dominds 1.18.2 → 1.19.3

package/dist/dialog-display-state.js

@@ -8,7 +8,7 @@
  * Design constraints:
  * - `displayState` is a UI/diagnostic projection, not a business source of truth.
  * - Primary control flow must rely on underlying facts (active runs, stop requests,
- *   pending Q4H, pending subdialogs, queued prompts, persisted status, explicit
+ *   pending Q4H, pending sideDialogs, queued prompts, persisted status, explicit
  *   interruption/death markers).
  * - The projection is persisted to latest.yaml (`DialogLatestFile.displayState`) so it survives
  *   restarts and multi-tab views can converge quickly.
@@ -28,10 +28,10 @@ exports.hasActiveRun = hasActiveRun;
 exports.getActiveRunSignal = getActiveRunSignal;
 exports.createActiveRun = createActiveRun;
 exports.clearActiveRun = clearActiveRun;
-exports.clearRootDialogQuarantiningIfIdle = clearRootDialogQuarantiningIfIdle;
-exports.markRootDialogQuarantining = markRootDialogQuarantining;
-exports.clearRootDialogQuarantining = clearRootDialogQuarantining;
-exports.forceStopActiveRunsForRootDialog = forceStopActiveRunsForRootDialog;
+exports.clearMainDialogQuarantiningIfIdle = clearMainDialogQuarantiningIfIdle;
+exports.markMainDialogQuarantining = markMainDialogQuarantining;
+exports.clearMainDialogQuarantining = clearMainDialogQuarantining;
+exports.forceStopActiveRunsForMainDialog = forceStopActiveRunsForMainDialog;
 exports.getStopRequestedReason = getStopRequestedReason;
 exports.loadDialogExecutionMarker = loadDialogExecutionMarker;
 exports.setDialogExecutionMarker = setDialogExecutionMarker;
@@ -55,7 +55,7 @@ const interjection_pause_stop_1 = require("./runtime/interjection-pause-stop");
 const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
-const quarantiningRootDialogIds = new Set();
+const quarantiningMainDialogIds = new Set();
 function setDisplayStateBroadcaster(fn) {
     broadcastToClients = fn;
 }
