crewly 1.0.0

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

@@ -0,0 +1,806 @@
+/**
+ * Slack-Orchestrator Bridge
+ *
+ * Routes messages between Slack and the Crewly orchestrator,
+ * enabling mobile control of AI teams.
+ *
+ * @module services/slack/bridge
+ */
+import { EventEmitter } from 'events';
+import { getSlackService } from './slack.service.js';
+import { getChatService } from '../chat/chat.service.js';
+import { isOrchestratorActive, 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_BRIDGE_CONSTANTS } from '../../constants.js';
+/**
+ * Default bridge configuration
+ */
+const DEFAULT_CONFIG = {
+    orchestratorSession: ORCHESTRATOR_SESSION_NAME,
+    showTypingIndicator: true,
+    maxResponseLength: 3000,
+    enableNotifications: true,
+    responseTimeoutMs: MESSAGE_QUEUE_CONSTANTS.DEFAULT_MESSAGE_TIMEOUT + 5000,
+    skillDeliveryWaitMs: SLACK_BRIDGE_CONSTANTS.SKILL_DELIVERY_WAIT_MS,
+};
+/**
+ * Slack-Orchestrator Bridge singleton
+ */
+let bridgeInstance = null;
+/**
+ * SlackOrchestratorBridge class
+ *
+ * Routes messages between Slack and the Crewly orchestrator.
+ * Handles command parsing, response formatting, and proactive notifications.
+ *
+ * @example
+ * ```typescript
+ * const bridge = getSlackOrchestratorBridge();
+ * await bridge.initialize();
+ *
+ * // Send notification when task completes
+ * await bridge.notifyTaskCompleted('Fix bug', 'Developer', 'MyProject');
+ * ```
+ */
+export class SlackOrchestratorBridge extends EventEmitter {
+    slackService;
+    chatService;
+    messageQueueService = null;
+    threadStore = null;
+    config;
+    initialized = false;
+    /** Track if we've already logged the missing scope warning */
+    loggedMissingScope = false;
+    /**
+     * 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
+     *
+     * @param config - Partial configuration to override defaults
+     */
+    constructor(config = {}) {
+        super();
+        this.slackService = getSlackService();
+        this.chatService = getChatService();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Initialize the bridge
+     *
+     * Sets up message listeners and orchestrator subscriptions.
+     *
+     * @returns Promise that resolves when initialized
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Listen for Slack messages
+        this.slackService.on('message', this.handleSlackMessage.bind(this));
+        this.initialized = true;
+        console.log('[SlackBridge] Initialized');
+    }
+    /**
+     * Check if bridge is initialized
+     *
+     * @returns True if initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Set the message queue service for enqueuing messages to the orchestrator.
+     * Called during server initialization.
+     *
+     * @param service - The MessageQueueService instance
+     */
+    setMessageQueueService(service) {
+        this.messageQueueService = service;
+    }
+    /**
+     * Set the Slack thread store service for persisting thread conversations.
+     * Called during server initialization.
+     *
+     * @param store - The SlackThreadStoreService instance
+     */
+    setSlackThreadStore(store) {
+        this.threadStore = store;
+    }
+    /**
+     * Get current configuration
+     *
+     * @returns A copy of the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Handle incoming Slack message
+     *
+     * Parses the command, routes to appropriate handler, and sends response.
+     *
+     * @param message - Incoming Slack message
+     */
+    async handleSlackMessage(message) {
+        console.log(`[SlackBridge] Received message: ${(message.text || '').substring(0, 50)}${message.hasImages ? ` [+${message.files?.length || 0} image(s)]` : ''}...`);
+        try {
+            // Download images if present
+            if (message.hasImages && message.files) {
+                await this.downloadMessageImages(message);
+            }
+            // Get or create conversation context
+            const context = this.slackService.getConversationContext(message.threadTs || message.ts, message.channelId, message.userId);
+            // Build enriched text with image references for the agent
+            const enrichedText = this.enrichTextWithImages(message);
+            // Store inbound message in thread file (with image metadata)
+            if (this.threadStore) {
+                const threadTs = message.threadTs || message.ts;
+                try {
+                    const userName = message.user?.realName || message.user?.name || message.userId;
+                    await this.threadStore.appendUserMessage(message.channelId, threadTs, userName, enrichedText, message.images);
+                }
+                catch (err) {
+                    console.warn('[SlackBridge] Failed to store thread message:', err instanceof Error ? err.message : String(err));
+                }
+            }
+            // Override message text with enriched version for downstream processing
+            message.text = enrichedText;
+            // Parse command intent
+            const command = this.parseCommand(message.text);
+            // Add typing indicator
+            if (this.config.showTypingIndicator) {
+                await this.addTypingIndicator(message);
+            }
+            // Handle based on intent
+            let response;
+            switch (command.intent) {
+                case 'help':
+                    response = this.getHelpMessage();
+                    break;
+                case 'status':
+                    response = await this.handleStatusCommand(command, context);
+                    break;
+                case 'list_projects':
+                case 'list_teams':
+                case 'list_agents':
+                    response = await this.handleListCommand(command, context);
+                    break;
+                case 'pause':
+                case 'resume':
+                    response = await this.handleControlCommand(command, context);
+                    break;
+                default:
+                    // Send to orchestrator for processing
+                    response = await this.sendToOrchestrator(message.text, context);
+            }
+            // Send response back to Slack
+            await this.sendSlackResponse(message, response);
+            // Replace typing indicator with checkmark
+            if (this.config.showTypingIndicator) {
+                await this.markComplete(message);
+            }
+            this.emit('message_handled', { message, response });
+        }
+        catch (error) {
+            console.error('[SlackBridge] Error handling message:', error);
+            await this.sendErrorResponse(message, error);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Parse command from message text
+     *
+     * Cleans the message and extracts the command intent.
+     *
+     * @param text - Raw message text
+     * @returns Parsed command with intent and parameters
+     */
+    parseCommand(text) {
+        // Remove bot mention if present
+        const cleanedText = text.replace(/<@[A-Z0-9]+>/g, '').trim();
+        return {
+            intent: parseCommandIntent(cleanedText),
+            rawText: cleanedText,
+            parameters: this.extractParameters(cleanedText),
+        };
+    }
+    /**
+     * Extract parameters from command text
+     *
+     * @param text - Command text
+     * @returns Extracted parameters
+     */
+    extractParameters(text) {
+        const params = {};
+        // Extract quoted strings
+        const quotedMatch = text.match(/"([^"]+)"/);
+        if (quotedMatch) {
+            params.quoted = quotedMatch[1];
+        }
+        // Extract @mentions
+        const mentionMatch = text.match(/@(\w+)/);
+        if (mentionMatch) {
+            params.mention = mentionMatch[1];
+        }
+        // Extract project/team names after keywords
+        const forMatch = text.match(/(?:for|on|in)\s+(\w+)/i);
+        if (forMatch) {
+            params.target = forMatch[1];
+        }
+        return params;
+    }
+    /**
+     * Get help message
+     *
+     * @returns Formatted help message for Slack
+     */
+    getHelpMessage() {
+        return `*Crewly Commands:*
+
+:clipboard: *Status*
+• \`status\` - Get overall status
+• \`status [project name]\` - Get project status
+• \`how is [team] doing\` - Get team progress
+
+:page_facing_up: *Lists*
+• \`list projects\` - Show all projects
+• \`list teams\` - Show all teams
+• \`list agents\` or \`who's working\` - Show active agents
+
+:gear: *Actions*
+• \`assign [task] to [agent/team]\` - Assign work
+• \`create task: [description]\` - Create a new task
+• \`pause [agent/team]\` - Pause work
+• \`resume [agent/team]\` - Resume work
+
+:speech_balloon: *Chat*
+Just type naturally to chat with the orchestrator!`;
+    }
+    /**
+     * Handle status command
+     *
+     * @param command - Parsed command
+     * @param context - Conversation context
+     * @returns Status response
+     */
+    async handleStatusCommand(command, context) {
+        return await this.sendToOrchestrator(`Give me a brief status update. ${command.rawText}`, context);
+    }
+    /**
+     * Handle list commands (projects, teams, agents)
+     *
+     * @param command - Parsed command
+     * @param context - Conversation context
+     * @returns List response
+     */
+    async handleListCommand(command, context) {
+        const prompts = {
+            list_projects: 'List all active projects with their status.',
+            list_teams: 'List all teams and their current assignments.',
+            list_agents: 'List all agents, their status, and what they are working on.',
+        };
+        return await this.sendToOrchestrator(prompts[command.intent] || command.rawText, context);
+    }
+    /**
+     * Handle control commands (pause, resume)
+     *
+     * @param command - Parsed command
+     * @param context - Conversation context
+     * @returns Control response
+     */
+    async handleControlCommand(command, context) {
+        const action = command.intent === 'pause' ? 'Pause' : 'Resume';
+        const target = command.parameters.target || command.parameters.mention || 'all agents';
+        return await this.sendToOrchestrator(`${action} ${target}.`, context);
+    }
+    /**
+     * Send message to orchestrator via the message queue and wait for response.
+     *
+     * Checks if the orchestrator is active before sending. Enqueues the message
+     * and waits for the response via a resolve callback injected into sourceMetadata.
+     *
+     * @param message - Message to send
+     * @param context - Optional conversation context
+     * @returns Orchestrator response or offline/error message
+     */
+    async sendToOrchestrator(message, context) {
+        try {
+            // Check if orchestrator is active before attempting to send
+            const isActive = await isOrchestratorActive();
+            if (!isActive) {
+                console.log('[SlackBridge] Orchestrator is not active, returning offline message');
+                return getOrchestratorOfflineMessage(true);
+            }
+            // Check if message queue service is available
+            if (!this.messageQueueService) {
+                console.error('[SlackBridge] Message queue service not configured');
+                return 'The Slack bridge is not properly configured. Please restart the server.';
+            }
+            // Enrich message with thread file path hint for orchestrator context
+            let enrichedMessage = message;
+            if (this.threadStore && context) {
+                const threadFilePath = this.threadStore.getThreadFilePath(context.channelId, context.threadTs);
+                enrichedMessage = `${message}\n\n[Thread context file: ${threadFilePath}]`;
+            }
+            // Send message via chat service to store it
+            const result = await this.chatService.sendMessage({
+                content: enrichedMessage,
+                conversationId: context?.conversationId,
+                metadata: {
+                    source: 'slack',
+                    userId: context?.userId,
+                    channelId: context?.channelId,
+                },
+            });
+            // Enqueue the message with a resolve callback for response routing.
+            // The QueueProcessorService will call slackResolve() when the
+            // orchestrator responds, unblocking this promise.
+            const response = await new Promise((resolve) => {
+                const timeoutId = setTimeout(() => {
+                    resolve('The orchestrator is taking longer than expected. Please try again.');
+                }, this.config.responseTimeoutMs);
+                try {
+                    this.messageQueueService.enqueue({
+                        content: enrichedMessage,
+                        conversationId: result.conversation.id,
+                        source: 'slack',
+                        sourceMetadata: {
+                            slackResolve: (resp) => {
+                                clearTimeout(timeoutId);
+                                resolve(resp);
+                            },
+                            userId: context?.userId,
+                            channelId: context?.channelId,
+                        },
+                    });
+                }
+                catch (enqueueErr) {
+                    clearTimeout(timeoutId);
+                    resolve(`Failed to enqueue message: ${enqueueErr instanceof Error ? enqueueErr.message : String(enqueueErr)}`);
+                }
+            });
+            return response;
+        }
+        catch (error) {
+            console.error('[SlackBridge] Error sending to orchestrator:', error);
+            throw error;
+        }
+    }
+    /**
+     * Download all image files from a Slack message using SlackImageService.
+     * Populates `message.images` with successfully downloaded image info.
+     * Downloads are batched with a concurrency limit of MAX_CONCURRENT_DOWNLOADS.
+     *
+     * @param message - Incoming message with files to download
+     */
+    async downloadMessageImages(message) {
+        const botToken = this.slackService.getBotToken();
+        if (!botToken) {
+            console.warn('[SlackBridge] Cannot download images: no bot token available');
+            return;
+        }
+        if (!message.files || message.files.length === 0) {
+            return;
+        }
+        const slackImageService = getSlackImageService();
+        const files = message.files;
+        const downloadedImages = [];
+        const maxConcurrent = SLACK_IMAGE_CONSTANTS.MAX_CONCURRENT_DOWNLOADS;
+        const rejectionMessages = [];
+        // Refresh file URLs via files.info API before downloading.
+        // The event payload URLs may not work with just the bot token — the
+        // files.info API returns authenticated URLs and also validates that
+        // the bot has the required files:read scope.
+        for (const file of files) {
+            try {
+                const freshInfo = await this.slackService.getFileInfo(file.id);
+                if (freshInfo.url_private_download) {
+                    file.url_private_download = freshInfo.url_private_download;
+                }
+                if (freshInfo.url_private) {
+                    file.url_private = freshInfo.url_private;
+                }
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (errMsg.includes('missing_scope') || errMsg.includes('not_allowed_token_type')) {
+                    console.error('[SlackBridge] Bot token lacks files:read scope — cannot download images. ' +
+                        'Please add the "files:read" scope to your Slack app at https://api.slack.com/apps and reinstall.');
+                    return; // Skip all downloads — scope is missing for all files
+                }
+                // For other errors (e.g. file_not_found), continue with original URL
+                console.warn(`[SlackBridge] Could not refresh URL for ${file.name} via files.info:`, errMsg);
+            }
+        }
+        for (let i = 0; i < files.length; i += maxConcurrent) {
+            const batch = files.slice(i, i + maxConcurrent);
+            const results = await Promise.allSettled(batch.map((file) => slackImageService.downloadImage(file, botToken)));
+            for (let j = 0; j < results.length; j++) {
+                const result = results[j];
+                if (result.status === 'fulfilled') {
+                    downloadedImages.push(result.value);
+                }
+                else {
+                    const fileName = batch[j].name;
+                    const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                    console.warn(`[SlackBridge] Failed to download image ${fileName}:`, reason);
+                    // Track files rejected due to validation (size/type) to warn the Slack user.
+                    // These match the error prefixes from SlackImageService.downloadImage().
+                    if (reason.startsWith('File too large:') || reason.startsWith('Unsupported image type:')) {
+                        rejectionMessages.push(`${fileName}: ${reason}`);
+                    }
+                }
+            }
+        }
+        if (downloadedImages.length > 0) {
+            message.images = downloadedImages;
+        }
+        // Send a warning back to Slack if any files were rejected
+        if (rejectionMessages.length > 0) {
+            try {
+                const maxMB = Math.round(SLACK_IMAGE_CONSTANTS.MAX_FILE_SIZE / (1024 * 1024));
+                const supportedTypes = SLACK_IMAGE_CONSTANTS.SUPPORTED_MIMES.map(m => m.replace('image/', '').toUpperCase()).join(', ');
+                const warningText = `:warning: Some image(s) could not be processed:\n${rejectionMessages.map(f => `• ${f}`).join('\n')}\n\nSupported types: ${supportedTypes}. Max size: ${maxMB} MB.`;
+                await this.slackService.sendMessage({
+                    channelId: message.channelId,
+                    text: warningText,
+                    threadTs: message.threadTs || message.ts,
+                });
+            }
+            catch (err) {
+                console.warn('[SlackBridge] Failed to send rejection warning to Slack:', err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+    /**
+     * Enrich message text with image file path references so agents
+     * can read them via their file-reading tools (Claude Code Read, Gemini @file).
+     *
+     * @param message - Message with optional downloaded images
+     * @returns Enriched text with image references appended
+     */
+    enrichTextWithImages(message) {
+        let text = message.text || '';
+        if (message.images && message.images.length > 0) {
+            for (const img of message.images) {
+                const dims = img.width && img.height ? ` (${img.width}x${img.height})` : '';
+                text += `\n[Slack Image: ${img.localPath}${dims}, ${img.mimetype}]`;
+            }
+        }
+        return text;
+    }
+    /**
+     * Add typing indicator to message
+     *
+     * @param message - Message to add indicator to
+     */
+    async addTypingIndicator(message) {
+        try {
+            await this.slackService.addReaction(message.channelId, message.ts, 'eyes');
+        }
+        catch (error) {
+            // Non-critical - reactions require 'reactions:write' scope which is optional
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('missing_scope')) {
+                // Only log once about missing scope, not on every message
+                if (!this.loggedMissingScope) {
+                    console.warn('[SlackBridge] Reactions disabled - add reactions:write scope to Slack app for typing indicators');
+                    this.loggedMissingScope = true;
+                }
+            }
+            else {
+                console.warn('[SlackBridge] Could not add typing indicator:', errorMessage);
+            }
+        }
+    }
+    /**
+     * Mark message as complete
+     *
+     * @param message - Message to mark complete
+     */
+    async markComplete(message) {
+        try {
+            await this.slackService.addReaction(message.channelId, message.ts, 'white_check_mark');
+        }
+        catch (error) {
+            // Non-critical - reactions require 'reactions:write' scope which is optional
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!errorMessage.includes('missing_scope')) {
+                console.warn('[SlackBridge] Could not add completion indicator:', errorMessage);
+            }
+            // Silent fail for missing_scope since we already logged about it
+        }
+    }
+    /**
+     * Send response back to Slack with fallback delivery.
+     *
+     * 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.
+     *
+     * @param originalMessage - Original incoming message
+     * @param response - Response content
+     */
+    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)) {
+            console.log('[SlackBridge] Slack reply already delivered by skill, skipping fallback');
+            return;
+        }
+        // Fallback: send the response directly to Slack
+        try {
+            console.log('[SlackBridge] reply-slack skill did not deliver, sending fallback response to Slack');
+            await this.slackService.sendMessage({
+                channelId: originalMessage.channelId,
+                text: trimmed,
+                threadTs,
+            });
+        }
+        catch (err) {
+            console.error('[SlackBridge] Fallback Slack delivery failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Send error response
+     *
+     * @param message - Original message
+     * @param error - Error that occurred
+     */
+    async sendErrorResponse(message, error) {
+        await this.slackService.sendMessage({
+            channelId: message.channelId,
+            text: `:warning: Sorry, I encountered an error: ${error.message}`,
+            threadTs: message.threadTs || message.ts,
+        });
+    }
+    /**
+     * Format response for Slack
+     *
+     * Converts markdown to Slack-compatible formatting.
+     *
+     * @param text - Text to format
+     * @returns Formatted text
+     */
+    formatForSlack(text) {
+        // Convert markdown headers to bold
+        let formatted = text.replace(/^### (.+)$/gm, '*$1*');
+        formatted = formatted.replace(/^## (.+)$/gm, '*$1*');
+        formatted = formatted.replace(/^# (.+)$/gm, '*$1*');
+        // Slack already supports backtick code formatting
+        // Convert code blocks (simplified)
+        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());
+        });
+    }
+    /**
+     * 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.
+     */
+    async recordThreadReply(originalMessage, content) {
+        if (!this.threadStore)
+            return;
+        const trimmed = content?.trim();
+        if (!trimmed)
+            return;
+        const threadTs = originalMessage.threadTs || originalMessage.ts;
+        if (!threadTs)
+            return;
+        try {
+            await this.threadStore.appendOrchestratorReply(originalMessage.channelId, threadTs, trimmed);
+        }
+        catch (err) {
+            console.warn('[SlackBridge] Failed to store thread reply:', 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
+     *
+     * @param notification - Notification to send
+     */
+    async sendNotification(notification) {
+        if (!this.config.enableNotifications)
+            return;
+        await this.slackService.sendNotification(notification);
+    }
+    /**
+     * Notify about task completion
+     *
+     * @param taskTitle - Title of completed task
+     * @param agentName - Name of agent that completed the task
+     * @param projectName - Name of the project
+     */
+    async notifyTaskCompleted(taskTitle, agentName, projectName) {
+        await this.sendNotification({
+            type: 'task_completed',
+            title: 'Task Completed',
+            message: `*${taskTitle}*\n\nCompleted by ${agentName} on project ${projectName}`,
+            urgency: 'normal',
+            timestamp: new Date().toISOString(),
+            metadata: { projectId: projectName },
+        });
+    }
+    /**
+     * Notify about agent needing assistance
+     *
+     * @param agentName - Name of agent with question
+     * @param question - The question from the agent
+     * @param projectName - Name of the project
+     */
+    async notifyAgentQuestion(agentName, question, projectName) {
+        await this.sendNotification({
+            type: 'agent_question',
+            title: 'Agent Needs Input',
+            message: `*${agentName}* has a question:\n\n_${question}_`,
+            urgency: 'high',
+            timestamp: new Date().toISOString(),
+            metadata: { agentId: agentName, projectId: projectName },
+        });
+    }
+    /**
+     * Notify about errors
+     *
+     * @param errorMessage - Error message
+     * @param agentName - Optional agent name
+     * @param projectName - Optional project name
+     */
+    async notifyError(errorMessage, agentName, projectName) {
+        await this.sendNotification({
+            type: 'agent_error',
+            title: 'Error Occurred',
+            message: errorMessage,
+            urgency: 'critical',
+            timestamp: new Date().toISOString(),
+            metadata: { agentId: agentName, projectId: projectName },
+        });
+    }
+    /**
+     * Notify about daily summary
+     *
+     * @param summary - Summary content
+     */
+    async notifyDailySummary(summary) {
+        await this.sendNotification({
+            type: 'daily_summary',
+            title: 'Daily Summary',
+            message: summary,
+            urgency: 'low',
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+/**
+ * Get bridge singleton
+ *
+ * @returns SlackOrchestratorBridge instance
+ */
+export function getSlackOrchestratorBridge() {
+    if (!bridgeInstance) {
+        bridgeInstance = new SlackOrchestratorBridge();
+    }
+    return bridgeInstance;
+}
+/**
+ * Reset bridge (for testing)
+ */
+export function resetSlackOrchestratorBridge() {
+    bridgeInstance = null;
+}
+//# sourceMappingURL=slack-orchestrator-bridge.js.map