@hailer/mcp 0.1.11 → 0.1.12

package/dist/client/bot-runner.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Bot Runner - Manages isolated bot processes per workspace
+ *
+ * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
+ */
+import type { WorkspaceConfig } from './types';
+export declare class BotRunner {
+    private runningBots;
+    private botEntryPoint;
+    private maxRestarts;
+    private restartDelayMs;
+    constructor();
+    private getKey;
+    /**
+     * Start a bot for a workspace
+     */
+    startBot(workspace: WorkspaceConfig, botId: string): Promise<boolean>;
+    /**
+     * Stop a bot for a workspace
+     */
+    stopBot(workspaceId: string, botId: string): Promise<void>;
+    /**
+     * Check if a bot is running
+     */
+    isRunning(workspaceId: string, botId: string): boolean;
+    /**
+     * Get all running bots for a workspace
+     */
+    getRunningBots(workspaceId: string): string[];
+    /**
+     * Stop all bots
+     */
+    stopAll(): Promise<void>;
+}
+//# sourceMappingURL=bot-runner.d.ts.map

package/dist/client/bot-runner.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Bot Runner - Manages isolated bot processes per workspace
+ *
+ * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
+ */
+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.BotRunner = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'bot-runner' });
+class BotRunner {
+    runningBots = new Map();
+    botEntryPoint;
+    maxRestarts = 5;
+    restartDelayMs = 5000;
+    constructor() {
+        // In production, this would be the compiled JS
+        this.botEntryPoint = path.join(__dirname, 'bot-entrypoint.js');
+    }
+    getKey(workspaceId, botId) {
+        return `${workspaceId}:${botId}`;
+    }
+    /**
+     * Start a bot for a workspace
+     */
+    async startBot(workspace, botId) {
+        const key = this.getKey(workspace.id, botId);
+        if (this.runningBots.has(key)) {
+            logger.warn('Bot already running', { workspaceId: workspace.id, botId });
+            return true;
+        }
+        logger.info('Starting bot', { workspaceId: workspace.id, botId });
+        try {
+            const child = (0, child_process_1.fork)(this.botEntryPoint, [], {
+                env: {
+                    ...process.env,
+                    BOT_WORKSPACE_ID: workspace.id,
+                    BOT_WORKSPACE_NAME: workspace.name,
+                    BOT_API_KEY: workspace.apiKey, // Use API key instead of email/password
+                    BOT_ID: botId,
+                    // Isolate per workspace
+                    NODE_UNIQUE_ID: workspace.id
+                },
+                stdio: ['pipe', 'pipe', 'pipe', 'ipc']
+            });
+            const running = {
+                workspaceId: workspace.id,
+                botId,
+                process: child,
+                startedAt: new Date(),
+                restartCount: 0
+            };
+            this.runningBots.set(key, running);
+            // Log output
+            child.stdout?.on('data', (data) => {
+                logger.info(`[${workspace.id}:${botId}] ${data.toString().trim()}`);
+            });
+            child.stderr?.on('data', (data) => {
+                logger.error(`[${workspace.id}:${botId}] ${data.toString().trim()}`);
+            });
+            // Handle exit
+            child.on('exit', (code, signal) => {
+                logger.warn('Bot process exited', { workspaceId: workspace.id, botId, code, signal });
+                this.runningBots.delete(key);
+                // Auto-restart on crash
+                if (code !== 0 && running.restartCount < this.maxRestarts) {
+                    running.restartCount++;
+                    setTimeout(() => {
+                        this.startBot(workspace, botId);
+                    }, this.restartDelayMs);
+                }
+            });
+            // Wait for ready signal
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    logger.warn('Bot startup timeout', { workspaceId: workspace.id, botId });
+                    resolve(false);
+                }, 30000);
+                child.on('message', (msg) => {
+                    if (msg.type === 'ready') {
+                        clearTimeout(timeout);
+                        logger.info('Bot ready', { workspaceId: workspace.id, botId });
+                        resolve(true);
+                    }
+                    else if (msg.type === 'error') {
+                        clearTimeout(timeout);
+                        logger.error('Bot startup error', { workspaceId: workspace.id, botId, error: msg.error });
+                        resolve(false);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            logger.error('Failed to start bot', { workspaceId: workspace.id, botId, error });
+            return false;
+        }
+    }
+    /**
+     * Stop a bot for a workspace
+     */
+    async stopBot(workspaceId, botId) {
+        const key = this.getKey(workspaceId, botId);
+        const running = this.runningBots.get(key);
+        if (!running) {
+            logger.warn('Bot not running', { workspaceId, botId });
+            return;
+        }
+        logger.info('Stopping bot', { workspaceId, botId });
+        // Prevent auto-restart
+        running.restartCount = this.maxRestarts;
+        // Send graceful shutdown
+        running.process.send({ type: 'shutdown' });
+        // Wait for exit or force kill
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                running.process.kill('SIGKILL');
+                resolve();
+            }, 10000);
+            running.process.once('exit', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        this.runningBots.delete(key);
+    }
+    /**
+     * Check if a bot is running
+     */
+    isRunning(workspaceId, botId) {
+        return this.runningBots.has(this.getKey(workspaceId, botId));
+    }
+    /**
+     * Get all running bots for a workspace
+     */
+    getRunningBots(workspaceId) {
+        const running = [];
+        for (const [, bot] of this.runningBots) {
+            if (bot.workspaceId === workspaceId) {
+                running.push(bot.botId);
+            }
+        }
+        return running;
+    }
+    /**
+     * Stop all bots
+     */
+    async stopAll() {
+        const stops = Array.from(this.runningBots.values()).map(bot => this.stopBot(bot.workspaceId, bot.botId));
+        await Promise.all(stops);
+    }
+}
+exports.BotRunner = BotRunner;
+//# sourceMappingURL=bot-runner.js.map

