agent-relay 2.0.22 → 2.0.24

package/packages/dashboard/dist/health-worker-manager.js

@@ -1,144 +0,0 @@
-/**
- * Health Worker Manager
- *
- * Manages the health check worker thread, sending periodic stats updates
- * and handling worker lifecycle.
- */
-import { Worker } from 'node:worker_threads';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export class HealthWorkerManager {
-    worker = null;
-    statsInterval = null;
-    config;
-    statsProvider;
-    ready = false;
-    constructor(config, statsProvider) {
-        this.config = {
-            statsInterval: 5000,
-            ...config,
-        };
-        this.statsProvider = statsProvider;
-    }
-    /**
-     * Start the health worker thread
-     */
-    async start() {
-        if (this.worker) {
-            console.warn('[health-manager] Worker already running');
-            return;
-        }
-        return new Promise((resolve, reject) => {
-            // Worker script path - handle both dev (src) and prod (dist)
-            const workerPath = path.join(__dirname, 'health-worker.js');
-            this.worker = new Worker(workerPath, {
-                workerData: { port: this.config.port },
-            });
-            this.worker.on('message', (msg) => {
-                if (msg.type === 'ready') {
-                    this.ready = true;
-                    console.log(`[health-manager] Worker ready on port ${msg.port}`);
-                    this.startStatsUpdates();
-                    resolve();
-                }
-                else if (msg.type === 'error') {
-                    console.error('[health-manager] Worker error:', msg.error);
-                }
-            });
-            this.worker.on('error', (err) => {
-                console.error('[health-manager] Worker thread error:', err);
-                if (!this.ready) {
-                    reject(err);
-                }
-            });
-            this.worker.on('exit', (code) => {
-                console.log(`[health-manager] Worker exited with code ${code}`);
-                this.ready = false;
-                this.worker = null;
-                this.stopStatsUpdates();
-            });
-            // Timeout for worker startup
-            setTimeout(() => {
-                if (!this.ready) {
-                    reject(new Error('Health worker startup timeout'));
-                }
-            }, 10000);
-        });
-    }
-    /**
-     * Stop the health worker thread
-     */
-    async stop() {
-        this.stopStatsUpdates();
-        if (this.worker) {
-            await this.worker.terminate();
-            this.worker = null;
-            this.ready = false;
-        }
-    }
-    /**
-     * Check if worker is ready
-     */
-    isReady() {
-        return this.ready;
-    }
-    /**
-     * Get the port the health worker is listening on
-     */
-    getPort() {
-        return this.config.port;
-    }
-    /**
-     * Start periodic stats updates to worker
-     */
-    startStatsUpdates() {
-        if (this.statsInterval)
-            return;
-        // Send initial stats
-        this.sendStats();
-        // Send periodic updates
-        this.statsInterval = setInterval(() => {
-            this.sendStats();
-        }, this.config.statsInterval);
-    }
-    /**
-     * Stop stats updates
-     */
-    stopStatsUpdates() {
-        if (this.statsInterval) {
-            clearInterval(this.statsInterval);
-            this.statsInterval = null;
-        }
-    }
-    /**
-     * Send current stats to worker
-     */
-    sendStats() {
-        if (!this.worker || !this.ready)
-            return;
-        try {
-            const stats = {
-                uptime: this.statsProvider.getUptime(),
-                memoryMB: this.statsProvider.getMemoryMB(),
-                relayConnected: this.statsProvider.getRelayConnected(),
-                agentCount: this.statsProvider.getAgentCount(),
-                status: this.statsProvider.getStatus(),
-            };
-            this.worker.postMessage(stats);
-        }
-        catch (err) {
-            console.error('[health-manager] Failed to send stats:', err);
-        }
-    }
-}
-/** Default health port offset from main port */
-export const HEALTH_PORT_OFFSET = 1;
-/**
- * Calculate health port from main port
- */
-export function getHealthPort(mainPort) {
-    return mainPort + HEALTH_PORT_OFFSET;
-}
-//# sourceMappingURL=health-worker-manager.js.map

package/packages/dashboard/dist/health-worker.d.ts

@@ -1,9 +0,0 @@
-/**
- * Health Check Worker Thread
- *
- * Runs a minimal HTTP server on a separate thread to handle health checks.
- * This ensures health checks respond even when the main event loop is blocked
- * by heavy compute tasks (builds, large file operations, etc.).
- */
-export {};
-//# sourceMappingURL=health-worker.d.ts.map

