@jungjaehoon/mama-os 0.9.2 → 0.9.4

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

@@ -14,9 +14,9 @@ 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 pr_review_poller_js_1 = require("./pr-review-poller.js");
 const delegation_format_validator_js_1 = require("./delegation-format-validator.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");
 /** Heartbeat interval for status polling (60 seconds) */
 const HEARTBEAT_INTERVAL_MS = 60 * 1000;
@@ -41,10 +41,10 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
     heartbeatChannelId = null;
     /** Heartbeat polling interval handle */
     heartbeatInterval;
-    /** PR poller summaries by channel for LEAD wake-up context. */
-    prPollerSummaries = new Map();
     /** Interval handle for periodic cleanup */
     mentionCleanupInterval;
+    /** Tracks the process used for history seeding per agent:channel */
+    historySeedProcess = new Map();
     constructor(config, processOptions = {}, runtimeOptions = {}) {
         super(config, processOptions, runtimeOptions);
         this.multiBotManager = new slack_multi_bot_manager_js_1.SlackMultiBotManager(config);
@@ -83,7 +83,7 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             const userId = match[1];
             const agentId = this.multiBotManager.resolveAgentIdFromUserId(userId);
             if (agentId) {
-                // Resolve 'main' to the actual agent ID (e.g., 'sisyphus')
+                // Resolve 'main' to the actual agent ID (e.g., 'conductor')
                 const resolvedId = agentId === 'main' ? (this.multiBotManager.getMainBotAgentId() ?? agentId) : agentId;
                 agentIds.push(resolvedId);
             }
@@ -96,6 +96,7 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             clearInterval(this.mentionCleanupInterval);
             this.mentionCleanupInterval = undefined;
         }
