dominds 1.4.1 → 1.4.2

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

@@ -10,16 +10,22 @@ const events_1 = require("./events");
 const flow_1 = require("./flow");
 const subdialog_1 = require("./subdialog");
 const types_1 = require("./types");
+function dispatchDrive(dialog, options) {
+    if (options.humanPrompt) {
+        return driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+    }
+    return driveDialogStream(dialog, undefined, options.waitInQue, options.driveOptions);
+}
 async function driveDialogStream(...driveArgs) {
     const runtime = (0, types_1.createKernelDriverRuntimeState)();
     return await (0, flow_1.executeDriveRound)({
         runtime,
         driveArgs,
         scheduleDrive: (dialog, options) => {
-            void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+            void dispatchDrive(dialog, options);
         },
         driveDialog: async (dialog, options) => {
-            await driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+            await dispatchDrive(dialog, options);
         },
     });
 }
@@ -38,7 +44,7 @@ async function supplyResponseToSupdialog(...args) {
         status,
         calleeResponseRef,
         scheduleDrive: (dialog, options) => {
-            void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+            void dispatchDrive(dialog, options);
         },
     });
 }
@@ -55,7 +61,7 @@ async function supplyResponseToSubdialogBridge(parentDialog, subdialogId, respon
         status,
         calleeResponseRef,
         scheduleDrive: (dialog, options) => {
-            void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+            void dispatchDrive(dialog, options);
         },
     });
 }

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

@@ -49,6 +49,60 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
+function resolveDriveRequestSource(humanPrompt, driveOptions) {
+    if (driveOptions?.source) {
+        return driveOptions.source;
+    }
+    if (humanPrompt?.origin === 'user') {
+        return 'ws_user_message';
+    }
+    return 'unspecified';
+}
+async function inspectNoPromptSubdialogDrive(args) {
+    const source = resolveDriveRequestSource(undefined, args.driveOptions);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    const runState = latest?.runState;
+    const rawCourse = latest?.currentCourse ?? args.dialog.currentCourse;
+    const currentCourse = Number.isFinite(rawCourse) && rawCourse > 0 ? Math.floor(rawCourse) : 1;
+    const courseEvents = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, currentCourse, args.dialog.status);
+    const rawLastEvent = courseEvents[courseEvents.length - 1];
+    const lastEvent = rawLastEvent?.type === 'teammate_call_anchor_record'
+        ? { type: rawLastEvent.type, anchorRole: rawLastEvent.anchorRole }
+        : rawLastEvent
+            ? { type: rawLastEvent.type }
+            : undefined;
+    const explicitInterruptedResumeAllowed = args.driveOptions?.allowResumeFromInterrupted === true && runState?.kind === 'interrupted';
+    const supplyResponseParentReviveAllowed = source === 'kernel_driver_supply_response_parent_revive' &&
+        runState?.kind === 'blocked' &&
+        runState.reason.kind === 'waiting_for_subdialogs';
+    if (lastEvent?.type === 'teammate_call_anchor_record' && lastEvent.anchorRole === 'response') {
+        return {
+            shouldReject: true,
+            source,
+            rejection: 'finalized_after_response_anchor',
+            runState,
+            currentCourse,
+            lastEvent,
+        };
+    }
+    if (!explicitInterruptedResumeAllowed && !supplyResponseParentReviveAllowed) {
+        return {
+            shouldReject: true,
+            source,
+            rejection: 'missing_explicit_interrupted_resume_entitlement',
+            runState,
+            currentCourse,
+            lastEvent,
+        };
+    }
+    return {
+        shouldReject: false,
+        source,
+        runState,
+        currentCourse,
+        lastEvent,
+    };
+}
 function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
         return humanPrompt;