package/packages/dashboard/dist/health-worker.js

@@ -1,79 +0,0 @@
-/**
- * Health Check Worker Thread
- *
- * Runs a minimal HTTP server on a separate thread to handle health checks.
- * This ensures health checks respond even when the main event loop is blocked
- * by heavy compute tasks (builds, large file operations, etc.).
- */
-import { parentPort, workerData } from 'node:worker_threads';
-import http from 'node:http';
-// Default stats until we receive updates from main thread
-let currentStats = {
-    uptime: 0,
-    memoryMB: 0,
-    relayConnected: false,
-    agentCount: 0,
-    status: 'healthy',
-};
-// Track when we last received stats from main thread
-let lastStatsUpdate = Date.now();
-const STATS_STALE_THRESHOLD_MS = 60_000; // 1 minute
-// Listen for stats updates from main thread
-if (parentPort) {
-    parentPort.on('message', (stats) => {
-        currentStats = stats;
-        lastStatsUpdate = Date.now();
-    });
-}
-const { port } = workerData;
-const server = http.createServer((req, res) => {
-    // Only handle /health endpoint
-    if (req.url !== '/health' && req.url !== '/') {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-        return;
-    }
-    // Check if stats are stale (main thread might be blocked)
-    const statsAge = Date.now() - lastStatsUpdate;
-    const isStale = statsAge > STATS_STALE_THRESHOLD_MS;
-    // Determine status
-    let status = currentStats.status;
-    if (isStale) {
-        status = 'busy'; // Main thread is likely blocked
-    }
-    const response = {
-        status,
-        uptime: currentStats.uptime,
-        memoryMB: currentStats.memoryMB,
-        relayConnected: currentStats.relayConnected,
-        agentCount: currentStats.agentCount,
-        statsAgeMs: statsAge,
-        worker: true, // Indicates response is from worker thread
-    };
-    // Return 200 for healthy/busy, 503 for degraded
-    const statusCode = status === 'degraded' ? 503 : 200;
-    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(response));
-});
-server.listen(port, '0.0.0.0', () => {
-    console.log(`[health-worker] Health check server listening on port ${port}`);
-    // Notify main thread we're ready
-    if (parentPort) {
-        parentPort.postMessage({ type: 'ready', port });
-    }
-});
-// Handle errors gracefully
-server.on('error', (err) => {
-    console.error('[health-worker] Server error:', err);
-    if (parentPort) {
-        parentPort.postMessage({ type: 'error', error: String(err) });
-    }
-});
-// Keep the worker alive
-process.on('uncaughtException', (err) => {
-    console.error('[health-worker] Uncaught exception:', err);
-});
-process.on('unhandledRejection', (err) => {
-    console.error('[health-worker] Unhandled rejection:', err);
-});
-//# sourceMappingURL=health-worker.js.map

package/packages/dashboard/dist/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * @agent-relay/dashboard
- *
- * Optional web dashboard for Agent Relay.
- * Install separately: npm install -g @agent-relay/dashboard
- *
- * This package provides:
- * - Dashboard HTTP API for agent management
- * - WebSocket connections for real-time updates
- * - User bridge for browser-based users
- * - Metrics collection and reporting
- * - Static Next.js UI for visual agent coordination
- */
-export { startDashboard } from './server.js';
-export { UserBridge, type IRelayClient } from './user-bridge.js';
-export { computeNeedsAttention, type AttentionMessage } from './needs-attention.js';
-export { computeSystemMetrics, formatPrometheusMetrics, type AgentMetrics, type ThroughputMetrics, } from './metrics.js';
-export { HealthWorkerManager, getHealthPort, type HealthWorkerConfig, type HealthStatsProvider } from './health-worker-manager.js';
-export type { ThreadMetadata } from './types/threading.js';
-//# sourceMappingURL=index.d.ts.map

package/packages/dashboard/dist/index.js

@@ -1,19 +0,0 @@
-/**
- * @agent-relay/dashboard
- *
- * Optional web dashboard for Agent Relay.
- * Install separately: npm install -g @agent-relay/dashboard
- *
- * This package provides:
- * - Dashboard HTTP API for agent management
- * - WebSocket connections for real-time updates
- * - User bridge for browser-based users
- * - Metrics collection and reporting
- * - Static Next.js UI for visual agent coordination
- */
-export { startDashboard } from './server.js';
-export { UserBridge } from './user-bridge.js';
-export { computeNeedsAttention } from './needs-attention.js';
-export { computeSystemMetrics, formatPrometheusMetrics, } from './metrics.js';
-export { HealthWorkerManager, getHealthPort } from './health-worker-manager.js';
-//# sourceMappingURL=index.js.map