package/dist/client/factory.d.ts

@@ -78,6 +78,10 @@ export declare class DaemonManager {
      * Check if running in orchestrator mode
      */
     isOrchestratorMode(): boolean;
+    /**
+     * Trigger HAL to respond in a discussion with context
+     */
+    triggerHalResponse(discussionId: string, activityId: string, context: string): Promise<void>;
     /**
      * Start periodic status logging
      */

package/dist/client/factory.js

@@ -228,6 +228,16 @@ class DaemonManager {
     isOrchestratorMode() {
         return !!this.options.orchestratorMode;
     }
+    /**
+     * Trigger HAL to respond in a discussion with context
+     */
+    async triggerHalResponse(discussionId, activityId, context) {
+        if (!this.orchestrator) {
+            logger.warn('Cannot trigger HAL response - orchestrator not running');
+            return;
+        }
+        await this.orchestrator.respondWithContext(discussionId, activityId, context);
+    }
     /**
      * Start periodic status logging
      */

package/dist/client/server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bot Control Server - API for AI Hub app
+ *
+ * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
+ */
+declare const app: import("express-serve-static-core").Express;
+export { app };
+//# sourceMappingURL=server.d.ts.map

package/dist/client/server.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Bot Control Server - API for AI Hub app
+ *
+ * Uses API key authentication (resolved to email/password internally via CLIENT_CONFIGS)
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../lib/logger");
+const bot_runner_1 = require("./bot-runner");
+const types_1 = require("./types");
+const logger = (0, logger_1.createLogger)({ component: 'bot-server' });
+const app = (0, express_1.default)();
+exports.app = app;
+const runner = new bot_runner_1.BotRunner();
+// State file
+const STATE_FILE = path.join(__dirname, 'workspaces.json');
+// Load/save state
+function loadState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to load state', { error });
+    }
+    return { workspaces: {} };
+}
+function saveState(state) {
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+let state = loadState();
+// Middleware
+app.use((0, cors_1.default)());
+app.use(express_1.default.json());
+// Request logging
+app.use((req, res, next) => {
+    logger.info(`${req.method} ${req.path}`, { body: req.body });
+    next();
+});
+/**
+ * GET /bots - List available bots
+ */
+app.get('/bots', (req, res) => {
+    res.json({ bots: types_1.AVAILABLE_BOTS });
+});
+/**
+ * POST /workspaces/register - Register a new workspace
+ */
+app.post('/workspaces/register', (req, res) => {
+    const { id, name, apiKey } = req.body;
+    if (!id || !apiKey) {
+        return res.status(400).json({ error: 'Missing required fields: id, apiKey' });
+    }
+    const workspace = {
+        id,
+        name: name || id,
+        apiKey, // Single API key - email/password resolved internally via CLIENT_CONFIGS
+        enabledBots: [],
+        registeredAt: new Date().toISOString()
+    };
+    state.workspaces[id] = workspace;
+    saveState(state);
+    logger.info('Workspace registered', { id, name });
+    res.json({ success: true, workspace: { id, name } });
+});
+/**
+ * DELETE /workspaces/:id - Unregister a workspace
+ */
+app.delete('/workspaces/:id', async (req, res) => {
+    const { id } = req.params;
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+        return res.status(404).json({ error: 'Workspace not found' });
+    }
+    // Stop all bots first
+    for (const botId of workspace.enabledBots) {
+        await runner.stopBot(id, botId);
+    }
+    delete state.workspaces[id];
+    saveState(state);
+    logger.info('Workspace unregistered', { id });
+    res.json({ success: true });
+});
+/**
+ * GET /workspaces/:id/status - Get workspace status
+ */
+app.get('/workspaces/:id/status', (req, res) => {
+    const { id } = req.params;
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+        return res.status(404).json({ error: 'Workspace not found' });
+    }
+    const status = {
+        id: workspace.id,
+        name: workspace.name,
+        registered: true,
+        bots: types_1.AVAILABLE_BOTS.map(bot => ({
+            id: bot.id,
+            name: bot.name,
+            enabled: workspace.enabledBots.includes(bot.id),
+            running: runner.isRunning(id, bot.id)
+        }))
+    };
+    res.json(status);
+});
+/**
+ * POST /workspaces/:id/bots/:botId/enable - Enable and start a bot
+ */
+app.post('/workspaces/:id/bots/:botId/enable', async (req, res) => {
+    const { id, botId } = req.params;
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+        return res.status(404).json({ error: 'Workspace not found' });
+    }
+    if (!types_1.AVAILABLE_BOTS.find(b => b.id === botId)) {
+        return res.status(404).json({ error: 'Bot not found' });
+    }
+    // Add to enabled list
+    if (!workspace.enabledBots.includes(botId)) {
+        workspace.enabledBots.push(botId);
+        saveState(state);
+    }
+    // Start the bot
+    const started = await runner.startBot(workspace, botId);
+    if (!started) {
+        return res.status(500).json({ error: 'Failed to start bot' });
+    }
+    logger.info('Bot enabled', { workspaceId: id, botId });
+    res.json({ success: true, running: true });
+});
+/**
+ * POST /workspaces/:id/bots/:botId/disable - Disable and stop a bot
+ */
+app.post('/workspaces/:id/bots/:botId/disable', async (req, res) => {
+    const { id, botId } = req.params;
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+        return res.status(404).json({ error: 'Workspace not found' });
+    }
+    // Remove from enabled list
+    workspace.enabledBots = workspace.enabledBots.filter(b => b !== botId);
+    saveState(state);
+    // Stop the bot
+    await runner.stopBot(id, botId);
+    logger.info('Bot disabled', { workspaceId: id, botId });
+    res.json({ success: true, running: false });
+});
+/**
+ * POST /workspaces/:id/start-all - Start all enabled bots
+ */
+app.post('/workspaces/:id/start-all', async (req, res) => {
+    const { id } = req.params;
+    const workspace = state.workspaces[id];
+    if (!workspace) {
+        return res.status(404).json({ error: 'Workspace not found' });
+    }
+    const results = {};
+    for (const botId of workspace.enabledBots) {
+        results[botId] = await runner.startBot(workspace, botId);
+    }
+    res.json({ success: true, results });
+});
+/**
+ * GET /status - Overall server status
+ */
+app.get('/status', (req, res) => {
+    const workspaceCount = Object.keys(state.workspaces).length;
+    const runningBots = [];
+    for (const workspace of Object.values(state.workspaces)) {
+        for (const botId of workspace.enabledBots) {
+            if (runner.isRunning(workspace.id, botId)) {
+                runningBots.push({ workspace: workspace.id, bot: botId });
+            }
+        }
+    }
+    res.json({
+        status: 'running',
+        workspaces: workspaceCount,
+        runningBots: runningBots.length,
+        bots: runningBots
+    });
+});
+// Start server
+const PORT = process.env.BOT_SERVER_PORT || 4000;
+// Graceful shutdown
+process.on('SIGINT', async () => {
+    logger.info('Shutting down...');
+    await runner.stopAll();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    logger.info('Shutting down...');
+    await runner.stopAll();
+    process.exit(0);
+});
+// Auto-start enabled bots on server start
+async function startEnabledBots() {
+    for (const workspace of Object.values(state.workspaces)) {
+        for (const botId of workspace.enabledBots) {
+            logger.info('Auto-starting bot', { workspaceId: workspace.id, botId });
+            await runner.startBot(workspace, botId);
+        }
+    }
+}
+app.listen(PORT, async () => {
+    logger.info(`Bot Control Server running on port ${PORT}`);
+    await startEnabledBots();
+});
+//# sourceMappingURL=server.js.map

