@jungjaehoon/mama-os 0.28.6 → 0.29.0

package/dist/multi-agent/multi-agent-slack.js

@@ -1,953 +0,0 @@
-"use strict";
-/**
- * Multi-Agent Slack Integration
- *
- * Extends the Slack gateway with multi-agent support.
- * Mirrors MultiAgentDiscordHandler but uses Slack-specific APIs.
- *
- * Reused platform-agnostic components:
- * - MultiAgentOrchestrator: agent selection, chain tracking
- * - AgentProcessManager: getProcess('slack', channelId, agentId)
- * - SharedContextManager: channelId-based context
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiAgentSlackHandler = void 0;
-const slack_multi_bot_manager_js_1 = require("./slack-multi-bot-manager.js");
-const message_splitter_js_1 = require("../gateways/message-splitter.js");
-const log_sanitizer_js_1 = require("../utils/log-sanitizer.js");
-const channel_history_js_1 = require("../gateways/channel-history.js");
-const multi_agent_base_js_1 = require("./multi-agent-base.js");
-const prompt_enhancer_js_1 = require("../agent/prompt-enhancer.js");
-const tool_status_tracker_js_1 = require("../gateways/tool-status-tracker.js");
-const config_manager_js_1 = require("../cli/config/config-manager.js");
-/** Heartbeat interval for status polling (60 seconds) */
-const HEARTBEAT_INTERVAL_MS = () => (0, config_manager_js_1.getConfig)().gateway_tuning?.heartbeat_interval_ms ?? 60_000;
-/** Status emoji for each process state */
-const STATE_EMOJI = {
-    busy: '🔄',
-    idle: '💤',
-    starting: '⏳',
-    dead: '💀',
-};
-/**
- * Multi-Agent Slack Handler
- *
- * Integrates with the Slack gateway to provide multi-agent support.
- */
-class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase {
-    multiBotManager;
-    logger = (0, log_sanitizer_js_1.createSafeLogger)('MultiAgentSlack');
-    /** Main Slack WebClient for posting system messages (heartbeat) */
-    mainWebClient = null;
-    /** Per-channel WebClient mapping (for multi-workspace support) */
-    channelWebClients = new Map();
-    /** Active channel for heartbeat reporting */
-    heartbeatChannelId = null;
-    /** Heartbeat polling interval handle */
-    heartbeatInterval;
-    /** Interval handle for periodic cleanup */
-    /** Tracks the process used for history seeding per agent:channel */
-    historySeedProcess = new Map();
-    promptEnhancer;
-    constructor(config, processOptions = {}, runtimeOptions = {}) {
-        super(config, processOptions, runtimeOptions);
-        this.multiBotManager = new slack_multi_bot_manager_js_1.SlackMultiBotManager(config);
-        this.promptEnhancer = new prompt_enhancer_js_1.PromptEnhancer();
-        // Setup idle event listeners for all agents (F7: message queue drain)
-        this.setupIdleListeners();
-    }
-    getPlatformName() {
-        return 'slack';
-    }
-    formatBold(text) {
-        return `*${text}*`;
-    }
-    /**
-     * Get the correct WebClient for a channel (multi-workspace aware).
-     * Returns channel-specific client if registered, otherwise mainWebClient.
-     */
-    getWebClientForChannel(channelId) {
-        return this.channelWebClients.get(channelId) ?? this.mainWebClient;
-    }
-    /**
-     * Register a WebClient for a specific channel (call when receiving messages from agent bots)
-     */
-    registerChannelWebClient(channelId, client) {
-        this.channelWebClients.set(channelId, client);
-    }
-    async sendChannelNotification(channelId, message) {
-        try {
-            const client = this.getWebClientForChannel(channelId);
-            if (client) {
-                await client.chat.postMessage({ channel: channelId, text: message });
-            }
-        }
-        catch (err) {
-            console.error(`[MultiAgentSlack] Failed to send channel notification:`, err);
-        }
-    }
-    /**
-     * Extract agent IDs from <@U...> mentions in message content
-     */
-    extractMentionedAgentIds(content) {
-        const mentionPattern = /<@([UW]\w+)>/g;
-        const agentIds = [];
-        let match;
-        while ((match = mentionPattern.exec(content)) !== null) {
-            const userId = match[1];
-            const agentId = this.multiBotManager.resolveAgentIdFromUserId(userId);
-            if (agentId) {
-                // Resolve 'main' to the actual agent ID (e.g., 'conductor')
-                const resolvedId = agentId === 'main' ? (this.multiBotManager.getMainBotAgentId() ?? agentId) : agentId;
-                agentIds.push(resolvedId);
-            }
-        }
-        return agentIds;
-    }
-    async platformCleanup() {
-        this.stopHeartbeat();
-        this.historySeedProcess.clear();
-        this.channelWebClients.clear();
-        await this.multiBotManager.stopAll();
-    }
-    /**
-     * Initialize multi-bot support (call after Slack connects)
-     */
-    async initializeMultiBots() {
-        if (this.multiBotInitialized)
-            return;
-        // Register mention callback so agent bots forward mentions to handler
-        this.multiBotManager.onMention(async (agentId, event, webClient) => {
-            // Register this channel's WebClient for correct workspace routing
-            this.channelWebClients.set(event.channel, webClient);
-            const cleanContent = event.text.replace(/<@[UW]\w+>/g, '').trim();
-            if (!cleanContent)
-                return;
-            // Determine if sender is an agent bot
-            const isFromAgent = !!event.bot_id;
-            const senderAgentId = isFromAgent
-                ? (this.multiBotManager.isFromAgentBot(event.bot_id) ?? undefined)
-                : undefined;
-            // Chain depth check for mention_delegation
-            if (isFromAgent && senderAgentId && senderAgentId !== 'main') {
-                const chainState = this.orchestrator.getChainState(event.channel);
-                const maxDepth = this.config.max_mention_depth ?? 3;
-                if (chainState.blocked) {
-                    this.logger.log(`[MultiAgentSlack] Mention chain blocked in channel ${event.channel}, ignoring`);
-                    return;
-                }
-                if (chainState.length >= maxDepth) {
-                    this.logger.log(`[MultiAgentSlack] Mention chain depth ${chainState.length} >= max ${maxDepth}, ignoring`);
-                    return;
-                }
-            }
-            this.logger.log(`[MultiAgentSlack] Mention-triggered: agent=${agentId}, from=${senderAgentId ?? event.user}, content="${cleanContent.substring(0, 50)}"`);
-            // Extract mentioned agent IDs from the original content
-            const mentionedAgentIds = this.extractMentionedAgentIds(event.text);
-            // Force this specific agent to respond
-            const mentionDescription = cleanContent.substring(0, 200);
-            try {
-                this.systemReminder.notify({
-                    type: 'delegation-started',
-                    taskId: '',
-                    description: mentionDescription,
-                    agentId,
-                    requestedBy: senderAgentId ?? event.user,
-                    channelId: event.channel,
-                    source: 'slack',
-                    timestamp: Date.now(),
-                });
-                const response = await this.processAgentResponse(agentId, {
-                    channelId: event.channel,
-                    userId: event.user,
-                    content: cleanContent,
-                    isBot: isFromAgent,
-                    senderAgentId: senderAgentId && senderAgentId !== 'main' ? senderAgentId : undefined,
-                    mentionedAgentIds,
-                    messageId: event.ts,
-                    timestamp: parseFloat(event.ts) * 1000,
-                }, cleanContent);
-                if (response) {
-                    this.systemReminder.notify({
-                        type: 'delegation-completed',
-                        taskId: '',
-                        description: mentionDescription,
-                        agentId,
-                        requestedBy: senderAgentId ?? event.user,
-                        channelId: event.channel,
-                        source: 'slack',
-                        duration: response.duration,
-                        timestamp: Date.now(),
-                    });
-                    const threadTs = event.thread_ts || event.ts;
-                    await this.sendAgentResponses(event.channel, threadTs, [response]);
-                    this.orchestrator.recordAgentResponse(agentId, event.channel, response.messageId);
-                }
-            }
-            catch (err) {
-                this.logger.error(`[MultiAgentSlack] Mention handler error:`, err);
-            }
-        });
-        await this.multiBotManager.initialize();
-        this.multiBotInitialized = true;
-        const connectedAgents = this.multiBotManager.getConnectedAgents();
-        if (connectedAgents.length > 0) {
-            this.logger.log(`[MultiAgentSlack] Multi-bot mode active for: ${connectedAgents.join(', ')}`);
-        }
-        // Pass bot ID map to process manager for mention-based delegation prompts
-        if (this.config.mention_delegation) {
-            const botUserIdMap = this.multiBotManager.getBotUserIdMap();
-            this.processManager.setBotUserIdMap(botUserIdMap);
-            this.processManager.setMentionDelegation(true);
-            this.logger.log(`[MultiAgentSlack] Mention delegation enabled with ${botUserIdMap.size} bot IDs`);
-        }
-    }
-    /**
-     * Set main Slack WebClient (for heartbeat status messages)
-     */
-    setMainWebClient(client) {
-        this.mainWebClient = client;
-        this.systemReminder.registerCallback(async (channelId, message) => {
-            const webClient = this.getWebClientForChannel(channelId) ?? client;
-            const chunks = (0, message_splitter_js_1.splitForSlack)(message);
-            for (const chunk of chunks) {
-                await webClient.chat.postMessage({ channel: channelId, text: chunk });
-            }
-        }, 'slack');
-    }
-    /**
-     * Set main bot's user ID (call when Slack connects via auth.test)
-     */
-    setBotUserId(userId) {
-        this.multiBotManager.setMainBotUserId(userId);
-    }
-    /**
-     * Set main bot's bot ID
-     */
-    setMainBotId(botId) {
-        this.multiBotManager.setMainBotId(botId);
-    }
-    /**
-     * Set main bot token (to avoid duplicate connections)
-     */
-    setMainBotToken(token) {
-        this.multiBotManager.setMainBotToken(token);
-    }
-    /**
-     * Update configuration (for hot reload)
-     */
-    updateConfig(config) {
-        this.config = config;
-        this.orchestrator.updateConfig(config);
-        this.processManager.updateConfig(config);
-    }
-    /**
-     * Handle a Slack message with multi-agent logic
-     *
-     * @returns Object with selected agents and their responses, or null if no agents respond
-     */
-    async handleMessage(event, cleanContent) {
-        // Build message context (extract mentioned agents from original text)
-        const context = this.buildMessageContext(event, cleanContent);
-        context.mentionedAgentIds = this.extractMentionedAgentIds(event.text);
-        // Record human message to shared context
-        if (!context.isBot) {
-            this.sharedContext.recordHumanMessage(context.channelId, event.user, cleanContent, event.ts);
-        }
-        // Select responding agents
-        const selection = this.orchestrator.selectRespondingAgents(context);
-        this.logger.log(`[MultiAgentSlack] Selection result: agents=${selection.selectedAgents.join(',')}, reason=${selection.reason}, blocked=${selection.blocked}`);
-        if (selection.blocked) {
-            this.logger.log(`[MultiAgentSlack] Blocked: ${selection.blockReason}`);
-            return null;
-        }
-        if (selection.selectedAgents.length === 0) {
-            return null;
-        }
-        // Process all selected agents in parallel
-        const results = await Promise.allSettled(selection.selectedAgents.map((agentId) => this.processAgentResponse(agentId, context, cleanContent)));
-        const responses = [];
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            const agentId = selection.selectedAgents[i];
-            if (result.status === 'fulfilled' && result.value) {
-                const response = result.value;
-                responses.push(response);
-                // Record agent response to orchestrator and shared context
-                this.orchestrator.recordAgentResponse(agentId, context.channelId, response.messageId);
-                const agent = this.orchestrator.getAgent(agentId);
-                if (agent) {
-                    this.sharedContext.recordAgentMessage(context.channelId, agent, response.content, response.messageId);
-                }
-            }
-            else if (result.status === 'rejected') {
-                this.logger.error(`[MultiAgentSlack] Error processing agent ${agentId}:`, result.reason);
-            }
-        }
-        if (responses.length === 0) {
-            return null;
-        }
-        return {
-            selectedAgents: selection.selectedAgents,
-            reason: selection.reason,
-            responses,
-        };
-    }
-    /**
-     * Process a single agent's response
-     */
-    async processAgentResponse(agentId, context, userMessage) {
-        const agent = this.orchestrator.getAgent(agentId);
-        if (!agent) {
-            this.logger.error(`[MultiAgentSlack] Unknown agent: ${agentId}`);
-            return null;
-        }
-        // Strip trigger prefix from message if present
-        const cleanMessage = this.orchestrator.stripTriggerPrefix(userMessage, agentId);
-        // Build context for this agent
-        const agentContext = this.sharedContext.buildContextForAgent(context.channelId, agentId, 5);
-        // Enhance with skill detection + keyword instructions
-        const workspacePath = globalThis.process?.env?.MAMA_WORKSPACE || globalThis.process?.env?.HOME || '/tmp';
-        const ruleContext = {
-            agentId,
-            tier: agent.tier,
-            channelId: context.channelId,
-        };
-        const enhanced = await this.promptEnhancer.enhance(cleanMessage, workspacePath, ruleContext);
-        // Build full prompt with context.
-        let fullPrompt = cleanMessage;
-        // Inject matched skill content into user message
-        if (enhanced.skillContent) {
-            const safeSkillContent = enhanced.skillContent.replace(/<\/system-reminder>/gi, '</system\\u2011reminder>');
-            fullPrompt = `<system-reminder>\n${safeSkillContent}\n</system-reminder>\n\n${fullPrompt}`;
-            this.logger.log(`[SkillMatch] Injecting skill into Slack agent ${agentId}: ${enhanced.skillContent.length} chars`);
-        }
-        if (enhanced.keywordInstructions) {
-            fullPrompt = `${enhanced.keywordInstructions}\n\n${fullPrompt}`;
-            this.logger.log(`[PromptEnhancer] Keyword detected for Slack agent ${agentId}: ${enhanced.keywordInstructions.length} chars`);
-        }
-        if (enhanced.rulesContent) {
-            fullPrompt = `## Project Rules\n${enhanced.rulesContent}\n\n${fullPrompt}`;
-        }
-        // Track work start (completed in finally block)
-        this.workTracker.startWork(agentId, context.channelId, cleanMessage);
-        let process = null;
-        try {
-            // Get or create process for this agent in this channel
-            process = await this.processManager.getProcess('slack', context.channelId, agentId);
-            // Inject channel history when process is new/replaced for this agent:channel.
-            // After process restart the CLI has no prior memory, so history must be re-seeded.
-            const sessionKey = `${agentId}:${context.channelId}`;
-            const needsHistorySeed = this.historySeedProcess.get(sessionKey) !== process;
-            if (needsHistorySeed) {
-                const channelHistory = (0, channel_history_js_1.getChannelHistory)();
-                const displayName = agent.display_name || agentId;
-                const historyContext = channelHistory.formatForContext(context.channelId, context.messageId, displayName);
-                if (historyContext) {
-                    fullPrompt = `${historyContext}\n\n${fullPrompt}`;
-                }
-                this.historySeedProcess.set(sessionKey, process);
-            }
-            if (agentContext) {
-                fullPrompt = `${agentContext}\n\n${fullPrompt}`;
-            }
-            // Inject agent availability status and active work (Phase 2 + 3)
-            const agentStatus = this.buildAgentStatusSection(agentId);
-            const workSection = this.workTracker.buildWorkSection(agentId);
-            const channelInfo = `## Current Channel\nPlatform: Slack\nchannel_id: ${context.channelId}\nUse **slack_send** to send messages/files to this channel.`;
-            const dynamicContext = [agentStatus, workSection, channelInfo].filter(Boolean).join('\n');
-            if (dynamicContext) {
-                fullPrompt = `${dynamicContext}\n\n${fullPrompt}`;
-            }
-            this.logger.log(`[MultiAgentSlack] Processing agent ${agentId}, prompt length: ${fullPrompt.length}`);
-            // Create tool status tracker for real-time progress
-            let tracker = null;
-            const channelClient = this.getWebClientForChannel(context.channelId);
-            if (channelClient) {
-                const webClient = channelClient;
-                const channelId = context.channelId;
-                const slackAdapter = {
-                    postPlaceholder: async (content) => {
-                        const res = await webClient.chat.postMessage({
-                            channel: channelId,
-                            text: content,
-                        });
-                        return res.ts ?? null;
-                    },
-                    editPlaceholder: async (handle, content) => {
-                        await webClient.chat.update({ channel: channelId, ts: handle, text: content });
-                    },
-                    deletePlaceholder: async (handle) => {
-                        await webClient.chat.delete({ channel: channelId, ts: handle });
-                    },
-                };
-                tracker = new tool_status_tracker_js_1.ToolStatusTracker(slackAdapter, {
-                    throttleMs: 1500,
-                    initialDelayMs: 3000,
-                });
-            }
-            // Send message and get response (with timeout, properly cleaned up)
-            // agent_ms=0 means unlimited (no timeout race)
-            let timeoutHandle;
-            let result;
-            try {
-                const agentTimeout = (0, multi_agent_base_js_1.AGENT_TIMEOUT_MS)();
-                const sendPromise = process.sendMessage(fullPrompt, tracker?.toPromptCallbacks());
-                if (agentTimeout > 0) {
-                    result = await Promise.race([
-                        sendPromise,
-                        new Promise((_, reject) => {
-                            timeoutHandle = setTimeout(() => reject(new Error(`Agent ${agentId} timed out after ${agentTimeout / 1000}s`)), agentTimeout);
-                        }),
-                    ]);
-                }
-                else {
-                    result = await sendPromise;
-                }
-            }
-            finally {
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
-                await tracker?.cleanup();
-            }
-            // Check for workflow plan BEFORE executing tool calls (priority)
-            const wfClient = this.getWebClientForChannel(context.channelId);
-            const workflowResult = await this.tryExecuteWorkflow(result.response, context.channelId, 'slack', (event) => {
-                if (!wfClient) {
-                    return;
-                }
-                let msg = '';
-                const modelTag = event.agentModel ? ` [${event.agentModel}]` : '';
-                const progress = event.totalSteps && event.completedSteps !== undefined
-                    ? ` [${event.completedSteps}/${event.totalSteps}]`
-                    : '';
-                if (event.type === 'step-started') {
-                    msg = `  ${event.agentDisplayName}${modelTag}${progress} starting...`;
-                }
-                else if (event.type === 'step-completed') {
-                    const sec = event.duration_ms ? Math.round(event.duration_ms / 1000) : 0;
-                    const pct = event.totalSteps && event.completedSteps !== undefined
-                        ? ` (${Math.round((event.completedSteps / event.totalSteps) * 100)}%)`
-                        : '';
-                    msg = `${event.agentDisplayName}${modelTag} (${sec}s)${pct} completed`;
-                }
-                else if (event.type === 'step-failed') {
-                    msg = `${event.agentDisplayName}${modelTag}${progress} ❌ failed: ${event.error?.substring(0, 100)}`;
-                }
-                if (msg) {
-                    wfClient.chat.postMessage({ channel: context.channelId, text: msg }).catch(() => { });
-                }
-            }, wfClient
-                ? (_stepAgentId) => {
-                    const chId = context.channelId;
-                    const adapter = {
-                        postPlaceholder: async (content) => {
-                            const res = await wfClient.chat.postMessage({ channel: chId, text: content });
-                            return res.ts ?? null;
-                        },
-                        editPlaceholder: async (handle, content) => {
-                            await wfClient.chat.update({ channel: chId, ts: handle, text: content });
-                        },
-                        deletePlaceholder: async (handle) => {
-                            await wfClient.chat.delete({ channel: chId, ts: handle });
-                        },
-                    };
-                    const stepTracker = new tool_status_tracker_js_1.ToolStatusTracker(adapter, {
-                        throttleMs: 1500,
-                        initialDelayMs: 2000,
-                    });
-                    return {
-                        callbacks: stepTracker.toPromptCallbacks(),
-                        cleanup: () => stepTracker.cleanup(),
-                    };
-                }
-                : undefined);
-            if (workflowResult) {
-                if (workflowResult.failed) {
-                    this.logger.warn(`[MultiAgentSlack] Workflow failed: ${workflowResult.failed}, sending feedback to conductor`);
-                    const feedback = `[SYSTEM] Your workflow_plan failed to execute.\nReason: ${workflowResult.failed}\nPlease adjust and retry, or respond without a workflow_plan.`;
-                    const retryResult = await process.sendMessage(feedback);
-                    const cleanedRetry = await this.executeTextToolCalls(retryResult.response);
-                    const formattedResponse = this.formatAgentResponse(agent, cleanedRetry);
-                    return {
-                        agentId,
-                        agent,
-                        content: formattedResponse,
-                        rawContent: cleanedRetry,
-                        duration: result.duration_ms,
-                    };
-                }
-                const display = workflowResult.directMessage
-                    ? `${workflowResult.directMessage}\n\n${workflowResult.result}`
-                    : workflowResult.result;
-                const formattedResponse = this.formatAgentResponse(agent, display);
-                return {
-                    agentId,
-                    agent,
-                    content: formattedResponse,
-                    rawContent: display,
-                    duration: result.duration_ms,
-                };
-            }
-            // Check for council plan (after workflow, before tool calls)
-            const councilClient = this.getWebClientForChannel(context.channelId);
-            const councilResult = await this.tryExecuteCouncil(result.response, context.channelId, 'slack', async (event) => {
-                if (!councilClient) {
-                    return;
-                }
-                let msg = '';
-                if (event.type === 'council-round-started') {
-                    msg = `🗣️ ${event.agentDisplayName} Round ${event.round} starting...`;
-                }
-                else if (event.type === 'council-round-completed') {
-                    const sec = event.duration_ms ? Math.round(event.duration_ms / 1000) : 0;
-                    msg = `🗣️ ${event.agentDisplayName} Round ${event.round} (${sec}s) completed`;
-                }
-                else if (event.type === 'council-round-failed') {
-                    msg = `🗣️ ${event.agentDisplayName} Round ${event.round} ❌ failed: ${event.error?.substring(0, 100)}`;
-                }
-                if (msg) {
-                    try {
-                        await councilClient.chat.postMessage({ channel: context.channelId, text: msg });
-                    }
-                    catch (err) {
-                        this.logger?.warn('[MultiAgentSlack] Failed to post council progress:', err);
-                    }
-                }
-            });
-            if (councilResult) {
-                const display = councilResult.directMessage
-                    ? `${councilResult.directMessage}\n\n${councilResult.result}`
-                    : councilResult.result;
-                const formattedResponse = this.formatAgentResponse(agent, display);
-                return {
-                    agentId,
-                    agent,
-                    content: formattedResponse,
-                    rawContent: display,
-                    duration: result.duration_ms,
-                };
-            }
-            // Strip any workflow/council plan JSON that wasn't executed
-            // (prevents raw JSON from leaking to Slack when plan execution is skipped)
-            let responseForProcessing = result.response;
-            if (this.workflowEngine?.isEnabled()) {
-                responseForProcessing = this.workflowEngine.extractNonPlanContent(responseForProcessing);
-            }
-            if (this.councilEngine) {
-                responseForProcessing = this.councilEngine.extractNonPlanContent(responseForProcessing);
-            }
-            // Execute text-based gateway tool calls (```tool_call blocks in response)
-            const cleanedResponse = await this.executeTextToolCalls(responseForProcessing);
-            // Format response with agent prefix
-            const formattedResponse = this.formatAgentResponse(agent, cleanedResponse);
-            return {
-                agentId,
-                agent,
-                content: formattedResponse,
-                rawContent: cleanedResponse,
-                duration: result.duration_ms,
-            };
-        }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            this.logger.error(`[MultiAgentSlack] Failed to get response from ${agentId}:`, error);
-            // Enqueue busy responses (F7: message queue)
-            if (errMsg.includes('busy')) {
-                this.logger.log(`[MultiAgentSlack] Agent ${agentId} busy, enqueuing message`);
-                const queuedMessage = {
-                    prompt: fullPrompt,
-                    channelId: context.channelId,
-                    threadTs: context.messageId,
-                    source: 'slack',
-                    enqueuedAt: Date.now(),
-                    context,
-                };
-                this.messageQueue.enqueue(agentId, queuedMessage);
-                const queueSize = this.messageQueue.getQueueSize(agentId);
-                const queueText = queueSize > 0
-                    ? `⚠️ ${agent.display_name} is currently busy. ${queueSize} messages queued.`
-                    : `⚠️ ${agent.display_name} is currently busy. Your request has been queued.`;
-                // Trigger immediate drain if process is idle or reaped
-                this.tryDrainNow(agentId, 'slack', context.channelId).catch(() => { });
-                return {
-                    agentId,
-                    agent,
-                    content: this.formatAgentResponse(agent, queueText),
-                    rawContent: queueText,
-                    duration: 0,
-                };
-            }
-            const fallbackMessage = errMsg.toLowerCase().includes('timed out') || errMsg.toLowerCase().includes('timeout')
-                ? `⚠️ ${agent.display_name} response timed out. Please try again later.`
-                : `⚠️ ${agent.display_name} error occurred while processing: ${errMsg}`;
-            const fallbackRaw = errMsg.toLowerCase().includes('timed out') || errMsg.toLowerCase().includes('timeout')
-                ? 'Response timed out'
-                : `Error: ${errMsg}`;
-            return {
-                agentId,
-                agent,
-                content: this.formatAgentResponse(agent, fallbackMessage),
-                rawContent: fallbackRaw,
-                duration: 0,
-            };
-        }
-        finally {
-            this.workTracker.completeWork(agentId, context.channelId);
-        }
-    }
-    /**
-     * Build message context from Slack event
-     */
-    buildMessageContext(event, cleanContent) {
-        const isBot = !!event.bot_id;
-        let senderAgentId;
-        if (isBot && event.bot_id) {
-            const agentBotId = this.multiBotManager.isFromAgentBot(event.bot_id);
-            if (agentBotId && agentBotId !== 'main') {
-                senderAgentId = agentBotId;
-            }
-        }
-        return {
-            channelId: event.channel,
-            userId: event.user,
-            content: cleanContent,
-            isBot,
-            senderAgentId,
-            messageId: event.ts,
-            timestamp: parseFloat(event.ts) * 1000,
-        };
-    }
-    /**
-     * Send formatted responses to Slack (handles message splitting)
-     * Uses agent's dedicated bot if available, otherwise main WebClient
-     */
-    async sendAgentResponses(channelId, threadTs, responses, mainWebClient) {
-        const sentMessageTs = [];
-        for (const response of responses) {
-            try {
-                const chunks = (0, message_splitter_js_1.splitForSlack)(response.content);
-                const hasOwnBot = this.multiBotManager.hasAgentBot(response.agentId);
-                for (let i = 0; i < chunks.length; i++) {
-                    let messageTs = null;
-                    if (hasOwnBot && threadTs) {
-                        // Use agent's dedicated bot (requires threadTs for reply)
-                        messageTs = await this.multiBotManager.replyAsAgent(response.agentId, channelId, threadTs, chunks[i]);
-                    }
-                    else if (hasOwnBot && !threadTs) {
-                        // Use agent's dedicated bot for top-level message
-                        messageTs = await this.multiBotManager.sendAsAgent(response.agentId, channelId, chunks[i]);
-                    }
-                    else if (mainWebClient) {
-                        // Use main bot -- broadcast first chunk to channel
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const msgParams = {
-                            channel: channelId,
-                            text: chunks[i],
-                            ...(threadTs && { thread_ts: threadTs }),
-                        };
-                        if (i === 0) {
-                            msgParams.reply_broadcast = true;
-                        }
-                        const result = await mainWebClient.chat.postMessage(msgParams);
-                        messageTs = result.ts;
-                    }
-                    if (messageTs) {
-                        sentMessageTs.push(messageTs);
-                        if (i === 0) {
-                            response.messageId = messageTs;
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                this.logger.error(`[MultiAgentSlack] Failed to send response for agent ${response.agentId}:`, err);
-            }
-        }
-        return sentMessageTs;
-    }
-    /**
-     * Send queued response to Slack (F7: message queue drain callback)
-     */
-    async sendQueuedResponse(agentId, message, response) {
-        const agent = this.orchestrator.getAgent(agentId);
-        if (!agent) {
-            this.logger.error(`[MultiAgentSlack] Unknown agent in queue: ${agentId}`);
-            return;
-        }
-        let displayResponse = response;
-        // Try executing workflow if this is a conductor response with a workflow_plan
-        const queueClient = this.getWebClientForChannel(message.channelId);
-        const createStepCbs = queueClient
-            ? (_stepAgentId) => {
-                const chId = message.channelId;
-                const adapter = {
-                    postPlaceholder: async (content) => {
-                        const res = await queueClient.chat.postMessage({ channel: chId, text: content });
-                        return res.ts ?? null;
-                    },
-                    editPlaceholder: async (handle, content) => {
-                        await queueClient.chat.update({ channel: chId, ts: handle, text: content });
-                    },
-                    deletePlaceholder: async (handle) => {
-                        await queueClient.chat.delete({ channel: chId, ts: handle });
-                    },
-                };
-                const stepTracker = new tool_status_tracker_js_1.ToolStatusTracker(adapter, {
-                    throttleMs: 1500,
-                    initialDelayMs: 2000,
-                });
-                return {
-                    callbacks: stepTracker.toPromptCallbacks(),
-                    cleanup: () => stepTracker.cleanup(),
-                };
-            }
-            : undefined;
-        const workflowResult = await this.tryExecuteWorkflow(response, message.channelId, 'slack', undefined, createStepCbs);
-        if (workflowResult && !workflowResult.failed) {
-            displayResponse = workflowResult.directMessage
-                ? `${workflowResult.directMessage}\n\n${workflowResult.result}`
-                : workflowResult.result;
-        }
-        else {
-            // Strip workflow/council plan JSON from queued responses
-            if (this.workflowEngine?.isEnabled()) {
-                displayResponse = this.workflowEngine.extractNonPlanContent(displayResponse);
-            }
-            if (this.councilEngine) {
-                displayResponse = this.councilEngine.extractNonPlanContent(displayResponse);
-            }
-            // Execute text-based gateway tool calls
-            displayResponse = await this.executeTextToolCalls(displayResponse);
-        }
-        // Format response with agent prefix
-        const formattedResponse = this.formatAgentResponse(agent, displayResponse);
-        const agentResponse = {
-            agentId,
-            agent,
-            content: formattedResponse,
-            rawContent: displayResponse,
-        };
-        // Send to channel (use channel-aware WebClient as fallback for agents without dedicated bots)
-        await this.sendAgentResponses(message.channelId, message.threadTs, [agentResponse], this.getWebClientForChannel(message.channelId) ?? undefined);
-        // Record to shared context
-        this.sharedContext.recordAgentMessage(message.channelId, agent, displayResponse, agentResponse.messageId || '');
-        this.logger.log(`[MultiAgentSlack] Queued message delivered for ${agentId} in ${message.channelId}`);
-    }
-    /**
-     * Handle bot->agent mention delegation (called by gateway for main bot messages).
-     * Bridges the gap where Slack's app_mention event doesn't fire for bot-posted messages.
-     */
-    async handleBotToAgentMention(targetAgentId, event, mainWebClient) {
-        // Dedup: prevent double processing if both gateway and SlackMultiBotManager fire
-        const dedupKey = `${targetAgentId}:${event.ts}`;
-        if (this.processedMentions.has(dedupKey))
-            return;
-        this.processedMentions.set(dedupKey, Date.now());
-        const cleanContent = event.text.replace(/<@[UW]\w+>/g, '').trim();
-        if (!cleanContent)
-            return;
-        // Determine sender agent
-        const senderBotResult = event.bot_id ? this.multiBotManager.isFromAgentBot(event.bot_id) : null;
-        const senderAgentId = senderBotResult === 'main'
-            ? (this.multiBotManager.getMainBotAgentId() ?? undefined)
-            : (senderBotResult ?? undefined);
-        // Chain depth check
-        const chainState = this.orchestrator.getChainState(event.channel);
-        const maxDepth = this.config.max_mention_depth ?? 3;
-        if (chainState.blocked || chainState.length >= maxDepth) {
-            this.logger.log(`[MultiAgentSlack] Bot->Agent mention chain blocked/maxed in ${event.channel}`);
-            return;
-        }
-        this.logger.log(`[MultiAgentSlack] Bot->Agent mention: ${senderAgentId ?? 'main'} -> ${targetAgentId}, content="${cleanContent.substring(0, 50)}"`);
-        // Add eyes reaction
-        try {
-            await mainWebClient.reactions.add({
-                channel: event.channel,
-                timestamp: event.ts,
-                name: 'eyes',
-            });
-        }
-        catch {
-            /* ignore reaction errors */
-        }
-        const botMentionDescription = cleanContent.substring(0, 200);
-        this.systemReminder.notify({
-            type: 'delegation-started',
-            taskId: '',
-            description: botMentionDescription,
-            agentId: targetAgentId,
-            requestedBy: senderAgentId ?? 'main',
-            channelId: event.channel,
-            source: 'slack',
-            timestamp: Date.now(),
-        });
-        try {
-            const response = await this.processAgentResponse(targetAgentId, {
-                channelId: event.channel,
-                userId: event.user,
-                content: cleanContent,
-                isBot: true,
-                senderAgentId,
-                mentionedAgentIds: [targetAgentId],
-                messageId: event.ts,
-                timestamp: parseFloat(event.ts) * 1000,
-            }, cleanContent);
-            if (response) {
-                this.systemReminder.notify({
-                    type: 'delegation-completed',
-                    taskId: '',
-                    description: botMentionDescription,
-                    agentId: targetAgentId,
-                    requestedBy: senderAgentId ?? 'main',
-                    channelId: event.channel,
-                    source: 'slack',
-                    duration: response.duration,
-                    timestamp: Date.now(),
-                });
-                const threadTs = event.thread_ts || event.ts;
-                await this.sendAgentResponses(event.channel, threadTs, [response], mainWebClient);
-                this.orchestrator.recordAgentResponse(targetAgentId, event.channel, response.messageId);
-                // Recursively route mentions in this agent's response.
-                // Necessary because Slack doesn't deliver a bot's own messages back to itself.
-                await this.routeResponseMentions(event.channel, threadTs, [response], mainWebClient);
-            }
-        }
-        catch (err) {
-            this.logger.error(`[MultiAgentSlack] Bot->Agent mention error:`, err);
-        }
-        finally {
-            // Replace eyes with checkmark regardless of success/failure
-            try {
-                await mainWebClient.reactions.remove({
-                    channel: event.channel,
-                    timestamp: event.ts,
-                    name: 'eyes',
-                });
-                await mainWebClient.reactions.add({
-                    channel: event.channel,
-                    timestamp: event.ts,
-                    name: 'white_check_mark',
-                });
-            }
-            catch {
-                /* ignore reaction errors */
-            }
-        }
-    }
-    /**
-     * After sending agent responses, check for mentions to other agents and route them.
-     * Necessary because Slack Socket Mode doesn't deliver a bot's own messages back to itself,
-     * so the gateway's message listener never fires for responses sent by any bot.
-     */
-    async routeResponseMentions(channelId, threadTs, responses, mainWebClient) {
-        for (const response of responses) {
-            // Filter out self-mentions to prevent routing an agent's response back to itself
-            const mentionedAgentIds = this.extractMentionedAgentIds(response.rawContent).filter((id) => id !== response.agentId);
-            if (mentionedAgentIds.length === 0) {
-                continue;
-            }
-            this.logger.log(`[MultiAgentSlack] Auto-routing mentions from ${response.agentId}: -> ${mentionedAgentIds.join(', ')}`);
-            // Route to all mentioned agents in parallel (not sequential)
-            await Promise.all(mentionedAgentIds.map((targetAgentId) => {
-                const syntheticEvent = {
-                    type: 'message',
-                    channel: channelId,
-                    user: '',
-                    text: response.rawContent,
-                    ts: `${response.messageId || threadTs}-${response.agentId}`,
-                    thread_ts: threadTs,
-                    bot_id: 'auto-route',
-                };
-                return this.handleBotToAgentMention(targetAgentId, syntheticEvent, mainWebClient);
-            }));
-        }
-    }
-    /**
-     * Get multi-bot manager
-     */
-    getMultiBotManager() {
-        return this.multiBotManager;
-    }
-    /**
-     * Start heartbeat polling for a channel.
-     * Only reports when at least 1 agent is busy. Silent when all idle.
-     */
-    startHeartbeat(channelId) {
-        // Already running for this channel
-        if (this.heartbeatInterval && this.heartbeatChannelId === channelId)
-            return;
-        // Stop existing heartbeat if switching channels
-        this.stopHeartbeat();
-        this.heartbeatChannelId = channelId;
-        this.heartbeatInterval = setInterval(() => {
-            this.pollAndReport().catch((err) => {
-                this.logger.error('[Heartbeat] Poll error:', err);
-            });
-        }, HEARTBEAT_INTERVAL_MS());
-        this.logger.log(`[Heartbeat] Started for channel ${channelId} (${HEARTBEAT_INTERVAL_MS() / 1000}s interval)`);
-    }
-    /**
-     * Stop heartbeat polling
-     */
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = undefined;
-            this.heartbeatChannelId = null;
-        }
-    }
-    /**
-     * Poll agent states and report to Slack if any are busy
-     */
-    async pollAndReport() {
-        if (!this.mainWebClient || !this.heartbeatChannelId) {
-            return;
-        }
-        const agentStates = this.processManager.getAgentStates();
-        // Check if any agent is busy
-        let hasBusy = false;
-        for (const state of agentStates.values()) {
-            if (state === 'busy' || state === 'starting') {
-                hasBusy = true;
-                break;
-            }
-        }
-        // Silent when no agents are busy
-        if (!hasBusy)
-            return;
-        // Build status line
-        const agentConfigs = this.config.agents;
-        const parts = [];
-        for (const [agentId, agentConfig] of Object.entries(agentConfigs)) {
-            if (agentConfig.enabled === false)
-                continue;
-            const state = agentStates.get(agentId) ?? 'idle';
-            const emoji = STATE_EMOJI[state] ?? '❓';
-            const queueSize = this.messageQueue.getQueueSize(agentId);
-            let entry = `${emoji} ${agentConfig.display_name}: ${state}`;
-            if (queueSize > 0) {
-                entry += ` (📬 ${queueSize} queued)`;
-            }
-            parts.push(entry);
-        }
-        const statusLine = `⏱️ *Agent Status* | ${parts.join(' | ')}`;
-        try {
-            await this.mainWebClient.chat.postMessage({
-                channel: this.heartbeatChannelId,
-                text: statusLine,
-            });
-        }
-        catch (err) {
-            this.logger.error('[Heartbeat] Failed to post status:', err);
-        }
-    }
-    /**
-     * Get status of all agent bots
-     */
-    getBotStatus() {
-        return this.multiBotManager.getStatus();
-    }
-}
-exports.MultiAgentSlackHandler = MultiAgentSlackHandler;
-//# sourceMappingURL=multi-agent-slack.js.map