dominds 0.7.1 → 0.7.3

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

@@ -42,48 +42,75 @@ async function supplyResponseToSupdialog(...args) {
         },
     });
 }
+function formatDriveTriggerForLog(trigger) {
+    return {
+        action: trigger.action,
+        rootId: trigger.rootId,
+        entryFound: trigger.entryFound,
+        previousNeedsDrive: trigger.previousNeedsDrive,
+        nextNeedsDrive: trigger.nextNeedsDrive,
+        source: trigger.source,
+        reason: trigger.reason,
+        emittedAtMs: trigger.emittedAtMs,
+    };
+}
+async function driveQueuedDialogsOnce() {
+    const dialogsToDrive = dialog_global_registry_1.globalDialogRegistry.getDialogsNeedingDrive();
+    for (const rootDialog of dialogsToDrive) {
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
+            const runStateKind = latest?.runState?.kind;
+            if (runStateKind === 'interrupted' || runStateKind === 'proceeding_stop_requested') {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: `run_state_blocked:${runStateKind}`,
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                continue;
+            }
+            if (!(await rootDialog.canDrive())) {
+                continue;
+            }
+            await driveDialogStream(rootDialog, undefined, true);
+            const status = await rootDialog.getSuspensionStatus();
+            const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
+            if (shouldStayQueued) {
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: rootDialog.hasUpNext() ? 'post_drive_upnext_pending' : 'post_drive_suspended',
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
+            }
+            else {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: 'post_drive_idle',
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+            }
+            if (status.subdialogs) {
+                log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`);
+            }
+            if (status.q4h) {
+                log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`);
+            }
+        }
+        catch (err) {
+            log_1.log.error(`Error driving dialog ${rootDialog.id.rootId}:`, err, undefined, {
+                dialogId: rootDialog.id.rootId,
+            });
+        }
+    }
+}
 function runBackendDriver() {
     return (async () => {
         while (true) {
             try {
-                const dialogsToDrive = dialog_global_registry_1.globalDialogRegistry.getDialogsNeedingDrive();
-                for (const rootDialog of dialogsToDrive) {
-                    try {
-                        const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
-                        const runStateKind = latest?.runState?.kind;
-                        if (runStateKind === 'interrupted' || runStateKind === 'proceeding_stop_requested') {
-                            dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
-                            await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
-                            continue;
-                        }
-                        if (!(await rootDialog.canDrive())) {
-                            continue;
-                        }
-                        await driveDialogStream(rootDialog, undefined, true);
-                        const status = await rootDialog.getSuspensionStatus();
-                        const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
-                        if (shouldStayQueued) {
-                            dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId);
-                            await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
-                        }
-                        else {
-                            dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
-                            await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
-                        }
-                        if (status.subdialogs) {
-                            log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`);
-                        }
-                        if (status.q4h) {
-                            log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`);
-                        }
-                    }
-                    catch (err) {
-                        log_1.log.error(`Error driving dialog ${rootDialog.id.rootId}:`, err, undefined, {
-                            dialogId: rootDialog.id.rootId,
-                        });
-                    }
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
+                await driveQueuedDialogsOnce();
+                const trigger = await dialog_global_registry_1.globalDialogRegistry.waitForDriveTrigger();
+                log_1.log.debug('Backend driver woke from drive trigger event', undefined, {
+                    trigger: formatDriveTriggerForLog(trigger),
+                });
             }
             catch (loopErr) {
                 log_1.log.error('Error in backend driver loop:', loopErr);

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

@@ -6,11 +6,95 @@ const dialog_run_state_1 = require("../../dialog-run-state");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
+const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
+const id_1 = require("../../shared/utils/id");
 const context_health_1 = require("./context-health");
 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();
+    const existing = contextHealthRoundStateByDialogKey.get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = {};
+    contextHealthRoundStateByDialogKey.set(key, created);
+    return created;
+}
+function resetContextHealthRoundState(dialog) {
+    contextHealthRoundStateByDialogKey.delete(dialog.id.key());
+}
+function resolveCriticalCountdownRemaining(dialog, snapshot) {
+    if (!snapshot || snapshot.kind !== 'available') {
+        resetContextHealthRoundState(dialog);
+        return defaultCriticalCountdownGenerations;
+    }
+    if (snapshot.level !== 'critical') {
+        if (snapshot.level === 'healthy') {
+            resetContextHealthRoundState(dialog);
+            return defaultCriticalCountdownGenerations;
+        }
+        const state = getContextHealthRoundState(dialog);
+        state.lastSeenLevel = snapshot.level;
+        state.criticalCountdownRemaining = undefined;
+        return defaultCriticalCountdownGenerations;
+    }
+    const state = getContextHealthRoundState(dialog);
+    if (state.lastSeenLevel !== 'critical' ||
+        typeof state.criticalCountdownRemaining !== 'number' ||
+        !Number.isFinite(state.criticalCountdownRemaining)) {
+        state.lastSeenLevel = 'critical';
+        state.criticalCountdownRemaining = defaultCriticalCountdownGenerations;
+    }
+    const remaining = Math.floor(state.criticalCountdownRemaining);
+    return remaining > 0 ? remaining : 0;
+}
+function consumeCriticalCountdown(dialog) {
+    const state = getContextHealthRoundState(dialog);
+    const currentRaw = typeof state.criticalCountdownRemaining === 'number' &&
+        Number.isFinite(state.criticalCountdownRemaining)
+        ? Math.floor(state.criticalCountdownRemaining)
+        : defaultCriticalCountdownGenerations;
+    const current = currentRaw > 0 ? currentRaw : 0;
+    const next = Math.max(0, current - 1);
+    state.lastSeenLevel = 'critical';
+    state.criticalCountdownRemaining = next;
+    return next;
+}
 function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
         return humanPrompt;
@@ -22,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,
@@ -77,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,
@@ -89,18 +191,56 @@ async function executeDriveRound(args) {
         if (!validation.ok) {
             throw new Error(`driver-v2 policy invariant violation: ${validation.detail}`);
         }
+        const snapshot = dialog.getLastContextHealth();
+        const hasQueuedUpNext = dialog.hasUpNext();
+        const criticalCountdownRemaining = resolveCriticalCountdownRemaining(dialog, snapshot);
         const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
-            snapshot: dialog.getLastContextHealth(),
-            hadUserPromptThisGen: args.driveArgs[1] !== undefined,
-            criticalCountdownRemaining: 1,
+            snapshot,
+            hadUserPromptThisGen: humanPrompt !== undefined,
+            criticalCountdownRemaining,
         });
         if (healthDecision.kind === 'suspend') {
             return;
         }
+        let healthPrompt;
+        if (healthDecision.kind === 'continue') {
+            if (healthDecision.reason === 'critical_force_new_course') {
+                const language = (0, runtime_language_1.getWorkLanguage)();
+                const newCoursePrompt = language === 'zh'
+                    ? '系统因上下文已告急（critical）而自动开启新一程对话，请继续推进任务。'
+                    : 'System auto-started a new dialog course because context health is critical. Please continue the task.';
+                await dialog.startNewCourse(newCoursePrompt);
+                dialog.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+                resetContextHealthRoundState(dialog);
+            }
+            else if (!hasQueuedUpNext) {
+                const language = (0, runtime_language_1.getWorkLanguage)();
+                const guideText = healthDecision.reason === 'caution_soft_remediation'
+                    ? (0, driver_messages_1.formatUserFacingContextHealthV3RemediationGuide)(language, {
+                        kind: 'caution',
+                        mode: 'soft',
+                    })
+                    : (0, driver_messages_1.formatUserFacingContextHealthV3RemediationGuide)(language, {
+                        kind: 'critical',
+                        mode: 'countdown',
+                        promptsRemainingAfterThis: consumeCriticalCountdown(dialog),
+                        promptsTotal: defaultCriticalCountdownGenerations,
+                    });
+                healthPrompt = {
+                    content: guideText,
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    userLanguageCode: language,
+                };
+            }
+        }
         args.runtime.driveCount += 1;
         args.runtime.totalGenIterations += 1;
         args.runtime.usedLegacyDriveCore = false;
-        const effectivePrompt = resolveEffectivePrompt(dialog, humanPrompt);
+        const promptForCore = healthDecision.kind === 'continue' && healthDecision.reason === 'critical_force_new_course'
+            ? undefined
+            : (healthPrompt ?? humanPrompt);
+        const effectivePrompt = resolveEffectivePrompt(dialog, promptForCore);
         subdialogReplyTarget = effectivePrompt?.subdialogReplyTarget;
         if (effectivePrompt && effectivePrompt.userLanguageCode) {
             dialog.setLastUserLanguageCode(effectivePrompt.userLanguageCode);
@@ -120,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 {
@@ -193,6 +192,33 @@ async function updateSubdialogAssignment(subdialog, assignment) {
     subdialog.assignmentFromSup = assignment;
     await persistence_1.DialogPersistence.updateSubdialogAssignment(subdialog.id, assignment);
 }
+async function lookupLiveRegisteredSubdialog(rootDialog, agentId, tellaskSession) {
+    const existing = rootDialog.lookupSubdialog(agentId, tellaskSession);
+    if (!existing) {
+        return undefined;
+    }
+    const existingSession = existing.tellaskSession;
+    if (!existingSession) {
+        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without tellaskSession (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
+    const runState = latest?.runState;
+    if (!runState || runState.kind !== 'dead') {
+        return existing;
+    }
+    const removed = rootDialog.unregisterSubdialog(existing.agentId, existingSession);
+    if (!removed) {
+        throw new Error(`Failed to unregister dead registered subdialog: root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
+    }
+    await rootDialog.saveSubdialogRegistry();
+    log_1.log.info('Pruned dead registered subdialog from Type B registry', undefined, {
+        rootId: rootDialog.id.rootId,
+        subdialogId: existing.id.selfId,
+        agentId: existing.agentId,
+        tellaskSession: existingSession,
+    });
+    return undefined;
+}
 function extractLastAssistantResponse(messages, defaultMessage) {
     let responseText = '';
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -392,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,
@@ -414,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,
@@ -662,7 +697,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                             callId,
                             collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                         };
-                        const existing = rootDialog.lookupSubdialog(parseResult.agentId, derivedSession);
+                        const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, derivedSession);
                         if (existing) {
                             try {
                                 await updateSubdialogAssignment(existing, assignment);
@@ -902,7 +937,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 };
                 const pendingOwner = callerDialog;
                 const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(rootDialog.id, async () => {
-                    const existing = rootDialog.lookupSubdialog(parseResult.agentId, parseResult.tellaskSession);
+                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.tellaskSession);
                     if (existing) {
                         try {
                             await updateSubdialogAssignment(existing, assignment);
@@ -1049,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);