agent-relay 1.0.22 → 1.2.0

package/dist/cli/index.js

@@ -17,6 +17,8 @@ import { RelayClient } from '../wrapper/client.js';
 import { generateAgentName } from '../utils/name-generator.js';
 import { getTmuxPath } from '../utils/tmux-resolver.js';
 import { readWorkersMetadata, getWorkerLogsDir } from '../bridge/spawner.js';
+import { getShadowForAgent } from '../bridge/shadow-config.js';
+import { selectShadowCli } from '../bridge/shadow-cli.js';
 import { checkForUpdatesInBackground, checkForUpdates } from '../utils/update-checker.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -53,6 +55,9 @@ program
     .option('-n, --name <name>', 'Agent name (auto-generated if not set)')
     .option('-q, --quiet', 'Disable debug output', false)
     .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)')
     .action(async (commandParts, options) => {
     // If no command provided, show help
@@ -81,8 +86,31 @@ program
     }
     const { TmuxWrapper } = await import('../wrapper/tmux-wrapper.js');
     const { AgentSpawner } = await import('../bridge/spawner.js');
-    // Create spawner so any agent can spawn workers
-    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 default port
+        const defaultPort = parseInt(DEFAULT_DASHBOARD_PORT, 10);
+        try {
+            const response = await fetch(`http://localhost:${defaultPort}/api/status`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(500), // Quick timeout for detection
+            });
+            if (response.ok) {
+                dashboardPort = defaultPort;
+                console.error(`Dashboard detected: http://localhost:${dashboardPort}`);
+            }
+        }
+        catch {
+            // Dashboard not running - spawn/release will use fallback callbacks
+        }
+    }
+    // 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,
@@ -92,7 +120,9 @@ program
         relayPrefix: options.prefix,
         useInbox: true,
         inboxDir: paths.dataDir, // Use the project-specific data directory for the inbox
-        // Wire up spawn/release callbacks so any agent can spawn workers
+        // 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({
@@ -121,10 +151,80 @@ program
     });
     process.on('SIGINT', async () => {
         await spawner.releaseAll();
-        wrapper.stop();
+        await wrapper.stop();
         process.exit(0);
     });
     await wrapper.start();
+    let shadowName;
+    let shadowRole;
+    let speakOn;
+    let shadowCli;
+    let shadowPrompt;
+    const rolePresets = {
+        reviewer: ['CODE_WRITTEN', 'REVIEW_REQUEST', 'EXPLICIT_ASK'],
+        auditor: ['SESSION_END', 'EXPLICIT_ASK'],
+        active: ['ALL_MESSAGES'],
+    };
+    if (options.shadow) {
+        // CLI flags provided
+        shadowName = options.shadow;
+        const role = options.shadowRole || 'EXPLICIT_ASK';
+        shadowRole = role;
+        if (rolePresets[role.toLowerCase()]) {
+            speakOn = rolePresets[role.toLowerCase()];
+        }
+        else {
+            speakOn = role.split(',').map((s) => s.trim().toUpperCase());
+        }
+    }
+    else {
+        // Check config file for shadow configuration
+        const shadowConfig = getShadowForAgent(paths.projectRoot, agentName);
+        if (shadowConfig) {
+            shadowName = shadowConfig.shadowName;
+            shadowRole = shadowConfig.roleName;
+            speakOn = shadowConfig.speakOn;
+            shadowCli = shadowConfig.cli;
+            shadowPrompt = shadowConfig.prompt;
+            console.error(`Shadow config: ${shadowName} (from .agent-relay.json)`);
+        }
+    }
+    // Spawn shadow if configured
+    if (shadowName && speakOn) {
+        // Decide how to run the shadow (subagent for Claude/OpenCode primaries)
+        let shadowSelection = null;
+        try {
+            shadowSelection = await selectShadowCli(mainCommand, { preferredShadowCli: shadowCli });
+            console.error(`[shadow] Mode: ${shadowSelection.mode} via ${shadowSelection.command || shadowSelection.cli} (primary: ${mainCommand})`);
+        }
+        catch (err) {
+            console.error(`[shadow] Shadow CLI selection failed: ${err.message}`);
+        }
+        // Subagent mode: do not spawn a separate shadow process
+        if (shadowSelection?.mode === 'subagent') {
+            console.error(`[shadow] ${shadowName} will run as ${shadowSelection.cli} subagent inside ${agentName}; no separate process spawned`);
+            return;
+        }
+        console.error(`Shadow: ${shadowName} (shadowing ${agentName}, speakOn: ${speakOn.join(',')})`);
+        // Wait for primary to register before spawning shadow
+        await new Promise(r => setTimeout(r, 3000));
+        // Build shadow task prompt
+        const defaultPrompt = `You are a shadow agent monitoring "${agentName}". You receive copies of their messages. Your role: ${shadowRole || 'observer'}. Stay passive unless your triggers activate.`;
+        const shadowTask = shadowPrompt || defaultPrompt;
+        const result = await spawner.spawn({
+            name: shadowName,
+            cli: shadowSelection?.command || shadowCli || mainCommand,
+            task: shadowTask,
+            shadowOf: agentName,
+            shadowSpeakOn: speakOn,
+        });
+        if (result.success) {
+            console.error(`Shadow ${shadowName} started [pid: ${result.pid}]`);
+        }
+        else {
+            console.error(`Failed to spawn shadow ${shadowName}: ${result.error}`);
+        }
+    }
 });
 // up - Start daemon + dashboard
 program
