crewly 1.3.31 → 1.4.0

package/dist/backend/backend/src/services/slack/slack-orchestrator-bridge.js

@@ -15,11 +15,10 @@ import { pipeline } from 'stream/promises';
 import { PDFParse } from 'pdf-parse';
 import { getSlackService } from './slack.service.js';
 import { getChatService } from '../chat/chat.service.js';
-import { isOrchestratorActive, getOrchestratorOfflineMessage, } from '../orchestrator/index.js';
+import { isOrchestratorActive, isAgentActive, getOrchestratorOfflineMessage, } from '../orchestrator/index.js';
 import { parseCommandIntent, } from '../../types/slack.types.js';
 import { getSlackImageService } from './slack-image.service.js';
-import { parseNotifyContent } from '../../types/chat.types.js';
-import { ORCHESTRATOR_SESSION_NAME, MESSAGE_QUEUE_CONSTANTS, SLACK_IMAGE_CONSTANTS, SLACK_FILE_DOWNLOAD_CONSTANTS, SLACK_BRIDGE_CONSTANTS } from '../../constants.js';
+import { ORCHESTRATOR_SESSION_NAME, MESSAGE_QUEUE_CONSTANTS, SLACK_IMAGE_CONSTANTS, SLACK_FILE_DOWNLOAD_CONSTANTS, SLACK_BRIDGE_CONSTANTS, AUDITOR_SCHEDULER_CONSTANTS } from '../../constants.js';
 import { LoggerService } from '../core/logger.service.js';
 /**
  * Default bridge configuration
@@ -61,14 +60,17 @@ export class SlackOrchestratorBridge extends EventEmitter {
     initialized = false;
     /** Track if we've already logged the missing scope warning */
     loggedMissingScope = false;
+    /**
+     * Pending completion reactions keyed by "channelId:threadTs".
+     * Stores the original message ts so that the ✅ reaction is added to the
+     * correct message when the reply-slack skill delivers a response.
+     */
+    pendingReactions = new Map();
     /**
      * Track channel+thread pairs where Slack delivery was already handled
      * by the reply-slack skill (execute.sh). Used by sendSlackResponse to
      * avoid sending a duplicate fallback message to the same thread.
      */
