agent-relay 2.3.13 → 2.4.0

package/packages/wrapper/dist/relay-pty-orchestrator.js

@@ -1,2550 +0,0 @@
-/**
- * RelayPtyOrchestrator - Orchestrates the relay-pty Rust binary
- *
- * This wrapper spawns the relay-pty binary and communicates via Unix socket.
- * It provides the same interface as PtyWrapper but with improved latency
- * (~550ms vs ~1700ms) by using direct PTY writes instead of tmux send-keys.
- *
- * Architecture:
- * 1. Spawn relay-pty --name {agentName} -- {command} as child process
- * 2. Connect to socket for injection:
- *    - With WORKSPACE_ID: /tmp/relay/{workspaceId}/sockets/{agentName}.sock
- *    - Without: /tmp/relay-pty-{agentName}.sock (legacy)
- * 3. Parse stdout for relay commands (relay-pty echoes all output)
- * 4. Translate SEND envelopes → inject messages via socket
- *
- * @see docs/RUST_WRAPPER_DESIGN.md for protocol details
- */
-import { spawn } from 'node:child_process';
-import { createConnection } from 'node:net';
-import { createHash } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import { homedir, freemem, totalmem } from 'node:os';
-import { execSync } from 'node:child_process';
-import { existsSync, unlinkSync, mkdirSync, symlinkSync, lstatSync, rmSync, watch, readdirSync, readlinkSync, writeFileSync, appendFileSync, accessSync, constants as fsConstants, } from 'node:fs';
-import { getProjectPaths } from '@agent-relay/config/project-namespace';
-import { fileURLToPath } from 'node:url';
-// Get the directory where this module is located
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import { BaseWrapper } from './base-wrapper.js';
-import { parseSummaryWithDetails, parseSessionEndFromOutput } from './parser.js';
-import { findRelayPtyBinary as findRelayPtyBinaryUtil } from '@agent-relay/utils/relay-pty-path';
-import { stripAnsi, sleep, buildInjectionString, AdaptiveThrottle, } from './shared.js';
-import { getMemoryMonitor, formatBytes, getCgroupManager, } from '@agent-relay/resiliency';
-// ============================================================================
-// Types for relay-pty socket protocol
-// ============================================================================
-const MAX_SOCKET_PATH_LENGTH = 107;
-/**
- * Maximum size for output buffers (rawBuffer, outputBuffer) in bytes.
- * Prevents RangeError: Invalid string length when agents produce lots of output.
- * Set to 10MB - enough to capture context but won't exhaust memory.
- */
-const MAX_OUTPUT_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
-// ============================================================================
-// Activity Verification Constants
-// ============================================================================
-/**
- * Activity patterns used to verify that a CLI has received and started processing
- * an injected task. These patterns work across Claude Code, Codex, and Droid/Gemini.
- *
- * The problem we're solving: Rust confirms "delivered to PTY" but that doesn't mean
- * the CLI processed it. The T-003 failure showed the CLI wasn't ready when input arrived.
- *
- * @see https://github.com/your-org/relay/issues/XXX for the original investigation
- */
-const ACTIVITY_VERIFICATION = {
-    /** Time to wait for activity patterns after injection (ms) */
-    TIMEOUT_MS: 5000,
-    /** How often to check for activity patterns (ms) */
-    POLL_INTERVAL_MS: 200,
-    /** Maximum retries when no activity is detected */
-    MAX_RETRIES: 3,
-    /** Delay between retries (ms) */
-    RETRY_DELAY_MS: 500,
-    /**
-     * Patterns indicating the task was received and displayed.
-     * These are the primary verification patterns.
-     */
-    TASK_RECEIVED_PATTERNS: [
-        /\[Pasted text #\d+/, // Claude Code shows "[Pasted text #1 +95 lines]"
-        /› Relay message from/, // Codex shows "› Relay message from"
-        /Relay message from \w+ \[[\w-]+\]/, // Droid/Gemini shows "Relay message from Agent [id]:"
-    ],
-    /**
-     * Patterns indicating the CLI is thinking/processing.
-     * Secondary verification - proves the CLI is active.
-     */
-    THINKING_PATTERNS: [
-        /\(.*esc to (?:interrupt|stop)\)/i, // All CLIs: "(esc to interrupt)" or "(Press ESC to stop)"
-        /[✻✶✳✢·✽⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/, // Spinner characters (Claude + Droid)
-        /Thinking\.\.\./, // Droid: "Thinking..."
-        /Working/, // Codex: "Working"
-        /Forming|Noodling|Manifesting/i, // Claude Code thinking states
-    ],
-    /**
-     * Patterns indicating tool execution started.
-     * Tertiary verification - proves the CLI is working.
-     */
-    TOOL_EXECUTION_PATTERNS: [
-        /⏺\s*(Bash|Read|Write|Edit|Glob|Grep|Task|WebFetch)/, // Claude Code tool markers
-        /•\s*Running/, // Codex: "• Running: command"
-    ],
-};
-function hashWorkspaceId(workspaceId) {
-    return createHash('sha256').update(workspaceId).digest('hex').slice(0, 12);
-}
-/**
- * Orchestrator for relay-pty Rust binary
- *
- * Extends BaseWrapper to provide the same interface as PtyWrapper
- * but uses the relay-pty binary for improved injection reliability.
- */
-export class RelayPtyOrchestrator extends BaseWrapper {
-    config;
-    // Process management
-    relayPtyProcess;
-    socketPath;
-    _logPath;
-    _outboxPath;
-    _legacyOutboxPath; // Legacy /tmp/relay-outbox path for backwards compat
-    _canonicalOutboxPath; // Canonical ~/.agent-relay/outbox path (agents write here)
-    _workspaceId; // For symlink setup
-    socket;
-    socketConnected = false;
-    // Output buffering
-    outputBuffer = '';
-    rawBuffer = '';
-    lastParsedLength = 0;
-    bufferTrimCount = 0;
-    // Interactive mode (show output to terminal)
-    isInteractive = false;
-    // Injection state
-    pendingInjections = new Map();
-    backpressureActive = false;
-    readyForMessages = false;
-    // Adaptive throttle for message queue - adjusts delay based on success/failure
-    throttle = new AdaptiveThrottle();
-    // Unread message indicator state
-    lastUnreadIndicatorTime = 0;
-    UNREAD_INDICATOR_COOLDOWN_MS = 5000; // Don't spam indicators
-    // Track whether any output has been received from the CLI
-    hasReceivedOutput = false;
-    // Queue monitor for stuck message detection
-    queueMonitorTimer;
-    QUEUE_MONITOR_INTERVAL_MS = 5000; // Check every 5 seconds
-    injectionStartTime = 0; // Track when isInjecting was set to true
-    MAX_INJECTION_STUCK_MS = 60000; // Force reset after 60 seconds
-    // Protocol monitor for detecting agent mistakes (e.g., empty AGENT_RELAY_NAME)
-    protocolWatcher;
-    protocolReminderCooldown = 0; // Prevent spam
-    PROTOCOL_REMINDER_COOLDOWN_MS = 30000; // 30 second cooldown between reminders
-    // Periodic protocol reminder for long sessions (agents sometimes forget the protocol)
-    periodicReminderTimer;
-    PERIODIC_REMINDER_INTERVAL_MS = 45 * 60 * 1000; // 45 minutes
-    sessionStartTime = 0;
-    // Track if agent is being gracefully stopped (vs crashed)
-    isGracefulStop = false;
-    // Track early process exit for better error messages
-    earlyExitInfo;
-    // Memory/CPU monitoring
-    memoryMonitor;
-    memoryAlertHandler = null;
-    // CPU limiting via cgroups (optional, Linux only)
-    cgroupManager;
-    hasCgroupSetup = false;
-    // Note: sessionEndProcessed and lastSummaryRawContent are inherited from BaseWrapper
-    /**
-     * Gather system diagnostics for debugging SIGKILL/unexpected exits.
-     * Returns a formatted string with memory, process, and system info.
-     */
-    static gatherSigkillDiagnostics(agentName, pid) {
-        const lines = [];
-        try {
-            // Memory info
-            const free = freemem();
-            const total = totalmem();
-            const usedPercent = Math.round((1 - free / total) * 100);
-            lines.push(`Memory: ${Math.round(free / 1024 / 1024)}MB free / ${Math.round(total / 1024 / 1024)}MB total (${usedPercent}% used)`);
-            // Process count (try to get relay-pty count)
-            try {
-                const psOutput = execSync('ps aux | grep -c relay-pty || echo 0', { encoding: 'utf-8', timeout: 1000 }).trim();
-                lines.push(`relay-pty processes: ${psOutput}`);
-            }
-            catch {
-                // Ignore - ps may not be available
-            }
-            // Check for OOM killer messages (Linux only)
-            try {
-                const dmesgOutput = execSync('dmesg -T 2>/dev/null | grep -i "killed process" | tail -3 || true', {
-                    encoding: 'utf-8',
-                    timeout: 1000
-                }).trim();
-                if (dmesgOutput) {
-                    lines.push(`Recent OOM kills: ${dmesgOutput.replace(/\n/g, ' | ')}`);
-                }
-            }
-            catch {
-                // Ignore - dmesg may require permissions
-            }
-            // Include PID if known
-            if (pid) {
-                lines.push(`Killed process PID: ${pid}`);
-            }
-            lines.push(`Agent name: ${agentName}`);
-            lines.push(`Timestamp: ${new Date().toISOString()}`);
-        }
-        catch (err) {
-            lines.push(`Diagnostics error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return lines.join('\n  ');
-    }
-    constructor(config) {
-        super(config);
-        this.config = config;
-        // Validate agent name to prevent path traversal attacks
-        if (config.name.includes('..') || config.name.includes('/') || config.name.includes('\\')) {
-            throw new Error(`Invalid agent name: "${config.name}" contains path traversal characters`);
-        }
-        // Get project paths (used for logs and local mode)
-        const projectPaths = getProjectPaths(config.cwd);
-        // Canonical outbox path - agents ALWAYS write here (transparent symlink in workspace mode)
-        // Uses ~/.agent-relay/outbox/{agentName}/ so agents don't need to know about workspace IDs
-        this._canonicalOutboxPath = join(projectPaths.dataDir, 'outbox', config.name);
-        // Check for workspace namespacing (for multi-tenant cloud deployment)
-        // WORKSPACE_ID can be in process.env or passed via config.env
-        const workspaceId = config.env?.WORKSPACE_ID || process.env.WORKSPACE_ID;
-        this._workspaceId = workspaceId;
-        if (workspaceId) {
-            // Workspace mode: relay-pty watches the actual workspace path
-            // Canonical path (~/.agent-relay/outbox/) will be symlinked to workspace path
-            const getWorkspacePaths = (id) => {
-                const workspaceDir = `/tmp/relay/${id}`;
-                return {
-                    workspaceDir,
-                    socketPath: `${workspaceDir}/sockets/${config.name}.sock`,
-                    outboxPath: `${workspaceDir}/outbox/${config.name}`,
-                };
-            };
-            let paths = getWorkspacePaths(workspaceId);
-            if (paths.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-                const hashedWorkspaceId = hashWorkspaceId(workspaceId);
-                const hashedPaths = getWorkspacePaths(hashedWorkspaceId);
-                console.warn(`[relay-pty-orchestrator:${config.name}] Socket path too long (${paths.socketPath.length} chars); using hashed workspace id ${hashedWorkspaceId}`);
-                paths = hashedPaths;
-            }
-            if (paths.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-                throw new Error(`Socket path exceeds ${MAX_SOCKET_PATH_LENGTH} chars: ${paths.socketPath.length}`);
-            }
-            this.socketPath = paths.socketPath;
-            // relay-pty watches the actual workspace path
-            this._outboxPath = paths.outboxPath;
-            // Legacy path for backwards compat (older agents might still use /tmp/relay-outbox)
-            this._legacyOutboxPath = `/tmp/relay-outbox/${config.name}`;
-        }
-        else {
-            // Local mode: use project paths directly (no symlinks needed)
-            this._outboxPath = this._canonicalOutboxPath;
-            // Socket path: use ~/.agent-relay/sockets/{projectId}/{agentName}.sock
-            // This keeps paths short (uses 12-char hashed projectId) while staying organized
-            // Example: /Users/foo/.agent-relay/sockets/abc123def456/MyAgent.sock (~65 chars)
-            this.socketPath = join(homedir(), '.agent-relay', 'sockets', projectPaths.projectId, `${config.name}.sock`);
-            // Legacy path for backwards compat (older agents might still use /tmp/relay-outbox)
-            // Even in local mode, we need this symlink for agents with stale instructions
-            this._legacyOutboxPath = `/tmp/relay-outbox/${config.name}`;
-        }
-        if (this.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-            throw new Error(`Socket path exceeds ${MAX_SOCKET_PATH_LENGTH} chars: ${this.socketPath.length}`);
-        }
-        // Generate log path using project paths
-        this._logPath = join(projectPaths.teamDir, 'worker-logs', `${config.name}.log`);
-        // Check if we're running interactively (stdin is a TTY)
-        // If headless mode is forced via config, always use pipes
-        this.isInteractive = config.headless ? false : (process.stdin.isTTY === true);
-        // Initialize memory monitor (shared singleton, 10s polling interval)
-        this.memoryMonitor = getMemoryMonitor({ checkIntervalMs: 10_000 });
-        // Initialize cgroup manager for CPU limiting (shared singleton)
-        this.cgroupManager = getCgroupManager();
-    }
-    /**
-     * Debug log - only outputs when debug is enabled
-     * Writes to log file to avoid polluting TUI output
-     */
-    log(message) {
-        if (this.config.debug) {
-            const logLine = `${new Date().toISOString()} [relay-pty-orchestrator:${this.config.name}] ${message}\n`;
-            try {
-                const logDir = dirname(this._logPath);
-                if (!existsSync(logDir)) {
-                    mkdirSync(logDir, { recursive: true });
-                }
-                appendFileSync(this._logPath, logLine);
-            }
-            catch {
-                // Fallback to stderr if file write fails (only during init before _logPath is set)
-            }
-        }
-    }
-    /**
-     * Error log - always outputs (errors are important)
-     * Writes to log file to avoid polluting TUI output
-     */
-    logError(message) {
-        const logLine = `${new Date().toISOString()} [relay-pty-orchestrator:${this.config.name}] ERROR: ${message}\n`;
-        try {
-            const logDir = dirname(this._logPath);
-            if (!existsSync(logDir)) {
-                mkdirSync(logDir, { recursive: true });
-            }
-            appendFileSync(this._logPath, logLine);
-        }
-        catch {
-            // Fallback to stderr if file write fails (only during init before _logPath is set)
-        }
-    }
-    /**
-     * Get the outbox path for this agent (for documentation purposes)
-     */
-    get outboxPath() {
-        return this._outboxPath;
-    }
-    // =========================================================================
-    // Abstract method implementations (required by BaseWrapper)
-    // =========================================================================
-    /**
-     * Start the relay-pty process and connect to socket
-     */
-    async start() {
-        if (this.running)
-            return;
-        this.log(` Starting...`);
-        // Ensure socket directory exists (for workspace-namespaced paths)
-        const socketDir = dirname(this.socketPath);
-        try {
-            if (!existsSync(socketDir)) {
-                mkdirSync(socketDir, { recursive: true });
-                this.log(` Created socket directory: ${socketDir}`);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to create socket directory: ${err.message}`);
-        }
-        // Clean up any stale socket from previous crashed process
-        try {
-            if (existsSync(this.socketPath)) {
-                this.log(` Removing stale socket: ${this.socketPath}`);
-                unlinkSync(this.socketPath);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to clean up socket: ${err.message}`);
-        }
-        // Set up outbox directory structure
-        // - Workspace mode:
-        //   1. Create actual workspace path /tmp/relay/{workspaceId}/outbox/{name}
-        //   2. Symlink canonical ~/.agent-relay/outbox/{name} -> workspace path
-        //   3. Optional: symlink /tmp/relay-outbox/{name} -> workspace path (backwards compat)
-        // - Local mode: just create ~/.agent-relay/{projectId}/outbox/{name} directly
-        try {
-            // Ensure the actual outbox directory exists (where relay-pty watches)
-            const outboxDir = dirname(this._outboxPath);
-            if (!existsSync(outboxDir)) {
-                mkdirSync(outboxDir, { recursive: true });
-            }
-            if (!existsSync(this._outboxPath)) {
-                mkdirSync(this._outboxPath, { recursive: true });
-            }
-            this.log(` Created outbox directory: ${this._outboxPath}`);
-            // Helper to create a symlink, cleaning up existing path first
-            const createSymlinkSafe = (linkPath, targetPath) => {
-                const linkParent = dirname(linkPath);
-                if (!existsSync(linkParent)) {
-                    mkdirSync(linkParent, { recursive: true });
-                }
-                // Remove existing path if it exists (file, symlink, or directory)
-                // Use lstatSync instead of existsSync to detect broken symlinks
-                // (existsSync returns false for broken symlinks, but the symlink itself still exists)
-                let pathExists = false;
-                try {
-                    lstatSync(linkPath);
-                    pathExists = true;
-                }
-                catch {
-                    // Path doesn't exist at all - proceed to create symlink
-                }
-                if (pathExists) {
-                    try {
-                        const stats = lstatSync(linkPath);
-                        if (stats.isSymbolicLink()) {
-                            // Handle both valid and broken symlinks
-                            try {
-                                const currentTarget = readlinkSync(linkPath);
-                                if (currentTarget === targetPath) {
-                                    // Symlink already points to correct target, no need to recreate
-                                    this.log(` Symlink already exists and is correct: ${linkPath} -> ${targetPath}`);
-                                    return;
-                                }
-                            }
-                            catch {
-                                // Broken symlink (target doesn't exist) - remove it
-                                this.log(` Removing broken symlink: ${linkPath}`);
-                            }
-                            unlinkSync(linkPath);
-                        }
-                        else if (stats.isFile()) {
-                            unlinkSync(linkPath);
-                        }
-                        else if (stats.isDirectory()) {
-                            // Force remove directory - this is critical for fixing existing directories
-                            rmSync(linkPath, { recursive: true, force: true });
-                            // Verify removal succeeded using lstatSync to catch broken symlinks
-                            try {
-                                lstatSync(linkPath);
-                                throw new Error(`Failed to remove existing directory: ${linkPath}`);
-                            }
-                            catch (err) {
-                                if (err.code !== 'ENOENT') {
-                                    throw err; // Re-throw if it's not a "doesn't exist" error
-                                }
-                                // Path successfully removed
-                            }
-                        }
-                    }
-                    catch (err) {
-                        // Log cleanup errors instead of silently ignoring them
-                        this.logError(` Failed to clean up existing path ${linkPath}: ${err.message}`);
-                        throw err; // Re-throw to prevent symlink creation on failed cleanup
-                    }
-                }
-                // Create the symlink
-                try {
-                    symlinkSync(targetPath, linkPath);
-                    // Verify symlink was created correctly
-                    if (!existsSync(linkPath)) {
-                        throw new Error(`Symlink creation failed: ${linkPath}`);
-                    }
-                    const verifyStats = lstatSync(linkPath);
-                    if (!verifyStats.isSymbolicLink()) {
-                        throw new Error(`Created path is not a symlink: ${linkPath}`);
-                    }
-                    const verifyTarget = readlinkSync(linkPath);
-                    if (verifyTarget !== targetPath) {
-                        throw new Error(`Symlink points to wrong target: expected ${targetPath}, got ${verifyTarget}`);
-                    }
-                    this.log(` Created symlink: ${linkPath} -> ${targetPath}`);
-                }
-                catch (err) {
-                    this.logError(` Failed to create symlink ${linkPath} -> ${targetPath}: ${err.message}`);
-                    throw err;
-                }
-            };
-            // In workspace mode, create symlinks so agents can use canonical path
-            if (this._workspaceId) {
-                // Symlink canonical path (~/.agent-relay/outbox/{name}) -> workspace path
-                // This is the PRIMARY symlink - agents write to canonical path, relay-pty watches workspace path
-                if (this._canonicalOutboxPath !== this._outboxPath) {
-                    createSymlinkSafe(this._canonicalOutboxPath, this._outboxPath);
-                }
-                // Also create legacy /tmp/relay-outbox symlink for backwards compat with older agents
-                if (this._legacyOutboxPath !== this._outboxPath && this._legacyOutboxPath !== this._canonicalOutboxPath) {
-                    createSymlinkSafe(this._legacyOutboxPath, this._outboxPath);
-                }
-            }
-            // In local mode, also create legacy symlink for backwards compat with stale instructions
-            if (!this._workspaceId && this._legacyOutboxPath !== this._outboxPath) {
-                createSymlinkSafe(this._legacyOutboxPath, this._outboxPath);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to set up outbox: ${err.message}`);
-        }
-        // Write MCP identity file so MCP servers can discover their agent name
-        // This is needed because Claude Code may not pass through env vars to MCP server processes
-        try {
-            const projectPaths = getProjectPaths(this.config.cwd);
-            const identityDir = join(projectPaths.dataDir);
-            if (!existsSync(identityDir)) {
-                mkdirSync(identityDir, { recursive: true });
-            }
-            // Write a per-process identity file (using PPID so MCP server finds parent's identity)
-            const identityPath = join(identityDir, `mcp-identity-${process.pid}`);
-            writeFileSync(identityPath, this.config.name, 'utf-8');
-            this.log(` Wrote MCP identity file: ${identityPath}`);
-            // Also write a simple identity file (for single-agent scenarios)
-            const simpleIdentityPath = join(identityDir, 'mcp-identity');
-            writeFileSync(simpleIdentityPath, this.config.name, 'utf-8');
-        }
-        catch (err) {
-            this.logError(` Failed to write MCP identity file: ${err.message}`);
-        }
-        // Find relay-pty binary
-        const binaryPath = this.findRelayPtyBinary();
-        if (!binaryPath) {
-            throw new Error('relay-pty binary not found. Build with: cd relay-pty && cargo build --release');
-        }
-        try {
-            accessSync(binaryPath, fsConstants.X_OK);
-        }
-        catch (err) {
-            throw new Error(`relay-pty binary not executable at ${binaryPath}: ${err?.message ?? 'permission denied'}. Build with: cd relay-pty && cargo build --release, or ensure the binary has execute permissions.`);
-        }
-        this.log(` Using binary: ${binaryPath}`);
-        // Spawn relay-pty process FIRST (before connecting to daemon)
-        // This ensures the CLI is actually running before we register with the daemon
-        await this.spawnRelayPty(binaryPath);
-        // Wait for socket to become available and connect
-        await this.connectToSocket();
-        // Connect to relay daemon AFTER CLI is spawned
-        // This prevents the spawner from seeing us as "registered" before the CLI runs
-        try {
-            await this.client.connect();
-            this.log(` Relay daemon connected`);
-        }
-        catch (err) {
-            this.logError(` Relay connect failed: ${err.message}`);
-        }
-        this.running = true;
-        // DON'T set readyForMessages yet - wait for CLI to be ready first
-        // This prevents messages from being injected during CLI startup
-        this.startStuckDetection();
-        this.startQueueMonitor();
-        this.startProtocolMonitor();
-        this.startPeriodicReminder();
-        this.log(` Socket connected: ${this.socketConnected}`);
-        this.log(` Relay client state: ${this.client.state}`);
-        // Wait for CLI to be fully ready (output received + idle state)
-        // This ensures we don't inject messages while the CLI is still starting up
-        // Messages arriving via daemon during this time will be queued but not processed
-        this.log(` Waiting for CLI to be ready before accepting messages...`);
-        const cliReady = await this.waitUntilCliReady(30000, 100);
-        if (cliReady) {
-            this.log(` CLI is ready, enabling message processing`);
-        }
-        else {
-            this.log(` CLI readiness timeout, enabling message processing anyway`);
-        }
-        // Now enable message processing
-        this.readyForMessages = true;
-        this.log(` Ready for messages`);
-        // Process any queued messages that arrived during startup
-        this.processMessageQueue();
-    }
-    /**
-     * Stop the relay-pty process gracefully
-     */
-    async stop() {
-        if (!this.running)
-            return;
-        this.isGracefulStop = true; // Mark as graceful to prevent crash broadcast
-        this.running = false;
-        this.stopStuckDetection();
-        this.stopQueueMonitor();
-        this.stopProtocolMonitor();
-        this.stopPeriodicReminder();
-        // Clear socket reconnect timer
-        if (this.socketReconnectTimer) {
-            clearTimeout(this.socketReconnectTimer);
-            this.socketReconnectTimer = undefined;
-        }
-        // Unregister from memory monitor
-        this.memoryMonitor.unregister(this.config.name);
-        if (this.memoryAlertHandler) {
-            this.memoryMonitor.off('alert', this.memoryAlertHandler);
-            this.memoryAlertHandler = null;
-        }
-        // Clean up cgroup if we set one up
-        if (this.hasCgroupSetup) {
-            await this.cgroupManager.removeAgentCgroup(this.config.name);
-            this.hasCgroupSetup = false;
-        }
-        // Auto-save continuity state before shutdown
-        // Pass sessionEndData to populate handoff (fixes empty handoff issue)
-        if (this.continuity) {
-            try {
-                await this.continuity.autoSave(this.config.name, 'session_end', this.sessionEndData);
-                this.log(` Continuity auto-saved`);
-            }
-            catch (err) {
-                this.logError(`Continuity auto-save failed: ${err.message}`);
-            }
-        }
-        this.log(` Stopping...`);
-        // Send shutdown command via socket
-        if (this.socket && this.socketConnected) {
-            try {
-                await this.sendSocketRequest({ type: 'shutdown' });
-            }
-            catch {
-                // Ignore errors during shutdown
-            }
-        }
-        // Close socket
-        this.disconnectSocket();
-        // Kill process if still running
-        if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-            this.relayPtyProcess.kill('SIGTERM');
-            // Force kill after timeout
-            await Promise.race([
-                new Promise((resolve) => {
-                    this.relayPtyProcess?.on('exit', () => resolve());
-                }),
-                sleep(5000).then(() => {
-                    if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-                        this.relayPtyProcess.kill('SIGKILL');
-                    }
-                }),
-            ]);
-        }
-        // Cleanup relay client
-        this.destroyClient();
-        // Clean up socket file
-        try {
-            if (existsSync(this.socketPath)) {
-                unlinkSync(this.socketPath);
-                this.log(` Cleaned up socket: ${this.socketPath}`);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to clean up socket: ${err.message}`);
-        }
-        // Clean up mcp-identity file for this process
-        try {
-            const projectPaths = getProjectPaths(this.config.cwd);
-            const identityPath = join(projectPaths.dataDir, `mcp-identity-${process.pid}`);
-            if (existsSync(identityPath)) {
-                unlinkSync(identityPath);
-                this.log(` Cleaned up identity file: ${identityPath}`);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to clean up identity file: ${err.message}`);
-        }
-        this.log(` Stopped`);
-    }
-    /**
-     * Inject content into the agent via socket
-     */
-    async performInjection(_content) {
-        // This is called by BaseWrapper but we handle injection differently
-        // via the socket protocol in processMessageQueue
-        throw new Error('Use injectMessage() instead of performInjection()');
-    }
-    /**
-     * Get cleaned output for parsing
-     */
-    getCleanOutput() {
-        return stripAnsi(this.rawBuffer);
-    }
-    // =========================================================================
-    // Process management
-    // =========================================================================
-    /**
-     * Find the relay-pty binary
-     * Uses shared utility from @agent-relay/utils
-     */
-    findRelayPtyBinary() {
-        // Check config path first
-        if (this.config.relayPtyPath && existsSync(this.config.relayPtyPath)) {
-            return this.config.relayPtyPath;
-        }
-        // Use shared utility with current module's __dirname
-        return findRelayPtyBinaryUtil(__dirname);
-    }
-    /**
-     * Spawn the relay-pty process
-     */
-    async spawnRelayPty(binaryPath) {
-        // Get terminal dimensions for proper rendering
-        const rows = process.stdout.rows || 24;
-        const cols = process.stdout.columns || 80;
-        const args = [
-            '--name', this.config.name,
-            '--socket', this.socketPath,
-            '--idle-timeout', String(this.config.idleBeforeInjectMs ?? 500),
-            '--json-output', // Enable Rust parsing output
-            '--rows', String(rows),
-            '--cols', String(cols),
-            '--log-level', 'warn', // Only show warnings and errors
-            '--log-file', this._logPath, // Enable output logging
-            '--outbox', this._outboxPath, // Enable file-based relay messages
-            '--', this.config.command,
-            ...(this.config.args ?? []),
-        ];
-        this.log(` Spawning: ${binaryPath} ${args.join(' ')}`);
-        // Reset early exit info from any previous spawn attempt
-        this.earlyExitInfo = undefined;
-        // For interactive mode, let Rust directly inherit stdin/stdout from the terminal
-        // This is more robust than manual forwarding through pipes
-        // We still pipe stderr to capture JSON parsed commands
-        const stdio = this.isInteractive
-            ? ['inherit', 'inherit', 'pipe'] // Rust handles terminal directly
-            : ['pipe', 'pipe', 'pipe']; // Headless mode - we handle I/O
-        const proc = spawn(binaryPath, args, {
-            cwd: this.config.cwd ?? process.cwd(),
-            env: {
-                ...process.env,
-                ...this.config.env,
-                AGENT_RELAY_NAME: this.config.name,
-                RELAY_AGENT_NAME: this.config.name, // MCP server uses this env var
-                AGENT_RELAY_OUTBOX: this._canonicalOutboxPath, // Agents use this for outbox path
-                TERM: 'xterm-256color',
-            },
-            stdio,
-        });
-        this.relayPtyProcess = proc;
-        // Handle stdout (agent output) - only in headless mode
-        if (!this.isInteractive && proc.stdout) {
-            proc.stdout.on('data', (data) => {
-                const text = data.toString();
-                this.handleOutput(text);
-            });
-        }
-        // Capture stderr for early exit diagnosis
-        let stderrBuffer = '';
-        // Handle stderr (relay-pty logs and JSON output) - always needed
-        // Also captures to buffer for error diagnostics if process dies early
-        if (proc.stderr) {
-            proc.stderr.on('data', (data) => {
-                const text = data.toString();
-                stderrBuffer += text;
-                this.handleStderr(text);
-            });
-        }
-        // Handle exit
-        proc.on('exit', (code, signal) => {
-            const exitCode = code ?? (signal === 'SIGKILL' ? 137 : 1);
-            this.log(` Process exited: code=${exitCode} signal=${signal}`);
-            // Capture early exit info for better error messages if socket not yet connected
-            if (!this.socketConnected) {
-                this.earlyExitInfo = { code, signal, stderr: stderrBuffer };
-            }
-            // Enhanced logging for SIGKILL/137 exits (likely OOM or resource limits)
-            if (signal === 'SIGKILL' || exitCode === 137) {
-                const diagnostics = RelayPtyOrchestrator.gatherSigkillDiagnostics(this.config.name, proc.pid);
-                this.logError(` SIGKILL DETECTED - gathering diagnostics:\n  ${diagnostics}`);
-                console.error(`[relay-pty-orchestrator] SIGKILL for ${this.config.name}:\n  ${diagnostics}`);
-            }
-            this.running = false;
-            // Get crash context before unregistering from memory monitor
-            const crashContext = this.memoryMonitor.getCrashContext(this.config.name);
-            // Unregister from memory monitor
-            this.memoryMonitor.unregister(this.config.name);
-            if (this.memoryAlertHandler) {
-                this.memoryMonitor.off('alert', this.memoryAlertHandler);
-                this.memoryAlertHandler = null;
-            }
-            // Clean up cgroup (fire and forget - process already exited)
-            if (this.hasCgroupSetup) {
-                this.cgroupManager.removeAgentCgroup(this.config.name).catch(() => { });
-                this.hasCgroupSetup = false;
-            }
-            // Broadcast crash notification if not a graceful stop
-            if (!this.isGracefulStop && this.client.state === 'READY') {
-                const canBroadcast = typeof this.client.broadcast === 'function';
-                const isNormalExit = exitCode === 0;
-                const wasKilled = signal === 'SIGKILL' || signal === 'SIGTERM' || exitCode === 137;
-                if (!isNormalExit) {
-                    const reason = wasKilled
-                        ? `killed by signal ${signal || 'SIGKILL'}`
-                        : `exit code ${exitCode}`;
-                    // Include crash context analysis if available
-                    const contextInfo = crashContext.likelyCause !== 'unknown'
-                        ? ` Likely cause: ${crashContext.likelyCause}. ${crashContext.analysisNotes.slice(0, 2).join('. ')}`
-                        : '';
-                    const message = `AGENT CRASHED: "${this.config.name}" has died unexpectedly (${reason}).${contextInfo}`;
-                    this.log(` Broadcasting crash notification: ${message}`);
-                    if (canBroadcast) {
-                        this.client.broadcast(message, 'message', {
-                            isSystemMessage: true,
-                            agentName: this.config.name,
-                            exitCode,
-                            signal: signal || undefined,
-                            crashType: 'unexpected_exit',
-                            crashContext: {
-                                likelyCause: crashContext.likelyCause,
-                                peakMemory: crashContext.peakMemory,
-                                averageMemory: crashContext.averageMemory,
-                                memoryTrend: crashContext.memoryTrend,
-                            },
-                        });
-                    }
-                    else {
-                        this.log(' broadcast skipped: client.broadcast not available');
-                    }
-                }
-            }
-            this.emit('exit', exitCode);
-            this.config.onExit?.(exitCode);
-        });
-        // Handle error
-        proc.on('error', (err) => {
-            this.logError(` Process error: ${err.message}`);
-            this.emit('error', err);
-        });
-        // Wait for process to start
-        await sleep(500);
-        if (proc.exitCode !== null) {
-            // Include any captured stderr in the error for debugging
-            const stderrInfo = stderrBuffer ? `\nStderr: ${stderrBuffer.slice(0, 500)}` : '';
-            throw new Error(`relay-pty exited immediately with code ${proc.exitCode}${stderrInfo}`);
-        }
-        // Register for memory/CPU monitoring
-        if (proc.pid) {
-            this.memoryMonitor.register(this.config.name, proc.pid);
-            this.memoryMonitor.start(); // Idempotent - starts if not already running
-            // Set up CPU limiting via cgroups (if configured and available)
-            // This prevents one agent from starving others during npm install/build
-            if (this.config.cpuLimitPercent && this.config.cpuLimitPercent > 0) {
-                this.setupCgroupLimit(proc.pid, this.config.cpuLimitPercent).catch((err) => {
-                    this.log(` Failed to set up cgroup CPU limit: ${err.message}`);
-                });
-            }
-            // Set up alert handler to send resource alerts to dashboard only (not other agents)
-            this.memoryAlertHandler = (alert) => {
-                if (alert.agentName !== this.config.name)
-                    return;
-                if (this.client.state !== 'READY')
-                    return;
-                const message = alert.type === 'recovered'
-                    ? `AGENT RECOVERED: "${this.config.name}" memory usage returned to normal.`
-                    : `AGENT RESOURCE ALERT: "${this.config.name}" - ${alert.message} (${formatBytes(alert.currentRss)})`;
-                this.log(` Sending resource alert to users: ${message}`);
-                // Send to all human users - agents don't need to know about each other's resource usage
-                this.client.sendMessage('@users', message, 'message', {
-                    isSystemMessage: true,
-                    agentName: this.config.name,
-                    alertType: alert.type,
-                    currentMemory: alert.currentRss,
-                    threshold: alert.threshold,
-                    recommendation: alert.recommendation,
-                });
-            };
-            this.memoryMonitor.on('alert', this.memoryAlertHandler);
-        }
-    }
-    /**
-     * Set up cgroup CPU limit for this agent
-     */
-    async setupCgroupLimit(pid, cpuPercent) {
-        await this.cgroupManager.initialize();
-        if (!this.cgroupManager.isAvailable()) {
-            this.log(` cgroups not available, skipping CPU limit`);
-            return;
-        }
-        const created = await this.cgroupManager.createAgentCgroup(this.config.name, { cpuPercent });
-        if (!created) {
-            return;
-        }
-        const added = await this.cgroupManager.addProcess(this.config.name, pid);
-        if (added) {
-            this.hasCgroupSetup = true;
-            this.log(` CPU limit set to ${cpuPercent}% for agent ${this.config.name}`);
-        }
-    }
-    /**
-     * Handle output from relay-pty stdout (headless mode only)
-     * In interactive mode, stdout goes directly to terminal via inherited stdio
-     */
-    handleOutput(data) {
-        // Skip processing if agent is no longer running (prevents ghost messages after release)
-        if (!this.running) {
-            return;
-        }
-        this.rawBuffer += data;
-        this.outputBuffer += data;
-        this.hasReceivedOutput = true;
-        // Trim buffers if they exceed max size to prevent RangeError: Invalid string length
-        // Keep the most recent output (tail) as it's more relevant for pattern matching
-        let buffersTrimmed = false;
-        if (this.rawBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
-            const trimAmount = this.rawBuffer.length - MAX_OUTPUT_BUFFER_SIZE;
-            this.rawBuffer = this.rawBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
-            // Adjust lastParsedLength to stay in sync with the trimmed buffer
-            // This ensures parseRelayCommands() doesn't skip content or re-parse old content
-            this.lastParsedLength = Math.max(0, this.lastParsedLength - trimAmount);
-            buffersTrimmed = true;
-        }
-        if (this.outputBuffer.length > MAX_OUTPUT_BUFFER_SIZE) {
-            this.outputBuffer = this.outputBuffer.slice(-MAX_OUTPUT_BUFFER_SIZE);
-            buffersTrimmed = true;
-        }
-        if (buffersTrimmed) {
-            this.bufferTrimCount += 1;
-        }
-        // Feed to idle detector
-        this.feedIdleDetectorOutput(data);
-        // Check for unread messages and append indicator if needed
-        const indicator = this.formatUnreadIndicator();
-        const outputWithIndicator = indicator ? data + indicator : data;
-        // Emit output event (with indicator if present)
-        this.emit('output', outputWithIndicator);
-        // Stream to daemon if configured
-        if (this.config.streamLogs !== false && this.client.state === 'READY') {
-            this.client.sendLog(outputWithIndicator);
-        }
-        // Parse for relay commands
-        this.parseRelayCommands();
-        // Check for summary and session end
-        const cleanContent = stripAnsi(this.rawBuffer);
-        this.checkForSummary(cleanContent);
-        this.checkForSessionEnd(cleanContent);
-    }
-    /**
-     * Format an unread message indicator if there are pending messages.
-     * Returns empty string if no pending messages or within cooldown period.
-     *
-     * Example output:
-     * ───────────────────────────
-     * 📬 2 unread messages (from: Alice, Bob)
-     */
-    formatUnreadIndicator() {
-        const queueLength = this.messageQueue.length;
-        if (queueLength === 0) {
-            return '';
-        }
-        // Check cooldown to avoid spamming
-        const now = Date.now();
-        if (now - this.lastUnreadIndicatorTime < this.UNREAD_INDICATOR_COOLDOWN_MS) {
-            return '';
-        }
-        this.lastUnreadIndicatorTime = now;
-        // Collect unique sender names
-        const senders = [...new Set(this.messageQueue.map(m => m.from))];
-        const senderList = senders.slice(0, 3).join(', ');
-        const moreCount = senders.length > 3 ? ` +${senders.length - 3} more` : '';
-        const line = '─'.repeat(27);
-        const messageWord = queueLength === 1 ? 'message' : 'messages';
-        return `\n${line}\n📬 ${queueLength} unread ${messageWord} (from: ${senderList}${moreCount})\n`;
-    }
-    /**
-     * Handle stderr from relay-pty (logs and JSON parsed commands)
-     */
-    handleStderr(data) {
-        // Skip processing if agent is no longer running (prevents ghost messages after release)
-        if (!this.running) {
-            return;
-        }
-        // relay-pty outputs JSON parsed commands to stderr with --json-output
-        const lines = data.split('\n').filter(l => l.trim());
-        for (const line of lines) {
-            if (line.startsWith('{')) {
-                // JSON output - parsed relay command from Rust
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.type === 'relay_command' && parsed.kind) {
-                        // Log parsed commands (only in debug mode to avoid TUI pollution)
-                        if (parsed.kind === 'spawn' || parsed.kind === 'release') {
-                            this.log(`Rust parsed [${parsed.kind}]: ${JSON.stringify({
-                                spawn_name: parsed.spawn_name,
-                                spawn_cli: parsed.spawn_cli,
-                                spawn_task: parsed.spawn_task?.substring(0, 50),
-                                release_name: parsed.release_name,
-                            })}`);
-                        }
-                        else {
-                            this.log(`Rust parsed [${parsed.kind}]: ${parsed.from} -> ${parsed.to}`);
-                        }
-                        this.handleRustParsedCommand(parsed);
-                    }
-                    else if (parsed.type === 'continuity') {
-                        // Handle continuity commands from relay-pty file-based protocol
-                        this.log(`Rust parsed [continuity]: action=${parsed.action}`);
-                        this.handleRustContinuityCommand(parsed);
-                    }
-                }
-                catch (e) {
-                    // Not JSON, just log (only in debug mode)
-                    if (this.config.debug) {
-                        console.error(`[relay-pty:${this.config.name}] ${line}`);
-                    }
-                }
-            }
-            else {
-                // Non-JSON stderr - only show in debug mode (logs, info messages)
-                if (this.config.debug) {
-                    console.error(`[relay-pty:${this.config.name}] ${line}`);
-                }
-            }
-        }
-    }
-    /**
-     * Handle a parsed command from Rust relay-pty
-     * Rust outputs structured JSON with 'kind' field: "message", "spawn", "release"
-     */
-    handleRustParsedCommand(parsed) {
-        switch (parsed.kind) {
-            case 'spawn':
-                if (parsed.spawn_name && parsed.spawn_cli) {
-                    this.log(` Spawn detected: ${parsed.spawn_name} (${parsed.spawn_cli})${parsed.spawn_cwd ? ` in ${parsed.spawn_cwd}` : ''}`);
-                    this.handleSpawnCommand(parsed.spawn_name, parsed.spawn_cli, parsed.spawn_task || '', parsed.spawn_cwd);
-                }
-                break;
-            case 'release':
-                if (parsed.release_name) {
-                    this.log(`Release: ${parsed.release_name}`);
-                    this.handleReleaseCommand(parsed.release_name);
-                }
-                else {
-                    this.logError(`Missing release_name in parsed command: ${JSON.stringify(parsed)}`);
-                }
-                break;
-            case 'message':
-            default:
-                this.sendRelayCommand({
-                    to: parsed.to,
-                    kind: 'message',
-                    body: parsed.body,
-                    thread: parsed.thread,
-                    raw: parsed.raw,
-                });
-                break;
-        }
-    }
-    /**
-     * Handle continuity command from Rust relay-pty
-     *
-     * Maps from Rust ContinuityCommand format to TypeScript ContinuityCommand
-     * and forwards to the ContinuityManager.
-     *
-     * Rust format: { type: "continuity", action: string, content: string }
-     * TypeScript format: { type: 'save' | 'load' | 'uncertain', content?: string, item?: string }
-     */
-    async handleRustContinuityCommand(parsed) {
-        if (!this.continuity) {
-            this.log('Continuity not initialized, skipping continuity command');
-            return;
-        }
-        // Map Rust action to TypeScript ContinuityCommand type
-        const action = parsed.action.toLowerCase();
-        if (!['save', 'load', 'uncertain'].includes(action)) {
-            this.logError(`Unknown continuity action: ${parsed.action}`);
-            return;
-        }
-        // Build TypeScript ContinuityCommand
-        const command = {
-            type: action,
-        };
-        if (action === 'save' && parsed.content) {
-            command.content = parsed.content;
-        }
-        else if (action === 'uncertain' && parsed.content) {
-            command.item = parsed.content;
-        }
-        // Deduplication (same logic as base-wrapper)
-        const cmdHash = `${command.type}:${command.content || command.item || 'no-content'}`;
-        if (command.content && this.processedContinuityCommands.has(cmdHash)) {
-            this.log(`Continuity command already processed: ${cmdHash}`);
-            return;
-        }
-        this.processedContinuityCommands.add(cmdHash);
-        // Limit dedup set size
-        if (this.processedContinuityCommands.size > 100) {
-            const oldest = this.processedContinuityCommands.values().next().value;
-            if (oldest)
-                this.processedContinuityCommands.delete(oldest);
-        }
-        try {
-            this.log(`Processing continuity command: ${command.type}`);
-            const response = await this.continuity.handleCommand(this.config.name, command);
-            if (response) {
-                // Queue response for injection (e.g., for 'load' command)
-                this.messageQueue.push({
-                    from: 'system',
-                    body: response,
-                    messageId: `continuity-${Date.now()}`,
-                    thread: 'continuity-response',
-                });
-                this.log(`Queued continuity response for injection`);
-            }
-            else {
-                this.log(`Continuity command ${command.type} completed (no response)`);
-            }
-        }
-        catch (err) {
-            this.logError(`Continuity command failed: ${err.message}`);
-        }
-    }
-    /**
-     * Handle spawn command (from Rust stderr JSON parsing)
-     *
-     * Note: We do NOT send the initial task message here because the spawner
-     * now handles it after waitUntilCliReady(). Sending it here would cause
-     * duplicate task delivery.
-     */
-    handleSpawnCommand(name, cli, task, cwd) {
-        const key = `spawn:${name}:${cli}`;
-        if (this.processedSpawnCommands.has(key)) {
-            this.log(`Spawn already processed: ${key}`);
-            return;
-        }
-        this.processedSpawnCommands.add(key);
-        // Log spawn attempts (only in debug mode to avoid TUI pollution)
-        this.log(`SPAWN REQUEST: ${name} (${cli})${cwd ? ` cwd=${cwd}` : ''}`);
-        this.log(`  client=${this.client.state}, dashboardPort=${this.config.dashboardPort}, onSpawn=${!!this.config.onSpawn}`);
-        // Try daemon socket first (most reliable - daemon has relay-pty binary),
-        // then dashboard API, then onSpawn callback as final fallback.
-        this.executeSpawnWithFallbacks(name, cli, task, cwd).catch(err => {
-            this.logError(`SPAWN FAILED: ${name} - all methods exhausted: ${err.message}`);
-        });
-    }
-    /**
-     * Execute spawn with daemon-first fallback chain.
-     * Order: daemon socket → dashboard API → onSpawn callback
-     */
-    async executeSpawnWithFallbacks(name, cli, task, cwd) {
-        // 1. Try daemon socket spawn first (daemon always has access to relay-pty)
-        if (this.client.state === 'READY') {
-            try {
-                this.log(`Spawning ${name} via daemon socket`);
-                const result = await this.client.spawn({ name, cli, task, cwd });
-                if (result.success) {
-                    this.log(`SPAWN SUCCESS: ${name} via daemon socket`);
-                    // Also register cwd with dashboard API so agentCwdMap is populated
-                    // (daemon socket spawn bypasses /api/spawn which normally sets this)
-                    if (cwd && this.config.dashboardPort) {
-                        this.registerCwdWithDashboard(name, cwd).catch(err => {
-                            this.log(`Failed to register cwd with dashboard: ${err.message}`);
-                        });
-                    }
-                }
-                else {
-                    // Daemon explicitly rejected - respect its decision (policy, duplicate, etc.)
-                    this.logError(`Daemon spawn rejected: ${result.error}`);
-                }
-                // Always return if daemon responded - only fall through on transport errors
-                return;
-            }
-            catch (err) {
-                this.logError(`Daemon spawn transport error: ${err.message}`);
-            }
-        }
-        // 2. Fall back to dashboard API
-        if (this.config.dashboardPort) {
-            try {
-                this.log(`Spawning ${name} via dashboard API at port ${this.config.dashboardPort}`);
-                await this.spawnViaDashboardApi(name, cli, task, cwd);
-                this.log(`SPAWN SUCCESS: ${name} via dashboard API`);
-                return;
-            }
-            catch (err) {
-                this.logError(`Dashboard spawn failed: ${err.message}`);
-            }
-        }
-        // 3. Final fallback: onSpawn callback
-        if (this.config.onSpawn) {
-            this.log(`Spawning ${name} via onSpawn callback`);
-            await this.config.onSpawn(name, cli, task, cwd);
-            return;
-        }
-        throw new Error(`No spawn mechanism available (client=${this.client.state}, dashboardPort=${this.config.dashboardPort}, onSpawn=${!!this.config.onSpawn})`);
-    }
-    /**
-     * Handle release command
-     */
-    handleReleaseCommand(name) {
-        const key = `release:${name}`;
-        if (this.processedReleaseCommands.has(key)) {
-            return;
-        }
-        this.processedReleaseCommands.add(key);
-        this.log(` Release: ${name}`);
-        // Try daemon socket first, then dashboard API, then callback
-        this.executeReleaseWithFallbacks(name).catch(err => {
-            this.logError(`RELEASE FAILED: ${name} - all methods exhausted: ${err.message}`);
-        });
-    }
-    /**
-     * Execute release with daemon-first fallback chain.
-     * Order: daemon socket → dashboard API → onRelease callback
-     */
-    async executeReleaseWithFallbacks(name) {
-        // 1. Try daemon socket release first
-        if (this.client.state === 'READY') {
-            try {
-                const result = await this.client.release(name);
-                if (result.success) {
-                    return;
-                }
-                // Daemon explicitly rejected - respect its decision
-                this.logError(`Daemon release rejected: ${result.error}`);
-                // Always return if daemon responded - only fall through on transport errors
-                return;
-            }
-            catch (err) {
-                this.logError(`Daemon release transport error: ${err.message}`);
-            }
-        }
-        // 2. Fall back to dashboard API
-        if (this.config.dashboardPort) {
-            try {
-                await this.releaseViaDashboardApi(name);
-                return;
-            }
-            catch (err) {
-                this.logError(`Dashboard release failed: ${err.message}`);
-            }
-        }
-        // 3. Final fallback: onRelease callback
-        if (this.config.onRelease) {
-            await this.config.onRelease(name);
-            return;
-        }
-        throw new Error(`No release mechanism available (client=${this.client.state}, dashboardPort=${this.config.dashboardPort}, onRelease=${!!this.config.onRelease})`);
-    }
-    /**
-     * Register an agent's cwd with the dashboard API.
-     * Used after daemon socket spawns which bypass /api/spawn and its agentCwdMap.
-     */
-    async registerCwdWithDashboard(name, cwd) {
-        const url = `http://localhost:${this.config.dashboardPort}/api/agents/${encodeURIComponent(name)}/cwd`;
-        const response = await fetch(url, {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ cwd }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-    }
-    /**
-     * Spawn agent via dashboard API
-     */
-    async spawnViaDashboardApi(name, cli, task, cwd) {
-        const url = `http://localhost:${this.config.dashboardPort}/api/spawn`;
-        const body = {
-            name,
-            cli,
-            task,
-            spawnerName: this.config.name, // Include spawner name so task appears from correct agent
-            cwd,
-        };
-        try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text().catch(() => 'unknown');
-                throw new Error(`HTTP ${response.status}: ${errorBody}`);
-            }
-            const result = await response.json().catch(() => ({}));
-            if (result.success === false) {
-                throw new Error(result.error || 'Spawn failed without specific error');
-            }
-        }
-        catch (err) {
-            // Enhance error with context
-            if (err.code === 'ECONNREFUSED') {
-                throw new Error(`Dashboard not reachable at ${url} (connection refused)`);
-            }
-            throw err;
-        }
-    }
-    /**
-     * Release agent via dashboard API
-     */
-    async releaseViaDashboardApi(name) {
-        const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawned/${encodeURIComponent(name)}`, {
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            const body = await response.json().catch(() => ({ error: 'Unknown' }));
-            throw new Error(`HTTP ${response.status}: ${body.error || 'Unknown error'}`);
-        }
-        this.log(`Released ${name} via dashboard API`);
-    }
-    // =========================================================================
-    // Socket communication
-    // =========================================================================
-    /**
-     * Check if the relay-pty process is still alive
-     */
-    isProcessAlive() {
-        if (!this.relayPtyProcess || this.relayPtyProcess.exitCode !== null) {
-            return false;
-        }
-        try {
-            // Signal 0 checks if process exists without killing it
-            process.kill(this.relayPtyProcess.pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Connect to the relay-pty socket
-     */
-    async connectToSocket() {
-        const timeout = this.config.socketConnectTimeoutMs ?? 5000;
-        const maxAttempts = this.config.socketReconnectAttempts ?? 3;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            // Check if relay-pty process died before attempting connection
-            if (!this.isProcessAlive()) {
-                const exitInfo = this.earlyExitInfo;
-                if (exitInfo) {
-                    const exitReason = exitInfo.signal
-                        ? `signal ${exitInfo.signal}`
-                        : `code ${exitInfo.code ?? 'unknown'}`;
-                    const stderrHint = exitInfo.stderr
-                        ? `\n  stderr: ${exitInfo.stderr.trim().slice(0, 500)}`
-                        : '';
-                    // Add enhanced diagnostics for SIGKILL (likely OOM or resource limit)
-                    const diagnostics = exitInfo.signal === 'SIGKILL' || exitInfo.code === 137
-                        ? `\n  Diagnostics (SIGKILL often indicates OOM or resource limits):\n  ${RelayPtyOrchestrator.gatherSigkillDiagnostics(this.config.name, this.relayPtyProcess?.pid)}`
-                        : '';
-                    throw new Error(`relay-pty process died early (${exitReason}).${stderrHint}${diagnostics}`);
-                }
-                throw new Error('relay-pty process died before socket could be created');
-            }
-            try {
-                await this.attemptSocketConnection(timeout);
-                this.log(` Socket connected`);
-                return;
-            }
-            catch (err) {
-                this.logError(` Socket connect attempt ${attempt}/${maxAttempts} failed: ${err.message}`);
-                if (attempt < maxAttempts) {
-                    await sleep(1000 * attempt); // Exponential backoff
-                }
-            }
-        }
-        // Final check for process death after all attempts
-        if (!this.isProcessAlive() && this.earlyExitInfo) {
-            const exitInfo = this.earlyExitInfo;
-            const exitReason = exitInfo.signal
-                ? `signal ${exitInfo.signal}`
-                : `code ${exitInfo.code ?? 'unknown'}`;
-            const stderrHint = exitInfo.stderr
-                ? `\n  stderr: ${exitInfo.stderr.trim().slice(0, 500)}`
-                : '';
-            // Add enhanced diagnostics for SIGKILL
-            const diagnostics = exitInfo.signal === 'SIGKILL' || exitInfo.code === 137
-                ? `\n  Diagnostics (SIGKILL often indicates OOM or resource limits):\n  ${RelayPtyOrchestrator.gatherSigkillDiagnostics(this.config.name, this.relayPtyProcess?.pid)}`
-                : '';
-            throw new Error(`relay-pty process died during socket connection (${exitReason}).${stderrHint}${diagnostics}`);
-        }
-        throw new Error(`Failed to connect to socket after ${maxAttempts} attempts`);
-    }
-    /**
-     * Attempt a single socket connection
-     */
-    attemptSocketConnection(timeout) {
-        return new Promise((resolve, reject) => {
-            // Clean up any existing socket before creating new one
-            // This prevents orphaned sockets with stale event handlers
-            if (this.socket) {
-                // Remove all listeners to prevent the old socket's 'close' event
-                // from triggering another reconnect cycle
-                this.socket.removeAllListeners();
-                this.socket.destroy();
-                this.socket = undefined;
-            }
-            const timer = setTimeout(() => {
-                reject(new Error('Socket connection timeout'));
-            }, timeout);
-            this.socket = createConnection(this.socketPath, () => {
-                clearTimeout(timer);
-                this.socketConnected = true;
-                resolve();
-            });
-            this.socket.on('error', (err) => {
-                clearTimeout(timer);
-                this.socketConnected = false;
-                reject(err);
-            });
-            // Handle 'end' event - server closed its write side (half-close)
-            this.socket.on('end', () => {
-                this.socketConnected = false;
-                this.log(` Socket received end (server closed write side)`);
-            });
-            this.socket.on('close', () => {
-                this.socketConnected = false;
-                this.log(` Socket closed`);
-                // Auto-reconnect if not intentionally stopped
-                if (this.running && !this.isGracefulStop) {
-                    this.scheduleSocketReconnect();
-                }
-            });
-            // Handle incoming data (responses)
-            let buffer = '';
-            this.socket.on('data', (data) => {
-                buffer += data.toString();
-                // Process complete lines
-                const lines = buffer.split('\n');
-                buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
-                for (const line of lines) {
-                    if (line.trim()) {
-                        this.handleSocketResponse(line);
-                    }
-                }
-            });
-        });
-    }
-    /**
-     * Disconnect from socket
-     */
-    disconnectSocket() {
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = undefined;
-            this.socketConnected = false;
-        }
-        // Reject all pending injections
-        for (const [_id, pending] of this.pendingInjections) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error('Socket disconnected'));
-        }
-        this.pendingInjections.clear();
-    }
-    /** Timer for socket reconnection */
-    socketReconnectTimer;
-    /** Current reconnection attempt count */
-    socketReconnectAttempt = 0;
-    /**
-     * Schedule a socket reconnection attempt with exponential backoff
-     */
-    scheduleSocketReconnect() {
-        const maxAttempts = this.config.socketReconnectAttempts ?? 3;
-        // Clear any existing timer
-        if (this.socketReconnectTimer) {
-            clearTimeout(this.socketReconnectTimer);
-            this.socketReconnectTimer = undefined;
-        }
-        if (this.socketReconnectAttempt >= maxAttempts) {
-            this.logError(` Socket reconnect failed after ${maxAttempts} attempts`);
-            // Reset counter for future reconnects (processMessageQueue can trigger new cycle)
-            this.socketReconnectAttempt = 0;
-            // Note: socketReconnectTimer is already undefined, allowing processMessageQueue
-            // to trigger a new reconnection cycle when new messages arrive
-            return;
-        }
-        this.socketReconnectAttempt++;
-        const delay = Math.min(1000 * Math.pow(2, this.socketReconnectAttempt - 1), 10000); // Max 10s
-        this.log(` Scheduling socket reconnect in ${delay}ms (attempt ${this.socketReconnectAttempt}/${maxAttempts})`);
-        this.socketReconnectTimer = setTimeout(async () => {
-            // Clear timer reference now that callback is executing
-            this.socketReconnectTimer = undefined;
-            if (!this.running || this.isGracefulStop) {
-                return;
-            }
-            try {
-                const timeout = this.config.socketConnectTimeoutMs ?? 5000;
-                await this.attemptSocketConnection(timeout);
-                this.log(` Socket reconnected successfully`);
-                this.socketReconnectAttempt = 0; // Reset on success
-                // Process any queued messages that were waiting
-                if (this.messageQueue.length > 0 && !this.isInjecting) {
-                    this.log(` Processing ${this.messageQueue.length} queued messages after reconnect`);
-                    this.processMessageQueue();
-                }
-            }
-            catch (err) {
-                this.logError(` Socket reconnect attempt ${this.socketReconnectAttempt} failed: ${err.message}`);
-                // Schedule another attempt
-                this.scheduleSocketReconnect();
-            }
-        }, delay);
-    }
-    /**
-     * Send a request to the socket and optionally wait for response
-     */
-    sendSocketRequest(request) {
-        return new Promise((resolve, reject) => {
-            if (!this.socket || !this.socketConnected) {
-                reject(new Error('Socket not connected'));
-                return;
-            }
-            const json = JSON.stringify(request) + '\n';
-            this.socket.write(json, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Handle a response from the socket
-     */
-    handleSocketResponse(line) {
-        try {
-            const response = JSON.parse(line);
-            switch (response.type) {
-                case 'inject_result':
-                    // handleInjectResult is async (does verification), but we don't await here
-                    // Errors are handled internally by the method
-                    this.handleInjectResult(response).catch((err) => {
-                        this.logError(` Error handling inject result: ${err.message}`);
-                    });
-                    break;
-                case 'status':
-                    // Status responses are typically requested explicitly
-                    this.log(` Status: idle=${response.agent_idle} queue=${response.queue_length}`);
-                    break;
-                case 'backpressure':
-                    this.handleBackpressure(response);
-                    break;
-                case 'error':
-                    this.logError(` Socket error: ${response.message}`);
-                    break;
-                case 'shutdown_ack':
-                    this.log(` Shutdown acknowledged`);
-                    break;
-                case 'send_enter_result':
-                    // SendEnter is no longer used - trust Rust delivery confirmation
-                    this.log(` Received send_enter_result (deprecated)`);
-                    break;
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to parse socket response: ${err.message}`);
-        }
-    }
-    /**
-     * Handle injection result response
-     * After Rust reports 'delivered', verifies the message appeared in output.
-     * If verification fails, retries up to MAX_RETRIES times.
-     */
-    async handleInjectResult(response) {
-        this.log(` handleInjectResult: id=${response.id.substring(0, 8)} status=${response.status}`);
-        const pending = this.pendingInjections.get(response.id);
-        if (!pending) {
-            // Response for unknown message - might be from a previous session
-            this.log(` No pending injection found for ${response.id.substring(0, 8)}`);
-            return;
-        }
-        if (response.status === 'delivered') {
-            // Rust says it sent the message + Enter key
-            // Trust Rust's delivery confirmation - relay-pty writes directly to PTY which is very reliable.
-            //
-            // IMPORTANT: We don't verify by looking for the message in output because:
-            // 1. TUI CLIs (Claude, Codex, Gemini) don't echo input like traditional terminals
-            // 2. The injected text appears as INPUT to the PTY, not OUTPUT
-            // 3. Output-based verification always fails for TUIs, causing unnecessary retries
-            //
-            // This is different from tmux-wrapper where we inject via tmux send-keys
-            // and can observe the echoed input in the pane output.
-            this.log(` Message ${pending.shortId} delivered by Rust ✓`);
-            clearTimeout(pending.timeout);
-            this.pendingInjections.delete(response.id);
-            if (pending.retryCount === 0) {
-                this.injectionMetrics.successFirstTry++;
-            }
-            else {
-                this.injectionMetrics.successWithRetry++;
-            }
-            this.injectionMetrics.total++;
-            pending.resolve(true);
-        }
-        else if (response.status === 'failed') {
-            clearTimeout(pending.timeout);
-            this.pendingInjections.delete(response.id);
-            this.injectionMetrics.failed++;
-            this.injectionMetrics.total++;
-            pending.resolve(false);
-            this.logError(` Message ${pending.shortId} failed: ${response.error}`);
-            this.emit('injection-failed', {
-                messageId: response.id,
-                from: pending.from,
-                error: response.error ?? 'Unknown error',
-            });
-        }
-        // queued/injecting are intermediate states - wait for final status
-    }
-    /**
-     * Handle backpressure notification
-     */
-    handleBackpressure(response) {
-        const wasActive = this.backpressureActive;
-        this.backpressureActive = !response.accept;
-        if (this.backpressureActive !== wasActive) {
-            this.log(` Backpressure: ${this.backpressureActive ? 'ACTIVE' : 'cleared'} (queue=${response.queue_length})`);
-            this.emit('backpressure', { queueLength: response.queue_length, accept: response.accept });
-            // Resume processing if backpressure cleared
-            if (!this.backpressureActive) {
-                this.processMessageQueue();
-            }
-        }
-    }
-    // =========================================================================
-    // Message handling
-    // =========================================================================
-    /**
-     * Inject a message into the agent via socket
-     */
-    async injectMessage(msg, retryCount = 0) {
-        const shortId = msg.messageId.substring(0, 8);
-        this.log(` === INJECT START: ${shortId} from ${msg.from} (attempt ${retryCount + 1}) ===`);
-        if (!this.socket || !this.socketConnected) {
-            this.logError(` Cannot inject - socket not connected`);
-            return false;
-        }
-        // Build injection content
-        const content = buildInjectionString(msg);
-        this.log(` Injection content (${content.length} bytes): ${content.substring(0, 100)}...`);
-        // Create request
-        const request = {
-            type: 'inject',
-            id: msg.messageId,
-            from: msg.from,
-            body: content,
-            priority: msg.importance ?? 0,
-        };
-        this.log(` Sending inject request to socket...`);
-        // Create promise for result
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.logError(` Inject timeout for ${shortId} after 30s`);
-                this.pendingInjections.delete(msg.messageId);
-                resolve(false); // Timeout = failure
-            }, 30000); // 30 second timeout for injection
-            this.pendingInjections.set(msg.messageId, {
-                resolve,
-                reject,
-                timeout,
-                from: msg.from,
-                shortId,
-                retryCount,
-                originalBody: content,
-            });
-            // Send request
-            this.sendSocketRequest(request)
-                .then(() => {
-                this.log(` Socket request sent for ${shortId}`);
-            })
-                .catch((err) => {
-                this.logError(` Socket request failed for ${shortId}: ${err.message}`);
-                clearTimeout(timeout);
-                this.pendingInjections.delete(msg.messageId);
-                resolve(false);
-            });
-        });
-    }
-    /**
-     * Process queued messages
-     */
-    async processMessageQueue() {
-        // Debug: Log blocking conditions when queue has messages
-        if (this.messageQueue.length > 0) {
-            if (!this.readyForMessages) {
-                this.log(` Queue blocked: readyForMessages=false (queue=${this.messageQueue.length})`);
-                return;
-            }
-            if (this.backpressureActive) {
-                this.log(` Queue blocked: backpressure active (queue=${this.messageQueue.length})`);
-                return;
-            }
-            if (this.isInjecting) {
-                // Already injecting - the finally block will process next message
-                // But add a safety timeout in case injection gets stuck
-                const elapsed = this.injectionStartTime > 0 ? Date.now() - this.injectionStartTime : 0;
-                if (elapsed > 35000) {
-                    this.logError(` Injection stuck for ${elapsed}ms, forcing reset`);
-                    this.isInjecting = false;
-                    this.injectionStartTime = 0;
-                }
-                return;
-            }
-        }
-        if (this.messageQueue.length === 0) {
-            return;
-        }
-        // Proactively reconnect socket if disconnected and we have messages to send
-        if (!this.socketConnected && !this.socketReconnectTimer) {
-            this.log(` Socket disconnected, triggering reconnect before processing queue`);
-            this.scheduleSocketReconnect();
-            return; // Wait for reconnection to complete
-        }
-        if (!this.socketConnected) {
-            // Reconnection in progress, wait for it
-            this.log(` Queue waiting: socket reconnecting (queue=${this.messageQueue.length})`);
-            return;
-        }
-        // Check if agent is in editor mode - delay injection if so
-        const idleResult = this.idleDetector.checkIdle();
-        if (idleResult.inEditorMode) {
-            this.log(` Agent in editor mode, delaying injection (queue: ${this.messageQueue.length})`);
-            // Check again in 2 seconds
-            setTimeout(() => this.processMessageQueue(), 2000);
-            return;
-        }
-        this.isInjecting = true;
-        this.injectionStartTime = Date.now();
-        const msg = this.messageQueue.shift();
-        const bodyPreview = msg.body.substring(0, 50).replace(/\n/g, '\\n');
-        this.log(` Processing message from ${msg.from}: "${bodyPreview}..." (remaining=${this.messageQueue.length})`);
-        try {
-            const success = await this.injectMessage(msg);
-            // Metrics are now tracked in handleInjectResult which knows about retries
-            if (!success) {
-                // Record failure for adaptive throttling
-                this.throttle.recordFailure();
-                this.logError(` Injection failed for message ${msg.messageId.substring(0, 8)}`);
-                this.config.onInjectionFailed?.(msg.messageId, 'Injection failed');
-                this.sendSyncAck(msg.messageId, msg.sync, 'ERROR', { error: 'injection_failed' });
-            }
-            else {
-                // Record success for adaptive throttling
-                this.throttle.recordSuccess();
-                this.sendSyncAck(msg.messageId, msg.sync, 'OK');
-            }
-        }
-        catch (err) {
-            this.logError(` Injection error: ${err.message}`);
-            // Track metrics for exceptions (not handled by handleInjectResult)
-            this.injectionMetrics.failed++;
-            this.injectionMetrics.total++;
-            // Record failure for adaptive throttling
-            this.throttle.recordFailure();
-            this.sendSyncAck(msg.messageId, msg.sync, 'ERROR', { error: err.message });
-        }
-        finally {
-            this.isInjecting = false;
-            this.injectionStartTime = 0;
-            // Process next message after adaptive delay (faster when healthy, slower under stress)
-            if (this.messageQueue.length > 0 && !this.backpressureActive) {
-                const delay = this.throttle.getDelay();
-                setTimeout(() => this.processMessageQueue(), delay);
-            }
-        }
-    }
-    /**
-     * Override handleIncomingMessage to trigger queue processing
-     */
-    handleIncomingMessage(from, payload, messageId, meta, originalTo) {
-        this.log(` === MESSAGE RECEIVED: ${messageId.substring(0, 8)} from ${from} ===`);
-        this.log(` Body preview: ${payload.body?.substring(0, 100) ?? '(no body)'}...`);
-        super.handleIncomingMessage(from, payload, messageId, meta, originalTo);
-        this.log(` Queue length after add: ${this.messageQueue.length}`);
-        this.processMessageQueue();
-    }
-    /**
-     * Override handleIncomingChannelMessage to trigger queue processing.
-     * Without this override, channel messages would be queued but processMessageQueue()
-     * would never be called, causing messages to get stuck until the queue monitor runs.
-     */
-    handleIncomingChannelMessage(from, channel, body, envelope) {
-        this.log(` === CHANNEL MESSAGE RECEIVED: ${envelope.id.substring(0, 8)} from ${from} on ${channel} ===`);
-        this.log(` Body preview: ${body?.substring(0, 100) ?? '(no body)'}...`);
-        super.handleIncomingChannelMessage(from, channel, body, envelope);
-        this.log(` Queue length after add: ${this.messageQueue.length}`);
-        this.processMessageQueue();
-    }
-    // =========================================================================
-    // Queue monitor - Detect and process stuck messages
-    // =========================================================================
-    /**
-     * Start the queue monitor to periodically check for stuck messages.
-     * This ensures messages don't get orphaned in the queue when the agent is idle.
-     */
-    startQueueMonitor() {
-        if (this.queueMonitorTimer) {
-            return; // Already started
-        }
-        this.log(` Starting queue monitor (interval: ${this.QUEUE_MONITOR_INTERVAL_MS}ms)`);
-        this.queueMonitorTimer = setInterval(() => {
-            this.checkForStuckQueue();
-        }, this.QUEUE_MONITOR_INTERVAL_MS);
-        // Don't keep process alive just for queue monitoring
-        this.queueMonitorTimer.unref?.();
-    }
-    /**
-     * Stop the queue monitor.
-     */
-    stopQueueMonitor() {
-        if (this.queueMonitorTimer) {
-            clearInterval(this.queueMonitorTimer);
-            this.queueMonitorTimer = undefined;
-            this.log(` Queue monitor stopped`);
-        }
-    }
-    // =========================================================================
-    // Protocol monitoring (detect agent mistakes like empty AGENT_RELAY_NAME)
-    // =========================================================================
-    /**
-     * Start watching for protocol issues in the outbox directory.
-     * Detects common mistakes like:
-     * - Empty AGENT_RELAY_NAME causing files at outbox//
-     * - Files created directly in outbox/ instead of agent subdirectory
-     */
-    startProtocolMonitor() {
-        // Get the outbox parent directory (one level up from agent's outbox)
-        const parentDir = dirname(this._canonicalOutboxPath);
-        // Ensure parent directory exists
-        try {
-            if (!existsSync(parentDir)) {
-                mkdirSync(parentDir, { recursive: true });
-            }
-        }
-        catch {
-            // Ignore - directory may already exist
-        }
-        try {
-            this.protocolWatcher = watch(parentDir, (eventType, filename) => {
-                if (eventType === 'rename' && filename) {
-                    // Check for files directly in parent (not in agent subdirectory)
-                    // This happens when $AGENT_RELAY_NAME is empty
-                    const fullPath = join(parentDir, filename);
-                    try {
-                        // If it's a file (not directory) directly in the parent, that's an issue
-                        if (existsSync(fullPath) && !lstatSync(fullPath).isDirectory()) {
-                            this.handleProtocolIssue('file_in_root', filename);
-                        }
-                        // Check for empty-named directory (double slash symptom)
-                        if (filename === '' || filename.startsWith('/')) {
-                            this.handleProtocolIssue('empty_agent_name', filename);
-                        }
-                    }
-                    catch {
-                        // Ignore stat errors
-                    }
-                }
-            });
-            // Don't keep process alive just for protocol monitoring
-            this.protocolWatcher.unref?.();
-            this.log(` Protocol monitor started on ${parentDir}`);
-        }
-        catch (err) {
-            // Don't fail start() if protocol monitoring fails
-            this.logError(` Failed to start protocol monitor: ${err.message}`);
-        }
-        // Also do an initial scan for existing issues
-        this.scanForProtocolIssues();
-    }
-    /**
-     * Stop the protocol monitor.
-     */
-    stopProtocolMonitor() {
-        if (this.protocolWatcher) {
-            this.protocolWatcher.close();
-            this.protocolWatcher = undefined;
-            this.log(` Protocol monitor stopped`);
-        }
-    }
-    /**
-     * Scan for existing protocol issues (called once at startup).
-     */
-    scanForProtocolIssues() {
-        const parentDir = dirname(this._canonicalOutboxPath);
-        try {
-            if (!existsSync(parentDir))
-                return;
-            const entries = readdirSync(parentDir);
-            for (const entry of entries) {
-                const fullPath = join(parentDir, entry);
-                try {
-                    // Check for files directly in parent (should only be directories)
-                    if (!lstatSync(fullPath).isDirectory()) {
-                        this.handleProtocolIssue('file_in_root', entry);
-                        break; // Only report once
-                    }
-                }
-                catch {
-                    // Ignore stat errors
-                }
-            }
-        }
-        catch {
-            // Ignore scan errors
-        }
-    }
-    /**
-     * Handle a detected protocol issue by injecting a helpful reminder.
-     */
-    handleProtocolIssue(issue, filename) {
-        const now = Date.now();
-        // Respect cooldown to avoid spamming
-        if (now - this.protocolReminderCooldown < this.PROTOCOL_REMINDER_COOLDOWN_MS) {
-            return;
-        }
-        this.protocolReminderCooldown = now;
-        this.log(` Protocol issue detected: ${issue} (${filename})`);
-        const reminders = {
-            empty_agent_name: `⚠️ **Protocol Issue Detected**
-
-Your \`$AGENT_RELAY_NAME\` environment variable appears to be empty or unset.
-Your agent name is: **${this.config.name}**
-
-Correct outbox path: \`$AGENT_RELAY_OUTBOX\`
-
-When writing relay files, use:
-\`\`\`bash
-cat > $AGENT_RELAY_OUTBOX/msg << 'EOF'
-TO: TargetAgent
-
-Your message here
-EOF
-\`\`\`
-Then output: \`->relay-file:msg\``,
-            file_in_root: `⚠️ **Protocol Issue Detected**
-
-Found file "${filename}" directly in the outbox root instead of using the proper path.
-Your agent name is: **${this.config.name}**
-
-The \`$AGENT_RELAY_OUTBOX\` path already points to your agent's directory.
-Write files directly inside it:
-
-\`\`\`bash
-cat > $AGENT_RELAY_OUTBOX/msg << 'EOF'
-TO: TargetAgent
-
-Your message here
-EOF
-\`\`\`
-Then output: \`->relay-file:msg\``,
-        };
-        const reminder = reminders[issue];
-        if (reminder) {
-            this.injectProtocolReminder(reminder);
-        }
-    }
-    /**
-     * Inject a protocol reminder message to the agent.
-     */
-    injectProtocolReminder(message) {
-        const queuedMsg = {
-            from: 'system',
-            body: message,
-            messageId: `protocol-reminder-${Date.now()}`,
-            importance: 2, // Higher priority
-        };
-        this.messageQueue.unshift(queuedMsg); // Add to front of queue
-        this.log(` Queued protocol reminder (queue size: ${this.messageQueue.length})`);
-        // Trigger processing if not already in progress
-        if (!this.isInjecting && this.readyForMessages) {
-            this.processMessageQueue();
-        }
-    }
-    // =========================================================================
-    // Periodic protocol reminders (for long sessions where agents forget protocol)
-    // =========================================================================
-    /**
-     * Start sending periodic protocol reminders.
-     * Agents in long sessions sometimes forget the relay protocol - these
-     * reminders help them stay on track without user intervention.
-     */
-    startPeriodicReminder() {
-        this.sessionStartTime = Date.now();
-        this.periodicReminderTimer = setInterval(() => {
-            this.sendPeriodicProtocolReminder();
-        }, this.PERIODIC_REMINDER_INTERVAL_MS);
-        // Don't keep process alive just for reminders
-        this.periodicReminderTimer.unref?.();
-        const intervalMinutes = Math.round(this.PERIODIC_REMINDER_INTERVAL_MS / 60000);
-        this.log(` Periodic protocol reminder started (interval: ${intervalMinutes} minutes)`);
-    }
-    /**
-     * Stop periodic protocol reminders.
-     */
-    stopPeriodicReminder() {
-        if (this.periodicReminderTimer) {
-            clearInterval(this.periodicReminderTimer);
-            this.periodicReminderTimer = undefined;
-            this.log(` Periodic protocol reminder stopped`);
-        }
-    }
-    /**
-     * Send a periodic protocol reminder to the agent.
-     * This reminds agents about proper relay communication format after long sessions.
-     */
-    sendPeriodicProtocolReminder() {
-        // Don't send if not ready
-        if (!this.running || !this.readyForMessages) {
-            return;
-        }
-        const sessionDurationMinutes = Math.round((Date.now() - this.sessionStartTime) / 60000);
-        const reminder = `📋 **Protocol Reminder** (Session: ${sessionDurationMinutes} minutes)
-
-You are **${this.config.name}** in a multi-agent relay system. Here's how to communicate:
-
-**Sending Messages:**
-\`\`\`bash
-cat > $AGENT_RELAY_OUTBOX/msg << 'EOF'
-TO: *
-
-Your message here
-EOF
-\`\`\`
-Then output: \`->relay-file:msg\`
-
-Use \`TO: *\` to broadcast to all agents, or \`TO: AgentName\` for a specific agent.
-
-**Spawning Agents:**
-\`\`\`bash
-cat > $AGENT_RELAY_OUTBOX/spawn << 'EOF'
-KIND: spawn
-NAME: WorkerName
-CLI: claude
-
-Task description here
-EOF
-\`\`\`
-Then output: \`->relay-file:spawn\`
-
-**Message Format:**
-- \`TO: AgentName\` for direct messages
-- \`TO: *\` to broadcast to all agents
-- \`TO: #channel\` for channel messages
-
-📖 See **AGENTS.md** in the project root for full protocol documentation.`;
-        this.log(` Sending periodic protocol reminder (session: ${sessionDurationMinutes}m)`);
-        this.injectProtocolReminder(reminder);
-    }
-    /**
-     * Check for messages stuck in the queue and process them if the agent is idle.
-     *
-     * This handles cases where:
-     * 1. Messages arrived while the agent was busy and the retry mechanism failed
-     * 2. Socket disconnection/reconnection left messages orphaned
-     * 3. Injection timeouts occurred without proper queue resumption
-     */
-    checkForStuckQueue() {
-        // Skip if not ready for messages
-        if (!this.readyForMessages || !this.running) {
-            return;
-        }
-        // Skip if queue is empty
-        if (this.messageQueue.length === 0) {
-            return;
-        }
-        // Check if currently injecting
-        if (this.isInjecting) {
-            // Check if injection has been stuck for too long
-            const stuckDuration = Date.now() - this.injectionStartTime;
-            if (stuckDuration > this.MAX_INJECTION_STUCK_MS) {
-                this.logError(` ⚠️ Injection stuck for ${Math.round(stuckDuration / 1000)}s - force resetting`);
-                this.isInjecting = false;
-                this.injectionStartTime = 0;
-                // Clear any pending injections that might be stuck
-                for (const [id, pending] of this.pendingInjections) {
-                    clearTimeout(pending.timeout);
-                    this.logError(` Clearing stuck pending injection: ${id.substring(0, 8)}`);
-                }
-                this.pendingInjections.clear();
-                // Continue to process the queue below
-            }
-            else {
-                return; // Still within normal injection time
-            }
-        }
-        // Skip if backpressure is active
-        if (this.backpressureActive) {
-            return;
-        }
-        // Check if the agent is idle (high confidence)
-        const idleResult = this.idleDetector.checkIdle({ minSilenceMs: 2000 });
-        if (!idleResult.isIdle) {
-            // Agent is still working, let it finish
-            return;
-        }
-        // We have messages in the queue, agent is idle, not currently injecting
-        // This is a stuck queue situation - trigger processing
-        const senders = [...new Set(this.messageQueue.map(m => m.from))];
-        this.log(` ⚠️ Queue monitor: Found ${this.messageQueue.length} stuck message(s) from [${senders.join(', ')}]`);
-        this.log(` ⚠️ Agent is idle (confidence: ${(idleResult.confidence * 100).toFixed(0)}%), triggering queue processing`);
-        // Process the queue
-        this.processMessageQueue();
-    }
-    // =========================================================================
-    // Output parsing
-    // =========================================================================
-    /**
-     * Parse relay commands from output
-     */
-    parseRelayCommands() {
-        const cleanContent = stripAnsi(this.rawBuffer);
-        if (cleanContent.length <= this.lastParsedLength) {
-            return;
-        }
-        // Parse new content with lookback for fenced messages
-        const lookbackStart = Math.max(0, this.lastParsedLength - 500);
-        const contentToParse = cleanContent.substring(lookbackStart);
-        // Parse fenced messages
-        this.parseFencedMessages(contentToParse);
-        // Parse single-line messages
-        this.parseSingleLineMessages(contentToParse);
-        // Parse spawn/release commands
-        this.parseSpawnReleaseCommands(contentToParse);
-        this.lastParsedLength = cleanContent.length;
-    }
-    /**
-     * Parse fenced multi-line messages
-     */
-    parseFencedMessages(content) {
-        const escapedPrefix = this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const fencePattern = new RegExp(`${escapedPrefix}(\\S+)(?:\\s+\\[thread:([\\w-]+)\\])?\\s*<<<([\\s\\S]*?)>>>`, 'g');
-        let match;
-        while ((match = fencePattern.exec(content)) !== null) {
-            const target = match[1];
-            const thread = match[2];
-            const body = match[3].trim();
-            if (!body || target === 'spawn' || target === 'release') {
-                continue;
-            }
-            this.sendRelayCommand({
-                to: target,
-                kind: 'message',
-                body,
-                thread,
-                raw: match[0],
-            });
-        }
-    }
-    /**
-     * Parse single-line messages
-     */
-    parseSingleLineMessages(content) {
-        const lines = content.split('\n');
-        const escapedPrefix = this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const pattern = new RegExp(`${escapedPrefix}(\\S+)(?:\\s+\\[thread:([\\w-]+)\\])?\\s+(.+)$`);
-        for (const line of lines) {
-            // Skip fenced messages
-            if (line.includes('<<<') || line.includes('>>>')) {
-                continue;
-            }
-            const match = line.match(pattern);
-            if (!match) {
-                continue;
-            }
-            const target = match[1];
-            const thread = match[2];
-            const body = match[3].trim();
-            if (!body || target === 'spawn' || target === 'release') {
-                continue;
-            }
-            this.sendRelayCommand({
-                to: target,
-                kind: 'message',
-                body,
-                thread,
-                raw: line,
-            });
-        }
-    }
-    // =========================================================================
-    // Summary and session end detection
-    // =========================================================================
-    /**
-     * Check for [[SUMMARY]] blocks
-     */
-    checkForSummary(content) {
-        const result = parseSummaryWithDetails(content);
-        if (!result.found || !result.valid) {
-            return;
-        }
-        if (result.rawContent === this.lastSummaryRawContent) {
-            return;
-        }
-        this.lastSummaryRawContent = result.rawContent ?? '';
-        this.emit('summary', {
-            agentName: this.config.name,
-            summary: result.summary,
-        });
-    }
-    /**
-     * Check for [[SESSION_END]] blocks
-     */
-    checkForSessionEnd(content) {
-        if (this.sessionEndProcessed) {
-            return;
-        }
-        const sessionEnd = parseSessionEndFromOutput(content);
-        if (!sessionEnd) {
-            return;
-        }
-        // Store SESSION_END data for use in autoSave (fixes empty handoff issue)
-        this.sessionEndData = sessionEnd;
-        this.sessionEndProcessed = true;
-        this.emit('session-end', {
-            agentName: this.config.name,
-            marker: sessionEnd,
-        });
-    }
-    // =========================================================================
-    // Public API
-    // =========================================================================
-    /**
-     * Query status from relay-pty
-     */
-    async queryStatus() {
-        if (!this.socket || !this.socketConnected) {
-            return null;
-        }
-        try {
-            await this.sendSocketRequest({ type: 'status' });
-            // Response will come asynchronously via handleSocketResponse
-            // For now, return null - could implement request/response matching
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Wait for the CLI to be ready to receive messages.
-     * This waits for:
-     * 1. The CLI to produce at least one output (it has started)
-     * 2. The CLI to become idle (it's ready for input)
-     *
-     * This is more reliable than a random sleep because it waits for
-     * actual signals from the CLI rather than guessing how long it takes to start.
-     *
-     * @param timeoutMs Maximum time to wait (default: 30s)
-     * @param pollMs Polling interval (default: 100ms)
-     * @returns true if CLI is ready, false if timeout
-     */
-    async waitUntilCliReady(timeoutMs = 30000, pollMs = 100) {
-        const startTime = Date.now();
-        this.log(` Waiting for CLI to be ready (timeout: ${timeoutMs}ms)`);
-        // In interactive mode, stdout is inherited (not captured), so hasReceivedOutput
-        // will never be set. Trust that the process is ready if it's running.
-        if (this.isInteractive) {
-            this.log(` Interactive mode - trusting process is ready`);
-            // Give a brief moment for the CLI to initialize its TUI.
-            // 500ms is a conservative estimate based on typical CLI startup times:
-            // - Claude CLI: ~200-300ms to show initial prompt
-            // - Codex/Gemini: ~300-400ms
-            // This delay is only used in interactive mode where we can't detect output.
-            // In non-interactive mode, we poll for actual output instead.
-            await sleep(500);
-            return this.running;
-        }
-        // Phase 1: Wait for first output (CLI has started)
-        while (Date.now() - startTime < timeoutMs) {
-            if (this.hasReceivedOutput) {
-                this.log(` CLI has started producing output`);
-                break;
-            }
-            await sleep(pollMs);
-        }
-        if (!this.hasReceivedOutput) {
-            this.log(` Timeout waiting for CLI to produce output`);
-            return false;
-        }
-        // Phase 2: Wait for idle state (CLI is ready for input)
-        const remainingTime = timeoutMs - (Date.now() - startTime);
-        if (remainingTime <= 0) {
-            return false;
-        }
-        const idleResult = await this.waitForIdleState(remainingTime, pollMs);
-        if (idleResult.isIdle) {
-            this.log(` CLI is idle and ready (confidence: ${idleResult.confidence.toFixed(2)})`);
-            return true;
-        }
-        this.log(` Timeout waiting for CLI to become idle`);
-        return false;
-    }
-    /**
-     * Check if the CLI has produced any output yet.
-     * Useful for checking if the CLI has started without blocking.
-     * In interactive mode, returns true if process is running (output isn't captured).
-     */
-    hasCliStarted() {
-        // In interactive mode, stdout isn't captured so hasReceivedOutput is never set
-        if (this.isInteractive) {
-            return this.running;
-        }
-        return this.hasReceivedOutput;
-    }
-    /**
-     * Check if the orchestrator is ready to receive and inject messages.
-     * This requires:
-     * 1. relay-pty process spawned
-     * 2. Socket connected to relay-pty
-     * 3. running flag set
-     *
-     * Use this to verify the agent can actually receive injected messages,
-     * not just that the CLI is running.
-     */
-    isReadyForMessages() {
-        return this.readyForMessages && this.running && this.socketConnected;
-    }
-    /**
-     * Wait until the orchestrator is ready to receive and inject messages.
-     * This is more comprehensive than waitUntilCliReady because it ensures:
-     * 1. CLI is ready (has output and is idle)
-     * 2. Orchestrator is ready (socket connected, can inject)
-     *
-     * @param timeoutMs Maximum time to wait (default: 30s)
-     * @param pollMs Polling interval (default: 100ms)
-     * @returns true if ready, false if timeout
-     */
-    async waitUntilReadyForMessages(timeoutMs = 30000, pollMs = 100) {
-        const startTime = Date.now();
-        this.log(` Waiting for orchestrator to be ready for messages (timeout: ${timeoutMs}ms)`);
-        // First wait for CLI to be ready (output + idle)
-        const cliReady = await this.waitUntilCliReady(timeoutMs, pollMs);
-        if (!cliReady) {
-            this.log(` CLI not ready within timeout`);
-            return false;
-        }
-        // Then wait for readyForMessages flag
-        const remainingTime = timeoutMs - (Date.now() - startTime);
-        if (remainingTime <= 0) {
-            this.log(` No time remaining to wait for readyForMessages`);
-            return this.isReadyForMessages();
-        }
-        while (Date.now() - startTime < timeoutMs) {
-            if (this.isReadyForMessages()) {
-                this.log(` Orchestrator is ready for messages`);
-                return true;
-            }
-            await sleep(pollMs);
-        }
-        this.log(` Timeout waiting for orchestrator to be ready for messages`);
-        return false;
-    }
-    /**
-     * Get raw output buffer
-     */
-    getRawOutput() {
-        return this.rawBuffer;
-    }
-    /**
-     * Check if backpressure is active
-     */
-    isBackpressureActive() {
-        return this.backpressureActive;
-    }
-    /**
-     * Get the socket path
-     */
-    getSocketPath() {
-        return this.socketPath;
-    }
-    /**
-     * Get the relay-pty process PID
-     */
-    get pid() {
-        return this.relayPtyProcess?.pid;
-    }
-    /**
-     * Get the log file path (not used by relay-pty, returns undefined)
-     */
-    get logPath() {
-        return this._logPath;
-    }
-    /**
-     * Kill the process forcefully
-     */
-    async kill() {
-        this.isGracefulStop = true; // Mark as intentional to prevent crash broadcast
-        if (this.socketReconnectTimer) {
-            clearTimeout(this.socketReconnectTimer);
-            this.socketReconnectTimer = undefined;
-        }
-        if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-            this.relayPtyProcess.kill('SIGKILL');
-        }
-        this.running = false;
-        this.disconnectSocket();
-        this.destroyClient();
-    }
-    /**
-     * Get output lines (for compatibility with PtyWrapper)
-     * @param limit Maximum number of lines to return
-     */
-    getOutput(limit) {
-        const lines = this.rawBuffer.split('\n');
-        if (limit && limit > 0) {
-            return lines.slice(-limit);
-        }
-        return lines;
-    }
-    /**
-     * Write data directly to the process stdin
-     * @param data Data to write
-     */
-    async write(data) {
-        if (!this.relayPtyProcess || !this.relayPtyProcess.stdin) {
-            throw new Error('Process not running');
-        }
-        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
-        this.relayPtyProcess.stdin.write(buffer);
-    }
-    /**
-     * Verify that the CLI shows activity after task injection.
-     * Checks output for patterns indicating the task was received and processing started.
-     *
-     * This catches the race condition where PTY write succeeds but CLI wasn't ready
-     * (the T-003 failure scenario where CLI showed bell characters instead of processing).
-     *
-     * @param outputBefore The output buffer content before injection
-     * @returns Promise resolving to true if activity detected, false otherwise
-     */
-    async verifyActivityAfterInjection(outputBefore) {
-        const startTime = Date.now();
-        const { TIMEOUT_MS, POLL_INTERVAL_MS, TASK_RECEIVED_PATTERNS, THINKING_PATTERNS, TOOL_EXECUTION_PATTERNS } = ACTIVITY_VERIFICATION;
-        const trimCountBefore = this.bufferTrimCount;
-        while (Date.now() - startTime < TIMEOUT_MS) {
-            // If buffers were trimmed during verification, treat it as activity.
-            // Large output growth triggers trimming, which would otherwise make slice() return
-            // an empty string and falsely signal no activity.
-            if (this.bufferTrimCount !== trimCountBefore) {
-                this.log(` Activity verified: output buffer trimmed during verification (large output)`);
-                return true;
-            }
-            // Get new output since injection
-            const currentOutput = this.outputBuffer;
-            const newOutput = currentOutput.slice(outputBefore.length);
-            if (newOutput.length > 0) {
-                // REJECTION CHECK: Multiple BEL characters (0x07) indicate CLI rejected input
-                // The T-003 failure showed CLI producing 1000+ BELs when input was injected
-                // while the CLI wasn't ready (still initializing or in wrong mode)
-                const belCount = (newOutput.match(/\x07/g) || []).length;
-                if (belCount > 10) {
-                    this.logError(` Input rejected: CLI produced ${belCount} BEL characters`);
-                    return false; // Don't wait - immediately fail so retry can attempt
-                }
-                // Check for task received patterns (primary verification)
-                for (const pattern of TASK_RECEIVED_PATTERNS) {
-                    if (pattern.test(newOutput)) {
-                        this.log(` Activity verified: task received pattern matched`);
-                        return true;
-                    }
-                }
-                // Check for thinking/processing patterns (secondary verification)
-                for (const pattern of THINKING_PATTERNS) {
-                    if (pattern.test(newOutput)) {
-                        this.log(` Activity verified: thinking pattern matched`);
-                        return true;
-                    }
-                }
-                // Check for tool execution patterns (tertiary verification)
-                for (const pattern of TOOL_EXECUTION_PATTERNS) {
-                    if (pattern.test(newOutput)) {
-                        this.log(` Activity verified: tool execution pattern matched`);
-                        return true;
-                    }
-                }
-                // Fallback: If output grew significantly (>100 meaningful chars), assume activity
-                // This catches CLIs with unusual output patterns
-                // IMPORTANT: Strip out BEL (0x07) and other control characters - these are rejection
-                // signals not activity. The T-003 failure showed CLI producing 1000+ BELs when input
-                // was injected before it was ready.
-                const meaningfulOutput = newOutput.replace(/[\x00-\x1f]/g, ''); // Strip control chars
-                if (meaningfulOutput.length > 100) {
-                    this.log(` Activity verified: significant output growth (${meaningfulOutput.length} meaningful chars)`);
-                    return true;
-                }
-            }
-            await sleep(POLL_INTERVAL_MS);
-        }
-        // No activity detected within timeout
-        this.log(` No activity detected within ${TIMEOUT_MS}ms`);
-        return false;
-    }
-    /**
-     * Inject a task using the socket-based injection system with activity verification.
-     * This is the preferred method for spawned agent task delivery.
-     *
-     * After socket confirms delivery, verifies the CLI shows activity (task received,
-     * thinking indicators, or tool execution). Retries if no activity is detected.
-     *
-     * @param task The task text to inject
-     * @param from The sender name (default: "spawner")
-     * @returns Promise resolving to true if task was delivered AND activity verified, false otherwise
-     */
-    async injectTask(task, from = 'spawner') {
-        const { MAX_RETRIES, RETRY_DELAY_MS } = ACTIVITY_VERIFICATION;
-        // Claude Code's TUI needs a stabilization delay after displaying the welcome screen
-        // before it's ready to accept stdin input. Without this, input may be silently dropped
-        // even though the CLI appears "idle" and doesn't reject with BELs.
-        // 1500ms is based on observed behavior - Claude Code typically needs 1-1.5s after
-        // its TUI renders before input handlers are fully initialized.
-        const STABILIZATION_DELAY_MS = 1500;
-        this.log(` Waiting ${STABILIZATION_DELAY_MS}ms for CLI stabilization before task injection`);
-        await sleep(STABILIZATION_DELAY_MS);
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            if (attempt > 0) {
-                this.log(` Retry ${attempt}/${MAX_RETRIES} - waiting ${RETRY_DELAY_MS}ms before retry`);
-                await sleep(RETRY_DELAY_MS);
-            }
-            // Capture output buffer state before injection
-            const outputBefore = this.outputBuffer;
-            // Attempt delivery via socket
-            const delivered = await this.performTaskInjection(task, from);
-            if (!delivered) {
-                this.logError(` Task delivery failed on attempt ${attempt + 1}`);
-                continue; // Retry
-            }
-            // Verify CLI shows activity (task received, thinking, or tool execution)
-            const activityVerified = await this.verifyActivityAfterInjection(outputBefore);
-            if (activityVerified) {
-                this.log(` Task delivered and activity verified successfully`);
-                return true;
-            }
-            // Delivery succeeded but no activity - CLI might not have been ready
-            this.logError(` Task delivered but no activity detected (attempt ${attempt + 1})`);
-        }
-        this.logError(` Task injection failed after ${MAX_RETRIES + 1} attempts - no CLI activity detected`);
-        return false;
-    }
-    /**
-     * Perform a single task injection attempt (without retry logic).
-     * @returns true if the injection was sent successfully, false otherwise
-     */
-    async performTaskInjection(task, from) {
-        if (!this.socket || !this.socketConnected) {
-            this.log(` Socket not connected for task injection, falling back to stdin write`);
-            try {
-                await this.write(task + '\n');
-                return true;
-            }
-            catch (err) {
-                this.logError(` Stdin write fallback failed: ${err.message}`);
-                return false;
-            }
-        }
-        const messageId = `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-        const shortId = messageId.substring(0, 8);
-        this.log(` Injecting task via socket: ${shortId}`);
-        // Create request
-        const request = {
-            type: 'inject',
-            id: messageId,
-            from,
-            body: task,
-            priority: 0, // High priority for initial task
-        };
-        // Send with timeout and get socket confirmation
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                this.logError(` Task inject timeout for ${shortId} after 30s`);
-                this.pendingInjections.delete(messageId);
-                resolve(false);
-            }, 30000);
-            this.pendingInjections.set(messageId, {
-                resolve,
-                reject: () => resolve(false),
-                timeout,
-                from,
-                shortId,
-                retryCount: 0,
-                originalBody: task,
-            });
-            this.sendSocketRequest(request)
-                .then(() => {
-                this.log(` Task inject request sent: ${shortId}`);
-            })
-                .catch((err) => {
-                this.logError(` Task inject socket request failed: ${err.message}`);
-                clearTimeout(timeout);
-                this.pendingInjections.delete(messageId);
-                resolve(false);
-            });
-        });
-    }
-    /**
-     * Get the agent ID (from continuity if available)
-     */
-    getAgentId() {
-        return this.agentId;
-    }
-}
-//# sourceMappingURL=relay-pty-orchestrator.js.map