@@ -113,7 +113,7 @@ async function getRunControlCountsSnapshot() {
         try {
             const dialogKey = dialogId.key();
             seenDialogKeys.add(dialogKey);
-            if (quarantiningRootDialogIds.has(dialogId.rootId)) {
+            if (quarantiningMainDialogIds.has(dialogId.rootId)) {
                 continue;
             }
             // listAllDialogIds() is intentionally a candidate scan. Per-dialog latest reads below may
@@ -139,8 +139,8 @@ async function getRunControlCountsSnapshot() {
                 }
                 else {
                     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-                    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
-                    if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
+                    if (q4h.length === 0 && pendingSideDialogs.length === 0) {
                         resumable++;
                     }
                 }
@@ -161,7 +161,7 @@ async function getRunControlCountsSnapshot() {
             continue;
         }
         const [rootId] = dialogKey.includes('#') ? dialogKey.split('#') : [dialogKey];
-        if (!rootId || quarantiningRootDialogIds.has(rootId)) {
+        if (!rootId || quarantiningMainDialogIds.has(rootId)) {
             continue;
         }
         if (!seenDialogKeys.has(dialogKey)) {
@@ -202,10 +202,10 @@ function createActiveRun(dialogId) {
 function clearActiveRun(dialogId, options) {
     const deleted = activeRunsByDialogKey.delete(dialogId.key());
     if (!deleted) {
-        clearQuarantiningRootDialogIfIdle(dialogId.rootId);
+        clearQuarantiningMainDialogIfIdle(dialogId.rootId);
         return;
     }
-    clearQuarantiningRootDialogIfIdle(dialogId.rootId);
+    clearQuarantiningMainDialogIfIdle(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',
@@ -214,30 +214,30 @@ function clearActiveRun(dialogId, options) {
     }
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);
 }
-function clearQuarantiningRootDialogIfIdle(rootId) {
+function clearQuarantiningMainDialogIfIdle(rootId) {
     for (const key of activeRunsByDialogKey.keys()) {
         const [candidateRootId] = key.includes('#') ? key.split('#') : [key];
         if (candidateRootId === rootId) {
             return;
         }
     }
-    quarantiningRootDialogIds.delete(rootId);
+    quarantiningMainDialogIds.delete(rootId);
 }
-function clearRootDialogQuarantiningIfIdle(rootDialogId) {
-    clearQuarantiningRootDialogIfIdle(rootDialogId.selfId);
+function clearMainDialogQuarantiningIfIdle(mainDialogId) {
+    clearQuarantiningMainDialogIfIdle(mainDialogId.selfId);
 }
-function markRootDialogQuarantining(rootDialogId) {
-    quarantiningRootDialogIds.add(rootDialogId.selfId);
+function markMainDialogQuarantining(mainDialogId) {
+    quarantiningMainDialogIds.add(mainDialogId.selfId);
 }
-function clearRootDialogQuarantining(rootDialogId) {
-    quarantiningRootDialogIds.delete(rootDialogId.selfId);
+function clearMainDialogQuarantining(mainDialogId) {
+    quarantiningMainDialogIds.delete(mainDialogId.selfId);
 }
-async function forceStopActiveRunsForRootDialog(rootDialogId) {
+async function forceStopActiveRunsForMainDialog(mainDialogId) {
     for (const key of Array.from(activeRunsByDialogKey.keys())) {
         const [rootId, selfId] = key.includes('#') ? key.split('#') : [key, key];
         if (!rootId || !selfId)
             continue;
-        if (rootId !== rootDialogId.selfId)
+        if (rootId !== mainDialogId.selfId)
             continue;
         const dialogId = new dialog_1.DialogID(selfId, rootId);
         const run = activeRunsByDialogKey.get(key);
@@ -252,9 +252,9 @@ async function forceStopActiveRunsForRootDialog(rootDialogId) {
                 });
             }
             catch (error) {
-                log.warn('Failed to persist stop-requested state while forcing root dialog stop', error, {
+                log.warn('Failed to persist stop-requested state while forcing main dialog stop', error, {
                     dialogId: dialogId.valueOf(),
-                    rootDialogId: rootDialogId.valueOf(),
+                    mainDialogId: mainDialogId.valueOf(),
                 });
             }
         }
@@ -262,9 +262,9 @@ async function forceStopActiveRunsForRootDialog(rootDialogId) {
             run.abortController.abort();
         }
         catch (error) {
-            log.warn('Failed to abort active run while forcing root dialog stop', error, {
+            log.warn('Failed to abort active run while forcing main dialog stop', error, {
                 dialogId: dialogId.valueOf(),
-                rootDialogId: rootDialogId.valueOf(),
+                mainDialogId: mainDialogId.valueOf(),
             });
         }
     }
@@ -278,7 +278,7 @@ async function loadDialogExecutionMarker(dialogId, status = 'running') {
 }
 async function setDialogExecutionMarker(dialogId, executionMarker) {
     if (executionMarker?.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
-        log.warn('Rejecting dead executionMarker for root dialog (root dialogs must not be dead)', undefined, {
+        log.warn('Rejecting dead executionMarker for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
         });
         return;
@@ -315,7 +315,7 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
 }
 async function setDialogDisplayState(dialogId, displayState) {
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
-        log.warn('Rejecting dead displayState for root dialog (root dialogs must not be dead)', undefined, {
+        log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
         });
         return;
@@ -425,15 +425,15 @@ async function computeIdleDisplayState(dlg) {
         };
     }
     const hasQ4H = await dlg.hasPendingQ4H();
-    const hasSubdialogs = await dlg.hasPendingSubdialogs();
-    if (hasQ4H && hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    const hasSideDialogs = await dlg.hasPendingSideDialogs();
+    if (hasQ4H && hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
     }
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    if (hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -464,17 +464,17 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         };
     }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
-    const hasSubdialogs = pendingSubdialogs.length > 0;
-    if (hasQ4H && hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    const hasSideDialogs = pendingSideDialogs.length > 0;
+    if (hasQ4H && hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
     }
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (hasSubdialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    if (hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -501,7 +501,7 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             // This is the one place where the projection intentionally preserves the paused-interjection
             // stopped state ahead of the current blocker facts. That is not a bug: after a user
             // interjection we want the UI to keep showing "original task paused; click Continue" even if
-            // the underlying dialog is still waiting on Q4H/subdialogs.
+            // the underlying dialog is still waiting on Q4H/sideDialogs.
             //
             // The true source-of-truth decision about what Continue should do next lives in
             // `flow.ts`'s resume path, which performs a fresh fact scan at resume time and then either:
@@ -524,17 +524,17 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             };
         }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
-        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+        const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
-        const hasSubdialogs = pendingSubdialogs.length > 0;
-        if (hasQ4H && hasSubdialogs) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+        const hasSideDialogs = pendingSideDialogs.length > 0;
+        if (hasQ4H && hasSideDialogs) {
+            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
         }
         if (hasQ4H) {
             return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
         }
-        if (hasSubdialogs) {
-            return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+        if (hasSideDialogs) {
+            return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
         }
         if (latest.executionMarker?.kind === 'interrupted') {
             return {

package/dist/dialog-factory.d.ts

@@ -4,34 +4,34 @@
  * Factory for creating Dialog instances with proper type hierarchy.
  * Provides a single point of dialog creation to ensure consistent initialization.
  */
-import { Dialog, DialogID, DialogInitParams, DialogStore, RootDialog, SubDialog } from './dialog';
+import { Dialog, DialogID, DialogInitParams, DialogStore, MainDialog, SideDialog } from './dialog';
 /**
  * Factory for creating Dialog instances.
- * Abstracts the creation of RootDialog and SubDialog with proper type hierarchy.
+ * Abstracts the creation of MainDialog and SideDialog with proper type hierarchy.
  */
 export declare class DialogFactory {
     /**
-     * Create a new RootDialog instance.
+     * Create a new MainDialog instance.
      */
-    static createRootDialog(dlgStore: DialogStore, taskDocPath: string, agentId: string, id?: DialogID, initialState?: DialogInitParams['initialState']): RootDialog;
+    static createMainDialog(dlgStore: DialogStore, taskDocPath: string, agentId: string, id?: DialogID, initialState?: DialogInitParams['initialState']): MainDialog;
     /**
-     * Create a new SubDialog instance.
+     * Create a new SideDialog instance.
      */
-    static createSubDialog(callerDialog: Dialog, taskDocPath: string, targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
+    static createSideDialog(askerDialog: Dialog, taskDocPath: string, targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
         callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
         originMemberId: string;
-        callerDialogId: string;
+        askerDialogId: string;
         callId: string;
         sessionSlug?: string;
         collectiveTargets?: string[];
         effectiveFbrEffort?: number;
-    }, initialState?: DialogInitParams['initialState']): SubDialog;
+    }, initialState?: DialogInitParams['initialState']): SideDialog;
     /**
-     * Check if a dialog is a RootDialog.
+     * Check if a dialog is a MainDialog.
      */
-    static isRootDialog(dialog: Dialog): dialog is RootDialog;
+    static isMainDialog(dialog: Dialog): dialog is MainDialog;
     /**
-     * Check if a dialog is a SubDialog.
+     * Check if a dialog is a SideDialog.
      */
-    static isSubDialog(dialog: Dialog): dialog is SubDialog;
+    static isSideDialog(dialog: Dialog): dialog is SideDialog;
 }

package/dist/dialog-factory.js

@@ -12,52 +12,55 @@ const dialog_global_registry_1 = require("./dialog-global-registry");
 const id_1 = require("./utils/id");
 /**
  * Factory for creating Dialog instances.
- * Abstracts the creation of RootDialog and SubDialog with proper type hierarchy.
+ * Abstracts the creation of MainDialog and SideDialog with proper type hierarchy.
  */
 class DialogFactory {
     /**
-     * Create a new RootDialog instance.
+     * Create a new MainDialog instance.
      */
-    static createRootDialog(dlgStore, taskDocPath, agentId, id, initialState) {
-        const rootDialog = new dialog_1.RootDialog(dlgStore, taskDocPath, id, agentId, initialState);
-        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
-        return rootDialog;
+    static createMainDialog(dlgStore, taskDocPath, agentId, id, initialState) {
+        const mainDialog = new dialog_1.MainDialog(dlgStore, taskDocPath, id, agentId, initialState);
+        dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
+        return mainDialog;
     }
     /**
-     * Create a new SubDialog instance.
+     * Create a new SideDialog instance.
      */
-    static createSubDialog(callerDialog, taskDocPath, targetAgentId, mentionList, tellaskContent, options, initialState) {
+    static createSideDialog(askerDialog, taskDocPath, targetAgentId, mentionList, tellaskContent, options, initialState) {
         const generatedId = (0, id_1.generateDialogID)();
-        const rootDialog = callerDialog instanceof dialog_1.RootDialog
-            ? callerDialog
-            : callerDialog instanceof dialog_1.SubDialog
-                ? callerDialog.rootDialog
+        const mainDialog = askerDialog instanceof dialog_1.MainDialog
+            ? askerDialog
+            : askerDialog instanceof dialog_1.SideDialog
+                ? askerDialog.mainDialog
                 : (() => {
-                    throw new Error(`createSubDialog invariant violation: unsupported caller dialog type (${callerDialog.constructor.name})`);
+                    throw new Error(`createSideDialog invariant violation: unsupported asker type (${askerDialog.constructor.name})`);
                 })();
-        const subdialogId = new dialog_1.DialogID(generatedId, rootDialog.id.rootId);
-        return new dialog_1.SubDialog(callerDialog.dlgStore, rootDialog, taskDocPath, subdialogId, targetAgentId, {
-            callName: options.callName,
-            mentionList,
-            tellaskContent,
-            originMemberId: options.originMemberId,
-            callerDialogId: options.callerDialogId,
-            callId: options.callId,
-            collectiveTargets: options.collectiveTargets,
-            effectiveFbrEffort: options.effectiveFbrEffort,
-        }, options.sessionSlug, initialState);
+        const sideDialogId = new dialog_1.DialogID(generatedId, mainDialog.id.rootId);
+        return new dialog_1.SideDialog(askerDialog.dlgStore, mainDialog, taskDocPath, sideDialogId, targetAgentId, (0, dialog_1.buildSideDialogAskerStack)({
+            askerDialogId: options.askerDialogId,
+            assignment: {
+                callName: options.callName,
+                mentionList,
+                tellaskContent,
+                originMemberId: options.originMemberId,
+                askerDialogId: options.askerDialogId,
+                callId: options.callId,
+                collectiveTargets: options.collectiveTargets,
+                effectiveFbrEffort: options.effectiveFbrEffort,
+            },
+        }), options.sessionSlug, initialState);
     }
     /**
-     * Check if a dialog is a RootDialog.
+     * Check if a dialog is a MainDialog.
      */
-    static isRootDialog(dialog) {
-        return dialog instanceof dialog_1.RootDialog;
+    static isMainDialog(dialog) {
+        return dialog instanceof dialog_1.MainDialog;
     }
     /**
-     * Check if a dialog is a SubDialog.
+     * Check if a dialog is a SideDialog.
      */
-    static isSubDialog(dialog) {
-        return dialog instanceof dialog_1.SubDialog;
+    static isSideDialog(dialog) {
+        return dialog instanceof dialog_1.SideDialog;
     }
 }
 exports.DialogFactory = DialogFactory;

package/dist/dialog-fork.d.ts

@@ -5,7 +5,7 @@ type ForkDialogAction = Readonly<{
 }> | Readonly<{
     kind: 'restore_pending';
     pendingQ4H: boolean;
-    pendingSubdialogs: boolean;
+    pendingSideDialogs: boolean;
 }> | Readonly<{
     kind: 'auto_continue';
 }>;
@@ -16,7 +16,7 @@ export type ForkDialogTreeResult = Readonly<{
     taskDocPath: string;
     action: ForkDialogAction;
 }>;
-export declare function forkRootDialogTreeAtGeneration(args: {
+export declare function forkMainDialogTreeAtGeneration(args: {
     sourceRootId: string;
     sourceStatus: DialogStatusKind;
     course: number;