-    skillDeliveredThreads = new Set();
-    /** Maximum entries before evicting oldest skill delivery records */
-    static MAX_SKILL_DELIVERY_RECORDS = 50;
     /**
      * Create a new SlackOrchestratorBridge
      *
@@ -174,8 +176,8 @@ export class SlackOrchestratorBridge extends EventEmitter {
             }
             // Override message text with enriched version for downstream processing
             message.text = enrichedText;
-            // Auditor prefix routing — intercept "auditor ..." messages
-            const auditorMatch = enrichedText.match(/^\/?auditor\s+(.*)/is);
+            // Auditor prefix routing — intercept "auditor ...", "/auditor ...", or "@auditor ..." messages
+            const auditorMatch = enrichedText.match(/^[/@]?auditor[\s:]+(.+)/is);
             if (auditorMatch) {
                 const auditorMessage = auditorMatch[1].trim();
                 try {
@@ -197,6 +199,33 @@ export class SlackOrchestratorBridge extends EventEmitter {
                 }
                 return;
             }
+            // #177: @mention routing — route to specific agent if @name is detected
+            const mentionTarget = await this.resolveMentionTarget(enrichedText);
+            if (mentionTarget) {
+                const isActive = await isAgentActive(mentionTarget.sessionName);
+                if (isActive) {
+                    this.logger.info('Routing message to mentioned agent', {
+                        agent: mentionTarget.name,
+                        session: mentionTarget.sessionName,
+                    });
+                    if (this.config.showTypingIndicator) {
+                        await this.addTypingIndicator(message);
+                    }
+                    // Strip the @mention prefix and send to the target agent
+                    const cleanMessage = enrichedText.replace(new RegExp(`^@${mentionTarget.name}\\s*`, 'i'), '').trim();
+                    const response = await this.sendToAgent(mentionTarget.sessionName, cleanMessage || enrichedText, context);
+                    await this.sendSlackResponse(message, response);
+                    if (this.config.showTypingIndicator) {
+                        await this.markComplete(message);
+                    }
+                    return;
+                }
+                else {
+                    this.logger.info('Mentioned agent is inactive, falling back to orchestrator', {
+                        agent: mentionTarget.name,
+                    });
+                }
+            }
             // Parse command intent
             const command = this.parseCommand(message.text);
             // Add typing indicator
@@ -205,6 +234,7 @@ export class SlackOrchestratorBridge extends EventEmitter {
             }
             // Handle based on intent
             let response;
+            let isOrchestratorRoute = false;
             switch (command.intent) {
                 case 'help':
                     response = this.getHelpMessage();
@@ -224,11 +254,20 @@ export class SlackOrchestratorBridge extends EventEmitter {
                 default:
                     // Send to orchestrator for processing
                     response = await this.sendToOrchestrator(message.text, context);
+                    isOrchestratorRoute = true;
             }
             // Send response back to Slack
             await this.sendSlackResponse(message, response);
-            // Replace typing indicator with checkmark
-            if (this.config.showTypingIndicator) {
+            // For orchestrator-routed messages, defer ✅ until reply-slack delivers
+            // the actual response. Store pending reaction keyed by channel+thread
+            // so addCompletionReaction() can find it when the reply arrives.
+            if (isOrchestratorRoute && this.config.showTypingIndicator) {
+                const threadTs = message.threadTs || message.ts;
+                const key = `${message.channelId}:${threadTs}`;
+                this.pendingReactions.set(key, message.ts);
+            }
+            else if (this.config.showTypingIndicator) {
+                // Non-orchestrator commands complete immediately
                 await this.markComplete(message);
             }
             this.emit('message_handled', { message, response });
@@ -360,6 +399,13 @@ Just type naturally to chat with the orchestrator!`;
             // Check if orchestrator is active before attempting to send
             const isActive = await isOrchestratorActive();
             if (!isActive) {
+                // Fallback: route to Auditor agent if it's active
+                const auditorSession = AUDITOR_SCHEDULER_CONSTANTS.AUDITOR_SESSION_NAME;
+                const auditorActive = await isAgentActive(auditorSession);
+                if (auditorActive) {
+                    this.logger.info('Orchestrator offline — routing message to Auditor agent');
+                    return this.sendToAuditorFallback(message, context);
+                }
                 this.logger.info('Orchestrator is not active, returning offline message');
                 return getOrchestratorOfflineMessage(true);
             }
@@ -392,7 +438,7 @@ Just type naturally to chat with the orchestrator!`;
                 const timeoutId = setTimeout(() => {
                     if (!resolved) {
                         resolved = true;
-                        resolve('The orchestrator is taking longer than expected. Please try again.');
+                        resolve('The orchestrator is still processing your request. It will reply here when ready — no need to resend.');
                     }
                 }, this.config.responseTimeoutMs);
                 try {
@@ -428,6 +474,71 @@ Just type naturally to chat with the orchestrator!`;
             throw error;
         }
     }
+    /**
+     * Route a message to the Auditor agent as a fallback when the orchestrator is offline.
+     *
+     * Enqueues the message targeting the Auditor's session so the queue processor
+     * delivers it to the Auditor PTY instead of the orchestrator. Includes Slack
+     * context (channel, thread) so the Auditor can respond.
+     *
+     * @param message - Original user message
+     * @param context - Slack conversation context
+     * @returns Acknowledgement message to the user
+     */
+    async sendToAuditorFallback(message, context) {
+        const auditorSession = AUDITOR_SCHEDULER_CONSTANTS.AUDITOR_SESSION_NAME;
+        // Build a context-enriched message so the Auditor knows the source
+        const slackPrefix = context
+            ? `[SLACK_CONTEXT:channelId=${context.channelId},threadTs=${context.threadTs || ''}]`
+            : '';
+        const enrichedMessage = `${slackPrefix} [FALLBACK] Orchestrator is offline. User message:\n${message}`;
+        // Try to enqueue via the message queue (same path as orchestrator delivery)
+        if (this.messageQueueService) {
+            try {
+                // Store in chat history
+                const result = await this.chatService.sendMessage({
+                    content: enrichedMessage,
+                    conversationId: context?.conversationId,
+                    metadata: {
+                        source: 'slack',
+                        userId: context?.userId,
+                        channelId: context?.channelId,
+                    },
+                });
+                this.messageQueueService.enqueue({
+                    content: enrichedMessage,
+                    conversationId: result.conversation.id,
+                    source: 'slack',
+                    targetSession: auditorSession,
+                    sourceMetadata: {
+                        slackResolve: undefined,
+                        userId: context?.userId,
+                        channelId: context?.channelId,
+                    },
+                });
+                this.logger.info('Message routed to Auditor agent via queue', { auditorSession });
+                return 'The orchestrator is currently offline. Your message has been forwarded to the Auditor agent.';
+            }
+            catch (err) {
+                this.logger.error('Failed to route message to Auditor via queue', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        // Last resort: direct delivery via AuditorSchedulerService
+        try {
+            const { AuditorSchedulerService } = await import('../agent/auditor-scheduler.service.js');
+            const scheduler = AuditorSchedulerService.getInstance();
+            await scheduler.handleUserMessage(`[FALLBACK] Orchestrator is offline. User message: ${message}`, { channelId: context?.channelId || '', threadTs: context?.threadTs || '' });
+            return 'The orchestrator is currently offline. Your message has been forwarded to the Auditor agent.';
+        }
+        catch (err) {
+            this.logger.error('Failed to route message to Auditor via scheduler', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return getOrchestratorOfflineMessage(true);
+    }
     /**
      * Refresh file download URLs via the Slack files.info API.
      * The event payload URLs may not work with just the bot token — the
@@ -759,53 +870,43 @@ Just type naturally to chat with the orchestrator!`;
         }
     }
     /**
-     * Send response back to Slack with fallback delivery.
+     * Add ✅ completion reaction to a pending message.
      *
-     * Waits for the reply-slack skill to deliver via the skill pipeline.
-     * If the skill delivers (detected via markDeliveredBySkill), this method
-     * skips sending to avoid duplicates. If the skill does not deliver within
-     * the wait window, sends the response directly to Slack as a fallback.
+     * Called by the reply-slack API endpoint after successfully delivering
+     * the agent's response. Looks up the original user message ts from
+     * the pending reactions map (keyed by channelId:threadTs) and adds
+     * a white_check_mark reaction.
      *
-     * @param originalMessage - Original incoming message
-     * @param response - Response content
+     * @param channelId - Slack channel ID
+     * @param threadTs - Thread timestamp used in the reply
      */
-    async sendSlackResponse(originalMessage, response) {
-        // Record to thread store regardless of delivery path
-        await this.recordThreadReply(originalMessage, response);
-        // Skip empty responses
-        const trimmed = response?.trim();
-        if (!trimmed)
-            return;
-        // Wait for the reply-slack skill to deliver (it runs asynchronously in the PTY)
-        if (this.config.skillDeliveryWaitMs > 0) {
-            await new Promise(resolve => setTimeout(resolve, this.config.skillDeliveryWaitMs));
-        }
-        // Check if the reply-slack skill already delivered to this thread
-        const threadTs = originalMessage.threadTs || originalMessage.ts;
-        if (this.wasDeliveredBySkill(originalMessage.channelId, threadTs)) {
-            this.logger.info('Slack reply already delivered by skill, skipping fallback');
+    async addCompletionReaction(channelId, threadTs) {
+        const key = `${channelId}:${threadTs}`;
+        const originalMessageTs = this.pendingReactions.get(key);
+        if (!originalMessageTs) {
             return;
         }
-        // Fallback: send the response directly to Slack
+        this.pendingReactions.delete(key);
         try {
-            this.logger.info('reply-slack skill did not deliver, sending fallback response to Slack');
-            const sanitized = this.sanitizeForSlack(trimmed);
-            if (!sanitized) {
-                this.logger.info('Fallback response empty after sanitization, skipping Slack send');
-                return;
-            }
-            await this.slackService.sendMessage({
-                channelId: originalMessage.channelId,
-                text: sanitized,
-                threadTs,
-            });
+            await this.slackService.addReaction(channelId, originalMessageTs, 'white_check_mark');
         }
-        catch (err) {
-            this.logger.error('Fallback Slack delivery failed', {
-                error: err instanceof Error ? err.message : String(err),
-            });
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!errorMessage.includes('missing_scope') && !errorMessage.includes('already_reacted')) {
+                this.logger.warn('Could not add deferred completion reaction', { error: errorMessage });
+            }
         }
     }
+    /**
+     * Record response to thread store. Slack delivery is handled exclusively
+     * by the reply-slack skill via the API — no terminal output fallback needed.
+     *
+     * @param originalMessage - Original incoming message
+     * @param response - Response content
+     */
+    async sendSlackResponse(originalMessage, response) {
+        await this.recordThreadReply(originalMessage, response);
+    }
     /**
      * Send error response
      *
@@ -837,125 +938,6 @@ Just type naturally to chat with the orchestrator!`;
         formatted = formatted.replace(/```[\w]*\n([\s\S]*?)```/g, '```$1```');
         return formatted;
     }
-    /**
-     * Extract [NOTIFY] payloads from orchestrator output.
-     */
-    extractNotifyPayloads(text) {
-        if (!text)
-            return [];
-        const payloads = [];
-        const notifyPattern = /\[NOTIFY\]([\s\S]*?)\[\/NOTIFY\]/g;
-        let match;
-        while ((match = notifyPattern.exec(text)) !== null) {
-            const payload = parseNotifyContent(match[1]);
-            if (payload) {
-                payloads.push(payload);
-            }
-        }
-        return payloads;
-    }
-    /**
-     * Determine whether the response already triggered a Slack delivery via NOTIFY.
-     */
-    findSlackPayloadForMessage(message, payloads) {
-        const targetChannel = message.channelId;
-        const targetThread = message.threadTs || message.ts;
-        return payloads.find((payload) => {
-            if (!payload.channelId || payload.channelId !== targetChannel) {
-                return false;
-            }
-            if (payload.threadTs && targetThread && payload.threadTs !== targetThread) {
-                return false;
-            }
-            return Boolean(payload.message && payload.message.trim());
-        });
-    }
-    /**
-     * Sanitize raw terminal output for Slack delivery.
-     *
-     * Strips NOTIFY markers/headers, Claude Code UI elements (satisfaction survey,
-     * permission prompts, status bar), Gemini CLI TUI elements, box-drawing
-     * decoration, and orphaned ANSI sequences.
-     *
-     * @param raw - Raw terminal text
-     * @returns Cleaned text suitable for Slack, or empty string if nothing meaningful remains
-     */
-    sanitizeForSlack(raw) {
-        return raw
-            // Strip [NOTIFY] / [/NOTIFY] tags
-            .replace(/\[\/?NOTIFY\]/g, '')
-            // Strip NOTIFY metadata headers
-            .replace(/^conversationId:.*$/gm, '')
-            .replace(/^channelId:.*$/gm, '')
-            .replace(/^threadTs:.*$/gm, '')
-            .replace(/^type:.*$/gm, '')
-            .replace(/^title:.*$/gm, '')
-            .replace(/^urgency:.*$/gm, '')
-            .replace(/^---$/gm, '')
-            // Strip Claude Code UI elements
-            .replace(/^.*How is Claude doing this session\?.*$/gm, '')
-            .replace(/^.*\d:\s*Bad\s+\d:\s*Fine\s+\d:\s*Good\s+\d:\s*Dismiss.*$/gm, '')
-            .replace(/^.*bypass permissions on.*$/gm, '')
-            .replace(/^.*shift\+tab to cycle.*$/gm, '')
-            .replace(/^.*esc to (?:interrupt|cancel|\.\.\.).*$/gmi, '')
-            .replace(/^.*Use meta\+t to toggle.*$/gmi, '')
-            .replace(/^.*ctrl\+g to edi.*$/gmi, '')
-            .replace(/^.*Osmosing.*$/gm, '')
-            .replace(/^.*✻ Baked for.*$/gm, '')
-            .replace(/^.*✢ Osmosing.*$/gm, '')
-            .replace(/^.*running stop hook.*$/gmi, '')
-            // Strip Claude Code tool indicators and prompt markers
-            .replace(/^[⏺⏵❯✻✢✽●·]\s*$/gm, '')
-            .replace(/^[⏺⏵]\s+.*$/gm, '')
-            // Strip Gemini CLI TUI elements
-            .replace(/^.*(?:Type\s+your\s+message|YOLO\s+mode|no\s+sandbox|context\s+left\)).*$/gmi, '')
-            .replace(/^.*(?:Initiating\s+File\s+Inspection).*$/gmi, '')
-            // Strip TUI box-drawing border characters
-            .replace(/^[\s│┃║|]+|[\s│┃║|]+$/gm, '')
-            // Remove pure decoration lines (corners, horizontal rules, dots)
-            .replace(/^[─━┄┅┈┉╌╍═┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬╭╮╰╯\-+\s▪▫■□●○◆◇•·]+$/gm, '')
-            // Strip orphaned ANSI CSI sequences
-            .replace(/\[\d+(?:;\d+)*[A-BJKHfm]/g, '')
-            // Strip CHAT: session header lines
-            .replace(/^.*\[CHAT:slack-[^\]]+\].*$/gm, '')
-            // Strip thread context file lines
-            .replace(/^\[Thread context file:.*\]$/gm, '')
-            // Collapse multiple blank lines
-            .replace(/\n{3,}/g, '\n\n')
-            .trim();
-    }
-    /**
-     * Build a Slack-friendly fallback response when no NOTIFY payload targeted Slack.
-     */
-    buildFallbackResponse(raw, payloads) {
-        const chatMessages = payloads
-            .filter((payload) => payload.message && !payload.channelId)
-            .map((payload) => payload.message.trim())
-            .filter(Boolean);
-        if (chatMessages.length > 0) {
-            return chatMessages.join('\n\n');
-        }
-        const cleaned = raw
-            .replace(/\[\/?NOTIFY\]/g, '')
-            .replace(/^conversationId:.*$/gm, '')
-            .replace(/^channelId:.*$/gm, '')
-            .replace(/^threadTs:.*$/gm, '')
-            .replace(/^type:.*$/gm, '')
-            .replace(/^title:.*$/gm, '')
-            .replace(/^urgency:.*$/gm, '')
-            .replace(/^---$/gm, '')
-            // Strip TUI box-drawing border characters from Gemini CLI output
-            .replace(/^[\s│┃║|]+|[\s│┃║|]+$/gm, '')
-            // Remove pure decoration lines (corners, horizontal rules)
-            .replace(/^[─━┄┅┈┉╌╍═┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬╭╮╰╯\-+\s]+$/gm, '')
-            // Strip orphaned multi-param ANSI CSI sequences (e.g. [38;2;249;226;175m)
-            .replace(/\[\d+(?:;\d+)*[A-BJKHfm]/g, '')
-            // Remove Gemini CLI TUI elements that leak into output
-            .replace(/^.*(?:Type\s+your\s+message|YOLO\s+mode|no\s+sandbox|context\s+left\)).*$/gmi, '')
-            .replace(/^.*(?:esc\s+to\s+cancel|Initiating\s+File\s+Inspection).*$/gmi, '')
-            .trim();
-        return cleaned;
-    }
     /**
      * Persist Slack reply content to the thread store when available.
      */
@@ -975,40 +957,6 @@ Just type naturally to chat with the orchestrator!`;
             this.logger.warn('Failed to store thread reply', { error: err instanceof Error ? err.message : String(err) });
         }
     }
-    /**
-     * Mark a channel+thread pair as already delivered to Slack by the reply-slack skill.
-     * Called by TerminalGateway.handleNotifyPayload when a slack_reply NOTIFY is processed.
-     *
-     * @param channelId - Slack channel ID
-     * @param threadTs - Thread timestamp (optional)
-     */
-    markDeliveredBySkill(channelId, threadTs) {
-        const key = `${channelId}:${threadTs || ''}`;
-        this.skillDeliveredThreads.add(key);
-        // Evict oldest entries if set is too large
-        if (this.skillDeliveredThreads.size > SlackOrchestratorBridge.MAX_SKILL_DELIVERY_RECORDS) {
-            const first = this.skillDeliveredThreads.values().next().value;
-            if (first !== undefined) {
-                this.skillDeliveredThreads.delete(first);
-            }
-        }
-    }
-    /**
-     * Check if a channel+thread pair was already delivered by the reply-slack skill.
-     *
-     * @param channelId - Slack channel ID
-     * @param threadTs - Thread timestamp (optional)
-     * @returns true if delivery was already handled by the skill
-     */
-    wasDeliveredBySkill(channelId, threadTs) {
-        const key = `${channelId}:${threadTs || ''}`;
-        if (this.skillDeliveredThreads.has(key)) {
-            // Remove after check to avoid permanent blocking of future replies to same thread
-            this.skillDeliveredThreads.delete(key);
-            return true;
-        }
-        return false;
-    }
     /**
      * Send proactive notification to Slack
      *
@@ -1084,6 +1032,123 @@ Just type naturally to chat with the orchestrator!`;
             timestamp: new Date().toISOString(),
         });
     }
+    /**
+     * Resolve @mention in message text to an agent session (#177).
+     *
+     * Matches patterns: @assistant, @auditor, @sam, @leo, etc.
+     * Looks up the agent name in team configs to find the session name.
+     *
+     * @param text - Message text to scan for @mentions
+     * @returns Target agent info, or null if no mention found
+     */
+    async resolveMentionTarget(text) {
+        // Match @name at the start of the message
+        const mentionMatch = text.match(/^@(\w+)\s/i);
+        if (!mentionMatch)
+            return null;
+        const mentionedName = mentionMatch[1].toLowerCase();
+        // Built-in aliases
+        const aliases = {
+            assistant: 'crewly-orc-assistant',
+            auditor: 'crewly-auditor',
+            orc: 'crewly-orc',
+            orchestrator: 'crewly-orc',
+        };
+        if (aliases[mentionedName]) {
+            return { name: mentionedName, sessionName: aliases[mentionedName] };
+        }
+        // Look up in team configs
+        try {
+            const StorageService = (await import('../core/storage.service.js')).StorageService;
+            const storage = StorageService.getInstance();
+            const teams = await storage.getTeams();
+            for (const team of teams) {
+                for (const member of (team.members || [])) {
+                    // Match by name (case-insensitive) or session name fragment
+                    const memberName = member.name?.toLowerCase() || '';
+                    const sessionParts = (member.sessionName || '').split('-');
+                    const shortName = sessionParts.length >= 3 ? sessionParts[2] : '';
+                    if (memberName === mentionedName || shortName === mentionedName) {
+                        return { name: mentionedName, sessionName: member.sessionName };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn('Failed to look up mention target', {
+                mention: mentionedName,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return null;
+    }
+    /**
+     * Send a message to a specific agent session via terminal deliver (#177).
+     *
+     * @param sessionName - Target agent session
+     * @param message - Message to send
+     * @param context - Slack context for response routing
+     * @returns Agent response text
+     */
+    async sendToAgent(sessionName, message, context) {
+        try {
+            // Enrich with Slack context for reply routing
+            let enrichedMessage = message;
+            if (context) {
+                enrichedMessage = `[SLACK_CONTEXT:channelId=${context.channelId},threadTs=${context.threadTs || ''}]\n${message}`;
+            }
+            // Use message queue for agents that support it, or deliver directly
+            if (this.messageQueueService) {
+                const chatResult = await this.chatService.sendMessage({
+                    content: enrichedMessage,
+                    conversationId: context?.conversationId,
+                    metadata: { source: 'slack', channelId: context?.channelId },
+                });
+                return new Promise((resolve) => {
+                    let resolved = false;
+                    const timeoutId = setTimeout(() => {
+                        if (!resolved) {
+                            resolved = true;
+                            resolve('Agent is processing your message. Check back shortly.');
+                        }
+                    }, this.config.responseTimeoutMs);
+                    this.messageQueueService.enqueue({
+                        content: enrichedMessage,
+                        conversationId: chatResult.conversation.id,
+                        source: 'slack',
+                        targetSession: sessionName,
+                        sourceMetadata: {
+                            slackResolve: (resp) => {
+                                if (!resolved) {
+                                    resolved = true;
+                                    clearTimeout(timeoutId);
+                                    resolve(resp);
+                                }
+                            },
+                            channelId: context?.channelId,
+                            threadTs: context?.threadTs,
+                        },
+                    });
+                });
+            }
+            // Fallback: direct terminal delivery
+            const { default: fetch } = await import('node-fetch').catch(() => ({ default: globalThis.fetch }));
+            const apiUrl = process.env.CREWLY_API_URL || 'http://localhost:8787';
+            await fetch(`${apiUrl}/api/terminal/${sessionName}/deliver`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message: enrichedMessage, force: true }),
+            });
+            return 'Message delivered to agent. Response will arrive shortly.';
+        }
+        catch (err) {
+            this.logger.error('Failed to send to agent', {
+                session: sessionName,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return `Failed to reach agent. Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
 }
 /**
  * Get bridge singleton