dominds 0.7.2 → 0.7.3

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

@@ -2451,6 +2451,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);
     }

package/dist/static/assets/{_baseUniq-C04fddeD.js → _baseUniq-zV3pyJ-s.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-CqMOe9zt.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-zV3pyJ-s.js.map