dominds 1.18.2 → 1.19.2

package/dist/llm/kernel-driver/tellask-special.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTellaskCallFunctionName = isTellaskCallFunctionName;
-exports.loadLatestActiveTellaskReplyDirective = loadLatestActiveTellaskReplyDirective;
+exports.loadActiveTellaskReplyDirective = loadActiveTellaskReplyDirective;
 exports.deliverTellaskBackReplyFromDirective = deliverTellaskBackReplyFromDirective;
 exports.recoverPendingReplyTellaskCalls = recoverPendingReplyTellaskCalls;
 exports.resolveTellaskFunctionCalls = resolveTellaskFunctionCalls;
 exports.formatTellaskInvalidCallResult = formatTellaskInvalidCallResult;
 exports.formatPendingTellaskFuncResultContent = formatPendingTellaskFuncResultContent;
+exports.formatResolvedTellaskFuncResultContent = formatResolvedTellaskFuncResultContent;
 exports.formatResolvedAskHumanResultContent = formatResolvedAskHumanResultContent;
 exports.executeTellaskCalls = executeTellaskCalls;
 exports.processTellaskFunctionRound = processTellaskFunctionRound;
@@ -25,8 +26,8 @@ const work_language_1 = require("../../runtime/work-language");
 const team_1 = require("../../team");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
 const fbr_1 = require("./fbr");
