@hailer/mcp 0.1.15 → 0.1.17

package/dist/agents/hal/daemon.js

@@ -0,0 +1,1103 @@
+"use strict";
+/**
+ * Orchestrator Daemon (HAL)
+ *
+ * The main conversational bot that handles general chat and coordinates
+ * with specialist bots when tasks are too complex.
+ *
+ * HAL can:
+ * - Handle general conversation and simple queries
+ * - Detect when a task needs specialist help
+ * - Invite specialist bots to the discussion
+ * - Hand off context to specialists
+ * - Summarize specialist responses for users
+ */
+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("../giuseppe/registries/pending-fix");
+const pending_classification_1 = require("../giuseppe/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 Giuseppe 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 main Hailer Assistant orchestrator. Handles general conversation and coordinates specialist bots for complex tasks.";
+    }
+    /**
+     * Override Position details for Orchestrator
+     */
+    getPositionDetails() {
+        return {
+            name: "HAL Orchestrator",
+            purpose: "Main point of contact for users. Handles general conversation, triages requests, and coordinates specialist bots for complex tasks.",
+            personaTone: "Sharp, efficient, and helpful. Professional but approachable. Uses clear, concise language.",
+            coreCapabilities: "- Monitor all workspace discussions\n- Respond to general queries and greetings\n- Detect when specialist help is needed\n- Invite specialists to discussions\n- Coordinate multi-step workflows\n- Execute MCP tools for data operations",
+            boundaries: "- Never fabricate data - always use tools\n- Don't attempt complex technical tasks alone\n- Hand off to specialists for: bulk operations, report creation, workflow setup\n- Don't share credentials or sensitive config",
+        };
+    }
+    /**
+     * Orchestrator only needs basic tools - complex ops go to specialists
+     */
+    getToolWhitelist() {
+        return [
+            // Workflow discovery
+            "list_workflows",
+            "list_workflow_phases",
+            "get_workflow_schema",
+            "list_workflows_minimal",
+            // Activity operations
+            "list_activities",
+            "show_activity_by_id",
+            "count_activities",
+            "create_activity",
+            "update_activity",
+            // Discussion tools
+            "join_discussion",
+            "add_discussion_message",
+            "invite_discussion_members",
+            "fetch_discussion_messages",
+            "get_activity_from_discussion",
+            "list_my_discussions",
+            // User lookup
+            "search_workspace_users",
+            // App tools (read-only)
+            "list_apps",
+        ];
+    }
+    /**
+     * 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_giuseppe_retry') {
+                // Handle locally - trigger Giuseppe 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 Giuseppe retry with explanation: "${explanation.substring(0, 100)}...". Giuseppe will analyze and apply a new fix.`
+                            : '❌ Failed to trigger retry. Giuseppe may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'confirm_bug_fix') {
+                // Handle locally - trigger Giuseppe 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. Giuseppe 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 Giuseppe to proceed with bug fix.'
+                            : '❌ Failed to trigger fix. Giuseppe may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'decline_bug_report') {
+                // Handle locally - trigger Giuseppe 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. Giuseppe 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. Giuseppe 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
+            const response = await this.client.messages.create({
+                model: this.config.model || 'claude-haiku-4-5-20251001',
+                max_tokens: 2000,
+                system: this.getSystemPrompt(),
+                messages: conversation,
+                tools: this.getToolsWithGiuseppeRetry(),
+            });
+            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
+        const response = await this.client.messages.create({
+            model: this.config.model || "claude-haiku-4-5-20251001",
+            max_tokens: 2000,
+            system: this.getSystemPrompt(),
+            messages: conversation,
+            tools: this.minimalTools,
+        });
+        // Track token usage in session
+        if (session && response.usage) {
+            session.metrics.inputTokens += response.usage.input_tokens;
+            session.metrics.outputTokens += response.usage.output_tokens;
+            session.lastActivityTime = Date.now();
+        }
+        // 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 Giuseppe retry tool when there's a pending fix
+     */
+    getTools() {
+        // Always include the Giuseppe retry tool so LLM knows about it
+        return this.getToolsWithGiuseppeRetry();
+    }
+    /**
+     * Get tools list with Giuseppe retry tool added
+     */
+    getToolsWithGiuseppeRetry() {
+        const giuseppeRetryTool = {
+            name: 'trigger_giuseppe_retry',
+            description: 'Trigger Giuseppe 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, giuseppeRetryTool, 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 Giuseppe!**
+
+- Bug ID: ${pendingFix.bugId}
+- State: ${pendingFix.state}
+- Fix Summary: ${pendingFix.fixSummary}
+
+**Your role:**
+- If user says "approved" → Giuseppe 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_giuseppe_retry tool with the explanation
+
+**Remember:** You're gathering info for Giuseppe. 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: Giuseppe 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" → Giuseppe 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>
+`;
+    }
+    /**
+     * Override system prompt to include orchestrator capabilities
+     */
+    getSystemPrompt() {
+        const now = new Date();
+        const { firstName, lastName } = this.getAgentName();
+        const fullName = `${firstName} ${lastName}`.trim();
+        // 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 `<identity>
+You are ${fullName} - the Hailer Assistant. Sharp, efficient, and helpful.
+Bot ID: ${this.botClient.userId}
+
+You're the main point of contact for users. You handle general conversation
+and simple tasks yourself, but can bring in specialist bots for complex work.
+</identity>
+
+<current_time>${now.toISOString()}</current_time>
+
+<personality>
+**BUSINESS MODE** (default):
+- Professional, direct, competent
+- Get things done efficiently
+- Provide accurate information
+
+**SARCASM MODE** (for ridiculous requests):
+- Dry wit, not mean-spirited
+- Still help after the gentle mockery
+</personality>
+
+<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>
+
+<specialists>
+${specialistInfo}
+${availableSpecialists.length > 0 ? `
+**When to invite a specialist:**
+- Creating new workflows/pipelines
+- Setting up reports/insights/dashboards
+- Bulk operations (10+ items)
+- Complex multi-step data tasks
+- Workflow configuration changes
+
+**When to handle yourself:**
+- General chat, greetings
+- Simple queries (list activities, show details)
+- Single create/update operations
+- Questions about the conversation
+- Clarifying user requirements
+
+<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>
+CRITICAL: When you've already gathered IDs (workflows, fields, phases), include them formatted in the handoff.
+
+<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>` : ''}
+</specialists>
+
+<tagging_syntax>
+To @mention someone in Hailer, use this format:
+[hailerTag|Display Name](userId)
+
+${availableSpecialists.length > 0 ? `Example: [hailerTag|${availableSpecialists[0][1].displayName || availableSpecialists[0][1].name}](${availableSpecialists[0][1].botUserId})` : 'Example: [hailerTag|User Name](userId)'}
+
+For specialists, use their display name and userId from the list above.
+Do NOT use plain @mentions like "@hailerExpert" - they won't work.
+</tagging_syntax>
+
+<giuseppe_autonomous>
+**Giuseppe - Autonomous Bug Fixer**
+
+Giuseppe is SPECIAL - he works AUTONOMOUSLY, not through invites!
+
+**How Giuseppe works:**
+1. Users create a bug report in the "Bug Reports" workflow
+2. Giuseppe 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" → Giuseppe publishes to production automatically
+6. On "denied" or complaint → YOU (HAL) gather info, then trigger Giuseppe 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_giuseppe_retry tool to pass the explanation
+4. Giuseppe 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 Giuseppe will pick it up automatically
+- Offer to help create the bug report for them
+</giuseppe_autonomous>
+
+<your_tools>
+You have access to basic MCP tools for simple operations:
+- list_workflows, list_workflow_phases, get_workflow_schema
+- list_activities, show_activity_by_id, count_activities
+- create_activity, update_activity (single operations)
+- search_workspace_users
+- Discussion tools (join_discussion, add_discussion_message, invite_discussion_members)
+
+For complex operations (workflow creation, insights, bulk ops), invite a specialist.
+
+**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>
+
+<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: Complete work before responding!**
+
+You work in a single-turn loop. When you respond with <respond>, your turn ENDS.
+There is NO "next turn" unless a new message arrives.
+
+**WRONG - promising future work:**
+<respond discussion="...">
+I found 29 players. Let me check which ones are injured...
+</respond>
+→ This posts the message but NEVER calls any tools!
+
+**RIGHT - complete the work first:**
+1. Call list_activities with injury filter
+2. Get results
+3. THEN respond with the actual answer:
+<respond discussion="...">
+Found 3 injured players: #player1, #player2, #player3
+</respond>
+
+**RULE: Never say "let me check" or "give me a second" - just DO IT by calling tools.**
+Only use <respond> when you have the FINAL answer to share.
+</agentic_loop>
+
+<rules>
+- Be concise - snappy responses, not essays
+- Use your memory - reference past conversations
+- For HIGH priority: respond immediately
+- For NORMAL priority: your DEFAULT is <ignore/>. Only break if you see a clear workspace question.
+- **Gibberish test:** No recognizable words, no vowels, repeated patterns = <ignore/>
+- **Relevance test:** Is this about workflows/activities/insights? If not = <ignore/>
+- When inviting specialists, explain to the user what's happening
+- After specialist responds, summarize for the user if needed
+- **Complete work before responding** - Never say "I'm going to do X", just DO X with tool calls
+</rules>
+
+${this.currentDiscussionId ? this.getPendingFixContext(this.currentDiscussionId) : ''}
+${this.currentDiscussionId ? this.getPendingClassificationContext(this.currentDiscussionId) : ''}`;
+    }
+    /**
+     * 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
+                const retryResponse = await this.client.messages.create({
+                    model: this.config.model || 'claude-haiku-4-5-20251001',
+                    max_tokens: 1000,
+                    system: this.getSystemPrompt(),
+                    messages: conversation,
+                    tools: this.getTools(),
+                });
+                // 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.stopTypingIndicator();
+                // 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.stopTypingIndicator();
+                    // 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.stopTypingIndicator();
+                    // 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.stopTypingIndicator();
+                    // 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.stopTypingIndicator();
+                // 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