@ranker/raxflow 0.2.1 → 0.2.3

package/src/doctor.ts

@@ -1,92 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { HostBridgeAdapter } from "rax-flow-providers";
-import { c } from "./styles.js";
-
-interface DoctorOptions {
-  cwd: string;
-}
-
-interface RaxConfig {
-  defaultProvider?: string;
-  strongProvider?: string;
-  providers?: {
-    host?: { model?: string; mode?: "auto" | "bridge-only" | "mock"; bridgeCommandEnv?: string; timeoutMs?: number };
-  };
-}
-
-async function loadConfig(cwd: string): Promise<RaxConfig | null> {
-  const file = path.join(cwd, ".raxrc");
-  try {
-    const raw = await readFile(file, "utf8");
-    return JSON.parse(raw) as RaxConfig;
-  } catch {
-    return null;
-  }
-}
-
-function printLine(ok: boolean, label: string, details?: string) {
-  const icon = ok ? c.green("[ok]") : c.red("[fail]");
-  console.log(`${icon} ${label}${details ? ` - ${details}` : ""}`);
-}
-
-export async function runDoctor(options: DoctorOptions): Promise<number> {
-  console.log(c.blue("RAXFLOW Doctor"));
-
-  const config = await loadConfig(options.cwd);
-  if (!config) {
-    printLine(false, "Missing .raxrc", "run `raxflow install` first");
-    return 1;
-  }
-  printLine(true, "Found .raxrc");
-
-  const hostCfg = config.providers?.host;
-  const bridgeCommandEnv = hostCfg?.bridgeCommandEnv ?? "RAX_HOST_BRIDGE_COMMAND";
-  const bridgeCommand = process.env[bridgeCommandEnv];
-  const provider = new HostBridgeAdapter({
-    model: hostCfg?.model ?? "host-managed",
-    mode: hostCfg?.mode ?? "auto",
-    command: bridgeCommand,
-    timeoutMs: hostCfg?.timeoutMs ?? 10000
-  });
-
-  const health = await provider.healthCheck();
-  printLine(health, "Host provider health", `mode=${hostCfg?.mode ?? "auto"}`);
-
-  const hasBridgeFn = typeof (globalThis as Record<string, unknown>).__RAX_HOST_BRIDGE__ === "function";
-  printLine(hasBridgeFn || Boolean(bridgeCommand), "Bridge source", hasBridgeFn ? "global bridge function" : bridgeCommand ? `command via ${bridgeCommandEnv}` : "auto/mock fallback");
-
-  try {
-    const ping = await provider.callModel("doctor ping", { model: hostCfg?.model ?? "host-managed", maxTokens: 32, temperature: 0 });
-    printLine(true, "callModel test", `provider=${ping.provider} model=${ping.model}`);
-  } catch (error) {
-    printLine(false, "callModel test", String(error));
-    return 1;
-  }
-
-  try {
-    const structured = await provider.callStructured(
-      "doctor structured ping",
-      {
-        type: "object",
-        required: ["agent", "success", "confidence", "risks", "logs", "data"],
-        properties: {
-          agent: { type: "string" },
-          success: { type: "boolean" },
-          confidence: { type: "number" },
-          risks: { type: "array" },
-          logs: { type: "array" },
-          data: { type: "object" }
-        }
-      },
-      { model: hostCfg?.model ?? "host-managed", maxTokens: 128, temperature: 0 }
-    );
-    printLine(true, "callStructured test", `model=${structured.model}`);
-  } catch (error) {
-    printLine(false, "callStructured test", String(error));
-    return 1;
-  }
-
-  console.log(c.green("Doctor checks passed."));
-  return 0;
-}

package/src/evolve.ts