package/packages/dashboard/dist/metrics.d.ts

@@ -1,105 +0,0 @@
-/**
- * Metrics collection and computation for the Agent Relay dashboard.
- * Provides real-time metrics for monitoring: throughput, agent health, error rates.
- */
-export interface AgentMetrics {
-    name: string;
-    messagesSent: number;
-    messagesReceived: number;
-    firstSeen: string;
-    lastSeen: string;
-    isOnline: boolean;
-    uptimeSeconds: number;
-}
-export interface ThroughputMetrics {
-    messagesLastMinute: number;
-    messagesLastHour: number;
-    messagesLast24Hours: number;
-    avgMessagesPerMinute: number;
-}
-export interface SessionMetrics {
-    totalSessions: number;
-    activeSessions: number;
-    closedByAgent: number;
-    closedByDisconnect: number;
-    closedByError: number;
-    errorRate: number;
-    recentSessions: Array<{
-        id: string;
-        agentName: string;
-        startedAt: string;
-        endedAt?: string;
-        closedBy?: 'agent' | 'disconnect' | 'error';
-        messageCount: number;
-    }>;
-}
-export interface SystemMetrics {
-    totalAgents: number;
-    onlineAgents: number;
-    offlineAgents: number;
-    totalMessages: number;
-    throughput: ThroughputMetrics;
-    sessions: SessionMetrics;
-    agents: AgentMetrics[];
-    timestamp: string;
-}
-export interface PrometheusMetric {
-    name: string;
-    help: string;
-    type: 'counter' | 'gauge' | 'histogram';
-    values: Array<{
-        labels: Record<string, string>;
-        value: number;
-    }>;
-}
-/**
- * Compute agent-level metrics from registry data
- */
-export declare function computeAgentMetrics(agents: Array<{
-    name: string;
-    messagesSent: number;
-    messagesReceived: number;
-    firstSeen: string;
-    lastSeen: string;
-}>): AgentMetrics[];
-/**
- * Compute throughput metrics from message history
- */
-export declare function computeThroughputMetrics(messages: Array<{
-    timestamp: string;
-}>): ThroughputMetrics;
-/**
- * Compute session lifecycle metrics from session history
- */
-export declare function computeSessionMetrics(sessions: Array<{
-    id: string;
-    agentName: string;
-    startedAt: number;
-    endedAt?: number;
-    closedBy?: 'agent' | 'disconnect' | 'error';
-    messageCount: number;
-}>): SessionMetrics;
-/**
- * Compute full system metrics
- */
-export declare function computeSystemMetrics(agents: Array<{
-    name: string;
-    messagesSent: number;
-    messagesReceived: number;
-    firstSeen: string;
-    lastSeen: string;
-}>, messages: Array<{
-    timestamp: string;
-}>, sessions?: Array<{
-    id: string;
-    agentName: string;
-    startedAt: number;
-    endedAt?: number;
-    closedBy?: 'agent' | 'disconnect' | 'error';
-    messageCount: number;
-}>): SystemMetrics;
-/**
- * Format metrics in Prometheus exposition format
- */
-export declare function formatPrometheusMetrics(metrics: SystemMetrics): string;
-//# sourceMappingURL=metrics.d.ts.map

package/packages/dashboard/dist/metrics.js

