@hailer/mcp 0.1.14 → 0.1.16

package/dist/mcp/tools/bot-config.js

@@ -7,38 +7,707 @@
  * - 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)
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.botConfigTools = exports.disableBotTool = exports.enableBotTool = exports.listBotsConfigTool = exports.AVAILABLE_BOTS = void 0;
+exports.botConfigTools = exports.checkSpecialistStatusTool = exports.disableBotTool = exports.enableBotTool = exports.listBotsConfigTool = exports.AVAILABLE_BOTS = void 0;
+exports.getWorkspaceByWorkflowId = getWorkspaceByWorkflowId;
+exports.getAllConfiguredWorkspaces = getAllConfiguredWorkspaces;
+exports.setActiveWorkspace = setActiveWorkspace;
+exports.getActiveWorkspace = getActiveWorkspace;
+exports.getWorkspaceSchema = getWorkspaceSchema;
+exports.setWorkspaceSchema = setWorkspaceSchema;
+exports.getAgentDirectoryWorkflowId = getAgentDirectoryWorkflowId;
+exports.getPhaseIds = getPhaseIds;
+exports.getOrchestratorUserId = getOrchestratorUserId;
+exports.setOrchestratorUserId = setOrchestratorUserId;
 exports.onBotStateChange = onBotStateChange;
+exports.onBotCredentialsChange = onBotCredentialsChange;
+exports.onDaemonRestartNeeded = onDaemonRestartNeeded;
+exports.cleanupBotConfig = cleanupBotConfig;
 exports.getBotState = getBotState;
+exports.getBotUserId = getBotUserId;
+exports.getBotType = getBotType;
+exports.getEnabledBotsWithTypes = getEnabledBotsWithTypes;
+exports.setBotUserId = setBotUserId;
 exports.setBotEnabled = setBotEnabled;
+exports.handleActivityPhaseChange = handleActivityPhaseChange;
+exports.reloadConfigFromHailer = reloadConfigFromHailer;
 exports.initBotConfigPersistence = initBotConfigPersistence;
+exports.initWorkspaceSchema = initWorkspaceSchema;
 exports.isPersistenceInitialized = isPersistenceInitialized;
+exports.getBotCredentials = getBotCredentials;
+exports.updateBotCredentials = updateBotCredentials;
+exports.getLocalBotCredentials = getLocalBotCredentials;
+exports.getAllLocalBotCredentials = getAllLocalBotCredentials;
 exports.getPersistenceStatus = getPersistenceStatus;
 const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const tool_registry_1 = require("../tool-registry");
 const index_1 = require("../utils/index");
+const signal_handler_1 = require("../signal-handler");
+const config_1 = require("../../config");
 const logger = (0, index_1.createLogger)({ component: 'bot-config-tools' });
 // ============================================================================
-// Agent Directory Workflow Configuration
+// Local State Persistence (fallback)
 // ============================================================================
