agent-relay 1.5.2 → 2.0.0

package/dist/bridge/spawner.js

@@ -1,858 +0,0 @@
-/**
- * Agent Spawner
- * Handles spawning and releasing worker agents via node-pty.
- * Workers run headlessly with output capture for logs.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { sleep } from './utils.js';
-import { getProjectPaths } from '../utils/project-namespace.js';
-import { resolveCommand } from '../utils/command-resolver.js';
-import { RelayPtyOrchestrator } from '../wrapper/relay-pty-orchestrator.js';
-import { PtyWrapper } from '../wrapper/pty-wrapper.js';
-import { selectShadowCli } from './shadow-cli.js';
-// Get the directory where this module is located (for binary path resolution)
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-import { AgentPolicyService } from '../policy/agent-policy.js';
-import { buildClaudeArgs, findAgentConfig } from '../utils/agent-config.js';
-import { composeForAgent } from '../wrapper/prompt-composer.js';
-import { getUserDirectoryService } from '../daemon/user-directory.js';
-/**
- * Get relay protocol instructions for a spawned agent.
- * This provides the agent with the communication protocol it needs to work with the relay.
- */
-function getRelayInstructions(agentName) {
-    return [
-        '# Agent Relay Protocol',
-        '',
-        `You are agent "${agentName}" connected to Agent Relay for multi-agent coordination.`,
-        '',
-        '## Sending Messages',
-        '',
-        'Write a file to your outbox, then output the trigger:',
-        '',
-        '```bash',
-        `cat > /tmp/relay-outbox/${agentName}/msg << 'EOF'`,
-        'TO: TargetAgent',
-        '',
-        'Your message here.',
-        'EOF',
-        '```',
-        '',
-        'Then output: `->relay-file:msg`',
-        '',
-        '## Communication Rules',
-        '',
-        '1. **ACK immediately** - When you receive a task:',
-        '```bash',
-        `cat > /tmp/relay-outbox/${agentName}/ack << 'EOF'`,
-        'TO: Sender',
-        '',
-        'ACK: Brief description of task received',
-        'EOF',
-        '```',
-        'Then: `->relay-file:ack`',
-        '',
-        '2. **Report completion** - When done:',
-        '```bash',
-        `cat > /tmp/relay-outbox/${agentName}/done << 'EOF'`,
-        'TO: Sender',
-        '',
-        'DONE: Brief summary of what was completed',
-        'EOF',
-        '```',
-        'Then: `->relay-file:done`',
-        '',
-        '## Message Format',
-        '',
-        '```',
-        'TO: Target',
-        'THREAD: optional-thread',
-        '',
-        'Message body (everything after blank line)',
-        '```',
-        '',
-        '| TO Value | Behavior |',
-        '|----------|----------|',
-        '| `AgentName` | Direct message |',
-        '| `*` | Broadcast to all |',
-        '| `#channel` | Channel message |',
-    ].join('\n');
-}
-/**
- * Check if the relay-pty binary is available.
- * Returns the path to the binary if found, null otherwise.
- *
- * Search order:
- * 1. bin/relay-pty in package root (installed by postinstall)
- * 2. relay-pty/target/release/relay-pty (local Rust build)
- * 3. /usr/local/bin/relay-pty (global install)
- */
-function findRelayPtyBinary() {
-    // Get the package root (three levels up from dist/bridge/)
-    const packageRoot = path.join(__dirname, '..', '..');
-    const candidates = [
-        // Primary: installed by postinstall from platform-specific binary
-        path.join(packageRoot, 'bin', 'relay-pty'),
-        // Development: local Rust build
-        path.join(packageRoot, 'relay-pty', 'target', 'release', 'relay-pty'),
-        path.join(packageRoot, 'relay-pty', 'target', 'debug', 'relay-pty'),
-        // Local build in cwd (for development)
-        path.join(process.cwd(), 'relay-pty', 'target', 'release', 'relay-pty'),
-        // Installed globally
-        '/usr/local/bin/relay-pty',
-        // In node_modules (when installed as dependency)
-        path.join(process.cwd(), 'node_modules', 'agent-relay', 'bin', 'relay-pty'),
-    ];
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-/** Cached result of relay-pty binary check */
-let relayPtyBinaryPath;
-let relayPtyBinaryChecked = false;
-/**
- * Check if relay-pty binary is available (cached).
- * Returns true if the binary exists, false otherwise.
- */
-function hasRelayPtyBinary() {
-    if (!relayPtyBinaryChecked) {
-        relayPtyBinaryPath = findRelayPtyBinary();
-        relayPtyBinaryChecked = true;
-        if (relayPtyBinaryPath) {
-            console.log(`[spawner] relay-pty binary found: ${relayPtyBinaryPath}`);
-        }
-        else {
-            console.log('[spawner] relay-pty binary not found, will use PtyWrapper fallback');
-        }
-    }
-    return relayPtyBinaryPath !== null;
-}
-export class AgentSpawner {
-    activeWorkers = new Map();
-    agentsPath;
-    projectRoot;
-    socketPath;
-    logsDir;
-    workersPath;
-    dashboardPort;
-    onAgentDeath;
-    cloudPersistence;
-    policyService;
-    policyEnforcementEnabled = false;
-    constructor(projectRoot, _tmuxSession, dashboardPort) {
-        const paths = getProjectPaths(projectRoot);
-        this.projectRoot = paths.projectRoot;
-        // Use connected-agents.json (live socket connections) instead of agents.json (historical registry)
-        // This ensures spawned agents have actual daemon connections for channel message delivery
-        this.agentsPath = path.join(paths.teamDir, 'connected-agents.json');
-        this.socketPath = paths.socketPath;
-        this.logsDir = path.join(paths.teamDir, 'worker-logs');
-        this.workersPath = path.join(paths.teamDir, 'workers.json');
-        this.dashboardPort = dashboardPort;
-        // Ensure logs directory exists
-        fs.mkdirSync(this.logsDir, { recursive: true });
-        // Initialize policy service if enforcement is enabled
-        if (process.env.AGENT_POLICY_ENFORCEMENT === '1') {
-            this.policyEnforcementEnabled = true;
-            this.policyService = new AgentPolicyService({
-                projectRoot: this.projectRoot,
-                workspaceId: process.env.WORKSPACE_ID,
-                strictMode: process.env.AGENT_POLICY_STRICT === '1',
-            });
-            console.log('[spawner] Policy enforcement enabled');
-        }
-    }
-    /**
-     * Set cloud policy fetcher for workspace-level policies
-     */
-    setCloudPolicyFetcher(fetcher) {
-        if (this.policyService) {
-            // Recreate policy service with cloud fetcher
-            this.policyService = new AgentPolicyService({
-                projectRoot: this.projectRoot,
-                workspaceId: process.env.WORKSPACE_ID,
-                cloudFetcher: fetcher,
-                strictMode: process.env.AGENT_POLICY_STRICT === '1',
-            });
-        }
-    }
-    /**
-     * Get the policy service (for external access to policy checks)
-     */
-    getPolicyService() {
-        return this.policyService;
-    }
-    /**
-     * Set the dashboard port (for nested spawn API calls).
-     * Called after the dashboard server starts and we know the actual port.
-     */
-    setDashboardPort(port) {
-        console.log(`[spawner] Dashboard port set to ${port} - nested spawns now enabled`);
-        this.dashboardPort = port;
-    }
-    /**
-     * Set callback for agent death notifications.
-     * Called when an agent exits unexpectedly (non-zero exit code).
-     */
-    setOnAgentDeath(callback) {
-        this.onAgentDeath = callback;
-    }
-    /**
-     * Set cloud persistence handler for forwarding RelayPtyOrchestrator events.
-     * When set, 'summary' and 'session-end' events from spawned agents
-     * are forwarded to the handler for cloud persistence (PostgreSQL/Redis).
-     *
-     * Note: Enable via RELAY_CLOUD_ENABLED=true environment variable.
-     */
-    setCloudPersistence(handler) {
-        this.cloudPersistence = handler;
-        console.log('[spawner] Cloud persistence handler set');
-    }
-    /**
-     * Bind cloud persistence event handlers to a RelayPtyOrchestrator.
-     * Returns the listener references for cleanup.
-     */
-    bindCloudPersistenceEvents(name, pty) {
-        if (!this.cloudPersistence)
-            return {};
-        const summaryListener = async (event) => {
-            try {
-                await this.cloudPersistence.onSummary(name, event);
-            }
-            catch (err) {
-                console.error(`[spawner] Cloud persistence summary error for ${name}:`, err);
-            }
-        };
-        const sessionEndListener = async (event) => {
-            try {
-                await this.cloudPersistence.onSessionEnd(name, event);
-            }
-            catch (err) {
-                console.error(`[spawner] Cloud persistence session-end error for ${name}:`, err);
-            }
-        };
-        pty.on('summary', summaryListener);
-        pty.on('session-end', sessionEndListener);
-        return { summary: summaryListener, sessionEnd: sessionEndListener };
-    }
-    /**
-     * Unbind all tracked listeners from a RelayPtyOrchestrator.
-     */
-    unbindListeners(pty, listeners) {
-        if (!listeners)
-            return;
-        if (listeners.output) {
-            pty.off('output', listeners.output);
-        }
-        if (listeners.summary) {
-            pty.off('summary', listeners.summary);
-        }
-        if (listeners.sessionEnd) {
-            pty.off('session-end', listeners.sessionEnd);
-        }
-    }
-    /**
-     * Spawn a new worker agent using node-pty
-     */
-    async spawn(request) {
-        const { name, cli, task, team, spawnerName, userId } = request;
-        const debug = process.env.DEBUG_SPAWN === '1';
-        // Check if worker already exists
-        if (this.activeWorkers.has(name)) {
-            return {
-                success: false,
-                name,
-                error: `Worker ${name} already exists`,
-            };
-        }
-        // Policy enforcement: check if the spawner is authorized to spawn this agent
-        if (this.policyEnforcementEnabled && this.policyService && spawnerName) {
-            const decision = await this.policyService.canSpawn(spawnerName, name, cli);
-            if (!decision.allowed) {
-                console.warn(`[spawner] Policy blocked spawn: ${spawnerName} -> ${name}: ${decision.reason}`);
-                return {
-                    success: false,
-                    name,
-                    error: `Policy denied: ${decision.reason}`,
-                    policyDecision: decision,
-                };
-            }
-            if (debug) {
-                console.log(`[spawner:debug] Policy allowed spawn: ${spawnerName} -> ${name} (source: ${decision.policySource})`);
-            }
-        }
-        try {
-            // Parse CLI command
-            const cliParts = cli.split(' ');
-            const commandName = cliParts[0];
-            const args = cliParts.slice(1);
-            // Resolve full path to avoid posix_spawnp failures
-            const command = resolveCommand(commandName);
-            console.log(`[spawner] Resolved '${commandName}' -> '${command}'`);
-            if (command === commandName && !commandName.startsWith('/')) {
-                // Command wasn't resolved - it might not exist
-                console.warn(`[spawner] Warning: Could not resolve path for '${commandName}', spawn may fail`);
-            }
-            // Add --dangerously-skip-permissions for Claude agents
-            const isClaudeCli = commandName.startsWith('claude');
-            if (isClaudeCli && !args.includes('--dangerously-skip-permissions')) {
-                args.push('--dangerously-skip-permissions');
-            }
-            // Apply agent config (model, --agent flag) from .claude/agents/ if available
-            // This ensures spawned agents respect their profile settings
-            if (isClaudeCli) {
-                // Get agent config for model tracking
-                const agentConfig = findAgentConfig(name, this.projectRoot);
-                const model = agentConfig?.model || 'sonnet'; // Default to sonnet
-                const configuredArgs = buildClaudeArgs(name, args, this.projectRoot);
-                // Replace args with configured version (includes --model and --agent if found)
-                args.length = 0;
-                args.push(...configuredArgs);
-                // Cost tracking: log which model is being used
-                console.log(`[spawner] Agent ${name}: model=${model}, cli=${cli}`);
-                if (debug)
-                    console.log(`[spawner:debug] Applied agent config for ${name}: ${args.join(' ')}`);
-            }
-            // Add --dangerously-bypass-approvals-and-sandbox for Codex agents
-            const isCodexCli = commandName.startsWith('codex');
-            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
-            let relayInstructions = getRelayInstructions(name);
-            // Compose role-specific prompts if agent has a role defined in .claude/agents/
-            const agentConfigForRole = isClaudeCli ? findAgentConfig(name, this.projectRoot) : null;
-            if (agentConfigForRole?.role) {
-                const validRoles = ['planner', 'worker', 'reviewer', 'lead', 'shadow'];
-                const role = agentConfigForRole.role.toLowerCase();
-                if (validRoles.includes(role)) {
-                    try {
-                        const composed = await composeForAgent({ name, role }, this.projectRoot, { taskDescription: task });
-                        if (composed.content) {
-                            relayInstructions = `${composed.content}\n\n---\n\n${relayInstructions}`;
-                            if (debug)
-                                console.log(`[spawner:debug] Composed role prompt for ${name} (role: ${role})`);
-                        }
-                    }
-                    catch (err) {
-                        console.warn(`[spawner] Failed to compose role prompt for ${name}: ${err.message}`);
-                    }
-                }
-            }
-            if (isClaudeCli && !args.includes('--append-system-prompt')) {
-                args.push('--append-system-prompt', relayInstructions);
-            }
-            else if (isCodexCli && !args.some(a => a.includes('developer_instructions'))) {
-                args.push('--config', `developer_instructions=${relayInstructions}`);
-            }
-            // Codex requires an initial prompt in TTY mode (unlike Claude which waits for input)
-            // Pass the task as the initial prompt, or a generic "ready" message if no task
-            if (isCodexCli) {
-                const initialPrompt = task || 'You are ready. Wait for messages from the relay system.';
-                args.push(initialPrompt);
-            }
-            if (debug)
-                console.log(`[spawner:debug] Spawning ${name} with: ${command} ${args.join(' ')}`);
-            // Create PtyWrapper config
-            // Use dashboardPort for nested spawns (API-based, works in non-TTY contexts)
-            // Fall back to callbacks only if no dashboardPort is not set
-            // Note: Spawned agents CAN spawn sub-workers intentionally - the parser is strict enough
-            // to avoid accidental spawns from documentation text (requires line start, PascalCase, known CLI)
-            // Use request.cwd if specified, otherwise use projectRoot
-            const agentCwd = request.cwd || this.projectRoot;
-            // Log whether nested spawning will be enabled for this agent
-            console.log(`[spawner] Spawning ${name}: dashboardPort=${this.dashboardPort || 'none'} (${this.dashboardPort ? 'nested spawns enabled' : 'nested spawns disabled'})`);
-            let userEnv;
-            if (userId) {
-                try {
-                    const userDirService = getUserDirectoryService();
-                    userEnv = userDirService.getUserEnvironment(userId);
-                }
-                catch (err) {
-                    console.warn('[spawner] Failed to resolve user environment, using default', {
-                        userId,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-            if (debug)
-                console.log(`[spawner:debug] Socket path for ${name}: ${this.socketPath ?? 'undefined'}`);
-            // Check if relay-pty binary is available - use PtyWrapper as fallback
-            const useRelayPty = hasRelayPtyBinary();
-            // Common exit handler for both wrapper types
-            const onExitHandler = (code) => {
-                if (debug)
-                    console.log(`[spawner:debug] Worker ${name} exited with code ${code}`);
-                // Get the agentId and clean up listeners before removing from active workers
-                const worker = this.activeWorkers.get(name);
-                const agentId = worker?.pty?.getAgentId?.();
-                if (worker?.listeners) {
-                    this.unbindListeners(worker.pty, worker.listeners);
-                }
-                this.activeWorkers.delete(name);
-                try {
-                    this.saveWorkersMetadata();
-                }
-                catch (err) {
-                    console.error(`[spawner] Failed to save metadata on exit:`, err);
-                }
-                // Notify if agent died unexpectedly (non-zero exit)
-                if (code !== 0 && code !== null && this.onAgentDeath) {
-                    this.onAgentDeath({
-                        name,
-                        exitCode: code,
-                        agentId,
-                        resumeInstructions: agentId
-                            ? `To resume this agent's work, use: --resume ${agentId}`
-                            : undefined,
-                    });
-                }
-            };
-            // Common spawn/release handlers
-            const onSpawnHandler = this.dashboardPort ? undefined : async (workerName, workerCli, workerTask) => {
-                if (debug)
-                    console.log(`[spawner:debug] Nested spawn: ${workerName}`);
-                await this.spawn({
-                    name: workerName,
-                    cli: workerCli,
-                    task: workerTask,
-                    userId,
-                });
-            };
-            const onReleaseHandler = this.dashboardPort ? undefined : async (workerName) => {
-                if (debug)
-                    console.log(`[spawner:debug] Release request: ${workerName}`);
-                await this.release(workerName);
-            };
-            // Create the appropriate wrapper based on binary availability
-            let pty;
-            if (useRelayPty) {
-                const ptyConfig = {
-                    name,
-                    command,
-                    args,
-                    socketPath: this.socketPath,
-                    cwd: agentCwd,
-                    dashboardPort: this.dashboardPort,
-                    env: userEnv,
-                    streamLogs: true,
-                    shadowOf: request.shadowOf,
-                    shadowSpeakOn: request.shadowSpeakOn,
-                    skipContinuity: true,
-                    onSpawn: onSpawnHandler,
-                    onRelease: onReleaseHandler,
-                    onExit: onExitHandler,
-                };
-                pty = new RelayPtyOrchestrator(ptyConfig);
-                if (debug)
-                    console.log(`[spawner:debug] Using RelayPtyOrchestrator for ${name}`);
-            }
-            else {
-                const ptyConfig = {
-                    name,
-                    command,
-                    args,
-                    socketPath: this.socketPath,
-                    cwd: agentCwd,
-                    dashboardPort: this.dashboardPort,
-                    env: userEnv,
-                    streamLogs: true,
-                    shadowOf: request.shadowOf,
-                    shadowSpeakOn: request.shadowSpeakOn,
-                    skipContinuity: true,
-                    onSpawn: onSpawnHandler,
-                    onRelease: onReleaseHandler,
-                    onExit: onExitHandler,
-                    logsDir: this.logsDir,
-                    allowSpawn: true,
-                };
-                pty = new PtyWrapper(ptyConfig);
-                if (debug)
-                    console.log(`[spawner:debug] Using PtyWrapper fallback for ${name}`);
-            }
-            // Track listener references for proper cleanup
-            const listeners = {};
-            // Hook up output events for live log streaming
-            const outputListener = (data) => {
-                // Broadcast to any connected WebSocket clients via global function
-                const broadcast = global.__broadcastLogOutput;
-                if (broadcast) {
-                    broadcast(name, data);
-                }
-            };
-            pty.on('output', outputListener);
-            listeners.output = outputListener;
-            // Bind cloud persistence events (if enabled) and store references
-            const cloudListeners = this.bindCloudPersistenceEvents(name, pty);
-            if (cloudListeners.summary)
-                listeners.summary = cloudListeners.summary;
-            if (cloudListeners.sessionEnd)
-                listeners.sessionEnd = cloudListeners.sessionEnd;
-            await pty.start();
-            if (debug)
-                console.log(`[spawner:debug] PTY started, pid: ${pty.pid}`);
-            // Wait for the agent to register with the daemon
-            const registered = await this.waitForAgentRegistration(name, 30_000, 500);
-            if (!registered) {
-                const error = `Worker ${name} failed to register within 30s`;
-                console.error(`[spawner] ${error}`);
-                await pty.kill();
-                return {
-                    success: false,
-                    name,
-                    error,
-                };
-            }
-            // Note: Task is NOT sent here. The spawning agent (wrapper) waits for the worker
-            // to come online and then sends the task via normal relay message.
-            // This avoids race conditions with the agent's readyForMessages state.
-            // Track the worker
-            const workerInfo = {
-                name,
-                cli,
-                task,
-                team,
-                userId,
-                spawnedAt: Date.now(),
-                pid: pty.pid,
-                pty,
-                logFile: pty.logPath,
-                listeners, // Store for cleanup
-            };
-            this.activeWorkers.set(name, workerInfo);
-            this.saveWorkersMetadata();
-            const teamInfo = team ? ` [team: ${team}]` : '';
-            const shadowInfo = request.shadowOf ? ` [shadow of: ${request.shadowOf}]` : '';
-            console.log(`[spawner] Spawned ${name} (${cli})${teamInfo}${shadowInfo} [pid: ${pty.pid}]`);
-            return {
-                success: true,
-                name,
-                pid: pty.pid,
-            };
-        }
-        catch (err) {
-            console.error(`[spawner] Failed to spawn ${name}:`, err.message);
-            if (debug)
-                console.error(`[spawner:debug] Full error:`, err);
-            return {
-                success: false,
-                name,
-                error: err.message,
-            };
-        }
-    }
-    /** Role presets for shadow agents */
-    static ROLE_PRESETS = {
-        reviewer: ['CODE_WRITTEN', 'REVIEW_REQUEST', 'EXPLICIT_ASK'],
-        auditor: ['SESSION_END', 'EXPLICIT_ASK'],
-        active: ['ALL_MESSAGES'],
-    };
-    /**
-     * Spawn a primary agent with its shadow agent
-     *
-     * Example usage:
-     * ```ts
-     * const result = await spawner.spawnWithShadow({
-     *   primary: { name: 'Lead', command: 'claude', task: 'Implement feature X' },
-     *   shadow: { name: 'Auditor', role: 'reviewer', speakOn: ['CODE_WRITTEN'] }
-     * });
-     * ```
-     */
-    async spawnWithShadow(request) {
-        const { primary, shadow } = request;
-        const debug = process.env.DEBUG_SPAWN === '1';
-        // Resolve shadow speakOn triggers
-        let speakOn = ['EXPLICIT_ASK']; // Default
-        // Check for role preset
-        if (shadow.role && AgentSpawner.ROLE_PRESETS[shadow.role.toLowerCase()]) {
-            speakOn = AgentSpawner.ROLE_PRESETS[shadow.role.toLowerCase()];
-        }
-        // Override with explicit speakOn if provided
-        if (shadow.speakOn && shadow.speakOn.length > 0) {
-            speakOn = shadow.speakOn;
-        }
-        // Build shadow task prompt
-        const defaultPrompt = `You are a shadow agent monitoring "${primary.name}". You receive copies of their messages. Your role: ${shadow.role || 'observer'}. Stay passive unless your triggers activate: ${speakOn.join(', ')}.`;
-        const shadowTask = shadow.prompt || defaultPrompt;
-        // Decide how to run the shadow (subagent for Claude/OpenCode primaries, process fallback otherwise)
-        let shadowSelection = null;
-        try {
-            shadowSelection = await selectShadowCli(primary.command || 'claude', {
-                preferredShadowCli: shadow.command,
-            });
-        }
-        catch (err) {
-            console.warn(`[spawner] Shadow CLI selection failed for ${shadow.name}: ${err.message}`);
-        }
-        if (debug) {
-            const mode = shadowSelection?.mode ?? 'unknown';
-            const cli = shadowSelection?.command ?? shadow.command ?? primary.command ?? 'claude';
-            console.log(`[spawner] spawnWithShadow: primary=${primary.name}, shadow=${shadow.name}, mode=${mode}, cli=${cli}, speakOn=${speakOn.join(',')}`);
-        }
-        // Step 1: Spawn primary agent
-        const primaryResult = await this.spawn({
-            name: primary.name,
-            cli: primary.command || 'claude',
-            task: primary.task || '',
-            team: primary.team,
-        });
-        if (!primaryResult.success) {
-            return {
-                success: false,
-                primary: primaryResult,
-                error: `Failed to spawn primary agent: ${primaryResult.error}`,
-            };
-        }
-        // Step 2: Wait for primary to register before spawning shadow
-        // The spawn() method already waits, but we add a small delay for stability
-        await sleep(1000);
-        // Subagent mode: no separate process needed
-        if (shadowSelection?.mode === 'subagent') {
-            console.log(`[spawner] Shadow ${shadow.name} will run as ${shadowSelection.cli} subagent inside ${primary.name} (no separate process)`);
-            return {
-                success: true,
-                primary: primaryResult,
-                shadow: {
-                    success: true,
-                    name: shadow.name,
-                },
-            };
-        }
-        // No available shadow CLI - proceed without spawning a shadow process
-        if (!shadowSelection) {
-            console.warn(`[spawner] No authenticated shadow CLI available; ${primary.name} will run without a shadow`);
-            return {
-                success: true,
-                primary: primaryResult,
-                error: 'Shadow spawn skipped: no authenticated shadow CLI available',
-            };
-        }
-        // Step 3: Spawn shadow agent with shadowOf and shadowSpeakOn
-        const shadowResult = await this.spawn({
-            name: shadow.name,
-            // Use the selected/validated CLI for process-mode shadows
-            cli: shadowSelection.command || shadow.command || primary.command || 'claude',
-            task: shadowTask,
-            shadowOf: primary.name,
-            shadowSpeakOn: speakOn,
-        });
-        if (!shadowResult.success) {
-            console.warn(`[spawner] Shadow agent ${shadow.name} failed to spawn, primary ${primary.name} continues without shadow`);
-            return {
-                success: true, // Primary succeeded, overall operation is partial success
-                primary: primaryResult,
-                shadow: shadowResult,
-                error: `Shadow spawn failed: ${shadowResult.error}`,
-            };
-        }
-        console.log(`[spawner] Spawned pair: ${primary.name} with shadow ${shadow.name} (speakOn: ${speakOn.join(',')})`);
-        return {
-            success: true,
-            primary: primaryResult,
-            shadow: shadowResult,
-        };
-    }
-    /**
-     * Release (terminate) a worker
-     */
-    async release(name) {
-        const worker = this.activeWorkers.get(name);
-        if (!worker) {
-            console.log(`[spawner] Worker ${name} not found`);
-            return false;
-        }
-        try {
-            // Unbind all listeners first to prevent memory leaks
-            this.unbindListeners(worker.pty, worker.listeners);
-            // Stop the pty process gracefully (handles auto-save internally)
-            await worker.pty.stop();
-            // Force kill if still running
-            if (worker.pty.isRunning) {
-                await worker.pty.kill();
-            }
-            this.activeWorkers.delete(name);
-            this.saveWorkersMetadata();
-            console.log(`[spawner] Released ${name}`);
-            return true;
-        }
-        catch (err) {
-            console.error(`[spawner] Failed to release ${name}:`, err.message);
-            // Still unbind and remove from tracking
-            this.unbindListeners(worker.pty, worker.listeners);
-            this.activeWorkers.delete(name);
-            this.saveWorkersMetadata();
-            return false;
-        }
-    }
-    /**
-     * Release all workers
-     */
-    async releaseAll() {
-        const workers = Array.from(this.activeWorkers.keys());
-        for (const name of workers) {
-            await this.release(name);
-        }
-    }
-    /**
-     * Get all active workers (returns WorkerInfo without pty reference)
-     */
-    getActiveWorkers() {
-        return Array.from(this.activeWorkers.values()).map((w) => ({
-            name: w.name,
-            cli: w.cli,
-            task: w.task,
-            team: w.team,
-            spawnedAt: w.spawnedAt,
-            pid: w.pid,
-        }));
-    }
-    /**
-     * Check if a worker exists
-     */
-    hasWorker(name) {
-        return this.activeWorkers.has(name);
-    }
-    /**
-     * Get worker info
-     */
-    getWorker(name) {
-        const worker = this.activeWorkers.get(name);
-        if (!worker)
-            return undefined;
-        return {
-            name: worker.name,
-            cli: worker.cli,
-            task: worker.task,
-            team: worker.team,
-            spawnedAt: worker.spawnedAt,
-            pid: worker.pid,
-        };
-    }
-    /**
-     * Get output logs from a worker
-     */
-    getWorkerOutput(name, limit) {
-        const worker = this.activeWorkers.get(name);
-        if (!worker)
-            return null;
-        return worker.pty.getOutput(limit);
-    }
-    /**
-     * Get raw output from a worker
-     */
-    getWorkerRawOutput(name) {
-        const worker = this.activeWorkers.get(name);
-        if (!worker)
-            return null;
-        return worker.pty.getRawOutput();
-    }
-    /**
-     * Send input to a worker's PTY (for interactive terminal support)
-     * @param name - Worker name
-     * @param data - Input data to send (keystrokes, text, etc.)
-     * @returns true if input was sent, false if worker not found
-     */
-    sendWorkerInput(name, data) {
-        const worker = this.activeWorkers.get(name);
-        if (!worker)
-            return false;
-        worker.pty.write(data);
-        return true;
-    }
-    /**
-     * Wait for an agent to appear in the registry (agents.json)
-     */
-    async waitForAgentRegistration(name, timeoutMs = 30_000, pollIntervalMs = 500) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (this.isAgentRegistered(name)) {
-                return true;
-            }
-            await sleep(pollIntervalMs);
-        }
-        return false;
-    }
-    isAgentRegistered(name) {
-        if (!this.agentsPath)
-            return false;
-        if (!fs.existsSync(this.agentsPath))
-            return false;
-        try {
-            const raw = JSON.parse(fs.readFileSync(this.agentsPath, 'utf-8'));
-            // connected-agents.json format: { agents: string[], users: string[], updatedAt: number }
-            // agents is a string array of connected agent names (not objects)
-            const agents = Array.isArray(raw?.agents) ? raw.agents : [];
-            // Case-insensitive check to match router behavior
-            const lowerName = name.toLowerCase();
-            return agents.some((a) => typeof a === 'string' && a.toLowerCase() === lowerName);
-        }
-        catch (err) {
-            console.error('[spawner] Failed to read connected-agents.json:', err.message);
-            return false;
-        }
-    }
-    /**
-     * Save workers metadata to disk for CLI access
-     */
-    saveWorkersMetadata() {
-        try {
-            const workers = Array.from(this.activeWorkers.values()).map((w) => ({
-                name: w.name,
-                cli: w.cli,
-                task: w.task,
-                team: w.team,
-                userId: w.userId,
-                spawnedAt: w.spawnedAt,
-                pid: w.pid,
-                logFile: w.logFile,
-            }));
-            fs.writeFileSync(this.workersPath, JSON.stringify({ workers }, null, 2));
-        }
-        catch (err) {
-            console.error('[spawner] Failed to save workers metadata:', err.message);
-        }
-    }
-    /**
-     * Get path to logs directory
-     */
-    getLogsDir() {
-        return this.logsDir;
-    }
-    /**
-     * Get path to workers metadata file
-     */
-    getWorkersPath() {
-        return this.workersPath;
-    }
-}
-/**
- * Read workers metadata from disk (for CLI use)
- */
-export function readWorkersMetadata(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    const workersPath = path.join(paths.teamDir, 'workers.json');
-    if (!fs.existsSync(workersPath)) {
-        return [];
-    }
-    try {
-        const raw = JSON.parse(fs.readFileSync(workersPath, 'utf-8'));
-        return Array.isArray(raw?.workers) ? raw.workers : [];
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get the worker logs directory path
- */
-export function getWorkerLogsDir(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    return path.join(paths.teamDir, 'worker-logs');
-}
-//# sourceMappingURL=spawner.js.map