@@ -1,193 +0,0 @@
-/**
- * Metrics collection and computation for the Agent Relay dashboard.
- * Provides real-time metrics for monitoring: throughput, agent health, error rates.
- */
-// Consider agents offline after 30 seconds of inactivity
-// Aligns with heartbeat timeout (5s heartbeat * 6 multiplier = 30s)
-const OFFLINE_THRESHOLD_MS = 30 * 1000;
-/**
- * Compute agent-level metrics from registry data
- */
-export function computeAgentMetrics(agents) {
-    const now = Date.now();
-    return agents.map((agent) => {
-        const lastSeenTime = new Date(agent.lastSeen).getTime();
-        const firstSeenTime = new Date(agent.firstSeen).getTime();
-        const isOnline = now - lastSeenTime < OFFLINE_THRESHOLD_MS;
-        const uptimeSeconds = Math.floor((now - firstSeenTime) / 1000);
-        return {
-            name: agent.name,
-            messagesSent: agent.messagesSent,
-            messagesReceived: agent.messagesReceived,
-            firstSeen: agent.firstSeen,
-            lastSeen: agent.lastSeen,
-            isOnline,
-            uptimeSeconds,
-        };
-    });
-}
-/**
- * Compute throughput metrics from message history
- */
-export function computeThroughputMetrics(messages) {
-    const now = Date.now();
-    const oneMinuteAgo = now - 60 * 1000;
-    const oneHourAgo = now - 60 * 60 * 1000;
-    const oneDayAgo = now - 24 * 60 * 60 * 1000;
-    let lastMinute = 0;
-    let lastHour = 0;
-    let last24Hours = 0;
-    for (const msg of messages) {
-        const ts = new Date(msg.timestamp).getTime();
-        if (ts >= oneMinuteAgo)
-            lastMinute++;
-        if (ts >= oneHourAgo)
-            lastHour++;
-        if (ts >= oneDayAgo)
-            last24Hours++;
-    }
-    // Calculate average messages per minute over the last hour
-    const avgMessagesPerMinute = lastHour / 60;
-    return {
-        messagesLastMinute: lastMinute,
-        messagesLastHour: lastHour,
-        messagesLast24Hours: last24Hours,
-        avgMessagesPerMinute: Math.round(avgMessagesPerMinute * 100) / 100,
-    };
-}
-/**
- * Compute session lifecycle metrics from session history
- */
-export function computeSessionMetrics(sessions) {
-    let activeSessions = 0;
-    let closedByAgent = 0;
-    let closedByDisconnect = 0;
-    let closedByError = 0;
-    for (const session of sessions) {
-        if (!session.endedAt) {
-            activeSessions++;
-        }
-        else {
-            switch (session.closedBy) {
-                case 'agent':
-                    closedByAgent++;
-                    break;
-                case 'disconnect':
-                    closedByDisconnect++;
-                    break;
-                case 'error':
-                    closedByError++;
-                    break;
-                default:
-                    // Ended but no closedBy - treat as disconnect
-                    closedByDisconnect++;
-            }
-        }
-    }
-    const closedSessions = closedByAgent + closedByDisconnect + closedByError;
-    const errorRate = closedSessions > 0 ? (closedByError / closedSessions) * 100 : 0;
-    // Format recent sessions for display (most recent 10)
-    const recentSessions = sessions
-        .slice(0, 10)
-        .map((s) => ({
-        id: s.id,
-        agentName: s.agentName,
-        startedAt: new Date(s.startedAt).toISOString(),
-        endedAt: s.endedAt ? new Date(s.endedAt).toISOString() : undefined,
-        closedBy: s.closedBy,
-        messageCount: s.messageCount,
-    }));
-    return {
-        totalSessions: sessions.length,
-        activeSessions,
-        closedByAgent,
-        closedByDisconnect,
-        closedByError,
-        errorRate: Math.round(errorRate * 100) / 100,
-        recentSessions,
-    };
-}
-/**
- * Compute full system metrics
- */
-export function computeSystemMetrics(agents, messages, sessions = []) {
-    const agentMetrics = computeAgentMetrics(agents);
-    const throughput = computeThroughputMetrics(messages);
-    const sessionMetrics = computeSessionMetrics(sessions);
-    const onlineAgents = agentMetrics.filter((a) => a.isOnline).length;
-    const totalMessages = agents.reduce((sum, a) => sum + a.messagesSent + a.messagesReceived, 0) / 2; // Divide by 2 since each message is counted twice (sent + received)
-    return {
-        totalAgents: agents.length,
-        onlineAgents,
-        offlineAgents: agents.length - onlineAgents,
-        totalMessages: Math.round(totalMessages),
-        throughput,
-        sessions: sessionMetrics,
-        agents: agentMetrics,
-        timestamp: new Date().toISOString(),
-    };
-}
-/**
- * Format metrics in Prometheus exposition format
- */
-export function formatPrometheusMetrics(metrics) {
-    const lines = [];
-    // Agent counts
-    lines.push('# HELP agent_relay_agents_total Total number of registered agents');
-    lines.push('# TYPE agent_relay_agents_total gauge');
-    lines.push(`agent_relay_agents_total ${metrics.totalAgents}`);
-    lines.push('# HELP agent_relay_agents_online Number of online agents');
-    lines.push('# TYPE agent_relay_agents_online gauge');
-    lines.push(`agent_relay_agents_online ${metrics.onlineAgents}`);
-    // Message throughput
-    lines.push('# HELP agent_relay_messages_total Total messages processed');
-    lines.push('# TYPE agent_relay_messages_total counter');
-    lines.push(`agent_relay_messages_total ${metrics.totalMessages}`);
-    lines.push('# HELP agent_relay_messages_last_minute Messages in last minute');
-    lines.push('# TYPE agent_relay_messages_last_minute gauge');
-    lines.push(`agent_relay_messages_last_minute ${metrics.throughput.messagesLastMinute}`);
-    lines.push('# HELP agent_relay_messages_last_hour Messages in last hour');
-    lines.push('# TYPE agent_relay_messages_last_hour gauge');
-    lines.push(`agent_relay_messages_last_hour ${metrics.throughput.messagesLastHour}`);
-    lines.push('# HELP agent_relay_messages_avg_per_minute Average messages per minute');
-    lines.push('# TYPE agent_relay_messages_avg_per_minute gauge');
-    lines.push(`agent_relay_messages_avg_per_minute ${metrics.throughput.avgMessagesPerMinute}`);
-    // Per-agent metrics
-    lines.push('# HELP agent_relay_agent_messages_sent Messages sent by agent');
-    lines.push('# TYPE agent_relay_agent_messages_sent counter');
-    for (const agent of metrics.agents) {
-        lines.push(`agent_relay_agent_messages_sent{agent="${agent.name}"} ${agent.messagesSent}`);
-    }
-    lines.push('# HELP agent_relay_agent_messages_received Messages received by agent');
-    lines.push('# TYPE agent_relay_agent_messages_received counter');
-    for (const agent of metrics.agents) {
-        lines.push(`agent_relay_agent_messages_received{agent="${agent.name}"} ${agent.messagesReceived}`);
-    }
-    lines.push('# HELP agent_relay_agent_online Agent online status (1=online, 0=offline)');
-    lines.push('# TYPE agent_relay_agent_online gauge');
-    for (const agent of metrics.agents) {
-        lines.push(`agent_relay_agent_online{agent="${agent.name}"} ${agent.isOnline ? 1 : 0}`);
-    }
-    lines.push('# HELP agent_relay_agent_uptime_seconds Agent uptime in seconds');
-    lines.push('# TYPE agent_relay_agent_uptime_seconds gauge');
-    for (const agent of metrics.agents) {
-        lines.push(`agent_relay_agent_uptime_seconds{agent="${agent.name}"} ${agent.uptimeSeconds}`);
-    }
-    // Session lifecycle metrics
-    lines.push('# HELP agent_relay_sessions_total Total number of sessions');
-    lines.push('# TYPE agent_relay_sessions_total counter');
-    lines.push(`agent_relay_sessions_total ${metrics.sessions.totalSessions}`);
-    lines.push('# HELP agent_relay_sessions_active Number of active sessions');
-    lines.push('# TYPE agent_relay_sessions_active gauge');
-    lines.push(`agent_relay_sessions_active ${metrics.sessions.activeSessions}`);
-    lines.push('# HELP agent_relay_sessions_closed_total Sessions closed by type');
-    lines.push('# TYPE agent_relay_sessions_closed_total counter');
-    lines.push(`agent_relay_sessions_closed_total{closed_by="agent"} ${metrics.sessions.closedByAgent}`);
-    lines.push(`agent_relay_sessions_closed_total{closed_by="disconnect"} ${metrics.sessions.closedByDisconnect}`);
-    lines.push(`agent_relay_sessions_closed_total{closed_by="error"} ${metrics.sessions.closedByError}`);
-    lines.push('# HELP agent_relay_sessions_error_rate Percentage of sessions closed by error');
-    lines.push('# TYPE agent_relay_sessions_error_rate gauge');
-    lines.push(`agent_relay_sessions_error_rate ${metrics.sessions.errorRate}`);
-    return lines.join('\n') + '\n';
-}
-//# sourceMappingURL=metrics.js.map

