dominds 1.18.2 → 1.19.2

package/dist/llm/kernel-driver/{subdialog.js → sideDialog.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.supplyResponseToSupdialog = supplyResponseToSupdialog;
-exports.supplySubdialogResponseToSpecificCallerIfPendingV2 = supplySubdialogResponseToSpecificCallerIfPendingV2;
-exports.supplySubdialogResponseToAssignedCallerIfPendingV2 = supplySubdialogResponseToAssignedCallerIfPendingV2;
+exports.supplyResponseToAskerDialog = supplyResponseToAskerDialog;
+exports.supplySideDialogResponseToSpecificAskerIfPendingV2 = supplySideDialogResponseToSpecificAskerIfPendingV2;
+exports.supplySideDialogResponseToAssignedAskerIfPendingV2 = supplySideDialogResponseToAssignedAskerIfPendingV2;
 const storage_1 = require("@longrun-ai/kernel/types/storage");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("../../dialog");
@@ -13,7 +13,7 @@ const persistence_1 = require("../../persistence");
 const inter_dialog_format_1 = require("../../runtime/inter-dialog-format");
 const work_language_1 = require("../../runtime/work-language");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
-const subdialog_txn_1 = require("./subdialog-txn");
+const sideDialog_txn_1 = require("./sideDialog-txn");
 async function syncPendingTellaskReminderBestEffort(dlg, where) {
     try {
         const changed = await (0, pending_tellask_reminder_1.syncPendingTellaskReminderState)(dlg);
@@ -30,22 +30,22 @@ async function syncPendingTellaskReminderBestEffort(dlg, where) {
         });
     }
 }
-async function resolveOwnerDialogBySelfId(subdialog, ownerDialogId) {
-    const rootDialog = subdialog.rootDialog;
-    if (!(await ensureDialogFreshOrDiscard(rootDialog, 'resolveOwnerDialogBySelfId:root'))) {
+async function resolveOwnerDialogBySelfId(sideDialog, ownerDialogId) {
+    const mainDialog = sideDialog.mainDialog;
+    if (!(await ensureDialogFreshOrDiscard(mainDialog, 'resolveOwnerDialogBySelfId:root'))) {
         return undefined;
     }
-    if (ownerDialogId === rootDialog.id.selfId) {
-        return rootDialog;
+    if (ownerDialogId === mainDialog.id.selfId) {
+        return mainDialog;
     }
-    const existing = rootDialog.lookupDialog(ownerDialogId);
+    const existing = mainDialog.lookupDialog(ownerDialogId);
     if (existing) {
         if (!(await ensureDialogFreshOrDiscard(existing, 'resolveOwnerDialogBySelfId:lookup'))) {
             return undefined;
         }
         return existing;
     }
-    const restored = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(ownerDialogId, rootDialog.id.rootId), rootDialog.status);
+    const restored = await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, new dialog_1.DialogID(ownerDialogId, mainDialog.id.rootId), mainDialog.status);
     if (!restored) {
         return undefined;
     }
@@ -74,13 +74,13 @@ async function ensureDialogFreshOrDiscard(dialog, where) {
                     inMemoryStatus: dialog.status,
                     persistedStatus: status,
                 });
-                if (dialog instanceof dialog_1.RootDialog) {
+                if (dialog instanceof dialog_1.MainDialog) {
                     dialog_global_registry_1.globalDialogRegistry.unregister(dialog.id.rootId);
                 }
                 return false;
             }
         }