-const subdialog_1 = require("./subdialog");
-const subdialog_txn_1 = require("./subdialog-txn");
+const sideDialog_1 = require("./sideDialog");
+const sideDialog_txn_1 = require("./sideDialog-txn");
 const TELLASK_SPECIAL_FUNCTION_NAMES = [
     'tellaskBack',
     'tellask',
@@ -47,37 +48,10 @@ function isReplyTellaskCallName(name) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-async function loadLatestActiveTellaskReplyDirective(dialog) {
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
-    if (!latest) {
-        return undefined;
-    }
-    const maxCourse = Math.floor(latest.currentCourse);
-    const resolvedTargetCallIds = new Set();
-    for (let course = maxCourse; course >= 1; course -= 1) {
-        const events = await persistence_1.DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
-        for (let index = events.length - 1; index >= 0; index -= 1) {
-            const event = events[index];
-            if (event.type === 'tellask_reply_resolution_record') {
-                const targetCallId = event.targetCallId.trim();
-                if (targetCallId !== '') {
-                    resolvedTargetCallIds.add(targetCallId);
-                }
-                continue;
-            }
-            if (event.type !== 'human_text_record') {
-                continue;
-            }
-            const directive = event.tellaskReplyDirective;
-            if (!directive) {
-                continue;
-            }
-            const targetCallId = directive.targetCallId.trim();
-            if (targetCallId === '' || resolvedTargetCallIds.has(targetCallId)) {
-                continue;
-            }
-            return directive;
-        }
+async function loadActiveTellaskReplyDirective(dialog) {
+    const durableObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialog.id, dialog.status);
+    if (durableObligation) {
+        return durableObligation;
     }
     return undefined;
 }
@@ -123,6 +97,7 @@ function formatReplyFuncErrorResult(args) {
 function buildAssignmentReplyDirective(args) {
     return {
         expectedReplyCallName: args.callName === 'tellask' ? 'replyTellask' : 'replyTellaskSessionless',
+        targetDialogId: args.targetDialogId,
         targetCallId: args.targetCallId,
         tellaskContent: args.tellaskContent,
     };
@@ -136,64 +111,65 @@ function buildTellaskBackReplyDirective(args) {
     };
 }
 async function deliverTellaskBackReplyFromDirective(args) {
-    // Type-A ask-back is the one place where the local "caller/callee" intuition flips:
-    // the dialog running `replyTellaskBack` is the ask-back responder, while
-    // directive.targetDialogId points to the ask-back requester that must receive the canonical
+    // Type-A ask-back is the one place where the local tellasker/tellaskee intuition flips:
+    // the dialog running `replyTellaskBack` is the ask-back tellaskee, while
+    // directive.targetDialogId points to the ask-back asker that must receive the canonical
     // tellaskBack result. Keep those roles explicit, otherwise it is very easy to accidentally
-    // write the same business result twice by confusing the responder's local plaintext with the
-    // canonical upstream delivery that must come only from an explicit reply tool call.
-    const rootDialog = args.replyingDialog instanceof dialog_1.RootDialog
+    // write the same business result twice by confusing the tellaskee's local plaintext with the
+    // canonical ask-back asker delivery that must come only from an explicit reply tool call.
+    const mainDialog = args.replyingDialog instanceof dialog_1.MainDialog
         ? args.replyingDialog
-        : args.replyingDialog instanceof dialog_1.SubDialog
-            ? args.replyingDialog.rootDialog
+        : args.replyingDialog instanceof dialog_1.SideDialog
+            ? args.replyingDialog.mainDialog
             : undefined;
-    if (!rootDialog) {
-        throw new Error('replyTellaskBack invariant violation: missing root dialog');
+    if (!mainDialog) {
+        throw new Error('replyTellaskBack invariant violation: missing main dialog');
     }
-    const askBackRequesterDialogId = new dialog_1.DialogID(args.directive.targetDialogId, rootDialog.id.rootId);
-    const askBackRequesterDialog = rootDialog.lookupDialog(askBackRequesterDialogId.selfId) ??
-        (await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, askBackRequesterDialogId, rootDialog.status));
-    if (!askBackRequesterDialog) {
-        throw new Error(`replyTellaskBack invariant violation: target dialog ${askBackRequesterDialogId.selfId} not found`);
+    const askBackAskerDialogId = new dialog_1.DialogID(args.directive.targetDialogId, mainDialog.id.rootId);
+    const askBackAskerDialog = mainDialog.lookupDialog(askBackAskerDialogId.selfId) ??
+        (await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, askBackAskerDialogId, mainDialog.status));
+    if (!askBackAskerDialog) {
+        throw new Error(`replyTellaskBack invariant violation: target dialog ${askBackAskerDialogId.selfId} not found`);
     }
     const response = (0, inter_dialog_format_1.formatTellaskResponseContent)({
         callName: 'tellaskBack',
+        callId: args.directive.targetCallId,
         responderId: args.replyingDialog.agentId,
-        requesterId: askBackRequesterDialog.agentId,
+        tellaskerId: askBackAskerDialog.agentId,
         tellaskContent: args.directive.tellaskContent,
         responseBody: args.replyContent,
         status: 'completed',
         deliveryMode: args.deliveryMode,
         language: (0, work_language_1.getWorkLanguage)(),
     });
-    const targetCallOriginCourse = (0, storage_1.toCallingCourseNumber)(askBackRequesterDialog.currentCourse);
-    const targetCallOriginGenseq = (() => {
-        for (let i = askBackRequesterDialog.msgs.length - 1; i >= 0; i -= 1) {
-            const msg = askBackRequesterDialog.msgs[i];
+    const targetCallSiteCourse = (0, storage_1.toCallSiteCourseNo)(askBackAskerDialog.currentCourse);
+    const targetCallSiteGenseq = (() => {
+        for (let i = askBackAskerDialog.msgs.length - 1; i >= 0; i -= 1) {
+            const msg = askBackAskerDialog.msgs[i];
             if (!msg || msg.type !== 'func_call_msg') {
                 continue;
             }
             if (msg.id !== args.directive.targetCallId) {
                 continue;
             }
-            return (0, storage_1.toCallingGenerationSeqNumber)(msg.genseq);
+            return (0, storage_1.toCallSiteGenseqNo)(msg.genseq);
         }
         return undefined;
     })();
-    const replyMirror = await askBackRequesterDialog.receiveTellaskResponse(args.replyingDialog.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.replyingDialog.id, {
+    const replyMirror = await askBackAskerDialog.receiveTellaskResponse(args.replyingDialog.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.replyingDialog.id, {
         response,
         agentId: args.replyingDialog.agentId,
         callId: args.directive.targetCallId,
-        originMemberId: askBackRequesterDialog.agentId,
-        originCourse: targetCallOriginCourse,
-        calling_genseq: targetCallOriginGenseq,
+        originMemberId: askBackAskerDialog.agentId,
+        callSiteCourse: targetCallSiteCourse,
+        callSiteGenseq: targetCallSiteGenseq,
     });
-    await askBackRequesterDialog.addChatMessages(replyMirror);
-    // Do not mark the requester resumed until the canonical tellaskBack result has actually been
+    await askBackAskerDialog.addChatMessages(replyMirror);
+    // Do not mark the ask-back asker resumed until the canonical tellaskBack result has actually been
     // persisted and mirrored locally. Otherwise a write failure here would leave suspension state
     // claiming "resumed" while the business fact never landed.
-    askBackRequesterDialog.setSuspensionState('resumed');
-    await reviveDialogIfUnblocked(askBackRequesterDialog, args.callbacks, 'reply_tellask_back_delivered');
+    askBackAskerDialog.setSuspensionState('resumed');
+    await reviveDialogIfUnblocked(askBackAskerDialog, args.callbacks, 'reply_tellask_back_delivered');
 }
 function isReplyTellaskCallRecord(record) {
     return isReplyTellaskCallName(record.name);
@@ -565,7 +541,6 @@ function resolveTellaskFunctionCalls(funcCalls, options) {
                 originalCall: call,
                 error: parsed.error,
                 rawArgumentsText,
-                contextArguments: rawArgumentsText,
             });
             continue;
         }
@@ -588,7 +563,7 @@ function formatTellaskInvalidCallResult(args) {
         genseq: args.call.genseq,
     };
 }
-function formatPendingTellaskFuncResultContent(name, startedAtMs) {
+function formatPendingTellaskFuncResultContent(name, startedAtMs, callId) {
     const language = (0, work_language_1.getWorkLanguage)();
     const elapsed = (() => {
         if (startedAtMs === null) {
@@ -600,12 +575,99 @@ function formatPendingTellaskFuncResultContent(name, startedAtMs) {
     })();
     if (name === 'askHuman') {
         return language === 'zh'
-            ? `Q4H 仍在等待人类回复，已持续 ${elapsed}。`
-            : `Q4H is still waiting for human reply (elapsed ${elapsed}).`;
+            ? [
+                '[Dominds 诉请状态]',
+                '',
+                '`askHuman` 诉请已发出，当前仍在等待人类回复。',
+                '',
+                ...(callId ? [`- callId: ${callId}`] : []),
+                `- 已等待: ${elapsed}`,
+                '',
+                '这不是回贴内容。若后续收到回复，运行时会在后续上下文中用同一 callId 补入对应回复事实。',
+            ].join('\n')
+            : [
+                '[Dominds tellask status]',
+                '',
+                '`askHuman` has been issued and is still waiting for human reply.',
+                '',
+                ...(callId ? [`- callId: ${callId}`] : []),
+                `- Elapsed: ${elapsed}`,
+                '',
+                'This is not reply content. If a reply arrives later, runtime will append the corresponding reply fact in later context with the same callId.',
+            ].join('\n');
     }
     return language === 'zh'
-        ? `支线对话仍在进行中，已持续 ${elapsed}。`
-        : `Sideline dialog is still running (elapsed ${elapsed}).`;
+        ? [
+            '[Dominds 诉请状态]',
+            '',
+            `\`${name}\` 诉请已发出，当前仍在等待回贴。`,
+            '',
+            ...(callId ? [`- callId: ${callId}`] : []),
+            `- 已等待: ${elapsed}`,
+            '',
+            '这不是回贴内容。若后续收到回贴，运行时会在后续上下文中用同一 callId 补入对应回贴事实。',
+        ].join('\n')
+        : [
+            '[Dominds tellask status]',
+            '',
+            `\`${name}\` has been issued and is still waiting for a reply.`,
+            '',
+            ...(callId ? [`- callId: ${callId}`] : []),
+            `- Elapsed: ${elapsed}`,
+            '',
+            'This is not reply content. If a reply arrives later, runtime will append the corresponding reply fact in later context with the same callId.',
+        ].join('\n');
+}
+function formatResolvedTellaskFuncResultContent(args) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const callId = args.callId.trim();
+    if (callId === '') {
+        throw new Error(`tellask status formatter invariant violation: empty callId for ${args.name}`);
+    }
+    if (language === 'zh') {
+        if (args.status === 'pending') {
+            return [
+                '[Dominds 诉请状态]',
+                '',
+                `\`${args.name}\` 诉请仍在等待回贴，当前没有回贴正文。`,
+                '',
+                `- callId: ${callId}`,
+                '',
+                '不要把本工具结果当作回贴正文；若后续收到回贴，运行时会用同一 callId 补入对应回贴事实。',
+            ].join('\n');
+        }
+        const statusLabel = args.status === 'completed' ? '已收到回贴' : '已失败收口';
+        return [
+            '[Dominds 诉请状态]',
+            '',
+            `\`${args.name}\` 诉请${statusLabel}，对应回贴事实已作为独立上下文事实补入。`,
+            '',
+            `- callId: ${callId}`,
+            '',
+            '请以同一 callId 的独立回贴事实为准；不要把本工具结果当作回贴正文。',
+        ].join('\n');
+    }
+    if (args.status === 'pending') {
+        return [
+            '[Dominds tellask status]',
+            '',
+            `\`${args.name}\` is still waiting for a reply; there is no reply body yet.`,
+            '',
+            `- callId: ${callId}`,
+            '',
+            'Do not treat this tool result as reply content. If a reply arrives later, runtime will append the corresponding reply fact with the same callId.',
+        ].join('\n');
+    }
+    const statusLabel = args.status === 'completed' ? 'has received a reply' : 'has failed/closed';
+    return [
+        '[Dominds tellask status]',
+        '',
+        `\`${args.name}\` ${statusLabel}; the corresponding reply fact is present separately in context.`,
+        '',
+        `- callId: ${callId}`,
+        '',
+        'Use the separate reply fact with the same callId as authoritative; do not treat this tool result as reply content.',
+    ].join('\n');
 }
 function formatResolvedAskHumanResultContent() {
     return (0, work_language_1.getWorkLanguage)() === 'zh'
@@ -619,7 +681,7 @@ function buildPendingTellaskFuncResult(args) {
         genseq: args.genseq,
         id: args.callId,
         name: args.callName,
-        content: formatPendingTellaskFuncResultContent(args.callName, null),
+        content: formatPendingTellaskFuncResultContent(args.callName, null, args.callId),
     };
 }
 async function persistTellaskFuncResult(dlg, result) {
@@ -636,8 +698,8 @@ function buildTellaskResultToolOutput(args) {
         callName: args.callName,
         status: args.status,
         content: args.content,
-        ...(typeof args.originCourse === 'number' ? { originCourse: args.originCourse } : {}),
-        ...(typeof args.calling_genseq === 'number' ? { calling_genseq: args.calling_genseq } : {}),
+        ...(typeof args.callSiteCourse === 'number' ? { callSiteCourse: args.callSiteCourse } : {}),
+        ...(typeof args.callSiteGenseq === 'number' ? { callSiteGenseq: args.callSiteGenseq } : {}),
         call: args.callName === 'tellask'
             ? {
                 tellaskContent: args.tellaskContent,
@@ -676,7 +738,7 @@ function buildTellaskCarryoverToolOutput(args) {
         role: 'user',
         genseq: args.genseq,
         content: args.content,
-        originCourse: args.originCourse,
+        callSiteCourse: args.callSiteCourse,
         carryoverCourse: args.carryoverCourse,
         responderId: args.responderId,
         callName: args.callName,
@@ -750,134 +812,66 @@ function resolveFbrEffort(member) {
         return 0;
     return raw;
 }
-async function createSubDialog(callerDialog, targetAgentId, mentionList, tellaskContent, options) {
-    return await callerDialog.createSubDialog(targetAgentId, mentionList, tellaskContent, options);
+async function createSideDialog(askerDialog, targetAgentId, mentionList, tellaskContent, options) {
+    return await askerDialog.createSideDialog(targetAgentId, mentionList, tellaskContent, options);
 }
-async function updateSubdialogAssignment(subdialog, assignment) {
-    subdialog.assignmentFromSup = assignment;
-    await persistence_1.DialogPersistence.updateSubdialogAssignment(subdialog.id, assignment);
+async function updateSideDialogAssignment(sideDialog, assignment, options) {
+    await persistence_1.DialogPersistence.updateSideDialogAssignment(sideDialog.id, assignment, sideDialog.status, options);
+    const nextAskerStackState = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(sideDialog.id, sideDialog.status);
+    if (!nextAskerStackState) {
+        throw new Error(`Missing asker stack after assignment update: ${sideDialog.id.valueOf()}`);
+    }
+    sideDialog.askerStack = nextAskerStackState;
 }
-async function lookupLiveRegisteredSubdialog(rootDialog, agentId, sessionSlug) {
-    const existing = rootDialog.lookupSubdialog(agentId, sessionSlug);
+async function lookupLiveRegisteredSideDialog(mainDialog, agentId, sessionSlug) {
+    const existing = mainDialog.lookupSideDialog(agentId, sessionSlug);
     if (!existing) {
         return undefined;
     }
     const existingSession = existing.sessionSlug;
     if (!existingSession) {
-        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without sessionSlug (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+        throw new Error(`Type B registry invariant violation: lookupSideDialog returned entry without sessionSlug (root=${mainDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
     }
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, mainDialog.status);
     const executionMarker = latest?.executionMarker;
     if (!executionMarker || executionMarker.kind !== 'dead') {
         return existing;
     }
-    const removed = rootDialog.unregisterSubdialog(existing.agentId, existingSession);
+    const removed = mainDialog.unregisterSideDialog(existing.agentId, existingSession);
     if (!removed) {
-        throw new Error(`Failed to unregister dead registered subdialog: root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
+        throw new Error(`Failed to unregister dead registered sideDialog: root=${mainDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
     }
-    await rootDialog.saveSubdialogRegistry();
-    log_1.log.debug('Pruned dead registered subdialog from Type B registry', undefined, {
-        rootId: rootDialog.id.rootId,
-        subdialogId: existing.id.selfId,
+    await mainDialog.saveSideDialogRegistry();
+    log_1.log.debug('Pruned dead registered sideDialog from Type B registry', undefined, {
+        rootId: mainDialog.id.rootId,
+        sideDialogId: existing.id.selfId,
         agentId: existing.agentId,
         sessionSlug: existingSession,
     });
     return undefined;
 }
-async function resolveDialogWithinRoot(rootDialog, callerDialogId) {
-    if (callerDialogId === rootDialog.id.selfId) {
-        return rootDialog;
+async function resolveDialogWithinRoot(mainDialog, askerDialogId) {
+    if (askerDialogId === mainDialog.id.selfId) {
+        return mainDialog;
     }
-    const live = rootDialog.lookupDialog(callerDialogId);
+    const live = mainDialog.lookupDialog(askerDialogId);
     if (live) {
         return live;
     }
-    const restored = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(callerDialogId, rootDialog.id.rootId), rootDialog.status);
+    const restored = await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, new dialog_1.DialogID(askerDialogId, mainDialog.id.rootId), mainDialog.status);
     if (!restored) {
-        throw new Error(`Type B caller restore invariant violation: root=${rootDialog.id.valueOf()} caller=${callerDialogId}`);
+        throw new Error(`Type B asker restore invariant violation: root=${mainDialog.id.valueOf()} asker=${askerDialogId}`);
     }
     return restored;
 }
-async function finishRegisteredTellaskReplacement(args) {
-    const { ownerDialog, subdialog, pendingRecord, responseBody } = args;
-    const language = (0, work_language_1.getWorkLanguage)();
-    const requesterId = ownerDialog.agentId;
-    const response = (0, inter_dialog_format_1.formatTellaskReplacementNoticeContent)({
-        responderId: subdialog.agentId,
-        requesterId,
-        mentionList: pendingRecord.mentionList,
-        sessionSlug: pendingRecord.sessionSlug,
-        tellaskContent: pendingRecord.tellaskContent,
-        responseBody,
-        language,
-    });
-    const carryoverOriginCourse = pendingRecord.callingCourse;
-    const carryoverContent = carryoverOriginCourse !== undefined && carryoverOriginCourse !== ownerDialog.currentCourse
-        ? (0, inter_dialog_format_1.formatTellaskCarryoverResultContent)({
-            originCourse: carryoverOriginCourse,
-            callName: pendingRecord.callName,
-            responderId: subdialog.agentId,
-            mentionList: pendingRecord.mentionList,
-            sessionSlug: pendingRecord.sessionSlug,
-            tellaskContent: pendingRecord.tellaskContent,
-            responseBody,
-            status: 'failed',
-            language,
-        })
-        : undefined;
-    await ownerDialog.receiveTellaskResponse(subdialog.agentId, pendingRecord.callName, pendingRecord.mentionList, pendingRecord.tellaskContent, 'failed', subdialog.id, {
-        response,
-        agentId: subdialog.agentId,
-        callId: pendingRecord.callId,
-        originMemberId: requesterId,
-        originCourse: carryoverOriginCourse,
-        calling_genseq: pendingRecord.callingGenseq,
-        carryoverContent,
-        sessionSlug: pendingRecord.sessionSlug,
-    });
-    const immediateMirror = carryoverContent !== undefined
-        ? buildTellaskCarryoverToolOutput({
-            genseq: ownerDialog.activeGenSeqOrUndefined ?? 1,
-            content: carryoverContent,
-            originCourse: carryoverOriginCourse,
-            carryoverCourse: ownerDialog.currentCourse,
-            responderId: subdialog.agentId,
-            callName: pendingRecord.callName,
-            tellaskContent: pendingRecord.tellaskContent,
-            status: 'failed',
-            response,
-            agentId: subdialog.agentId,
-            callId: pendingRecord.callId,
-            originMemberId: requesterId,
-            mentionList: pendingRecord.mentionList,
-            sessionSlug: pendingRecord.sessionSlug,
-            calleeDialogId: subdialog.id.selfId,
-        })
-        : buildTellaskResultToolOutput({
-            callId: pendingRecord.callId,
-            callName: pendingRecord.callName,
-            content: response,
-            status: 'failed',
-            originCourse: carryoverOriginCourse,
-            calling_genseq: pendingRecord.callingGenseq,
-            responderId: subdialog.agentId,
-            tellaskContent: pendingRecord.tellaskContent,
-            mentionList: pendingRecord.mentionList,
-            sessionSlug: pendingRecord.sessionSlug,
-            agentId: subdialog.agentId,
-            originMemberId: requesterId,
-            calleeDialogId: subdialog.id.selfId,
-        });
-    await ownerDialog.addChatMessages(immediateMirror);
-}
 async function reviveDialogIfUnblocked(dialog, callbacks, reason) {
     const suspension = await dialog.getSuspensionStatus({
-        allowPendingSubdialogs: reason === 'reply_tellask_back_delivered',
+        allowPendingSideDialogs: true,
     });
     if (!suspension.canDrive) {
         return;
     }
-    if (dialog instanceof dialog_1.RootDialog) {
+    if (dialog instanceof dialog_1.MainDialog) {
         await persistence_1.DialogPersistence.setNeedsDrive(dialog.id, true, dialog.status);
     }
     callbacks.scheduleDrive(dialog, {
@@ -886,12 +880,10 @@ async function reviveDialogIfUnblocked(dialog, callbacks, reason) {
             source: 'kernel_driver_supply_response_parent_revive',
             reason,
             suppressDiligencePush: dialog.disableDiligencePush,
-            noPromptSubdialogResumeEntitlement: dialog instanceof dialog_1.SubDialog
+            noPromptSideDialogResumeEntitlement: dialog instanceof dialog_1.SideDialog
                 ? {
                     ownerDialogId: dialog.id.selfId,
-                    reason: reason === 'reply_tellask_back_delivered'
-                        ? 'reply_tellask_back_delivered'
-                        : 'resolved_pending_subdialog_reply',
+                    reason: 'reply_tellask_back_delivered',
                 }
                 : undefined,
         },
@@ -914,13 +906,13 @@ function extractLastAssistantResponse(messages, defaultMessage) {
     }
     return responseText;
 }
-function findDeliveredTellaskBackReplyOnAskBackRequester(args) {
+function findDeliveredTellaskBackReplyOnAskBackAsker(args) {
     // `replyTellaskBack` persists the canonical tellaskBack business result onto the ask-back
-    // requester dialog immediately. Type-A orchestration must check that canonical delivery first
-    // before it even considers any fallback extraction from responder plaintext, or we risk a
+    // asker immediately. Type-A orchestration must check that canonical delivery first
+    // before it even considers any fallback extraction from tellaskee plaintext, or we risk a
     // second final result with the same target callId.
-    for (let i = args.requesterDialog.msgs.length - 1; i >= 0; i -= 1) {
-        const msg = args.requesterDialog.msgs[i];
+    for (let i = args.askerDialog.msgs.length - 1; i >= 0; i -= 1) {
+        const msg = args.askerDialog.msgs[i];
         if (msg.type !== 'tellask_result_msg' || msg.callName !== 'tellaskBack') {
             continue;
         }
@@ -931,25 +923,31 @@ function findDeliveredTellaskBackReplyOnAskBackRequester(args) {
     }
     return undefined;
 }
-async function extractAskBackResponderPlaintextFallback(args) {
+async function extractAskBackTellaskeePlaintextFallback(args) {
     try {
-        return extractLastAssistantResponse(args.responderDialog.msgs, 'Supdialog completed without producing output.');
+        return extractLastAssistantResponse(args.tellaskeeDialog.msgs, 'AskerDialog completed without producing output.');
     }
     catch (err) {
-        log_1.log.warn('Failed to extract supdialog response for Type A', err);
-        return 'Supdialog completed with errors.';
+        log_1.log.warn('Failed to extract askerDialog response for Type A', err);
+        return 'AskerDialog completed with errors.';
     }
 }
 async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, options) {
     const toolOutputs = [];
     const callName = options.callName;
-    const rawCallingCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
-    const callingCourse = Number.isFinite(rawCallingCourse) && rawCallingCourse > 0
-        ? (0, storage_1.toCallingCourseNumber)(rawCallingCourse)
-        : undefined;
-    const callingGenseq = typeof dlg.activeGenSeqOrUndefined === 'number'
-        ? (0, storage_1.toCallingGenerationSeqNumber)(dlg.activeGenSeqOrUndefined)
-        : undefined;
+    const rawCallSiteCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+    if (!Number.isFinite(rawCallSiteCourse) || rawCallSiteCourse <= 0) {
+        throw new Error(`tellask pending invariant violation: missing valid call-site course ` +
+            `(rootId=${dlg.id.rootId}, selfId=${dlg.id.selfId}, callId=${callId}, callName=${callName})`);
+    }
+    const callSiteCourse = (0, storage_1.toCallSiteCourseNo)(rawCallSiteCourse);
+    if (typeof dlg.activeGenSeqOrUndefined !== 'number' ||
+        !Number.isInteger(dlg.activeGenSeqOrUndefined) ||
+        dlg.activeGenSeqOrUndefined <= 0) {
+        throw new Error(`tellask pending invariant violation: missing active genseq ` +
+            `(rootId=${dlg.id.rootId}, selfId=${dlg.id.selfId}, callId=${callId}, callName=${callName})`);
+    }
+    const callSiteGenseq = (0, storage_1.toCallSiteGenseqNo)(dlg.activeGenSeqOrUndefined);
     const parseResult = options.parseResult;
     const normalizedMentionList = mentionList ?? [];
     const isFreshBootsCall = callName === 'freshBootsReasoning';
@@ -971,7 +969,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 callSiteRef: {
                     course: dlg.currentCourse,
                     messageIndex: dlg.msgs.length,
-                    ...(callingGenseq !== undefined ? { callingGenseq } : {}),
+                    ...(callSiteGenseq !== undefined ? { callSiteGenseq } : {}),
                 },
             };
             await persistence_1.DialogPersistence.appendQuestion4HumanState(dlg.id, question);
@@ -1014,8 +1012,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 callName,
                 content: msg,
                 status: 'failed',
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
                 responderId: 'dominds',
                 tellaskContent: body,
                 mentionList: normalizedMentionList,
@@ -1023,8 +1021,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 originMemberId: dlg.agentId,
             }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
             });
             dlg.clearCurrentCallId();
             return toolOutputs;
@@ -1034,7 +1032,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
         if (callName === 'tellaskBack' && parseResult.type !== 'A') {
             throw new Error(`tellaskBack invariant violation: expected Type A parseResult (callId=${callId}, got=${parseResult.type})`);
         }
-        const subdialogCallName = callName === 'tellaskBack' ? 'freshBootsReasoning' : callName;
+        const sideDialogCallName = callName === 'tellaskBack' ? 'freshBootsReasoning' : callName;
         const firstMentionForError = options.targetForError ?? parseResult.agentId;
         if (parseResult.type !== 'A' && member === null) {
             const msg = (0, driver_messages_1.formatDomindsNoteTellaskForTeammatesOnly)((0, work_language_1.getWorkLanguage)(), {
@@ -1046,8 +1044,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 callName,
                 content: msg,
                 status: 'failed',
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
                 responderId: 'dominds',
                 tellaskContent: body,
                 mentionList: normalizedMentionList,
@@ -1055,8 +1053,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 originMemberId: dlg.agentId,
             }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
             });
             dlg.clearCurrentCallId();
             return toolOutputs;
@@ -1071,8 +1069,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     callName,
                     content: msg,
                     status: 'failed',
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                     responderId: 'dominds',
                     tellaskContent: body,
                     mentionList: normalizedMentionList,
@@ -1080,8 +1078,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     originMemberId: dlg.agentId,
                 }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                 });
                 dlg.clearCurrentCallId();
                 return toolOutputs;
@@ -1103,8 +1101,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     callName,
                     content: msg,
                     status: 'failed',
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                     responderId: 'dominds',
                     tellaskContent: body,
                     mentionList: normalizedMentionList,
@@ -1112,13 +1110,13 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     originMemberId: dlg.agentId,
                 }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                 });
                 dlg.clearCurrentCallId();
                 return toolOutputs;
             }
-            const callerDialog = dlg;
+            const askerDialog = dlg;
             const originMemberId = dlg.agentId;
             const collectiveTargets = options?.collectiveTargets ?? [parseResult.agentId];
             if (parseResult.type !== 'C') {
@@ -1131,8 +1129,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     callName,
                     content: msg,
                     status: 'failed',
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                     responderId: 'dominds',
                     tellaskContent: body,
                     mentionList: normalizedMentionList,
@@ -1140,38 +1138,38 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     originMemberId: dlg.agentId,
                 }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                    originCourse: callingCourse,
-                    calling_genseq: callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                 });
                 dlg.clearCurrentCallId();
                 return toolOutputs;
             }
-            const sub = await createSubDialog(dlg, parseResult.agentId, mentionList, body, {
-                callName: subdialogCallName,
+            const sub = await createSideDialog(dlg, parseResult.agentId, mentionList, body, {
+                callName: sideDialogCallName,
                 originMemberId,
-                callerDialogId: callerDialog.id.selfId,
+                askerDialogId: askerDialog.id.selfId,
                 callId,
                 collectiveTargets,
                 effectiveFbrEffort: fbrEffort,
             });
             sub.setFbrConclusionToolsEnabled(false);
             const pendingRecord = {
-                subdialogId: sub.id.selfId,
+                sideDialogId: sub.id.selfId,
                 createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                callName: subdialogCallName,
+                callName: sideDialogCallName,
                 mentionList,
                 tellaskContent: body,
                 targetAgentId: parseResult.agentId,
                 callId,
-                callingCourse,
-                callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
                 callType: 'C',
             };
-            await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
-                    rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
-                    rootGenseq: dlg instanceof dialog_1.SubDialog
-                        ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
+            await (0, sideDialog_txn_1.withSideDialogTxnLock)(dlg.id, async () => {
+                await persistence_1.DialogPersistence.appendPendingSideDialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
+                    rootCourse: dlg instanceof dialog_1.SideDialog ? dlg.mainDialog.currentCourse : dlg.currentCourse,
+                    rootGenseq: dlg instanceof dialog_1.SideDialog
+                        ? (dlg.mainDialog.activeGenSeqOrUndefined ?? 0)
                         : (dlg.activeGenSeqOrUndefined ?? 0),
                 }));
             });
@@ -1203,8 +1201,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 humanPrompt: initPrompt,
                 waitInQue: true,
                 driveOptions: {
-                    source: 'kernel_driver_subdialog_init',
-                    reason: 'fresh_boots_reasoning_subdialog_init',
+                    source: 'kernel_driver_sideDialog_init',
+                    reason: 'fresh_boots_reasoning_sideDialog_init',
                 },
             });
             return toolOutputs;
@@ -1218,8 +1216,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 callName,
                 content: msg,
                 status: 'failed',
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
                 responderId: 'dominds',
                 tellaskContent: body,
                 mentionList: normalizedMentionList,
@@ -1227,34 +1225,47 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 originMemberId: dlg.agentId,
             }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-                originCourse: callingCourse,
-                calling_genseq: callingGenseq,
+                callSiteCourse,
+                callSiteGenseq,
             });
             dlg.clearCurrentCallId();
             return toolOutputs;
         }
         if (parseResult.type === 'A') {
-            if (dlg instanceof dialog_1.SubDialog) {
+            if (dlg instanceof dialog_1.SideDialog) {
                 // Identity map for Type-A ask-back:
-                // - `askBackRequesterDialog` is the sideline dialog that asked upstream for clarification.
-                // - `askBackResponderDialog` is the upstream dialog that must answer that ask-back.
+                // - `askBackAskerDialog` is the Side Dialog that asked the tellasker for clarification.
+                // - `askBackTellaskeeDialog` is the tellasker that must answer that ask-back.
                 // The original tellask relationship is the opposite of the current ask-back relationship,
-                // so variable names like "supdialog" or "target" are too lossy here and invite bugs.
-                const askBackRequesterDialog = dlg;
-                const askBackResponderDialog = dlg.supdialog;
-                askBackRequesterDialog.setSuspensionState('suspended');
+                // so variable names like "askerDialog" or "target" are too lossy here and invite bugs.
+                const askBackAskerDialog = dlg;
+                const askBackTellaskeeDialog = dlg.askerDialog;
+                askBackAskerDialog.setSuspensionState('suspended');
                 try {
-                    const assignment = askBackRequesterDialog.assignmentFromSup;
-                    const supPrompt = {
-                        content: (0, inter_dialog_format_1.formatSupdialogCallPrompt)({
-                            fromAgentId: askBackRequesterDialog.agentId,
-                            toAgentId: askBackResponderDialog.agentId,
-                            subdialogRequest: {
+                    const assignment = askBackAskerDialog.assignmentFromAsker;
+                    const tellaskBackReplyDirective = buildTellaskBackReplyDirective({
+                        targetDialogId: askBackAskerDialog.id.selfId,
+                        targetCallId: callId,
+                        tellaskContent: body,
+                    });
+                    await persistence_1.DialogPersistence.pushTellaskReplyObligation(askBackTellaskeeDialog.id, tellaskBackReplyDirective, askBackTellaskeeDialog.status);
+                    if (askBackTellaskeeDialog instanceof dialog_1.SideDialog) {
+                        const nextAskerStackState = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(askBackTellaskeeDialog.id, askBackTellaskeeDialog.status);
+                        if (!nextAskerStackState) {
+                            throw new Error(`Missing asker stack after tellaskBack push: ${askBackTellaskeeDialog.id.valueOf()}`);
+                        }
+                        askBackTellaskeeDialog.askerStack = nextAskerStackState;
+                    }
+                    const askerPrompt = {
+                        content: (0, inter_dialog_format_1.formatAskerDialogCallPrompt)({
+                            fromAgentId: askBackAskerDialog.agentId,
+                            toAgentId: askBackTellaskeeDialog.agentId,
+                            sideDialogRequest: {
                                 callName,
                                 mentionList,
                                 tellaskContent: body,
                             },
-                            supdialogAssignment: {
+                            askerDialogAssignment: {
                                 callName: assignment.callName,
                                 mentionList: assignment.mentionList,
                                 tellaskContent: assignment.tellaskContent,
@@ -1264,39 +1275,36 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         msgId: (0, id_1.generateShortId)(),
                         grammar: 'markdown',
                         origin: 'runtime',
-                        tellaskReplyDirective: buildTellaskBackReplyDirective({
-                            targetDialogId: askBackRequesterDialog.id.selfId,
-                            targetCallId: callId,
-                            tellaskContent: body,
-                        }),
+                        tellaskReplyDirective: tellaskBackReplyDirective,
                     };
-                    await callbacks.driveDialog(askBackResponderDialog, {
-                        humanPrompt: supPrompt,
+                    await callbacks.driveDialog(askBackTellaskeeDialog, {
+                        humanPrompt: askerPrompt,
                         waitInQue: true,
                         driveOptions: {
-                            source: 'kernel_driver_type_a_supdialog_call',
-                            reason: 'type_a_supdialog_roundtrip',
+                            source: 'kernel_driver_type_a_askerDialog_call',
+                            reason: 'type_a_askerDialog_roundtrip',
                         },
                     });
-                    const explicitReplyDelivery = findDeliveredTellaskBackReplyOnAskBackRequester({
-                        requesterDialog: askBackRequesterDialog,
+                    const explicitReplyDelivery = findDeliveredTellaskBackReplyOnAskBackAsker({
+                        askerDialog: askBackAskerDialog,
                         targetCallId: callId,
                     });
                     if (explicitReplyDelivery) {
-                        // Important invariant: once the responder used `replyTellaskBack`, that write is the
+                        // Important invariant: once the tellaskee used `replyTellaskBack`, that write is the
                         // single source of truth. Do not also synthesize another tellask result from the
-                        // responder's generic assistant words, even if those words look "compatible".
-                        askBackRequesterDialog.setSuspensionState('resumed');
+                        // tellaskee's generic assistant words, even if those words look "compatible".
+                        askBackAskerDialog.setSuspensionState('resumed');
                         toolOutputs.push(explicitReplyDelivery);
                         return toolOutputs;
                     }
-                    const responseText = await extractAskBackResponderPlaintextFallback({
-                        responderDialog: askBackResponderDialog,
+                    const responseText = await extractAskBackTellaskeePlaintextFallback({
+                        tellaskeeDialog: askBackTellaskeeDialog,
                     });
                     const responseContent = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                         callName,
+                        callId,
                         responderId: parseResult.agentId,
-                        requesterId: askBackRequesterDialog.agentId,
+                        tellaskerId: askBackAskerDialog.agentId,
                         mentionList,
                         tellaskContent: body,
                         responseBody: responseText,
@@ -1304,38 +1312,39 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         deliveryMode: 'direct_fallback',
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
-                    askBackRequesterDialog.setSuspensionState('resumed');
+                    askBackAskerDialog.setSuspensionState('resumed');
                     toolOutputs.push(buildTellaskResultToolOutput({
                         callId,
                         callName,
                         content: responseContent,
                         status: 'completed',
-                        originCourse: callingCourse,
-                        calling_genseq: callingGenseq,
+                        callSiteCourse,
+                        callSiteGenseq,
                         responderId: parseResult.agentId,
                         tellaskContent: body,
                         mentionList,
                         agentId: parseResult.agentId,
-                        originMemberId: askBackRequesterDialog.agentId,
-                        calleeDialogId: askBackResponderDialog.id.selfId,
+                        originMemberId: askBackAskerDialog.agentId,
+                        calleeDialogId: askBackTellaskeeDialog.id.selfId,
                     }));
-                    await askBackRequesterDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'completed', askBackResponderDialog.id, {
+                    await askBackAskerDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'completed', askBackTellaskeeDialog.id, {
                         response: responseContent,
                         agentId: parseResult.agentId,
                         callId,
-                        originMemberId: askBackRequesterDialog.agentId,
-                        originCourse: callingCourse,
-                        calling_genseq: callingGenseq,
+                        originMemberId: askBackAskerDialog.agentId,
+                        callSiteCourse,
+                        callSiteGenseq,
                     });
                 }
                 catch (err) {
-                    log_1.log.warn('Type A supdialog processing error:', err);
-                    askBackRequesterDialog.setSuspensionState('resumed');
+                    log_1.log.warn('Type A askerDialog processing error:', err);
+                    askBackAskerDialog.setSuspensionState('resumed');
                     const errorText = `❌ **Error processing request to @${parseResult.agentId}:**\n\n${showErrorToAi(err)}`;
                     const errorContent = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                         callName,
+                        callId,
                         responderId: parseResult.agentId,
-                        requesterId: askBackRequesterDialog.agentId,
+                        tellaskerId: askBackAskerDialog.agentId,
                         mentionList,
                         tellaskContent: body,
                         responseBody: errorText,
@@ -1347,261 +1356,206 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         callName,
                         content: errorContent,
                         status: 'failed',
-                        originCourse: callingCourse,
-                        calling_genseq: callingGenseq,
+                        callSiteCourse,
+                        callSiteGenseq,
                         responderId: parseResult.agentId,
                         tellaskContent: body,
                         mentionList,
                         agentId: parseResult.agentId,
-                        originMemberId: askBackRequesterDialog.agentId,
-                        calleeDialogId: askBackResponderDialog.id.selfId,
+                        originMemberId: askBackAskerDialog.agentId,
+                        calleeDialogId: askBackTellaskeeDialog.id.selfId,
                     }));
-                    await askBackRequesterDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'failed', askBackResponderDialog.id, {
+                    await askBackAskerDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'failed', askBackTellaskeeDialog.id, {
                         response: errorContent,
                         agentId: parseResult.agentId,
                         callId,
-                        originMemberId: askBackRequesterDialog.agentId,
-                        originCourse: callingCourse,
-                        calling_genseq: callingGenseq,
+                        originMemberId: askBackAskerDialog.agentId,
+                        callSiteCourse,
+                        callSiteGenseq,
                     });
                 }
             }
             else {
-                log_1.log.warn('Type A call on dialog without supdialog, falling back to Type C', undefined, {
-                    dialogId: dlg.id.selfId,
+                const err = new Error(`Type A tellaskBack invariant violation: dialog is not a sideDialog ` +
+                    `(rootId=${dlg.id.rootId}, selfId=${dlg.id.selfId}, callId=${callId})`);
+                log_1.log.error('Type A tellaskBack invariant violation: dialog is not a sideDialog', err, {
+                    rootId: dlg.id.rootId,
+                    selfId: dlg.id.selfId,
+                    course: callSiteCourse,
+                    genseq: callSiteGenseq,
+                    callId,
                 });
+                throw err;
             }
         }
         else if (parseResult.type === 'B') {
-            const callerDialog = dlg;
-            let rootDialog;
-            if (dlg instanceof dialog_1.RootDialog) {
-                rootDialog = dlg;
+            const askerDialog = dlg;
+            let mainDialog;
+            if (dlg instanceof dialog_1.MainDialog) {
+                mainDialog = dlg;
             }
-            else if (dlg instanceof dialog_1.SubDialog) {
-                rootDialog = dlg.rootDialog;
+            else if (dlg instanceof dialog_1.SideDialog) {
+                mainDialog = dlg.mainDialog;
             }
-            if (!rootDialog) {
-                log_1.log.warn('Type B call without root dialog, falling back to Type C', undefined, {
-                    dialogId: dlg.id.selfId,
+            if (!mainDialog) {
+                const err = new Error(`Type B tellask invariant violation: missing mainDialog ` +
+                    `(rootId=${dlg.id.rootId}, selfId=${dlg.id.selfId}, callId=${callId})`);
+                log_1.log.error('Type B tellask invariant violation: missing mainDialog', err, {
+                    rootId: dlg.id.rootId,
+                    selfId: dlg.id.selfId,
+                    course: callSiteCourse,
+                    genseq: callSiteGenseq,
+                    callId,
+                    sessionSlug: parseResult.sessionSlug,
                 });
-                try {
-                    const sub = await createSubDialog(dlg, parseResult.agentId, mentionList, body, {
-                        callName: subdialogCallName,
-                        originMemberId: dlg.agentId,
-                        callerDialogId: callerDialog.id.selfId,
-                        callId,
-                        sessionSlug: parseResult.sessionSlug,
-                        collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
-                    });
-                    const pendingRecord = {
-                        subdialogId: sub.id.selfId,
-                        createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        callName: subdialogCallName,
-                        mentionList,
-                        tellaskContent: body,
-                        targetAgentId: parseResult.agentId,
-                        callId,
-                        callingCourse,
-                        callingGenseq,
-                        callType: 'C',
-                        sessionSlug: parseResult.sessionSlug,
-                    };
-                    await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
-                            rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
-                            rootGenseq: dlg instanceof dialog_1.SubDialog
-                                ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
-                                : (dlg.activeGenSeqOrUndefined ?? 0),
-                        }));
-                    });
-                    await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:TypeB-fallback:appendPending');
-                    const initPrompt = {
-                        content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
-                            callName: subdialogCallName,
-                            fromAgentId: dlg.agentId,
-                            toAgentId: sub.agentId,
-                            mentionList,
-                            tellaskContent: body,
-                            language: (0, work_language_1.getWorkLanguage)(),
-                            collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
-                        }),
-                        msgId: (0, id_1.generateShortId)(),
-                        grammar: 'markdown',
-                        origin: 'runtime',
-                        tellaskReplyDirective: buildAssignmentReplyDirective({
-                            callName: 'tellaskSessionless',
-                            targetCallId: callId,
-                            tellaskContent: body,
-                        }),
-                        subdialogReplyTarget: {
-                            ownerDialogId: callerDialog.id.selfId,
-                            callType: 'C',
-                            callId,
-                        },
-                    };
-                    callbacks.scheduleDrive(sub, {
-                        humanPrompt: initPrompt,
-                        waitInQue: true,
-                        driveOptions: {
-                            source: 'kernel_driver_subdialog_init',
-                            reason: 'type_b_fallback_subdialog_init',
-                        },
-                    });
-                }
-                catch (err) {
-                    log_1.log.warn('Type B fallback subdialog creation error:', err);
-                }
+                throw err;
             }
             else {
                 const originMemberId = dlg.agentId;
                 const assignment = {
-                    callName: subdialogCallName,
+                    callName: sideDialogCallName,
                     mentionList,
                     tellaskContent: body,
                     originMemberId,
-                    callerDialogId: callerDialog.id.selfId,
+                    askerDialogId: askerDialog.id.selfId,
                     callId,
                     collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                 };
-                const pendingOwner = callerDialog;
-                const replacementNotice = (0, driver_messages_1.formatRegisteredTellaskCallerUpdateNotice)((0, work_language_1.getWorkLanguage)());
+                const pendingOwner = askerDialog;
+                const isSameRegisteredSessionPending = (record) => record.callType === 'B' &&
+                    record.callName === 'tellask' &&
+                    record.targetAgentId === parseResult.agentId &&
+                    record.sessionSlug === parseResult.sessionSlug;
                 const result = await (async () => {
                     for (let attempt = 0; attempt < 4; attempt += 1) {
-                        const seededExisting = rootDialog.lookupSubdialog(parseResult.agentId, parseResult.sessionSlug);
-                        const seededPreviousCallerId = seededExisting?.assignmentFromSup.callerDialogId;
-                        const lockIds = [rootDialog.id, pendingOwner.id];
-                        if (seededPreviousCallerId !== undefined &&
-                            seededPreviousCallerId !== rootDialog.id.selfId &&
-                            seededPreviousCallerId !== pendingOwner.id.selfId) {
-                            lockIds.push(new dialog_1.DialogID(seededPreviousCallerId, rootDialog.id.rootId));
+                        const seededExisting = mainDialog.lookupSideDialog(parseResult.agentId, parseResult.sessionSlug);
+                        const seededPreviousAskerId = seededExisting?.assignmentFromAsker.askerDialogId;
+                        const lockIds = [mainDialog.id, pendingOwner.id];
+                        if (seededPreviousAskerId !== undefined &&
+                            seededPreviousAskerId !== mainDialog.id.selfId &&
+                            seededPreviousAskerId !== pendingOwner.id.selfId) {
+                            lockIds.push(new dialog_1.DialogID(seededPreviousAskerId, mainDialog.id.rootId));
                         }
-                        const attemptResult = await (0, subdialog_txn_1.withSubdialogTxnLocks)(lockIds, async () => {
-                            const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.sessionSlug);
+                        const attemptResult = await (0, sideDialog_txn_1.withSideDialogTxnLocks)(lockIds, async () => {
+                            const existing = await lookupLiveRegisteredSideDialog(mainDialog, parseResult.agentId, parseResult.sessionSlug);
                             if (existing) {
-                                if (existing.assignmentFromSup.callerDialogId !== seededPreviousCallerId) {
+                                if (existing.assignmentFromAsker.askerDialogId !== seededPreviousAskerId) {
                                     return { kind: 'retry' };
                                 }
-                                const previousCaller = await resolveDialogWithinRoot(rootDialog, existing.assignmentFromSup.callerDialogId);
+                                const previousAssignment = existing.assignmentFromAsker;
                                 const pendingRecord = {
-                                    subdialogId: existing.id.selfId,
+                                    sideDialogId: existing.id.selfId,
                                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                                    callName: subdialogCallName,
+                                    callName: sideDialogCallName,
                                     mentionList,
                                     tellaskContent: body,
                                     targetAgentId: parseResult.agentId,
                                     callId,
-                                    callingCourse,
-                                    callingGenseq,
+                                    callSiteCourse,
+                                    callSiteGenseq,
                                     callType: 'B',
                                     sessionSlug: parseResult.sessionSlug,
                                 };
                                 try {
-                                    const previousPending = await persistence_1.DialogPersistence.loadPendingSubdialogs(previousCaller.id, previousCaller.status);
-                                    const replacedPending = previousPending.filter((record) => record.subdialogId === existing.id.selfId);
-                                    if (replacedPending.length > 1) {
-                                        throw new Error(`Type B pending invariant violation: caller=${previousCaller.id.valueOf()} sub=${existing.id.valueOf()} count=${replacedPending.length}`);
-                                    }
-                                    if (previousCaller.id.selfId === pendingOwner.id.selfId) {
-                                        const nextPending = previousPending.filter((record) => record.subdialogId !== existing.id.selfId);
-                                        nextPending.push(pendingRecord);
-                                        await persistence_1.DialogPersistence.savePendingSubdialogs(pendingOwner.id, nextPending, undefined, pendingOwner.status);
-                                    }
-                                    else {
-                                        await persistence_1.DialogPersistence.savePendingSubdialogs(previousCaller.id, previousPending.filter((record) => record.subdialogId !== existing.id.selfId), undefined, previousCaller.status);
-                                        const nextPending = (await persistence_1.DialogPersistence.loadPendingSubdialogs(pendingOwner.id, pendingOwner.status)).filter((record) => record.subdialogId !== existing.id.selfId);
-                                        nextPending.push(pendingRecord);
-                                        await persistence_1.DialogPersistence.savePendingSubdialogs(pendingOwner.id, nextPending, undefined, pendingOwner.status);
+                                    if (previousAssignment.askerDialogId !== pendingOwner.id.selfId) {
+                                        await persistence_1.DialogPersistence.mutatePendingSideDialogs(new dialog_1.DialogID(previousAssignment.askerDialogId, mainDialog.id.rootId), (previousPending) => ({
+                                            kind: 'replace',
+                                            records: previousPending.filter((record) => !isSameRegisteredSessionPending(record)),
+                                        }), undefined, pendingOwner.status);
                                     }
-                                    await updateSubdialogAssignment(existing, assignment);
+                                    await persistence_1.DialogPersistence.mutatePendingSideDialogs(pendingOwner.id, (previousPending) => ({
+                                        kind: 'replace',
+                                        records: [
+                                            ...previousPending.filter((record) => !isSameRegisteredSessionPending(record)),
+                                            pendingRecord,
+                                        ],
+                                    }), undefined, pendingOwner.status);
+                                    await updateSideDialogAssignment(existing, assignment, {
+                                        replacePendingCallId: previousAssignment.callId,
+                                        replacePendingAskerDialogId: previousAssignment.askerDialogId,
+                                    });
                                     return {
                                         kind: 'existing',
-                                        subdialog: existing,
-                                        previousCaller,
-                                        replacedPending: replacedPending[0],
+                                        sideDialog: existing,
+                                        previousPendingOwnerId: previousAssignment.askerDialogId,
                                     };
                                 }
                                 catch (err) {
-                                    log_1.log.warn('Failed to update registered subdialog assignment', err);
-                                    return {
-                                        kind: 'existing',
-                                        subdialog: existing,
-                                        previousCaller,
-                                        replacedPending: undefined,
-                                    };
+                                    log_1.log.error('Failed to update registered sideDialog assignment', err, {
+                                        rootId: mainDialog.id.rootId,
+                                        sideDialogId: existing.id.selfId,
+                                        ownerDialogId: pendingOwner.id.selfId,
+                                        callId,
+                                        sessionSlug: parseResult.sessionSlug,
+                                    });
+                                    throw err;
                                 }
                             }
-                            if (seededPreviousCallerId !== undefined) {
+                            if (seededPreviousAskerId !== undefined) {
                                 return { kind: 'retry' };
                             }
-                            const created = await createSubDialog(rootDialog, parseResult.agentId, mentionList, body, {
-                                callName: subdialogCallName,
+                            const created = await createSideDialog(askerDialog, parseResult.agentId, mentionList, body, {
+                                callName: sideDialogCallName,
                                 originMemberId,
-                                callerDialogId: callerDialog.id.selfId,
+                                askerDialogId: askerDialog.id.selfId,
                                 callId,
                                 sessionSlug: parseResult.sessionSlug,
                                 collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                             });
-                            rootDialog.registerSubdialog(created);
-                            await rootDialog.saveSubdialogRegistry();
+                            mainDialog.registerSideDialog(created);
+                            await mainDialog.saveSideDialogRegistry();
                             const pendingRecord = {
-                                subdialogId: created.id.selfId,
+                                sideDialogId: created.id.selfId,
                                 createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                                callName: subdialogCallName,
+                                callName: sideDialogCallName,
                                 mentionList,
                                 tellaskContent: body,
                                 targetAgentId: parseResult.agentId,
                                 callId,
-                                callingCourse,
-                                callingGenseq,
+                                callSiteCourse,
+                                callSiteGenseq,
                                 callType: 'B',
                                 sessionSlug: parseResult.sessionSlug,
                             };
-                            const nextPending = (await persistence_1.DialogPersistence.loadPendingSubdialogs(pendingOwner.id, pendingOwner.status)).filter((record) => record.subdialogId !== created.id.selfId);
-                            nextPending.push(pendingRecord);
-                            await persistence_1.DialogPersistence.savePendingSubdialogs(pendingOwner.id, nextPending, undefined, pendingOwner.status);
-                            return { kind: 'created', subdialog: created };
+                            await persistence_1.DialogPersistence.appendPendingSideDialog(pendingOwner.id, pendingRecord, undefined, pendingOwner.status);
+                            return { kind: 'created', sideDialog: created };
                         });
                         if (attemptResult.kind !== 'retry') {
                             return attemptResult;
                         }
                     }
-                    throw new Error(`Type B registered subdialog mutation failed to stabilize: root=${rootDialog.id.valueOf()} agent=${parseResult.agentId} session=${parseResult.sessionSlug}`);
+                    throw new Error(`Type B registered sideDialog mutation failed to stabilize: root=${mainDialog.id.valueOf()} agent=${parseResult.agentId} session=${parseResult.sessionSlug}`);
                 })();
-                await syncPendingTellaskReminderBestEffort(pendingOwner, 'kernel-driver:executeTellaskCall:TypeB:replacePending');
-                if (result.kind === 'existing' && result.replacedPending) {
-                    await finishRegisteredTellaskReplacement({
-                        ownerDialog: result.previousCaller,
-                        subdialog: result.subdialog,
-                        pendingRecord: result.replacedPending,
-                        responseBody: replacementNotice,
-                    });
-                    if (result.previousCaller.id.selfId !== pendingOwner.id.selfId) {
-                        await syncPendingTellaskReminderBestEffort(result.previousCaller, 'kernel-driver:executeTellaskCall:TypeB:clearPreviousPending');
-                        await reviveDialogIfUnblocked(result.previousCaller, callbacks, 'type_b_registered_subdialog_replaced_pending_round');
+                await syncPendingTellaskReminderBestEffort(pendingOwner, 'kernel-driver:executeTellaskCall:TypeB:pushPendingAssignment');
+                if (result.kind === 'existing' &&
+                    result.previousPendingOwnerId !== pendingOwner.id.selfId) {
+                    const previousPendingOwner = mainDialog.lookupDialog(result.previousPendingOwnerId);
+                    if (previousPendingOwner) {
+                        await syncPendingTellaskReminderBestEffort(previousPendingOwner, 'kernel-driver:executeTellaskCall:TypeB:replacePreviousPendingAssignment');
                     }
                 }
                 if (result.kind === 'existing') {
                     const resumePrompt = {
-                        content: (0, inter_dialog_format_1.formatUpdatedAssignmentFromSupdialog)({
-                            callName: subdialogCallName,
+                        content: (0, inter_dialog_format_1.formatUpdatedAssignmentFromAskerDialog)({
+                            callName: sideDialogCallName,
                             fromAgentId: dlg.agentId,
-                            toAgentId: result.subdialog.agentId,
+                            toAgentId: result.sideDialog.agentId,
                             mentionList,
                             sessionSlug: parseResult.sessionSlug,
                             tellaskContent: body,
                             language: (0, work_language_1.getWorkLanguage)(),
-                            collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
+                            collectiveTargets: options?.collectiveTargets ?? [result.sideDialog.agentId],
                         }),
                         msgId: (0, id_1.generateShortId)(),
                         grammar: 'markdown',
                         origin: 'runtime',
                         tellaskReplyDirective: buildAssignmentReplyDirective({
                             callName: 'tellask',
+                            targetDialogId: pendingOwner.id.selfId,
                             targetCallId: callId,
                             tellaskContent: body,
                         }),
-                        subdialogReplyTarget: {
+                        sideDialogReplyTarget: {
                             ownerDialogId: pendingOwner.id.selfId,
                             callType: 'B',
                             callId,
@@ -1610,77 +1564,78 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     let queuedIntoActiveLoop = false;
                     let queuedRuntimePrompt = false;
                     try {
-                        result.subdialog.queueRegisteredAssignmentUpdatePrompt({
+                        result.sideDialog.queueRegisteredAssignmentUpdatePrompt({
                             prompt: resumePrompt.content,
                             msgId: resumePrompt.msgId,
                             grammar: resumePrompt.grammar,
                             userLanguageCode: resumePrompt.userLanguageCode,
                             tellaskReplyDirective: resumePrompt.tellaskReplyDirective,
                             skipTaskdoc: resumePrompt.skipTaskdoc,
-                            subdialogReplyTarget: resumePrompt.subdialogReplyTarget,
+                            sideDialogReplyTarget: resumePrompt.sideDialogReplyTarget,
                         });
                         queuedRuntimePrompt = true;
-                        queuedIntoActiveLoop = result.subdialog.isLocked();
+                        queuedIntoActiveLoop = result.sideDialog.isLocked();
                     }
                     catch (err) {
-                        log_1.log.warn('Failed to queue registered subdialog update into active loop', err, {
-                            subdialogId: result.subdialog.id.valueOf(),
+                        log_1.log.warn('Failed to queue registered sideDialog update into active loop', err, {
+                            sideDialogId: result.sideDialog.id.valueOf(),
                             sessionSlug: parseResult.sessionSlug,
                             callId,
                         });
                     }
                     if (queuedRuntimePrompt && !queuedIntoActiveLoop) {
-                        callbacks.scheduleDrive(result.subdialog, {
+                        callbacks.scheduleDrive(result.sideDialog, {
                             waitInQue: true,
                             driveOptions: {
-                                source: 'kernel_driver_subdialog_resume',
-                                reason: 'type_b_registered_subdialog_resume',
+                                source: 'kernel_driver_sideDialog_resume',
+                                reason: 'type_b_registered_sideDialog_resume',
                             },
                         });
                     }
                     else if (!queuedRuntimePrompt) {
-                        callbacks.scheduleDrive(result.subdialog, {
+                        callbacks.scheduleDrive(result.sideDialog, {
                             humanPrompt: resumePrompt,
                             waitInQue: true,
                             driveOptions: {
-                                source: 'kernel_driver_subdialog_resume',
-                                reason: 'type_b_registered_subdialog_resume',
+                                source: 'kernel_driver_sideDialog_resume',
+                                reason: 'type_b_registered_sideDialog_resume',
                             },
                         });
                     }
                 }
                 else {
                     const initPrompt = {
-                        content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
-                            callName: subdialogCallName,
-                            fromAgentId: rootDialog.agentId,
-                            toAgentId: result.subdialog.agentId,
+                        content: (0, inter_dialog_format_1.formatAssignmentFromAskerDialog)({
+                            callName: sideDialogCallName,
+                            fromAgentId: mainDialog.agentId,
+                            toAgentId: result.sideDialog.agentId,
                             mentionList,
                             sessionSlug: parseResult.sessionSlug,
                             tellaskContent: body,
                             language: (0, work_language_1.getWorkLanguage)(),
-                            collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
+                            collectiveTargets: options?.collectiveTargets ?? [result.sideDialog.agentId],
                         }),
                         msgId: (0, id_1.generateShortId)(),
                         grammar: 'markdown',
                         origin: 'runtime',
                         tellaskReplyDirective: buildAssignmentReplyDirective({
                             callName: 'tellask',
+                            targetDialogId: pendingOwner.id.selfId,
                             targetCallId: callId,
                             tellaskContent: body,
                         }),
-                        subdialogReplyTarget: {
+                        sideDialogReplyTarget: {
                             ownerDialogId: pendingOwner.id.selfId,
                             callType: 'B',
                             callId,
                         },
                     };
-                    callbacks.scheduleDrive(result.subdialog, {
+                    callbacks.scheduleDrive(result.sideDialog, {
                         humanPrompt: initPrompt,
                         waitInQue: true,
                         driveOptions: {
-                            source: 'kernel_driver_subdialog_init',
-                            reason: 'type_b_registered_subdialog_init',
+                            source: 'kernel_driver_sideDialog_init',
+                            reason: 'type_b_registered_sideDialog_init',
                         },
                     });
                 }
@@ -1688,36 +1643,36 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
         }
         if (parseResult.type === 'C') {
             try {
-                const sub = await createSubDialog(dlg, parseResult.agentId, mentionList, body, {
-                    callName: subdialogCallName,
+                const sub = await createSideDialog(dlg, parseResult.agentId, mentionList, body, {
+                    callName: sideDialogCallName,
                     originMemberId: dlg.agentId,
-                    callerDialogId: dlg.id.selfId,
+                    askerDialogId: dlg.id.selfId,
                     callId,
                     collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                 });
                 const pendingRecord = {
-                    subdialogId: sub.id.selfId,
+                    sideDialogId: sub.id.selfId,
                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                    callName: subdialogCallName,
+                    callName: sideDialogCallName,
                     mentionList,
                     tellaskContent: body,
                     targetAgentId: parseResult.agentId,
                     callId,
-                    callingCourse,
-                    callingGenseq,
+                    callSiteCourse,
+                    callSiteGenseq,
                     callType: 'C',
                 };
-                await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
-                    await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
-                        rootCourse: dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.currentCourse : dlg.currentCourse,
-                        rootGenseq: dlg instanceof dialog_1.SubDialog
-                            ? (dlg.rootDialog.activeGenSeqOrUndefined ?? 0)
+                await (0, sideDialog_txn_1.withSideDialogTxnLock)(dlg.id, async () => {
+                    await persistence_1.DialogPersistence.appendPendingSideDialog(dlg.id, pendingRecord, (0, storage_1.toRootGenerationAnchor)({
+                        rootCourse: dlg instanceof dialog_1.SideDialog ? dlg.mainDialog.currentCourse : dlg.currentCourse,
+                        rootGenseq: dlg instanceof dialog_1.SideDialog
+                            ? (dlg.mainDialog.activeGenSeqOrUndefined ?? 0)
                             : (dlg.activeGenSeqOrUndefined ?? 0),
                     }));
                 });
                 await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:TypeC:appendPending');
                 const initPrompt = {
-                    content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                    content: (0, inter_dialog_format_1.formatAssignmentFromAskerDialog)({
                         callName,
                         fromAgentId: dlg.agentId,
                         toAgentId: sub.agentId,
@@ -1731,10 +1686,11 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     origin: 'runtime',
                     tellaskReplyDirective: buildAssignmentReplyDirective({
                         callName: 'tellaskSessionless',
+                        targetDialogId: dlg.id.selfId,
                         targetCallId: callId,
                         tellaskContent: body,
                     }),
-                    subdialogReplyTarget: {
+                    sideDialogReplyTarget: {
                         ownerDialogId: dlg.id.selfId,
                         callType: 'C',
                         callId,
@@ -1744,13 +1700,20 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     humanPrompt: initPrompt,
                     waitInQue: true,
                     driveOptions: {
-                        source: 'kernel_driver_subdialog_init',
-                        reason: 'type_c_subdialog_init',
+                        source: 'kernel_driver_sideDialog_init',
+                        reason: 'type_c_sideDialog_init',
                     },
                 });
             }
             catch (err) {
-                log_1.log.warn('Subdialog creation error:', err);
+                log_1.log.error('SideDialog creation error', err, {
+                    rootId: dlg.id.rootId,
+                    selfId: dlg.id.selfId,
+                    callId,
+                    callName,
+                    targetAgentId: parseResult.agentId,
+                });
+                throw err;
             }
         }
     }
@@ -1764,8 +1727,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             callName,
             content: msg,
             status: 'failed',
-            originCourse: callingCourse,
-            calling_genseq: callingGenseq,
+            callSiteCourse,
+            callSiteGenseq,
             responderId: 'dominds',
             tellaskContent: body,
             mentionList: normalizedMentionList,
@@ -1773,8 +1736,8 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             originMemberId: dlg.agentId,
         }));
         await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId, {
-            originCourse: callingCourse,
-            calling_genseq: callingGenseq,
+            callSiteCourse,
+            callSiteGenseq,
         });
         dlg.clearCurrentCallId();
     }
@@ -1791,7 +1754,7 @@ async function emitTellaskCallEvents(args) {
 }
 async function executeReplyTellaskCall(args) {
     const genseq = args.dlg.activeGenSeqOrUndefined ?? 1;
-    const activeDirective = args.activePromptReplyDirective ?? (await loadLatestActiveTellaskReplyDirective(args.dlg));
+    const activeDirective = args.activePromptReplyDirective ?? (await loadActiveTellaskReplyDirective(args.dlg));
     const expectedCallName = activeDirective?.expectedReplyCallName;
     if (!expectedCallName) {
         return {
@@ -1833,15 +1796,19 @@ async function executeReplyTellaskCall(args) {
     switch (args.call.callName) {
         case 'replyTellask':
         case 'replyTellaskSessionless': {
-            if (!(args.dlg instanceof dialog_1.SubDialog)) {
-                throw new Error(`${args.call.callName} invariant violation: only subdialogs may reply upstream`);
+            if (!(args.dlg instanceof dialog_1.SideDialog)) {
+                throw new Error(`${args.call.callName} invariant violation: only sideDialogs may reply to the tellasker`);
             }
-            const expectedCallName = args.call.callName === 'replyTellask' ? 'tellask' : 'tellaskSessionless';
-            if (args.dlg.assignmentFromSup.callName !== expectedCallName) {
-                throw new Error(`${args.call.callName} invariant violation: assignment callName=${args.dlg.assignmentFromSup.callName}`);
+            const assignmentCallName = args.dlg.assignmentFromAsker.callName;
+            const assignmentMatchesReplyCall = args.call.callName === 'replyTellask'
+                ? assignmentCallName === 'tellask'
+                : assignmentCallName === 'tellaskSessionless' ||
+                    assignmentCallName === 'freshBootsReasoning';
+            if (!assignmentMatchesReplyCall) {
+                throw new Error(`${args.call.callName} invariant violation: assignment callName=${assignmentCallName}`);
             }
-            const supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                subdialog: args.dlg,
+            const supplied = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                sideDialog: args.dlg,
                 responseText: args.call.replyContent,
                 responseGenseq: genseq,
                 replyResolution: {
@@ -1868,6 +1835,11 @@ async function executeReplyTellaskCall(args) {
                     ],
                 };
             }
+            const nextAskerStackState = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(args.dlg.id, args.dlg.status);
+            if (!nextAskerStackState) {
+                throw new Error(`Missing asker stack after reply delivery: ${args.dlg.id.valueOf()}`);
+            }
+            args.dlg.askerStack = nextAskerStackState;
             return {
                 delivered: true,
                 messages: [
@@ -1971,6 +1943,13 @@ function toExecutableValidTellaskCall(call) {
 async function executeValidTellaskCalls(args) {
     const results = [];
     const successfulReplyCallIds = [];
+    const deferredScheduleCalls = [];
+    const registrationPhaseCallbacks = {
+        driveDialog: args.callbacks.driveDialog,
+        scheduleDrive: (dialog, options) => {
+            deferredScheduleCalls.push({ dialog, options });
+        },
+    };
     for (const call of args.calls) {
         const runtimeMentionList = (() => {
             switch (call.callName) {
@@ -2002,9 +1981,11 @@ async function executeValidTellaskCalls(args) {
         let parseResult;
         switch (call.callName) {
             case 'tellaskBack': {
-                targetForError = args.dlg instanceof dialog_1.SubDialog ? args.dlg.supdialog.agentId : undefined;
+                targetForError = args.dlg instanceof dialog_1.SideDialog ? args.dlg.askerDialog.agentId : undefined;
                 parseResult =
-                    args.dlg instanceof dialog_1.SubDialog ? { type: 'A', agentId: args.dlg.supdialog.agentId } : null;
+                    args.dlg instanceof dialog_1.SideDialog
+                        ? { type: 'A', agentId: args.dlg.askerDialog.agentId }
+                        : null;
                 break;
             }
             case 'replyTellask':
@@ -2057,7 +2038,7 @@ async function executeValidTellaskCalls(args) {
         if (isReplyTellaskCallName(call.callName)) {
             throw new Error(`replyTellask* control-flow invariant violation: unexpected call ${call.callName}`);
         }
-        const toolOutputs = await executeTellaskCall(args.dlg, runtimeMentionList, call.tellaskContent, call.callId, args.callbacks, {
+        const toolOutputs = await executeTellaskCall(args.dlg, runtimeMentionList, call.tellaskContent, call.callId, registrationPhaseCallbacks, {
             callName: call.callName,
             parseResult,
             targetForError,
@@ -2065,6 +2046,9 @@ async function executeValidTellaskCalls(args) {
         });
         results.push(toolOutputs);
     }
+    for (const scheduled of deferredScheduleCalls) {
+        args.callbacks.scheduleDrive(scheduled.dialog, scheduled.options);
+    }
     return {
         toolOutputs: results.flatMap((result) => result),
         successfulReplyCallIds,
@@ -2100,11 +2084,11 @@ async function processTellaskFunctionRound(args) {
         if (multiAskHumanCalls.length > 1 && originalCall.name === 'askHuman') {
             orderedSpecialDispositions.push({
                 kind: 'invalid',
+                callName: originalCall.name,
                 issue: {
                     originalCall,
                     error: MULTIPLE_ASKHUMAN_CALLS_ERROR,
                     rawArgumentsText: getRawArgumentsText(originalCall),
-                    contextArguments: getRawArgumentsText(originalCall),
                 },
             });
             continue;
@@ -2116,7 +2100,7 @@ async function processTellaskFunctionRound(args) {
         }
         const issue = invalidByCallId.get(originalCall.id);
         if (issue) {
-            orderedSpecialDispositions.push({ kind: 'invalid', issue });
+            orderedSpecialDispositions.push({ kind: 'invalid', callName: originalCall.name, issue });
             continue;
         }
         throw new Error(`kernel-driver tellask special call invariant violation: unresolved tellask disposition for '${originalCall.id}' (${originalCall.name})`);
@@ -2146,19 +2130,12 @@ async function processTellaskFunctionRound(args) {
             continue;
         }
         const issue = disposition.issue;
-        await args.dlg.funcCallRequested(issue.originalCall.id, issue.originalCall.name, issue.contextArguments);
+        await args.dlg.persistTellaskCall(issue.originalCall.id, disposition.callName, issue.rawArgumentsText, issue.originalCall.genseq, { deliveryMode: 'func_call_requested' });
         const result = formatTellaskInvalidCallResult({
             call: issue.originalCall,
             error: issue.error,
         });
-        await args.dlg.persistTellaskCallResultPair({
-            id: issue.originalCall.id,
-            name: issue.originalCall.name,
-            rawArgumentsText: issue.rawArgumentsText,
-            genseq: issue.originalCall.genseq,
-            result,
-            deliveryMode: 'func_call_requested',
-        });
+        await persistTellaskFuncResult(args.dlg, result);
         tellaskCallMessages.push({
             type: 'func_call_msg',
             role: 'assistant',