macro-agent 0.1.2 → 0.1.4

package/dist/teams/team-runtime-v2.js

@@ -0,0 +1,741 @@
+/**
+ * Team Runtime V2
+ *
+ * Rewired to use InboxAdapter for signal filtering/emission validation
+ * and TasksAdapter for scaling. Drops EventStore and MessageRouter dependencies.
+ *
+ * Key changes from V1:
+ * - Signal filter + emission validator installed on InboxAdapter (adapter-side)
+ * - No MERGE_REQUEST polling (handled by AgentManagerV2 terminate flow)
+ * - No EventStore team_config event (subsystems don't need cross-process discovery)
+ * - One inbox scope per team
+ *
+ * @module teams/team-runtime-v2
+ */
+import { WORKSPACE_CAPABILITIES } from "../roles/capabilities.js";
+// =============================================================================
+// Helper: Convert legacy manifest to resolved template
+// =============================================================================
+function manifestToResolved(manifest) {
+    return {
+        template: {
+            manifest: {
+                name: manifest.name,
+                description: manifest.description,
+                version: manifest.version,
+                roles: manifest.roles,
+                topology: manifest.topology,
+                communication: manifest.communication,
+            },
+            roles: new Map(),
+            prompts: new Map(),
+            mcpServers: manifest._mcpServers,
+            sourcePath: "",
+        },
+        resolvedRoles: manifest._resolvedRoles,
+        macroAgent: manifest.macro_agent,
+    };
+}
+function isMacroResolvedTemplate(input) {
+    return "template" in input && "resolvedRoles" in input;
+}
+// =============================================================================
+// TeamRuntimeV2
+// =============================================================================
+export class TeamRuntimeV2 {
+    services;
+    rootAgentId;
+    companionAgentIds = [];
+    roleRegistry;
+    lifecycleUnsubscribe;
+    integrationStrategy;
+    scalingTimer;
+    lastScaleUpTime = 0;
+    teamStreamId;
+    /** The resolved template */
+    resolved;
+    /** Legacy loaded prompts map */
+    loadedPrompts;
+    /** Role name → spawned agent ID */
+    roleAgentMap = new Map();
+    /** Per-agent signal filters from peer connections. Key: "fromAgentId→toAgentId" */
+    peerSignalFilters = new Map();
+    /** Agent ID → role name */
+    agentRoleMap = new Map();
+    /** Pre-computed per-role allowed signals */
+    roleAllowedSignals = new Map();
+    /** Pending peer routes for deferred wiring */
+    pendingPeerRoutes = [];
+    /** Lifecycle unsubscribe for deferred peer wiring */
+    peerWiringUnsubscribe;
+    constructor(input, services) {
+        this.services = services;
+        this.resolved = isMacroResolvedTemplate(input)
+            ? input
+            : manifestToResolved(input);
+        this.loadedPrompts = !isMacroResolvedTemplate(input)
+            ? input._loadedPrompts
+            : new Map();
+        this.roleRegistry = services.agentManager.getRoleRegistry();
+    }
+    // Convenience accessors
+    get manifest() {
+        return this.resolved.template.manifest;
+    }
+    get communication() {
+        return (this.manifest.communication ?? {});
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Initialization
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Wire team configuration: register roles, instantiate integration strategy.
+     *
+     * Drops EventStore team_config event — subsystems don't need cross-process
+     * discovery since messaging is in agent-inbox and tasks in opentasks.
+     */
+    async initialize(_options) {
+        // 1. Register team roles into RoleRegistry
+        for (const [, resolved] of this.resolved.resolvedRoles) {
+            const rd = resolved.roleDefinition;
+            const existing = this.roleRegistry.getRole(rd.name);
+            if (existing) {
+                const existingCaps = [...existing.capabilities].sort();
+                const newCaps = [...rd.capabilities].sort();
+                if (existingCaps.length !== newCaps.length ||
+                    existingCaps.some((c, i) => c !== newCaps[i])) {
+                    console.warn(`[TeamRuntimeV2] Role '${rd.name}' conflict: team '${this.manifest.name}' ` +
+                        `re-registers with different capabilities.`);
+                }
+            }
+            this.roleRegistry.registerRole(rd);
+        }
+        // 2. Instantiate integration strategy
+        try {
+            const { defaultStrategyRegistry } = await import("../workspace/strategies/registry.js");
+            const strategyName = this.resolved.macroAgent.integration?.strategy ?? "queue";
+            const strategyConfig = this.resolved.macroAgent.integration?.config ?? {};
+            this.integrationStrategy = defaultStrategyRegistry.get(strategyName, strategyConfig);
+            if (this.integrationStrategy.initialize) {
+                await this.integrationStrategy.initialize();
+            }
+            // Wire merge queue to queue strategy
+            if (this.services.workspaceManager &&
+                strategyName === "queue" &&
+                "setMergeQueue" in this.integrationStrategy) {
+                const mergeQueue = this.services.workspaceManager.getMergeQueue();
+                this.integrationStrategy.setMergeQueue(mergeQueue);
+            }
+        }
+        catch {
+            // Strategy instantiation is best-effort
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Bootstrap
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Spawn root and companion agents, build role mappings,
+     * compute signal filters.
+     *
+     * Drops MessageRouter peer wiring — agent-inbox handles message delivery.
+     * Peer signal filters are still computed for adapter-side enforcement.
+     */
+    async bootstrap() {
+        const { agentManager } = this.services;
+        const { topology } = this.manifest;
+        // 1. Spawn root agent (scope = team name)
+        const rootPrompt = this.getPromptForTopologyNode(topology.root);
+        const root = await agentManager.spawn({
+            task: rootPrompt
+                ? `[${this.manifest.name}] ${topology.root.role}`
+                : `Team ${this.manifest.name} root: ${topology.root.role}`,
+            parent: null,
+            role: topology.root.role,
+            config: {
+                model: topology.root.config?.model,
+            },
+            customPrompt: rootPrompt,
+            interactionPatterns: this.getInteractionPatterns(),
+            team_instance: this.manifest.name, // scope = team name
+        });
+        this.rootAgentId = root.id;
+        // 1b. Set up workspace integration
+        this.setupWorkspaceIntegration(root.id);
+        // 2. Spawn companions
+        const companionIds = [];
+        for (const companion of topology.companions ?? []) {
+            const companionPrompt = this.getPromptForTopologyNode(companion);
+            const agent = await agentManager.spawn({
+                task: `[${this.manifest.name}] ${companion.role}`,
+                parent: null,
+                role: companion.role,
+                config: {
+                    model: companion.config?.model,
+                },
+                customPrompt: companionPrompt,
+                interactionPatterns: this.getInteractionPatterns(),
+                team_instance: this.manifest.name,
+            });
+            companionIds.push(agent.id);
+        }
+        this.companionAgentIds = companionIds;
+        // 3. Build role↔agent mappings
+        this.roleAgentMap.set(topology.root.role, root.id);
+        this.agentRoleMap.set(root.id, topology.root.role);
+        for (let i = 0; i < (topology.companions ?? []).length; i++) {
+            const role = topology.companions[i].role;
+            this.roleAgentMap.set(role, companionIds[i]);
+            this.agentRoleMap.set(companionIds[i], role);
+        }
+        // 4. Compute peer signal filters (for adapter-side enforcement)
+        this.computePeerSignalFilters();
+        // 5. Pre-compute role allowed signals
+        this.computeRoleAllowedSignals();
+        // 6. Continuation monitoring
+        this.monitorContinuations();
+        // 7. Auto-scaling
+        this.monitorScaling();
+        return { rootId: root.id, companionIds };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Teardown
+    // ─────────────────────────────────────────────────────────────
+    async teardown() {
+        if (this.lifecycleUnsubscribe) {
+            this.lifecycleUnsubscribe();
+            this.lifecycleUnsubscribe = undefined;
+        }
+        if (this.peerWiringUnsubscribe) {
+            this.peerWiringUnsubscribe();
+            this.peerWiringUnsubscribe = undefined;
+        }
+        if (this.scalingTimer) {
+            clearInterval(this.scalingTimer);
+            this.scalingTimer = undefined;
+        }
+        if (this.integrationStrategy?.close) {
+            try {
+                await this.integrationStrategy.close();
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Getters
+    // ─────────────────────────────────────────────────────────────
+    getTaskMode() {
+        return this.resolved.macroAgent.task_assignment?.mode ?? "push";
+    }
+    getStrategyName() {
+        return this.resolved.macroAgent.integration?.strategy ?? "queue";
+    }
+    getManifest() {
+        return {
+            ...this.manifest,
+            description: this.manifest.description ?? "",
+            communication: this.communication,
+            macro_agent: this.resolved.macroAgent,
+            _resolvedRoles: this.resolved.resolvedRoles,
+            _loadedPrompts: this.loadedPrompts,
+            _mcpServers: this.resolved.template.mcpServers,
+        };
+    }
+    getResolvedTemplate() {
+        return this.resolved;
+    }
+    getRootAgentId() {
+        return this.rootAgentId;
+    }
+    getCompanionAgentIds() {
+        return [...this.companionAgentIds];
+    }
+    getIntegrationStrategy() {
+        return this.integrationStrategy;
+    }
+    getTeamStreamId() {
+        return this.teamStreamId;
+    }
+    getPeerSignalFilters() {
+        return this.peerSignalFilters;
+    }
+    getAgentRoleMap() {
+        return this.agentRoleMap;
+    }
+    /**
+     * Register an agent's role mapping (dynamic spawn tracking).
+     *
+     * NOTE: roleAgentMap is 1:1 (last writer wins). This is fine for bootstrap
+     * agents (one per role) and peer route wiring. Dynamic workers with the
+     * same role will overwrite each other here, but that's acceptable because
+     * dynamic lookup uses agentRoleMap (agent→role) not roleAgentMap (role→agent).
+     * If multi-instance role→agent resolution is needed in the future, change
+     * roleAgentMap to Map<string, Set<AgentId>>.
+     */
+    registerAgent(agentId, roleName) {
+        this.agentRoleMap.set(agentId, roleName);
+        this.roleAgentMap.set(roleName, agentId);
+    }
+    hasAgent(agentId) {
+        return this.agentRoleMap.has(agentId);
+    }
+    /** Get the team's inbox scope (= team name) */
+    getScope() {
+        return this.manifest.name;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Signal Filter + Emission Validator (adapter-side)
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Create a signal filter for the InboxAdapter.
+     *
+     * Same logic as V1 but returns a SignalFilterFn (adapter type)
+     * instead of a MessageRouter SignalFilter.
+     */
+    createSignalFilter() {
+        return (from, to, message) => {
+            // Extract signal from message content
+            const signal = this.extractSignal(message);
+            if (!signal)
+                return true; // No signal → allow
+            // Check peer connection filter (directional: from→to)
+            const peerFilter = this.peerSignalFilters.get(`${from}→${to}`);
+            if (peerFilter) {
+                return peerFilter.includes(signal);
+            }
+            // Check channel subscription filter for recipient's role
+            const recipientRole = this.agentRoleMap.get(to);
+            if (recipientRole) {
+                const allowed = this.roleAllowedSignals.get(recipientRole);
+                if (allowed && allowed !== "all") {
+                    return allowed.has(signal);
+                }
+            }
+            return true; // No filter → allow
+        };
+    }
+    /**
+     * Create an emission validator for the InboxAdapter.
+     *
+     * Returns a rejection reason string (or null to allow).
+     */
+    createEmissionValidator() {
+        const emissions = this.communication.emissions;
+        const enforcement = this.communication.enforcement ?? "permissive";
+        if (!emissions || Object.keys(emissions).length === 0) {
+            return () => null; // No emissions config → allow all
+        }
+        return (from, message) => {
+            const signal = this.extractSignal(message);
+            if (!signal)
+                return null; // No signal → allow
+            const role = this.agentRoleMap.get(from);
+            if (!role)
+                return null; // Not a team agent → allow
+            const allowedSignals = emissions[role];
+            if (!allowedSignals)
+                return null; // No restrictions for this role
+            if (allowedSignals.includes(signal))
+                return null; // Allowed
+            const reason = `Agent '${from}' (role: ${role}) emitted disallowed signal '${signal}'. ` +
+                `Allowed: [${allowedSignals.join(", ")}]`;
+            if (enforcement === "strict")
+                return reason;
+            if (enforcement === "permissive") {
+                console.warn(`[TeamRuntimeV2] ${reason}`);
+                return null; // Warn but allow
+            }
+            return null; // audit → allow with logging
+        };
+    }
+    /**
+     * Install signal filter and emission validator on the InboxAdapter.
+     *
+     * Uses addSignalFilter/addEmissionValidator with team name as ID
+     * so multiple teams can coexist without overwriting each other.
+     * Also installs spawn interceptor on the AgentManager.
+     */
+    installOnServices() {
+        const { agentManager, inboxAdapter } = this.services;
+        agentManager.setSpawnInterceptor(this.createSpawnInterceptor());
+        inboxAdapter.addSignalFilter(this.manifest.name, this.createSignalFilter());
+        inboxAdapter.addEmissionValidator(this.manifest.name, this.createEmissionValidator());
+    }
+    uninstallFromServices() {
+        this.services.agentManager.setSpawnInterceptor(null);
+        this.services.inboxAdapter.removeSignalFilter(this.manifest.name);
+        this.services.inboxAdapter.removeEmissionValidator(this.manifest.name);
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Spawn Interceptor
+    // ─────────────────────────────────────────────────────────────
+    createSpawnInterceptor() {
+        return (options) => {
+            const roleName = options.role;
+            if (!roleName)
+                return options;
+            const resolved = this.resolved.resolvedRoles.get(roleName);
+            if (!resolved)
+                return options;
+            const teamTopics = this.getTopicsForRole(roleName);
+            const teamMcpServers = this.getMcpServersForRole(roleName);
+            const teamPrompt = this.getPromptForRole(roleName);
+            const teamEnv = {
+                MACRO_TEAM_NAME: this.manifest.name,
+                MACRO_TASK_MODE: this.getTaskMode(),
+            };
+            const strategyName = this.getStrategyName();
+            if (strategyName) {
+                teamEnv.MACRO_INTEGRATION_STRATEGY = strategyName;
+            }
+            // Workspace injection
+            const capabilities = resolved.capabilities;
+            let streamId = options.streamId;
+            let streamConfig = options.streamConfig;
+            let dataplaneTaskId = options.dataplaneTaskId;
+            if (this.teamStreamId && capabilities) {
+                if (capabilities.includes(WORKSPACE_CAPABILITIES.WORKTREE)) {
+                    streamId = streamId ?? this.teamStreamId;
+                    dataplaneTaskId = dataplaneTaskId ?? `worker-${Date.now()}`;
+                }
+                else if (capabilities.includes(WORKSPACE_CAPABILITIES.INTEGRATE)) {
+                    streamId = streamId ?? this.teamStreamId;
+                }
+            }
+            return {
+                ...options,
+                streamId,
+                streamConfig,
+                dataplaneTaskId,
+                capabilities: capabilities ?? options.capabilities,
+                // Set team scope on all team agents
+                team_instance: options.team_instance ?? this.manifest.name,
+                topics: [...(options.topics ?? []), ...teamTopics],
+                config: {
+                    ...options.config,
+                    mcpServers: [
+                        ...(options.config?.mcpServers ?? []),
+                        ...teamMcpServers.map((s) => ({
+                            name: s.name,
+                            command: s.command,
+                            args: s.args,
+                            env: s.env,
+                        })),
+                    ],
+                    env: {
+                        ...options.config?.env,
+                        ...teamEnv,
+                    },
+                },
+                customPrompt: options.customPrompt ?? teamPrompt,
+                interactionPatterns: options.interactionPatterns ?? this.getInteractionPatterns(),
+            };
+        };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Communication Helpers
+    // ─────────────────────────────────────────────────────────────
+    getTopicsForRole(roleName) {
+        const topics = [];
+        const subs = this.communication.subscriptions?.[roleName] ?? [];
+        for (const sub of subs) {
+            if (!topics.includes(sub.channel)) {
+                topics.push(sub.channel);
+            }
+        }
+        return topics;
+    }
+    getMcpServersForRole(roleName) {
+        return this.resolved.template.mcpServers.get(roleName) ?? [];
+    }
+    getPromptForRole(roleName) {
+        const resolved = this.resolved.resolvedRoles.get(roleName);
+        if (!resolved?.prompt)
+            return undefined;
+        return this.loadedPrompts.get(resolved.prompt);
+    }
+    getPromptForTopologyNode(node) {
+        if (node.prompt)
+            return this.loadedPrompts.get(node.prompt);
+        return this.getPromptForRole(node.role);
+    }
+    getInteractionPatterns() {
+        const patterns = [];
+        const taskMode = this.getTaskMode();
+        if (taskMode === "pull") {
+            const pullConfig = this.resolved.macroAgent.task_assignment?.pull;
+            const idleTimeout = pullConfig?.idle_timeout_s ?? 300;
+            patterns.push(`## Task Claiming
+
+You operate in PULL mode. After completing a task:
+1. Call done() with your results
+2. Call claim_task() to get your next task
+3. If no tasks available, wait briefly and retry
+4. After ${idleTimeout} seconds idle, call done() to exit gracefully
+
+Claim and execute independently — do not wait for instructions.`);
+        }
+        const strategy = this.getStrategyName();
+        if (strategy === "trunk") {
+            patterns.push(`## Integration
+
+Your changes are integrated via trunk-based development. When you call done(),
+your work is pushed directly to the integration branch. If there's a conflict,
+the system will rebase and retry automatically. Write small, focused changes
+to minimize conflict probability.`);
+        }
+        else if (strategy === "optimistic") {
+            patterns.push(`## Integration
+
+Your changes are integrated optimistically. They are pushed immediately and
+validated asynchronously. If validation fails, a fixup task will be created.
+Focus on correctness — your changes go live immediately.`);
+        }
+        return patterns;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Internal: Signal and peer filter computation
+    // ─────────────────────────────────────────────────────────────
+    /**
+     * Extract signal name from a message. Looks at event-type messages
+     * and thread tags for signal identification.
+     */
+    extractSignal(message) {
+        const content = message.content;
+        if (!content)
+            return undefined;
+        // Event messages carry signal in event field
+        if (content.type === "event" && content.event) {
+            return content.event;
+        }
+        // Check metadata for signal field
+        if (message.metadata?.signal) {
+            return message.metadata.signal;
+        }
+        return undefined;
+    }
+    /**
+     * Compute peer signal filters from routing.peers config.
+     * These are directional: from→to with specific allowed signals.
+     */
+    computePeerSignalFilters() {
+        const peers = this.communication.routing?.peers;
+        if (!peers)
+            return;
+        for (const peer of peers) {
+            const fromAgent = this.roleAgentMap.get(peer.from);
+            const toAgent = this.roleAgentMap.get(peer.to);
+            if (!fromAgent || !toAgent) {
+                this.pendingPeerRoutes.push(peer);
+                continue;
+            }
+            if (peer.signals && peer.signals.length > 0) {
+                this.peerSignalFilters.set(`${fromAgent}→${toAgent}`, peer.signals);
+            }
+        }
+        // Set up deferred wiring for peers not yet spawned
+        if (this.pendingPeerRoutes.length > 0) {
+            this.setupDeferredPeerWiring();
+        }
+    }
+    setupDeferredPeerWiring() {
+        const { agentManager } = this.services;
+        this.peerWiringUnsubscribe = agentManager.onLifecycleEvent((event) => {
+            if (event.type !== "spawned")
+                return;
+            const remaining = [];
+            for (const peer of this.pendingPeerRoutes) {
+                const fromAgent = this.roleAgentMap.get(peer.from);
+                const toAgent = this.roleAgentMap.get(peer.to);
+                if (fromAgent && toAgent) {
+                    if (peer.signals && peer.signals.length > 0) {
+                        this.peerSignalFilters.set(`${fromAgent}→${toAgent}`, peer.signals);
+                    }
+                }
+                else {
+                    remaining.push(peer);
+                }
+            }
+            this.pendingPeerRoutes = remaining;
+            if (remaining.length === 0 && this.peerWiringUnsubscribe) {
+                this.peerWiringUnsubscribe();
+                this.peerWiringUnsubscribe = undefined;
+            }
+        });
+    }
+    computeRoleAllowedSignals() {
+        this.roleAllowedSignals.clear();
+        for (const [roleName, subs] of Object.entries(this.communication.subscriptions ?? {})) {
+            let allowed = new Set();
+            for (const sub of subs) {
+                if (!sub.signals || sub.signals.length === 0) {
+                    allowed = "all";
+                    break;
+                }
+                for (const sig of sub.signals) {
+                    allowed.add(sig);
+                }
+            }
+            this.roleAllowedSignals.set(roleName, allowed);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Continuation Monitoring
+    // ─────────────────────────────────────────────────────────────
+    monitorContinuations() {
+        const lifecycleConfig = this.resolved.macroAgent.lifecycle;
+        if (!lifecycleConfig?.continuations?.enabled)
+            return;
+        const { agentManager } = this.services;
+        const monitoredAgents = new Set([
+            this.rootAgentId,
+            ...this.companionAgentIds,
+        ]);
+        this.lifecycleUnsubscribe = agentManager.onLifecycleEvent((event) => {
+            if (event.type !== "stopped")
+                return;
+            if (!monitoredAgents.has(event.agent.id))
+                return;
+            const reason = event.reason;
+            if (reason === "completed" || reason === "cancelled")
+                return;
+            setTimeout(async () => {
+                try {
+                    const newAgent = await agentManager.continueAgent(event.agent.id);
+                    monitoredAgents.delete(event.agent.id);
+                    monitoredAgents.add(newAgent.id);
+                    if (event.agent.id === this.rootAgentId) {
+                        this.rootAgentId = newAgent.id;
+                    }
+                    else {
+                        const idx = this.companionAgentIds.indexOf(event.agent.id);
+                        if (idx >= 0)
+                            this.companionAgentIds[idx] = newAgent.id;
+                    }
+                }
+                catch {
+                    // Failed to continue
+                }
+            }, 1000);
+        });
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Auto-Scaling (uses TasksAdapter instead of TaskBackend)
+    // ─────────────────────────────────────────────────────────────
+    static SCALE_COOLDOWN_MS = 10_000;
+    static SCALE_CHECK_INTERVAL_MS = 5_000;
+    monitorScaling() {
+        const scalingConfig = this.resolved.macroAgent.lifecycle?.scaling;
+        if (!scalingConfig || scalingConfig.scale_on !== "task_queue_depth")
+            return;
+        const { tasksAdapter, agentManager } = this.services;
+        if (!tasksAdapter.connected)
+            return;
+        const maxWorkers = scalingConfig.max_workers ?? Infinity;
+        const workerRoleNames = new Set();
+        for (const [name, resolved] of this.resolved.resolvedRoles) {
+            if (resolved.baseRole === "worker") {
+                workerRoleNames.add(name);
+            }
+        }
+        if (workerRoleNames.size === 0)
+            return;
+        const spawnRole = [...workerRoleNames][0];
+        this.scalingTimer = setInterval(async () => {
+            try {
+                const claimable = await tasksAdapter.listClaimable();
+                const pendingCount = claimable.length;
+                const allAgents = agentManager.list({ state: "running" });
+                let activeWorkers = 0;
+                for (const agent of allAgents) {
+                    if (agent.role &&
+                        workerRoleNames.has(agent.role) &&
+                        this.agentRoleMap.has(agent.id)) {
+                        activeWorkers++;
+                    }
+                }
+                if (pendingCount > activeWorkers &&
+                    activeWorkers < maxWorkers) {
+                    const now = Date.now();
+                    if (now - this.lastScaleUpTime < TeamRuntimeV2.SCALE_COOLDOWN_MS) {
+                        return;
+                    }
+                    if (!this.rootAgentId)
+                        return;
+                    try {
+                        await agentManager.spawn({
+                            task: `[${this.manifest.name}] auto-scaled ${spawnRole}`,
+                            role: spawnRole,
+                            parent: this.rootAgentId,
+                        });
+                        this.lastScaleUpTime = now;
+                    }
+                    catch {
+                        // Will retry next tick
+                    }
+                }
+            }
+            catch {
+                // Best-effort
+            }
+        }, TeamRuntimeV2.SCALE_CHECK_INTERVAL_MS);
+        if (this.scalingTimer.unref) {
+            this.scalingTimer.unref();
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Workspace Integration (simplified — no merge request polling)
+    // ─────────────────────────────────────────────────────────────
+    setupWorkspaceIntegration(rootAgentId) {
+        const { workspaceManager } = this.services;
+        if (!workspaceManager || !this.integrationStrategy)
+            return;
+        try {
+            this.teamStreamId = workspaceManager.createIntegrationStream(rootAgentId, { name: this.manifest.name, forkFrom: "main" });
+        }
+        catch {
+            return; // Workspace isolation unavailable
+        }
+        // Subscribe to merge queue events — wake integrator on mr:submitted
+        try {
+            const mergeQueue = workspaceManager.getMergeQueue();
+            if (mergeQueue?.onEvent) {
+                mergeQueue.onEvent((event) => {
+                    if (event.type !== "mr:submitted")
+                        return;
+                    for (const [agentId, roleName] of this.agentRoleMap) {
+                        const resolved = this.resolved.resolvedRoles.get(roleName);
+                        const caps = resolved?.capabilities ?? [];
+                        if (caps.includes(WORKSPACE_CAPABILITIES.INTEGRATE)) {
+                            try {
+                                // prompt() returns AsyncIterable — drain in background (fire-and-forget)
+                                const iter = this.services.agentManager.prompt(agentId, `Merge request submitted. Process the merge queue.`);
+                                (async () => {
+                                    try {
+                                        for await (const _ of iter) { /* drain */ }
+                                    }
+                                    catch {
+                                        // Best-effort wake — ignore errors
+                                    }
+                                })();
+                            }
+                            catch {
+                                // Best-effort wake
+                            }
+                            break;
+                        }
+                    }
+                });
+            }
+        }
+        catch {
+            // Merge queue not available
+        }
+        // NOTE: No merge request polling. AgentManagerV2.terminate() handles
+        // merge request submission directly when a worker with a workspace
+        // completes. This eliminates the 2-second EventStore polling loop.
+    }
+}
+//# sourceMappingURL=team-runtime-v2.js.map