@@ -1,74 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { c } from "./styles.js";
-
-interface EvolveOptions {
-    cwd: string;
-    history?: boolean;
-}
-
-interface Blueprint {
-    id: string;
-    version: string;
-    createdAt: string;
-    fitnessScore: number;
-    mutationType: string;
-    metadata?: {
-        message?: string;
-        reason?: string;
-    };
-}
-
-export async function showEvolution(options: EvolveOptions): Promise<number> {
-    const evolutionDir = path.join(options.cwd, ".rax-flow", "evolutions");
-
-    try {
-        const files = await readdir(evolutionDir);
-        const blueprintFiles = files.filter(f => f.startsWith("blueprint_") && f.endsWith(".json"));
-
-        if (blueprintFiles.length === 0) {
-            console.log(c.yellow("\nNo evolutions recorded yet. Run more tasks to trigger Darwinian mutations."));
-            return 0;
-        }
-
-        const blueprints: Blueprint[] = [];
-        for (const file of blueprintFiles) {
-            const raw = await readFile(path.join(evolutionDir, file), "utf8");
-            blueprints.push(JSON.parse(raw) as Blueprint);
-        }
-
-        // Sort by creation date
-        blueprints.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-
-        console.log(c.bold(c.magenta(`\n\n--- [GENETIC LINEAGE: RAX-FLOW] ---`)));
-        console.log(c.gray(`Found ${blueprints.length} evolutionary jumps.\n`));
-
-        blueprints.forEach((bp, i) => {
-            const connector = i === blueprints.length - 1 ? "└" : "├";
-            const branch = i === 0 ? "" : `  ${connector}── `;
-
-            const scoreColor = bp.fitnessScore >= 0.8 ? c.green : (bp.fitnessScore >= 0.6 ? c.yellow : c.red);
-
-            console.log(`${branch}${c.bold(bp.id)} ${c.gray(`v${bp.version}`)}`);
-            console.log(`     ${c.gray("Type:")} ${c.cyan(bp.mutationType)}`);
-            console.log(`     ${c.gray("Fitness:")} ${scoreColor(bp.fitnessScore.toFixed(2))}`);
-            if (bp.metadata?.reason || bp.metadata?.message) {
-                console.log(`     ${c.gray("Note:")} ${c.white(bp.metadata.reason || bp.metadata.message || "")}`);
-            }
-            if (i < blueprints.length - 1) {
-                console.log(`     ${c.gray("│")}`);
-            }
-        });
-
-        console.log(c.bold(c.cyan(`\nSurvival of the fittest: Blueprint ${blueprints[blueprints.length - 1]?.id} is currently dominant.`)));
-
-        return 0;
-    } catch (error) {
-        if ((error as any).code === "ENOENT") {
-            console.log(c.yellow("\nNo evolutions directory found. Run tasks first."));
-            return 0;
-        }
-        console.error(c.red(`Failed to read evolution history: ${error}`));
-        return 1;
-    }
-}

package/src/host-init-templates.ts

