dominds 0.7.3 → 0.7.5

package/dist/dialog-global-registry.js

@@ -6,6 +6,7 @@ const evt_1 = require("./shared/evt");
 class GlobalDialogRegistry {
     constructor() {
         this.entries = new Map();
+        this.lastDriveTriggerByRootId = new Map();
         this.driveTriggerPubChan = (0, evt_1.createPubChan)();
         this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
     }
@@ -48,7 +49,7 @@ class GlobalDialogRegistry {
         this.entries.delete(rootId);
     }
     publishDriveTrigger(args) {
-        this.driveTriggerPubChan.write({
+        const trigger = {
             type: 'drive_trigger_evt',
             action: args.action,
             rootId: args.rootId,
@@ -58,7 +59,9 @@ class GlobalDialogRegistry {
             source: args.meta.source,
             reason: args.meta.reason,
             emittedAtMs: Date.now(),
-        });
+        };
+        this.lastDriveTriggerByRootId.set(args.rootId, trigger);
+        this.driveTriggerPubChan.write(trigger);
     }
     async waitForDriveTrigger() {
         for (;;) {
@@ -113,6 +116,9 @@ class GlobalDialogRegistry {
             .filter((entry) => entry.needsDrive)
             .map((entry) => entry.rootDialog);
     }
+    getLastDriveTrigger(rootId) {
+        return this.lastDriveTriggerByRootId.get(rootId);
+    }
     getAll() {
         return Array.from(this.entries.values()).map((entry) => entry.rootDialog);
     }

package/dist/evt-registry.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dialogEventRegistry = void 0;
+exports.setGlobalDialogEventBroadcaster = setGlobalDialogEventBroadcaster;
 exports.setQ4HBroadcaster = setQ4HBroadcaster;
 exports.postDialogEvent = postDialogEvent;
 exports.postDialogEventById = postDialogEventById;
@@ -18,22 +19,45 @@ class DialogEventRegistryImpl {
     constructor() {
         this.pubChans = new Map();
         this.log = (0, log_1.createLogger)('evt-registry');
-        // Q4H (Questions for Human) is globally visible in the WebUI.
-        // These events must reach ALL connected clients, not only those subscribed to a specific dialog stream.
-        this.q4hBroadcaster = null;
+        // Some dialog events are global UI state updates. They must reach ALL connected clients,
+        // not only those subscribed to a specific dialog stream.
+        this.globalDialogEventBroadcaster = null;
     }
-    setQ4HBroadcaster(fn) {
-        this.q4hBroadcaster = fn;
+    setGlobalDialogEventBroadcaster(fn) {
+        this.globalDialogEventBroadcaster = fn;
     }
-    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 false;
-        const fn = this.q4hBroadcaster;
+    broadcastGlobalEvent(evt) {
+        const fn = this.globalDialogEventBroadcaster;
+        if (!fn)
+            return;
+        fn(evt);
+    }
+    emitDialogTouched(source) {
+        if (source.type === 'dlg_touched_evt')
+            return;
+        const touchedEvt = {
+            dialog: source.dialog,
+            timestamp: source.timestamp,
+            type: 'dlg_touched_evt',
+            sourceType: source.type,
+        };
+        this.broadcastGlobalEvent(touchedEvt);
+    }
+    dispatchGloballyIfNeeded(evt) {
+        // Global-only delivery prevents duplicate deliveries from two independent paths
+        // (global broadcaster + dialog-scoped stream).
+        switch (evt.type) {
+            case 'new_q4h_asked':
+            case 'q4h_answered':
+            case 'subdialog_created_evt':
+            case 'dlg_touched_evt':
+                break;
+            default:
+                return false;
+        }
+        const fn = this.globalDialogEventBroadcaster;
         if (!fn) {
-            throw new Error(`Q4H broadcaster missing: cannot publish ${evt.type} for dialog=${evt.dialog.selfId}`);
+            throw new Error(`Global dialog event broadcaster missing: cannot publish ${evt.type} for dialog=${evt.dialog.selfId}`);
         }
         fn(evt);
         return true;
@@ -80,7 +104,8 @@ class DialogEventRegistryImpl {
      */
     postEvent(dlg, event) {
         const typedEvent = this.createTypedEvent(dlg.id, event);
-        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+        this.emitDialogTouched(typedEvent);
+        if (this.dispatchGloballyIfNeeded(typedEvent)) {
             return;
         }
         const chan = this.getPubChan(dlg.id);
@@ -88,7 +113,8 @@ class DialogEventRegistryImpl {
     }
     postEventById(dialogId, event) {
         const typedEvent = this.createTypedEvent(dialogId, event);
-        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+        this.emitDialogTouched(typedEvent);
+        if (this.dispatchGloballyIfNeeded(typedEvent)) {
             return;
         }
         const chan = this.getPubChan(dialogId);
@@ -115,8 +141,12 @@ class DialogEventRegistryImpl {
 }
 // Export singleton instance
 exports.dialogEventRegistry = new DialogEventRegistryImpl();
+function setGlobalDialogEventBroadcaster(fn) {
+    exports.dialogEventRegistry.setGlobalDialogEventBroadcaster(fn);
+}
+// Backward-compatible alias used by existing tests/callers.
 function setQ4HBroadcaster(fn) {
-    exports.dialogEventRegistry.setQ4HBroadcaster(fn);
+    setGlobalDialogEventBroadcaster(fn);
 }
 // Export helper function to import in other modules
 function postDialogEvent(dlg, event) {

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

@@ -1,6 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = void 0;
+exports.resetContextHealthRoundState = resetContextHealthRoundState;
+exports.resolveCriticalCountdownRemaining = resolveCriticalCountdownRemaining;
+exports.consumeCriticalCountdown = consumeCriticalCountdown;
 exports.decideDriverV2ContextHealth = decideDriverV2ContextHealth;
+exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
+const contextHealthRoundStateByDialogKey = new Map();
+function getContextHealthRoundState(dialogKey) {
+    const existing = contextHealthRoundStateByDialogKey.get(dialogKey);
+    if (existing) {
+        return existing;
+    }
+    const created = {};
+    contextHealthRoundStateByDialogKey.set(dialogKey, created);
+    return created;
+}
+function resetContextHealthRoundState(dialogKey) {
+    contextHealthRoundStateByDialogKey.delete(dialogKey);
+}
+function resolveCriticalCountdownRemaining(dialogKey, snapshot) {
+    if (!snapshot || snapshot.kind !== 'available') {
+        resetContextHealthRoundState(dialogKey);
+        return exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS;
+    }
+    if (snapshot.level !== 'critical') {
+        if (snapshot.level === 'healthy') {
+            resetContextHealthRoundState(dialogKey);
+            return exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS;
+        }
+        const state = getContextHealthRoundState(dialogKey);
+        state.lastSeenLevel = snapshot.level;
+        state.criticalCountdownRemaining = undefined;
+        return exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS;
+    }
+    const state = getContextHealthRoundState(dialogKey);
+    if (state.lastSeenLevel !== 'critical' ||
+        typeof state.criticalCountdownRemaining !== 'number' ||
+        !Number.isFinite(state.criticalCountdownRemaining)) {
+        state.lastSeenLevel = 'critical';
+        state.criticalCountdownRemaining = exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS;
+    }
+    const remaining = Math.floor(state.criticalCountdownRemaining);
+    return remaining > 0 ? remaining : 0;
+}
+function consumeCriticalCountdown(dialogKey) {
+    const state = getContextHealthRoundState(dialogKey);
+    const currentRaw = typeof state.criticalCountdownRemaining === 'number' &&
+        Number.isFinite(state.criticalCountdownRemaining)
+        ? Math.floor(state.criticalCountdownRemaining)
+        : exports.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS;
+    const current = currentRaw > 0 ? currentRaw : 0;
+    const next = Math.max(0, current - 1);
+    state.lastSeenLevel = 'critical';
+    state.criticalCountdownRemaining = next;
+    return next;
+}
 function decideDriverV2ContextHealth(args) {
     const { snapshot } = args;
     if (!snapshot || snapshot.kind !== 'available') {

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

@@ -10,12 +10,14 @@ 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 id_1 = require("../../shared/utils/id");
 const tellask_1 = require("../../tellask");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
 const registry_1 = require("../gen/registry");
 const tools_projection_1 = require("../tools-projection");
 const context_1 = require("./context");
+const context_health_1 = require("./context-health");
 const policy_1 = require("./policy");
 const runtime_utils_1 = require("./runtime-utils");
 const saying_events_1 = require("./saying-events");
@@ -58,6 +60,12 @@ function resolveUpNextPrompt(dlg) {
         userLanguageCode: upNext.userLanguageCode,
     };
 }
+function isUserOriginPrompt(prompt) {
+    if (!prompt) {
+        return false;
+    }
+    return (prompt.origin ?? 'user') === 'user';
+}
 async function emitUserMarkdown(dlg, content) {
     if (!content.trim()) {
         return;
@@ -428,6 +436,63 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
             const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, canonicalFuncTools);
             const funcTools = projected.tools;
+            if (genIterNo > 1) {
+                const snapshot = dlg.getLastContextHealth();
+                const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
+                const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dlg.id.key(), snapshot);
+                const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
+                    snapshot,
+                    hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
+                    criticalCountdownRemaining,
+                });
+                if (healthDecision.kind === 'suspend') {
+                    log_1.log.info('driver-v2 suspend iterative generation due to critical context while waiting for human prompt', undefined, {
+                        dialogId: dlg.id.valueOf(),
+                        rootId: dlg.id.rootId,
+                        selfId: dlg.id.selfId,
+                        genIterNo,
+                        pendingPromptOrigin: pendingPrompt?.origin ?? null,
+                    });
+                    break;
+                }
+                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 dlg.startNewCourse(newCoursePrompt);
+                        dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+                        (0, context_health_1.resetContextHealthRoundState)(dlg.id.key());
+                        const nextPrompt = resolveUpNextPrompt(dlg);
+                        if (!nextPrompt) {
+                            throw new Error(`driver-v2 critical force-new-course invariant violation: missing upNext prompt after startNewCourse for dialog=${dlg.id.valueOf()}`);
+                        }
+                        pendingPrompt = nextPrompt;
+                        skipTaskdocForThisDrive = false;
+                    }
+                    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: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                                promptsTotal: context_health_1.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
+                            });
+                        pendingPrompt = {
+                            content: guideText,
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            userLanguageCode: language,
+                        };
+                    }
+                }
+            }
             let suspendForHuman = false;
             let llmGenModelForGen = model;
             let contextHealthForGen;

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

@@ -88,11 +88,47 @@ async function driveQueuedDialogsOnce() {
                 });
                 await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
             }
+            const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(rootDialog.id.rootId);
+            const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
             if (status.subdialogs) {
-                log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`);
+                log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`, {
+                    rootId: rootDialog.id.rootId,
+                    waitingQ4H: status.q4h,
+                    waitingSubdialogs: status.subdialogs,
+                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    lastDriveTrigger: lastTrigger
+                        ? {
+                            action: lastTrigger.action,
+                            source: lastTrigger.source,
+                            reason: lastTrigger.reason,
+                            emittedAtMs: lastTrigger.emittedAtMs,
+                            ageMs: lastTriggerAgeMs,
+                            entryFound: lastTrigger.entryFound,
+                            previousNeedsDrive: lastTrigger.previousNeedsDrive,
+                            nextNeedsDrive: lastTrigger.nextNeedsDrive,
+                        }
+                        : null,
+                });
             }
             if (status.q4h) {
-                log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`);
+                log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`, {
+                    rootId: rootDialog.id.rootId,
+                    waitingQ4H: status.q4h,
+                    waitingSubdialogs: status.subdialogs,
+                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    lastDriveTrigger: lastTrigger
+                        ? {
+                            action: lastTrigger.action,
+                            source: lastTrigger.source,
+                            reason: lastTrigger.reason,
+                            emittedAtMs: lastTrigger.emittedAtMs,
+                            ageMs: lastTriggerAgeMs,
+                            entryFound: lastTrigger.entryFound,
+                            previousNeedsDrive: lastTrigger.previousNeedsDrive,
+                            nextNeedsDrive: lastTrigger.nextNeedsDrive,
+                        }
+                        : null,
+                });
             }
         }
         catch (err) {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDriveRound = executeDriveRound;
 const dialog_1 = require("../../dialog");
+const dialog_global_registry_1 = require("../../dialog-global-registry");
 const dialog_run_state_1 = require("../../dialog-run-state");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
@@ -13,7 +14,6 @@ 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 {
@@ -44,57 +44,6 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
-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;
@@ -167,6 +116,8 @@ async function executeDriveRound(args) {
         if (!humanPrompt) {
             const suspension = await dialog.getSuspensionStatus();
             if (!suspension.canDrive) {
+                const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(dialog.id.rootId);
+                const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
                 log_1.log.info('driver-v2 skip queued auto-drive while dialog is suspended', {
                     dialogId: dialog.id.valueOf(),
                     rootId: dialog.id.rootId,
@@ -175,6 +126,18 @@ async function executeDriveRound(args) {
                     hasQueuedUpNext: dialog.hasUpNext(),
                     waitingQ4H: suspension.q4h,
                     waitingSubdialogs: suspension.subdialogs,
+                    lastDriveTrigger: lastTrigger
+                        ? {
+                            action: lastTrigger.action,
+                            source: lastTrigger.source,
+                            reason: lastTrigger.reason,
+                            emittedAtMs: lastTrigger.emittedAtMs,
+                            ageMs: lastTriggerAgeMs,
+                            entryFound: lastTrigger.entryFound,
+                            previousNeedsDrive: lastTrigger.previousNeedsDrive,
+                            nextNeedsDrive: lastTrigger.nextNeedsDrive,
+                        }
+                        : null,
                 });
                 return;
             }
@@ -193,7 +156,7 @@ async function executeDriveRound(args) {
         }
         const snapshot = dialog.getLastContextHealth();
         const hasQueuedUpNext = dialog.hasUpNext();
-        const criticalCountdownRemaining = resolveCriticalCountdownRemaining(dialog, snapshot);
+        const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dialog.id.key(), snapshot);
         const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
             snapshot,
             hadUserPromptThisGen: humanPrompt !== undefined,
@@ -211,7 +174,7 @@ async function executeDriveRound(args) {
                     : '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);
+                (0, context_health_1.resetContextHealthRoundState)(dialog.id.key());
             }
             else if (!hasQueuedUpNext) {
                 const language = (0, runtime_language_1.getWorkLanguage)();
@@ -223,8 +186,8 @@ async function executeDriveRound(args) {
                     : (0, driver_messages_1.formatUserFacingContextHealthV3RemediationGuide)(language, {
                         kind: 'critical',
                         mode: 'countdown',
-                        promptsRemainingAfterThis: consumeCriticalCountdown(dialog),
-                        promptsTotal: defaultCriticalCountdownGenerations,
+                        promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dialog.id.key()),
+                        promptsTotal: context_health_1.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
                     });
                 healthPrompt = {
                     content: guideText,

package/dist/llm/driver-v2/supdialog-response.js

@@ -135,17 +135,32 @@ async function supplyResponseToSupdialogV2(args) {
         };
         await parentDialog.addChatMessages(immediateMirror);
         if (result.shouldRevive) {
-            log_1.log.info(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} auto-reviving`);
-            if (parentDialog instanceof dialog_1.RootDialog) {
+            const isRoot = parentDialog instanceof dialog_1.RootDialog;
+            const hasRegistryEntry = isRoot
+                ? dialog_global_registry_1.globalDialogRegistry.get(parentDialog.id.rootId) !== undefined
+                : false;
+            log_1.log.info(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, {
+                rootId: parentDialog.id.rootId,
+                selfId: parentDialog.id.selfId,
+                via: isRoot && hasRegistryEntry ? 'backend_loop_trigger' : 'direct_schedule_drive',
+                isRoot,
+                hasRegistryEntry,
+            });
+            if (isRoot) {
                 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,
-                driveOptions: { suppressDiligencePush: parentDialog.disableDiligencePush },
-            });
+            // Root dialogs should normally be resumed by backend loop drive-trigger.
+            // Direct schedule is kept only as fallback for non-root callers or when registry
+            // entry is not available yet (e.g., transient bootstrap windows).
+            if (!isRoot || !hasRegistryEntry) {
+                scheduleDrive(parentDialog, {
+                    waitInQue: true,
+                    driveOptions: { suppressDiligencePush: parentDialog.disableDiligencePush },
+                });
+            }
         }
     }
     catch (error) {

package/dist/persistence.js

@@ -298,6 +298,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async createSubDialog(supdialog, targetAgentId, tellaskHead, tellaskBody, options) {
         const generatedId = (0, id_1.generateDialogID)();
+        const nowTs = (0, time_1.formatUnifiedTimestamp)(new Date());
         // For subdialogs, use the supdialog's root dialog ID as the root
         const subdialogId = new dialog_1.DialogID(generatedId, supdialog.id.rootId);
         // Prepare subdialog store
@@ -316,7 +317,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             id: subdialogId.selfId,
             agentId: targetAgentId,
             taskDocPath: supdialog.taskDocPath,
-            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            createdAt: nowTs,
             supdialogId: supdialog.id.selfId,
             tellaskSession: options.tellaskSession,
             assignmentFromSup: {
@@ -334,7 +335,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             kind: 'replace',
             next: {
                 currentCourse: 1,
-                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                lastModified: nowTs,
                 status: 'active',
                 messageCount: 0,
                 functionCallCount: 0,
@@ -364,6 +365,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             targetAgentId,
             tellaskHead,
             tellaskBody,
+            subDialogNode: {
+                selfId: subdialogId.selfId,
+                rootId: subdialogId.rootId,
+                supdialogId: supdialog.id.selfId,
+                agentId: targetAgentId,
+                taskDocPath: supdialog.taskDocPath,
+                status: 'running',
+                currentCourse: 1,
+                createdAt: nowTs,
+                lastModified: nowTs,
+                runState: { kind: 'idle_waiting_user' },
+                tellaskSession: options.tellaskSession,
+                assignmentFromSup: {
+                    tellaskHead,
+                    tellaskBody,
+                    originMemberId: options.originMemberId,
+                    callerDialogId: options.callerDialogId,
+                    callId: options.callId,
+                },
+            },
         };
         // Post subdialog_created_evt to PARENT's PubChan so frontend can receive it
         // The frontend subscribes to the parent's events, not the subdialog's
@@ -1052,7 +1073,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             // Events are already in chronological order from JSONL file (append-only pattern)
             // Send each persistence event directly to the requesting WebSocket
             for (const event of persistenceEvents) {
-                await this.sendEventDirectlyToWebSocket(ws, dialog, currentCourse, event);
+                await this.sendEventDirectlyToWebSocket(ws, dialog, currentCourse, event, status);
             }
             // Rehydrate reminders from dialog state
             const dialogState = await DialogPersistence.restoreDialog(dialog.id, status);
@@ -1071,7 +1092,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Send a single persistence event directly to a WebSocket connection
      * CRITICAL: Avoid PubChan completely for dialog restoration to the single client's display_dialog request
      */
-    async sendEventDirectlyToWebSocket(ws, dialog, course, event) {
+    async sendEventDirectlyToWebSocket(ws, dialog, course, event, status) {
         switch (event.type) {
             case 'human_text_record': {
                 const genseq = event.genseq;
@@ -1604,25 +1625,67 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             }
             case 'quest_for_sup_record': {
                 // Handle subdialog creation requests
+                const subdialogId = new dialog_1.DialogID(event.subDialogId, dialog.id.rootId);
+                const loadOrder = [
+                    status,
+                    'running',
+                    'completed',
+                    'archived',
+                ].filter((candidate, index, arr) => arr.indexOf(candidate) === index);
+                let foundStatus = null;
+                let subMeta = null;
+                let subLatest = null;
+                for (const candidateStatus of loadOrder) {
+                    const candidateMeta = await DialogPersistence.loadDialogMetadata(subdialogId, candidateStatus);
+                    if (!candidateMeta || !isSubdialogMetadataFile(candidateMeta))
+                        continue;
+                    foundStatus = candidateStatus;
+                    subMeta = candidateMeta;
+                    subLatest = await DialogPersistence.loadDialogLatest(subdialogId, candidateStatus);
+                    break;
+                }
+                if (!foundStatus || !subMeta) {
+                    throw new Error(`subdialog_created_evt replay invariant violation: metadata missing for ${subdialogId.valueOf()}`);
+                }
+                const derivedSupdialogId = subMeta.assignmentFromSup?.callerDialogId &&
+                    subMeta.assignmentFromSup.callerDialogId.trim() !== ''
+                    ? subMeta.assignmentFromSup.callerDialogId
+                    : typeof subMeta.supdialogId === 'string' && subMeta.supdialogId.trim() !== ''
+                        ? subMeta.supdialogId
+                        : dialog.id.selfId;
                 const subdialogCreatedEvent = {
                     type: 'subdialog_created_evt',
                     course,
                     dialog: {
                         // Add dialog field for proper event routing
-                        selfId: event.subDialogId,
-                        rootId: dialog.id.rootId,
+                        selfId: subdialogId.selfId,
+                        rootId: subdialogId.rootId,
                     },
                     parentDialog: {
                         selfId: dialog.id.selfId,
                         rootId: dialog.id.rootId,
                     },
                     subDialog: {
-                        selfId: event.subDialogId,
-                        rootId: dialog.id.rootId, // Use parent's rootId for subdialog's rootId
+                        selfId: subdialogId.selfId,
+                        rootId: subdialogId.rootId,
                     },
-                    targetAgentId: 'unknown', // Will be resolved during actual subdialog creation
+                    targetAgentId: subMeta.agentId,
                     tellaskHead: event.tellaskHead,
                     tellaskBody: event.tellaskBody,
+                    subDialogNode: {
+                        selfId: subMeta.id,
+                        rootId: subdialogId.rootId,
+                        supdialogId: derivedSupdialogId,
+                        agentId: subMeta.agentId,
+                        taskDocPath: subMeta.taskDocPath,
+                        status: foundStatus,
+                        currentCourse: subLatest?.currentCourse || 1,
+                        createdAt: subMeta.createdAt,
+                        lastModified: subLatest?.lastModified || subMeta.createdAt,
+                        runState: subLatest?.runState,
+                        tellaskSession: subMeta.tellaskSession,
+                        assignmentFromSup: subMeta.assignmentFromSup,
+                    },
                     timestamp: event.ts,
                 };
                 if (ws.readyState === 1) {