@@ -82,6 +136,7 @@ async function executeDriveRound(args) {
     let driveResult;
     let subdialogReplyTarget;
     const allowResumeFromInterrupted = driveOptions?.allowResumeFromInterrupted === true || humanPrompt?.origin === 'user';
+    const driveSource = resolveDriveRequestSource(humanPrompt, driveOptions);
     try {
         // Prime active-run registration right after acquiring dialog lock so user stop can
         // reliably interrupt queued auto-revive drives during preflight.
@@ -125,6 +180,38 @@ async function executeDriveRound(args) {
         // suspended by pending Q4H or subdialogs. This prevents duplicate generations when
         // multiple wake-ups race around the same subdialog completion boundary.
         if (!humanPrompt) {
+            if (dialog instanceof dialog_1.SubDialog && !dialog.hasUpNext()) {
+                try {
+                    const inspection = await inspectNoPromptSubdialogDrive({ dialog, driveOptions });
+                    if (inspection.shouldReject) {
+                        log_1.log.error('Rejected unexpected no-prompt subdialog drive request', undefined, {
+                            dialogId: dialog.id.valueOf(),
+                            rootId: dialog.id.rootId,
+                            selfId: dialog.id.selfId,
+                            source: inspection.source,
+                            reason: driveOptions?.reason ?? null,
+                            rejection: inspection.rejection,
+                            allowResumeFromInterrupted: driveOptions?.allowResumeFromInterrupted === true,
+                            runState: inspection.runState ?? null,
+                            currentCourse: inspection.currentCourse,
+                            lastEvent: inspection.lastEvent ?? null,
+                            waitInQue,
+                        });
+                        return;
+                    }
+                }
+                catch (err) {
+                    log_1.log.error('Failed to inspect unexpected no-prompt subdialog drive request', err, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        source: driveSource,
+                        reason: driveOptions?.reason ?? null,
+                        allowResumeFromInterrupted: driveOptions?.allowResumeFromInterrupted === true,
+                    });
+                    return;
+                }
+            }
             const suspension = await dialog.getSuspensionStatus();
             if (!suspension.canDrive) {
                 const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(dialog.id.rootId);
@@ -149,6 +236,8 @@ async function executeDriveRound(args) {
                             nextNeedsDrive: lastTrigger.nextNeedsDrive,
                         }
                         : null,
+                    source: driveSource,
+                    reason: driveOptions?.reason ?? null,
                 });
                 return;
             }
@@ -333,6 +422,10 @@ async function executeDriveRound(args) {
     if (followUp) {
         args.scheduleDrive(dialog, {
             waitInQue: true,
+            driveOptions: {
+                source: 'kernel_driver_follow_up',
+                reason: 'follow_up_prompt',
+            },
             humanPrompt: {
                 content: followUp.prompt,
                 msgId: followUp.msgId,

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

@@ -34,7 +34,10 @@ async function driveQueuedDialogsOnce() {
             if (!(await rootDialog.canDrive())) {
                 continue;
             }
-            await (0, engine_1.driveDialogStream)(rootDialog, undefined, true);
+            await (0, engine_1.driveDialogStream)(rootDialog, undefined, true, {
+                source: 'kernel_driver_backend_loop',
+                reason: 'global_dialog_registry_needs_drive',
+            });
             const status = await rootDialog.getSuspensionStatus();
             const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
             if (shouldStayQueued) {

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

@@ -356,7 +356,11 @@ async function supplyResponseToSupdialog(args) {
             if (!isRoot || !hasRegistryEntry) {
                 scheduleDrive(parentDialog, {
                     waitInQue: true,
-                    driveOptions: { suppressDiligencePush: parentDialog.disableDiligencePush },
+                    driveOptions: {
+                        suppressDiligencePush: parentDialog.disableDiligencePush,
+                        source: 'kernel_driver_supply_response_parent_revive',
+                        reason: `all_pending_subdialogs_resolved:type_${callType}`,
+                    },
                 });
             }
         }

package/dist/llm/kernel-driver/tellask-special.js

@@ -594,7 +594,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                         : {}),
                 };
                 try {
-                    await callbacks.driveDialog(sub, { humanPrompt: initPrompt, waitInQue: true });
+                    await callbacks.driveDialog(sub, {
+                        humanPrompt: initPrompt,
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_fbr_subdialog_round',
+                            reason: `fbr_round_${i}_of_${fbrEffort}`,
+                        },
+                    });
                 }
                 catch (error) {
                     const detail = error instanceof Error ? error.message : String(error);
@@ -668,7 +675,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                         grammar: 'markdown',
                         origin: 'runtime',
                     };
-                    await callbacks.driveDialog(supdialog, { humanPrompt: supPrompt, waitInQue: true });
+                    await callbacks.driveDialog(supdialog, {
+                        humanPrompt: supPrompt,
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_type_a_supdialog_call',
+                            reason: 'type_a_supdialog_roundtrip',
+                        },
+                    });
                     const responseText = await extractSupdialogResponseForTypeA(supdialog);
                     const responseContent = (0, inter_dialog_format_1.formatTeammateResponseContent)({
                         callName,
@@ -793,7 +807,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                             callId,
                         },
                     };
-                    callbacks.scheduleDrive(sub, { humanPrompt: initPrompt, waitInQue: true });
+                    callbacks.scheduleDrive(sub, {
+                        humanPrompt: initPrompt,
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_subdialog_init',
+                            reason: 'type_b_fallback_subdialog_init',
+                        },
+                    });
                     subdialogsCreated.push(sub.id);
                     suspend = true;
                 }
@@ -877,7 +898,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                             callId,
                         },
                     };