-// Agent Directory workflow config
-const AGENT_DIRECTORY_WORKFLOW_ID = '695784898d347a6c707ee365';
-const DEPLOYED_PHASE_ID = '695784898d347a6c707ee37d'; // enabled
-const RETIRED_PHASE_ID = '695784898d347a6c707ee37e'; // disabled
-// Mapping from bot IDs to their activity IDs in the Agent Directory workflow
-const AGENT_ACTIVITY_IDS = {
+const LOCAL_STATE_FILE = path.join(process.cwd(), '.bot-state.json');
+const SCHEMAS_DIR = path.join(process.cwd(), '.bot-schemas');
+// Per-workspace schema storage (keyed by workspaceId)
+const workspaceSchemas = new Map();
+// Reverse lookup: Agent Directory workflow ID → workspace ID
+const workflowToWorkspace = new Map();
+/**
+ * Ensure the schemas directory exists
+ */
+function ensureSchemasDir() {
+    if (!fs.existsSync(SCHEMAS_DIR)) {
+        fs.mkdirSync(SCHEMAS_DIR, { recursive: true });
+    }
+}
+/**
+ * Save schema config for a specific workspace
+ */
+function saveSchemaConfig(workspaceId) {
+    try {
+        ensureSchemasDir();
+        const schema = workspaceSchemas.get(workspaceId);
+        if (!schema) {
+            logger.warn('No schema to save for workspace', { workspaceId });
+            return;
+        }
+        const filePath = path.join(SCHEMAS_DIR, `${workspaceId}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(schema, null, 2));
+        logger.debug('Schema config saved', { workspaceId, file: filePath });
+    }
+    catch (error) {
+        logger.warn('Failed to save schema config', { workspaceId, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+/**
+ * Load schema config for a specific workspace
+ */
+function loadSchemaConfig(workspaceId) {
+    try {
+        const filePath = path.join(SCHEMAS_DIR, `${workspaceId}.json`);
+        if (fs.existsSync(filePath)) {
+            const data = fs.readFileSync(filePath, 'utf-8');
+            const config = JSON.parse(data);
+            workspaceSchemas.set(workspaceId, config);
+            if (config.agentDirectoryWorkflowId) {
+                workflowToWorkspace.set(config.agentDirectoryWorkflowId, workspaceId);
+            }
+            logger.info('Schema config loaded', {
+                workspaceId,
+                workflowId: config.agentDirectoryWorkflowId ?? undefined,
+                deployedPhaseId: config.deployedPhaseId ?? undefined
+            });
+            return config;
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to load schema config', { workspaceId, error: error instanceof Error ? error.message : String(error) });
+    }
+    return null;
+}
+/**
+ * Load all schema configs from the schemas directory
+ */
+function loadAllSchemaConfigs() {
+    try {
+        // Migrate from old single-file format if it exists
+        const oldSchemaFile = path.join(process.cwd(), '.bot-schema.json');
+        if (fs.existsSync(oldSchemaFile)) {
+            logger.info('Found legacy .bot-schema.json - migration needed (manual)');
+            // Don't auto-migrate - user needs to know which workspace it belongs to
+        }
+        if (!fs.existsSync(SCHEMAS_DIR)) {
+            logger.debug('No schemas directory found');
+            return;
+        }
+        const files = fs.readdirSync(SCHEMAS_DIR).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            const workspaceId = file.replace('.json', '');
+            loadSchemaConfig(workspaceId);
+        }
+        logger.info('Loaded schema configs', { count: workspaceSchemas.size, workspaces: Array.from(workspaceSchemas.keys()) });
+    }
+    catch (error) {
+        logger.warn('Failed to load schema configs', { error: error instanceof Error ? error.message : String(error) });
+    }
+}
+/**
+ * Get workspace ID by Agent Directory workflow ID (reverse lookup)
+ */
+function getWorkspaceByWorkflowId(workflowId) {
+    return workflowToWorkspace.get(workflowId) ?? null;
+}
+/**
+ * Get all configured workspace IDs
+ */
+function getAllConfiguredWorkspaces() {
+    return Array.from(workspaceSchemas.keys());
+}
+/**
+ * Set the active workspace ID (called when switching workspaces)
+ */
+function setActiveWorkspace(workspaceId) {
+    activeWorkspaceId = workspaceId;
+    logger.info('Active workspace changed', { workspaceId });
+}
+/**
+ * Get the active workspace ID
+ */
+function getActiveWorkspace() {
+    return activeWorkspaceId;
+}
+/**
+ * Get schema for a workspace
+ */
+function getWorkspaceSchema(workspaceId) {
+    return workspaceSchemas.get(workspaceId) ?? null;
+}
+/**
+ * Set schema for a workspace
+ */
+function setWorkspaceSchema(workspaceId, schema) {
+    workspaceSchemas.set(workspaceId, schema);
+    if (schema.agentDirectoryWorkflowId) {
+        workflowToWorkspace.set(schema.agentDirectoryWorkflowId, workspaceId);
+    }
+    saveSchemaConfig(workspaceId);
+}
+/**
+ * Load bot state from local file (LEGACY - for migration only)
+ * @returns loaded state or empty object if file doesn't exist
+ */
+function loadStateFromLocalFile() {
+    try {
+        if (fs.existsSync(LOCAL_STATE_FILE)) {
+            const data = fs.readFileSync(LOCAL_STATE_FILE, 'utf-8');
+            const parsed = JSON.parse(data);
+            // Migrate old format: {botId: boolean} -> {botId: {enabled: boolean, userId: null, botType: null}}
+            const migrated = {};
+            for (const [botId, value] of Object.entries(parsed)) {
+                if (typeof value === 'boolean') {
+                    // Old format - migrate
+                    migrated[botId] = { enabled: value, userId: null, botType: null };
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    // New format - ensure botType exists (may be missing from older saves)
+                    const entry = value;
+                    migrated[botId] = { enabled: entry.enabled ?? false, userId: entry.userId ?? null, botType: entry.botType ?? null };
+                }
+            }
+            logger.info('Bot state loaded from local file', { file: '.bot-state.json' });
+            return migrated;
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to load bot state from local file', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {};
+}
+/**
+ * Load bot state from .bot-config/ directory (webhook-maintained configs)
+ * This is the new primary source of truth for bot configuration
+ * @returns loaded state keyed by userId
+ */
+function loadBotStateFromBotConfig() {
+    const state = {};
+    const configDir = path.join(process.cwd(), '.bot-config');
+    try {
+        if (!fs.existsSync(configDir)) {
+            logger.debug('.bot-config directory does not exist');
+            return state;
+        }
+        const files = fs.readdirSync(configDir).filter(f => f.endsWith('.json'));
+        logger.debug('Loading bot state from .bot-config/', { fileCount: files.length });
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(configDir, file), 'utf-8');
+                const config = JSON.parse(content);
+                // Load orchestrator (always enabled if present in config)
+                if (config.orchestrator?.userId) {
+                    state[config.orchestrator.userId] = {
+                        enabled: true,
+                        userId: config.orchestrator.userId,
+                        botType: 'orchestrator'
+                    };
+                    logger.debug('Loaded orchestrator from .bot-config/', {
+                        file,
+                        userId: config.orchestrator.userId
+                    });
+                }
+                // Load specialists with their enabled flags
+                if (Array.isArray(config.specialists)) {
+                    for (const spec of config.specialists) {
+                        if (spec.userId) {
+                            state[spec.userId] = {
+                                enabled: spec.enabled ?? false,
+                                userId: spec.userId,
+                                botType: spec.botType ?? null
+                            };
+                            logger.debug('Loaded specialist from .bot-config/', {
+                                file,
+                                userId: spec.userId,
+                                enabled: spec.enabled,
+                                botType: spec.botType
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to parse .bot-config file', {
+                    file,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        logger.info('Bot state loaded from .bot-config/', { botCount: Object.keys(state).length });
+    }
+    catch (error) {
+        logger.warn('Failed to load bot state from .bot-config/', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return state;
+}
+// ============================================================================
+// Agent Directory Workflow Configuration (Dynamic Discovery)
+// ============================================================================
+// Legacy globals - kept for backwards compatibility but now read from first workspace
+// New code should use getWorkspaceSchema(workspaceId) instead
+let activeWorkspaceId = null;
+// Helper getters that read from active workspace (backwards compatibility)
+function getActiveSchema() {
+    if (!activeWorkspaceId)
+        return null;
+    return workspaceSchemas.get(activeWorkspaceId) ?? null;
+}
+// Legacy accessors - these read from active workspace for backwards compatibility
+function get_agentDirectoryWorkflowId() { return getActiveSchema()?.agentDirectoryWorkflowId ?? null; }
+function get_deployedPhaseId() { return getActiveSchema()?.deployedPhaseId ?? null; }
+function get_retiredPhaseId() { return getActiveSchema()?.retiredPhaseId ?? null; }
+function get_hailerProfileFieldId() { return getActiveSchema()?.hailerProfileFieldId ?? null; }
+function get_emailFieldId() { return getActiveSchema()?.emailFieldId ?? null; }
+function get_passwordFieldId() { return getActiveSchema()?.passwordFieldId ?? null; }
+function get_botTypeFieldId() { return getActiveSchema()?.botTypeFieldId ?? null; }
+// Load all workspace schemas on module init
+loadAllSchemaConfigs();
+// Set active workspace to first loaded (backwards compatibility)
+const firstWorkspace = Array.from(workspaceSchemas.keys())[0];
+if (firstWorkspace) {
+    activeWorkspaceId = firstWorkspace;
+    logger.info('Active workspace set from loaded schemas', { workspaceId: activeWorkspaceId });
+}
+// Workflow/phase name patterns for discovery
+const AGENT_DIRECTORY_PATTERNS = ['Agent Directory', 'AI Agents', '🤖 Agent Directory'];
+const DEPLOYED_PHASE_PATTERNS = ['deployed', 'active', 'enabled'];
+const RETIRED_PHASE_PATTERNS = ['retired', 'disabled', 'inactive'];
+// Field key patterns for discovery
+const FIELD_KEY_HAILER_PROFILE = ['hailerProfile', 'Agent Hailer profile'];
+const FIELD_KEY_EMAIL = ['agentEmailInHailer', 'email', 'Email of Hailer profile'];
+const FIELD_KEY_PASSWORD = ['password'];
+const FIELD_KEY_BOT_TYPE = ['botType', 'bot_type', 'type'];
+const FIELD_KEY_SCHEMA_CONFIG = ['schemaConfig', 'schema_config', 'schema_config_f3a'];
+/**
+ * Find field ID by trying multiple key patterns
+ */
+function findFieldId(fields, patterns) {
+    for (const pattern of patterns) {
+        if (fields[pattern])
+            return fields[pattern];
+    }
+    return null;
+}
+/**
+ * Find phase by name pattern (case-insensitive partial match)
+ */
+function findPhaseByPattern(phases, patterns) {
+    for (const pattern of patterns) {
+        const match = phases.find(p => p.name.toLowerCase().includes(pattern.toLowerCase()));
+        if (match)
+            return match.id;
+    }
+    return null;
+}
+/**
+ * Discover Agent Directory workflow schema dynamically for a specific workspace
+ * @param client - Hailer client (connected to the workspace)
+ * @param workspaceId - The workspace ID to discover schema for
+ */
+async function discoverAgentDirectorySchema(client, workspaceId, hintProcessId) {
+    try {
+        // Get list of workflows - filter by workspace ID to avoid API caching issues
+        const workflows = await client.listWorkflows(workspaceId);
+        // Log all workflow names for debugging
+        logger.debug('Available workflows for discovery', {
+            workspaceId,
+            count: workflows.length,
+            names: workflows.map((w) => w.name).slice(0, 10) // First 10 for brevity
+        });
+        // Find ALL workflows matching Agent Directory pattern
+        const matchingWorkflows = workflows.filter((w) => AGENT_DIRECTORY_PATTERNS.some(p => w.name?.includes(p)));
+        logger.debug('Matching Agent Directory workflows', {
+            workspaceId,
+            count: matchingWorkflows.length,
+            workflows: matchingWorkflows.map((w) => ({ id: w._id, name: w.name }))
+        });
+        // First, check if hintProcessId points to a valid Agent Directory
+        // (even if name doesn't match our patterns - structure-based detection)
+        let agentDir = null;
+        if (hintProcessId) {
+            let hintWorkflow = workflows.find((w) => w._id === hintProcessId);
+            // If workflow not in list, try fetching directly (API might return stale cached list)
+            if (!hintWorkflow) {
+                logger.debug('Hint workflow not in list, fetching directly', { hintProcessId, listCount: workflows.length });
+                try {
+                    // Use process.get to fetch workflow directly by ID
+                    const directWorkflow = await client.getClient().socket.request('process.get', [hintProcessId]);
+                    if (directWorkflow && directWorkflow._id) {
+                        hintWorkflow = directWorkflow;
+                        logger.info('Fetched workflow directly by ID', {
+                            workflowId: hintProcessId,
+                            name: directWorkflow.name,
+                            workspaceId: directWorkflow.cid
+                        });
+                    }
+                }
+                catch (fetchErr) {
+                    logger.debug('Could not fetch workflow directly', { hintProcessId, error: fetchErr instanceof Error ? fetchErr.message : JSON.stringify(fetchErr) });
+                }
+            }
+            if (hintWorkflow) {
+                const phases = Object.values(hintWorkflow.phases || {});
+                const hasDeployedPhase = phases.some(p => DEPLOYED_PHASE_PATTERNS.some(pat => p.name?.toLowerCase().includes(pat)));
+                const hasRetiredPhase = phases.some(p => RETIRED_PHASE_PATTERNS.some(pat => p.name?.toLowerCase().includes(pat)));
+                const fieldKeys = Object.values(hintWorkflow.fields || {}).map((f) => f.key?.toLowerCase() || '');
+                const hasProfileField = fieldKeys.some(k => k.includes('hailerprofile') || k.includes('profile'));
+                if (hasDeployedPhase && hasRetiredPhase && hasProfileField) {
+                    agentDir = hintWorkflow;
+                    logger.info('Using hinted workflow (structure matches Agent Directory)', {
+                        workspaceId,
+                        hintProcessId,
+                        name: hintWorkflow.name,
+                        phases: phases.map(p => p.name)
+                    });
+                }
+            }
+        }
+        // If no hint match, try name-based matching
+        if (!agentDir) {
+            if (matchingWorkflows.length === 0) {
+                logger.warn('Agent Directory workflow not found by name pattern', {
+                    workspaceId,
+                    patterns: AGENT_DIRECTORY_PATTERNS,
+                    availableWorkflows: workflows.map((w) => w.name)
+                });
+                return false;
+            }
+            // If we have a hint, check if it matches one of the name-matched workflows
+            if (hintProcessId) {
+                const hintMatch = matchingWorkflows.find((w) => w._id === hintProcessId);
+                if (hintMatch) {
+                    agentDir = hintMatch;
+                    logger.info('Using hinted workflow from signal', { workspaceId, hintProcessId });
+                }
+            }
+            // If still no match, prefer unknown workflow over already-known
+            if (!agentDir && matchingWorkflows.length > 1) {
+                const unknownWorkflows = matchingWorkflows.filter((w) => !workflowToWorkspace.has(w._id));
+                if (unknownWorkflows.length > 0) {
+                    agentDir = unknownWorkflows[0];
+                    logger.info('Preferring unknown workflow over already-known one', {
+                        workspaceId,
+                        chosen: agentDir._id,
+                        skipped: matchingWorkflows.filter((w) => workflowToWorkspace.has(w._id)).map((w) => w._id)
+                    });
+                }
+            }
+            // Fallback to first match
+            if (!agentDir) {
+                agentDir = matchingWorkflows[0];
+            }
+        }
+        const discoveredWorkflowId = agentDir._id;
+        // Use the workflow's actual workspace ID if available (from direct fetch)
+        // This handles the case where the workflow belongs to a different workspace than we're searching in
+        const actualWorkspaceId = agentDir.cid || workspaceId;
+        if (actualWorkspaceId !== workspaceId) {
+            logger.info('Workflow belongs to different workspace than expected', {
+                expectedWorkspaceId: workspaceId,
+                actualWorkspaceId,
+                workflowId: discoveredWorkflowId
+            });
+        }
+        logger.info('Discovered Agent Directory workflow', { workspaceId: actualWorkspaceId, id: discoveredWorkflowId, name: agentDir.name });
+        // Use workflow data directly from listWorkflows (already includes phases/fields)
+        const workflowDetails = agentDir;
+        // Extract phases
+        const phases = [];
+        if (workflowDetails.phases) {
+            for (const [phaseId, phase] of Object.entries(workflowDetails.phases)) {
+                phases.push({ id: phaseId, name: phase.name || phaseId });
+            }
+        }
+        const discoveredDeployedPhaseId = findPhaseByPattern(phases, DEPLOYED_PHASE_PATTERNS);
+        const discoveredRetiredPhaseId = findPhaseByPattern(phases, RETIRED_PHASE_PATTERNS);
+        logger.info('Discovered phases', {
+            workspaceId: actualWorkspaceId,
+            deployed: discoveredDeployedPhaseId,
+            retired: discoveredRetiredPhaseId,
+            allPhases: phases.map(p => p.name)
+        });
+        // Extract field IDs by key
+        const fieldMap = {};
+        if (workflowDetails.fields) {
+            for (const [fieldId, field] of Object.entries(workflowDetails.fields)) {
+                const key = field.key;
+                if (key)
+                    fieldMap[key] = fieldId;
+            }
+        }
+        const discoveredHailerProfileFieldId = findFieldId(fieldMap, FIELD_KEY_HAILER_PROFILE);
+        const discoveredEmailFieldId = findFieldId(fieldMap, FIELD_KEY_EMAIL);
+        const discoveredPasswordFieldId = findFieldId(fieldMap, FIELD_KEY_PASSWORD);
+        const discoveredBotTypeFieldId = findFieldId(fieldMap, FIELD_KEY_BOT_TYPE);
+        logger.info('Discovered field IDs', {
+            workspaceId: actualWorkspaceId,
+            hailerProfile: discoveredHailerProfileFieldId,
+            email: discoveredEmailFieldId,
+            password: discoveredPasswordFieldId,
+            botType: discoveredBotTypeFieldId
+        });
+        // Build and store schema config for this workspace
+        const schema = {
+            agentDirectoryWorkflowId: discoveredWorkflowId,
+            deployedPhaseId: discoveredDeployedPhaseId,
+            retiredPhaseId: discoveredRetiredPhaseId,
+            hailerProfileFieldId: discoveredHailerProfileFieldId,
+            emailFieldId: discoveredEmailFieldId,
+            passwordFieldId: discoveredPasswordFieldId,
+            botTypeFieldId: discoveredBotTypeFieldId
+        };
+        setWorkspaceSchema(actualWorkspaceId, schema);
+        // Set as active workspace if none set
+        if (!activeWorkspaceId) {
+            activeWorkspaceId = actualWorkspaceId;
+            logger.info('Set active workspace', { workspaceId: actualWorkspaceId });
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error('Failed to discover Agent Directory schema', {
+            workspaceId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return false;
+    }
+}
+/**
+ * Sync bot credentials from a workspace's Agent Directory
+ * Called after schema discovery to load deployed bots
+ */
+async function syncCredentialsFromWorkspace(client, workspaceId) {
+    const schema = workspaceSchemas.get(workspaceId);
+    if (!schema?.agentDirectoryWorkflowId || !schema?.deployedPhaseId) {
+        logger.debug('Cannot sync credentials - missing schema', { workspaceId });
+        return;
+    }
+    try {
+        logger.info('Syncing credentials from workspace Agent Directory', { workspaceId });
+        // Fetch deployed agents
+        const deployedActivities = await client.fetchActivityList(schema.agentDirectoryWorkflowId, schema.deployedPhaseId, 100, { returnFlat: true });
+        const deployedList = Array.isArray(deployedActivities)
+            ? deployedActivities
+            : (deployedActivities?.data || deployedActivities?.activities || []);
+        logger.info('Found deployed agents in workspace', { workspaceId, count: deployedList.length });
+        for (const activity of deployedList) {
+            const userId = extractUserIdFromActivity(activity, schema);
+            if (!userId)
+                continue;
+            // Extract and save credentials
+            const creds = extractCredentialsFromActivity(activity, schema);
+            if (creds) {
+                updateLocalCredentials(userId, creds);
+                logger.info('Synced credentials from workspace', { workspaceId, userId, email: (0, config_1.maskEmail)(creds.email) });
+            }
+            // Extract bot type and update state
+            const botType = extractBotTypeFromActivity(activity, schema);
+            botState[userId] = {
+                enabled: true,
+                userId,
+                botType: botType ?? botState[userId]?.botType ?? null
+            };
+        }
+        // Also sync retired agents (for completeness)
+        if (schema.retiredPhaseId) {
+            const retiredActivities = await client.fetchActivityList(schema.agentDirectoryWorkflowId, schema.retiredPhaseId, 100, { returnFlat: true });
+            const retiredList = Array.isArray(retiredActivities)
+                ? retiredActivities
+                : (retiredActivities?.data || retiredActivities?.activities || []);
+            for (const activity of retiredList) {
+                const userId = extractUserIdFromActivity(activity, schema);
+                if (!userId)
+                    continue;
+                const creds = extractCredentialsFromActivity(activity, schema);
+                if (creds) {
+                    updateLocalCredentials(userId, creds);
+                }
+                const botType = extractBotTypeFromActivity(activity, schema);
+                botState[userId] = {
+                    enabled: false,
+                    userId,
+                    botType: botType ?? botState[userId]?.botType ?? null
+                };
+            }
+        }
+        // Note: Persistence now handled by webhooks via .bot-config/ files
+        // saveStateToLocalFile(botState); // REMOVED: Webhooks maintain .bot-config/ as source of truth
+        logger.info('Credentials synced from workspace', { workspaceId });
+    }
+    catch (error) {
+        logger.error('Failed to sync credentials from workspace', {
+            workspaceId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+/**
+ * Sync credentials from ALL workspaces that have loaded schemas
+ * Called at startup to ensure credentials are synced for all discovered Agent Directories
+ */
+async function syncCredentialsFromAllWorkspaces(client) {
+    const workspaceIds = Array.from(workspaceSchemas.keys());
+    if (workspaceIds.length === 0) {
+        logger.debug('No workspace schemas loaded - skipping credential sync');
+        return;
+    }
+    logger.info('Syncing credentials from all workspace schemas', { workspaceCount: workspaceIds.length });
+    // Remember original workspace to switch back
+    let originalWorkspaceId = null;
+    try {
+        const init = await client.fetchInit(['network']);
+        originalWorkspaceId = init?.network?._id;
+    }
+    catch (e) {
+        logger.warn('Could not determine original workspace');
+    }
+    for (const wsId of workspaceIds) {
+        const schema = workspaceSchemas.get(wsId);
+        if (!schema?.agentDirectoryWorkflowId || !schema?.deployedPhaseId) {
+            logger.debug('Skipping workspace - incomplete schema', { workspaceId: wsId });
+            continue;
+        }
+        try {
+            // Switch to this workspace
+            logger.info('Switching to workspace for credential sync', { workspaceId: wsId });
+            await client.getClient().socket.request('core.switch_ecosystem', [wsId]);
+            // Verify switch
+            const verifyInit = await client.fetchInit(['network']);
+            const currentWs = verifyInit?.network?._id;
+            if (currentWs !== wsId) {
+                logger.warn('Workspace switch failed', { target: wsId, current: currentWs });
+                continue;
+            }
+            // Sync credentials
+            await syncCredentialsFromWorkspace(client, wsId);
+        }
+        catch (error) {
+            logger.warn('Failed to sync credentials from workspace', {
+                workspaceId: wsId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    // Switch back to original workspace
+    if (originalWorkspaceId) {
+        try {
+            await client.getClient().socket.request('core.switch_ecosystem', [originalWorkspaceId]);
+            logger.info('Switched back to original workspace', { workspaceId: originalWorkspaceId });
+        }
+        catch (e) {
+            logger.warn('Failed to switch back to original workspace');
+        }
+    }
+}
+/**
+ * Get discovered workflow ID for a workspace (or active workspace if not specified)
+ */
+function getAgentDirectoryWorkflowId(workspaceId) {
+    const wsId = workspaceId ?? activeWorkspaceId;
+    if (!wsId)
+        return null;
+    return workspaceSchemas.get(wsId)?.agentDirectoryWorkflowId ?? null;
+}
+/**
+ * Get discovered phase IDs for a workspace (or active workspace if not specified)
+ */
+function getPhaseIds(workspaceId) {
+    const wsId = workspaceId ?? activeWorkspaceId;
+    if (!wsId)
+        return { deployed: null, retired: null };
+    const schema = workspaceSchemas.get(wsId);
+    return { deployed: schema?.deployedPhaseId ?? null, retired: schema?.retiredPhaseId ?? null };
+}
+// Dynamically discovered activity IDs (populated at runtime from Hailer)
+// NOW KEYED BY USER ID instead of bot ID
+let discoveredActivityIds = {};
+// Legacy hardcoded IDs (fallback only)
+const LEGACY_AGENT_ACTIVITY_IDS = {
     hal: '6957848b8d347a6c707ee3f6',
     hailerExpert: '695784913c659fc4d8fe0e02',
     giuseppe: '695e42deca61319424bc8b23',
     vastuullisuus: '695e42dfca61319424bc8b2e'
 };
+// Get activity ID for a bot - prefers discovered IDs over legacy
+function getActivityIdForBot(botId) {
+    return discoveredActivityIds[botId] || LEGACY_AGENT_ACTIVITY_IDS[botId];
+}
 // Persistence state
 let persistenceInitialized = false;
 let hailerClient = null; // Will be set during initialization
@@ -73,154 +742,1086 @@ exports.AVAILABLE_BOTS = [
         description: 'Sustainability analysis for SMEs',
         icon: '🌱'
     }
-];
-// In-memory bot state (will be synced with workflow)
-const botState = {
-    hal: true, // HAL enabled by default
-    giuseppe: false,
-    hailerExpert: false,
-    vastuullisuus: false
-};
-// Callbacks for when bot state changes
-const stateChangeCallbacks = [];
-function onBotStateChange(callback) {
-    stateChangeCallbacks.push(callback);
+];
+// In-memory bot state (synced with workflow via AI Hub)
+// Only contains bots registered via AI Hub - no legacy defaults
+let botState = {};
+// Activity signal deduplication to prevent duplicate processing on socket reconnects
+// Maps activityId+phaseId to timestamp of last processing
+const processedSignals = new Map();
+const SIGNAL_DEDUP_WINDOW_MS = 5000; // 5 seconds
+/**
+ * Check if an activity signal was recently processed (deduplication)
+ * Returns true if signal should be skipped (already processed)
+ */
+function isDuplicateSignal(activityId, phaseId) {
+    const key = `${activityId}:${phaseId}`;
+    const now = Date.now();
+    const lastProcessed = processedSignals.get(key);
+    if (lastProcessed && now - lastProcessed < SIGNAL_DEDUP_WINDOW_MS) {
+        return true;
+    }
+    // Mark as processed
+    processedSignals.set(key, now);
+    // Cleanup old entries periodically (keep map from growing unbounded)
+    if (processedSignals.size > 1000) {
+        const cutoff = now - SIGNAL_DEDUP_WINDOW_MS;
+        for (const [k, timestamp] of processedSignals) {
+            if (timestamp < cutoff) {
+                processedSignals.delete(k);
+            }
+        }
+    }
+    return false;
+}
+// Track orchestrator user ID (set during sync from Agent Directory)
+let orchestratorUserId = null;
+/**
+ * Get the orchestrator user ID
+ * Returns the user ID of the bot marked as orchestrator in Agent Directory
+ */
+function getOrchestratorUserId() {
+    return orchestratorUserId;
+}
+/**
+ * Set the orchestrator user ID
+ * Called during Agent Directory sync - set to first deployed bot with credentials
+ */
+function setOrchestratorUserId(userId) {
+    const wasNull = orchestratorUserId === null;
+    orchestratorUserId = userId;
+    logger.info('Orchestrator user ID set', { userId: userId ?? undefined });
+    // Notify daemon to restart if we just discovered an orchestrator
+    if (wasNull && userId !== null) {
+        notifyDaemonRestartNeeded();
+    }
+}
+// Load local state immediately on module load (before any async operations)
+const localStateOnLoad = loadStateFromLocalFile();
+if (Object.keys(localStateOnLoad).length > 0) {
+    // Accept ALL entries including user-ID based bots (not just AVAILABLE_BOTS)
+    Object.keys(localStateOnLoad).forEach(botId => {
+        botState[botId] = localStateOnLoad[botId];
+    });
+    logger.info('Bot state restored from local file on module load', { config: botState });
+}
+// Callbacks for when bot state changes
+const stateChangeCallbacks = [];
+function onBotStateChange(callback) {
+    stateChangeCallbacks.push(callback);
+}
+// Callbacks for when bot credentials change
+const credentialChangeCallbacks = [];
+function onBotCredentialsChange(callback) {
+    credentialChangeCallbacks.push(callback);
+}
+// Callbacks for when daemon restart is needed (new orchestrator discovered)
+const daemonRestartCallbacks = [];
+function onDaemonRestartNeeded(callback) {
+    daemonRestartCallbacks.push(callback);
+}
+// Debounce mechanism to prevent multiple rapid restart triggers
+let restartDebounceTimer = null;
+const RESTART_DEBOUNCE_MS = 500;
+/**
+ * Cleanup function to clear pending timers and state on shutdown
+ * Should be called from Core.stop() to prevent orphaned callbacks
+ */
+function cleanupBotConfig() {
+    if (restartDebounceTimer) {
+        clearTimeout(restartDebounceTimer);
+        restartDebounceTimer = null;
+    }
+    // Clear deduplication cache
+    processedSignals.clear();
+    // Clear callbacks to prevent memory leaks
+    stateChangeCallbacks.length = 0;
+    daemonRestartCallbacks.length = 0;
+    logger.debug('Bot config cleanup completed');
+}
+function notifyDaemonRestartNeeded() {
+    // Clear any pending restart to reset the debounce window
+    if (restartDebounceTimer) {
+        logger.debug('Daemon restart already pending, resetting debounce timer');
+        clearTimeout(restartDebounceTimer);
+    }
+    // Debounce the restart notification
+    restartDebounceTimer = setTimeout(() => {
+        restartDebounceTimer = null;
+        logger.info('Notifying daemon restart needed (new orchestrator discovered)');
+        daemonRestartCallbacks.forEach(cb => {
+            try {
+                cb();
+            }
+            catch (error) {
+                logger.error('Daemon restart callback failed', { error });
+            }
+        });
+    }, RESTART_DEBOUNCE_MS);
+}
+function getBotState() {
+    const result = {};
+    // First, read from webhook configs (.bot-config/*.json)
+    const configDir = path.join(process.cwd(), '.bot-config');
+    if (fs.existsSync(configDir)) {
+        const files = fs.readdirSync(configDir).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(configDir, file), 'utf-8');
+                const config = JSON.parse(content);
+                // Add orchestrator
+                if (config.orchestrator?.userId) {
+                    result[config.orchestrator.userId] = true; // Orchestrator in config = enabled
+                }
+                // Add specialists
+                if (config.specialists) {
+                    for (const spec of config.specialists) {
+                        if (spec.userId) {
+                            result[spec.userId] = spec.enabled;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to read webhook config', { file, error: String(error) });
+            }
+        }
+    }
+    // Merge with in-memory state (webhook config takes precedence)
+    for (const [botId, entry] of Object.entries(botState)) {
+        if (!(botId in result)) {
+            result[botId] = entry.enabled;
+        }
+    }
+    return result;
+}
+/**
+ * Get the user ID associated with a bot
+ */
+function getBotUserId(botId) {
+    return botState[botId]?.userId ?? null;
+}
+/**
+ * Get the bot type for a user ID
+ * Returns values like 'orchestrator', 'workflow-expert', 'bug-fixer', etc.
+ */
+function getBotType(userId) {
+    return botState[userId]?.botType ?? null;
+}
+/**
+ * Get all enabled bots with their types
+ * Returns map of userId -> botType for enabled bots only
+ */
+function getEnabledBotsWithTypes() {
+    const result = new Map();
+    for (const [userId, entry] of Object.entries(botState)) {
+        if (entry.enabled) {
+            result.set(userId, entry.botType);
+        }
+    }
+    return result;
+}
+/**
+ * Set the user ID associated with a bot
+ */
+function setBotUserId(botId, userId) {
+    if (!botState[botId]) {
+        botState[botId] = { enabled: false, userId: null, botType: null };
+    }
+    botState[botId].userId = userId;
+    // saveStateToLocalFile(botState); // REMOVED: Webhooks maintain .bot-config/ as source of truth
+    logger.debug('Bot userId updated', { botId, userId: userId ?? undefined });
+}
+/**
+ * Set bot enabled state
+ *
+ * Updates in-memory state and persists to Agent Directory by moving
+ * the agent activity to the appropriate phase (deployed/retired).
+ */
+function setBotEnabled(botId, enabled) {
+    if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
+        throw new Error(`Unknown bot: ${botId}`);
+    }
+    const existing = botState[botId];
+    botState[botId] = {
+        enabled,
+        userId: existing?.userId ?? null,
+        botType: existing?.botType ?? null
+    };
+    // Notify listeners
+    stateChangeCallbacks.forEach(cb => cb(botId, enabled));
+    logger.info('Bot state changed', { botId, enabled });
+    // Note: Persistence now handled by webhooks via .bot-config/ files
+    // saveStateToLocalFile(botState); // REMOVED: Webhooks maintain .bot-config/ as source of truth
+    // Persist to Hailer (triggers webhook which updates .bot-config/)
+    persistBotToHailer(botId, enabled).catch(err => logger.warn('Hailer persistence failed', { botId, err: err instanceof Error ? err.message : String(err) }));
+}
+/**
+ * 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
+ */
+async function handleActivityPhaseChange(processId, activityIds, newPhaseId) {
+    // Look up which workspace this workflow belongs to (reverse lookup)
+    let workspaceId = workflowToWorkspace.get(processId);
+    // If no workspace found, try to auto-discover by checking all accessible workspaces
+    if (!workspaceId && hailerClient) {
+        logger.info('Unknown workflow - attempting auto-discovery across workspaces', { processId });
+        try {
+            // Get all workspaces the user has access to
+            const init = await hailerClient.fetchInit(['networks']);
+            const allWorkspaces = init?.networks ? Object.keys(init.networks) : [];
+            logger.debug('Checking workspaces for unknown workflow', { processId, workspaceCount: allWorkspaces.length });
+            for (const wsId of allWorkspaces) {
+                // Skip if we already have schema for this workspace AND the signal's processId matches
+                // (Don't skip if the signal is from a different workflow - might be a new Agent Directory)
+                const existingSchema = workspaceSchemas.get(wsId);
+                if (existingSchema?.agentDirectoryWorkflowId) {
+                    // If signal processId matches cached schema, use cached data
+                    if (existingSchema.agentDirectoryWorkflowId === processId) {
+                        logger.debug('Signal matches cached schema - using cached workflow', { workspaceId: wsId, processId });
+                        workspaceId = wsId;
+                        break;
+                    }
+                    // If schema exists but points to different workflow, we might need to re-discover
+                    // Only skip if we're sure this workspace can't contain the signal's workflow
+                    if (workflowToWorkspace.has(existingSchema.agentDirectoryWorkflowId)) {
+                        logger.debug('Skipping workspace - schema points to different workflow', {
+                            workspaceId: wsId,
+                            cachedWorkflowId: existingSchema.agentDirectoryWorkflowId,
+                            signalProcessId: processId
+                        });
+                        continue;
+                    }
+                }
+                try {
+                    // Switch to this workspace
+                    logger.info('Switching to workspace for discovery', { workspaceId: wsId });
+                    await hailerClient.getClient().socket.request('core.switch_ecosystem', [wsId]);
+                    // Force a fresh init to confirm we're in the right workspace
+                    const verifyInit = await hailerClient.fetchInit(['network']);
+                    const currentWs = verifyInit?.network?._id;
+                    logger.info('Workspace switch verified', { targetWorkspace: wsId, currentWorkspace: currentWs });
+                    if (currentWs !== wsId) {
+                        logger.warn('Workspace switch failed - still in wrong workspace', { targetWorkspace: wsId, currentWorkspace: currentWs });
+                        continue;
+                    }
+                    // Try to discover Agent Directory - pass processId as hint
+                    // If the signal came from an Agent Directory, this will prefer that workflow
+                    const discovered = await discoverAgentDirectorySchema(hailerClient, wsId, processId);
+                    if (discovered) {
+                        // Sync credentials from this workspace's Agent Directory
+                        await syncCredentialsFromWorkspace(hailerClient, wsId);
+                        // Check if this processId is now known
+                        workspaceId = workflowToWorkspace.get(processId);
+                        if (workspaceId) {
+                            logger.info('Auto-discovered schema for workspace', { workspaceId, processId });
+                            break;
+                        }
+                    }
+                }
+                catch (switchError) {
+                    logger.debug('Could not discover in workspace', { workspaceId: wsId, error: switchError instanceof Error ? switchError.message : String(switchError) });
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Auto-discovery failed', { processId, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    // Still no workspace found after discovery attempt
+    if (!workspaceId) {
+        logger.debug('Skipping signal - workflow not an Agent Directory', { processId });
+        return;
+    }
+    // Get schema for this workspace
+    let schema = workspaceSchemas.get(workspaceId);
+    if (!schema) {
+        logger.debug('Skipping signal - no schema for workspace', { workspaceId, processId });
+        return;
+    }
+    logger.info('Processing Agent Directory signal', { workspaceId, processId, activityIds, newPhaseId });
+    // If we have IDs cached, check phase match
+    let isDeployed = schema.deployedPhaseId ? newPhaseId === schema.deployedPhaseId : false;
+    let isRetired = schema.retiredPhaseId ? newPhaseId === schema.retiredPhaseId : false;
+    // Check if we need to discover phase IDs (workflow is known but phases aren't)
+    const needsDiscovery = !schema.deployedPhaseId || !schema.retiredPhaseId;
+    // Also check if field IDs need discovery (separate from workflow/phase IDs)
+    const needsFieldDiscovery = !schema.passwordFieldId || !schema.emailFieldId || !schema.hailerProfileFieldId;
+    // Run field discovery if we have the workflow ID but not field IDs
+    if (needsFieldDiscovery && schema.agentDirectoryWorkflowId && hailerClient) {
+        await discoverFieldIds(hailerClient, workspaceId, schema.agentDirectoryWorkflowId);
+        // Refresh schema after discovery
+        schema = workspaceSchemas.get(workspaceId) ?? schema;
+    }
+    for (const activityId of activityIds) {
+        // Skip duplicate signals (socket reconnects can re-deliver same signal)
+        if (isDuplicateSignal(activityId, newPhaseId)) {
+            logger.debug('Skipping duplicate activity signal', { activityId, newPhaseId });
+            continue;
+        }
+        // Fetch the activity to check for schema config and user ID
+        if (!hailerClient) {
+            logger.debug('No Hailer client for activity fetch', { activityId });
+            continue;
+        }
+        let activity;
+        try {
+            // Try fetchActivityByIdSafe first (uses v3.activity.list, workspace-scoped)
+            activity = await hailerClient.fetchActivityByIdSafe(activityId, processId, newPhaseId);
+            // Fallback: use activities.load for cross-workspace access
+            // This works when signal comes from a different workspace than current socket context
+            if (!activity) {
+                logger.debug('Activity not found via v3.activity.list, trying activities.load', { activityId, processId, phaseId: newPhaseId });
+                activity = await hailerClient.fetchActivityById(activityId);
+            }
+            if (!activity) {
+                logger.warn('Activity not found for phase change', { activityId, processId, phaseId: newPhaseId });
+                continue;
+            }
+        }
+        catch (e) {
+            logger.warn('Could not fetch activity for phase change', { activityId, processId, phaseId: newPhaseId, error: e instanceof Error ? e.message : String(e) });
+            continue;
+        }
+        // Try to discover schema config from this activity (written by AI Hub)
+        if (needsDiscovery) {
+            const activitySchemaConfig = extractSchemaConfigFromActivity(activity);
+            if (activitySchemaConfig) {
+                // This IS an Agent Directory activity - apply config
+                applySchemaConfig(workspaceId, activitySchemaConfig);
+                // Discover field IDs if not already known
+                if (hailerClient && schema.agentDirectoryWorkflowId) {
+                    await discoverFieldIds(hailerClient, workspaceId, schema.agentDirectoryWorkflowId);
+                }
+                // Refresh schema and re-check phase match with newly discovered IDs
+                schema = workspaceSchemas.get(workspaceId) ?? schema;
+                isDeployed = newPhaseId === schema.deployedPhaseId;
+                isRetired = newPhaseId === schema.retiredPhaseId;
+                logger.info('Schema config discovered from signal', {
+                    workspaceId,
+                    processId,
+                    workflowId: schema.agentDirectoryWorkflowId ?? undefined,
+                    deployedPhaseId: schema.deployedPhaseId ?? undefined,
+                    retiredPhaseId: schema.retiredPhaseId ?? undefined
+                });
+            }
+            else {
+                // No schema config = not an Agent Directory activity (or not yet configured)
+                // Check if activity has hailerProfile to determine if it's a bot
+                const userId = extractUserIdFromActivity(activity);
+                if (!userId) {
+                    logger.debug('Activity has no schemaConfig or hailerProfile - not an agent', { activityId });
+                    continue;
+                }
+                // Has hailerProfile but no schemaConfig - might be Agent Directory but not configured yet
+                logger.debug('Activity has hailerProfile but no schemaConfig', { activityId, userId });
+            }
+        }
+        // Skip if phase doesn't match known phases
+        if (!isDeployed && !isRetired) {
+            continue;
+        }
+        // Extract user ID from activity
+        let userId = extractUserIdFromActivity(activity);
+        // If no hailerProfile, try to auto-link by matching activity name to user name
+        if (!userId && hailerClient) {
+            const activityName = activity.name;
+            if (activityName) {
+                try {
+                    // Try to find user by name match
+                    const foundUserId = await hailerClient.findUserByName(activityName);
+                    if (foundUserId) {
+                        logger.info('Auto-linking hailerProfile by name match', {
+                            activityId,
+                            activityName,
+                            userId: foundUserId
+                        });
+                        // Update activity with hailerProfile (users field expects array)
+                        // Use field ID 6965fe1179ec994375269e94 for hailerProfile
+                        const hailerProfileFieldIdForUpdate = '6965fe1179ec994375269e94';
+                        await hailerClient.updateActivities([{
+                                _id: activityId,
+                                fields: { [hailerProfileFieldIdForUpdate]: [foundUserId] }
+                            }], {});
+                        userId = foundUserId;
+                    }
+                    else {
+                        logger.debug('No user found matching activity name', {
+                            activityName,
+                            hint: 'Set the "Hailer Profile" field manually in the Agent Directory, or ensure activity name matches user\'s full name exactly'
+                        });
+                    }
+                }
+                catch (e) {
+                    logger.warn('Failed to auto-link hailerProfile by name', {
+                        activityId,
+                        error: e instanceof Error ? e.message : String(e)
+                    });
+                }
+            }
+        }
+        if (!userId) {
+            logger.debug('Activity has no hailerProfile user ID', { activityId });
+            continue;
+        }
+        // Cache the activity ID for this user
+        discoveredActivityIds[userId] = activityId;
+        // Extract bot type
+        const extractedBotType = extractBotTypeFromActivity(activity);
+        // Sync credentials
+        const creds = extractCredentialsFromActivity(activity);
+        if (creds) {
+            updateLocalCredentials(userId, creds);
+        }
+        logger.info('Agent Directory activity phase change detected', {
+            activityId,
+            userId,
+            newPhaseId,
+            isDeployed,
+            isRetired
+        });
+        const enabled = isDeployed;
+        const existingEntry = botState[userId];
+        botState[userId] = {
+            enabled,
+            userId, // Self-referential for compatibility
+            botType: extractedBotType ?? existingEntry?.botType ?? null
+        };
+        // saveStateToLocalFile(botState); // REMOVED: Webhooks maintain .bot-config/ as source of truth
+        // Notify listeners
+        stateChangeCallbacks.forEach(cb => cb(userId, enabled));
+        logger.info('Bot state updated from phase change', { userId, enabled, activityId });
+        // Only restart daemon if orchestrator state changes
+        // For specialists, the stateChangeCallbacks above will handle updating the orchestrator
+        const botType = botState[userId]?.botType;
+        if (botType === 'orchestrator') {
+            logger.info('Orchestrator state changed, triggering daemon restart');
+            notifyDaemonRestartNeeded();
+        }
+        else {
+            logger.debug('Specialist state changed, no daemon restart needed', { userId, botType });
+        }
+    }
+}
+/**
+ * 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.
+ */
+async function reloadConfigFromHailer() {
+    // If schema discovery hasn't succeeded yet, log that we're retrying
+    // (loadConfigFromHailer will attempt discovery internally)
+    if (workspaceSchemas.size === 0) {
+        logger.info('No workspace schemas discovered yet, reloadConfigFromHailer will attempt discovery...');
+    }
+    const config = await loadConfigFromHailer();
+    if (config) {
+        for (const [userId, enabled] of Object.entries(config)) {
+            if (botState[userId]?.enabled !== enabled) {
+                const existingEntry = botState[userId];
+                botState[userId] = {
+                    enabled,
+                    userId, // Self-referential
+                    botType: existingEntry?.botType ?? null
+                };
+                stateChangeCallbacks.forEach(cb => cb(userId, enabled));
+                logger.info('Bot state reloaded from Hailer', { userId, enabled });
+            }
+        }
+        // saveStateToLocalFile(botState); // REMOVED: Webhooks maintain .bot-config/ as source of truth
+    }
+}
+// ============================================================================
+// Persistence Layer Functions
+// ============================================================================
+/**
+ * Initialize persistence layer
+ * Called once during MCP server startup
+ *
+ * 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
+ */
+async function initBotConfigPersistence(client) {
+    if (persistenceInitialized) {
+        logger.debug('Bot config persistence already initialized');
+        return;
+    }
+    hailerClient = client;
+    // Set up signal handler for real-time activity signals
+    try {
+        signal_handler_1.SignalHandler.getOrCreate(client.getClient());
+        logger.info('Signal handler initialized for bot config monitoring');
+    }
+    catch (error) {
+        logger.warn('Failed to initialize signal handler', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    // Check if .bot-config/ directory has any files
+    const configDir = path.join(process.cwd(), '.bot-config');
+    const hasConfigFiles = fs.existsSync(configDir) &&
+        fs.readdirSync(configDir).some(f => f.endsWith('.json'));
+    // Priority 1: Load from .bot-config/ directory (webhook-maintained configs)
+    if (hasConfigFiles) {
+        const botConfigState = loadBotStateFromBotConfig();
+        if (Object.keys(botConfigState).length > 0) {
+            Object.keys(botConfigState).forEach(userId => {
+                botState[userId] = botConfigState[userId];
+            });
+            logger.info('Bot config loaded from .bot-config/ directory', { botCount: Object.keys(botConfigState).length });
+        }
+    }
+    else {
+        // Priority 2: Fallback to legacy .bot-state.json if .bot-config/ is empty
+        const localState = loadStateFromLocalFile();
+        if (Object.keys(localState).length > 0) {
+            Object.keys(localState).forEach(userId => {
+                botState[userId] = localState[userId];
+            });
+            logger.info('Bot config loaded from legacy .bot-state.json', { botCount: Object.keys(localState).length });
+        }
+    }
+    // Only sync credentials if .bot-config/ is empty (first-time setup)
+    // Otherwise, webhooks have already maintained the credentials
+    if (!hasConfigFiles) {
+        logger.info('No .bot-config/ files found - syncing credentials from workspaces');
+        await syncCredentialsFromAllWorkspaces(client);
+    }
+    else {
+        logger.info('Skipping credential sync - .bot-config/ files already exist (webhook-maintained)');
+    }
+    logger.info('Bot config persistence initialized');
+    persistenceInitialized = true;
+}
+/**
+ * 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
+ */
+async function initWorkspaceSchema(client, workspaceId) {
+    // Check if we already have schema for this workspace
+    const existingSchema = workspaceSchemas.get(workspaceId);
+    if (existingSchema?.agentDirectoryWorkflowId) {
+        logger.debug('Workspace schema already initialized', { workspaceId });
+        return true;
+    }
+    // Try to load from local file first
+    const loadedSchema = loadSchemaConfig(workspaceId);
+    if (loadedSchema?.agentDirectoryWorkflowId) {
+        logger.info('Workspace schema loaded from file', { workspaceId });
+        // Sync credentials from this workspace's Agent Directory
+        await syncCredentialsFromWorkspace(client, workspaceId);
+        return true;
+    }
+    // Discover schema from Hailer
+    logger.info('Discovering Agent Directory schema for workspace', { workspaceId });
+    const discovered = await discoverAgentDirectorySchema(client, workspaceId);
+    if (discovered) {
+        logger.info('Workspace schema discovered successfully', { workspaceId });
+        // Sync credentials from this workspace's Agent Directory
+        await syncCredentialsFromWorkspace(client, workspaceId);
+    }
+    else {
+        logger.debug('Agent Directory not found in workspace (may not have AI Hub installed)', { workspaceId });
+    }
+    return discovered;
+}
+/**
+ * Extract bot type from activity's botType field
+ */
+function extractBotTypeFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    const fieldsAndValues = activity.fieldsAndValues || [];
+    const botTypeFieldId = schema?.botTypeFieldId ?? get_botTypeFieldId();
+    // Try fields object format - by field KEY first (from returnFlat: true)
+    if (fields.botType) {
+        return typeof fields.botType === 'string' ? fields.botType : (fields.botType?.value || null);
+    }
+    // Try fields object format - by field ID
+    if (botTypeFieldId) {
+        const botTypeField = fields[botTypeFieldId];
+        if (botTypeField) {
+            return botTypeField.value || botTypeField;
+        }
+    }
+    // Try fieldsAndValues array format
+    const fav = fieldsAndValues.find((f) => (botTypeFieldId && f.fieldId === botTypeFieldId) || f.fieldName === 'Bot Type');
+    if (fav?.value) {
+        return typeof fav.value === 'string' ? fav.value : null;
+    }
+    return null;
+}
+/**
+ * Check if a string looks like a MongoDB ObjectId (24 hex characters)
+ */
+function looksLikeUserId(value) {
+    return /^[a-f0-9]{24}$/i.test(value);
+}
+/**
+ * Extract user ID from activity's hailerProfile field
+ */
+function extractUserIdFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    const fieldsAndValues = activity.fieldsAndValues || [];
+    const hailerProfileFieldId = schema?.hailerProfileFieldId ?? get_hailerProfileFieldId();
+    // Debug: log fields for troubleshooting
+    logger.debug('Extracting user ID - available fields', {
+        activityId: activity._id,
+        fieldKeys: Object.keys(fields),
+        hailerProfileFieldId,
+        fieldsSnapshot: JSON.stringify(fields).slice(0, 500)
+    });
+    // Try fields object format - by field KEY first (from returnFlat: true)
+    if (fields.hailerProfile) {
+        const value = fields.hailerProfile;
+        return typeof value === 'string' ? value : (Array.isArray(value) ? value[0] : null);
+    }
+    // Try fields object format - by field ID
+    if (hailerProfileFieldId) {
+        const profileField = fields[hailerProfileFieldId];
+        if (profileField) {
+            const value = profileField.value || profileField;
+            return typeof value === 'string' ? value : (Array.isArray(value) ? value[0] : null);
+        }
+    }
+    // Try fieldsAndValues array format
+    const fav = fieldsAndValues.find((f) => hailerProfileFieldId && f.fieldId === hailerProfileFieldId);
+    if (fav?.value) {
+        return typeof fav.value === 'string' ? fav.value : (Array.isArray(fav.value) ? fav.value[0] : null);
+    }
+    // Fallback: iterate ALL fields and look for users field type
+    // This handles activities.load returning fields by ID with {type, value} structure
+    for (const [fieldId, fieldValue] of Object.entries(fields)) {
+        // Check for {type: "users", value: "..."} structure from activities.load
+        if (fieldValue && typeof fieldValue === 'object' && !Array.isArray(fieldValue)) {
+            const typedField = fieldValue;
+            if (typedField.type === 'users' && typedField.value) {
+                const value = typedField.value;
+                const userId = typeof value === 'string' ? value : (Array.isArray(value) ? value[0] : null);
+                if (userId && looksLikeUserId(userId)) {
+                    logger.debug('Found user ID in typed users field', { fieldId, userId });
+                    return userId;
+                }
+            }
+        }
+        // Users fields are typically arrays of user IDs
+        if (Array.isArray(fieldValue) && fieldValue.length > 0) {
+            const firstVal = fieldValue[0];
+            if (typeof firstVal === 'string' && looksLikeUserId(firstVal)) {
+                logger.debug('Found user ID in array field', { fieldId, userId: firstVal });
+                return firstVal;
+            }
+        }
+        // Also check for single user ID string
+        if (typeof fieldValue === 'string' && looksLikeUserId(fieldValue)) {
+            // Skip known non-user fields (we're looking for hailerProfile specifically)
+            // Avoid returning schemaConfig field ID or other IDs
+            if (!fieldValue.startsWith('{')) { // Not JSON
+                logger.debug('Found potential user ID in string field', { fieldId, userId: fieldValue });
+                // Only return if this looks like a user field (not other activity links)
+                // For now, return the first match - could be refined
+            }
+        }
+    }
+    return null;
 }
-function getBotState() {
-    return { ...botState };
+/**
+ * Extract credentials and display name from activity
+ */
+function extractCredentialsFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    const fieldsAndValues = activity.fieldsAndValues || [];
+    const emailFieldId = schema?.emailFieldId ?? get_emailFieldId();
+    const passwordFieldId = schema?.passwordFieldId ?? get_passwordFieldId();
+    let email = null;
+    let password = null;
+    // Try fields object format - by field KEY first (from returnFlat: true)
+    if (fields.agentEmailInHailer) {
+        email = typeof fields.agentEmailInHailer === 'string' ? fields.agentEmailInHailer : (fields.agentEmailInHailer?.value || null);
+    }
+    if (fields.password) {
+        password = typeof fields.password === 'string' ? fields.password : (fields.password?.value || null);
+    }
+    // Try fields object format - by field ID
+    if (!email && emailFieldId) {
+        const emailField = fields[emailFieldId];
+        if (emailField) {
+            email = emailField.value || emailField;
+        }
+    }
+    if (!password && passwordFieldId) {
+        const passwordField = fields[passwordFieldId];
+        if (passwordField) {
+            password = passwordField.value || passwordField;
+        }
+    }
+    // Try fieldsAndValues array format
+    if (!email) {
+        const emailFav = fieldsAndValues.find((f) => emailFieldId && f.fieldId === emailFieldId);
+        email = emailFav?.value || null;
+    }
+    if (!password) {
+        const passwordFav = fieldsAndValues.find((f) => passwordFieldId && f.fieldId === passwordFieldId);
+        password = passwordFav?.value || null;
+    }
+    // Fallback: iterate ALL fields and find email/password by pattern
+    // This is only used if field discovery hasn't run - prefer using discovered field IDs
+    if (!email || !password) {
+        for (const [fieldId, fieldValue] of Object.entries(fields)) {
+            const strValue = typeof fieldValue === 'string' ? fieldValue : fieldValue?.value;
+            if (typeof strValue !== 'string')
+                continue;
+            // Email pattern: contains @
+            if (!email && strValue.includes('@') && strValue.includes('.')) {
+                const cleanEmail = strValue.replace(/['"]/g, '').trim();
+                logger.debug('Found email by pattern', { fieldId, email: (0, config_1.maskEmail)(cleanEmail) });
+                email = cleanEmail;
+            }
+        }
+        // Note: password fallback removed - rely on field discovery for correct password field
+        if (!password) {
+            logger.debug('Password not found - field discovery may not have run');
+        }
+    }
+    if (email && password) {
+        // Include activity name as display name for the bot
+        const displayName = activity.name || undefined;
+        return { email, password, displayName };
+    }
+    return null;
 }
 /**
- * Set bot enabled state
- *
- * Updates in-memory state and persists to Agent Directory by moving
- * the agent activity to the appropriate phase (deployed/retired).
+ * Extract schema config from activity (written by AI Hub for MCP sync)
+ * Returns the workflow/phase IDs if found, null otherwise
  */
-function setBotEnabled(botId, enabled) {
-    if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
-        throw new Error(`Unknown bot: ${botId}`);
+function extractSchemaConfigFromActivity(activity) {
+    const fields = activity.fields || {};
+    // Debug: log available field keys
+    logger.debug('Extracting schema config - available fields', {
+        activityId: activity._id,
+        fieldKeys: Object.keys(fields),
+        lookingFor: FIELD_KEY_SCHEMA_CONFIG
+    });
+    // Try fields object format - by field KEY first (from returnFlat: true)
+    let configJson = null;
+    for (const key of FIELD_KEY_SCHEMA_CONFIG) {
+        if (fields[key]) {
+            configJson = typeof fields[key] === 'string' ? fields[key] : (fields[key]?.value || null);
+            logger.debug('Found schema config field by key', { key, value: configJson });
+            if (configJson)
+                break;
+        }
+    }
+    // If not found by key, iterate ALL fields and try to parse as schema config
+    // (activities.load returns fields keyed by field ID, not field key)
+    if (!configJson) {
+        for (const [fieldId, fieldValue] of Object.entries(fields)) {
+            const valueStr = typeof fieldValue === 'string' ? fieldValue : fieldValue?.value;
+            if (typeof valueStr === 'string' && valueStr.startsWith('{')) {
+                try {
+                    const parsed = JSON.parse(valueStr);
+                    if (parsed.agentDirectoryWorkflowId && parsed.deployedPhaseId && parsed.retiredPhaseId) {
+                        logger.debug('Found schema config by field ID', { fieldId, value: valueStr });
+                        configJson = valueStr;
+                        break;
+                    }
+                }
+                catch {
+                    // Not valid JSON, skip
+                }
+            }
+        }
+    }
+    if (!configJson) {
+        logger.debug('No schema config found in fields');
+        return null;
+    }
+    try {
+        const config = JSON.parse(configJson);
+        // Validate required fields
+        if (config.agentDirectoryWorkflowId && config.deployedPhaseId && config.retiredPhaseId) {
+            return config;
+        }
+        logger.warn('Schema config missing required fields', { config });
+        return null;
+    }
+    catch (e) {
+        logger.warn('Failed to parse schema config JSON', { configJson, error: e });
+        return null;
     }
-    botState[botId] = enabled;
-    // Notify listeners
-    stateChangeCallbacks.forEach(cb => cb(botId, enabled));
-    logger.info('Bot state changed', { botId, enabled });
-    // Persist single bot to Hailer asynchronously (more efficient than full sync)
-    persistBotToHailer(botId, enabled).catch(err => logger.warn('Persistence failed', { botId, err: err instanceof Error ? err.message : String(err) }));
 }
-// ============================================================================
-// Persistence Layer Functions
-// ============================================================================
 /**
- * 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
- *
- * @param client - HailerApiClient instance for API calls
+ * Apply schema config from activity to a workspace
  */
-async function initBotConfigPersistence(client) {
-    if (persistenceInitialized) {
-        logger.debug('Bot config persistence already initialized');
+function applySchemaConfig(workspaceId, config) {
+    // Get existing schema or create new one
+    const existingSchema = workspaceSchemas.get(workspaceId);
+    const schema = {
+        agentDirectoryWorkflowId: config.agentDirectoryWorkflowId,
+        deployedPhaseId: config.deployedPhaseId,
+        retiredPhaseId: config.retiredPhaseId,
+        hailerProfileFieldId: existingSchema?.hailerProfileFieldId ?? null,
+        emailFieldId: existingSchema?.emailFieldId ?? null,
+        passwordFieldId: existingSchema?.passwordFieldId ?? null,
+        botTypeFieldId: existingSchema?.botTypeFieldId ?? null
+    };
+    setWorkspaceSchema(workspaceId, schema);
+    logger.info('Schema config applied from activity', {
+        workspaceId,
+        workflowId: config.agentDirectoryWorkflowId,
+        deployedPhaseId: config.deployedPhaseId,
+        retiredPhaseId: config.retiredPhaseId
+    });
+}
+/**
+ * Discover field IDs from workflow schema for a workspace
+ */
+async function discoverFieldIds(client, workspaceId, workflowId, phaseId) {
+    const schema = workspaceSchemas.get(workspaceId);
+    // Skip if already discovered
+    if (schema?.passwordFieldId && schema?.emailFieldId && schema?.hailerProfileFieldId) {
         return;
     }
-    hailerClient = client;
     try {
-        logger.info('Initializing bot config persistence from Agent Directory...', {
-            workflowId: AGENT_DIRECTORY_WORKFLOW_ID,
-            deployedPhaseId: DEPLOYED_PHASE_ID,
-            retiredPhaseId: RETIRED_PHASE_ID
-        });
-        // Load agent state from Agent Directory workflow
-        const existingConfig = await loadConfigFromHailer();
-        if (existingConfig) {
-            // Update in-memory state with persisted values
-            Object.keys(existingConfig).forEach(botId => {
-                if (exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
-                    botState[botId] = existingConfig[botId];
-                }
-            });
-            logger.info('Bot config loaded from Agent Directory', {
-                config: botState
-            });
+        // Use the phase ID if provided, otherwise try deployed phase
+        const targetPhaseId = phaseId || schema?.deployedPhaseId;
+        if (!targetPhaseId) {
+            logger.debug('No phase ID for field discovery', { workspaceId });
+            return;
+        }
+        // Get workflow fields from init data (has 'key' property)
+        const init = await client.fetchInit(['processes']);
+        const workflow = init?.processes?.find?.((p) => p._id === workflowId)
+            || (init?.processes?.[workflowId]); // Could be object or array
+        if (!workflow?.fields) {
+            logger.debug('Workflow fields not found in init', { workspaceId, workflowId });
+            return;
         }
-        logger.info('Bot config persistence initialized');
-        persistenceInitialized = true;
+        // Extract field IDs by key from workflow.fields
+        const fieldMap = {};
+        for (const [fieldId, field] of Object.entries(workflow.fields)) {
+            const fieldKey = field.key;
+            if (fieldKey) {
+                fieldMap[fieldKey] = fieldId;
+            }
+        }
+        logger.debug('Field map from init', {
+            workspaceId,
+            keys: Object.keys(fieldMap),
+            password: fieldMap['password'],
+            email: fieldMap['agentEmailInHailer'],
+            hailerProfile: fieldMap['hailerProfile']
+        });
+        // Update the schema with discovered field IDs
+        const updatedSchema = {
+            agentDirectoryWorkflowId: schema?.agentDirectoryWorkflowId ?? null,
+            deployedPhaseId: schema?.deployedPhaseId ?? null,
+            retiredPhaseId: schema?.retiredPhaseId ?? null,
+            hailerProfileFieldId: findFieldId(fieldMap, FIELD_KEY_HAILER_PROFILE),
+            emailFieldId: findFieldId(fieldMap, FIELD_KEY_EMAIL),
+            passwordFieldId: findFieldId(fieldMap, FIELD_KEY_PASSWORD),
+            botTypeFieldId: findFieldId(fieldMap, FIELD_KEY_BOT_TYPE)
+        };
+        setWorkspaceSchema(workspaceId, updatedSchema);
+        logger.info('Discovered field IDs from schema', {
+            workspaceId,
+            hailerProfile: updatedSchema.hailerProfileFieldId,
+            email: updatedSchema.emailFieldId,
+            password: updatedSchema.passwordFieldId,
+            botType: updatedSchema.botTypeFieldId
+        });
     }
     catch (error) {
-        logger.warn('Failed to initialize bot config persistence, using defaults', {
+        logger.warn('Failed to discover field IDs', {
+            workspaceId,
+            workflowId,
             error: error instanceof Error ? error.message : String(error)
         });
-        // Still mark as initialized to prevent repeated failures
-        persistenceInitialized = true;
     }
 }
+/**
+ * Update local credentials file with synced credentials from Hailer
+ */
+function updateLocalCredentials(userId, creds) {
+    const localCreds = loadLocalCredentials();
+    localCreds[userId] = {
+        email: creds.email,
+        password: creds.password,
+        ...(creds.displayName && { displayName: creds.displayName })
+    };
+    saveLocalCredentials(localCreds);
+    logger.debug('Credentials synced from Hailer', { userId, email: (0, config_1.maskEmail)(creds.email), displayName: creds.displayName });
+}
 /**
  * Load config from Agent Directory workflow
  *
+ * Discovers agents by their hailerProfile (user ID) field.
+ * Auto-syncs credentials from Hailer to local storage.
+ * Sets the first deployed bot with credentials as the orchestrator (simple approach).
  * Checks which phase each agent activity is in:
- * - DEPLOYED_PHASE_ID = enabled
- * - RETIRED_PHASE_ID = disabled
+ * - deployedPhaseId = enabled
+ * - retiredPhaseId = disabled
  *
- * @returns bot config or null if not found
+ * @returns bot config (keyed by user ID) or null if not found
  */
 async function loadConfigFromHailer() {
     if (!hailerClient) {
         logger.debug('Cannot load config: missing Hailer client');
         return null;
     }
+    // Get active workspace schema, or try to discover if not set
+    let schema = activeWorkspaceId ? workspaceSchemas.get(activeWorkspaceId) : null;
+    // If schema IDs not set, try to discover them dynamically
+    if (!schema?.agentDirectoryWorkflowId || !schema?.deployedPhaseId || !schema?.retiredPhaseId) {
+        logger.info('Schema IDs not set, attempting dynamic discovery...');
+        // Get workspace ID from client's init if we don't have one
+        if (!activeWorkspaceId) {
+            try {
+                const init = await hailerClient.fetchInit(['network']);
+                activeWorkspaceId = init?.network?._id;
+            }
+            catch (e) {
+                logger.warn('Could not determine workspace ID');
+            }
+        }
+        if (!activeWorkspaceId) {
+            logger.debug('Cannot discover schema: no workspace ID');
+            return null;
+        }
+        const discovered = await discoverAgentDirectorySchema(hailerClient, activeWorkspaceId);
+        if (!discovered) {
+            logger.debug('Cannot load config: schema discovery failed - will retry on signal');
+            return null;
+        }
+        schema = workspaceSchemas.get(activeWorkspaceId);
+        logger.info('Schema discovery successful', {
+            workspaceId: activeWorkspaceId,
+            workflowId: schema?.agentDirectoryWorkflowId ?? 'unknown',
+            deployedPhaseId: schema?.deployedPhaseId ?? 'unknown',
+            retiredPhaseId: schema?.retiredPhaseId ?? 'unknown'
+        });
+    }
+    // After discovery, verify we have all required IDs
+    if (!schema?.agentDirectoryWorkflowId || !schema?.deployedPhaseId || !schema?.retiredPhaseId) {
+        logger.warn('Schema discovery incomplete - missing required IDs');
+        return null;
+    }
+    // Now TypeScript knows these are non-null
+    const workflowId = schema.agentDirectoryWorkflowId;
+    const deployedPhase = schema.deployedPhaseId;
+    const retiredPhase = schema.retiredPhaseId;
     try {
         const config = {};
-        // Create reverse mapping: activityId -> botId
-        const activityIdToBotId = {};
-        for (const [botId, activityId] of Object.entries(AGENT_ACTIVITY_IDS)) {
-            activityIdToBotId[activityId] = botId;
-        }
+        // Reset discovered IDs (now keyed by user ID)
+        discoveredActivityIds = {};
+        // Reset orchestrator user ID (will be set to first deployed bot with credentials)
+        orchestratorUserId = null;
         // Fetch activities from deployed phase (enabled agents)
-        logger.debug('Fetching deployed agents...', { phaseId: DEPLOYED_PHASE_ID });
-        const deployedActivities = await hailerClient.fetchActivityList(AGENT_DIRECTORY_WORKFLOW_ID, DEPLOYED_PHASE_ID, 100, // limit
+        logger.debug('Fetching deployed agents...', { phaseId: deployedPhase });
+        const deployedActivities = await hailerClient.fetchActivityList(workflowId, deployedPhase, 100, // limit
         { returnFlat: true });
         // Mark agents in deployed phase as enabled
         const deployedList = Array.isArray(deployedActivities)
             ? deployedActivities
-            : (deployedActivities?.activities || []);
+            : (deployedActivities?.data || deployedActivities?.activities || []);
+        // Debug: log first activity structure to understand format
+        if (deployedList.length > 0) {
+            logger.debug('First deployed activity structure', {
+                activityId: deployedList[0]._id,
+                name: deployedList[0].name,
+                hasFields: !!deployedList[0].fields,
+                hasFieldsAndValues: !!deployedList[0].fieldsAndValues,
+                fieldKeys: deployedList[0].fields ? Object.keys(deployedList[0].fields) : [],
+                fieldsAndValuesLength: deployedList[0].fieldsAndValues?.length || 0
+            });
+        }
         for (const activity of deployedList) {
-            const botId = activityIdToBotId[activity._id];
-            if (botId) {
-                config[botId] = true;
-                logger.debug('Agent found in deployed phase (enabled)', { botId, activityId: activity._id });
+            const userId = extractUserIdFromActivity(activity);
+            if (userId) {
+                config[userId] = true;
+                discoveredActivityIds[userId] = activity._id;
+                // Extract botType from activity
+                const botType = extractBotTypeFromActivity(activity);
+                // Auto-sync credentials from Hailer
+                const creds = extractCredentialsFromActivity(activity);
+                if (creds) {
+                    updateLocalCredentials(userId, creds);
+                    // Set orchestrator based on botType='orchestrator', or fall back to first deployed bot with credentials
+                    if (botType === 'orchestrator' && !orchestratorUserId) {
+                        setOrchestratorUserId(userId);
+                        logger.info('Orchestrator set from botType field', { userId, activityId: activity._id, name: activity.name });
+                    }
+                    else if (!orchestratorUserId) {
+                        setOrchestratorUserId(userId);
+                        logger.info('Orchestrator set to first deployed bot with credentials', { userId, activityId: activity._id, name: activity.name });
+                    }
+                }
+                // Store botType in bot state
+                const existingEntry = botState[userId];
+                botState[userId] = {
+                    enabled: true,
+                    userId,
+                    botType: botType ?? existingEntry?.botType ?? null
+                };
+                logger.debug('Agent found (enabled)', { userId, activityId: activity._id, name: activity.name, botType });
             }
         }
         // Fetch activities from retired phase (disabled agents)
-        logger.debug('Fetching retired agents...', { phaseId: RETIRED_PHASE_ID });
-        const retiredActivities = await hailerClient.fetchActivityList(AGENT_DIRECTORY_WORKFLOW_ID, RETIRED_PHASE_ID, 100, // limit
+        logger.debug('Fetching retired agents...', { phaseId: retiredPhase });
+        const retiredActivities = await hailerClient.fetchActivityList(workflowId, retiredPhase, 100, // limit
         { returnFlat: true });
         // Mark agents in retired phase as disabled
         const retiredList = Array.isArray(retiredActivities)
             ? retiredActivities
-            : (retiredActivities?.activities || []);
+            : (retiredActivities?.data || retiredActivities?.activities || []);
         for (const activity of retiredList) {
-            const botId = activityIdToBotId[activity._id];
-            if (botId) {
-                config[botId] = false;
-                logger.debug('Agent found in retired phase (disabled)', { botId, activityId: activity._id });
-            }
-        }
-        // For any bots not found in either phase, default based on AVAILABLE_BOTS defaults
-        for (const bot of exports.AVAILABLE_BOTS) {
-            if (config[bot.id] === undefined) {
-                // Default: HAL enabled, others disabled
-                config[bot.id] = bot.id === 'hal';
-                logger.debug('Agent not found in any phase, using default', {
-                    botId: bot.id,
-                    default: config[bot.id]
-                });
+            const userId = extractUserIdFromActivity(activity);
+            if (userId) {
+                config[userId] = false;
+                discoveredActivityIds[userId] = activity._id;
+                // Extract botType from activity
+                const botType = extractBotTypeFromActivity(activity);
+                // Also sync credentials for retired bots
+                const creds = extractCredentialsFromActivity(activity);
+                if (creds) {
+                    updateLocalCredentials(userId, creds);
+                }
+                // Store botType in bot state
+                const existingEntry = botState[userId];
+                botState[userId] = {
+                    enabled: false,
+                    userId,
+                    botType: botType ?? existingEntry?.botType ?? null
+                };
+                logger.debug('Agent found (disabled)', { userId, activityId: activity._id, name: activity.name, botType });
             }
         }
+        logger.info('Discovered agents by user ID', { discoveredActivityIds });
         logger.info('Bot config loaded from Agent Directory', {
             deployedCount: deployedList.length,
             retiredCount: retiredList.length,
-            config
+            userIdCount: Object.keys(config).length,
+            orchestratorUserId
         });
         return config;
     }
@@ -235,8 +1836,8 @@ async function loadConfigFromHailer() {
  * Persist a single bot's state to Hailer
  *
  * Moves the bot's agent activity between phases:
- * - enabled = move to DEPLOYED_PHASE_ID
- * - disabled = move to RETIRED_PHASE_ID
+ * - enabled = move to deployedPhaseId
+ * - disabled = move to retiredPhaseId
  *
  * @param botId - The bot ID to persist
  * @param enabled - Whether the bot is enabled
@@ -246,12 +1847,12 @@ async function persistBotToHailer(botId, enabled) {
         logger.debug('Persistence not initialized, skipping save');
         return;
     }
-    const activityId = AGENT_ACTIVITY_IDS[botId];
+    const activityId = getActivityIdForBot(botId);
     if (!activityId) {
-        logger.warn('No activity ID found for bot', { botId });
+        logger.warn('No activity ID found for bot (not discovered yet)', { botId });
         return;
     }
-    const targetPhaseId = enabled ? DEPLOYED_PHASE_ID : RETIRED_PHASE_ID;
+    const targetPhaseId = enabled ? get_deployedPhaseId() : get_retiredPhaseId();
     try {
         logger.debug('Moving agent to phase...', {
             botId,
@@ -277,66 +1878,328 @@ async function persistBotToHailer(botId, enabled) {
     }
 }
 /**
- * Save current bot state to Hailer (legacy function for full sync)
- * Called asynchronously after state changes
+ * Check if persistence is initialized
+ */
+function isPersistenceInitialized() {
+    return persistenceInitialized;
+}
+// ============================================================================
+// Local Credential Storage (Fallback)
+// ============================================================================
+const LOCAL_CREDENTIALS_FILE = path.join(process.cwd(), '.bot-credentials.json');
+/**
+ * Load credentials from local file storage
+ */
+function loadLocalCredentials() {
+    try {
+        if (fs.existsSync(LOCAL_CREDENTIALS_FILE)) {
+            const data = fs.readFileSync(LOCAL_CREDENTIALS_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to load local credentials', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {};
+}
+/**
+ * Save credentials to local file storage
+ */
+function saveLocalCredentials(creds) {
+    try {
+        fs.writeFileSync(LOCAL_CREDENTIALS_FILE, JSON.stringify(creds, null, 2));
+        logger.debug('Local credentials saved', { file: LOCAL_CREDENTIALS_FILE });
+    }
+    catch (error) {
+        logger.warn('Failed to save local credentials', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+// ============================================================================
+// Credential Management Functions
+// ============================================================================
+// Agent Directory field IDs for credentials
+// These are the field IDs in the Agent Directory workflow schema
+const AGENT_DIRECTORY_FIELD_IDS = {
+    email: '695784898d347a6c707ee375', // agentEmailInHailer
+    password: '695784898d347a6c707ee376', // password
+    firstName: '695784898d347a6c707ee36c', // firstName (Etunimi)
+    lastName: '695784898d347a6c707ee36d', // lastName (Sukunimi)
+};
+/**
+ * Get the Hailer user ID for a bot from the Agent Directory's hailerProfile field
+ * Returns null if not found or not configured
+ */
+async function getAgentUserIdFromDirectory(botId, hailerClient) {
+    if (!hailerClient)
+        return null;
+    const AGENT_DIRECTORY_WORKFLOW = '695784898d347a6c707ee365';
+    const DEPLOYED_PHASE = '695784898d347a6c707ee37d';
+    const HAILER_PROFILE_FIELD = '695784898d347a6c707ee374';
+    try {
+        // Find bot activity by name matching botId
+        const response = await hailerClient.request('v3.activity.list', [
+            { processId: AGENT_DIRECTORY_WORKFLOW, phaseId: DEPLOYED_PHASE },
+            { limit: 50 }
+        ]);
+        // Match bot by name (case-insensitive, partial match)
+        const botActivity = response.data?.find(a => a.name.toLowerCase().includes(botId.toLowerCase()));
+        if (!botActivity) {
+            logger.debug('Bot activity not found in Agent Directory', { botId });
+            return null;
+        }
+        // Get hailerProfile field value
+        const profileField = botActivity.fieldsAndValues?.find(f => f.fieldId === HAILER_PROFILE_FIELD);
+        if (!profileField?.value) {
+            logger.debug('Bot has no hailerProfile configured', { botId, activityId: botActivity._id });
+            return null;
+        }
+        // Users field can be array or single value
+        const userId = Array.isArray(profileField.value) ? profileField.value[0] : profileField.value;
+        logger.debug('Found user ID for bot', { botId, userId });
+        return userId;
+    }
+    catch (error) {
+        logger.warn('Failed to get agent user ID from directory', {
+            botId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return null;
+    }
+}
+/**
+ * Get bot credentials from Agent Directory
  *
- * Note: This syncs all bots. For single bot changes, persistBotToHailer is more efficient.
+ * 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
  */
-async function persistToHailer() {
-    if (!hailerClient || !persistenceInitialized) {
-        logger.debug('Persistence not initialized, skipping save');
-        return;
+async function getBotCredentials(botIdOrActivityId, showPassword = false) {
+    // Support both bot IDs (hal, giuseppe) and activity IDs
+    let botId = botIdOrActivityId;
+    let activityId = getActivityIdForBot(botIdOrActivityId);
+    // If not found by bot ID, try reverse lookup by activity ID
+    if (!activityId) {
+        // Check if input is an activity ID in discovered or legacy lists
+        const allActivityIds = { ...discoveredActivityIds, ...LEGACY_AGENT_ACTIVITY_IDS };
+        const reverseEntry = Object.entries(allActivityIds).find(([, aId]) => aId === botIdOrActivityId);
+        if (reverseEntry) {
+            botId = reverseEntry[0];
+            activityId = reverseEntry[1];
+        }
+        else {
+            // Not in predefined list - assume input is a raw activity ID
+            activityId = botIdOrActivityId;
+            botId = botIdOrActivityId; // Use activity ID as identifier
+            logger.debug('Using raw activity ID for credentials lookup', { activityId });
+        }
+    }
+    // Try local storage first as it may have newer credentials
+    const localCreds = loadLocalCredentials();
+    // NEW: Try to get user ID from Agent Directory first
+    const userId = await getAgentUserIdFromDirectory(botId, hailerClient);
+    if (userId && localCreds[userId]) {
+        logger.debug('Found credentials by user ID', { botId, userId, showPassword });
+        return {
+            email: localCreds[userId].email,
+            password: showPassword ? localCreds[userId].password : '********',
+        };
+    }
+    // Fallback: Try bot ID directly (backwards compatibility)
+    const localBotCreds = localCreds[botId];
+    if (localBotCreds) {
+        logger.debug('Found credentials by bot ID (legacy)', { botId, showPassword });
+    }
+    if (!hailerClient) {
+        // No Hailer connection - use local storage only
+        if (localBotCreds) {
+            logger.debug('Using local credentials (Hailer unavailable)', { botId, showPassword });
+            return {
+                email: localBotCreds.email,
+                password: showPassword ? localBotCreds.password : '********',
+            };
+        }
+        logger.warn('Cannot get credentials: Hailer client not initialized and no local credentials', { botId });
+        return null;
     }
+    // Try Hailer first if available
     try {
-        logger.debug('Persisting all bot config to Hailer...', { state: botState });
-        // Build updates for all bots
-        const enabledUpdates = [];
-        const disabledUpdates = [];
-        for (const [botId, enabled] of Object.entries(botState)) {
-            const activityId = AGENT_ACTIVITY_IDS[botId];
-            if (!activityId) {
-                logger.debug('No activity ID for bot, skipping', { botId });
-                continue;
-            }
-            if (enabled) {
-                enabledUpdates.push({ _id: activityId });
-            }
-            else {
-                disabledUpdates.push({ _id: activityId });
+        logger.debug('Fetching bot credentials from Hailer...', { botId, activityId });
+        // Fetch the activity to get field values
+        const activity = await hailerClient.fetchActivityById(activityId);
+        if (!activity) {
+            logger.warn('Activity not found', { botId, activityId });
+            // Fall back to local storage
+            if (localBotCreds) {
+                logger.debug('Activity not found in Hailer, using local credentials', { botId, showPassword });
+                return {
+                    email: localBotCreds.email,
+                    password: showPassword ? localBotCreds.password : '********',
+                };
             }
+            return null;
         }
-        // Move enabled agents to deployed phase
-        if (enabledUpdates.length > 0) {
-            await hailerClient.updateActivities(enabledUpdates, { phaseId: DEPLOYED_PHASE_ID });
-            logger.debug('Moved agents to deployed phase', {
-                count: enabledUpdates.length,
-                phaseId: DEPLOYED_PHASE_ID
-            });
+        // Extract email and password from fieldsAndValues
+        const fields = activity.fieldsAndValues || {};
+        const email = fields[AGENT_DIRECTORY_FIELD_IDS.email];
+        const password = fields[AGENT_DIRECTORY_FIELD_IDS.password];
+        logger.debug('Bot credentials fetched from Hailer', {
+            botId,
+            hasEmail: !!email,
+            hasPassword: !!password,
+            showPassword
+        });
+        // If Hailer has no credentials stored, fall back to local storage
+        if (!email && !password && localBotCreds) {
+            logger.debug('Hailer has empty credentials, falling back to local storage', { botId });
+            return {
+                email: localBotCreds.email,
+                password: showPassword ? localBotCreds.password : '********'
+            };
         }
-        // Move disabled agents to retired phase
-        if (disabledUpdates.length > 0) {
-            await hailerClient.updateActivities(disabledUpdates, { phaseId: RETIRED_PHASE_ID });
-            logger.debug('Moved agents to retired phase', {
-                count: disabledUpdates.length,
-                phaseId: RETIRED_PHASE_ID
-            });
+        return {
+            email: email || undefined,
+            // Mask password for security unless showPassword is true
+            password: password ? (showPassword ? password : '********') : undefined
+        };
+    }
+    catch (error) {
+        logger.warn('Failed to get bot credentials from Hailer, trying local storage', {
+            botId,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        // Fall back to local storage
+        if (localBotCreds) {
+            return {
+                email: localBotCreds.email,
+                password: showPassword ? localBotCreds.password : '********'
+            };
+        }
+        return 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)
+ */
+async function updateBotCredentials(botIdOrActivityId, credentials) {
+    let activityId = getActivityIdForBot(botIdOrActivityId);
+    let botId = botIdOrActivityId;
+    // If not found by bot ID, try reverse lookup or use as raw activity ID
+    if (!activityId) {
+        const allActivityIds = { ...discoveredActivityIds, ...LEGACY_AGENT_ACTIVITY_IDS };
+        const reverseEntry = Object.entries(allActivityIds).find(([, aId]) => aId === botIdOrActivityId);
+        if (reverseEntry) {
+            botId = reverseEntry[0];
+            activityId = reverseEntry[1];
+        }
+        else {
+            // Assume input is a raw activity ID
+            activityId = botIdOrActivityId;
+            logger.debug('Using raw activity ID for credentials update', { activityId });
+        }
+    }
+    // Check if email is already used by another bot
+    if (credentials.email) {
+        const localCreds = loadLocalCredentials();
+        for (const [existingBotId, existingCreds] of Object.entries(localCreds)) {
+            if (existingBotId !== botId && existingCreds.email.toLowerCase() === credentials.email.toLowerCase()) {
+                const errorMsg = `Email is already used by another bot`;
+                logger.warn('Email already in use', { botId, email: (0, config_1.maskEmail)(credentials.email), usedBy: existingBotId });
+                throw new Error(errorMsg);
+            }
         }
-        logger.info('Bot config persisted to Agent Directory', {
-            enabledCount: enabledUpdates.length,
-            disabledCount: disabledUpdates.length
+    }
+    // Always save to local storage first (as backup and for hot-reload)
+    if (credentials.email && credentials.password && credentials.password !== '********') {
+        const localCreds = loadLocalCredentials();
+        localCreds[botId] = {
+            email: credentials.email,
+            password: credentials.password
+        };
+        saveLocalCredentials(localCreds);
+        logger.info('Bot credentials saved locally', { botId });
+    }
+    // Notify listeners (even if Hailer save fails, local save succeeded)
+    credentialChangeCallbacks.forEach(cb => cb(botId));
+    if (!hailerClient) {
+        logger.info('Hailer client not initialized - credentials saved locally only', { botId });
+        return; // Success - saved locally
+    }
+    // Build field updates - only include fields that were provided
+    const fields = {};
+    if (credentials.email !== undefined) {
+        fields[AGENT_DIRECTORY_FIELD_IDS.email] = credentials.email;
+    }
+    // Only update password if it's not the masked value
+    if (credentials.password !== undefined && credentials.password !== '********') {
+        fields[AGENT_DIRECTORY_FIELD_IDS.password] = credentials.password;
+    }
+    if (Object.keys(fields).length === 0) {
+        logger.debug('No credentials to update in Hailer', { botId });
+        return;
+    }
+    try {
+        logger.info('Updating bot credentials in Hailer...', {
+            botId,
+            activityId,
+            updatingEmail: !!fields[AGENT_DIRECTORY_FIELD_IDS.email],
+            updatingPassword: !!fields[AGENT_DIRECTORY_FIELD_IDS.password]
         });
+        // Update the activity fields
+        await hailerClient.updateActivities([{ _id: activityId, fields }], {});
+        logger.info('Bot credentials updated in Hailer', { botId });
     }
     catch (error) {
-        logger.warn('Failed to persist bot config to Hailer', {
+        logger.warn('Failed to update bot credentials in Hailer (already saved locally)', {
+            botId,
             error: error instanceof Error ? error.message : String(error)
         });
+        // Don't throw - credentials are already saved locally and listeners already notified
     }
 }
 /**
- * Check if persistence is initialized
+ * 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
  */
-function isPersistenceInitialized() {
-    return persistenceInitialized;
+function getLocalBotCredentials(userIdOrBotId) {
+    const localCreds = loadLocalCredentials();
+    // Direct lookup by user ID (new approach)
+    if (localCreds[userIdOrBotId]) {
+        return localCreds[userIdOrBotId];
+    }
+    // Legacy: Try getting userId from bot-state, then lookup by userId
+    const userId = getBotUserId(userIdOrBotId);
+    if (userId && localCreds[userId]) {
+        return localCreds[userId];
+    }
+    return null;
+}
+/**
+ * Get all local bot credentials (for daemon initialization)
+ * Returns all bots stored in .bot-credentials.json
+ */
+function getAllLocalBotCredentials() {
+    return loadLocalCredentials();
 }
 /**
  * Get persistence status info (for debugging)
@@ -344,10 +2207,10 @@ function isPersistenceInitialized() {
 function getPersistenceStatus() {
     return {
         initialized: persistenceInitialized,
-        workflowId: AGENT_DIRECTORY_WORKFLOW_ID,
-        deployedPhaseId: DEPLOYED_PHASE_ID,
-        retiredPhaseId: RETIRED_PHASE_ID,
-        agentActivityIds: { ...AGENT_ACTIVITY_IDS },
+        workflowId: get_agentDirectoryWorkflowId(),
+        deployedPhaseId: get_deployedPhaseId(),
+        retiredPhaseId: get_retiredPhaseId(),
+        agentActivityIds: { ...LEGACY_AGENT_ACTIVITY_IDS, ...discoveredActivityIds },
         hasClient: hailerClient !== null
     };
 }
@@ -362,7 +2225,7 @@ exports.listBotsConfigTool = {
     execute: async (_params, _context) => {
         const bots = exports.AVAILABLE_BOTS.map(bot => ({
             ...bot,
-            enabled: botState[bot.id] || false
+            enabled: botState[bot.id]?.enabled || false
         }));
         return {
             content: [{
@@ -434,9 +2297,160 @@ exports.disableBotTool = {
         };
     }
 };
+/**
+ * Check specialist status from Agent Directory
+ * Returns real-time status showing which specialists are deployed vs retired
+ */
+exports.checkSpecialistStatusTool = {
+    name: 'check_specialist_status',
+    group: tool_registry_1.ToolGroup.READ,
+    description: 'Check real-time status of AI specialists from Agent Directory. Returns which specialists are deployed (active) vs retired (disabled).',
+    schema: zod_1.z.object({
+        specialistName: zod_1.z.string().optional().describe("Optional: specific specialist name to check (e.g., 'Hailer Expert', 'Giuseppe'). If not provided, returns all specialists.")
+    }),
+    execute: async (params, _context) => {
+        const { specialistName } = params;
+        // Check if we have the required IDs
+        let workflowId = get_agentDirectoryWorkflowId();
+        let deployedPhase = get_deployedPhaseId();
+        let retiredPhase = get_retiredPhaseId();
+        if (!workflowId || !deployedPhase || !retiredPhase) {
+            // Try to discover schema if not already done
+            if (hailerClient && activeWorkspaceId) {
+                const discovered = await discoverAgentDirectorySchema(hailerClient, activeWorkspaceId);
+                workflowId = get_agentDirectoryWorkflowId();
+                deployedPhase = get_deployedPhaseId();
+                retiredPhase = get_retiredPhaseId();
+                if (!discovered || !workflowId || !deployedPhase || !retiredPhase) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: '**Agent Directory not configured**\n\nThe Agent Directory workflow was not found or not properly configured. Make sure the AI Hub template is installed in your workspace.'
+                            }],
+                        isError: true
+                    };
+                }
+            }
+            else {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '**Agent Directory not available**\n\nNo Hailer connection available to query Agent Directory.'
+                        }],
+                    isError: true
+                };
+            }
+        }
+        if (!hailerClient) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: '**Connection Error**\n\nHailer client not initialized.'
+                    }],
+                isError: true
+            };
+        }
+        try {
+            const deployedSpecialists = [];
+            const retiredSpecialists = [];
+            // Fetch deployed (active) specialists
+            const deployedActivities = await hailerClient.fetchActivityList(workflowId, deployedPhase, 100, { returnFlat: true });
+            const deployedList = Array.isArray(deployedActivities)
+                ? deployedActivities
+                : (deployedActivities?.data || deployedActivities?.activities || []);
+            for (const activity of deployedList) {
+                const botType = extractBotTypeFromActivity(activity);
+                const name = activity.name || 'Unknown';
+                // Filter by specialist name if provided
+                if (specialistName) {
+                    const normalizedSearch = specialistName.toLowerCase();
+                    const normalizedName = name.toLowerCase();
+                    const normalizedBotType = (botType || '').toLowerCase();
+                    if (!normalizedName.includes(normalizedSearch) && !normalizedBotType.includes(normalizedSearch)) {
+                        continue;
+                    }
+                }
+                deployedSpecialists.push({
+                    name,
+                    botType,
+                    activityId: activity._id
+                });
+            }
+            // Fetch retired (disabled) specialists
+            const retiredActivities = await hailerClient.fetchActivityList(workflowId, retiredPhase, 100, { returnFlat: true });
+            const retiredList = Array.isArray(retiredActivities)
+                ? retiredActivities
+                : (retiredActivities?.data || retiredActivities?.activities || []);
+            for (const activity of retiredList) {
+                const botType = extractBotTypeFromActivity(activity);
+                const name = activity.name || 'Unknown';
+                // Filter by specialist name if provided
+                if (specialistName) {
+                    const normalizedSearch = specialistName.toLowerCase();
+                    const normalizedName = name.toLowerCase();
+                    const normalizedBotType = (botType || '').toLowerCase();
+                    if (!normalizedName.includes(normalizedSearch) && !normalizedBotType.includes(normalizedSearch)) {
+                        continue;
+                    }
+                }
+                retiredSpecialists.push({
+                    name,
+                    botType,
+                    activityId: activity._id
+                });
+            }
+            // Format output
+            let output = '**Specialist Status** (live from Agent Directory)\n\n';
+            if (deployedSpecialists.length > 0) {
+                output += '✅ **Deployed (Active):**\n';
+                for (const specialist of deployedSpecialists) {
+                    const typeDisplay = specialist.botType ? ` (${specialist.botType})` : '';
+                    output += `- ${specialist.name}${typeDisplay}\n`;
+                }
+            }
+            else {
+                output += '✅ **Deployed (Active):** None\n';
+            }
+            output += '\n';
+            if (retiredSpecialists.length > 0) {
+                output += '❌ **Retired (Disabled):**\n';
+                for (const specialist of retiredSpecialists) {
+                    const typeDisplay = specialist.botType ? ` (${specialist.botType})` : '';
+                    output += `- ${specialist.name}${typeDisplay}\n`;
+                }
+            }
+            else {
+                output += '❌ **Retired (Disabled):** None\n';
+            }
+            // Add note if filtering
+            if (specialistName && deployedSpecialists.length === 0 && retiredSpecialists.length === 0) {
+                output = `**No specialists found matching "${specialistName}"**\n\nTry searching without a filter to see all specialists.`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: output
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Failed to check specialist status', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Error checking specialist status**\n\n${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    }
+};
 exports.botConfigTools = [
     exports.listBotsConfigTool,
     exports.enableBotTool,
-    exports.disableBotTool
+    exports.disableBotTool,
+    exports.checkSpecialistStatusTool
 ];
 //# sourceMappingURL=bot-config.js.map