dominds 1.16.2 → 1.16.3

package/dist/dialog-display-state.d.ts

@@ -34,7 +34,9 @@ export declare function broadcastRunControlCountsSnapshot(): Promise<void>;
 export declare function hasActiveRun(dialogId: DialogID): boolean;
 export declare function getActiveRunSignal(dialogId: DialogID): AbortSignal | undefined;
 export declare function createActiveRun(dialogId: DialogID): AbortSignal;
-export declare function clearActiveRun(dialogId: DialogID): void;
+export declare function clearActiveRun(dialogId: DialogID, options?: Readonly<{
+    notifyBackendLoop?: boolean;
+}>): void;
 export declare function clearRootDialogQuarantiningIfIdle(rootDialogId: DialogID): void;
 export declare function markRootDialogQuarantining(rootDialogId: DialogID): void;
 export declare function clearRootDialogQuarantining(rootDialogId: DialogID): void;

package/dist/dialog-display-state.js

@@ -44,6 +44,7 @@ exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("./dialog");
+const dialog_global_registry_1 = require("./dialog-global-registry");
 const dialog_interruption_1 = require("./dialog-interruption");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
@@ -178,13 +179,19 @@ function createActiveRun(dialogId) {
     syncRunControlCountsAfterActiveRunChange('create_active_run', dialogId);
     return run.abortController.signal;
 }
