lattice-orchestrator 0.7.0

package/dist/lattice-server.js

@@ -0,0 +1,969 @@
+import express from 'express';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { displayServerStartup } from './utils/server-startup.js';
+// Get the directory of this module for serving static files
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import { createProcessManager } from './services/process/process-manager-factory.js';
+import { StreamManager } from './services/infrastructure/stream-manager.js';
+import { ClaudeHistoryReader } from './services/sessions/claude-history-reader.js';
+import { PermissionTracker } from './services/permission-tracker.js';
+import { QuestionTracker } from './services/question-tracker.js';
+import { PendingQuestionService } from './services/pending-question-service.js';
+import { MCPConfigGenerator } from './services/mcp-config-generator.js';
+import { FileSystemService } from './services/infrastructure/file-system-service.js';
+import { ConfigService } from './services/infrastructure/config-service.js';
+import { SessionInfoService } from './services/sessions/session-info-service.js';
+import { ConversationStatusManager } from './services/process/conversation-status-manager.js';
+import { WorkingDirectoriesService } from './services/working-directories-service.js';
+import { ToolMetricsService } from './services/ToolMetricsService.js';
+import { NotificationService } from './services/notification-service.js';
+import { WebPushService } from './services/web-push-service.js';
+import { geminiService } from './services/gemini-service.js';
+import { anthropicService } from './services/insights/anthropic-service.js';
+import { ClaudeRouterService } from './services/claude-router-service.js';
+import { LatticeError } from './types/index.js';
+import { createLogger } from './services/infrastructure/logger.js';
+import { createConversationRoutes } from './routes/conversation.routes.js';
+import { createSystemRoutes } from './routes/system.routes.js';
+import { createPermissionRoutes } from './routes/permission.routes.js';
+import { createQuestionRoutes } from './routes/question.routes.js';
+import { createPendingQuestionRoutes } from './routes/pending-question.routes.js';
+import { createFileSystemRoutes } from './routes/filesystem.routes.js';
+import { createLogRoutes } from './routes/log.routes.js';
+import { createStreamingRoutes } from './routes/streaming.routes.js';
+import { createWorkingDirectoriesRoutes } from './routes/working-directories.routes.js';
+import { createConfigRoutes } from './routes/config.routes.js';
+import { createInsightsRoutes } from './routes/insights.routes.js';
+import { createLatticeRoutes } from './routes/lattice.routes.js';
+import { LatticeService } from './services/lattice-service.js';
+import { TurnCaptureService } from './services/sessions/turn-capture-service.js';
+import { createLicenseRoutes } from './routes/license.routes.js';
+import { createAnalysisRoutes } from './routes/analysis.routes.js';
+import { createWalkthroughRoutes } from './routes/walkthrough.routes.js';
+import { createPrototypeRoutes } from './routes/prototype.routes.js';
+import processEventsRouter from './routes/process-events.routes.js';
+import { errorHandler } from './middleware/error-handler.js';
+import { requestLogger } from './middleware/request-logger.js';
+import { createCorsMiddleware } from './middleware/cors-setup.js';
+import { queryParser } from './middleware/query-parser.js';
+import { checkForUpdatesOnStartup } from './utils/update-check.js';
+import { registerStateProvider, startPeriodicStateLogging } from './services/connection-debug-logger.js';
+import { serviceRegistry } from './services/infrastructure/service-registry.js';
+// ViteExpress will be imported dynamically in initialize() if needed
+let ViteExpress;
+/**
+ * Main CUI server class
+ */
+export class LatticeServer {
+    app;
+    server;
+    processManager; // Initialized in initialize()
+    streamManager;
+    historyReader;
+    permissionTracker;
+    questionTracker;
+    pendingQuestionService;
+    mcpConfigGenerator;
+    fileSystemService;
+    configService;
+    sessionInfoService;
+    conversationStatusManager;
+    workingDirectoriesService;
+    toolMetricsService;
+    notificationService;
+    webPushService;
+    routerService;
+    turnCaptureService;
+    logger;
+    port;
+    host;
+    configOverrides;
+    orphanCleanupInterval;
+    constructor(configOverrides) {
+        this.app = express();
+        this.configOverrides = configOverrides;
+        this.logger = createLogger('LatticeServer');
+        // TEST: Add debug log right at the start
+        this.logger.debug('🔍 TEST: LatticeServer constructor started - this should be visible if debug logging works');
+        // Initialize config service first
+        this.configService = ConfigService.getInstance();
+        // Will be set after config is loaded
+        this.port = 0;
+        this.host = '';
+        this.logger.debug('Initializing LatticeServer', {
+            nodeEnv: process.env.NODE_ENV,
+            configOverrides
+        });
+        // Initialize services
+        this.logger.debug('Initializing services');
+        // Use singleton to ensure event handlers get the same initialized instance
+        this.sessionInfoService = SessionInfoService.getInstance();
+        this.historyReader = new ClaudeHistoryReader(this.sessionInfoService);
+        this.conversationStatusManager = new ConversationStatusManager();
+        this.toolMetricsService = new ToolMetricsService();
+        this.fileSystemService = new FileSystemService();
+        // processManager is initialized in initialize() to support daemon mode
+        this.streamManager = new StreamManager();
+        this.permissionTracker = new PermissionTracker();
+        this.questionTracker = new QuestionTracker();
+        this.pendingQuestionService = PendingQuestionService.getInstance();
+        this.mcpConfigGenerator = new MCPConfigGenerator(this.fileSystemService);
+        this.workingDirectoriesService = new WorkingDirectoriesService(this.historyReader, this.logger);
+        this.notificationService = new NotificationService();
+        this.webPushService = WebPushService.getInstance();
+        this.turnCaptureService = TurnCaptureService.getInstance();
+        // Wire up services that don't depend on processManager
+        this.permissionTracker.setNotificationService(this.notificationService);
+        this.permissionTracker.setConversationStatusManager(this.conversationStatusManager);
+        this.permissionTracker.setHistoryReader(this.historyReader);
+        this.logger.debug('Services initialized (processManager deferred to initialize())');
+        this.setupMiddleware();
+        // Routes and processManager integration are set up in initialize()
+    }
+    /**
+     * Get the Express app instance
+     */
+    getApp() {
+        return this.app;
+    }
+    /**
+     * Get the configured port
+     */
+    getPort() {
+        return this.port;
+    }
+    /**
+     * Get the configured host
+     */
+    getHost() {
+        return this.host;
+    }
+    /**
+     * Initialize services without starting the HTTP server
+     */
+    async initialize() {
+        this.logger.debug('Initialize method called');
+        try {
+            // =========================================================================
+            // PHASE 1: Register services with dependency graph
+            // This declares the initialization order - actual init happens below
+            // =========================================================================
+            serviceRegistry.register('ConfigService');
+            serviceRegistry.register('SessionInfoService', { dependsOn: ['ConfigService'] });
+            serviceRegistry.register('PendingQuestionService', { dependsOn: ['SessionInfoService'] });
+            serviceRegistry.register('ProcessManager', { dependsOn: ['SessionInfoService'] });
+            serviceRegistry.register('GeminiService', { dependsOn: ['ConfigService'] });
+            serviceRegistry.register('AnthropicService', { dependsOn: ['ConfigService'] });
+            serviceRegistry.register('CostTracker', { dependsOn: ['ConfigService'] });
+            serviceRegistry.register('InsightsCoordinator', {
+                dependsOn: ['SessionInfoService', 'AnthropicService']
+            });
+            // =========================================================================
+            // PHASE 2: Initialize services in dependency order
+            // =========================================================================
+            // Initialize configuration first
+            this.logger.debug('Initializing configuration');
+            await this.configService.initialize();
+            serviceRegistry.markInitialized('ConfigService');
+            // Set the invocation cwd if provided via CLI
+            if (this.configOverrides?.cwd) {
+                this.configService.setInvocationCwd(this.configOverrides.cwd);
+            }
+            const config = this.configService.getConfig();
+            // Initialize session info service
+            this.logger.debug('Initializing session info service');
+            await this.sessionInfoService.initialize();
+            serviceRegistry.markInitialized('SessionInfoService');
+            this.logger.debug('Session info service initialized successfully');
+            // Initialize pending question service (uses same DB as session info)
+            this.logger.debug('Initializing pending question service');
+            await this.pendingQuestionService.initialize();
+            serviceRegistry.markInitialized('PendingQuestionService');
+            this.logger.debug('Pending question service initialized successfully');
+            // Initialize process manager (skip if already set, e.g. by tests)
+            if (!this.processManager) {
+                this.logger.debug('Initializing process manager');
+                this.processManager = await createProcessManager({
+                    historyReader: this.historyReader,
+                    statusTracker: this.conversationStatusManager,
+                    toolMetricsService: this.toolMetricsService,
+                    sessionInfoService: this.sessionInfoService,
+                    fileSystemService: this.fileSystemService
+                });
+            }
+            else {
+                this.logger.debug('Process manager already set, skipping initialization');
+            }
+            this.processManager.setNotificationService(this.notificationService);
+            this.processManager.setConversationStatusManager(this.conversationStatusManager);
+            // Set up event listeners now that processManager exists
+            this.setupProcessManagerIntegration();
+            this.setupPermissionTrackerIntegration();
+            this.setupQuestionTrackerIntegration();
+            serviceRegistry.markInitialized('ProcessManager');
+            this.logger.debug('Process manager initialized successfully');
+            this.logger.debug('Initializing Gemini service');
+            await geminiService.initialize();
+            serviceRegistry.markInitialized('GeminiService');
+            this.logger.debug('Gemini service initialized successfully');
+            this.logger.debug('Initializing Anthropic service');
+            await anthropicService.initialize();
+            serviceRegistry.markInitialized('AnthropicService');
+            this.logger.debug('Anthropic service initialized successfully');
+            // Initialize cost tracker for LLM usage monitoring
+            this.logger.debug('Initializing cost tracker');
+            const { getCostTracker } = await import('./services/infrastructure/cost-tracker.js');
+            await getCostTracker().initialize();
+            serviceRegistry.markInitialized('CostTracker');
+            this.logger.debug('Cost tracker initialized successfully');
+            // Initialize insights coordinator (unified event-driven system)
+            this.logger.debug('Initializing insights coordinator');
+            const { initializeInsightsCoordinator, getInsightsCoordinator } = await import('./services/insights/insights-coordinator.js');
+            initializeInsightsCoordinator();
+            serviceRegistry.markInitialized('InsightsCoordinator');
+            // Wire up session-ended to expedite insight patches
+            this.conversationStatusManager.on('session-ended', ({ claudeSessionId }) => {
+                // handleSessionEnded is async - fire and forget but log errors
+                getInsightsCoordinator().handleSessionEnded(claudeSessionId).catch(err => {
+                    this.logger.error('Failed to handle session ended for insights', {
+                        sessionId: claudeSessionId.slice(0, 8),
+                        error: err.message
+                    });
+                });
+            });
+            this.logger.debug('Insights coordinator initialized successfully');
+            // Initialize router service if configured
+            await this.initializeOrReloadRouter(config);
+            // Apply overrides if provided (for tests and CLI options)
+            this.port = this.configOverrides?.port ?? config.server.port;
+            this.host = this.configOverrides?.host ?? config.server.host;
+            this.logger.info('Configuration loaded', {
+                machineId: config.machine_id,
+                port: this.port,
+                host: this.host,
+                overrides: this.configOverrides ? Object.keys(this.configOverrides) : []
+            });
+            // Set up routes after services are initialized
+            // This allows tests to override services before routes are created
+            this.logger.debug('Setting up routes');
+            this.setupRoutes();
+            // Register connection state provider for debug logging
+            const conversationStatusManager = this.conversationStatusManager;
+            const streamManager = this.streamManager;
+            const processManager = this.processManager;
+            registerStateProvider({
+                getConnectionState: () => ({
+                    conversationStatusManager: {
+                        activeSessions: conversationStatusManager.getStats().activeSessions,
+                    },
+                    streamManager: {
+                        activeSessions: streamManager.getActiveSessions(),
+                        clientCounts: Object.fromEntries(streamManager.getActiveSessions().map(s => [s, streamManager.getClientCount(s)])),
+                    },
+                    processManager: {
+                        activeSessions: processManager.getActiveSessions(),
+                    },
+                }),
+            });
+            startPeriodicStateLogging(30000); // Check every 30 seconds
+            // Generate MCP config before starting server
+            try {
+                const mcpConfigPath = await this.mcpConfigGenerator.generateConfig(this.port);
+                this.processManager.setMCPConfigPath(mcpConfigPath);
+                this.logger.debug('MCP config generated and set', { path: mcpConfigPath });
+            }
+            catch (error) {
+                const isNonProduction = process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development';
+                if (isNonProduction) {
+                    this.logger.warn('MCP config generation failed in non-production environment, proceeding without MCP', {
+                        error: error instanceof Error ? error.message : String(error),
+                        nodeEnv: process.env.NODE_ENV
+                    });
+                    // Don't set MCP config path - conversations will run without MCP
+                }
+                else {
+                    this.logger.error('MCP config generation failed in production environment', {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    throw new LatticeError('MCP_CONFIG_REQUIRED', `MCP server files are required in production but not found: ${error instanceof Error ? error.message : String(error)}`, 500);
+                }
+            }
+            // Subscribe to configuration changes to hot-reload router when needed
+            this.configService.onChange(async (newConfig) => {
+                try {
+                    await this.initializeOrReloadRouter(newConfig);
+                }
+                catch (error) {
+                    this.logger.error('Failed to reload router after config change', error);
+                }
+            });
+            // Check for updates (non-blocking, just logs if update available)
+            checkForUpdatesOnStartup();
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize server:', error, {
+                errorType: error instanceof Error ? error.constructor.name : typeof error,
+                errorMessage: error instanceof Error ? error.message : String(error)
+            });
+            if (error instanceof LatticeError) {
+                throw error;
+            }
+            else {
+                throw new LatticeError('SERVER_INIT_FAILED', `Server initialization failed: ${error}`, 500);
+            }
+        }
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        this.logger.debug('Start method called');
+        try {
+            // Initialize all services
+            await this.initialize();
+            // Start Express server
+            const isDev = process.env.NODE_ENV === 'development';
+            this.logger.debug('Creating HTTP server listener', {
+                useViteExpress: isDev,
+                environment: process.env.NODE_ENV
+            });
+            // Import ViteExpress dynamically if in development mode
+            if (isDev && !ViteExpress) {
+                const viteExpressModule = await import('vite-express');
+                ViteExpress = viteExpressModule.default;
+            }
+            await new Promise((resolve, reject) => {
+                // Use ViteExpress only in development
+                if (isDev && ViteExpress) {
+                    try {
+                        this.server = this.app.listen(this.port, this.host, () => {
+                            this.logger.debug('Server successfully bound to port (dev mode)', {
+                                port: this.port,
+                                host: this.host,
+                                address: this.server?.address()
+                            });
+                            // Display startup info now that server is actually listening
+                            displayServerStartup({
+                                host: this.host,
+                                port: this.port,
+                                logger: this.logger
+                            });
+                            // Configure and bind ViteExpress AFTER server is listening
+                            ViteExpress.config({
+                                mode: 'development',
+                                viteConfigFile: 'vite.config.mts'
+                            });
+                            ViteExpress.bind(this.app, this.server);
+                            this.logger.info(`CUI development server running on http://${this.host}:${this.port}`);
+                            resolve();
+                        });
+                    }
+                    catch (error) {
+                        this.logger.error('Failed to start ViteExpress server', error);
+                        reject(error);
+                    }
+                }
+                else {
+                    // Production/test mode - regular Express server
+                    this.server = this.app.listen(this.port, this.host, () => {
+                        this.logger.debug('Server successfully bound to port', {
+                            port: this.port,
+                            host: this.host,
+                            address: this.server?.address(),
+                            mode: process.env.NODE_ENV || 'production'
+                        });
+                        // Display startup info now that server is actually listening
+                        displayServerStartup({
+                            host: this.host,
+                            port: this.port,
+                            logger: this.logger
+                        });
+                        resolve();
+                    });
+                }
+                if (this.server) {
+                    this.server.on('error', (error) => {
+                        this.logger.error('Failed to start HTTP server:', error, {
+                            errorCode: error.code,
+                            errorSyscall: error.syscall,
+                            port: this.port,
+                            host: this.host
+                        });
+                        reject(new LatticeError('HTTP_SERVER_START_FAILED', `Failed to start HTTP server: ${error.message}`, 500));
+                    });
+                }
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to start server:', error, {
+                errorType: error instanceof Error ? error.constructor.name : typeof error,
+                errorMessage: error instanceof Error ? error.message : String(error)
+            });
+            // Attempt cleanup on startup failure
+            await this.cleanup();
+            if (error instanceof LatticeError) {
+                throw error;
+            }
+            else {
+                throw new LatticeError('SERVER_START_FAILED', `Server startup failed: ${error}`, 500);
+            }
+        }
+    }
+    /**
+     * Stop the server gracefully
+     */
+    async stop() {
+        this.logger.debug('Stop method called', {
+            hasServer: !!this.server,
+            activeSessions: this.processManager.getActiveSessions().length,
+            connectedClients: this.streamManager.getTotalClientCount()
+        });
+        if (this.routerService) {
+            await this.routerService.stop();
+        }
+        // Stop all active Claude processes (only in direct mode - daemon keeps them alive)
+        if (this.processManager.mode === 'direct') {
+            const activeSessions = this.processManager.getActiveSessions();
+            if (activeSessions.length > 0) {
+                this.logger.info(`Stopping ${activeSessions.length} active sessions...`);
+                this.logger.debug('Active sessions to stop', { sessionIds: activeSessions });
+                const stopResults = await Promise.allSettled(activeSessions.map(streamingId => this.processManager.stopConversation(streamingId)
+                    .catch(error => this.logger.error(`Error stopping session ${streamingId}:`, error))));
+                this.logger.debug('Session stop results', {
+                    total: stopResults.length,
+                    fulfilled: stopResults.filter(r => r.status === 'fulfilled').length,
+                    rejected: stopResults.filter(r => r.status === 'rejected').length
+                });
+            }
+        }
+        else {
+            this.logger.info('Daemon mode: keeping Claude processes alive through restart');
+        }
+        // Stop orphan cleanup interval
+        if (this.orphanCleanupInterval) {
+            clearInterval(this.orphanCleanupInterval);
+            this.orphanCleanupInterval = undefined;
+        }
+        // Disconnect from daemon to stop reconnection loop
+        this.processManager.disconnect();
+        // Disconnect all streaming clients (sends close events and ends responses)
+        this.logger.debug('Disconnecting all streaming clients');
+        this.streamManager.disconnectAll();
+        // Clean up MCP config
+        this.logger.debug('Cleaning up MCP config');
+        this.mcpConfigGenerator.cleanup();
+        // Close HTTP server to release port
+        if (this.server) {
+            this.logger.debug('Closing HTTP server');
+            // Force close all connections after ending SSE streams
+            // This ensures we don't wait for clients that haven't acknowledged the close
+            if (typeof this.server.closeAllConnections === 'function') {
+                this.server.closeAllConnections();
+            }
+            // Close with timeout - don't block shutdown forever
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    this.logger.warn('HTTP server close timed out after 2s, forcing shutdown');
+                    resolve();
+                }, 2000);
+                this.server.close(() => {
+                    clearTimeout(timeout);
+                    this.logger.info('HTTP server closed successfully');
+                    resolve();
+                });
+            });
+        }
+    }
+    /**
+     * Cleanup resources during failed startup
+     */
+    async cleanup() {
+        this.logger.info('Performing cleanup after startup failure...');
+        this.logger.debug('Cleanup initiated', {
+            hasServer: !!this.server,
+            hasActiveStreams: this.streamManager.getTotalClientCount() > 0
+        });
+        try {
+            // Close HTTP server if it was started
+            if (this.server) {
+                await new Promise((resolve) => {
+                    this.server.close(() => {
+                        this.logger.info('HTTP server closed during cleanup');
+                        resolve();
+                    });
+                });
+            }
+            // Disconnect streaming clients
+            this.streamManager.disconnectAll();
+            this.logger.info('Cleanup completed');
+        }
+        catch (error) {
+            this.logger.error('Error during cleanup:', error, {
+                errorType: error instanceof Error ? error.constructor.name : typeof error
+            });
+        }
+    }
+    setupMiddleware() {
+        this.app.use(createCorsMiddleware());
+        this.app.use(express.json({ limit: '10mb' }));
+        // Static file serving
+        const isDev = process.env.NODE_ENV === 'development';
+        if (!isDev) {
+            // In production/test, serve built static files
+            // In production, __dirname will be /path/to/node_modules/cui-server/dist
+            // We need to serve from dist/web
+            const staticPath = path.join(__dirname, 'web');
+            this.logger.debug('Serving static files from', { path: staticPath });
+            this.app.use(express.static(staticPath));
+        }
+        // In development, ViteExpress handles static file serving
+        // Request logging
+        this.app.use(requestLogger);
+        // Query parameter parsing - convert strings to proper types
+        this.app.use(queryParser);
+    }
+    setupRoutes() {
+        // System routes (includes health check) - before auth
+        this.app.use('/api/system', createSystemRoutes(this.processManager, this.historyReader, this.conversationStatusManager, this.streamManager));
+        this.app.use('/', createSystemRoutes(this.processManager, this.historyReader, this.conversationStatusManager, this.streamManager)); // For /health at root
+        // Permission routes (needed for MCP server communication)
+        this.app.use('/api/permissions', createPermissionRoutes(this.permissionTracker));
+        // API routes
+        // Insights routes first: has specific paths like /activity-check
+        // Conversation routes second: has /:sessionId catch-all that would match anything
+        this.app.use('/api/conversations', createInsightsRoutes(this.historyReader, this.sessionInfoService));
+        this.app.use('/api/conversations', createConversationRoutes(this.processManager, this.historyReader, this.conversationStatusManager, this.sessionInfoService, this.toolMetricsService));
+        this.app.use('/api/filesystem', createFileSystemRoutes(this.fileSystemService));
+        this.app.use('/api/logs', createLogRoutes());
+        this.app.use('/api/stream', createStreamingRoutes(this.streamManager));
+        this.app.use('/api/working-directories', createWorkingDirectoriesRoutes(this.workingDirectoriesService));
+        this.app.use('/api/config', createConfigRoutes(this.configService));
+        this.app.use('/api/questions', createQuestionRoutes(this.questionTracker, this.processManager));
+        this.app.use('/api/pending-questions', createPendingQuestionRoutes(this.pendingQuestionService, this.processManager, this.historyReader));
+        // Lattice orchestrator routes
+        const latticeService = LatticeService.getInstance({
+            processManager: this.processManager,
+            historyReader: this.historyReader,
+            statusManager: this.conversationStatusManager
+        });
+        this.app.use('/api/lattice', createLatticeRoutes(latticeService));
+        // License routes
+        this.app.use('/api/license', createLicenseRoutes());
+        // Post-session analysis routes
+        this.app.use('/api/analysis', createAnalysisRoutes());
+        // Walkthrough generation routes
+        this.app.use('/api/walkthrough', createWalkthroughRoutes({
+            historyReader: this.historyReader,
+            processManager: this.processManager,
+            streamManager: this.streamManager,
+            conversationStatusManager: this.conversationStatusManager,
+        }));
+        // Process event log routes (observability)
+        this.app.use('/api/process-events', processEventsRouter);
+        // Prototype routes (experimental features)
+        this.app.use('/api/prototype', createPrototypeRoutes());
+        // React Router catch-all - must be after all API routes
+        const isDev = process.env.NODE_ENV === 'development';
+        if (!isDev) {
+            // In production/test, serve index.html for all non-API routes
+            this.app.get('*', (req, res) => {
+                res.sendFile(path.join(__dirname, 'web', 'index.html'));
+            });
+        }
+        // In development, ViteExpress handles React routing
+        // Error handling - MUST be last
+        this.app.use(errorHandler);
+    }
+    setupProcessManagerIntegration() {
+        this.logger.debug('Setting up ProcessManager integration with StreamManager');
+        // Set up tool metrics service to listen to claude messages
+        this.toolMetricsService.listenToClaudeMessages(this.processManager);
+        // Local map to track streamingId -> sessionId (populated from system_init messages)
+        // This is a simple, reliable source of truth that doesn't depend on external services
+        const streamingSessionMap = new Map();
+        // Repopulate from daemon's active sessions on server restart
+        // This handles the case where the server restarts while sessions are still running
+        const existingMappings = this.processManager.getActiveSessionMappings();
+        for (const { streamingId, sessionId } of existingMappings) {
+            streamingSessionMap.set(streamingId, sessionId);
+        }
+        if (existingMappings.length > 0) {
+            this.logger.info('[SESSION-MAP] Repopulated from daemon active sessions', {
+                count: existingMappings.length,
+                mappings: existingMappings.map(m => ({
+                    streamingId: m.streamingId.slice(0, 8),
+                    sessionId: m.sessionId.slice(0, 8)
+                }))
+            });
+        }
+        // Start buffering events when a process spawns
+        // This handles the race condition where events are broadcast before the SSE client connects
+        this.processManager.on('process-spawned', ({ streamingId }) => {
+            this.logger.info('[BUFFERING] Process spawned, starting event buffering', { streamingId: streamingId.slice(0, 8) });
+            this.streamManager.startBuffering(streamingId);
+        });
+        // Forward Claude messages to stream
+        this.processManager.on('claude-message', ({ streamingId, message }) => {
+            this.logger.debug('Received claude-message event', {
+                streamingId,
+                messageType: message?.type,
+                messageSubtype: message?.subtype,
+                hasContent: !!message?.content,
+                contentLength: message?.content?.length || 0,
+                messageKeys: message ? Object.keys(message) : []
+            });
+            // Capture sessionId from system init messages (this is our source of truth)
+            if (message && message.type === 'system' && message.subtype === 'init' && message.session_id) {
+                streamingSessionMap.set(streamingId, message.session_id);
+                this.logger.info('[SESSION-MAP] Captured sessionId from system_init', {
+                    streamingId: streamingId.slice(0, 8),
+                    sessionId: message.session_id.slice(0, 8),
+                    mapSize: streamingSessionMap.size
+                });
+            }
+            // Skip broadcasting system init messages as they're now included in API response
+            if (message && message.type === 'system' && message.subtype === 'init') {
+                this.logger.debug('Skipping broadcast of system init message (included in API response)', {
+                    streamingId,
+                    sessionId: message.session_id
+                });
+                return;
+            }
+            // Detect AskUserQuestion tool_use and register with QuestionTracker + persist to DB
+            // Debug: log all assistant messages to see what structure we're getting
+            if (message && message.type === 'assistant') {
+                this.logger.debug('Assistant message received', {
+                    streamingId,
+                    hasMessage: !!message.message,
+                    hasContent: !!message.message?.content,
+                    contentIsArray: Array.isArray(message.message?.content),
+                    contentLength: Array.isArray(message.message?.content) ? message.message.content.length : 0
+                });
+            }
+            if (message && message.type === 'assistant' && message.message?.content) {
+                const content = message.message.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        // Debug: log each block to see tool_use blocks
+                        if (block.type === 'tool_use') {
+                            this.logger.info('Tool use block detected', {
+                                streamingId,
+                                toolName: block.name,
+                                blockId: block.id
+                            });
+                        }
+                        if (block.type === 'tool_use' && block.name === 'AskUserQuestion') {
+                            // Debug: log session state when AskUserQuestion arrives
+                            const activeSessions = this.conversationStatusManager.getActiveSessionIds();
+                            this.logger.info('AskUserQuestion detected - checking session state', {
+                                incomingStreamingId: streamingId,
+                                activeSessions,
+                                activeCount: activeSessions.length
+                            });
+                            const input = block.input;
+                            if (input.questions) {
+                                // Add to in-memory tracker (for active session UI)
+                                const questionRequest = this.questionTracker.addQuestionRequest(block.id, input.questions, streamingId);
+                                // Persist to DB (for recovery after timeout/disconnect)
+                                // Use local streamingSessionMap as primary source (populated from system_init)
+                                // Fall back to other sources if needed
+                                let claudeSessionId = streamingSessionMap.get(streamingId);
+                                if (!claudeSessionId) {
+                                    claudeSessionId = this.conversationStatusManager.getSessionId(streamingId);
+                                    if (claudeSessionId) {
+                                        this.logger.debug('Using conversationStatusManager sessionId fallback', { streamingId, claudeSessionId });
+                                    }
+                                }
+                                if (!claudeSessionId) {
+                                    claudeSessionId = this.processManager.getClaudeSessionId(streamingId);
+                                    if (claudeSessionId) {
+                                        this.logger.debug('Using processManager sessionId fallback', { streamingId, claudeSessionId });
+                                    }
+                                }
+                                if (claudeSessionId) {
+                                    this.pendingQuestionService.addQuestion(questionRequest.id, claudeSessionId, streamingId, block.id, input.questions);
+                                    this.logger.info('AskUserQuestion persisted for recovery', {
+                                        questionId: questionRequest.id,
+                                        sessionId: claudeSessionId,
+                                        streamingId,
+                                        questionCount: input.questions.length
+                                    });
+                                    // Stop the session immediately to prevent Claude from continuing
+                                    // The session will be resumed when the user answers the question
+                                    this.logger.info('Stopping session to await user answer', { streamingId, claudeSessionId });
+                                    this.processManager.stopConversation(streamingId).catch((err) => {
+                                        this.logger.warn('Failed to stop session after AskUserQuestion', {
+                                            streamingId,
+                                            error: err instanceof Error ? err.message : String(err)
+                                        });
+                                    });
+                                }
+                                else {
+                                    this.logger.warn('AskUserQuestion NOT persisted - claudeSessionId not found for streamingId', {
+                                        questionId: questionRequest.id,
+                                        streamingId,
+                                        questionCount: input.questions.length,
+                                        activeSessionCount: this.conversationStatusManager.getActiveSessionIds().length
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Stream other Claude messages as normal
+            this.logger.debug('Broadcasting message to StreamManager', {
+                streamingId,
+                messageType: message?.type,
+                messageSubtype: message?.subtype
+            });
+            this.streamManager.broadcast(streamingId, message);
+        });
+        // Handle process closure
+        this.processManager.on('process-closed', ({ streamingId, code }) => {
+            // Derive termination reason from exit code
+            const terminationReason = code === 0 ? 'normal_completion' :
+                code === 143 ? 'user_stop' : // SIGTERM = 128 + 15
+                    code === 137 ? 'force_killed' : // SIGKILL = 128 + 9
+                        'process_crash';
+            this.logger.info('[PROCESS-CLOSED] Received process-closed event', {
+                streamingId: streamingId.slice(0, 8),
+                exitCode: code,
+                terminationReason,
+                clientCount: this.streamManager.getClientCount(streamingId),
+                wasSuccessful: code === 0
+            });
+            // Capture turn BEFORE cleaning up (need sessionId from map)
+            // Use local streamingSessionMap as primary source (populated from system_init)
+            // Fall back to conversationStatusManager if map is empty (e.g., after server restart)
+            let sessionIdForTurn = streamingSessionMap.get(streamingId);
+            if (!sessionIdForTurn) {
+                sessionIdForTurn = this.conversationStatusManager.getSessionId(streamingId);
+                if (sessionIdForTurn) {
+                    this.logger.debug('[TURN-CAPTURE] Used fallback sessionId from conversationStatusManager', {
+                        streamingId: streamingId.slice(0, 8),
+                        sessionId: sessionIdForTurn.slice(0, 8)
+                    });
+                }
+            }
+            if (sessionIdForTurn) {
+                // Fire and forget - don't block cleanup on turn capture
+                this.turnCaptureService.captureTurn(sessionIdForTurn, code, terminationReason)
+                    .then(turn => {
+                    if (turn) {
+                        // Emit SSE event for real-time UI updates
+                        import('./services/sessions/session-activity-watcher.js').then(({ getSessionActivityWatcher }) => {
+                            getSessionActivityWatcher().emitTurnCaptured({
+                                sessionId: sessionIdForTurn,
+                                turn: {
+                                    id: turn.id,
+                                    turnNumber: turn.turnNumber,
+                                    timestamp: turn.timestamp,
+                                    headline: turn.headline,
+                                    actions: turn.actions,
+                                    tag: turn.tag,
+                                    icon: turn.icon,
+                                    toolCount: turn.toolCount,
+                                }
+                            });
+                        });
+                    }
+                })
+                    .catch(err => {
+                    this.logger.debug('Turn capture failed (non-blocking)', { error: err });
+                });
+            }
+            else {
+                this.logger.warn('[TURN-CAPTURE] Could not find sessionId for turn capture', {
+                    streamingId: streamingId.slice(0, 8),
+                    exitCode: code,
+                    terminationReason,
+                    mapSize: streamingSessionMap.size
+                });
+            }
+            // Check for pending questions BEFORE unregistering (we need the sessionId mapping)
+            // If there are pending questions, this was likely an AskUserQuestion timeout
+            const pendingQuestions = this.pendingQuestionService.getPendingByStreamingId(streamingId);
+            if (pendingQuestions.length > 0) {
+                this.logger.info('Session closed with pending AskUserQuestion - questions preserved for later resume', {
+                    streamingId,
+                    pendingQuestionCount: pendingQuestions.length,
+                    questionIds: pendingQuestions.map(q => q.id)
+                });
+                // Questions remain in DB with status='pending' for later retrieval
+                // The in-memory tracker will be cleaned up below, but DB persists
+            }
+            // Clean up local session map
+            streamingSessionMap.delete(streamingId);
+            // Unregister session from status tracker
+            this.logger.debug('Unregistering session from status tracker', { streamingId });
+            this.conversationStatusManager.unregisterActiveSession(streamingId);
+            // Clean up conversation context (handled automatically in unregisterActiveSession)
+            // Clean up permissions for this streaming session
+            const removedCount = this.permissionTracker.removePermissionsByStreamingId(streamingId);
+            if (removedCount > 0) {
+                this.logger.debug('Cleaned up permissions for closed session', {
+                    streamingId,
+                    removedPermissions: removedCount
+                });
+            }
+            // Check for in-memory questions BEFORE removing them
+            // If there are pending questions, we need to keep them for error suppression
+            // They'll be cleaned up when answered or expired, not on session close
+            const inMemoryQuestions = this.questionTracker.getQuestionsByStreamingId(streamingId);
+            if (inMemoryQuestions.length > 0) {
+                this.logger.info('Preserving in-memory questions for error suppression (awaiting user answer)', {
+                    streamingId,
+                    inMemoryQuestionCount: inMemoryQuestions.length,
+                    questionIds: inMemoryQuestions.map(q => q.id)
+                });
+            }
+            else {
+                // No pending questions - safe to clean up
+                const removedQuestions = this.questionTracker.removeQuestionsByStreamingId(streamingId);
+                if (removedQuestions > 0) {
+                    this.logger.debug('Cleaned up in-memory questions for closed session', {
+                        streamingId,
+                        removedQuestions
+                    });
+                }
+            }
+            this.streamManager.closeSession(streamingId);
+        });
+        // Handle process errors
+        this.processManager.on('process-error', ({ streamingId, error }) => {
+            this.logger.info('[PROCESS-ERROR] Received process-error event', {
+                streamingId: streamingId.slice(0, 8),
+                error: error?.toString().slice(0, 200),
+                clientCount: this.streamManager.getClientCount(streamingId)
+            });
+            // Check if there's a pending question for this streaming session
+            // If so, suppress the error - the session was intentionally stopped to wait for user answer
+            const pendingQuestions = this.questionTracker.getQuestionsByStreamingId(streamingId);
+            if (pendingQuestions.length > 0) {
+                this.logger.info('Suppressing process error due to pending AskUserQuestion', {
+                    streamingId,
+                    pendingQuestionCount: pendingQuestions.length,
+                    questionIds: pendingQuestions.map(q => q.id)
+                });
+                // Still unregister the session but don't broadcast the error
+                this.conversationStatusManager.unregisterActiveSession(streamingId);
+                return;
+            }
+            // Unregister session from status tracker on error
+            this.logger.debug('Unregistering session from status tracker due to error', { streamingId });
+            this.conversationStatusManager.unregisterActiveSession(streamingId);
+            // Clean up conversation context on error (handled automatically in unregisterActiveSession)
+            const errorEvent = {
+                type: 'error',
+                error: error.toString(),
+                streamingId: streamingId,
+                timestamp: new Date().toISOString()
+            };
+            this.logger.debug('Broadcasting error event to clients', {
+                streamingId,
+                errorEventKeys: Object.keys(errorEvent)
+            });
+            this.streamManager.broadcast(streamingId, errorEvent);
+        });
+        // Start periodic cleanup of orphaned SSE sessions (every 60 seconds)
+        // This catches edge cases where process-closed event didn't fire or was missed
+        this.orphanCleanupInterval = setInterval(() => {
+            const activeProcessIds = new Set(this.processManager.getActiveSessions());
+            const cleaned = this.streamManager.cleanupOrphanedSessions(activeProcessIds);
+            if (cleaned > 0) {
+                this.logger.info('Periodic orphan cleanup removed stale SSE sessions', { count: cleaned });
+            }
+        }, 60_000);
+        this.logger.debug('ProcessManager integration setup complete', {
+            totalEventListeners: this.processManager.listenerCount('claude-message') +
+                this.processManager.listenerCount('process-closed') +
+                this.processManager.listenerCount('process-error')
+        });
+    }
+    setupPermissionTrackerIntegration() {
+        this.logger.debug('Setting up PermissionTracker integration');
+        // Forward permission events to stream
+        this.permissionTracker.on('permission_request', (request) => {
+            this.logger.debug('Permission request event received', {
+                id: request.id,
+                toolName: request.toolName,
+                streamingId: request.streamingId
+            });
+            // Broadcast to the appropriate streaming session
+            if (request.streamingId && request.streamingId !== 'unknown') {
+                const event = {
+                    type: 'permission_request',
+                    data: request,
+                    streamingId: request.streamingId,
+                    timestamp: new Date().toISOString()
+                };
+                this.streamManager.broadcast(request.streamingId, event);
+            }
+        });
+        this.logger.debug('PermissionTracker integration setup complete');
+    }
+    setupQuestionTrackerIntegration() {
+        this.logger.debug('Setting up QuestionTracker integration');
+        // Forward question events to stream
+        this.questionTracker.on('question_request', (request) => {
+            // Log at info level to diagnose question flow issues
+            this.logger.info('Question request event received, broadcasting to stream', {
+                id: request.id,
+                toolUseId: request.toolUseId,
+                streamingId: request.streamingId,
+                questionCount: request.questions.length,
+                clientCount: this.streamManager.getClientCount(request.streamingId)
+            });
+            // Broadcast to the appropriate streaming session
+            if (request.streamingId && request.streamingId !== 'unknown') {
+                const event = {
+                    type: 'question_request',
+                    data: request,
+                    streamingId: request.streamingId,
+                    timestamp: new Date().toISOString()
+                };
+                this.streamManager.broadcast(request.streamingId, event);
+            }
+        });
+        this.logger.debug('QuestionTracker integration setup complete');
+    }
+    async initializeOrReloadRouter(config) {
+        // If router is disabled, ensure it is stopped
+        if (!config.router?.enabled) {
+            if (this.routerService) {
+                this.logger.info('Router disabled in configuration, stopping router service');
+                await this.routerService.stop();
+                this.routerService = undefined;
+                this.processManager.setRouterService(undefined);
+            }
+            else {
+                this.logger.info('Router service is disabled');
+            }
+            return;
+        }
+        // If router is enabled
+        try {
+            // If there is an existing router, stop it first
+            if (this.routerService) {
+                this.logger.info('Reloading router service due to configuration change...');
+                await this.routerService.stop();
+                this.routerService = undefined;
+            }
+            else {
+                this.logger.debug('Router service is enabled, attempting to initialize...');
+            }
+            this.routerService = new ClaudeRouterService(config.router);
+            await this.routerService.initialize();
+            this.processManager.setRouterService(this.routerService);
+            this.logger.info('Router service initialized');
+        }
+        catch (error) {
+            this.logger.error('Router initialization failed, continuing without router', error);
+        }
+    }
+}
+//# sourceMappingURL=lattice-server.js.map