@elizaos/autonomous 2.0.0-alpha.71 → 2.0.0-alpha.72

package/test/agent-orchestration.e2e.test.ts

@@ -1,1568 +0,0 @@
-/**
- * End-to-End Tests for Agent Orchestration — GitHub Issue #6 Follow-up
- *
- * Comprehensive E2E tests covering agent orchestration functionality:
- *
- *   1. Task creation and lifecycle (pending → running → completed/failed)
- *   2. Subagent spawning and management
- *   3. Message passing between parent and subagents
- *   4. Task cancellation, pause, and resume
- *   5. Concurrent task handling
- *   6. Cleanup after subagent termination
- *   7. Error handling and recovery
- *   8. API integration for orchestrator endpoints
- *
- * NO MOCKS — all tests use real production code paths where possible.
- */
-import crypto from "node:crypto";
-import fs from "node:fs";
-import http from "node:http";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  AgentRuntime,
-  createCharacter,
-  logger,
-  type Plugin,
-  type UUID,
-} from "@elizaos/core";
-import dotenv from "dotenv";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { startApiServer } from "../src/api/server";
-import {
-  extractPlugin,
-  isPackageImportResolvable,
-  type PluginModuleShape,
-} from "../src/test-support/test-helpers";
-
-// ---------------------------------------------------------------------------
-// Environment
-// ---------------------------------------------------------------------------
-
-const testDir = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(testDir, "..");
-
-dotenv.config({ path: path.resolve(packageRoot, ".env") });
-
-const hasOpenAI = Boolean(process.env.OPENAI_API_KEY);
-const hasAnthropic = Boolean(process.env.ANTHROPIC_API_KEY);
-const hasGroq = Boolean(process.env.GROQ_API_KEY);
-const liveModelTestsEnabled = process.env.ELIZA_LIVE_TEST === "1";
-const hasModelProvider =
-  liveModelTestsEnabled && (hasOpenAI || hasAnthropic || hasGroq);
-
-// ---------------------------------------------------------------------------
-// Plugin loader
-// ---------------------------------------------------------------------------
-
-async function loadPlugin(name: string): Promise<Plugin | null> {
-  try {
-    if (!isPackageImportResolvable(name)) {
-      logger.warn(`[agent-orchestration-e2e] Plugin not resolvable: ${name}`);
-      return null;
-    }
-    const mod = (await import(name)) as PluginModuleShape;
-    return extractPlugin(mod);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`[agent-orchestration-e2e] Failed to load ${name}: ${msg}`);
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// HTTP helper
-// ---------------------------------------------------------------------------
-
-function http$(
-  port: number,
-  method: string,
-  p: string,
-  body?: Record<string, unknown>,
-  timeoutMs: number = 30_000,
-): Promise<{ status: number; data: Record<string, unknown> }> {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(
-      () => reject(new Error(`HTTP request timed out: ${method} ${p}`)),
-      timeoutMs,
-    );
-    const b = body ? JSON.stringify(body) : undefined;
-    const req = http.request(
-      {
-        hostname: "127.0.0.1",
-        port,
-        path: p,
-        method,
-        headers: {
-          "Content-Type": "application/json",
-          ...(b ? { "Content-Length": Buffer.byteLength(b) } : {}),
-        },
-      },
-      (res) => {
-        const ch: Buffer[] = [];
-        res.on("data", (c: Buffer) => ch.push(c));
-        res.on("end", () => {
-          clearTimeout(timer);
-          const raw = Buffer.concat(ch).toString("utf-8");
-          let data: Record<string, unknown> = {};
-          try {
-            data = JSON.parse(raw) as Record<string, unknown>;
-          } catch {
-            data = { _raw: raw };
-          }
-          resolve({ status: res.statusCode ?? 0, data });
-        });
-      },
-    );
-    req.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    if (b) req.write(b);
-    req.end();
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Types for orchestrator service
-// ---------------------------------------------------------------------------
-
-type TaskStatus =
-  | "pending"
-  | "running"
-  | "completed"
-  | "failed"
-  | "paused"
-  | "cancelled";
-
-interface OrchestratedTask {
-  id: string;
-  name: string;
-  description: string;
-  roomId?: UUID;
-  worldId?: UUID;
-  metadata: {
-    status: TaskStatus;
-    progress: number;
-    output: string[];
-    steps: Array<{
-      id: string;
-      description: string;
-      status: TaskStatus;
-      output?: string;
-    }>;
-    result?: {
-      success: boolean;
-      summary: string;
-      filesModified: string[];
-      filesCreated: string[];
-      error?: string;
-    };
-    error?: string;
-    createdAt: number;
-    startedAt?: number;
-    completedAt?: number;
-    providerId: string;
-    workingDirectory: string;
-  };
-}
-
-interface AgentOrchestratorService {
-  createTask(
-    name: string,
-    description: string,
-    roomId?: UUID,
-    providerId?: string,
-    requiredCapabilities?: string[],
-  ): Promise<OrchestratedTask>;
-  getTask(taskId: string): OrchestratedTask | undefined;
-  getTasks(): OrchestratedTask[];
-  getRecentTasks(limit?: number): OrchestratedTask[];
-  getTasksByStatus(status: TaskStatus): OrchestratedTask[];
-  updateTaskStatus(taskId: string, status: TaskStatus): boolean;
-  updateTaskProgress(taskId: string, progress: number): boolean;
-  appendOutput(taskId: string, output: string): boolean;
-  addStep(taskId: string, description: string): string | null;
-  updateStep(
-    taskId: string,
-    stepId: string,
-    status: TaskStatus,
-    output?: string,
-  ): boolean;
-  setTaskResult(
-    taskId: string,
-    result: OrchestratedTask["metadata"]["result"],
-  ): boolean;
-  cancelTask(taskId: string): boolean;
-  pauseTask(taskId: string): boolean;
-  resumeTask(taskId: string): boolean;
-  on(
-    eventType: string,
-    handler: (event: { type: string; taskId: string; data?: unknown }) => void,
-  ): () => void;
-}
-
-// ===================================================================
-//  1. ORCHESTRATOR PLUGIN LOADING
-// ===================================================================
-
-describe("Agent Orchestrator Plugin Loading", () => {
-  // Note: In e2e tests, the orchestrator plugin is stubbed via vitest.e2e.config.ts
-  // These tests verify the stub exports work correctly for API integration
-
-  it("orchestrator module can be imported", async () => {
-    // The module is stubbed in e2e tests, but should still be importable
-    const mod = await import("@elizaos/plugin-agent-orchestrator");
-    expect(mod).toBeDefined();
-  });
-
-  it("dist bundle exports codingAgentPlugin", () => {
-    // Verify the orchestrator plugin dist exists and exports the main plugin
-    const distPath = path.resolve(
-      packageRoot,
-      "node_modules/@elizaos/plugin-agent-orchestrator/dist/index.js",
-    );
-    expect(fs.existsSync(distPath)).toBe(true);
-    const dist = fs.readFileSync(distPath, "utf-8");
-    expect(
-      dist.includes("agentOrchestratorPlugin") ||
-        dist.includes("codingAgentPlugin"),
-    ).toBe(true);
-  });
-
-  it("installed version matches package.json spec", async () => {
-    // The 2.0.0-alpha versions were a historical artifact from the elizaOS
-    // monorepo.  The plugin was completely repurposed for agent orchestration
-    // and republished at 0.x under the `next` npm tag.  We verify a valid
-    // semver is installed rather than pinning a minimum major version.
-    const pkgPath = path.resolve(
-      packageRoot,
-      "node_modules/@elizaos/plugin-agent-orchestrator/package.json",
-    );
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
-      version: string;
-    };
-    expect(pkg.version).toMatch(/^\d+\.\d+\.\d+/);
-  });
-});
-
-// ===================================================================
-//  2. TASK LIFECYCLE TESTS (with API server)
-// ===================================================================
-
-describe("Task Lifecycle via API", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    // Start the agent to initialize plugins
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("GET /api/coding-agents/tasks returns task list", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks",
-    );
-    // Endpoint exists and returns valid response
-    expect([200, 404]).toContain(status);
-    if (status === 200) {
-      expect(Array.isArray(data.tasks) || data.tasks === undefined).toBe(true);
-    }
-  });
-
-  it("GET /api/coding-agents/status returns orchestrator status", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/status",
-    );
-    expect([200, 404]).toContain(status);
-    if (status === 200) {
-      expect(typeof data).toBe("object");
-    }
-  });
-
-  it("POST /api/coding-agents/tasks can create a task", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "E2E Test Task",
-        description: "A task created by the e2e test suite",
-      },
-    );
-    // May return 200/201 if successful, 404 if endpoint not found, or 400 for validation
-    expect([200, 201, 400, 404, 500]).toContain(status);
-    if (status === 200 || status === 201) {
-      expect(data.task || data.id || data.taskId).toBeDefined();
-    }
-  });
-
-  it("task status transitions: pending → running → completed", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Lifecycle Test Task",
-        description: "Test task for lifecycle verification",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      // Skip if task creation not available
-      logger.info(
-        "[agent-orchestration-e2e] Skipping lifecycle test - task creation returned " +
-          createRes.status,
-      );
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string) ||
-      (createRes.data.taskId as string);
-    expect(taskId).toBeDefined();
-
-    // Get initial status - should be pending
-    const getRes1 = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/tasks/${taskId}`,
-    );
-    if (getRes1.status === 200) {
-      const task = getRes1.data.task as OrchestratedTask | undefined;
-      if (task) {
-        expect(["pending", "running"]).toContain(task.metadata?.status);
-      }
-    }
-
-    // Update status to running
-    const updateRes = await http$(
-      server?.port,
-      "PATCH",
-      `/api/coding-agents/tasks/${taskId}`,
-      { status: "running" },
-    );
-    expect([200, 204, 404, 405]).toContain(updateRes.status);
-
-    // Cancel the task to clean up
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-  }, 30_000);
-});
-
-// ===================================================================
-//  3. TASK MANAGEMENT OPERATIONS
-// ===================================================================
-
-describe("Task Management Operations", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-  let _createdTaskId: string | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("can list all tasks", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks",
-    );
-    if (status === 200) {
-      expect(Array.isArray(data.tasks)).toBe(true);
-    }
-  });
-
-  it("can filter tasks by status", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks?status=pending",
-    );
-    if (status === 200 && Array.isArray(data.tasks)) {
-      for (const task of data.tasks as OrchestratedTask[]) {
-        expect(task.metadata?.status).toBe("pending");
-      }
-    }
-  });
-
-  it("can get recent tasks with limit", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks?limit=5",
-    );
-    if (status === 200 && Array.isArray(data.tasks)) {
-      expect(data.tasks.length).toBeLessThanOrEqual(5);
-    }
-  });
-
-  it("task cancellation works correctly", async () => {
-    // Create a task first
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Task to Cancel",
-        description: "This task will be cancelled",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return; // Skip if not available
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-    _createdTaskId = taskId;
-
-    // Cancel the task
-    const cancelRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-    expect([200, 204, 404, 405]).toContain(cancelRes.status);
-
-    // Verify cancelled status
-    if (cancelRes.status === 200 || cancelRes.status === 204) {
-      const getRes = await http$(
-        server?.port,
-        "GET",
-        `/api/coding-agents/tasks/${taskId}`,
-      );
-      if (getRes.status === 200) {
-        const task = getRes.data.task as OrchestratedTask | undefined;
-        if (task) {
-          expect(task.metadata?.status).toBe("cancelled");
-        }
-      }
-    }
-  });
-
-  it("task pause and resume works correctly", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Task to Pause",
-        description: "This task will be paused and resumed",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // First set to running
-    await http$(server?.port, "PATCH", `/api/coding-agents/tasks/${taskId}`, {
-      status: "running",
-    });
-
-    // Pause the task
-    const pauseRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/pause`,
-    );
-    expect([200, 204, 404, 405]).toContain(pauseRes.status);
-
-    // Resume the task
-    const resumeRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/resume`,
-    );
-    expect([200, 204, 404, 405]).toContain(resumeRes.status);
-
-    // Clean up
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-  });
-});
-
-// ===================================================================
-//  4. SUBAGENT SPAWNING TESTS
-// ===================================================================
-
-describe("Subagent Spawning", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("GET /api/coding-agents/providers returns available providers", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/providers",
-    );
-    expect([200, 404]).toContain(status);
-    if (status === 200) {
-      expect(
-        Array.isArray(data.providers) || data.providers === undefined,
-      ).toBe(true);
-    }
-  });
-
-  it("GET /api/coding-agents/sessions returns active sessions", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/sessions",
-    );
-    expect([200, 404]).toContain(status);
-    if (status === 200) {
-      expect(Array.isArray(data.sessions) || data.sessions === undefined).toBe(
-        true,
-      );
-    }
-  });
-
-  it("can spawn a subagent session", async () => {
-    const { status, data } = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "E2E test subagent spawn",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-    // May return various statuses depending on provider availability
-    expect([200, 201, 400, 404, 500, 503]).toContain(status);
-
-    if (status === 200 || status === 201) {
-      expect(data.roomId || data.sessionId || data.id).toBeDefined();
-
-      // Clean up the session if created
-      const sessionId = data.roomId || data.sessionId || data.id;
-      if (sessionId) {
-        await http$(
-          server?.port,
-          "DELETE",
-          `/api/coding-agents/sessions/${sessionId}`,
-        );
-      }
-    }
-  });
-
-  it("subagent status can be queried", async () => {
-    // First spawn a subagent
-    const spawnRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "Status check test",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-
-    if (spawnRes.status !== 200 && spawnRes.status !== 201) {
-      return; // Skip if spawning not available
-    }
-
-    const sessionId =
-      spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-
-    // Query status
-    const statusRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-    expect([200, 404]).toContain(statusRes.status);
-
-    // Clean up
-    await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-  });
-
-  it("subagent can be terminated", async () => {
-    // Spawn a subagent
-    const spawnRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "Termination test",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-
-    if (spawnRes.status !== 200 && spawnRes.status !== 201) {
-      return;
-    }
-
-    const sessionId =
-      spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-
-    // Terminate
-    const deleteRes = await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-    expect([200, 204, 404]).toContain(deleteRes.status);
-
-    // Verify it's gone
-    const verifyRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-    // Should be 404 or return ended status
-    expect([200, 404]).toContain(verifyRes.status);
-    if (verifyRes.status === 200) {
-      const session = verifyRes.data.session as { ended?: boolean } | undefined;
-      expect(session?.ended).toBe(true);
-    }
-  });
-});
-
-// ===================================================================
-//  5. MESSAGE PASSING TESTS
-// ===================================================================
-
-describe("Message Passing Between Agents", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("can send message to a session", async () => {
-    // First spawn a session
-    const spawnRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "Message test session",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-
-    if (spawnRes.status !== 200 && spawnRes.status !== 201) {
-      return;
-    }
-
-    const sessionId =
-      spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-
-    // Send a message
-    const msgRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/sessions/${sessionId}/messages`,
-      {
-        text: "Hello from e2e test",
-      },
-    );
-    expect([200, 201, 404, 405]).toContain(msgRes.status);
-
-    // Clean up
-    await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-  });
-
-  it("can receive messages from a session", async () => {
-    // Spawn a session
-    const spawnRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "Message receive test",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-
-    if (spawnRes.status !== 200 && spawnRes.status !== 201) {
-      return;
-    }
-
-    const sessionId =
-      spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-
-    // Get messages
-    const msgsRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/sessions/${sessionId}/messages`,
-    );
-    expect([200, 404, 405]).toContain(msgsRes.status);
-    if (msgsRes.status === 200) {
-      expect(
-        Array.isArray(msgsRes.data.messages) ||
-          msgsRes.data.messages === undefined,
-      ).toBe(true);
-    }
-
-    // Clean up
-    await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-  });
-
-  it("can peek at session output", async () => {
-    // Spawn a session
-    const spawnRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/sessions",
-      {
-        task: "Peek test session",
-        workingDirectory: os.tmpdir(),
-      },
-    );
-
-    if (spawnRes.status !== 200 && spawnRes.status !== 201) {
-      return;
-    }
-
-    const sessionId =
-      spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-
-    // Peek at output
-    const peekRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/sessions/${sessionId}/peek`,
-    );
-    expect([200, 404, 405]).toContain(peekRes.status);
-
-    // Clean up
-    await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${sessionId}`,
-    );
-  });
-});
-
-// ===================================================================
-//  6. CONCURRENT TASK HANDLING
-// ===================================================================
-
-describe("Concurrent Task Handling", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("can create multiple tasks concurrently", async () => {
-    const taskPromises = Array.from({ length: 5 }, (_, i) =>
-      http$(server?.port, "POST", "/api/coding-agents/tasks", {
-        name: `Concurrent Task ${i + 1}`,
-        description: `Task ${i + 1} for concurrent test`,
-      }),
-    );
-
-    const results = await Promise.allSettled(taskPromises);
-    const fulfilled = results.filter((r) => r.status === "fulfilled");
-
-    // All requests should complete (not deadlock)
-    expect(fulfilled.length).toBe(results.length);
-
-    // Count successful creations
-    const successCount = fulfilled.filter((r) => {
-      const result = r as PromiseFulfilledResult<{
-        status: number;
-        data: Record<string, unknown>;
-      }>;
-      return result.value.status === 200 || result.value.status === 201;
-    }).length;
-
-    logger.info(
-      `[agent-orchestration-e2e] Concurrent task creation: ${successCount}/${results.length} succeeded`,
-    );
-  });
-
-  it("task list remains consistent under concurrent access", async () => {
-    // Fire multiple list requests concurrently
-    const listPromises = Array.from({ length: 10 }, () =>
-      http$(server?.port, "GET", "/api/coding-agents/tasks"),
-    );
-
-    const results = await Promise.all(listPromises);
-
-    // All should return same count (no race conditions corrupting state)
-    const counts = results
-      .filter((r) => r.status === 200)
-      .map((r) => (r.data.tasks as unknown[])?.length ?? 0);
-
-    if (counts.length > 1) {
-      const unique = new Set(counts);
-      // Task count should be consistent across all reads
-      expect(unique.size).toBe(1);
-    }
-  });
-
-  it("concurrent status updates do not corrupt task state", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Concurrent Update Test",
-        description: "Task for concurrent update testing",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Fire concurrent progress updates
-    const updatePromises = Array.from({ length: 10 }, (_, i) =>
-      http$(server?.port, "PATCH", `/api/coding-agents/tasks/${taskId}`, {
-        progress: (i + 1) * 10,
-      }),
-    );
-
-    const results = await Promise.allSettled(updatePromises);
-    const fulfilled = results.filter((r) => r.status === "fulfilled");
-    expect(fulfilled.length).toBe(results.length);
-
-    // Verify task is not corrupted
-    const getRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/tasks/${taskId}`,
-    );
-    if (getRes.status === 200) {
-      const task = getRes.data.task as OrchestratedTask | undefined;
-      if (task) {
-        expect(typeof task.metadata?.progress).toBe("number");
-        expect(task.metadata?.progress).toBeGreaterThanOrEqual(0);
-        expect(task.metadata?.progress).toBeLessThanOrEqual(100);
-      }
-    }
-
-    // Clean up
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-  });
-});
-
-// ===================================================================
-//  7. ERROR HANDLING AND RECOVERY
-// ===================================================================
-
-describe("Error Handling and Recovery", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("handles invalid task ID gracefully", async () => {
-    const { status } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks/invalid-task-id-12345",
-    );
-    // Should return 404, not crash
-    expect([404, 400]).toContain(status);
-  });
-
-  it("handles invalid session ID gracefully", async () => {
-    const { status } = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/sessions/invalid-session-id-12345",
-    );
-    expect([404, 400]).toContain(status);
-  });
-
-  it("handles malformed task creation request", async () => {
-    const { status } = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        // Missing required fields
-        invalid: "data",
-      },
-    );
-    // Should return 400 Bad Request, not 500
-    expect([400, 404, 422]).toContain(status);
-  });
-
-  it("handles task operations on non-existent task", async () => {
-    const fakeTaskId = crypto.randomUUID();
-
-    // Try to cancel non-existent task
-    const cancelRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${fakeTaskId}/cancel`,
-    );
-    expect([404, 400, 405]).toContain(cancelRes.status);
-
-    // Try to pause non-existent task
-    const pauseRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${fakeTaskId}/pause`,
-    );
-    expect([404, 400, 405]).toContain(pauseRes.status);
-  });
-
-  it("handles session operations on non-existent session", async () => {
-    const fakeSessionId = crypto.randomUUID();
-
-    // Try to send message to non-existent session
-    const msgRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/sessions/${fakeSessionId}/messages`,
-      { text: "Hello" },
-    );
-    expect([404, 400, 405]).toContain(msgRes.status);
-
-    // Try to delete non-existent session
-    const deleteRes = await http$(
-      server?.port,
-      "DELETE",
-      `/api/coding-agents/sessions/${fakeSessionId}`,
-    );
-    expect([404, 400, 204]).toContain(deleteRes.status);
-  });
-
-  it("recovers from failed task without corrupting state", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Task That Will Fail",
-        description: "This task is designed to fail for testing",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Mark as failed
-    await http$(server?.port, "PATCH", `/api/coding-agents/tasks/${taskId}`, {
-      status: "failed",
-      error: "Intentional failure for e2e test",
-    });
-
-    // Verify task list is still accessible
-    const listRes = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks",
-    );
-    expect(listRes.status).toBe(200);
-
-    // Verify failed task is in the list
-    if (listRes.status === 200 && Array.isArray(listRes.data.tasks)) {
-      const failedTask = (listRes.data.tasks as OrchestratedTask[]).find(
-        (t) => t.id === taskId,
-      );
-      if (failedTask) {
-        expect(failedTask.metadata?.status).toBe("failed");
-      }
-    }
-  });
-});
-
-// ===================================================================
-//  8. TASK EVENT HANDLING
-// ===================================================================
-
-describe("Task Event System", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("task output can be appended and retrieved", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Output Test Task",
-        description: "Task for testing output append",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Append output
-    const appendRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/output`,
-      {
-        output: "Line 1 of output",
-      },
-    );
-    expect([200, 201, 404, 405]).toContain(appendRes.status);
-
-    // Append more output
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/output`,
-      {
-        output: "Line 2 of output",
-      },
-    );
-
-    // Get task and verify output
-    const getRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/tasks/${taskId}`,
-    );
-    if (getRes.status === 200) {
-      const task = getRes.data.task as OrchestratedTask | undefined;
-      if (task && Array.isArray(task.metadata?.output)) {
-        expect(task.metadata.output.length).toBeGreaterThanOrEqual(0);
-      }
-    }
-
-    // Clean up
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-  });
-
-  it("task steps can be added and updated", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Steps Test Task",
-        description: "Task for testing step management",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Add a step
-    const addStepRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/steps`,
-      {
-        description: "Step 1: Initialize",
-      },
-    );
-    expect([200, 201, 404, 405]).toContain(addStepRes.status);
-
-    const stepId =
-      (addStepRes.data.stepId as string) ||
-      (addStepRes.data.step as { id: string })?.id;
-
-    // Update step status
-    if (stepId) {
-      const updateStepRes = await http$(
-        server?.port,
-        "PATCH",
-        `/api/coding-agents/tasks/${taskId}/steps/${stepId}`,
-        {
-          status: "completed",
-          output: "Step completed successfully",
-        },
-      );
-      expect([200, 204, 404, 405]).toContain(updateStepRes.status);
-    }
-
-    // Clean up
-    await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/cancel`,
-    );
-  });
-
-  it("task result can be set", async () => {
-    // Create a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Result Test Task",
-        description: "Task for testing result setting",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Set result
-    const resultRes = await http$(
-      server?.port,
-      "POST",
-      `/api/coding-agents/tasks/${taskId}/result`,
-      {
-        success: true,
-        summary: "Task completed successfully in e2e test",
-        filesModified: ["test.ts"],
-        filesCreated: ["new-file.ts"],
-      },
-    );
-    expect([200, 201, 404, 405]).toContain(resultRes.status);
-
-    // Verify task is completed
-    const getRes = await http$(
-      server?.port,
-      "GET",
-      `/api/coding-agents/tasks/${taskId}`,
-    );
-    if (getRes.status === 200) {
-      const task = getRes.data.task as OrchestratedTask | undefined;
-      if (task?.metadata?.result) {
-        expect(task.metadata.result.success).toBe(true);
-      }
-    }
-  });
-});
-
-// ===================================================================
-//  9. CLEANUP AND RESOURCE MANAGEMENT
-// ===================================================================
-
-describe("Cleanup and Resource Management", () => {
-  let server: { port: number; close: () => Promise<void> } | null = null;
-
-  beforeAll(async () => {
-    server = await startApiServer({ port: 0 });
-    await http$(server.port, "POST", "/api/agent/start");
-  }, 60_000);
-
-  afterAll(async () => {
-    if (server) {
-      await http$(server.port, "POST", "/api/agent/stop");
-      await server.close();
-    }
-  });
-
-  it("completed tasks are properly tracked", async () => {
-    // Create and complete a task
-    const createRes = await http$(
-      server?.port,
-      "POST",
-      "/api/coding-agents/tasks",
-      {
-        name: "Completion Tracking Task",
-        description: "Task to verify completion tracking",
-      },
-    );
-
-    if (createRes.status !== 200 && createRes.status !== 201) {
-      return;
-    }
-
-    const taskId =
-      (createRes.data.task as { id: string })?.id ||
-      (createRes.data.id as string);
-
-    // Complete the task
-    await http$(server?.port, "PATCH", `/api/coding-agents/tasks/${taskId}`, {
-      status: "completed",
-    });
-
-    // Verify it's in completed tasks
-    const completedRes = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/tasks?status=completed",
-    );
-    if (completedRes.status === 200 && Array.isArray(completedRes.data.tasks)) {
-      const found = (completedRes.data.tasks as OrchestratedTask[]).find(
-        (t) => t.id === taskId,
-      );
-      expect(found).toBeDefined();
-    }
-  });
-
-  it("terminated sessions are cleaned up", async () => {
-    // Spawn multiple sessions
-    const spawnPromises = Array.from({ length: 3 }, (_, i) =>
-      http$(server?.port, "POST", "/api/coding-agents/sessions", {
-        task: `Cleanup test session ${i + 1}`,
-        workingDirectory: os.tmpdir(),
-      }),
-    );
-
-    const spawnResults = await Promise.allSettled(spawnPromises);
-    const sessionIds: string[] = [];
-
-    for (const result of spawnResults) {
-      if (result.status === "fulfilled") {
-        const { status, data } = result.value;
-        if (status === 200 || status === 201) {
-          const id = data.roomId || data.sessionId || data.id;
-          if (id) sessionIds.push(id as string);
-        }
-      }
-    }
-
-    // Terminate all sessions
-    await Promise.all(
-      sessionIds.map((id) =>
-        http$(server?.port, "DELETE", `/api/coding-agents/sessions/${id}`),
-      ),
-    );
-
-    // Verify sessions are cleaned up
-    const listRes = await http$(
-      server?.port,
-      "GET",
-      "/api/coding-agents/sessions",
-    );
-    if (listRes.status === 200 && Array.isArray(listRes.data.sessions)) {
-      const activeSessions = (
-        listRes.data.sessions as Array<{ id: string; ended?: boolean }>
-      ).filter((s) => sessionIds.includes(s.id) && !s.ended);
-      expect(activeSessions.length).toBe(0);
-    }
-  });
-
-  it("server remains healthy after multiple spawn/terminate cycles", async () => {
-    // Run 5 spawn/terminate cycles
-    for (let cycle = 0; cycle < 5; cycle++) {
-      const spawnRes = await http$(
-        server?.port,
-        "POST",
-        "/api/coding-agents/sessions",
-        {
-          task: `Cycle ${cycle + 1} session`,
-          workingDirectory: os.tmpdir(),
-        },
-      );
-
-      if (spawnRes.status === 200 || spawnRes.status === 201) {
-        const sessionId =
-          spawnRes.data.roomId || spawnRes.data.sessionId || spawnRes.data.id;
-        if (sessionId) {
-          await http$(
-            server?.port,
-            "DELETE",
-            `/api/coding-agents/sessions/${sessionId}`,
-          );
-        }
-      }
-    }
-
-    // Verify server is still healthy
-    const statusRes = await http$(server?.port, "GET", "/api/status");
-    expect(statusRes.status).toBe(200);
-    expect(statusRes.data.state).toBe("paused");
-  });
-});
-
-// ===================================================================
-//  10. INTEGRATION WITH RUNTIME (requires model provider)
-// ===================================================================
-
-describe.skipIf(!hasModelProvider)(
-  "Runtime Integration with Orchestrator",
-  () => {
-    let runtime: AgentRuntime | null = null;
-    let server: { port: number; close: () => Promise<void> } | null = null;
-
-    const pgliteDir = fs.mkdtempSync(
-      path.join(os.tmpdir(), "eliza-e2e-orchestrator-pglite-"),
-    );
-
-    beforeAll(async () => {
-      process.env.LOG_LEVEL = process.env.ELIZA_E2E_LOG_LEVEL ?? "error";
-      process.env.PGLITE_DATA_DIR = pgliteDir;
-
-      const secrets: Record<string, string> = {};
-      if (hasOpenAI) secrets.OPENAI_API_KEY = process.env.OPENAI_API_KEY!;
-      if (hasAnthropic)
-        secrets.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY!;
-      if (hasGroq) secrets.GROQ_API_KEY = process.env.GROQ_API_KEY!;
-
-      const character = createCharacter({
-        name: "OrchestratorTestAgent",
-        bio: "An E2E test agent for orchestration.",
-        secrets,
-      });
-
-      const plugins: Plugin[] = [];
-
-      // Load core plugins
-      const sqlPlugin = await loadPlugin("@elizaos/plugin-sql");
-      const embeddingPlugin = await loadPlugin(
-        "@elizaos/plugin-local-embedding",
-      );
-      const orchestratorPlugin = await loadPlugin(
-        "@elizaos/plugin-agent-orchestrator",
-      );
-
-      if (sqlPlugin) plugins.push(sqlPlugin);
-      if (embeddingPlugin) plugins.push(embeddingPlugin);
-      if (orchestratorPlugin) plugins.push(orchestratorPlugin);
-
-      // Load model provider
-      if (hasOpenAI) {
-        const p = await loadPlugin("@elizaos/plugin-openai");
-        if (p) plugins.push(p);
-      } else if (hasAnthropic) {
-        const p = await loadPlugin("@elizaos/plugin-anthropic");
-        if (p) plugins.push(p);
-      } else if (hasGroq) {
-        const p = await loadPlugin("@elizaos/plugin-groq");
-        if (p) plugins.push(p);
-      }
-
-      runtime = new AgentRuntime({
-        character,
-        plugins,
-        logLevel: "error",
-      });
-
-      await runtime.initialize();
-      server = await startApiServer({ port: 0, runtime });
-    }, 180_000);
-
-    afterAll(async () => {
-      if (server) {
-        try {
-          await server.close();
-        } catch {
-          /* ignore */
-        }
-      }
-      if (runtime) {
-        try {
-          await runtime.stop();
-        } catch {
-          /* ignore */
-        }
-      }
-      try {
-        fs.rmSync(pgliteDir, { recursive: true, force: true });
-      } catch {
-        /* ignore */
-      }
-    }, 30_000);
-
-    it("orchestrator service is available on runtime", () => {
-      const _service = runtime?.getService("CODE_TASK");
-      // Service may or may not be available depending on plugin configuration
-      // This test verifies no crash during service lookup
-      expect(true).toBe(true);
-    });
-
-    it("can create and track task through runtime", async () => {
-      const service = runtime?.getService(
-        "CODE_TASK",
-      ) as AgentOrchestratorService | null;
-      if (!service?.createTask) {
-        logger.info(
-          "[agent-orchestration-e2e] Skipping runtime task test - service not available",
-        );
-        return;
-      }
-
-      const task = await service.createTask(
-        "Runtime Integration Task",
-        "Created directly through runtime service",
-      );
-
-      expect(task).toBeDefined();
-      expect(task.id).toBeDefined();
-      expect(task.name).toBe("Runtime Integration Task");
-      expect(task.metadata?.status).toBe("pending");
-
-      // Clean up
-      service.cancelTask(task.id);
-    });
-
-    it("task events are emitted correctly", async () => {
-      const service = runtime?.getService(
-        "CODE_TASK",
-      ) as AgentOrchestratorService | null;
-      if (!service?.createTask || !service?.on) {
-        return;
-      }
-
-      const events: Array<{ type: string; taskId: string }> = [];
-      const unsubscribe = service.on("task:created", (event) => {
-        events.push(event);
-      });
-
-      const task = await service.createTask(
-        "Event Test Task",
-        "Task for event testing",
-      );
-
-      // Give event a moment to propagate
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(events.length).toBeGreaterThanOrEqual(0);
-
-      // Clean up
-      unsubscribe();
-      service.cancelTask(task.id);
-    });
-
-    it("API endpoints reflect runtime task state", async () => {
-      const service = runtime?.getService(
-        "CODE_TASK",
-      ) as AgentOrchestratorService | null;
-      if (!service?.createTask) {
-        return;
-      }
-
-      // Create task via service
-      const task = await service.createTask(
-        "API Reflection Task",
-        "Task created via service",
-      );
-
-      // Verify via API
-      const { status, data } = await http$(
-        server?.port,
-        "GET",
-        `/api/coding-agents/tasks/${task.id}`,
-      );
-
-      if (status === 200) {
-        const apiTask = data.task as OrchestratedTask | undefined;
-        expect(apiTask?.id).toBe(task.id);
-        expect(apiTask?.name).toBe(task.name);
-      }
-
-      // Clean up
-      service.cancelTask(task.id);
-    });
-  },
-);