package/dist/client/types.d.ts

@@ -295,4 +295,33 @@ export declare const MCP_CONFIG: {
     };
 };
 export declare const SESSION_IDLE_TIMEOUT = 60000;
+export interface BotDefinition {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+}
+export { AVAILABLE_BOTS } from '../mcp/tools/bot-config';
+export interface WorkspaceConfig {
+    id: string;
+    name: string;
+    apiKey: string;
+    enabledBots: string[];
+    registeredAt: string;
+    lastSeen?: string;
+}
+export interface WorkspacesState {
+    workspaces: Record<string, WorkspaceConfig>;
+}
+export interface WorkspaceStatus {
+    id: string;
+    name: string;
+    registered: boolean;
+    bots: Array<{
+        id: string;
+        name: string;
+        enabled: boolean;
+        running: boolean;
+    }>;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/client/types.js

@@ -4,7 +4,7 @@
  * All interfaces and types for the agent system
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_IDLE_TIMEOUT = exports.MCP_CONFIG = exports.TOOL_REGISTRY = exports.TEAMS = exports.POSITIONS = exports.SESSION_LOG = exports.AGENT_DIRECTORY = void 0;
+exports.AVAILABLE_BOTS = exports.SESSION_IDLE_TIMEOUT = exports.MCP_CONFIG = exports.TOOL_REGISTRY = exports.TEAMS = exports.POSITIONS = exports.SESSION_LOG = exports.AGENT_DIRECTORY = void 0;
 // ===== WORKFLOW CONSTANTS =====
 // DEPRECATED: These IDs are for ONE workspace only!
 // Use WorkspaceSchemaCacheService for dynamic per-workspace lookup.
@@ -115,4 +115,7 @@ exports.MCP_CONFIG = {
 };
 // ===== CONSTANTS =====
 exports.SESSION_IDLE_TIMEOUT = 60_000; // 60 seconds
+// Export AVAILABLE_BOTS from bot-config tools (single source of truth)
+var bot_config_1 = require("../mcp/tools/bot-config");
+Object.defineProperty(exports, "AVAILABLE_BOTS", { enumerable: true, get: function () { return bot_config_1.AVAILABLE_BOTS; } });
 //# sourceMappingURL=types.js.map

package/dist/core.d.ts

@@ -11,6 +11,7 @@ export declare class Core {
     private mcpServer?;
     private daemonManager;
     private statusLogInterval?;
+    private bugReportsModule?;
     constructor();
     /**
      * Public API for external tool registration
@@ -20,6 +21,8 @@ export declare class Core {
     start(): Promise<void>;
     private startMCPServer;
     private startMCPClient;
+    private startBugMonitor;
+    private initBotConfig;
     private initializeDaemonMode;
     /**
      * Get daemon status (for HTTP endpoint)

package/dist/core.js

@@ -11,6 +11,9 @@ const config_1 = require("./config");
 const factory_1 = require("./client/factory");
 const mcp_server_1 = require("./mcp-server");
 const tool_registry_1 = require("./mcp/tool-registry");
+const bug_reports_1 = require("./modules/bug-reports");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const bot_config_1 = require("./mcp/tools/bot-config");
 class Core {
     logger;
     appConfig;
@@ -18,6 +21,7 @@ class Core {
     mcpServer;
     daemonManager = null;
     statusLogInterval;
+    bugReportsModule;
     constructor() {
         // Initialize logger first
         this.logger = (0, logger_1.createLogger)({
@@ -58,10 +62,14 @@ class Core {
                     await this.startMCPServer();
                 }
             }
+            // Initialize bot config persistence (reads config from Hailer Agent Directory)
+            await this.initBotConfig();
             // Start client/daemon AFTER MCP server is ready
             if (this.appConfig.server.enableClient) {
                 await this.startMCPClient();
             }
+            // Start Bug Monitor service (reads config from Hailer)
+            await this.startBugMonitor();
             this.setupGracefulShutdown();
             this.logger.info('All configured services started successfully');
         }
@@ -94,6 +102,66 @@ class Core {
             });
         }
     }
+    async startBugMonitor() {
+        try {
+            // Get first configured account for Bug Reports Module
+            const accounts = Object.entries(this.appConfig.hailerAccounts);
+            if (accounts.length === 0) {
+                this.logger.info('No Hailer accounts configured - Bug Reports Module disabled');
+                return;
+            }
+            const [apiKey] = accounts[0];
+            const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+            this.bugReportsModule = new bug_reports_1.BugReportsModule(userContext);
+            // Register bot user IDs to ignore (so bug monitor only processes human messages)
+            if (this.daemonManager) {
+                const daemonStatus = this.daemonManager.getStatus();
+                for (const daemon of daemonStatus) {
+                    this.bugReportsModule.registerBotUser(daemon.botId);
+                    this.logger.debug('Registered bot user for bug monitor to ignore', { botId: daemon.botId });
+                }
+            }
+            // Register giuseppe disabled handler to trigger HAL response (BEFORE start!)
+            this.bugReportsModule.onGiuseppeDisabled(async (bug) => {
+                if (this.daemonManager && bug.discussionId) {
+                    const context = `[System notification: A new bug report "${bug.name}" was detected, but Giuseppe (the auto-fix bot) is currently disabled. The user may ask how to enable Giuseppe or want to know more about this bug. Be helpful and explain they can enable Giuseppe in the AI Hub app.]`;
+                    await this.daemonManager.triggerHalResponse(bug.discussionId, bug.id, context);
+                }
+            });
+            await this.bugReportsModule.start();
+            if (this.bugReportsModule.isRunning()) {
+                const config = this.bugReportsModule.getConfig();
+                this.logger.info('Bug Reports Module started', {
+                    autoFix: config.autoFix,
+                    interval: `${config.intervalMs / 1000}s`
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn('Bug Reports Module failed to start - server will continue without bug monitoring', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    async initBotConfig() {
+        try {
+            // Get first configured account for bot config persistence
+            const accounts = Object.entries(this.appConfig.hailerAccounts);
+            if (accounts.length === 0) {
+                this.logger.info('No Hailer accounts configured - Bot config persistence disabled');
+                return;
+            }
+            const [apiKey] = accounts[0];
+            const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+            await (0, bot_config_1.initBotConfigPersistence)(userContext.hailer);
+            this.logger.info('Bot config persistence initialized');
+        }
+        catch (error) {
+            this.logger.warn('Bot config persistence failed to initialize - using in-memory defaults', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
     async initializeDaemonMode() {
         this.logger.info('Initializing Chat Agent Daemon');
         // Check for orchestrator mode via environment variable
@@ -126,6 +194,10 @@ class Core {
             if (this.statusLogInterval) {
                 clearInterval(this.statusLogInterval);
             }
+            // Stop Bug Reports Module
+            if (this.bugReportsModule) {
+                await this.bugReportsModule.stop();
+            }
             if (this.daemonManager) {
                 this.daemonManager.stopAll();
                 this.logger.info('Chat Agent Daemon stopped');