+        this.historySeedProcess.clear();
         await this.multiBotManager.stopAll();
     }
     /**
@@ -185,131 +186,6 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             this.processManager.setMentionDelegation(true);
             this.logger.log(`[MultiAgentSlack] Mention delegation enabled with ${botUserIdMap.size} bot IDs`);
         }
-        // Configure PR poller wiring (if enabled)
-        this.configurePrPoller();
-    }
-    /**
-     * Configure PR Review Poller callbacks.
-     * Extracted so it can be called from both initializeMultiBots() and updateConfig()
-     * to enable hot-reload of PR poller.
-     */
-    configurePrPoller() {
-        if (!this.isPrReviewPollingEnabled()) {
-            return;
-        }
-        if (this.config.mention_delegation) {
-            const botUserIdMap = this.multiBotManager.getBotUserIdMap();
-            const orchestratorId = this.config.default_agent || 'sisyphus';
-            const orchestratorUserId = botUserIdMap.get(orchestratorId);
-            if (orchestratorUserId) {
-                this.prReviewPoller.setTargetAgentUserId(orchestratorUserId);
-            }
-        }
-        // PR Review Poller: wake up LEAD with compact summaries from new review items.
-        this.prReviewPoller.setMessageSender(async () => { });
-        this.prReviewPoller.setOnBatchItem(async (channelId, summary, item) => {
-            const compact = this.compactPrReviewBatchSummary(summary);
-            const bucket = this.prPollerSummaries.get(channelId) ?? [];
-            if (!compact || bucket.some((candidate) => candidate.id === item.id)) {
-                return;
-            }
-            const merged = { ...item, summary: compact };
-            this.prPollerSummaries.set(channelId, [...bucket, merged].slice(-12));
-        });
-        this.prReviewPoller.setOnBatchComplete(async (channelId, digest) => {
-            const items = (digest?.items && digest.items.length > 0
-                ? digest.items
-                : this.prPollerSummaries.get(channelId)) ?? [];
-            const count = items.length;
-            if (count === 0) {
-                return;
-            }
-            const actionableItems = digest?.newItems ?? items.filter((item) => !item.isReminder);
-            if (actionableItems.length === 0) {
-                this.prPollerSummaries.delete(channelId);
-                return;
-            }
-            const reminderCount = (digest?.reminderItems ?? items.filter((item) => item.isReminder))
-                .length;
-            this.prPollerSummaries.delete(channelId);
-            const sessions = this.prReviewPoller.getSessionDetails();
-            const session = sessions.find((s) => s.channelId === channelId);
-            if (!session) {
-                return;
-            }
-            const prLabel = `${session.owner}/${session.repo}#${session.prNumber}`;
-            const summaryLines = items
-                .map((item, idx) => `- ${idx + 1}. [${item.severity}] ${item.summary}`)
-                .join('\n');
-            const promptSummary = `\n${summaryLines}`;
-            const reminderSuffix = reminderCount > 0 ? `\n🔔 Reminders: ${reminderCount} item(s).` : '';
-            if (this.mainWebClient) {
-                await this.mainWebClient.chat.postMessage({
-                    channel: channelId,
-                    text: `📊 PR ${prLabel} — ${count} new review item(s)\n\n${promptSummary}${reminderSuffix}`,
-                });
-            }
-            this.orchestrator.resetChain(channelId);
-            const defaultAgentId = this.config.default_agent || 'sisyphus';
-            const basePrompt = `📊 PR Review follow-up (${count} new item(s))\n` +
-                `Target: ${prLabel}\n` +
-                `Workspace: \`${session.workspaceDir}\`\n` +
-                `Items:\n${promptSummary}${reminderSuffix}`;
-            this.messageQueue.enqueue(defaultAgentId, {
-                prompt: `${basePrompt}\n\nClassify severity, implement fixable items, and coordinate with Dev/Reviewer.`,
-                channelId,
-                source: 'slack',
-                enqueuedAt: Date.now(),
-                context: { channelId, userId: 'pr-poller' },
-            });
-            this.logger.info(`[MultiAgentSlack] PR Poller -> LEAD wake-up (${count} items)`);
-            this.tryDrainNow(defaultAgentId, 'slack', channelId).catch(() => { });
-            const helperAgents = this.resolvePrReviewAssistants(defaultAgentId);
-            for (const helperAgentId of helperAgents) {
-                const helperPrompt = helperAgentId === 'developer'
-                    ? `${basePrompt}\n\nImplement available fixes in the workspace and request Reviewer verification when changes are made.`
-                    : `${basePrompt}\n\nInspect the comments for correctness issues and provide reviewer guidance.`;
-                this.messageQueue.enqueue(helperAgentId, {
-                    prompt: helperPrompt,
-                    channelId,
-                    source: 'slack',
-                    enqueuedAt: Date.now(),
-                    context: { channelId, userId: 'pr-poller' },
-                });
-                this.logger.info(`[MultiAgentSlack] PR Poller -> ${helperAgentId} wake-up (${count} items)`);
-                this.tryDrainNow(helperAgentId, 'slack', channelId).catch(() => { });
-            }
-        });
-        this.logger.log('[MultiAgentSlack] PR Poller summaries now feed LEAD wake-up');
-    }
-    /**
-     * Keep PR poller summaries short and remove duplicates.
-     */
-    compactPrReviewBatchSummary(summary) {
-        const compact = summary.replace(/[\r\n]+/g, ' ').trim();
-        const max = 230;
-        if (!compact) {
-            return '';
-        }
-        return compact.length > max ? `${compact.slice(0, max)}…` : compact;
-    }
-    /**
-     * Resolve helper agents for PR review workflow in addition to default lead.
-     */
-    resolvePrReviewAssistants(defaultAgentId) {
-        const candidateIds = ['developer', 'reviewer', 'dev', 'lead'];
-        const helperAgents = [];
-        for (const id of candidateIds) {
-            const cfg = this.config.agents[id];
-            if (!cfg || id === defaultAgentId) {
-                continue;
-            }
-            if (cfg.enabled === false) {
-                continue;
-            }
-            helperAgents.push(id);
-        }
-        return [...new Set(helperAgents)];
     }
     /**
      * Set main Slack WebClient (for heartbeat status messages)
@@ -322,12 +198,6 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
                 await client.chat.postMessage({ channel: channelId, text: chunk });
             }
         }, 'slack');
-        // Only set PR poller sender if not already configured (e.g., by reviewer bot)
-        if (this.isPrReviewPollingEnabled() && !this.prReviewPoller.hasMessageSender?.()) {
-            this.prReviewPoller.setMessageSender(async (channelId, text) => {
-                await client.chat.postMessage({ channel: channelId, text });
-            });
-        }
     }
     /**
      * Set main bot's user ID (call when Slack connects via auth.test)
@@ -354,66 +224,6 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
         this.config = config;
         this.orchestrator.updateConfig(config);
         this.processManager.updateConfig(config);
-        if (this.isPrReviewPollingEnabled()) {
-            // Re-wire PR poller callbacks on hot-reload enable
-            this.configurePrPoller();
-        }
-        else {
-            this.prReviewPoller.stopAll();
-            this.prPollerSummaries.clear();
-        }
-    }
-    /**
-     * Handle PR review polling commands from human messages.
-     * Returns true if the message was a PR command (consumed), false otherwise.
-     *
-     * Start: message contains a GitHub PR URL (auto-detect)
-     * Stop: message contains "pr stop", "stop polling"
-     */
-    async handlePRCommand(channelId, content) {
-        if (!this.isPrReviewPollingEnabled()) {
-            return false;
-        }
-        if (!this.mainWebClient) {
-            return false;
-        }
-        const contentLower = content.toLowerCase();
-        // Stop commands
-        const stopPatterns = ['pr 중지', 'pr stop', '폴링 중지', 'stop polling', 'pr 종료', 'stop pr'];
-        if (stopPatterns.some((p) => contentLower.includes(p))) {
-            const sessions = this.prReviewPoller.getActiveSessions();
-            if (sessions.length === 0) {
-                await this.mainWebClient.chat.postMessage({
-                    channel: channelId,
-                    text: '📭 No active PR polling sessions.',
-                });
-            }
-            else {
-                this.prReviewPoller.stopAll();
-                await this.mainWebClient.chat.postMessage({
-                    channel: channelId,
-                    text: `⏹️ PR review polling stopped: ${sessions.join(', ')}`,
-                });
-            }
-            return true;
-        }
-        // Start: detect PR URL in message
-        const prUrls = pr_review_poller_js_1.PRReviewPoller.extractPRUrls(content);
-        if (prUrls.length > 0) {
-            for (const prUrl of prUrls) {
-                const started = await this.prReviewPoller.startPolling(prUrl, channelId);
-                if (started) {
-                    const parsed = this.prReviewPoller.parsePRUrl(prUrl);
-                    const key = parsed ? `${parsed.owner}/${parsed.repo}#${parsed.prNumber}` : prUrl;
-                    await this.mainWebClient.chat.postMessage({
-                        channel: channelId,
-                        text: `👀 *PR Review Poller started* -- ${key}\nPolling for new review comments every 60 seconds. Type "PR stop" to stop.`,
-                    });
-                }
-            }
-            return true;
-        }
-        return false;
     }
     /**
      * Handle a Slack message with multi-agent logic
@@ -481,29 +291,38 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
         // Build context for this agent
         const agentContext = this.sharedContext.buildContextForAgent(context.channelId, agentId, 5);
         // Build full prompt with context.
-        // NOTE: Do NOT inject historyContext into persistent processes -- the CLI process
-        // already retains conversation memory across turns. Injecting historyContext causes
-        // duplicate messages in Claude's context, making old messages appear "just conversed"
-        // and creating cross-agent context confusion.
-        // Only inject agentContext (other agents' messages) for inter-agent awareness.
         let fullPrompt = cleanMessage;
-        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 dynamicContext = [agentStatus, workSection].filter(Boolean).join('\n');
-        if (dynamicContext) {
-            fullPrompt = `${dynamicContext}\n\n${fullPrompt}`;
-        }
-        this.logger.log(`[MultiAgentSlack] Processing agent ${agentId}, prompt length: ${fullPrompt.length}`);
         // 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}`);
             // Send message and get response (with timeout, properly cleaned up)
             let timeoutHandle;
             let result;
@@ -525,21 +344,42 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
                 }
                 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} 시작...`;
+                    msg = `  ${event.agentDisplayName}${modelTag}${progress} 시작...`;
                 }
                 else if (event.type === 'step-completed') {
                     const sec = event.duration_ms ? Math.round(event.duration_ms / 1000) : 0;
-                    msg = `${event.agentDisplayName}${modelTag} (${sec}s) 완료`;
+                    const pct = event.totalSteps && event.completedSteps !== undefined
+                        ? ` (${Math.round((event.completedSteps / event.totalSteps) * 100)}%)`
+                        : '';
+                    msg = `${event.agentDisplayName}${modelTag} (${sec}s)${pct} 완료`;
                 }
                 else if (event.type === 'step-failed') {
-                    msg = `${event.agentDisplayName}${modelTag} ❌ 실패: ${event.error?.substring(0, 100)}`;
+                    msg = `${event.agentDisplayName}${modelTag}${progress} ❌ 실패: ${event.error?.substring(0, 100)}`;
                 }
                 if (msg) {
                     this.mainWebClient.chat.postMessage({ channel: context.channelId, text: msg }).catch(() => { });
                 }
             });
             if (workflowResult) {
+                if (workflowResult.failed) {
+                    // Workflow plan parsed but execution failed — feed error back to Conductor
+                    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;
@@ -552,36 +392,103 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
                     duration: result.duration_ms,
                 };
             }
+            // Check for council plan (after workflow, before tool calls)
+            const councilResult = await this.tryExecuteCouncil(result.response, context.channelId, 'slack', async (event) => {
+                if (!this.mainWebClient) {
+                    return;
+                }
+                let msg = '';
+                if (event.type === 'council-round-started') {
+                    msg = `🗣️ ${event.agentDisplayName} Round ${event.round} 시작...`;
+                }
+                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) 완료`;
+                }
+                else if (event.type === 'council-round-failed') {
+                    msg = `🗣️ ${event.agentDisplayName} Round ${event.round} ❌ 실패: ${event.error?.substring(0, 100)}`;
+                }
+                if (msg) {
+                    try {
+                        await this.mainWebClient.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(result.response);
-            const bgDelegation = this.delegationManager.parseDelegation(agentId, cleanedResponse);
-            if (bgDelegation && bgDelegation.background) {
-                const check = this.delegationManager.isDelegationAllowed(bgDelegation.fromAgentId, bgDelegation.toAgentId);
+            const cleanedResponse = await this.executeTextToolCalls(responseForProcessing);
+            // Parse all delegation commands (both sync and background)
+            const delegations = this.delegationManager.parseAllDelegations(agentId, cleanedResponse);
+            let displayResponse = cleanedResponse;
+            // Handle background delegations
+            const bgDelegations = delegations.filter((d) => d.background);
+            if (bgDelegations.length > 0) {
+                let submittedCount = 0;
+                for (const delegation of bgDelegations) {
+                    const check = this.delegationManager.isDelegationAllowed(delegation.fromAgentId, delegation.toAgentId);
+                    if (check.allowed) {
+                        this.backgroundTaskManager.submit({
+                            description: delegation.task.substring(0, 200),
+                            prompt: delegation.task,
+                            agentId: delegation.toAgentId,
+                            requestedBy: agentId,
+                            channelId: context.channelId,
+                            source: 'slack',
+                        });
+                        this.logger.log(`[MultiAgentSlack] Background delegation: ${agentId} -> ${delegation.toAgentId} (async)`);
+                        submittedCount++;
+                    }
+                }
+                if (submittedCount > 0) {
+                    displayResponse =
+                        bgDelegations[0].originalContent || `🔄 ${submittedCount} background task(s) delegated`;
+                }
+            }
+            // Handle synchronous delegations via message queue
+            const syncDelegations = delegations.filter((d) => !d.background);
+            for (const delegation of syncDelegations) {
+                const check = this.delegationManager.isDelegationAllowed(delegation.fromAgentId, delegation.toAgentId);
                 if (check.allowed) {
-                    const toAgent = this.orchestrator.getAgent(bgDelegation.toAgentId);
-                    this.backgroundTaskManager.submit({
-                        description: bgDelegation.task.substring(0, 200),
-                        prompt: bgDelegation.task,
-                        agentId: bgDelegation.toAgentId,
-                        requestedBy: agentId,
+                    this.messageQueue.enqueue(delegation.toAgentId, {
+                        prompt: delegation.task,
                         channelId: context.channelId,
                         source: 'slack',
+                        enqueuedAt: Date.now(),
+                        context,
                     });
-                    this.logger.log(`[MultiAgentSlack] Background delegation: ${agentId} -> ${bgDelegation.toAgentId} (async)`);
-                    const displayResponse = bgDelegation.originalContent ||
-                        `🔄 Background task submitted to *${toAgent?.display_name ?? bgDelegation.toAgentId}*`;
-                    const formattedResponse = this.formatAgentResponse(agent, displayResponse);
-                    return {
-                        agentId,
-                        agent,
-                        content: formattedResponse,
-                        rawContent: displayResponse,
-                        duration: result.duration_ms,
-                    };
+                    this.logger.log(`[MultiAgentSlack] Sync delegation (queued): ${agentId} -> ${delegation.toAgentId}`);
+                    this.tryDrainNow(delegation.toAgentId, 'slack', context.channelId).catch(() => { });
+                }
+                else {
+                    this.logger.log(`[MultiAgentSlack] Sync delegation denied: ${agentId} -> ${delegation.toAgentId}: ${check.reason}`);
                 }
             }
             // Format response with agent prefix
-            const formattedResponse = this.formatAgentResponse(agent, cleanedResponse);
+            const formattedResponse = this.formatAgentResponse(agent, displayResponse);
             return {
                 agentId,
                 agent,
@@ -605,11 +512,33 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
                     context,
                 };
                 this.messageQueue.enqueue(agentId, queuedMessage);
+                const queueSize = this.messageQueue.getQueueSize(agentId);
+                const queueText = queueSize > 0
+                    ? `⚠️ ${agent.display_name}이(가) 현재 작업 중입니다. ${queueSize}개의 메시지가 대기열에 있습니다.`
+                    : `⚠️ ${agent.display_name}이(가) 현재 작업 중입니다. 요청이 대기열에 등록되었습니다.`;
                 // Trigger immediate drain if process is idle or reaped
                 this.tryDrainNow(agentId, 'slack', context.channelId).catch(() => { });
-                return null;
+                return {
+                    agentId,
+                    agent,
+                    content: this.formatAgentResponse(agent, queueText),
+                    rawContent: queueText,
+                    duration: 0,
+                };
             }
-            return null;
+            const fallbackMessage = errMsg.toLowerCase().includes('timed out') || errMsg.toLowerCase().includes('timeout')
+                ? `⚠️ ${agent.display_name} 응답이 시간 초과되어 처리 결과를 못 받았습니다. 잠시 후 다시 시도해 주세요.`
+                : `⚠️ ${agent.display_name} 처리 중 오류가 발생했습니다: ${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 {
             if (process) {
@@ -819,8 +748,9 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
         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)
+            if (mentionedAgentIds.length === 0) {
                 continue;
+            }
             // Hard gate: block malformed delegations from can_delegate agents
             const senderAgent = this.orchestrator.getAgent(response.agentId);
             if (senderAgent?.can_delegate && (0, delegation_format_validator_js_1.isDelegationAttempt)(response.rawContent)) {
@@ -907,10 +837,7 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             return;
         }
         const agentStates = this.processManager.getAgentStates();
-        const prSessions = this.isPrReviewPollingEnabled()
-            ? this.prReviewPoller.getActiveSessions()
-            : [];
-        // Check if any agent is busy or PR polling is active
+        // Check if any agent is busy
         let hasBusy = false;
         for (const state of agentStates.values()) {
             if (state === 'busy' || state === 'starting') {
@@ -918,8 +845,8 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
                 break;
             }
         }
-        // Silent when no agents are busy AND no PR polling active
-        if (!hasBusy && prSessions.length === 0)
+        // Silent when no agents are busy
+        if (!hasBusy)
             return;
         // Build status line
         const agentConfigs = this.config.agents;
@@ -936,11 +863,7 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             }
             parts.push(entry);
         }
-        let statusLine = `⏱️ *Agent Status* | ${parts.join(' | ')}`;
-        // Append PR polling info
-        if (prSessions.length > 0) {
-            statusLine += ` | 👀 PR: ${prSessions.join(', ')}`;
-        }
+        const statusLine = `⏱️ *Agent Status* | ${parts.join(' | ')}`;
         try {
             await this.mainWebClient.chat.postMessage({
                 channel: this.heartbeatChannelId,
@@ -951,9 +874,6 @@ class MultiAgentSlackHandler extends multi_agent_base_js_1.MultiAgentHandlerBase
             this.logger.error('[Heartbeat] Failed to post status:', err);
         }
     }
-    isPrReviewPollingEnabled() {
-        return this.config.pr_review_poller?.enabled === true;
-    }
     /**
      * Get status of all agent bots
      */