@jungjaehoon/mama-os 0.28.6 → 0.29.1

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

@@ -1,1235 +0,0 @@
-"use strict";
-/**
- * Multi-Agent Discord Integration
- *
- * Extends the Discord gateway with multi-agent support.
- * Enables multiple AI personas to interact in Discord channels.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiAgentDiscordHandler = void 0;
-const multi_bot_manager_js_1 = require("./multi-bot-manager.js");
-const message_splitter_js_1 = require("../gateways/message-splitter.js");
-const channel_history_js_1 = require("../gateways/channel-history.js");
-const prompt_enhancer_js_1 = require("../agent/prompt-enhancer.js");
-const tool_status_tracker_js_1 = require("../gateways/tool-status-tracker.js");
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const config_manager_js_1 = require("../cli/config/config-manager.js");
-const multi_agent_base_js_1 = require("./multi-agent-base.js");
-const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
-const { DebugLogger } = debugLogger;
-const logger = new DebugLogger('MultiAgentDiscord');
-/** Delay before showing progress message (ms) -- fast requests never show it */
-const PROGRESS_DELAY_MS = 5_000;
-/** Minimum interval between progress message edits (ms) -- Discord rate limit safety */
-const PROGRESS_EDIT_INTERVAL_MS = 3_000;
-/** Phase emoji progression */
-const _PHASE_EMOJIS = ['👀', '🔍', '💻', '🔧', '📝', '✅'];
-/** Max characters allowed for dynamic context blocks to avoid prompt bloat */
-const MAX_DYNAMIC_CONTEXT_CHARS = () => (0, config_manager_js_1.getConfig)().io?.max_dynamic_context_chars ?? 4_000;
-/** Map tool names to phase emojis */
-function toolToPhaseEmoji(toolName) {
-    switch (toolName) {
-        case 'Task':
-        case 'Read':
-        case 'Grep':
-        case 'Glob':
-        case 'WebFetch':
-        case 'WebSearch':
-            return '🔍'; // analysis
-        case 'Bash':
-            return '💻'; // terminal commands
-        case 'Edit':
-        case 'Write':
-        case 'NotebookEdit':
-            return '🔧'; // implementation (file mutations only)
-        default:
-            return null; // no change
-    }
-}
-/**
- * Multi-Agent Discord Handler
- *
- * Integrates with the Discord gateway to provide multi-agent support.
- * Should be instantiated and called from the Discord gateway when
- * multi-agent mode is enabled.
- */
-class MultiAgentDiscordHandler extends multi_agent_base_js_1.MultiAgentHandlerBase {
-    multiBotManager;
-    promptEnhancer;
-    /** Discord client reference for main bot channel sends */
-    discordClient = null;
-    /** Tracks which agent:channel combos have received history injection (new session only) */
-    historyInjected = new Set();
-    constructor(config, processOptions = {}, runtimeOptions = {}) {
-        super(config, processOptions, runtimeOptions);
-        this.multiBotManager = new multi_bot_manager_js_1.MultiBotManager(config);
-        this.promptEnhancer = new prompt_enhancer_js_1.PromptEnhancer();
-        // Setup idle event listeners for all agents (F7)
-        this.setupIdleListeners();
-    }
-    getPlatformName() {
-        return 'discord';
-    }
-    formatBold(text) {
-        return `**${text}**`;
-    }
-    async sendChannelNotification(channelId, message) {
-        try {
-            if (this.discordClient) {
-                const channel = await this.discordClient.channels.fetch(channelId);
-                if (channel && 'send' in channel) {
-                    await channel.send({
-                        content: message,
-                    });
-                }
-            }
-        }
-        catch (err) {
-            console.error(`[MultiAgent] Failed to send channel notification:`, err);
-        }
-    }
-    /**
-     * Extract agent IDs from <@USER_ID> mentions in message content.
-     */
-    extractMentionedAgentIds(content) {
-        const agentIds = [];
-        // Discord native mentions: <@USER_ID> or <@!USER_ID>
-        const mentionPattern = /<@!?(\d+)>/g;
-        let match;
-        while ((match = mentionPattern.exec(content)) !== null) {
-            const userId = match[1];
-            const agentId = this.multiBotManager.resolveAgentIdFromUserId(userId);
-            if (agentId && agentId !== 'main') {
-                agentIds.push(agentId);
-            }
-            else if (agentId === 'main' && this.config.default_agent) {
-                // Main bot userId maps to the default agent (LEAD)
-                agentIds.push(this.config.default_agent);
-            }
-        }
-        return agentIds;
-    }
-    async platformCleanup() {
-        await this.multiBotManager.stopAll();
-    }
-    /**
-     * Initialize multi-bot support (call after Discord connects)
-     */
-    async initializeMultiBots() {
-        if (this.multiBotInitialized)
-            return;
-        // Register mention callback so agent bots forward mentions to handler
-        this.multiBotManager.onMention(async (agentId, message) => {
-            // Dedup: skip if already processed via routeResponseMentions
-            const dedupKey = `${agentId}:${message.id}`;
-            if (this.processedMentions.has(dedupKey))
-                return;
-            this.processedMentions.set(dedupKey, Date.now());
-            const cleanContent = message.content.replace(/<@!?\d+>/g, '').trim();
-            if (!cleanContent)
-                return;
-            // Determine if sender is an agent bot (for mention_delegation chains)
-            const isFromAgent = message.author.bot;
-            const senderAgentId = isFromAgent
-                ? (this.multiBotManager.isFromAgentBot(message) ?? undefined)
-                : undefined;
-            // Chain depth check for mention_delegation
-            if (isFromAgent && senderAgentId && senderAgentId !== 'main') {
-                const chainState = this.orchestrator.getChainState(message.channel.id);
-                const maxDepth = this.getEffectiveMaxMentionDepth();
-                if (chainState.blocked) {
-                    logger.info(`[MultiAgent] Mention chain blocked in channel ${message.channel.id}, ignoring`);
-                    return;
-                }
-                if (chainState.length >= maxDepth) {
-                    logger.info(`[MultiAgent] Mention chain depth ${chainState.length} >= max ${maxDepth}, ignoring`);
-                    return;
-                }
-            }
-            logger.info(`[MultiAgent] Mention-triggered: agent=${agentId}, from=${senderAgentId ?? message.author.tag}, content="${cleanContent.substring(0, 50)}"`);
-            // Extract mentioned agent IDs from the original content
-            const mentionedAgentIds = this.extractMentionedAgentIds(message.content);
-            // Add eyes emoji to indicate processing
-            try {
-                await message.react('👀');
-            }
-            catch {
-                /* ignore */
-            }
-            // Force this specific agent to respond
-            const mentionDescription = cleanContent.substring(0, 200);
-            let mentionResponse = null;
-            try {
-                this.systemReminder.notify({
-                    type: 'delegation-started',
-                    taskId: '',
-                    description: mentionDescription,
-                    agentId,
-                    requestedBy: senderAgentId ?? message.author.tag,
-                    channelId: message.channel.id,
-                    source: 'discord',
-                    timestamp: Date.now(),
-                });
-                mentionResponse = await this.processAgentResponse(agentId, {
-                    channelId: message.channel.id,
-                    userId: message.author.id,
-                    content: cleanContent,
-                    isBot: isFromAgent,
-                    senderAgentId: senderAgentId && senderAgentId !== 'main' ? senderAgentId : undefined,
-                    mentionedAgentIds,
-                    messageId: message.id,
-                    timestamp: message.createdTimestamp,
-                }, cleanContent, message);
-                if (mentionResponse) {
-                    this.systemReminder.notify({
-                        type: 'delegation-completed',
-                        taskId: '',
-                        description: mentionDescription,
-                        agentId,
-                        requestedBy: senderAgentId ?? message.author.tag,
-                        channelId: message.channel.id,
-                        source: 'discord',
-                        duration: mentionResponse.duration,
-                        timestamp: Date.now(),
-                    });
-                    await this.sendAgentResponses(message, [mentionResponse]);
-                    this.orchestrator.recordAgentResponse(agentId, message.channel.id, mentionResponse.messageId);
-                    // Route delegation mentions from this agent's response
-                    if (this.isMentionDelegationEnabled()) {
-                        await this.routeResponseMentions(message, [mentionResponse]);
-                    }
-                }
-            }
-            catch (err) {
-                console.error(`[MultiAgent] Mention handler error:`, err);
-            }
-            finally {
-                // Only add checkmark if agent responded (null = busy/queued)
-                if (mentionResponse) {
-                    try {
-                        await message.react('✅');
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }
-        });
-        await this.multiBotManager.initialize();
-        this.multiBotInitialized = true;
-        const connectedAgents = this.multiBotManager.getConnectedAgents();
-        if (connectedAgents.length > 0) {
-            logger.info(`[MultiAgent] 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();
-            // Include LEAD (default agent) which uses the main bot token
-            // Without this, @Conductor in other agents' personas won't resolve to <@userId>
-            const defaultAgentId = this.config.default_agent;
-            if (defaultAgentId && !botUserIdMap.has(defaultAgentId)) {
-                const mainBotUserId = this.multiBotManager.getMainBotUserId();
-                if (mainBotUserId) {
-                    botUserIdMap.set(defaultAgentId, mainBotUserId);
-                }
-            }
-            this.processManager.setBotUserIdMap(botUserIdMap);
-            this.processManager.setMentionDelegation(true);
-            logger.info(`[MultiAgent] Mention delegation enabled with ${botUserIdMap.size} bot IDs`);
-        }
-    }
-    /**
-     * Set bot's own user ID (call when Discord connects)
-     * Also wires the PR Review Poller message sender via Discord client.
-     */
-    setBotUserId(userId) {
-        this.multiBotManager.setMainBotUserId(userId);
-    }
-    /**
-     * Set Discord client for PR Review Poller message delivery.
-     * Call after Discord client is ready.
-     * The sender posts the message to the channel AND injects it into the
-     * multi-agent flow so LEAD processes the review comments.
-     */
-    setDiscordClient(client) {
-        // Guard against setting different client when already configured
-        if (this.discordClient && this.discordClient !== client) {
-            console.warn('[MultiAgent] Attempted to set different Discord client - ignoring');
-            return;
-        }
-        this.discordClient = client;
-        this.systemReminder.registerCallback(async (channelId, message) => {
-            const ch = await client.channels.fetch(channelId);
-            if (ch && 'send' in ch) {
-                const chunks = (0, message_splitter_js_1.splitForDiscord)(message);
-                for (const chunk of chunks) {
-                    await ch.send({
-                        content: chunk,
-                    });
-                }
-            }
-        }, 'discord');
-    }
-    /**
-     * Set main bot token (to avoid duplicate logins in MultiBotManager)
-     */
-    setMainBotToken(token) {
-        this.multiBotManager.setMainBotToken(token);
-    }
-    /**
-     * Update configuration (for hot reload)
-     */
-    updateConfig(config) {
-        this.config = config;
-        this.orchestrator.updateConfig(config);
-        this.processManager.updateConfig(config);
-        this.multiBotManager.updateConfig(config);
-    }
-    /**
-     * Handle a Discord message with multi-agent logic
-     *
-     * @returns Object with selected agents and their responses, or null if no agents respond
-     */
-    async handleMessage(message, cleanContent) {
-        // Intercept !stop command before any agent routing
-        if (cleanContent.startsWith('!stop')) {
-            await this.handleStopCommand(message, cleanContent);
-            return null;
-        }
-        // Build message context
-        const context = this.buildMessageContext(message, cleanContent);
-        // Record human message to shared context
-        if (!context.isBot) {
-            this.sharedContext.recordHumanMessage(context.channelId, message.author.username, cleanContent, message.id);
-        }
-        // Select responding agents
-        const selection = this.orchestrator.selectRespondingAgents(context);
-        logger.info(`[MultiAgent] Selection result: agents=${selection.selectedAgents.join(',')}, reason=${selection.reason}, blocked=${selection.blocked}`);
-        if (selection.blocked) {
-            logger.info(`[MultiAgent] 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, message)));
-        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') {
-                console.error(`[MultiAgent] Error processing agent ${agentId}:`, result.reason);
-            }
-        }
-        if (responses.length === 0) {
-            return null;
-        }
-        return {
-            selectedAgents: selection.selectedAgents,
-            reason: selection.reason,
-            responses,
-        };
-    }
-    async handleStopCommand(message, cleanContent) {
-        const channelId = message.channel.id;
-        const args = cleanContent.slice('!stop'.length).trim();
-        if (args) {
-            const agentId = args;
-            const agent = this.orchestrator.getAgent(agentId);
-            if (!agent) {
-                await message.reply({ content: `⏹️ Unknown agent: \`${agentId}\`` });
-                return;
-            }
-            const hasActive = this.processManager.hasActiveProcess('discord', channelId, agentId);
-            if (hasActive) {
-                this.processManager.stopProcess('discord', channelId, agentId);
-                this.orchestrator.resetChain(channelId);
-                const displayName = agent.display_name || agentId;
-                await message.reply({ content: `⏹️ Stopped ${displayName}` });
-            }
-            else {
-                await message.reply({ content: `⏹️ No running agents to stop` });
-            }
-        }
-        else {
-            const activeAgents = this.processManager.getActiveAgentsInChannel('discord', channelId);
-            if (activeAgents.length > 0) {
-                this.processManager.stopChannelProcesses('discord', channelId);
-                this.orchestrator.resetChain(channelId);
-                await message.reply({ content: `⏹️ Stopped all agents in this channel` });
-            }
-            else {
-                await message.reply({ content: `⏹️ No running agents to stop` });
-            }
-        }
-        logger.info(`[MultiAgent] !stop command: channel=${channelId}, target=${args || 'all'}`);
-    }
-    /**
-     * Process a single agent's response
-     * @param discordMessage - Optional Discord message for emoji progression
-     */
-    async processAgentResponse(agentId, context, userMessage, discordMessage) {
-        const agent = this.orchestrator.getAgent(agentId);
-        if (!agent) {
-            console.error(`[MultiAgent] Unknown agent: ${agentId}`);
-            return null;
-        }
-        // Strip trigger prefix from message if present
-        const cleanMessage = this.orchestrator.stripTriggerPrefix(userMessage, agentId);
-        // Build context for this agent.
-        // In delegation chains (senderAgentId set), include own messages so the agent
-        // can see what it already said and reason about whether to repeat.
-        // In normal triggers, exclude own messages to avoid self-reference confusion.
-        let agentContext;
-        if (context.senderAgentId) {
-            const messages = this.sharedContext.getRecentMessages(context.channelId, 10);
-            if (messages.length > 0) {
-                const lines = messages.map((msg) => {
-                    const isSelf = msg.agentId === agentId;
-                    const prefix = msg.isHuman ? '👤' : isSelf ? '📌 (you)' : '🤖';
-                    const content = msg.content.length > 600 ? msg.content.slice(0, 600) + '...' : msg.content;
-                    return `${prefix} **${msg.displayName}**: ${content}`;
-                });
-                agentContext = `## Delegation Chain Context\n${lines.join('\n')}`;
-            }
-            else {
-                agentContext = '';
-            }
-        }
-        else {
-            agentContext = this.sharedContext.buildContextForAgent(context.channelId, agentId, 5);
-        }
-        // Build full prompt with context.
-        // - agentContext: other agents' recent messages (inter-agent awareness)
-        // - historyContext: human-only channel history (LEAD agent only)
-        //   DevBot/Reviewer are sub-agent-like -- they get tasks via delegation, not channel history.
-        //   Only LEAD needs channel context to understand the conversation flow.
-        let fullPrompt = cleanMessage;
-        // Inject channel history for all agents on new sessions only.
-        // - Keeps human messages + this agent's own messages, excludes other bots.
-        // - Only on first message per session (subsequent messages are in session memory).
-        const sessionKey = `${agentId}:${context.channelId}`;
-        if (!this.historyInjected.has(sessionKey)) {
-            const channelHistory = (0, channel_history_js_1.getChannelHistory)();
-            const displayName = agent.display_name || agentId;
-            const historyContext = channelHistory.formatForContext(context.channelId, context.messageId, displayName // keep human + this agent's own messages, exclude other bots
-            );
-            if (historyContext) {
-                fullPrompt = `${historyContext}\n\n${fullPrompt}`;
-            }
-            this.historyInjected.add(sessionKey);
-        }
-        if (agentContext) {
-            fullPrompt = `${agentContext}\n\n${fullPrompt}`;
-        }
-        // Inject agent availability status, active work, and channel context (Phase 2 + 3)
-        const agentStatus = this.buildAgentStatusSection(agentId);
-        const workSection = this.workTracker.buildWorkSection(agentId);
-        const channelInfo = `## Current Channel\nPlatform: Discord\nchannel_id: ${context.channelId}\nUse **discord_send** to send messages/files to this channel.`;
-        const dynamicContextRaw = [agentStatus, workSection, channelInfo].filter(Boolean).join('\n');
-        const dynamicContext = dynamicContextRaw.length > MAX_DYNAMIC_CONTEXT_CHARS()
-            ? `${dynamicContextRaw.slice(0, MAX_DYNAMIC_CONTEXT_CHARS())}\n...`
-            : dynamicContextRaw;
-        if (dynamicContext) {
-            fullPrompt = `${dynamicContext}\n\n${fullPrompt}`;
-        }
-        // Enhance prompt with keyword detection (ultrawork/search/analyze modes)
-        const workspacePath = globalThis.process.env.MAMA_WORKSPACE || '';
-        const ruleContext = {
-            agentId,
-            tier: agent.tier,
-            channelId: context.channelId,
-        };
-        const enhanced = await this.promptEnhancer.enhance(cleanMessage, workspacePath, ruleContext);
-        if (enhanced.skillContent) {
-            const safeSkillContent = enhanced.skillContent.replace(/<\/system-reminder>/gi, '</system\u2011reminder>');
-            fullPrompt = `<system-reminder>\n${safeSkillContent}\n</system-reminder>\n\n${fullPrompt}`;
-            logger.info(`[SkillMatch] Injecting skill into Discord agent ${agentId}: ${enhanced.skillContent.length} chars`);
-        }
-        if (enhanced.keywordInstructions) {
-            fullPrompt = `${enhanced.keywordInstructions}\n\n${fullPrompt}`;
-            logger.info(`[PromptEnhancer] Keyword detected for agent ${agentId}: ${enhanced.keywordInstructions.length} chars injected`);
-        }
-        if (enhanced.rulesContent) {
-            fullPrompt = `## Project Rules\n${enhanced.rulesContent}\n\n${fullPrompt}`;
-            logger.info(`[PromptEnhancer] Rules injected for agent ${agentId}: ${enhanced.rulesContent.length} chars`);
-        }
-        logger.info(`[MultiAgent] Processing agent ${agentId}, prompt length: ${fullPrompt.length}`);
-        // Track work start (completed in finally block)
-        this.workTracker.startWork(agentId, context.channelId, cleanMessage);
-        let agentProcess = null;
-        try {
-            // Get or create process for this agent in this channel
-            agentProcess = await this.processManager.getProcess('discord', context.channelId, agentId);
-            // Build onToolUse callback for emoji progression (accumulate, don't replace)
-            const addedEmojis = new Set();
-            const hasOwnBot = this.multiBotManager.hasAgentBot(agentId);
-            // Create tool status tracker for progress messages
-            let tracker = null;
-            if (discordMessage) {
-                const channelId = discordMessage.channel.id;
-                let placeholderMsg = null;
-                const discordAdapter = {
-                    postPlaceholder: async (content) => {
-                        if (hasOwnBot) {
-                            placeholderMsg = await this.multiBotManager.sendAsAgent(agentId, channelId, content);
-                        }
-                        else if ('send' in discordMessage.channel) {
-                            placeholderMsg = await discordMessage.channel.send(content);
-                        }
-                        return placeholderMsg?.id ?? null;
-                    },
-                    editPlaceholder: async (_handle, content) => {
-                        if (placeholderMsg) {
-                            await placeholderMsg.edit(content);
-                        }
-                    },
-                    deletePlaceholder: async (_handle) => {
-                        if (placeholderMsg) {
-                            await placeholderMsg.delete();
-                            placeholderMsg = null;
-                        }
-                    },
-                };
-                tracker = new tool_status_tracker_js_1.ToolStatusTracker(discordAdapter, {
-                    throttleMs: PROGRESS_EDIT_INTERVAL_MS,
-                    initialDelayMs: PROGRESS_DELAY_MS,
-                });
-            }
-            const onToolUse = discordMessage
-                ? (name, input) => {
-                    // Emoji reaction behavior
-                    const emoji = toolToPhaseEmoji(name);
-                    if (emoji && !addedEmojis.has(emoji)) {
-                        addedEmojis.add(emoji);
-                        if (hasOwnBot) {
-                            this.multiBotManager
-                                .reactAsAgent(agentId, discordMessage.channel.id, discordMessage.id, emoji)
-                                .catch(() => {
-                                /* ignore */
-                            });
-                        }
-                        else {
-                            discordMessage.react(emoji).catch(() => {
-                                /* ignore */
-                            });
-                        }
-                    }
-                    // Tool status tracker
-                    tracker?.onToolUse(name, input);
-                }
-                : undefined;
-            // 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 = agentProcess.sendMessage(fullPrompt, onToolUse ? { onToolUse } : undefined);
-                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();
-            }
-            // Execute text-based gateway tool calls (```tool_call blocks in response)
-            // Claude CLI handles built-in tools (Read, Bash, Glob) internally via native tool_use.
-            // Gateway tools (discord_send, mama_*) are requested via text-based tool_call blocks.
-            // discord_send is routed through the agent's own bot (not the main LEAD bot).
-            // Check for workflow plan BEFORE executing tool calls (priority)
-            const workflowStart = Date.now();
-            const workflowResult = await this.tryExecuteWorkflow(result.response, context.channelId, 'discord', (event) => {
-                if (!this.discordClient) {
-                    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) {
-                    this.sendChannelNotification(context.channelId, msg).catch(() => { });
-                }
-            });
-            if (workflowResult) {
-                if (workflowResult.failed) {
-                    this.logger.warn(`[MultiAgentDiscord] 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 agentProcess.sendMessage(feedback);
-                    const cleanedRetry = await this.executeAgentToolCalls(agentId, retryResult.response);
-                    const formattedResponse = this.formatAgentResponse(agent, cleanedRetry);
-                    return {
-                        agentId,
-                        agent,
-                        content: formattedResponse,
-                        rawContent: cleanedRetry,
-                        duration: Date.now() - workflowStart + (result.duration_ms ?? 0),
-                    };
-                }
-                const display = workflowResult.directMessage
-                    ? `${workflowResult.directMessage}\n\n${workflowResult.result}`
-                    : workflowResult.result;
-                const formattedResponse = this.formatAgentResponse(agent, display);
-                const totalDuration = Date.now() - workflowStart + (result.duration_ms ?? 0);
-                return {
-                    agentId,
-                    agent,
-                    content: formattedResponse,
-                    rawContent: display,
-                    duration: totalDuration,
-                };
-            }
-            // Check for council plan (after workflow, before tool calls)
-            const councilResult = await this.tryExecuteCouncil(result.response, context.channelId, 'discord', (event) => {
-                if (!this.discordClient)
-                    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) {
-                    this.sendChannelNotification(context.channelId, msg).catch(() => { });
-                }
-            });
-            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: Date.now() - workflowStart + (result.duration_ms ?? 0),
-                };
-            }
-            // Strip any workflow/council plan JSON that wasn't executed
-            let responseForProcessing = result.response;
-            if (this.workflowEngine?.isEnabled()) {
-                responseForProcessing = this.workflowEngine.extractNonPlanContent(responseForProcessing);
-            }
-            if (this.councilEngine) {
-                responseForProcessing = this.councilEngine.extractNonPlanContent(responseForProcessing);
-            }
-            const cleanedResponse = await this.executeAgentToolCalls(agentId, responseForProcessing);
-            // Detect API error responses — skip mention resolution to prevent error loops
-            const isErrorResponse = /API Error:\s*\d{3}\b/.test(cleanedResponse);
-            const resolvedResponse = isErrorResponse
-                ? cleanedResponse
-                : this.resolveResponseMentions(cleanedResponse);
-            const formattedResponse = this.formatAgentResponse(agent, resolvedResponse);
-            return {
-                agentId,
-                agent,
-                content: formattedResponse,
-                rawContent: resolvedResponse,
-                duration: result.duration_ms,
-            };
-        }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            console.error(`[MultiAgent] Failed to get response from ${agentId}:`, error);
-            if (errMsg.includes('busy')) {
-                logger.info(`[MultiAgent] Agent ${agentId} busy, enqueuing message`);
-                const queuedMessage = {
-                    prompt: fullPrompt,
-                    channelId: context.channelId,
-                    threadTs: context.messageId,
-                    source: 'discord',
-                    enqueuedAt: Date.now(),
-                    context,
-                    discordMessageId: discordMessage?.id,
-                };
-                this.messageQueue.enqueue(agentId, queuedMessage);
-                // Trigger immediate drain if process is idle or reaped
-                this.tryDrainNow(agentId, 'discord', context.channelId).catch(() => { });
-                if (discordMessage) {
-                    try {
-                        await discordMessage.react('⏳');
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }
-            return null;
-        }
-        finally {
-            this.workTracker.completeWork(agentId, context.channelId);
-        }
-    }
-    /**
-     * Build message context from Discord message
-     */
-    buildMessageContext(message, cleanContent) {
-        const isBot = message.author.bot;
-        let senderAgentId;
-        if (isBot) {
-            // Check if message is from one of our agent bots
-            const agentBotId = this.multiBotManager.isFromAgentBot(message);
-            if (agentBotId && agentBotId !== 'main') {
-                senderAgentId = agentBotId;
-            }
-            else {
-                // Try to extract agent ID from message display name (main bot)
-                const extracted = this.orchestrator.extractAgentIdFromMessage(message.content);
-                senderAgentId = extracted ?? undefined;
-            }
-        }
-        // Extract mentioned agent IDs from Discord mentions
-        const mentionedAgentIds = isBot ? undefined : this.extractMentionedAgentIds(message.content);
-        return {
-            channelId: message.channel.id,
-            userId: message.author.id,
-            content: cleanContent,
-            isBot,
-            senderAgentId,
-            mentionedAgentIds: mentionedAgentIds?.length ? mentionedAgentIds : undefined,
-            messageId: message.id,
-            timestamp: message.createdTimestamp,
-        };
-    }
-    /**
-     * Send queued response to Discord (F7: message queue drain callback)
-     */
-    async sendQueuedResponse(agentId, message, response) {
-        const agent = this.orchestrator.getAgent(agentId);
-        if (!agent) {
-            console.error(`[MultiAgent] Unknown agent in queue: ${agentId}`);
-            return;
-        }
-        // Try executing workflow if this is a conductor response with a workflow_plan
-        let cleanedResponse;
-        const workflowResult = await this.tryExecuteWorkflow(response, message.channelId, 'discord');
-        if (workflowResult && !workflowResult.failed) {
-            cleanedResponse = workflowResult.directMessage
-                ? `${workflowResult.directMessage}\n\n${workflowResult.result}`
-                : workflowResult.result;
-        }
-        else {
-            // Strip workflow/council plan JSON that wasn't executed
-            let strippedResponse = response;
-            if (this.workflowEngine?.isEnabled()) {
-                strippedResponse = this.workflowEngine.extractNonPlanContent(strippedResponse);
-            }
-            if (this.councilEngine) {
-                strippedResponse = this.councilEngine.extractNonPlanContent(strippedResponse);
-            }
-            // Execute gateway tool calls from response
-            cleanedResponse = await this.executeAgentToolCalls(agentId, strippedResponse);
-        }
-        const displayResponse = cleanedResponse;
-        // Format response with agent prefix
-        const formattedResponse = this.formatAgentResponse(agent, displayResponse);
-        const chunks = (0, message_splitter_js_1.splitForDiscord)(formattedResponse);
-        const hasOwnBot = this.multiBotManager.hasAgentBot(agentId);
-        for (const chunk of chunks) {
-            try {
-                if (hasOwnBot) {
-                    // Use agent's dedicated bot - send to channel
-                    await this.multiBotManager.sendAsAgent(agentId, message.channelId, chunk);
-                }
-                else if (this.discordClient) {
-                    // Use main bot via stored Discord client
-                    const channel = await this.discordClient.channels.fetch(message.channelId);
-                    if (channel && 'send' in channel) {
-                        await channel.send(chunk);
-                    }
-                }
-                else {
-                    console.warn(`[MultiAgent] Cannot send queued message for ${agentId}: no agent bot or Discord client`);
-                }
-            }
-            catch (err) {
-                console.error(`[MultiAgent] Failed to send queued response for ${agentId}:`, err);
-            }
-        }
-        // Record to shared context
-        this.sharedContext.recordAgentMessage(message.channelId, agent, response, '');
-        // Mark original Discord message as completed
-        if (message.discordMessageId && this.discordClient) {
-            try {
-                const channel = await this.discordClient.channels.fetch(message.channelId);
-                if (channel && 'messages' in channel) {
-                    const originalMsg = await channel.messages.fetch(message.discordMessageId);
-                    if (originalMsg) {
-                        await originalMsg.react('✅');
-                    }
-                }
-            }
-            catch {
-                /* ignore -- message may have been deleted */
-            }
-        }
-        logger.info(`[MultiAgent] Queued message delivered for ${agentId} in ${message.channelId}`);
-    }
-    /**
-     * Send formatted response to Discord (handles message splitting)
-     * Uses agent's dedicated bot if available, otherwise main bot
-     */
-    async sendAgentResponses(originalMessage, responses) {
-        const sentMessages = [];
-        for (const response of responses) {
-            try {
-                const chunks = (0, message_splitter_js_1.splitForDiscord)(response.content);
-                const hasOwnBot = this.multiBotManager.hasAgentBot(response.agentId);
-                for (let i = 0; i < chunks.length; i++) {
-                    let sentMessage = null;
-                    try {
-                        if (hasOwnBot) {
-                            // Use agent's dedicated bot
-                            if (i === 0) {
-                                // First chunk: reply to original message
-                                sentMessage = await this.multiBotManager.replyAsAgent(response.agentId, originalMessage, chunks[i]);
-                            }
-                            else {
-                                // Subsequent chunks: send as new message
-                                sentMessage = await this.multiBotManager.sendAsAgent(response.agentId, originalMessage.channel.id, chunks[i]);
-                            }
-                        }
-                        else {
-                            // Use main bot
-                            if (sentMessages.length === 0 && i === 0) {
-                                // First message: reply to original
-                                sentMessage = await originalMessage.reply({ content: chunks[i] });
-                            }
-                            else {
-                                // Subsequent messages: send as new message
-                                if ('send' in originalMessage.channel) {
-                                    sentMessage = await originalMessage.channel.send({ content: chunks[i] });
-                                }
-                            }
-                        }
-                        if (sentMessage) {
-                            sentMessages.push(sentMessage);
-                            // Update response with message ID (for chain tracking)
-                            if (i === 0) {
-                                response.messageId = sentMessage.id;
-                            }
-                        }
-                    }
-                    catch (chunkErr) {
-                        // Per-chunk error handling: don't let one chunk failure drop remaining chunks
-                        console.error(`[MultiAgent] Failed to send chunk ${i + 1}/${chunks.length} for agent ${response.agentId}:`, chunkErr);
-                        // Continue with next chunk
-                    }
-                }
-            }
-            catch (err) {
-                // Per-response error handling: don't let one agent's failure drop other agents' responses
-                console.error(`[MultiAgent] Failed to send response for agent ${response.agentId}:`, err);
-            }
-        }
-        // Post-send: Auto-review trigger for default agent (Armed Conductor) self-implementations
-        const defaultAgentId = this.config.default_agent;
-        if (defaultAgentId) {
-            const selfImplemented = responses.find((r) => r.agentId === defaultAgentId && this.detectSelfImplementation(r.rawContent));
-            if (selfImplemented && sentMessages.length > 0) {
-                this.triggerAutoReviewIfNeeded(originalMessage.channel.id, defaultAgentId).catch((err) => console.error('[AutoReview] Failed to check diff size:', err));
-            }
-        }
-        return sentMessages;
-    }
-    /**
-     * Detect if the default agent (Conductor) performed direct code edits.
-     * Checks for Claude CLI tool-use markers that indicate Edit/Write operations.
-     */
-    detectSelfImplementation(rawContent) {
-        // Claude CLI responses contain tool use results -- look for Edit/Write indicators
-        const editIndicators = [
-            /\bedit\b.*\bapplied\b/i,
-            /\bwrote\b.*\bfile\b/i,
-            /\bmodified\b.*\bfile/i,
-            /\bEdit\b.*\bsuccess/i,
-            /\bWrite\b.*\bsuccess/i,
-            /파일.*수정/, // Korean: "file...modified" — detects Korean user input
-            /수정.*완료/, // Korean: "modification...completed" — detects Korean user input
-            /\[SOLO\]/i,
-            /\[PAIR\]/i,
-        ];
-        return editIndicators.some((pattern) => pattern.test(rawContent));
-    }
-    /**
-     * Check git diff size after Conductor self-implementation.
-     * If diff exceeds thresholds, auto-trigger Reviewer for quality gate.
-     *
-     * Thresholds (PAIR mode auto-escalation):
-     * - >3 files changed -> auto-mention Reviewer
-     * - >200 lines changed -> auto-mention Reviewer
-     */
-    async triggerAutoReviewIfNeeded(channelId, defaultAgentId) {
-        const MAX_FILES = 3;
-        const MAX_LINES = 200;
-        try {
-            // Get diff stats from git
-            const { stdout: diffStat } = await execFileAsync('git', ['diff', '--stat', '--cached'], {
-                cwd: process.cwd(),
-                timeout: 5000,
-            });
-            // Also check unstaged changes (increased timeout for large repos)
-            const { stdout: diffUnstaged } = await execFileAsync('git', ['diff', '--stat'], {
-                cwd: process.cwd(),
-                timeout: 10000,
-            });
-            const combinedDiff = diffStat + '\n' + diffUnstaged;
-            const fileLines = combinedDiff
-                .split('\n')
-                .filter((l) => l.includes('|'))
-                .map((l) => l.trim())
-                .filter((l) => l.length > 0);
-            const filesChanged = fileLines.length;
-            // Parse total insertions/deletions from summary line
-            const summaryMatch = combinedDiff.match(/(\d+)\s+insertion|(\d+)\s+deletion/g);
-            let totalLines = 0;
-            if (summaryMatch) {
-                for (const m of summaryMatch) {
-                    const num = m.match(/(\d+)/);
-                    if (num) {
-                        totalLines += parseInt(num[1], 10);
-                    }
-                }
-            }
-            if (filesChanged > MAX_FILES || totalLines > MAX_LINES) {
-                logger.info(`[AutoReview] Conductor self-implementation exceeded thresholds: ${filesChanged} files, ${totalLines} lines -> auto-triggering Reviewer`);
-                // Find reviewer agent using shared helper
-                const reviewerEntry = this.findReviewerAgent();
-                const reviewerAgentId = reviewerEntry?.[0];
-                if (reviewerAgentId && this.multiBotManager.hasAgentBot(reviewerAgentId)) {
-                    const reviewMsg = `⬆️ **Auto-Review Triggered** -- ${defaultAgentId} self-implemented but diff exceeded thresholds (${filesChanged} files, ${totalLines} lines). Requesting @Reviewer auto-review.`;
-                    await this.multiBotManager.sendAsAgent(reviewerAgentId, channelId, reviewMsg);
-                }
-            }
-            else {
-                logger.info(`[AutoReview] Conductor self-implementation within thresholds: ${filesChanged} files, ${totalLines} lines -- no auto-review needed`);
-            }
-        }
-        catch {
-            // Git not available or not in a repo -- skip silently
-        }
-    }
-    /**
-     * Get multi-bot manager
-     */
-    getMultiBotManager() {
-        return this.multiBotManager;
-    }
-    /**
-     * Get status of all agent bots
-     */
-    getBotStatus() {
-        return this.multiBotManager.getStatus();
-    }
-    /**
-     * After sending agent responses, check for mentions to other agents and route them.
-     * Discord equivalent of Slack's routeResponseMentions -- necessary because Discord
-     * bots don't receive their own messages as events.
-     */
-    async routeResponseMentions(originalMessage, responses) {
-        for (const response of responses) {
-            // Filter out self-mentions only. All agents can route to any other agent
-            // including LEAD -- the receiving LLM agent can reason about whether to
-            // respond with new information or acknowledge without repeating.
-            const mentionedAgentIds = this.extractMentionedAgentIds(response.rawContent).filter((id) => id !== response.agentId // no self-mention
-            );
-            if (mentionedAgentIds.length === 0)
-                continue;
-            logger.info(`[MultiAgent] Auto-routing mentions from ${response.agentId}: -> ${mentionedAgentIds.join(', ')}`);
-            // Route to all mentioned agents in parallel
-            await Promise.all(mentionedAgentIds.map((targetAgentId) => this.handleDelegatedMention(targetAgentId, originalMessage, response)));
-        }
-    }
-    /**
-     * Handle a delegated mention: process target agent response and recursively route.
-     */
-    async handleDelegatedMention(targetAgentId, originalMessage, sourceResponse) {
-        // Dedup: prevent double processing
-        const dedupKey = `${targetAgentId}:${sourceResponse.messageId || originalMessage.id}`;
-        if (this.processedMentions.has(dedupKey))
-            return;
-        this.processedMentions.set(dedupKey, Date.now());
-        // Chain depth check
-        const chainState = this.orchestrator.getChainState(originalMessage.channel.id);
-        const maxDepth = this.config.max_mention_depth ?? 3;
-        if (chainState.blocked || chainState.length >= maxDepth) {
-            logger.info(`[MultiAgent] Delegation chain blocked/maxed in ${originalMessage.channel.id}`);
-            return;
-        }
-        // Delegation rule validation (Phase 4)
-        if (this.config.delegation_rules) {
-            const rule = this.config.delegation_rules.find((r) => r.from === sourceResponse.agentId && r.to.includes(targetAgentId));
-            if (!rule) {
-                logger.info(`[MultiAgent] Delegation blocked by rule: ${sourceResponse.agentId} → ${targetAgentId}`);
-                return;
-            }
-        }
-        logger.info(`[MultiAgent] Delegated mention: ${sourceResponse.agentId} -> ${targetAgentId}`);
-        // React on the delegation message (source agent's response), not the user's original message
-        const hasOwnBot = this.multiBotManager.hasAgentBot(targetAgentId);
-        const delegationMsgId = sourceResponse.messageId || originalMessage.id;
-        const channelId = originalMessage.channel.id;
-        try {
-            if (hasOwnBot) {
-                await this.multiBotManager.reactAsAgent(targetAgentId, channelId, delegationMsgId, '👀');
-            }
-            else {
-                await originalMessage.react('👀');
-            }
-        }
-        catch {
-            /* ignore */
-        }
-        const truncatedDescription = sourceResponse.rawContent
-            .replace(/<@!?\d+>/g, '')
-            .trim()
-            .substring(0, 200);
-        this.systemReminder.notify({
-            type: 'delegation-started',
-            taskId: '',
-            description: truncatedDescription,
-            agentId: targetAgentId,
-            requestedBy: sourceResponse.agentId,
-            channelId,
-            source: 'discord',
-            timestamp: Date.now(),
-        });
-        const delegationContent = sourceResponse.rawContent.replace(/<@!?\d+>/g, '').trim();
-        try {
-            const response = await this.processAgentResponse(targetAgentId, {
-                channelId,
-                userId: originalMessage.author.id,
-                content: delegationContent,
-                isBot: true,
-                senderAgentId: sourceResponse.agentId,
-                mentionedAgentIds: [targetAgentId],
-                messageId: originalMessage.id,
-                timestamp: originalMessage.createdTimestamp,
-            }, delegationContent, undefined // Don't pass discordMessage -- emojis handled here via delegation messageId
-            );
-            if (response) {
-                this.systemReminder.notify({
-                    type: 'delegation-completed',
-                    taskId: '',
-                    description: truncatedDescription,
-                    agentId: targetAgentId,
-                    requestedBy: sourceResponse.agentId,
-                    channelId,
-                    source: 'discord',
-                    duration: response.duration,
-                    timestamp: Date.now(),
-                });
-                await this.sendAgentResponses(originalMessage, [response]);
-                this.orchestrator.recordAgentResponse(targetAgentId, originalMessage.channel.id, response.messageId);
-                // Recursively route mentions in this agent's response
-                await this.routeResponseMentions(originalMessage, [response]);
-            }
-        }
-        catch (err) {
-            const isBusy = err instanceof Error && err.message.includes('Process is busy');
-            if (isBusy) {
-                logger.info(`[MultiAgent] ${targetAgentId} busy, enqueuing delegation from ${sourceResponse.agentId}`);
-                this.messageQueue.enqueue(targetAgentId, {
-                    prompt: delegationContent,
-                    channelId,
-                    source: 'discord',
-                    enqueuedAt: Date.now(),
-                    context: { channelId, userId: originalMessage.author.id },
-                });
-                this.tryDrainNow(targetAgentId, 'discord', channelId).catch(() => { });
-            }
-            else {
-                console.error(`[MultiAgent] Delegated mention error (${targetAgentId}):`, err);
-            }
-        }
-        finally {
-            // Add checkmark on the delegation message (source agent's response)
-            try {
-                if (hasOwnBot) {
-                    await this.multiBotManager.reactAsAgent(targetAgentId, channelId, delegationMsgId, '✅');
-                }
-                else {
-                    // Fix: React to the delegation message, not the original user message
-                    const delegationMsg = await originalMessage.channel.messages.fetch(delegationMsgId);
-                    await delegationMsg.react('✅');
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    /**
-     * Execute text-based tool calls, routing discord_send through the agent's own bot.
-     * Non-discord tools fall through to the base executeTextToolCalls.
-     */
-    async executeAgentToolCalls(agentId, responseText) {
-        const toolCalls = this.parseToolCallsFromText(responseText);
-        if (toolCalls.length === 0)
-            return responseText;
-        const hasOwnBot = this.multiBotManager.hasAgentBot(agentId);
-        for (const toolCall of toolCalls) {
-            try {
-                if (toolCall.name === 'discord_send' && hasOwnBot) {
-                    if (typeof toolCall.input !== 'object' || toolCall.input === null) {
-                        console.warn(`[MultiAgent] Tool ${toolCall.name}: invalid input (not an object)`);
-                        continue;
-                    }
-                    const input = toolCall.input;
-                    const channelId = typeof input.channel_id === 'string' ? input.channel_id : undefined;
-                    const filePath = typeof input.file_path === 'string'
-                        ? input.file_path
-                        : typeof input.image_path === 'string'
-                            ? input.image_path
-                            : undefined;
-                    const message = typeof input.message === 'string' ? input.message : undefined;
-                    if (!channelId || (!filePath && !message)) {
-                        console.warn(`[MultiAgent] Tool ${toolCall.name}: missing channel_id or payload`);
-                        continue;
-                    }
-                    if (channelId && filePath) {
-                        await this.multiBotManager.sendFileAsAgent(agentId, channelId, filePath, message);
-                    }
-                    else if (channelId && message) {
-                        await this.multiBotManager.sendAsAgent(agentId, channelId, message);
-                    }
-                    logger.info(`[MultiAgent] discord_send routed through agent bot: ${agentId}`);
-                }
-                else if (this.gatewayToolExecutor) {
-                    const result = await this.gatewayToolExecutor.execute(toolCall.name, toolCall.input);
-                    logger.info(`[MultiAgent] Tool ${toolCall.name} succeeded:`, JSON.stringify(result).substring(0, 200));
-                }
-            }
-            catch (error) {
-                console.error(`[MultiAgent] Tool ${toolCall.name} failed:`, error instanceof Error ? error.message : error);
-            }
-        }
-        return this.removeToolCallBlocks(responseText);
-    }
-    /**
-     * Resolve @Name mentions in LLM response text to <@userId> Discord format.
-     * LLMs generate plain text like "@LEAD", "@Conductor", "@DevBot" which won't
-     * trigger Discord mentions or routeResponseMentions detection.
-     */
-    resolveResponseMentions(text) {
-        if (!this.config.mention_delegation)
-            return text;
-        const botUserIdMap = this.multiBotManager.getBotUserIdMap();
-        const mainBotUserId = this.multiBotManager.getMainBotUserId();
-        const defaultAgentId = this.config.default_agent;
-        // Build pattern -> <@userId> lookup
-        const patterns = new Map();
-        for (const [agentId, agentConfig] of Object.entries(this.config.agents)) {
-            let userId = botUserIdMap.get(agentId);
-            if (!userId && agentId === defaultAgentId && mainBotUserId) {
-                userId = mainBotUserId;
-            }
-            if (!userId)
-                continue;
-            const mention = `<@${userId}>`;
-            if (agentConfig.name)
-                patterns.set(agentConfig.name.toLowerCase(), { mention, agentId });
-            if (agentConfig.display_name)
-                patterns.set(agentConfig.display_name.toLowerCase(), { mention, agentId });
-            patterns.set(agentId.toLowerCase(), { mention, agentId });
-        }
-        // Also match "LEAD" for the default agent
-        if (defaultAgentId && mainBotUserId) {
-            patterns.set('lead', { mention: `<@${mainBotUserId}>`, agentId: defaultAgentId });
-        }
-        let resolved = text;
-        for (const [pattern, { mention }] of patterns) {
-            // Match @pattern but NOT already-resolved <@pattern
-            const regex = new RegExp(`(?<!<)@${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
-            resolved = resolved.replace(regex, mention);
-        }
-        return resolved;
-    }
-    getEffectiveMaxMentionDepth() {
-        return this.config.max_mention_depth ?? 3;
-    }
-    /**
-     * Find the reviewer agent entry from config
-     */
-    findReviewerAgent() {
-        return Object.entries(this.config.agents).find(([aid, cfg]) => aid.toLowerCase().includes('review') || cfg.name?.toLowerCase().includes('review'));
-    }
-}
-exports.MultiAgentDiscordHandler = MultiAgentDiscordHandler;
-//# sourceMappingURL=multi-agent-discord.js.map