@hailer/mcp 0.1.14 → 0.1.16

package/dist/app.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("./core");
 const config_1 = require("./config");
+const logger_1 = require("./lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'app' });
 const file_1 = require("./mcp/tools/file");
 const activity_1 = require("./mcp/tools/activity");
 const discussion_1 = require("./mcp/tools/discussion");
@@ -10,9 +12,10 @@ const workflow_1 = require("./mcp/tools/workflow");
 const insight_1 = require("./mcp/tools/insight");
 const app_1 = require("./mcp/tools/app");
 const bot_config_1 = require("./mcp/tools/bot-config");
+const giuseppe_tools_1 = require("./mcp/tools/giuseppe-tools");
 const core = new core_1.Core();
-console.log('Registering tools...');
-console.log(`Nuclear tools ${config_1.environment.ENABLE_NUCLEAR_TOOLS ? 'ENABLED' : 'DISABLED'} (set ENABLE_NUCLEAR_TOOLS=true in .env.local to enable)`);
+logger.info('Registering tools...');
+logger.info('Nuclear tools status', { enabled: config_1.environment.ENABLE_NUCLEAR_TOOLS });
 core.addTool(file_1.uploadFilesTool);
 core.addTool(activity_1.listActivitiesTool);
 core.addTool(activity_1.showActivityByIdTool);
@@ -77,10 +80,24 @@ core.addTool(app_1.installMarketplaceAppTool);
 core.addTool(bot_config_1.listBotsConfigTool);
 core.addTool(bot_config_1.enableBotTool);
 core.addTool(bot_config_1.disableBotTool);
-console.log('All tools registered successfully!');
+core.addTool(bot_config_1.checkSpecialistStatusTool);
+// Giuseppe bug-fixing tools
+core.addTool(giuseppe_tools_1.giuseppeFindAppTool);
+core.addTool(giuseppe_tools_1.giuseppeListFilesTool);
+core.addTool(giuseppe_tools_1.giuseppeReadFileTool);
+core.addTool(giuseppe_tools_1.giuseppeWriteFileTool);
+core.addTool(giuseppe_tools_1.giuseppeApplyFixTool);
+core.addTool(giuseppe_tools_1.giuseppeRunBuildTool);
+core.addTool(giuseppe_tools_1.giuseppeGitStatusTool);
+core.addTool(giuseppe_tools_1.giuseppeGitPullTool);
+core.addTool(giuseppe_tools_1.giuseppeGitCommitTool);
+core.addTool(giuseppe_tools_1.giuseppeGitPushTool);
+core.addTool(giuseppe_tools_1.giuseppeGitRevertTool);
+core.addTool(giuseppe_tools_1.giuseppePublishAppTool);
+logger.info('All tools registered successfully');
 // Start the application
 core.start().catch((error) => {
-    console.error('Failed to start Hailer MCP application:', error);
+    logger.error('Failed to start Hailer MCP application', error);
     process.exit(1);
 });
 // Export core for testing and external access

package/dist/client/agents/orchestrator.d.ts

@@ -80,6 +80,7 @@ export declare class OrchestratorDaemon extends ChatAgentDaemon {
     private updateContextMemory;
     /**
      * Override to update cross-discussion memory when entering activity discussions
+     * Also checks if a specialist bot (like Giuseppe) has locked this discussion
      */
     protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
     /**

package/dist/client/agents/orchestrator.js

@@ -19,6 +19,7 @@ const definitions_1 = require("./definitions");
 const logger_1 = require("../../lib/logger");
 const pending_fix_registry_1 = require("../../modules/bug-reports/pending-fix-registry");
 const pending_classification_registry_1 = require("../../modules/bug-reports/pending-classification-registry");
+const discussion_lock_1 = require("../../lib/discussion-lock");
 class OrchestratorDaemon extends base_1.ChatAgentDaemon {
     orchestratorLogger;
     specialists = new Map();
@@ -369,11 +370,21 @@ class OrchestratorDaemon extends base_1.ChatAgentDaemon {
     }
     /**
      * Override to update cross-discussion memory when entering activity discussions
+     * Also checks if a specialist bot (like Giuseppe) has locked this discussion
      */
     async extractIncomingMessage(signal) {
         const message = await super.extractIncomingMessage(signal);
+        if (!message)
+            return null;
+        // Check if this discussion is locked by a specialist bot (e.g., Giuseppe handling a bug)
+        if ((0, discussion_lock_1.isDiscussionLocked)(message.discussionId, 'hal')) {
+            this.orchestratorLogger.debug('Discussion locked by specialist, skipping', {
+                discussionId: message.discussionId
+            });
+            return null;
+        }
         // Update context memory if this message is from an activity discussion
-        if (message?.linkedActivityId) {
+        if (message.linkedActivityId) {
             this.updateContextMemory(message.linkedActivityId, message.linkedActivityName || null);
         }
         return message;

package/dist/commands/seed-config.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env tsx
+/**
+ * Seed Bot Configuration
+ *
+ * Connects as master user, discovers Agent Directory workflows across all workspaces,
+ * and writes bot configuration to .bot-config/{workspaceId}.json
+ */
+export {};
+//# sourceMappingURL=seed-config.d.ts.map

package/dist/commands/seed-config.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Seed Bot Configuration
+ *
+ * Connects as master user, discovers Agent Directory workflows across all workspaces,
+ * and writes bot configuration to .bot-config/{workspaceId}.json
+ */
+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 });
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const hailer_clients_1 = require("../mcp/hailer-clients");
+const hailer_api_client_1 = require("../mcp/utils/hailer-api-client");
+// Load environment variables
+dotenv.config();
+// Constants
+const BOT_CONFIG_DIR = '.bot-config';
+const AGENT_DIRECTORY_PATTERNS = ['Agent Directory', 'AI Agents', '🤖 Agent Directory'];
+const DEPLOYED_PHASE_PATTERNS = ['deployed', 'active', 'enabled'];
+const RETIRED_PHASE_PATTERNS = ['retired', 'disabled', 'inactive'];
+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'];
+// Helper functions
+function findFieldId(fields, patterns) {
+    for (const pattern of patterns) {
+        if (fields[pattern])
+            return fields[pattern];
+    }
+    return null;
+}
+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;
+}
+function looksLikeUserId(value) {
+    return /^[a-f0-9]{24}$/i.test(value);
+}
+function extractCredentialsFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    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 && schema.emailFieldId) {
+        const emailField = fields[schema.emailFieldId];
+        if (emailField) {
+            email = emailField.value || emailField;
+        }
+    }
+    if (!password && schema.passwordFieldId) {
+        const passwordField = fields[schema.passwordFieldId];
+        if (passwordField) {
+            password = passwordField.value || passwordField;
+        }
+    }
+    // Fallback: find email by pattern
+    if (!email) {
+        for (const [, fieldValue] of Object.entries(fields)) {
+            const strValue = typeof fieldValue === 'string' ? fieldValue : fieldValue?.value;
+            if (typeof strValue === 'string' && strValue.includes('@') && strValue.includes('.')) {
+                email = strValue.replace(/['"]/g, '').trim();
+                break;
+            }
+        }
+    }
+    if (email && password) {
+        return { email, password };
+    }
+    return null;
+}
+function extractUserIdFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    // Try fields object format - by field KEY first
+    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 (schema.hailerProfileFieldId) {
+        const profileField = fields[schema.hailerProfileFieldId];
+        if (profileField) {
+            const value = profileField.value || profileField;
+            return typeof value === 'string' ? value : (Array.isArray(value) ? value[0] : null);
+        }
+    }
+    // Fallback: iterate ALL fields and look for users field type
+    for (const [, fieldValue] of Object.entries(fields)) {
+        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)) {
+                    return userId;
+                }
+            }
+        }
+        if (Array.isArray(fieldValue) && fieldValue.length > 0) {
+            const firstVal = fieldValue[0];
+            if (typeof firstVal === 'string' && looksLikeUserId(firstVal)) {
+                return firstVal;
+            }
+        }
+    }
+    return null;
+}
+function extractBotTypeFromActivity(activity, schema) {
+    const fields = activity.fields || {};
+    // Try fields object format - by field KEY first
+    if (fields.botType) {
+        return typeof fields.botType === 'string' ? fields.botType : (fields.botType?.value || null);
+    }
+    // Try fields object format - by field ID
+    if (schema.botTypeFieldId) {
+        const botTypeField = fields[schema.botTypeFieldId];
+        if (botTypeField) {
+            return botTypeField.value || botTypeField;
+        }
+    }
+    return null;
+}
+async function discoverAgentDirectory(apiClient, workspaceId) {
+    // Get list of workflows
+    const workflows = await apiClient.listWorkflows(workspaceId);
+    // Find Agent Directory workflow
+    const agentDir = workflows.find((w) => AGENT_DIRECTORY_PATTERNS.some(p => w.name?.includes(p)));
+    if (!agentDir) {
+        return null;
+    }
+    const workflowId = agentDir._id;
+    // Extract phases
+    const phases = [];
+    if (agentDir.phases) {
+        for (const [phaseId, phase] of Object.entries(agentDir.phases)) {
+            phases.push({ id: phaseId, name: phase.name || phaseId });
+        }
+    }
+    const deployedPhaseId = findPhaseByPattern(phases, DEPLOYED_PHASE_PATTERNS);
+    const retiredPhaseId = findPhaseByPattern(phases, RETIRED_PHASE_PATTERNS);
+    // Extract field IDs by key
+    const fieldMap = {};
+    if (agentDir.fields) {
+        for (const [fieldId, field] of Object.entries(agentDir.fields)) {
+            const key = field.key;
+            if (key)
+                fieldMap[key] = fieldId;
+        }
+    }
+    return {
+        workflowId,
+        deployedPhaseId,
+        retiredPhaseId,
+        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),
+    };
+}
+async function fetchBotActivities(apiClient, workflowId, phaseId) {
+    const result = await apiClient.fetchActivityList(workflowId, phaseId, 100, { returnFlat: true });
+    return result.data || result.activities || result.list || [];
+}
+async function processWorkspace(apiClient, workspaceId, workspaceName) {
+    console.log(`\n  Discovering Agent Directory...`);
+    const schema = await discoverAgentDirectory(apiClient, workspaceId);
+    if (!schema) {
+        console.log(`  No Agent Directory found`);
+        return null;
+    }
+    console.log(`  Found workflow: ${schema.workflowId}`);
+    if (!schema.deployedPhaseId) {
+        console.log(`  No deployed phase found`);
+        return null;
+    }
+    // Fetch deployed activities
+    console.log(`  Fetching deployed bots...`);
+    const deployedActivities = await fetchBotActivities(apiClient, schema.workflowId, schema.deployedPhaseId);
+    // Fetch retired activities if available
+    let retiredActivities = [];
+    if (schema.retiredPhaseId) {
+        retiredActivities = await fetchBotActivities(apiClient, schema.workflowId, schema.retiredPhaseId);
+    }
+    console.log(`  Found ${deployedActivities.length} deployed, ${retiredActivities.length} retired bots`);
+    const config = {
+        workspaceId,
+        workspaceName,
+        specialists: [],
+        lastSynced: new Date().toISOString(),
+    };
+    // Process deployed activities
+    for (const activity of deployedActivities) {
+        const creds = extractCredentialsFromActivity(activity, schema);
+        const userId = extractUserIdFromActivity(activity, schema);
+        const botType = extractBotTypeFromActivity(activity, schema);
+        if (!creds || !userId) {
+            console.log(`    Skipping ${activity.name} - missing credentials or userId`);
+            continue;
+        }
+        if (botType === 'orchestrator') {
+            config.orchestrator = {
+                activityId: activity._id,
+                userId,
+                email: creds.email,
+                password: creds.password,
+            };
+            console.log(`    Orchestrator: ${activity.name}`);
+        }
+        else {
+            config.specialists.push({
+                activityId: activity._id,
+                userId,
+                email: creds.email,
+                password: creds.password,
+                botType: botType || 'unknown',
+                enabled: true,
+            });
+            console.log(`    Specialist: ${activity.name} (${botType || 'unknown'})`);
+        }
+    }
+    // Process retired activities (disabled specialists)
+    for (const activity of retiredActivities) {
+        const creds = extractCredentialsFromActivity(activity, schema);
+        const userId = extractUserIdFromActivity(activity, schema);
+        const botType = extractBotTypeFromActivity(activity, schema);
+        if (!creds || !userId)
+            continue;
+        if (botType === 'orchestrator')
+            continue; // Skip retired orchestrators
+        config.specialists.push({
+            activityId: activity._id,
+            userId,
+            email: creds.email,
+            password: creds.password,
+            botType: botType || 'unknown',
+            enabled: false,
+        });
+        console.log(`    Retired: ${activity.name} (${botType || 'unknown'})`);
+    }
+    // Skip workspaces without orchestrator
+    if (!config.orchestrator) {
+        console.log(`  No orchestrator found - skipping workspace`);
+        return null;
+    }
+    return config;
+}
+async function main() {
+    console.log('\n Bot Config Seeder');
+    console.log('==================\n');
+    // Check environment variables
+    const email = process.env.HAILER_EMAIL;
+    const password = process.env.HAILER_PASSWORD;
+    const host = process.env.HAILER_API_URL || 'https://app.hailer.com';
+    if (!email || !password) {
+        console.error(' Error: HAILER_EMAIL and HAILER_PASSWORD environment variables are required');
+        console.error('\nSet them in your .env file or export them:');
+        console.error('  export HAILER_EMAIL=your@email.com');
+        console.error('  export HAILER_PASSWORD=yourpassword');
+        process.exit(1);
+    }
+    console.log(` Connecting to ${host} as ${email}...`);
+    // Connect to Hailer
+    const clientManager = new hailer_clients_1.HailerClientManager(host, email, password);
+    let hailerClient;
+    try {
+        hailerClient = await clientManager.connect();
+        console.log(' Connected successfully\n');
+    }
+    catch (error) {
+        console.error(' Failed to connect:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    const apiClient = new hailer_api_client_1.HailerApiClient(hailerClient);
+    // Get all workspaces
+    console.log(' Fetching workspaces...');
+    const init = await apiClient.request('v2.core.init', [['networks']]);
+    const workspaces = init.networks || {};
+    const workspaceIds = Object.keys(workspaces);
+    console.log(` Found ${workspaceIds.length} workspace(s)\n`);
+    // Create config directory
+    const configDir = path.join(process.cwd(), BOT_CONFIG_DIR);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+        console.log(` Created ${BOT_CONFIG_DIR}/ directory\n`);
+    }
+    let successCount = 0;
+    let skipCount = 0;
+    // Process each workspace
+    for (const wsId of workspaceIds) {
+        const ws = workspaces[wsId];
+        const wsName = ws.name || wsId;
+        console.log(` [${wsName}]`);
+        try {
+            // Switch to workspace
+            await apiClient.request('v2.network.switch', [wsId]);
+            const config = await processWorkspace(apiClient, wsId, wsName);
+            if (config) {
+                // Write config file
+                const configPath = path.join(configDir, `${wsId}.json`);
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+                console.log(`  Saved to ${BOT_CONFIG_DIR}/${wsId}.json`);
+                successCount++;
+            }
+            else {
+                skipCount++;
+            }
+        }
+        catch (error) {
+            console.error(`  Error: ${error instanceof Error ? error.message : error}`);
+            skipCount++;
+        }
+    }
+    // Disconnect
+    clientManager.disconnect();
+    // Summary
+    console.log('\n==================');
+    console.log(` Done!`);
+    console.log(`   ${successCount} workspace(s) configured`);
+    console.log(`   ${skipCount} workspace(s) skipped`);
+    console.log(`\nConfig files saved to: ${configDir}/\n`);
+}
+// Run
+main().catch(error => {
+    console.error('\n Unexpected error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=seed-config.js.map

package/dist/config.d.ts

@@ -54,6 +54,16 @@ export declare const environment: {
     OPENAI_MODEL?: string | undefined;
     ANTHROPIC_API_KEY?: string | undefined;
 };
+/**
+ * Mask sensitive data for safe logging
+ * Shows first 4 and last 4 characters, hiding the rest
+ */
+export declare function maskSensitiveData(value: string | undefined): string;
+/**
+ * Mask email for safe logging
+ * Shows first 2 chars of local part + domain: user@domain.com -> us***@domain.com
+ */
+export declare function maskEmail(email: string | undefined): string;
 export interface HailerAccount {
     email: string;
     password: string;

package/dist/config.js

@@ -16,6 +16,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApplicationConfig = exports.environment = void 0;
+exports.maskSensitiveData = maskSensitiveData;
+exports.maskEmail = maskEmail;
 exports.createApplicationConfig = createApplicationConfig;
 const zod_1 = require("zod");
 const dotenv_1 = require("dotenv");
@@ -35,8 +37,11 @@ const hailerAccountSchema = zod_1.z.object({
 /**
  * Transform CLIENT_CONFIGS to efficient Map format
  * Supports both legacy array and new object formats
+ * Optional with default empty object for hot-reload support
  */
 const clientConfigsSchema = zod_1.z.string()
+    .optional()
+    .default('{}')
     .transform((value, ctx) => {
     try {
         const parsed = JSON.parse(value);
@@ -129,7 +134,7 @@ const environmentSchema = zod_1.z.object({
     CONTEXT_MAX_SUMMARIZATION_CHUNKS: zod_1.z.string().transform(v => parseInt(v) || 10).default('10'),
 });
 /**
- * Get process environment (no defaults - CLIENT_CONFIGS is required)
+ * Get process environment
  */
 function getProcessEnv() {
     return { ...process.env };
@@ -139,6 +144,61 @@ function getProcessEnv() {
  */
 exports.environment = environmentSchema.parse(getProcessEnv());
 // ================================================================================
+// SECURITY UTILITIES
+// ================================================================================
+/**
+ * Mask sensitive data for safe logging
+ * Shows first 4 and last 4 characters, hiding the rest
+ */
+function maskSensitiveData(value) {
+    if (!value || value.length < 8)
+        return '***';
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+/**
+ * Mask email for safe logging
+ * Shows first 2 chars of local part + domain: user@domain.com -> us***@domain.com
+ */
+function maskEmail(email) {
+    if (!email)
+        return '***';
+    const [local, domain] = email.split('@');
+    if (!domain)
+        return maskSensitiveData(email);
+    const maskedLocal = local.length > 2 ? `${local.slice(0, 2)}***` : '***';
+    return `${maskedLocal}@${domain}`;
+}
+/**
+ * Validate CORS origins for security issues
+ * Returns warnings for potentially insecure configurations
+ */
+function validateCorsOrigins(origins) {
+    const warnings = [];
+    for (const origin of origins) {
+        // Check for wildcard in subdomain (e.g., *.example.com patterns in URLs)
+        if (origin.includes('*')) {
+            warnings.push(`CORS origin contains wildcard: ${origin} - consider using explicit origins`);
+        }
+        // Check for localhost/127.0.0.1 in production
+        if (process.env.NODE_ENV === 'production') {
+            if (origin.includes('localhost') || origin.includes('127.0.0.1')) {
+                warnings.push(`CORS origin allows localhost in production: ${origin}`);
+            }
+        }
+        // Check for HTTP (non-HTTPS) origins in production
+        if (process.env.NODE_ENV === 'production' && origin.startsWith('http://')) {
+            warnings.push(`CORS origin uses HTTP instead of HTTPS in production: ${origin}`);
+        }
+    }
+    return warnings;
+}
+// Validate CORS origins and log warnings
+const corsWarnings = validateCorsOrigins(exports.environment.CORS_ORIGINS);
+if (corsWarnings.length > 0) {
+    console.warn('[Security] CORS configuration warnings:');
+    corsWarnings.forEach(warning => console.warn(`  - ${warning}`));
+}
+// ================================================================================
 // UNIVERSAL APPLICATION CONFIG
 // ================================================================================
 /**

package/dist/core.d.ts

@@ -12,6 +12,8 @@ export declare class Core {
     private daemonManager;
     private statusLogInterval?;
     private bugReportsModule?;
+    private daemonInitInProgress;
+    private initialDaemonReady;
     constructor();
     /**
      * Public API for external tool registration
@@ -23,6 +25,12 @@ export declare class Core {
     private startMCPClient;
     private startBugMonitor;
     private initBotConfig;
+    /**
+     * Attempt to restart daemon mode when bot state changes
+     * Stops existing daemons and starts fresh with updated configuration
+     * Includes retry logic for transient connection failures
+     */
+    private attemptDaemonRestart;
     private initializeDaemonMode;
     /**
      * Get daemon status (for HTTP endpoint)