@hailer/mcp 0.1.11 → 0.1.13

package/dist/client/bot-entrypoint.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Bot Entry Point - Single workspace, single bot
+ *
+ * Uses API key authentication via UserContextCache (which resolves to email/password internally)
+ */
+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 logger_1 = require("../lib/logger");
+const workspaceId = process.env.BOT_WORKSPACE_ID || 'unknown';
+const botId = process.env.BOT_ID || 'unknown';
+const logger = (0, logger_1.createLogger)({ component: `bot-${workspaceId}-${botId}` });
+async function main() {
+    const apiKey = process.env.BOT_API_KEY;
+    const workspaceName = process.env.BOT_WORKSPACE_NAME || workspaceId;
+    if (!apiKey) {
+        throw new Error('Missing BOT_API_KEY');
+    }
+    logger.info('Bot starting', { workspaceId, workspaceName, botId });
+    try {
+        // Dynamic import based on bot ID
+        if (botId === 'giuseppe') {
+            // Import UserContextCache and Bug Reports module
+            const { UserContextCache } = await Promise.resolve().then(() => __importStar(require('../mcp/UserContextCache')));
+            const { BugReportsModule } = await Promise.resolve().then(() => __importStar(require('../modules/bug-reports')));
+            // Get user context via API key (handles Hailer connection internally)
+            const userContext = await UserContextCache.getContext(apiKey);
+            logger.info('Connected to Hailer', { workspaceId });
+            // Start Giuseppe
+            const bugReports = new BugReportsModule(userContext);
+            await bugReports.start();
+            logger.info('Giuseppe bot started', { workspaceId });
+            // Notify parent
+            if (process.send) {
+                process.send({ type: 'ready' });
+            }
+            // Handle shutdown
+            process.on('message', async (msg) => {
+                if (msg.type === 'shutdown') {
+                    logger.info('Shutting down');
+                    await bugReports.stop();
+                    process.exit(0);
+                }
+            });
+        }
+        else if (botId === 'vastuullisuus') {
+            // TODO: Implement Vastuullisuus bot
+            logger.info('Vastuullisuus bot not yet implemented');
+            if (process.send) {
+                process.send({ type: 'ready' });
+            }
+            process.on('message', async (msg) => {
+                if (msg.type === 'shutdown') {
+                    process.exit(0);
+                }
+            });
+        }
+        else {
+            throw new Error(`Unknown bot: ${botId}`);
+        }
+    }
+    catch (error) {
+        logger.error('Bot failed', { error });
+        if (process.send) {
+            process.send({ type: 'error', error: error instanceof Error ? error.message : String(error) });
+        }
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=bot-entrypoint.js.map

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)