agent-relay 2.1.1 → 2.1.3

package/packages/wrapper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/wrapper",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "CLI agent wrappers for Agent Relay - tmux, pty integration",
   "type": "module",
   "main": "dist/index.js",
@@ -30,11 +30,11 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@agent-relay/api-types": "2.1.1",
-    "@agent-relay/protocol": "2.1.1",
-    "@agent-relay/config": "2.1.1",
-    "@agent-relay/continuity": "2.1.1",
-    "@agent-relay/resiliency": "2.1.1",
+    "@agent-relay/api-types": "2.1.3",
+    "@agent-relay/protocol": "2.1.3",
+    "@agent-relay/config": "2.1.3",
+    "@agent-relay/continuity": "2.1.3",
+    "@agent-relay/resiliency": "2.1.3",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/packages/wrapper/src/base-wrapper.ts

@@ -32,6 +32,7 @@ import {
   sortByPriority,
   getPriorityFromImportance,
   MESSAGE_PRIORITY,
+  shouldIgnoreForIdleDetection,
 } from './shared.js';
 import {
   DEFAULT_IDLE_BEFORE_INJECT_MS,
@@ -267,8 +268,22 @@ export abstract class BaseWrapper extends EventEmitter {
   /**
    * Feed output to the idle and stuck detectors.
    * Call this whenever new output is received from the agent.
+   *
+   * Note: Auto-suggestions (ghost text) are filtered out to prevent
+   * false idle resets. Claude Code and other CLIs show suggestions
+   * in gray/dim text with cursor save/restore, which should not
+   * be treated as "real" output for idle detection.
    */
   protected feedIdleDetectorOutput(output: string): void {
+    // Check if this output is likely an auto-suggestion (ghost text)
+    // Auto-suggestions should not reset the idle timer
+    if (shouldIgnoreForIdleDetection(output)) {
+      // Still feed to stuck detector - it strips ANSI and checks for patterns
+      // But don't feed to idle detector to avoid resetting the silence timer
+      this.stuckDetector.onOutput(output);
+      return;
+    }
+
     this.idleDetector.onOutput(output);
     this.stuckDetector.onOutput(output);
   }

package/packages/wrapper/src/shared.test.ts

@@ -13,7 +13,7 @@ describe('buildInjectionString', () => {
   };
 
   describe('sender name display', () => {
-    it('uses msg.from when from is not _DashboardUI', () => {
+    it('uses msg.from when from is not Dashboard', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
         from: 'RegularAgent',
@@ -22,40 +22,40 @@ describe('buildInjectionString', () => {
       expect(result).toContain('Relay message from RegularAgent');
     });
 
-    it('uses msg.from when from is _DashboardUI but no senderName in data', () => {
+    it('uses msg.from when from is Dashboard but no senderName in data', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
-        from: '_DashboardUI',
+        from: 'Dashboard',
       };
       const result = buildInjectionString(msg);
-      expect(result).toContain('Relay message from _DashboardUI');
+      expect(result).toContain('Relay message from Dashboard');
     });
 
-    it('uses senderName when from is _DashboardUI and senderName exists', () => {
+    it('uses senderName when from is Dashboard and senderName exists', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
-        from: '_DashboardUI',
+        from: 'Dashboard',
         data: { senderName: 'GitHubUser123' },
       };
       const result = buildInjectionString(msg);
       expect(result).toContain('Relay message from GitHubUser123');
-      expect(result).not.toContain('_DashboardUI');
+      expect(result).not.toContain('Dashboard');
     });
 
     it('uses msg.from when senderName is not a string', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
-        from: '_DashboardUI',
+        from: 'Dashboard',
         data: { senderName: 12345 }, // not a string
       };
       const result = buildInjectionString(msg);
-      expect(result).toContain('Relay message from _DashboardUI');
+      expect(result).toContain('Relay message from Dashboard');
     });
 
     it('uses msg.from when senderName is empty string', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
-        from: '_DashboardUI',
+        from: 'Dashboard',
         data: { senderName: '' },
       };
       // Empty string is falsy but still a string - our check uses typeof === 'string'
@@ -65,7 +65,7 @@ describe('buildInjectionString', () => {
       expect(result).toContain('Relay message from  ['); // empty between 'from' and '['
     });
 
-    it('does not use senderName when from is not _DashboardUI even if senderName exists', () => {
+    it('does not use senderName when from is not Dashboard even if senderName exists', () => {
       const msg: QueuedMessage = {
         ...baseMessage,
         from: 'OtherAgent',
@@ -320,3 +320,148 @@ describe('Message Priority System', () => {
     });
   });
 });
+
+// Import auto-suggestion detection functions for testing
+import { detectAutoSuggest, shouldIgnoreForIdleDetection } from './shared.js';
+
+describe('Auto-suggestion Detection', () => {
+  describe('detectAutoSuggest', () => {
+    it('detects dim text styling (common for ghost text)', () => {
+      // \x1B[2m is dim text
+      const output = '\x1B[2msuggested completion\x1B[0m';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(true);
+      expect(result.patterns).toContain('dim');
+      expect(result.confidence).toBeGreaterThanOrEqual(0.4);
+    });
+
+    it('detects bright black (dark gray) styling', () => {
+      // \x1B[90m is bright black (dark gray)
+      const output = '\x1B[90mauto-suggested text\x1B[0m';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(true);
+      expect(result.patterns).toContain('brightBlack');
+      expect(result.confidence).toBeGreaterThanOrEqual(0.4);
+    });
+
+    it('detects 256-color gray styling (pattern detected but alone not enough)', () => {
+      // \x1B[38;5;8m is 256-color dark gray
+      // By itself it only adds 0.3 confidence, below the 0.4 threshold
+      const output = '\x1B[38;5;8msuggestion\x1B[0m';
+      const result = detectAutoSuggest(output);
+
+      expect(result.patterns).toContain('gray256');
+      expect(result.confidence).toBeGreaterThan(0);
+      // 256-color gray alone isn't enough - need additional signals
+      expect(result.isAutoSuggest).toBe(false);
+    });
+
+    it('detects 256-color gray combined with other signals', () => {
+      // 256-color gray + cursor save/restore = strong signal
+      const output = '\x1B[s\x1B[38;5;8msuggestion\x1B[0m\x1B[u';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(true);
+      expect(result.patterns).toContain('gray256');
+      expect(result.patterns).toContain('cursorSaveRestore');
+    });
+
+    it('detects cursor save/restore pair (strong indicator)', () => {
+      // \x1B[s saves cursor, \x1B[u restores cursor
+      const output = '\x1B[s\x1B[90msuggestion\x1B[0m\x1B[u';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(true);
+      expect(result.patterns).toContain('cursorSaveRestore');
+      expect(result.confidence).toBeGreaterThanOrEqual(0.5);
+    });
+
+    it('detects alternative cursor save/restore (ESC 7/8)', () => {
+      // \x1B7 saves cursor, \x1B8 restores cursor (alternative format)
+      const output = '\x1B7\x1B[2mcompletion\x1B0m\x1B8';
+      const result = detectAutoSuggest(output);
+
+      expect(result.patterns).toContain('cursorSaveRestore');
+    });
+
+    it('returns false for normal text output', () => {
+      const output = 'Hello, this is normal output text\n';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(false);
+      expect(result.confidence).toBe(0);
+      expect(result.patterns).toHaveLength(0);
+    });
+
+    it('returns false for colored output without gray/dim', () => {
+      // Regular green text - not an auto-suggestion
+      const output = '\x1B[32mSuccess: Tests passed\x1B[0m';
+      const result = detectAutoSuggest(output);
+
+      expect(result.isAutoSuggest).toBe(false);
+    });
+
+    it('reduces confidence for multi-line output', () => {
+      // Auto-suggestions are typically single-line
+      const multiLine = '\x1B[90mLine 1\nLine 2\nLine 3\nLine 4\x1B[0m';
+      const result = detectAutoSuggest(multiLine);
+
+      // Still detects the pattern but confidence is reduced
+      expect(result.patterns).toContain('brightBlack');
+      // Multi-line reduces confidence by 50%
+      expect(result.confidence).toBeLessThan(0.4);
+    });
+
+    it('combines multiple patterns for higher confidence', () => {
+      // Both dim and cursor save/restore
+      const output = '\x1B[s\x1B[2m\x1B[90msuggestion\x1B[0m\x1B[u';
+      const result = detectAutoSuggest(output);
+
+      expect(result.patterns).toContain('dim');
+      expect(result.patterns).toContain('brightBlack');
+      expect(result.patterns).toContain('cursorSaveRestore');
+      expect(result.confidence).toBeGreaterThanOrEqual(0.8);
+    });
+
+    it('includes stripped content for debugging', () => {
+      const output = '\x1B[90msuggested text\x1B[0m';
+      const result = detectAutoSuggest(output);
+
+      expect(result.strippedContent).toBe('suggested text');
+    });
+  });
+
+  describe('shouldIgnoreForIdleDetection', () => {
+    it('ignores empty output', () => {
+      expect(shouldIgnoreForIdleDetection('')).toBe(true);
+    });
+
+    it('ignores output that is only ANSI control sequences', () => {
+      // Just cursor movement, no actual content
+      const output = '\x1B[2J\x1B[H'; // Clear screen and home cursor
+      expect(shouldIgnoreForIdleDetection(output)).toBe(true);
+    });
+
+    it('ignores auto-suggestion output', () => {
+      const autoSuggest = '\x1B[90mtype "exit" to quit\x1B[0m';
+      expect(shouldIgnoreForIdleDetection(autoSuggest)).toBe(true);
+    });
+
+    it('does not ignore normal text output', () => {
+      const normalOutput = 'Hello world\n';
+      expect(shouldIgnoreForIdleDetection(normalOutput)).toBe(false);
+    });
+
+    it('does not ignore colored output (non-gray)', () => {
+      const greenOutput = '\x1B[32mTest passed!\x1B[0m\n';
+      expect(shouldIgnoreForIdleDetection(greenOutput)).toBe(false);
+    });
+
+    it('does not ignore relay messages', () => {
+      const relayMessage = '->relay:Lead Task completed';
+      expect(shouldIgnoreForIdleDetection(relayMessage)).toBe(false);
+    });
+  });
+});

package/packages/wrapper/src/shared.ts

@@ -200,6 +200,158 @@ export function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * ANSI escape patterns for auto-suggestion (ghost text) detection.
+ *
+ * Claude Code and other CLIs show auto-suggestions using:
+ * - Dim text: \x1B[2m
+ * - Bright black (gray): \x1B[90m
+ * - 256-color gray: \x1B[38;5;8m or \x1B[38;5;240m through \x1B[38;5;250m
+ * - Cursor save/restore: \x1B[s / \x1B[u or \x1B7 / \x1B8
+ *
+ * Auto-suggestions are typically:
+ * 1. Styled with dim/gray text
+ * 2. Cursor position is saved before, restored after (so cursor doesn't advance)
+ * 3. The actual text content is the "ghost" suggestion
+ */
+// eslint-disable-next-line no-control-regex
+const AUTO_SUGGEST_PATTERNS = {
+  // Dim text styling - commonly used for ghost text
+  dim: /\x1B\[2m/,
+  // Bright black (dark gray) - common for suggestions
+  brightBlack: /\x1B\[90m/,
+  // 256-color grays (8 is dark gray, 240-250 are grays)
+  gray256: /\x1B\[38;5;(?:8|24[0-9]|250)m/,
+  // Cursor save (CSI s or ESC 7)
+  cursorSave: /\x1B\[s|\x1B7/,
+  // Cursor restore (CSI u or ESC 8)
+  cursorRestore: /\x1B\[u|\x1B8/,
+  // Italic text - sometimes used for suggestions
+  italic: /\x1B\[3m/,
+};
+
+/**
+ * Result of auto-suggestion detection.
+ */
+export interface AutoSuggestResult {
+  /** True if the output looks like an auto-suggestion */
+  isAutoSuggest: boolean;
+  /** Confidence level (0-1) */
+  confidence: number;
+  /** Which patterns were detected */
+  patterns: string[];
+  /** The actual content after stripping ANSI (for debugging) */
+  strippedContent?: string;
+}
+
+/**
+ * Detect if terminal output is likely an auto-suggestion (ghost text).
+ *
+ * Auto-suggestions should NOT reset the idle timer because they represent
+ * the CLI showing suggestions to the user, not actual output from the agent.
+ *
+ * Detection heuristics:
+ * 1. Contains dim/gray styling without other foreground colors
+ * 2. Has cursor save/restore patterns (suggestion doesn't advance cursor)
+ * 3. Stripped content is non-empty but doesn't contain relay commands
+ *
+ * @param output Raw terminal output including ANSI codes
+ * @returns Detection result with confidence and matched patterns
+ */
+export function detectAutoSuggest(output: string): AutoSuggestResult {
+  const patterns: string[] = [];
+  let confidence = 0;
+
+  // Check for dim styling (very common for ghost text)
+  if (AUTO_SUGGEST_PATTERNS.dim.test(output)) {
+    patterns.push('dim');
+    confidence += 0.4;
+  }
+
+  // Check for bright black (dark gray)
+  if (AUTO_SUGGEST_PATTERNS.brightBlack.test(output)) {
+    patterns.push('brightBlack');
+    confidence += 0.4;
+  }
+
+  // Check for 256-color gray
+  if (AUTO_SUGGEST_PATTERNS.gray256.test(output)) {
+    patterns.push('gray256');
+    confidence += 0.3;
+  }
+
+  // Check for italic (sometimes used for suggestions)
+  if (AUTO_SUGGEST_PATTERNS.italic.test(output)) {
+    patterns.push('italic');
+    confidence += 0.2;
+  }
+
+  // Check for cursor save/restore pair (strong indicator)
+  const hasCursorSave = AUTO_SUGGEST_PATTERNS.cursorSave.test(output);
+  const hasCursorRestore = AUTO_SUGGEST_PATTERNS.cursorRestore.test(output);
+
+  if (hasCursorSave && hasCursorRestore) {
+    patterns.push('cursorSaveRestore');
+    confidence += 0.5;
+  } else if (hasCursorSave || hasCursorRestore) {
+    patterns.push(hasCursorSave ? 'cursorSave' : 'cursorRestore');
+    confidence += 0.2;
+  }
+
+  // Cap confidence at 1.0
+  confidence = Math.min(confidence, 1.0);
+
+  // Strip ANSI to check actual content
+  const stripped = stripAnsi(output);
+
+  // If no patterns detected, it's not an auto-suggest
+  if (patterns.length === 0) {
+    return { isAutoSuggest: false, confidence: 0, patterns, strippedContent: stripped };
+  }
+
+  // Additional checks to reduce false positives:
+  // - Actual content should be relatively short (suggestions are typically one line)
+  // - Should not contain newlines (multi-line output is probably real output)
+  const lines = stripped.split('\n').filter(l => l.trim().length > 0);
+  if (lines.length > 2) {
+    // Multi-line content - less likely to be just a suggestion
+    confidence *= 0.5;
+  }
+
+  // Consider it an auto-suggest if confidence is above threshold
+  const isAutoSuggest = confidence >= 0.4;
+
+  return { isAutoSuggest, confidence, patterns, strippedContent: stripped };
+}
+
+/**
+ * Check if output should be ignored for idle detection purposes.
+ * Returns true if the output is likely an auto-suggestion or control sequence only.
+ *
+ * @param output Raw terminal output
+ * @returns true if output should be ignored for idle detection
+ */
+export function shouldIgnoreForIdleDetection(output: string): boolean {
+  // Empty output should be ignored
+  if (!output || output.length === 0) {
+    return true;
+  }
+
+  // Check if it's an auto-suggestion
+  const result = detectAutoSuggest(output);
+  if (result.isAutoSuggest) {
+    return true;
+  }
+
+  // Check if stripped content is empty (only control sequences)
+  const stripped = stripAnsi(output).trim();
+  if (stripped.length === 0) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Build the injection string for a relay message.
  * Format: Relay message from {from} [{shortId}]{hints}: {body}
@@ -221,9 +373,9 @@ export function buildInjectionString(msg: QueuedMessage): string {
 
   const shortId = msg.messageId.substring(0, 8);
 
-  // Use senderName from data if available (for dashboard messages sent via _DashboardUI)
+  // Use senderName from data if available (for dashboard messages sent via Dashboard)
   // This allows showing the actual GitHub username instead of the system client name
-  const displayFrom = (msg.from === '_DashboardUI' && typeof msg.data?.senderName === 'string')
+  const displayFrom = (msg.from === 'Dashboard' && typeof msg.data?.senderName === 'string')
     ? msg.data.senderName
     : msg.from;
 

package/packages/wrapper/src/tmux-wrapper.ts

@@ -1291,7 +1291,7 @@ export class TmuxWrapper extends BaseWrapper {
           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
+          // This ensures the message comes "from" this agent, not from Dashboard
           if (this.client.state === 'READY') {
             const sent = this.client.sendMessage(agentName, task, 'message');
             if (sent) {