-                    callbacks.scheduleDrive(result.subdialog, { humanPrompt: resumePrompt, waitInQue: true });
+                    callbacks.scheduleDrive(result.subdialog, {
+                        humanPrompt: resumePrompt,
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_subdialog_resume',
+                            reason: 'type_b_registered_subdialog_resume',
+                        },
+                    });
                 }
                 else {
                     const initPrompt = {
@@ -900,7 +928,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                             callId,
                         },
                     };
-                    callbacks.scheduleDrive(result.subdialog, { humanPrompt: initPrompt, waitInQue: true });
+                    callbacks.scheduleDrive(result.subdialog, {
+                        humanPrompt: initPrompt,
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_subdialog_init',
+                            reason: 'type_b_registered_subdialog_init',
+                        },
+                    });
                 }
                 subdialogsCreated.push(result.subdialog.id);
                 suspend = true;
@@ -949,7 +984,14 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
                         callId,
                     },
                 };
-                callbacks.scheduleDrive(sub, { humanPrompt: initPrompt, waitInQue: true });
+                callbacks.scheduleDrive(sub, {
+                    humanPrompt: initPrompt,
+                    waitInQue: true,
+                    driveOptions: {
+                        source: 'kernel_driver_subdialog_init',
+                        reason: 'type_c_subdialog_init',
+                    },
+                });
                 subdialogsCreated.push(sub.id);
                 suspend = true;
             }

package/dist/server/websocket-handler.js

@@ -451,7 +451,10 @@ async function maybeTriggerImmediateDiligencePrompt(rootDialog) {
             });
         }
         if (prepared.kind === 'prompt') {
-            await (0, kernel_driver_1.driveDialogStream)(rootDialog, prepared.prompt, true);
+            await (0, kernel_driver_1.driveDialogStream)(rootDialog, prepared.prompt, true, {
+                source: 'ws_diligence_push',
+                reason: 'enable_keep_going_immediate_prompt',
+            });
         }
     }
     catch (error) {
@@ -1008,7 +1011,10 @@ async function handleUserMsg2Dlg(ws, packet) {
                 grammar: effectivePrompt.grammar,
                 userLanguageCode: effectivePrompt.userLanguageCode,
                 origin: 'user',
-            }, true, undefined);
+            }, true, {
+                source: 'ws_user_message',
+                reason: 'drive_dlg_by_user_msg',
+            });
             return;
         }
         // Dialog not found in wsLiveDlg - drive using the canonical root/subdialog instances.
@@ -1038,7 +1044,10 @@ async function handleUserMsg2Dlg(ws, packet) {
                 grammar: effectivePrompt.grammar,
                 userLanguageCode: effectivePrompt.userLanguageCode,
                 origin: 'user',
-            }, true, undefined);
+            }, true, {
+                source: 'ws_user_message',
+                reason: 'drive_dlg_by_user_msg',
+            });
             return;
         }
         catch (restoreError) {
@@ -1116,7 +1125,11 @@ async function handleResumeDialog(ws, packet) {
         return;
     }
     const restored = await restoreDialogForDrive(dialogIdObj, 'running');
-    await (0, kernel_driver_1.driveDialogStream)(restored, undefined, true, { allowResumeFromInterrupted: true });
+    await (0, kernel_driver_1.driveDialogStream)(restored, undefined, true, {
+        allowResumeFromInterrupted: true,
+        source: 'ws_resume_dialog',
+        reason: 'resume_dialog',
+    });
 }
 async function handleResumeAll(ws, packet) {
     if (packet.type !== 'resume_all') {
@@ -1131,7 +1144,11 @@ async function handleResumeAll(ws, packet) {
         void (async () => {
             try {
                 const dlg = await restoreDialogForDrive(id, 'running');
-                await (0, kernel_driver_1.driveDialogStream)(dlg, undefined, true, { allowResumeFromInterrupted: true });
+                await (0, kernel_driver_1.driveDialogStream)(dlg, undefined, true, {
+                    allowResumeFromInterrupted: true,
+                    source: 'ws_resume_all',
+                    reason: 'resume_all',
+                });
             }
             catch (err) {
                 log.warn('resume_all: failed to resume dialog', err, { dialogId: id.valueOf() });
@@ -1250,7 +1267,10 @@ async function handleUserAnswer2Q4H(ws, packet) {
             userLanguageCode: effectivePrompt.userLanguageCode,
             q4hAnswerCallIds: askHumanCallIds,
             origin: 'user',
-        }, true, undefined);
+        }, true, {
+            source: 'ws_user_answer',
+            reason: 'drive_dialog_by_user_answer',
+        });
     }
     catch (error) {
         log.error('Error processing Q4H user answer:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "DevOps Mindsets — Sustainable Agentic Product Lifecycle",
   "type": "commonjs",
   "private": false,