@toyako/hive 1.0.0

package/src/convergence/ConvergenceValidator.ts

@@ -0,0 +1,367 @@
+/**
+ * Runtime Stability Convergence Validation Plan v1.0
+ * 
+ * 验证系统是否具备长期稳定收敛能力（Stability Convergence）
+ * 
+ * Stability Convergence = system applies mitigations → system stabilizes → system remains stable over time
+ * 
+ * 验证：Is this a self-stabilizing system or just a self-fixing system?
+ */
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 1: Controlled Instability Injection（受控破坏）
+// ═══════════════════════════════════════════════════════════════
+
+export type InjectionType = "RETRY_STORM" | "SCHEDULER_SATURATION" | "WORKER_INSTABILITY" | "EVENT_DELAY";
+
+export interface InjectionConfig {
+  type: InjectionType;
+  intensity: number; // 0-1
+  duration: number; // ms
+}
+
+export interface InjectionResult {
+  type: InjectionType;
+  success: boolean;
+  metrics: {
+    failureRate: number;
+    latencyIncrease: number;
+    queueBacklog: number;
+  };
+  timestamp: number;
+}
+
+export class InstabilityInjector {
+  /**
+   * 注入重试风暴
+   */
+  injectRetryStorm(intensity: number): InjectionConfig {
+    return {
+      type: "RETRY_STORM",
+      intensity,
+      duration: 30000
+    };
+  }
+
+  /**
+   * 注入调度器饱和
+   */
+  injectSchedulerSaturation(intensity: number): InjectionConfig {
+    return {
+      type: "SCHEDULER_SATURATION",
+      intensity,
+      duration: 60000
+    };
+  }
+
+  /**
+   * 注入Worker不稳定
+   */
+  injectWorkerInstability(intensity: number): InjectionConfig {
+    return {
+      type: "WORKER_INSTABILITY",
+      intensity,
+      duration: 45000
+    };
+  }
+
+  /**
+   * 注入事件延迟
+   */
+  injectEventDelay(intensity: number): InjectionConfig {
+    return {
+      type: "EVENT_DELAY",
+      intensity,
+      duration: 30000
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 2: Stabilization Response Phase（修复响应）
+// ═══════════════════════════════════════════════════════════════
+
+export interface StabilizationMetrics {
+  timeToDetect: number; // ms
+  timeToMitigate: number; // ms
+  timeToStabilize: number; // ms
+  autoTriggered: boolean;
+  correctStrategy: boolean;
+  overMitigation: boolean;
+}
+
+export class StabilizationMonitor {
+  private startTime: number = 0;
+  private detectTime: number = 0;
+  private mitigateTime: number = 0;
+  private stabilizeTime: number = 0;
+
+  /**
+   * 开始监控
+   */
+  start(): void {
+    this.startTime = Date.now();
+  }
+
+  /**
+   * 记录检测时间
+   */
+  recordDetection(): void {
+    this.detectTime = Date.now();
+  }
+
+  /**
+   * 记录缓解时间
+   */
+  recordMitigation(): void {
+    this.mitigateTime = Date.now();
+  }
+
+  /**
+   * 记录稳定时间
+   */
+  recordStabilization(): void {
+    this.stabilizeTime = Date.now();
+  }
+
+  /**
+   * 获取指标
+   */
+  getMetrics(): StabilizationMetrics {
+    return {
+      timeToDetect: this.detectTime - this.startTime,
+      timeToMitigate: this.mitigateTime - this.startTime,
+      timeToStabilize: this.stabilizeTime - this.startTime,
+      autoTriggered: this.detectTime > this.startTime,
+      correctStrategy: this.mitigateTime > this.detectTime,
+      overMitigation: false
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 3: Stability Hold Phase（稳定保持）
+// ═══════════════════════════════════════════════════════════════
+
+export interface StabilityWindow {
+  duration: number; // ms
+  samples: number[];
+  mean: number;
+  variance: number;
+  driftRate: number;
+}
+
+export class StabilityHoldMonitor {
+  private windows: StabilityWindow[] = [];
+
+  /**
+   * 添加稳定性窗口
+   */
+  addWindow(scores: number[], duration: number): StabilityWindow {
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    
+    // 计算漂移率（线性回归斜率）
+    const driftRate = this.calculateDriftRate(scores);
+
+    const window: StabilityWindow = {
+      duration,
+      samples: scores,
+      mean,
+      variance,
+      driftRate
+    };
+
+    this.windows.push(window);
+    return window;
+  }
+
+  /**
+   * 计算漂移率
+   */
+  private calculateDriftRate(scores: number[]): number {
+    if (scores.length < 2) return 0;
+
+    const n = scores.length;
+    const xMean = (n - 1) / 2;
+    const yMean = scores.reduce((a, b) => a + b, 0) / n;
+
+    let numerator = 0;
+    let denominator = 0;
+
+    for (let i = 0; i < n; i++) {
+      numerator += (i - xMean) * (scores[i] - yMean);
+      denominator += Math.pow(i - xMean, 2);
+    }
+
+    return denominator !== 0 ? numerator / denominator : 0;
+  }
+
+  /**
+   * 获取所有窗口
+   */
+  getWindows(): StabilityWindow[] {
+    return [...this.windows];
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Convergence Metric System（核心指标系统）
+// ═══════════════════════════════════════════════════════════════
+
+export interface ConvergenceMetrics {
+  stabilityRetention: number; // 0-1
+  driftRate: number; // 0-1
+  recoveryConsistency: number; // 0-1
+  scoreVariance: number;
+  recoveryTimeStable: boolean;
+}
+
+export type DecayCurveType = "flat" | "oscillating" | "declining";
+
+export interface ConvergenceResult {
+  convergenceScore: number; // 0-100
+  stabilityRetention: string;
+  driftRate: string;
+  recoveryConsistency: string;
+  decayCurve: DecayCurveType;
+  failureRecurrence: boolean;
+  result: "CONVERGED" | "NON_CONVERGED" | "UNSTABLE";
+}
+
+export class ConvergenceValidator {
+  /**
+   * 验证收敛性
+   */
+  validate(
+    metrics: ConvergenceMetrics,
+    stabilityWindows: StabilityWindow[]
+  ): ConvergenceResult {
+    // 计算收敛分数
+    const convergenceScore = this.calculateConvergenceScore(metrics);
+
+    // 分析衰减曲线
+    const decayCurve = this.analyzeDecayCurve(stabilityWindows);
+
+    // 判断失败复发
+    const failureRecurrence = this.checkFailureRecurrence(stabilityWindows);
+
+    // 判定结果
+    const result = this.determineResult(convergenceScore, decayCurve, failureRecurrence);
+
+    return {
+      convergenceScore,
+      stabilityRetention: `${(metrics.stabilityRetention * 100).toFixed(1)}%`,
+      driftRate: `${(metrics.driftRate * 100).toFixed(1)}%`,
+      recoveryConsistency: `${(metrics.recoveryConsistency * 100).toFixed(1)}%`,
+      decayCurve,
+      failureRecurrence,
+      result
+    };
+  }
+
+  /**
+   * 计算收敛分数
+   */
+  private calculateConvergenceScore(metrics: ConvergenceMetrics): number {
+    const weights = {
+      retention: 0.4,
+      drift: 0.25,
+      consistency: 0.2,
+      variance: 0.1,
+      recovery: 0.05
+    };
+
+    const retentionScore = metrics.stabilityRetention * 100;
+    const driftScore = (1 - metrics.driftRate) * 100;
+    const consistencyScore = metrics.recoveryConsistency * 100;
+    const varianceScore = Math.max(0, 100 - metrics.scoreVariance * 1000);
+    const recoveryScore = metrics.recoveryTimeStable ? 100 : 50;
+
+    return Math.round(
+      retentionScore * weights.retention +
+      driftScore * weights.drift +
+      consistencyScore * weights.consistency +
+      varianceScore * weights.variance +
+      recoveryScore * weights.recovery
+    );
+  }
+
+  /**
+   * 分析衰减曲线
+   */
+  private analyzeDecayCurve(windows: StabilityWindow[]): DecayCurveType {
+    if (windows.length < 2) return "flat";
+
+    const driftRates = windows.map(w => w.driftRate);
+    const avgDrift = driftRates.reduce((a, b) => a + b, 0) / driftRates.length;
+    const driftVariance = driftRates.reduce((sum, d) => sum + Math.pow(d - avgDrift, 2), 0) / driftRates.length;
+
+    if (Math.abs(avgDrift) < 0.01 && driftVariance < 0.001) {
+      return "flat";
+    } else if (driftVariance > 0.01) {
+      return "oscillating";
+    } else {
+      return "declining";
+    }
+  }
+
+  /**
+   * 检查失败复发
+   */
+  private checkFailureRecurrence(windows: StabilityWindow[]): boolean {
+    // 检查是否有连续下降的趋势
+    if (windows.length < 3) return false;
+
+    const recentWindows = windows.slice(-3);
+    const declining = recentWindows.every((w, i) => {
+      if (i === 0) return true;
+      return w.mean < recentWindows[i - 1].mean;
+    });
+
+    return declining;
+  }
+
+  /**
+   * 判定结果
+   */
+  private determineResult(
+    score: number,
+    decayCurve: DecayCurveType,
+    failureRecurrence: boolean
+  ): ConvergenceResult["result"] {
+    if (score >= 80 && decayCurve === "flat" && !failureRecurrence) {
+      return "CONVERGED";
+    } else if (score < 50 || failureRecurrence) {
+      return "UNSTABLE";
+    } else {
+      return "NON_CONVERGED";
+    }
+  }
+
+  /**
+   * 格式化报告
+   */
+  format(result: ConvergenceResult): string {
+    const lines: string[] = [];
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    lines.push("Stability Convergence Validation Report");
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    lines.push("");
+    lines.push(`Convergence Score: ${result.convergenceScore}/100`);
+    lines.push(`Result: ${result.result}`);
+    lines.push("");
+    lines.push("Metrics:");
+    lines.push(`  Stability Retention: ${result.stabilityRetention}`);
+    lines.push(`  Drift Rate: ${result.driftRate}`);
+    lines.push(`  Recovery Consistency: ${result.recoveryConsistency}`);
+    lines.push("");
+    lines.push("Analysis:");
+    lines.push(`  Decay Curve: ${result.decayCurve}`);
+    lines.push(`  Failure Recurrence: ${result.failureRecurrence ? "Yes" : "No"}`);
+    lines.push("");
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    return lines.join("\n");
+  }
+}

package/src/convergence/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Runtime Stability Convergence Validation Plan v1.0
+ * 
+ * 验证系统是否具备长期稳定收敛能力（Stability Convergence）
+ * 
+ * Stability Convergence = system applies mitigations → system stabilizes → system remains stable over time
+ */
+
+// Phase 1: Controlled Instability Injection
+export {
+  InjectionType,
+  InjectionConfig,
+  InjectionResult,
+  InstabilityInjector
+} from "./ConvergenceValidator";
+
+// Phase 2: Stabilization Response Phase
+export {
+  StabilizationMetrics,
+  StabilizationMonitor
+} from "./ConvergenceValidator";
+
+// Phase 3: Stability Hold Phase
+export {
+  StabilityWindow,
+  StabilityHoldMonitor
+} from "./ConvergenceValidator";
+
+// Convergence Metric System
+export {
+  ConvergenceMetrics,
+  DecayCurveType,
+  ConvergenceResult,
+  ConvergenceValidator
+} from "./ConvergenceValidator";

package/src/conversation/ConversationManager.ts

@@ -0,0 +1,158 @@
+import { Conversation, MessageEnvelope, MessageType } from "../types";
+import { uuid } from "../utils/uuid";
+import * as fs from "fs";
+import * as path from "path";
+
+const CONVERSATIONS_DIR = path.resolve(process.cwd(), ".agent-hive/conversations");
+
+/**
+ * ConversationManager
+ *
+ * Manages multi-turn conversations between agents.
+ * Each conversation is a sequence of messages between participants.
+ */
+export class ConversationManager {
+  private conversations: Map<string, Conversation> = new Map();
+  private conversationsDir: string;
+
+  constructor(baseDir?: string) {
+    this.conversationsDir = baseDir || CONVERSATIONS_DIR;
+    fs.mkdirSync(this.conversationsDir, { recursive: true });
+    this.loadPersisted();
+  }
+
+  /**
+   * Create a new conversation.
+   */
+  create(taskId: string, participants: string[]): Conversation {
+    const conv: Conversation = {
+      id: `conv-${uuid()}`,
+      taskId,
+      participants,
+      messages: [],
+      status: "active",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    this.conversations.set(conv.id, conv);
+    this.persist(conv);
+    return conv;
+  }
+
+  /**
+   * Add a message to a conversation.
+   */
+  addMessage(conversationId: string, msg: MessageEnvelope): void {
+    const conv = this.conversations.get(conversationId);
+    if (!conv) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+    if (conv.status !== "active") {
+      throw new Error(`Conversation is not active: ${conversationId} (status: ${conv.status})`);
+    }
+
+    conv.messages.push(msg);
+    conv.updatedAt = Date.now();
+
+    // Ensure participant is tracked
+    if (!conv.participants.includes(msg.from)) {
+      conv.participants.push(msg.from);
+    }
+
+    this.persist(conv);
+  }
+
+  /**
+   * Get a conversation by id.
+   */
+  get(conversationId: string): Conversation | undefined {
+    return this.conversations.get(conversationId);
+  }
+
+  /**
+   * Get all conversations for a task.
+   */
+  getByTask(taskId: string): Conversation[] {
+    return Array.from(this.conversations.values()).filter(c => c.taskId === taskId);
+  }
+
+  /**
+   * Get message history for a conversation.
+   */
+  getMessages(conversationId: string): MessageEnvelope[] {
+    const conv = this.conversations.get(conversationId);
+    return conv ? [...conv.messages] : [];
+  }
+
+  /**
+   * Complete a conversation.
+   */
+  complete(conversationId: string): void {
+    const conv = this.conversations.get(conversationId);
+    if (conv) {
+      conv.status = "completed";
+      conv.updatedAt = Date.now();
+      this.persist(conv);
+    }
+  }
+
+  /**
+   * Fail a conversation.
+   */
+  fail(conversationId: string, reason?: string): void {
+    const conv = this.conversations.get(conversationId);
+    if (conv) {
+      conv.status = "failed";
+      conv.updatedAt = Date.now();
+      this.persist(conv);
+    }
+  }
+
+  /**
+   * Timeout a conversation.
+   */
+  timeout(conversationId: string): void {
+    const conv = this.conversations.get(conversationId);
+    if (conv) {
+      conv.status = "timeout";
+      conv.updatedAt = Date.now();
+      this.persist(conv);
+    }
+  }
+
+  /**
+   * Get all active conversations.
+   */
+  active(): Conversation[] {
+    return Array.from(this.conversations.values()).filter(c => c.status === "active");
+  }
+
+  /**
+   * Get all conversations.
+   */
+  all(): Conversation[] {
+    return Array.from(this.conversations.values());
+  }
+
+  // ─── Persistence ──────────────────────────────────
+
+  private persist(conv: Conversation): void {
+    const fp = path.join(this.conversationsDir, `${conv.id}.json`);
+    fs.writeFileSync(fp, JSON.stringify(conv, null, 2));
+  }
+
+  private loadPersisted(): void {
+    if (!fs.existsSync(this.conversationsDir)) return;
+    try {
+      const files = fs.readdirSync(this.conversationsDir).filter(f => f.endsWith(".json"));
+      for (const f of files) {
+        const conv: Conversation = JSON.parse(
+          fs.readFileSync(path.join(this.conversationsDir, f), "utf-8")
+        );
+        this.conversations.set(conv.id, conv);
+      }
+    } catch {
+      // Corrupted files, start fresh
+    }
+  }
+}

package/src/dashboard/EventStore.ts

@@ -0,0 +1,54 @@
+/**
+ * ObservationEvent — unified event schema for all observations.
+ * All metrics must be based on event_timestamp.
+ */
+export interface ObservationEvent {
+  event_id: string;
+  task_id: string;
+  event_type: "execution" | "review" | "reset" | "eval";
+  event_timestamp: string;
+  task_commit_timestamp?: string;
+  evaluation_timestamp?: string;
+  data: Record<string, unknown>;
+}
+
+export class EventStore {
+  private events: ObservationEvent[] = [];
+
+  record(event: Omit<ObservationEvent, "event_id">): ObservationEvent {
+    const full: ObservationEvent = {
+      ...event,
+      event_id: `evt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    };
+    this.events.push(full);
+    return full;
+  }
+
+  getByTask(taskId: string): ObservationEvent[] {
+    return this.events.filter(e => e.task_id === taskId);
+  }
+
+  getByType(type: ObservationEvent["event_type"]): ObservationEvent[] {
+    return this.events.filter(e => e.event_type === type);
+  }
+
+  getRecent(n: number): ObservationEvent[] {
+    return this.events.slice(-n);
+  }
+
+  all(): ObservationEvent[] { return [...this.events]; }
+  count(): number { return this.events.length; }
+
+  /** Replay last N tasks */
+  replayLastN(n: number): ObservationEvent[] {
+    const recent = this.getRecent(n * 3); // ~3 events per task
+    return recent;
+  }
+
+  /** Replay failure chain for a task */
+  replayFailureChain(taskId: string): ObservationEvent[] {
+    return this.getByTask(taskId).filter(e =>
+      e.event_type === "execution" || e.event_type === "reset"
+    );
+  }
+}