@@ -1,134 +0,0 @@
-export type HostTarget = "claude-code" | "codex" | "opencode" | "kilo" | "generic";
-
-export interface HostTemplate {
-  id: HostTarget;
-  title: string;
-  envHint: string;
-  chatHint: string;
-  bootstrapPromptBase: string[];
-  quickCommands: string[];
-  autoInjectMode: "native" | "scripted" | "manual";
-  sessionEntryExamples: string[];
-}
-
-export const HOST_TEMPLATES: Record<HostTarget, HostTemplate> = {
-  "claude-code": {
-    id: "claude-code",
-    title: "Claude Code",
-    envHint: "Export RAX_HOST_BRIDGE_COMMAND before starting Claude Code session.",
-    chatHint: "Paste BOOTSTRAP_PROMPT.txt at the beginning of the chat.",
-    bootstrapPromptBase: [
-      "RAXFLOW bootstrap (Claude Code)",
-      "- Enable host-native orchestration.",
-      "- Route generation through the configured host bridge.",
-      "- Keep structured JSON outputs for orchestration steps.",
-      "- Execute Verify -> Fix loop when schema validation fails.",
-      "- Report confidence, risk flags, and logs for each step."
-    ],
-    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
-    autoInjectMode: "scripted",
-    sessionEntryExamples: [
-      "claude-code chat --message-file .raxflow/host-init/claude-code/BOOTSTRAP_PROMPT.txt",
-      "claude-code (open session, then paste BOOTSTRAP_PROMPT.txt)"
-    ]
-  },
-  codex: {
-    id: "codex",
-    title: "Codex",
-    envHint: "Set RAX_HOST_BRIDGE_COMMAND in the shell running Codex.",
-    chatHint: "Send BOOTSTRAP_PROMPT.txt as first instruction in session.",
-    bootstrapPromptBase: [
-      "RAXFLOW bootstrap (Codex)",
-      "- Use host-native model execution through the host bridge.",
-      "- Produce strict structured outputs for all agent steps.",
-      "- Apply Verify -> Fix until valid schema or retry cap.",
-      "- Include confidence and risks in every final step."
-    ],
-    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
-    autoInjectMode: "scripted",
-    sessionEntryExamples: [
-      "codex chat --message-file .raxflow/host-init/codex/BOOTSTRAP_PROMPT.txt",
-      "codex (open session, then paste BOOTSTRAP_PROMPT.txt)"
-    ]
-  },
-  opencode: {
-    id: "opencode",
-    title: "OpenCode",
-    envHint: "Configure RAX_HOST_BRIDGE_COMMAND in OpenCode terminal/runtime env.",
-    chatHint: "Paste BOOTSTRAP_PROMPT.txt before requesting implementation.",
-    bootstrapPromptBase: [
-      "RAXFLOW bootstrap (OpenCode)",
-      "- Activate host bridge orchestration mode.",
-      "- Keep responses compact but structured for agent pipeline.",
-      "- Trigger fix cycles on validation failures automatically.",
-      "- Emit step logs and confidence scores."
-    ],
-    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
-    autoInjectMode: "manual",
-    sessionEntryExamples: [
-      "opencode chat --message-file .raxflow/host-init/opencode/BOOTSTRAP_PROMPT.txt",
-      "opencode (open session, then paste BOOTSTRAP_PROMPT.txt)"
-    ]
-  },
-  kilo: {
-    id: "kilo",
-    title: "Kilo Code",
-    envHint: "Set RAX_HOST_BRIDGE_COMMAND in Kilo launch environment.",
-    chatHint: "Paste BOOTSTRAP_PROMPT.txt as initialization message.",
-    bootstrapPromptBase: [
-      "RAXFLOW bootstrap (Kilo)",
-      "- Run in host-native orchestration mode.",
-      "- Enforce structured output contract for each stage.",
-      "- Apply Verify -> Fix and escalate when confidence is low.",
-      "- Return actionable logs and risk flags."
-    ],
-    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
-    autoInjectMode: "manual",
-    sessionEntryExamples: [
-      "kilo chat --message-file .raxflow/host-init/kilo/BOOTSTRAP_PROMPT.txt",
-      "kilo (open session, then paste BOOTSTRAP_PROMPT.txt)"
-    ]
-  },
-  generic: {
-    id: "generic",
-    title: "Generic Host",
-    envHint: "Provide a bridge command through RAX_HOST_BRIDGE_COMMAND.",
-    chatHint: "Paste BOOTSTRAP_PROMPT.txt at session start.",
-    bootstrapPromptBase: [
-      "RAXFLOW bootstrap (Generic)",
-      "- Enable orchestration through host bridge.",
-      "- Return strict JSON for each orchestration step.",
-      "- Retry/fix invalid outputs automatically.",
-      "- Report confidence, risks, and logs."
-    ],
-    quickCommands: ["npx raxflow doctor", "npx raxflow run --prompt \"Build feature X\" --stream"],
-    autoInjectMode: "manual",
-    sessionEntryExamples: [
-      "your-host-cli chat --message-file .raxflow/host-init/generic/BOOTSTRAP_PROMPT.txt",
-      "open session, then paste BOOTSTRAP_PROMPT.txt"
-    ]
-  }
-};
-
-export function parseHostTarget(value: string | undefined): HostTarget {
-  if (!value) return "generic";
-  if (value in HOST_TEMPLATES) return value as HostTarget;
-  return "generic";
-}
-
-export function listHostTargets(): HostTarget[] {
-  return Object.keys(HOST_TEMPLATES) as HostTarget[];
-}
-
-export function buildBootstrapPrompt(target: HostTarget, task?: string): string {
-  const template = HOST_TEMPLATES[target];
-  const lines = [...template.bootstrapPromptBase];
-
-  if (task && task.trim().length > 0) {
-    lines.push(`- Task context: ${task.trim()}`);
-    lines.push("- Keep orchestration aligned with this task context unless user changes scope.");
-  }
-
-  lines.push("- If bridge call fails, report issue clearly and keep orchestration state.");
-  return lines.join("\n");
-}

