macro-agent 0.1.2 → 0.1.3

package/dist/agent/agent-manager.js

@@ -1,1324 +1,17 @@
 /**
- * AgentManager - Service for managing agent lifecycle and sessions
+ * AgentManager - Interface and types for managing agent lifecycle and sessions
  *
- * Integrates:
- * - acp-factory for Claude Code process/session management
- * - EventStore for persistent agent state
- * - MessageRouter for subscription setup
- */
-import { nanoid } from "nanoid";
-import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
-import { AgentFactory, } from "acp-factory";
-import { AgentManagerError } from "./types.js";
-import { AGENT_CAPABILITIES } from "../roles/capabilities.js";
-import { DefaultRoleRegistry } from "../roles/registry.js";
-import { generateSystemPrompt } from "./system-prompt.js";
-import { terminateWithChangeConsolidation, } from "../lifecycle/cascade.js";
-// ─────────────────────────────────────────────────────────────────
-// Helper Functions
-// ─────────────────────────────────────────────────────────────────
-/**
- * Map a child role name to the required spawn capability.
- * Handles subroles like "worker.resolver" by checking base role.
+ * The V1 implementation has been removed. The V2 implementation lives in
+ * agent-manager-v2.ts and is wired via boot-v2.ts.
+ *
+ * This file retains:
+ * - The AgentManager interface (used everywhere)
+ * - The AgentManagerConfig interface
+ * - The SpawnInterceptor type
+ * - A re-export of createAgentManagerV2 as createAgentManager for backward compat
  */
-function getSpawnCapability(childRole) {
-    // Extract base role (e.g., "worker.resolver" -> "worker")
-    const baseRole = childRole.split(".")[0];
-    switch (baseRole) {
-        case "worker":
-            return AGENT_CAPABILITIES.SPAWN_WORKER;
-        case "integrator":
-            return AGENT_CAPABILITIES.SPAWN_INTEGRATOR;
-        case "monitor":
-            return AGENT_CAPABILITIES.SPAWN_MONITOR;
-        case "coordinator":
-            // Coordinators require special handling - typically only other coordinators
-            // or system-level agents can spawn coordinators
-            return AGENT_CAPABILITIES.SPAWN_CUSTOM;
-        default:
-            // For team-defined roles (e.g., "grinder"), return the specific capability
-            // (e.g., "agent.spawn.grinder"). The spawn check also accepts
-            // "agent.spawn.custom" as a generic fallback.
-            return `agent.spawn.${childRole}`;
-    }
-}
 // ─────────────────────────────────────────────────────────────────
-// AgentManager Implementation
+// Re-export V2 implementation as createAgentManager for backward compat
 // ─────────────────────────────────────────────────────────────────