@@ -134,7 +234,67 @@ program
     .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)')
+    .option('--max-restarts <n>', 'Max restarts in 60s before giving up (default: 5)', '5')
     .action(async (options) => {
+    // If --watch is specified, run in supervisor mode
+    if (options.watch) {
+        const { spawn } = await import('node:child_process');
+        const maxRestarts = parseInt(options.maxRestarts, 10) || 5;
+        const restartWindow = 60_000; // 60 seconds
+        const restartTimes = [];
+        let child = null;
+        let shuttingDown = false;
+        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)
+                args.push('--no-spawn');
+            console.log(`[supervisor] Starting daemon...`);
+            child = spawn(process.execPath, [process.argv[1], ...args], {
+                stdio: 'inherit',
+                env: { ...process.env, AGENT_RELAY_SUPERVISED: '1' },
+            });
+            child.on('exit', (code, signal) => {
+                if (shuttingDown) {
+                    process.exit(0);
+                    return;
+                }
+                const now = Date.now();
+                restartTimes.push(now);
+                // Remove restarts outside the window
+                while (restartTimes.length > 0 && restartTimes[0] < now - restartWindow) {
+                    restartTimes.shift();
+                }
+                if (restartTimes.length >= maxRestarts) {
+                    console.error(`[supervisor] Daemon crashed ${maxRestarts} times in ${restartWindow / 1000}s, giving up`);
+                    process.exit(1);
+                }
+                const exitReason = signal ? `signal ${signal}` : `code ${code}`;
+                console.log(`[supervisor] Daemon exited (${exitReason}), restarting in 2s... (${restartTimes.length}/${maxRestarts} restarts)`);
+                setTimeout(startDaemon, 2000);
+            });
+        };
+        process.on('SIGINT', () => {
+            console.log('\n[supervisor] Stopping...');
+            shuttingDown = true;
+            if (child)
+                child.kill('SIGINT');
+        });
+        process.on('SIGTERM', () => {
+            shuttingDown = true;
+            if (child)
+                child.kill('SIGTERM');
+        });
+        startDaemon();
+        return;
+    }
     const { ensureProjectDir } = await import('../utils/project-namespace.js');
     const { loadTeamsConfig } = await import('../bridge/teams-config.js');
     const { AgentSpawner } = await import('../bridge/spawner.js');
@@ -157,6 +317,34 @@ program
     });
     // Create spawner for auto-spawn (will be initialized after dashboard starts)
     let spawner = null;
+    // Track if we're already shutting down to prevent double-cleanup
+    let isShuttingDown = false;
+    const gracefulShutdown = async (reason) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.log(`\n[daemon] ${reason}, shutting down...`);
+        try {
+            if (spawner)
+                await spawner.releaseAll();
+            await daemon.stop();
+        }
+        catch (err) {
+            console.error('[daemon] Error during shutdown:', err);
+        }
+        process.exit(1);
+    };
+    // Handle uncaught exceptions - log and exit (supervisor will restart)
+    process.on('uncaughtException', (err) => {
+        console.error('[daemon] Uncaught exception:', err);
+        gracefulShutdown('Uncaught exception');
+    });
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[daemon] Unhandled rejection at:', promise, 'reason:', reason);
+        // Don't exit on unhandled rejections - just log them
+        // Most are recoverable (e.g., failed message delivery)
+    });
     process.on('SIGINT', async () => {
         console.log('\nStopping...');
         if (spawner) {
@@ -189,6 +377,13 @@ program
                 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
@@ -288,9 +483,11 @@ program
     .command('agents')
     .description('List connected agents and spawned workers')
     .option('--all', 'Include internal/CLI agents')
+    .option('--remote', 'Include agents from other linked machines (requires cloud link)')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const os = await import('node:os');
     const paths = getProjectPaths();
     const agentsPath = path.join(paths.teamDir, 'agents.json');
     // Load registered agents
@@ -311,6 +508,7 @@ program
             lastSeen: agent.lastSeen,
             team: worker?.team,
             pid: worker?.pid,
+            location: 'local',
         });
     });
     // Add workers not in registry (orphaned or not yet registered)
@@ -323,9 +521,51 @@ program
                 cli: worker.cli || '-',
                 team: worker.team,
                 pid: worker.pid,
+                location: 'local',
             });
         }
     });
