@toyako/hive 1.0.0

package/src/commands/run-daily-validation.js

@@ -0,0 +1,125 @@
+/**
+ * Continuous Validation — Daily Task Generator + Runner
+ *
+ * Generates real tasks from the Agent Hive codebase and runs them.
+ * Designed to be executed daily via cron or manually.
+ *
+ * Usage: node run-daily-validation.js [day-number]
+ */
+const fs = require("fs");
+const path = require("path");
+
+const PROJECT_ROOT = path.resolve(__dirname, "../..");
+const REPORTS_DIR = path.resolve(PROJECT_ROOT, "reports");
+const TASKS_DIR = path.resolve(PROJECT_ROOT, ".agent-hive/tasks");
+
+// Task templates — real tasks from the Agent Hive codebase
+const TASK_TEMPLATES = [
+  {
+    name: "Add unit test for TaskIntentClassifier",
+    intent: "coding",
+    instruction: "Write unit tests for src/product/TaskIntentClassifier.ts. Test all 6 intent categories (coding, review, planning, refactor, architecture, research). Test edge cases (empty string, mixed keywords). Use plain Node.js assert module. Output to src/commands/test-intent-classifier.ts",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Review Broker.ts for edge cases",
+    intent: "review",
+    instruction: "Review src/broker/Broker.ts for potential issues: error handling, null checks, race conditions in async methods. List any findings with line numbers. Focus on production readiness.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Refactor: extract timeout logic",
+    intent: "refactor",
+    instruction: "The timeout logic in src/broker/TaskProcessor.ts (execWithTimeout method) is duplicated. Extract it into a shared utility at src/utils/withTimeout.ts. Keep the same behavior: reject with TIMEOUT error after specified ms. Update TaskProcessor to import from the new utility.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Document API surface",
+    intent: "research",
+    instruction: "Analyze the Agent Hive public API surface: all exported classes, functions, and types from src/. Generate a concise API reference at docs/api-reference.md. Group by module (broker, adapters, graph, types, product).",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Add error handling to adapters",
+    intent: "coding",
+    instruction: "Review all adapter files in src/adapters/*.ts. For each adapter, verify that execute() and review() methods have proper try/catch with descriptive error messages. If any adapter is missing error handling, add it. Focus on network errors and timeout handling.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Architecture review: module dependencies",
+    intent: "architecture",
+    instruction: "Analyze the module dependency graph of Agent Hive src/. Check for: circular dependencies, unnecessary coupling between modules, modules that import too many dependencies. Report findings at docs/architecture-review.md with recommendations.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Optimize: reduce adapter registration time",
+    intent: "refactor",
+    instruction: "Profile the adapter registration flow in Broker.registerAdapter(). The detect() call makes network requests that can be slow. Add parallel detection (detect all adapters concurrently instead of sequentially). Maintain the same output format.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Add integration test for revision loop",
+    intent: "coding",
+    instruction: "Write an integration test that forces a revision loop: create a mock reviewer that always returns FAIL for the first 2 attempts, then PASS on the 3rd. Verify that the broker correctly handles the revision cycle. Output to src/commands/test-revision-loop.ts",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Review security: API key handling",
+    intent: "review",
+    instruction: "Audit how API keys are handled in Agent Hive: runtime.json stores keys in plaintext. Review all files that read runtime.json. Check if keys could leak through logs, error messages, or console output. Report findings.",
+    workDir: PROJECT_ROOT,
+  },
+  {
+    name: "Plan: v3.1 feature roadmap",
+    intent: "planning",
+    instruction: "Based on the current Agent Hive codebase, propose a v3.1 feature roadmap. Consider: what's missing for production use, what users would want next, what technical debt remains. Output to docs/roadmap-v3.1.md with priority ranking.",
+    workDir: PROJECT_ROOT,
+  },
+];
+
+function cleanTasks() {
+  if (fs.existsSync(TASKS_DIR)) {
+    for (const f of fs.readdirSync(TASKS_DIR).filter(f => f.endsWith(".json"))) {
+      fs.unlinkSync(path.join(TASKS_DIR, f));
+    }
+  }
+}
+
+function main() {
+  const day = parseInt(process.argv[2]) || 1;
+  const taskIndex = (day - 1) % TASK_TEMPLATES.length;
+  const template = TASK_TEMPLATES[taskIndex];
+
+  console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+  console.log(`Continuous Validation — Day ${day}`);
+  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+
+  console.log(`Task: ${template.name}`);
+  console.log(`Intent: ${template.intent}`);
+  console.log(`Working directory: ${template.workDir}\n`);
+
+  // Clean stale tasks
+  cleanTasks();
+
+  // Output task config for the runner
+  const taskConfig = {
+    day,
+    timestamp: new Date().toISOString(),
+    task: template,
+  };
+
+  fs.mkdirSync(REPORTS_DIR, { recursive: true });
+  fs.writeFileSync(
+    path.join(REPORTS_DIR, `day-${day}-config.json`),
+    JSON.stringify(taskConfig, null, 2)
+  );
+
+  console.log(`Config saved to reports/day-${day}-config.json`);
+  console.log(`\nRun with: node dist/commands/cli.js run --task "${template.instruction.slice(0, 80)}..."\n`);
+
+  // Also print the full command
+  console.log(`Full command:`);
+  console.log(`  node dist/commands/cli.js run --task "${template.instruction.replace(/"/g, '\\"')}" --dir "${template.workDir}" --max-revision 3\n`);
+}
+
+main();