-function clearActiveRun(dialogId) {
+function clearActiveRun(dialogId, options) {
     const deleted = activeRunsByDialogKey.delete(dialogId.key());
     if (!deleted) {
         clearQuarantiningRootDialogIfIdle(dialogId.rootId);
         return;
     }
     clearQuarantiningRootDialogIfIdle(dialogId.rootId);
+    if (dialogId.selfId === dialogId.rootId && options?.notifyBackendLoop !== false) {
+        dialog_global_registry_1.globalDialogRegistry.notifyActiveRunCleared(dialogId.rootId, {
+            source: 'dialog_display_state_active_run_clear',
+            reason: 'root_active_run_cleared',
+        });
+    }
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);
 }
 function clearQuarantiningRootDialogIfIdle(rootId) {

package/dist/dialog-global-registry.d.ts

@@ -1,7 +1,7 @@
 import type { RootDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
-    action: 'mark_needs_drive' | 'mark_not_needing_drive';
+    action: 'mark_needs_drive' | 'mark_not_needing_drive' | 'active_run_cleared';
     rootId: string;
     entryFound: boolean;
     previousNeedsDrive: boolean | null;
@@ -28,6 +28,10 @@ declare class GlobalDialogRegistry {
     waitForDriveTrigger(): Promise<DriveTriggerEvent>;
     markNeedsDrive(rootId: string, meta?: DriveTriggerMeta): void;
     markNotNeedingDrive(rootId: string, meta?: DriveTriggerMeta): void;
+    notifyActiveRunCleared(rootId: string, meta?: DriveTriggerMeta): void;
+    noteActiveRunBlockedQueuedDrive(rootId: string): void;
+    hasPendingActiveRunClearedWake(rootId: string): boolean;
+    isMarkedNeedingDrive(rootId: string): boolean;
     getDialogsNeedingDrive(): RootDialog[];
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
     getAll(): RootDialog[];

package/dist/dialog-global-registry.js

@@ -29,7 +29,11 @@ class GlobalDialogRegistry {
         if (existing) {
             return;
         }
-        this.entries.set(rootDialog.id.rootId, { rootDialog, needsDrive: false });
+        this.entries.set(rootDialog.id.rootId, {
+            rootDialog,
+            needsDrive: false,
+            activeRunClearedWakePending: false,
+        });
         void (async () => {
             try {
                 const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(rootDialog.id);
@@ -82,6 +86,8 @@ class GlobalDialogRegistry {
         const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = true;
+            // A fresh queueing trigger supersedes any earlier "wake me once active run clears" debt.
+            entry.activeRunClearedWakePending = false;
         }
         this.publishDriveTrigger({
             action: 'mark_needs_drive',
@@ -101,6 +107,7 @@ class GlobalDialogRegistry {
         const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = false;
+            entry.activeRunClearedWakePending = false;
         }
         this.publishDriveTrigger({
             action: 'mark_not_needing_drive',
@@ -111,6 +118,43 @@ class GlobalDialogRegistry {
             meta: triggerMeta,
         });
     }
+    notifyActiveRunCleared(rootId, meta) {
+        const triggerMeta = meta ?? {
+            source: 'unknown',
+            reason: 'unspecified',
+        };
+        const entry = this.entries.get(rootId);
+        if (!entry) {
+            return;
+        }
+        if (!entry.activeRunClearedWakePending || !entry.needsDrive) {
+            entry.activeRunClearedWakePending = false;
+            return;
+        }
+        const currentNeedsDrive = entry ? entry.needsDrive : null;
+        entry.activeRunClearedWakePending = false;
+        this.publishDriveTrigger({
+            action: 'active_run_cleared',
+            rootId,
+            entryFound: true,
+            previousNeedsDrive: currentNeedsDrive,
+            nextNeedsDrive: entry.needsDrive,
+            meta: triggerMeta,
+        });
+    }
+    noteActiveRunBlockedQueuedDrive(rootId) {
+        const entry = this.entries.get(rootId);
+        if (!entry || !entry.needsDrive) {
+            return;
+        }
+        entry.activeRunClearedWakePending = true;
+    }
+    hasPendingActiveRunClearedWake(rootId) {
+        return this.entries.get(rootId)?.activeRunClearedWakePending === true;
+    }
+    isMarkedNeedingDrive(rootId) {
+        return this.entries.get(rootId)?.needsDrive === true;
+    }
     getDialogsNeedingDrive() {
         return Array.from(this.entries.values())
             .filter((entry) => entry.needsDrive)

package/dist/llm/kernel-driver/flow.js

@@ -74,6 +74,38 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
+async function clearConsumedDeferredRootQueueIfIdle(dialog) {
+    if (dialog.id.selfId !== dialog.id.rootId) {
+        return;
+    }
+    if (!dialog_global_registry_1.globalDialogRegistry.get(dialog.id.rootId)) {
+        return;
+    }
+    const suspension = await dialog.getSuspensionStatus();
+    if (dialog.hasUpNext() || !suspension.canDrive) {
+        return;
+    }
+    const persistedNeedsDrive = await persistence_1.DialogPersistence.getNeedsDrive(dialog.id);
+    const registryNeedsDrive = dialog_global_registry_1.globalDialogRegistry.isMarkedNeedingDrive(dialog.id.rootId);
+    if (!registryNeedsDrive && !persistedNeedsDrive) {
+        return;
+    }
+    try {
+        await persistence_1.DialogPersistence.setNeedsDrive(dialog.id, false, dialog.status);
+    }
+    catch (error) {
+        log_1.log.error('kernel-driver failed to persist consumed deferred root queue cleanup', error, {
+            dialogId: dialog.id.valueOf(),
+            rootId: dialog.id.rootId,
+            selfId: dialog.id.selfId,
+        });
+        return;
+    }
+    dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(dialog.id.rootId, {
+        source: 'kernel_driver_flow_tail',
+        reason: 'root_idle_after_consuming_deferred_queue',
+    });
+}
 function hasNoPromptSubdialogResumeEntitlement(dialog, driveOptions) {
     const entitlement = driveOptions?.noPromptSubdialogResumeEntitlement;
     if (!entitlement) {
@@ -490,203 +522,224 @@ async function executeDriveRound(args) {
         if (!interruptedBySignal) {
             followUp = dialog.takeUpNext();
         }
-    }
-    finally {
-        if (activeRunPrimed && ownsActiveRun) {
-            (0, dialog_display_state_1.clearActiveRun)(dialog.id);
-        }
-        release();
-    }
-    if (dialog instanceof dialog_1.SubDialog &&
-        driveResult &&
-        !interruptedBySignal &&
-        (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
-        if (driveResult.fbrConclusion) {
-            await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                subdialog: dialog,
-                responseText: driveResult.fbrConclusion.responseText,
-                responseGenseq: driveResult.fbrConclusion.responseGenseq,
-                scheduleDrive: args.scheduleDrive,
-            });
-        }
-        else if (driveResult.lastAssistantSayingContent !== null) {
-            const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
-                Number.isFinite(driveResult.lastFunctionCallGenseq) &&
-                driveResult.lastFunctionCallGenseq > 0 &&
-                (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                    !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                    driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
-            if (hasInProgressFunctionCall) {
-                // Any function call means execution is still in-progress. Only supply when the callee
-                // has produced a newer assistant saying after the latest function call.
-                log_1.log.debug('kernel-driver skip subdialog response supply because latest saying is not after function calls', undefined, {
-                    rootId: dialog.id.rootId,
-                    selfId: dialog.id.selfId,
-                    lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
-                    lastFunctionCallGenseq: driveResult.lastFunctionCallGenseq,
-                });
-            }
-            else {
-                const hasFollowUp = followUp !== undefined;
-                const suspension = await dialog.getSuspensionStatus();
-                if (!suspension.canDrive || hasFollowUp) {
-                    log_1.log.debug('kernel-driver skip subdialog response supply while callee is not finalized', undefined, {
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                        waitingQ4H: suspension.q4h,
-                        waitingSubdialogs: suspension.subdialogs,
-                        hasFollowUp,
+        let tailError;
+        try {
+            if (dialog instanceof dialog_1.SubDialog &&
+                driveResult &&
+                !interruptedBySignal &&
+                (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
+                if (driveResult.fbrConclusion) {
+                    await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                        subdialog: dialog,
+                        responseText: driveResult.fbrConclusion.responseText,
+                        responseGenseq: driveResult.fbrConclusion.responseGenseq,
+                        scheduleDrive: args.scheduleDrive,
                     });
                 }
-                if (suspension.canDrive && !hasFollowUp) {
-                    if (!activeTellaskReplyDirective) {
-                        log_1.log.debug('kernel-driver skip implicit subdialog reply because no active tellask reply directive is bound to this drive', undefined, {
+                else if (driveResult.lastAssistantSayingContent !== null) {
+                    const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
+                        Number.isFinite(driveResult.lastFunctionCallGenseq) &&
+                        driveResult.lastFunctionCallGenseq > 0 &&
+                        (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                            driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                    if (hasInProgressFunctionCall) {
+                        // Any function call means execution is still in-progress. Only supply when the callee
+                        // has produced a newer assistant saying after the latest function call.
+                        log_1.log.debug('kernel-driver skip subdialog response supply because latest saying is not after function calls', undefined, {
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
+                            lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
+                            lastFunctionCallGenseq: driveResult.lastFunctionCallGenseq,
                         });
                     }
                     else {
-                        if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                            driveResult.lastAssistantSayingGenseq <= 0) {
-                            throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
-                        }
-                        const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
-                        const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
-                        let supplied = false;
-                        if (subdialogReplyTarget) {
-                            supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
-                                subdialog: dialog,
-                                responseText: driveResult.lastAssistantSayingContent,
-                                responseGenseq,
-                                target: subdialogReplyTarget,
-                                deliveryMode: 'direct_fallback',
-                                replyResolution: {
-                                    callId: directFallbackCallId,
-                                    replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                },
-                                scheduleDrive: args.scheduleDrive,
+                        const hasFollowUp = followUp !== undefined;
+                        const suspension = await dialog.getSuspensionStatus();
+                        if (!suspension.canDrive || hasFollowUp) {
+                            log_1.log.debug('kernel-driver skip subdialog response supply while callee is not finalized', undefined, {
+                                rootId: dialog.id.rootId,
+                                selfId: dialog.id.selfId,
+                                waitingQ4H: suspension.q4h,
+                                waitingSubdialogs: suspension.subdialogs,
+                                hasFollowUp,
                             });
-                            if (!supplied) {
-                                supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                    subdialog: dialog,
-                                    responseText: driveResult.lastAssistantSayingContent,
-                                    responseGenseq,
-                                    deliveryMode: 'direct_fallback',
-                                    replyResolution: {
-                                        callId: directFallbackCallId,
-                                        replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                    },
-                                    scheduleDrive: args.scheduleDrive,
+                        }
+                        if (suspension.canDrive && !hasFollowUp) {
+                            if (!activeTellaskReplyDirective) {
+                                log_1.log.debug('kernel-driver skip implicit subdialog reply because no active tellask reply directive is bound to this drive', undefined, {
+                                    rootId: dialog.id.rootId,
+                                    selfId: dialog.id.selfId,
                                 });
                             }
-                        }
-                        else {
-                            supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                subdialog: dialog,
-                                responseText: driveResult.lastAssistantSayingContent,
-                                responseGenseq,
-                                deliveryMode: 'direct_fallback',
-                                replyResolution: {
-                                    callId: directFallbackCallId,
-                                    replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
-                                },
-                                scheduleDrive: args.scheduleDrive,
-                            });
-                        }
-                        if (!supplied && subdialogReplyTarget) {
-                            const diagnostics = await loadPendingDiagnosticsSnapshot({
-                                rootId: dialog.id.rootId,
-                                ownerDialogId: subdialogReplyTarget.ownerDialogId,
-                                expectedSubdialogId: dialog.id.selfId,
-                                status: dialog.status,
-                            });
-                            log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
-                                calleeId: dialog.id.valueOf(),
-                                targetOwner: subdialogReplyTarget.ownerDialogId,
-                                targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
-                                targetCallType: subdialogReplyTarget.callType,
-                                targetCallId: subdialogReplyTarget.callId,
-                                diagnostics,
-                            });
+                            else {
+                                if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                                    !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                                    driveResult.lastAssistantSayingGenseq <= 0) {
+                                    throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
+                                }
+                                const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
+                                const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
+                                let supplied = false;
+                                if (subdialogReplyTarget) {
+                                    supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
+                                        subdialog: dialog,
+                                        responseText: driveResult.lastAssistantSayingContent,
+                                        responseGenseq,
+                                        target: subdialogReplyTarget,
+                                        deliveryMode: 'direct_fallback',
+                                        replyResolution: {
+                                            callId: directFallbackCallId,
+                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                        },
+                                        scheduleDrive: args.scheduleDrive,
+                                    });
+                                    if (!supplied) {
+                                        supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                                            subdialog: dialog,
+                                            responseText: driveResult.lastAssistantSayingContent,
+                                            responseGenseq,
+                                            deliveryMode: 'direct_fallback',
+                                            replyResolution: {
+                                                callId: directFallbackCallId,
+                                                replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                            },
+                                            scheduleDrive: args.scheduleDrive,
+                                        });
+                                    }
+                                }
+                                else {
+                                    supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
+                                        subdialog: dialog,
+                                        responseText: driveResult.lastAssistantSayingContent,
+                                        responseGenseq,
+                                        deliveryMode: 'direct_fallback',
+                                        replyResolution: {
+                                            callId: directFallbackCallId,
+                                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
+                                        },
+                                        scheduleDrive: args.scheduleDrive,
+                                    });
+                                }
+                                if (!supplied && subdialogReplyTarget) {
+                                    const diagnostics = await loadPendingDiagnosticsSnapshot({
+                                        rootId: dialog.id.rootId,
+                                        ownerDialogId: subdialogReplyTarget.ownerDialogId,
+                                        expectedSubdialogId: dialog.id.selfId,
+                                        status: dialog.status,
+                                    });
+                                    log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
+                                        calleeId: dialog.id.valueOf(),
+                                        targetOwner: subdialogReplyTarget.ownerDialogId,
+                                        targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
+                                        targetCallType: subdialogReplyTarget.callType,
+                                        targetCallId: subdialogReplyTarget.callId,
+                                        diagnostics,
+                                    });
+                                }
+                            }
                         }
                     }
                 }
             }
-        }
-    }
-    if (!(dialog instanceof dialog_1.SubDialog) &&
-        driveResult &&
-        !interruptedBySignal &&
-        driveResult.lastAssistantSayingContent !== null &&
-        activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
-        followUp === undefined) {
-        const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
-            Number.isFinite(driveResult.lastFunctionCallGenseq) &&
-            driveResult.lastFunctionCallGenseq > 0 &&
-            (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
-        if (!hasInProgressFunctionCall) {
-            if (!activePromptWasReplyToolReminder) {
-                const language = (0, work_language_1.getWorkLanguage)();
-                followUp = {
-                    prompt: await buildReplyToolReminderPrompt({
-                        dlg: dialog,
-                        directive: activeTellaskReplyDirective,
-                        language,
-                    }),
-                    msgId: (0, id_1.generateShortId)(),
-                    grammar: 'markdown',
-                    origin: 'runtime',
-                    userLanguageCode: language,
-                    tellaskReplyDirective: activeTellaskReplyDirective,
-                };
-                log_1.log.debug('kernel-driver queued replyTellaskBack reminder prompt after plain reply', undefined, {
-                    dialogId: dialog.id.valueOf(),
-                    targetCallId: activeTellaskReplyDirective.targetCallId,
-                });
+            if (!(dialog instanceof dialog_1.SubDialog) &&
+                driveResult &&
+                !interruptedBySignal &&
+                driveResult.lastAssistantSayingContent !== null &&
+                activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
+                followUp === undefined) {
+                const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
+                    Number.isFinite(driveResult.lastFunctionCallGenseq) &&
+                    driveResult.lastFunctionCallGenseq > 0 &&
+                    (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+                        !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+                        driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                if (!hasInProgressFunctionCall) {
+                    if (!activePromptWasReplyToolReminder) {
+                        const language = (0, work_language_1.getWorkLanguage)();
+                        followUp = {
+                            prompt: await buildReplyToolReminderPrompt({
+                                dlg: dialog,
+                                directive: activeTellaskReplyDirective,
+                                language,
+                            }),
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            origin: 'runtime',
+                            userLanguageCode: language,
+                            tellaskReplyDirective: activeTellaskReplyDirective,
+                        };
+                        log_1.log.debug('kernel-driver queued replyTellaskBack reminder prompt after plain reply', undefined, {
+                            dialogId: dialog.id.valueOf(),
+                            targetCallId: activeTellaskReplyDirective.targetCallId,
+                        });
+                    }
+                    else {
+                        await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
+                            dlg: dialog,
+                            directive: activeTellaskReplyDirective,
+                            replyContent: driveResult.lastAssistantSayingContent,
+                            callbacks: {
+                                scheduleDrive: args.scheduleDrive,
+                                driveDialog: args.driveDialog,
+                            },
+                            deliveryMode: 'direct_fallback',
+                        });
+                        await dialog.appendTellaskReplyResolution({
+                            callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
+                            replyCallName: 'replyTellaskBack',
+                            targetCallId: activeTellaskReplyDirective.targetCallId,
+                        });
+                    }
+                }
             }
-            else {
-                await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
-                    dlg: dialog,
-                    directive: activeTellaskReplyDirective,
-                    replyContent: driveResult.lastAssistantSayingContent,
-                    callbacks: {
-                        scheduleDrive: args.scheduleDrive,
-                        driveDialog: args.driveDialog,
+            if (followUp) {
+                args.scheduleDrive(dialog, {
+                    waitInQue: true,
+                    driveOptions: {
+                        source: 'kernel_driver_follow_up',
+                        reason: 'follow_up_prompt',
+                    },
+                    humanPrompt: {
+                        content: followUp.prompt,
+                        msgId: followUp.msgId,
+                        grammar: followUp.grammar ?? 'markdown',
+                        origin: followUp.origin,
+                        userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
+                            ? followUp.userLanguageCode
+                            : undefined,
+                        q4hAnswerCallId: followUp.q4hAnswerCallId,
+                        tellaskReplyDirective: followUp.tellaskReplyDirective,
+                        skipTaskdoc: followUp.skipTaskdoc,
+                        subdialogReplyTarget: followUp.subdialogReplyTarget,
+                        runControl: followUp.runControl,
                     },
-                    deliveryMode: 'direct_fallback',
                 });
-                await dialog.appendTellaskReplyResolution({
-                    callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
-                    replyCallName: 'replyTellaskBack',
-                    targetCallId: activeTellaskReplyDirective.targetCallId,
+            }
+        }
+        catch (error) {
+            tailError = error;
+        }
+        if (tailError === undefined) {
+            try {
+                await clearConsumedDeferredRootQueueIfIdle(dialog);
+            }
+            catch (error) {
+                log_1.log.error('kernel-driver failed to reconcile consumed deferred root queue after tail', error, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
                 });
             }
         }
+        if (tailError !== undefined) {
+            throw tailError;
+        }
     }
-    if (followUp) {
-        args.scheduleDrive(dialog, {
-            waitInQue: true,
-            driveOptions: {
-                source: 'kernel_driver_follow_up',
-                reason: 'follow_up_prompt',
-            },
-            humanPrompt: {
-                content: followUp.prompt,
-                msgId: followUp.msgId,
-                grammar: followUp.grammar ?? 'markdown',
-                origin: followUp.origin,
-                userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
-                    ? followUp.userLanguageCode
-                    : undefined,
-                q4hAnswerCallId: followUp.q4hAnswerCallId,
-                tellaskReplyDirective: followUp.tellaskReplyDirective,
-                skipTaskdoc: followUp.skipTaskdoc,
-                subdialogReplyTarget: followUp.subdialogReplyTarget,
-                runControl: followUp.runControl,
-            },
-        });
+    finally {
+        if (activeRunPrimed && ownsActiveRun) {
+            (0, dialog_display_state_1.clearActiveRun)(dialog.id);
+        }
+        release();
     }
 }

package/dist/llm/kernel-driver/loop.js

@@ -36,6 +36,11 @@ async function driveQueuedDialogsOnce() {
                 continue;
             }
             if ((0, dialog_display_state_1.hasActiveRun)(rootDialog.id)) {
+                log_1.log.debug('Backend driver deferred queued root drive because dialog already has an active run', undefined, {
+                    dialogId: rootDialog.id.valueOf(),
+                    rootId: rootDialog.id.rootId,
+                });
+                dialog_global_registry_1.globalDialogRegistry.noteActiveRunBlockedQueuedDrive(rootDialog.id.rootId);
                 continue;
             }
             if (!(await rootDialog.canDrive())) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.16.2",
+  "version": "1.16.3",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,9 +52,9 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
+    "@longrun-ai/codex-auth": "0.12.0",
     "@longrun-ai/kernel": "1.8.11",
-    "@longrun-ai/shell": "1.8.11",
-    "@longrun-ai/codex-auth": "0.12.0"
+    "@longrun-ai/shell": "1.8.11"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",