@toyako/hive 1.0.0

package/src/commands/demo.ts

@@ -0,0 +1,81 @@
+/**
+ * Demo: Agent Hive v1.1 — Mock mode (architecture verification)
+ */
+import { Broker } from "../broker/Broker";
+import { MockCodexAdapter } from "../adapters/MockCodexAdapter";
+import { MockClaudeAdapter } from "../adapters/MockClaudeAdapter";
+
+async function main() {
+  console.log("╔══════════════════════════════════════════╗");
+  console.log("║     Agent Hive v1.1 — Mock Demo         ║");
+  console.log("╚══════════════════════════════════════════╝\n");
+
+  // ── Scenario 1: Direct pass ──
+  console.log("━━━ Scenario 1: Direct Pass ━━━\n");
+  {
+    const broker = new Broker();
+    await broker.registerAdapter(new MockCodexAdapter());
+    await broker.registerAdapter(new MockClaudeAdapter({ failCount: 0 }));
+    broker.registry.link("codex", "claude");
+
+    broker.submit({
+      instruction: "Optimize Navbar.vue scroll animation",
+      executor: "codex",
+      reviewer: "claude",
+    });
+
+    await broker.run();
+  }
+
+  console.log("\n━━━ Scenario 2: Revision Loop (fail 2x then pass) ━━━\n");
+  {
+    const broker = new Broker();
+    await broker.registerAdapter(new MockCodexAdapter());
+    await broker.registerAdapter(new MockClaudeAdapter({ failCount: 2 }));
+    broker.registry.link("codex", "claude");
+
+    broker.submit({
+      instruction: "Refactor authentication module",
+      executor: "codex",
+      reviewer: "claude",
+      maxRevision: 3,
+    });
+
+    await broker.run();
+
+    // Show revision history
+    const history = broker.history.get(broker.listTasks()[0]?.id || "");
+    if (history.length) {
+      console.log("  Revision History:");
+      for (const r of history) {
+        console.log(`    #${r.attempt}: ${r.decision} (score=${r.score})`);
+      }
+    }
+  }
+
+  console.log("\n━━━ Scenario 3: Max Revision Exceeded ━━━\n");
+  {
+    const broker = new Broker();
+    await broker.registerAdapter(new MockCodexAdapter());
+    await broker.registerAdapter(new MockClaudeAdapter({ failCount: 10 }));
+    broker.registry.link("codex", "claude");
+
+    broker.submit({
+      instruction: "Implement impossible feature",
+      executor: "codex",
+      reviewer: "claude",
+      maxRevision: 2,
+    });
+
+    await broker.run();
+  }
+
+  console.log("╔══════════════════════════════════════════╗");
+  console.log("║            Demo Complete                 ║");
+  console.log("╚══════════════════════════════════════════╝");
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});

package/src/commands/experiment-routing.ts

