agent-relay 1.3.2 → 1.3.3

package/README.md

@@ -17,15 +17,27 @@ sudo apt-get update && sudo apt-get install -y build-essential
 
 ## Quick Start
 
+```bash
+# Start Mega coordinator with Claude (starts daemon automatically)
+agent-relay claude
+
+# Or with Codex
+agent-relay codex
+```
+
+The `claude` and `codex` commands start a Mega coordinator agent that can spawn and manage worker agents.
+
+### Manual Setup
+
 ```bash
 # Terminal 1: Start daemon
 agent-relay up
 
 # Terminal 2: Start an agent
-agent-relay -n Alice claude
+agent-relay create-agent -n Alice claude
 
 # Terminal 3: Start another agent
-agent-relay -n Bob codex
+agent-relay create-agent -n Bob codex
 ```
 
 Agents communicate by outputting `->relay:` patterns. Always use the fenced format:
@@ -42,8 +54,10 @@ Broadcasting to everyone>>>
 
 | Command | Description |
 |---------|-------------|
-| `agent-relay <cmd>` | Wrap agent with messaging |
-| `agent-relay -n Name <cmd>` | Wrap with specific name |
+| `agent-relay claude` | Start daemon + Mega coordinator with Claude |
+| `agent-relay codex` | Start daemon + Mega coordinator with Codex |
+| `agent-relay create-agent <cmd>` | Wrap agent with messaging |
+| `agent-relay create-agent -n Name <cmd>` | Wrap with specific name |
 | `agent-relay up` | Start daemon + dashboard |
 | `agent-relay down` | Stop daemon |
 | `agent-relay status` | Check if running |
@@ -53,7 +67,7 @@ Broadcasting to everyone>>>
 ## How It Works
 
 1. `agent-relay up` starts a daemon that routes messages via Unix socket
-2. `agent-relay <cmd>` wraps your agent in tmux, parsing output for `->relay:` patterns
+2. `agent-relay create-agent <cmd>` wraps your agent in tmux, parsing output for `->relay:` patterns
 3. Messages are injected into recipient terminals in real-time
 
 ```
@@ -109,9 +123,9 @@ Agent names automatically match role definitions (case-insensitive):
 
 ```bash
 # If .claude/agents/lead.md exists:
-agent-relay -n Lead claude    # matches lead.md
-agent-relay -n LEAD claude    # matches lead.md
-agent-relay -n lead claude    # matches lead.md
+agent-relay create-agent -n Lead claude    # matches lead.md
+agent-relay create-agent -n LEAD claude    # matches lead.md
+agent-relay create-agent -n lead claude    # matches lead.md
 
 # Supported locations:
 # - .claude/agents/<name>.md
@@ -140,7 +154,7 @@ agent-relay bridge ~/auth ~/frontend ~/api
 ### Workflow
 
 1. **Start daemons** in each project: `agent-relay up`
-2. **Start agents** in each project: `agent-relay -n Alice claude`
+2. **Start agents** in each project: `agent-relay create-agent -n Alice claude`
 3. **Bridge** from anywhere: `agent-relay bridge ~/project1 ~/project2`
 
 ### Cross-Project Messaging

package/dist/bridge/spawner.js

@@ -14,16 +14,33 @@ import { AgentPolicyService } from '../policy/agent-policy.js';
 import { buildClaudeArgs } from '../utils/agent-config.js';
 import { getUserDirectoryService } from '../daemon/user-directory.js';
 /**
- * Get a minimal relay reminder.
- * Agents already have full relay docs via CLAUDE.md - this is just a brief reminder.
- * Loading full docs (400+ lines) overwhelms agents and causes "meandering".
+ * Get relay protocol instructions for a spawned agent.
+ * This provides the agent with the communication protocol it needs to work with the relay.
  */
