@hailer/mcp 0.1.15 → 0.1.16

package/dist/core.js

@@ -8,12 +8,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
 const logger_1 = require("./lib/logger");
 const config_1 = require("./config");
-const factory_1 = require("./client/factory");
+const factory_1 = require("./agents/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 giuseppe_1 = require("./agents/giuseppe");
 const UserContextCache_1 = require("./mcp/UserContextCache");
 const bot_config_1 = require("./mcp/tools/bot-config");
+const webhook_handler_1 = require("./mcp/webhook-handler");
 class Core {
     logger;
     appConfig;
@@ -22,6 +23,8 @@ class Core {
     daemonManager = null;
     statusLogInterval;
     bugReportsModule;
+    daemonInitInProgress = false;
+    initialDaemonReady = false; // Prevents restart attempts before first daemon init
     constructor() {
         // Initialize logger first
         this.logger = (0, logger_1.createLogger)({
@@ -91,9 +94,15 @@ class Core {
         this.logger.info('MCP Server service started');
     }
     async startMCPClient() {
+        if (this.daemonInitInProgress) {
+            this.logger.debug('Daemon init already in progress, skipping startMCPClient');
+            return;
+        }
         this.logger.info('Starting Chat Agent Daemon (persistent conversation mode)');
+        this.daemonInitInProgress = true;
         try {
             await this.initializeDaemonMode();
+            this.initialDaemonReady = true; // Mark daemon as ready for restart signals
             this.logger.info('Chat Agent Daemon started');
         }
         catch (error) {
@@ -101,6 +110,9 @@ class Core {
                 error: error instanceof Error ? error.message : String(error)
             });
         }
+        finally {
+            this.daemonInitInProgress = false;
+        }
     }
     async startBugMonitor() {
         try {
@@ -112,7 +124,7 @@ class Core {
             }
             const [apiKey] = accounts[0];
             const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
-            this.bugReportsModule = new bug_reports_1.BugReportsModule(userContext);
+            this.bugReportsModule = new giuseppe_1.BugReportsModule(userContext);
             // Register bot user IDs to ignore (so bug monitor only processes human messages)
             if (this.daemonManager) {
                 const daemonStatus = this.daemonManager.getStatus();
@@ -155,6 +167,10 @@ class Core {
             const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
             await (0, bot_config_1.initBotConfigPersistence)(userContext.hailer);
             this.logger.info('Bot config persistence initialized');
+            // Register callback for daemon restart when new orchestrator is discovered
+            (0, bot_config_1.onDaemonRestartNeeded)(() => {
+                this.attemptDaemonRestart();
+            });
         }
         catch (error) {
             this.logger.warn('Bot config persistence failed to initialize - using in-memory defaults', {
@@ -162,12 +178,83 @@ class Core {
             });
         }
     }
-    async initializeDaemonMode() {
-        this.logger.info('Initializing Chat Agent Daemon');
+    /**
+     * 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
+     */
+    async attemptDaemonRestart(retryCount = 0, workspaceId) {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAY_MS = 5000;
+        // Skip restart if initial daemon hasn't been created yet
+        // (signals can fire before first daemon init completes)
+        if (!this.initialDaemonReady) {
+            this.logger.debug('Skipping daemon restart - initial daemon not yet ready');
+            return;
+        }
+        if (this.daemonInitInProgress) {
+            this.logger.debug('Daemon init already in progress, skipping');
+            return;
+        }
+        this.logger.info('Restarting daemons after bot state change', { retryCount });
+        this.daemonInitInProgress = true;
+        try {
+            // Stop existing daemons if running
+            if (this.daemonManager) {
+                this.logger.info('Stopping existing daemons for restart');
+                if (this.statusLogInterval) {
+                    clearInterval(this.statusLogInterval);
+                    this.statusLogInterval = undefined;
+                }
+                await this.daemonManager.stopAll();
+                this.daemonManager = null;
+            }
+            // Start fresh with updated bot state
+            await this.initializeDaemonMode(workspaceId);
+            // Verify orchestrator was created successfully (daemonManager is set by initializeDaemonMode)
+            // Use explicit re-read to help TypeScript understand the state change
+            const newManager = this.daemonManager;
+            if (!newManager) {
+                throw new Error('Daemon manager was not created');
+            }
+            if (!newManager.getOrchestrator()) {
+                throw new Error('Daemon manager created but no orchestrator available');
+            }
+            this.logger.info('Daemons successfully restarted after state change');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isTransientError = errorMessage.includes('Timeout') ||
+                errorMessage.includes('ECONNREFUSED') ||
+                errorMessage.includes('No orchestrator');
+            if (isTransientError && retryCount < MAX_RETRIES) {
+                this.logger.warn('Daemon restart failed with transient error, scheduling retry', {
+                    error: errorMessage,
+                    retryCount: retryCount + 1,
+                    retryDelayMs: RETRY_DELAY_MS
+                });
+                // Reset flag before scheduling retry
+                this.daemonInitInProgress = false;
+                setTimeout(() => {
+                    this.attemptDaemonRestart(retryCount + 1, workspaceId);
+                }, RETRY_DELAY_MS);
+                return;
+            }
+            this.logger.warn('Daemon restart failed', {
+                error: errorMessage,
+                retriesExhausted: retryCount >= MAX_RETRIES
+            });
+        }
+        finally {
+            this.daemonInitInProgress = false;
+        }
+    }
+    async initializeDaemonMode(workspaceId) {
+        this.logger.info('Initializing Chat Agent Daemon', { workspaceId });
         // Check for orchestrator mode via environment variable
         const orchestratorMode = process.env.DAEMON_ORCHESTRATOR_MODE === 'true';
         this.logger.info(`Daemon mode: ${orchestratorMode ? 'ORCHESTRATOR' : 'STANDARD'}`);
-        this.daemonManager = await (0, factory_1.createDaemonManager)({ orchestratorMode });
+        this.daemonManager = await (0, factory_1.createDaemonManager)({ orchestratorMode, workspaceId });
         if (!this.daemonManager) {
             throw new Error('Failed to create daemon manager');
         }
@@ -177,6 +264,48 @@ class Core {
             bots: status.map(s => s.botId),
             orchestratorMode
         });
+        // Wire webhook updates to daemon hot-reload
+        (0, webhook_handler_1.onBotUpdate)((workspaceId, bot, action) => {
+            this.logger.info('Webhook bot update received', { workspaceId, botType: bot.botType, action, enabled: bot.enabled });
+            if (bot.botType === 'orchestrator') {
+                if (action === 'remove') {
+                    // Orchestrator disabled - stop daemons, don't restart
+                    this.logger.info('Orchestrator disabled via webhook, stopping daemons');
+                    this.daemonManager?.stopAll().catch(err => {
+                        this.logger.error('Failed to stop daemons after orchestrator removal', err);
+                    });
+                }
+                else {
+                    // Orchestrator added/updated - restart daemons
+                    this.logger.info('Orchestrator config changed via webhook, triggering daemon restart');
+                    this.attemptDaemonRestart(0, workspaceId).catch(err => {
+                        this.logger.error('Failed to restart daemon after orchestrator webhook update', err);
+                    });
+                }
+            }
+            else {
+                // Specialist changed - hot-reload without losing orchestrator context
+                this.logger.info('Specialist config changed via webhook, hot-reloading', {
+                    botType: bot.botType,
+                    enabled: bot.enabled
+                });
+                if (this.daemonManager && bot.botType) {
+                    this.daemonManager.hotReloadSpecialist(bot.email, bot.password, bot.botType, bot.enabled, bot.userId || undefined).then(success => {
+                        if (success) {
+                            this.logger.info('Specialist hot-reloaded successfully', {
+                                botType: bot.botType,
+                                enabled: bot.enabled
+                            });
+                        }
+                        else {
+                            this.logger.warn('Specialist hot-reload failed', { botType: bot.botType });
+                        }
+                    }).catch(err => {
+                        this.logger.error('Error during specialist hot-reload', err);
+                    });
+                }
+            }
+        });
         // Start periodic status logging (every 60s)
         this.statusLogInterval = this.daemonManager.startStatusLogging(60000);
         this.logger.info('Daemon status logging started (every 60s)');
@@ -198,6 +327,8 @@ class Core {
             if (this.bugReportsModule) {
                 await this.bugReportsModule.stop();
             }
+            // Cleanup bot config (clear timers and callbacks)
+            (0, bot_config_1.cleanupBotConfig)();
             if (this.daemonManager) {
                 this.daemonManager.stopAll();
                 this.logger.info('Chat Agent Daemon stopped');

package/dist/lib/discussion-lock.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Discussion Lock Registry
+ *
+ * Prevents multiple bots from responding to the same discussion.
+ * When a specialist bot (like Giuseppe) is handling a discussion,
+ * it acquires a lock. Other bots (like Orchestrator) check the lock
+ * before responding.
+ */
+/**
+ * Acquire a lock on a discussion
+ * @param discussionId - The discussion to lock
+ * @param botName - Name of the bot acquiring the lock (for logging)
+ * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
+ * @returns true if lock acquired, false if already locked by another bot
+ */
+export declare function acquireDiscussionLock(discussionId: string, botName: string, ttlMs?: number): boolean;
+/**
+ * Release a lock on a discussion
+ * @param discussionId - The discussion to unlock
+ * @param botName - Name of the bot releasing (must match acquirer)
+ */
+export declare function releaseDiscussionLock(discussionId: string, botName: string): void;
+/**
+ * Check if a discussion is locked by another bot
+ * @param discussionId - The discussion to check
+ * @param myBotName - Name of the checking bot (own locks don't block)
+ * @returns true if locked by ANOTHER bot, false if free or own lock
+ */
+export declare function isDiscussionLocked(discussionId: string, myBotName: string): boolean;
+/**
+ * Clean up expired locks (call periodically)
+ */
+export declare function cleanupExpiredLocks(): number;
+/**
+ * Get current lock status (for debugging)
+ */
+export declare function getLockStatus(): Map<string, {
+    botName: string;
+    acquiredAt: number;
+    expiresAt: number;
+}>;
+//# sourceMappingURL=discussion-lock.d.ts.map

package/dist/lib/discussion-lock.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Discussion Lock Registry
+ *
+ * Prevents multiple bots from responding to the same discussion.
+ * When a specialist bot (like Giuseppe) is handling a discussion,
+ * it acquires a lock. Other bots (like Orchestrator) check the lock
+ * before responding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireDiscussionLock = acquireDiscussionLock;
+exports.releaseDiscussionLock = releaseDiscussionLock;
+exports.isDiscussionLocked = isDiscussionLocked;
+exports.cleanupExpiredLocks = cleanupExpiredLocks;
+exports.getLockStatus = getLockStatus;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)({ component: 'discussion-lock' });
+// Singleton map of discussionId -> { botName, acquiredAt, expiresAt }
+const locks = new Map();
+// Default lock TTL: 5 minutes (allows for LLM processing time)
+const DEFAULT_LOCK_TTL_MS = 5 * 60 * 1000;
+/**
+ * Acquire a lock on a discussion
+ * @param discussionId - The discussion to lock
+ * @param botName - Name of the bot acquiring the lock (for logging)
+ * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
+ * @returns true if lock acquired, false if already locked by another bot
+ */
+function acquireDiscussionLock(discussionId, botName, ttlMs = DEFAULT_LOCK_TTL_MS) {
+    const now = Date.now();
+    const existing = locks.get(discussionId);
+    // Check if existing lock is still valid
+    if (existing && existing.expiresAt > now) {
+        if (existing.botName === botName) {
+            // Same bot - extend the lock
+            existing.expiresAt = now + ttlMs;
+            return true;
+        }
+        // Different bot has the lock
+        logger.debug('Discussion already locked', {
+            discussionId,
+            lockedBy: existing.botName,
+            requestedBy: botName
+        });
+        return false;
+    }
+    // Acquire lock
+    locks.set(discussionId, {
+        botName,
+        acquiredAt: now,
+        expiresAt: now + ttlMs
+    });
+    logger.debug('Discussion lock acquired', { discussionId, botName, ttlMs });
+    return true;
+}
+/**
+ * Release a lock on a discussion
+ * @param discussionId - The discussion to unlock
+ * @param botName - Name of the bot releasing (must match acquirer)
+ */
+function releaseDiscussionLock(discussionId, botName) {
+    const existing = locks.get(discussionId);
+    if (existing && existing.botName === botName) {
+        locks.delete(discussionId);
+        logger.debug('Discussion lock released', { discussionId, botName });
+    }
+}
+/**
+ * Check if a discussion is locked by another bot
+ * @param discussionId - The discussion to check
+ * @param myBotName - Name of the checking bot (own locks don't block)
+ * @returns true if locked by ANOTHER bot, false if free or own lock
+ */
+function isDiscussionLocked(discussionId, myBotName) {
+    const now = Date.now();
+    const existing = locks.get(discussionId);
+    // No lock or expired
+    if (!existing || existing.expiresAt <= now) {
+        return false;
+    }
+    // Own lock doesn't block
+    if (existing.botName === myBotName) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Clean up expired locks (call periodically)
+ */
+function cleanupExpiredLocks() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [discussionId, lock] of locks.entries()) {
+        if (lock.expiresAt <= now) {
+            locks.delete(discussionId);
+            cleaned++;
+        }
+    }
+    if (cleaned > 0) {
+        logger.debug('Cleaned up expired locks', { count: cleaned });
+    }
+    return cleaned;
+}
+/**
+ * Get current lock status (for debugging)
+ */
+function getLockStatus() {
+    return new Map(locks);
+}
+//# sourceMappingURL=discussion-lock.js.map

package/dist/mcp/UserContextCache.js

@@ -101,9 +101,9 @@ class UserContextCache {
             const client = await (0, hailer_clients_1.createHailerClientByApiKey)(apiKey);
             // Create API client (host extracted from client automatically)
             const hailer = new index_1.HailerApiClient(client);
-            // Fetch user's workspace initialization data
+            // Fetch user's workspace initialization data (including teams for activity creation)
             const init = await client.socket.request('v2.core.init', [
-                ['processes', 'users', 'network', 'networks']
+                ['processes', 'users', 'network', 'networks', 'teams']
             ]);
             // Create workspace cache from init data
             const appConfig = (0, config_1.createApplicationConfig)();

package/dist/mcp/hailer-clients.d.ts

@@ -24,6 +24,7 @@ export declare class HailerClientManager {
     private socketClient;
     private restClient;
     private signalHandlers;
+    private signalsInitialized;
     constructor(host: string, username: string, password: string);
     connect(): Promise<HailerClient>;
     private setupSignalHandling;
@@ -42,8 +43,22 @@ export declare const createHailerClientByApiKey: (apiKey: string) => Promise<Hai
  * Disconnect client by API key (new unified approach)
  */
 export declare const disconnectHailerClientByApiKey: (apiKey: string) => void;
+/**
+ * Clear all connections - forces fresh reconnect on next request
+ * Use this when you need to refresh stale server-side data (e.g., after template install)
+ */
+export declare const clearAllConnections: () => void;
 /**
  * Subscribe to signals for a client connection
  */
 export declare const subscribeToSignal: (apiKey: string, eventType: SignalType | string, handler: SignalHandler) => (() => void) | null;
+/**
+ * Register new bot credentials for dynamic bot creation
+ * Returns an API key that can be used to create a connection
+ */
+export declare function registerBotCredentials(botId: string, email: string, password: string): string;
+/**
+ * Unregister bot credentials and disconnect
+ */
+export declare function unregisterBotCredentials(apiKey: string): void;
 //# sourceMappingURL=hailer-clients.d.ts.map

package/dist/mcp/hailer-clients.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribeToSignal = exports.disconnectHailerClientByApiKey = exports.createHailerClientByApiKey = exports.HailerClientManager = void 0;
+exports.subscribeToSignal = exports.clearAllConnections = exports.disconnectHailerClientByApiKey = exports.createHailerClientByApiKey = exports.HailerClientManager = void 0;
 exports.getCurrentUserId = getCurrentUserId;
+exports.registerBotCredentials = registerBotCredentials;
+exports.unregisterBotCredentials = unregisterBotCredentials;
 const cli_1 = require("@hailer/cli");
 const auth_1 = require("./auth");
 const logger_1 = require("../lib/logger");
@@ -74,6 +76,7 @@ class HailerClientManager {
     socketClient = null;
     restClient = null;
     signalHandlers = new Map();
+    signalsInitialized = false;
     constructor(host, username, password) {
         this.host = host;
         this.username = username;
@@ -88,14 +91,35 @@ class HailerClientManager {
             password: this.password,
             ...(isLocalDev && { rejectUnauthorized: false }), // Add for local dev with self-signed certs
         };
+        // Track timeout for proper cleanup
+        let timeoutId = null;
+        let timeoutCleared = false;
         try {
-            // Create socket client using @hailer/cli with timeout
+            // Create socket client using @hailer/cli with cancellable timeout
             this.socketClient = (await Promise.race([
-                cli_1.Client.create(clientOptions),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("Socket connection timeout after 30s")), 30000)),
+                cli_1.Client.create(clientOptions).then(client => {
+                    // Clear timeout on success
+                    if (timeoutId && !timeoutCleared) {
+                        clearTimeout(timeoutId);
+                        timeoutCleared = true;
+                    }
+                    return client;
+                }),
+                new Promise((_, reject) => {
+                    timeoutId = setTimeout(() => {
+                        if (!timeoutCleared) {
+                            reject(new Error(`Timeout connecting to: ${this.host}`));
+                        }
+                    }, 30000);
+                }),
             ]));
         }
         catch (error) {
+            // Ensure timeout is cleared on error too
+            if (timeoutId && !timeoutCleared) {
+                clearTimeout(timeoutId);
+                timeoutCleared = true;
+            }
             logger.error('Failed to create socket client', error, { username: this.username });
             throw error;
         }
@@ -123,10 +147,43 @@ class HailerClientManager {
         };
     }
     setupSignalHandling() {
-        if (!this.socketClient)
+        if (!this.socketClient || this.signalsInitialized)
             return;
+        this.signalsInitialized = true;
+        // Connection lifecycle logging - helps diagnose bot death issues
+        this.socketClient.on("disconnect", (reason) => {
+            logger.warn('Socket disconnected', {
+                reason,
+                username: this.username,
+                willReconnect: reason !== 'io server disconnect' && reason !== 'io client disconnect'
+            });
+        });
+        this.socketClient.on("reconnect", () => {
+            logger.info('Socket reconnected and session resumed', { username: this.username });
+        });
+        this.socketClient.on("connect", () => {
+            logger.info('Socket connected', { username: this.username });
+        });
+        this.socketClient.on("connect_error", (error) => {
+            logger.error('Socket connection error', { error: error.message, username: this.username });
+        });
+        this.socketClient.on("reconnect_attempt", (attempt) => {
+            logger.info('Socket reconnection attempt', { attempt, username: this.username });
+        });
+        this.socketClient.on("reconnect_failed", () => {
+            logger.error('Socket reconnection failed permanently', { username: this.username });
+        });
         this.socketClient.on("signals", (signal) => {
             const [eventType, eventData] = signal;
+            // Debug: log all incoming signals to see what we're receiving
+            if (eventType === 'messenger.new') {
+                logger.debug('HailerClientManager received messenger.new signal', {
+                    eventType,
+                    discussion: eventData.discussion,
+                    handlersRegistered: this.signalHandlers.has(eventType),
+                    handlerCount: this.signalHandlers.get(eventType)?.length || 0,
+                });
+            }
             // Dispatch to registered handlers
             const handlers = this.signalHandlers.get(eventType);
             if (handlers) {
@@ -165,6 +222,7 @@ class HailerClientManager {
         }
         this.restClient = null;
         this.signalHandlers.clear();
+        this.signalsInitialized = false;
     }
     isConnected() {
         return this.socketClient !== null && this.restClient !== null;
@@ -223,7 +281,7 @@ const createHailerClientByApiKey = async (apiKey) => {
     // Create new connection
     logger.info('Creating new connection', {
         apiKey: apiKey.substring(0, 8) + '...',
-        email: account.email,
+        email: (0, config_1.maskEmail)(account.email),
         host: account.apiBaseUrl
     });
     clientManager = new HailerClientManager(account.apiBaseUrl, account.email, account.password);
@@ -243,6 +301,19 @@ const disconnectHailerClientByApiKey = (apiKey) => {
     }
 };
 exports.disconnectHailerClientByApiKey = disconnectHailerClientByApiKey;
+/**
+ * Clear all connections - forces fresh reconnect on next request
+ * Use this when you need to refresh stale server-side data (e.g., after template install)
+ */
+const clearAllConnections = () => {
+    const count = connectionPool.size;
+    for (const [, clientManager] of connectionPool.entries()) {
+        clientManager.disconnect();
+    }
+    connectionPool.clear();
+    logger.info('Cleared Hailer connections', { count });
+};
+exports.clearAllConnections = clearAllConnections;
 /**
  * Subscribe to signals for a client connection
  */
@@ -258,4 +329,27 @@ const subscribeToSignal = (apiKey, eventType, handler) => {
     };
 };
 exports.subscribeToSignal = subscribeToSignal;
+/**
+ * Register new bot credentials for dynamic bot creation
+ * Returns an API key that can be used to create a connection
+ */
+function registerBotCredentials(botId, email, password) {
+    const apiKey = `bot-${botId}-${Date.now()}`;
+    // Add to environment CLIENT_CONFIGS
+    config_1.environment.CLIENT_CONFIGS[apiKey] = {
+        email,
+        password,
+        apiBaseUrl: 'https://api.hailer.com',
+    };
+    logger.info('Bot credentials registered', { botId });
+    return apiKey;
+}
+/**
+ * Unregister bot credentials and disconnect
+ */
+function unregisterBotCredentials(apiKey) {
+    delete config_1.environment.CLIENT_CONFIGS[apiKey];
+    (0, exports.disconnectHailerClientByApiKey)(apiKey);
+    logger.info('Bot credentials unregistered');
+}
 //# sourceMappingURL=hailer-clients.js.map

package/dist/mcp/signal-handler.d.ts

@@ -3,7 +3,7 @@ import { HailerClient } from './hailer-clients';
 /**
  * Signal types that Hailer emits via socket.io
  */
-export type HailerSignalType = 'activities.updated' | 'activities.created' | 'activities.deleted' | 'discussion.message' | 'messenger.new' | 'user.joined' | 'user.left' | 'workspace.updated' | 'process.updated' | 'cache.invalidate';
+export type HailerSignalType = 'activities.updated' | 'activities.created' | 'activities.deleted' | 'discussion.message' | 'messenger.new' | 'user.joined' | 'user.left' | 'workspace.updated' | 'process.updated' | 'cache.invalidate' | 'company.new_invitation';
 /** Raw signal from Hailer socket - tuple of [eventType, eventData] */
 export type HailerSocketSignal = [string, Record<string, unknown>];
 /** Message object nested in signal data */
@@ -14,6 +14,13 @@ export interface HailerSignalMessage {
     user?: string;
     userName?: string;
 }
+/** Metadata for activities.updated signals - contains phase change information */
+export interface ActivityUpdatedMeta {
+    processId: string;
+    phase: string;
+    prevPhase?: string;
+    activity_id: string | string[];
+}
 /** Signal data varies by type - common fields for type narrowing */
 export interface HailerSignalData {
     _id?: string;
@@ -26,6 +33,7 @@ export interface HailerSignalData {
     discussion?: string;
     uid?: string;
     message?: HailerSignalMessage;
+    meta?: ActivityUpdatedMeta;
     [key: string]: unknown;
 }
 export interface HailerSignal {
@@ -46,7 +54,13 @@ export declare class SignalHandler {
     private subscriptions;
     private signalHistory;
     private maxHistorySize;
+    private static handlersBySocketId;
     constructor(client: HailerClient, workspaceCache?: WorkspaceCache | undefined);
+    /**
+     * Get or create a SignalHandler for a client (prevents duplicate listeners)
+     */
+    static getOrCreate(client: HailerClient, workspaceCache?: WorkspaceCache): SignalHandler;
+    private signalListener;
     private initializeSignalHandling;
     private handleIncomingSignal;
     private addToHistory;
@@ -58,14 +72,11 @@ export declare class SignalHandler {
     private handleWorkspaceUpdated;
     private handleMessengerNew;
     private handleCacheInvalidate;
+    private handleNewInvitation;
     subscribe(id: string, types: HailerSignalType[], handler: (signal: HailerSignal) => void, workspaceId?: string): void;
     unsubscribe(id: string): boolean;
     getSignalHistory(types?: HailerSignalType[], limit?: number, workspaceId?: string): HailerSignal[];
     getActiveSubscriptions(): SignalSubscription[];
     clearHistory(): void;
-    createMcpSignalTools(server: {
-        tool: (...args: unknown[]) => void;
-    }): void;
 }
-export declare const createSignalHandler: (clients: HailerClient, workspaceCache?: WorkspaceCache) => SignalHandler;
 //# sourceMappingURL=signal-handler.d.ts.map