-export function createAgentManager(eventStore, messageRouter, config = {}) {
-    const { defaultPermissionMode = "auto-approve", defaultAgentType = "claude-code", defaultCwd = process.cwd(), workspaceManager, roleRegistry = new DefaultRoleRegistry(), healthCheckService, mailService: initialMailService, conversationMap: initialConversationMap, serverUrl, serverToken, agentTokenManager, taskBackend: configTaskBackend, openTasksSocketPath: initialOpenTasksSocketPath, } = config;
-    // Mutable OpenTasks socket path (support late binding via setOpenTasksSocketPath)
-    let configOpenTasksSocketPath = initialOpenTasksSocketPath;
-    // Mutable mail services (support late binding via setMailServices)
-    let mailService = initialMailService;
-    let conversationMap = initialConversationMap;
-    // Mutable spawn interceptor (set by TeamRuntime)
-    let spawnInterceptor = null;
-    // Active sessions tracked in memory
-    const activeSessions = new Map();
-    // Agent workspace mappings (agentId → workspace)
-    const agentWorkspaces = new Map();
-    // Lifecycle event listeners
-    const lifecycleListeners = new Set();
-    // Shutdown guard — prevents spawns during close()
-    let isShuttingDown = false;
-    // ─────────────────────────────────────────────────────────────────
-    // MCP Server Config
-    // ─────────────────────────────────────────────────────────────────
-    /**
-     * Build the macro-agent MCP server config for a Claude Code agent session.
-     * Used by spawn(), resume(), and forkAgent() to ensure every agent gets
-     * access to the macro-agent coordination tools.
-     */
-    function buildMacroAgentMcp(opts) {
-        // Common env vars for both thin-client and legacy modes
-        const env = [
-            { name: "MACRO_AGENT_ID", value: opts.agentId },
-            { name: "MACRO_PARENT_ID", value: opts.parentId },
-            { name: "MACRO_TASK_ID", value: opts.taskId },
-            { name: "MACRO_AGENT_CWD", value: opts.cwd },
-            { name: "MACRO_PERMISSION_MODE", value: opts.permissionMode },
-            {
-                name: "MACRO_TASK_BACKEND",
-                value: configTaskBackend ?? process.env.MACRO_TASK_BACKEND ?? "",
-            },
-            {
-                name: "OPENTASKS_SOCKET_PATH",
-                value: configOpenTasksSocketPath ?? process.env.OPENTASKS_SOCKET_PATH ?? "",
-            },
-            // Pass streamId so MCP subprocess can include it in lifecycle context
-            // (WorkspaceManager is not available in subprocess)
-            { name: "MACRO_STREAM_ID", value: opts.streamId ?? "" },
-        ];
-        if (serverUrl) {
-            // Thin-client mode: forward tool calls to main server via MAP WebSocket
-            env.push({ name: "MACRO_SERVER_URL", value: serverUrl }, {
-                name: "MACRO_AGENT_LINEAGE",
-                value: JSON.stringify(opts.lineage ?? []),
-            }, { name: "MACRO_SESSION_ID", value: opts.sessionId ?? "" });
-            // Auth tokens for thin-client connections
-            if (serverToken) {
-                env.push({ name: "MACRO_SERVER_TOKEN", value: serverToken });
-            }
-            if (agentTokenManager) {
-                const agentToken = agentTokenManager.createToken(opts.agentId);
-                env.push({ name: "MACRO_AGENT_TOKEN", value: agentToken });
-            }
-        }
-        else {
-            // Legacy mode: create local service stack with shared SQLite
-            env.push({ name: "MACRO_INSTANCE_ID", value: eventStore.instanceId }, { name: "MACRO_BASE_DIR", value: eventStore.baseDir });
-        }
-        return {
-            name: "macro-agent",
-            command: "npx",
-            args: ["multiagent-mcp"],
-            env,
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Lifecycle
-    // ─────────────────────────────────────────────────────────────────
-    async function spawn(rawOptions) {
-        if (isShuttingDown) {
-            throw new AgentManagerError("Cannot spawn agent during shutdown", "SHUTDOWN_IN_PROGRESS");
-        }
-        // Apply spawn interceptor if set (used by TeamRuntime for team context injection)
-        const options = spawnInterceptor
-            ? await spawnInterceptor(rawOptions)
-            : rawOptions;
-        const { task, task_id, parent, cwd = defaultCwd, permissionMode = defaultPermissionMode, subscribeParent = true, topics = [], config: agentConfig, agentType = defaultAgentType, customPrompt, interactionPatterns, 
-        // Workspace-related fields (Phase 2)
-        role, team_instance, streamId, streamConfig, dataplaneTaskId, capabilities, } = options;
-        // Generate IDs upfront (including session_id so we can persist before starting MCP)
-        const agentId = `agent_${nanoid(12)}`;
-        const taskId = task_id ?? `task_${nanoid(12)}`;
-        const sessionId = `session_${nanoid(12)}`;
-        // Validate parent exists if specified
-        if (parent) {
-            const parentAgent = eventStore.getAgent(parent);
-            if (!parentAgent) {
-                throw new AgentManagerError(`Parent agent not found: ${parent}`, "AGENT_NOT_FOUND", parent);
-            }
-            // Check spawn capability
-            const childRole = role ?? "worker";
-            const requiredCapability = getSpawnCapability(childRole);
-            const parentRole = parentAgent.role ?? "worker";
-            // Accept either the specific capability (e.g., agent.spawn.grinder)
-            // or the generic agent.spawn.custom as a fallback for non-built-in roles
-            const hasSpecific = roleRegistry.hasCapability(parentRole, requiredCapability);
-            const hasGeneric = requiredCapability !== AGENT_CAPABILITIES.SPAWN_CUSTOM &&
-                roleRegistry.hasCapability(parentRole, AGENT_CAPABILITIES.SPAWN_CUSTOM);
-            if (!hasSpecific && !hasGeneric) {
-                throw new AgentManagerError(`Parent agent with role '${parentRole}' does not have capability to spawn '${childRole}' agents. ` +
-                    `Required capability: ${requiredCapability}`, "CAPABILITY_DENIED", parent);
-            }
-        }
-        // Build system prompt context
-        const parentAgent = parent ? eventStore.getAgent(parent) : null;
-        const promptContext = {
-            agentId,
-            task,
-            taskId,
-            parentId: parent ?? null,
-            isHeadManager: !parent,
-            lineage: parentAgent?.lineage ? [...parentAgent.lineage, parent] : [],
-            role: role ?? "worker",
-            mcpTools: [
-                "done", // Listed first - most important tool for completion
-                "spawn_agent",
-                "emit_status",
-                "send_message",
-                "check_messages",
-                "get_hierarchy",
-                "get_agent_summary",
-                "stop_agent",
-                "create_task",
-                "get_task",
-            ],
-        };
-        let systemPrompt = generateSystemPrompt(promptContext);
-        // Append role prompt: team customPrompt takes precedence over resolvedRole.systemPrompt
-        const resolvedRole = roleRegistry.resolveRole(role ?? "worker");
-        if (customPrompt) {
-            systemPrompt += `\n\n# Role Instructions\n\n${customPrompt}`;
-        }
-        else if (resolvedRole.systemPrompt) {
-            systemPrompt += `\n\n# Role-Specific Instructions\n\n${resolvedRole.systemPrompt}`;
-        }
-        // Append team interaction pattern sections (pull mode, trunk integration, etc.)
-        if (interactionPatterns && interactionPatterns.length > 0) {
-            for (const pattern of interactionPatterns) {
-                systemPrompt += `\n\n${pattern}`;
-            }
-        }
-        eventStore.emit({
-            type: "spawn",
-            source: { agent_id: parent ?? "system" },
-            payload: {
-                agent_id: agentId,
-                session_id: sessionId,
-                task,
-                task_id: taskId,
-                parent: parent ?? null,
-                role: role ?? undefined,
-                team_instance: team_instance ?? undefined,
-                config: agentConfig ?? {},
-                cwd,
-            },
-        });
-        // Generate a human-readable default name
-        const generatedName = uniqueNamesGenerator({
-            dictionaries: [adjectives, animals],
-            separator: "-",
-            length: 2,
-        });
-        eventStore.updateAgentMetadata(agentId, { name: generatedName });
-        // Persist immediately so MCP server subprocess can read the agent
-        await eventStore.persist();
-        // Verify the agent is now in the store
-        const verifyAgent = eventStore.getAgent(agentId);
-        const allAgents = eventStore.listAgents();
-        console.error(`[AgentManager] After persist: agent ${agentId} exists = ${!!verifyAgent}, total agents = ${allAgents.length}, instancePath = ${eventStore.instancePath}`);
-        console.error(`[AgentManager] All agent IDs: ${allAgents.map((a) => a.id).join(", ")}`);
-        try {
-            // Spawn agent process via acp-factory
-            const handle = await AgentFactory.spawn(agentType, {
-                permissionMode,
-                env: agentConfig?.env,
-            });
-            try {
-                // ─────────────────────────────────────────────────────────────────
-                // Workspace Creation (before session, so cwd reflects worktree)
-                // ─────────────────────────────────────────────────────────────────
-                let workspace;
-                let resolvedStreamId = streamId;
-                if (workspaceManager && role) {
-                    try {
-                        workspace = await createWorkspaceForRole(workspaceManager, agentId, role, {
-                            streamId,
-                            streamConfig,
-                            dataplaneTaskId,
-                            capabilities,
-                            cwd,
-                        });
-                        if (workspace) {
-                            agentWorkspaces.set(agentId, workspace);
-                            resolvedStreamId = workspace.streamId;
-                            // Create and claim a dataplane task so the worktree gets a real
-                            // worker branch.  Without this, the worktree stays in detached
-                            // HEAD and done() would detect "HEAD" instead of the actual
-                            // worker branch name (e.g. worker/<agentId>/<taskId>).
-                            if (workspace.role === "worker" && workspace.streamId) {
-                                try {
-                                    const dpTaskId = workspaceManager.createTask(workspace.streamId, { title: task ?? `Task for ${agentId}` });
-                                    workspaceManager.claimTask(dpTaskId, agentId, workspace.path);
-                                }
-                                catch (claimErr) {
-                                    console.error(`[AgentManager] Failed to create/claim dataplane task for ${agentId}:`, claimErr);
-                                    // Continue without a branch — worktree stays in detached HEAD
-                                }
-                            }
-                            // Register with parent coordinator if applicable
-                            const isChildRole = role === "worker" || role === "integrator" ||
-                                (capabilities && (capabilities.includes("workspace.worktree") || capabilities.includes("workspace.integrate")));
-                            if (parent && isChildRole) {
-                                const parentWorkspace = agentWorkspaces.get(parent);
-                                if (parentWorkspace?.role === "coordinator") {
-                                    workspaceManager.registerChildWorkspace(parent, agentId, workspace.path);
-                                }
-                            }
-                        }
-                    }
-                    catch (wsError) {
-                        console.error(`[AgentManager] Failed to create workspace for ${agentId}: ${wsError}`);
-                        // Continue without workspace — don't fail the spawn
-                    }
-                }
-                // Use workspace path as the agent's working directory when available.
-                // This ensures the agent process, MCP subprocess (MACRO_AGENT_CWD), and
-                // done handler all use the worktree path instead of the repo root.
-                const effectiveCwd = workspace?.path ?? cwd;
-                // Update agent's cwd in EventStore so resume() also uses workspace path
-                if (workspace) {
-                    eventStore.updateAgentMetadata(agentId, { cwd: effectiveCwd });
-                    await eventStore.persist();
-                }
-                const macroAgentMcp = buildMacroAgentMcp({
-                    agentId,
-                    parentId: parent ?? "",
-                    taskId,
-                    cwd: effectiveCwd,
-                    permissionMode,
-                    lineage: parentAgent?.lineage
-                        ? [...parentAgent.lineage, parent]
-                        : [],
-                    sessionId,
-                    streamId,
-                });
-                // Combine with any user-provided MCP servers
-                // Note: Like macroAgentMcp, user MCP servers use stdio (no 'type' field)
-                const userMcpServers = agentConfig?.mcpServers?.map((s) => ({
-                    name: s.name,
-                    command: s.command,
-                    args: s.args ?? [],
-                    env: s.env
-                        ? Object.entries(s.env).map(([name, value]) => ({ name, value }))
-                        : [],
-                })) ?? [];
-                // Create session with MCP servers
-                // Note: The MCP server subprocess will start here and look for the agent
-                // in EventStore. We already persisted the spawn event above.
-                //
-                // When permissionMode is "interactive", we strip settingSources so that
-                // the Claude Code subprocess doesn't read pre-approved tool rules from
-                // the user's ~/.claude/settings.local.json. This ensures ALL tool calls
-                // go through the canUseTool → requestPermission ACP flow.
-                const agentMeta = permissionMode === "interactive"
-                    ? { claudeCode: { options: { settingSources: [] } } }
-                    : undefined;
-                const session = await handle.createSession(effectiveCwd, {
-                    mcpServers: [macroAgentMcp, ...userMcpServers],
-                    ...(agentMeta && { agentMeta }),
-                });
-                // Emit started status (session is ready)
-                // Include the provider's session ID (e.g., Claude Code UUID) so
-                // it can be used for handle.loadSession() during resume
-                eventStore.emit({
-                    type: "status",
-                    source: { agent_id: agentId },
-                    payload: {
-                        status_type: "started",
-                        summary: "Agent session started",
-                        provider_session_id: session.id,
-                    },
-                });
-                // Persist the status event
-                await eventStore.persist();
-                // Set up default subscriptions via MessageRouter
-                messageRouter.setupDefaultSubscriptions({
-                    agent_id: agentId,
-                    parent_id: parent ?? undefined,
-                    task_id: taskId,
-                    subscribe_parent: subscribeParent,
-                    additional_topics: topics,
-                    role: role ?? undefined,
-                });
-                // ─────────────────────────────────────────────────────────────────
-                // Mail: Create task conversation for this agent
-                // ─────────────────────────────────────────────────────────────────
-                if (mailService && conversationMap) {
-                    try {
-                        const parentConversationId = parent
-                            ? (conversationMap.getAgentConversation(parent) ??
-                                conversationMap.getSessionConversation(parent))
-                            : undefined;
-                        const { conversationId: taskConvId } = mailService.createConversation({
-                            type: "task",
-                            subject: task?.slice(0, 80),
-                            createdBy: parent ?? agentId,
-                            parentConversationId: parentConversationId,
-                        });
-                        // Join parent and child as participants
-                        if (parent) {
-                            mailService.joinConversation({
-                                conversationId: taskConvId,
-                                participantId: parent,
-                                participantType: "agent",
-                                role: "initiator",
-                                agentId: parent,
-                            });
-                        }
-                        mailService.joinConversation({
-                            conversationId: taskConvId,
-                            participantId: agentId,
-                            participantType: "agent",
-                            role: "worker",
-                            agentId,
-                        });
-                        conversationMap.setAgentConversation(agentId, taskConvId);
-                    }
-                    catch (err) {
-                        // Never fail spawn due to mail errors
-                        console.warn(`[AgentManager] Failed to create task conversation for ${agentId}:`, err);
-                    }
-                }
-                // Track active session
-                const activeSession = {
-                    agentId,
-                    handle,
-                    session,
-                    createdAt: Date.now(),
-                    isPrompting: false,
-                };
-                activeSessions.set(agentId, activeSession);
-                // Get the agent from materialized view
-                const agent = eventStore.getAgent(agentId);
-                // Notify lifecycle listeners
-                notifyLifecycle({ type: "spawned", agent });
-                notifyLifecycle({ type: "started", agent });
-                // Start health monitoring for coordinators
-                if (healthCheckService && role === "coordinator") {
-                    healthCheckService.startForCoordinator(agentId);
-                }
-                return {
-                    id: agentId,
-                    session_id: sessionId, // Macro-agent's own session ID for ACP protocol mapping
-                    agent,
-                    session,
-                    workspace,
-                    streamId: resolvedStreamId,
-                };
-            }
-            catch (handleError) {
-                // Close the spawned process to prevent orphaning
-                try {
-                    await handle.close();
-                }
-                catch {
-                    // Ignore errors during cleanup
-                }
-                throw handleError;
-            }
-        }
-        catch (error) {
-            // Clean up the spawn event we already emitted
-            eventStore.emit({
-                type: "stop",
-                source: { agent_id: agentId },
-                payload: {
-                    reason: "failed",
-                },
-            });
-            await eventStore.persist();
-            throw new AgentManagerError(`Failed to spawn agent: ${error}`, "SPAWN_FAILED", agentId);
-        }
-    }
-    async function terminate(agentId, reason) {
-        const agent = eventStore.getAgent(agentId);
-        if (!agent) {
-            throw new AgentManagerError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", agentId);
-        }
-        // Close active session if exists
-        const activeSession = activeSessions.get(agentId);
-        if (activeSession) {
-            try {
-                await activeSession.handle.close();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-            activeSessions.delete(agentId);
-        }
-        // Stop health monitoring for coordinators
-        if (healthCheckService && agent.role === "coordinator") {
-            healthCheckService.stopForCoordinator(agentId);
-        }
-        // ─────────────────────────────────────────────────────────────────
-        // Workspace Cleanup (Phase 2)
-        // ─────────────────────────────────────────────────────────────────
-        if (workspaceManager && agentWorkspaces.has(agentId)) {
-            try {
-                workspaceManager.deallocateWorkspace(agentId);
-                agentWorkspaces.delete(agentId);
-            }
-            catch (wsError) {
-                console.error(`[AgentManager] Failed to deallocate workspace for ${agentId}: ${wsError}`);
-                // Continue with termination even if workspace cleanup fails
-            }
-        }
-        // Revoke agent authentication token
-        if (agentTokenManager) {
-            agentTokenManager.revokeToken(agentId);
-        }
-        // ─────────────────────────────────────────────────────────────────
-        // Mail: Close task conversation on terminate
-        // ─────────────────────────────────────────────────────────────────
-        if (mailService && conversationMap) {
-            try {
-                const convId = conversationMap.getAgentConversation(agentId);
-                if (convId) {
-                    mailService.closeConversation({
-                        conversationId: convId,
-                        closedBy: agentId,
-                        reason: reason === "completed" ? "completed" : "failed",
-                    });
-                }
-                // Close any peer conversations
-                const peerConvIds = conversationMap.closePeerConversationsFor(agentId);
-                for (const peerConvId of peerConvIds) {
-                    mailService.closeConversation({
-                        conversationId: peerConvId,
-                        closedBy: agentId,
-                        reason: "participant_left",
-                    });
-                }
-                conversationMap.removeAgent(agentId);
-            }
-            catch (err) {
-                console.warn(`[AgentManager] Failed to close conversation for ${agentId}:`, err);
-            }
-        }
-        // Emit stop event
-        eventStore.emit({
-            type: "stop",
-            source: { agent_id: agentId },
-            payload: {
-                agent_id: agentId,
-                reason,
-            },
-        });
-        // If agent had a task, update task status based on reason
-        if (agent.task_id) {
-            const taskStatus = reason === "completed"
-                ? "completed"
-                : reason === "failed"
-                    ? "failed"
-                    : "pending";
-            eventStore.emit({
-                type: "task",
-                source: { agent_id: agentId },
-                payload: {
-                    task_id: agent.task_id,
-                    action: reason === "completed" ? "completed" : "status_change",
-                    details: { status: taskStatus },
-                },
-            });
-        }
-        // Persist events to SQLite for cross-process visibility
-        await eventStore.persist();
-        // Notify lifecycle listeners
-        const updatedAgent = eventStore.getAgent(agentId);
-        notifyLifecycle({ type: "stopped", agent: updatedAgent, reason });
-        // Terminate child agents when parent stops (always cascade)
-        // Use change consolidation to merge child branches back to parent before terminating
-        const children = getChildren(agentId);
-        const parentWorkspace = agentWorkspaces.get(agentId);
-        for (const child of children) {
-            if (child.state === "running" || child.state === "spawning") {
-                // Create workspace provider for change consolidation
-                const workspaceProvider = parentWorkspace
-                    ? {
-                        getWorkspace: (id) => agentWorkspaces.get(id) ?? null,
-                    }
-                    : undefined;
-                // Create cascade adapter for termination
-                const cascadeAdapter = {
-                    getChildren: (id) => getChildren(id).map((c) => ({
-                        id: c.id,
-                        state: c.state,
-                        parent: c.parent,
-                    })),
-                    terminate: async (id, terminateReason) => {
-                        await terminate(id, terminateReason);
-                    },
-                };
-                // Use terminateWithChangeConsolidation to merge changes before terminating
-                await terminateWithChangeConsolidation(child.id, agentId, cascadeAdapter, workspaceProvider);
-            }
-        }
-    }
-    async function resume(agentId, overridePermissionMode) {
-        if (isShuttingDown) {
-            throw new AgentManagerError("Cannot resume agent during shutdown", "SHUTDOWN_IN_PROGRESS", agentId);
-        }
-        const agent = eventStore.getAgent(agentId);
-        if (!agent) {
-            throw new AgentManagerError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", agentId);
-        }
-        // Check if already running
-        if (activeSessions.has(agentId)) {
-            throw new AgentManagerError(`Agent already has active session: ${agentId}`, "ALREADY_RUNNING", agentId);
-        }
-        const permissionMode = overridePermissionMode ?? defaultPermissionMode;
-        // Spawn new process
-        const handle = await AgentFactory.spawn(defaultAgentType, {
-            permissionMode,
-        });
-        try {
-            const agentCwd = agent.cwd ?? defaultCwd;
-            let session;
-            // When interactive mode, strip settings to prevent auto-approval
-            const resumeAgentMeta = permissionMode === "interactive"
-                ? { claudeCode: { options: { settingSources: [] } } }
-                : undefined;
-            const macroAgentMcp = buildMacroAgentMcp({
-                agentId,
-                parentId: agent.parent ?? "",
-                taskId: agent.task_id ?? "",
-                cwd: agentCwd,
-                permissionMode,
-                lineage: agent.lineage ?? [],
-                sessionId: agent.session_id ?? "",
-            });
-            const mcpServers = [macroAgentMcp];
-            if (agent.provider_session_id) {
-                // Load existing session using the provider's session ID (e.g., Claude Code UUID)
-                // Note: loadSession's TS type for mcpServers is { name, uri }[] but
-                // the underlying ACP protocol accepts full McpServerStdio. The JS
-                // implementation passes mcpServers through to the connection unchanged.
-                session = await handle.loadSession(agent.provider_session_id, agentCwd, mcpServers, resumeAgentMeta ? { agentMeta: resumeAgentMeta } : undefined);
-            }
-            else {
-                // No provider session ID available (agent predates this feature or wasn't persisted).
-                // Create a new session instead of loading with the macro-agent session_id
-                // which is not a valid provider session ID (e.g., Claude Code expects UUIDs).
-                session = await handle.createSession(agentCwd, {
-                    mcpServers,
-                    ...(resumeAgentMeta && { agentMeta: resumeAgentMeta }),
-                });
-                // Store the provider session ID for future resumes
-                eventStore.emit({
-                    type: "status",
-                    source: { agent_id: agentId },
-                    payload: {
-                        status_type: "started",
-                        summary: "Agent session created (no provider session to resume)",
-                        provider_session_id: session.id,
-                    },
-                });
-            }
-            // Track active session
-            const activeSession = {
-                agentId,
-                handle,
-                session,
-                createdAt: Date.now(),
-                isPrompting: false,
-            };
-            activeSessions.set(agentId, activeSession);
-            // Emit status event for resume
-            eventStore.emit({
-                type: "status",
-                source: { agent_id: agentId },
-                payload: {
-                    status_type: "started",
-                    summary: "Agent session resumed",
-                    provider_session_id: session.id,
-                },
-            });
-            return {
-                id: agentId,
-                session_id: agent.session_id, // Macro-agent's own session ID
-                agent: eventStore.getAgent(agentId),
-                session,
-            };
-        }
-        catch (handleError) {
-            // Close the spawned process to prevent orphaning
-            try {
-                await handle.close();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-            throw handleError;
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Fork
-    // ─────────────────────────────────────────────────────────────────
-    async function forkAgent(sourceAgentId, options) {
-        if (isShuttingDown) {
-            throw new AgentManagerError("Cannot fork agent during shutdown", "SHUTDOWN_IN_PROGRESS", sourceAgentId);
-        }
-        const sourceAgent = eventStore.getAgent(sourceAgentId);
-        if (!sourceAgent) {
-            throw new AgentManagerError(`Agent not found: ${sourceAgentId}`, "AGENT_NOT_FOUND", sourceAgentId);
-        }
-        // Need either an active session or a persisted provider_session_id
-        const activeSession = activeSessions.get(sourceAgentId);
-        if (!activeSession && !sourceAgent.provider_session_id) {
-            throw new AgentManagerError(`Agent has no session to fork: ${sourceAgentId}`, "FORK_NOT_SUPPORTED", sourceAgentId);
-        }
-        // Generate new IDs
-        const agentId = `agent_${nanoid(12)}`;
-        const taskId = `task_${nanoid(12)}`;
-        const sessionId = `session_${nanoid(12)}`;
-        const cwd = options?.cwd ?? sourceAgent.cwd ?? defaultCwd;
-        // Emit spawn event with fork metadata
-        eventStore.emit({
-            type: "spawn",
-            source: { agent_id: sourceAgentId },
-            payload: {
-                agent_id: agentId,
-                session_id: sessionId,
-                task: options?.name ?? `[Fork of ${sourceAgentId}]`,
-                task_id: taskId,
-                parent: sourceAgent.parent ?? null,
-                role: sourceAgent.role ?? undefined,
-                team_instance: sourceAgent.team_instance ?? undefined,
-                config: {},
-                cwd,
-                metadata: { fork_of: sourceAgentId },
-            },
-        });
-        // Generate a human-readable name
-        const generatedName = uniqueNamesGenerator({
-            dictionaries: [adjectives, animals],
-            separator: "-",
-            length: 2,
-        });
-        eventStore.updateAgentMetadata(agentId, { name: generatedName });
-        await eventStore.persist();
-        // Get the provider session ID to fork from
-        let forkedProviderSessionId;
-        if (activeSession) {
-            // Active session: fork with flush to ensure data is persisted
-            const forkedSession = await activeSession.session.forkWithFlush();
-            forkedProviderSessionId = forkedSession.id;
-        }
-        else {
-            // Stopped agent: use the persisted provider session ID directly
-            forkedProviderSessionId = sourceAgent.provider_session_id;
-        }
-        // Spawn a new process
-        const handle = await AgentFactory.spawn(defaultAgentType, {
-            permissionMode: defaultPermissionMode,
-        });
-        try {
-            const macroAgentMcp = buildMacroAgentMcp({
-                agentId,
-                parentId: sourceAgent.parent ?? "",
-                taskId,
-                cwd,
-                permissionMode: defaultPermissionMode,
-                lineage: sourceAgent.lineage ?? [],
-                sessionId,
-            });
-            // Load the forked session on the new process with correct MCP config.
-            // Note: loadSession's TS type for mcpServers is { name, uri }[] but
-            // the underlying ACP protocol accepts full McpServerStdio. The JS
-            // implementation passes mcpServers through to the connection unchanged.
-            const session = await handle.loadSession(forkedProviderSessionId, cwd, [
-                macroAgentMcp,
-            ]);
-            // Emit started status with provider session ID
-            eventStore.emit({
-                type: "status",
-                source: { agent_id: agentId },
-                payload: {
-                    status_type: "started",
-                    summary: "Agent session started (forked)",
-                    provider_session_id: session.id,
-                },
-            });
-            await eventStore.persist();
-            // Set up message router subscriptions
-            messageRouter.setupDefaultSubscriptions({
-                agent_id: agentId,
-                parent_id: sourceAgent.parent ?? undefined,
-                task_id: taskId,
-                subscribe_parent: false,
-                additional_topics: [],
-                role: sourceAgent.role ?? undefined,
-            });
-            // Track active session
-            const newActiveSession = {
-                agentId,
-                handle,
-                session,
-                createdAt: Date.now(),
-                isPrompting: false,
-            };
-            activeSessions.set(agentId, newActiveSession);
-            const agent = eventStore.getAgent(agentId);
-            notifyLifecycle({ type: "spawned", agent });
-            notifyLifecycle({ type: "started", agent });
-            return {
-                id: agentId,
-                session_id: sessionId,
-                agent,
-                session,
-            };
-        }
-        catch (handleError) {
-            try {
-                await handle.close();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-            throw handleError;
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Queries
-    // ─────────────────────────────────────────────────────────────────
-    function get(agentId) {
-        return eventStore.getAgent(agentId);
-    }
-    function list(filter) {
-        let agents = eventStore.listAgents();
-        if (filter) {
-            if (filter.state) {
-                agents = agents.filter((a) => a.state === filter.state);
-            }
-            if (filter.parent !== undefined) {
-                agents = agents.filter((a) => a.parent === filter.parent);
-            }
-            if (filter.task_id) {
-                agents = agents.filter((a) => a.task_id === filter.task_id);
-            }
-            if (filter.headManagersOnly) {
-                agents = agents.filter((a) => a.parent === null);
-            }
-        }
-        return agents;
-    }
-    function getChildren(agentId) {
-        return eventStore.listAgents({ parent: agentId });
-    }
-    function getHierarchy(agentId, options) {
-        const agent = eventStore.getAgent(agentId);
-        if (!agent)
-            return null;
-        const maxDepth = options?.depth;
-        function buildNode(a, currentDepth) {
-            const shouldIncludeChildren = maxDepth === undefined || currentDepth < maxDepth;
-            const children = shouldIncludeChildren ? getChildren(a.id) : [];
-            return {
-                agent: a,
-                children: children.map((c) => buildNode(c, currentDepth + 1)),
-            };
-        }
-        const root = buildNode(agent, 1);
-        // Calculate depth and total agents
-        function calcDepth(node) {
-            if (node.children.length === 0)
-                return 1;
-            return 1 + Math.max(...node.children.map(calcDepth));
-        }
-        function countAgents(node) {
-            return 1 + node.children.reduce((sum, c) => sum + countAgents(c), 0);
-        }
-        return {
-            root,
-            depth: calcDepth(root),
-            totalAgents: countAgents(root),
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Head Manager
-    // ─────────────────────────────────────────────────────────────────
-    async function getOrCreateHeadManager(options) {
-        const { cwd, systemPrompt, permissionMode, topics = [], sessionId, forceNew = false, } = options;
-        // If not forcing new, attempt to resume an existing session
-        if (!forceNew) {
-            const headManagers = listHeadManagers()
-                .filter((h) => h.state === "running")
-                .sort((a, b) => {
-                // Sort by started_at descending, then by created_at descending as tiebreaker
-                const startDiff = (b.started_at ?? 0) - (a.started_at ?? 0);
-                if (startDiff !== 0)
-                    return startDiff;
-                return b.created_at - a.created_at;
-            });
-            if (sessionId) {
-                // Resume specific session by ID
-                const specific = headManagers.find((h) => h.session_id === sessionId);
-                if (specific && activeSessions.has(specific.id)) {
-                    const activeSession = activeSessions.get(specific.id);
-                    return {
-                        id: specific.id,
-                        session_id: specific.session_id,
-                        agent: specific,
-                        session: activeSession.session,
-                    };
-                }
-            }
-            else if (headManagers.length > 0) {
-                // Resume latest running session with active session
-                const latest = headManagers[0];
-                if (activeSessions.has(latest.id)) {
-                    const activeSession = activeSessions.get(latest.id);
-                    return {
-                        id: latest.id,
-                        session_id: latest.session_id,
-                        agent: latest,
-                        session: activeSession.session,
-                    };
-                }
-            }
-        }
-        // No existing session found or forceNew requested - create new
-        return spawn({
-            task: systemPrompt ??
-                "You are a head manager agent. Coordinate tasks and spawn child agents as needed.",
-            parent: null,
-            cwd,
-            permissionMode,
-            topics,
-            subscribeParent: false,
-        });
-    }
-    function listHeadManagers() {
-        return list({ headManagersOnly: true });
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Session Interaction
-    // ─────────────────────────────────────────────────────────────────
-    async function* prompt(agentId, message) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            throw new AgentManagerError(`No active session for agent: ${agentId}`, "SESSION_NOT_FOUND", agentId);
-        }
-        activeSession.isPrompting = true;
-        try {
-            for await (const update of activeSession.session.prompt(message)) {
-                yield update;
-            }
-        }
-        finally {
-            activeSession.isPrompting = false;
-        }
-    }
-    /**
-     * Prompt an agent and automatically follow up to ensure done() is called.
-     */
-    async function promptUntilDone(agentId, message, options) {
-        const maxFollowUps = options?.maxFollowUps ?? 2;
-        const throwOnMaxExceeded = options?.throwOnMaxExceeded ?? false;
-        const onUpdate = options?.onUpdate;
-        const allUpdates = [];
-        let followUpCount = 0;
-        // Helper to check if done() was called by looking for status events
-        // The done() MCP tool emits status events with status_type completed/failed
-        // and includes signal: "WORKER_DONE" in the details
-        const checkDoneCalled = async () => {
-            // Reload from disk to see events from MCP subprocess
-            await eventStore.reload();
-            const statusEvents = eventStore.query({ type: "status" });
-            // Look for status events from this agent that indicate completion
-            const agentCompletedStatus = statusEvents.find((e) => e.source?.agent_id === agentId &&
-                (e.payload?.status_type === "completed" ||
-                    e.payload?.status_type === "failed" ||
-                    e.payload?.details?.signal ===
-                        "WORKER_DONE"));
-            if (agentCompletedStatus) {
-                return {
-                    called: true,
-                    status: agentCompletedStatus.payload?.status_type,
-                };
-            }
-            return { called: false };
-        };
-        // Initial prompt
-        for await (const update of prompt(agentId, message)) {
-            allUpdates.push(update);
-            onUpdate?.(update);
-        }
-        // Check if done() was called
-        let doneResult = await checkDoneCalled();
-        if (doneResult.called) {
-            return {
-                doneCalled: true,
-                doneStatus: doneResult.status,
-                exceededMax: false,
-                followUpCount: 0,
-                updates: allUpdates,
-            };
-        }
-        // Follow-up prompts
-        const followUpMessages = [
-            `Your work appears complete, but you haven't called done() yet. Please call done() now with your completion status.
-
-Example: done({ status: "completed", summary: "Brief description of what you accomplished" })
-
-If you're blocked or need help, call: done({ status: "blocked", summary: "What you need help with" })`,
-            `IMPORTANT: You MUST call the done() tool to signal completion. This is required for proper cleanup.
-
-Call done() NOW with status "completed" if your work is finished, or "blocked" if you need assistance.`,
-        ];
-        for (let i = 0; i < maxFollowUps; i++) {
-            followUpCount++;
-            const followUpMessage = followUpMessages[Math.min(i, followUpMessages.length - 1)];
-            // Send follow-up prompt
-            for await (const update of prompt(agentId, followUpMessage)) {
-                allUpdates.push(update);
-                onUpdate?.(update);
-            }
-            // Check again
-            doneResult = await checkDoneCalled();
-            if (doneResult.called) {
-                return {
-                    doneCalled: true,
-                    doneStatus: doneResult.status,
-                    exceededMax: false,
-                    followUpCount,
-                    updates: allUpdates,
-                };
-            }
-        }
-        // done() was never called after max follow-ups
-        if (throwOnMaxExceeded) {
-            throw new Error(`Agent ${agentId} did not call done() after ${maxFollowUps} follow-up attempts. ` +
-                `Total prompts sent: ${1 + followUpCount}. Consider increasing maxFollowUps or investigating agent behavior.`);
-        }
-        return {
-            doneCalled: false,
-            exceededMax: true,
-            followUpCount,
-            updates: allUpdates,
-        };
-    }
-    function getSession(agentId) {
-        const activeSession = activeSessions.get(agentId);
-        return activeSession?.session ?? null;
-    }
-    function hasActiveSession(agentId) {
-        return activeSessions.has(agentId);
-    }
-    function isPrompting(agentId) {
-        const activeSession = activeSessions.get(agentId);
-        return activeSession?.isPrompting ?? false;
-    }
-    async function supportsInjection(agentId) {
-        const session = getSession(agentId);
-        if (!session) {
-            return false;
-        }
-        // Check if the session supports injection
-        // Uses acp-factory's supportsInject() which returns cached/estimated result
-        try {
-            return session.supportsInject();
-        }
-        catch {
-            return false;
-        }
-    }
-    function isProcessRunning(agentId) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            return false;
-        }
-        return activeSession.handle.isRunning();
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Permission Handling
-    // ─────────────────────────────────────────────────────────────────
-    function respondToPermission(agentId, requestId, optionId) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            console.warn(`[AgentManager] Cannot respond to permission: no active session for agent ${agentId}`);
-            return false;
-        }
-        try {
-            activeSession.session.respondToPermission(requestId, optionId);
-            console.log(`[AgentManager] Responded to permission ${requestId} for agent ${agentId} with ${optionId}`);
-            return true;
-        }
-        catch (err) {
-            console.error(`[AgentManager] Error responding to permission ${requestId}:`, err);
-            return false;
-        }
-    }
-    function cancelPermission(agentId, requestId) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            console.warn(`[AgentManager] Cannot cancel permission: no active session for agent ${agentId}`);
-            return false;
-        }
-        try {
-            activeSession.session.cancelPermission(requestId);
-            console.log(`[AgentManager] Cancelled permission ${requestId} for agent ${agentId}`);
-            return true;
-        }
-        catch (err) {
-            console.error(`[AgentManager] Error cancelling permission ${requestId}:`, err);
-            return false;
-        }
-    }
-    function setPermissionMode(agentId, mode) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            console.warn(`[AgentManager] Cannot set permission mode: no active session for agent ${agentId}`);
-            return false;
-        }
-        try {
-            activeSession.handle.setPermissionMode(mode);
-            console.log(`[AgentManager] Set permission mode for agent ${agentId} to ${mode}`);
-            return true;
-        }
-        catch (err) {
-            console.error(`[AgentManager] Error setting permission mode for agent ${agentId}:`, err);
-            return false;
-        }
-    }
-    function getPermissionMode(agentId) {
-        const activeSession = activeSessions.get(agentId);
-        if (!activeSession) {
-            return null;
-        }
-        return activeSession.handle.getPermissionMode();
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Lifecycle Callbacks
-    // ─────────────────────────────────────────────────────────────────
-    function onLifecycleEvent(callback) {
-        lifecycleListeners.add(callback);
-        return () => lifecycleListeners.delete(callback);
-    }
-    function notifyLifecycle(event) {
-        for (const listener of lifecycleListeners) {
-            try {
-                listener(event);
-            }
-            catch {
-                // Ignore listener errors
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // OpenTasks Socket Path (Late Binding)
-    // ─────────────────────────────────────────────────────────────────
-    function setOpenTasksSocketPath(socketPath) {
-        configOpenTasksSocketPath = socketPath;
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Mail Services (Late Binding)
-    // ─────────────────────────────────────────────────────────────────
-    function setMailServices(ms, cm) {
-        mailService = ms;
-        conversationMap = cm;
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Cleanup
-    // ─────────────────────────────────────────────────────────────────
-    async function close() {
-        // Prevent new spawns/resumes from racing with cleanup
-        isShuttingDown = true;
-        // Stop all health checks
-        if (healthCheckService) {
-            healthCheckService.stopAll();
-        }
-        // Close all active sessions
-        const closePromises = [];
-        for (const [agentId, session] of activeSessions) {
-            closePromises.push((async () => {
-                try {
-                    await session.handle.close();
-                }
-                catch {
-                    // Ignore errors during cleanup
-                }
-            })());
-        }
-        await Promise.all(closePromises);
-        activeSessions.clear();
-        lifecycleListeners.clear();
-    }
-    function setSpawnInterceptor(interceptor) {
-        spawnInterceptor = interceptor;
-    }
-    function getRoleRegistry() {
-        return roleRegistry;
-    }
-    /**
-     * Continue a terminated agent by spawning a new agent with the same
-     * role and task, injecting prior conversation context as a resume prefix.
-     */
-    async function continueAgent(agentId, options) {
-        const agent = eventStore.getAgent(agentId);
-        if (!agent) {
-            throw new AgentManagerError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", agentId);
-        }
-        // Build resume context from EventStore events
-        const maxMessages = options?.maxMessages ?? 50;
-        const events = eventStore.query({
-            type: "status",
-            source_agent_id: agentId,
-            limit: maxMessages,
-        });
-        // Format conversation turns as resume context
-        const contextLines = [];
-        if (options?.additionalContext) {
-            contextLines.push(options.additionalContext);
-        }
-        if (events.length > 0) {
-            contextLines.push("## Prior Session Context");
-            contextLines.push(`Continuing from agent ${agentId} (${events.length} events).`);
-            for (const event of events.slice(-20)) {
-                const summary = event.payload?.summary;
-                if (summary && typeof summary === "string") {
-                    contextLines.push(`- ${summary}`);
-                }
-            }
-        }
-        const resumeContext = contextLines.join("\n");
-        // Spawn a continuation agent with same role, task, and context
-        const taskDescription = options?.task ?? agent.task ?? `Continue work from ${agentId}`;
-        const newAgent = await spawn({
-            task: taskDescription,
-            role: agent.role,
-            parent: agent.parent ?? undefined,
-            cwd: agent.cwd ?? defaultCwd,
-            customPrompt: resumeContext || undefined,
-        });
-        // Emit continuation event
-        eventStore.emit({
-            type: "status",
-            source: { agent_id: newAgent.id },
-            payload: {
-                status_type: "started",
-                summary: `Continuation of agent ${agentId}`,
-                continuation_of: agentId,
-            },
-        });
-        return newAgent;
-    }
-    return {
-        spawn,
-        terminate,
-        resume,
-        continueAgent,
-        forkAgent,
-        get,
-        list,
-        getChildren,
-        getHierarchy,
-        getOrCreateHeadManager,
-        listHeadManagers,
-        prompt,
-        promptUntilDone,
-        getSession,
-        hasActiveSession,
-        isPrompting,
-        supportsInjection,
-        isProcessRunning,
-        respondToPermission,
-        cancelPermission,
-        setPermissionMode,
-        getPermissionMode,
-        onLifecycleEvent,
-        setSpawnInterceptor,
-        getRoleRegistry,
-        setOpenTasksSocketPath,
-        setMailServices,
-        close,
-    };
-}
-/**
- * Create a workspace for an agent based on their capabilities.
- *
- * Dispatches on workspace capabilities (workspace.stream, workspace.integrate,
- * workspace.worktree) rather than role names. This allows team-defined roles
- * (e.g., "developer" extending "worker") to get proper workspace allocation
- * by inheriting workspace capabilities from their base role.
- *
- * Falls back to role-name matching for backward compatibility when no
- * capabilities are provided.
- *
- * @param workspaceManager - WorkspaceManager instance
- * @param agentId - Agent ID
- * @param role - Agent role name (used for logging and fallback)
- * @param options - Workspace options including capabilities
- * @returns Created workspace or undefined
- */
-async function createWorkspaceForRole(workspaceManager, agentId, role, options) {
-    const { streamId, streamConfig, dataplaneTaskId, capabilities } = options;
-    // Capability-based dispatch (preferred — works for team-defined roles)
-    if (capabilities && capabilities.length > 0) {
-        if (capabilities.includes("workspace.stream")) {
-            // Coordinator pattern: create integration stream.
-            // In team mode, stream is managed by TeamRuntime.setupWorkspaceIntegration(),
-            // so missing streamConfig is expected — return silently.
-            if (!streamConfig) {
-                return undefined;
-            }
-            const newStreamId = workspaceManager.createIntegrationStream(agentId, streamConfig);
-            return workspaceManager.createCoordinatorWorkspace(agentId, newStreamId);
-        }
-        else if (capabilities.includes("workspace.integrate")) {
-            // Integrator pattern: join existing stream
-            if (!streamId) {
-                console.warn(`[AgentManager] ${role} ${agentId} has workspace.integrate but no streamId, skipping workspace`);
-                return undefined;
-            }
-            return workspaceManager.createIntegratorWorkspace(agentId, streamId);
-        }
-        else if (capabilities.includes("workspace.worktree")) {
-            // Worker pattern: create worktree in stream
-            if (!streamId) {
-                console.warn(`[AgentManager] ${role} ${agentId} has workspace.worktree but no streamId, skipping workspace`);
-                return undefined;
-            }
-            const taskId = dataplaneTaskId ?? agentId;
-            return workspaceManager.createWorkerWorkspace(agentId, taskId, streamId);
-        }
-        // Has capabilities but no workspace capability — no workspace needed
-        return undefined;
-    }
-    // Fallback: role-name dispatch (backward compatibility for non-team spawns)
-    switch (role) {
-        case "coordinator": {
-            if (!streamConfig) {
-                console.warn(`[AgentManager] Coordinator ${agentId} spawn missing streamConfig, skipping workspace`);
-                return undefined;
-            }
-            const newStreamId = workspaceManager.createIntegrationStream(agentId, streamConfig);
-            return workspaceManager.createCoordinatorWorkspace(agentId, newStreamId);
-        }
-        case "integrator": {
-            if (!streamId) {
-                console.warn(`[AgentManager] Integrator ${agentId} spawn missing streamId, skipping workspace`);
-                return undefined;
-            }
-            return workspaceManager.createIntegratorWorkspace(agentId, streamId);
-        }
-        case "worker":
-        case "worker.resolver": {
-            if (!streamId) {
-                console.warn(`[AgentManager] Worker ${agentId} spawn missing streamId, skipping workspace`);
-                return undefined;
-            }
-            const taskId = dataplaneTaskId ?? agentId;
-            return workspaceManager.createWorkerWorkspace(agentId, taskId, streamId);
-        }
-        case "monitor":
-            return undefined;
-        default:
-            return undefined;
-    }
-}
+export { createAgentManagerV2, createAgentManagerV2 as createAgentManager } from "./agent-manager-v2.js";
 //# sourceMappingURL=agent-manager.js.map