package/src/hub/__tests__/commands.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { registerCommand, getCommandRegistry } from "../commands/index.js";
-import { CommandDefinition } from "../types.js";
-
-describe("Command Registry", () => {
-  beforeEach(() => {
-    // Clear the registry before each test
-    const registry = getCommandRegistry();
-    registry.clear();
-  });
-
-  describe("registerCommand", () => {
-    it("should register a command", () => {
-      const cmd: CommandDefinition = {
-        name: "test",
-        description: "Test command",
-        handler: async () => {},
-      };
-
-      registerCommand(cmd);
-      const registry = getCommandRegistry();
-      expect(registry.has("test")).toBe(true);
-    });
-
-    it("should register command with aliases", () => {
-      const cmd: CommandDefinition = {
-        name: "status",
-        description: "Show status",
-        handler: async () => {},
-        aliases: ["st", "s"],
-      };
-
-      registerCommand(cmd);
-      const registry = getCommandRegistry();
-      expect(registry.has("status")).toBe(true);
-      expect(registry.has("st")).toBe(true);
-      expect(registry.has("s")).toBe(true);
-    });
-
-    it("should allow multiple commands to be registered", () => {
-      registerCommand({
-        name: "cmd1",
-        description: "Command 1",
-        handler: async () => {},
-      });
-
-      registerCommand({
-        name: "cmd2",
-        description: "Command 2",
-        handler: async () => {},
-      });
-
-      const registry = getCommandRegistry();
-      expect(registry.size).toBe(2);
-    });
-  });
-
-  describe("getCommandRegistry", () => {
-    it("should return the same registry instance", () => {
-      const registry1 = getCommandRegistry();
-      const registry2 = getCommandRegistry();
-      expect(registry1).toBe(registry2);
-    });
-
-    it("should allow retrieving registered commands", async () => {
-      const mockHandler = async () => {
-        // Mock handler that does nothing
-      };
-      
-      registerCommand({
-        name: "mock",
-        description: "Mock command",
-        handler: mockHandler,
-      });
-
-      const registry = getCommandRegistry();
-      const cmd = registry.get("mock");
-      expect(cmd).toBeDefined();
-      expect(cmd?.name).toBe("mock");
-      expect(cmd?.description).toBe("Mock command");
-      expect(cmd?.handler).toBe(mockHandler);
-    });
-  });
-});

package/src/hub/__tests__/history.test.ts