-        if (dialog instanceof dialog_1.RootDialog && dialog.status === 'running') {
+        if (dialog instanceof dialog_1.MainDialog && dialog.status === 'running') {
             const createdAt = (0, time_1.formatUnifiedTimestamp)(new Date());
             await persistence_1.DialogPersistence.saveDialogMetadata(dialog.id, {
                 id: dialog.id.selfId,
@@ -88,7 +88,7 @@ async function ensureDialogFreshOrDiscard(dialog, where) {
                 taskDocPath: dialog.taskDocPath,
                 createdAt,
             }, 'running');
-            log_1.log.warn('kernel-driver auto-persisted missing root dialog metadata', undefined, {
+            log_1.log.warn('kernel-driver auto-persisted missing main dialog metadata', undefined, {
                 where,
                 rootId: dialog.id.rootId,
                 selfId: dialog.id.selfId,
@@ -111,7 +111,7 @@ async function ensureDialogFreshOrDiscard(dialog, where) {
         selfId: dialog.id.selfId,
         status: dialog.status,
     });
-    if (dialog instanceof dialog_1.RootDialog) {
+    if (dialog instanceof dialog_1.MainDialog) {
         dialog_global_registry_1.globalDialogRegistry.unregister(dialog.id.rootId);
     }
     return false;
@@ -147,22 +147,25 @@ async function resolveLatestAssignmentAnchorRef(args) {
     }
     return undefined;
 }
-async function supplyResponseToSupdialog(args) {
-    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', deliveryMode = 'reply_tool', calleeResponseRef, callerCourseOverride, scheduleDrive, subdialog: maybeSubdialog, } = args;
+async function supplyResponseToAskerDialog(args) {
+    const { parentDialog, sideDialogId, responseText, callType, callId, status = 'completed', deliveryMode = 'reply_tool', calleeResponseRef, askerCourseOverride, scheduleDrive, sideDialog: maybeSideDialog, } = args;
     try {
-        const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(parentDialog.id, async () => {
-            const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(parentDialog.id, parentDialog.status);
+        const result = await (0, sideDialog_txn_1.withSideDialogTxnLock)(parentDialog.id, async () => {
+            const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(parentDialog.id, parentDialog.status);
             let pendingRecord;
             const filteredPending = [];
-            for (const pending of pendingSubdialogs) {
-                if (pending.subdialogId === subdialogId.selfId) {
+            const requestedCallId = typeof callId === 'string' ? callId.trim() : '';
+            for (const pending of pendingSideDialogs) {
+                if (pending.sideDialogId === sideDialogId.selfId &&
+                    (requestedCallId === '' || pending.callId === requestedCallId) &&
+                    pendingRecord === undefined) {
                     pendingRecord = pending;
                 }
                 else {
                     filteredPending.push(pending);
                 }
             }
-            let responderId = subdialogId.rootId;
+            let responderId = sideDialogId.rootId;
             let responderAgentId;
             let callName = 'tellaskSessionless';
             let mentionList;
@@ -170,26 +173,25 @@ async function supplyResponseToSupdialog(args) {
             let originMemberId;
             let sessionSlug;
             try {
-                const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(subdialogId, parentDialog.status);
-                if (metadata && metadata.assignmentFromSup) {
-                    originMemberId = metadata.assignmentFromSup.originMemberId;
+                const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(sideDialogId, parentDialog.status);
+                if (metadata) {
+                    const assignmentFromAsker = await persistence_1.DialogPersistence.loadSideDialogAssignmentFromAsker(sideDialogId, parentDialog.status);
+                    originMemberId = assignmentFromAsker.originMemberId;
                     if (!pendingRecord) {
-                        callName = metadata.assignmentFromSup.callName;
-                        mentionList = metadata.assignmentFromSup.mentionList;
-                        tellaskContent = metadata.assignmentFromSup.tellaskContent;
+                        callName = assignmentFromAsker.callName;
+                        mentionList = assignmentFromAsker.mentionList;
+                        tellaskContent = assignmentFromAsker.tellaskContent;
                     }
-                }
-                if (!pendingRecord && metadata && typeof metadata.agentId === 'string') {
-                    if (metadata.agentId.trim() !== '') {
+                    if (!pendingRecord && metadata.agentId.trim() !== '') {
                         responderId = metadata.agentId;
                         responderAgentId = metadata.agentId;
                     }
                 }
             }
             catch (err) {
-                log_1.log.warn('Failed to load subdialog metadata for response record', undefined, {
+                log_1.log.warn('Failed to load sideDialog metadata for response record', undefined, {
                     parentId: parentDialog.id.selfId,
-                    subdialogId: subdialogId.selfId,
+                    sideDialogId: sideDialogId.selfId,
                     error: err,
                 });
             }
@@ -208,17 +210,21 @@ async function supplyResponseToSupdialog(args) {
                 (!Array.isArray(mentionList) || mentionList.length < 1)) {
                 mentionList = [`@${responderId}`];
             }
-            await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending, (0, storage_1.toRootGenerationAnchor)({
-                rootCourse: parentDialog instanceof dialog_1.SubDialog
-                    ? parentDialog.rootDialog.currentCourse
+            await persistence_1.DialogPersistence.savePendingSideDialogs(parentDialog.id, filteredPending, (0, storage_1.toRootGenerationAnchor)({
+                rootCourse: parentDialog instanceof dialog_1.SideDialog
+                    ? parentDialog.mainDialog.currentCourse
                     : parentDialog.currentCourse,
-                rootGenseq: parentDialog instanceof dialog_1.SubDialog
-                    ? (parentDialog.rootDialog.activeGenSeqOrUndefined ?? 0)
+                rootGenseq: parentDialog instanceof dialog_1.SideDialog
+                    ? (parentDialog.mainDialog.activeGenSeqOrUndefined ?? 0)
                     : (parentDialog.activeGenSeqOrUndefined ?? 0),
             }), parentDialog.status);
+            const sameWaitGroupPending = pendingRecord === undefined
+                ? []
+                : filteredPending.filter((pending) => pending.callSiteCourse === pendingRecord.callSiteCourse &&
+                    pending.callSiteGenseq === pendingRecord.callSiteGenseq);
             const hasQ4H = await parentDialog.hasPendingQ4H();
-            const shouldRevive = !hasQ4H && filteredPending.length === 0;
-            if (shouldRevive && parentDialog instanceof dialog_1.RootDialog) {
+            const shouldRevive = pendingRecord !== undefined && !hasQ4H && sameWaitGroupPending.length === 0;
+            if (shouldRevive && parentDialog instanceof dialog_1.MainDialog) {
                 await persistence_1.DialogPersistence.setNeedsDrive(parentDialog.id, true, parentDialog.status);
             }
             return {
@@ -230,70 +236,76 @@ async function supplyResponseToSupdialog(args) {
                 originMemberId,
                 sessionSlug,
                 callId: pendingRecord?.callId,
-                callingCourse: pendingRecord?.callingCourse,
-                callingGenseq: pendingRecord?.callingGenseq,
-                callerCourse: pendingRecord?.callingCourse !== undefined
-                    ? (0, storage_1.toCallerCourseNumber)(pendingRecord.callingCourse)
-                    : callerCourseOverride,
+                callSiteCourse: pendingRecord?.callSiteCourse,
+                callSiteGenseq: pendingRecord?.callSiteGenseq,
+                resolvedCallIds: pendingRecord ? [pendingRecord.callId] : [],
+                askerCourse: pendingRecord?.callSiteCourse !== undefined
+                    ? (0, storage_1.toAskerCourseNumber)(pendingRecord.callSiteCourse)
+                    : askerCourseOverride,
                 shouldRevive,
             };
         });
         const normalizedCallId = typeof callId === 'string' ? callId.trim() : '';
         const fallbackCallId = typeof result.callId === 'string' ? result.callId.trim() : '';
         const resolvedCallId = normalizedCallId !== '' ? normalizedCallId : fallbackCallId;
-        const rootForLookup = parentDialog instanceof dialog_1.RootDialog
+        const rootForLookup = parentDialog instanceof dialog_1.MainDialog
             ? parentDialog
-            : parentDialog instanceof dialog_1.SubDialog
-                ? parentDialog.rootDialog
+            : parentDialog instanceof dialog_1.SideDialog
+                ? parentDialog.mainDialog
                 : undefined;
-        const resolvedSubdialog = maybeSubdialog ?? rootForLookup?.lookupDialog(subdialogId.selfId);
-        const upstreamResponseBody = responseText;
-        const requesterId = result.originMemberId ?? parentDialog.agentId;
-        const upstreamResponseText = (0, inter_dialog_format_1.formatTellaskResponseContent)({
+        const lookedUpSideDialog = rootForLookup?.lookupDialog(sideDialogId.selfId);
+        const resolvedSideDialog = maybeSideDialog ??
+            (lookedUpSideDialog instanceof dialog_1.SideDialog ? lookedUpSideDialog : undefined);
+        const tellaskerResponseBody = responseText;
+        const tellaskerId = result.originMemberId ?? parentDialog.agentId;
+        const tellaskerResponseText = (0, inter_dialog_format_1.formatTellaskResponseContent)({
             callName: result.callName,
+            callId: resolvedCallId,
             responderId: result.responderId,
-            requesterId,
+            tellaskerId,
             mentionList: result.mentionList,
             sessionSlug: result.sessionSlug,
             tellaskContent: result.tellaskContent,
-            responseBody: upstreamResponseBody,
+            responseBody: tellaskerResponseBody,
             status,
             deliveryMode,
             language: (0, work_language_1.getWorkLanguage)(),
         });
-        const carryoverOriginCourse = result.callingCourse;
+        const carryoverCallSiteCourse = result.callSiteCourse;
         let assignmentRef;
-        const carryoverContent = carryoverOriginCourse !== undefined && carryoverOriginCourse !== parentDialog.currentCourse
+        const carryoverContent = carryoverCallSiteCourse !== undefined &&
+            carryoverCallSiteCourse !== parentDialog.currentCourse
             ? (0, inter_dialog_format_1.formatTellaskCarryoverResultContent)({
-                originCourse: carryoverOriginCourse,
+                callSiteCourse: carryoverCallSiteCourse,
                 callName: result.callName,
+                callId: resolvedCallId,
                 responderId: result.responderId,
                 mentionList: result.mentionList,
                 sessionSlug: result.sessionSlug,
                 tellaskContent: result.tellaskContent,
-                responseBody: upstreamResponseBody,
+                responseBody: tellaskerResponseBody,
                 status,
                 language: (0, work_language_1.getWorkLanguage)(),
             })
             : undefined;
         if (resolvedCallId !== '' && calleeResponseRef) {
-            if (result.callerCourse === undefined) {
-                throw new Error(`tellask response anchor invariant violation: missing callerCourse ` +
-                    `(parentId=${parentDialog.id.selfId}, subdialogId=${subdialogId.selfId}, callId=${resolvedCallId})`);
+            if (result.askerCourse === undefined) {
+                throw new Error(`tellask response anchor invariant violation: missing askerCourse ` +
+                    `(parentId=${parentDialog.id.selfId}, sideDialogId=${sideDialogId.selfId}, callId=${resolvedCallId})`);
             }
             assignmentRef = await resolveLatestAssignmentAnchorRef({
-                calleeDialogId: subdialogId,
+                calleeDialogId: sideDialogId,
                 callId: resolvedCallId,
                 status: parentDialog.status,
             });
             if (!assignmentRef) {
-                // A sideline can legitimately finish a pending tellask before the queued assignment
+                // A Side Dialog can legitimately finish a pending tellask before the queued assignment
                 // prompt for that call is rendered locally, for example after a direct user nudge inside
-                // the sideline dialog. Keep the caller deep-link anchor, but do not treat the missing
+                // the Side Dialog. Keep the asker deep-link anchor, but do not treat the missing
                 // local assignment bubble as an invariant violation.
                 log_1.log.debug('Tellask response anchor has no local assignment anchor', undefined, {
                     parentId: parentDialog.id.selfId,
-                    subdialogId: subdialogId.selfId,
+                    sideDialogId: sideDialogId.selfId,
                     callId: resolvedCallId,
                     responseCourse: calleeResponseRef.course,
                     responseGenseq: calleeResponseRef.genseq,
@@ -308,18 +320,29 @@ async function supplyResponseToSupdialog(args) {
                     replyCallName: args.replyResolution.replyCallName,
                     targetCallId: resolvedCallId,
                     ...(0, storage_1.toRootGenerationAnchor)({
-                        rootCourse: parentDialog instanceof dialog_1.SubDialog
-                            ? parentDialog.rootDialog.currentCourse
+                        rootCourse: parentDialog instanceof dialog_1.SideDialog
+                            ? parentDialog.mainDialog.currentCourse
                             : parentDialog.currentCourse,
-                        rootGenseq: parentDialog instanceof dialog_1.SubDialog
-                            ? (parentDialog.rootDialog.activeGenSeqOrUndefined ?? 0)
+                        rootGenseq: parentDialog instanceof dialog_1.SideDialog
+                            ? (parentDialog.mainDialog.activeGenSeqOrUndefined ?? 0)
                             : (parentDialog.activeGenSeqOrUndefined ?? 0),
                     }),
                 };
-                await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, replyResolutionRecord, parentDialog.status);
-                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(subdialogId, parentDialog.status);
+                await persistence_1.DialogPersistence.appendEvent(sideDialogId, calleeResponseRef.course, replyResolutionRecord, parentDialog.status);
+                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(sideDialogId, parentDialog.status);
                 if (deferredReplyReassertion?.directive.targetCallId === resolvedCallId) {
-                    await persistence_1.DialogPersistence.setDeferredReplyReassertion(subdialogId, undefined, parentDialog.status);
+                    await persistence_1.DialogPersistence.setDeferredReplyReassertion(sideDialogId, undefined, parentDialog.status);
+                }
+                const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(sideDialogId, parentDialog.status);
+                if (activeReplyObligation?.targetCallId === resolvedCallId) {
+                    await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(sideDialogId, undefined, parentDialog.status);
+                    if (maybeSideDialog) {
+                        const nextAskerStackState = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(maybeSideDialog.id, maybeSideDialog.status);
+                        if (!nextAskerStackState) {
+                            throw new Error(`Missing asker stack after reply obligation pop: ${maybeSideDialog.id.valueOf()}`);
+                        }
+                        maybeSideDialog.askerStack = nextAskerStackState;
+                    }
                 }
             }
             const anchorRecord = {
@@ -329,33 +352,33 @@ async function supplyResponseToSupdialog(args) {
                 callId: resolvedCallId,
                 genseq: calleeResponseRef.genseq,
                 ...(0, storage_1.toRootGenerationAnchor)({
-                    rootCourse: parentDialog instanceof dialog_1.SubDialog
-                        ? parentDialog.rootDialog.currentCourse
+                    rootCourse: parentDialog instanceof dialog_1.SideDialog
+                        ? parentDialog.mainDialog.currentCourse
                         : parentDialog.currentCourse,
-                    rootGenseq: parentDialog instanceof dialog_1.SubDialog
-                        ? (parentDialog.rootDialog.activeGenSeqOrUndefined ?? 0)
+                    rootGenseq: parentDialog instanceof dialog_1.SideDialog
+                        ? (parentDialog.mainDialog.activeGenSeqOrUndefined ?? 0)
                         : (parentDialog.activeGenSeqOrUndefined ?? 0),
                 }),
                 assignmentCourse: assignmentRef !== undefined ? (0, storage_1.toAssignmentCourseNumber)(assignmentRef.course) : undefined,
                 assignmentGenseq: assignmentRef !== undefined
                     ? (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentRef.genseq)
                     : undefined,
-                callerDialogId: parentDialog.id.selfId,
-                callerCourse: result.callerCourse,
+                askerDialogId: parentDialog.id.selfId,
+                askerCourse: result.askerCourse,
             };
-            await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, anchorRecord, parentDialog.status);
+            await persistence_1.DialogPersistence.appendEvent(sideDialogId, calleeResponseRef.course, anchorRecord, parentDialog.status);
         }
-        await syncPendingTellaskReminderBestEffort(parentDialog, 'kernel-driver:supplyResponseToSupdialog');
-        await parentDialog.receiveTellaskResponse(result.responderId, result.callName, result.mentionList, result.tellaskContent, status, subdialogId, {
-            response: upstreamResponseText,
+        await syncPendingTellaskReminderBestEffort(parentDialog, 'kernel-driver:supplyResponseToAskerDialog');
+        await parentDialog.receiveTellaskResponse(result.responderId, result.callName, result.mentionList, result.tellaskContent, status, sideDialogId, {
+            response: tellaskerResponseText,
             agentId: result.responderAgentId ?? result.responderId,
             callId: resolvedCallId,
-            originMemberId: requesterId,
-            originCourse: carryoverOriginCourse,
-            calling_genseq: result.callingGenseq !== undefined
-                ? (0, storage_1.toCallingGenerationSeqNumber)(result.callingGenseq)
+            originMemberId: tellaskerId,
+            callSiteCourse: carryoverCallSiteCourse,
+            callSiteGenseq: result.callSiteGenseq !== undefined
+                ? (0, storage_1.toCallSiteGenseqNo)(result.callSiteGenseq)
                 : assignmentRef !== undefined
-                    ? (0, storage_1.toCallingGenerationSeqNumber)(assignmentRef.genseq)
+                    ? (0, storage_1.toCallSiteGenseqNo)(assignmentRef.genseq)
                     : undefined,
             carryoverContent,
             sessionSlug: result.sessionSlug,
@@ -372,16 +395,16 @@ async function supplyResponseToSupdialog(args) {
                 role: 'user',
                 genseq: parentDialog.activeGenSeqOrUndefined ?? 1,
                 content: carryoverContent,
-                originCourse: carryoverOriginCourse,
+                callSiteCourse: carryoverCallSiteCourse,
                 carryoverCourse: parentDialog.currentCourse,
                 responderId: result.responderId,
                 callName: result.callName,
                 tellaskContent: result.tellaskContent,
                 status,
-                response: upstreamResponseText,
+                response: tellaskerResponseText,
                 agentId: result.responderAgentId ?? result.responderId,
                 callId: resolvedCallId,
-                originMemberId: requesterId,
+                originMemberId: tellaskerId,
                 ...(result.callName === 'tellask'
                     ? {
                         mentionList: result.mentionList ?? [],
@@ -394,12 +417,12 @@ async function supplyResponseToSupdialog(args) {
                         : {}),
                 ...(calleeResponseRef !== undefined
                     ? {
-                        calleeDialogId: subdialogId.selfId,
+                        calleeDialogId: sideDialogId.selfId,
                         calleeCourse: calleeResponseRef.course,
                         calleeGenseq: calleeResponseRef.genseq,
                     }
                     : {
-                        calleeDialogId: subdialogId.selfId,
+                        calleeDialogId: sideDialogId.selfId,
                     }),
             }
             : {
@@ -408,12 +431,14 @@ async function supplyResponseToSupdialog(args) {
                 callId: resolvedCallId,
                 callName: result.callName,
                 status,
-                content: upstreamResponseText,
-                ...(result.callingCourse !== undefined ? { originCourse: result.callingCourse } : {}),
-                ...(result.callingGenseq !== undefined
-                    ? { calling_genseq: result.callingGenseq }
+                content: tellaskerResponseText,
+                ...(result.callSiteCourse !== undefined
+                    ? { callSiteCourse: result.callSiteCourse }
+                    : {}),
+                ...(result.callSiteGenseq !== undefined
+                    ? { callSiteGenseq: result.callSiteGenseq }
                     : assignmentRef !== undefined
-                        ? { calling_genseq: assignmentRef.genseq }
+                        ? { callSiteGenseq: assignmentRef.genseq }
                         : {}),
                 call: result.callName === 'tellask'
                     ? {
@@ -432,10 +457,10 @@ async function supplyResponseToSupdialog(args) {
                 responder: {
                     responderId: result.responderId,
                     agentId: result.responderAgentId ?? result.responderId,
-                    originMemberId: requesterId,
+                    originMemberId: tellaskerId,
                 },
                 route: {
-                    calleeDialogId: subdialogId.selfId,
+                    calleeDialogId: sideDialogId.selfId,
                     ...(calleeResponseRef !== undefined
                         ? {
                             calleeCourse: calleeResponseRef.course,
@@ -446,13 +471,15 @@ async function supplyResponseToSupdialog(args) {
             };
         await parentDialog.addChatMessages(immediateMirror);
         if (result.shouldRevive) {
-            const isRoot = parentDialog instanceof dialog_1.RootDialog;
+            const isRoot = parentDialog instanceof dialog_1.MainDialog;
             const hasRegistryEntry = isRoot
                 ? dialog_global_registry_1.globalDialogRegistry.get(parentDialog.id.rootId) !== undefined
                 : false;
-            log_1.log.debug(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, undefined, {
+            log_1.log.debug(`All Type ${callType} sideDialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, undefined, {
                 rootId: parentDialog.id.rootId,
                 selfId: parentDialog.id.selfId,
+                callSiteCourse: result.callSiteCourse,
+                callSiteGenseq: result.callSiteGenseq,
                 via: isRoot && hasRegistryEntry ? 'backend_loop_trigger' : 'direct_schedule_drive',
                 isRoot,
                 hasRegistryEntry,
@@ -460,58 +487,64 @@ async function supplyResponseToSupdialog(args) {
             if (isRoot) {
                 dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId, {
                     source: 'kernel_driver_supply_response',
-                    reason: `all_pending_subdialogs_resolved:type_${callType}`,
+                    reason: `all_pending_sideDialogs_resolved:type_${callType}`,
                 });
             }
-            if (!isRoot || !hasRegistryEntry) {
-                scheduleDrive(parentDialog, {
-                    waitInQue: true,
-                    driveOptions: {
-                        suppressDiligencePush: parentDialog.disableDiligencePush,
-                        noPromptSubdialogResumeEntitlement: {
-                            ownerDialogId: parentDialog.id.selfId,
-                            reason: 'resolved_pending_subdialog_reply',
-                            subdialogId: subdialogId.selfId,
-                            callType,
-                            callId: resolvedCallId,
-                        },
-                        source: 'kernel_driver_supply_response_parent_revive',
-                        reason: `all_pending_subdialogs_resolved:type_${callType}`,
-                    },
-                });
+            if (result.callSiteCourse === undefined || result.callSiteGenseq === undefined) {
+                throw new Error(`sideDialog revive entitlement invariant violation: missing wait-group coordinates ` +
+                    `(rootId=${parentDialog.id.rootId}, selfId=${parentDialog.id.selfId}, callId=${resolvedCallId})`);
             }
+            scheduleDrive(parentDialog, {
+                waitInQue: true,
+                driveOptions: {
+                    suppressDiligencePush: parentDialog.disableDiligencePush,
+                    noPromptSideDialogResumeEntitlement: {
+                        ownerDialogId: parentDialog.id.selfId,
+                        reason: 'resolved_pending_sideDialog_reply',
+                        sideDialogId: sideDialogId.selfId,
+                        callType,
+                        callId: resolvedCallId,
+                        callSiteCourse: result.callSiteCourse,
+                        callSiteGenseq: result.callSiteGenseq,
+                        resolvedCallIds: result.resolvedCallIds,
+                        triggerCallId: resolvedCallId,
+                    },
+                    source: 'kernel_driver_supply_response_parent_revive',
+                    reason: `wait_group_resolved:type_${callType}:c${result.callSiteCourse}:g${result.callSiteGenseq}`,
+                },
+            });
         }
     }
     catch (error) {
-        log_1.log.error('kernel-driver failed to supply subdialog response', error, {
+        log_1.log.error('kernel-driver failed to supply sideDialog response', error, {
             parentId: parentDialog.id.selfId,
-            subdialogId: subdialogId.selfId,
+            sideDialogId: sideDialogId.selfId,
         });
         throw error;
     }
 }
-async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
-    const { subdialog, responseText, responseGenseq, target, scheduleDrive } = args;
-    const assignment = subdialog.assignmentFromSup;
+async function supplySideDialogResponseToSpecificAskerIfPendingV2(args) {
+    const { sideDialog, responseText, responseGenseq, target, scheduleDrive } = args;
+    const assignment = sideDialog.assignmentFromAsker;
     if (!assignment) {
         return false;
     }
-    const ownerDialog = await resolveOwnerDialogBySelfId(subdialog, target.ownerDialogId);
+    const ownerDialog = await resolveOwnerDialogBySelfId(sideDialog, target.ownerDialogId);
     if (!ownerDialog) {
         return false;
     }
-    if (!(await ensureDialogFreshOrDiscard(ownerDialog, 'supplySubdialogResponseToSpecificCallerIfPendingV2:owner'))) {
+    if (!(await ensureDialogFreshOrDiscard(ownerDialog, 'supplySideDialogResponseToSpecificAskerIfPendingV2:owner'))) {
         return false;
     }
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(ownerDialog.id, ownerDialog.status);
-    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(ownerDialog.id, ownerDialog.status);
+    const pendingRecord = pending.find((p) => p.sideDialogId === sideDialog.id.selfId && p.callId === target.callId);
     if (!pendingRecord) {
         return false;
     }
     if (pendingRecord.callType !== target.callType) {
         log_1.log.warn('Reply target callType does not match pending callType; skipping stale reply target', undefined, {
-            rootId: subdialog.rootDialog.id.rootId,
-            subdialogId: subdialog.id.selfId,
+            rootId: sideDialog.mainDialog.id.rootId,
+            sideDialogId: sideDialog.id.selfId,
             ownerDialogId: ownerDialog.id.selfId,
             targetCallType: target.callType,
             pendingCallType: pendingRecord.callType,
@@ -520,29 +553,29 @@ async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
     }
     if (pendingRecord.callType === 'B') {
         const assignmentAnchorRef = await resolveLatestAssignmentAnchorRef({
-            calleeDialogId: subdialog.id,
+            calleeDialogId: sideDialog.id,
             callId: pendingRecord.callId,
-            status: subdialog.status,
+            status: sideDialog.status,
         });
         if (!assignmentAnchorRef) {
             log_1.log.debug('Skip Type B response supply before updated assignment is rendered locally', undefined, {
-                rootId: subdialog.rootDialog.id.rootId,
-                subdialogId: subdialog.id.selfId,
+                rootId: sideDialog.mainDialog.id.rootId,
+                sideDialogId: sideDialog.id.selfId,
                 ownerDialogId: ownerDialog.id.selfId,
                 callId: pendingRecord.callId,
                 responseGenseq,
             });
             return false;
         }
-        if (subdialog.currentCourse < assignmentAnchorRef.course ||
-            (subdialog.currentCourse === assignmentAnchorRef.course &&
+        if (sideDialog.currentCourse < assignmentAnchorRef.course ||
+            (sideDialog.currentCourse === assignmentAnchorRef.course &&
                 responseGenseq < assignmentAnchorRef.genseq)) {
             log_1.log.debug('Skip stale Type B response supply from before latest local assignment', undefined, {
-                rootId: subdialog.rootDialog.id.rootId,
-                subdialogId: subdialog.id.selfId,
+                rootId: sideDialog.mainDialog.id.rootId,
+                sideDialogId: sideDialog.id.selfId,
                 ownerDialogId: ownerDialog.id.selfId,
                 callId: pendingRecord.callId,
-                responseCourse: subdialog.currentCourse,
+                responseCourse: sideDialog.currentCourse,
                 responseGenseq,
                 assignmentCourse: assignmentAnchorRef.course,
                 assignmentGenseq: assignmentAnchorRef.genseq,
@@ -550,69 +583,69 @@ async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
             return false;
         }
     }
-    await supplyResponseToSupdialog({
+    await supplyResponseToAskerDialog({
         parentDialog: ownerDialog,
-        subdialogId: subdialog.id,
+        sideDialogId: sideDialog.id,
         responseText,
-        subdialog,
+        sideDialog,
         callType: pendingRecord.callType,
         callId: target.callId,
         status: 'completed',
         deliveryMode: args.deliveryMode,
         replyResolution: args.replyResolution,
-        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
+        calleeResponseRef: { course: sideDialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,
     });
     return true;
 }
-async function supplySubdialogResponseToAssignedCallerIfPendingV2(args) {
-    const { subdialog, responseText, responseGenseq, scheduleDrive } = args;
-    const assignment = subdialog.assignmentFromSup;
+async function supplySideDialogResponseToAssignedAskerIfPendingV2(args) {
+    const { sideDialog, responseText, responseGenseq, scheduleDrive } = args;
+    const assignment = sideDialog.assignmentFromAsker;
     if (!assignment) {
         return false;
     }
-    const callerDialog = await resolveOwnerDialogBySelfId(subdialog, assignment.callerDialogId);
-    if (!callerDialog) {
-        log_1.log.warn('Missing caller dialog for subdialog response supply', undefined, {
-            rootId: subdialog.rootDialog.id.rootId,
-            subdialogId: subdialog.id.selfId,
-            callerDialogId: assignment.callerDialogId,
+    const askerDialog = await resolveOwnerDialogBySelfId(sideDialog, assignment.askerDialogId);
+    if (!askerDialog) {
+        log_1.log.warn('Missing tellasker for sideDialog response supply', undefined, {
+            rootId: sideDialog.mainDialog.id.rootId,
+            sideDialogId: sideDialog.id.selfId,
+            askerDialogId: assignment.askerDialogId,
         });
         return false;
     }
-    if (!(await ensureDialogFreshOrDiscard(callerDialog, 'supplySubdialogResponseToAssignedCallerIfPendingV2:caller'))) {
+    if (!(await ensureDialogFreshOrDiscard(askerDialog, 'supplySideDialogResponseToAssignedAskerIfPendingV2:asker'))) {
         return false;
     }
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(callerDialog.id, callerDialog.status);
-    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(askerDialog.id, askerDialog.status);
+    const pendingRecord = pending.find((p) => p.sideDialogId === sideDialog.id.selfId && p.callId === assignment.callId);
     if (!pendingRecord) {
         return false;
     }
     if (pendingRecord.callType === 'B') {
         const assignmentAnchorRef = await resolveLatestAssignmentAnchorRef({
-            calleeDialogId: subdialog.id,
+            calleeDialogId: sideDialog.id,
             callId: pendingRecord.callId,
-            status: subdialog.status,
+            status: sideDialog.status,
         });
         if (!assignmentAnchorRef) {
             log_1.log.debug('Skip assigned Type B response supply before updated assignment is rendered locally', undefined, {
-                rootId: subdialog.rootDialog.id.rootId,
-                subdialogId: subdialog.id.selfId,
-                callerDialogId: callerDialog.id.selfId,
+                rootId: sideDialog.mainDialog.id.rootId,
+                sideDialogId: sideDialog.id.selfId,
+                askerDialogId: askerDialog.id.selfId,
                 callId: pendingRecord.callId,
                 responseGenseq,
             });
             return false;
         }
-        if (subdialog.currentCourse < assignmentAnchorRef.course ||
-            (subdialog.currentCourse === assignmentAnchorRef.course &&
+        if (sideDialog.currentCourse < assignmentAnchorRef.course ||
+            (sideDialog.currentCourse === assignmentAnchorRef.course &&
                 responseGenseq < assignmentAnchorRef.genseq)) {
             log_1.log.debug('Skip assigned stale Type B response supply from before latest local assignment', undefined, {
-                rootId: subdialog.rootDialog.id.rootId,
-                subdialogId: subdialog.id.selfId,
-                callerDialogId: callerDialog.id.selfId,
+                rootId: sideDialog.mainDialog.id.rootId,
+                sideDialogId: sideDialog.id.selfId,
+                askerDialogId: askerDialog.id.selfId,
                 callId: pendingRecord.callId,
-                responseCourse: subdialog.currentCourse,
+                responseCourse: sideDialog.currentCourse,
                 responseGenseq,
                 assignmentCourse: assignmentAnchorRef.course,
                 assignmentGenseq: assignmentAnchorRef.genseq,
@@ -620,17 +653,17 @@ async function supplySubdialogResponseToAssignedCallerIfPendingV2(args) {
             return false;
         }
     }
-    await supplyResponseToSupdialog({
-        parentDialog: callerDialog,
-        subdialogId: subdialog.id,
+    await supplyResponseToAskerDialog({
+        parentDialog: askerDialog,
+        sideDialogId: sideDialog.id,
         responseText,
-        subdialog,
+        sideDialog,
         callType: pendingRecord.callType,
         callId: assignment.callId,
         status: 'completed',
         deliveryMode: args.deliveryMode,
         replyResolution: args.replyResolution,
-        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
+        calleeResponseRef: { course: sideDialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,
     });
     return true;