agent-relay 1.3.2 → 1.5.0

package/dist/wrapper/shared.d.ts

@@ -53,7 +53,7 @@ export declare const INJECTION_CONSTANTS: {
     /** Timeout for injection verification (ms) */
     readonly VERIFICATION_TIMEOUT_MS: 2000;
     /** Delay between message and Enter key (ms) */
-    readonly ENTER_DELAY_MS: 50;
+    readonly ENTER_DELAY_MS: 100;
     /** Backoff multiplier for retries (ms per attempt) */
     readonly RETRY_BACKOFF_MS: 300;
     /** Delay between processing queued messages (ms) */

package/dist/wrapper/shared.js

@@ -19,7 +19,7 @@ export const INJECTION_CONSTANTS = {
     /** Timeout for injection verification (ms) */
     VERIFICATION_TIMEOUT_MS: 2000,
     /** Delay between message and Enter key (ms) */
-    ENTER_DELAY_MS: 50,
+    ENTER_DELAY_MS: 100,
     /** Backoff multiplier for retries (ms per attempt) */
     RETRY_BACKOFF_MS: 300,
     /** Delay between processing queued messages (ms) */
@@ -58,6 +58,11 @@ export function sleep(ms) {
  */
 export function buildInjectionString(msg) {
     const shortId = msg.messageId.substring(0, 8);
+    // Use senderName from data if available (for dashboard messages sent via _DashboardUI)
+    // This allows showing the actual GitHub username instead of the system client name
+    const displayFrom = (msg.from === '_DashboardUI' && typeof msg.data?.senderName === 'string')
+        ? msg.data.senderName
+        : msg.from;
     // Strip ANSI and normalize whitespace
     const sanitizedBody = stripAnsi(msg.body).replace(/[\r\n]+/g, ' ').trim();
     // Thread hint
@@ -68,8 +73,13 @@ export function buildInjectionString(msg) {
         : msg.importance !== undefined && msg.importance > 50
             ? ' [!]'
             : '';
-    // Channel indicator for broadcasts
-    const channelHint = msg.originalTo === '*' ? ' [#general]' : '';
+    // Channel indicator for channel messages and broadcasts
+    // originalTo will be '*' for broadcasts or the channel name (e.g., '#general') for channel messages
+    const channelHint = msg.originalTo === '*'
+        ? ' [#general]'
+        : msg.originalTo?.startsWith('#')
+            ? ` [${msg.originalTo}]`
+            : '';
     // Extract attachment file paths if present
     let attachmentHint = '';
     if (msg.data?.attachments && Array.isArray(msg.data.attachments)) {
@@ -80,7 +90,7 @@ export function buildInjectionString(msg) {
             attachmentHint = ` [Attachments: ${filePaths.join(', ')}]`;
         }
     }
-    return `Relay message from ${msg.from} [${shortId}]${threadHint}${importanceHint}${channelHint}${attachmentHint}: ${sanitizedBody}`;
+    return `Relay message from ${displayFrom} [${shortId}]${threadHint}${importanceHint}${channelHint}${attachmentHint}: ${sanitizedBody}`;
 }
 /**
  * Calculate injection success rate from metrics

package/dist/wrapper/tmux-wrapper.d.ts

@@ -232,9 +232,16 @@ export declare class TmuxWrapper extends BaseWrapper {
      */
     private parseSessionEndAndClose;
     /**
-     * Execute spawn via API (if dashboardPort set) or callback
+     * Execute spawn via API (if dashboardPort set) or callback.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    private waitAndSendTask;
     /**
      * Execute release via API (if dashboardPort set) or callback
      */
@@ -255,6 +262,11 @@ export declare class TmuxWrapper extends BaseWrapper {
      *                     Agents should reply to originalTo to maintain channel routing (e.g., respond to #general, not DM).
      */
     protected handleIncomingMessage(from: string, payload: SendPayload, messageId: string, meta?: SendMeta, originalTo?: string): void;
+    /**
+     * Handle incoming channel message from relay.
+     * Channel messages include a channel indicator so the agent knows to reply to the channel.
+     */
+    protected handleIncomingChannelMessage(from: string, channel: string, body: string, envelope: import('../protocol/types.js').Envelope<import('../protocol/channels.js').ChannelMessagePayload>): void;
     /**
      * Check if we should inject a message.
      * Uses UniversalIdleDetector (from BaseWrapper) for robust cross-CLI idle detection.

package/dist/wrapper/tmux-wrapper.js

@@ -218,11 +218,18 @@ export class TmuxWrapper extends BaseWrapper {
         if (!this.config.args || this.config.args.length === 0) {
             return this.config.command;
         }
-        // Quote any argument that contains spaces, quotes, or special chars
+        // Quote any argument that contains spaces, quotes, or shell special chars
+        // Must handle: spaces, quotes, $, <, >, |, &, ;, (, ), `, etc.
         const quotedArgs = this.config.args.map(arg => {
-            if (arg.includes(' ') || arg.includes('"') || arg.includes("'") || arg.includes('$')) {
-                // Use double quotes and escape internal quotes
-                return `"${arg.replace(/"/g, '\\"')}"`;
+            if (/[\s"'$<>|&;()`,!\\]/.test(arg)) {
+                // Use double quotes and escape internal quotes and special chars
+                const escaped = arg
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\$/g, '\\$')
+                    .replace(/`/g, '\\`')
+                    .replace(/!/g, '\\!');
+                return `"${escaped}"`;
             }
             return arg;
         });
@@ -251,9 +258,14 @@ export class TmuxWrapper extends BaseWrapper {
             this.inbox.init();
         }
         // Connect to relay daemon (in background, don't block)
-        this.client.connect().catch((err) => {
+        this.client.connect()
+            .then(() => {
+            this.logStderr(`Relay connected (state: ${this.client.state})`, true);
+        })
+            .catch((err) => {
             // Connection failures will retry via client backoff; surface once to stderr.
             this.logStderr(`Relay connect failed: ${err.message}. Will retry if enabled.`, true);
+            this.logStderr(`Relay client state: ${this.client.state}`, true);
         });
         // Kill any existing session with this name
         try {
@@ -330,9 +342,13 @@ export class TmuxWrapper extends BaseWrapper {
             // Wait for shell to be ready (look for prompt)
             await this.waitForShellReady();
             // Send the command to run
+            this.logStderr('Sending command to tmux...');
             await this.sendKeysLiteral(fullCommand);
-            await sleep(100);
+            await sleep(300); // Give shell time to process the command literal
+            this.logStderr('Sending Enter...');
             await this.sendKeys('Enter');
+            await sleep(500); // Ensure Enter is processed and command starts before we continue
+            this.logStderr('Command sent');
         }
         catch (err) {
             throw new Error(`Failed to create tmux session: ${err.message}`);
@@ -452,6 +468,8 @@ export class TmuxWrapper extends BaseWrapper {
     async injectInstructions() {
         if (!this.running)
             return;
+        if (this.config.skipInstructions)
+            return;
         // Use escaped prefix (\->relay:) in examples to prevent parser from treating them as real commands
         const escapedPrefix = '\\' + this.relayPrefix;
         // Build instructions including relay and trail
@@ -991,20 +1009,23 @@ export class TmuxWrapper extends BaseWrapper {
         });
     }
     /**
-     * Execute spawn via API (if dashboardPort set) or callback
+     * Execute spawn via API (if dashboardPort set) or callback.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     async executeSpawn(name, cli, task) {
+        let spawned = false;
         if (this.config.dashboardPort) {
             // Use dashboard API for spawning (works from any context, no terminal required)
             try {
                 const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawn`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, cli, task }),
+                    body: JSON.stringify({ name, cli }), // No task - we send it after agent is online
                 });
                 const result = await response.json();
                 if (result.success) {
                     this.logStderr(`Spawned ${name} via API`);
+                    spawned = true;
                 }
                 else {
                     this.logStderr(`Spawn failed: ${result.error}`, true);
@@ -1018,11 +1039,57 @@ export class TmuxWrapper extends BaseWrapper {
             // Fall back to callback
             try {
                 await this.config.onSpawn(name, cli, task);
+                spawned = true;
             }
             catch (err) {
                 this.logStderr(`Spawn failed: ${err.message}`, true);
             }
         }
+        // If spawn succeeded and we have a task, wait for agent to come online and send it
+        if (spawned && task && task.trim() && this.config.dashboardPort) {
+            await this.waitAndSendTask(name, task);
+        }
+    }
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    async waitAndSendTask(agentName, task) {
+        const maxWaitMs = 30000;
+        const pollIntervalMs = 500;
+        const startTime = Date.now();
+        this.logStderr(`Waiting for ${agentName} to come online...`);
+        // Poll for agent to be online using dedicated status endpoint
+        while (Date.now() - startTime < maxWaitMs) {
+            try {
+                const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/agents/${encodeURIComponent(agentName)}/online`);
+                const data = await response.json();
+                if (data.online) {
+                    this.logStderr(`${agentName} is online, sending task...`);
+                    // Send task directly via our relay client (not dashboard API)
+                    // This ensures the message comes "from" this agent, not from _DashboardUI
+                    if (this.client.state === 'READY') {
+                        const sent = this.client.sendMessage(agentName, task, 'message');
+                        if (sent) {
+                            this.logStderr(`Task sent to ${agentName}`);
+                        }
+                        else {
+                            this.logStderr(`Failed to send task to ${agentName}: sendMessage returned false`, true);
+                        }
+                    }
+                    else {
+                        this.logStderr(`Failed to send task to ${agentName}: relay client not ready (state: ${this.client.state})`, true);
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                // Ignore poll errors, keep trying
+            }
+            await sleep(pollIntervalMs);
+        }
+        this.logStderr(`Timeout waiting for ${agentName} to come online`, true);
     }
     /**
      * Execute release via API (if dashboardPort set) or callback
@@ -1069,6 +1136,10 @@ export class TmuxWrapper extends BaseWrapper {
         // Only process if we have API or callbacks configured
         const canSpawn = this.config.dashboardPort || this.config.onSpawn;
         const canRelease = this.config.dashboardPort || this.config.onRelease;
+        // Debug: Log spawn capability status
+        if (content.includes('->relay:spawn')) {
+            this.logStderr(`[spawn-debug] canSpawn=${!!canSpawn} dashboardPort=${this.config.dashboardPort} hasOnSpawn=${!!this.config.onSpawn}`);
+        }
         if (!canSpawn && !canRelease)
             return;
         const lines = content.split('\n');
@@ -1079,6 +1150,12 @@ export class TmuxWrapper extends BaseWrapper {
             let trimmed = line.trim();
             // Strip common line prefixes (bullets, prompts) before checking for commands
             trimmed = trimmed.replace(linePrefixPattern, '');
+            // Fix for over-stripping: the linePrefixPattern includes - and > characters,
+            // which can accidentally strip the -> from ->relay:spawn, leaving just relay:spawn.
+            // If we detect this happened, restore the -> prefix.
+            if (/^(relay|thinking|continuity):/.test(trimmed)) {
+                trimmed = '->' + trimmed;
+            }
             // If we're in fenced spawn mode, accumulate lines until we see >>>
             if (this.pendingFencedSpawn) {
                 // Check for fence close (>>> at end of line or on its own line)
@@ -1217,6 +1294,40 @@ export class TmuxWrapper extends BaseWrapper {
         // Try to inject
         this.checkForInjectionOpportunity();
     }
+    /**
+     * Handle incoming channel message from relay.
+     * Channel messages include a channel indicator so the agent knows to reply to the channel.
+     */
+    handleIncomingChannelMessage(from, channel, body, envelope) {
+        const messageId = envelope.id;
+        if (this.hasSeenIncoming(messageId)) {
+            this.logStderr(`← ${from} [${channel}]: duplicate delivery (${messageId.substring(0, 8)})`);
+            return;
+        }
+        const truncatedBody = body.substring(0, Math.min(DEBUG_LOG_TRUNCATE_LENGTH, body.length));
+        this.logStderr(`← ${from} [${channel}]: ${truncatedBody}...`);
+        // Record in trajectory via trail
+        this.trajectory?.message('received', from, this.config.name, body);
+        // Queue for injection - include channel as originalTo so we can inform the agent how to route responses
+        this.messageQueue.push({
+            from,
+            body,
+            messageId,
+            thread: envelope.payload.thread,
+            data: {
+                _isChannelMessage: true,
+                _channel: channel,
+                _mentions: envelope.payload.mentions,
+            },
+            originalTo: channel, // Set channel as the reply target
+        });
+        // Write to inbox if enabled
+        if (this.inbox) {
+            this.inbox.addMessage(from, body);
+        }
+        // Try to inject
+        this.checkForInjectionOpportunity();
+    }
     /**
      * Check if we should inject a message.
      * Uses UniversalIdleDetector (from BaseWrapper) for robust cross-CLI idle detection.
@@ -1236,11 +1347,6 @@ export class TmuxWrapper extends BaseWrapper {
             setTimeout(() => this.checkForInjectionOpportunity(), retryMs);
             return;
         }
-        // Log detection method in debug mode
-        if (this.config.debug && idleResult.signals.length > 0) {
-            const signalInfo = idleResult.signals.map(s => `${s.source}:${(s.confidence * 100).toFixed(0)}%`).join(', ');
-            this.logStderr(`Idle detected (${signalInfo})`);
-        }
         this.injectNextMessage();
     }
     /**
@@ -1252,19 +1358,16 @@ export class TmuxWrapper extends BaseWrapper {
         if (!msg)
             return;
         this.isInjecting = true;
-        this.logStderr(`Injecting message from ${msg.from} (cli: ${this.cliType})`);
         try {
             const shortId = msg.messageId.substring(0, 8);
             // Wait for input to be clear before injecting
             // If input is not clear (human typing), re-queue and try later - never clear forcefully!
-            // Fix for agent-relay-j9z: forceful clearing destroys human input in progress
             const waitTimeoutMs = this.config.inputWaitTimeoutMs ?? 5000;
             const waitPollMs = this.config.inputWaitPollMs ?? 200;
             const inputClear = await this.waitForClearInput(waitTimeoutMs, waitPollMs);
             if (!inputClear) {
                 // Input still has text after timeout - DON'T clear forcefully, re-queue instead
-                // This preserves any human input in progress
-                this.logStderr('Input not clear after waiting, re-queuing injection to preserve human input');
+                this.logStderr('Input not clear, re-queuing injection');
                 this.messageQueue.unshift(msg);
                 this.isInjecting = false;
                 setTimeout(() => this.checkForInjectionOpportunity(), this.config.injectRetryMs ?? 1000);
@@ -1316,7 +1419,9 @@ export class TmuxWrapper extends BaseWrapper {
                     }
                 },
                 performInjection: async (inj) => {
-                    await this.pasteLiteral(inj);
+                    // Use send-keys -l (literal) instead of paste-buffer
+                    // paste-buffer causes issues where Claude shows "[Pasted text]" but content doesn't appear
+                    await this.sendKeysLiteral(inj);
                     await sleep(INJECTION_CONSTANTS.ENTER_DELAY_MS);
                     await this.sendKeys('Enter');
                 },
@@ -1367,7 +1472,15 @@ export class TmuxWrapper extends BaseWrapper {
      * Send special keys to tmux
      */
     async sendKeys(keys) {
-        await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} ${keys}`);
+        const cmd = `"${this.tmuxPath}" send-keys -t ${this.sessionName} ${keys}`;
+        try {
+            await execAsync(cmd);
+            this.logStderr(`[sendKeys] Sent: ${keys}`);
+        }
+        catch (err) {
+            this.logStderr(`[sendKeys] Failed to send ${keys}: ${err.message}`, true);
+            throw err;
+        }
     }
     /**
      * Send literal text to tmux
@@ -1382,7 +1495,14 @@ export class TmuxWrapper extends BaseWrapper {
             .replace(/\$/g, '\\$')
             .replace(/`/g, '\\`')
             .replace(/!/g, '\\!');
-        await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} -l "${escaped}"`);
+        try {
+            await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} -l "${escaped}"`);
+            this.logStderr(`[sendKeysLiteral] Sent ${text.length} chars`);
+        }
+        catch (err) {
+            this.logStderr(`[sendKeysLiteral] Failed: ${err.message}`, true);
+            throw err;
+        }
     }
     /**
      * Paste text using tmux buffer with optional bracketed paste to avoid interleaving with ongoing output.
@@ -1398,15 +1518,9 @@ export class TmuxWrapper extends BaseWrapper {
             .replace(/`/g, '\\`')
             .replace(/!/g, '\\!');
         // Set tmux buffer then paste
-        // Skip bracketed paste (-p) for CLIs that don't handle it properly (droid, other)
-        await execAsync(`"${this.tmuxPath}" set-buffer -- "${escaped}"`);
-        const useBracketedPaste = this.cliType === 'claude' || this.cliType === 'codex' || this.cliType === 'gemini' || this.cliType === 'opencode';
-        if (useBracketedPaste) {
-            await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName} -p`);
-        }
-        else {
-            await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName}`);
-        }
+        const setBufferCmd = `"${this.tmuxPath}" set-buffer -- "${escaped}"`;
+        await execAsync(setBufferCmd);
+        await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName}`);
     }
     /**
      * Reset session-specific state for wrapper reuse.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "1.3.2",
+  "version": "1.5.0",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,9 @@
   },
   "scripts": {
     "postinstall": "npm rebuild better-sqlite3 && node scripts/postinstall.js",
-    "build": "npm run clean && tsc",
-    "postbuild": "chmod +x dist/cli/index.js",
+    "build": "npm run clean && tsc && npm run build:dashboard",
+    "build:dashboard": "cd src/dashboard && npm run build",
+    "postbuild": "chmod +x dist/cli/index.js && mkdir -p dist/dashboard && cp -r src/dashboard/out dist/dashboard/",
     "dev:watch": "tsc -w",
     "predev": "npm run clean && tsc && chmod +x dist/cli/index.js",
     "dev": "concurrently -n daemon,next -c blue,magenta \"npm run dev:daemon\" \"npm run dev:next\"",
@@ -26,6 +27,7 @@
     "dev:rebuild": "npm run build && echo '✓ Rebuilt (linked version updated)'",
     "start": "node dist/cli/index.js",
     "daemon": "node dist/daemon/server.js",
+    "dashboard": "node dist/dashboard-server/start.js",
     "pretest": "npm run build",
     "test": "vitest run",
     "test:integration": "vitest run test/cloud/*.integration.test.ts",
@@ -97,6 +99,9 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^14.3.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
@@ -116,7 +121,7 @@
     "eslint": "^8.57.1",
     "jsdom": "^25.0.1",
     "typescript": "^5.9.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/postinstall.js

@@ -3,14 +3,16 @@
  * Postinstall Script for agent-relay
  *
  * This script runs after npm install to:
- * 1. Install dashboard dependencies
- * 2. Patch agent-trajectories CLI
- * 3. Check for tmux availability
+ * 1. Install relay-pty binary for current platform
+ * 2. Install dashboard dependencies
+ * 3. Patch agent-trajectories CLI
+ * 4. Check for tmux availability (fallback)
  */
 
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
+import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -41,6 +43,86 @@ function warn(msg) {
   console.log(`${colors.yellow}[warn]${colors.reset} ${msg}`);
 }
 
+/**
+ * Get the platform-specific binary name for relay-pty
+ * Returns null if platform is not supported
+ */
+function getRelayPtyBinaryName() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  // Map Node.js arch to Rust target arch
+  const archMap = {
+    'arm64': 'arm64',
+    'x64': 'x64',
+  };
+
+  // Map Node.js platform to Rust target platform
+  const platformMap = {
+    'darwin': 'darwin',
+    'linux': 'linux',
+  };
+
+  const targetPlatform = platformMap[platform];
+  const targetArch = archMap[arch];
+
+  if (!targetPlatform || !targetArch) {
+    return null;
+  }
+
+  return `relay-pty-${targetPlatform}-${targetArch}`;
+}
+
+/**
+ * Install the relay-pty binary for the current platform
+ */
+function installRelayPtyBinary() {
+  const pkgRoot = getPackageRoot();
+  const binaryName = getRelayPtyBinaryName();
+
+  if (!binaryName) {
+    warn(`Unsupported platform: ${os.platform()}-${os.arch()}`);
+    warn('relay-pty binary not available, will fall back to tmux mode');
+    return false;
+  }
+
+  const sourcePath = path.join(pkgRoot, 'bin', binaryName);
+  const targetPath = path.join(pkgRoot, 'bin', 'relay-pty');
+
+  // Check if platform-specific binary exists
+  if (!fs.existsSync(sourcePath)) {
+    warn(`relay-pty binary not found for ${os.platform()}-${os.arch()}`);
+    warn('Will fall back to tmux mode');
+    return false;
+  }
+
+  // Check if already installed (and is a symlink or copy of correct binary)
+  if (fs.existsSync(targetPath)) {
+    try {
+      // Check if it's already the right binary by comparing size
+      const sourceStats = fs.statSync(sourcePath);
+      const targetStats = fs.statSync(targetPath);
+      if (sourceStats.size === targetStats.size) {
+        info('relay-pty binary already installed');
+        return true;
+      }
+    } catch {
+      // Continue to reinstall
+    }
+  }
+
+  // Copy the binary (symlinks don't work well across npm install)
+  try {
+    fs.copyFileSync(sourcePath, targetPath);
+    fs.chmodSync(targetPath, 0o755);
+    success(`Installed relay-pty binary for ${os.platform()}-${os.arch()}`);
+    return true;
+  } catch (err) {
+    warn(`Failed to install relay-pty binary: ${err.message}`);
+    return false;
+  }
+}
+
 /**
  * Check if tmux is available on the system
  */