@@ -1,137 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { CommandHistory } from "../history.js";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { tmpdir } from "os";
-
-describe("CommandHistory", () => {
-  let tempDir: string;
-  let history: CommandHistory;
-
-  beforeEach(async () => {
-    // Create a temporary directory for testing
-    tempDir = path.join(tmpdir(), `raxflow-test-${Date.now()}`);
-    await fs.mkdir(tempDir, { recursive: true });
-    history = new CommandHistory(tempDir);
-  });
-
-  afterEach(async () => {
-    // Clean up temporary directory
-    try {
-      await fs.rm(tempDir, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("add", () => {
-    it("should add a command to history", () => {
-      history.add("status");
-      expect(history.getAll()).toContain("status");
-    });
-
-    it("should not add duplicate consecutive commands", () => {
-      history.add("status");
-      history.add("status");
-      expect(history.getAll().filter(c => c === "status").length).toBe(1);
-    });
-
-    it("should allow same command if not consecutive", () => {
-      history.add("status");
-      history.add("agents");
-      history.add("status");
-      expect(history.getAll()).toEqual(["status", "agents", "status"]);
-    });
-  });
-
-  describe("up/down navigation", () => {
-    it("should return undefined when navigating up on empty history", () => {
-      expect(history.up()).toBeUndefined();
-    });
-
-    it("should return commands when navigating up", () => {
-      history.add("status");
-      history.add("agents");
-      history.add("run test");
-
-      expect(history.up()).toBe("run test");
-      expect(history.up()).toBe("agents");
-      expect(history.up()).toBe("status");
-    });
-
-    it("should stop at the beginning when navigating up", () => {
-      history.add("status");
-      history.up();
-      expect(history.up()).toBeUndefined();
-    });
-
-    it("should navigate down after navigating up", () => {
-      history.add("status");
-      history.add("agents");
-      history.up();
-      history.up();
-      expect(history.down()).toBe("agents");
-    });
-
-    it("should return undefined when navigating down past the end", () => {
-      history.add("status");
-      history.down();
-      expect(history.down()).toBeUndefined();
-    });
-  });
-
-  describe("save and load", () => {
-    it("should save history to file", async () => {
-      history.add("status");
-      history.add("agents");
-      await history.save();
-
-      const historyPath = path.join(tempDir, ".rax", "history.json");
-      const content = await fs.readFile(historyPath, "utf-8");
-      const saved = JSON.parse(content);
-      expect(saved).toEqual(["status", "agents"]);
-    });
-
-    it("should load history from file", async () => {
-      // Setup: Create history file
-      const raxDir = path.join(tempDir, ".rax");
-      await fs.mkdir(raxDir, { recursive: true });
-      const historyPath = path.join(raxDir, "history.json");
-      await fs.writeFile(historyPath, JSON.stringify(["status", "agents"]));
-
-      // Load and verify
-      const newHistory = new CommandHistory(tempDir);
-      await newHistory.load();
-      expect(newHistory.getAll()).toEqual(["status", "agents"]);
-    });
-
-    it("should handle missing history file gracefully", async () => {
-      await history.load();
-      expect(history.getAll()).toEqual([]);
-    });
-
-    it("should limit history to last 1000 commands", async () => {
-      // Add 1005 commands
-      for (let i = 0; i < 1005; i++) {
-        history.add(`command-${i}`);
-      }
-      await history.save();
-
-      const historyPath = path.join(tempDir, ".rax", "history.json");
-      const content = await fs.readFile(historyPath, "utf-8");
-      const saved = JSON.parse(content);
-      expect(saved.length).toBe(1000);
-      expect(saved[0]).toBe("command-5"); // First 5 should be removed
-      expect(saved[saved.length - 1]).toBe("command-1004");
-    });
-  });
-
-  describe("getAll", () => {
-    it("should return copy of history array", () => {
-      history.add("status");
-      const all = history.getAll();
-      all.push("modified");
-      expect(history.getAll()).not.toContain("modified");
-    });
-  });
-});

package/src/hub/__tests__/parser.test.ts

@@ -1,105 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseCommand, getCompletions } from "../parser.js";
-import { HubContext } from "../types.js";
-
-describe("parseCommand", () => {
-  it("should parse a simple command", () => {
-    const result = parseCommand("status");
-    expect(result.name).toBe("status");
-    expect(result.args).toEqual([]);
-    expect(result.flags).toEqual({});
-  });
-
-  it("should parse a command with arguments", () => {
-    const result = parseCommand("run Create an API");
-    expect(result.name).toBe("run");
-    expect(result.args).toEqual(["Create", "an", "API"]);
-    expect(result.flags).toEqual({});
-  });
-
-  it("should parse a command with long flags", () => {
-    const result = parseCommand("run --workflow test.json --stream Create API");
-    expect(result.name).toBe("run");
-    expect(result.args).toEqual(["Create", "API"]);
-    expect(result.flags).toEqual({
-      workflow: "test.json",
-      stream: true,
-    });
-  });
-
-  it("should parse a command with short flags", () => {
-    const result = parseCommand("logs -f --agent CodeGenerator");
-    expect(result.name).toBe("logs");
-    expect(result.args).toEqual([]);
-    expect(result.flags).toEqual({
-      f: true,
-      agent: "CodeGenerator",
-    });
-  });
-
-  it("should parse mixed flags and arguments", () => {
-    const result = parseCommand("run --json --max-parallel 6 Create API");
-    expect(result.name).toBe("run");
-    expect(result.args).toEqual(["Create", "API"]);
-    expect(result.flags).toEqual({
-      json: true,
-      "max-parallel": "6",
-    });
-  });
-
-  it("should handle empty input", () => {
-    const result = parseCommand("");
-    expect(result.name).toBe("");
-    expect(result.args).toEqual([]);
-    expect(result.flags).toEqual({});
-  });
-
-  it("should handle whitespace-only input", () => {
-    const result = parseCommand("   ");
-    expect(result.name).toBe("");
-    expect(result.args).toEqual([]);
-    expect(result.flags).toEqual({});
-  });
-});
-
-describe("getCompletions", () => {
-  it("should return all commands for empty input", () => {
-    const completions = getCompletions("");
-    expect(completions).toContain("run");
-    expect(completions).toContain("status");
-    expect(completions).toContain("agents");
-    expect(completions).toContain("exit");
-    expect(completions.length).toBeGreaterThan(10);
-  });
-
-  it("should filter commands by prefix", () => {
-    const completions = getCompletions("sta");
-    expect(completions).toContain("status");
-    expect(completions.every(c => c.startsWith("sta"))).toBe(true);
-  });
-
-  it("should suggest run flags after 'run' command", () => {
-    const completions = getCompletions("run ");
-    expect(completions).toContain("--workflow");
-    expect(completions).toContain("--max-parallel");
-    expect(completions).toContain("--stream");
-    expect(completions).toContain("--json");
-  });
-
-  it("should suggest log flags after 'logs' command", () => {
-    const completions = getCompletions("logs ");
-    expect(completions).toContain("-f");
-    expect(completions).toContain("--agent");
-    expect(completions).toContain("--level");
-  });
-
-  it("should return empty array for unknown command context", () => {
-    const completions = getCompletions("unknowncommand ");
-    expect(completions).toEqual([]);
-  });
-
-  it("should handle partial flag completion", () => {
-    const completions = getCompletions("run --work");
-    expect(completions).toContain("--workflow");
-  });
-});

package/src/hub/commands/agents.ts

@@ -1,53 +0,0 @@
-import { HubContext } from "../types.js";
-import { drawBox } from "../styles/borders.js";
-import { colorize, formatStatus, providerIndicators } from "../styles/colors.js";
-import { padRight } from "../styles/typography.js";
-
-interface AgentInfo {
-  name: string;
-  role: string;
-  status: string;
-  provider: string;
-  lastExecution: string;
-  avgResponseTime: string;
-}
-
-export async function listAgents(_args: string[], _flags: Record<string, string | boolean>, _context: HubContext): Promise<void> {
-  const width = 75;
-  
-  // Agent definitions from official-agents
-  const agents: AgentInfo[] = [
-    { name: "IntentClassifier", role: "Classify user intent", status: "online", provider: "host", lastExecution: "2s ago", avgResponseTime: "45ms" },
-    { name: "Brainstorm", role: "Generate ideas", status: "online", provider: "host", lastExecution: "5m ago", avgResponseTime: "120ms" },
-    { name: "Spec", role: "Write specifications", status: "online", provider: "host", lastExecution: "1m ago", avgResponseTime: "89ms" },
-    { name: "Architecture", role: "Design architecture", status: "online", provider: "host", lastExecution: "3m ago", avgResponseTime: "156ms" },
-    { name: "TaskPlanner", role: "Decompose to DAG", status: "online", provider: "host", lastExecution: "2s ago", avgResponseTime: "34ms" },
-    { name: "CodeGenerator", role: "Generate code", status: "running", provider: "host", lastExecution: "running", avgResponseTime: "234ms" },
-    { name: "Test", role: "Run tests", status: "queued", provider: "host", lastExecution: "--", avgResponseTime: "--" },
-    { name: "Validator", role: "Validate outputs", status: "online", provider: "host", lastExecution: "1m ago", avgResponseTime: "67ms" },
-    { name: "Fix", role: "Patch defects", status: "online", provider: "host", lastExecution: "2m ago", avgResponseTime: "89ms" },
-    { name: "Optimizer", role: "Optimize performance", status: "idle", provider: "anthropic", lastExecution: "1h ago", avgResponseTime: "178ms" },
-    { name: "Documentation", role: "Generate docs", status: "online", provider: "host", lastExecution: "5m ago", avgResponseTime: "145ms" },
-    { name: "Benchmark", role: "Run benchmarks", status: "idle", provider: "host", lastExecution: "2h ago", avgResponseTime: "567ms" },
-  ];
-
-  const lines: string[] = [];
-
-  // Header
-  lines.push(`  ${colorize("AGENT", "bright")}           ${colorize("ROLE", "bright")}              ${colorize("STATUS", "bright")}    ${colorize("PROVIDER", "bright")}  ${colorize("LAST RUN", "bright")}`);
-  lines.push("  " + "─".repeat(71));
-
-  // Agent list
-  for (const agent of agents) {
-    const indicator = formatStatus(agent.status);
-    const providerTag = providerIndicators[agent.provider] || "[?]";
-    const statusColor = agent.status === "running" ? "yellow" : agent.status === "queued" ? "gray" : "green";
-    
-    lines.push(`  ${padRight(agent.name, 16)} ${padRight(agent.role.slice(0, 17), 18)} ${indicator} ${colorize(agent.status.toUpperCase().padEnd(8), statusColor)} ${providerTag}    ${colorize(agent.lastExecution, "gray")}`);
-  }
-
-  lines.push("");
-  lines.push(`  ${colorize("Legend:", "bright")} ● online  ○ idle  ▶ running  ◐ queued`);
-
-  console.log(drawBox(lines, width, "AGENTS"));
-}