+    // Include remote agents if --remote flag is set
+    if (options.remote) {
+        const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+            path.join(os.homedir(), '.local', 'share', 'agent-relay');
+        const configPath = path.join(dataDir, 'cloud-config.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                const response = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${config.apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ agents: [] }),
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    // Add remote agents (exclude local ones by name)
+                    const localNames = new Set(combined.map(a => a.name));
+                    for (const agent of data.allAgents) {
+                        if (!localNames.has(agent.name)) {
+                            combined.push({
+                                name: agent.name,
+                                status: agent.status.toUpperCase(),
+                                cli: '-',
+                                location: agent.daemonName,
+                                daemonId: agent.daemonId,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error('[warn] Failed to fetch remote agents:', err.message);
+            }
+        }
+        else {
+            console.error('[warn] Cloud not linked. Run `agent-relay cloud link` to see remote agents.');
+        }
+    }
     if (options.json) {
         console.log(JSON.stringify(combined, null, 2));
         return;
@@ -335,21 +575,39 @@ program
         console.log(`No agents found. Ensure the daemon is running and agents are connected${hint}.`);
         return;
     }
-    console.log('NAME            STATUS   CLI       TEAM');
-    console.log('─'.repeat(50));
-    combined.forEach((agent) => {
-        const name = agent.name.padEnd(15);
-        const status = agent.status.padEnd(8);
-        const cli = agent.cli.padEnd(9);
-        const team = agent.team ?? '-';
-        console.log(`${name} ${status} ${cli} ${team}`);
-    });
+    const hasRemote = combined.some(a => a.location !== 'local');
+    if (hasRemote) {
+        console.log('NAME            STATUS   CLI       LOCATION');
+        console.log('─'.repeat(55));
+        combined.forEach((agent) => {
+            const name = agent.name.padEnd(15);
+            const status = agent.status.padEnd(8);
+            const cli = agent.cli.padEnd(9);
+            const location = agent.location ?? 'local';
+            console.log(`${name} ${status} ${cli} ${location}`);
+        });
+    }
+    else {
+        console.log('NAME            STATUS   CLI       TEAM');
+        console.log('─'.repeat(50));
+        combined.forEach((agent) => {
+            const name = agent.name.padEnd(15);
+            const status = agent.status.padEnd(8);
+            const cli = agent.cli.padEnd(9);
+            const team = agent.team ?? '-';
+            console.log(`${name} ${status} ${cli} ${team}`);
+        });
+    }
     if (workers.length > 0) {
         console.log('');
         console.log('Commands:');
         console.log('  agent-relay agents:logs <name>   - View spawned agent output');
         console.log('  agent-relay agents:kill <name>   - Kill a spawned agent');
     }
+    if (!options.remote) {
+        console.log('');
+        console.log('Tip: Use --remote to include agents from other linked machines.');
+    }
 });
 // who - Show currently active agents (online within last 30s)
 program
@@ -541,6 +799,7 @@ program
     .description('Bridge multiple projects as orchestrator')
     .argument('[projects...]', 'Project paths to bridge')
     .option('--cli <tool>', 'CLI tool override for all projects')
+    .option('--architect [cli]', 'Spawn an architect agent to coordinate all projects (default: claude)')
     .action(async (projectPaths, options) => {
     const { resolveProjects, validateDaemons } = await import('../bridge/config.js');
     const { MultiProjectClient } = await import('../bridge/multi-project-client.js');
@@ -646,9 +905,106 @@ program
     console.log('Connected to all projects.');
     console.log('');
     console.log('Cross-project messaging:');
-    console.log('  @relay:projectId:agent Message');
-    console.log('  @relay:*:lead Broadcast to all leads');
+    console.log('  ->relay:projectId:agent Message');
+    console.log('  ->relay:*:lead Broadcast to all leads');
     console.log('');
+    // 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
+        const baseProject = valid[0];
+        const basePaths = getProjectPaths(baseProject.path);
+        // Build project context for the architect
+        const projectContext = valid.map(p => `- ${p.id}: ${p.path} (Lead: ${p.leadName})`).join('\n');
+        // Create architect system prompt
+        const architectPrompt = `You are the Architect, a cross-project coordinator overseeing multiple codebases.
+
+## Connected Projects
+${projectContext}
+
+## Your Role
+- Coordinate high-level work across all projects
+- Assign tasks to project leads
+- Ensure consistency and resolve cross-project dependencies
+- Review overall architecture decisions
+
+## Cross-Project Messaging
+
+Use this syntax to message agents in specific projects:
+
+\`\`\`
+->relay:${valid[0].id}:${valid[0].leadName} <<<
+Your message to this project's lead>>>
+
+->relay:${valid.length > 1 ? valid[1].id : valid[0].id}:* <<<
+Broadcast to all agents in a project>>>
+
+->relay:*:* <<<
+Broadcast to ALL agents in ALL projects>>>
+\`\`\`
+
+Format: \`->relay:project-id:agent-name\`
+
+## Getting Started
+1. Check in with each project lead to understand current status
+2. Identify cross-project dependencies
+3. Coordinate work across teams
+
+Start by greeting the project leads and asking for status updates.`;
+        console.log('Spawning Architect agent...');
+        console.log(`  CLI: ${architectCli}`);
+        console.log(`  Base project: ${baseProject.path}`);
+        console.log('');
+        // Determine command and args based on CLI
+        let command;
+        let args = [];
+        if (architectCli === 'claude' || architectCli.startsWith('claude:')) {
+            command = 'claude';
+            args = ['--dangerously-skip-permissions'];
+            // Add model if specified (e.g., claude:opus)
+            if (architectCli.includes(':')) {
+                const model = architectCli.split(':')[1];
+                args.push('--model', model);
+            }
+        }
+        else if (architectCli === 'codex') {
+            command = 'codex';
+            args = ['--dangerously-skip-permissions'];
+        }
+        else {
+            command = architectCli;
+        }
+        try {
+            architectWrapper = new TmuxWrapper({
+                name: 'Architect',
+                command,
+                args,
+                socketPath: basePaths.socketPath,
+                debug: false,
+                useInbox: true,
+                inboxDir: basePaths.dataDir,
+            });
+            await architectWrapper.start();
+            // Wait for agent to be ready, then inject the prompt
+            setTimeout(async () => {
+                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) {
+                    console.error('Failed to inject architect prompt:', err);
+                }
+            }, 3000);
+        }
+        catch (err) {
+            console.error('Failed to spawn Architect agent:', err);
+        }
+    }
     // Handle messages from projects
     client.onMessage = (projectId, from, payload, messageId) => {
         console.log(`[${projectId}] ${from}: ${payload.body.substring(0, 80)}...`);
@@ -985,6 +1341,40 @@ program
         }
     }
 });