@@ -140,6 +222,9 @@ function patchAgentTrajectories() {
  * Main postinstall routine
  */
 async function main() {
+  // Install relay-pty binary for current platform (primary mode)
+  const hasRelayPty = installRelayPtyBinary();
+
   // Ensure trail CLI captures agent info on start
   patchAgentTrajectories();
 
@@ -151,18 +236,23 @@ async function main() {
     return;
   }
 
-  // Check if system tmux is available
+  // If relay-pty is installed, we're good
+  if (hasRelayPty) {
+    info('Using relay-pty for agent communication (fast mode)');
+    return;
+  }
+
+  // Fall back to tmux check
   if (hasSystemTmux()) {
-    info('System tmux found');
+    info('System tmux found (fallback mode)');
     return;
   }
 
-  // Recommend user installs tmux manually
-  warn('tmux not found on system');
-  info('To use tmux mode, install tmux:');
-  info('  macOS:  brew install tmux');
-  info('  Ubuntu: sudo apt install tmux');
-  info('  Or use PTY mode via the dashboard (no tmux required)');
+  // Neither relay-pty nor tmux available
+  warn('Neither relay-pty nor tmux available');
+  info('Agent spawning will not work without one of:');
+  info('  1. relay-pty binary (included for darwin-arm64, darwin-x64, linux-x64)');
+  info('  2. tmux: brew install tmux (macOS) or apt install tmux (Linux)');
 }
 
 main().catch((err) => {

package/.trajectories/active/traj_3yx9dy148mge.json

@@ -1,42 +0,0 @@
-{
-  "id": "traj_3yx9dy148mge",
-  "version": 1,
-  "task": {
-    "title": "Investigate agent-relay codex-auth tunnel failure"
-  },
-  "status": "active",
-  "startedAt": "2026-01-10T04:02:25.981Z",
-  "agents": [
-    {
-      "name": "khaliqgant",
-      "role": "lead",
-      "joinedAt": "2026-01-10T04:02:25.985Z"
-    }
-  ],
-  "chapters": [
-    {
-      "id": "chap_18hrx02drpjk",
-      "title": "Work",
-      "agentName": "default",
-      "startedAt": "2026-01-10T04:20:27.656Z",
-      "events": [
-        {
-          "ts": 1768018827657,
-          "type": "decision",
-          "content": "Switched workspace SSH tunnel port to 3022: Switched workspace SSH tunnel port to 3022",
-          "raw": {
-            "question": "Switched workspace SSH tunnel port to 3022",
-            "chosen": "Switched workspace SSH tunnel port to 3022",
-            "alternatives": [],
-            "reasoning": "sshd failed to bind 2222 in workspace; moving default tunneling port avoids conflicts"
-          },
-          "significance": "high"
-        }
-      ]
-    }
-  ],
-  "commits": [],
-  "filesChanged": [],
-  "projectId": "/Users/khaliqgant/Projects/agent-workforce/relay",
-  "tags": []
-}

package/.trajectories/agent-relay-322-324.md

@@ -1,17 +0,0 @@
-# Trajectory: Fix agent-relay-322 and agent-relay-324
-
-> **Status:** 🔄 Active
-> **Task:** agent-relay-322,agent-relay-324
-> **Started:** January 6, 2026 at 01:36 PM
-
----
-
-## Chapters
-
-### 1. Initial work
-*Agent: Fullstack*
-
-- Added buildClaudeArgs call to spawner.ts spawn() method to apply model and --agent flags from agent profiles: Added buildClaudeArgs call to spawner.ts spawn() method to apply model and --agent flags from agent profiles
-- Created PR #80 for agent-relay-322. Now working on agent-relay-324 - replacing ps command with /proc parsing: Created PR #80 for agent-relay-322. Now working on agent-relay-324 - replacing ps command with /proc parsing
-- Replaced ps command with /proc/[pid]/status parsing. VmRSS line provides resident set size in kB. CPU% left at 0 since it requires time-based sampling.: Replaced ps command with /proc/[pid]/status parsing. VmRSS line provides resident set size in kB. CPU% left at 0 since it requires time-based sampling.
-