dominds 0.7.2 → 0.7.4

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

@@ -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,20 +19,48 @@ 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;
     }
-    broadcastIfQ4H(evt) {
-        // Only broadcast Q4H events; all other dialog events remain dialog-scoped streams.
-        if (evt.type !== 'new_q4h_asked' && evt.type !== 'q4h_answered')
+    broadcastGlobalEvent(evt) {
+        const fn = this.globalDialogEventBroadcaster;
+        if (!fn)
             return;
-        const fn = this.q4hBroadcaster;
-        if (fn)
-            fn(evt);
+        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(`Global dialog event 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 +104,19 @@ class DialogEventRegistryImpl {
      */
     postEvent(dlg, event) {
         const typedEvent = this.createTypedEvent(dlg.id, event);
-        this.broadcastIfQ4H(typedEvent);
+        this.emitDialogTouched(typedEvent);
+        if (this.dispatchGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dlg.id);
         chan.write(typedEvent);
     }
     postEventById(dialogId, event) {
         const typedEvent = this.createTypedEvent(dialogId, event);
-        this.broadcastIfQ4H(typedEvent);
+        this.emitDialogTouched(typedEvent);
+        if (this.dispatchGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dialogId);
         chan.write(typedEvent);
     }
@@ -106,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.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);