macro-agent 0.1.2 → 0.1.3

package/dist/router/message-router.js

@@ -1,903 +0,0 @@
-/**
- * MessageRouter - Core Internal Message Routing Service
- *
- * ## Routing Architecture
- *
- * MessageRouter is the **core internal routing authority** for macro-agent.
- * It handles all message delivery between internal agents.
- *
- * ```
- * External → MAPAdapter/TriggerRouter → MessageRouter → EventStore
- *            (protocol translation)     (routing logic)   (persistence)
- * ```
- *
- * **Three routing entry points exist:**
- *
- * 1. **MessageRouter** (this module)
- *    - Internal routing for agent-to-agent communication
- *    - Supports: send(), sendToAddress(), emitStatus()
- *    - Used by: AgentManager, MCP tools, internal components
- *
- * 2. **MAPAdapter** (src/map/adapter/)
- *    - External MAP protocol interface for clients/agents/gateways
- *    - Translates MAP protocol → internal routing
- *    - Delegates message delivery to MessageRouter
- *
- * 3. **TriggerRouter** (src/trigger/router/)
- *    - External event routing (webhooks, cron, system events)
- *    - Queues events for batch delivery
- *    - Uses WakeManager for delivery scheduling
- *
- * ## Supported Routing Methods
- *
- * **Legacy Channel-based** (send, sendMessage):
- * - Direct agent, task, topic, lineage, subtree, broadcast
- *
- * **MAP Address-based** (sendToAddress):
- * - Agent, agents, task, scope, role, broadcast, hierarchical, federated
- *
- * @module router/message-router
- */
-import { nanoid } from "nanoid";
-import { AddressRoutingError, DEFAULT_TRUNCATION_CONFIG } from "./types.js";
-import { resolveBroadcastTarget, } from "./broadcast.js";
-import { resolveRoleTarget, } from "./role-resolver.js";
-import { getWakeDecisionWithHint, } from "./wake.js";
-import { isAgentAddress, isAgentsAddress, isScopeAddress, isRoleAddress, isTaskAddress, isBroadcastAddress, isHierarchicalAddress, isFederatedAddress, describeAddress, } from "../map/types.js";
-import { getSystemFromAddress } from "../map/federation/federation-handler.js";
-import { resolveHierarchicalAddress, } from "./address-resolver.js";
-/**
- * Create a MessageRouter instance
- */
-export function createMessageRouter(eventStore, config = {}) {
-    const truncationConfig = config.truncation ?? DEFAULT_TRUNCATION_CONFIG;
-    const agentSpawner = config.agentSpawner;
-    const agentSessionChecker = config.agentSessionChecker;
-    const sessionChecker = config.sessionChecker;
-    const wakeHandler = config.wakeHandler;
-    const federationHandler = config.federationHandler;
-    // Turn recorder for conversation tracking (late-bound)
-    let turnRecorder;
-    // Signal filter for status notification delivery (late-bound)
-    let signalFilter;
-    // Emission validator for outbound status events (late-bound)
-    let emissionValidator;
-    // Track acknowledged messages: Map<agentId, Set<messageId>>
-    const acknowledgedMessages = new Map();
-    // ─────────────────────────────────────────────────────────────────
-    // Message Operations
-    // ─────────────────────────────────────────────────────────────────
-    /**
-     * Send a message using MAP Address-based routing.
-     */
-    async function sendToAddress(request) {
-        const { from, to, content, options = {} } = request;
-        const { priority = "normal", delivery, correlationId } = options;
-        // Handle hierarchical addresses using the resolver
-        if (isHierarchicalAddress(to)) {
-            return sendToHierarchicalAddress(from, to, content, options);
-        }
-        // Handle multi-agent addresses (not legacy compatible, handle directly)
-        if (isAgentsAddress(to)) {
-            return sendToMultipleAgents(from, to, content, options);
-        }
-        // Handle federated addresses (cross-system routing)
-        if (isFederatedAddress(to)) {
-            if (!federationHandler) {
-                throw new AddressRoutingError("Federation not configured for cross-system messaging", "FEDERATION_NOT_AVAILABLE", to);
-            }
-            const systemId = getSystemFromAddress(to);
-            if (!federationHandler.isConnected(systemId)) {
-                throw new AddressRoutingError(`Not connected to federated system: ${systemId}`, "FEDERATION_NOT_AVAILABLE", to, { systemId });
-            }
-            // Send via federation handler
-            await federationHandler.sendMessage(systemId, {
-                type: "map/send",
-                from,
-                to,
-                content,
-                options,
-            });
-            // Return result (no delivery confirmation for federated messages)
-            return {
-                id: `fed-${nanoid()}`,
-                from,
-                to,
-                content,
-                timestamp: Date.now(),
-                delivered: [], // Cannot confirm delivery for federated messages
-                correlationId,
-            };
-        }
-        // Handle remaining address types directly
-        const delivered = [];
-        if (isAgentAddress(to)) {
-            // Direct agent address
-            const agent = eventStore.getAgent(to.agent);
-            if (!agent) {
-                throw new AddressRoutingError(`Agent not found: ${to.agent}`, "AGENT_NOT_FOUND", to);
-            }
-            const event = eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    agent_id: to.agent,
-                    address: to,
-                    delivered: [to.agent],
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                },
-            });
-            // Handle wake decision
-            if (sessionChecker && wakeHandler) {
-                const decision = getWakeDecisionWithHint(to.agent, { priority: priority, deliveryHint: delivery }, sessionChecker);
-                if (decision.shouldWake || decision.shouldInterrupt) {
-                    wakeHandler(to.agent, decision, event.id);
-                }
-            }
-            delivered.push(to.agent);
-            // Record turn for conversation tracking
-            if (turnRecorder) {
-                try {
-                    turnRecorder({ from, toAgent: to.agent, content, messageId: event.id, addressType: "agent" });
-                }
-                catch {
-                    // Never fail delivery due to turn recording
-                }
-            }
-            return {
-                id: event.id,
-                from,
-                to,
-                content,
-                timestamp: event.timestamp,
-                delivered,
-                correlationId,
-            };
-        }
-        if (isTaskAddress(to)) {
-            // Task address - resolve to assigned agent
-            const task = eventStore.getTask(to.task);
-            if (!task) {
-                throw new AddressRoutingError(`Task not found: ${to.task}`, "TASK_NOT_FOUND", to);
-            }
-            let targetAgentId;
-            if (!task.assigned_agent) {
-                // Try to spawn an agent for unassigned task
-                if (!agentSpawner) {
-                    throw new AddressRoutingError(`Task ${to.task} has no assigned agent`, "TASK_UNASSIGNED", to);
-                }
-                const result = await agentSpawner(to.task, task.description);
-                targetAgentId = result.agent_id;
-            }
-            else {
-                targetAgentId = task.assigned_agent;
-            }
-            const event = eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    agent_id: targetAgentId,
-                    address: to,
-                    delivered: [targetAgentId],
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                    original_target: { task: to.task },
-                },
-            });
-            // Handle wake decision
-            if (sessionChecker && wakeHandler) {
-                const decision = getWakeDecisionWithHint(targetAgentId, { priority: priority, deliveryHint: delivery }, sessionChecker);
-                if (decision.shouldWake || decision.shouldInterrupt) {
-                    wakeHandler(targetAgentId, decision, event.id);
-                }
-            }
-            delivered.push(targetAgentId);
-            // Record turn for conversation tracking
-            if (turnRecorder) {
-                try {
-                    turnRecorder({ from, toAgent: targetAgentId, content, messageId: event.id, addressType: "task" });
-                }
-                catch {
-                    // Never fail delivery due to turn recording
-                }
-            }
-            return {
-                id: event.id,
-                from,
-                to,
-                content,
-                timestamp: event.timestamp,
-                delivered,
-                correlationId,
-            };
-        }
-        if (isScopeAddress(to)) {
-            // Scope address - route to topic subscribers
-            const subscribers = eventStore.getSubscribers({
-                type: "topic",
-                target: to.scope,
-            });
-            if (subscribers.length === 0) {
-                throw new AddressRoutingError(`Scope has no subscribers: ${to.scope}`, "NO_RECIPIENTS", to);
-            }
-            const event = eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    topic: to.scope,
-                    address: to,
-                    delivered: subscribers,
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                },
-            });
-            // Handle wake decisions for each subscriber
-            // Note: The EventStore already fans out to subscribers via target.topic routing,
-            // so we don't emit separate events here (that would cause duplicate messages)
-            for (const subscriberId of subscribers) {
-                if (sessionChecker && wakeHandler) {
-                    const decision = getWakeDecisionWithHint(subscriberId, { priority: priority, deliveryHint: delivery }, sessionChecker);
-                    if (decision.shouldWake || decision.shouldInterrupt) {
-                        wakeHandler(subscriberId, decision, event.id);
-                    }
-                }
-                delivered.push(subscriberId);
-            }
-            return {
-                id: event.id,
-                from,
-                to,
-                content,
-                timestamp: event.timestamp,
-                delivered,
-                correlationId,
-            };
-        }
-        if (isRoleAddress(to)) {
-            // Role address - resolve to matching agents
-            const agentSource = {
-                listAgents: () => eventStore.listAgents(),
-                getAgent: (id) => eventStore.getAgent(id),
-                // Get agents subscribed to a scope/topic
-                getScopeMembers: (scope) => {
-                    return eventStore.getSubscribers({ type: "topic", target: scope });
-                },
-            };
-            const recipientIds = resolveRoleTarget(agentSource, {
-                role: to.role,
-                // RoleAddress.within is a ScopeId (subscription-based), not a coordinatorId (hierarchy-based)
-                scope: to.within,
-            });
-            if (recipientIds.length === 0) {
-                throw new AddressRoutingError(`No agents found for role: ${to.role}${to.within ? ` within ${to.within}` : ""}`, "NO_RECIPIENTS", to);
-            }
-            const event = eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    address: to,
-                    delivered: recipientIds,
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                    multicast: {
-                        type: "role",
-                        role: to.role,
-                        coordinatorId: to.within,
-                        recipientCount: recipientIds.length,
-                    },
-                },
-            });
-            // Fan out to each recipient
-            for (const recipientId of recipientIds) {
-                eventStore.emit({
-                    type: "message",
-                    source: { agent_id: from },
-                    target: {
-                        agent_id: recipientId,
-                        address: { agent: recipientId },
-                    },
-                    payload: {
-                        content,
-                        correlation_id: correlationId,
-                        priority,
-                        delivery_hint: delivery,
-                        via: "role",
-                        original_message_id: event.id,
-                    },
-                });
-                // Handle wake decision
-                if (sessionChecker && wakeHandler) {
-                    const decision = getWakeDecisionWithHint(recipientId, { priority: priority, deliveryHint: delivery }, sessionChecker);
-                    if (decision.shouldWake || decision.shouldInterrupt) {
-                        wakeHandler(recipientId, decision, event.id);
-                    }
-                }
-                delivered.push(recipientId);
-            }
-            return {
-                id: event.id,
-                from,
-                to,
-                content,
-                timestamp: event.timestamp,
-                delivered,
-                correlationId,
-            };
-        }
-        if (isBroadcastAddress(to)) {
-            // Broadcast to all agents
-            const agentSource = {
-                listAgents: () => eventStore.listAgents(),
-            };
-            const recipientIds = resolveBroadcastTarget(agentSource, { scope: "all" });
-            const event = eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    address: to,
-                    delivered: recipientIds,
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                    multicast: {
-                        type: "broadcast",
-                        scope: "all",
-                        recipientCount: recipientIds.length,
-                    },
-                },
-            });
-            // Fan out to each recipient
-            for (const recipientId of recipientIds) {
-                eventStore.emit({
-                    type: "message",
-                    source: { agent_id: from },
-                    target: {
-                        agent_id: recipientId,
-                        address: { agent: recipientId },
-                    },
-                    payload: {
-                        content,
-                        correlation_id: correlationId,
-                        priority,
-                        delivery_hint: delivery,
-                        via: "broadcast",
-                        original_message_id: event.id,
-                    },
-                });
-                // Handle wake decision
-                if (sessionChecker && wakeHandler) {
-                    const decision = getWakeDecisionWithHint(recipientId, { priority: priority, deliveryHint: delivery }, sessionChecker);
-                    if (decision.shouldWake || decision.shouldInterrupt) {
-                        wakeHandler(recipientId, decision, event.id);
-                    }
-                }
-                delivered.push(recipientId);
-            }
-            return {
-                id: event.id,
-                from,
-                to,
-                content,
-                timestamp: event.timestamp,
-                delivered,
-                correlationId,
-            };
-        }
-        // Should not reach here for legacy-compatible addresses
-        throw new AddressRoutingError(`Unhandled address type: ${describeAddress(to)}`, "ADDRESS_NOT_SUPPORTED", to);
-    }
-    /**
-     * Send a message to a hierarchical address (parent, children, ancestors, descendants, siblings).
-     * Uses the address resolver to convert the relative address to concrete agent IDs.
-     */
-    async function sendToHierarchicalAddress(from, to, content, options = {}) {
-        const { priority = "normal", delivery, correlationId } = options;
-        const delivered = [];
-        // Create hierarchy source from EventStore
-        const hierarchySource = {
-            getAgent: (id) => {
-                const agent = eventStore.getAgent(id);
-                if (!agent)
-                    return undefined;
-                return {
-                    id: agent.id,
-                    parent: agent.parent ?? undefined,
-                    lineage: agent.lineage,
-                    state: agent.state,
-                };
-            },
-            listAgents: () => eventStore.listAgents().map((agent) => ({
-                id: agent.id,
-                parent: agent.parent ?? undefined,
-                lineage: agent.lineage,
-                state: agent.state,
-            })),
-        };
-        // Resolve the hierarchical address
-        const resolved = resolveHierarchicalAddress(to, from, hierarchySource);
-        if (resolved.agentIds.length === 0) {
-            throw new AddressRoutingError(`No recipients found for hierarchical address: ${describeAddress(to)}`, "NO_RECIPIENTS", to);
-        }
-        // Emit a primary event for the hierarchical send
-        const event = eventStore.emit({
-            type: "message",
-            source: { agent_id: from },
-            target: {
-                address: to,
-                delivered: resolved.agentIds,
-            },
-            payload: {
-                content,
-                correlation_id: correlationId,
-                priority,
-                delivery_hint: delivery,
-                multicast: {
-                    type: "hierarchical",
-                    address: describeAddress(to),
-                    recipientCount: resolved.agentIds.length,
-                },
-            },
-        });
-        // Fan out to each resolved recipient
-        for (const recipientId of resolved.agentIds) {
-            eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    agent_id: recipientId,
-                    address: { agent: recipientId },
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                    via: "hierarchical",
-                    original_message_id: event.id,
-                },
-            });
-            // Handle wake decision
-            if (sessionChecker && wakeHandler) {
-                const decision = getWakeDecisionWithHint(recipientId, {
-                    priority: priority,
-                    deliveryHint: delivery,
-                }, sessionChecker);
-                if (decision.shouldWake || decision.shouldInterrupt) {
-                    wakeHandler(recipientId, decision, event.id);
-                }
-            }
-            delivered.push(recipientId);
-        }
-        return {
-            id: event.id,
-            from,
-            to,
-            content,
-            timestamp: event.timestamp,
-            delivered,
-            correlationId,
-        };
-    }
-    /**
-     * Send a message to multiple specific agents.
-     * Used for { agents: [...] } addresses.
-     */
-    async function sendToMultipleAgents(from, to, content, options = {}) {
-        const { priority = "normal", delivery, correlationId } = options;
-        const delivered = [];
-        const recipientIds = to.agents;
-        if (recipientIds.length === 0) {
-            throw new AddressRoutingError("Empty agents array", "NO_RECIPIENTS", to);
-        }
-        // Verify all agents exist first
-        for (const agentId of recipientIds) {
-            const agent = eventStore.getAgent(agentId);
-            if (!agent) {
-                throw new AddressRoutingError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", to);
-            }
-        }
-        // Emit primary event for the multi-agent send
-        const event = eventStore.emit({
-            type: "message",
-            source: { agent_id: from },
-            target: {
-                address: to,
-                delivered: recipientIds,
-            },
-            payload: {
-                content,
-                correlation_id: correlationId,
-                priority,
-                delivery_hint: delivery,
-                multicast: {
-                    type: "agents",
-                    recipientCount: recipientIds.length,
-                },
-            },
-        });
-        // Fan out to each recipient
-        for (const recipientId of recipientIds) {
-            eventStore.emit({
-                type: "message",
-                source: { agent_id: from },
-                target: {
-                    agent_id: recipientId,
-                    address: { agent: recipientId },
-                },
-                payload: {
-                    content,
-                    correlation_id: correlationId,
-                    priority,
-                    delivery_hint: delivery,
-                    via: "agents",
-                    original_message_id: event.id,
-                },
-            });
-            // Handle wake decision
-            if (sessionChecker && wakeHandler) {
-                const decision = getWakeDecisionWithHint(recipientId, {
-                    priority: priority,
-                    deliveryHint: delivery,
-                }, sessionChecker);
-                if (decision.shouldWake || decision.shouldInterrupt) {
-                    wakeHandler(recipientId, decision, event.id);
-                }
-            }
-            delivered.push(recipientId);
-        }
-        return {
-            id: event.id,
-            from,
-            to,
-            content,
-            timestamp: event.timestamp,
-            delivered,
-            correlationId,
-        };
-    }
-    function emitStatus(request) {
-        const { from, status_type, summary, details } = request;
-        // Check emission restrictions if validator installed
-        if (emissionValidator) {
-            const signal = details?.signal;
-            const result = emissionValidator(from.agent_id, signal);
-            if (result.action === "reject") {
-                // Strict mode: block the emission entirely
-                return;
-            }
-            if (result.action === "audit") {
-                // Audit mode: record audit event, then continue with emission
-                eventStore.emit({
-                    type: "status",
-                    source: { agent_id: "system" },
-                    payload: {
-                        status_type: "discovery",
-                        summary: result.message ?? `Emission audit: agent ${from.agent_id} emitted signal '${signal}'`,
-                        audit: {
-                            type: "emission_violation",
-                            agent_id: from.agent_id,
-                            signal,
-                            status_type,
-                        },
-                    },
-                });
-            }
-            // "warn" and "allow" proceed normally (warning is logged by the validator installer)
-        }
-        // Emit status event to event store
-        const event = eventStore.emit({
-            type: "status",
-            source: {
-                agent_id: from.agent_id,
-                task_id: from.task_id,
-            },
-            payload: {
-                status_type,
-                summary,
-                details,
-            },
-        });
-        const statusNotification = {
-            agent_id: from.agent_id,
-            task_id: from.task_id,
-            status_type,
-            summary,
-            details,
-            timestamp: event.timestamp,
-        };
-        // Route to subtree subscribers (hierarchical: parents/ancestors)
-        const subtreeRecipients = routeStatusToSubtreeSubscribers(from.agent_id, statusNotification);
-        // Route to topic co-subscribers (non-hierarchical: peers sharing topics)
-        routeStatusToTopicSubscribers(from.agent_id, statusNotification, subtreeRecipients);
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Message Retrieval
-    // ─────────────────────────────────────────────────────────────────
-    function getMessages(agentId, options) {
-        const limit = options?.limit;
-        const includeAcknowledged = options?.includeAcknowledged ?? false;
-        // Get all messages from event store
-        const allMessages = eventStore.getMessages(agentId, undefined);
-        // Filter out acknowledged unless requested
-        const acknowledged = acknowledgedMessages.get(agentId) ?? new Set();
-        const filtered = includeAcknowledged
-            ? allMessages
-            : allMessages.filter((msg) => !acknowledged.has(msg.id));
-        // Apply limit
-        const limited = limit ? filtered.slice(0, limit) : filtered;
-        return limited;
-    }
-    function getFullMessage(messageId) {
-        return eventStore.getFullMessage(messageId);
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Message Acknowledgment
-    // ─────────────────────────────────────────────────────────────────
-    function acknowledgeMessage(agentId, messageId) {
-        if (!acknowledgedMessages.has(agentId)) {
-            acknowledgedMessages.set(agentId, new Set());
-        }
-        acknowledgedMessages.get(agentId).add(messageId);
-    }
-    function acknowledgeMessages(agentId, messageIds) {
-        if (!acknowledgedMessages.has(agentId)) {
-            acknowledgedMessages.set(agentId, new Set());
-        }
-        const set = acknowledgedMessages.get(agentId);
-        for (const id of messageIds) {
-            set.add(id);
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Subscription Management
-    // ─────────────────────────────────────────────────────────────────
-    function subscribe(agentId, channel) {
-        eventStore.addSubscription(agentId, {
-            type: channel.type,
-            target: channel.target,
-        });
-    }
-    function unsubscribe(agentId, channel) {
-        eventStore.removeSubscription(agentId, {
-            type: channel.type,
-            target: channel.target,
-        });
-    }
-    function getSubscriptions(agentId) {
-        const subs = eventStore.getSubscriptions(agentId);
-        return subs.map((s) => ({
-            type: s.type,
-            target: s.target,
-        }));
-    }
-    function getSubscribers(channel) {
-        return eventStore.getSubscribers({
-            type: channel.type,
-            target: channel.target,
-        });
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Setup Helpers
-    // ─────────────────────────────────────────────────────────────────
-    function setupDefaultSubscriptions(options) {
-        const { agent_id, parent_id, task_id, subscribe_parent = true, additional_topics = [], role, } = options;
-        // 1. Subscribe agent to its own direct channel
-        subscribe(agent_id, { type: "agent", target: agent_id });
-        // 2. Subscribe agent to lineage (receives messages from ancestors)
-        subscribe(agent_id, { type: "lineage", target: agent_id });
-        // 3. Subscribe agent to task channel if task_id provided
-        if (task_id) {
-            subscribe(agent_id, { type: "task", target: task_id });
-        }
-        // 4. Subscribe parent to agent's subtree if requested
-        if (parent_id && subscribe_parent) {
-            subscribe(parent_id, { type: "subtree", target: agent_id });
-        }
-        // 5. Subscribe to additional topics
-        for (const topic of additional_topics) {
-            subscribe(agent_id, { type: "topic", target: topic });
-        }
-        // 6. Auto-subscribe to role channel if role is provided (Tier 1: Gastown model)
-        if (role) {
-            subscribe(agent_id, { type: "role", target: role });
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    // Internal Helpers
-    // ─────────────────────────────────────────────────────────────────
-    /**
-     * Route status event to subtree subscribers.
-     * Parents who have subscribed to an agent's subtree receive status notifications.
-     * Returns the set of agents that were notified (for dedup with topic routing).
-     */
-    function routeStatusToSubtreeSubscribers(agentId, status) {
-        const notified = new Set();
-        const agent = eventStore.getAgent(agentId);
-        if (!agent)
-            return notified;
-        // Find all agents with subtree subscription that includes this agent
-        // This includes:
-        // 1. Direct subtree subscription to this agent
-        // 2. Subtree subscription to any ancestor of this agent
-        const agentsToNotify = new Set();
-        // Check direct subtree subscribers
-        const directSubscribers = eventStore.getSubscribers({
-            type: "subtree",
-            target: agentId,
-        });
-        for (const sub of directSubscribers) {
-            agentsToNotify.add(sub);
-        }
-        // Check subtree subscribers of ancestors (they also want events from descendants)
-        for (const ancestorId of agent.lineage) {
-            const ancestorSubscribers = eventStore.getSubscribers({
-                type: "subtree",
-                target: ancestorId,
-            });
-            // Only add if the subscriber is an ancestor of the current agent
-            // (meaning they subscribed to one of our ancestors' subtrees)
-            for (const sub of ancestorSubscribers) {
-                // Check if sub is an ancestor of agentId
-                if (agent.lineage.includes(sub)) {
-                    agentsToNotify.add(sub);
-                }
-            }
-        }
-        // Extract signal name from details (if tagged)
-        const statusSignal = status.details?.signal;
-        // Send status notification to each subscriber
-        for (const subscriberId of agentsToNotify) {
-            // Skip self-notification
-            if (subscriberId === agentId)
-                continue;
-            // Apply signal filter if installed
-            if (signalFilter && !signalFilter(agentId, subscriberId, statusSignal)) {
-                continue;
-            }
-            const statusContent = JSON.stringify({
-                type: "status_notification",
-                ...status,
-            });
-            const event = eventStore.emit({
-                type: "message",
-                source: {
-                    agent_id: agentId,
-                },
-                target: {
-                    agent_id: subscriberId,
-                },
-                payload: {
-                    content: statusContent,
-                    via: "subtree",
-                },
-            });
-            // Wake sleeping agents on status notifications
-            if (sessionChecker && wakeHandler) {
-                try {
-                    const decision = getWakeDecisionWithHint(subscriberId, { priority: "normal" }, sessionChecker);
-                    if (decision.shouldWake || decision.shouldInterrupt) {
-                        wakeHandler(subscriberId, decision, event.id);
-                    }
-                }
-                catch {
-                    // Never fail status delivery due to wake errors
-                }
-            }
-            notified.add(subscriberId);
-        }
-        return notified;
-    }
-    /**
-     * Route status event to topic co-subscribers.
-     * Agents sharing topic subscriptions with the emitting agent receive status notifications.
-     * This enables non-hierarchical visibility: peers on the same topic see each other's status.
-     * Skips agents already notified via subtree routing to avoid duplicates.
-     */
-    function routeStatusToTopicSubscribers(agentId, status, alreadyNotified) {
-        // Find all topics the emitting agent is subscribed to
-        const subscriptions = eventStore.getSubscriptions(agentId);
-        const topicSubscriptions = subscriptions.filter((s) => s.type === "topic");
-        if (topicSubscriptions.length === 0)
-            return;
-        // Collect unique recipients across all shared topics
-        const topicRecipients = new Set();
-        for (const sub of topicSubscriptions) {
-            const subscribers = eventStore.getSubscribers({
-                type: "topic",
-                target: sub.target,
-            });
-            for (const subscriberId of subscribers) {
-                // Skip self and already-notified (from subtree routing)
-                if (subscriberId !== agentId && !alreadyNotified.has(subscriberId)) {
-                    topicRecipients.add(subscriberId);
-                }
-            }
-        }
-        if (topicRecipients.size === 0)
-            return;
-        // Extract signal name from details (if tagged)
-        const statusSignal = status.details?.signal;
-        const statusContent = JSON.stringify({
-            type: "status_notification",
-            ...status,
-        });
-        // Deliver to each topic co-subscriber
-        for (const recipientId of topicRecipients) {
-            // Apply signal filter if installed
-            if (signalFilter && !signalFilter(agentId, recipientId, statusSignal)) {
-                continue;
-            }
-            const event = eventStore.emit({
-                type: "message",
-                source: {
-                    agent_id: agentId,
-                },
-                target: {
-                    agent_id: recipientId,
-                },
-                payload: {
-                    content: statusContent,
-                    via: "topic",
-                },
-            });
-            // Wake sleeping agents on status notifications
-            if (sessionChecker && wakeHandler) {
-                try {
-                    const decision = getWakeDecisionWithHint(recipientId, { priority: "normal" }, sessionChecker);
-                    if (decision.shouldWake || decision.shouldInterrupt) {
-                        wakeHandler(recipientId, decision, event.id);
-                    }
-                }
-                catch {
-                    // Never fail status delivery due to wake errors
-                }
-            }
-        }
-    }
-    function setTurnRecorder(recorder) {
-        turnRecorder = recorder;
-    }
-    function setSignalFilter(filter) {
-        signalFilter = filter;
-    }
-    function setEmissionValidator(validator) {
-        emissionValidator = validator;
-    }
-    return {
-        sendToAddress,
-        emitStatus,
-        getMessages,
-        getFullMessage,
-        acknowledgeMessage,
-        acknowledgeMessages,
-        subscribe,
-        unsubscribe,
-        getSubscriptions,
-        getSubscribers,
-        setupDefaultSubscriptions,
-        setTurnRecorder,
-        setSignalFilter,
-        setEmissionValidator,
-    };
-}
-//# sourceMappingURL=message-router.js.map