agent-relay 1.3.2 → 1.5.0

package/dist/cli/index.js

@@ -3,17 +3,21 @@
  * Agent Relay CLI
  *
  * Commands:
- *   relay <cmd>         - Wrap agent with real-time messaging (default)
- *   relay -n Name cmd   - Wrap with specific agent name
- *   relay up            - Start daemon
- *   relay read <id>     - Read full message by ID
- *   relay agents        - List connected agents
- *   relay who           - Show currently active agents
+ *   relay claude                   - Start daemon + Dashboard coordinator with Claude
+ *   relay codex                    - Start daemon + Dasbboard coordinator with Codex
+ *   relay create-agent <cmd>       - Wrap agent with real-time messaging
+ *   relay create-agent -n Name cmd - Wrap with specific agent name
+ *   relay up                       - Start daemon + dashboard
+ *   relay read <id>                - Read full message by ID
+ *   relay agents                   - List connected agents
+ *   relay who                      - Show currently active agents
  */
 import { Command } from 'commander';
 import { config as dotenvConfig } from 'dotenv';
 import { Daemon } from '../daemon/server.js';
 import { RelayClient } from '../wrapper/client.js';
+import { RelayPtyOrchestrator } from '../wrapper/relay-pty-orchestrator.js';
+import { AgentSpawner } from '../bridge/spawner.js';
 import { generateAgentName } from '../utils/name-generator.js';
 import { getTmuxPath } from '../utils/tmux-resolver.js';
 import { readWorkersMetadata, getWorkerLogsDir } from '../bridge/spawner.js';
@@ -26,6 +30,7 @@ import { promisify } from 'node:util';
 import { exec } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 dotenvConfig();
+const DEFAULT_DASHBOARD_PORT = process.env.AGENT_RELAY_DASHBOARD_PORT || '3888';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -35,7 +40,7 @@ const VERSION = packageJson.version;
 const execAsync = promisify(exec);
 // Check for updates in background (non-blocking)
 // Only show notification for interactive commands, not when wrapping agents or running update
