dominds 0.1.0

package/dist/server/websocket-handler.js

@@ -0,0 +1,1011 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWebSocketMessage = handleWebSocketMessage;
+exports.setupWebSocketServer = setupWebSocketServer;
+exports.cleanupEventSystems = cleanupEventSystems;
+const ws_1 = require("ws");
+const dialog_1 = require("../dialog");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const dialog_instance_registry_1 = require("../dialog-instance-registry");
+const dialog_run_state_1 = require("../dialog-run-state");
+const evt_registry_1 = require("../evt-registry");
+const driver_1 = require("../llm/driver");
+const log_1 = require("../log");
+const persistence_1 = require("../persistence");
+const problems_1 = require("../problems");
+const diligence_1 = require("../shared/diligence");
+const evt_1 = require("../shared/evt");
+const runtime_language_1 = require("../shared/runtime-language");
+const language_1 = require("../shared/types/language");
+const time_1 = require("../shared/utils/time");
+const team_1 = require("../team");
+const id_1 = require("../utils/id");
+const task_package_1 = require("../utils/task-package");
+const auth_1 = require("./auth");
+function resolveMemberDiligencePushMax(team, agentId) {
+    const member = team.getMember(agentId);
+    if (member && member.diligence_push_max !== undefined) {
+        return member.diligence_push_max;
+    }
+    return diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+}
+const log = (0, log_1.createLogger)('websocket-handler');
+const wsLiveDlg = new WeakMap();
+const wsSub = new WeakMap();
+const wsUiLanguage = new WeakMap();
+let broadcastDialogsIndexMessage = null;
+function resolveUserLanguageCode(ws, raw, fallbackDialog) {
+    if (typeof raw === 'string') {
+        const parsed = (0, language_1.normalizeLanguageCode)(raw);
+        if (parsed)
+            return parsed;
+    }
+    const fromWs = wsUiLanguage.get(ws);
+    if (fromWs)
+        return fromWs;
+    if (fallbackDialog)
+        return fallbackDialog.getLastUserLanguageCode();
+    return (0, runtime_language_1.getWorkLanguage)();
+}
+/**
+ * Get error code from unknown error
+ */
+function getErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const maybeCode = error.code;
+    return typeof maybeCode === 'string' ? maybeCode : undefined;
+}
+/**
+ * Cleanup WebSocket client: cancel active forwarder and clear live dialog state
+ */
+function cleanupWsClient(ws) {
+    const existingSub = wsSub.get(ws);
+    if (existingSub) {
+        try {
+            existingSub.subChan.cancel();
+        }
+        catch (err) {
+            log.warn('Failed to cancel forwarder on cleanupWsClient', err);
+        }
+        wsSub.delete(ws);
+    }
+    wsLiveDlg.delete(ws);
+    wsUiLanguage.delete(ws);
+}
+/**
+ * Setup WebSocket subscription for real-time dialog events
+ * Ensures only one subscription per WebSocket connection
+ */
+async function setupWebSocketSubscription(ws, dialog) {
+    // Cancel any existing subscription
+    const existingSub = wsSub.get(ws);
+    if (existingSub) {
+        try {
+            existingSub.subChan.cancel();
+        }
+        catch (err) {
+            log.warn('Failed to cancel existing subscription', undefined, err);
+        }
+    }
+    // Store dialog in wsLiveDlg
+    wsLiveDlg.set(ws, dialog);
+    // Create new subscription for real-time events
+    const subChan = evt_registry_1.dialogEventRegistry.createSubChan(dialog.id);
+    wsSub.set(ws, { dialogKey: dialog.id.valueOf(), subChan });
+    // Forward events from SubChan to WebSocket
+    (async () => {
+        try {
+            for await (const event of subChan.stream()) {
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(event));
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            if (err !== evt_1.EndOfStream) {
+                log.warn(`Event forwarding error for dialog ${dialog.id.selfId}:`, err);
+            }
+        }
+    })().catch((err) => {
+        log.warn(`Event forwarding task failed for dialog ${dialog.id.selfId}:`, err);
+    });
+}
+/**
+ * Handle incoming WebSocket messages
+ */
+async function handleWebSocketMessage(ws, packet) {
+    try {
+        switch (packet.type) {
+            case 'set_ui_language':
+                await handleSetUiLanguage(ws, packet);
+                break;
+            case 'get_problems':
+                await handleGetProblems(ws, packet);
+                break;
+            case 'create_dialog':
+                await handleCreateDialog(ws, packet);
+                break;
+            case 'display_dialog':
+                await handleDisplayDialog(ws, packet);
+                break;
+            case 'set_diligence_push':
+                await handleSetDiligencePush(ws, packet);
+                break;
+            case 'get_q4h_state':
+                await handleGetQ4HState(ws, packet);
+                break;
+            case 'display_reminders':
+                await handleDisplayReminders(ws, packet);
+                break;
+            case 'display_round':
+                await handleDisplayRound(ws, packet);
+                break;
+            case 'drive_dlg_by_user_msg':
+                await handleUserMsg2Dlg(ws, packet);
+                break;
+            case 'drive_dialog_by_user_answer':
+                await handleUserAnswer2Q4H(ws, packet);
+                break;
+            case 'interrupt_dialog':
+                await handleInterruptDialog(ws, packet);
+                break;
+            case 'emergency_stop':
+                await handleEmergencyStop(ws, packet);
+                break;
+            case 'resume_dialog':
+                await handleResumeDialog(ws, packet);
+                break;
+            case 'resume_all':
+                await handleResumeAll(ws, packet);
+                break;
+            default:
+                log.warn('Unknown WebSocket packet type:', undefined, packet.type);
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    message: `Unknown packet type: ${packet.type}`,
+                }));
+        }
+    }
+    catch (error) {
+        log.error('Error processing WebSocket packet:', error);
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }));
+    }
+}
+async function handleSetDiligencePush(ws, packet) {
+    try {
+        const { dialog, disableDiligencePush } = packet;
+        if (!isRecord(dialog)) {
+            ws.send(JSON.stringify({ type: 'error', message: 'dialog is required' }));
+            return;
+        }
+        const selfId = typeof dialog.selfId === 'string' ? dialog.selfId : null;
+        const rootId = typeof dialog.rootId === 'string' ? dialog.rootId : null;
+        if (!selfId || !rootId) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'Invalid dialog identifiers for set_diligence_push: selfId/rootId must be strings',
+            }));
+            return;
+        }
+        if (typeof disableDiligencePush !== 'boolean') {
+            ws.send(JSON.stringify({ type: 'error', message: 'disableDiligencePush must be a boolean' }));
+            return;
+        }
+        const dialogIdObj = new dialog_1.DialogID(selfId, rootId);
+        // Locate dialog status (running/completed/archived) for persistence.
+        const statuses = [
+            'running',
+            'completed',
+            'archived',
+        ];
+        let foundStatus = null;
+        for (const status of statuses) {
+            const meta = await persistence_1.DialogPersistence.loadDialogMetadata(dialogIdObj, status);
+            if (!meta)
+                continue;
+            foundStatus = status;
+            break;
+        }
+        if (!foundStatus) {
+            ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogIdObj.valueOf()} not found` }));
+            return;
+        }
+        await persistence_1.DialogPersistence.mutateDialogLatest(dialogIdObj, (previous) => ({
+            kind: 'patch',
+            patch: { disableDiligencePush },
+        }), foundStatus);
+        // Update live in-memory instance if it's loaded.
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, foundStatus);
+        if (rootDialog) {
+            const target = dialogIdObj.selfId === dialogIdObj.rootId
+                ? rootDialog
+                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, foundStatus);
+            if (target) {
+                target.disableDiligencePush = disableDiligencePush;
+            }
+        }
+        const msg = {
+            type: 'diligence_push_updated',
+            dialog: { selfId, rootId },
+            disableDiligencePush,
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        };
+        ws.send(JSON.stringify(msg));
+    }
+    catch (error) {
+        log.warn('Failed to handle set_diligence_push', error);
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: error instanceof Error ? error.message : 'Unknown error updating diligence push setting',
+        }));
+    }
+}
+async function handleGetProblems(ws, packet) {
+    if (packet.type !== 'get_problems') {
+        throw new Error('Internal error: handleGetProblems called with non get_problems packet');
+    }
+    const _req = packet;
+    ws.send(JSON.stringify((0, problems_1.createProblemsSnapshotMessage)()));
+}
+async function handleSetUiLanguage(ws, packet) {
+    if (packet.type !== 'set_ui_language') {
+        throw new Error('Internal error: handleSetUiLanguage called with non set_ui_language packet');
+    }
+    const raw = packet.uiLanguage;
+    if (typeof raw !== 'string') {
+        ws.send(JSON.stringify({ type: 'error', message: 'uiLanguage must be a string' }));
+        return;
+    }
+    const parsed = (0, language_1.normalizeLanguageCode)(raw);
+    if (!parsed) {
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: `Unsupported uiLanguage '${raw}'. Supported: ${language_1.supportedLanguageCodes.join(', ')}`,
+        }));
+        return;
+    }
+    wsUiLanguage.set(ws, parsed);
+    ws.send(JSON.stringify({ type: 'ui_language_set', uiLanguage: parsed }));
+}
+/**
+ * Handle dialog creation via WebSocket
+ */
+async function handleCreateDialog(ws, packet) {
+    try {
+        const { agentId, taskDocPath } = packet;
+        // Validate that taskDocPath is provided (it's now mandatory)
+        if (!taskDocPath || taskDocPath.trim() === '') {
+            throw new Error('Task Doc path is required for creating a dialog');
+        }
+        if (!(0, task_package_1.isTaskPackagePath)(taskDocPath)) {
+            throw new Error(`Task Doc must be a directory ending in '.tsk' (got: '${taskDocPath}')`);
+        }
+        // Auto-fill default_responder if no agentId provided
+        let finalAgentId = agentId;
+        if (!finalAgentId) {
+            try {
+                const teamConfig = await team_1.Team.load();
+                const def = teamConfig.getDefaultResponder();
+                finalAgentId = def ? def.id : undefined;
+            }
+            catch (error) {
+                throw new Error(`Failed to load team configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        if (!finalAgentId) {
+            throw new Error('No team members available to create a dialog');
+        }
+        const generatedId = (0, id_1.generateDialogID)();
+        // For root dialogs, self and root are the same
+        const dialogId = new dialog_1.DialogID(generatedId);
+        // Import Dialog and DiskFileDialogStore
+        // Create DiskFileDialogStore for file-based persistence
+        const dialogUI = new persistence_1.DiskFileDialogStore(dialogId);
+        // Create RootDialog instance with the new store
+        const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, finalAgentId);
+        dialog_global_registry_1.globalDialogRegistry.register(dialog);
+        // Setup WebSocket subscription for real-time events
+        await setupWebSocketSubscription(ws, dialog);
+        // Persist dialog metadata and latest.yaml (write-once pattern)
+        const metadata = {
+            id: dialogId.selfId,
+            agentId: finalAgentId,
+            taskDocPath: taskDocPath,
+            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        };
+        await persistence_1.DialogPersistence.saveDialogMetadata(new dialog_1.DialogID(dialogId.selfId), metadata);
+        // Initialize latest.yaml via the mutation API (write-back will flush).
+        await persistence_1.DialogPersistence.mutateDialogLatest(new dialog_1.DialogID(dialogId.selfId), () => ({
+            kind: 'replace',
+            next: {
+                currentRound: 1,
+                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                status: 'active',
+                messageCount: 0,
+                functionCallCount: 0,
+                subdialogCount: 0,
+                runState: { kind: 'idle_waiting_user' },
+                disableDiligencePush: false,
+            },
+        }));
+        // Send dialog_ready with full info so frontend can track the active dialog
+        const team = await team_1.Team.load();
+        const response = {
+            type: 'dialog_ready',
+            dialog: {
+                selfId: dialogId.selfId,
+                rootId: dialogId.rootId,
+            },
+            agentId: finalAgentId,
+            taskDocPath: taskDocPath,
+            disableDiligencePush: false,
+            diligencePushMax: resolveMemberDiligencePushMax(team, finalAgentId),
+        };
+        ws.send(JSON.stringify(response));
+        broadcastDialogsIndexMessage?.({
+            type: 'dialogs_created',
+            scope: { kind: 'root', rootId: dialogId.selfId },
+            status: 'running',
+            createdRootIds: [dialogId.selfId],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+    }
+    catch (error) {
+        log.warn('Failed to create dialog', undefined, error);
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: error instanceof Error ? error.message : 'Unknown error creating dialog',
+        }));
+    }
+}
+/**
+ * Handle dialog retrieval via WebSocket
+ */
+async function handleDisplayDialog(ws, packet) {
+    try {
+        const { dialog: dialogIdent } = packet;
+        if (!dialogIdent) {
+            throw new Error('dialog is required');
+        }
+        // Extract dialog ID from DialogIdent
+        let dialogId = dialogIdent.selfId;
+        let rootDialogId = dialogIdent.rootId;
+        // Handle case where dialogIdent properties might be objects instead of strings
+        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'Invalid dialog identifiers for display_dialog: selfId/rootId must be strings',
+            }));
+            return;
+        }
+        // IMPORTANT: cancel any existing event forwarder before emitting restoration events.
+        // Otherwise, the same client can receive overlapping "replay" and "live" streams,
+        // which surfaces as duplicate generation lifecycle events on the frontend.
+        const existing = wsLiveDlg.get(ws);
+        if (existing) {
+            const existingId = existing.id;
+            const isSameDialog = existingId.selfId === dialogId && existingId.rootId === rootDialogId;
+            if (isSameDialog) {
+                log.warn('display_dialog: refreshing the same dialog; cancelling existing subscription to prevent duplicate stream events', undefined, { dialogId, rootDialogId });
+            }
+            else {
+                log.debug('display_dialog: switching dialogs; cancelling previous subscription', undefined, {
+                    previousDialogId: existingId.valueOf(),
+                    nextDialogId: new dialog_1.DialogID(dialogId, rootDialogId).valueOf(),
+                });
+            }
+            cleanupWsClient(ws);
+        }
+        const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+        const statuses = [
+            'running',
+            'completed',
+            'archived',
+        ];
+        let foundStatus = null;
+        let dialogState = null;
+        let metadata = null;
+        for (const status of statuses) {
+            const state = await persistence_1.DialogPersistence.restoreDialog(dialogIdObj, status);
+            if (!state)
+                continue;
+            const meta = await persistence_1.DialogPersistence.loadDialogMetadata(dialogIdObj, status);
+            if (!meta)
+                continue;
+            foundStatus = status;
+            dialogState = state;
+            metadata = meta;
+            break;
+        }
+        if (!foundStatus || !dialogState || !metadata) {
+            throw new Error('Dialog not found');
+        }
+        const decidedRound = (await persistence_1.DialogPersistence.getCurrentRoundNumber(dialogIdObj, foundStatus)) ||
+            (dialogState.currentRound ?? 1);
+        const enableLive = foundStatus === 'running';
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, foundStatus);
+        if (!rootDialog) {
+            throw new Error('Root dialog not found');
+        }
+        if (enableLive) {
+            dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        }
+        let dialog;
+        if (dialogIdObj.selfId === dialogIdObj.rootId) {
+            dialog = rootDialog;
+        }
+        else {
+            const loaded = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, foundStatus);
+            if (!loaded) {
+                throw new Error('Dialog not found');
+            }
+            dialog = loaded;
+        }
+        // CRITICAL FIX: Send dialog events directly to requesting WebSocket only
+        // This bypasses PubChan to ensure only the requesting session receives restoration events
+        // Pass decidedRound explicitly since dialog.currentRound defaults to 1 for new Dialog objects
+        try {
+            const dialogStore = dialog.dlgStore;
+            if (dialogStore instanceof persistence_1.DiskFileDialogStore) {
+                await dialogStore.sendDialogEventsDirectly(ws, dialog, decidedRound, decidedRound, foundStatus);
+            }
+            else {
+                throw new Error('Unexpected dialog store type for sendDialogEventsDirectly');
+            }
+        }
+        catch (err) {
+            log.warn(`Failed to send dialog events directly for ${dialogId}:`, err);
+        }
+        // Always subscribe for future realtime events (including cross-client revival + continued drive).
+        // Live generation is still gated by dialog.status ('running') in drive handlers.
+        await setupWebSocketSubscription(ws, dialog);
+        // Send dialog_ready with full info so frontend knows the current dialog ID
+        const team = await team_1.Team.load();
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogIdObj, foundStatus);
+        const dialogReadyResponse = {
+            type: 'dialog_ready',
+            dialog: {
+                selfId: dialogId,
+                rootId: rootDialogId,
+            },
+            agentId: metadata.agentId,
+            taskDocPath: metadata.taskDocPath,
+            supdialogId: metadata.supdialogId,
+            tellaskSession: metadata.tellaskSession,
+            assignmentFromSup: metadata.assignmentFromSup,
+            disableDiligencePush: latest?.disableDiligencePush ?? false,
+            diligencePushMax: resolveMemberDiligencePushMax(team, metadata.agentId),
+        };
+        ws.send(JSON.stringify(dialogReadyResponse));
+        // Send authoritative run state for this dialog so the client can render Send↔Stop and Continue.
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogIdObj, foundStatus);
+            const runState = latest?.runState ??
+                (foundStatus === 'running'
+                    ? { kind: 'idle_waiting_user' }
+                    : foundStatus === 'completed'
+                        ? { kind: 'terminal', status: 'completed' }
+                        : { kind: 'terminal', status: 'archived' });
+            const runStateEvt = evt_registry_1.dialogEventRegistry.createTypedEvent(dialogIdObj, {
+                type: 'dlg_run_state_evt',
+                runState,
+            });
+            ws.send(JSON.stringify(runStateEvt));
+        }
+        catch (err) {
+            log.warn(`Failed to send dlg_run_state_evt for ${dialogIdObj.valueOf()}:`, err);
+        }
+        // Emit Q4H state to ensure frontend has current questions count
+        // Load Q4H from ALL running dialogs for global display (not just this dialog)
+        try {
+            const allQuestions = await persistence_1.DialogPersistence.loadAllQ4HState();
+            // Emit new_q4h_asked events for each question (best-effort sync on dialog display).
+            // Include full dialog context (selfId/rootId/agentId/taskDocPath) so the frontend can
+            // render origin info without relying on additional lookups.
+            for (const q of allQuestions) {
+                const newQ4HEvent = {
+                    type: 'new_q4h_asked',
+                    question: {
+                        id: q.id,
+                        kind: q.kind,
+                        selfId: q.selfId,
+                        rootId: q.rootId,
+                        agentId: q.agentId,
+                        taskDocPath: q.taskDocPath,
+                        headLine: q.headLine,
+                        bodyContent: q.bodyContent,
+                        askedAt: q.askedAt,
+                        callSiteRef: q.callSiteRef,
+                    },
+                };
+                ws.send(JSON.stringify(newQ4HEvent));
+            }
+        }
+        catch (err) {
+            log.warn(`Failed to emit Q4H state for ${dialogIdObj}:`, err);
+        }
+        // Proactively emit reminders for the newly active dialog
+        // todo: maybe emit only to the requestiong websocket, not publish via PubChan as curr impl
+        try {
+            await dialog.processReminderUpdates();
+        }
+        catch (err) {
+            log.warn(`Failed to emit proactive reminders for ${dialogIdObj}:`, err);
+        }
+    }
+    catch (error) {
+        log.warn('Failed to handle display_dialog', error);
+    }
+}
+/**
+ * Handle Q4H state request via WebSocket
+ * Fetches Q4H questions from ALL running dialogs for global display
+ */
+async function handleGetQ4HState(ws, _packet) {
+    try {
+        // Load Q4H from all running dialogs
+        const allQuestions = await persistence_1.DialogPersistence.loadAllQ4HState();
+        // Transform to wire `Q4HStateResponse` question entries.
+        // `selfId` + `rootId` uniquely identify the originating dialog (including subdialogs).
+        const questions = allQuestions.map((q) => ({
+            id: q.id,
+            kind: q.kind,
+            selfId: q.selfId,
+            rootId: q.rootId,
+            agentId: q.agentId,
+            taskDocPath: q.taskDocPath,
+            headLine: q.headLine,
+            bodyContent: q.bodyContent,
+            askedAt: q.askedAt,
+            callSiteRef: q.callSiteRef,
+        }));
+        // Send single response packet with all questions (not PubChan events)
+        const response = {
+            type: 'q4h_state_response',
+            questions,
+        };
+        ws.send(JSON.stringify(response));
+    }
+    catch (error) {
+        log.warn('Failed to handle get_q4h_state', error);
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: error instanceof Error ? error.message : 'Unknown error getting Q4H state',
+        }));
+    }
+}
+async function handleDisplayReminders(ws, packet) {
+    try {
+        const live = wsLiveDlg.get(ws);
+        if (!live) {
+            log.warn('No live dialog found for display_reminders');
+            return;
+        }
+        if (live.id.selfId !== packet.dialog.selfId) {
+            log.warn(`Dialog ${packet.dialog} for reminders is not current live (live dialog is ${live.id})`);
+            return;
+        }
+        await live.processReminderUpdates();
+    }
+    catch (error) {
+        log.warn('Failed to display reminders', error);
+    }
+}
+async function handleDisplayRound(ws, packet) {
+    try {
+        const { dialog, round } = packet;
+        if (!dialog || typeof round !== 'number') {
+            throw new Error('dialog and round are required');
+        }
+        // Extract dialog ID from DialogIdent
+        let dialogIdStr = dialog.selfId;
+        let rootDialogIdStr = dialog.rootId;
+        // Handle case where dialog properties might be objects instead of strings
+        if (typeof dialogIdStr !== 'string' || typeof rootDialogIdStr !== 'string') {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'Invalid dialog identifiers for display_round: selfId/rootId must be strings',
+            }));
+            return;
+        }
+        const dialogId = new dialog_1.DialogID(dialogIdStr, rootDialogIdStr);
+        try {
+            const statuses = [
+                'running',
+                'completed',
+                'archived',
+            ];
+            let foundStatus = null;
+            let metadata = null;
+            for (const status of statuses) {
+                const meta = await persistence_1.DialogPersistence.loadDialogMetadata(dialogId, status);
+                if (!meta)
+                    continue;
+                foundStatus = status;
+                metadata = meta;
+                break;
+            }
+            if (!foundStatus || !metadata) {
+                log.warn('Metadata not found for display_round', undefined, { dialogId: dialogId.selfId });
+                return;
+            }
+            const totalRounds = (await persistence_1.DialogPersistence.getCurrentRoundNumber(dialogId, foundStatus)) || round;
+            const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogId.rootId, foundStatus);
+            if (!rootDialog)
+                return;
+            const dialog = dialogId.selfId === dialogId.rootId
+                ? rootDialog
+                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogId, foundStatus);
+            if (!dialog)
+                return;
+            const store = dialog.dlgStore;
+            if (!(store instanceof persistence_1.DiskFileDialogStore)) {
+                throw new Error('Unexpected dialog store type for display_round');
+            }
+            // Send the requested round's persisted events directly to this WebSocket.
+            // This is a UI navigation operation; do not emit via PubChan.
+            await store.sendDialogEventsDirectly(ws, dialog, round, totalRounds, foundStatus);
+        }
+        catch (err) {
+            log.warn('Failed to send dialog events for display_round', err);
+        }
+    }
+    catch (error) {
+        log.warn('Failed to handle display_round', error);
+    }
+}
+/**
+ * Handle message sending via WebSocket
+ */
+async function handleUserMsg2Dlg(ws, packet) {
+    try {
+        const { dialog: dialogIdent, content, msgId } = packet;
+        const userLanguageCode = resolveUserLanguageCode(ws, packet.userLanguageCode);
+        // Basic validation
+        if (!dialogIdent || !content || !msgId) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'dialog, content, and msgId are required',
+            }));
+            return;
+        }
+        // Extract dialog ID from DialogIdent
+        const dialogId = dialogIdent.selfId;
+        const rootDialogId = dialogIdent.rootId;
+        // Validate dialog identifiers
+        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'Invalid dialog identifiers for drive_dlg_by_user_msg: selfId/rootId must be strings',
+            }));
+            return;
+        }
+        // If the dialog is already active for this WebSocket, runnable (status === 'running'),
+        // and has an event forwarder (subChan),
+        // drive it directly to preserve in-memory state (pending subdialogs, teammate tellask tracking, etc).
+        //
+        // IMPORTANT: do not drive a view-only dialog instance here. When users browse a completed/archived
+        // dialog, handleDisplayDialog restores it with dialog.status set to completed/archived. If that
+        // dialog is later revived to running by another client, the UI may re-enable input without
+        // re-issuing display_dialog. In that case, we must restore from running rather than driving the
+        // cached view-only dialog (stale state, wrong hydration, etc).
+        const existingDialog = wsLiveDlg.get(ws);
+        const existingSub = wsSub.get(ws);
+        if (existingDialog &&
+            existingDialog.id.selfId === dialogId &&
+            existingDialog.id.rootId === rootDialogId &&
+            existingDialog.status === 'running' &&
+            existingSub &&
+            existingSub.dialogKey === existingDialog.id.valueOf()) {
+            await (0, driver_1.driveDialogStream)(existingDialog, { content, msgId, grammar: 'tellask', userLanguageCode }, true);
+            return;
+        }
+        // Dialog not found in wsLiveDlg - drive using the canonical root/subdialog instances.
+        // This supports driving subdialogs and cross-client revival without creating duplicate dialog objects.
+        try {
+            const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+            const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, 'running');
+            if (!rootDialog) {
+                ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
+                return;
+            }
+            dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+            const dialog = dialogIdObj.selfId === dialogIdObj.rootId
+                ? rootDialog
+                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, 'running');
+            if (!dialog) {
+                ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
+                return;
+            }
+            await setupWebSocketSubscription(ws, dialog);
+            await (0, driver_1.driveDialogStream)(dialog, { content, msgId, grammar: 'tellask', userLanguageCode }, true);
+            return;
+        }
+        catch (restoreError) {
+            log.warn('Failed to restore dialog for message:', restoreError);
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: `Cannot send message to dialog ${dialogId}: dialog is not the currently active dialog and could not be restored`,
+            }));
+            return;
+        }
+    }
+    catch (error) {
+        // Log the error at warning level in the backend console
+        log.warn(`Failed to drive dialog ${packet?.dialog?.selfId} with user message: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
+        // Send error response to client
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: `Failed to process message: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        }));
+    }
+}
+async function restoreDialogForDrive(dialogIdObj, status) {
+    const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, status);
+    if (!rootDialog) {
+        throw new Error(`Dialog ${dialogIdObj.valueOf()} not found`);
+    }
+    dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+    if (dialogIdObj.selfId === dialogIdObj.rootId) {
+        return rootDialog;
+    }
+    const sub = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, status);
+    if (!sub) {
+        throw new Error(`Dialog ${dialogIdObj.valueOf()} not found`);
+    }
+    return sub;
+}
+async function handleInterruptDialog(ws, packet) {
+    if (packet.type !== 'interrupt_dialog') {
+        throw new Error('Internal error: handleInterruptDialog called with non interrupt_dialog packet');
+    }
+    const dialog = packet.dialog;
+    if (!dialog || typeof dialog.selfId !== 'string' || typeof dialog.rootId !== 'string') {
+        ws.send(JSON.stringify({ type: 'error', message: 'interrupt_dialog requires dialog.selfId/rootId' }));
+        return;
+    }
+    const dialogIdObj = new dialog_1.DialogID(dialog.selfId, dialog.rootId);
+    const res = await (0, dialog_run_state_1.requestInterruptDialog)(dialogIdObj, 'user_stop');
+    if (!res.applied) {
+        // Stop should be idempotent: a double-click (or concurrent stop) must not surface as an error.
+        // If the dialog is already not proceeding, treat as a no-op.
+        return;
+    }
+}
+async function handleEmergencyStop(ws, packet) {
+    if (packet.type !== 'emergency_stop') {
+        throw new Error('Internal error: handleEmergencyStop called with non emergency_stop packet');
+    }
+    await (0, dialog_run_state_1.requestEmergencyStopAll)();
+}
+async function handleResumeDialog(ws, packet) {
+    if (packet.type !== 'resume_dialog') {
+        throw new Error('Internal error: handleResumeDialog called with non resume_dialog packet');
+    }
+    const dialog = packet.dialog;
+    if (!dialog || typeof dialog.selfId !== 'string' || typeof dialog.rootId !== 'string') {
+        ws.send(JSON.stringify({ type: 'error', message: 'resume_dialog requires dialog.selfId/rootId' }));
+        return;
+    }
+    const dialogIdObj = new dialog_1.DialogID(dialog.selfId, dialog.rootId);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogIdObj, 'running');
+    const runState = latest?.runState;
+    if (!runState || runState.kind !== 'interrupted') {
+        ws.send(JSON.stringify({ type: 'error', message: 'Dialog is not eligible for resumption.' }));
+        return;
+    }
+    const restored = await restoreDialogForDrive(dialogIdObj, 'running');
+    await (0, driver_1.driveDialogStream)(restored, undefined, true);
+}
+async function handleResumeAll(ws, packet) {
+    if (packet.type !== 'resume_all') {
+        throw new Error('Internal error: handleResumeAll called with non resume_all packet');
+    }
+    const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
+    for (const id of dialogIds) {
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(id, 'running');
+        const runState = latest?.runState;
+        if (!runState || runState.kind !== 'interrupted')
+            continue;
+        void (async () => {
+            try {
+                const dlg = await restoreDialogForDrive(id, 'running');
+                await (0, driver_1.driveDialogStream)(dlg, undefined, true);
+            }
+            catch (err) {
+                log.warn('resume_all: failed to resume dialog', err, { dialogId: id.valueOf() });
+            }
+        })();
+    }
+}
+/**
+ * Handle user answer to a Q4H (Questions for Human) question
+ * Validates questionId, clears q4h.yaml entry, and resumes dialog with user's answer
+ */
+async function handleUserAnswer2Q4H(ws, packet) {
+    try {
+        const { dialog: dialogIdent, content, msgId, questionId } = packet;
+        const userLanguageCode = resolveUserLanguageCode(ws, packet.userLanguageCode);
+        // Basic validation
+        if (!dialogIdent || !content || !msgId || !questionId) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'dialog, content, msgId, and questionId are required',
+            }));
+            return;
+        }
+        // Extract dialog ID from DialogIdent
+        const dialogId = dialogIdent.selfId;
+        const rootDialogId = dialogIdent.rootId;
+        // Validate dialog identifiers
+        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: 'Invalid dialog identifiers for drive_dialog_by_user_answer: selfId/rootId must be strings',
+            }));
+            return;
+        }
+        const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+        // Load current questions from q4h.yaml
+        const questions = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogIdObj);
+        // Validate questionId exists
+        const questionIndex = questions.findIndex((q) => q.id === questionId);
+        if (questionIndex === -1) {
+            ws.send(JSON.stringify({
+                type: 'error',
+                message: `Question ${questionId} not found in dialog ${dialogId}`,
+            }));
+            return;
+        }
+        // Remove answered question from the list
+        questions.splice(questionIndex, 1);
+        // Save updated questions to q4h.yaml
+        if (questions.length > 0) {
+            await persistence_1.DialogPersistence._saveQuestions4HumanState(dialogIdObj, questions);
+        }
+        else {
+            // No more questions - remove the q4h.yaml file
+            await persistence_1.DialogPersistence.clearQuestions4HumanState(dialogIdObj);
+        }
+        // Restore the canonical dialog instances (root + subdialogs) to avoid duplicates.
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, 'running');
+        if (!rootDialog) {
+            ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
+            return;
+        }
+        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        const dialog = dialogIdObj.selfId === dialogIdObj.rootId
+            ? rootDialog
+            : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, 'running');
+        if (!dialog) {
+            ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
+            return;
+        }
+        // Ensure the requesting WebSocket receives q4h_answered and subsequent resume stream events.
+        await setupWebSocketSubscription(ws, dialog);
+        // Emit q4h_answered event for answered question
+        const answeredEvent = {
+            type: 'q4h_answered',
+            questionId,
+            selfId: dialogId,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, answeredEvent);
+        // Resume the dialog with the user's answer.
+        await (0, driver_1.driveDialogStream)(dialog, { content, msgId, grammar: 'tellask', userLanguageCode }, true);
+    }
+    catch (error) {
+        log.error('Error processing Q4H user answer:', error);
+        ws.send(JSON.stringify({
+            type: 'error',
+            message: `Failed to process Q4H answer: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        }));
+    }
+}
+/**
+ * Setup WebSocket server with dialog handling
+ */
+function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage) {
+    const wss = new ws_1.WebSocketServer({ server: httpServer });
+    // Broadcast dialog run-state changes to all connected clients so multi-tab views converge.
+    (0, dialog_run_state_1.setRunStateBroadcaster)((msg) => {
+        const data = JSON.stringify(msg);
+        for (const ws of clients) {
+            if (ws.readyState === 1) {
+                ws.send(data);
+            }
+        }
+    });
+    // Broadcast dialog index changes (create/move/delete) so other tabs refresh their lists.
+    // This ensures multi-tab/multi-browser updates stay consistent without polling.
+    broadcastDialogsIndexMessage = (msg) => {
+        const data = JSON.stringify(msg);
+        for (const ws of clients) {
+            if (ws.readyState === 1) {
+                ws.send(data);
+            }
+        }
+    };
+    // Broadcast workspace Problems snapshots to all connected clients.
+    (0, problems_1.setProblemsBroadcaster)((msg) => {
+        const data = JSON.stringify(msg);
+        for (const ws of clients) {
+            if (ws.readyState === 1) {
+                ws.send(data);
+            }
+        }
+    });
+    wss.on('connection', (ws, req) => {
+        const authCheck = (0, auth_1.getWebSocketAuthCheck)(req, auth);
+        if (authCheck.kind !== 'ok') {
+            ws.close(4401, 'unauthorized');
+            return;
+        }
+        clients.add(ws);
+        wsUiLanguage.set(ws, serverWorkLanguage);
+        // Send welcome message
+        ws.send(JSON.stringify({
+            type: 'welcome',
+            message: 'Connected to dialog server',
+            serverWorkLanguage,
+            supportedLanguageCodes: [...language_1.supportedLanguageCodes],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        }));
+        // Send an initial snapshot so the UI can render a stable Problems indicator immediately.
+        ws.send(JSON.stringify((0, problems_1.createProblemsSnapshotMessage)()));
+        ws.on('message', async (data) => {
+            try {
+                const packet = JSON.parse(data.toString());
+                if (!isRecord(packet) || typeof packet.type !== 'string') {
+                    throw new Error('Invalid packet format');
+                }
+                await handleWebSocketMessage(ws, packet);
+            }
+            catch (error) {
+                log.error('Error handling WebSocket packet:', error);
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    message: 'Invalid packet format',
+                }));
+            }
+        });
+        ws.on('close', () => {
+            clients.delete(ws);
+            // Clean up client subscriptions
+            cleanupWsClient(ws);
+        });
+        ws.on('error', (error) => {
+            log.error('WebSocket error:', error);
+            clients.delete(ws);
+            // Clean up client subscriptions on error
+            cleanupWsClient(ws);
+        });
+    });
+    return wss;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Clean up all event channels and subscriptions
+ */
+function cleanupEventSystems() {
+    // Clear all WebSocket subscriptions (WeakMap will be garbage collected)
+    // Just trigger cleanup of the event channel registry
+    evt_registry_1.dialogEventRegistry.cleanup();
+}
+// Register cleanup on process exit
+process.on('SIGINT', () => {
+    cleanupEventSystems();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    cleanupEventSystems();
+    process.exit(0);
+});