agent-relay 1.1.0 → 1.2.3

package/dist/dashboard-server/server.js

@@ -5,6 +5,7 @@ import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import crypto from 'crypto';
+import { exec } from 'child_process';
 import { fileURLToPath } from 'url';
 import { SqliteStorageAdapter } from '../storage/sqlite-adapter.js';
 import { RelayClient } from '../wrapper/client.js';
@@ -12,7 +13,169 @@ import { computeNeedsAttention } from './needs-attention.js';
 import { computeSystemMetrics, formatPrometheusMetrics } from './metrics.js';
 import { MultiProjectClient } from '../bridge/multi-project-client.js';
 import { AgentSpawner } from '../bridge/spawner.js';
+import { listTrajectorySteps, getTrajectoryStatus, getTrajectoryHistory } from '../trajectory/integration.js';
 import { loadTeamsConfig } from '../bridge/teams-config.js';
+import { getMemoryMonitor } from '../resiliency/memory-monitor.js';
+import { detectWorkspacePath } from '../utils/project-namespace.js';
+import { startCLIAuth, getAuthSession, cancelAuthSession, submitAuthCode, completeAuthSession, getSupportedProviders, } from '../daemon/cli-auth.js';
+/**
+ * Initialize cloud persistence for session tracking.
+ *
+ * Activation modes:
+ * 1. Local dev: Set RELAY_CLOUD_ENABLED=true and DATABASE_URL
+ * 2. Cloud deployment: Plan-based - user must have Pro+ subscription
+ *    (enforced at cloud API level when linking daemon or enabling workspace)
+ *
+ * Session persistence (Pro+ feature) enables:
+ * - [[SUMMARY]] blocks saved to PostgreSQL
+ * - [[SESSION_END]] markers for session tracking
+ * - Session recovery and agent handoff
+ *
+ * @see canUseSessionPersistence in services/planLimits.ts
+ */
+async function initCloudPersistence(workspaceId) {
+    // Local dev mode: simple env var check
+    // Cloud mode: plan check happens at API level (daemon linking, workspace config)
+    if (process.env.RELAY_CLOUD_ENABLED !== 'true') {
+        return null;
+    }
+    try {
+        // Dynamic import to avoid loading cloud dependencies unless enabled
+        const { getDb } = await import('../cloud/db/drizzle.js');
+        const { agentSessions, agentSummaries } = await import('../cloud/db/schema.js');
+        const { eq } = await import('drizzle-orm');
+        const db = getDb();
+        console.log('[dashboard] Cloud persistence enabled');
+        // Track active sessions per agent with timestamps for TTL cleanup
+        const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+        const MAX_SESSIONS = 10000;
+        const agentSessionIds = new Map();
+        // Track pending session creation to prevent race conditions
+        const pendingSessionCreation = new Map();
+        // Periodic cleanup of stale sessions (every 5 minutes)
+        const cleanupInterval = setInterval(() => {
+            const now = Date.now();
+            let evicted = 0;
+            for (const [name, { lastActivity }] of agentSessionIds.entries()) {
+                if (now - lastActivity > SESSION_TTL_MS) {
+                    agentSessionIds.delete(name);
+                    evicted++;
+                }
+            }
+            if (evicted > 0) {
+                console.log(`[cloud] Evicted ${evicted} stale session entries`);
+            }
+        }, 5 * 60 * 1000);
+        // Don't keep process alive just for cleanup
+        cleanupInterval.unref();
+        // Helper to get or create session with race protection
+        const getOrCreateSession = async (agentName) => {
+            // Check cache first
+            const cached = agentSessionIds.get(agentName);
+            if (cached) {
+                return cached.id;
+            }
+            // Check if creation is already in progress
+            const pending = pendingSessionCreation.get(agentName);
+            if (pending) {
+                return pending;
+            }
+            // Create session with mutex
+            const creationPromise = (async () => {
+                try {
+                    // Double-check cache after acquiring "lock"
+                    const rechecked = agentSessionIds.get(agentName);
+                    if (rechecked) {
+                        return rechecked.id;
+                    }
+                    // Enforce max size - evict oldest if needed
+                    if (agentSessionIds.size >= MAX_SESSIONS) {
+                        let oldest = null;
+                        for (const [name, { lastActivity }] of agentSessionIds.entries()) {
+                            if (!oldest || lastActivity < oldest.time) {
+                                oldest = { name, time: lastActivity };
+                            }
+                        }
+                        if (oldest) {
+                            agentSessionIds.delete(oldest.name);
+                            console.log(`[cloud] Evicted oldest session for ${oldest.name} (max sessions reached)`);
+                        }
+                    }
+                    // Create a new session with null safety
+                    const result = await db.insert(agentSessions).values({
+                        workspaceId,
+                        agentName,
+                        status: 'active',
+                        startedAt: new Date(),
+                    }).returning();
+                    const session = result[0];
+                    if (!session) {
+                        throw new Error(`Failed to create session for agent ${agentName}`);
+                    }
+                    // Update cache
+                    agentSessionIds.set(agentName, { id: session.id, lastActivity: Date.now() });
+                    return session.id;
+                }
+                finally {
+                    pendingSessionCreation.delete(agentName);
+                }
+            })();
+            pendingSessionCreation.set(agentName, creationPromise);
+            return creationPromise;
+        };
+        return {
+            onSummary: async (agentName, event) => {
+                try {
+                    // Get or create session with race protection
+                    const sessionId = await getOrCreateSession(agentName);
+                    // Update activity timestamp
+                    agentSessionIds.set(agentName, { id: sessionId, lastActivity: Date.now() });
+                    // Insert summary
+                    await db.insert(agentSummaries).values({
+                        sessionId,
+                        agentName,
+                        summary: event.summary,
+                        createdAt: new Date(),
+                    });
+                    console.log(`[cloud] Saved summary for ${agentName}: ${event.summary.currentTask || 'no task'}`);
+                }
+                catch (err) {
+                    console.error(`[cloud] Failed to save summary for ${agentName}:`, err);
+                }
+            },
+            onSessionEnd: async (agentName, event) => {
+                try {
+                    const cached = agentSessionIds.get(agentName);
+                    if (cached) {
+                        // Update session as ended
+                        await db.update(agentSessions)
+                            .set({
+                            status: 'ended',
+                            endedAt: new Date(),
+                            endMarker: event.marker,
+                        })
+                            .where(eq(agentSessions.id, cached.id));
+                        agentSessionIds.delete(agentName);
+                        console.log(`[cloud] Session ended for ${agentName}: ${event.marker.summary || 'no summary'}`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[cloud] Failed to end session for ${agentName}:`, err);
+                }
+            },
+            destroy: () => {
+                clearInterval(cleanupInterval);
+                agentSessionIds.clear();
+                pendingSessionCreation.clear();
+                console.log('[cloud] Cloud persistence handler destroyed');
+            },
+        };
+    }
+    catch (err) {
+        console.warn('[dashboard] Cloud persistence not available:', err);
+        return null;
+    }
+}
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -105,9 +268,49 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
         ? new SqliteStorageAdapter({ dbPath })
         : undefined;
     // Initialize spawner if enabled
+    // Use detectWorkspacePath to find the actual repo directory in cloud workspaces
+    const workspacePath = detectWorkspacePath(projectRoot || dataDir);
+    console.log(`[dashboard] Workspace path: ${workspacePath}`);
+    // Pass dashboard port to spawner so spawned agents can call spawn/release APIs for nested spawning
     const spawner = enableSpawner
-        ? new AgentSpawner(projectRoot || dataDir, tmuxSession)
+        ? new AgentSpawner(workspacePath, tmuxSession, port)
         : undefined;
+    // Initialize cloud persistence and memory monitoring if enabled (RELAY_CLOUD_ENABLED=true)
+    if (spawner) {
+        // Use workspace ID from env or generate from project root
+        const workspaceId = process.env.RELAY_WORKSPACE_ID ||
+            crypto.createHash('sha256').update(projectRoot || dataDir).digest('hex').slice(0, 36);
+        initCloudPersistence(workspaceId).then((cloudHandler) => {
+            if (cloudHandler) {
+                spawner.setCloudPersistence(cloudHandler);
+            }
+        }).catch((err) => {
+            console.warn('[dashboard] Failed to initialize cloud persistence:', err);
+        });
+        // Initialize memory monitoring for cloud deployments
+        // Memory monitoring is enabled by default when cloud is enabled
+        if (process.env.RELAY_CLOUD_ENABLED === 'true' || process.env.RELAY_MEMORY_MONITORING === 'true') {
+            try {
+                const memoryMonitor = getMemoryMonitor({
+                    checkIntervalMs: 10000, // Check every 10 seconds
+                    enableTrendAnalysis: true,
+                    enableProactiveAlerts: true,
+                });
+                memoryMonitor.start();
+                console.log('[dashboard] Memory monitoring enabled');
+                // Register existing workers with memory monitor
+                const workers = spawner.getActiveWorkers();
+                for (const worker of workers) {
+                    if (worker.pid) {
+                        memoryMonitor.register(worker.name, worker.pid);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn('[dashboard] Failed to initialize memory monitoring:', err);
+            }
+        }
+    }
     process.on('uncaughtException', (err) => {
         console.error('Uncaught Exception:', err);
     });
@@ -244,7 +447,7 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                         evictedCount++;
                     }
                 }
-                catch (err) {
+                catch (_err) {
                     // Ignore errors for individual files (may have been deleted)
                 }
             }
@@ -928,20 +1131,27 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             getRecentSessions(),
             getAgentSummaries(),
         ]);
-        // Filter agents:
+        // Filter and separate agents from human users:
         // 1. Exclude "Dashboard" (internal agent, not a real team member)
         // 2. Exclude offline agents (no lastSeen or lastSeen > threshold)
+        // 3. Exclude agents without a known CLI (these are improperly registered or stale)
+        // 4. Separate human users (cli === 'dashboard') from AI agents
         const now = Date.now();
         // 30 seconds - aligns with heartbeat timeout (5s heartbeat * 6 multiplier = 30s)
         // This ensures agents disappear quickly after they stop responding to heartbeats
         const OFFLINE_THRESHOLD_MS = 30 * 1000;
-        const filteredAgents = Array.from(agentsMap.values()).filter(agent => {
+        // First pass: filter out invalid/offline entries
+        const validEntries = Array.from(agentsMap.values())
+            .filter(agent => {
             // Exclude Dashboard
             if (agent.name === 'Dashboard')
                 return false;
             // Exclude agents starting with __ (internal/system agents)
             if (agent.name.startsWith('__'))
                 return false;
+            // Exclude agents without a proper CLI (improperly registered or stale)
+            if (!agent.cli || agent.cli === 'Unknown')
+                return false;
             // Exclude offline agents (no lastSeen or too old)
             if (!agent.lastSeen)
                 return false;
@@ -950,8 +1160,22 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                 return false;
             return true;
         });
+        // Separate AI agents from human users
+        const filteredAgents = validEntries
+            .filter(agent => agent.cli !== 'dashboard')
+            .map(agent => ({
+            ...agent,
+            isHuman: false,
+        }));
+        const humanUsers = validEntries
+            .filter(agent => agent.cli === 'dashboard')
+            .map(agent => ({
+            ...agent,
+            isHuman: true,
+        }));
         return {
             agents: filteredAgents,
+            users: humanUsers,
             messages: allMessages,
             activity: allMessages, // For now, activity log is just the message log
             sessions,
@@ -1194,8 +1418,8 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             logSubscriptions.get(agentName).add(ws);
             console.log(`[dashboard] Client subscribed to logs for: ${agentName} (spawned: ${isSpawned}, daemon: ${isDaemon})`);
             if (isSpawned && spawner) {
-                // Send initial log history for spawned agents
-                const lines = spawner.getWorkerOutput(agentName, 200);
+                // Send initial log history for spawned agents (5000 lines to match xterm scrollback capacity)
+                const lines = spawner.getWorkerOutput(agentName, 5000);
                 ws.send(JSON.stringify({
                     type: 'history',
                     agent: agentName,
@@ -1258,11 +1482,51 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             console.log(`[dashboard] Logs WebSocket client disconnected (code: ${code}, reason: ${reasonStr})`);
         });
     });
+    // Deduplication for log output - prevent same content from being broadcast multiple times
+    // Key: agentName -> Set of recent content hashes (rolling window)
+    const recentLogHashes = new Map();
+    const MAX_LOG_HASH_WINDOW = 50; // Keep last 50 hashes per agent
+    // Simple hash function for log dedup
+    const hashLogContent = (content) => {
+        // Normalize whitespace and create a simple hash
+        const normalized = content.replace(/\s+/g, ' ').trim().slice(0, 200);
+        let hash = 0;
+        for (let i = 0; i < normalized.length; i++) {
+            const char = normalized.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    };
     // Function to broadcast log output to subscribed clients
     const broadcastLogOutput = (agentName, output) => {
         const clients = logSubscriptions.get(agentName);
         if (!clients || clients.size === 0)
             return;
+        // Skip empty or whitespace-only output
+        const trimmed = output.trim();
+        if (!trimmed)
+            return;
+        // Dedup: Check if we've recently broadcast this content
+        const hash = hashLogContent(output);
+        let agentHashes = recentLogHashes.get(agentName);
+        if (!agentHashes) {
+            agentHashes = new Set();
+            recentLogHashes.set(agentName, agentHashes);
+        }
+        if (agentHashes.has(hash)) {
+            // Already broadcast this content recently, skip
+            return;
+        }
+        // Add to rolling window
+        agentHashes.add(hash);
+        if (agentHashes.size > MAX_LOG_HASH_WINDOW) {
+            // Remove oldest entry (first in Set iteration order)
+            const oldest = agentHashes.values().next().value;
+            if (oldest !== undefined) {
+                agentHashes.delete(oldest);
+            }
+        }
         const payload = JSON.stringify({
             type: 'output',
             agent: agentName,
@@ -1291,8 +1555,35 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
     const getOnlineUsersList = () => {
         return Array.from(onlineUsers.values()).map((state) => state.info);
     };
+    // Heartbeat to detect dead connections (30 seconds)
+    const PRESENCE_HEARTBEAT_INTERVAL = 30000;
+    const presenceHealth = new WeakMap();
+    const presenceHeartbeat = setInterval(() => {
+        wssPresence.clients.forEach((ws) => {
+            const health = presenceHealth.get(ws);
+            if (!health) {
+                presenceHealth.set(ws, { isAlive: true });
+                return;
+            }
+            if (!health.isAlive) {
+                ws.terminate();
+                return;
+            }
+            health.isAlive = false;
+            ws.ping();
+        });
+    }, PRESENCE_HEARTBEAT_INTERVAL);
+    wssPresence.on('close', () => {
+        clearInterval(presenceHeartbeat);
+    });
     wssPresence.on('connection', (ws) => {
-        console.log('[dashboard] Presence WebSocket client connected');
+        // Initialize health tracking (no log - too noisy)
+        presenceHealth.set(ws, { isAlive: true });
+        ws.on('pong', () => {
+            const health = presenceHealth.get(ws);
+            if (health)
+                health.isAlive = true;
+        });
         let clientUsername;
         ws.on('message', (data) => {
             try {
@@ -1318,7 +1609,11 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
                             // Add this connection to existing user
                             existing.connections.add(ws);
                             existing.info.lastSeen = now;
-                            console.log(`[dashboard] User ${username} opened new tab (${existing.connections.size} connections)`);
+                            // Only log at milestones to reduce noise
+                            const count = existing.connections.size;
+                            if (count === 2 || count === 5 || count === 10 || count % 50 === 0) {
+                                console.log(`[dashboard] User ${username} has ${count} connections`);
+                            }
                         }
                         else {
                             // New user - create presence state
@@ -1495,6 +1790,172 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             websocketClients: wss.clients.size,
         });
     });
+    // ===== CLI Auth API (for workspace-based provider authentication) =====
+    /**
+     * POST /auth/cli/:provider/start - Start CLI auth flow
+     * Body: { useDeviceFlow?: boolean }
+     */
+    app.post('/auth/cli/:provider/start', async (req, res) => {
+        const { provider } = req.params;
+        const { useDeviceFlow } = req.body || {};
+        try {
+            const session = await startCLIAuth(provider, { useDeviceFlow });
+            res.json({
+                sessionId: session.id,
+                status: session.status,
+                authUrl: session.authUrl,
+            });
+        }
+        catch (err) {
+            res.status(400).json({
+                error: err instanceof Error ? err.message : 'Failed to start CLI auth',
+            });
+        }
+    });
+    /**
+     * GET /auth/cli/:provider/status/:sessionId - Get auth session status
+     */
+    app.get('/auth/cli/:provider/status/:sessionId', (req, res) => {
+        const { sessionId } = req.params;
+        const session = getAuthSession(sessionId);
+        if (!session) {
+            return res.status(404).json({ error: 'Session not found' });
+        }
+        res.json({
+            status: session.status,
+            authUrl: session.authUrl,
+            error: session.error,
+        });
+    });
+    /**
+     * GET /auth/cli/:provider/creds/:sessionId - Get credentials from completed auth
+     */
+    app.get('/auth/cli/:provider/creds/:sessionId', (req, res) => {
+        const { sessionId } = req.params;
+        const session = getAuthSession(sessionId);
+        if (!session) {
+            return res.status(404).json({ error: 'Session not found' });
+        }
+        if (session.status !== 'success') {
+            return res.status(400).json({ error: 'Auth not complete', status: session.status });
+        }
+        res.json({
+            token: session.token,
+            refreshToken: session.refreshToken,
+            expiresAt: session.tokenExpiresAt?.toISOString(),
+        });
+    });
+    /**
+     * POST /auth/cli/:provider/cancel/:sessionId - Cancel auth session
+     */
+    app.post('/auth/cli/:provider/cancel/:sessionId', (req, res) => {
+        const { sessionId } = req.params;
+        const cancelled = cancelAuthSession(sessionId);
+        if (!cancelled) {
+            return res.status(404).json({ error: 'Session not found' });
+        }
+        res.json({ success: true });
+    });
+    /**
+     * POST /auth/cli/:provider/code/:sessionId - Submit auth code to PTY
+     * Used when OAuth returns a code that must be pasted into the CLI
+     */
+    app.post('/auth/cli/:provider/code/:sessionId', async (req, res) => {
+        const { provider, sessionId } = req.params;
+        const { code } = req.body;
+        console.log('[cli-auth] Auth code submission received', { provider, sessionId, codeLength: code?.length });
+        if (!code || typeof code !== 'string') {
+            return res.status(400).json({ error: 'Auth code is required' });
+        }
+        try {
+            const result = await submitAuthCode(sessionId, code);
+            console.log('[cli-auth] Auth code submission result', { provider, sessionId, result });
+            if (!result.success) {
+                // Use 400 for all errors since they can be retried
+                return res.status(400).json({
+                    error: result.error || 'Session not found or process not running',
+                    needsRestart: result.needsRestart ?? true,
+                });
+            }
+            // Wait a few seconds for CLI to process and write credentials
+            // The 1s delay in submitAuthCode + CLI processing time means credentials
+            // should be available within 3-5 seconds
+            let sessionStatus = 'waiting_auth';
+            for (let i = 0; i < 10; i++) {
+                await new Promise(resolve => setTimeout(resolve, 500));
+                const session = getAuthSession(sessionId);
+                if (session?.status === 'success') {
+                    sessionStatus = 'success';
+                    console.log('[cli-auth] Credentials found after code submission', { provider, sessionId, attempt: i + 1 });
+                    break;
+                }
+                if (session?.status === 'error') {
+                    sessionStatus = 'error';
+                    break;
+                }
+            }
+            res.json({
+                success: true,
+                message: 'Auth code submitted',
+                status: sessionStatus,
+            });
+        }
+        catch (err) {
+            console.error('[cli-auth] Auth code submission error', { provider, sessionId, error: String(err) });
+            return res.status(500).json({
+                error: 'Internal error submitting auth code. Please try again.',
+                needsRestart: true,
+            });
+        }
+    });
+    /**
+     * POST /auth/cli/:provider/complete/:sessionId - Complete auth
+     * For providers like Claude: just polls for credentials
+     * For providers like Codex: accepts authCode (redirect URL) and extracts the code
+     */
+    app.post('/auth/cli/:provider/complete/:sessionId', async (req, res) => {
+        const { sessionId } = req.params;
+        const { authCode } = req.body || {};
+        // If authCode provided, try to extract code and submit it
+        if (authCode && typeof authCode === 'string') {
+            let code = authCode;
+            // If it's a URL, extract the code parameter
+            if (authCode.startsWith('http')) {
+                try {
+                    const url = new URL(authCode);
+                    const codeParam = url.searchParams.get('code');
+                    if (codeParam) {
+                        code = codeParam;
+                    }
+                }
+                catch {
+                    // Not a valid URL, use as-is
+                }
+            }
+            // Submit the code to the CLI process
+            const submitResult = await submitAuthCode(sessionId, code);
+            if (!submitResult.success) {
+                return res.status(400).json({
+                    error: submitResult.error,
+                    needsRestart: submitResult.needsRestart,
+                });
+            }
+            // Wait a moment for credentials to be written
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        // Poll for credentials
+        const result = await completeAuthSession(sessionId);
+        if (!result.success) {
+            return res.status(400).json({ error: result.error });
+        }
+        res.json({ success: true, message: 'Authentication complete' });
+    });
+    /**
+     * GET /auth/cli/providers - List supported providers
+     */
+    app.get('/auth/cli/providers', (req, res) => {
+        res.json({ providers: getSupportedProviders() });
+    });
     // ===== Metrics API =====
     /**
      * GET /api/metrics - JSON format metrics for dashboard
@@ -1564,6 +2025,197 @@ export async function startDashboard(portOrOptions, dataDirArg, teamDirArg, dbPa
             res.status(500).send('# Error computing metrics\n');
         }
     });
+    // ===== Agent Memory Metrics API =====
+    /**
+     * GET /api/metrics/agents - Detailed agent memory and resource metrics
+     */
+    app.get('/api/metrics/agents', async (req, res) => {
+        try {
+            const agents = [];
+            // Get metrics from spawner's active workers
+            if (spawner) {
+                const activeWorkers = spawner.getActiveWorkers();
+                for (const worker of activeWorkers) {
+                    // Get memory usage via ps command
+                    let rssBytes = 0;
+                    let cpuPercent = 0;
+                    if (worker.pid) {
+                        try {
+                            const { execSync } = await import('child_process');
+                            const output = execSync(`ps -o rss=,pcpu= -p ${worker.pid}`, {
+                                encoding: 'utf8',
+                                timeout: 3000,
+                            }).trim();
+                            const parts = output.split(/\s+/);
+                            rssBytes = parseInt(parts[0] || '0', 10) * 1024;
+                            cpuPercent = parseFloat(parts[1] || '0');
+                        }
+                        catch {
+                            // Process may have exited
+                        }
+                    }
+                    agents.push({
+                        name: worker.name,
+                        pid: worker.pid,
+                        status: worker.pid ? 'running' : 'unknown',
+                        rssBytes,
+                        cpuPercent,
+                        trend: 'unknown',
+                        alertLevel: rssBytes > 1024 * 1024 * 1024 ? 'critical' :
+                            rssBytes > 512 * 1024 * 1024 ? 'warning' : 'normal',
+                        highWatermark: rssBytes,
+                        uptimeMs: worker.spawnedAt ? Date.now() - worker.spawnedAt : 0,
+                        startedAt: worker.spawnedAt ? new Date(worker.spawnedAt).toISOString() : undefined,
+                    });
+                }
+            }
+            // Also check agents.json for registered agents that may not be spawned
+            const agentsPath = path.join(teamDir, 'agents.json');
+            if (fs.existsSync(agentsPath)) {
+                const data = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+                const registeredAgents = data.agents || [];
+                for (const agent of registeredAgents) {
+                    if (!agents.find(a => a.name === agent.name)) {
+                        // Check if recently active (within 30 seconds)
+                        const lastSeen = agent.lastSeen ? new Date(agent.lastSeen).getTime() : 0;
+                        const isActive = Date.now() - lastSeen < 30000;
+                        if (isActive) {
+                            agents.push({
+                                name: agent.name,
+                                status: 'active',
+                                alertLevel: 'normal',
+                            });
+                        }
+                    }
+                }
+            }
+            res.json({
+                agents,
+                system: {
+                    totalMemory: os.totalmem(),
+                    freeMemory: os.freemem(),
+                    heapUsed: process.memoryUsage().heapUsed,
+                },
+            });
+        }
+        catch (err) {
+            console.error('Failed to get agent metrics', err);
+            res.status(500).json({ error: 'Failed to get agent metrics' });
+        }
+    });
+    /**
+     * GET /api/metrics/health - System health and crash insights
+     */
+    app.get('/api/metrics/health', async (req, res) => {
+        try {
+            // Calculate health score based on available data
+            let healthScore = 100;
+            const issues = [];
+            const recommendations = [];
+            const crashes = [];
+            const alerts = [];
+            let agentCount = 0;
+            const totalCrashes24h = 0;
+            let totalAlerts24h = 0;
+            // Get spawned agent count
+            if (spawner) {
+                const workers = spawner.getActiveWorkers();
+                agentCount = workers.length;
+                // Check for high memory usage
+                for (const worker of workers) {
+                    if (worker.pid) {
+                        try {
+                            const { execSync } = await import('child_process');
+                            const output = execSync(`ps -o rss= -p ${worker.pid}`, {
+                                encoding: 'utf8',
+                                timeout: 3000,
+                            }).trim();
+                            const rssBytes = parseInt(output, 10) * 1024;
+                            if (rssBytes > 1.5 * 1024 * 1024 * 1024) {
+                                // > 1.5GB
+                                healthScore -= 20;
+                                issues.push({
+                                    severity: 'critical',
+                                    message: `Agent "${worker.name}" is using ${Math.round(rssBytes / 1024 / 1024)}MB of memory`,
+                                });
+                                totalAlerts24h++;
+                                alerts.push({
+                                    id: `alert-${Date.now()}-${worker.name}`,
+                                    agentName: worker.name,
+                                    alertType: 'oom_imminent',
+                                    message: `Memory usage critical: ${Math.round(rssBytes / 1024 / 1024)}MB`,
+                                    createdAt: new Date().toISOString(),
+                                });
+                            }
+                            else if (rssBytes > 1024 * 1024 * 1024) {
+                                // > 1GB
+                                healthScore -= 10;
+                                issues.push({
+                                    severity: 'high',
+                                    message: `Agent "${worker.name}" memory usage is elevated (${Math.round(rssBytes / 1024 / 1024)}MB)`,
+                                });
+                            }
+                        }
+                        catch {
+                            // Process may have exited
+                        }
+                    }
+                }
+            }
+            // Check registered agents
+            const agentsPath = path.join(teamDir, 'agents.json');
+            if (fs.existsSync(agentsPath)) {
+                const data = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+                const registeredAgents = data.agents || [];
+                const activeAgents = registeredAgents.filter((a) => {
+                    const lastSeen = a.lastSeen ? new Date(a.lastSeen).getTime() : 0;
+                    return Date.now() - lastSeen < 30000;
+                });
+                agentCount = Math.max(agentCount, activeAgents.length);
+            }
+            // Generate recommendations based on issues
+            if (issues.some(i => i.severity === 'critical')) {
+                recommendations.push('Consider restarting agents with high memory usage');
+                recommendations.push('Monitor system resources closely');
+            }
+            if (agentCount === 0) {
+                recommendations.push('No active agents detected - start agents to begin monitoring');
+            }
+            // Clamp health score
+            healthScore = Math.max(0, Math.min(100, healthScore));
+            // Generate summary
+            let summary;
+            if (healthScore >= 90) {
+                summary = 'System is healthy. All agents operating normally.';
+            }
+            else if (healthScore >= 70) {
+                summary = 'Some issues detected. Review warnings and recommendations.';
+            }
+            else if (healthScore >= 50) {
+                summary = 'Multiple issues detected. Action recommended.';
+            }
+            else {
+                summary = 'Critical issues detected. Immediate action required.';
+            }
+            res.json({
+                healthScore,
+                summary,
+                issues,
+                recommendations,
+                crashes,
+                alerts,
+                stats: {
+                    totalCrashes24h,
+                    totalAlerts24h,
+                    agentCount,
+                },
+            });
+        }
+        catch (err) {
+            console.error('Failed to compute health metrics', err);
+            res.status(500).json({ error: 'Failed to compute health metrics' });
+        }
+    });
     // ===== File Search API =====
     /**
      * GET /api/files - Search for files in the repository
@@ -2087,6 +2739,654 @@ Start by greeting the project leads and asking for status updates.`;
             });
         }
     });
+    /**
+     * GET /api/trajectory - Get current trajectory status
+     */
+    app.get('/api/trajectory', async (_req, res) => {
+        try {
+            const status = await getTrajectoryStatus();
+            res.json({
+                success: true,
+                ...status,
+            });
+        }
+        catch (err) {
+            console.error('[api] Trajectory status error:', err);
+            res.status(500).json({
+                success: false,
+                error: err.message,
+            });
+        }
+    });
+    /**
+     * GET /api/trajectory/steps - List trajectory steps
+     */
+    app.get('/api/trajectory/steps', async (req, res) => {
+        try {
+            const trajectoryId = req.query.trajectoryId;
+            const result = await listTrajectorySteps(trajectoryId);
+            if (result.success) {
+                res.json({
+                    success: true,
+                    steps: result.steps,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    steps: [],
+                    error: result.error,
+                });
+            }
+        }
+        catch (err) {
+            console.error('[api] Trajectory steps error:', err);
+            res.status(500).json({
+                success: false,
+                steps: [],
+                error: err.message,
+            });
+        }
+    });
+    /**
+     * GET /api/trajectory/history - List all trajectories (completed and active)
+     */
+    app.get('/api/trajectory/history', async (_req, res) => {
+        try {
+            const result = await getTrajectoryHistory();
+            if (result.success) {
+                res.json({
+                    success: true,
+                    trajectories: result.trajectories,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    trajectories: [],
+                    error: result.error,
+                });
+            }
+        }
+        catch (err) {
+            console.error('[api] Trajectory history error:', err);
+            res.status(500).json({
+                success: false,
+                trajectories: [],
+                error: err.message,
+            });
+        }
+    });
+    // ===== Settings API =====
+    /**
+     * GET /api/settings - Get all workspace settings with documentation
+     */
+    app.get('/api/settings', async (_req, res) => {
+        try {
+            const { readRelayConfig, shouldStoreInRepo, getTrajectoriesStorageDescription } = await import('../trajectory/config.js');
+            const config = readRelayConfig();
+            res.json({
+                success: true,
+                settings: {
+                    trajectories: {
+                        storeInRepo: shouldStoreInRepo(),
+                        storageLocation: getTrajectoriesStorageDescription(),
+                        description: 'Trajectories record the journey of agent work using the PDERO paradigm (Plan, Design, Execute, Review, Observe). They capture decisions, phase transitions, and retrospectives.',
+                        benefits: [
+                            'Track why decisions were made, not just what was built',
+                            'Enable session recovery when agents crash or context is lost',
+                            'Provide learning data for future agents working on similar tasks',
+                            'Create an audit trail of agent work for review',
+                        ],
+                        learnMore: 'https://pdero.com',
+                        optInReason: 'Enable "Store in repo" to version-control your trajectories alongside your code. This is useful for teams who want to review agent decision-making processes.',
+                    },
+                },
+                config,
+            });
+        }
+        catch (err) {
+            console.error('[api] Settings error:', err);
+            res.status(500).json({
+                success: false,
+                error: err.message,
+            });
+        }
+    });
+    /**
+     * GET /api/settings/trajectory - Get trajectory storage settings
+     */
+    app.get('/api/settings/trajectory', async (_req, res) => {
+        try {
+            const { readRelayConfig, shouldStoreInRepo, getTrajectoriesStorageDescription } = await import('../trajectory/config.js');
+            const config = readRelayConfig();
+            res.json({
+                success: true,
+                settings: {
+                    storeInRepo: shouldStoreInRepo(),
+                    storageLocation: getTrajectoriesStorageDescription(),
+                },
+                config: config.trajectories || {},
+                // Documentation for the UI
+                documentation: {
+                    title: 'Trajectory Storage',
+                    description: 'Trajectories record the journey of agent work using the PDERO paradigm (Plan, Design, Execute, Review, Observe).',
+                    whatIsIt: 'A trajectory captures not just what an agent built, but WHY it made specific decisions. This includes phase transitions, key decisions with reasoning, and retrospective summaries.',
+                    benefits: [
+                        'Understand agent decision-making for code review',
+                        'Enable session recovery if agents crash',
+                        'Train future agents on your codebase patterns',
+                        'Create audit trails of AI work',
+                    ],
+                    storeInRepoExplanation: 'When enabled, trajectories are stored in .trajectories/ in your repo and can be committed to source control. When disabled (default), they are stored in your user directory (~/.config/agent-relay/trajectories/).',
+                    learnMore: 'https://pdero.com',
+                },
+            });
+        }
+        catch (err) {
+            console.error('[api] Settings trajectory error:', err);
+            res.status(500).json({
+                success: false,
+                error: err.message,
+            });
+        }
+    });
+    /**
+     * PUT /api/settings/trajectory - Update trajectory storage settings
+     *
+     * Body: { storeInRepo: boolean }
+     *
+     * This writes to .relay/config.json in the project root
+     */
+    app.put('/api/settings/trajectory', async (req, res) => {
+        try {
+            const { storeInRepo } = req.body;
+            if (typeof storeInRepo !== 'boolean') {
+                return res.status(400).json({
+                    success: false,
+                    error: 'storeInRepo must be a boolean',
+                });
+            }
+            const { getRelayConfigPath, readRelayConfig } = await import('../trajectory/config.js');
+            const { getProjectPaths } = await import('../utils/project-namespace.js');
+            const { projectRoot: _projectRoot } = getProjectPaths();
+            // Read existing config
+            const config = readRelayConfig();
+            // Update trajectory settings
+            config.trajectories = {
+                ...config.trajectories,
+                storeInRepo,
+            };
+            // Ensure .relay directory exists
+            const configPath = getRelayConfigPath();
+            const configDir = path.dirname(configPath);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            // Write updated config
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            res.json({
+                success: true,
+                settings: {
+                    storeInRepo,
+                    storageLocation: storeInRepo ? 'repo (.trajectories/)' : 'user (~/.config/agent-relay/trajectories/)',
+                },
+            });
+        }
+        catch (err) {
+            console.error('[api] Settings trajectory update error:', err);
+            res.status(500).json({
+                success: false,
+                error: err.message,
+            });
+        }
+    });
+    const decisions = new Map();
+    /**
+     * GET /api/decisions - List all pending decisions
+     */
+    app.get('/api/decisions', (_req, res) => {
+        const allDecisions = Array.from(decisions.values())
+            .sort((a, b) => {
+            const urgencyOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            return urgencyOrder[a.urgency] - urgencyOrder[b.urgency];
+        });
+        res.json({ success: true, decisions: allDecisions });
+    });
+    /**
+     * POST /api/decisions - Create a new decision request
+     * Body: { agentName, title, description, options?, urgency, category, expiresAt?, context? }
+     */
+    app.post('/api/decisions', (req, res) => {
+        const { agentName, title, description, options, urgency, category, expiresAt, context } = req.body;
+        if (!agentName || !title || !urgency || !category) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required fields: agentName, title, urgency, category',
+            });
+        }
+        const decision = {
+            id: `decision-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            agentName,
+            title,
+            description: description || '',
+            options,
+            urgency,
+            category,
+            createdAt: new Date().toISOString(),
+            expiresAt,
+            context,
+        };
+        decisions.set(decision.id, decision);
+        // Broadcast to WebSocket clients
+        broadcastData().catch(() => { });
+        res.json({ success: true, decision });
+    });
+    /**
+     * POST /api/decisions/:id/approve - Approve/resolve a decision
+     * Body: { optionId?: string, response?: string }
+     */
+    app.post('/api/decisions/:id/approve', async (req, res) => {
+        const { id } = req.params;
+        const { optionId, response } = req.body;
+        const decision = decisions.get(id);
+        if (!decision) {
+            return res.status(404).json({ success: false, error: 'Decision not found' });
+        }
+        // Send response to the agent via relay
+        const agentName = decision.agentName;
+        let responseMessage = `DECISION APPROVED: ${decision.title}`;
+        if (optionId && decision.options) {
+            const option = decision.options.find(o => o.id === optionId);
+            if (option) {
+                responseMessage += `\nSelected: ${option.label}`;
+            }
+        }
+        if (response) {
+            responseMessage += `\nResponse: ${response}`;
+        }
+        // Try to send message to agent
+        try {
+            const client = await getRelayClient('Dashboard');
+            if (client) {
+                await client.sendMessage(agentName, responseMessage, 'message');
+            }
+        }
+        catch (err) {
+            console.warn('[api] Could not send decision response to agent:', err);
+        }
+        decisions.delete(id);
+        broadcastData().catch(() => { });
+        res.json({ success: true, message: 'Decision approved' });
+    });
+    /**
+     * POST /api/decisions/:id/reject - Reject a decision
+     * Body: { reason?: string }
+     */
+    app.post('/api/decisions/:id/reject', async (req, res) => {
+        const { id } = req.params;
+        const { reason } = req.body;
+        const decision = decisions.get(id);
+        if (!decision) {
+            return res.status(404).json({ success: false, error: 'Decision not found' });
+        }
+        // Send rejection to the agent
+        const agentName = decision.agentName;
+        let responseMessage = `DECISION REJECTED: ${decision.title}`;
+        if (reason) {
+            responseMessage += `\nReason: ${reason}`;
+        }
+        try {
+            const client = await getRelayClient('Dashboard');
+            if (client) {
+                await client.sendMessage(agentName, responseMessage, 'message');
+            }
+        }
+        catch (err) {
+            console.warn('[api] Could not send decision rejection to agent:', err);
+        }
+        decisions.delete(id);
+        broadcastData().catch(() => { });
+        res.json({ success: true, message: 'Decision rejected' });
+    });
+    /**
+     * DELETE /api/decisions/:id - Delete/dismiss a decision
+     */
+    app.delete('/api/decisions/:id', (_req, res) => {
+        const { id } = _req.params;
+        if (!decisions.has(id)) {
+            return res.status(404).json({ success: false, error: 'Decision not found' });
+        }
+        decisions.delete(id);
+        broadcastData().catch(() => { });
+        res.json({ success: true, message: 'Decision dismissed' });
+    });
+    /**
+     * GET /api/fleet/servers - Get fleet server overview
+     * Returns local daemon info + any connected bridge servers
+     * Note: When bridge is active, local agents are already included in bridge project agents,
+     * so we don't add a separate "Local Daemon" entry to avoid double-counting.
+     */
+    app.get('/api/fleet/servers', async (_req, res) => {
+        const servers = [];
+        const localAgents = spawner?.getActiveWorkers() || [];
+        const agentStatuses = await loadAgentStatuses();
+        let hasBridgeProjects = false;
+        // Check for bridge connections first
+        const bridgeStatePath = path.join(dataDir, 'bridge-state.json');
+        if (fs.existsSync(bridgeStatePath)) {
+            try {
+                const bridgeState = JSON.parse(fs.readFileSync(bridgeStatePath, 'utf-8'));
+                if (bridgeState.projects && bridgeState.projects.length > 0) {
+                    hasBridgeProjects = true;
+                    for (const project of bridgeState.projects) {
+                        // Enrich with actual online agents from agents.json (same logic as getBridgeData)
+                        // This fixes the bug where stale agents were counted
+                        let projectAgents = [];
+                        if (project.path) {
+                            const projectHash = crypto.createHash('sha256').update(project.path).digest('hex').slice(0, 12);
+                            const projectDataDir = path.join(path.dirname(dataDir), projectHash);
+                            const projectTeamDir = path.join(projectDataDir, 'team');
+                            const agentsPath = path.join(projectTeamDir, 'agents.json');
+                            if (fs.existsSync(agentsPath)) {
+                                try {
+                                    const agentsData = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+                                    if (agentsData.agents && Array.isArray(agentsData.agents)) {
+                                        // Filter to only show online agents (seen within 30 seconds)
+                                        const thirtySecondsAgo = Date.now() - 30 * 1000;
+                                        projectAgents = agentsData.agents
+                                            .filter((a) => {
+                                            if (!a.lastSeen)
+                                                return false;
+                                            return new Date(a.lastSeen).getTime() > thirtySecondsAgo;
+                                        })
+                                            .map((a) => ({
+                                            name: a.name,
+                                            status: 'online',
+                                        }));
+                                    }
+                                }
+                                catch (e) {
+                                    console.warn(`[api] Failed to read agents for ${project.path}:`, e);
+                                }
+                            }
+                        }
+                        servers.push({
+                            id: project.id,
+                            name: project.name || project.path.split('/').pop() || project.id,
+                            status: project.connected ? 'healthy' : 'offline',
+                            agents: projectAgents,
+                            cpuUsage: 0,
+                            memoryUsage: 0,
+                            activeConnections: project.connected ? 1 : 0,
+                            uptime: 0,
+                            lastHeartbeat: project.lastSeen || new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                console.warn('[api] Failed to read bridge state:', err);
+            }
+        }
+        // Only add local daemon entry if we don't have bridge projects
+        // (otherwise local agents are already counted in the bridge project)
+        if (!hasBridgeProjects) {
+            servers.push({
+                id: 'local',
+                name: 'Local Daemon',
+                status: 'healthy',
+                agents: localAgents.map(a => ({
+                    name: a.name,
+                    status: agentStatuses[a.name]?.status || 'unknown',
+                })),
+                cpuUsage: Math.random() * 30, // Mock - would come from actual metrics
+                memoryUsage: Math.random() * 50,
+                activeConnections: wss.clients.size,
+                uptime: process.uptime(),
+                lastHeartbeat: new Date().toISOString(),
+            });
+        }
+        res.json({ success: true, servers });
+    });
+    /**
+     * GET /api/fleet/stats - Get aggregate fleet statistics
+     */
+    app.get('/api/fleet/stats', async (_req, res) => {
+        const localAgents = spawner?.getActiveWorkers() || [];
+        const agentStatuses = await loadAgentStatuses();
+        const totalAgents = localAgents.length;
+        let onlineAgents = 0;
+        let busyAgents = 0;
+        for (const agent of localAgents) {
+            const status = agentStatuses[agent.name]?.status;
+            if (status === 'online')
+                onlineAgents++;
+            if (status === 'busy')
+                busyAgents++;
+        }
+        res.json({
+            success: true,
+            stats: {
+                totalAgents,
+                onlineAgents,
+                busyAgents,
+                pendingDecisions: decisions.size,
+                activeTasks: Array.from(tasks.values()).filter(t => t.status === 'assigned' || t.status === 'in_progress').length,
+            },
+        });
+    });
+    const tasks = new Map();
+    /**
+     * GET /api/tasks - List all tasks
+     */
+    app.get('/api/tasks', (req, res) => {
+        const status = req.query.status;
+        const agentName = req.query.agent;
+        let allTasks = Array.from(tasks.values());
+        if (status) {
+            allTasks = allTasks.filter(t => t.status === status);
+        }
+        if (agentName) {
+            allTasks = allTasks.filter(t => t.agentName === agentName);
+        }
+        // Sort by priority and creation time
+        allTasks.sort((a, b) => {
+            const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0)
+                return priorityDiff;
+            return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+        });
+        res.json({ success: true, tasks: allTasks });
+    });
+    /**
+     * POST /api/tasks - Create and assign a task
+     * Body: { agentName, title, description, priority }
+     */
+    app.post('/api/tasks', async (req, res) => {
+        const { agentName, title, description, priority } = req.body;
+        if (!agentName || !title || !priority) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required fields: agentName, title, priority',
+            });
+        }
+        const task = {
+            id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            agentName,
+            title,
+            description: description || '',
+            priority,
+            status: 'assigned',
+            createdAt: new Date().toISOString(),
+            assignedAt: new Date().toISOString(),
+        };
+        tasks.set(task.id, task);
+        // Send task to agent via relay
+        try {
+            const client = await getRelayClient('Dashboard');
+            if (client) {
+                const taskMessage = `TASK ASSIGNED [${priority.toUpperCase()}]: ${title}\n\n${description || 'No additional details.'}`;
+                await client.sendMessage(agentName, taskMessage, 'message');
+            }
+        }
+        catch (err) {
+            console.warn('[api] Could not send task to agent:', err);
+        }
+        broadcastData().catch(() => { });
+        res.json({ success: true, task });
+    });
+    /**
+     * PATCH /api/tasks/:id - Update task status
+     * Body: { status, result? }
+     */
+    app.patch('/api/tasks/:id', (req, res) => {
+        const { id } = req.params;
+        const { status, result } = req.body;
+        const task = tasks.get(id);
+        if (!task) {
+            return res.status(404).json({ success: false, error: 'Task not found' });
+        }
+        if (status) {
+            task.status = status;
+            if (status === 'completed' || status === 'failed') {
+                task.completedAt = new Date().toISOString();
+            }
+        }
+        if (result !== undefined) {
+            task.result = result;
+        }
+        tasks.set(id, task);
+        broadcastData().catch(() => { });
+        res.json({ success: true, task });
+    });
+    /**
+     * DELETE /api/tasks/:id - Cancel/delete a task
+     */
+    app.delete('/api/tasks/:id', async (req, res) => {
+        const { id } = req.params;
+        const task = tasks.get(id);
+        if (!task) {
+            return res.status(404).json({ success: false, error: 'Task not found' });
+        }
+        // Notify agent of cancellation if task is still active
+        if (task.status === 'pending' || task.status === 'assigned' || task.status === 'in_progress') {
+            try {
+                const client = await getRelayClient('Dashboard');
+                if (client) {
+                    await client.sendMessage(task.agentName, `TASK CANCELLED: ${task.title}`, 'message');
+                }
+            }
+            catch (err) {
+                console.warn('[api] Could not send task cancellation to agent:', err);
+            }
+        }
+        tasks.delete(id);
+        broadcastData().catch(() => { });
+        res.json({ success: true, message: 'Task cancelled' });
+    });
+    // ===== Beads Integration API =====
+    /**
+     * POST /api/beads - Create a bead (task/issue) via the bd CLI
+     */
+    app.post('/api/beads', async (req, res) => {
+        const { title, assignee, priority, type, description: _description } = req.body;
+        if (!title || typeof title !== 'string') {
+            return res.status(400).json({ success: false, error: 'Title is required' });
+        }
+        // Build bd create command
+        const args = ['create', `--title="${title.replace(/"/g, '\\"')}"`];
+        if (assignee) {
+            args.push(`--assignee=${assignee}`);
+        }
+        if (priority !== undefined && priority !== null) {
+            args.push(`--priority=${priority}`);
+        }
+        if (type && ['task', 'bug', 'feature'].includes(type)) {
+            args.push(`--type=${type}`);
+        }
+        const cmd = `bd ${args.join(' ')}`;
+        console.log('[api/beads] Creating bead:', cmd);
+        // Execute bd create command
+        exec(cmd, { cwd: dataDir }, (error, stdout, stderr) => {
+            if (error) {
+                console.error('[api/beads] bd create failed:', stderr || error.message);
+                return res.status(500).json({
+                    success: false,
+                    error: stderr || error.message || 'Failed to create bead',
+                });
+            }
+            // Parse bead ID from output (bd create outputs the ID)
+            const output = stdout.trim();
+            // bd create typically outputs: "Created beads-xxx: title"
+            const idMatch = output.match(/Created\s+(beads-\w+)/i) || output.match(/(beads-\w+)/);
+            const beadId = idMatch ? idMatch[1] : `beads-${Date.now()}`;
+            console.log('[api/beads] Created bead:', beadId);
+            res.json({
+                success: true,
+                bead: {
+                    id: beadId,
+                    title,
+                    assignee,
+                    priority,
+                    type: type || 'task',
+                },
+            });
+        });
+    });
+    /**
+     * POST /api/relay/send - Send a relay message to an agent
+     */
+    app.post('/api/relay/send', async (req, res) => {
+        const { to, content, thread } = req.body;
+        if (!to || typeof to !== 'string') {
+            return res.status(400).json({ success: false, error: 'Recipient (to) is required' });
+        }
+        if (!content || typeof content !== 'string') {
+            return res.status(400).json({ success: false, error: 'Message content is required' });
+        }
+        try {
+            const client = await getRelayClient('Dashboard');
+            if (!client) {
+                return res.status(503).json({
+                    success: false,
+                    error: 'Relay client not available',
+                });
+            }
+            const messageId = await client.sendMessage(to, content, thread ? 'message' : 'message');
+            console.log('[api/relay/send] Sent message to', to, ':', messageId);
+            res.json({
+                success: true,
+                messageId: messageId || `msg-${Date.now()}`,
+            });
+        }
+        catch (err) {
+            console.error('[api/relay/send] Failed to send message:', err);
+            res.status(500).json({
+                success: false,
+                error: err instanceof Error ? err.message : 'Failed to send message',
+            });
+        }
+    });
+    // Helper to load agent statuses
+    async function loadAgentStatuses() {
+        const agentsFile = path.join(dataDir, 'agents.json');
+        try {
+            if (fs.existsSync(agentsFile)) {
+                const data = JSON.parse(fs.readFileSync(agentsFile, 'utf-8'));
+                const result = {};
+                for (const agent of data.agents || []) {
+                    result[agent.name] = { status: agent.status || 'offline' };
+                }
+                return result;
+            }
+        }
+        catch (err) {
+            console.warn('[api] Failed to load agent statuses:', err);
+        }
+        return {};
+    }
     // Watch for changes
     if (storage) {
         setInterval(() => {