@@ -0,0 +1,360 @@
+/**
+ * Runtime Intelligence Validation Experiment
+ *
+ * Compare: Fixed Routing vs Intelligent Routing
+ * 20 tasks each, measure successRate / latency / reviewScore
+ */
+import { Broker } from "../broker/Broker";
+import { CapabilityDiscovery } from "../runtime/CapabilityDiscovery";
+import { RuntimeScoreManager } from "../runtime/RuntimeScoreManager";
+import { RuntimeSelector } from "../runtime/RuntimeSelector";
+import { AgentAdapter, AgentResult, ReviewResult, Task } from "../types";
+import * as fs from "fs";
+
+// ─── Real-ish Mock Adapters ──────────────────────────
+// Each has different strengths to make the comparison meaningful
+
+class CodexMock implements AgentAdapter {
+  name = "codex";
+  role = "developer" as const;
+  capabilities = ["coding", "refactor"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    // Good at coding/refactor, mediocre at review/planning
+    const isStrong = task.instruction.includes("code") || task.instruction.includes("refactor") || task.instruction.includes("function") || task.instruction.includes("API");
+    await sleep(isStrong ? 50 : 150);
+    return {
+      success: true,
+      output: isStrong
+        ? `[Codex]高质量完成: ${prompt}\n代码结构清晰，测试覆盖完整。`
+        : `[Codex]基本完成: ${prompt}\n代码可用但不够优雅。`,
+    };
+  }
+}
+
+class ClaudeMock implements AgentAdapter {
+  name = "claude";
+  role = "reviewer" as const;
+  capabilities = ["review", "architecture", "coding"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    // Good at review/architecture, decent at coding
+    const isStrong = task.instruction.includes("review") || task.instruction.includes("审核") || task.instruction.includes("架构") || task.instruction.includes("design");
+    await sleep(isStrong ? 80 : 120);
+    return {
+      success: true,
+      output: isStrong
+        ? `[Claude]高质量完成: ${prompt}\n分析深入，建议具体。`
+        : `[Claude]完成: ${prompt}\n质量合格。`,
+    };
+  }
+  async review(task: Task): Promise<ReviewResult> {
+    await sleep(40);
+    // Reviews are thorough
+    return { decision: "PASS", score: 88, issues: [] };
+  }
+}
+
+class HermesMock implements AgentAdapter {
+  name = "hermes";
+  role = "planner" as const;
+  capabilities = ["planning", "research"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    // Good at planning/research, weak at coding
+    const isStrong = task.instruction.includes("plan") || task.instruction.includes("设计") || task.instruction.includes("research") || task.instruction.includes("分析");
+    await sleep(isStrong ? 30 : 200);
+    return {
+      success: Math.random() > (isStrong ? 0.02 : 0.15), // Higher failure rate for non-strength tasks
+      output: isStrong
+        ? `[Hermes]高质量完成: ${prompt}\n方案清晰，考虑全面。`
+        : `[Hermes]勉强完成: ${prompt}\n需要进一步优化。`,
+      error: isStrong ? undefined : "Output quality below threshold",
+    };
+  }
+  async review(task: Task): Promise<ReviewResult> {
+    await sleep(30);
+    return { decision: "PASS", score: 75, issues: [] };
+  }
+}
+
+// ─── Task definitions ────────────────────────────────
+
+const TASKS = [
+  { instruction: "实现一个用户登录API接口", type: "coding" },
+  { instruction: "实现一个数据导出功能", type: "coding" },
+  { instruction: "实现一个文件上传模块", type: "coding" },
+  { instruction: "实现一个WebSocket消息推送", type: "coding" },
+  { instruction: "重构数据库连接池代码", type: "refactor" },
+  { instruction: "重构错误处理中间件", type: "refactor" },
+  { instruction: "重构配置加载逻辑", type: "refactor" },
+  { instruction: "重构日志输出模块", type: "refactor" },
+  { instruction: "审核以下代码的安全性", type: "review" },
+  { instruction: "审核PR中的性能问题", type: "review" },
+  { instruction: "审核API接口的错误处理", type: "review" },
+  { instruction: "审核数据库查询的合理性", type: "review" },
+  { instruction: "设计微服务架构方案", type: "planning" },
+  { instruction: "设计缓存策略方案", type: "planning" },
+  { instruction: "设计CI/CD流水线", type: "planning" },
+  { instruction: "分析系统瓶颈并给出优化方案", type: "planning" },
+  { instruction: "实现一个CRUD自动生成器", type: "coding" },
+  { instruction: "实现一个权限校验中间件", type: "coding" },
+  { instruction: "重构前端状态管理代码", type: "refactor" },
+  { instruction: "设计API版本管理方案", type: "planning" },
+];
+
+// ─── Experiment ──────────────────────────────────────
+
+interface RunResult {
+  taskType: string;
+  runtime: string;
+  success: boolean;
+  latencyMs: number;
+  reviewScore: number;
+  selectedBy: "fixed" | "intelligence";
+}
+
+async function runExperiment(): Promise<void> {
+  console.log("╔══════════════════════════════════════════════════╗");
+  console.log("║   Runtime Intelligence Validation Experiment     ║");
+  console.log("╚══════════════════════════════════════════════════╝\n");
+
+  // Clean state
+  try { fs.rmSync(".agent-hive", { recursive: true, force: true }); } catch {}
+  fs.mkdirSync(".agent-hive", { recursive: true });
+
+  const codex = new CodexMock();
+  const claude = new ClaudeMock();
+  const hermes = new HermesMock();
+
+  const results: { fixed: RunResult[]; intelligence: RunResult[] } = { fixed: [], intelligence: [] };
+
+  // ── Experiment A: Fixed Routing (everything through Claude) ──
+  console.log("━━━ 实验A: 固定路由 (全部走 Claude) ━━━\n");
+
+  for (const task of TASKS) {
+    const start = Date.now();
+    const result = await claude.execute({
+      id: `fixed-${Date.now()}`,
+      instruction: task.instruction,
+      executor: "claude",
+      reviewer: "claude",
+      status: "EXECUTING",
+      revisionCount: 0,
+      maxRevision: 3,
+      timeout: 60000,
+      workingDirectory: "/tmp",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    const latency = Date.now() - start;
+
+    let reviewScore = 0;
+    if (result.success) {
+      const review = await claude.review!({
+        id: "review",
+        instruction: "",
+        executor: "claude",
+        reviewer: "claude",
+        status: "REVIEWING",
+        revisionCount: 0,
+        maxRevision: 3,
+        timeout: 60000,
+        workingDirectory: "/tmp",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        result: result.output,
+      });
+      reviewScore = review.score;
+    }
+
+    results.fixed.push({
+      taskType: task.type,
+      runtime: "claude",
+      success: result.success,
+      latencyMs: latency,
+      reviewScore,
+      selectedBy: "fixed",
+    });
+    process.stdout.write(`  ${task.type.padEnd(10)} → claude  ${result.success ? "✓" : "✗"}  ${latency}ms  score=${reviewScore}\n`);
+  }
+
+  // ── Experiment B: Intelligent Routing ──
+  console.log("\n━━━ 实验B: 智能路由 (RuntimeSelector) ━━━\n");
+
+  // Set up intelligence
+  const discovery = new CapabilityDiscovery();
+  const scoreManager = new RuntimeScoreManager();
+  const broker = new Broker();
+
+  await broker.registerAdapter(codex);
+  await broker.registerAdapter(claude);
+  await broker.registerAdapter(hermes);
+
+  await discovery.discover(codex);
+  await discovery.discover(claude);
+  await discovery.discover(hermes);
+
+  // Seed some initial performance data
+  scoreManager.record({ runtimeId: "codex", role: "executor", success: true, latencyMs: 1500, reviewScore: 90 });
+  scoreManager.record({ runtimeId: "claude", role: "executor", success: true, latencyMs: 3000, reviewScore: 88 });
+  scoreManager.record({ runtimeId: "hermes", role: "executor", success: true, latencyMs: 1000, reviewScore: 75 });
+
+  const selector = new RuntimeSelector(discovery, scoreManager, broker.registry);
+
+  for (const task of TASKS) {
+    const selection = selector.select({ taskType: task.type });
+    const runtimeName = selection?.runtimeId || "claude";
+    const adapter = runtimeName === "codex" ? codex : runtimeName === "hermes" ? hermes : claude;
+
+    const start = Date.now();
+    const result = await adapter.execute({
+      id: `intel-${Date.now()}`,
+      instruction: task.instruction,
+      executor: runtimeName,
+      reviewer: "claude",
+      status: "EXECUTING",
+      revisionCount: 0,
+      maxRevision: 3,
+      timeout: 60000,
+      workingDirectory: "/tmp",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    const latency = Date.now() - start;
+
+    let reviewScore = 0;
+    if (result.success) {
+      const reviewer = claude;
+      const review = await reviewer.review!({
+        id: "review",
+        instruction: "",
+        executor: runtimeName,
+        reviewer: "claude",
+        status: "REVIEWING",
+        revisionCount: 0,
+        maxRevision: 3,
+        timeout: 60000,
+        workingDirectory: "/tmp",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        result: result.output,
+      });
+      reviewScore = review.score;
+    }
+
+    // Record for score learning
+    scoreManager.record({
+      runtimeId: runtimeName,
+      role: "executor",
+      success: result.success,
+      latencyMs: latency,
+      reviewScore,
+    });
+
+    results.intelligence.push({
+      taskType: task.type,
+      runtime: runtimeName,
+      success: result.success,
+      latencyMs: latency,
+      reviewScore,
+      selectedBy: "intelligence",
+    });
+    process.stdout.write(`  ${task.type.padEnd(10)} → ${runtimeName.padEnd(7)} ${result.success ? "✓" : "✗"}  ${latency}ms  score=${reviewScore}\n`);
+  }
+
+  // ── Analysis ──
+  console.log("\n╔══════════════════════════════════════════════════╗");
+  console.log("║                  对比分析                         ║");
+  console.log("╚══════════════════════════════════════════════════╝\n");
+
+  const fixedStats = calcStats(results.fixed);
+  const intelStats = calcStats(results.intelligence);
+
+  console.log("  指标              固定路由    智能路由    提升");
+  console.log("  ─────────────────────────────────────────────");
+  console.log(`  成功率            ${fixedStats.successRate.toFixed(1)}%      ${intelStats.successRate.toFixed(1)}%      ${formatDiff(fixedStats.successRate, intelStats.successRate)}`);
+  console.log(`  平均延迟          ${fixedStats.avgLatency.toFixed(0)}ms     ${intelStats.avgLatency.toFixed(0)}ms     ${formatDiff(fixedStats.avgLatency, intelStats.avgLatency, true)}`);
+  console.log(`  平均审核分        ${fixedStats.avgReviewScore.toFixed(1)}       ${intelStats.avgReviewScore.toFixed(1)}       ${formatDiff(fixedStats.avgReviewScore, intelStats.avgReviewScore)}`);
+
+  // Per-type breakdown
+  console.log("\n  按任务类型:");
+  console.log("  类型          固定路由(分)  智能路由(分)  提升");
+  console.log("  ─────────────────────────────────────────────");
+
+  for (const type of ["coding", "refactor", "review", "planning"]) {
+    const fixedType = calcStats(results.fixed.filter(r => r.taskType === type));
+    const intelType = calcStats(results.intelligence.filter(r => r.taskType === type));
+    console.log(`  ${type.padEnd(13)} ${fixedType.avgReviewScore.toFixed(1).padStart(10)}  ${intelType.avgReviewScore.toFixed(1).padStart(10)}  ${formatDiff(fixedType.avgReviewScore, intelType.avgReviewScore)}`);
+  }
+
+  // Runtime distribution for intelligent routing
+  console.log("\n  智能路由 Runtime 分布:");
+  const dist: Record<string, number> = {};
+  for (const r of results.intelligence) {
+    dist[r.runtime] = (dist[r.runtime] || 0) + 1;
+  }
+  for (const [name, count] of Object.entries(dist)) {
+    console.log(`    ${name}: ${count}/20 tasks (${(count/20*100).toFixed(0)}%)`);
+  }
+
+  // Verdict
+  const compositeImprovement = (
+    (intelStats.successRate - fixedStats.successRate) / Math.max(fixedStats.successRate, 1) * 0.4 +
+    (fixedStats.avgLatency - intelStats.avgLatency) / Math.max(fixedStats.avgLatency, 1) * 0.3 +
+    (intelStats.avgReviewScore - fixedStats.avgReviewScore) / Math.max(fixedStats.avgReviewScore, 1) * 0.3
+  ) * 100;
+
+  console.log(`\n  综合提升: ${compositeImprovement.toFixed(1)}%`);
+
+  if (compositeImprovement > 20) {
+    console.log("  结论: 提升明显 (>20%)，建议进入 v2.2");
+  } else if (compositeImprovement > 10) {
+    console.log("  结论: 提升中等 (10-20%)，可选择性优化");
+  } else {
+    console.log("  结论: 提升不明显 (<10%)，停止继续开发 Runtime Intelligence");
+  }
+
+  // Save results
+  fs.writeFileSync("docs/experiment-results.json", JSON.stringify({
+    timestamp: new Date().toISOString(),
+    fixed: fixedStats,
+    intelligence: intelStats,
+    compositeImprovement,
+    taskCount: TASKS.length,
+    details: results,
+  }, null, 2));
+
+  console.log("\n  结果已保存: docs/experiment-results.json");
+}
+
+function calcStats(results: RunResult[]) {
+  const successCount = results.filter(r => r.success).length;
+  const totalLatency = results.reduce((sum, r) => sum + r.latencyMs, 0);
+  const totalScore = results.reduce((sum, r) => sum + r.reviewScore, 0);
+  return {
+    successRate: results.length > 0 ? successCount / results.length * 100 : 0,
+    avgLatency: results.length > 0 ? totalLatency / results.length : 0,
+    avgReviewScore: results.length > 0 ? totalScore / results.length : 0,
+  };
+}
+
+function formatDiff(fixed: number, intel: number, lowerIsBetter = false): string {
+  const diff = lowerIsBetter ? fixed - intel : intel - fixed;
+  const pct = fixed !== 0 ? (diff / Math.abs(fixed) * 100) : 0;
+  const sign = diff >= 0 ? "+" : "";
+  const arrow = diff > 0 ? "↑" : diff < 0 ? "↓" : "→";
+  return `${arrow} ${sign}${pct.toFixed(1)}%`;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+runExperiment().catch(err => { console.error("Fatal:", err); process.exit(1); });

package/src/commands/generate-dashboard.js

@@ -0,0 +1,235 @@
+/**
+ * Dashboard Generator
+ *
+ * Reads .agent-hive/ data and generates a static HTML dashboard.
+ * Usage: node generate-dashboard.js > dashboard/index.html
+ */
+const fs = require("fs");
+const path = require("path");
+
+const BASE = path.resolve(__dirname, "../.agent-hive");
+const REPORTS = path.resolve(__dirname, "../reports");
+
+function loadJSON(filepath) {
+  try { return JSON.parse(fs.readFileSync(filepath, "utf-8")); } catch { return null; }
+}
+
+function main() {
+  const runtimeMetrics = loadJSON(path.join(BASE, "metrics/runtime.json")) || {};
+  const benchmark = loadJSON(path.join(BASE, "benchmark/runtime-benchmark.json")) || {};
+  const validation = loadJSON(path.join(REPORTS, "validation-metrics.json")) || {};
+
+  // Load traces
+  const tracesDir = path.join(BASE, "traces");
+  const traces = [];
+  if (fs.existsSync(tracesDir)) {
+    for (const f of fs.readdirSync(tracesDir).filter(f => f.endsWith(".json"))) {
+      traces.push(loadJSON(path.join(tracesDir, f)));
+    }
+  }
+
+  const data = { runtimeMetrics, benchmark, validation, traces };
+
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Agent Hive Dashboard</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f1117; color: #e4e4e7; min-height: 100vh; }
+  .header { background: linear-gradient(135deg, #1a1b2e 0%, #16213e 100%); padding: 24px 32px; border-bottom: 1px solid #2a2d3e; }
+  .header h1 { font-size: 24px; font-weight: 700; background: linear-gradient(90deg, #6366f1, #8b5cf6); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+  .header p { color: #71717a; font-size: 14px; margin-top: 4px; }
+  .container { max-width: 1200px; margin: 0 auto; padding: 24px; }
+  .grid { display: grid; gap: 20px; }
+  .grid-2 { grid-template-columns: repeat(2, 1fr); }
+  .grid-3 { grid-template-columns: repeat(3, 1fr); }
+  .grid-4 { grid-template-columns: repeat(4, 1fr); }
+  .card { background: #1a1b2e; border: 1px solid #2a2d3e; border-radius: 12px; padding: 20px; }
+  .card h3 { font-size: 14px; color: #71717a; text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 12px; }
+  .card .value { font-size: 32px; font-weight: 700; color: #fff; }
+  .card .sub { font-size: 13px; color: #52525b; margin-top: 4px; }
+  .section { margin-top: 32px; }
+  .section h2 { font-size: 18px; font-weight: 600; color: #e4e4e7; margin-bottom: 16px; }
+  .bar-chart { display: flex; align-items: flex-end; gap: 8px; height: 160px; padding: 0 8px; }
+  .bar-group { display: flex; flex-direction: column; align-items: center; flex: 1; }
+  .bar { width: 100%; border-radius: 6px 6px 0 0; transition: height 0.5s ease; min-height: 4px; }
+  .bar-label { font-size: 11px; color: #71717a; margin-top: 8px; text-align: center; }
+  .bar-value { font-size: 12px; color: #a1a1aa; margin-bottom: 4px; font-weight: 600; }
+  .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 12px; font-weight: 600; }
+  .badge-green { background: #064e3b; color: #34d399; }
+  .badge-yellow { background: #713f12; color: #fbbf24; }
+  .badge-red { background: #7f1d1d; color: #f87171; }
+  .badge-blue { background: #1e3a5f; color: #60a5fa; }
+  table { width: 100%; border-collapse: collapse; }
+  th { text-align: left; font-size: 12px; color: #71717a; text-transform: uppercase; letter-spacing: 0.5px; padding: 8px 12px; border-bottom: 1px solid #2a2d3e; }
+  td { padding: 10px 12px; font-size: 14px; border-bottom: 1px solid #1f2033; }
+  .timeline { display: flex; align-items: center; gap: 4px; flex-wrap: wrap; }
+  .timeline-dot { width: 8px; height: 8px; border-radius: 50%; }
+  .timeline-line { width: 20px; height: 2px; background: #2a2d3e; }
+  .status-dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; margin-right: 8px; }
+  .status-green { background: #34d399; }
+  .status-yellow { background: #fbbf24; }
+  .status-red { background: #f87171; }
+  @media (max-width: 768px) { .grid-2, .grid-3, .grid-4 { grid-template-columns: 1fr; } }
+</style>
+</head>
+<body>
+<div class="header">
+  <h1>🦞 Agent Hive Dashboard</h1>
+  <p>Multi-Runtime AI Orchestration — v3.0</p>
+</div>
+<div class="container">
+
+  <!-- Summary Cards -->
+  <div class="grid grid-4">
+    <div class="card">
+      <h3>Runtimes</h3>
+      <div class="value">${Object.keys(benchmark).length}</div>
+      <div class="sub">${Object.keys(benchmark).map(r => r).join(", ")}</div>
+    </div>
+    <div class="card">
+      <h3>Total Tasks</h3>
+      <div class="value">${validation.totalTasks || traces.length}</div>
+      <div class="sub">${validation.successRate || "100%"} success rate</div>
+    </div>
+    <div class="card">
+      <h3>Avg Score</h3>
+      <div class="value">${validation.averageReviewScore || "N/A"}</div>
+      <div class="sub">Review score</div>
+    </div>
+    <div class="card">
+      <h3>Traces</h3>
+      <div class="value">${traces.length}</div>
+      <div class="sub">Recorded executions</div>
+    </div>
+  </div>
+
+  <!-- Runtime Ranking -->
+  <div class="section">
+    <h2>Runtime Ranking</h2>
+    <div class="grid grid-2">
+      <div class="card">
+        <h3>Coding</h3>
+        <div class="bar-chart">
+          ${Object.entries(benchmark).map(([name, r]) => `
+            <div class="bar-group">
+              <div class="bar-value">${r.coding}</div>
+              <div class="bar" style="height: ${r.coding * 1.5}px; background: linear-gradient(180deg, #6366f1, #4f46e5);"></div>
+              <div class="bar-label">${name}</div>
+            </div>`).join("")}
+        </div>
+      </div>
+      <div class="card">
+        <h3>Review</h3>
+        <div class="bar-chart">
+          ${Object.entries(benchmark).map(([name, r]) => `
+            <div class="bar-group">
+              <div class="bar-value">${r.review}</div>
+              <div class="bar" style="height: ${r.review * 1.5}px; background: linear-gradient(180deg, #8b5cf6, #7c3aed);"></div>
+              <div class="bar-label">${name}</div>
+            </div>`).join("")}
+        </div>
+      </div>
+      <div class="card">
+        <h3>Planning</h3>
+        <div class="bar-chart">
+          ${Object.entries(benchmark).map(([name, r]) => `
+            <div class="bar-group">
+              <div class="bar-value">${r.planning}</div>
+              <div class="bar" style="height: ${r.planning * 1.5}px; background: linear-gradient(180deg, #a78bfa, #8b5cf6);"></div>
+              <div class="bar-label">${name}</div>
+            </div>`).join("")}
+        </div>
+      </div>
+      <div class="card">
+        <h3>Reasoning</h3>
+        <div class="bar-chart">
+          ${Object.entries(benchmark).map(([name, r]) => `
+            <div class="bar-group">
+              <div class="bar-value">${r.reasoning}</div>
+              <div class="bar" style="height: ${r.reasoning * 1.5}px; background: linear-gradient(180deg, #c084fc, #a855f7);"></div>
+              <div class="bar-label">${name}</div>
+            </div>`).join("")}
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Runtime Status -->
+  <div class="section">
+    <h2>Runtime Status</h2>
+    <div class="card">
+      <table>
+        <tr><th>Runtime</th><th>Tasks</th><th>Success</th><th>Avg Latency</th><th>Avg Score</th><th>Status</th></tr>
+        ${Object.entries(runtimeMetrics).map(([name, r]) => `
+          <tr>
+            <td><strong>${name}</strong></td>
+            <td>${r.taskCount}</td>
+            <td>${(r.successRate * 100).toFixed(0)}%</td>
+            <td>${(r.avgLatency * 1000).toFixed(0)}ms</td>
+            <td>${r.avgReviewScore.toFixed(1)}</td>
+            <td><span class="status-dot status-green"></span>Online</td>
+          </tr>`).join("")}
+      </table>
+    </div>
+  </div>
+
+  <!-- Validation Results -->
+  ${validation.tasks ? `
+  <div class="section">
+    <h2>Validation Results</h2>
+    <div class="card">
+      <table>
+        <tr><th>Task</th><th>Executor</th><th>Reviewer</th><th>Status</th><th>Score</th><th>Revisions</th><th>Duration</th></tr>
+        ${validation.tasks.map(t => `
+          <tr>
+            <td><strong>${t.name}</strong></td>
+            <td>${t.executor}</td>
+            <td>${t.reviewer}</td>
+            <td><span class="badge ${t.status === 'COMPLETED' ? 'badge-green' : 'badge-red'}">${t.status}</span></td>
+            <td>${t.score}</td>
+            <td>${t.revisionCount}</td>
+            <td>${t.duration}</td>
+          </tr>`).join("")}
+      </table>
+    </div>
+  </div>` : ""}
+
+  <!-- Recent Traces -->
+  <div class="section">
+    <h2>Recent Traces (${traces.length})</h2>
+    <div class="card">
+      <table>
+        <tr><th>Task ID</th><th>Status</th><th>Events</th></tr>
+        ${traces.slice(0, 20).map(t => `
+          <tr>
+            <td><strong>${t.taskId}</strong></td>
+            <td><span class="badge ${t.status === 'COMPLETED' ? 'badge-green' : t.status === 'FAILED' ? 'badge-red' : 'badge-yellow'}">${t.status}</span></td>
+            <td>${(t.events || []).length} events</td>
+          </tr>`).join("")}
+      </table>
+    </div>
+  </div>
+
+</div>
+<script>
+  // Animate bars on load
+  document.querySelectorAll('.bar').forEach(bar => {
+    const h = bar.style.height;
+    bar.style.height = '4px';
+    setTimeout(() => { bar.style.height = h; }, 100);
+  });
+</script>
+</body>
+</html>`;
+
+  const outDir = path.resolve(__dirname, "../../dashboard");
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(path.join(outDir, "index.html"), html);
+  console.log("Dashboard generated: dashboard/index.html");
+}
+
+main();