macro-agent 0.1.1 → 0.1.3

package/src/teams/__tests__/team-system.test.ts

@@ -1,1280 +0,0 @@
-/**
- * Team System Tests
- *
- * Tests loading team templates, runtime initialization, bootstrap,
- * and integration between team subsystems (roles, communication,
- * strategies, task modes).
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import * as path from "path";
-import { loadTeam } from "../team-loader.js";
-import { TeamRuntime, type TeamServices } from "../team-runtime.js";
-import { DefaultRoleRegistry } from "../../roles/registry.js";
-import type { RoleDefinition } from "../../roles/types.js";
-import type { AgentManager, SpawnInterceptor } from "../../agent/agent-manager.js";
-import type { MessageRouter } from "../../router/message-router.js";
-import type { EventStore } from "../../store/event-store.js";
-import type { SpawnAgentOptions } from "../../agent/types.js";
-import type { AgentId, Event } from "../../store/types/index.js";
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-const PROJECT_ROOT = path.resolve(import.meta.dirname, "../../..");
-
-function createMockEventStore(): EventStore {
-  const events: Event[] = [];
-  return {
-    emit: vi.fn((input: Record<string, unknown>) => {
-      const event = {
-        id: `evt_${events.length}`,
-        type: input.type,
-        timestamp: Date.now(),
-        source: input.source,
-        target: input.target,
-        payload: input.payload,
-      } as unknown as Event;
-      events.push(event);
-      return event;
-    }),
-    persist: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-    query: vi.fn().mockReturnValue([]),
-    getAgent: vi.fn().mockReturnValue(null),
-    getTask: vi.fn().mockReturnValue(null),
-    listAgents: vi.fn().mockReturnValue([]),
-    onAgentChange: vi.fn(),
-    onTaskChange: vi.fn(),
-    instanceId: "test-instance",
-    _events: events,
-  } as unknown as EventStore & { _events: Event[] };
-}
-
-function createMockMessageRouter(): MessageRouter {
-  return {
-    sendToAddress: vi.fn().mockResolvedValue({ delivered: true }),
-    emitStatus: vi.fn(),
-    getMessages: vi.fn().mockReturnValue([]),
-    subscribe: vi.fn(),
-    unsubscribe: vi.fn(),
-    getSubscriptions: vi.fn().mockReturnValue([]),
-    setupDefaultSubscriptions: vi.fn(),
-    setSignalFilter: vi.fn(),
-    setEmissionValidator: vi.fn(),
-  } as unknown as MessageRouter;
-}
-
-let spawnCounter = 0;
-let capturedInterceptor: SpawnInterceptor | null = null;
-let interceptedSpawnOptions: SpawnAgentOptions[] = [];
-
-function createMockAgentManager(roleRegistry: DefaultRoleRegistry): AgentManager {
-  capturedInterceptor = null;
-  spawnCounter = 0;
-  interceptedSpawnOptions = [];
-
-  return {
-    spawn: vi.fn(async (options: SpawnAgentOptions) => {
-      // Apply interceptor if set and record the intercepted options
-      const opts = capturedInterceptor ? capturedInterceptor(options) : options;
-      interceptedSpawnOptions.push(opts);
-      const id = `agent_${spawnCounter++}`;
-      return {
-        id,
-        session_id: `session_${id}`,
-        task: opts.task ?? "test",
-        state: "running" as const,
-        created_at: Date.now(),
-        parent: opts.parent ?? null,
-        role: opts.role,
-        config: opts.config,
-        _spawnOptions: opts,
-      };
-    }),
-    terminate: vi.fn().mockResolvedValue(undefined),
-    get: vi.fn().mockReturnValue(null),
-    list: vi.fn().mockReturnValue([]),
-    getChildren: vi.fn().mockReturnValue([]),
-    getHierarchy: vi.fn().mockReturnValue(null),
-    getSession: vi.fn().mockReturnValue(null),
-    hasActiveSession: vi.fn().mockReturnValue(false),
-    setSpawnInterceptor: vi.fn((interceptor: SpawnInterceptor | null) => {
-      capturedInterceptor = interceptor;
-    }),
-    getRoleRegistry: vi.fn(() => roleRegistry),
-    onLifecycleEvent: vi.fn(() => vi.fn()),
-    continueAgent: vi.fn().mockResolvedValue({ id: "continued_0" }),
-    close: vi.fn().mockResolvedValue(undefined),
-    getOrCreateHeadManager: vi.fn(),
-    prompt: vi.fn(),
-    isPrompting: vi.fn().mockReturnValue(false),
-  } as unknown as AgentManager;
-}
-
-// =============================================================================
-// Tests: Team Loading
-// =============================================================================
-
-describe("Team Template Loading", () => {
-  let roleRegistry: DefaultRoleRegistry;
-
-  beforeEach(() => {
-    roleRegistry = new DefaultRoleRegistry();
-  });
-
-  it("loads self-driving team template", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    expect(manifest.name).toBe("self-driving");
-    expect(manifest.version).toBe(1);
-    expect(manifest.roles).toEqual(["planner", "grinder", "judge"]);
-  });
-
-  it("resolves self-driving roles with correct base roles", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    const planner = manifest._resolvedRoles.get("planner");
-    expect(planner).toBeDefined();
-    expect(planner!.baseRole).toBe("coordinator");
-
-    const grinder = manifest._resolvedRoles.get("grinder");
-    expect(grinder).toBeDefined();
-    expect(grinder!.baseRole).toBe("worker");
-
-    const judge = manifest._resolvedRoles.get("judge");
-    expect(judge).toBeDefined();
-    expect(judge!.baseRole).toBe("monitor");
-  });
-
-  it("resolves capability additions and removals", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    const planner = manifest._resolvedRoles.get("planner");
-    expect(planner!.capabilities).toContain("task.claim");
-    expect(planner!.capabilities).not.toContain("agent.spawn.integrator");
-    expect(planner!.capabilities).not.toContain("agent.spawn.monitor");
-
-    const grinder = manifest._resolvedRoles.get("grinder");
-    expect(grinder!.capabilities).toContain("task.claim");
-    expect(grinder!.capabilities).toContain("git.push");
-  });
-
-  it("translates spawn_rules into capabilities", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    const planner = manifest._resolvedRoles.get("planner");
-    expect(planner!.capabilities).toContain("agent.spawn.grinder");
-    expect(planner!.capabilities).toContain("agent.spawn.planner");
-
-    // Judge and grinder have no spawn rules → no spawn capabilities
-    const judge = manifest._resolvedRoles.get("judge");
-    expect(judge!.capabilities.filter((c) => c.startsWith("agent.spawn."))).toEqual([]);
-  });
-
-  it("loads prompt files", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    expect(manifest._loadedPrompts.has("prompts/planner.md")).toBe(true);
-    expect(manifest._loadedPrompts.has("prompts/grinder.md")).toBe(true);
-    expect(manifest._loadedPrompts.has("prompts/judge.md")).toBe(true);
-
-    const plannerPrompt = manifest._loadedPrompts.get("prompts/planner.md")!;
-    expect(plannerPrompt).toContain("Planner");
-  });
-
-  it("parses macro_agent extensions", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    expect(manifest.macro_agent.task_assignment?.mode).toBe("pull");
-    expect(manifest.macro_agent.integration?.strategy).toBe("trunk");
-    expect(manifest.macro_agent.lifecycle?.continuations?.enabled).toBe(true);
-    expect(manifest.macro_agent.lifecycle?.scaling?.max_workers).toBe(20);
-  });
-
-  it("validates communication topology", async () => {
-    const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-    expect(manifest.communication.channels).toBeDefined();
-    expect(Object.keys(manifest.communication.channels!)).toContain("task_updates");
-    expect(Object.keys(manifest.communication.channels!)).toContain("work_coordination");
-    expect(Object.keys(manifest.communication.channels!)).toContain("health");
-
-    expect(manifest.communication.subscriptions?.planner).toBeDefined();
-    expect(manifest.communication.emissions?.planner).toContain("TASK_CREATED");
-  });
-
-  it("loads structured team template", async () => {
-    const manifest = await loadTeam("structured", roleRegistry, PROJECT_ROOT);
-
-    expect(manifest.name).toBe("structured");
-    expect(manifest.roles).toEqual(["lead", "developer", "reviewer"]);
-    expect(manifest.macro_agent.task_assignment?.mode).toBe("push");
-    expect(manifest.macro_agent.integration?.strategy).toBe("queue");
-  });
-
-  it("resolves structured roles", async () => {
-    const manifest = await loadTeam("structured", roleRegistry, PROJECT_ROOT);
-
-    const lead = manifest._resolvedRoles.get("lead");
-    expect(lead!.baseRole).toBe("coordinator");
-
-    const developer = manifest._resolvedRoles.get("developer");
-    expect(developer!.baseRole).toBe("worker");
-
-    const reviewer = manifest._resolvedRoles.get("reviewer");
-    expect(reviewer!.baseRole).toBe("monitor");
-    expect(reviewer!.capabilities).toContain("exec.build");
-    expect(reviewer!.capabilities).toContain("exec.test");
-  });
-});
-
-// =============================================================================
-// Tests: TeamRuntime
-// =============================================================================
-
-describe("TeamRuntime", () => {
-  let roleRegistry: DefaultRoleRegistry;
-  let agentManager: AgentManager;
-  let messageRouter: MessageRouter;
-  let eventStore: EventStore & { _events: Event[] };
-  let services: TeamServices;
-
-  beforeEach(() => {
-    roleRegistry = new DefaultRoleRegistry();
-    eventStore = createMockEventStore() as EventStore & { _events: Event[] };
-    messageRouter = createMockMessageRouter();
-    agentManager = createMockAgentManager(roleRegistry);
-    services = { agentManager, messageRouter, eventStore };
-  });
-
-  describe("initialize()", () => {
-    it("registers team roles in the role registry", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-
-      // Roles should be registered in the registry
-      expect(roleRegistry.getRole("planner")).toBeDefined();
-      expect(roleRegistry.getRole("grinder")).toBeDefined();
-      expect(roleRegistry.getRole("judge")).toBeDefined();
-    });
-
-    it("emits team_config event to EventStore", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-
-      expect(eventStore.emit).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: "status",
-          payload: expect.objectContaining({
-            status_type: "discovery",
-            team_config: expect.objectContaining({
-              teamName: "self-driving",
-              strategy: "trunk",
-              taskMode: "pull",
-            }),
-          }),
-        })
-      );
-    });
-
-    it("sets spawn interceptor on agent manager", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-
-      expect(agentManager.setSpawnInterceptor).toHaveBeenCalledWith(
-        expect.any(Function)
-      );
-    });
-  });
-
-  describe("bootstrap()", () => {
-    it("spawns root and companion agents", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      expect(result.rootId).toBeDefined();
-      expect(result.companionIds).toHaveLength(1); // judge is the companion
-
-      // Two spawn calls: planner (root) + judge (companion)
-      expect(agentManager.spawn).toHaveBeenCalledTimes(2);
-    });
-
-    it("spawns root with correct role and model", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const spawnCalls = vi.mocked(agentManager.spawn).mock.calls;
-      const rootCall = spawnCalls[0][0];
-
-      expect(rootCall.role).toBe("planner");
-      expect(rootCall.config?.model).toBe("sonnet");
-      expect(rootCall.parent).toBeNull();
-    });
-
-    it("spawns companion as peer (not child)", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const spawnCalls = vi.mocked(agentManager.spawn).mock.calls;
-      const companionCall = spawnCalls[1][0];
-
-      expect(companionCall.role).toBe("judge");
-      expect(companionCall.config?.model).toBe("haiku");
-      expect(companionCall.parent).toBeNull();
-    });
-
-    it("wires config-driven peer subscriptions from routing.peers", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // self-driving has 2 peer entries: judge→planner + planner→judge, both via: "direct"
-      // Each creates one directional subtree subscription
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(2);
-
-      // judge (agent_1) subscribes to planner's (agent_0) subtree
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.companionIds[0], // judge = agent_1
-        { type: "subtree", target: result.rootId } // planner = agent_0
-      );
-
-      // planner (agent_0) subscribes to judge's (agent_1) subtree
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.rootId, // planner = agent_0
-        { type: "subtree", target: result.companionIds[0] } // judge = agent_1
-      );
-    });
-
-    it("injects interaction patterns for pull mode", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const spawnCalls = vi.mocked(agentManager.spawn).mock.calls;
-      const rootCall = spawnCalls[0][0];
-
-      expect(rootCall.interactionPatterns).toBeDefined();
-      expect(rootCall.interactionPatterns!.length).toBeGreaterThan(0);
-      expect(rootCall.interactionPatterns!.some((p) => p.includes("PULL mode"))).toBe(true);
-      expect(rootCall.interactionPatterns!.some((p) => p.includes("trunk"))).toBe(true);
-    });
-
-    it("provides team prompts to spawned agents", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const spawnCalls = vi.mocked(agentManager.spawn).mock.calls;
-      const rootCall = spawnCalls[0][0];
-
-      expect(rootCall.customPrompt).toBeDefined();
-      expect(rootCall.customPrompt).toContain("Planner");
-    });
-  });
-
-  describe("spawn interceptor", () => {
-    it("injects team topics into spawned agent options", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      // Now spawn a grinder through the interceptor
-      await agentManager.spawn({
-        task: "test grinder task",
-        role: "grinder",
-        parent: "agent_0",
-      });
-
-      // Check the intercepted options (not the original args)
-      const lastOpts = interceptedSpawnOptions.at(-1)!;
-      // Interceptor should have added topics for grinder subscriptions
-      expect(lastOpts.topics).toBeDefined();
-      expect(lastOpts.topics).toContain("work_coordination");
-    });
-
-    it("injects team environment variables", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      // Spawn a grinder
-      await agentManager.spawn({
-        task: "test task",
-        role: "grinder",
-        parent: "agent_0",
-      });
-
-      const lastOpts = interceptedSpawnOptions.at(-1)!;
-      expect(lastOpts.config?.env?.MACRO_TEAM_NAME).toBe("self-driving");
-      expect(lastOpts.config?.env?.MACRO_TASK_MODE).toBe("pull");
-      expect(lastOpts.config?.env?.MACRO_INTEGRATION_STRATEGY).toBe("trunk");
-    });
-
-    it("does not override caller-provided options", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const customPrompt = "My custom prompt";
-      await agentManager.spawn({
-        task: "test task",
-        role: "grinder",
-        parent: "agent_0",
-        customPrompt,
-      });
-
-      const lastOpts = interceptedSpawnOptions.at(-1)!;
-      expect(lastOpts.customPrompt).toBe(customPrompt);
-    });
-  });
-
-  describe("getters", () => {
-    it("returns task mode and strategy", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      expect(runtime.getTaskMode()).toBe("pull");
-      expect(runtime.getStrategyName()).toBe("trunk");
-    });
-
-    it("returns agent IDs after bootstrap", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      expect(runtime.getRootAgentId()).toBe(result.rootId);
-      expect(runtime.getCompanionAgentIds()).toEqual(result.companionIds);
-    });
-  });
-
-  describe("teardown()", () => {
-    it("clears spawn interceptor", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-      await runtime.teardown();
-
-      expect(agentManager.setSpawnInterceptor).toHaveBeenLastCalledWith(null);
-    });
-  });
-
-  describe("peer routing", () => {
-    it("stores signal filters from peer connections", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filters = runtime.getPeerSignalFilters();
-
-      // judge→planner has signals: [FIXUP_CREATED, GREEN_SNAPSHOT]
-      const judgeToPlanner = filters.get(`${result.companionIds[0]}→${result.rootId}`);
-      expect(judgeToPlanner).toEqual(["FIXUP_CREATED", "GREEN_SNAPSHOT"]);
-
-      // planner→judge has signals: [CONVERGENCE_CHECK]
-      const plannerToJudge = filters.get(`${result.rootId}→${result.companionIds[0]}`);
-      expect(plannerToJudge).toEqual(["CONVERGENCE_CHECK"]);
-    });
-
-    it("falls back to legacy subtree subscriptions when no peers config", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-      // Remove routing.peers to test fallback
-      manifest.communication.routing = { status: "upstream" };
-
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Legacy: 2 bidirectional subtree subs (root→companion + companion→root)
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(2);
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.rootId,
-        { type: "subtree", target: result.companionIds[0] }
-      );
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.companionIds[0],
-        { type: "subtree", target: result.rootId }
-      );
-    });
-
-    it("defers wiring for roles not spawned at bootstrap", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-      // Add a peer connection involving grinder (not spawned at bootstrap)
-      manifest.communication.routing!.peers!.push({
-        from: "grinder",
-        to: "planner",
-        via: "direct",
-        signals: ["WORKER_DONE"],
-      });
-
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // 2 wired at bootstrap (judge↔planner) + 1 deferred (grinder→planner)
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(2);
-
-      // onLifecycleEvent should have been called twice: once for deferred wiring, once for continuations
-      expect(agentManager.onLifecycleEvent).toHaveBeenCalledTimes(2);
-
-      // Simulate grinder spawn via lifecycle event
-      const lifecycleCallbacks = vi.mocked(agentManager.onLifecycleEvent).mock.calls;
-      // The deferred wiring callback is the first one registered (wirePeerRoutes before monitorContinuations)
-      const deferredCallback = lifecycleCallbacks[0][0];
-
-      deferredCallback({
-        type: "spawned",
-        agent: { id: "grinder_agent", role: "grinder", state: "running" },
-      } as any);
-
-      // Now the deferred route should be wired
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(3);
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        "grinder_agent",
-        { type: "subtree", target: result.rootId }
-      );
-
-      // Signal filter should be stored
-      const filters = runtime.getPeerSignalFilters();
-      expect(filters.get(`grinder_agent→${result.rootId}`)).toEqual(["WORKER_DONE"]);
-    });
-
-    it("serializes peerRoutes in team_config event", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-
-      expect(eventStore.emit).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: "status",
-          payload: expect.objectContaining({
-            team_config: expect.objectContaining({
-              peerRoutes: expect.arrayContaining([
-                expect.objectContaining({
-                  from: "judge",
-                  to: "planner",
-                  via: "direct",
-                  signals: ["FIXUP_CREATED", "GREEN_SNAPSHOT"],
-                }),
-              ]),
-            }),
-          }),
-        })
-      );
-    });
-
-    it("teardown cleans up deferred wiring listener", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-      // Add a deferred route to ensure the wiring listener is set up
-      manifest.communication.routing!.peers!.push({
-        from: "grinder",
-        to: "judge",
-        via: "direct",
-      });
-
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      // onLifecycleEvent called twice: deferred wiring + continuations
-      expect(agentManager.onLifecycleEvent).toHaveBeenCalledTimes(2);
-
-      // Both return unsubscribe fns (index 0 = deferred wiring, index 1 = continuations)
-      const peerWiringUnsub = vi.mocked(agentManager.onLifecycleEvent).mock.results[0].value;
-      const continuationsUnsub = vi.mocked(agentManager.onLifecycleEvent).mock.results[1].value;
-
-      await runtime.teardown();
-
-      // Both unsubscribe fns should be called
-      expect(peerWiringUnsub).toHaveBeenCalled();
-      expect(continuationsUnsub).toHaveBeenCalled();
-    });
-
-    it("via topic creates shared topic subscription", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-      // Replace peers with a topic-based connection
-      manifest.communication.routing!.peers = [
-        { from: "planner", to: "judge", via: "topic" },
-      ];
-
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Topic creates 2 subscriptions: both agents to the same topic
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(2);
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.rootId, // planner
-        { type: "topic", target: "peer:planner:judge" }
-      );
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.companionIds[0], // judge
-        { type: "topic", target: "peer:planner:judge" }
-      );
-    });
-
-    it("via scope creates role subscription", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-
-      // Replace peers with a scope-based connection
-      manifest.communication.routing!.peers = [
-        { from: "planner", to: "judge", via: "scope" },
-      ];
-
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Scope creates 1 subscription: from subscribes to to's role channel
-      expect(messageRouter.subscribe).toHaveBeenCalledTimes(1);
-      expect(messageRouter.subscribe).toHaveBeenCalledWith(
-        result.rootId, // planner
-        { type: "role", target: "judge" }
-      );
-    });
-  });
-
-  describe("signal filtering", () => {
-    it("installs signal filter on message router after bootstrap", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      expect(messageRouter.setSignalFilter).toHaveBeenCalledTimes(1);
-      expect(messageRouter.setSignalFilter).toHaveBeenCalledWith(expect.any(Function));
-    });
-
-    it("peer connection filter allows matching signals", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Extract the installed filter
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      const judgeId = result.companionIds[0]; // judge
-      const plannerId = result.rootId; // planner
-
-      // judge→planner peer has signals: [FIXUP_CREATED, GREEN_SNAPSHOT]
-      expect(filterFn(judgeId, plannerId, "FIXUP_CREATED")).toBe(true);
-      expect(filterFn(judgeId, plannerId, "GREEN_SNAPSHOT")).toBe(true);
-    });
-
-    it("peer connection filter blocks non-matching signals", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      const judgeId = result.companionIds[0];
-      const plannerId = result.rootId;
-
-      // judge→planner peer does NOT include WORKER_DONE
-      expect(filterFn(judgeId, plannerId, "WORKER_DONE")).toBe(false);
-    });
-
-    it("untagged status events always pass through", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      const judgeId = result.companionIds[0];
-      const plannerId = result.rootId;
-
-      // No signal (undefined) should always pass
-      expect(filterFn(judgeId, plannerId, undefined)).toBe(true);
-    });
-
-    it("channel subscription filter allows role's configured signals", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      // Use a "grinder" agent as recipient - grinder only allows WORK_ASSIGNED
-      // Simulate spawning a grinder by triggering deferred wiring
-      // But grinder has no peer connection, so we test channel sub filter directly
-      // by spawning through the lifecycle event to populate agentRoleMap
-
-      // Add a grinder peer route so deferred wiring populates agentRoleMap
-      manifest.communication.routing!.peers!.push({
-        from: "grinder",
-        to: "planner",
-        via: "direct",
-      });
-
-      // Re-bootstrap with updated manifest
-      const runtime2 = new TeamRuntime(manifest, services);
-      await runtime2.initialize();
-      const result2 = await runtime2.bootstrap();
-
-      // Simulate grinder spawn via lifecycle event
-      const deferredCallback = vi.mocked(agentManager.onLifecycleEvent).mock.calls.at(-2)![0];
-      deferredCallback({
-        type: "spawned",
-        agent: { id: "grinder_1", role: "grinder", state: "running" },
-      } as any);
-
-      // Get the latest filter (from runtime2's installSignalFilter)
-      const filterFn2 = vi.mocked(messageRouter.setSignalFilter).mock.calls.at(-1)![0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      // grinder allows WORK_ASSIGNED from channel subs
-      // But grinder→planner is a peer route (no signal filter), so test from a non-peer source
-      // From planner to grinder_1 (no peer filter exists for this direction)
-      expect(filterFn2(result2.rootId, "grinder_1", "WORK_ASSIGNED")).toBe(true);
-      expect(filterFn2(result2.rootId, "grinder_1", "WORKER_DONE")).toBe(false);
-    });
-
-    it("roles with any unfiltered subscription receive all signals", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      // planner has task_updates subscription with no signals filter → receives all
-      // But planner's peer connections have explicit filters, so test from a non-peer agent
-      // From an unknown agent to planner — falls through to channel sub filter
-      expect(filterFn("unknown_agent", result.rootId, "ANY_SIGNAL")).toBe(true);
-      expect(filterFn("unknown_agent", result.rootId, "RANDOM")).toBe(true);
-    });
-
-    it("peer filter takes precedence over channel subscription filter", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const filterFn = vi.mocked(messageRouter.setSignalFilter).mock.calls[0][0] as (
-        from: string, to: string, signal: string | undefined
-      ) => boolean;
-
-      const judgeId = result.companionIds[0];
-      const plannerId = result.rootId;
-
-      // judge→planner peer only allows FIXUP_CREATED, GREEN_SNAPSHOT
-      // Even though planner's channel subs allow "all" (via unfiltered task_updates),
-      // the peer filter takes precedence
-      expect(filterFn(judgeId, plannerId, "TASK_CREATED")).toBe(false);
-    });
-  });
-
-  describe("emission validation", () => {
-    it("installs emission validator on message router after bootstrap", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      expect(messageRouter.setEmissionValidator).toHaveBeenCalledTimes(1);
-      expect(messageRouter.setEmissionValidator).toHaveBeenCalledWith(expect.any(Function));
-    });
-
-    it("allows emissions in role's allowed list", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      const plannerId = result.rootId;
-
-      // planner's emissions: [TASK_CREATED, WORK_ASSIGNED]
-      expect(validatorFn(plannerId, "TASK_CREATED").action).toBe("allow");
-      expect(validatorFn(plannerId, "WORK_ASSIGNED").action).toBe("allow");
-    });
-
-    it("rejects disallowed emissions in strict mode", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.enforcement = "strict";
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      const plannerId = result.rootId;
-
-      // WORKER_DONE is not in planner's allowed emissions
-      const res = validatorFn(plannerId, "WORKER_DONE");
-      expect(res.action).toBe("reject");
-      expect(res.message).toContain("WORKER_DONE");
-      expect(res.message).toContain("planner");
-    });
-
-    it("warns on disallowed emissions in permissive mode", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.enforcement = "permissive";
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      const plannerId = result.rootId;
-
-      const res = validatorFn(plannerId, "HEALTH_CHECK");
-      expect(res.action).toBe("warn");
-      expect(res.message).toContain("HEALTH_CHECK");
-    });
-
-    it("audits disallowed emissions in audit mode", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.enforcement = "audit";
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      const plannerId = result.rootId;
-
-      const res = validatorFn(plannerId, "FORBIDDEN");
-      expect(res.action).toBe("audit");
-      expect(res.message).toContain("FORBIDDEN");
-    });
-
-    it("allows untagged emissions for any role", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.enforcement = "strict";
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      // Undefined signal always passes even in strict mode
-      expect(validatorFn(result.rootId, undefined).action).toBe("allow");
-      expect(validatorFn(result.companionIds[0], undefined).action).toBe("allow");
-    });
-
-    it("allows emissions from agents with no role mapping", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.enforcement = "strict";
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const validatorFn = vi.mocked(messageRouter.setEmissionValidator).mock.calls[0][0] as (
-        agentId: string, signal: string | undefined
-      ) => { action: string; message?: string };
-
-      // Unknown agent — no role mapping, so allowed
-      expect(validatorFn("unknown_agent", "ANYTHING").action).toBe("allow");
-    });
-
-    it("does not install validator when no emissions config", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      manifest.communication.emissions = undefined;
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      expect(messageRouter.setEmissionValidator).not.toHaveBeenCalled();
-    });
-
-    it("serializes emissions in team_config event", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-
-      expect(eventStore.emit).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: "status",
-          payload: expect.objectContaining({
-            team_config: expect.objectContaining({
-              emissions: expect.objectContaining({
-                planner: ["TASK_CREATED", "WORK_ASSIGNED"],
-                judge: ["HEALTH_CHECK", "GREEN_SNAPSHOT", "FIXUP_CREATED"],
-                grinder: ["WORKER_DONE"],
-              }),
-            }),
-          }),
-        })
-      );
-    });
-  });
-
-  describe("monitorContinuations()", () => {
-    it("auto-continues root agent on unexpected stop", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Capture the lifecycle callback registered during bootstrap
-      const onLifecycleEventMock = vi.mocked(agentManager.onLifecycleEvent);
-      expect(onLifecycleEventMock).toHaveBeenCalled();
-      const lifecycleCallback = onLifecycleEventMock.mock.calls[0][0];
-
-      // Simulate unexpected stop of root agent (no reason = unexpected)
-      lifecycleCallback({
-        type: "stopped",
-        agent: { id: result.rootId, role: "planner", state: "stopped" },
-      } as any);
-
-      // Wait for the setTimeout (1s) + async continuation
-      await vi.waitFor(
-        () => {
-          expect(agentManager.continueAgent).toHaveBeenCalledWith(result.rootId);
-        },
-        { timeout: 3000 }
-      );
-
-      // Root agent ID should be updated to the continued agent
-      expect(runtime.getRootAgentId()).toBe("continued_0");
-    });
-
-    it("auto-continues companion agent on unexpected stop", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-      const companionId = result.companionIds[0];
-
-      const lifecycleCallback = vi.mocked(agentManager.onLifecycleEvent).mock.calls[0][0];
-
-      // Simulate unexpected stop of companion
-      lifecycleCallback({
-        type: "stopped",
-        agent: { id: companionId, role: "judge", state: "stopped" },
-      } as any);
-
-      await vi.waitFor(
-        () => {
-          expect(agentManager.continueAgent).toHaveBeenCalledWith(companionId);
-        },
-        { timeout: 3000 }
-      );
-
-      // Companion ID should be updated
-      expect(runtime.getCompanionAgentIds()).toContain("continued_0");
-    });
-
-    it("does NOT auto-continue on completed stop", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const lifecycleCallback = vi.mocked(agentManager.onLifecycleEvent).mock.calls[0][0];
-
-      // Simulate completed stop (should NOT trigger continuation)
-      lifecycleCallback({
-        type: "stopped",
-        agent: { id: result.rootId, role: "planner", state: "stopped" },
-        reason: "completed",
-      } as any);
-
-      // Wait a bit to ensure no continuation is triggered
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-      expect(agentManager.continueAgent).not.toHaveBeenCalled();
-    });
-
-    it("does NOT auto-continue on cancelled stop", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      const lifecycleCallback = vi.mocked(agentManager.onLifecycleEvent).mock.calls[0][0];
-
-      lifecycleCallback({
-        type: "stopped",
-        agent: { id: result.rootId, role: "planner", state: "stopped" },
-        reason: "cancelled",
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-      expect(agentManager.continueAgent).not.toHaveBeenCalled();
-    });
-
-    it("does NOT trigger for non-monitored agents", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      const lifecycleCallback = vi.mocked(agentManager.onLifecycleEvent).mock.calls[0][0];
-
-      // Simulate stop of an unrelated agent
-      lifecycleCallback({
-        type: "stopped",
-        agent: { id: "unrelated_agent", role: "worker", state: "stopped" },
-      } as any);
-
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-      expect(agentManager.continueAgent).not.toHaveBeenCalled();
-    });
-
-    it("unsubscribes lifecycle listener on teardown", async () => {
-      const manifest = await loadTeam("self-driving", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      await runtime.initialize();
-      await runtime.bootstrap();
-
-      // onLifecycleEvent returns an unsubscribe function
-      const unsubscribeFn = vi.mocked(agentManager.onLifecycleEvent).mock.results[0].value;
-
-      await runtime.teardown();
-
-      // The unsubscribe function should have been called
-      expect(unsubscribeFn).toHaveBeenCalled();
-    });
-  });
-
-  describe("structured team", () => {
-    it("bootstraps with push mode and queue strategy", async () => {
-      const manifest = await loadTeam("structured", roleRegistry, PROJECT_ROOT);
-      const runtime = new TeamRuntime(manifest, services);
-
-      expect(runtime.getTaskMode()).toBe("push");
-      expect(runtime.getStrategyName()).toBe("queue");
-
-      await runtime.initialize();
-      const result = await runtime.bootstrap();
-
-      // Root (lead) + 1 companion (reviewer)
-      expect(agentManager.spawn).toHaveBeenCalledTimes(2);
-      expect(result.companionIds).toHaveLength(1);
-
-      // Verify no pull-mode interaction patterns injected
-      const rootCall = vi.mocked(agentManager.spawn).mock.calls[0][0];
-      const pullPatterns = rootCall.interactionPatterns?.filter((p) =>
-        p.includes("PULL mode")
-      ) ?? [];
-      expect(pullPatterns).toHaveLength(0);
-    });
-  });
-});
-
-// =============================================================================
-// Tests: Integration Strategies
-// =============================================================================
-
-describe("Integration Strategies", () => {
-  it("imports trunk strategy module", async () => {
-    const { TrunkIntegrationStrategy } = await import(
-      "../../workspace/strategies/trunk.js"
-    );
-    const strategy = new TrunkIntegrationStrategy();
-    expect(strategy.name).toBe("trunk");
-  });
-
-  it("imports optimistic strategy module", async () => {
-    const { OptimisticIntegrationStrategy } = await import(
-      "../../workspace/strategies/optimistic.js"
-    );
-    const strategy = new OptimisticIntegrationStrategy();
-    expect(strategy.name).toBe("optimistic");
-  });
-
-  it("imports queue strategy module", async () => {
-    const { QueueIntegrationStrategy } = await import(
-      "../../workspace/strategies/queue.js"
-    );
-    const strategy = new QueueIntegrationStrategy();
-    expect(strategy.name).toBe("queue");
-  });
-
-  it("registry provides all built-in strategies", async () => {
-    const { defaultStrategyRegistry } = await import(
-      "../../workspace/strategies/registry.js"
-    );
-    expect(defaultStrategyRegistry.has("queue")).toBe(true);
-    expect(defaultStrategyRegistry.has("trunk")).toBe(true);
-    expect(defaultStrategyRegistry.has("optimistic")).toBe(true);
-  });
-});
-
-// =============================================================================
-// Tests: Task Pull Model
-// =============================================================================
-
-describe("Task Pull Model", () => {
-  it("claim_task tool module exports correctly", async () => {
-    const { CLAIM_TASK_TOOL_INFO, ClaimTaskSchema, createClaimTaskHandler } =
-      await import("../../mcp/tools/claim_task.js");
-
-    expect(CLAIM_TASK_TOOL_INFO.name).toBe("claim_task");
-    expect(createClaimTaskHandler).toBeInstanceOf(Function);
-    expect(ClaimTaskSchema).toBeDefined();
-  });
-
-  it("unclaim_task tool module exports correctly", async () => {
-    const { UNCLAIM_TASK_TOOL_INFO, createUnclaimTaskHandler } = await import(
-      "../../mcp/tools/unclaim_task.js"
-    );
-
-    expect(UNCLAIM_TASK_TOOL_INFO.name).toBe("unclaim_task");
-    expect(createUnclaimTaskHandler).toBeInstanceOf(Function);
-  });
-
-  it("list_claimable_tasks tool module exports correctly", async () => {
-    const { LIST_CLAIMABLE_TASKS_TOOL_INFO, createListClaimableTasksHandler } =
-      await import("../../mcp/tools/list_claimable_tasks.js");
-
-    expect(LIST_CLAIMABLE_TASKS_TOOL_INFO.name).toBe("list_claimable_tasks");
-    expect(createListClaimableTasksHandler).toBeInstanceOf(Function);
-  });
-
-  it("task.claim capability is registered", async () => {
-    const { TASK_CAPABILITIES, ALL_CAPABILITIES } = await import(
-      "../../roles/capabilities.js"
-    );
-
-    expect(TASK_CAPABILITIES.CLAIM).toBe("task.claim");
-    expect(ALL_CAPABILITIES.has("task.claim")).toBe(true);
-  });
-});
-
-// =============================================================================
-// Tests: Metrics Module
-// =============================================================================
-
-describe("Metrics Module", () => {
-  it("exports all metric functions", async () => {
-    const {
-      getThroughputMetrics,
-      getUtilizationMetrics,
-      getErrorMetrics,
-    } = await import("../../metrics/index.js");
-
-    expect(getThroughputMetrics).toBeInstanceOf(Function);
-    expect(getUtilizationMetrics).toBeInstanceOf(Function);
-    expect(getErrorMetrics).toBeInstanceOf(Function);
-  });
-
-  it("computes throughput metrics from empty store", async () => {
-    const { getThroughputMetrics } = await import("../../metrics/index.js");
-    const store = createMockEventStore();
-
-    const metrics = getThroughputMetrics(store, 60000);
-
-    expect(metrics.tasksCompleted).toBe(0);
-    expect(metrics.tasksFailed).toBe(0);
-    expect(metrics.tasksCreated).toBe(0);
-    expect(metrics.completedPerMinute).toBe(0);
-    expect(metrics.avgCompletionTimeMs).toBeNull();
-  });
-
-  it("computes utilization metrics from empty store", async () => {
-    const { getUtilizationMetrics } = await import("../../metrics/index.js");
-    const store = createMockEventStore();
-
-    const metrics = getUtilizationMetrics(store);
-
-    expect(metrics.activeAgents).toBe(0);
-    expect(metrics.totalSpawned).toBe(0);
-    expect(metrics.totalStopped).toBe(0);
-  });
-
-  it("computes error metrics from empty store", async () => {
-    const { getErrorMetrics } = await import("../../metrics/index.js");
-    const store = createMockEventStore();
-
-    const metrics = getErrorMetrics(store);
-
-    expect(metrics.totalErrors).toBe(0);
-    expect(metrics.recentErrors).toEqual([]);
-  });
-});