@hailer/mcp 0.1.17 → 0.2.1

package/dist/client/agents/orchestrator.js

@@ -1,1062 +0,0 @@
-"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("./base");
-const definitions_1 = require("./definitions");
-const logger_1 = require("../../lib/logger");
-const pending_fix_registry_1 = require("../../modules/bug-reports/pending-fix-registry");
-const pending_classification_registry_1 = require("../../modules/bug-reports/pending-classification-registry");
-const discussion_lock_1 = require("../../lib/discussion-lock");
-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
-        for (const [key, specialist] of Object.entries(definitions_1.SPECIALISTS)) {
-            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_registry_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_registry_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_registry_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_registry_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_registry_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_registry_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
-     * Also checks if a specialist bot (like Giuseppe) has locked this discussion
-     */
-    async extractIncomingMessage(signal) {
-        const message = await super.extractIncomingMessage(signal);
-        if (!message)
-            return null;
-        // Check if this discussion is locked by a specialist bot (e.g., Giuseppe handling a bug)
-        if ((0, discussion_lock_1.isDiscussionLocked)(message.discussionId, 'hal')) {
-            this.orchestratorLogger.debug('Discussion locked by specialist, skipping', {
-                discussionId: message.discussionId
-            });
-            return null;
-        }
-        // 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) {
-        this.specialistUserIds.set(specialistKey, userId);
-        const specialist = this.specialists.get(specialistKey);
-        if (specialist) {
-            specialist.botUserId = userId;
-            this.orchestratorLogger.info("Specialist registered", {
-                key: specialistKey,
-                name: specialist.name,
-                userId,
-            });
-        }
-    }
-    /**
-     * Check if a specialist is already active in a discussion
-     */
-    isSpecialistActiveInDiscussion(discussionId, specialistUserId) {
-        const active = this.activeSpecialistsInDiscussion.get(discussionId);
-        return active?.has(specialistUserId) ?? false;
-    }
-    /**
-     * 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
-     */
-    async inviteSpecialist(specialist, discussionId, handoffContext) {
-        const specialistUserId = specialist.botUserId;
-        if (!specialistUserId) {
-            this.orchestratorLogger.warn("Specialist has no user ID", {
-                name: specialist.name,
-            });
-            return false;
-        }
-        // Check if already active
-        if (this.isSpecialistActiveInDiscussion(discussionId, specialistUserId)) {
-            this.orchestratorLogger.debug("Specialist already in discussion", {
-                name: specialist.name,
-                discussionId,
-            });
-            // Just tag them again
-            await this.postResponse(discussionId, `@"${specialist.name}" - ${handoffContext}`);
-            return true;
-        }
-        try {
-            this.orchestratorLogger.info("Inviting specialist to discussion", {
-                name: specialist.name,
-                userId: specialistUserId,
-                discussionId,
-            });
-            // Invite using MCP tool
-            await this.callMcpTool("invite_discussion_members", {
-                discussionId,
-                userIds: [specialistUserId],
-            });
-            this.markSpecialistActive(discussionId, specialistUserId);
-            // Post handoff message
-            await this.postResponse(discussionId, `@"${specialist.name}" - ${handoffContext}`);
-            this.orchestratorLogger.info("Specialist invited successfully", {
-                name: specialist.name,
-                discussionId,
-            });
-            return true;
-        }
-        catch (error) {
-            this.orchestratorLogger.error("Failed to invite specialist", {
-                name: specialist.name,
-                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_registry_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_registry_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
-        const specialistInfo = Array.from(this.specialists.entries())
-            .map(([key, spec]) => {
-            const hasUserId = !!spec.botUserId;
-            return `- **${spec.name}** ${hasUserId ? "(available)" : "(not configured)"}
-  Expertise: ${spec.expertise.join(", ")}
-  Triggers: ${spec.triggerKeywords.slice(0, 5).join(", ")}`;
-        })
-            .join("\n\n");
-        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>
-You can invite specialist bots when tasks are too complex.
-
-${specialistInfo}
-
-**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="hailerExpert">
-Clear description of what you need done.
-Include relevant context from the conversation.
-</invite>
-</invite_syntax>
-
-<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>
-
-<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 {
-                this.orchestratorLogger.warn("Specialist not available", {
-                    key: specialistKey,
-                    hasSpecialist: !!specialist,
-                    hasUserId: !!specialist?.botUserId,
-                });
-            }
-        }
-        // 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=orchestrator.js.map