package/packages/dashboard/dist/needs-attention.d.ts

@@ -1,24 +0,0 @@
-/**
- * Derive which agents currently need attention based on message history.
- *
- * Heuristic:
- * - Track the most recent inbound message to an agent for each conversation key.
- * - Conversation key is thread ID if present, otherwise the counterparty agent.
- * - Track the most recent outbound message from the agent for the same key.
- * - An agent needs attention if their latest inbound message for any key is newer
- *   than their latest outbound message for that key.
- */
-export interface AttentionMessage {
-    from: string;
-    to: string;
-    timestamp: string;
-    thread?: string;
-    /** Whether the message was sent as a broadcast (to: '*') */
-    isBroadcast?: boolean;
-}
-/**
- * Compute which agents have pending inbound messages they haven't answered.
- * Only considers messages within the attention window (last 30 minutes).
- */
-export declare function computeNeedsAttention(messages: AttentionMessage[]): Set<string>;
-//# sourceMappingURL=needs-attention.d.ts.map

package/packages/dashboard/dist/needs-attention.js

@@ -1,78 +0,0 @@
-/**
- * Derive which agents currently need attention based on message history.
- *
- * Heuristic:
- * - Track the most recent inbound message to an agent for each conversation key.
- * - Conversation key is thread ID if present, otherwise the counterparty agent.
- * - Track the most recent outbound message from the agent for the same key.
- * - An agent needs attention if their latest inbound message for any key is newer
- *   than their latest outbound message for that key.
- */
-// Only consider messages from the last 30 minutes for "needs attention"
-const ATTENTION_WINDOW_MS = 30 * 60 * 1000;
-function updateLatest(map, agent, key, ts) {
-    const agentMap = map.get(agent) ?? new Map();
-    const prev = agentMap.get(key) ?? -Infinity;
-    if (ts > prev) {
-        agentMap.set(key, ts);
-        map.set(agent, agentMap);
-    }
-}
-/**
- * Compute which agents have pending inbound messages they haven't answered.
- * Only considers messages within the attention window (last 30 minutes).
- */
-export function computeNeedsAttention(messages) {
-    const latestInbound = new Map(); // agent -> (key -> ts)
-    const latestOutbound = new Map(); // agent -> (key -> ts)
-    const now = Date.now();
-    const cutoffTime = now - ATTENTION_WINDOW_MS;
-    for (const message of messages) {
-        const ts = Date.parse(message.timestamp);
-        if (Number.isNaN(ts))
-            continue;
-        // Detect broadcasts: either explicit isBroadcast flag or to === '*'
-        const isBroadcast = message.isBroadcast || message.to === '*';
-        // Inbound: messages directed to a specific agent (ignore broadcasts)
-        // Note: isBroadcast indicates the message was originally a broadcast, even though
-        // the 'to' field is set to the individual recipient for storage purposes
-        if (message.to && !isBroadcast) {
-            const inboundKey = message.thread ? `thread:${message.thread}` : `sender:${message.from}`;
-            updateLatest(latestInbound, message.to, inboundKey, ts);
-        }
-        // Outbound: track replies by thread (preferred) or by target agent
-        // Also treat broadcasts as clearing attention for all prior senders
-        if (message.from) {
-            const outboundKey = message.thread
-                ? `thread:${message.thread}`
-                : (message.to && !isBroadcast)
-                    ? `sender:${message.to}`
-                    : null;
-            if (outboundKey) {
-                updateLatest(latestOutbound, message.from, outboundKey, ts);
-            }
-            // Broadcasts clear attention: agent is actively participating
-            // Track as a "catch-all" outbound timestamp for this agent
-            if (isBroadcast) {
-                updateLatest(latestOutbound, message.from, '__broadcast__', ts);
-            }
-        }
-    }
-    const needsAttention = new Set();
-    latestInbound.forEach((keyMap, agent) => {
-        keyMap.forEach((inboundTs, key) => {
-            // Skip if inbound message is too old (outside attention window)
-            if (inboundTs < cutoffTime)
-                return;
-            const outboundTs = latestOutbound.get(agent)?.get(key) ?? -Infinity;
-            // Also check if agent sent a broadcast after the inbound message
-            const broadcastTs = latestOutbound.get(agent)?.get('__broadcast__') ?? -Infinity;
-            const latestReply = Math.max(outboundTs, broadcastTs);
-            if (inboundTs > latestReply) {
-                needsAttention.add(agent);
-            }
-        });
-    });
-    return needsAttention;
-}
-//# sourceMappingURL=needs-attention.js.map