package/src/commands/run-validation.ts

@@ -0,0 +1,316 @@
+/**
+ * v2.2 Validation Runner — runs 3 real tasks through Agent Hive
+ * Uses Broker programmatically (bypasses CLI exit issue)
+ */
+import { Broker } from "../broker/Broker";
+import { getAllAdapters } from "../adapters/registry";
+import { TopologyTemplates } from "../graph/TopologyTemplates";
+import * as fs from "fs";
+import * as path from "path";
+
+interface TaskResult {
+  taskNumber: number;
+  name: string;
+  executor: string;
+  reviewer: string;
+  status: string;
+  revisionCount: number;
+  reviewScore: number;
+  reviewDecision: string;
+  durationMs: number;
+  output: string;
+  issues: string[];
+  escalated: boolean;
+}
+
+const RESULTS_DIR = path.resolve(__dirname, "../../artifacts");
+const REPORTS_DIR = path.resolve(__dirname, "../../reports");
+
+async function runValidation() {
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("Agent Hive v2.2 — Real Project Validation");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+
+  const allResults: TaskResult[] = [];
+  const startTime = Date.now();
+
+  // ─── Task 1: Landing Page ──────────────────────────
+  console.log("═══ Task 1: Landing Page ═══\n");
+  const task1 = await runTask({
+    taskNumber: 1,
+    name: "Landing Page",
+    instruction: `Create a complete marketing landing page for "Agent Hive" — an AI multi-runtime orchestration platform.
+
+Requirements:
+1. Hero section with headline "Agent Hive — Multi-Runtime AI Orchestration" and a CTA button
+2. Features section with 3-4 feature cards (Graph Architecture, Runtime Intelligence, Revision Loop, Observability)
+3. Responsive design (mobile-friendly)
+4. Modern CSS (gradients, smooth transitions, clean typography)
+5. Pure HTML/CSS/JS — no external dependencies
+
+Output a single index.html file.`,
+    executor: "claude",
+    reviewer: "codex",
+    workDir: path.join(RESULTS_DIR, "task-1"),
+    timeout: 180_000,
+  });
+  allResults.push(task1);
+
+  // ─── Task 2: REST API ──────────────────────────────
+  console.log("\n═══ Task 2: REST API ═══\n");
+  const task2 = await runTask({
+    taskNumber: 2,
+    name: "REST API (Users CRUD)",
+    instruction: `Implement a real Users CRUD REST API in Node.js (vanilla, no Express).
+
+Requirements:
+1. GET /users — list all users
+2. POST /users — create user (name, email required)
+3. PUT /users/:id — update user
+4. DELETE /users/:id — delete user
+5. JSON error handling with proper status codes
+6. Input validation (email format, required fields)
+7. In-memory storage (array)
+8. PORT from env or default 3000
+
+Output: package.json + src/index.js. The server must be startable with "node src/index.js".`,
+    executor: "codex",
+    reviewer: "claude",
+    workDir: path.join(RESULTS_DIR, "task-2"),
+    timeout: 180_000,
+  });
+  allResults.push(task2);
+
+  // ─── Task 3: Refactor ──────────────────────────────
+  console.log("\n═══ Task 3: Refactor Bad Code ═══\n");
+
+  // First, create the bad code
+  const badCodeDir = path.join(RESULTS_DIR, "task-3");
+  const badCodePath = path.join(badCodeDir, "bad-code.ts");
+  fs.mkdirSync(badCodeDir, { recursive: true });
+  fs.writeFileSync(badCodePath, BAD_CODE);
+
+  const task3 = await runTask({
+    taskNumber: 3,
+    name: "Refactor Bad Code",
+    instruction: `Refactor the TypeScript file at ${badCodePath}.
+
+The file has these problems:
+1. Duplicate code — same logic repeated 3+ times
+2. Poor naming — single letter variables, unclear function names
+3. No separation of concerns — everything in one file
+4. Missing error handling — no try/catch, no input validation
+5. No types — using 'any' everywhere
+
+Refactor the file:
+- Extract reusable functions
+- Use clear, descriptive names
+- Add proper TypeScript types
+- Add error handling
+- Split into logical modules if needed
+
+Write the refactored code to ${badCodeDir}/refactored/`,
+    executor: "codex",
+    reviewer: "claude",
+    workDir: badCodeDir,
+    timeout: 180_000,
+  });
+  allResults.push(task3);
+
+  // ─── Collect Metrics ───────────────────────────────
+  const totalTime = Date.now() - startTime;
+  const metrics = collectMetrics(allResults, totalTime);
+
+  // ─── Write Reports ─────────────────────────────────
+  fs.mkdirSync(REPORTS_DIR, { recursive: true });
+  fs.writeFileSync(
+    path.join(REPORTS_DIR, "validation-metrics.json"),
+    JSON.stringify(metrics, null, 2)
+  );
+
+  console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("Validation Complete");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log(`  Total time: ${(totalTime / 1000).toFixed(1)}s`);
+  console.log(`  Success rate: ${metrics.taskSuccessRate}`);
+  console.log(`  Avg revision count: ${metrics.averageRevisionCount}`);
+  console.log(`  Avg review score: ${metrics.averageReviewScore}`);
+  console.log(`  Reports: ${REPORTS_DIR}/validation-metrics.json`);
+
+  process.exit(0);
+}
+
+interface TaskConfig {
+  taskNumber: number;
+  name: string;
+  instruction: string;
+  executor: string;
+  reviewer: string;
+  workDir: string;
+  timeout: number;
+}
+
+async function runTask(config: TaskConfig): Promise<TaskResult> {
+  // Clean stale tasks from previous runs
+  const tasksDir = path.resolve(process.cwd(), ".agent-hive/tasks");
+  if (fs.existsSync(tasksDir)) {
+    for (const f of fs.readdirSync(tasksDir).filter(f => f.endsWith(".json"))) {
+      fs.unlinkSync(path.join(tasksDir, f));
+    }
+  }
+
+  const broker = new Broker();
+
+  // Register adapters
+  for (const adapter of getAllAdapters()) {
+    await broker.registerAdapter(adapter);
+  }
+
+  // Build graph with runtime names as agent IDs
+  const { AgentProfile } = require("../types");
+  broker.addAgentProfile({ id: config.executor, runtimeId: config.executor, role: "executor", maxConcurrency: 1, status: "idle" });
+  broker.addAgentProfile({ id: config.reviewer, runtimeId: config.reviewer, role: "reviewer", maxConcurrency: 1, status: "idle" });
+  broker.addGraphEdge(config.executor, config.reviewer, "reviews", 10);
+  broker.addGraphEdge(config.reviewer, config.executor, "escalates", 5);
+  broker.enableGraphMode();
+
+  // Submit task
+  broker.submit({
+    instruction: config.instruction,
+    executor: config.executor,
+    reviewer: config.reviewer,
+    workingDirectory: config.workDir,
+    maxRevision: 3,
+    timeout: config.timeout,
+  });
+
+  // Run
+  const start = Date.now();
+  await broker.run();
+  const duration = Date.now() - start;
+
+  // Collect results
+  const tasks = broker.listTasks();
+  const task = tasks[0];
+  const history = broker.history.get(task?.id || "");
+  const lastReview = history[history.length - 1];
+
+  const result: TaskResult = {
+    taskNumber: config.taskNumber,
+    name: config.name,
+    executor: config.executor,
+    reviewer: config.reviewer,
+    status: task?.status || "UNKNOWN",
+    revisionCount: task?.revisionCount || 0,
+    reviewScore: lastReview?.score || 0,
+    reviewDecision: lastReview?.decision || "UNKNOWN",
+    durationMs: duration,
+    output: (task?.result || "").slice(0, 500),
+    issues: lastReview?.issues || [],
+    escalated: task?.status === "ESCALATED",
+  };
+
+  // Save artifacts
+  fs.mkdirSync(config.workDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(config.workDir, "result.json"),
+    JSON.stringify(result, null, 2)
+  );
+
+  console.log(`  Status: ${result.status}`);
+  console.log(`  Revisions: ${result.revisionCount}`);
+  console.log(`  Score: ${result.reviewScore}`);
+  console.log(`  Time: ${(duration / 1000).toFixed(1)}s`);
+
+  return result;
+}
+
+function collectMetrics(results: TaskResult[], totalTime: number) {
+  const successCount = results.filter(r => r.status === "COMPLETED").length;
+  const totalRevisions = results.reduce((s, r) => s + r.revisionCount, 0);
+  const totalScore = results.reduce((s, r) => s + r.reviewScore, 0);
+  const escalationCount = results.filter(r => r.escalated).length;
+
+  return {
+    timestamp: new Date().toISOString(),
+    totalTasks: results.length,
+    successfulTasks: successCount,
+    taskSuccessRate: `${((successCount / results.length) * 100).toFixed(0)}%`,
+    averageRevisionCount: (totalRevisions / results.length).toFixed(1),
+    averageReviewScore: (totalScore / results.length).toFixed(1),
+    totalDurationMs: totalTime,
+    averageCompletionMs: Math.round(totalTime / results.length),
+    escalationCount,
+    runtimeDistribution: {
+      executor: results.map(r => r.executor),
+      reviewer: results.map(r => r.reviewer),
+    },
+    taskDetails: results,
+  };
+}
+
+// ─── Deliberately bad code for Task 3 ──────────────────
+
+const BAD_CODE = `import * as fs from "fs";
+
+// process data
+function p(d: any) {
+  let r = [];
+  for (let i = 0; i < d.length; i++) {
+    if (d[i].t == "a") {
+      r.push({ n: d[i].n, v: d[i].v * 2 });
+    }
+  }
+  return r;
+}
+
+// also process data but slightly different
+function p2(d: any) {
+  let r = [];
+  for (let i = 0; i < d.length; i++) {
+    if (d[i].t == "b") {
+      r.push({ n: d[i].n, v: d[i].v * 3 });
+    }
+  }
+  return r;
+}
+
+// and again
+function p3(d: any) {
+  let r = [];
+  for (let i = 0; i < d.length; i++) {
+    if (d[i].t == "c") {
+      r.push({ n: d[i].n, v: d[i].v + 10 });
+    }
+  }
+  return r;
+}
+
+// save to file
+function s(d: any, f: string) {
+  fs.writeFileSync(f, JSON.stringify(d));
+}
+
+// load from file
+function l(f: string) {
+  return JSON.parse(fs.readFileSync(f, "utf-8"));
+}
+
+// do everything
+function main() {
+  const d = l("data.json");
+  const a = p(d);
+  const b = p2(d);
+  const c = p3(d);
+  const all = [...a, ...b, ...c];
+  s(all, "output.json");
+  console.log("done: " + all.length);
+}
+
+main();
+`;
+
+runValidation().catch((err) => {
+  console.error("Validation failed:", err);
+  process.exit(1);
+});

