@hailer/mcp 0.1.14 → 0.1.16

package/dist/mcp/signal-handler.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSignalHandler = exports.SignalHandler = void 0;
-const zod_1 = require("zod");
+exports.SignalHandler = void 0;
 const logger_1 = require("../lib/logger");
+const bot_config_1 = require("./tools/bot-config");
 const logger = (0, logger_1.createLogger)({ component: 'signal-handler' });
 class SignalHandler {
     client;
@@ -10,16 +10,41 @@ class SignalHandler {
     subscriptions = new Map();
     signalHistory = [];
     maxHistorySize = 100;
+    // Static cache to prevent duplicate handlers per socket
+    static handlersBySocketId = new Map();
     constructor(client, workspaceCache) {
         this.client = client;
         this.workspaceCache = workspaceCache;
         this.initializeSignalHandling();
     }
+    /**
+     * Get or create a SignalHandler for a client (prevents duplicate listeners)
+     */
+    static getOrCreate(client, workspaceCache) {
+        // Use session key as unique identifier - each HailerClient has a unique sessionKey
+        const sessionKey = client.sessionKey;
+        const existing = SignalHandler.handlersBySocketId.get(sessionKey);
+        if (existing) {
+            logger.debug('Reusing existing SignalHandler', { sessionKey });
+            return existing;
+        }
+        const handler = new SignalHandler(client, workspaceCache);
+        SignalHandler.handlersBySocketId.set(sessionKey, handler);
+        logger.debug('Created new SignalHandler', { sessionKey });
+        return handler;
+    }
+    signalListener = null;
     initializeSignalHandling() {
-        // Register for all signals from the socket client
-        this.client.socket.on('signals', (signal) => {
+        // Remove any existing listener first to prevent duplicates
+        if (this.signalListener) {
+            this.client.socket.off('signals', this.signalListener);
+        }
+        // Create and store the listener reference
+        this.signalListener = (signal) => {
             this.handleIncomingSignal(signal);
-        });
+        };
+        // Register for all signals from the socket client
+        this.client.socket.on('signals', this.signalListener);
     }
     handleIncomingSignal(rawSignal) {
         try {
@@ -37,16 +62,13 @@ class SignalHandler {
                     currentWorkspaceId: this.workspaceCache.currentWorkspace._id,
                 });
             }
-            // Debug: log raw signal data to discover available fields
-            if (eventType === 'messenger.new') {
-                const data = eventData;
-                logger.debug('Raw messenger.new signal data', {
-                    eventType,
-                    dataKeys: Object.keys(eventData),
-                    sid: String(data.sid || ''),
-                    workspaceId: String(data.workspaceId || ''),
-                });
-            }
+            // Debug: log ALL incoming signals to discover what's available
+            const data = eventData;
+            logger.debug('Signal received', {
+                eventType,
+                dataKeys: Object.keys(eventData),
+                sid: String(data.sid || ''),
+            });
             const signal = {
                 type: eventType,
                 data: eventData,
@@ -108,27 +130,71 @@ class SignalHandler {
             case 'cache.invalidate':
                 this.handleCacheInvalidate(signal);
                 break;
+            case 'company.new_invitation':
+                this.handleNewInvitation(signal);
+                break;
             default:
                 logger.debug('Unhandled signal type received', { signalType: signal.type });
         }
     }
     handleActivityUpdated(signal) {
+        const data = signal.data;
+        // Check for phase change data - try direct properties first, then meta (for backwards compatibility)
+        const processId = data.processId || data.meta?.processId;
+        const phase = data.phase || data.meta?.phase;
+        const activityIdRaw = data.activity_id || data.meta?.activity_id;
+        // Log full signal data to debug phase change detection
+        logger.debug('Activity updated signal - FULL DATA', {
+            signalDataKeys: Object.keys(signal.data || {}),
+            meta: data.meta ? JSON.stringify(data.meta) : 'undefined',
+            hasActivityId: !!activityIdRaw,
+            hasProcessId: !!processId,
+            hasPhase: !!phase,
+        });
         logger.debug('Activity updated signal received', {
-            activityId: signal.data?._id || signal.data?.id,
-            workspaceId: signal.workspaceId
+            activityId: signal.data._id || signal.data.id,
+            workspaceId: signal.workspaceId,
+            processId,
+            phase,
+            prevPhase: data.prevPhase || data.meta?.prevPhase
         });
-        // TODO: Update workspace cache if we have the activity cached
-        // This could invalidate cached activity lists and trigger re-fetching
-        // Example: Emit MCP notification for real-time updates
-        // this.emitMcpNotification('activity_updated', signal.data);
+        // Handle Agent Directory phase changes for bot enable/disable
+        // DISABLED: Now using webhook instead of socket signals for Agent Directory updates
+        // The webhook handler (src/mcp/webhook-handler.ts) handles bot config updates
+        // Keeping this code for potential fallback if webhook is unavailable
+        // if (processId && phase && activityIdRaw) {
+        //   const activityIds = Array.isArray(activityIdRaw)
+        //     ? activityIdRaw
+        //     : [activityIdRaw];
+        //
+        //   handleActivityPhaseChange(processId, activityIds, phase).catch(err => {
+        //     logger.error('Failed to handle activity phase change', err);
+        //   });
+        // }
     }
     handleActivityCreated(signal) {
+        const data = signal.data;
+        // Extract data - try direct properties first, then meta
+        const processId = data.processId || data.meta?.processId;
+        const phase = data.phase || data.meta?.phase;
+        const activityIdRaw = data.activity_id || data.meta?.activity_id || data._id || data.id;
         logger.debug('Activity created signal received', {
-            activityId: signal.data?._id || signal.data?.id,
-            workspaceId: signal.workspaceId
+            activityId: Array.isArray(activityIdRaw) ? activityIdRaw.join(',') : activityIdRaw,
+            workspaceId: signal.workspaceId,
+            processId,
+            phase,
         });
-        // TODO: Add new activity to workspace cache
-        // This could update activity counts and lists
+        // Handle Agent Directory discovery - when a new bot is added, discover schema
+        // DISABLED: Now using webhook instead of socket signals for Agent Directory updates
+        // if (processId && phase && activityIdRaw) {
+        //   const activityIds = Array.isArray(activityIdRaw)
+        //     ? activityIdRaw
+        //     : [activityIdRaw];
+        //
+        //   handleActivityPhaseChange(processId, activityIds, phase).catch(err => {
+        //     logger.error('Failed to handle activity creation for bot discovery', err);
+        //   });
+        // }
     }
     handleDiscussionMessage(signal) {
         logger.debug('Discussion message signal received', {
@@ -163,13 +229,28 @@ class SignalHandler {
         });
         try {
             // Refresh cache by fetching fresh data - API requires array of keys to fetch
-            const init = await this.client.socket.request('v2.core.init', [['users', 'network', 'networks']]);
+            // IMPORTANT: Include 'processes' to get updated workflow list (e.g., after template install)
+            const init = await this.client.socket.request('v2.core.init', [['users', 'network', 'networks', 'processes']]);
             // Update workspace cache with fresh data
             if (init.processes) {
                 this.workspaceCache.rawInit.processes = init.processes;
                 logger.info('Workflows cache refreshed', {
                     workflowCount: init.processes.length
                 });
+                // Check if Agent Directory workflow now exists (hot-load after template install)
+                // This enables the daemon to start automatically when AI Hub template is installed
+                const agentDirectoryPatterns = ['agent directory', 'ai agents', '🤖 agent directory'];
+                const hasAgentDirectory = init.processes.some((p) => {
+                    const name = (p.name || '').toLowerCase();
+                    return agentDirectoryPatterns.some(pattern => name.includes(pattern));
+                });
+                if (hasAgentDirectory) {
+                    logger.info('Agent Directory workflow detected after cache refresh, triggering bot config reload');
+                    // Async reload - don't await to avoid blocking signal handling
+                    (0, bot_config_1.reloadConfigFromHailer)().catch(err => {
+                        logger.warn('Bot config reload failed after Agent Directory detection', { error: err });
+                    });
+                }
             }
             if (init.users) {
                 // Store raw users in rawInit - the users array is derived from this
@@ -193,6 +274,72 @@ class SignalHandler {
             logger.error('Failed to refresh cache after invalidation signal', error);
         }
     }
+    async handleNewInvitation(signal) {
+        logger.info('New workspace invitation received', {
+            workspaceId: signal.workspaceId
+        });
+        // Auto-accept all pending invitations
+        try {
+            // Get pending invites
+            const invites = await this.client.socket.request('v2.user.invite.list', []);
+            if (!invites || invites.length === 0) {
+                logger.debug('No pending invitations to accept');
+                return;
+            }
+            logger.info('Found pending invitations', { count: invites.length });
+            // Accept each invitation
+            for (const invite of invites) {
+                try {
+                    await this.client.socket.request('v2.user.invite.accept', [invite.invite_key]);
+                    logger.info('Auto-accepted workspace invitation', {
+                        workspaceId: invite.cid,
+                        workspaceName: invite.network?.name
+                    });
+                    // Switch to the new workspace so the existing automation can discover Agent Directory
+                    try {
+                        logger.info('Switching to new workspace', { workspaceId: invite.cid });
+                        await this.client.socket.request('core.switch_ecosystem', [invite.cid]);
+                        logger.info('Switched to workspace successfully', { workspaceId: invite.cid });
+                        // Update active workspace for bot-config
+                        (0, bot_config_1.setActiveWorkspace)(invite.cid);
+                        // Trigger Agent Directory discovery and bot initialization
+                        try {
+                            logger.info('Triggering bot config reload for new workspace');
+                            await (0, bot_config_1.reloadConfigFromHailer)();
+                            logger.info('Bot config reload completed');
+                        }
+                        catch (reloadError) {
+                            logger.error('Failed to reload bot config', reloadError);
+                        }
+                    }
+                    catch (switchError) {
+                        logger.error('Failed to switch to workspace', switchError, {
+                            workspaceId: invite.cid
+                        });
+                    }
+                }
+                catch (acceptError) {
+                    logger.error('Failed to accept invitation', acceptError, {
+                        inviteKey: invite.invite_key,
+                        workspaceId: invite.cid
+                    });
+                }
+            }
+            // Refresh cache after accepting invitations
+            if (this.workspaceCache) {
+                const init = await this.client.socket.request('v2.core.init', [['networks']]);
+                if (init.networks) {
+                    this.workspaceCache.allWorkspaces = init.networks;
+                    logger.info('Workspaces cache refreshed after accepting invitations', {
+                        workspaceCount: Object.keys(init.networks).length
+                    });
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to handle new invitation', error);
+        }
+    }
     // Public API for subscription management
     subscribe(id, types, handler, workspaceId) {
         // Check if subscription already exists
@@ -240,102 +387,6 @@ class SignalHandler {
         this.signalHistory = [];
         logger.info('Signal history cleared', { previousHistorySize: previousCount });
     }
-    // Utility methods for MCP integration
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP server type from @modelcontextprotocol/sdk
-    createMcpSignalTools(server) {
-        // Add MCP tools for signal subscription management
-        server.tool("subscribe_to_signals", "🔔 Subscribe to real-time Hailer signals - Get notified of activity updates, new messages, and workspace changes", {
-            types: zod_1.z.array(zod_1.z.enum([
-                'activities.updated',
-                'activities.created',
-                'activities.deleted',
-                'discussion.message',
-                'user.joined',
-                'user.left',
-                'workspace.updated',
-                'process.updated',
-                'cache.invalidate'
-            ])).describe("Signal types to subscribe to"),
-            workspaceId: zod_1.z.string().optional().describe("Optional workspace ID to filter signals"),
-        }, async (args) => {
-            const subscriptionId = `mcp-${Date.now()}`;
-            this.subscribe(subscriptionId, args.types, (signal) => {
-                // TODO: Send MCP notification to client
-                logger.debug('MCP signal notification', {
-                    subscriptionId,
-                    signalType: signal.type,
-                    workspaceId: signal.workspaceId
-                });
-            }, args.workspaceId);
-            return {
-                content: [{
-                        type: "text",
-                        text: `🔔 Subscribed to real-time signals!\n\n` +
-                            `📡 Subscription ID: ${subscriptionId}\n` +
-                            `📋 Signal types: ${args.types.join(", ")}\n` +
-                            `${args.workspaceId ? `🏢 Workspace filter: ${args.workspaceId}\n` : ''}` +
-                            `\n💡 You'll now receive real-time notifications for these events.\n` +
-                            `Use get_signal_history to see recent signals.`,
-                    }],
-            };
-        });
-        server.tool("get_signal_history", "📜 Get recent real-time signal history - See what's been happening in your workspace", {
-            types: zod_1.z.array(zod_1.z.string()).optional().describe("Optional filter for specific signal types"),
-            limit: zod_1.z.number().optional().default(20).describe("Maximum number of signals to return"),
-            workspaceId: zod_1.z.string().optional().describe("Optional workspace ID to filter signals"),
-        }, async (args) => {
-            const history = this.getSignalHistory(args.types, args.limit, args.workspaceId);
-            const summary = {
-                totalSignals: history.length,
-                timeRange: history.length > 0 ? {
-                    newest: new Date(history[0].timestamp).toISOString(),
-                    oldest: new Date(history[history.length - 1].timestamp).toISOString(),
-                } : null,
-                typeBreakdown: history.reduce((acc, signal) => {
-                    acc[signal.type] = (acc[signal.type] || 0) + 1;
-                    return acc;
-                }, {}),
-                signals: history.map(signal => ({
-                    type: signal.type,
-                    timestamp: new Date(signal.timestamp).toISOString(),
-                    workspaceId: signal.workspaceId,
-                    data: signal.data,
-                })),
-            };
-            return {
-                content: [{
-                        type: "text",
-                        text: `📜 Signal History (${history.length} signals)\n\n` +
-                            `📊 Summary:\n` +
-                            `${Object.entries(summary.typeBreakdown).map(([type, count]) => `- ${type}: ${count}`).join('\n')}\n\n` +
-                            `⏰ Time range: ${summary.timeRange ? `${summary.timeRange.oldest} → ${summary.timeRange.newest}` : 'No signals'}\n\n` +
-                            `📡 Real-time signals help you stay updated on workspace activity!\n\n` +
-                            `${JSON.stringify(summary, null, 2)}`,
-                    }],
-            };
-        });
-        server.tool("list_signal_subscriptions", "📋 List active signal subscriptions - See what real-time notifications are configured", {}, async () => {
-            const subscriptions = this.getActiveSubscriptions();
-            return {
-                content: [{
-                        type: "text",
-                        text: `📋 Active Signal Subscriptions (${subscriptions.length})\n\n` +
-                            (subscriptions.length > 0
-                                ? subscriptions.map((sub, index) => `${index + 1}. **${sub.id}**\n` +
-                                    `   - Types: ${sub.types.join(", ")}\n` +
-                                    `   - Workspace: ${sub.workspaceId || "All workspaces"}`).join('\n\n')
-                                : "No active subscriptions") +
-                            `\n\n💡 Use subscribe_to_signals to create new subscriptions.\n` +
-                            `💡 Subscriptions automatically receive real-time updates.`,
-                    }],
-            };
-        });
-    }
 }
 exports.SignalHandler = SignalHandler;
-// Factory function for creating signal handler
-const createSignalHandler = (clients, workspaceCache) => {
-    return new SignalHandler(clients, workspaceCache);
-};
-exports.createSignalHandler = createSignalHandler;
 //# sourceMappingURL=signal-handler.js.map

package/dist/mcp/tools/activity.js

@@ -724,7 +724,15 @@ exports.createActivityTool = {
             const isBulk = args.activities && Array.isArray(args.activities) && args.activities.length > 0;
             // Get workflow's default team (owner team) if available
             const rawWorkflow = context.init.processes.find((p) => p._id === args.workflowId);
-            const defaultTeamId = rawWorkflow?.team;
+            let defaultTeamId = rawWorkflow?.team;
+            // Fallback to first workspace team if workflow has no default team
+            if (!defaultTeamId && context.init.teams) {
+                const teamIds = Object.keys(context.init.teams);
+                if (teamIds.length > 0) {
+                    defaultTeamId = teamIds[0];
+                    logger.debug('Using fallback team from workspace', { teamId: defaultTeamId });
+                }
+            }
             let activitiesToCreate;
             let options = {
                 returnDocument: true,

package/dist/mcp/tools/bot-config.d.ts

@@ -6,15 +6,61 @@
  * - Deployed agents phase = enabled
  * - Retired agents phase = disabled
  *
- * Architecture:
- * - In-memory state is primary (for speed)
+ * Architecture (User ID-based discovery):
+ * - In-memory state is primary (for speed), keyed by USER ID
  * - Agent Directory workflow is persistence layer (agents as activities, phases for state)
- * - On startup: Load config from Hailer by checking which phase each agent is in
+ * - On startup: Load config from Hailer by extracting hailerProfile (user ID) from each agent
  * - On change: Move agent activity between phases
+ * - Credentials: Auto-synced from Hailer to local storage on discovery
+ * - Orchestrator: Simply the first deployed bot with credentials (no special field needed)
  */
 import { z } from 'zod';
 import { Tool } from '../tool-registry';
 import { HailerApiClient } from '../utils/index';
+interface SchemaConfig {
+    agentDirectoryWorkflowId: string | null;
+    deployedPhaseId: string | null;
+    retiredPhaseId: string | null;
+    hailerProfileFieldId: string | null;
+    emailFieldId: string | null;
+    passwordFieldId: string | null;
+    botTypeFieldId: string | null;
+}
+/**
+ * Get workspace ID by Agent Directory workflow ID (reverse lookup)
+ */
+export declare function getWorkspaceByWorkflowId(workflowId: string): string | null;
+/**
+ * Get all configured workspace IDs
+ */
+export declare function getAllConfiguredWorkspaces(): string[];
+/**
+ * Set the active workspace ID (called when switching workspaces)
+ */
+export declare function setActiveWorkspace(workspaceId: string): void;
+/**
+ * Get the active workspace ID
+ */
+export declare function getActiveWorkspace(): string | null;
+/**
+ * Get schema for a workspace
+ */
+export declare function getWorkspaceSchema(workspaceId: string): SchemaConfig | null;
+/**
+ * Set schema for a workspace
+ */
+export declare function setWorkspaceSchema(workspaceId: string, schema: SchemaConfig): void;
+/**
+ * Get discovered workflow ID for a workspace (or active workspace if not specified)
+ */
+export declare function getAgentDirectoryWorkflowId(workspaceId?: string): string | null;
+/**
+ * Get discovered phase IDs for a workspace (or active workspace if not specified)
+ */
+export declare function getPhaseIds(workspaceId?: string): {
+    deployed: string | null;
+    retired: string | null;
+};
 /**
  * Available bots - single source of truth
  *
@@ -27,8 +73,43 @@ export declare const AVAILABLE_BOTS: {
     description: string;
     icon: string;
 }[];
+/**
+ * Get the orchestrator user ID
+ * Returns the user ID of the bot marked as orchestrator in Agent Directory
+ */
+export declare function getOrchestratorUserId(): string | null;
+/**
+ * Set the orchestrator user ID
+ * Called during Agent Directory sync - set to first deployed bot with credentials
+ */
+export declare function setOrchestratorUserId(userId: string | null): void;
 export declare function onBotStateChange(callback: (botId: string, enabled: boolean) => void): void;
+export declare function onBotCredentialsChange(callback: (botId: string) => void): void;
+export declare function onDaemonRestartNeeded(callback: () => void): void;
+/**
+ * Cleanup function to clear pending timers and state on shutdown
+ * Should be called from Core.stop() to prevent orphaned callbacks
+ */
+export declare function cleanupBotConfig(): void;
 export declare function getBotState(): Record<string, boolean>;
+/**
+ * Get the user ID associated with a bot
+ */
+export declare function getBotUserId(botId: string): string | null;
+/**
+ * Get the bot type for a user ID
+ * Returns values like 'orchestrator', 'workflow-expert', 'bug-fixer', etc.
+ */
+export declare function getBotType(userId: string): string | null;
+/**
+ * Get all enabled bots with their types
+ * Returns map of userId -> botType for enabled bots only
+ */
+export declare function getEnabledBotsWithTypes(): Map<string, string | null>;
+/**
+ * Set the user ID associated with a bot
+ */
+export declare function setBotUserId(botId: string, userId: string | null): void;
 /**
  * Set bot enabled state
  *
@@ -36,29 +117,117 @@ export declare function getBotState(): Record<string, boolean>;
  * the agent activity to the appropriate phase (deployed/retired).
  */
 export declare function setBotEnabled(botId: string, enabled: boolean): void;
+/**
+ * Handle activity phase change signal from Hailer
+ *
+ * Called by signal-handler when an activity.updated signal is received.
+ * Updates bot state if the activity belongs to Agent Directory workflow.
+ *
+ * NEW: Now looks up activities by user ID instead of bot type.
+ *
+ * @param processId - Workflow ID from the signal
+ * @param activityIds - Array of activity IDs that were updated
+ * @param newPhaseId - The phase the activities moved to
+ */
+export declare function handleActivityPhaseChange(processId: string, activityIds: string[], newPhaseId: string): Promise<void>;
+/**
+ * Force reload bot config from Hailer
+ *
+ * Can be called to manually refresh state from Hailer.
+ * NEW: Now works with user IDs instead of bot IDs.
+ *
+ * Also handles hot-reload: if schema discovery hasn't succeeded yet
+ * (e.g., AI Hub template wasn't installed at startup), it will
+ * retry discovery and initialize the daemon.
+ */
+export declare function reloadConfigFromHailer(): Promise<void>;
 /**
  * Initialize persistence layer
  * Called once during MCP server startup
  *
- * Loads agent enabled state from the Agent Directory workflow:
- * - Agents in DEPLOYED_PHASE_ID are enabled
- * - Agents in RETIRED_PHASE_ID are disabled
+ * Loads bot config from local files only (no Hailer API calls on startup).
+ * Real-time updates from Hailer are handled via signal handler when activities change.
  *
  * @param client - HailerApiClient instance for API calls
  */
+/**
+ * Set the target workspace ID for bot config operations
+ * Called by signal handler when workspace is switched
+ */
 export declare function initBotConfigPersistence(client: HailerApiClient): Promise<void>;
+/**
+ * Initialize workspace schema for a specific workspace
+ * Called by bot clients after connecting to discover the Agent Directory in that workspace
+ * @param client - HailerApiClient for API calls
+ * @param workspaceId - The workspace ID to initialize schema for
+ */
+export declare function initWorkspaceSchema(client: HailerApiClient, workspaceId: string): Promise<boolean>;
 /**
  * Check if persistence is initialized
  */
 export declare function isPersistenceInitialized(): boolean;
+/**
+ * Bot credentials interface
+ */
+export interface BotCredentials {
+    email?: string;
+    password?: string;
+}
+/**
+ * Get bot credentials from Agent Directory
+ *
+ * Reads the email and password fields from the bot's activity.
+ * Password is masked for security unless showPassword is true.
+ * Falls back to local file storage if Hailer is unavailable.
+ *
+ * @param botIdOrActivityId - The bot ID (hal, giuseppe, etc.) or activity ID
+ * @param showPassword - If true, returns unmasked password. Default false for security.
+ * @returns Credentials or null if not found
+ */
+export declare function getBotCredentials(botIdOrActivityId: string, showPassword?: boolean): Promise<BotCredentials | null>;
+/**
+ * Update bot credentials in Agent Directory
+ *
+ * Writes the email and/or password to the bot's activity fields.
+ * Only updates fields that are provided.
+ * Saves to local file storage as backup (and uses as fallback if Hailer unavailable).
+ *
+ * @param botIdOrActivityId - The bot ID (hal, giuseppe, etc.) or raw activity ID
+ * @param credentials - Credentials to update (email and/or password)
+ */
+export declare function updateBotCredentials(botIdOrActivityId: string, credentials: BotCredentials): Promise<void>;
+/**
+ * Get unmasked bot credentials for daemon creation
+ *
+ * NEW: Now primarily looks up by user ID instead of bot ID.
+ * This function returns the actual password (not masked) from local storage.
+ * Should only be used internally for creating bot daemon instances.
+ *
+ * @param userIdOrBotId - The user ID or legacy bot ID (hal, giuseppe, etc.)
+ * @returns Unmasked credentials or null if not found
+ */
+export declare function getLocalBotCredentials(userIdOrBotId: string): {
+    email: string;
+    password: string;
+    displayName?: string;
+} | null;
+/**
+ * Get all local bot credentials (for daemon initialization)
+ * Returns all bots stored in .bot-credentials.json
+ */
+export declare function getAllLocalBotCredentials(): Record<string, {
+    email: string;
+    password: string;
+    displayName?: string;
+}>;
 /**
  * Get persistence status info (for debugging)
  */
 export declare function getPersistenceStatus(): {
     initialized: boolean;
-    workflowId: string;
-    deployedPhaseId: string;
-    retiredPhaseId: string;
+    workflowId: string | null;
+    deployedPhaseId: string | null;
+    retiredPhaseId: string | null;
     agentActivityIds: Record<string, string>;
     hasClient: boolean;
 };
@@ -74,5 +243,11 @@ export declare const enableBotTool: Tool;
  * Disable a bot
  */
 export declare const disableBotTool: Tool;
+/**
+ * Check specialist status from Agent Directory
+ * Returns real-time status showing which specialists are deployed vs retired
+ */
+export declare const checkSpecialistStatusTool: Tool;
 export declare const botConfigTools: Tool<z.ZodType<any, z.ZodTypeDef, any>>[];
+export {};
 //# sourceMappingURL=bot-config.d.ts.map