macro-agent 0.1.2 → 0.1.4

package/src/teams/__tests__/team-runtime-v2.test.ts

@@ -0,0 +1,402 @@
+/**
+ * Tests for TeamRuntimeV2 — uses InboxAdapter + TasksAdapter
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as path from "path";
+import { TeamRuntimeV2, type TeamServicesV2 } from "../team-runtime-v2.js";
+import { DefaultRoleRegistry } from "../../roles/registry.js";
+import type { AgentManager, SpawnInterceptor } from "../../agent/agent-manager.js";
+import type { InboxAdapter, TasksAdapter, SignalFilterFn, EmissionValidatorFn } from "../../adapters/types.js";
+import type { SpawnAgentOptions } from "../../agent/types.js";
+import type { AgentId } from "../../store/types/index.js";
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+const PROJECT_ROOT = path.resolve(import.meta.dirname, "../../..");
+
+let spawnCounter = 0;
+let capturedInterceptor: SpawnInterceptor | null = null;
+let interceptedSpawnOptions: SpawnAgentOptions[] = [];
+let lifecycleCallbacks: Array<(event: any) => void> = [];
+
+function createMockAgentManager(roleRegistry: DefaultRoleRegistry): AgentManager {
+  capturedInterceptor = null;
+  spawnCounter = 0;
+  interceptedSpawnOptions = [];
+  lifecycleCallbacks = [];
+
+  return {
+    spawn: vi.fn(async (options: SpawnAgentOptions) => {
+      const opts = capturedInterceptor
+        ? await 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,
+      };
+    }),
+    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((callback: (event: any) => void) => {
+      lifecycleCallbacks.push(callback);
+      return vi.fn(); // unsubscribe
+    }),
+    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;
+}
+
+function createMockInboxAdapter(): InboxAdapter & {
+  _signalFilter: SignalFilterFn | null;
+  _emissionValidator: EmissionValidatorFn | null;
+} {
+  const signalFilters = new Map<string, SignalFilterFn>();
+  const emissionValidators = new Map<string, EmissionValidatorFn>();
+
+  return {
+    registerAgent: vi.fn().mockResolvedValue(undefined),
+    deregisterAgent: vi.fn().mockResolvedValue(undefined),
+    send: vi.fn().mockResolvedValue("msg-1"),
+    onDelivery: vi.fn(),
+    offDelivery: vi.fn(),
+    checkInbox: vi.fn().mockResolvedValue([]),
+    readThread: vi.fn().mockResolvedValue([]),
+    setSignalFilter: vi.fn((f: SignalFilterFn) => {
+      signalFilters.set("default", f);
+    }),
+    setEmissionValidator: vi.fn((v: EmissionValidatorFn) => {
+      emissionValidators.set("default", v);
+    }),
+    addSignalFilter: vi.fn((id: string, f: SignalFilterFn) => {
+      signalFilters.set(id, f);
+    }),
+    removeSignalFilter: vi.fn((id: string) => {
+      signalFilters.delete(id);
+    }),
+    addEmissionValidator: vi.fn((id: string, v: EmissionValidatorFn) => {
+      emissionValidators.set(id, v);
+    }),
+    removeEmissionValidator: vi.fn((id: string) => {
+      emissionValidators.delete(id);
+    }),
+    socketPath: "/tmp/test-inbox.sock",
+    stop: vi.fn().mockResolvedValue(undefined),
+    get _signalFilter() {
+      // Return the most recently added filter (for backward compat with existing tests)
+      const values = [...signalFilters.values()];
+      return values.length > 0 ? values[values.length - 1] : null;
+    },
+    get _emissionValidator() {
+      const values = [...emissionValidators.values()];
+      return values.length > 0 ? values[values.length - 1] : null;
+    },
+  } as unknown as InboxAdapter & {
+    _signalFilter: SignalFilterFn | null;
+    _emissionValidator: EmissionValidatorFn | null;
+  };
+}
+
+function createMockTasksAdapter(): TasksAdapter {
+  return {
+    createTask: vi.fn().mockResolvedValue("ot-task-1"),
+    assignTask: vi.fn().mockResolvedValue(undefined),
+    transitionTask: vi.fn().mockResolvedValue(undefined),
+    getTask: vi.fn().mockResolvedValue({ id: "t-1", title: "test", status: "open" }),
+    queryReady: vi.fn().mockResolvedValue([]),
+    listTasks: vi.fn().mockResolvedValue([]),
+    addBlocker: vi.fn().mockResolvedValue(undefined),
+    removeBlocker: vi.fn().mockResolvedValue(undefined),
+    claimTask: vi.fn().mockResolvedValue(null),
+    unclaimTask: vi.fn().mockResolvedValue(undefined),
+    listClaimable: vi.fn().mockResolvedValue([]),
+    connect: vi.fn().mockResolvedValue(undefined),
+    disconnect: vi.fn(),
+    connected: true,
+  } as unknown as TasksAdapter;
+}
+
+async function loadTeamTemplate(teamName: string, roleRegistry: DefaultRoleRegistry) {
+  const { loadTeam } = await import("../team-loader.js");
+  return loadTeam(teamName, roleRegistry, PROJECT_ROOT);
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("TeamRuntimeV2", () => {
+  let roleRegistry: DefaultRoleRegistry;
+  let agentManager: AgentManager;
+  let inboxAdapter: ReturnType<typeof createMockInboxAdapter>;
+  let tasksAdapter: TasksAdapter;
+  let services: TeamServicesV2;
+
+  beforeEach(() => {
+    roleRegistry = new DefaultRoleRegistry();
+    agentManager = createMockAgentManager(roleRegistry);
+    inboxAdapter = createMockInboxAdapter();
+    tasksAdapter = createMockTasksAdapter();
+    services = { agentManager, inboxAdapter, tasksAdapter };
+  });
+
+  describe("initialize()", () => {
+    it("should register team roles in role registry", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+
+      expect(roleRegistry.getRole("planner")).toBeDefined();
+      expect(roleRegistry.getRole("grinder")).toBeDefined();
+      expect(roleRegistry.getRole("judge")).toBeDefined();
+    });
+
+    it("should not require eventStore", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      // Should not throw — no EventStore dependency
+      await expect(runtime.initialize()).resolves.toBeUndefined();
+    });
+  });
+
+  describe("bootstrap()", () => {
+    it("should spawn root and companion agents", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      const result = await runtime.bootstrap();
+
+      expect(result.rootId).toBeDefined();
+      expect(result.companionIds).toHaveLength(1);
+      expect(agentManager.spawn).toHaveBeenCalledTimes(2);
+    });
+
+    it("should pass team_instance as scope", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+
+      // Root agent should have team_instance set
+      const rootSpawnOpts = interceptedSpawnOptions[0];
+      expect(rootSpawnOpts.team_instance).toBe("self-driving");
+    });
+
+    it("should build agent↔role mappings", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      const result = await runtime.bootstrap();
+
+      expect(runtime.hasAgent(result.rootId)).toBe(true);
+      expect(runtime.hasAgent(result.companionIds[0])).toBe(true);
+      expect(runtime.hasAgent("nonexistent")).toBe(false);
+    });
+  });
+
+  describe("signal filtering (adapter-side)", () => {
+    it("should install signal filter on InboxAdapter", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      expect(inboxAdapter.addSignalFilter).toHaveBeenCalledWith(
+        "self-driving",
+        expect.any(Function)
+      );
+    });
+
+    it("should filter signals based on peer routes", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      const result = await runtime.bootstrap();
+      runtime.installOnServices();
+
+      const filter = inboxAdapter._signalFilter!;
+      const companionId = result.companionIds[0];
+      const rootId = result.rootId;
+
+      // judge→planner peer route allows FIXUP_CREATED and GREEN_SNAPSHOT
+      const makeMsg = (event: string) => ({
+        content: { type: "event", event },
+        metadata: {},
+      });
+
+      expect(filter(companionId, rootId, makeMsg("FIXUP_CREATED") as any)).toBe(true);
+      expect(filter(companionId, rootId, makeMsg("GREEN_SNAPSHOT") as any)).toBe(true);
+      expect(filter(companionId, rootId, makeMsg("WORKER_DONE") as any)).toBe(false);
+    });
+
+    it("should allow signals for non-team agents", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      const filter = inboxAdapter._signalFilter!;
+      const makeMsg = (event: string) => ({
+        content: { type: "event", event },
+        metadata: {},
+      });
+
+      expect(filter("unknown_from", "unknown_to", makeMsg("ANY_SIGNAL") as any)).toBe(true);
+    });
+  });
+
+  describe("emission validation (adapter-side)", () => {
+    it("should install emission validator on InboxAdapter", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      expect(inboxAdapter.addEmissionValidator).toHaveBeenCalledWith(
+        "self-driving",
+        expect.any(Function)
+      );
+    });
+
+    it("should allow valid emissions", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      const result = await runtime.bootstrap();
+      runtime.installOnServices();
+
+      const validator = inboxAdapter._emissionValidator!;
+      const makeMsg = (event: string) => ({
+        content: { type: "event", event },
+        metadata: {},
+      });
+
+      // planner's allowed emissions: [TASK_CREATED, WORK_ASSIGNED]
+      expect(validator(result.rootId, makeMsg("TASK_CREATED") as any)).toBeNull();
+    });
+
+    it("should allow emissions from non-team agents", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      const validator = inboxAdapter._emissionValidator!;
+      const makeMsg = (event: string) => ({
+        content: { type: "event", event },
+        metadata: {},
+      });
+
+      expect(validator("unknown_agent", makeMsg("ANYTHING") as any)).toBeNull();
+    });
+  });
+
+  describe("spawn interceptor", () => {
+    it("should inject team context into spawn options", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      // Spawn a grinder via interceptor
+      await agentManager.spawn({
+        task: "grinder task",
+        role: "grinder",
+        parent: runtime.getRootAgentId(),
+      });
+
+      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.team_instance).toBe("self-driving");
+      expect(lastOpts.topics).toContain("work_coordination");
+    });
+
+    it("should pass through agents with unknown roles", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+      runtime.installOnServices();
+
+      await agentManager.spawn({
+        task: "unknown role",
+        role: "unknown_role",
+        parent: null,
+      });
+
+      const lastOpts = interceptedSpawnOptions.at(-1)!;
+      // Unknown role → no team context injected
+      expect(lastOpts.config?.env?.MACRO_TEAM_NAME).toBeUndefined();
+    });
+  });
+
+  describe("getters", () => {
+    it("should return task mode and strategy", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+
+      expect(runtime.getTaskMode()).toBe("pull");
+      expect(runtime.getStrategyName()).toBe("trunk");
+    });
+
+    it("should return scope = team name", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+
+      expect(runtime.getScope()).toBe("self-driving");
+    });
+  });
+
+  describe("agent registration", () => {
+    it("should track dynamically registered agents", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+
+      runtime.registerAgent("dynamic_1" as AgentId, "grinder");
+
+      expect(runtime.hasAgent("dynamic_1")).toBe(true);
+    });
+  });
+
+  describe("teardown", () => {
+    it("should clean up without errors", async () => {
+      const manifest = await loadTeamTemplate("self-driving", roleRegistry);
+      const runtime = new TeamRuntimeV2(manifest, services);
+      await runtime.initialize();
+      await runtime.bootstrap();
+
+      await expect(runtime.teardown()).resolves.toBeUndefined();
+    });
+  });
+});

package/src/teams/index.ts

@@ -1,6 +1,4 @@
 export { loadTeam } from "./team-loader.js";
-export { TeamRuntime, type TeamServices, type TeamBootstrapResult } from "./team-runtime.js";
-export { TeamManager, type TeamInstance, type TeamStartOverrides } from "./team-manager.js";
 export { seedDefaultTemplates } from "./seed-defaults.js";
 export {
   TeamLoadError,

package/src/teams/team-manager-v2.ts

@@ -0,0 +1,268 @@
+/**
+ * TeamManagerV2 — Multi-team orchestrator.
+ *
+ * Manages multiple concurrent team instances, each with its own
+ * TeamRuntimeV2. Uses composite signal filters and emission validators
+ * (via addSignalFilter/addEmissionValidator) so teams don't overwrite
+ * each other's policy hooks.
+ *
+ * Key responsibilities:
+ * - Hold multiple team instances with agent-to-team mapping
+ * - Install a composite spawn interceptor on AgentManager
+ * - Auto-register child agents in parent's team via lifecycle listener
+ * - Provide API for starting/stopping teams
+ *
+ * @module teams/team-manager-v2
+ */
+
+import type { AgentManager, SpawnInterceptor } from "../agent/agent-manager.js";
+import type { SpawnAgentOptions } from "../agent/types.js";
+import type { AgentId } from "../store/types/index.js";
+import type { InboxAdapter, TasksAdapter } from "../adapters/types.js";
+import type { WorkspaceManager } from "../workspace/types.js";
+import { TeamRuntimeV2, type TeamBootstrapResult, type TeamServicesV2 } from "./team-runtime-v2.js";
+import type { TeamManifest } from "./types.js";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface TeamManagerV2Services {
+  agentManager: AgentManager;
+  inboxAdapter: InboxAdapter;
+  tasksAdapter: TasksAdapter;
+  workspaceManager?: WorkspaceManager;
+}
+
+export interface TeamInstance {
+  id: string;
+  templateName: string;
+  runtime: TeamRuntimeV2;
+  result: TeamBootstrapResult;
+}
+
+// =============================================================================
+// TeamManagerV2
+// =============================================================================
+
+export class TeamManagerV2 {
+  /** Active team instances by instance ID */
+  private instances = new Map<string, TeamInstance>();
+
+  /** Agent ID → TeamInstance mapping */
+  private agentTeamMap = new Map<string, TeamInstance>();
+
+  /** Lifecycle listener unsubscribe */
+  private lifecycleUnsubscribe?: () => void;
+
+  /** Whether install() has been called */
+  private installed = false;
+
+  /** Counter for unique instance IDs */
+  private instanceCounter = 0;
+
+  constructor(private readonly services: TeamManagerV2Services) {}
+
+  // ─────────────────────────────────────────────────────────────
+  // Installation
+  // ─────────────────────────────────────────────────────────────
+
+  /**
+   * Install composite spawn interceptor and lifecycle listener.
+   * Must be called once before starting any teams.
+   */
+  install(): void {
+    if (this.installed) return;
+
+    const { agentManager } = this.services;
+
+    // Install composite spawn interceptor that delegates to the correct team
+    agentManager.setSpawnInterceptor(this.createCompositeSpawnInterceptor());
+
+    // Listen for lifecycle events to auto-register children
+    this.lifecycleUnsubscribe = agentManager.onLifecycleEvent((event) => {
+      if (event.type !== "spawned") return;
+
+      const parentId = event.agent.parent;
+      if (!parentId) return;
+
+      const parentTeam = this.agentTeamMap.get(parentId);
+      if (!parentTeam) return;
+
+      // Auto-register child in parent's team
+      this.agentTeamMap.set(event.agent.id, parentTeam);
+      const roleName = event.agent.role;
+      if (roleName) {
+        parentTeam.runtime.registerAgent(event.agent.id as AgentId, roleName);
+      }
+    });
+
+    this.installed = true;
+  }
+
+  /**
+   * Uninstall composite interceptor and lifecycle listener.
+   */
+  uninstall(): void {
+    if (!this.installed) return;
+
+    this.services.agentManager.setSpawnInterceptor(null);
+
+    if (this.lifecycleUnsubscribe) {
+      this.lifecycleUnsubscribe();
+      this.lifecycleUnsubscribe = undefined;
+    }
+
+    this.installed = false;
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // Team Lifecycle
+  // ─────────────────────────────────────────────────────────────
+
+  /**
+   * Start a team from a template name.
+   *
+   * Loads the template, creates a TeamRuntimeV2, initializes,
+   * bootstraps, and registers filters via addSignalFilter/addEmissionValidator.
+   *
+   * @param name - Team template name
+   * @param basePath - Project root for template loading
+   * @returns The team instance ID
+   */
+  async startTeam(name: string, basePath?: string): Promise<string> {
+    const { agentManager, inboxAdapter, tasksAdapter, workspaceManager } = this.services;
+
+    // Load template
+    const { loadTeam } = await import("./team-loader.js");
+    const roleRegistry = agentManager.getRoleRegistry();
+    const manifest: TeamManifest = await loadTeam(
+      name,
+      roleRegistry,
+      basePath ?? process.cwd()
+    );
+
+    // Create runtime
+    const runtimeServices: TeamServicesV2 = {
+      agentManager,
+      inboxAdapter,
+      tasksAdapter,
+      workspaceManager,
+    };
+    const runtime = new TeamRuntimeV2(manifest, runtimeServices);
+
+    // Generate instance ID
+    const instanceId = `${name}-${++this.instanceCounter}`;
+
+    // Initialize and bootstrap
+    await runtime.initialize({ teamInstanceId: instanceId });
+    const result = await runtime.bootstrap();
+
+    // Register filters via composite methods (not set — avoids overwrite)
+    inboxAdapter.addSignalFilter(instanceId, runtime.createSignalFilter());
+    inboxAdapter.addEmissionValidator(instanceId, runtime.createEmissionValidator());
+
+    // Build instance
+    const instance: TeamInstance = {
+      id: instanceId,
+      templateName: name,
+      runtime,
+      result,
+    };
+
+    // Track in instances map
+    this.instances.set(instanceId, instance);
+
+    // Map bootstrap agents to this team
+    this.agentTeamMap.set(result.rootId, instance);
+    for (const companionId of result.companionIds) {
+      this.agentTeamMap.set(companionId, instance);
+    }
+
+    return instanceId;
+  }
+
+  /**
+   * Stop a team instance.
+   *
+   * Tears down the runtime, removes signal filters/validators,
+   * and clears agent mappings.
+   */
+  async stopTeam(instanceId: string): Promise<void> {
+    const instance = this.instances.get(instanceId);
+    if (!instance) return;
+
+    // Teardown runtime
+    await instance.runtime.teardown();
+
+    // Remove filters
+    this.services.inboxAdapter.removeSignalFilter(instanceId);
+    this.services.inboxAdapter.removeEmissionValidator(instanceId);
+
+    // Clear agent mappings for this team
+    for (const [agentId, team] of this.agentTeamMap) {
+      if (team === instance) {
+        this.agentTeamMap.delete(agentId);
+      }
+    }
+
+    // Remove from instances
+    this.instances.delete(instanceId);
+  }
+
+  /**
+   * Stop all active teams and uninstall.
+   */
+  async teardownAll(): Promise<void> {
+    const instanceIds = [...this.instances.keys()];
+    for (const id of instanceIds) {
+      await this.stopTeam(id);
+    }
+    this.uninstall();
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // Queries
+  // ─────────────────────────────────────────────────────────────
+
+  /** Get the team instance an agent belongs to. */
+  getTeamForAgent(agentId: string): TeamInstance | undefined {
+    return this.agentTeamMap.get(agentId);
+  }
+
+  /** Get a team instance by ID. */
+  getInstance(id: string): TeamInstance | undefined {
+    return this.instances.get(id);
+  }
+
+  /** Get all active team instances. */
+  getInstances(): TeamInstance[] {
+    return [...this.instances.values()];
+  }
+
+  /** Whether any team is currently active. */
+  hasActiveTeam(): boolean {
+    return this.instances.size > 0;
+  }
+
+  // ─────────────────────────────────────────────────────────────
+  // Private: Composite Spawn Interceptor
+  // ─────────────────────────────────────────────────────────────
+
+  private createCompositeSpawnInterceptor(): SpawnInterceptor {
+    return (
+      options: SpawnAgentOptions
+    ): SpawnAgentOptions | Promise<SpawnAgentOptions> => {
+      // Find the parent's team
+      const parentId = options.parent;
+      if (!parentId) return options;
+
+      const parentTeam = this.agentTeamMap.get(parentId);
+      if (!parentTeam) return options;
+
+      // Delegate to team's spawn interceptor
+      const teamInterceptor = parentTeam.runtime.createSpawnInterceptor();
+      return teamInterceptor(options);
+    };
+  }
+}