-function getMinimalRelayReminder() {
-    return `# Quick Relay Reference
-- Send: \`->relay:Name <<<message>>>\`
-- ACK tasks, send DONE when complete
-- Use \`trail start/decision/complete\` for trajectories
-- Output \`[[SESSION_END]]..[[/SESSION_END]]\` when done`;
+function getRelayInstructions(agentName) {
+    return [
+        '# Agent Relay Protocol',
+        '',
+        `You are agent "${agentName}" connected to Agent Relay for multi-agent coordination.`,
+        '',
+        '## Sending Messages',
+        '',
+        'Use fenced format for all messages:',
+        '->relay:TargetAgent <<<',
+        'Your message here.>>>',
+        '',
+        '## Communication Rules',
+        '',
+        '1. **ACK immediately** - When you receive a task:',
+        '   ->relay:Sender <<<',
+        '   ACK: Brief description of task received>>>',
+        '',
+        '2. **Report completion** - When done:',
+        '   ->relay:Sender <<<',
+        '   DONE: Brief summary of what was completed>>>',
+        '',
+        '3. Close >>> must immediately follow content (no blank lines before it)',
+    ].join('\n');
 }
 export class AgentSpawner {
     activeWorkers = new Map();
@@ -209,6 +226,14 @@ export class AgentSpawner {
             if (isCodexCli && !args.includes('--dangerously-bypass-approvals-and-sandbox')) {
                 args.push('--dangerously-bypass-approvals-and-sandbox');
             }
+            // Inject relay protocol instructions via CLI-specific system prompt
+            const relayInstructions = getRelayInstructions(name);
+            if (isClaudeCli && !args.includes('--append-system-prompt')) {
+                args.push('--append-system-prompt', relayInstructions);
+            }
+            else if (isCodexCli && !args.some(a => a.includes('developer_instructions'))) {
+                args.push('--config', `developer_instructions=${relayInstructions}`);
+            }
             if (debug)
                 console.log(`[spawner:debug] Spawning ${name} with: ${command} ${args.join(' ')}`);
             // Create PtyWrapper config
@@ -247,6 +272,8 @@ export class AgentSpawner {
                 // Shadow agent configuration
                 shadowOf: request.shadowOf,
                 shadowSpeakOn: request.shadowSpeakOn,
+                // Skip continuity for spawned agents - they're short-lived workers
+                skipContinuity: true,
                 // Only use callbacks if dashboardPort is not set (for backwards compatibility)
                 onSpawn: this.dashboardPort ? undefined : async (workerName, workerCli, workerTask) => {
                     // Handle nested spawn requests (legacy path, may fail in non-TTY)
@@ -330,72 +357,9 @@ export class AgentSpawner {
                     error,
                 };
             }
-            // Build the full message: minimal relay reminder + policy instructions (if any) + task
-            // Only build message if there's an actual task - empty task means interactive mode
-            let fullMessage = task || '';
-            // Only prepend relay reminder if we have an actual task
-            // Empty task = interactive mode, user will respond to prompts directly
-            if (fullMessage.trim()) {
-                // Prepend a brief relay reminder (agents have full docs via CLAUDE.md)
-                // Note: Previously loaded full 400+ line docs which overwhelmed agents
-                const relayReminder = getMinimalRelayReminder();
-                if (relayReminder) {
-                    fullMessage = `${relayReminder}\n\n---\n\n${fullMessage}`;
-                    if (debug)
-                        console.log(`[spawner:debug] Prepended relay reminder for ${name}`);
-                }
-            }
-            // Prepend policy instructions if enforcement is enabled (only if we have a task)
-            if (fullMessage.trim() && this.policyEnforcementEnabled && this.policyService) {
-                const policyInstruction = await this.policyService.getPolicyInstruction(name);
-                if (policyInstruction) {
-                    fullMessage = `${policyInstruction}\n\n${fullMessage}`;
-                    if (debug)
-                        console.log(`[spawner:debug] Prepended policy instructions to task for ${name}`);
-                }
-            }
-            // Send task via relay message if provided (not via direct PTY injection)
-            // This ensures the agent is ready to receive before processing the task
-            if (fullMessage && fullMessage.trim()) {
-                if (debug)
-                    console.log(`[spawner:debug] Will send task via relay: ${fullMessage.substring(0, 50)}...`);
-                // If we have dashboard API, send task as relay message
-                if (this.dashboardPort) {
-                    // Wait a moment for the agent's relay client to be ready
-                    await sleep(1000);
-                    try {
-                        const response = await fetch(`http://localhost:${this.dashboardPort}/api/send`, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({
-                                to: name,
-                                message: fullMessage,
-                                from: '__spawner__',
-                            }),
-                        });
-                        const result = await response.json();
-                        if (result.success) {
-                            if (debug)
-                                console.log(`[spawner:debug] Task sent via relay to ${name}`);
-                        }
-                        else {
-                            console.warn(`[spawner] Failed to send task via relay: ${result.error}`);
-                            // Fall back to direct injection
-                            pty.write(fullMessage + '\r');
-                        }
-                    }
-                    catch (err) {
-                        console.warn(`[spawner] Relay send failed, falling back to direct injection: ${err.message}`);
-                        pty.write(fullMessage + '\r');
-                    }
-                }
-                else {
-                    // No dashboard API available - use direct injection as fallback
-                    if (debug)
-                        console.log(`[spawner:debug] No dashboard API, using direct injection`);
-                    pty.write(fullMessage + '\r');
-                }
-            }
+            // Note: Task is NOT sent here. The spawning agent (wrapper) waits for the worker
+            // to come online and then sends the task via normal relay message.
+            // This avoids race conditions with the agent's readyForMessages state.
             // Track the worker
             const workerInfo = {
                 name,

package/dist/cli/index.d.ts

@@ -3,12 +3,14 @@
  * 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
  */
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -3,12 +3,14 @@
  * 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';
@@ -26,6 +28,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 +38,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 +52,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();
@@ -84,18 +86,53 @@ program
     }
     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);
+    // 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 TmuxWrapper({
         name: agentName,
         command: mainCommand,
         args: finalArgs,
         socketPath: paths.socketPath,
-        debug: false, // Use -q to keep quiet (debug off by default)
+        debug: options.debug ?? false,
         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,
+        // 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 +236,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 +258,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 +373,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 +407,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 +458,162 @@ 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 { resolveTmux, TmuxNotFoundError } = await import('../utils/tmux-resolver.js');
+    // Check for tmux first
+    const tmuxInfo = resolveTmux();
+    if (!tmuxInfo) {
+        const error = new TmuxNotFoundError();
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+    const paths = getProjectPaths();
+    console.log(`Starting Dashboard with ${operator}...`);
+    console.log(`Project: ${paths.projectRoot}`);
+    console.log(`Tmux: ${tmuxInfo.path} (v${tmuxInfo.version})`);
+    // 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')
@@ -1293,7 +1514,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 +1525,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 +1611,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 +2181,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 +2300,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) {

package/dist/daemon/agent-manager.js

@@ -97,6 +97,8 @@ export class AgentManager extends EventEmitter {
                 args,
                 cwd: workspacePath,
                 logsDir: this.logsDir,
+                // Skip continuity for cloud-managed agents
+                skipContinuity: true,
                 env: {
                     CLOUD_API_URL: process.env.CLOUD_API_URL || '',
                     WORKSPACE_TOKEN: process.env.WORKSPACE_TOKEN || '',
@@ -341,6 +343,8 @@ export class AgentManager extends EventEmitter {
                 args,
                 cwd: workspacePath,
                 logsDir: this.logsDir,
+                // Skip continuity for cloud-managed agents
+                skipContinuity: true,
                 env: {
                     CLOUD_API_URL: process.env.CLOUD_API_URL || '',
                     WORKSPACE_TOKEN: process.env.WORKSPACE_TOKEN || '',