dominds 0.7.2 → 0.7.3

package/dist/dialog-global-registry.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalDialogRegistry = void 0;
 const persistence_1 = require("./persistence");
+const evt_1 = require("./shared/evt");
 class GlobalDialogRegistry {
     constructor() {
         this.entries = new Map();
+        this.driveTriggerPubChan = (0, evt_1.createPubChan)();
+        this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
     }
     static getInstance() {
         if (!GlobalDialogRegistry.instance) {
@@ -30,7 +33,10 @@ class GlobalDialogRegistry {
             try {
                 const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(rootDialog.id);
                 if (needsDrive) {
-                    this.markNeedsDrive(rootDialog.id.rootId);
+                    this.markNeedsDrive(rootDialog.id.rootId, {
+                        source: 'dialog_registry_hydration',
+                        reason: 'persisted_needs_drive_true',
+                    });
                 }
             }
             catch {
@@ -41,17 +47,66 @@ class GlobalDialogRegistry {
     unregister(rootId) {
         this.entries.delete(rootId);
     }
-    markNeedsDrive(rootId) {
+    publishDriveTrigger(args) {
+        this.driveTriggerPubChan.write({
+            type: 'drive_trigger_evt',
+            action: args.action,
+            rootId: args.rootId,
+            entryFound: args.entryFound,
+            previousNeedsDrive: args.previousNeedsDrive,
+            nextNeedsDrive: args.nextNeedsDrive,
+            source: args.meta.source,
+            reason: args.meta.reason,
+            emittedAtMs: Date.now(),
+        });
+    }
+    async waitForDriveTrigger() {
+        for (;;) {
+            const trigger = await this.driveTriggerSubChan.read();
+            if (trigger !== evt_1.EndOfStream) {
+                return trigger;
+            }
+            // Recreate subscription if EOS is ever observed (should not happen in normal runtime).
+            this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
+        }
+    }
+    markNeedsDrive(rootId, meta) {
+        const triggerMeta = meta ?? {
+            source: 'unknown',
+            reason: 'unspecified',
+        };
         const entry = this.entries.get(rootId);
+        const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = true;
         }
+        this.publishDriveTrigger({
+            action: 'mark_needs_drive',
+            rootId,
+            entryFound: entry !== undefined,
+            previousNeedsDrive,
+            nextNeedsDrive: true,
+            meta: triggerMeta,
+        });
     }
-    markNotNeedingDrive(rootId) {
+    markNotNeedingDrive(rootId, meta) {
+        const triggerMeta = meta ?? {
+            source: 'unknown',
+            reason: 'unspecified',
+        };
         const entry = this.entries.get(rootId);
+        const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = false;
         }
+        this.publishDriveTrigger({
+            action: 'mark_not_needing_drive',
+            rootId,
+            entryFound: entry !== undefined,
+            previousNeedsDrive,
+            nextNeedsDrive: false,
+            meta: triggerMeta,
+        });
     }
     getDialogsNeedingDrive() {
         return Array.from(this.entries.values())

package/dist/dialog.js

@@ -502,9 +502,26 @@ class Dialog {
         this._upNext = {
             prompt: trimmed,
             msgId: (0, id_1.generateShortId)(),
+            grammar: 'markdown',
             userLanguageCode: this._lastUserLanguageCode,
         };
     }
+    queueUpNextPrompt(options) {
+        if (this._upNext !== undefined) {
+            throw new Error(`UpNext prompt overwrite violation: dialog=${this.id.valueOf()} existingMsgId=${this._upNext.msgId} incomingMsgId=${options.msgId}`);
+        }
+        const trimmed = options.prompt.trim();
+        if (!trimmed) {
+            throw new Error('Prompt is required to queue upNext');
+        }
+        this._upNext = {
+            prompt: trimmed,
+            msgId: options.msgId,
+            grammar: options.grammar,
+            userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
+        };
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    }
     hasUpNext() {
         return this._upNext !== undefined;
     }

package/dist/evt-registry.js

@@ -25,13 +25,18 @@ class DialogEventRegistryImpl {
     setQ4HBroadcaster(fn) {
         this.q4hBroadcaster = fn;
     }
-    broadcastIfQ4H(evt) {
-        // Only broadcast Q4H events; all other dialog events remain dialog-scoped streams.
+    dispatchQ4HGloballyIfNeeded(evt) {
+        // Q4H MUST be global-only: emit to all clients via broadcaster and do not
+        // also write into dialog-scoped stream, otherwise subscribed clients will
+        // receive duplicate deliveries via two independent paths.
         if (evt.type !== 'new_q4h_asked' && evt.type !== 'q4h_answered')
-            return;
+            return false;
         const fn = this.q4hBroadcaster;
-        if (fn)
-            fn(evt);
+        if (!fn) {
+            throw new Error(`Q4H broadcaster missing: cannot publish ${evt.type} for dialog=${evt.dialog.selfId}`);
+        }
+        fn(evt);
+        return true;
     }
     /**
      * Get or create a PubChan for a specific dialog ID
@@ -75,13 +80,17 @@ class DialogEventRegistryImpl {
      */
     postEvent(dlg, event) {
         const typedEvent = this.createTypedEvent(dlg.id, event);
-        this.broadcastIfQ4H(typedEvent);
+        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dlg.id);
         chan.write(typedEvent);
     }
     postEventById(dialogId, event) {
         const typedEvent = this.createTypedEvent(dialogId, event);
-        this.broadcastIfQ4H(typedEvent);
+        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dialogId);
         chan.write(typedEvent);
     }

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

@@ -39,7 +39,8 @@ function buildDriveBaseContextMessages(parts) {
 }
 function appendDriveEphemeralContext(base, parts) {
     const next = [...base];
-    if (parts.subdialogResponseContextMsgs.length > 0) {
+    if (Array.isArray(parts.subdialogResponseContextMsgs) &&
+        parts.subdialogResponseContextMsgs.length > 0) {
         next.push(...parts.subdialogResponseContextMsgs);
     }
     if (parts.internalDrivePromptMsg) {

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

@@ -10,7 +10,6 @@ const persistence_1 = require("../../persistence");
 const diligence_1 = require("../../shared/diligence");
 const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
-const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
 const tellask_1 = require("../../tellask");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
@@ -20,7 +19,6 @@ const context_1 = require("./context");
 const policy_1 = require("./policy");
 const runtime_utils_1 = require("./runtime-utils");
 const saying_events_1 = require("./saying-events");
-const subdialog_txn_1 = require("./subdialog-txn");
 const tellask_bridge_1 = require("./tellask-bridge");
 class DialogInterruptedError extends Error {
     constructor(reason) {
@@ -56,7 +54,7 @@ function resolveUpNextPrompt(dlg) {
     return {
         content: upNext.prompt,
         msgId: upNext.msgId,
-        grammar: 'markdown',
+        grammar: upNext.grammar ?? 'markdown',
         userLanguageCode: upNext.userLanguageCode,
     };
 }
@@ -210,21 +208,6 @@ async function buildProviderContext(args) {
     }
     return { provider, model, providerCfg };
 }
-async function hasQueuedSubdialogResponses(dialog) {
-    try {
-        const queued = await (0, subdialog_txn_1.withSubdialogTxnLock)(dialog.id, async () => {
-            return await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(dialog.id);
-        });
-        return queued.length > 0;
-    }
-    catch (err) {
-        log_1.log.warn('driver-v2 failed to check queued subdialog responses; suppressing diligence as safe default', {
-            dialogId: dialog.id.valueOf(),
-            error: err,
-        });
-        return true;
-    }
-}
 async function executeFunctionCalls(args) {
     const { dialog, agent, agentTools, funcCalls, abortSignal } = args;
     const functionPromises = funcCalls.map(async (func) => {
@@ -357,13 +340,6 @@ async function maybeContinueWithDiligencePrompt(args) {
         }
         return { kind: 'break' };
     }
-    const queuedResponses = await hasQueuedSubdialogResponses(dlg);
-    if (queuedResponses) {
-        log_1.log.info('driver-v2 skip diligence prompt while subdialog responses remain queued', {
-            dialogId: dlg.id.valueOf(),
-        });
-        return { kind: 'break' };
-    }
     const prepared = await (0, runtime_utils_1.maybePrepareDiligenceAutoContinuePrompt)({
         dlg,
         isRootDialog: true,
@@ -415,12 +391,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
     await (0, dialog_run_state_1.setDialogRunState)(dlg.id, { kind: 'proceeding' });
     let pubRemindersVer = dlg.remindersVer;
     let lastAssistantSayingContent = null;
-    let generationHadError = false;
-    let tookSubdialogResponses = false;
-    let takenSubdialogResponses = [];
-    let subdialogResponseContextMsgs = [];
     let internalDrivePromptMsg;
-    let committedTakenSubdialogResponses = false;
     let genIterNo = 0;
     let pendingPrompt = humanPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
@@ -548,20 +519,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
-                if (genIterNo === 1 && !tookSubdialogResponses) {
-                    tookSubdialogResponses = true;
-                    try {
-                        takenSubdialogResponses = await (0, subdialog_txn_1.takeSubdialogResponses)(dlg.id);
-                    }
-                    catch (err) {
-                        log_1.log.warn('driver-v2 failed to take subdialog responses for injection', {
-                            dialogId: dlg.id.selfId,
-                            error: err,
-                        });
-                        generationHadError = true;
-                        takenSubdialogResponses = [];
-                    }
-                }
                 const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
                 const coursePrefixMsgs = (() => {
                     const msgs = dlg.getCoursePrefixMsgs();
@@ -574,19 +531,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         return false;
                     return true;
                 });
-                if (genIterNo === 1 && takenSubdialogResponses.length > 0) {
-                    subdialogResponseContextMsgs = takenSubdialogResponses.map((response) => ({
-                        type: 'environment_msg',
-                        role: 'user',
-                        content: (0, inter_dialog_format_1.formatTeammateResponseContent)({
-                            responderId: response.responderId,
-                            requesterId: response.originMemberId,
-                            originalCallHeadLine: response.tellaskHead,
-                            responseBody: response.response,
-                            language: (0, runtime_language_1.getWorkLanguage)(),
-                        }),
-                    }));
-                }
                 await dlg.processReminderUpdates();
                 const renderedReminders = dlg.reminders.length > 0
                     ? await Promise.all(dlg.reminders.map(async (reminder, index) => {
@@ -618,7 +562,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         dialogMsgsForContext,
                     },
                     ephemeral: {
-                        subdialogResponseContextMsgs,
                         internalDrivePromptMsg,
                     },
                     tail: {
@@ -1005,12 +948,10 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         : { kind: 'system_stop', detail: 'Aborted.' }
                 : undefined;
         if (interruptedReason) {
-            generationHadError = true;
             finalRunState = { kind: 'interrupted', reason: interruptedReason };
             (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
             return { lastAssistantSayingContent, interrupted: true };
         }
-        generationHadError = true;
         const errText = (0, log_1.extractErrorDetails)(err).message;
         try {
             await dlg.streamError(errText);
@@ -1053,63 +994,5 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             });
         }
         await (0, dialog_run_state_1.setDialogRunState)(dlg.id, finalRunState);
-        if (tookSubdialogResponses) {
-            try {
-                if (generationHadError) {
-                    await (0, subdialog_txn_1.rollbackTakenSubdialogResponses)(dlg.id);
-                }
-                else {
-                    await (0, subdialog_txn_1.commitTakenSubdialogResponses)(dlg.id);
-                    committedTakenSubdialogResponses = true;
-                }
-            }
-            catch (err2) {
-                log_1.log.warn('driver-v2 failed to finalize subdialog response queue after drive', {
-                    dialogId: dlg.id.selfId,
-                    error: err2,
-                });
-            }
-        }
-        if (committedTakenSubdialogResponses && takenSubdialogResponses.length > 0) {
-            try {
-                const mirroredMsgs = [];
-                for (const response of takenSubdialogResponses) {
-                    const content = (0, inter_dialog_format_1.formatTeammateResponseContent)({
-                        responderId: response.responderId,
-                        requesterId: response.originMemberId,
-                        originalCallHeadLine: response.tellaskHead,
-                        responseBody: response.response,
-                        language: (0, runtime_language_1.getWorkLanguage)(),
-                    });
-                    const status = response.status ?? 'completed';
-                    const alreadyMirrored = dlg.msgs.some((msg) => msg.type === 'tellask_result_msg' &&
-                        msg.role === 'tool' &&
-                        msg.responderId === response.responderId &&
-                        msg.tellaskHead === response.tellaskHead &&
-                        msg.status === status &&
-                        msg.content === content);
-                    if (alreadyMirrored) {
-                        continue;
-                    }
-                    mirroredMsgs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: response.responderId,
-                        tellaskHead: response.tellaskHead,
-                        status,
-                        content,
-                    });
-                }
-                if (mirroredMsgs.length > 0) {
-                    await dlg.addChatMessages(...mirroredMsgs);
-                }
-            }
-            catch (err) {
-                log_1.log.warn('driver-v2 failed to mirror committed subdialog responses into dialog msgs', {
-                    dialogId: dlg.id.selfId,
-                    error: err,
-                });
-            }
-        }
     }
 }

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

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