@hailer/mcp 0.2.7 → 1.0.21

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

@@ -1,2456 +0,0 @@
-"use strict";
-/**
- * Bot Configuration MCP Tools
- *
- * Manages which bots are enabled/disabled in the workspace.
- * Config is stored in the Agent Directory workflow - agents are activities.
- * - Deployed agents phase = enabled
- * - Retired agents phase = disabled
- *
- * 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 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.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' });
-// ============================================================================
-// Local State Persistence (fallback)
-// ============================================================================
-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',
-    bugFixer: '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
-/**
- * Available bots - single source of truth
- *
- * All bots that can be enabled/disabled in the workspace.
- * This list should match the AI Hub app and agent definitions.
- */
-exports.AVAILABLE_BOTS = [
-    {
-        id: 'hal',
-        name: 'HAL',
-        description: 'Main orchestrator - handles general chat and coordinates specialists',
-        icon: '🤖'
-    },
-    {
-        id: 'bugFixer',
-        name: 'Bug Fixer',
-        description: 'Bug fixing specialist - analyzes and repairs Hailer app issues',
-        icon: '🔧'
-    },
-    {
-        id: 'hailerExpert',
-        name: 'Hailer Expert',
-        description: 'Workflow & data specialist - bulk operations, insights, reports',
-        icon: '📊'
-    },
-    {
-        id: 'vastuullisuus',
-        name: 'Vastuullisuus',
-        description: 'Sustainability analysis for SMEs',
-        icon: '🌱'
-    }
-];
-// 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;
-}
-/**
- * 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;
-}
-/**
- * Extract schema config from activity (written by AI Hub for MCP sync)
- * Returns the workflow/phase IDs if found, null otherwise
- */
-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;
-    }
-}
-/**
- * Apply schema config from activity to a workspace
- */
-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;
-    }
-    try {
-        // 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;
-        }
-        // 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 discover field IDs', {
-            workspaceId,
-            workflowId,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-}
-/**
- * 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:
- * - deployedPhaseId = enabled
- * - retiredPhaseId = disabled
- *
- * @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 = {};
-        // 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: 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?.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 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: 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?.data || retiredActivities?.activities || []);
-        for (const activity of retiredList) {
-            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,
-            userIdCount: Object.keys(config).length,
-            orchestratorUserId
-        });
-        return config;
-    }
-    catch (error) {
-        logger.warn('Failed to load bot config from Agent Directory', {
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return null;
-    }
-}
-/**
- * Persist a single bot's state to Hailer
- *
- * Moves the bot's agent activity between phases:
- * - enabled = move to deployedPhaseId
- * - disabled = move to retiredPhaseId
- *
- * @param botId - The bot ID to persist
- * @param enabled - Whether the bot is enabled
- */
-async function persistBotToHailer(botId, enabled) {
-    if (!hailerClient || !persistenceInitialized) {
-        logger.debug('Persistence not initialized, skipping save');
-        return;
-    }
-    const activityId = getActivityIdForBot(botId);
-    if (!activityId) {
-        logger.warn('No activity ID found for bot (not discovered yet)', { botId });
-        return;
-    }
-    const targetPhaseId = enabled ? get_deployedPhaseId() : get_retiredPhaseId();
-    try {
-        logger.debug('Moving agent to phase...', {
-            botId,
-            activityId,
-            enabled,
-            targetPhaseId
-        });
-        // Use updateActivities to move the agent activity to the appropriate phase
-        await hailerClient.updateActivities([{ _id: activityId }], { phaseId: targetPhaseId });
-        logger.info('Agent moved to phase', {
-            botId,
-            activityId,
-            phase: enabled ? 'deployed' : 'retired',
-            phaseId: targetPhaseId
-        });
-    }
-    catch (error) {
-        logger.warn('Failed to persist bot state to Hailer', {
-            botId,
-            activityId,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-}
-/**
- * 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
- *
- * 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, bugFixer, etc.) or activity ID
- * @param showPassword - If true, returns unmasked password. Default false for security.
- * @returns Credentials or null if not found
- */
-async function getBotCredentials(botIdOrActivityId, showPassword = false) {
-    // Support both bot IDs (hal, bugFixer) 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('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;
-        }
-        // 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 : '********'
-            };
-        }
-        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, bugFixer, 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);
-            }
-        }
-    }
-    // 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 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
-    }
-}
-/**
- * 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, bugFixer, etc.)
- * @returns Unmasked credentials or null if not found
- */
-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)
- */
-function getPersistenceStatus() {
-    return {
-        initialized: persistenceInitialized,
-        workflowId: get_agentDirectoryWorkflowId(),
-        deployedPhaseId: get_deployedPhaseId(),
-        retiredPhaseId: get_retiredPhaseId(),
-        agentActivityIds: { ...LEGACY_AGENT_ACTIVITY_IDS, ...discoveredActivityIds },
-        hasClient: hailerClient !== null
-    };
-}
-/**
- * List available bots and their status
- */
-exports.listBotsConfigTool = {
-    name: 'list_bots_config',
-    group: tool_registry_1.ToolGroup.READ,
-    description: 'List available AI bots and their enabled/disabled status',
-    schema: zod_1.z.object({}),
-    execute: async (_params, _context) => {
-        const bots = exports.AVAILABLE_BOTS.map(bot => ({
-            ...bot,
-            enabled: botState[bot.id]?.enabled || false
-        }));
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({ bots }, null, 2)
-                }]
-        };
-    }
-};
-/**
- * Enable a bot
- */
-exports.enableBotTool = {
-    name: 'enable_bot',
-    group: tool_registry_1.ToolGroup.WRITE,
-    description: 'Enable an AI bot in this workspace',
-    schema: zod_1.z.object({
-        botId: zod_1.z.string().describe('Bot ID to enable (hal, bugFixer, hailerExpert, vastuullisuus)')
-    }),
-    execute: async (params, _context) => {
-        const { botId } = params;
-        if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Unknown bot: ${botId}. Available: ${exports.AVAILABLE_BOTS.map(b => b.id).join(', ')}`
-                    }],
-                isError: true
-            };
-        }
-        // Use setBotEnabled to trigger persistence
-        setBotEnabled(botId, true);
-        return {
-            content: [{
-                    type: 'text',
-                    text: `${botId} bot enabled`
-                }]
-        };
-    }
-};
-/**
- * Disable a bot
- */
-exports.disableBotTool = {
-    name: 'disable_bot',
-    group: tool_registry_1.ToolGroup.WRITE,
-    description: 'Disable an AI bot in this workspace',
-    schema: zod_1.z.object({
-        botId: zod_1.z.string().describe('Bot ID to disable (hal, bugFixer, hailerExpert, vastuullisuus)')
-    }),
-    execute: async (params, _context) => {
-        const { botId } = params;
-        if (!exports.AVAILABLE_BOTS.find(b => b.id === botId)) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Unknown bot: ${botId}. Available: ${exports.AVAILABLE_BOTS.map(b => b.id).join(', ')}`
-                    }],
-                isError: true
-            };
-        }
-        // Use setBotEnabled to trigger persistence
-        setBotEnabled(botId, false);
-        return {
-            content: [{
-                    type: 'text',
-                    text: `${botId} bot disabled`
-                }]
-        };
-    }
-};
-/**
- * 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', 'Bug Fixer'). 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.checkSpecialistStatusTool
-];
-//# sourceMappingURL=core.js.map