dominds 0.7.2 → 0.7.4

package/dist/llm/driver-v2/round.js

@@ -14,6 +14,36 @@ const core_1 = require("./core");
 const policy_1 = require("./policy");
 const supdialog_response_1 = require("./supdialog-response");
 const defaultCriticalCountdownGenerations = 5;
+async function loadPendingDiagnosticsSnapshot(args) {
+    const ownerDialogIdObj = new dialog_1.DialogID(args.ownerDialogId, args.rootId);
+    try {
+        const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(ownerDialogIdObj);
+        const matchedSubdialogIds = pending
+            .filter((record) => record.subdialogId === args.expectedSubdialogId)
+            .map((record) => record.subdialogId);
+        return {
+            kind: 'loaded',
+            ownerDialogId: args.ownerDialogId,
+            totalCount: pending.length,
+            matchedSubdialogIds,
+            records: pending.map((record) => ({
+                subdialogId: record.subdialogId,
+                callType: record.callType,
+                targetAgentId: record.targetAgentId,
+                tellaskSession: record.tellaskSession,
+                createdAt: record.createdAt,
+                tellaskHeadSummary: record.tellaskHead.trim().slice(0, 160),
+            })),
+        };
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            ownerDialogId: args.ownerDialogId,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
 const contextHealthRoundStateByDialogKey = new Map();
 function getContextHealthRoundState(dialog) {
     const key = dialog.id.key();
@@ -76,7 +106,7 @@ function resolveEffectivePrompt(dialog, humanPrompt) {
     return {
         content: upNext.prompt,
         msgId: upNext.msgId,
-        grammar: 'markdown',
+        grammar: upNext.grammar ?? 'markdown',
         userLanguageCode: upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
             ? upNext.userLanguageCode
             : undefined,
@@ -131,6 +161,24 @@ async function executeDriveRound(args) {
                 dialogId: dialog.id.valueOf(),
             });
         }
+        // Queued/auto drive (without fresh human input) must not proceed while dialog is
+        // suspended by pending Q4H or subdialogs. This prevents duplicate generations when
+        // multiple wake-ups race around the same subdialog completion boundary.
+        if (!humanPrompt) {
+            const suspension = await dialog.getSuspensionStatus();
+            if (!suspension.canDrive) {
+                log_1.log.info('driver-v2 skip queued auto-drive while dialog is suspended', {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                    waitInQue,
+                    hasQueuedUpNext: dialog.hasUpNext(),
+                    waitingQ4H: suspension.q4h,
+                    waitingSubdialogs: suspension.subdialogs,
+                });
+                return;
+            }
+        }
         const minds = await (0, load_1.loadAgentMinds)(dialog.agentId, dialog);
         const policy = (0, policy_1.buildDriverV2Policy)({
             dlg: dialog,
@@ -212,47 +260,85 @@ async function executeDriveRound(args) {
         }
         release();
     }
-    if (followUp) {
-        args.scheduleDrive(dialog, {
-            waitInQue: true,
-            humanPrompt: {
-                content: followUp.prompt,
-                msgId: followUp.msgId,
-                grammar: 'markdown',
-                userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
-                    ? followUp.userLanguageCode
-                    : undefined,
-            },
-        });
-        return;
-    }
     if (dialog instanceof dialog_1.SubDialog &&
         driveResult &&
         !driveResult.interrupted &&
         driveResult.lastAssistantSayingContent !== null) {
-        const suspension = await dialog.getSuspensionStatus();
-        if (!suspension.canDrive) {
-            log_1.log.info('driver-v2 skip supplying subdialog response because dialog is still suspended', {
-                rootId: dialog.id.rootId,
-                selfId: dialog.id.selfId,
-                waitingQ4H: suspension.q4h,
-                waitingSubdialogs: suspension.subdialogs,
-            });
-            return;
-        }
+        let supplied = false;
         if (subdialogReplyTarget) {
-            await (0, supdialog_response_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
+            supplied = await (0, supdialog_response_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
                 subdialog: dialog,
                 responseText: driveResult.lastAssistantSayingContent,
                 target: subdialogReplyTarget,
                 scheduleDrive: args.scheduleDrive,
             });
-            return;
+            if (!supplied) {
+                supplied = await (0, supdialog_response_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                    subdialog: dialog,
+                    responseText: driveResult.lastAssistantSayingContent,
+                    scheduleDrive: args.scheduleDrive,
+                });
+            }
         }
-        await (0, supdialog_response_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-            subdialog: dialog,
-            responseText: driveResult.lastAssistantSayingContent,
-            scheduleDrive: args.scheduleDrive,
+        else {
+            supplied = await (0, supdialog_response_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                subdialog: dialog,
+                responseText: driveResult.lastAssistantSayingContent,
+                scheduleDrive: args.scheduleDrive,
+            });
+        }
+        if (!supplied && subdialogReplyTarget) {
+            const assignment = dialog.assignmentFromSup;
+            const ownerDialogIds = Array.from(new Set([subdialogReplyTarget.ownerDialogId, assignment.callerDialogId]));
+            const pendingSnapshots = await Promise.all(ownerDialogIds.map(async (ownerDialogId) => loadPendingDiagnosticsSnapshot({
+                rootId: dialog.id.rootId,
+                ownerDialogId,
+                expectedSubdialogId: dialog.id.selfId,
+            })));
+            const streamErr = `Subdialog response supply invariant violation: ` +
+                `subdialog=${dialog.id.selfId} root=${dialog.id.rootId} ` +
+                `targetOwner=${subdialogReplyTarget.ownerDialogId} targetCallType=${subdialogReplyTarget.callType} targetCallId=${subdialogReplyTarget.callId} ` +
+                `assignmentCaller=${assignment.callerDialogId} assignmentCallId=${assignment.callId} ` +
+                `pendingSnapshots=${pendingSnapshots.length}`;
+            try {
+                await dialog.streamError(streamErr);
+            }
+            catch (streamErrPost) {
+                log_1.log.warn('driver-v2 failed to emit stream_error_evt for response supply violation', {
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                    targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
+                    targetCallType: subdialogReplyTarget.callType,
+                    targetCallId: subdialogReplyTarget.callId,
+                    assignmentCallerDialogId: assignment.callerDialogId,
+                    assignmentCallId: assignment.callId,
+                    pendingSnapshots,
+                    error: streamErrPost instanceof Error ? streamErrPost.message : String(streamErrPost),
+                });
+            }
+            log_1.log.error('driver-v2 subdialog produced response but found no pending caller to supply', {
+                rootId: dialog.id.rootId,
+                selfId: dialog.id.selfId,
+                targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
+                targetCallType: subdialogReplyTarget.callType,
+                targetCallId: subdialogReplyTarget.callId,
+                assignmentCallerDialogId: assignment.callerDialogId,
+                assignmentCallId: assignment.callId,
+                pendingSnapshots,
+            });
+        }
+    }
+    if (followUp) {
+        args.scheduleDrive(dialog, {
+            waitInQue: true,
+            humanPrompt: {
+                content: followUp.prompt,
+                msgId: followUp.msgId,
+                grammar: followUp.grammar ?? 'markdown',
+                userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
+                    ? followUp.userLanguageCode
+                    : undefined,
+            },
         });
     }
 }

package/dist/llm/driver-v2/runtime-utils.js

@@ -181,6 +181,7 @@ async function suspendForKeepGoingBudgetExhausted(options) {
             bodyContent: question.bodyContent,
             askedAt: question.askedAt,
             callId: question.callId,
+            remainingCallIds: question.remainingCallIds,
             callSiteRef: question.callSiteRef,
             rootId: dlg.id.rootId,
             agentId: dlg.agentId,

package/dist/llm/driver-v2/supdialog-response.js

@@ -9,9 +9,7 @@ const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const runtime_language_1 = require("../../shared/runtime-language");
-const id_1 = require("../../shared/utils/id");
 const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
-const time_1 = require("../../shared/utils/time");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
 const subdialog_txn_1 = require("./subdialog-txn");
 async function syncPendingTellaskReminderBestEffort(dlg, where) {
@@ -98,20 +96,6 @@ async function supplyResponseToSupdialogV2(args) {
             if (tellaskHead.trim() === '') {
                 tellaskHead = responseText.slice(0, 100) + (responseText.length > 100 ? '...' : '');
             }
-            const completedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
-            const responseId = (0, id_1.generateShortId)();
-            await persistence_1.DialogPersistence.appendSubdialogResponse(parentDialog.id, {
-                responseId,
-                subdialogId: subdialogId.selfId,
-                response: responseText,
-                completedAt,
-                status,
-                callType,
-                tellaskHead,
-                responderId,
-                originMemberId,
-                callId: callId ?? '',
-            });
             await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending);
             const hasQ4H = await parentDialog.hasPendingQ4H();
             const shouldRevive = !hasQ4H && filteredPending.length === 0;
@@ -134,7 +118,7 @@ async function supplyResponseToSupdialogV2(args) {
             originMemberId: result.originMemberId ?? parentDialog.agentId,
         });
         // Keep in-memory dialog context in sync with live teammate-response events immediately.
-        // Without this, tellask_result_msg can appear batched at drive-finalization mirror time.
+        // v2 context assembly now relies on dialog msgs + persisted teammate_response_record only.
         const immediateMirror = {
             type: 'tellask_result_msg',
             role: 'tool',
@@ -153,7 +137,10 @@ async function supplyResponseToSupdialogV2(args) {
         if (result.shouldRevive) {
             log_1.log.info(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} auto-reviving`);
             if (parentDialog instanceof dialog_1.RootDialog) {
-                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId);
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId, {
+                    source: 'driver_v2_supply_response',
+                    reason: `all_pending_subdialogs_resolved:type_${callType}`,
+                });
             }
             scheduleDrive(parentDialog, {
                 waitInQue: true,

package/dist/llm/driver-v2/tellask-bridge.js

@@ -46,7 +46,6 @@ const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
 const time_1 = require("../../shared/utils/time");
 const team_1 = require("../../team");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
-const id_2 = require("../../utils/id");
 const subdialog_txn_1 = require("./subdialog-txn");
 function showErrorToAi(err) {
     try {
@@ -419,13 +418,21 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
     const isQ4H = firstMention === 'human';
     if (isQ4H) {
         try {
-            const questionId = `q4h-${(0, id_2.generateDialogID)()}`;
+            const normalizedCallId = callId.trim();
+            if (normalizedCallId === '') {
+                throw new Error(`Q4H call invariant violation: empty callId (rootId=${dlg.id.rootId} selfId=${dlg.id.selfId})`);
+            }
+            const questionId = `q4h-${dlg.id.rootId}-${dlg.id.selfId}-c${dlg.currentCourse}-${normalizedCallId}`;
+            const normalizedRemainingCallIds = Array.from(new Set((options?.q4hRemainingCallIds ?? [])
+                .map((value) => value.trim())
+                .filter((value) => value !== '' && value !== normalizedCallId)));
             const question = {
                 id: questionId,
                 tellaskHead: tellaskHead.trim(),
                 bodyContent: body.trim(),
                 askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                callId: callId.trim() === '' ? undefined : callId,
+                callId: normalizedCallId,
+                remainingCallIds: normalizedRemainingCallIds.length > 0 ? normalizedRemainingCallIds : undefined,
                 callSiteRef: {
                     course: dlg.currentCourse,
                     messageIndex: dlg.msgs.length,
@@ -441,6 +448,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     bodyContent: question.bodyContent,
                     askedAt: question.askedAt,
                     callId: question.callId,
+                    remainingCallIds: question.remainingCallIds,
                     callSiteRef: question.callSiteRef,
                     rootId: dlg.id.rootId,
                     agentId: dlg.agentId,
@@ -1076,7 +1084,61 @@ async function executeTellaskCalls(args) {
     const callbacks = ensureCallbacks(args.callbacks);
     const malformedToolOutputs = await emitMalformedTellaskResponses(dlg, collectedCalls);
     const validCalls = collectedCalls.filter((call) => call.validation.kind === 'valid');
-    const results = await Promise.all(validCalls.map((call) => executeTellaskCall(dlg, agent, call.validation.firstMention, call.tellaskHead, call.body, call.callId, callbacks)));
+    const q4hCalls = validCalls.filter((call) => call.validation.firstMention === 'human');
+    const nonQ4HCalls = validCalls
+        .filter((call) => call.validation.firstMention !== 'human')
+        .map((call) => ({ ...call }));
+    let mergedQ4HCall = null;
+    if (q4hCalls.length === 1) {
+        mergedQ4HCall = { ...q4hCalls[0] };
+    }
+    else if (q4hCalls.length > 1) {
+        const primary = q4hCalls[0];
+        const remainingCallIds = q4hCalls
+            .slice(1)
+            .map((call) => call.callId.trim())
+            .filter((callId) => callId !== '');
+        const language = (0, runtime_language_1.getWorkLanguage)();
+        const intro = language === 'zh'
+            ? `我这次有 ${q4hCalls.length} 个问题，想请你一次性回复：`
+            : `I have ${q4hCalls.length} questions this round. Please answer them in one response:`;
+        const mergedBody = [
+            intro,
+            ...q4hCalls.map((call, index) => {
+                const body = call.body.trim();
+                const normalizedBody = body !== ''
+                    ? body
+                    : language === 'zh'
+                        ? '请结合当前上下文补充这一项。'
+                        : 'Please provide this item based on the current context.';
+                return language === 'zh'
+                    ? `问题 ${index + 1}：\n${normalizedBody}`
+                    : `Question ${index + 1}:\n${normalizedBody}`;
+            }),
+        ].join('\n\n');
+        mergedQ4HCall = {
+            ...primary,
+            body: mergedBody,
+            q4hRemainingCallIds: remainingCallIds.length > 0 ? remainingCallIds : undefined,
+        };
+        log_1.log.info('Q4H multi-question normalized into a single prompt', {
+            rootId: dlg.id.rootId,
+            selfId: dlg.id.selfId,
+            mergedCount: q4hCalls.length,
+            primaryCallId: primary.callId,
+            remainingCallIds,
+        });
+    }
+    const executionCalls = mergedQ4HCall
+        ? [...nonQ4HCalls, mergedQ4HCall]
+        : nonQ4HCalls;
+    const results = [];
+    for (const call of executionCalls) {
+        const result = await executeTellaskCall(dlg, agent, call.validation.firstMention, call.tellaskHead, call.body, call.callId, callbacks, {
+            q4hRemainingCallIds: call.q4hRemainingCallIds,
+        });
+        results.push(result);
+    }
     const suspend = results.some((result) => result.suspend);
     const toolOutputs = [...malformedToolOutputs, ...results.flatMap((result) => result.toolOutputs)];
     const subdialogsCreated = results.flatMap((result) => result.subdialogsCreated);

package/dist/persistence.js

@@ -298,6 +298,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async createSubDialog(supdialog, targetAgentId, tellaskHead, tellaskBody, options) {
         const generatedId = (0, id_1.generateDialogID)();
+        const nowTs = (0, time_1.formatUnifiedTimestamp)(new Date());
         // For subdialogs, use the supdialog's root dialog ID as the root
         const subdialogId = new dialog_1.DialogID(generatedId, supdialog.id.rootId);
         // Prepare subdialog store
@@ -316,7 +317,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             id: subdialogId.selfId,
             agentId: targetAgentId,
             taskDocPath: supdialog.taskDocPath,
-            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            createdAt: nowTs,
             supdialogId: supdialog.id.selfId,
             tellaskSession: options.tellaskSession,
             assignmentFromSup: {
@@ -334,7 +335,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             kind: 'replace',
             next: {
                 currentCourse: 1,
-                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                lastModified: nowTs,
                 status: 'active',
                 messageCount: 0,
                 functionCallCount: 0,
@@ -364,6 +365,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             targetAgentId,
             tellaskHead,
             tellaskBody,
+            subDialogNode: {
+                selfId: subdialogId.selfId,
+                rootId: subdialogId.rootId,
+                supdialogId: supdialog.id.selfId,
+                agentId: targetAgentId,
+                taskDocPath: supdialog.taskDocPath,
+                status: 'running',
+                currentCourse: 1,
+                createdAt: nowTs,
+                lastModified: nowTs,
+                runState: { kind: 'idle_waiting_user' },
+                tellaskSession: options.tellaskSession,
+                assignmentFromSup: {
+                    tellaskHead,
+                    tellaskBody,
+                    originMemberId: options.originMemberId,
+                    callerDialogId: options.callerDialogId,
+                    callId: options.callId,
+                },
+            },
         };
         // Post subdialog_created_evt to PARENT's PubChan so frontend can receive it
         // The frontend subscribes to the parent's events, not the subdialog's
@@ -1052,7 +1073,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             // Events are already in chronological order from JSONL file (append-only pattern)
             // Send each persistence event directly to the requesting WebSocket
             for (const event of persistenceEvents) {
-                await this.sendEventDirectlyToWebSocket(ws, dialog, currentCourse, event);
+                await this.sendEventDirectlyToWebSocket(ws, dialog, currentCourse, event, status);
             }
             // Rehydrate reminders from dialog state
             const dialogState = await DialogPersistence.restoreDialog(dialog.id, status);
@@ -1071,7 +1092,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Send a single persistence event directly to a WebSocket connection
      * CRITICAL: Avoid PubChan completely for dialog restoration to the single client's display_dialog request
      */
-    async sendEventDirectlyToWebSocket(ws, dialog, course, event) {
+    async sendEventDirectlyToWebSocket(ws, dialog, course, event, status) {
         switch (event.type) {
             case 'human_text_record': {
                 const genseq = event.genseq;
@@ -1604,25 +1625,67 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             }
             case 'quest_for_sup_record': {
                 // Handle subdialog creation requests
+                const subdialogId = new dialog_1.DialogID(event.subDialogId, dialog.id.rootId);
+                const loadOrder = [
+                    status,
+                    'running',
+                    'completed',
+                    'archived',
+                ].filter((candidate, index, arr) => arr.indexOf(candidate) === index);
+                let foundStatus = null;
+                let subMeta = null;
+                let subLatest = null;
+                for (const candidateStatus of loadOrder) {
+                    const candidateMeta = await DialogPersistence.loadDialogMetadata(subdialogId, candidateStatus);
+                    if (!candidateMeta || !isSubdialogMetadataFile(candidateMeta))
+                        continue;
+                    foundStatus = candidateStatus;
+                    subMeta = candidateMeta;
+                    subLatest = await DialogPersistence.loadDialogLatest(subdialogId, candidateStatus);
+                    break;
+                }
+                if (!foundStatus || !subMeta) {
+                    throw new Error(`subdialog_created_evt replay invariant violation: metadata missing for ${subdialogId.valueOf()}`);
+                }
+                const derivedSupdialogId = subMeta.assignmentFromSup?.callerDialogId &&
+                    subMeta.assignmentFromSup.callerDialogId.trim() !== ''
+                    ? subMeta.assignmentFromSup.callerDialogId
+                    : typeof subMeta.supdialogId === 'string' && subMeta.supdialogId.trim() !== ''
+                        ? subMeta.supdialogId
+                        : dialog.id.selfId;
                 const subdialogCreatedEvent = {
                     type: 'subdialog_created_evt',
                     course,
                     dialog: {
                         // Add dialog field for proper event routing
-                        selfId: event.subDialogId,
-                        rootId: dialog.id.rootId,
+                        selfId: subdialogId.selfId,
+                        rootId: subdialogId.rootId,
                     },
                     parentDialog: {
                         selfId: dialog.id.selfId,
                         rootId: dialog.id.rootId,
                     },
                     subDialog: {
-                        selfId: event.subDialogId,
-                        rootId: dialog.id.rootId, // Use parent's rootId for subdialog's rootId
+                        selfId: subdialogId.selfId,
+                        rootId: subdialogId.rootId,
                     },
-                    targetAgentId: 'unknown', // Will be resolved during actual subdialog creation
+                    targetAgentId: subMeta.agentId,
                     tellaskHead: event.tellaskHead,
                     tellaskBody: event.tellaskBody,
+                    subDialogNode: {
+                        selfId: subMeta.id,
+                        rootId: subdialogId.rootId,
+                        supdialogId: derivedSupdialogId,
+                        agentId: subMeta.agentId,
+                        taskDocPath: subMeta.taskDocPath,
+                        status: foundStatus,
+                        currentCourse: subLatest?.currentCourse || 1,
+                        createdAt: subMeta.createdAt,
+                        lastModified: subLatest?.lastModified || subMeta.createdAt,
+                        runState: subLatest?.runState,
+                        tellaskSession: subMeta.tellaskSession,
+                        assignmentFromSup: subMeta.assignmentFromSup,
+                    },
                     timestamp: event.ts,
                 };
                 if (ws.readyState === 1) {
@@ -2451,6 +2514,14 @@ class DialogPersistence {
                     throw new Error(`Q4H duplicate call id violation: dialog=${dialogId.valueOf()} status=${status} callId=${normalizedCallId} existingQuestionId=${byCallId.id} incomingQuestionId=${questionId} existingAskedAt=${byCallId.askedAt} incomingAskedAt=${question.askedAt}`);
                 }
             }
+            if (previousQuestions.length > 0) {
+                const existingIds = previousQuestions.map((q) => q.id).join(',');
+                const existingCallIds = previousQuestions
+                    .map((q) => (typeof q.callId === 'string' ? q.callId.trim() : ''))
+                    .filter((value) => value !== '')
+                    .join(',');
+                throw new Error(`Q4H multi-pending violation: dialog=${dialogId.valueOf()} status=${status} existingCount=${previousQuestions.length} existingQuestionIds=${existingIds} existingCallIds=${existingCallIds} incomingQuestionId=${questionId} incomingCallId=${normalizedCallId ?? ''}`);
+            }
             return { kind: 'append', question };
         }, status);
     }

package/dist/server/websocket-handler.js

@@ -390,9 +390,11 @@ async function maybeTriggerImmediateDiligencePrompt(rootDialog) {
         if (!suspension.canDrive) {
             return;
         }
-        const queuedResponses = await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(rootDialog.id);
-        if (queuedResponses.length > 0) {
-            return;
+        if ((0, driver_entry_1.getActiveDriverEngine)() === 'v1') {
+            const queuedResponses = await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(rootDialog.id);
+            if (queuedResponses.length > 0) {
+                return;
+            }
         }
         const team = await team_1.Team.load();
         const prepared = await (0, runtime_utils_1.maybePrepareDiligenceAutoContinuePrompt)({
@@ -755,31 +757,29 @@ async function handleDisplayDialog(ws, packet) {
         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)
+        // Emit one Q4H snapshot to ensure frontend has current global questions state.
+        // Do NOT replay per-question `new_q4h_asked` events here: those are real-time
+        // incremental events and replaying them on display refresh can create duplicate
+        // delivery paths and blur event semantics.
         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,
-                        selfId: q.selfId,
-                        rootId: q.rootId,
-                        agentId: q.agentId,
-                        taskDocPath: q.taskDocPath,
-                        tellaskHead: q.tellaskHead,
-                        bodyContent: q.bodyContent,
-                        askedAt: q.askedAt,
-                        callId: q.callId,
-                        callSiteRef: q.callSiteRef,
-                    },
-                };
-                ws.send(JSON.stringify(newQ4HEvent));
-            }
+            const response = {
+                type: 'q4h_state_response',
+                questions: allQuestions.map((q) => ({
+                    id: q.id,
+                    selfId: q.selfId,
+                    rootId: q.rootId,
+                    agentId: q.agentId,
+                    taskDocPath: q.taskDocPath,
+                    tellaskHead: q.tellaskHead,
+                    bodyContent: q.bodyContent,
+                    askedAt: q.askedAt,
+                    callId: q.callId,
+                    remainingCallIds: q.remainingCallIds,
+                    callSiteRef: q.callSiteRef,
+                })),
+            };
+            ws.send(JSON.stringify(response));
         }
         catch (err) {
             log.warn(`Failed to emit Q4H state for ${dialogIdObj}:`, err);
@@ -818,6 +818,7 @@ async function handleGetQ4HState(ws, _packet) {
             bodyContent: q.bodyContent,
             askedAt: q.askedAt,
             callId: q.callId,
+            remainingCallIds: q.remainingCallIds,
             callSiteRef: q.callSiteRef,
         }));
         // Send single response packet with all questions (not PubChan events)
@@ -1157,6 +1158,22 @@ async function handleUserAnswer2Q4H(ws, packet) {
             selfId: dialogId,
         };
         (0, evt_registry_1.postDialogEvent)(dialog, answeredEvent);
+        const hasPendingSubdialogs = await dialog.hasPendingSubdialogs();
+        if (hasPendingSubdialogs) {
+            dialog.queueUpNextPrompt({
+                prompt: content,
+                msgId,
+                grammar: 'tellask',
+                userLanguageCode,
+            });
+            log.info('Deferred Q4H answer until pending subdialogs resolve', {
+                rootId: dialog.id.rootId,
+                selfId: dialog.id.selfId,
+                questionId,
+                msgId,
+            });
+            return;
+        }
         // Resume the dialog with the user's answer.
         await (0, driver_entry_1.driveDialogStream)(dialog, { content, msgId, grammar: 'tellask', userLanguageCode, origin: 'user' }, true);
     }
@@ -1182,9 +1199,11 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage) {
             }
         }
     });
-    // Broadcast Q4H events globally: Q4H is rtws-global state in the WebUI.
-    // Without this, a client can miss Q4H updates when it's not subscribed to the originating dialog stream.
-    (0, evt_registry_1.setQ4HBroadcaster)((evt) => {
+    // Broadcast global dialog events to all connected clients:
+    // - Q4H updates are rtws-global state in WebUI
+    // - subdialog creation must refresh hierarchy/list even when current subscription is elsewhere
+    // - dlg_touched_evt keeps dialog list timestamps/reordering in sync across clients
+    (0, evt_registry_1.setGlobalDialogEventBroadcaster)((evt) => {
         const data = JSON.stringify(evt);
         for (const ws of clients) {
             if (ws.readyState === 1) {

package/dist/static/assets/{_baseUniq-C04fddeD.js → _baseUniq-C_6DmNp6.js}

@@ -1,4 +1,4 @@
-import { aV as isObjectLike, br as baseGetTag, aE as isArray, aT as Symbol$1, bs as arrayLikeKeys, bt as baseKeys, aD as isArrayLike, bu as memoize, bv as isArguments, bw as MapCache, bm as eq, bx as Uint8Array, aW as getTag, a$ as isBuffer, b2 as Stack, by as isTypedArray, aZ as isObject, bz as isLength, bp as isIndex, aF as identity, bn as baseFor, bA as Set } from "./index-CQr8MdPI.js";
+import { aV as isObjectLike, br as baseGetTag, aE as isArray, aT as Symbol$1, bs as arrayLikeKeys, bt as baseKeys, aD as isArrayLike, bu as memoize, bv as isArguments, bw as MapCache, bm as eq, bx as Uint8Array, aW as getTag, a$ as isBuffer, b2 as Stack, by as isTypedArray, aZ as isObject, bz as isLength, bp as isIndex, aF as identity, bn as baseFor, bA as Set } from "./index-CIEJ2QXv.js";
 var symbolTag$1 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$1;
@@ -658,4 +658,4 @@ export {
   hasIn as x,
   toString as y
 };
-//# sourceMappingURL=_baseUniq-C04fddeD.js.map
+//# sourceMappingURL=_baseUniq-C_6DmNp6.js.map