+// release - Release a spawned agent via API (works from any context, no terminal required)
+program
+    .command('release')
+    .description('Release a spawned agent via API (no terminal required)')
+    .argument('<name>', 'Agent name to release')
+    .option('--port <port>', 'Dashboard port', DEFAULT_DASHBOARD_PORT)
+    .action(async (name, options) => {
+    const port = options.port || DEFAULT_DASHBOARD_PORT;
+    try {
+        const response = await fetch(`http://localhost:${port}/api/spawned/${encodeURIComponent(name)}`, {
+            method: 'DELETE',
+        });
+        const result = await response.json();
+        if (result.success) {
+            console.log(`Released agent: ${name}`);
+            process.exit(0);
+        }
+        else {
+            console.error(`Failed to release ${name}: ${result.error || 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        // If API call fails, try to provide helpful error message
+        if (err.code === 'ECONNREFUSED') {
+            console.error(`Cannot connect to dashboard at port ${port}. Is the daemon running?`);
+            console.log(`Run 'agent-relay up' to start the daemon.`);
+        }
+        else {
+            console.error(`Failed to release ${name}: ${err.message}`);
+        }
+        process.exit(1);
+    }
+});
 // agents:kill - Kill a spawned agent by PID
 program
     .command('agents:kill')
@@ -1039,5 +1429,796 @@ program
         }
     }
 });
+// ============================================================================
+// Cloud commands
+// ============================================================================
+const cloudCommand = program
+    .command('cloud')
+    .description('Cloud account and sync commands');
+cloudCommand
+    .command('link')
+    .description('Link this machine to your Agent Relay Cloud account')
+    .option('--name <name>', 'Name for this machine')
+    .option('--cloud-url <url>', 'Cloud API URL', process.env.AGENT_RELAY_CLOUD_URL || 'https://api.agent-relay.com')
+    .action(async (options) => {
+    const os = await import('node:os');
+    const crypto = await import('node:crypto');
+    const readline = await import('node:readline');
+    const cloudUrl = options.cloudUrl;
+    const machineName = options.name || os.hostname();
+    // Generate machine ID
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const machineIdPath = path.join(dataDir, 'machine-id');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    let machineId;
+    if (fs.existsSync(machineIdPath)) {
+        machineId = fs.readFileSync(machineIdPath, 'utf-8').trim();
+    }
+    else {
+        machineId = `${os.hostname()}-${crypto.randomBytes(8).toString('hex')}`;
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.writeFileSync(machineIdPath, machineId);
+    }
+    console.log('');
+    console.log('🔗 Agent Relay Cloud - Link Machine');
+    console.log('');
+    console.log(`Machine: ${machineName}`);
+    console.log(`ID: ${machineId}`);
+    console.log('');
+    // Generate a temporary code for the browser auth flow
+    const tempCode = crypto.randomBytes(16).toString('hex');
+    // Store temp code for callback
+    const tempCodePath = path.join(dataDir, '.link-code');
+    fs.writeFileSync(tempCodePath, tempCode);
+    const authUrl = `${cloudUrl.replace('/api', '')}/cloud/link?code=${tempCode}&machine=${encodeURIComponent(machineId)}&name=${encodeURIComponent(machineName)}`;
+    console.log('Open this URL in your browser to authenticate:');
+    console.log('');
+    console.log(`  ${authUrl}`);
+    console.log('');
+    // Try to open browser automatically
+    try {
+        const openCommand = process.platform === 'darwin' ? 'open' :
+            process.platform === 'win32' ? 'start' : 'xdg-open';
+        await execAsync(`${openCommand} "${authUrl}"`);
+        console.log('(Browser opened automatically)');
+    }
+    catch {
+        console.log('(Copy the URL above and paste it in your browser)');
+    }
+    console.log('');
+    console.log('After authenticating, paste your API key here:');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const apiKey = await new Promise((resolve) => {
+        rl.question('API Key: ', (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+    if (!apiKey || !apiKey.startsWith('ar_live_')) {
+        console.error('');
+        console.error('Invalid API key format. Expected ar_live_...');
+        process.exit(1);
+    }
+    // Verify the API key works
+    console.log('');
+    console.log('Verifying API key...');
+    try {
+        const response = await fetch(`${cloudUrl}/api/daemons/heartbeat`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                agents: [],
+                metrics: { linkedAt: new Date().toISOString() },
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to verify API key: ${error}`);
+            process.exit(1);
+        }
+        // Save config
+        const config = {
+            apiKey,
+            cloudUrl,
+            machineId,
+            machineName,
+            linkedAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        fs.chmodSync(configPath, 0o600); // Secure the file
+        // Clean up temp code
+        if (fs.existsSync(tempCodePath)) {
+            fs.unlinkSync(tempCodePath);
+        }
+        console.log('');
+        console.log('✓ Machine linked successfully!');
+        console.log('');
+        console.log('Your daemon will now sync with Agent Relay Cloud.');
+        console.log('Run `agent-relay up` to start with cloud sync enabled.');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to connect to cloud: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('unlink')
+    .description('Unlink this machine from Agent Relay Cloud')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log('This machine is not linked to Agent Relay Cloud.');
+        return;
+    }
+    // Read current config
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    // Delete config file
+    fs.unlinkSync(configPath);
+    console.log('');
+    console.log('✓ Machine unlinked from Agent Relay Cloud');
+    console.log('');
+    console.log(`Machine ID: ${config.machineId}`);
+    console.log(`Was linked since: ${config.linkedAt}`);
+    console.log('');
+    console.log('Note: The API key has been removed locally. To fully revoke access,');
+    console.log('visit your Agent Relay Cloud dashboard and remove this machine.');
+    console.log('');
+});
+cloudCommand
+    .command('status')
+    .description('Show cloud sync status')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.log('');
+        console.log('Cloud sync: Not configured');
+        console.log('');
+        console.log('Run `agent-relay cloud link` to connect to Agent Relay Cloud.');
+        console.log('');
+        return;
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log('');
+    console.log('Cloud sync: Enabled');
+    console.log('');
+    console.log(`  Machine: ${config.machineName}`);
+    console.log(`  ID: ${config.machineId}`);
+    console.log(`  Cloud URL: ${config.cloudUrl}`);
+    console.log(`  Linked: ${new Date(config.linkedAt).toLocaleString()}`);
+    console.log('');
+    // Check if daemon is running and connected
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    if (fs.existsSync(paths.socketPath)) {
+        console.log('  Daemon: Running');
+        // Try to get cloud sync status from daemon
+        try {
+            const response = await fetch(`${config.cloudUrl}/api/daemons/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ agents: [], metrics: {} }),
+            });
+            if (response.ok) {
+                console.log('  Cloud connection: Online');
+            }
+            else {
+                console.log('  Cloud connection: Error (API key may be invalid)');
+            }
+        }
+        catch (err) {
+            console.log(`  Cloud connection: Offline (${err.message})`);
+        }
+    }
+    else {
+        console.log('  Daemon: Not running');
+        console.log('  Cloud connection: Offline (daemon not started)');
+    }
+    console.log('');
+});
+cloudCommand
+    .command('sync')
+    .description('Manually sync credentials from cloud')
+    .action(async () => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log('Syncing credentials from cloud...');
+    try {
+        const response = await fetch(`${config.cloudUrl}/api/daemons/credentials`, {
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to sync: ${error}`);
+            process.exit(1);
+        }
+        const data = await response.json();
+        console.log('');
+        console.log(`Synced ${data.credentials.length} provider credentials:`);
+        for (const cred of data.credentials) {
+            console.log(`  - ${cred.provider}`);
+        }
+        // Save credentials locally for daemon to use
+        const credentialsPath = path.join(dataDir, 'cloud-credentials.json');
+        fs.writeFileSync(credentialsPath, JSON.stringify(data.credentials, null, 2));
+        fs.chmodSync(credentialsPath, 0o600);
+        console.log('');
+        console.log('✓ Credentials synced successfully');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to sync: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ============================================================================
+// TRAJECTORY COMMANDS (trail proxy)
+// ============================================================================
+// trail - Proxy to trail CLI for trajectory tracking
+program
+    .command('trail')
+    .description('Trajectory tracking commands (proxies to trail CLI)')
+    .argument('[args...]', 'Arguments to pass to trail CLI')
+    .allowUnknownOption()
+    .action(async (args) => {
+    const { spawn } = await import('node:child_process');
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    const paths = getProjectPaths();
+    // Check if trail is available
+    const trailCheck = spawn('which', ['trail'], { stdio: 'pipe' });
+    const trailExists = await new Promise((resolve) => {
+        trailCheck.on('close', (code) => resolve(code === 0));
+        trailCheck.on('error', () => resolve(false));
+    });
+    if (!trailExists) {
+        console.error('trail CLI not found. Install with: npm install -g agent-trajectories');
+        console.log('');
+        console.log('The trail CLI provides trajectory tracking for agent work:');
+        console.log('  trail start "<task>"         Start tracking a new trajectory');
+        console.log('  trail status                 Show current trajectory status');
+        console.log('  trail phase <phase>          Transition to PDERO phase');
+        console.log('  trail decision "<choice>"    Record a decision');
+        console.log('  trail complete               Complete the trajectory');
+        console.log('  trail list                   List all trajectories');
+        console.log('');
+        console.log('PDERO phases: plan, design, execute, review, observe');
+        process.exit(1);
+    }
+    // Spawn trail with the provided arguments
+    const trailProc = spawn('trail', args, {
+        cwd: paths.projectRoot,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            TRAJECTORIES_PROJECT: paths.projectId,
+            TRAJECTORIES_DATA_DIR: paths.dataDir,
+        },
+    });
+    trailProc.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+    trailProc.on('error', (err) => {
+        console.error(`Failed to run trail: ${err.message}`);
+        process.exit(1);
+    });
+});
+cloudCommand
+    .command('agents')
+    .description('List agents across all linked machines')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    try {
+        // Get agents from cloud
+        const response = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ agents: [] }), // Report no agents, just fetch list
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error(`Failed to fetch agents: ${error}`);
+            process.exit(1);
+        }
+        const data = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(data.allAgents, null, 2));
+            return;
+        }
+        if (!data.allAgents.length) {
+            console.log('No agents found across linked machines.');
+            console.log('Make sure daemons are running on linked machines.');
+            return;
+        }
+        console.log('');
+        console.log('Agents across all linked machines:');
+        console.log('');
+        console.log('NAME            STATUS   DAEMON              MACHINE');
+        console.log('─'.repeat(65));
+        // Group by daemon
+        const byDaemon = new Map();
+        for (const agent of data.allAgents) {
+            const existing = byDaemon.get(agent.daemonName) || [];
+            existing.push(agent);
+            byDaemon.set(agent.daemonName, existing);
+        }
+        for (const [daemonName, agents] of byDaemon.entries()) {
+            for (const agent of agents) {
+                const name = agent.name.padEnd(15);
+                const status = agent.status.padEnd(8);
+                const daemon = daemonName.padEnd(18);
+                const machine = agent.machineId.substring(0, 20);
+                console.log(`${name} ${status} ${daemon} ${machine}`);
+            }
+        }
+        console.log('');
+        console.log(`Total: ${data.allAgents.length} agents on ${byDaemon.size} machines`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to fetch agents: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('send')
+    .description('Send a message to an agent on any linked machine')
+    .argument('<agent>', 'Target agent name')
+    .argument('<message>', 'Message to send')
+    .option('--from <name>', 'Sender name', 'cli')
+    .action(async (agent, message, options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    console.log(`Sending message to ${agent}...`);
+    try {
+        // First, find which daemon the agent is on
+        const agentsResponse = await fetch(`${config.cloudUrl}/api/daemons/agents`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ agents: [] }),
+        });
+        if (!agentsResponse.ok) {
+            const error = await agentsResponse.text();
+            console.error(`Failed to find agent: ${error}`);
+            process.exit(1);
+        }
+        const agentsData = await agentsResponse.json();
+        const targetAgent = agentsData.allAgents.find(a => a.name === agent);
+        if (!targetAgent) {
+            console.error(`Agent "${agent}" not found.`);
+            console.log('Available agents:');
+            for (const a of agentsData.allAgents) {
+                console.log(`  - ${a.name} (on ${a.daemonName})`);
+            }
+            process.exit(1);
+        }
+        // Send the message
+        const sendResponse = await fetch(`${config.cloudUrl}/api/daemons/message`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                targetDaemonId: targetAgent.daemonId,
+                targetAgent: agent,
+                message: {
+                    from: options.from,
+                    content: message,
+                },
+            }),
+        });
+        if (!sendResponse.ok) {
+            const error = await sendResponse.text();
+            console.error(`Failed to send message: ${error}`);
+            process.exit(1);
+        }
+        console.log('');
+        console.log(`✓ Message sent to ${agent} on ${targetAgent.daemonName}`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed to send message: ${err.message}`);
+        process.exit(1);
+    }
+});
+cloudCommand
+    .command('daemons')
+    .description('List all linked daemon instances')
+    .option('--json', 'Output as JSON')
+    .action(async (_options) => {
+    const os = await import('node:os');
+    const dataDir = process.env.AGENT_RELAY_DATA_DIR ||
+        path.join(os.homedir(), '.local', 'share', 'agent-relay');
+    const configPath = path.join(dataDir, 'cloud-config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('Not linked to cloud. Run `agent-relay cloud link` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    try {
+        // Get daemons list (requires browser auth, so we use a workaround)
+        // For now, just show what we know about our own daemon
+        console.log('');
+        console.log('Linked Daemon:');
+        console.log('');
+        console.log(`  Machine: ${config.machineName}`);
+        console.log(`  ID: ${config.machineId}`);
+        console.log(`  Cloud: ${config.cloudUrl}`);
+        console.log(`  Linked: ${new Date(config.linkedAt).toLocaleString()}`);
+        console.log('');
+        console.log('Note: To see all linked daemons, visit your cloud dashboard.');
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Failed: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Monitoring commands (metrics, health, profiler)
+// ============================================================================
+// metrics - Show agent memory metrics
+program
+    .command('metrics')
+    .description('Show agent memory metrics and resource usage')
+    .option('--agent <name>', 'Show metrics for specific agent')
+    .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 || DEFAULT_DASHBOARD_PORT;
+    const fetchMetrics = async () => {
+        try {
+            const response = await fetch(`http://localhost:${port}/api/metrics/agents`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (err) {
+            if (err.code === 'ECONNREFUSED') {
+                console.error(`Cannot connect to dashboard at port ${port}. Is the daemon running?`);
+                console.log(`Run 'agent-relay up' to start the daemon.`);
+            }
+            else {
+                console.error(`Failed to fetch metrics: ${err.message}`);
+            }
+            process.exit(1);
+        }
+    };
+    const formatBytes = (bytes) => {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(k));
+        return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+    };
+    const formatUptime = (ms) => {
+        if (ms < 60000)
+            return `${Math.floor(ms / 1000)}s`;
+        if (ms < 3600000)
+            return `${Math.floor(ms / 60000)}m`;
+        return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+    };
+    const displayMetrics = (data) => {
+        let agents = data.agents;
+        if (options.agent) {
+            agents = agents.filter(a => a.name === options.agent);
+            if (agents.length === 0) {
+                console.error(`Agent "${options.agent}" not found`);
+                return;
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify({ agents, system: data.system }, null, 2));
+            return;
+        }
+        if (options.watch) {
+            // Clear screen for watch mode
+            console.clear();
+            console.log(`Agent Metrics (updating every ${options.interval}ms)  [Ctrl+C to stop]`);
+            console.log(`System: ${formatBytes(data.system.heapUsed)} heap / ${formatBytes(data.system.freeMemory)} free`);
+            console.log('');
+        }
+        if (agents.length === 0) {
+            console.log('No agents with memory metrics.');
+            console.log('Ensure agents are running and memory monitoring is enabled.');
+            return;
+        }
+        console.log('AGENT           PID      MEMORY      CPU    TREND       ALERT     UPTIME');
+        console.log('─'.repeat(75));
+        for (const agent of agents) {
+            const name = agent.name.padEnd(15);
+            const pid = (agent.pid?.toString() || '-').padEnd(8);
+            const memory = formatBytes(agent.rssBytes || 0).padEnd(11);
+            const cpu = ((agent.cpuPercent?.toFixed(1) || '0') + '%').padEnd(6);
+            const trend = (agent.trend || 'unknown').padEnd(11);
+            const alertColors = {
+                normal: 'normal',
+                warning: '\x1b[33mwarning\x1b[0m',
+                critical: '\x1b[31mcritical\x1b[0m',
+                oom_imminent: '\x1b[31;1mOOM!\x1b[0m',
+            };
+            const alert = (alertColors[agent.alertLevel || 'normal'] || agent.alertLevel || '-').padEnd(9);
+            const uptime = formatUptime(agent.uptimeMs || 0);
+            console.log(`${name} ${pid} ${memory} ${cpu} ${trend} ${alert} ${uptime}`);
+        }
+        if (!options.watch) {
+            console.log('');
+            console.log(`Total: ${agents.length} agent(s)`);
+            if (agents.some(a => a.alertLevel && a.alertLevel !== 'normal')) {
+                console.log('');
+                console.log('⚠️  Some agents have elevated memory usage. Run `agent-relay health` for details.');
+            }
+        }
+    };
+    if (options.watch) {
+        const interval = parseInt(options.interval || '5000', 10);
+        const update = async () => {
+            try {
+                const data = await fetchMetrics();
+                displayMetrics(data);
+            }
+            catch {
+                // Error already logged in fetchMetrics
+            }
+        };
+        process.on('SIGINT', () => {
+            console.log('\nStopped watching metrics.');
+            process.exit(0);
+        });
+        await update();
+        setInterval(update, interval);
+    }
+    else {
+        const data = await fetchMetrics();
+        displayMetrics(data);
+    }
+});
+// health - Show crash insights and system health
+program
+    .command('health')
+    .description('Show system health, crash insights, and recommendations')
+    .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 || DEFAULT_DASHBOARD_PORT;
+    try {
+        const response = await fetch(`http://localhost:${port}/api/metrics/health`);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        // Health score with color
+        const scoreColor = data.healthScore >= 80 ? '\x1b[32m' : // Green
+            data.healthScore >= 50 ? '\x1b[33m' : // Yellow
+                '\x1b[31m'; // Red
+        const resetColor = '\x1b[0m';
+        console.log('');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log(`  SYSTEM HEALTH: ${scoreColor}${data.healthScore}/100${resetColor}`);
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('');
+        console.log(`  ${data.summary}`);
+        console.log('');
+        // Show stats
+        console.log(`  Agents: ${data.stats.agentCount}`);
+        console.log(`  Crashes (24h): ${data.stats.totalCrashes24h}`);
+        console.log(`  Alerts (24h): ${data.stats.totalAlerts24h}`);
+        console.log('');
+        // Show issues
+        if (data.issues.length > 0) {
+            console.log('  ISSUES:');
+            for (const issue of data.issues) {
+                const icon = issue.severity === 'critical' ? '🔴' :
+                    issue.severity === 'high' ? '🟠' :
+                        issue.severity === 'medium' ? '🟡' : '🔵';
+                console.log(`    ${icon} ${issue.message}`);
+            }
+            console.log('');
+        }
+        // Show recommendations
+        if (data.recommendations.length > 0) {
+            console.log('  RECOMMENDATIONS:');
+            for (const rec of data.recommendations) {
+                console.log(`    → ${rec}`);
+            }
+            console.log('');
+        }
+        // Show crashes if requested
+        if (options.crashes && data.crashes.length > 0) {
+            console.log('  RECENT CRASHES:');
+            console.log('  ─────────────────────────────────────────────────────────────');
+            for (const crash of data.crashes.slice(0, 10)) {
+                const time = new Date(crash.crashedAt).toLocaleString();
+                console.log(`    ${crash.agentName} - ${time}`);
+                console.log(`      Cause: ${crash.likelyCause} | ${crash.summary.slice(0, 60)}...`);
+            }
+            console.log('');
+        }
+        // Show alerts if requested
+        if (options.alerts && data.alerts.length > 0) {
+            console.log('  UNACKNOWLEDGED ALERTS:');
+            console.log('  ─────────────────────────────────────────────────────────────');
+            for (const alert of data.alerts.slice(0, 10)) {
+                const _time = new Date(alert.createdAt).toLocaleString();
+                const icon = alert.alertType === 'oom_imminent' ? '🔴' :
+                    alert.alertType === 'critical' ? '🟠' : '🟡';
+                console.log(`    ${icon} ${alert.agentName} - ${alert.alertType}`);
+                console.log(`      ${alert.message}`);
+            }
+            console.log('');
+        }
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('');
+        if (!options.crashes && data.stats.totalCrashes24h > 0) {
+            console.log('  Tip: Run `agent-relay health --crashes` to see crash details');
+        }
+        if (!options.alerts && data.stats.totalAlerts24h > 0) {
+            console.log('  Tip: Run `agent-relay health --alerts` to see alerts');
+        }
+        console.log('');
+    }
+    catch (err) {
+        if (err.code === 'ECONNREFUSED') {
+            console.error(`Cannot connect to dashboard at port ${port}. Is the daemon running?`);
+            console.log(`Run 'agent-relay up' to start the daemon.`);
+        }
+        else {
+            console.error(`Failed to fetch health data: ${err.message}`);
+        }
+        process.exit(1);
+    }
+});
+// profile - Run agent with profiling enabled
+program
+    .command('profile')
+    .description('Run an agent with memory profiling enabled')
+    .argument('<command...>', 'Command to profile')
+    .option('-n, --name <name>', 'Agent name')
+    .option('--heap-snapshot-interval <ms>', 'Take heap snapshots at interval (ms)', '60000')
+    .option('--output-dir <dir>', 'Directory for profile output', './profiles')
+    .option('--expose-gc', 'Expose garbage collector for manual GC')
+    .action(async (commandParts, options) => {
+    const { getProjectPaths } = await import('../utils/project-namespace.js');
+    if (!commandParts || commandParts.length === 0) {
+        console.error('No command specified');
+        process.exit(1);
+    }
+    const [cmd, ...args] = commandParts;
+    const agentName = options.name ?? generateAgentName();
+    const outputDir = options.outputDir || './profiles';
+    const snapshotInterval = parseInt(options.heapSnapshotInterval || '60000', 10);
+    // Create output directory
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    console.log('');
+    console.log('🔬 Agent Relay Profiler');
+    console.log('');
+    console.log(`  Agent: ${agentName}`);
+    console.log(`  Command: ${cmd} ${args.join(' ')}`);
+    console.log(`  Output: ${outputDir}`);
+    console.log(`  Heap snapshots: every ${snapshotInterval}ms`);
+    console.log('');
+    // Build Node.js flags for profiling
+    const nodeFlags = [
+        '--inspect', // Enable inspector
+        '--inspect-brk=0', // Don't actually break, just enable
+    ];
+    if (options.exposeGc) {
+        nodeFlags.push('--expose-gc');
+    }
+    // Set environment variables for profiling
+    const profileEnv = {
+        ...process.env,
+        NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} ${nodeFlags.join(' ')}`.trim(),
+        AGENT_RELAY_PROFILE_ENABLED: '1',
+        AGENT_RELAY_PROFILE_OUTPUT: outputDir,
+        AGENT_RELAY_PROFILE_INTERVAL: snapshotInterval.toString(),
+    };
+    console.log('Starting profiled agent...');
+    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({
+        name: agentName,
+        command: cmd,
+        args,
+        socketPath: paths.socketPath,
+        debug: true,
+        env: profileEnv,
+        useInbox: true,
+        inboxDir: paths.dataDir,
+    });
+    // Start memory sampling
+    const sampleInterval = setInterval(() => {
+        const memUsage = process.memoryUsage();
+        const timestamp = new Date().toISOString();
+        const sample = {
+            timestamp,
+            heapUsed: memUsage.heapUsed,
+            heapTotal: memUsage.heapTotal,
+            external: memUsage.external,
+            rss: memUsage.rss,
+        };
+        // Append to samples file
+        const samplesFile = path.join(outputDir, `${agentName}-memory.jsonl`);
+        fs.appendFileSync(samplesFile, JSON.stringify(sample) + '\n');
+    }, 5000);
+    process.on('SIGINT', async () => {
+        clearInterval(sampleInterval);
+        console.log('\n');
+        console.log('Profiling stopped.');
+        console.log('');
+        console.log(`Profile data saved to: ${outputDir}/`);
+        console.log(`  - ${agentName}-memory.jsonl  (memory samples)`);
+        console.log('');
+        console.log('To analyze:');
+        console.log(`  1. Open chrome://inspect in Chrome`);
+        console.log(`  2. Load CPU/heap profiles from ${outputDir}/`);
+        console.log('');
+        wrapper.stop();
+        process.exit(0);
+    });
+    await wrapper.start();
+    console.log(`Profiling ${agentName}... Press Ctrl+C to stop.`);
+});
 program.parse();
 //# sourceMappingURL=index.js.map