agent-relay 1.5.1 → 1.6.0

package/dist/bridge/spawner.d.ts

@@ -36,6 +36,22 @@ export type OnAgentDeathCallback = (info: {
     agentId?: string;
     resumeInstructions?: string;
 }) => void;
+/** Options for AgentSpawner constructor */
+export interface AgentSpawnerOptions {
+    projectRoot: string;
+    tmuxSession?: string;
+    dashboardPort?: number;
+    /**
+     * Callback to mark an agent as spawning (before HELLO completes).
+     * Messages sent to this agent will be queued for delivery after registration.
+     */
+    onMarkSpawning?: (agentName: string) => void;
+    /**
+     * Callback to clear the spawning flag for an agent.
+     * Called when spawn fails or is cancelled.
+     */
+    onClearSpawning?: (agentName: string) => void;
+}
 export declare class AgentSpawner {
     private activeWorkers;
     private agentsPath;
@@ -48,7 +64,10 @@ export declare class AgentSpawner {
     private cloudPersistence?;
     private policyService?;
     private policyEnforcementEnabled;
+    private onMarkSpawning?;
+    private onClearSpawning?;
     constructor(projectRoot: string, _tmuxSession?: string, dashboardPort?: number);
+    constructor(options: AgentSpawnerOptions);
     /**
      * Set cloud policy fetcher for workspace-level policies
      */

package/dist/bridge/spawner.js

@@ -16,7 +16,8 @@ import { selectShadowCli } from './shadow-cli.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 import { AgentPolicyService } from '../policy/agent-policy.js';
-import { buildClaudeArgs } from '../utils/agent-config.js';
+import { buildClaudeArgs, findAgentConfig } from '../utils/agent-config.js';
+import { composeForAgent } from '../wrapper/prompt-composer.js';
 import { getUserDirectoryService } from '../daemon/user-directory.js';
 /**
  * Get relay protocol instructions for a spawned agent.
@@ -144,8 +145,14 @@ export class AgentSpawner {
     cloudPersistence;
     policyService;
     policyEnforcementEnabled = false;
-    constructor(projectRoot, _tmuxSession, dashboardPort) {
-        const paths = getProjectPaths(projectRoot);
+    onMarkSpawning;
+    onClearSpawning;
+    constructor(projectRootOrOptions, _tmuxSession, dashboardPort) {
+        // Handle both old and new constructor signatures
+        const options = typeof projectRootOrOptions === 'string'
+            ? { projectRoot: projectRootOrOptions, tmuxSession: _tmuxSession, dashboardPort }
+            : projectRootOrOptions;
+        const paths = getProjectPaths(options.projectRoot);
         this.projectRoot = paths.projectRoot;
         // Use connected-agents.json (live socket connections) instead of agents.json (historical registry)
         // This ensures spawned agents have actual daemon connections for channel message delivery
@@ -153,7 +160,10 @@ export class AgentSpawner {
         this.socketPath = paths.socketPath;
         this.logsDir = path.join(paths.teamDir, 'worker-logs');
         this.workersPath = path.join(paths.teamDir, 'workers.json');
-        this.dashboardPort = dashboardPort;
+        this.dashboardPort = options.dashboardPort;
+        // Store spawn tracking callbacks
+        this.onMarkSpawning = options.onMarkSpawning;
+        this.onClearSpawning = options.onClearSpawning;
         // Ensure logs directory exists
         fs.mkdirSync(this.logsDir, { recursive: true });
         // Initialize policy service if enforcement is enabled
@@ -306,10 +316,15 @@ export class AgentSpawner {
             // Apply agent config (model, --agent flag) from .claude/agents/ if available
             // This ensures spawned agents respect their profile settings
             if (isClaudeCli) {
+                // Get agent config for model tracking
+                const agentConfig = findAgentConfig(name, this.projectRoot);
+                const model = agentConfig?.model || 'sonnet'; // Default to sonnet
                 const configuredArgs = buildClaudeArgs(name, args, this.projectRoot);
                 // Replace args with configured version (includes --model and --agent if found)
                 args.length = 0;
                 args.push(...configuredArgs);
+                // Cost tracking: log which model is being used
+                console.log(`[spawner] Agent ${name}: model=${model}, cli=${cli}`);
                 if (debug)
                     console.log(`[spawner:debug] Applied agent config for ${name}: ${args.join(' ')}`);
             }
@@ -319,13 +334,38 @@ export class AgentSpawner {
                 args.push('--dangerously-bypass-approvals-and-sandbox');
             }
             // Inject relay protocol instructions via CLI-specific system prompt
-            const relayInstructions = getRelayInstructions(name);
+            let relayInstructions = getRelayInstructions(name);
+            // Compose role-specific prompts if agent has a role defined in .claude/agents/
+            const agentConfigForRole = isClaudeCli ? findAgentConfig(name, this.projectRoot) : null;
+            if (agentConfigForRole?.role) {
+                const validRoles = ['planner', 'worker', 'reviewer', 'lead', 'shadow'];
+                const role = agentConfigForRole.role.toLowerCase();
+                if (validRoles.includes(role)) {
+                    try {
+                        const composed = await composeForAgent({ name, role }, this.projectRoot, { taskDescription: task });
+                        if (composed.content) {
+                            relayInstructions = `${composed.content}\n\n---\n\n${relayInstructions}`;
+                            if (debug)
+                                console.log(`[spawner:debug] Composed role prompt for ${name} (role: ${role})`);
+                        }
+                    }
+                    catch (err) {
+                        console.warn(`[spawner] Failed to compose role prompt for ${name}: ${err.message}`);
+                    }
+                }
+            }
             if (isClaudeCli && !args.includes('--append-system-prompt')) {
                 args.push('--append-system-prompt', relayInstructions);
             }
             else if (isCodexCli && !args.some(a => a.includes('developer_instructions'))) {
                 args.push('--config', `developer_instructions=${relayInstructions}`);
             }
+            // Codex requires an initial prompt in TTY mode (unlike Claude which waits for input)
+            // Pass the task as the initial prompt, or a generic "ready" message if no task
+            if (isCodexCli) {
+                const initialPrompt = task || 'You are ready. Wait for messages from the relay system.';
+                args.push(initialPrompt);
+            }
             if (debug)
                 console.log(`[spawner:debug] Spawning ${name} with: ${command} ${args.join(' ')}`);
             // Create PtyWrapper config
@@ -463,6 +503,13 @@ export class AgentSpawner {
                 listeners.summary = cloudListeners.summary;
             if (cloudListeners.sessionEnd)
                 listeners.sessionEnd = cloudListeners.sessionEnd;
+            // Mark agent as spawning BEFORE starting PTY
+            // This allows messages sent to this agent to be queued until HELLO completes
+            if (this.onMarkSpawning) {
+                this.onMarkSpawning(name);
+                if (debug)
+                    console.log(`[spawner:debug] Marked ${name} as spawning`);
+            }
             await pty.start();
             if (debug)
                 console.log(`[spawner:debug] PTY started, pid: ${pty.pid}`);
@@ -471,6 +518,10 @@ export class AgentSpawner {
             if (!registered) {
                 const error = `Worker ${name} failed to register within 30s`;
                 console.error(`[spawner] ${error}`);
+                // Clear spawning flag since spawn failed
+                if (this.onClearSpawning) {
+                    this.onClearSpawning(name);
+                }
                 await pty.kill();
                 return {
                     success: false,
@@ -478,9 +529,47 @@ export class AgentSpawner {
                     error,
                 };
             }
-            // Note: Task is NOT sent here. The spawning agent (wrapper) waits for the worker
-            // to come online and then sends the task via normal relay message.
-            // This avoids race conditions with the agent's readyForMessages state.
+            // Send task to the newly spawned agent if provided
+            // We do this AFTER registration AND after the CLI is ready to receive input
+            if (task && task.trim() && this.dashboardPort) {
+                try {
+                    // Wait for the CLI to be ready (has produced output AND is idle)
+                    // This is more reliable than a random sleep because it waits for actual signals
+                    if (useRelayPty && 'waitUntilCliReady' in pty) {
+                        const orchestrator = pty;
+                        const ready = await orchestrator.waitUntilCliReady(15000, 100);
+                        if (!ready) {
+                            console.warn(`[spawner] CLI for ${name} did not become ready within timeout, sending task anyway`);
+                        }
+                        else if (debug) {
+                            console.log(`[spawner:debug] CLI for ${name} is ready to receive messages`);
+                        }
+                    }
+                    else {
+                        // PtyWrapper fallback - use short delay as it doesn't have waitUntilCliReady
+                        await sleep(500);
+                    }
+                    const sendResponse = await fetch(`http://localhost:${this.dashboardPort}/api/send`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            to: name,
+                            message: task,
+                            from: spawnerName, // Include spawner name so message appears from correct agent
+                        }),
+                    });
+                    if (sendResponse.ok) {
+                        if (debug)
+                            console.log(`[spawner:debug] Task sent to ${name}`);
+                    }
+                    else {
+                        console.error(`[spawner] Failed to send task to ${name}: ${sendResponse.status}`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[spawner] Error sending task to ${name}:`, err.message);
+                }
+            }
             // Track the worker
             const workerInfo = {
                 name,
@@ -509,6 +598,10 @@ export class AgentSpawner {
             console.error(`[spawner] Failed to spawn ${name}:`, err.message);
             if (debug)
                 console.error(`[spawner:debug] Full error:`, err);
+            // Clear spawning flag since spawn failed
+            if (this.onClearSpawning) {
+                this.onClearSpawning(name);
+            }
             return {
                 success: false,
                 name,

package/dist/cli/index.js

@@ -384,6 +384,9 @@ program
                 dbPath,
                 enableSpawner: true,
                 projectRoot: paths.projectRoot,
+                // Pass spawn tracking callbacks so messages can be queued before HELLO completes
+                onMarkSpawning: (name) => daemon.markSpawning(name),
+                onClearSpawning: (name) => daemon.clearSpawning(name),
             });
             console.log(`Dashboard: http://localhost:${dashboardPort}`);
             // Hook daemon log output to dashboard WebSocket

package/dist/cloud/api/daemons.js

@@ -12,6 +12,8 @@ import { Router } from 'express';
 import { randomBytes, createHash } from 'crypto';
 import { requireAuth } from './auth.js';
 import { db } from '../db/index.js';
+import { getOnlineUsersForDiscovery, isUserOnline } from '../services/presence-registry.js';
+import { cloudMessageBus } from '../services/cloud-message-bus.js';
 export const daemonsRouter = Router();
 /**
  * Generate a secure API key
@@ -330,9 +332,12 @@ daemonsRouter.post('/agents', requireDaemonAuth, async (req, res) => {
                 machineId: d.machineId,
             }));
         });
+        // Get online users from presence registry (for cross-machine user routing)
+        const allUsers = getOnlineUsersForDiscovery();
         res.json({
             success: true,
             allAgents, // Return all agents across all linked daemons
+            allUsers, // Return online users for cross-machine routing
         });
     }
     catch (error) {
@@ -351,6 +356,27 @@ daemonsRouter.post('/message', requireDaemonAuth, async (req, res) => {
         return res.status(400).json({ error: 'targetDaemonId, targetAgent, and message are required' });
     }
     try {
+        // Special case: messages to cloud users (daemonId = 'cloud')
+        if (targetDaemonId === 'cloud') {
+            // Verify user is online
+            if (!isUserOnline(targetAgent)) {
+                return res.status(404).json({ error: 'User not online' });
+            }
+            // Send via cloud message bus for WebSocket delivery
+            cloudMessageBus.sendToUser(targetAgent, {
+                from: {
+                    daemonId: daemon.id,
+                    daemonName: daemon.name,
+                    agent: message.from,
+                },
+                to: targetAgent,
+                body: message.content,
+                timestamp: new Date().toISOString(),
+                metadata: message.metadata,
+            });
+            console.log(`[daemons] Message sent to cloud user ${targetAgent} from ${message.from}`);
+            return res.json({ success: true, message: 'Message sent to cloud user' });
+        }
         // Verify target daemon belongs to same user
         const targetDaemon = await db.linkedDaemons.findById(targetDaemonId);
         if (!targetDaemon || targetDaemon.userId !== daemon.userId) {

package/dist/cloud/server.js

@@ -40,6 +40,8 @@ import { adminRouter } from './api/admin.js';
 import { consensusRouter } from './api/consensus.js';
 import { db } from './db/index.js';
 import { validateSshSecurityConfig } from './services/ssh-security.js';
+import { registerUserPresence, unregisterUserPresence, updateUserLastSeen } from './services/presence-registry.js';
+import { cloudMessageBus } from './services/cloud-message-bus.js';
 /**
  * Proxy a request to the user's primary running workspace
  */
@@ -1337,6 +1339,8 @@ export async function createServer() {
                         if (existing) {
                             existing.connections.add(ws);
                             existing.info.lastSeen = now;
+                            // Update last seen in shared presence registry
+                            updateUserLastSeen(username);
                             // Only log at milestones to reduce noise
                             const count = existing.connections.size;
                             if (count === 2 || count === 5 || count === 10 || count % 50 === 0) {
@@ -1348,6 +1352,8 @@ export async function createServer() {
                                 info: { username, avatarUrl, connectedAt: now, lastSeen: now },
                                 connections: new Set([ws]),
                             });
+                            // Register with shared presence registry for cross-module access
+                            registerUserPresence({ username, avatarUrl, connectedAt: now, lastSeen: now });
                             console.log(`[cloud] User ${username} came online`);
                             broadcastPresence({
                                 type: 'presence_join',
@@ -1367,6 +1373,8 @@ export async function createServer() {
                             userState.connections.delete(ws);
                             if (userState.connections.size === 0) {
                                 onlineUsers.delete(clientUsername);
+                                // Unregister from shared presence registry
+                                unregisterUserPresence(clientUsername);
                                 console.log(`[cloud] User ${clientUsername} went offline`);
                                 broadcastPresence({ type: 'presence_leave', username: clientUsername });
                             }
@@ -1379,6 +1387,8 @@ export async function createServer() {
                     const userState = onlineUsers.get(clientUsername);
                     if (userState) {
                         userState.info.lastSeen = new Date().toISOString();
+                        // Update last seen in shared presence registry
+                        updateUserLastSeen(clientUsername);
                     }
                     broadcastPresence({
                         type: 'typing',
@@ -1430,6 +1440,8 @@ export async function createServer() {
                     userState.connections.delete(ws);
                     if (userState.connections.size === 0) {
                         onlineUsers.delete(clientUsername);
+                        // Unregister from shared presence registry
+                        unregisterUserPresence(clientUsername);
                         console.log(`[cloud] User ${clientUsername} disconnected`);
                         broadcastPresence({ type: 'presence_leave', username: clientUsername });
                     }
@@ -1443,6 +1455,34 @@ export async function createServer() {
     wssPresence.on('error', (err) => {
         console.error('[cloud] Presence WebSocket server error:', err);
     });
+    // Subscribe to cloud message bus for delivering messages to cloud users
+    cloudMessageBus.on('user-message', ({ username, message }) => {
+        const userState = onlineUsers.get(username);
+        if (!userState) {
+            console.warn(`[cloud] Cannot deliver message to ${username}: user not online`);
+            return;
+        }
+        // Deliver to all of the user's WebSocket connections
+        const payload = JSON.stringify({
+            type: 'direct_message',
+            from: message.from.agent,
+            body: message.body,
+            timestamp: message.timestamp,
+            metadata: {
+                ...message.metadata,
+                daemonId: message.from.daemonId,
+                daemonName: message.from.daemonName,
+            },
+        });
+        let delivered = 0;
+        userState.connections.forEach((ws) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(payload);
+                delivered++;
+            }
+        });
+        console.log(`[cloud] Delivered message to ${username} (${delivered} connections)`);
+    });
     return {
         app,
         async start() {

package/dist/cloud/services/cloud-message-bus.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cloud Message Bus - Event-based message delivery for cloud users.
+ *
+ * This module provides a simple pub/sub mechanism for delivering messages
+ * to users connected via the cloud dashboard. The daemons API publishes
+ * messages here, and the presence WebSocket handler subscribes to deliver them.
+ */
+import { EventEmitter } from 'events';
+export interface CloudMessage {
+    from: {
+        daemonId: string;
+        daemonName: string;
+        agent: string;
+    };
+    to: string;
+    body: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+declare class CloudMessageBus extends EventEmitter {
+    /**
+     * Send a message to a cloud user
+     */
+    sendToUser(username: string, message: CloudMessage): void;
+}
+export declare const cloudMessageBus: CloudMessageBus;
+export {};
+//# sourceMappingURL=cloud-message-bus.d.ts.map

package/dist/cloud/services/cloud-message-bus.js

@@ -0,0 +1,19 @@
+/**
+ * Cloud Message Bus - Event-based message delivery for cloud users.
+ *
+ * This module provides a simple pub/sub mechanism for delivering messages
+ * to users connected via the cloud dashboard. The daemons API publishes
+ * messages here, and the presence WebSocket handler subscribes to deliver them.
+ */
+import { EventEmitter } from 'events';
+class CloudMessageBus extends EventEmitter {
+    /**
+     * Send a message to a cloud user
+     */
+    sendToUser(username, message) {
+        this.emit('user-message', { username, message });
+    }
+}
+// Singleton instance
+export const cloudMessageBus = new CloudMessageBus();
+//# sourceMappingURL=cloud-message-bus.js.map

package/dist/cloud/services/index.d.ts

@@ -12,4 +12,6 @@ export { handleMention, handleIssueAssignment, getPendingMentions, getPendingIss
 export { ComputeEnforcementService, ComputeEnforcementConfig, EnforcementResult, getComputeEnforcementService, createComputeEnforcementService, } from './compute-enforcement.js';
 export { IntroExpirationService, IntroExpirationConfig, IntroStatus, ExpirationResult as IntroExpirationResult, INTRO_PERIOD_DAYS, getIntroStatus, getIntroExpirationService, startIntroExpirationService, stopIntroExpirationService, } from './intro-expiration.js';
 export { WorkspaceKeepaliveService, WorkspaceKeepaliveConfig, KeepaliveStats, getWorkspaceKeepaliveService, createWorkspaceKeepaliveService, } from './workspace-keepalive.js';
+export { registerUserPresence, unregisterUserPresence, updateUserLastSeen, isUserOnline, getOnlineUser, getOnlineUsers, getOnlineUsersForDiscovery, clearAllPresence, type PresenceUserInfo, } from './presence-registry.js';
+export { cloudMessageBus, type CloudMessage, } from './cloud-message-bus.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cloud/services/index.js

@@ -18,4 +18,8 @@ export { ComputeEnforcementService, getComputeEnforcementService, createComputeE
 export { IntroExpirationService, INTRO_PERIOD_DAYS, getIntroStatus, getIntroExpirationService, startIntroExpirationService, stopIntroExpirationService, } from './intro-expiration.js';
 // Workspace keepalive (prevent Fly.io from idling machines with active agents)
 export { WorkspaceKeepaliveService, getWorkspaceKeepaliveService, createWorkspaceKeepaliveService, } from './workspace-keepalive.js';
+// Presence registry (shared registry for tracking online users)
+export { registerUserPresence, unregisterUserPresence, updateUserLastSeen, isUserOnline, getOnlineUser, getOnlineUsers, getOnlineUsersForDiscovery, clearAllPresence, } from './presence-registry.js';
+// Cloud message bus (event-based message delivery for cloud users)
+export { cloudMessageBus, } from './cloud-message-bus.js';
 //# sourceMappingURL=index.js.map

package/dist/cloud/services/presence-registry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Presence Registry - Shared registry for tracking online users across cloud server.
+ *
+ * This singleton module allows both the WebSocket handler in server.ts and the
+ * daemons API routes to access the current list of online users.
+ */
+export interface PresenceUserInfo {
+    username: string;
+    avatarUrl?: string;
+    connectedAt: string;
+    lastSeen: string;
+    /** Optional workspace context for the user */
+    workspaceId?: string;
+}
+/**
+ * Register a user connection
+ */
+export declare function registerUserPresence(info: PresenceUserInfo): void;
+/**
+ * Update last seen time for a user
+ */
+export declare function updateUserLastSeen(username: string): void;
+/**
+ * Unregister a user connection
+ */
+export declare function unregisterUserPresence(username: string): void;
+/**
+ * Check if a user is online
+ */
+export declare function isUserOnline(username: string): boolean;
+/**
+ * Get info for a specific online user
+ */
+export declare function getOnlineUser(username: string): PresenceUserInfo | undefined;
+/**
+ * Get list of all online users
+ */
+export declare function getOnlineUsers(): PresenceUserInfo[];
+/**
+ * Get online users formatted for remote agent discovery.
+ * Returns in the same format as RemoteAgent so daemons can route to users.
+ */
+export declare function getOnlineUsersForDiscovery(): Array<{
+    name: string;
+    status: string;
+    daemonId: string;
+    daemonName: string;
+    machineId: string;
+    isHuman: boolean;
+    avatarUrl?: string;
+}>;
+/**
+ * Clear all presence (for testing or shutdown)
+ */
+export declare function clearAllPresence(): void;
+//# sourceMappingURL=presence-registry.d.ts.map

package/dist/cloud/services/presence-registry.js

@@ -0,0 +1,91 @@
+/**
+ * Presence Registry - Shared registry for tracking online users across cloud server.
+ *
+ * This singleton module allows both the WebSocket handler in server.ts and the
+ * daemons API routes to access the current list of online users.
+ */
+/**
+ * In-memory registry of online users.
+ * Key: username
+ * Value: presence state with connection count
+ */
+const onlineUsers = new Map();
+/**
+ * Register a user connection
+ */
+export function registerUserPresence(info) {
+    const existing = onlineUsers.get(info.username);
+    if (existing) {
+        // Update info and increment connection count
+        existing.info = { ...existing.info, ...info, lastSeen: new Date().toISOString() };
+        existing.connectionCount++;
+    }
+    else {
+        onlineUsers.set(info.username, {
+            info: { ...info, lastSeen: new Date().toISOString() },
+            connectionCount: 1,
+        });
+    }
+}
+/**
+ * Update last seen time for a user
+ */
+export function updateUserLastSeen(username) {
+    const state = onlineUsers.get(username);
+    if (state) {
+        state.info.lastSeen = new Date().toISOString();
+    }
+}
+/**
+ * Unregister a user connection
+ */
+export function unregisterUserPresence(username) {
+    const state = onlineUsers.get(username);
+    if (state) {
+        state.connectionCount--;
+        if (state.connectionCount <= 0) {
+            onlineUsers.delete(username);
+        }
+    }
+}
+/**
+ * Check if a user is online
+ */
+export function isUserOnline(username) {
+    return onlineUsers.has(username);
+}
+/**
+ * Get info for a specific online user
+ */
+export function getOnlineUser(username) {
+    return onlineUsers.get(username)?.info;
+}
+/**
+ * Get list of all online users
+ */
+export function getOnlineUsers() {
+    return Array.from(onlineUsers.values()).map((state) => state.info);
+}
+/**
+ * Get online users formatted for remote agent discovery.
+ * Returns in the same format as RemoteAgent so daemons can route to users.
+ */
+export function getOnlineUsersForDiscovery() {
+    return getOnlineUsers().map((user) => ({
+        name: user.username,
+        status: 'online',
+        // Use special "cloud" identifier so daemon knows to route via cloud
+        daemonId: 'cloud',
+        daemonName: 'Cloud Dashboard',
+        machineId: 'cloud',
+        isHuman: true,
+        avatarUrl: user.avatarUrl,
+    }));
+}
+/**
+ * Clear all presence (for testing or shutdown)
+ */
+export function clearAllPresence() {
+    onlineUsers.clear();
+}
+//# sourceMappingURL=presence-registry.js.map

package/dist/daemon/agent-registry.d.ts

@@ -75,6 +75,11 @@ export declare class AgentRegistry {
      * Get a snapshot of all agents.
      */
     getAgents(): AgentRecord[];
+    /**
+     * Check if an agent exists in the registry (has connected before).
+     * Used by the router to determine if messages should be queued for offline agents.
+     */
+    has(agentName: string): boolean;
     /**
      * Remove an agent from the registry.
      */

package/dist/daemon/agent-registry.js

@@ -101,6 +101,13 @@ export class AgentRegistry {
     getAgents() {
         return Array.from(this.agents.values());
     }
+    /**
+     * Check if an agent exists in the registry (has connected before).
+     * Used by the router to determine if messages should be queued for offline agents.
+     */
+    has(agentName) {
+        return this.agents.has(agentName);
+    }
     /**
      * Remove an agent from the registry.
      */

package/dist/daemon/cloud-sync.d.ts

@@ -50,6 +50,7 @@ export declare class CloudSyncService extends EventEmitter {
     private machineId;
     private localAgents;
     private remoteAgents;
+    private remoteUsers;
     private connected;
     private storage;
     private lastMessageSyncTs;

package/dist/daemon/cloud-sync.js

@@ -22,6 +22,7 @@ export class CloudSyncService extends EventEmitter {
     machineId;
     localAgents = new Map();
     remoteAgents = [];
+    remoteUsers = [];
     connected = false;
     storage = null;
     lastMessageSyncTs = 0;
@@ -246,6 +247,13 @@ export class CloudSyncService extends EventEmitter {
         if (this.remoteAgents.length > 0) {
             this.emit('remote-agents-updated', this.remoteAgents);
         }
+        // Handle remote users (humans connected via cloud dashboard)
+        if (data.allUsers) {
+            this.remoteUsers = data.allUsers.filter((u) => !this.localAgents.has(u.name));
+            if (this.remoteUsers.length > 0) {
+                this.emit('remote-users-updated', this.remoteUsers);
+            }
+        }
     }
     /**
      * Fetch queued messages from cloud