-const interactiveCommands = ['up', 'down', 'status', 'agents', 'who', 'version', '--version', '-V', '--help', '-h'];
+const interactiveCommands = ['up', 'down', 'status', 'agents', 'who', 'version', '--version', '-V', '--help', '-h', 'create-agent', 'claude', 'codex'];
 const shouldCheckUpdates = process.argv.length > 2 &&
     interactiveCommands.includes(process.argv[2]);
 if (shouldCheckUpdates) {
@@ -49,20 +54,19 @@ program
     .name('agent-relay')
     .description('Agent-to-agent messaging')
     .version(VERSION, '-V, --version', 'Output the version number');
-// Default action = wrap agent
+// create-agent - Wrap agent with real-time messaging
 program
+    .command('create-agent')
+    .description('Wrap an agent with real-time messaging')
     .option('-n, --name <name>', 'Agent name (auto-generated if not set)')
-    .option('-q, --quiet', 'Disable debug output', false)
+    .option('-d, --debug', 'Enable debug output')
     .option('--prefix <pattern>', 'Relay prefix pattern (default: ->relay:)')
+    .option('--dashboard-port <port>', 'Dashboard port for spawn/release API (auto-detected if not set)')
     .option('--shadow <name>', 'Spawn a shadow agent with this name that monitors the primary')
     .option('--shadow-role <role>', 'Shadow role: reviewer, auditor, or triggers (comma-separated: SESSION_END,CODE_WRITTEN,REVIEW_REQUEST,EXPLICIT_ASK,ALL_MESSAGES)')
-    .argument('[command...]', 'Command to wrap (e.g., claude)')
+    .option('--skip-instructions', 'Skip initial instruction injection (use with --append-system-prompt)')
+    .argument('<command...>', 'Command to wrap (e.g., claude)')
     .action(async (commandParts, options) => {
-    // If no command provided, show help
-    if (!commandParts || commandParts.length === 0) {
-        program.help();
-        return;
-    }
     const { getProjectPaths } = await import('../utils/project-namespace.js');
     const { findAgentConfig, isClaudeCli, buildClaudeArgs } = await import('../utils/agent-config.js');
     const paths = getProjectPaths();
@@ -82,20 +86,52 @@ program
             finalArgs = buildClaudeArgs(agentName, commandArgs, paths.projectRoot);
         }
     }
-    const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
-    const { AgentSpawner } = await import('../bridge/spawner.js');
-    // Create spawner for spawn/release callbacks
-    const spawner = new AgentSpawner(paths.projectRoot);
-    const wrapper = new TmuxWrapper({
+    // Determine dashboard port for spawn/release API
+    // Priority: CLI flag > env var > auto-detect default port
+    let dashboardPort;
+    if (options.dashboardPort) {
+        dashboardPort = parseInt(options.dashboardPort, 10);
+    }
+    else {
+        // Try to detect if dashboard is running at common ports
+        const portsToTry = [
+            parseInt(DEFAULT_DASHBOARD_PORT, 10),
+            3889, 3890, 3891, // Common fallback ports when default is in use
+        ];
+        for (const port of portsToTry) {
+            try {
+                const response = await fetch(`http://localhost:${port}/api/health`, {
+                    method: 'GET',
+                    signal: AbortSignal.timeout(300), // Quick timeout for detection
+                });
+                if (response.ok) {
+                    const health = await response.json();
+                    if (health.status === 'healthy') {
+                        dashboardPort = port;
+                        console.error(`Dashboard detected: http://localhost:${dashboardPort}`);
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Try next port
+            }
+        }
+    }
+    // Create spawner as fallback for direct spawn (if dashboard API not available)
+    const spawner = new AgentSpawner(paths.projectRoot, undefined, dashboardPort);
+    const wrapper = new RelayPtyOrchestrator({
         name: agentName,
         command: mainCommand,
         args: finalArgs,
         socketPath: paths.socketPath,
-        debug: false, // Use -q to keep quiet (debug off by default)
+        cwd: paths.projectRoot,
         relayPrefix: options.prefix,
-        useInbox: true,
-        inboxDir: paths.dataDir, // Use the project-specific data directory for the inbox
-        // Wire up spawn/release callbacks
+        skipInstructions: options.skipInstructions,
+        streamLogs: true,
+        // Use dashboard API for spawn/release when available (preferred - works from any context)
+        dashboardPort,
+        // Wire up spawn/release callbacks as fallback (if no dashboardPort)
         onSpawn: async (workerName, workerCli, task) => {
             console.error(`[${agentName}] Spawning ${workerName} (${workerCli})...`);
             const result = await spawner.spawn({
@@ -199,10 +235,12 @@ program
         }
     }
 });
-// up - Start daemon
+// up - Start daemon + dashboard
 program
     .command('up')
-    .description('Start daemon')
+    .description('Start daemon + dashboard')
+    .option('--no-dashboard', 'Disable web dashboard')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .option('--spawn', 'Force spawn all agents from teams.json')
     .option('--no-spawn', 'Do not auto-spawn agents (just start daemon)')
     .option('--watch', 'Auto-restart daemon on crash (supervisor mode)')
@@ -219,6 +257,10 @@ program
         const startDaemon = () => {
             // Build args without --watch to prevent infinite recursion
             const args = ['up'];
+            if (options.dashboard === false)
+                args.push('--no-dashboard');
+            if (options.port)
+                args.push('--port', options.port);
             if (options.spawn === true)
                 args.push('--spawn');
             if (options.spawn === false)
@@ -330,6 +372,28 @@ program
     try {
         await daemon.start();
         console.log('Daemon started.');
+        let dashboardPort;
+        // Dashboard starts by default (use --no-dashboard to disable)
+        if (options.dashboard !== false) {
+            const port = parseInt(options.port, 10);
+            const { startDashboard } = await import('../dashboard-server/server.js');
+            dashboardPort = await startDashboard({
+                port,
+                dataDir: paths.dataDir,
+                teamDir: paths.teamDir,
+                dbPath,
+                enableSpawner: true,
+                projectRoot: paths.projectRoot,
+            });
+            console.log(`Dashboard: http://localhost:${dashboardPort}`);
+            // Hook daemon log output to dashboard WebSocket
+            daemon.onLogOutput = (agentName, data, _timestamp) => {
+                const broadcast = global.__broadcastLogOutput;
+                if (broadcast) {
+                    broadcast(agentName, data);
+                }
+            };
+        }
         // Determine if we should auto-spawn agents
         // --spawn: force spawn
         // --no-spawn: never spawn
@@ -342,7 +406,7 @@ program
         if (shouldSpawn && teamsConfig && teamsConfig.agents.length > 0) {
             console.log('');
             console.log('Auto-spawning agents from teams.json...');
-            spawner = new AgentSpawner(paths.projectRoot);
+            spawner = new AgentSpawner(paths.projectRoot, undefined, dashboardPort);
             for (const agent of teamsConfig.agents) {
                 console.log(`  Spawning ${agent.name} (${agent.cli})...`);
                 const result = await spawner.spawn({
@@ -393,6 +457,153 @@ program
         console.log('Cleaned up stale pid');
     }
 });
+// System prompt for Dashboard agent - plain text to avoid shell escaping issues
+const MEGA_SYSTEM_PROMPT = [
+    'You are Dashboard, a lead coordinator in agent-relay.',
+    'Your PRIMARY job is to delegate - you should almost NEVER do implementation work yourself.',
+    'ALWAYS SPAWN AGENTS: For any non-trivial task, spawn specialized workers.',
+].join(' ');
+// Helper function for starting Dashboard coordinator with a specific provider
+async function startDashboardCoordinator(operator) {
+    const { spawn } = await import('node:child_process');
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    console.log(`Starting Dashboard with ${operator}...`);
+    console.log(`Project: ${paths.projectRoot}`);
+    // Step 1: Check if daemon is already running, start if needed
+    console.log('\n[1/3] Checking daemon...');
+    // Check if socket exists (daemon running)
+    const socketExists = fs.existsSync(paths.socketPath);
+    // Ports to try for dashboard detection
+    const portsToTry = [
+        parseInt(DEFAULT_DASHBOARD_PORT, 10),
+        3889, 3890, 3891,
+    ];
+    // Check if dashboard is responding for THIS project
+    let dashboardReady = false;
+    let detectedPort;
+    // Helper to check health at a port
+    const checkPort = async (port) => {
+        try {
+            const response = await fetch(`http://localhost:${port}/api/health`, {
+                signal: AbortSignal.timeout(500),
+            });
+            if (response.ok) {
+                const health = await response.json();
+                return health.status === 'healthy';
+            }
+        }
+        catch {
+            // Port not responding
+        }
+        return false;
+    };
+    if (socketExists) {
+        for (const port of portsToTry) {
+            if (await checkPort(port)) {
+                dashboardReady = true;
+                detectedPort = port;
+                break;
+            }
+        }
+    }
+    if (dashboardReady && detectedPort) {
+        console.log(`Daemon already running at port ${detectedPort}, reusing...`);
+    }
+    else {
+        console.log('Starting daemon...');
+        const daemonProc = spawn(process.execPath, [process.argv[1], 'up'], {
+            stdio: 'ignore',
+            detached: true,
+        });
+        daemonProc.unref();
+        // Wait for dashboard to be ready (up to 10 seconds)
+        const maxWait = 10000;
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            for (const port of portsToTry) {
+                if (await checkPort(port)) {
+                    dashboardReady = true;
+                    detectedPort = port;
+                    break;
+                }
+            }
+            if (dashboardReady)
+                break;
+        }
+        if (!dashboardReady) {
+            console.error('Warning: Dashboard may not be fully ready. Spawn might not work.');
+            detectedPort = parseInt(DEFAULT_DASHBOARD_PORT, 10); // Fallback
+        }
+    }
+    const dashboardPort = detectedPort || parseInt(DEFAULT_DASHBOARD_PORT, 10);
+    // Step 2: Install prpm snippet via npx
+    console.log('[2/3] Installing agent-relay snippet...');
+    const prpmArgs = operator.toLowerCase() === 'claude'
+        ? ['prpm', 'install', '@agent-relay/agent-relay-snippet', '--location', 'CLAUDE.md']
+        : ['prpm', 'install', '@agent-relay/agent-relay-snippet'];
+    try {
+        await new Promise((resolve, reject) => {
+            const prpmProc = spawn('npx', prpmArgs, {
+                stdio: 'inherit',
+            });
+            prpmProc.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`npx prpm exited with code ${code}`));
+            });
+            prpmProc.on('error', reject);
+        });
+    }
+    catch (err) {
+        console.warn(`Warning: prpm install failed: ${err.message}`);
+        console.warn('Continuing without snippet installation...');
+    }
+    // Step 3: Start Dashboard agent with system prompt
+    console.log(`[3/3] Starting Dashboard agent with ${operator}...`);
+    console.log('');
+    const op = operator.toLowerCase();
+    // Build CLI-specific arguments for system prompt
+    // These args go AFTER the operator command, passed through to the CLI
+    let cliArgs = [];
+    if (op === 'claude') {
+        // Claude: --append-system-prompt <content> (takes content directly, not file)
+        cliArgs = ['--append-system-prompt', MEGA_SYSTEM_PROMPT];
+    }
+    else if (op === 'codex') {
+        // Codex: --config developer_instructions="<content>"
+        cliArgs = ['--config', `developer_instructions=${MEGA_SYSTEM_PROMPT}`];
+    }
+    // Use '--' to separate agent-relay options from the command + its args
+    // Format: agent-relay create-agent -n Dashboard --skip-instructions --dashboard-port <port> -- claude --append-system-prompt "..."
+    const agentProc = spawn(process.execPath, [process.argv[1], 'create-agent', '-n', 'Dashboard', '--skip-instructions', '--dashboard-port', String(dashboardPort), '--', operator, ...cliArgs], { stdio: 'inherit' });
+    // Forward signals to agent process
+    process.on('SIGINT', () => {
+        agentProc.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        agentProc.kill('SIGTERM');
+    });
+    agentProc.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+}
+// claude - Start daemon and spawn Dashboard coordinator with Claude
+program
+    .command('claude')
+    .description('Start daemon and Dashboard coordinator with Claude')
+    .action(async () => {
+    await startDashboardCoordinator('claude');
+});
+// codex - Start daemon and spawn Dashboard coordinator with Codex
+program
+    .command('codex')
+    .description('Start daemon and Dashboard coordinator with Codex')
+    .action(async () => {
+    await startDashboardCoordinator('codex');
+});
 // status - Check daemon status
 program
     .command('status')
@@ -435,6 +646,7 @@ program
     const os = await import('node:os');
     const paths = getProjectPaths();
     const agentsPath = path.join(paths.teamDir, 'agents.json');
+    const connectedAgentsPath = path.join(paths.teamDir, 'connected-agents.json');
     // Load registered agents
     const allAgents = loadAgents(agentsPath);
     const agents = options.all
@@ -442,13 +654,41 @@ program
         : allAgents.filter(isVisibleAgent);
     // Load spawned workers
     const workers = readWorkersMetadata(paths.projectRoot);
+    // Load currently connected agents (agents with active socket connections)
+    let connectedAgentNames = new Set();
+    let connectedUpdatedAt = 0;
+    try {
+        if (fs.existsSync(connectedAgentsPath)) {
+            const connectedData = JSON.parse(fs.readFileSync(connectedAgentsPath, 'utf-8'));
+            connectedAgentNames = new Set([
+                ...(connectedData.agents || []),
+                ...(connectedData.users || []),
+            ]);
+            connectedUpdatedAt = connectedData.updatedAt || 0;
+        }
+    }
+    catch {
+        // If file doesn't exist or is invalid, fall back to registry-based status
+    }
+    // Check if connected-agents.json is fresh (within 30 seconds)
+    const isConnectedAgentsStale = Date.now() - connectedUpdatedAt > 30_000;
     const combined = [];
     // Add registered agents
     agents.forEach((agent) => {
         const worker = workers.find(w => w.name === agent.name);
+        // Use connected-agents.json if fresh, otherwise fall back to registry lastSeen
+        let status;
+        if (!isConnectedAgentsStale && connectedAgentNames.size > 0) {
+            // We have fresh connected-agents data - use actual connection status
+            status = connectedAgentNames.has(agent.name ?? '') ? 'ONLINE' : 'OFFLINE';
+        }
+        else {
+            // Fall back to registry-based status
+            status = getAgentStatus(agent);
+        }
         combined.push({
             name: agent.name ?? 'unknown',
-            status: getAgentStatus(agent),
+            status,
             cli: agent.cli ?? '-',
             lastSeen: agent.lastSeen,
             team: worker?.team,
@@ -856,7 +1096,6 @@ program
     // Spawn architect agent if --architect flag is set
     let architectWrapper = null;
     if (options.architect !== undefined) {
-        const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
         // Determine CLI to use (default to claude)
         const architectCli = typeof options.architect === 'string' ? options.architect : 'claude';
         // Use first project as the base for the architect
@@ -923,14 +1162,13 @@ Start by greeting the project leads and asking for status updates.`;
             command = architectCli;
         }
         try {
-            architectWrapper = new TmuxWrapper({
+            architectWrapper = new RelayPtyOrchestrator({
                 name: 'Architect',
                 command,
                 args,
                 socketPath: basePaths.socketPath,
-                debug: false,
-                useInbox: true,
-                inboxDir: basePaths.dataDir,
+                cwd: baseProject.path,
+                streamLogs: true,
             });
             await architectWrapper.start();
             // Wait for agent to be ready, then inject the prompt
@@ -938,7 +1176,6 @@ Start by greeting the project leads and asking for status updates.`;
                 try {
                     await architectWrapper.injectMessage(architectPrompt);
                     console.log('Architect agent started and initialized.');
-                    console.log('Attach to session: tmux attach -t relay-Architect');
                     console.log('');
                 }
                 catch (err) {
@@ -1293,7 +1530,7 @@ program
     .argument('<name>', 'Agent name')
     .argument('<cli>', 'CLI to use (claude, codex, gemini, etc.)')
     .argument('[task]', 'Task description (can also be piped via stdin)')
-    .option('--port <port>', 'Dashboard port', '3888')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .option('--team <team>', 'Team name for the agent')
     .option('--spawner <name>', 'Name of the agent requesting the spawn (for policy enforcement)')
     .option('--interactive', 'Disable auto-accept of permission prompts (for auth setup flows)')
@@ -1304,7 +1541,7 @@ program
     .option('--shadow-triggers <triggers>', 'When to trigger shadow (comma-separated: SESSION_END,CODE_WRITTEN,REVIEW_REQUEST,EXPLICIT_ASK,ALL_MESSAGES)')
     .option('--shadow-speak-on <triggers>', 'When shadow should speak (comma-separated, same values as --shadow-triggers)')
     .action(async (name, cli, task, options) => {
-    const port = options.port || '3888';
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
     // Read task from stdin if not provided as argument
     let finalTask = task;
     if (!finalTask && !process.stdin.isTTY) {
@@ -1390,9 +1627,9 @@ program
     .command('release')
     .description('Release a spawned agent via API (no terminal required)')
     .argument('<name>', 'Agent name to release')
-    .option('--port <port>', 'Dashboard port', '3888')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .action(async (name, options) => {
-    const port = options.port || '3888';
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
     try {
         const response = await fetch(`http://localhost:${port}/api/spawned/${encodeURIComponent(name)}`, {
             method: 'DELETE',
@@ -1960,12 +2197,12 @@ program
     .command('metrics')
     .description('Show agent memory metrics and resource usage')
     .option('--agent <name>', 'Show metrics for specific agent')
-    .option('--port <port>', 'Dashboard port', '3888')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .option('--json', 'Output as JSON')
     .option('--watch', 'Continuously update metrics')
     .option('--interval <ms>', 'Update interval for watch mode', '5000')
     .action(async (options) => {
-    const port = options.port || '3888';
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
     const fetchMetrics = async () => {
         try {
             const response = await fetch(`http://localhost:${port}/api/metrics/agents`);
@@ -2079,12 +2316,12 @@ program
 program
     .command('health')
     .description('Show system health, crash insights, and recommendations')
-    .option('--port <port>', 'Dashboard port', '3888')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
     .option('--json', 'Output as JSON')
     .option('--crashes', 'Show recent crash history')
     .option('--alerts', 'Show unacknowledged alerts')
     .action(async (options) => {
-    const port = options.port || '3888';
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
     try {
         const response = await fetch(`http://localhost:${port}/api/metrics/health`);
         if (!response.ok) {
@@ -2227,16 +2464,14 @@ program
     console.log('');
     // Use the regular wrapper but with profiling environment
     const paths = getProjectPaths();
-    const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
-    const wrapper = new TmuxWrapper({
+    const wrapper = new RelayPtyOrchestrator({
         name: agentName,
         command: cmd,
         args,
         socketPath: paths.socketPath,
-        debug: true,
+        cwd: paths.projectRoot,
         env: profileEnv,
-        useInbox: true,
-        inboxDir: paths.dataDir,
+        streamLogs: true,
     });
     // Start memory sampling
     const sampleInterval = setInterval(() => {

package/dist/cloud/api/daemons.js

@@ -161,6 +161,8 @@ daemonsRouter.get('/workspace/:workspaceId/agents', requireAuth, async (req, res
                 name: agent.name,
                 status: agent.status,
                 isLocal: true,
+                isHuman: agent.isHuman,
+                avatarUrl: agent.avatarUrl,
                 daemonId: daemon.id,
                 daemonName: daemon.name,
                 daemonStatus: daemon.status,
@@ -394,22 +396,8 @@ daemonsRouter.get('/messages', requireDaemonAuth, async (req, res) => {
 });
 /**
  * POST /api/daemons/messages/sync
- * Sync messages from daemon to cloud storage
- *
- * Accepts batches of messages and stores them in agent_messages table.
- * Uses upsert logic to handle duplicates (based on workspace_id + original_id).
- *
- * Request body:
- * {
- *   messages: SyncMessageInput[]
- * }
- *
- * Response:
- * {
- *   success: true,
- *   synced: number,    // Count of messages synced
- *   duplicates: number // Count of messages skipped (already existed)
- * }
+ * Bulk sync messages from local daemon to cloud storage.
+ * Messages are stored for backup/history - local SQLite is used for display.
  */
 daemonsRouter.post('/messages/sync', requireDaemonAuth, async (req, res) => {
     const daemon = req.daemon;
@@ -420,7 +408,6 @@ daemonsRouter.post('/messages/sync', requireDaemonAuth, async (req, res) => {
     if (messages.length === 0) {
         return res.json({ success: true, synced: 0, duplicates: 0 });
     }
-    // Limit batch size to prevent abuse
     if (messages.length > 500) {
         return res.status(400).json({ error: 'Maximum batch size is 500 messages' });
     }
@@ -444,19 +431,15 @@ daemonsRouter.post('/messages/sync', requireDaemonAuth, async (req, res) => {
         return res.status(400).json({ error: hint });
     }
     try {
-        // Get user plan to determine retention policy
         const user = await db.users.findById(daemon.userId);
         const plan = user?.plan || 'free';
-        // Calculate expires_at based on plan
         let expiresAt = null;
         if (plan === 'free') {
-            expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000); // 30 days
+            expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
         }
         else if (plan === 'pro') {
-            expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000); // 90 days
+            expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000);
         }
-        // Enterprise: null (never expires)
-        // Transform to NewAgentMessage format
         const dbMessages = messages.map((msg) => ({
             workspaceId,
             daemonId: daemon.id,
@@ -483,11 +466,7 @@ daemonsRouter.post('/messages/sync', requireDaemonAuth, async (req, res) => {
         const synced = result.inserted;
         const duplicates = result.duplicates;
         console.log(`[message-sync] Synced ${synced} messages for daemon ${daemon.id}, ${duplicates} duplicates skipped (${result.durationMs}ms)`);
-        res.json({
-            success: true,
-            synced,
-            duplicates,
-        });
+        res.json({ success: true, synced, duplicates });
     }
     catch (error) {
         console.error('Error syncing messages:', error);
@@ -496,7 +475,7 @@ daemonsRouter.post('/messages/sync', requireDaemonAuth, async (req, res) => {
 });
 /**
  * GET /api/daemons/messages/stats
- * Get message sync statistics for this daemon's workspace
+ * Get message sync statistics and database health.
  */
 daemonsRouter.get('/messages/stats', requireDaemonAuth, async (req, res) => {
     const daemon = req.daemon;
@@ -504,12 +483,14 @@ daemonsRouter.get('/messages/stats', requireDaemonAuth, async (req, res) => {
         return res.status(400).json({ error: 'Daemon must be linked to a workspace' });
     }
     try {
-        // Get message count and pool health in parallel
-        const [count, poolHealth, poolStats] = await Promise.all([
-            db.agentMessages.countByWorkspace(daemon.workspaceId),
+        // Get message count via raw query and pool health in parallel
+        const pool = db.getRawPool();
+        const [countResult, poolHealth, poolStats] = await Promise.all([
+            pool.query('SELECT COUNT(*) FROM agent_messages WHERE workspace_id = $1', [daemon.workspaceId]),
             db.bulk.checkHealth(),
             Promise.resolve(db.bulk.getPoolStats()),
         ]);
+        const count = parseInt(countResult.rows[0]?.count || '0', 10);
         res.json({
             workspaceId: daemon.workspaceId,
             messageCount: count,

package/dist/cloud/api/onboarding.js

@@ -637,10 +637,8 @@ async function validateProviderToken(provider, token) {
                 },
             },
             google: {
-                url: 'https://generativelanguage.googleapis.com/v1/models',
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                },
+                url: `https://generativelanguage.googleapis.com/v1/models?key=${encodeURIComponent(token)}`,
+                headers: {},
             },
         };
         const config = endpoints[provider];

package/dist/cloud/api/providers.js

@@ -298,6 +298,12 @@ providersRouter.post('/:provider/api-key', async (req, res) => {
             // 200 = valid, 401 = invalid key, 400/other = might still be valid key
             isValid = testRes.status !== 401;
         }
+        else if (provider === 'google') {
+            // Test Google/Gemini API key (uses query param auth, not Bearer token)
+            const testRes = await fetch(`https://generativelanguage.googleapis.com/v1/models?key=${encodeURIComponent(apiKey)}`);
+            // 200 = valid, 400/401/403 = invalid key
+            isValid = testRes.status === 200;
+        }
         else {
             // For other providers, just accept the key
             isValid = true;

package/dist/cloud/config.d.ts

@@ -6,6 +6,7 @@ export interface CloudConfig {
     publicUrl: string;
     appUrl: string;
     sessionSecret: string;
+    localDashboardUrl?: string;
     databaseUrl: string;
     redisUrl: string;
     github: {

package/dist/cloud/config.js

@@ -17,6 +17,8 @@ export function loadConfig() {
         publicUrl: process.env.PUBLIC_URL || 'http://localhost:4567',
         appUrl: process.env.APP_URL || process.env.PUBLIC_URL || 'http://localhost:4567',
         sessionSecret: requireEnv('SESSION_SECRET'),
+        // Local dashboard for channel API (auto-detected if not set)
+        localDashboardUrl: optionalEnv('LOCAL_DASHBOARD_URL'),
         databaseUrl: requireEnv('DATABASE_URL'),
         redisUrl: process.env.REDIS_URL || 'redis://localhost:6379',
         github: {