@hailer/mcp 1.1.14 → 1.1.16

package/dist/agents/hal/daemon.js

@@ -0,0 +1,1385 @@
+"use strict";
+/**
+ * Orchestrator Daemon (HAL) - OMNIPOTENT HAILER ASSISTANT
+ *
+ * The definitive Hailer expert with FULL ACCESS to all 39+ MCP tools.
+ * HAL handles EVERYTHING - from simple queries to complex multi-step operations.
+ *
+ * HAL can:
+ * - Full workflow management (create, configure, update fields/phases)
+ * - Complete activity operations (CRUD, single and bulk)
+ * - SQL insight creation, previewing, and analytics
+ * - App management, scaffolding, and deployment
+ * - Template and marketplace operations
+ * - Discussion management, file handling, user searches
+ * - Billing and workspace balance checks
+ * - Coordinate specialists for collaborative tasks (rare)
+ *
+ * Specialists exist but are RARELY needed - HAL handles everything himself first.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestratorDaemon = void 0;
+const base_1 = require("../shared/base");
+const definitions_1 = require("./definitions");
+const logger_1 = require("../../lib/logger");
+const pending_fix_1 = require("../bug-fixer/registries/pending-fix");
+const pending_classification_1 = require("../bug-fixer/registries/pending-classification");
+class OrchestratorDaemon extends base_1.ChatAgentDaemon {
+    orchestratorLogger;
+    specialists = new Map();
+    activeSpecialistsInDiscussion = new Map(); // discussionId -> Set<specialistUserId>
+    specialistUserIds = new Map(); // specialistKey -> userId
+    toolsUsedInCurrentMessage = false; // Track if tools were used in current message processing
+    lastToolsUsed = []; // Track which tools were used (for silent success detection)
+    lastToolsFailed = false; // Track if any tool failed (to allow error reporting)
+    // Tools that should NOT trigger confirmation messages back to source chat (on SUCCESS only)
+    static SILENT_SUCCESS_TOOLS = new Set(['join_discussion']);
+    // Cross-discussion memory - remembers recent activity context
+    lastKnownActivityId = null;
+    lastKnownActivityName = null;
+    lastKnownActivityTime = 0;
+    static CONTEXT_MEMORY_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+    constructor(config) {
+        super(config);
+        this.orchestratorLogger = (0, logger_1.createLogger)({
+            component: "OrchestratorDaemon",
+            botId: config.botClient.userId,
+        });
+        // Register specialists from config (make copies to avoid cross-workspace contamination)
+        for (const [key, specialist] of Object.entries(definitions_1.SPECIALISTS)) {
+            // Clone the specialist so each orchestrator has its own instance
+            this.specialists.set(key, { ...specialist });
+        }
+        // Set specialist user IDs if provided
+        if (config.specialistUserIds) {
+            this.specialistUserIds = config.specialistUserIds;
+        }
+    }
+    /**
+     * Trigger HAL to respond in a discussion with specific context
+     * Used when bug monitor needs HAL to naturally inform users about Bug Fixer being disabled
+     */
+    async respondWithContext(discussionId, activityId, contextMessage) {
+        this.orchestratorLogger.info('Triggering contextual response', { discussionId, activityId });
+        try {
+            // Join the discussion first using MCP tool
+            await this.callMcpTool("join_discussion", { activityId });
+            // Get workspace ID from bot client cache
+            const workspaceId = this.config.botClient.workspaceCache?.currentWorkspace?._id || '';
+            // Create a synthetic incoming message with the context
+            const syntheticMessage = {
+                id: `synthetic-${Date.now()}`,
+                discussionId,
+                linkedActivityId: activityId,
+                workspaceId,
+                content: contextMessage,
+                senderName: 'System',
+                senderId: 'system',
+                timestamp: Date.now(),
+                priority: 'high',
+                priorityReason: 'system_notification',
+                isReplyToBot: false,
+                isMention: false,
+                isDirectMessage: false,
+            };
+            // Process through normal LLM pipeline
+            // This will make HAL respond naturally with the context
+            await this['processMessage'](syntheticMessage);
+        }
+        catch (error) {
+            this.orchestratorLogger.error('Failed to respond with context', { error });
+        }
+    }
+    // ===== AGENT DIRECTORY OVERRIDES =====
+    /**
+     * Override agent name for Agent Directory
+     * Uses the actual Hailer user name from BotClient (set in workspace)
+     */
+    getAgentName() {
+        // Use parent implementation which gets name from BotClient
+        return super.getAgentName();
+    }
+    /**
+     * Override agent description for Agent Directory
+     */
+    getAgentDescription() {
+        return "HAL - the omnipotent Hailer Assistant. Full access to 39+ MCP tools. Handles everything from simple queries to complex workflows, insights, and bulk operations. Can view apps but cannot create or manage them.";
+    }
+    /**
+     * Override Position details for Orchestrator
+     */
+    getPositionDetails() {
+        return {
+            name: "HAL - Omnipotent Hailer Assistant",
+            purpose: "THE definitive Hailer expert. Full access to 39+ MCP tools. Handles everything from simple queries to complex workflows, insights, bulk operations, and marketplace operations. Can view apps but cannot create or manage them.",
+            personaTone: "Sharp, efficient, and confident. Professional but approachable. Knows the platform inside and out.",
+            coreCapabilities: "- Full workflow management (create, configure, update fields/phases)\n- Complete activity operations (CRUD, bulk updates)\n- SQL insight creation and analytics\n- View apps (no creation or management)\n- Template and marketplace operations\n- Discussion management and file handling\n- User management and billing\n- Monitor all workspace discussions\n- Coordinate specialists for collaborative tasks (rare)",
+            boundaries: "- Never fabricate data - always use tools\n- Don't share credentials or sensitive config\n- Specialists available but rarely needed",
+        };
+    }
+    /**
+     * Full Hailer Expert - HAL can do everything a Hailer power user can do
+     */
+    getToolWhitelist() {
+        return [
+            // === WORKFLOW MANAGEMENT ===
+            "list_workflows",
+            "list_workflow_phases",
+            "get_workflow_schema",
+            "list_workflows_minimal",
+            "install_workflow",
+            "update_workflow_field",
+            "update_workflow_phase",
+            // === ACTIVITY OPERATIONS ===
+            "list_activities",
+            "show_activity_by_id",
+            "count_activities",
+            "create_activity",
+            "update_activity",
+            // === INSIGHT MANAGEMENT ===
+            "list_insights",
+            "create_insight",
+            "preview_insight",
+            "get_insight_data",
+            "update_insight",
+            // === APP MANAGEMENT ===
+            "list_apps", // View only
+            // === TEMPLATE & MARKETPLACE ===
+            "list_templates",
+            "get_template",
+            "create_template",
+            "install_template",
+            "publish_template",
+            "get_product",
+            "get_product_manifest",
+            "install_marketplace_app",
+            // === DISCUSSION TOOLS ===
+            "join_discussion",
+            "leave_discussion",
+            "add_discussion_message",
+            "invite_discussion_members",
+            "fetch_discussion_messages",
+            "fetch_previous_discussion_messages",
+            "get_activity_from_discussion",
+            "list_my_discussions",
+            // === USER & FILES ===
+            "search_workspace_users",
+            "download_file",
+            "upload_files",
+            // === BILLING ===
+            "get_workspace_balance",
+            // === ADVANCED ===
+            "test_function_field",
+        ];
+    }
+    /**
+     * Get allowed actions for structured outputs mode
+     * Maps to the tool whitelist but includes meta actions
+     */
+    getAllowedActions() {
+        return [
+            // Meta actions
+            "respond",
+            "ignore",
+            "invite_specialist",
+            // Same as tool whitelist
+            ...this.getToolWhitelist(),
+        ];
+    }
+    /**
+     * Handle specialist invitation from structured outputs
+     * Translates action to existing specialist coordination logic
+     */
+    async handleSpecialistInvite(specialistKey, context, originalMessage) {
+        const specialist = this.specialists.get(specialistKey);
+        if (!specialist) {
+            this.orchestratorLogger.warn("Unknown specialist requested", { specialistKey });
+            // Respond with error
+            await this.postResponse(originalMessage.discussionId, `I don't have a specialist available for "${specialistKey}". Available specialists: ${Array.from(this.specialists.keys()).join(", ")}`);
+            return;
+        }
+        // Use existing specialist invitation logic
+        await this.inviteSpecialist(specialist, originalMessage.discussionId, context || "");
+    }
+    /**
+     * Preprocess tool input - inject context for certain tools
+     * Uses cross-discussion memory to maintain context awareness
+     */
+    preprocessToolInput(toolName, input) {
+        // Force compact output for schema tools (avoid verbose field dumps in discussions)
+        if (toolName === "get_workflow_schema") {
+            return { ...input, compact: true };
+        }
+        // Auto-inject sourceActivityId for join_discussion
+        if (toolName === "join_discussion") {
+            // Debug: Log current context state
+            this.orchestratorLogger.debug("join_discussion context check", {
+                currentLinkedActivityId: this.currentLinkedActivityId || "none",
+                lastKnownActivityId: this.lastKnownActivityId || "none",
+                inputSourceActivityId: input.sourceActivityId || "none",
+                currentDiscussionId: this.currentDiscussionId || "none",
+            });
+            if (!input.sourceActivityId) {
+                // First try current message's linked activity
+                const currentActivityId = this.currentLinkedActivityId;
+                // Fall back to recent memory if within timeout
+                const memoryStillValid = Date.now() - this.lastKnownActivityTime < OrchestratorDaemon.CONTEXT_MEMORY_TIMEOUT;
+                const sourceActivityId = currentActivityId || (memoryStillValid ? this.lastKnownActivityId : null);
+                if (sourceActivityId) {
+                    this.orchestratorLogger.info("Auto-injected sourceActivityId", {
+                        sourceActivityId,
+                        fromCurrentMessage: !!currentActivityId,
+                        fromMemory: !currentActivityId && !!sourceActivityId,
+                    });
+                    input = { ...input, sourceActivityId };
+                }
+                else {
+                    this.orchestratorLogger.debug("No sourceActivityId available to inject", {
+                        currentLinkedActivityId: this.currentLinkedActivityId,
+                        lastKnownActivityId: this.lastKnownActivityId,
+                        memoryStillValid,
+                    });
+                }
+            }
+            // Always inject a default welcomeReason if user is being invited
+            // This ensures welcome messages are always posted
+            if (input.inviteUserId && !input.welcomeReason) {
+                const reason = this.lastKnownActivityName
+                    ? `Added from ${this.lastKnownActivityName} discussion`
+                    : "Added to this discussion";
+                this.orchestratorLogger.debug("Auto-injected welcomeReason", { reason });
+                input = { ...input, welcomeReason: reason };
+            }
+        }
+        return input;
+    }
+    /**
+     * Override to detect tool failures for silent success feature
+     */
+    async executeToolsAndContinue(toolUseBlocks, originalMessage) {
+        // Reset failure flag before executing tools
+        this.lastToolsFailed = false;
+        // Handle local tools (not sent to MCP)
+        const localToolResults = [];
+        const mcpToolBlocks = [];
+        for (const toolBlock of toolUseBlocks) {
+            if (toolBlock.name === 'trigger_bug_fixer_retry') {
+                // Handle locally - trigger Bug Fixer retry
+                const input = toolBlock.input;
+                const explanation = input.explanation || '';
+                const discussionId = originalMessage.discussionId;
+                const pendingFix = pending_fix_1.pendingFixRegistry.getPendingFix(discussionId);
+                if (!pendingFix) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending fix found for this discussion. The fix may have already been approved or cancelled.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    // Trigger the retry
+                    const success = await pending_fix_1.pendingFixRegistry.triggerRetry(discussionId, explanation);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? `✅ Triggered Bug Fixer retry with explanation: "${explanation.substring(0, 100)}...". Bug Fixer will analyze and apply a new fix.`
+                            : '❌ Failed to trigger retry. Bug Fixer may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'confirm_bug_fix') {
+                // Handle locally - trigger Bug Fixer fix confirmation
+                const discussionId = originalMessage.discussionId;
+                const hasPending = pending_classification_1.pendingClassificationRegistry.has(discussionId);
+                if (!hasPending) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending classification found for this discussion. Bug Fixer may have already processed it.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    const success = await pending_classification_1.pendingClassificationRegistry.triggerFixIt(discussionId);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? '✅ Triggered Bug Fixer to proceed with bug fix.'
+                            : '❌ Failed to trigger fix. Bug Fixer may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'decline_bug_report') {
+                // Handle locally - trigger Bug Fixer decline
+                const discussionId = originalMessage.discussionId;
+                const hasPending = pending_classification_1.pendingClassificationRegistry.has(discussionId);
+                if (!hasPending) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending classification found for this discussion. Bug Fixer may have already processed it.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    const success = await pending_classification_1.pendingClassificationRegistry.triggerNotABug(discussionId);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? '✅ Marked as not a bug. Report moved to Declined.'
+                            : '❌ Failed to decline. Bug Fixer may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else {
+                // Send to MCP
+                mcpToolBlocks.push(toolBlock);
+            }
+        }
+        // If we handled all tools locally, skip MCP execution
+        if (mcpToolBlocks.length === 0 && localToolResults.length > 0) {
+            const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+            conversation.push({
+                role: 'user',
+                content: localToolResults,
+            });
+            // Continue with LLM (with caching enabled)
+            const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+            const response = await this.client.messages.create({
+                model: this.config.model || 'claude-haiku-4-5-20251001',
+                max_tokens: 2000,
+                system: this.getCachedSystemPrompt(),
+                messages: cachedConversation,
+                tools: this.getToolsWithBugFixerRetry(),
+            });
+            // Track and burn tokens for local tool handling
+            const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
+            const localSession = this.sessionLogger.getSession(sessionKey);
+            if (localSession && response.usage) {
+                const inputTokens = response.usage.input_tokens;
+                const outputTokens = response.usage.output_tokens;
+                const cacheCreationTokens = response.usage.cache_creation_input_tokens || 0;
+                const cacheReadTokens = response.usage.cache_read_input_tokens || 0;
+                localSession.metrics.inputTokens += inputTokens;
+                localSession.metrics.outputTokens += outputTokens;
+                localSession.metrics.cacheCreationTokens += cacheCreationTokens;
+                localSession.metrics.cacheReadTokens += cacheReadTokens;
+                localSession.metrics.apiCalls += 1;
+                localSession.lastActivityTime = Date.now();
+                // Burn tokens real-time (fire-and-forget)
+                if (this.tokenBilling && localSession.workspaceId) {
+                    const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                    this.tokenBilling.burnTokens({
+                        workspaceId: localSession.workspaceId,
+                        inputTokens,
+                        outputTokens,
+                        cacheCreationTokens,
+                        cacheReadTokens,
+                        costUsd: cost,
+                        sessionId: localSession.discussionId,
+                        activityId: localSession.activityId,
+                    });
+                }
+            }
+            await this.handleLlmResponse(response, originalMessage);
+            return;
+        }
+        // If we have local results, add them to be processed together with MCP results
+        // (for now, just continue with original flow for MCP tools)
+        // Get current activity session
+        const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
+        const session = this.sessionLogger.getSession(sessionKey);
+        // Store the user's request that triggered these tool calls (for context)
+        if (session && !session.triggerRequest) {
+            session.triggerRequest = originalMessage.content.substring(0, 500);
+            session.requestedBy = originalMessage.senderName;
+            session.requestedById = originalMessage.senderId;
+        }
+        // Execute tools using the tool executor service
+        const toolResults = await this.toolExecutor.executeTools(toolUseBlocks, {
+            session,
+            preprocessToolInput: this.preprocessToolInput.bind(this),
+        });
+        // Check if any tool failed (detect various error patterns)
+        const anyToolFailed = toolResults.some(r => {
+            if (r.is_error)
+                return true;
+            // Check for error patterns in content (MCP tools return error text)
+            const content = r.content.toLowerCase();
+            return content.includes('error') || content.includes('failed') || content.includes('❌');
+        });
+        if (anyToolFailed) {
+            this.lastToolsFailed = true;
+            this.orchestratorLogger.debug("Tool failure detected", {
+                tools: this.lastToolsUsed,
+                failedCount: toolResults.filter(r => r.is_error).length,
+            });
+        }
+        // Get conversation for this discussion
+        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+        // Add tool results to conversation
+        conversation.push({
+            role: "user",
+            content: toolResults,
+        });
+        // Continue with LLM (with caching enabled)
+        const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+        const response = await this.client.messages.create({
+            model: this.config.model || "claude-haiku-4-5-20251001",
+            max_tokens: 2000,
+            system: this.getCachedSystemPrompt(),
+            messages: cachedConversation,
+            tools: this.minimalTools,
+        });
+        // Track token usage in session (including cache stats for billing)
+        if (session && response.usage) {
+            const inputTokens = response.usage.input_tokens;
+            const outputTokens = response.usage.output_tokens;
+            const cacheCreationTokens = response.usage.cache_creation_input_tokens || 0;
+            const cacheReadTokens = response.usage.cache_read_input_tokens || 0;
+            session.metrics.inputTokens += inputTokens;
+            session.metrics.outputTokens += outputTokens;
+            session.metrics.cacheCreationTokens += cacheCreationTokens;
+            session.metrics.cacheReadTokens += cacheReadTokens;
+            session.metrics.apiCalls += 1;
+            session.lastActivityTime = Date.now();
+            // Burn tokens real-time (fire-and-forget) - inherited from base
+            if (this.tokenBilling && session.workspaceId) {
+                const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                this.tokenBilling.burnTokens({
+                    workspaceId: session.workspaceId,
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationTokens,
+                    cacheReadTokens,
+                    costUsd: cost,
+                    sessionId: session.discussionId,
+                    activityId: session.activityId,
+                });
+            }
+        }
+        // Recursively handle (might need more tools or finally respond)
+        await this.handleLlmResponse(response, originalMessage);
+    }
+    /**
+     * Update cross-discussion memory when processing messages
+     * Call this when entering an activity discussion to remember context
+     */
+    updateContextMemory(activityId, activityName) {
+        if (activityId) {
+            this.lastKnownActivityId = activityId;
+            this.lastKnownActivityName = activityName;
+            this.lastKnownActivityTime = Date.now();
+            this.orchestratorLogger.debug("Updated context memory", { activityId, activityName });
+        }
+    }
+    /**
+     * Override to update cross-discussion memory when entering activity discussions
+     */
+    async extractIncomingMessage(signal) {
+        const message = await super.extractIncomingMessage(signal);
+        // Update context memory if this message is from an activity discussion
+        if (message?.linkedActivityId) {
+            this.updateContextMemory(message.linkedActivityId, message.linkedActivityName || null);
+        }
+        return message;
+    }
+    /**
+     * Register a specialist's Hailer user ID
+     * Called during initialization when we know the specialist bot's user ID
+     */
+    registerSpecialistUserId(specialistKey, userId, displayName) {
+        this.specialistUserIds.set(specialistKey, userId);
+        const specialist = this.specialists.get(specialistKey);
+        if (specialist) {
+            specialist.botUserId = userId;
+            if (displayName) {
+                specialist.displayName = displayName;
+            }
+            this.orchestratorLogger.info("Specialist registered", {
+                key: specialistKey,
+                name: specialist.name,
+                displayName: specialist.displayName || specialist.name,
+                userId,
+            });
+        }
+    }
+    /**
+     * Unregister a specialist (called when specialist is disabled/stopped)
+     * This prevents HAL from trying to invite a disabled specialist
+     */
+    unregisterSpecialist(specialistKey) {
+        const specialist = this.specialists.get(specialistKey);
+        if (specialist) {
+            specialist.botUserId = undefined; // Mark as unavailable
+            this.orchestratorLogger.info("Specialist unregistered", {
+                key: specialistKey,
+                name: specialist.name,
+            });
+        }
+        this.specialistUserIds.delete(specialistKey);
+    }
+    /**
+     * Mark a specialist as active in a discussion
+     */
+    markSpecialistActive(discussionId, specialistUserId) {
+        if (!this.activeSpecialistsInDiscussion.has(discussionId)) {
+            this.activeSpecialistsInDiscussion.set(discussionId, new Set());
+        }
+        this.activeSpecialistsInDiscussion.get(discussionId).add(specialistUserId);
+    }
+    /**
+     * Invite a specialist to a discussion
+     * Always invites first (tool handles membership check), then tags
+     */
+    async inviteSpecialist(specialist, discussionId, handoffContext) {
+        const specialistUserId = specialist.botUserId;
+        const displayName = specialist.displayName || specialist.name;
+        if (!specialistUserId) {
+            this.orchestratorLogger.warn("Specialist has no user ID", {
+                name: specialist.name,
+            });
+            return false;
+        }
+        try {
+            this.orchestratorLogger.info("Inviting specialist to discussion", {
+                name: specialist.name,
+                displayName,
+                userId: specialistUserId,
+                discussionId,
+            });
+            // Always call invite - the tool checks if already a member and handles gracefully
+            await this.callMcpTool("invite_discussion_members", {
+                discussionId,
+                userIds: [specialistUserId],
+            });
+            this.markSpecialistActive(discussionId, specialistUserId);
+            // Post handoff message with Hailer tag format using actual display name
+            await this.postResponse(discussionId, `[hailerTag|${displayName}](${specialistUserId}) - ${handoffContext}`);
+            this.orchestratorLogger.info("Specialist invited successfully", {
+                name: specialist.name,
+                displayName,
+                discussionId,
+            });
+            return true;
+        }
+        catch (error) {
+            this.orchestratorLogger.error("Failed to invite specialist", {
+                name: specialist.name,
+                displayName,
+                discussionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Override getTools to include Bug Fixer retry tool when there's a pending fix
+     */
+    getTools() {
+        // Always include the Bug Fixer retry tool so LLM knows about it
+        return this.getToolsWithBugFixerRetry();
+    }
+    /**
+     * Get tools list with Bug Fixer retry tool added
+     */
+    getToolsWithBugFixerRetry() {
+        const bugFixerRetryTool = {
+            name: 'trigger_bug_fixer_retry',
+            description: 'Trigger Bug Fixer to retry fixing a bug with new explanation. Use this after gathering enough info about what went wrong with the previous fix. Only works in discussions with a pending bug fix.',
+            input_schema: {
+                type: 'object',
+                properties: {
+                    explanation: {
+                        type: 'string',
+                        description: 'Clear explanation of what is wrong with the current fix and what the expected behavior should be. Include: (1) what is broken, (2) expected vs actual behavior, (3) any specific details the user mentioned.',
+                    },
+                },
+                required: ['explanation'],
+            },
+        };
+        const confirmBugFixTool = {
+            name: 'confirm_bug_fix',
+            description: 'Confirm that a bug report should be fixed. Use when user indicates they want the bug fixed (variations of "fix it", "yes fix", "please fix", etc.). Only works in discussions with a pending classification.',
+            input_schema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        };
+        const declineBugReportTool = {
+            name: 'decline_bug_report',
+            description: 'Decline a bug report as not actually a bug. Use when user indicates it\'s not a bug (variations of "not a bug", "feature request", "not actually broken", etc.). Only works in discussions with a pending classification.',
+            input_schema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        };
+        return [...this.minimalTools, bugFixerRetryTool, confirmBugFixTool, declineBugReportTool];
+    }
+    /**
+     * Get pending fix context for a discussion (if any)
+     */
+    getPendingFixContext(discussionId) {
+        const pendingFix = pending_fix_1.pendingFixRegistry.getPendingFix(discussionId);
+        if (!pendingFix) {
+            return '';
+        }
+        return `
+<pending_bug_fix>
+**IMPORTANT: This discussion has a pending bug fix from Bug Fixer!**
+
+- Bug ID: ${pendingFix.bugId}
+- State: ${pendingFix.state}
+- Fix Summary: ${pendingFix.fixSummary}
+
+**Your role:**
+- If user says "approved" → Bug Fixer handles it automatically (you do nothing)
+- If user expresses ANY dissatisfaction (denied, not working, still broken, etc.):
+  1. Ask what's wrong (if not clear)
+  2. Gather: what's broken + expected behavior
+  3. Use trigger_bug_fixer_retry tool with the explanation
+
+**Remember:** You're gathering info for Bug Fixer. Be concise, ask ONE question at a time.
+</pending_bug_fix>
+`;
+    }
+    /**
+     * Get pending classification context for a discussion (if any)
+     */
+    getPendingClassificationContext(discussionId) {
+        const pending = pending_classification_1.pendingClassificationRegistry.getPendingClassification(discussionId);
+        if (!pending) {
+            return '';
+        }
+        const classificationLabel = pending.classification === 'bug' ? 'Bug' :
+            pending.classification === 'feature_request' ? 'Feature Request' : 'Unclear';
+        return `
+<pending_classification>
+**IMPORTANT: Bug Fixer just classified this report and is waiting for user decision!**
+
+- Bug: ${pending.bugName}
+- App: ${pending.appName || pending.appId || 'Unknown'}
+- Classification: ${classificationLabel}
+- Reason: ${pending.reason}
+
+**User options:**
+- "fix it" → Bug Fixer will proceed to fix the bug
+- "not a bug" → Report will be moved to Declined
+
+**Your role - Use tools for user intent:**
+- User wants to fix the bug → Call confirm_bug_fix tool
+- User says it's not a bug / feature request → Call decline_bug_report tool
+- User has questions → Help explain the classification
+
+**Detecting intent (use tools, don't wait for exact words):**
+- "fix it", "yes fix", "go ahead", "please fix", "fix this" → confirm_bug_fix
+- "not a bug", "feature request", "not broken", "close it", "decline" → decline_bug_report
+
+**Remember:** Use the tools to trigger actions. Don't tell user to type magic words.
+</pending_classification>
+`;
+    }
+    /**
+     * Get the STATIC portion of the system prompt (cacheable)
+     * This contains all content that doesn't change between calls for this bot instance
+     */
+    getStaticSystemPrompt() {
+        const { firstName, lastName } = this.getAgentName();
+        const fullName = `${firstName} ${lastName}`.trim();
+        return `<identity>
+You are ${fullName} - the OMNIPOTENT Hailer Assistant. The full Hailer expert.
+Bot ID: ${this.botClient.userId}
+
+You are THE definitive Hailer power user. You have FULL ACCESS to ALL Hailer capabilities:
+workflows, activities, insights, apps, templates, marketplace, discussions, files, and more.
+You handle EVERYTHING yourself - from simple queries to complex multi-step operations.
+
+Specialists exist but are RARELY needed. You should ALWAYS try to solve tasks yourself first.
+Only consider specialists for truly collaborative multi-person tasks that benefit from
+parallel work or when you explicitly want to demonstrate specialist capabilities.
+</identity>
+
+<personality>
+**BUSINESS MODE** (default):
+- Professional, direct, competent
+- Get things done efficiently
+- Provide accurate information
+- Confident in your full capabilities
+
+**SARCASM MODE** (for ridiculous requests):
+- Dry wit, not mean-spirited
+- Still help after the gentle mockery
+</personality>
+
+<memory_awareness>
+**When users ask about your memory or what you remember:**
+
+You have access to the current discussion's message history. On each conversation:
+- You load the last 15 messages from this discussion
+- You remember everything said in THIS discussion thread
+- Cross-session memory (what happened in OTHER discussions) is not available
+
+**How to respond to "what do you remember?":**
+- Keep it brief and positive
+- Focus on what you CAN see (this discussion)
+- Don't over-explain limitations
+- If they want to reference past work, ask them to remind you of the context
+
+**Good response:** "I can see our conversation in this thread. What specifically would you like me to recall or work on?"
+
+**Bad response:** "That's a great question. Honestly, I don't have access to your previous conversation history with me..." (too verbose, focuses on limitations)
+</memory_awareness>
+
+<decision_framework>
+For each message, decide:
+
+1. **HIGH PRIORITY** (priority="high") - ALWAYS RESPOND:
+   - Direct messages (1:1) -> respond helpfully
+   - @mentions -> respond (even if just a greeting - acknowledge and ask how you can help)
+   - Replies to your messages -> respond
+   - **NEVER use <ignore/> for HIGH priority. Always acknowledge the user.**
+
+2. **NORMAL PRIORITY** (general chat) - STRICT FILTERING:
+
+   **RESPOND ONLY IF the message:**
+   - Explicitly asks about Hailer (workflows, activities, insights, apps, discussions)
+   - Requests to find/list/create/update workspace data
+   - Discusses a specific activity, customer, project, or workflow by name
+   - You can genuinely help with workspace-related context
+   - Is a complex task needing specialist help
+
+   **IGNORE (output <ignore/>) for NORMAL priority if:**
+   - Random characters, gibberish, keyboard mashing (no real words, repeated patterns)
+   - General chit-chat unrelated to workspace ("how are you", jokes)
+   - Conversations between other users that don't need you
+   - Bare greetings without a question ("hi", "hey") - but NOT if HIGH priority!
+   - Off-topic discussions (sports, weather, personal chat)
+   - Anything you're uncertain about
+
+   **CRITICAL:** For NORMAL priority only - if no clear workspace-related question/task, output <ignore/>.
+   When in doubt about NORMAL priority, IGNORE. Your DEFAULT for normal priority is <ignore/>.
+
+3. **RESPOND FORMAT** (only when you have something helpful):
+   <respond discussion="DISCUSSION_ID">
+   Your response
+   </respond>
+
+4. **IGNORE FORMAT** (use liberally - this is your DEFAULT):
+   <ignore/>
+</decision_framework>
+
+<specialist_guidelines>
+**YOU ARE THE EXPERT - Handle everything yourself first!**
+
+You have FULL ACCESS to all 39+ MCP tools. You can do EVERYTHING:
+- Create workflows, configure fields and phases
+- Build insights with SQL queries
+- Perform bulk operations on activities
+- Generate reports and dashboards
+- Manage apps and marketplace items
+- Handle complex multi-step workflows
+
+**When to HANDLE YOURSELF (almost always):**
+- ALL workflow operations (create, configure, update)
+- ALL insight creation (SQL queries, dashboards, reports)
+- ALL bulk operations (even 100+ items)
+- Complex multi-step data tasks
+- Activity CRUD (single or bulk)
+- File handling and attachments
+- User searches and invitations
+- Template and marketplace operations
+- App management
+
+**When specialists MIGHT help (rare):**
+- User explicitly requests collaborative work with multiple bots
+- Demonstrating specialist capabilities to users
+- Long-running parallel tasks where multiple agents working simultaneously adds value
+
+**DEFAULT BEHAVIOR:** Do it yourself. You're the Hailer expert.
+
+<invite_syntax>
+<invite specialist="specialistKey">
+Clear description of what you need done.
+Include relevant context from the conversation.
+</invite>
+</invite_syntax>
+
+<invite_rules>
+**CRITICAL: NEVER use tools to invite or tag specialists directly!**
+- DO NOT use invite_discussion_members for specialists
+- DO NOT use add_discussion_message with [hailerTag|...] for specialists
+- ALWAYS use the <invite specialist="key">...</invite> XML pattern
+
+The system will handle inviting the specialist to the discussion and tagging them.
+If you try to invite/tag specialists directly via tools, they may not receive the message.
+</invite_rules>
+
+<handoff_rules>
+If you DO invite a specialist (rare), include all gathered IDs:
+
+<bad_handoff>
+"Create an insight for the Injuries workflow showing player data"
+</bad_handoff>
+
+<good_handoff>
+"Create insight for Injuries workflow:
+- workflowId: 691ffdf84217e9e8434e56ad
+- Fields: { name: 'playerName', fieldId: '691ffdf84217e9e8434e56b1' }, { name: 'injuryType', fieldId: '691ffdf84217e9e8434e56b2' }
+- Query: SELECT name as \\"Activity\\", playerName, injuryType FROM injuries ORDER BY name"
+</good_handoff>
+
+<insight_field_format>
+Always format fields as: { name: 'Column Name', fieldId: 'FIELD_ID' }
+Use 'fieldId' not 'id' for the field identifier.
+</insight_field_format>
+</handoff_rules>
+
+<after_invite>
+1. I invite them to the discussion
+2. I post your handoff message mentioning them
+3. They see it and take action
+</after_invite>
+</specialist_guidelines>
+
+<tagging_syntax>
+To @mention someone in Hailer, use this format:
+[hailerTag|Display Name](userId)
+
+Example: [hailerTag|User Name](userId)
+
+For specialists, use their display name and userId from the specialists list.
+Do NOT use plain @mentions like "@hailerExpert" - they won't work.
+</tagging_syntax>
+
+<bug_fixer_autonomous>
+**Bug Fixer - Autonomous Bug Fixer**
+
+Bug Fixer is SPECIAL - he works AUTONOMOUSLY, not through invites!
+
+**How Bug Fixer works:**
+1. Users create a bug report in the "Bug Reports" workflow
+2. Bug Fixer automatically detects new bugs and starts fixing them
+3. He analyzes the code, generates a fix, tests it
+4. He asks the user to verify with "approved" or "denied"
+5. On "approved" → Bug Fixer publishes to production automatically
+6. On "denied" or complaint → YOU (HAL) gather info, then trigger Bug Fixer retry
+
+**YOUR ROLE IN BUG FIX DENIALS:**
+When a discussion has a pending bug fix and the user expresses dissatisfaction:
+1. YOU handle the conversation - ask what's wrong, what behavior they expected
+2. Gather enough context: what's broken, expected vs actual behavior
+3. Once you have clear info, use trigger_bug_fixer_retry tool to pass the explanation
+4. Bug Fixer will receive your gathered info and retry the fix
+
+**Detecting denial signals:**
+- "denied", "not working", "still broken", "wrong", "doesn't work"
+- Any complaint about the fix behavior
+- User describing unexpected behavior
+
+**Gathering info (ask ONE question at a time):**
+- "What behavior are you seeing?"
+- "What did you expect to happen instead?"
+- "Is the issue consistent or intermittent?"
+
+**When to trigger retry:**
+Once you have: (1) what's wrong, (2) expected behavior → trigger the retry
+
+**When someone mentions bugs (NEW bugs):**
+- Tell them to create a bug report in "Bug Reports" workflow
+- Explain Bug Fixer will pick it up automatically
+- Offer to help create the bug report for them
+</bug_fixer_autonomous>
+
+<your_tools>
+**YOU HAVE FULL ACCESS TO ALL 39+ HAILER MCP TOOLS:**
+
+**WORKFLOW MANAGEMENT:**
+- list_workflows, list_workflows_minimal - Browse all workflows
+- list_workflow_phases - Get phases for a workflow
+- get_workflow_schema - Get field definitions (use compact: true)
+- install_workflow - Create new workflows from templates
+- update_workflow_field - Modify field properties
+- update_workflow_phase - Modify phase properties
+
+**ACTIVITY OPERATIONS:**
+- list_activities - Query activities with filters
+- show_activity_by_id - Get full activity details
+- count_activities - Get activity counts
+- create_activity - Create single or BULK activities
+- update_activity - Update single or BULK activities
+
+**INSIGHT MANAGEMENT (SQL Analytics):**
+- list_insights - Browse existing insights
+- preview_insight - Test SQL queries before saving
+- create_insight - Save new SQL insights
+- get_insight_data - Execute and get results
+- update_insight - Modify existing insights
+
+**APP MANAGEMENT:**
+- list_apps (view only)
+
+**TEMPLATE & MARKETPLACE:**
+- list_templates, get_template, create_template, install_template
+- publish_template - Publish workspace as template
+- get_product, get_product_manifest
+- install_marketplace_app, publish_app
+
+**DISCUSSION TOOLS:**
+- join_discussion, leave_discussion
+- add_discussion_message - Post messages
+- invite_discussion_members - Add users to chats
+- fetch_discussion_messages, fetch_previous_discussion_messages
+- get_activity_from_discussion, list_my_discussions
+
+**USER & FILES:**
+- search_workspace_users - Find users by name
+- upload_files, download_file - Handle file attachments
+
+**BILLING:**
+- get_workspace_balance - Check token balance
+
+**ADVANCED:**
+- test_function_field - Test computed field functions
+
+**You are the FULL Hailer expert. Use these tools directly - no need to delegate!**
+
+**CRITICAL for join_discussion when inviting users:**
+ALWAYS pass these parameters from the incoming message:
+- inviteUserId = user_id attribute
+- sourceActivityId = activity_id attribute (creates "came from" link!)
+- welcomeReason = why they're being invited
+
+**join_discussion ID types:**
+- HailerTags like [hailerTag|Name](ID) usually contain ACTIVITY IDs, not discussion IDs
+- When user references an activity/player/customer by tag, use: activityId parameter
+- Only use discussionId for direct discussion links (rare)
+- The tool auto-detects: if discussionId fails, it tries as activityId
+
+**SILENT SUCCESS for join_discussion:**
+After successfully joining a discussion, do NOT post a confirmation message back to the source chat.
+The action is self-evident (bot appears in target discussion). Only report ERRORS back to source chat.
+
+**CRITICAL - Extract IDs from context:**
+The <incoming> tag contains IDs. ALWAYS use them:
+- activityId attribute → pass to show_activity_by_id, update_activity
+- discussionId attribute → pass to get_activity_from_discussion, add_discussion_message
+
+**NEVER call tools with empty parameters {}** - always extract from context first.
+
+**update_activity formats:**
+- Single mode: use \`activityId\` parameter
+- Bulk mode (activities array): use \`_id\` inside each object, NOT \`activityId\`
+
+**Field values must be plain:**
+- numericunit: just the number → \`78\` (NOT \`{"type":"numericunit","value":78}\`)
+- text: just the string → \`"hello"\`
+- activitylink: just the ID → \`"abc123..."\`
+</your_tools>
+
+<file_handling>
+**When users drop files in chat:**
+
+The incoming message will contain file attachment info like:
+\`[File attached: 1 file(s) - IDs: abc123...]\`
+
+**To read a file:** Use \`download_file\` with the fileId to read its contents.
+
+**To attach a file to an EXISTING activity:**
+The Hailer API doesn't support adding files via update_activity. Instead:
+1. Get the activity's discussion ID using \`show_activity_by_id\`
+2. Join the discussion using \`join_discussion(activityId: "...")\`
+3. Post the file using \`add_discussion_message\` with the fileId:
+   \`add_discussion_message(discussionId: "...", content: "Attaching file", fileIds: ["abc123"])\`
+
+The file will appear in the activity's discussion thread.
+
+**To attach a file to a NEW activity:**
+Use \`create_activity\` with the \`fileIds\` parameter - this works directly.
+
+**Key point:** When a user drops a file, it's already uploaded to Hailer. Use the fileId directly - no need to re-upload.
+</file_handling>
+
+<tagging>
+**Activity Tags:** #ACTIVITY_ID (24-char hex)
+- Correct: "Check out #691ffe874217e9e8434e57fc"
+- Wrong: "Check out #691ffe874217e9e8434e57fc (Name)" - name auto-displays
+
+**User Mentions:** @"Full Name" or @userId
+</tagging>
+
+<agentic_loop>
+**CRITICAL: The 'respond' action ENDS YOUR TURN!**
+
+When you output {"action": "respond", ...}, your turn ENDS IMMEDIATELY.
+You CANNOT call any more tools after responding. There is NO "next turn".
+
+**THIS WILL FAIL (you lose your turn before doing work):**
+{"action": "respond", "response_text": "Let me check that for you..."}
+→ Message posted, turn ends, NO tools called!
+
+**THIS IS CORRECT (gather data FIRST, then respond):**
+1. {"action": "list_workflow_phases", "params": {...}}  → get phases
+2. {"action": "get_workflow_schema", "params": {...}}   → get fields
+3. {"action": "list_activities", "params": {...}}       → get data
+4. {"action": "respond", "response_text": "Here are the 3 injured players: ..."}  → FINAL answer
+
+**FORBIDDEN response_text patterns:**
+- "Let me check..." / "I'll look into..." / "One moment..."
+- "Working on it..." / "I'm going to..."
+- ANY promise of future work
+
+**ONLY respond when you have the ACTUAL ANSWER.**
+</agentic_loop>
+
+<rules>
+- Be concise - snappy responses, not essays
+- Use your memory - reference past conversations
+- For HIGH priority: respond immediately with work, not promises
+- For NORMAL priority: your DEFAULT is "ignore" action. Only respond if clear workspace question.
+- **Gibberish test:** No recognizable words = "ignore" action
+- **Relevance test:** Is this about workflows/activities/insights? If not = "ignore" action
+- When inviting specialists, explain what's happening
+- **NEVER use "respond" until you have gathered ALL needed data via tool actions**
+</rules>`;
+    }
+    /**
+     * Get the DYNAMIC portion of the system prompt (not cacheable)
+     * This contains time-sensitive and per-call context
+     */
+    getDynamicContext() {
+        // Round time to 5-minute intervals to allow cache reuse
+        // Without this, every request has a different timestamp, killing the cache
+        const now = new Date();
+        const fiveMinutes = 5 * 60 * 1000;
+        const roundedTime = new Date(Math.floor(now.getTime() / fiveMinutes) * fiveMinutes);
+        // Build specialist info for prompt - ONLY show available specialists
+        const availableSpecialists = Array.from(this.specialists.entries())
+            .filter(([_, spec]) => !!spec.botUserId);
+        const specialistInfo = availableSpecialists.length > 0
+            ? availableSpecialists
+                .map(([key, spec]) => {
+                const mentionName = spec.displayName || spec.name;
+                return `- **${spec.name}** (available)
+  Tag with: [hailerTag|${mentionName}](${spec.botUserId})
+  Key for invite tag: ${key}
+  Expertise: ${spec.expertise.join(", ")}
+  Triggers: ${spec.triggerKeywords.slice(0, 5).join(", ")}`;
+            })
+                .join("\n\n")
+            : `**NO SPECIALISTS ARE CURRENTLY ENABLED.**
+DO NOT invent, fabricate, or mention any specialist names.
+DO NOT use <invite> tags. DO NOT claim to "hand off" to anyone.
+Handle all requests yourself or tell the user: "No specialists are enabled. You can enable them in AI Hub."`;
+        return `<current_time>${roundedTime.toISOString()}</current_time>
+
+<specialists>
+${specialistInfo}
+</specialists>
+
+${this.currentDiscussionId ? this.getPendingFixContext(this.currentDiscussionId) : ''}
+${this.currentDiscussionId ? this.getPendingClassificationContext(this.currentDiscussionId) : ''}`;
+    }
+    /**
+     * Override system prompt to combine static and dynamic parts
+     * Used for backwards compatibility
+     */
+    getSystemPrompt() {
+        return this.getStaticSystemPrompt() + "\n\n" + this.getDynamicContext();
+    }
+    /**
+     * Override to return cached system prompt with proper structure
+     * Static content is cached (50% cost reduction), dynamic content appended fresh
+     */
+    getCachedSystemPrompt() {
+        return [
+            {
+                type: "text",
+                text: this.getStaticSystemPrompt(),
+                cache_control: { type: "ephemeral" },
+            },
+            {
+                type: "text",
+                text: this.getDynamicContext(),
+            },
+        ];
+    }
+    /**
+     * Override response handling to detect specialist invitations
+     */
+    async handleLlmResponse(response, originalMessage) {
+        // Get conversation for this discussion
+        const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+        // Add assistant response to conversation
+        // Cast response content to MessageParam content type (ContentBlock[] → ContentBlockParam[])
+        conversation.push({
+            role: "assistant",
+            content: response.content,
+        });
+        // Check for specialist invitation in text content
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        const textContent = textBlocks.map((b) => b.text).join("\n");
+        // Look for <invite specialist="...">...</invite> pattern
+        const inviteMatch = textContent.match(/<invite specialist="(\w+)">([\s\S]*?)<\/invite>/);
+        if (inviteMatch) {
+            const [_fullMatch, specialistKey, handoffContext] = inviteMatch;
+            const specialist = this.specialists.get(specialistKey);
+            if (specialist && specialist.botUserId) {
+                this.orchestratorLogger.info("LLM requested specialist invitation", {
+                    specialist: specialistKey,
+                    discussionId: originalMessage.discussionId,
+                });
+                // Extract any text before the invite tag to post as acknowledgment
+                const preInviteText = textContent
+                    .substring(0, textContent.indexOf("<invite"))
+                    .trim();
+                // Check for respond wrapper
+                const respondMatch = preInviteText.match(/<respond discussion="([^"]+)">([\s\S]*)/);
+                if (respondMatch) {
+                    const [, discussionId, content] = respondMatch;
+                    const cleanContent = content.replace(/<\/respond>.*$/s, "").trim();
+                    if (cleanContent) {
+                        await this.postResponse(discussionId, cleanContent);
+                    }
+                }
+                else if (preInviteText) {
+                    // No respond wrapper, but there's text - might be for high priority
+                    if (originalMessage.priority === "high") {
+                        await this.postResponse(originalMessage.discussionId, preInviteText);
+                    }
+                }
+                // Invite the specialist
+                const invited = await this.inviteSpecialist(specialist, originalMessage.discussionId, handoffContext.trim());
+                if (!invited) {
+                    // Failed to invite - let user know
+                    await this.postResponse(originalMessage.discussionId, `I tried to bring in ${specialist.name} but couldn't reach them. Let me try handling this myself...`);
+                    // Continue with normal handling
+                }
+                return; // Don't continue with normal response handling
+            }
+            else {
+                // Specialist is disabled - feed back to LLM for natural response
+                this.orchestratorLogger.info("Specialist disabled, asking LLM to respond naturally", {
+                    key: specialistKey,
+                    name: specialist?.name || specialistKey,
+                });
+                // Add system feedback to conversation so LLM knows the specialist is unavailable
+                const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+                conversation.push({
+                    role: 'user',
+                    content: `[SYSTEM: The specialist "${specialist?.name || specialistKey}" you tried to invite is currently disabled. Please inform the user naturally that this specialist is not available and they can enable it in the AI Hub settings if needed. Do NOT use XML tags in your response.]`,
+                });
+                // Get LLM to respond naturally about the unavailability (with caching enabled)
+                const cachedConversation = this.conversationManager.prepareForCaching(conversation);
+                const retryResponse = await this.client.messages.create({
+                    model: this.config.model || 'claude-haiku-4-5-20251001',
+                    max_tokens: 1000,
+                    system: this.getCachedSystemPrompt(),
+                    messages: cachedConversation,
+                    tools: this.getTools(),
+                });
+                // Track and burn tokens for specialist unavailable retry
+                const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
+                const retrySession = this.sessionLogger.getSession(sessionKey);
+                if (retrySession && retryResponse.usage) {
+                    const inputTokens = retryResponse.usage.input_tokens;
+                    const outputTokens = retryResponse.usage.output_tokens;
+                    const cacheCreationTokens = retryResponse.usage.cache_creation_input_tokens || 0;
+                    const cacheReadTokens = retryResponse.usage.cache_read_input_tokens || 0;
+                    retrySession.metrics.inputTokens += inputTokens;
+                    retrySession.metrics.outputTokens += outputTokens;
+                    retrySession.metrics.cacheCreationTokens += cacheCreationTokens;
+                    retrySession.metrics.cacheReadTokens += cacheReadTokens;
+                    retrySession.metrics.apiCalls += 1;
+                    retrySession.lastActivityTime = Date.now();
+                    // Burn tokens real-time (fire-and-forget)
+                    if (this.tokenBilling && retrySession.workspaceId) {
+                        const cost = this.tokenBilling.calculateCost(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
+                        this.tokenBilling.burnTokens({
+                            workspaceId: retrySession.workspaceId,
+                            inputTokens,
+                            outputTokens,
+                            cacheCreationTokens,
+                            cacheReadTokens,
+                            costUsd: cost,
+                            sessionId: retrySession.discussionId,
+                            activityId: retrySession.activityId,
+                        });
+                    }
+                }
+                // Process the retry response (should be a simple text response)
+                await this.handleLlmResponse(retryResponse, originalMessage);
+                return;
+            }
+        }
+        // Check for tool calls
+        const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
+        if (toolUseBlocks.length > 0) {
+            // Mark that tools were used - subsequent responses should be posted
+            this.toolsUsedInCurrentMessage = true;
+            // Track which tools were used (for silent success detection)
+            this.lastToolsUsed = toolUseBlocks.map(b => b.name);
+            // Execute tools and continue conversation
+            await this.executeToolsAndContinue(toolUseBlocks, originalMessage);
+            return;
+        }
+        // Check for regular response (no invite, no tools)
+        if (textBlocks.length > 0) {
+            const responseText = textContent.trim();
+            this.orchestratorLogger.info("LLM raw response", {
+                discussion: originalMessage.discussionId,
+                priority: originalMessage.priority,
+                responseLength: responseText.length,
+                fullResponse: responseText.substring(0, 500),
+                hasIgnoreTag: responseText.includes("<ignore"),
+                hasRespondTag: responseText.includes("<respond"),
+            });
+            // Check for IGNORE decision - remove from context to keep it clean
+            if (responseText.includes("<decision>IGNORE</decision>") ||
+                responseText.includes("<ignore")) {
+                this.orchestratorLogger.debug("LLM decided to ignore - removing from context", {
+                    discussion: originalMessage.discussionId,
+                });
+                // Stop typing indicator
+                this.typingIndicator?.stop();
+                // Remove both the assistant's response AND the incoming message from context
+                conversation.pop(); // Remove assistant response we just added
+                conversation.pop(); // Remove the incoming message
+                this.toolsUsedInCurrentMessage = false; // Reset for next message
+                return;
+            }
+            // Check for explicit response directive
+            const responseMatch = responseText.match(/<respond discussion="([^"]+)">([\s\S]*?)<\/respond>/);
+            if (responseMatch) {
+                const targetDiscussion = responseMatch[1];
+                const content = responseMatch[2].trim();
+                // SILENT SUCCESS: Skip confirmation if we just ran a silent tool successfully (not on error)
+                const usedSilentTool = this.lastToolsUsed.some(t => OrchestratorDaemon.SILENT_SUCCESS_TOOLS.has(t));
+                if (usedSilentTool && !this.lastToolsFailed) {
+                    this.orchestratorLogger.debug("Suppressing confirmation for silent success tool", {
+                        discussion: originalMessage.discussionId,
+                        tools: this.lastToolsUsed,
+                    });
+                    // Stop typing indicator
+                    this.typingIndicator?.stop();
+                    // NOTE: Don't pop from context - keep conversation valid for future messages
+                    this.toolsUsedInCurrentMessage = false;
+                    this.lastToolsUsed = [];
+                    this.lastToolsFailed = false;
+                    return;
+                }
+                await this.postResponse(targetDiscussion, content);
+                this.toolsUsedInCurrentMessage = false; // Reset for next message
+                this.lastToolsUsed = [];
+                this.lastToolsFailed = false;
+                return;
+            }
+            // For high priority messages, always send substantive responses
+            // (unless we just ran a silent success tool)
+            if (originalMessage.priority === "high" &&
+                responseText &&
+                !responseText.includes("<thinking>") &&
+                !responseText.startsWith("I'll") &&
+                responseText.length > 10) {
+                // SILENT SUCCESS: Skip confirmation if we just ran a silent tool successfully (not on error)
+                const usedSilentTool = this.lastToolsUsed.some(t => OrchestratorDaemon.SILENT_SUCCESS_TOOLS.has(t));
+                if (usedSilentTool && !this.lastToolsFailed) {
+                    this.orchestratorLogger.debug("Suppressing high-priority confirmation for silent success tool", {
+                        discussion: originalMessage.discussionId,
+                        tools: this.lastToolsUsed,
+                    });
+                    // Stop typing indicator
+                    this.typingIndicator?.stop();
+                    // NOTE: Don't pop from context - keep conversation valid for future messages
+                    this.toolsUsedInCurrentMessage = false;
+                    this.lastToolsUsed = [];
+                    this.lastToolsFailed = false;
+                    return;
+                }
+                await this.postResponse(originalMessage.discussionId, responseText);
+                this.toolsUsedInCurrentMessage = false; // Reset for next message
+                this.lastToolsUsed = [];
+                this.lastToolsFailed = false;
+                return;
+            }
+            // For normal priority:
+            // - If tools were used, post substantive responses (LLM was doing real work)
+            // - Otherwise, require explicit <respond> tag
+            if (originalMessage.priority === "normal") {
+                // SILENT SUCCESS: Skip confirmation if we just ran a silent tool successfully (not on error)
+                const usedSilentTool = this.lastToolsUsed.some(t => OrchestratorDaemon.SILENT_SUCCESS_TOOLS.has(t));
+                const shouldSuppressSilent = usedSilentTool && !this.lastToolsFailed;
+                if (this.toolsUsedInCurrentMessage && responseText.length > 50 && !responseText.includes("<ignore") && !shouldSuppressSilent) {
+                    // Tools were used and we have a substantive response - post it
+                    this.orchestratorLogger.info("Posting tool-assisted response", {
+                        discussion: originalMessage.discussionId,
+                        responseLength: responseText.length,
+                    });
+                    await this.postResponse(originalMessage.discussionId, responseText);
+                    this.toolsUsedInCurrentMessage = false; // Reset for next message
+                    this.lastToolsUsed = [];
+                    this.lastToolsFailed = false;
+                    return;
+                }
+                if (shouldSuppressSilent) {
+                    this.orchestratorLogger.debug("Suppressing normal-priority confirmation for silent success tool", {
+                        discussion: originalMessage.discussionId,
+                        tools: this.lastToolsUsed,
+                    });
+                    // Stop typing indicator
+                    this.typingIndicator?.stop();
+                    // NOTE: Don't pop from context when tools were used - keep conversation valid
+                    this.toolsUsedInCurrentMessage = false;
+                    this.lastToolsUsed = [];
+                    this.lastToolsFailed = false;
+                    return;
+                }
+                this.orchestratorLogger.debug("Normal priority without <respond> tag - removing from context", {
+                    discussion: originalMessage.discussionId,
+                    responsePreview: responseText.substring(0, 100),
+                    toolsUsed: this.toolsUsedInCurrentMessage,
+                });
+                // Stop typing indicator
+                this.typingIndicator?.stop();
+                // Remove from context - we didn't respond (only safe when no tools were used)
+                if (!this.toolsUsedInCurrentMessage) {
+                    conversation.pop(); // Remove assistant response
+                    conversation.pop(); // Remove incoming message
+                }
+                this.toolsUsedInCurrentMessage = false; // Reset for next message
+                this.lastToolsUsed = [];
+                this.lastToolsFailed = false;
+            }
+        }
+    }
+    /**
+     * Get orchestrator status including specialist info
+     */
+    getOrchestratorStatus() {
+        const specialists = Array.from(this.specialists.entries()).map(([key, spec]) => ({
+            key,
+            name: spec.name,
+            available: !!spec.botUserId,
+            userId: spec.botUserId,
+        }));
+        const activeInDiscussions = {};
+        for (const [discussionId, userIds] of this.activeSpecialistsInDiscussion) {
+            activeInDiscussions[discussionId] = Array.from(userIds);
+        }
+        return {
+            conversationState: this.getConversationState(),
+            specialists,
+            activeInDiscussions,
+        };
+    }
+}
+exports.OrchestratorDaemon = OrchestratorDaemon;
+//# sourceMappingURL=daemon.js.map