package/src/commands/test-benchmark.ts

@@ -0,0 +1,208 @@
+import { BenchmarkDataset } from "../benchmark/BenchmarkDataset";
+import { BenchmarkRunner } from "../benchmark/BenchmarkRunner";
+import { BenchmarkReport } from "../benchmark/BenchmarkReport";
+import { BENCHMARK_CASES, BenchmarkResult } from "../benchmark/BenchmarkSuite";
+import { RuntimeSelector } from "../runtime/RuntimeSelector";
+import { CapabilityDiscovery } from "../runtime/CapabilityDiscovery";
+import { RuntimeScoreManager } from "../runtime/RuntimeScoreManager";
+import { Broker } from "../broker/Broker";
+import { TaskTimeline } from "../observability/TaskTimeline";
+import { RuntimeMetrics } from "../observability/RuntimeMetrics";
+import { DecisionRecorder } from "../observability/DecisionRecorder";
+import { AgentAdapter, AgentResult, Task } from "../types";
+import * as fs from "fs";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { console.log(`    ✓ ${msg}`); passed++; }
+  else { console.log(`    ✗ ${msg}`); failed++; }
+}
+
+// Mock runtimes with different strengths
+class StrongCoderAdapter implements AgentAdapter {
+  name = "codex";
+  role = "developer" as const;
+  capabilities = ["coding", "refactor"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task): Promise<AgentResult> {
+    return { success: true, output: "function greet(name) { return 'Hello, ' + name + '!'; }" };
+  }
+}
+
+class StrongReviewerAdapter implements AgentAdapter {
+  name = "claude";
+  role = "reviewer" as const;
+  capabilities = ["review", "architecture", "coding"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task): Promise<AgentResult> {
+    return { success: true, output: "SQL injection vulnerability found. Use parameterized queries." };
+  }
+}
+
+class StrongPlannerAdapter implements AgentAdapter {
+  name = "hermes";
+  role = "planner" as const;
+  capabilities = ["planning", "research"];
+  async detect() { return true; }
+  async health() { return true; }
+  async execute(task: Task): Promise<AgentResult> {
+    return { success: true, output: "Components: API gateway, database, cache, message queue. Flow: request → gateway → service → db → response." };
+  }
+}
+
+async function main() {
+  try { fs.rmSync(".agent-hive", { recursive: true, force: true }); } catch {}
+  fs.mkdirSync(".agent-hive", { recursive: true });
+
+  console.log("═══════════════════════════════════════════");
+  console.log("  Test Suite: Benchmark (v2.1.7)");
+  console.log("═══════════════════════════════════════════\n");
+
+  // Test 1: BenchmarkDataset
+  console.log("  [Test 1] BenchmarkDataset");
+  console.log("  ────────────────────────────────────");
+  {
+    const ds = new BenchmarkDataset();
+    ds.set({ runtimeId: "codex", coding: 97, review: 88, planning: 82, reasoning: 90, latency: 1500, successRate: 1.0, updatedAt: Date.now() });
+    ds.set({ runtimeId: "claude", coding: 92, review: 96, planning: 94, reasoning: 95, latency: 3000, successRate: 1.0, updatedAt: Date.now() });
+
+    const codex = ds.get("codex");
+    assert(codex !== undefined, "Codex exists");
+    assert(codex!.coding === 97, "Codex coding: " + codex!.coding);
+    assert(ds.all().length === 2, "Total: " + ds.all().length);
+    assert(ds.getCategoryScore("codex", "coding") === 97, "Category score works");
+    assert(ds.getOverallScore("codex") > 0, "Overall score: " + ds.getOverallScore("codex").toFixed(1));
+    assert(fs.existsSync(".agent-hive/benchmark/runtime-benchmark.json"), "Persisted");
+    console.log("  Test 1: PASS ✓\n");
+  }
+
+  // Test 2: BenchmarkRunner
+  console.log("  [Test 2] BenchmarkRunner");
+  console.log("  ────────────────────────────────────");
+  {
+    const ds = new BenchmarkDataset();
+    const tl = new TaskTimeline();
+    const m = new RuntimeMetrics();
+    const dr = new DecisionRecorder();
+    const runner = new BenchmarkRunner(ds, tl, m, dr);
+
+    const coder = new StrongCoderAdapter();
+    const results = await runner.runRuntime(coder);
+
+    assert(results.length === BENCHMARK_CASES.length, "Results: " + results.length + "/" + BENCHMARK_CASES.length);
+    assert(results.every(r => r.success), "All succeeded");
+    assert(results.some(r => r.score > 0), "Some scored > 0");
+
+    // Aggregate
+    const benchmark = runner.aggregate("codex", results);
+    assert(benchmark.runtimeId === "codex", "Runtime: " + benchmark.runtimeId);
+    assert(benchmark.coding > 0, "Coding score: " + benchmark.coding);
+    assert(benchmark.successRate === 1.0, "Success rate: " + benchmark.successRate);
+
+    console.log("  Test 2: PASS ✓\n");
+  }
+
+  // Test 3: BenchmarkReport
+  console.log("  [Test 3] BenchmarkReport");
+  console.log("  ────────────────────────────────────");
+  {
+    const ds = new BenchmarkDataset();
+    const tl = new TaskTimeline();
+    const m = new RuntimeMetrics();
+    const dr = new DecisionRecorder();
+    const runner = new BenchmarkRunner(ds, tl, m, dr);
+
+    // Run benchmarks for 3 runtimes
+    const allResults = new Map<string, BenchmarkResult[]>();
+    for (const adapter of [new StrongCoderAdapter(), new StrongReviewerAdapter(), new StrongPlannerAdapter()]) {
+      const results = await runner.runRuntime(adapter);
+      runner.aggregate(adapter.name, results);
+      allResults.set(adapter.name, results);
+    }
+
+    const report = new BenchmarkReport(ds);
+
+    // JSON report
+    const json = report.generateJSON(allResults);
+    assert(json !== null, "JSON report generated");
+    assert(fs.existsSync(".agent-hive/reports/benchmark-report.json"), "JSON persisted");
+
+    // Markdown report
+    const md = report.generateMarkdown();
+    assert(md.includes("Runtime Benchmark Report"), "MD has title");
+    assert(md.includes("codex"), "MD has codex");
+    assert(fs.existsSync(".agent-hive/reports/benchmark-report.md"), "MD persisted");
+
+    // Rankings
+    const rankings = report.getRankings();
+    assert(rankings.overall.length === 3, "Overall ranking: " + rankings.overall.length);
+    assert(rankings.coding.length === 3, "Coding ranking: " + rankings.coding.length);
+
+    const formatted = report.formatRankings();
+    assert(formatted.includes("codex"), "Formatted has codex");
+
+    console.log("  Test 3: PASS ✓\n");
+  }
+
+  // Test 4: RuntimeSelector Integration
+  console.log("  [Test 4] RuntimeSelector Integration");
+  console.log("  ────────────────────────────────────");
+  {
+    const ds = new BenchmarkDataset();
+    // Set benchmark data
+    ds.set({ runtimeId: "codex", coding: 97, review: 88, planning: 82, reasoning: 90, latency: 1500, successRate: 1.0, updatedAt: Date.now() });
+    ds.set({ runtimeId: "claude", coding: 92, review: 96, planning: 94, reasoning: 95, latency: 3000, successRate: 1.0, updatedAt: Date.now() });
+    ds.set({ runtimeId: "hermes", coding: 80, review: 90, planning: 96, reasoning: 92, latency: 2000, successRate: 1.0, updatedAt: Date.now() });
+
+    // Verify benchmark data influences selection
+    const codexCoding = ds.getCategoryScore("codex", "coding");
+    const claudeCoding = ds.getCategoryScore("claude", "coding");
+    const hermesPlanning = ds.getCategoryScore("hermes", "planning");
+
+    assert(codexCoding > claudeCoding, "Codex coding > Claude coding: " + codexCoding + " > " + claudeCoding);
+    assert(hermesPlanning > ds.getCategoryScore("codex", "planning"), "Hermes planning > Codex planning: " + hermesPlanning + " > " + ds.getCategoryScore("codex", "planning"));
+
+    // Overall scores
+    const codexOverall = ds.getOverallScore("codex");
+    const claudeOverall = ds.getOverallScore("claude");
+    assert(codexOverall > 0 && claudeOverall > 0, "Overall scores calculated");
+
+    console.log("  Test 4: PASS ✓\n");
+  }
+
+  // Test 5: Observability Integration
+  console.log("  [Test 5] Observability Integration");
+  console.log("  ────────────────────────────────────");
+  {
+    const ds = new BenchmarkDataset();
+    const tl = new TaskTimeline();
+    const m = new RuntimeMetrics();
+    const dr = new DecisionRecorder();
+    const runner = new BenchmarkRunner(ds, tl, m, dr);
+
+    await runner.runRuntime(new StrongCoderAdapter());
+
+    // Timeline should have records
+    const allTraces = tl.all();
+    assert(allTraces.length > 0, "Timeline has " + allTraces.length + " traces");
+
+    // Metrics should have records
+    const codexMetrics = m.get("codex");
+    assert(codexMetrics !== undefined, "Metrics recorded for codex");
+    assert(codexMetrics!.taskCount > 0, "Task count: " + codexMetrics!.taskCount);
+
+    console.log("  Test 5: PASS ✓\n");
+  }
+
+  console.log("═══════════════════════════════════════════");
+  console.log("  Results: " + passed + " passed, " + failed + " failed");
+  console.log("═══════════════════════════════════════════");
+
+  if (failed > 0) process.exit(1);
+}
+
+main().catch(err => { console.error("Fatal:", err); process.exit(1); });