@hailer/mcp 0.1.8 → 0.1.9

package/dist/client/agents/orchestrator.js

@@ -0,0 +1,760 @@
+"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");
+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;
+        }
+    }
+    // ===== 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;
+        // 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) {
+        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 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>
+
+<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>`;
+    }
+    /**
+     * 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