dominds 1.18.2 → 1.19.2

package/dist/server/websocket-handler.js

@@ -183,7 +183,7 @@ function readOptionalPersistableDialogStatus(raw) {
     }
     return { kind: 'value', status };
 }
-function formatDeclaredDeadSubdialogNotice(language, dialogId, callName) {
+function formatDeclaredDeadSideDialogNotice(language, dialogId, callName) {
     if (language === 'zh') {
         switch (callName) {
             case 'tellask':
@@ -196,11 +196,11 @@ function formatDeclaredDeadSubdialogNotice(language, dialogId, callName) {
     }
     switch (callName) {
         case 'tellask':
-            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} sideline dialog ${dialogId} has been declared dead by the user (irreversible). You may reuse the same slug to start a brand-new sideline dialog, but previous context is no longer retained; include the latest complete context in the new tellask body.`;
+            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} Side Dialog ${dialogId} has been declared dead by the user (irreversible). You may reuse the same slug to start a brand-new Side Dialog, but previous context is no longer retained; include the latest complete context in the new tellask body.`;
         case 'tellaskSessionless':
-            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} sideline dialog ${dialogId} has been declared dead by the user (irreversible). This was a one-shot sideline dialog; if you still need the work, start a new sideline dialog. Previous context will not carry over, so include the latest complete context in the new tellask body.`;
+            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} Side Dialog ${dialogId} has been declared dead by the user (irreversible). This was a one-shot Side Dialog; if you still need the work, start a new Side Dialog. Previous context will not carry over, so include the latest complete context in the new tellask body.`;
         case 'freshBootsReasoning':
-            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} sideline dialog ${dialogId} has been declared dead by the user (irreversible). This was an FBR sideline dialog; if you still need the work, start a new FBR sideline dialog. Previous context will not carry over, so include the latest complete context in the new tellask body.`;
+            return `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} Side Dialog ${dialogId} has been declared dead by the user (irreversible). This was an FBR Side Dialog; if you still need the work, start a new FBR Side Dialog. Previous context will not carry over, so include the latest complete context in the new tellask body.`;
     }
 }
 const log = (0, log_1.createLogger)('websocket-handler');
@@ -236,20 +236,20 @@ function buildResumeIneligibleMessage(latest) {
     switch (state.kind) {
         case 'blocked':
             switch (state.reason.kind) {
-                case 'needs_human_input_and_subdialogs':
+                case 'needs_human_input_and_sideDialogs':
                     return {
-                        reason: 'needs_human_input_and_subdialogs',
-                        message: 'Fresh state scan shows this dialog is waiting for both human input and sideline dialogs, so it cannot resume yet.',
+                        reason: 'needs_human_input_and_sideDialogs',
+                        message: 'Fresh state scan shows this dialog is waiting for both human input and Side Dialogs, so it cannot resume yet.',
                     };
                 case 'needs_human_input':
                     return {
                         reason: 'needs_human_input',
                         message: 'Fresh state scan shows this dialog is waiting for human input, so it cannot resume yet.',
                     };
-                case 'waiting_for_subdialogs':
+                case 'waiting_for_sideDialogs':
                     return {
-                        reason: 'waiting_for_subdialogs',
-                        message: 'Fresh state scan shows this dialog is waiting for sideline dialogs, so it cannot resume yet.',
+                        reason: 'waiting_for_sideDialogs',
+                        message: 'Fresh state scan shows this dialog is waiting for Side Dialogs, so it cannot resume yet.',
                     };
                 default: {
                     const _exhaustive = state.reason;
@@ -493,8 +493,8 @@ async function handleWebSocketMessage(ws, packet) {
             case 'resume_all':
                 await handleResumeAll(ws, packet);
                 break;
-            case 'declare_subdialog_dead':
-                await handleDeclareSubdialogDead(ws, packet);
+            case 'declare_sideDialog_dead':
+                await handleDeclareSideDialogDead(ws, packet);
                 break;
             default:
                 log.warn('Unknown WebSocket packet type:', undefined, packet.type);
@@ -512,21 +512,21 @@ async function handleWebSocketMessage(ws, packet) {
         }));
     }
 }
-async function handleDeclareSubdialogDead(ws, packet) {
+async function handleDeclareSideDialogDead(ws, packet) {
     const dialog = packet.dialog;
     const noteRaw = typeof packet.note === 'string' ? packet.note : '';
     const note = noteRaw.trim();
     if (!dialog || typeof dialog.selfId !== 'string' || typeof dialog.rootId !== 'string') {
         ws.send(JSON.stringify({
             type: 'error',
-            message: 'declare_subdialog_dead requires dialog.selfId/rootId',
+            message: 'declare_sideDialog_dead requires dialog.selfId/rootId',
         }));
         return;
     }
     if (dialog.selfId === dialog.rootId) {
         ws.send(JSON.stringify({
             type: 'error',
-            message: 'declare_subdialog_dead is allowed only for subdialogs (selfId must differ)',
+            message: 'declare_sideDialog_dead is allowed only for sideDialogs (selfId must differ)',
         }));
         return;
     }
@@ -535,7 +535,7 @@ async function handleDeclareSubdialogDead(ws, packet) {
     if (requestedStatusInput.kind === 'invalid') {
         ws.send(JSON.stringify({
             type: 'error',
-            message: 'declare_subdialog_dead requires status running, completed, or archived',
+            message: 'declare_sideDialog_dead requires status running, completed, or archived',
         }));
         return;
     }
@@ -543,7 +543,7 @@ async function handleDeclareSubdialogDead(ws, packet) {
     if (requestedStatus !== 'running') {
         ws.send(JSON.stringify({
             type: 'error',
-            message: 'declare_subdialog_dead is available only for running dialogs',
+            message: 'declare_sideDialog_dead is available only for running dialogs',
         }));
         return;
     }
@@ -566,43 +566,40 @@ async function handleDeclareSubdialogDead(ws, packet) {
         reason: { kind: 'declared_by_user' },
     });
     await (0, dialog_display_state_1.setDialogDisplayState)(dialogIdObj, { kind: 'dead', reason: { kind: 'declared_by_user' } });
-    // If a supdialog is waiting on this subdialog (pending-subdialogs.json), supply a system-style
-    // response so the supdialog can unblock and the model sees the failure reason.
+    // If an askerDialog is waiting on this sideDialog (pending-sideDialogs.json), supply a system-style
+    // response so the askerDialog can unblock and the model sees the failure reason.
     const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(dialogIdObj, requestedStatus);
     if (!metadata)
         return;
     if (typeof metadata.sessionSlug === 'string' && metadata.sessionSlug.trim() !== '') {
         const rootRestored = await restoreDialogForDrive(new dialog_1.DialogID(dialogIdObj.rootId), 'running');
-        if (!(rootRestored instanceof dialog_1.RootDialog)) {
-            throw new Error(`Expected root dialog instance for ${dialogIdObj.rootId}`);
+        if (!(rootRestored instanceof dialog_1.MainDialog)) {
+            throw new Error(`Expected main dialog instance for ${dialogIdObj.rootId}`);
         }
-        const removed = rootRestored.unregisterSubdialog(metadata.agentId, metadata.sessionSlug);
+        const removed = rootRestored.unregisterSideDialog(metadata.agentId, metadata.sessionSlug);
         if (removed) {
-            await rootRestored.saveSubdialogRegistry();
+            await rootRestored.saveSideDialogRegistry();
         }
     }
-    if (!('assignmentFromSup' in metadata))
+    const assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(dialogIdObj, requestedStatus);
+    const askerDialogId = assignmentFromAsker.askerDialogId;
+    if (typeof askerDialogId !== 'string' || askerDialogId.trim() === '')
         return;
-    if (!metadata.assignmentFromSup)
-        return;
-    const callerDialogId = metadata.assignmentFromSup.callerDialogId;
-    if (typeof callerDialogId !== 'string' || callerDialogId.trim() === '')
-        return;
-    const callerDialogIdObj = new dialog_1.DialogID(callerDialogId, dialogIdObj.rootId);
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(callerDialogIdObj, requestedStatus);
-    const pendingRecord = pending.find((p) => p.subdialogId === dialogIdObj.selfId);
+    const askerDialogIdObj = new dialog_1.DialogID(askerDialogId, dialogIdObj.rootId);
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(askerDialogIdObj, requestedStatus);
+    const pendingRecord = pending.find((p) => p.sideDialogId === dialogIdObj.selfId);
     if (!pendingRecord) {
-        // Caller is not waiting on this subdialog anymore; do not auto-revive.
+        // Asker is not waiting on this sideDialog anymore; do not auto-revive.
         return;
     }
-    const parentDialog = await restoreDialogForDrive(callerDialogIdObj, 'running');
-    const responseText = formatDeclaredDeadSubdialogNotice((0, work_language_1.getWorkLanguage)(), dialogIdObj.valueOf(), metadata.assignmentFromSup.callName);
+    const parentDialog = await restoreDialogForDrive(askerDialogIdObj, 'running');
+    const responseText = formatDeclaredDeadSideDialogNotice((0, work_language_1.getWorkLanguage)(), dialogIdObj.valueOf(), assignmentFromAsker.callName);
     const responseTextWithNote = note === ''
         ? responseText
         : (0, work_language_1.getWorkLanguage)() === 'zh'
             ? `${responseText}\n\n使用者补充（来自输入框）：\n${note}`
             : `${responseText}\n\nUser note (from the input box):\n${note}`;
-    await (0, kernel_driver_1.supplyResponseToSupdialog)(parentDialog, dialogIdObj, responseTextWithNote, pendingRecord.callType, metadata.assignmentFromSup.callId, 'failed');
+    await (0, kernel_driver_1.supplyResponseToAskerDialog)(parentDialog, dialogIdObj, responseTextWithNote, pendingRecord.callType, assignmentFromAsker.callId, 'failed');
 }
 async function handleSetDiligencePush(ws, packet) {
     try {
@@ -624,7 +621,7 @@ async function handleSetDiligencePush(ws, packet) {
             ws.send(JSON.stringify({ type: 'error', message: 'disableDiligencePush must be a boolean' }));
             return;
         }
-        // Diligence Push is root-dialog state. Even if a subdialog is displayed, always mutate the root.
+        // Diligence Push is main-dialog state. Even if a sideDialog is displayed, always mutate the root.
         const dialogIdObj = new dialog_1.DialogID(rootId);
         const requestedStatusInput = readOptionalPersistableDialogStatus(dialog.status);
         if (requestedStatusInput.kind === 'invalid') {
@@ -652,9 +649,9 @@ async function handleSetDiligencePush(ws, packet) {
             patch: { disableDiligencePush },
         }), requestedStatus);
         // Update live in-memory instance if it's loaded.
-        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, requestedStatus);
-        if (rootDialog) {
-            rootDialog.disableDiligencePush = disableDiligencePush;
+        const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, requestedStatus);
+        if (mainDialog) {
+            mainDialog.disableDiligencePush = disableDiligencePush;
         }
         const msg = {
             type: 'diligence_push_updated',
@@ -666,9 +663,9 @@ async function handleSetDiligencePush(ws, packet) {
         const shouldTriggerImmediateDiligence = requestedStatus === 'running' &&
             prevDisableDiligencePush &&
             !disableDiligencePush &&
-            rootDialog instanceof dialog_1.RootDialog;
+            mainDialog instanceof dialog_1.MainDialog;
         if (shouldTriggerImmediateDiligence) {
-            void maybeTriggerImmediateDiligencePrompt(rootDialog);
+            void maybeTriggerImmediateDiligencePrompt(mainDialog);
         }
     }
     catch (error) {
@@ -684,48 +681,48 @@ function clampNonNegativeFiniteInt(value, fallback) {
         return fallback;
     return Math.max(0, Math.floor(value));
 }
-async function maybeTriggerImmediateDiligencePrompt(rootDialog) {
+async function maybeTriggerImmediateDiligencePrompt(mainDialog) {
     try {
-        if (rootDialog.disableDiligencePush) {
+        if (mainDialog.disableDiligencePush) {
             return;
         }
-        if ((0, dialog_display_state_1.hasActiveRun)(rootDialog.id)) {
+        if ((0, dialog_display_state_1.hasActiveRun)(mainDialog.id)) {
             return;
         }
-        if ((0, dialog_display_state_1.getStopRequestedReason)(rootDialog.id) !== undefined) {
+        if ((0, dialog_display_state_1.getStopRequestedReason)(mainDialog.id) !== undefined) {
             return;
         }
-        const executionMarker = await (0, dialog_display_state_1.loadDialogExecutionMarker)(rootDialog.id, 'running');
+        const executionMarker = await (0, dialog_display_state_1.loadDialogExecutionMarker)(mainDialog.id, 'running');
         if (executionMarker?.kind === 'interrupted' || executionMarker?.kind === 'dead') {
             return;
         }
-        const suspension = await rootDialog.getSuspensionStatus();
+        const suspension = await mainDialog.getSuspensionStatus();
         if (!suspension.canDrive) {
             return;
         }
         const team = await team_1.Team.load();
         const prepared = await (0, runtime_2.maybePrepareDiligenceAutoContinuePrompt)({
-            dlg: rootDialog,
-            isRootDialog: true,
-            remainingBudget: rootDialog.diligencePushRemainingBudget,
-            diligencePushMax: resolveMemberDiligencePushMax(team, rootDialog.agentId),
+            dlg: mainDialog,
+            isMainDialog: true,
+            remainingBudget: mainDialog.diligencePushRemainingBudget,
+            diligencePushMax: resolveMemberDiligencePushMax(team, mainDialog.agentId),
         });
-        rootDialog.diligencePushRemainingBudget = prepared.nextRemainingBudget;
-        await persistence_1.DialogPersistence.mutateDialogLatest(rootDialog.id, () => ({
+        mainDialog.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+        await persistence_1.DialogPersistence.mutateDialogLatest(mainDialog.id, () => ({
             kind: 'patch',
-            patch: { diligencePushRemainingBudget: rootDialog.diligencePushRemainingBudget },
+            patch: { diligencePushRemainingBudget: mainDialog.diligencePushRemainingBudget },
         }));
         if (prepared.kind !== 'disabled') {
-            (0, evt_registry_1.postDialogEvent)(rootDialog, {
+            (0, evt_registry_1.postDialogEvent)(mainDialog, {
                 type: 'diligence_budget_evt',
                 maxInjectCount: prepared.maxInjectCount,
                 injectedCount: Math.max(0, prepared.maxInjectCount - prepared.nextRemainingBudget),
                 remainingCount: Math.max(0, prepared.nextRemainingBudget),
-                disableDiligencePush: rootDialog.disableDiligencePush,
+                disableDiligencePush: mainDialog.disableDiligencePush,
             });
         }
         if (prepared.kind === 'prompt') {
-            await (0, kernel_driver_1.driveDialogStream)(rootDialog, prepared.prompt, true, {
+            await (0, kernel_driver_1.driveDialogStream)(mainDialog, prepared.prompt, true, {
                 source: 'ws_diligence_push',
                 reason: 'enable_keep_going_immediate_prompt',
             });
@@ -733,7 +730,7 @@ async function maybeTriggerImmediateDiligencePrompt(rootDialog) {
     }
     catch (error) {
         log.warn('Failed to trigger immediate diligence prompt after enabling keep-going', error, {
-            dialogId: rootDialog.id.valueOf(),
+            dialogId: mainDialog.id.valueOf(),
         });
     }
 }
@@ -751,7 +748,7 @@ async function handleRefillDiligencePushBudget(ws, packet) {
         }));
         return;
     }
-    const rootDialogId = new dialog_1.DialogID(rootId);
+    const mainDialogId = new dialog_1.DialogID(rootId);
     const requestedStatusInput = readOptionalPersistableDialogStatus(dialog.status);
     if (requestedStatusInput.kind === 'invalid') {
         ws.send(JSON.stringify({
@@ -761,41 +758,41 @@ async function handleRefillDiligencePushBudget(ws, packet) {
         return;
     }
     const requestedStatus = requestedStatusInput.kind === 'missing' ? 'running' : requestedStatusInput.status;
-    const rootMeta = await persistence_1.DialogPersistence.loadDialogMetadata(rootDialogId, requestedStatus);
+    const rootMeta = await persistence_1.DialogPersistence.loadDialogMetadata(mainDialogId, requestedStatus);
     if (!rootMeta) {
         ws.send(JSON.stringify({
             type: 'error',
-            message: `Dialog ${rootDialogId.valueOf()} not found in ${requestedStatus}; dialog context is stale`,
+            message: `Dialog ${mainDialogId.valueOf()} not found in ${requestedStatus}; dialog context is stale`,
         }));
         return;
     }
-    const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootDialogId.rootId, requestedStatus);
-    if (!rootDialog) {
+    const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(mainDialogId.rootId, requestedStatus);
+    if (!mainDialog) {
         ws.send(JSON.stringify({
             type: 'error',
-            message: `Root dialog ${rootDialogId.rootId} is not available for refill`,
+            message: `Main dialog ${mainDialogId.rootId} is not available for refill`,
         }));
         return;
     }
     const team = await team_1.Team.load();
-    const configuredMax = normalizeDiligencePushMax(resolveMemberDiligencePushMax(team, rootDialog.agentId));
+    const configuredMax = normalizeDiligencePushMax(resolveMemberDiligencePushMax(team, mainDialog.agentId));
     if (configuredMax > 0) {
-        rootDialog.diligencePushRemainingBudget = configuredMax;
+        mainDialog.diligencePushRemainingBudget = configuredMax;
     }
     else {
-        rootDialog.diligencePushRemainingBudget =
-            clampNonNegativeFiniteInt(rootDialog.diligencePushRemainingBudget, 0) + 3;
+        mainDialog.diligencePushRemainingBudget =
+            clampNonNegativeFiniteInt(mainDialog.diligencePushRemainingBudget, 0) + 3;
     }
-    await persistence_1.DialogPersistence.mutateDialogLatest(rootDialogId, () => ({
+    await persistence_1.DialogPersistence.mutateDialogLatest(mainDialogId, () => ({
         kind: 'patch',
-        patch: { diligencePushRemainingBudget: rootDialog.diligencePushRemainingBudget },
+        patch: { diligencePushRemainingBudget: mainDialog.diligencePushRemainingBudget },
     }), requestedStatus);
-    (0, evt_registry_1.postDialogEvent)(rootDialog, {
+    (0, evt_registry_1.postDialogEvent)(mainDialog, {
         type: 'diligence_budget_evt',
         maxInjectCount: configuredMax > 0 ? configuredMax : 0,
         injectedCount: 0,
-        remainingCount: rootDialog.diligencePushRemainingBudget,
-        disableDiligencePush: rootDialog.disableDiligencePush,
+        remainingCount: mainDialog.diligencePushRemainingBudget,
+        disableDiligencePush: mainDialog.disableDiligencePush,
     });
 }
 async function handleGetProblems(ws, packet) {
@@ -853,13 +850,13 @@ async function handleCreateDialog(ws, packet) {
     try {
         const { requestId, agentId, taskDocPath, priming } = parsed;
         const generatedId = (0, id_1.generateDialogID)();
-        // For root dialogs, self and root are the same
+        // For main dialogs, self and root are the same
         const dialogId = new dialog_1.DialogID(generatedId);
         // Import Dialog and DiskFileDialogStore
         // Create DiskFileDialogStore for file-based persistence
         const dialogUI = new persistence_1.DiskFileDialogStore(dialogId);
-        // Create RootDialog instance with the new store
-        const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, agentId);
+        // Create MainDialog instance with the new store
+        const dialog = new dialog_1.MainDialog(dialogUI, taskDocPath, dialogId, agentId);
         // display_dialog is intentionally read-only. Do not trigger replyTellask* recovery here:
         // merely opening a dialog must not deliver persisted replies or kick off follow-up drives.
         syncDialogLanguagePreference(dialog, resolveUserLanguageCode(ws, undefined, dialog));
@@ -872,7 +869,7 @@ async function handleCreateDialog(ws, packet) {
             agentId,
             taskDocPath: taskDocPath,
             createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            priming: (0, priming_1.buildRootDialogPrimingMetadata)(priming),
+            priming: (0, priming_1.buildMainDialogPrimingMetadata)(priming),
         };
         await persistence_1.DialogPersistence.saveDialogMetadata(new dialog_1.DialogID(dialogId.selfId), metadata);
         const team = await team_1.Team.load();
@@ -889,7 +886,7 @@ async function handleCreateDialog(ws, packet) {
                 status: 'active',
                 messageCount: 0,
                 functionCallCount: 0,
-                subdialogCount: 0,
+                sideDialogCount: 0,
                 displayState: { kind: 'idle_waiting_user' },
                 disableDiligencePush: defaultDisableDiligencePush,
                 diligencePushRemainingBudget: dialog.diligencePushRemainingBudget,
@@ -951,9 +948,9 @@ async function handleDisplayDialog(ws, packet) {
         }
         // Extract dialog ID from DialogIdent
         let dialogId = dialogIdent.selfId;
-        let rootDialogId = dialogIdent.rootId;
+        let mainDialogId = dialogIdent.rootId;
         // Handle case where dialogIdent properties might be objects instead of strings
-        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+        if (typeof dialogId !== 'string' || typeof mainDialogId !== 'string') {
             ws.send(JSON.stringify({
                 type: 'error',
                 message: 'Invalid dialog identifiers for display_dialog: selfId/rootId must be strings',
@@ -966,19 +963,19 @@ async function handleDisplayDialog(ws, packet) {
         const existing = wsLiveDlg.get(ws);
         if (existing) {
             const existingId = existing.id;
-            const isSameDialog = existingId.selfId === dialogId && existingId.rootId === rootDialogId;
+            const isSameDialog = existingId.selfId === dialogId && existingId.rootId === mainDialogId;
             if (isSameDialog) {
-                log.debug('display_dialog: refreshing the same dialog; cancelling existing subscription to prevent duplicate stream events', undefined, { dialogId, rootDialogId });
+                log.debug('display_dialog: refreshing the same dialog; cancelling existing subscription to prevent duplicate stream events', undefined, { dialogId, mainDialogId });
             }
             else {
                 log.debug('display_dialog: switching dialogs; cancelling previous subscription', undefined, {
                     previousDialogId: existingId.valueOf(),
-                    nextDialogId: new dialog_1.DialogID(dialogId, rootDialogId).valueOf(),
+                    nextDialogId: new dialog_1.DialogID(dialogId, mainDialogId).valueOf(),
                 });
             }
             cleanupWsClient(ws);
         }
-        const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+        const dialogIdObj = new dialog_1.DialogID(dialogId, mainDialogId);
         const requestedStatusInput = readOptionalPersistableDialogStatus(dialogIdent.status);
         if (requestedStatusInput.kind === 'invalid') {
             ws.send(JSON.stringify({
@@ -993,24 +990,24 @@ async function handleDisplayDialog(ws, packet) {
         if (!dialogState || !metadata) {
             throw new Error(`Dialog ${dialogIdObj.valueOf()} not found in ${requestedStatus}; dialog context is stale`);
         }
-        const rootPrimingConfig = dialogIdObj.selfId === dialogIdObj.rootId ? (0, priming_1.getRootDialogPrimingConfig)(metadata) : undefined;
+        const rootPrimingConfig = dialogIdObj.selfId === dialogIdObj.rootId ? (0, priming_1.getMainDialogPrimingConfig)(metadata) : undefined;
         const showPrimingEventsInUi = rootPrimingConfig?.showInUi !== false;
         const decidedCourse = (await persistence_1.DialogPersistence.getCurrentCourseNumber(dialogIdObj, requestedStatus)) ||
             (dialogState.currentCourse ?? 1);
         const enableLive = requestedStatus === 'running';
-        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, requestedStatus);
-        if (!rootDialog) {
-            throw new Error('Root dialog not found');
+        const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, requestedStatus);
+        if (!mainDialog) {
+            throw new Error('Main dialog not found');
         }
         if (enableLive) {
-            dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+            dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
         }
         let dialog;
         if (dialogIdObj.selfId === dialogIdObj.rootId) {
-            dialog = rootDialog;
+            dialog = mainDialog;
         }
         else {
-            const loaded = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, requestedStatus);
+            const loaded = await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, dialogIdObj, requestedStatus);
             if (!loaded) {
                 throw new Error('Dialog not found');
             }
@@ -1046,26 +1043,38 @@ async function handleDisplayDialog(ws, packet) {
             ? rootLatest.disableDiligencePush
             : defaultDisableDiligencePush;
         const effectiveDisableDiligencePush = persistedDisableDiligencePush;
-        rootDialog.disableDiligencePush = effectiveDisableDiligencePush;
-        const derivedSupdialogId = metadata.assignmentFromSup?.callerDialogId &&
-            metadata.assignmentFromSup.callerDialogId.trim() !== ''
-            ? metadata.assignmentFromSup.callerDialogId
-            : metadata.supdialogId;
+        mainDialog.disableDiligencePush = effectiveDisableDiligencePush;
+        let derivedAskerDialogId;
+        let assignmentFromAsker;
+        if (dialogIdObj.selfId !== dialogIdObj.rootId) {
+            assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(dialogIdObj, requestedStatus);
+            derivedAskerDialogId = assignmentFromAsker ? assignmentFromAsker.askerDialogId.trim() : '';
+        }
+        if (dialogIdObj.selfId !== dialogIdObj.rootId && !derivedAskerDialogId) {
+            const error = new Error(`dialog_ready invariant violation: missing assignmentFromAsker.askerDialogId ` +
+                `(rootId=${dialogIdObj.rootId}, selfId=${dialogIdObj.selfId}, status=${requestedStatus})`);
+            log.error('dialog_ready invariant violation: missing assignmentFromAsker.askerDialogId', error, {
+                rootId: dialogIdObj.rootId,
+                selfId: dialogIdObj.selfId,
+                status: requestedStatus,
+            });
+            throw error;
+        }
         const dialogReadyResponse = {
             type: 'dialog_ready',
             dialog: {
                 selfId: dialogId,
-                rootId: rootDialogId,
+                rootId: mainDialogId,
                 status: requestedStatus,
             },
             agentId: metadata.agentId,
             taskDocPath: metadata.taskDocPath,
-            supdialogId: derivedSupdialogId,
+            askerDialogId: derivedAskerDialogId,
             sessionSlug: metadata.sessionSlug,
-            assignmentFromSup: metadata.assignmentFromSup,
+            assignmentFromAsker,
             disableDiligencePush: effectiveDisableDiligencePush,
             diligencePushMax,
-            diligencePushRemainingBudget: clampNonNegativeFiniteInt(rootDialog.diligencePushRemainingBudget, diligencePushMax > 0 ? diligencePushMax : 0),
+            diligencePushRemainingBudget: clampNonNegativeFiniteInt(mainDialog.diligencePushRemainingBudget, diligencePushMax > 0 ? diligencePushMax : 0),
         };
         ws.send(JSON.stringify(dialogReadyResponse));
         // Running dialogs expose a persisted display-state snapshot for viewport controls.
@@ -1138,7 +1147,7 @@ async function handleGetQ4HState(ws, _packet) {
         // Load Q4H from all running dialogs
         const allQuestions = await persistence_1.DialogPersistence.loadAllQ4HState();
         // Transform to wire `Q4HStateResponse` question entries.
-        // `selfId` + `rootId` uniquely identify the originating dialog (including subdialogs).
+        // `selfId` + `rootId` uniquely identify the originating dialog (including sideDialogs).
         const questions = allQuestions.map((q) => ({
             id: q.id,
             selfId: q.selfId,
@@ -1191,16 +1200,16 @@ async function handleDisplayCourse(ws, packet) {
         }
         // Extract dialog ID from DialogIdent
         let dialogIdStr = dialog.selfId;
-        let rootDialogIdStr = dialog.rootId;
+        let mainDialogIdStr = dialog.rootId;
         // Handle case where dialog properties might be objects instead of strings
-        if (typeof dialogIdStr !== 'string' || typeof rootDialogIdStr !== 'string') {
+        if (typeof dialogIdStr !== 'string' || typeof mainDialogIdStr !== 'string') {
             ws.send(JSON.stringify({
                 type: 'error',
                 message: 'Invalid dialog identifiers for display_course: selfId/rootId must be strings',
             }));
             return;
         }
-        const dialogId = new dialog_1.DialogID(dialogIdStr, rootDialogIdStr);
+        const dialogId = new dialog_1.DialogID(dialogIdStr, mainDialogIdStr);
         try {
             const requestedStatusInput = readOptionalPersistableDialogStatus(dialog.status);
             if (requestedStatusInput.kind === 'invalid') {
@@ -1220,12 +1229,12 @@ async function handleDisplayCourse(ws, packet) {
                 return;
             }
             const totalCourses = (await persistence_1.DialogPersistence.getCurrentCourseNumber(dialogId, requestedStatus)) || course;
-            const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogId.rootId, requestedStatus);
-            if (!rootDialog)
+            const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogId.rootId, requestedStatus);
+            if (!mainDialog)
                 return;
             const restoredDialog = dialogId.selfId === dialogId.rootId
-                ? rootDialog
-                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogId, requestedStatus);
+                ? mainDialog
+                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, dialogId, requestedStatus);
             if (!restoredDialog)
                 return;
             const store = restoredDialog.dlgStore;
@@ -1262,16 +1271,16 @@ async function handleUserMsg2Dlg(ws, packet) {
         }
         // Extract dialog ID from DialogIdent
         const dialogId = dialogIdent.selfId;
-        const rootDialogId = dialogIdent.rootId;
+        const mainDialogId = dialogIdent.rootId;
         // Validate dialog identifiers
-        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+        if (typeof dialogId !== 'string' || typeof mainDialogId !== 'string') {
             ws.send(JSON.stringify({
                 type: 'error',
                 message: 'Invalid dialog identifiers for drive_dlg_by_user_msg: selfId/rootId must be strings',
             }));
             return;
         }
-        const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+        const dialogIdObj = new dialog_1.DialogID(dialogId, mainDialogId);
         const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogIdObj, 'running');
         if (latest?.executionMarker?.kind === 'dead') {
             ws.send(JSON.stringify({
@@ -1289,7 +1298,7 @@ async function handleUserMsg2Dlg(ws, packet) {
         const preparedAttachments = prepareUserImageAttachments(attachments);
         // If the dialog is already active for this WebSocket, runnable (status === 'running'),
         // and has an event forwarder (subChan),
-        // drive it directly to preserve in-memory state (pending subdialogs, teammate tellask tracking, etc).
+        // drive it directly to preserve in-memory state (pending sideDialogs, teammate tellask tracking, etc).
         //
         // IMPORTANT: do not drive a view-only dialog instance here. When users browse a completed/archived
         // dialog, handleDisplayDialog restores it with dialog.status set to completed/archived. If that
@@ -1300,7 +1309,7 @@ async function handleUserMsg2Dlg(ws, packet) {
         const existingSub = wsSub.get(ws);
         if (existingDialog &&
             existingDialog.id.selfId === dialogId &&
-            existingDialog.id.rootId === rootDialogId &&
+            existingDialog.id.rootId === mainDialogId &&
             existingDialog.status === 'running' &&
             existingSub &&
             existingSub.dialogKey === existingDialog.id.valueOf()) {
@@ -1329,18 +1338,18 @@ async function handleUserMsg2Dlg(ws, packet) {
             });
             return;
         }
-        // Dialog not found in wsLiveDlg - drive using the canonical root/subdialog instances.
-        // This supports driving subdialogs and cross-client revival without creating duplicate dialog objects.
+        // Dialog not found in wsLiveDlg - drive using the canonical root/sideDialog instances.
+        // This supports driving sideDialogs and cross-client revival without creating duplicate dialog objects.
         try {
-            const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, 'running');
-            if (!rootDialog) {
+            const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, 'running');
+            if (!mainDialog) {
                 ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
                 return;
             }
-            dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+            dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
             const dialog = dialogIdObj.selfId === dialogIdObj.rootId
-                ? rootDialog
-                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, 'running');
+                ? mainDialog
+                : await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, dialogIdObj, 'running');
             if (!dialog) {
                 ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
                 return;
@@ -1391,20 +1400,20 @@ async function handleUserMsg2Dlg(ws, packet) {
     }
 }
 async function restoreDialogForDrive(dialogIdObj, status) {
-    const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, status);
-    if (!rootDialog) {
+    const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, status);
+    if (!mainDialog) {
         throw new Error(`Dialog ${dialogIdObj.valueOf()} not found`);
     }
-    dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+    dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
     // This helper is intentionally for business operations that will mutate or continue execution
-    // immediately after restore (for example resume_dialog, resume_all, or dead-subdialog recovery).
+    // immediately after restore (for example resume_dialog, resume_all, or dead-sideDialog recovery).
     // Because those operations are execution-oriented, we repair pending replyTellask* delivery
-    // before handing the dialog back to the caller.
+    // before handing the dialog back to the tellasker.
     if (dialogIdObj.selfId === dialogIdObj.rootId) {
-        await (0, reply_special_1.recoverPendingReplyTellaskCallsForDialog)(rootDialog);
-        return rootDialog;
+        await (0, reply_special_1.recoverPendingReplyTellaskCallsForDialog)(mainDialog);
+        return mainDialog;
     }
-    const sub = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, status);
+    const sub = await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, dialogIdObj, status);
     if (!sub) {
         throw new Error(`Dialog ${dialogIdObj.valueOf()} not found`);
     }
@@ -1548,16 +1557,16 @@ async function handleReceiveHumanReply(ws, packet) {
         }
         // Extract dialog ID from DialogIdent
         const dialogId = dialogIdent.selfId;
-        const rootDialogId = dialogIdent.rootId;
+        const mainDialogId = dialogIdent.rootId;
         // Validate dialog identifiers
-        if (typeof dialogId !== 'string' || typeof rootDialogId !== 'string') {
+        if (typeof dialogId !== 'string' || typeof mainDialogId !== 'string') {
             ws.send(JSON.stringify({
                 type: 'error',
                 message: 'Invalid dialog identifiers for receiveHumanReply: selfId/rootId must be strings',
             }));
             return;
         }
-        const dialogIdObj = new dialog_1.DialogID(dialogId, rootDialogId);
+        const dialogIdObj = new dialog_1.DialogID(dialogId, mainDialogId);
         const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogIdObj, 'running');
         if (latest?.executionMarker?.kind === 'dead') {
             ws.send(JSON.stringify({
@@ -1573,16 +1582,16 @@ async function handleReceiveHumanReply(ws, packet) {
             userLanguageCode,
         };
         const preparedAttachments = prepareUserImageAttachments(attachments);
-        // Restore the canonical dialog instances (root + subdialogs) to avoid duplicates.
-        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(dialogIdObj.rootId, 'running');
-        if (!rootDialog) {
+        // Restore the canonical dialog instances (main dialog + sideDialogs) to avoid duplicates.
+        const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(dialogIdObj.rootId, 'running');
+        if (!mainDialog) {
             ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
             return;
         }
-        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
         const dialog = dialogIdObj.selfId === dialogIdObj.rootId
-            ? rootDialog
-            : await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, dialogIdObj, 'running');
+            ? mainDialog
+            : await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, dialogIdObj, 'running');
         if (!dialog) {
             ws.send(JSON.stringify({ type: 'error', message: `Dialog ${dialogId} not found` }));
             return;
@@ -1611,10 +1620,11 @@ async function handleReceiveHumanReply(ws, packet) {
             msgId: effectivePrompt.msgId,
             attachments: preparedAttachments,
         });
-        const askHumanOriginCourse = removedQuestion.callSiteRef.course;
+        const askHumanCallSiteCourse = removedQuestion.callSiteRef.course;
         const askHumanCarryoverContent = (0, inter_dialog_format_1.formatTellaskCarryoverResultContent)({
-            originCourse: askHumanOriginCourse,
+            callSiteCourse: askHumanCallSiteCourse,
             callName: 'askHuman',
+            callId: removedQuestion.callId,
             responderId: 'human',
             tellaskContent: removedQuestion.tellaskContent,
             responseBody: effectivePrompt.content,
@@ -1626,8 +1636,8 @@ async function handleReceiveHumanReply(ws, packet) {
             agentId: 'human',
             callId: askHumanCallId,
             originMemberId: dialog.agentId,
-            originCourse: (0, storage_1.toCallingCourseNumber)(askHumanOriginCourse),
-            calling_genseq: removedQuestion.callSiteRef.callingGenseq,
+            callSiteCourse: (0, storage_1.toCallSiteCourseNo)(askHumanCallSiteCourse),
+            callSiteGenseq: removedQuestion.callSiteRef.callSiteGenseq,
             carryoverContent: askHumanCarryoverContent,
             contentItems,
         });
@@ -1639,10 +1649,10 @@ async function handleReceiveHumanReply(ws, packet) {
             selfId: dialogId,
         };
         (0, evt_registry_1.postDialogEvent)(dialog, answeredEvent);
-        const hasPendingSubdialogs = await dialog.hasPendingSubdialogs();
-        if (hasPendingSubdialogs) {
+        const hasPendingSideDialogs = await dialog.hasPendingSideDialogs();
+        if (hasPendingSideDialogs) {
             // This queued item is only the post-answer continuation input that resumes the suspended
-            // round after subdialogs settle. The human answer fact has already been persisted above as
+            // round after sideDialogs settle. The human answer fact has already been persisted above as
             // askHuman tellask result/carryover and must not be reinterpreted as a new user prompt.
             dialog.queueDeferredQ4HAnswerPrompt({
                 prompt: effectivePrompt.content,
@@ -1652,7 +1662,7 @@ async function handleReceiveHumanReply(ws, packet) {
                 userLanguageCode: effectivePrompt.userLanguageCode,
                 q4hAnswerCallId: askHumanCallId,
             });
-            log.debug('Deferred post-Q4H continuation input until pending subdialogs resolve', undefined, {
+            log.debug('Deferred post-Q4H continuation input until pending sideDialogs resolve', undefined, {
                 rootId: dialog.id.rootId,
                 selfId: dialog.id.selfId,
                 questionId,
@@ -1701,7 +1711,7 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
     (0, dialog_display_state_1.setDisplayStateBroadcaster)(broadcastToClients);
     // Broadcast global dialog events to all connected clients:
     // - Q4H updates are rtws-global state in WebUI
-    // - subdialog creation must refresh hierarchy/list even when current subscription is elsewhere
+    // - sideDialog creation must refresh hierarchy/list even when current subscription is elsewhere
     // - dlg_touched_evt keeps dialog list timestamps/reordering in sync across clients
     (0, global_dialog_event_broadcaster_1.installGlobalDialogEventBroadcaster)({
         label: 'websocket-server',
@@ -1714,22 +1724,22 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
     broadcastDialogsIndexMessage = (msg) => {
         broadcastToClients(msg);
     };
-    (0, persistence_1.setPrepareDialogQuarantineHook)(async ({ rootDialogId, status }) => {
+    (0, persistence_1.setPrepareDialogQuarantineHook)(async ({ mainDialogId, status }) => {
         if (status !== 'running') {
             return;
         }
-        (0, dialog_display_state_1.markRootDialogQuarantining)(rootDialogId);
-        await (0, dialog_display_state_1.forceStopActiveRunsForRootDialog)(rootDialogId);
+        (0, dialog_display_state_1.markMainDialogQuarantining)(mainDialogId);
+        await (0, dialog_display_state_1.forceStopActiveRunsForMainDialog)(mainDialogId);
     });
-    (0, persistence_1.setFinalizeDialogQuarantineHook)(({ rootDialogId, status, quarantined }) => {
+    (0, persistence_1.setFinalizeDialogQuarantineHook)(({ mainDialogId, status, quarantined }) => {
         if (status !== 'running') {
             return;
         }
         if (quarantined) {
-            (0, dialog_display_state_1.clearRootDialogQuarantiningIfIdle)(rootDialogId);
+            (0, dialog_display_state_1.clearMainDialogQuarantiningIfIdle)(mainDialogId);
             return;
         }
-        (0, dialog_display_state_1.clearRootDialogQuarantining)(rootDialogId);
+        (0, dialog_display_state_1.clearMainDialogQuarantining)(mainDialogId);
     });
     (0, persistence_1.setDialogsQuarantinedBroadcaster)((msg) => {
         broadcastToClients(msg);