dominds 1.18.2 → 1.19.2

package/dist/persistence.js

@@ -89,7 +89,7 @@ function summarizeLatestProjectionState(latest) {
         status: latest.status,
         messageCount: latest.messageCount ?? null,
         functionCallCount: latest.functionCallCount ?? null,
-        subdialogCount: latest.subdialogCount ?? null,
+        sideDialogCount: latest.sideDialogCount ?? null,
         generating: latest.generating ?? false,
         needsDrive: latest.needsDrive ?? false,
         disableDiligencePush: latest.disableDiligencePush ?? false,
@@ -101,8 +101,8 @@ function summarizeLatestProjectionState(latest) {
         pendingCourseStartPromptGrammar: latest.pendingCourseStartPrompt?.grammar ?? null,
         pendingCourseStartPromptUserLanguageCode: latest.pendingCourseStartPrompt?.userLanguageCode ?? null,
         pendingCourseStartPromptContentLength: latest.pendingCourseStartPrompt?.content.length ?? null,
-        pendingCourseStartPromptReplyTargetCallId: latest.pendingCourseStartPrompt?.subdialogReplyTarget?.callId ?? null,
-        pendingCourseStartPromptReplyTargetOwnerDialogId: latest.pendingCourseStartPrompt?.subdialogReplyTarget?.ownerDialogId ?? null,
+        pendingCourseStartPromptReplyTargetCallId: latest.pendingCourseStartPrompt?.sideDialogReplyTarget?.callId ?? null,
+        pendingCourseStartPromptReplyTargetOwnerDialogId: latest.pendingCourseStartPrompt?.sideDialogReplyTarget?.ownerDialogId ?? null,
         pendingCourseStartPromptExpectedReplyCallName: latest.pendingCourseStartPrompt?.tellaskReplyDirective?.expectedReplyCallName ?? null,
         pendingCourseStartPromptTargetCallId: latest.pendingCourseStartPrompt?.tellaskReplyDirective?.targetCallId ?? null,
     };
@@ -119,7 +119,7 @@ function summarizeLatestMutationPatch(patch) {
         status: patch.status ?? null,
         messageCount: patch.messageCount ?? null,
         functionCallCount: patch.functionCallCount ?? null,
-        subdialogCount: patch.subdialogCount ?? null,
+        sideDialogCount: patch.sideDialogCount ?? null,
         generating: patch.generating ?? null,
         needsDrive: patch.needsDrive ?? null,
         disableDiligencePush: patch.disableDiligencePush ?? null,
@@ -131,8 +131,8 @@ function summarizeLatestMutationPatch(patch) {
         pendingCourseStartPromptGrammar: patch.pendingCourseStartPrompt?.grammar ?? null,
         pendingCourseStartPromptUserLanguageCode: patch.pendingCourseStartPrompt?.userLanguageCode ?? null,
         pendingCourseStartPromptContentLength: patch.pendingCourseStartPrompt?.content.length ?? null,
-        pendingCourseStartPromptReplyTargetOwnerDialogId: patch.pendingCourseStartPrompt?.subdialogReplyTarget?.ownerDialogId ?? null,
-        pendingCourseStartPromptReplyTargetCallId: patch.pendingCourseStartPrompt?.subdialogReplyTarget?.callId ?? null,
+        pendingCourseStartPromptReplyTargetOwnerDialogId: patch.pendingCourseStartPrompt?.sideDialogReplyTarget?.ownerDialogId ?? null,
+        pendingCourseStartPromptReplyTargetCallId: patch.pendingCourseStartPrompt?.sideDialogReplyTarget?.callId ?? null,
         pendingCourseStartPromptExpectedReplyCallName: patch.pendingCourseStartPrompt?.tellaskReplyDirective?.expectedReplyCallName ?? null,
         pendingCourseStartPromptTargetCallId: patch.pendingCourseStartPrompt?.tellaskReplyDirective?.targetCallId ?? null,
     };
@@ -220,7 +220,7 @@ function normalizeGeneratingDisplayStateMismatch(dialogId, status, previous, lat
         executionMarker: hasInterruptedExecutionMarker ? undefined : latest.executionMarker,
     };
 }
-const quarantiningRootDialogs = new Set();
+const quarantiningMainDialogs = new Set();
 const PERSISTABLE_DIALOG_STATUSES = ['running', 'completed', 'archived'];
 const RUN_STATUS_DIR = 'run';
 const DONE_STATUS_DIR = 'done';
@@ -272,7 +272,11 @@ function isSuppressedTellaskPlaceholderFuncResult(args) {
         return true;
     }
     if (raw.startsWith('支线对话仍在进行中，已持续 ') ||
-        raw.startsWith('Sideline dialog is still running (elapsed ')) {
+        raw.startsWith('Side Dialog is still running (elapsed ')) {
+        return true;
+    }
+    if ((raw.startsWith('[Dominds 诉请状态]') || raw.startsWith('[Dominds tellask status]')) &&
+        (raw.includes('当前仍在等待') || raw.includes('is still waiting'))) {
         return true;
     }
     return false;
@@ -619,11 +623,11 @@ function buildTellaskResultRecord(result) {
         status: result.status,
         content: result.content,
         contentItems: result.contentItems,
-        ...(typeof result.originCourse === 'number'
-            ? { originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse) }
+        ...(typeof result.callSiteCourse === 'number'
+            ? { callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse) }
             : {}),
-        ...(typeof result.calling_genseq === 'number'
-            ? { calling_genseq: (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq) }
+        ...(typeof result.callSiteGenseq === 'number'
+            ? { callSiteGenseq: (0, storage_1.toCallSiteGenseqNo)(result.callSiteGenseq) }
             : {}),
         responder: {
             responderId,
@@ -673,7 +677,7 @@ function buildTellaskCarryoverRecord(result, genseq) {
         ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
         type: 'tellask_carryover_record',
         genseq,
-        originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+        callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse),
         carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
         responderId: result.responderId,
         callName: result.callName,
@@ -716,11 +720,11 @@ function buildTellaskResultEvent(result, course) {
         return {
             type: 'tellask_result_evt',
             course,
-            ...(typeof result.originCourse === 'number'
-                ? { originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse) }
+            ...(typeof result.callSiteCourse === 'number'
+                ? { callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse) }
                 : {}),
-            calling_genseq: typeof result.calling_genseq === 'number'
-                ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+            callSiteGenseq: typeof result.callSiteGenseq === 'number'
+                ? (0, storage_1.toCallSiteGenseqNo)(result.callSiteGenseq)
                 : undefined,
             callId: result.callId,
             callName: result.callName,
@@ -747,11 +751,11 @@ function buildTellaskResultEvent(result, course) {
         return {
             type: 'tellask_result_evt',
             course,
-            ...(typeof result.originCourse === 'number'
-                ? { originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse) }
+            ...(typeof result.callSiteCourse === 'number'
+                ? { callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse) }
                 : {}),
-            calling_genseq: typeof result.calling_genseq === 'number'
-                ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+            callSiteGenseq: typeof result.callSiteGenseq === 'number'
+                ? (0, storage_1.toCallSiteGenseqNo)(result.callSiteGenseq)
                 : undefined,
             callId: result.callId,
             callName: result.callName,
@@ -776,11 +780,11 @@ function buildTellaskResultEvent(result, course) {
     return {
         type: 'tellask_result_evt',
         course,
-        ...(typeof result.originCourse === 'number'
-            ? { originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse) }
+        ...(typeof result.callSiteCourse === 'number'
+            ? { callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse) }
             : {}),
-        calling_genseq: typeof result.calling_genseq === 'number'
-            ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+        callSiteGenseq: typeof result.callSiteGenseq === 'number'
+            ? (0, storage_1.toCallSiteGenseqNo)(result.callSiteGenseq)
             : undefined,
         callId: result.callId,
         callName: result.callName,
@@ -811,7 +815,7 @@ function buildTellaskCarryoverEvent(result, course) {
             type: 'tellask_carryover_evt',
             course,
             genseq: result.genseq,
-            originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+            callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse),
             carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
             responderId: result.responderId,
             callName: result.callName,
@@ -838,7 +842,7 @@ function buildTellaskCarryoverEvent(result, course) {
             type: 'tellask_carryover_evt',
             course,
             genseq: result.genseq,
-            originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+            callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse),
             carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
             responderId: result.responderId,
             callName: result.callName,
@@ -863,7 +867,7 @@ function buildTellaskCarryoverEvent(result, course) {
         type: 'tellask_carryover_evt',
         course,
         genseq: result.genseq,
-        originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+        callSiteCourse: (0, storage_1.toCallSiteCourseNo)(result.callSiteCourse),
         carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
         responderId: result.responderId,
         callName: result.callName,
@@ -890,10 +894,10 @@ function isReplyTellaskCallRecordName(name) {
     return (name === 'replyTellask' || name === 'replyTellaskSessionless' || name === 'replyTellaskBack');
 }
 function resolveRootGenerationAnchor(dialog) {
-    const rootDialog = dialog instanceof dialog_1.SubDialog ? dialog.rootDialog : dialog;
+    const mainDialog = dialog instanceof dialog_1.SideDialog ? dialog.mainDialog : dialog;
     return (0, storage_1.toRootGenerationAnchor)({
-        rootCourse: rootDialog.currentCourse,
-        rootGenseq: rootDialog.activeGenSeqOrUndefined ?? 0,
+        rootCourse: mainDialog.currentCourse,
+        rootGenseq: mainDialog.activeGenSeqOrUndefined ?? 0,
     });
 }
 function resolveReconciledRecordWriteTarget(dialog) {
@@ -923,7 +927,7 @@ function attachRootGenerationRef(dialog, record) {
         rootGenseq: anchor.rootGenseq,
     };
 }
-function isRootDialogMetadataFile(value) {
+function isMainDialogMetadataFile(value) {
     if (!isRecord(value))
         return false;
     if (typeof value.id !== 'string')
@@ -934,11 +938,11 @@ function isRootDialogMetadataFile(value) {
         return false;
     if (typeof value.createdAt !== 'string')
         return false;
-    if (value.supdialogId !== undefined)
+    if (value.askerDialogId !== undefined)
         return false;
     if (value.sessionSlug !== undefined)
         return false;
-    if (value.assignmentFromSup !== undefined)
+    if (value.assignmentFromAsker !== undefined)
         return false;
     if (value.priming !== undefined) {
         if (!isRecord(value.priming))
@@ -952,66 +956,49 @@ function isRootDialogMetadataFile(value) {
     }
     return true;
 }
-function isSubdialogMetadataFile(value) {
+function isSideDialogAssignmentFromAsker(value) {
     if (!isRecord(value))
         return false;
-    if (typeof value.id !== 'string')
-        return false;
-    if (typeof value.agentId !== 'string')
-        return false;
-    if (typeof value.taskDocPath !== 'string')
-        return false;
-    if (typeof value.createdAt !== 'string')
-        return false;
-    if (typeof value.supdialogId !== 'string')
-        return false;
-    if (value.priming !== undefined)
-        return false;
-    if (value.sessionSlug !== undefined && typeof value.sessionSlug !== 'string')
-        return false;
-    const assignment = value.assignmentFromSup;
-    if (!isRecord(assignment))
-        return false;
-    if (typeof assignment.tellaskContent !== 'string')
+    if (typeof value.tellaskContent !== 'string')
         return false;
-    if (typeof assignment.originMemberId !== 'string')
+    if (typeof value.originMemberId !== 'string')
         return false;
-    if (typeof assignment.callerDialogId !== 'string')
+    if (typeof value.askerDialogId !== 'string')
         return false;
-    if (typeof assignment.callId !== 'string')
+    if (typeof value.callId !== 'string')
         return false;
-    if (assignment.collectiveTargets !== undefined) {
-        if (!Array.isArray(assignment.collectiveTargets))
+    if (value.collectiveTargets !== undefined) {
+        if (!Array.isArray(value.collectiveTargets))
             return false;
-        if (!assignment.collectiveTargets.every((item) => typeof item === 'string'))
+        if (!value.collectiveTargets.every((item) => typeof item === 'string'))
             return false;
     }
-    if (assignment.effectiveFbrEffort !== undefined) {
-        if (typeof assignment.effectiveFbrEffort !== 'number' ||
-            !Number.isInteger(assignment.effectiveFbrEffort)) {
+    if (value.effectiveFbrEffort !== undefined) {
+        if (typeof value.effectiveFbrEffort !== 'number' ||
+            !Number.isInteger(value.effectiveFbrEffort)) {
             return false;
         }
-        if (assignment.effectiveFbrEffort < 1 || assignment.effectiveFbrEffort > 100) {
+        if (value.effectiveFbrEffort < 1 || value.effectiveFbrEffort > 100) {
             return false;
         }
     }
-    switch (assignment.callName) {
+    switch (value.callName) {
         case 'tellask':
         case 'tellaskSessionless': {
-            if (!Array.isArray(assignment.mentionList))
+            if (!Array.isArray(value.mentionList))
                 return false;
-            if (assignment.mentionList.length < 1)
+            if (value.mentionList.length < 1)
                 return false;
-            if (!assignment.mentionList.every((item) => typeof item === 'string'))
+            if (!value.mentionList.every((item) => typeof item === 'string'))
                 return false;
-            if (assignment.effectiveFbrEffort !== undefined)
+            if (value.effectiveFbrEffort !== undefined)
                 return false;
             break;
         }
         case 'freshBootsReasoning': {
-            if (assignment.mentionList !== undefined)
+            if (value.mentionList !== undefined)
                 return false;
-            if (assignment.effectiveFbrEffort === undefined)
+            if (value.effectiveFbrEffort === undefined)
                 return false;
             break;
         }
@@ -1020,8 +1007,26 @@ function isSubdialogMetadataFile(value) {
     }
     return true;
 }
-function isDialogMetadataFile(value) {
-    return isRootDialogMetadataFile(value) || isSubdialogMetadataFile(value);
+function isSideDialogMetadataFile(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string')
+        return false;
+    if (typeof value.agentId !== 'string')
+        return false;
+    if (typeof value.taskDocPath !== 'string')
+        return false;
+    if (typeof value.createdAt !== 'string')
+        return false;
+    if (value.askerDialogId !== undefined)
+        return false;
+    if (value.assignmentFromAsker !== undefined)
+        return false;
+    if (value.priming !== undefined)
+        return false;
+    if (value.sessionSlug !== undefined && typeof value.sessionSlug !== 'string')
+        return false;
+    return true;
 }
 function parseTellaskReplyDirective(value) {
     if (!isRecord(value))
@@ -1037,24 +1042,116 @@ function parseTellaskReplyDirective(value) {
     if (typeof targetCallId !== 'string' || typeof tellaskContent !== 'string') {
         return null;
     }
+    const targetDialogId = value.targetDialogId;
+    if (typeof targetDialogId !== 'string')
+        return null;
     if (expectedReplyCallName === 'replyTellaskBack') {
-        const targetDialogId = value.targetDialogId;
-        if (typeof targetDialogId !== 'string')
-            return null;
         return {
             expectedReplyCallName,
-            targetCallId,
             targetDialogId,
+            targetCallId,
             tellaskContent,
         };
     }
     return {
         expectedReplyCallName,
+        targetDialogId,
         targetCallId,
         tellaskContent,
     };
 }
-function parseDialogSubdialogReplyTarget(value) {
+function isAskerDialogStackFrame(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind !== 'asker_dialog_stack_frame')
+        return false;
+    if (typeof value.askerDialogId !== 'string')
+        return false;
+    if (value.assignmentFromAsker !== undefined &&
+        !isSideDialogAssignmentFromAsker(value.assignmentFromAsker)) {
+        return false;
+    }
+    if (value.assignmentFromAsker !== undefined &&
+        value.assignmentFromAsker.askerDialogId !== value.askerDialogId) {
+        return false;
+    }
+    if (value.tellaskReplyObligation !== undefined) {
+        const directive = parseTellaskReplyDirective(value.tellaskReplyObligation);
+        if (directive === null)
+            return false;
+        if (value.assignmentFromAsker !== undefined) {
+            const expectedReplyCallName = value.assignmentFromAsker.callName === 'tellask'
+                ? 'replyTellask'
+                : 'replyTellaskSessionless';
+            if (directive.expectedReplyCallName !== expectedReplyCallName)
+                return false;
+            if (directive.targetDialogId !== value.askerDialogId)
+                return false;
+            if (directive.targetCallId !== value.assignmentFromAsker.callId)
+                return false;
+            if (directive.tellaskContent !== value.assignmentFromAsker.tellaskContent)
+                return false;
+        }
+        else if (directive.targetDialogId !== value.askerDialogId) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDialogAskerStackState(value) {
+    if (!isRecord(value))
+        return false;
+    if (!Array.isArray(value.askerStack))
+        return false;
+    return value.askerStack.every(isAskerDialogStackFrame);
+}
+function getDialogAskerStackTop(state) {
+    const top = state.askerStack[state.askerStack.length - 1];
+    if (!top) {
+        throw new Error('asker stack invariant violation: empty stack');
+    }
+    return top;
+}
+function getDialogAskerStackCurrentAssignment(state) {
+    for (let index = state.askerStack.length - 1; index >= 0; index -= 1) {
+        const frame = state.askerStack[index];
+        if (frame?.assignmentFromAsker !== undefined) {
+            return frame.assignmentFromAsker;
+        }
+    }
+    throw new Error('asker stack invariant violation: missing assignment frame');
+}
+function buildAssignmentTellaskReplyObligation(args) {
+    switch (args.assignment.callName) {
+        case 'tellask':
+            return {
+                expectedReplyCallName: 'replyTellask',
+                targetDialogId: args.targetDialogId,
+                targetCallId: args.assignment.callId,
+                tellaskContent: args.assignment.tellaskContent,
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                expectedReplyCallName: 'replyTellaskSessionless',
+                targetDialogId: args.targetDialogId,
+                targetCallId: args.assignment.callId,
+                tellaskContent: args.assignment.tellaskContent,
+            };
+    }
+}
+function buildAssignmentAskerStackFrame(args) {
+    return {
+        kind: 'asker_dialog_stack_frame',
+        askerDialogId: args.askerDialogId,
+        assignmentFromAsker: args.assignment,
+        tellaskReplyObligation: buildAssignmentTellaskReplyObligation({
+            targetDialogId: args.assignment.askerDialogId,
+            assignment: args.assignment,
+        }),
+    };
+}
+function parseDialogSideDialogReplyTarget(value) {
     if (!isRecord(value))
         return null;
     const ownerDialogId = value.ownerDialogId;
@@ -1096,22 +1193,22 @@ function parseDialogPendingCourseStartPrompt(value) {
     if (value.tellaskReplyDirective !== undefined && tellaskReplyDirective === null) {
         return null;
     }
-    const subdialogReplyTarget = value.subdialogReplyTarget === undefined
+    const sideDialogReplyTarget = value.sideDialogReplyTarget === undefined
         ? undefined
-        : parseDialogSubdialogReplyTarget(value.subdialogReplyTarget);
-    if (value.subdialogReplyTarget !== undefined && subdialogReplyTarget === null) {
+        : parseDialogSideDialogReplyTarget(value.sideDialogReplyTarget);
+    if (value.sideDialogReplyTarget !== undefined && sideDialogReplyTarget === null) {
         return null;
     }
     const userLanguageCode = userLanguageCodeRaw;
     const skipTaskdoc = skipTaskdocRaw;
     const normalizedTellaskReplyDirective = tellaskReplyDirective === null ? undefined : tellaskReplyDirective;
-    const normalizedSubdialogReplyTarget = subdialogReplyTarget === null ? undefined : subdialogReplyTarget;
-    if (normalizedSubdialogReplyTarget !== undefined &&
+    const normalizedSideDialogReplyTarget = sideDialogReplyTarget === null ? undefined : sideDialogReplyTarget;
+    if (normalizedSideDialogReplyTarget !== undefined &&
         normalizedTellaskReplyDirective === undefined) {
         return null;
     }
     if (normalizedTellaskReplyDirective !== undefined &&
-        normalizedSubdialogReplyTarget !== undefined) {
+        normalizedSideDialogReplyTarget !== undefined) {
         return {
             content: value.content,
             msgId: value.msgId,
@@ -1120,7 +1217,7 @@ function parseDialogPendingCourseStartPrompt(value) {
             ...(userLanguageCode === undefined ? {} : { userLanguageCode }),
             ...(skipTaskdoc === undefined ? {} : { skipTaskdoc }),
             tellaskReplyDirective: normalizedTellaskReplyDirective,
-            subdialogReplyTarget: normalizedSubdialogReplyTarget,
+            sideDialogReplyTarget: normalizedSideDialogReplyTarget,
         };
     }
     if (normalizedTellaskReplyDirective !== undefined) {
@@ -1162,7 +1259,7 @@ function parseDialogLatestFile(value) {
         return null;
     if (value.functionCallCount !== undefined && typeof value.functionCallCount !== 'number')
         return null;
-    if (value.subdialogCount !== undefined && typeof value.subdialogCount !== 'number')
+    if (value.sideDialogCount !== undefined && typeof value.sideDialogCount !== 'number')
         return null;
     if (value.generating !== undefined && typeof value.generating !== 'boolean')
         return null;
@@ -1203,10 +1300,13 @@ function parseDialogLatestFile(value) {
             switch (reason.kind) {
                 case 'needs_human_input':
                     return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-                case 'waiting_for_subdialogs':
-                    return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
-                case 'needs_human_input_and_subdialogs':
-                    return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+                case 'waiting_for_sideDialogs':
+                    return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+                case 'needs_human_input_and_sideDialogs':
+                    return {
+                        kind: 'blocked',
+                        reason: { kind: 'needs_human_input_and_sideDialogs' },
+                    };
                 default:
                     return null;
             }
@@ -1342,7 +1442,7 @@ function parseDialogLatestFile(value) {
         lastModified: value.lastModified,
         messageCount: value.messageCount,
         functionCallCount: value.functionCallCount,
-        subdialogCount: value.subdialogCount,
+        sideDialogCount: value.sideDialogCount,
         status: value.status,
         generating: value.generating,
         needsDrive: value.needsDrive,
@@ -1355,12 +1455,14 @@ function parseDialogLatestFile(value) {
         diligencePushRemainingBudget: value.diligencePushRemainingBudget,
     };
 }
-function isSubdialogResponseRecord(value) {
+function isSideDialogResponseRecord(value) {
     if (!isRecord(value))
         return false;
     if (typeof value.responseId !== 'string')
         return false;
-    if (typeof value.subdialogId !== 'string')
+    if (value.responseId.trim() === '')
+        return false;
+    if (typeof value.sideDialogId !== 'string')
         return false;
     if (typeof value.response !== 'string')
         return false;
@@ -1402,6 +1504,19 @@ function isSubdialogResponseRecord(value) {
         return false;
     return true;
 }
+function assertUniqueSideDialogResponseIds(records, context) {
+    const seen = new Set();
+    for (const record of records) {
+        const responseId = record.responseId.trim();
+        if (responseId === '') {
+            throw new Error(`sideDialog responses empty responseId invariant violation: ${context}`);
+        }
+        if (seen.has(responseId)) {
+            throw new Error(`sideDialog responses duplicate responseId invariant violation: ${context} responseId=${responseId}`);
+        }
+        seen.add(responseId);
+    }
+}
 function isReminderPriority(value) {
     return value === 'high' || value === 'medium' || value === 'low';
 }
@@ -1457,14 +1572,14 @@ function isHumanQuestion(value) {
         return false;
     if (typeof value.callSiteRef.messageIndex !== 'number')
         return false;
-    if ('callingGenseq' in value.callSiteRef) {
-        const callingGenseq = value.callSiteRef.callingGenseq;
-        if (callingGenseq !== undefined) {
-            if (typeof callingGenseq !== 'number')
+    if ('callSiteGenseq' in value.callSiteRef) {
+        const callSiteGenseq = value.callSiteRef.callSiteGenseq;
+        if (callSiteGenseq !== undefined) {
+            if (typeof callSiteGenseq !== 'number')
                 return false;
-            if (!Number.isFinite(callingGenseq))
+            if (!Number.isFinite(callSiteGenseq))
                 return false;
-            if (Math.floor(callingGenseq) <= 0)
+            if (Math.floor(callSiteGenseq) <= 0)
                 return false;
         }
     }
@@ -1597,85 +1712,78 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         this.thinkingReasoning = undefined;
         this.dialogId = dialogId;
     }
-    // === DialogStore interface methods (for compatibility) ===
+    // === DialogStore interface methods ===
     /**
-     * Create subdialog with automatic persistence
+     * Create sideDialog with automatic persistence
      */
-    async createSubDialog(callerDialog, targetAgentId, mentionList, tellaskContent, options) {
+    async createSideDialog(askerDialog, targetAgentId, mentionList, tellaskContent, options) {
         const generatedId = (0, id_1.generateDialogID)();
         const nowTs = (0, time_1.formatUnifiedTimestamp)(new Date());
-        const rootDialog = callerDialog instanceof dialog_1.RootDialog
-            ? callerDialog
-            : callerDialog instanceof dialog_1.SubDialog
-                ? callerDialog.rootDialog
+        const mainDialog = askerDialog instanceof dialog_1.MainDialog
+            ? askerDialog
+            : askerDialog instanceof dialog_1.SideDialog
+                ? askerDialog.mainDialog
                 : (() => {
-                    throw new Error(`createSubDialog invariant violation: unsupported caller dialog type (${callerDialog.constructor.name})`);
+                    throw new Error(`createSideDialog invariant violation: unsupported asker type (${askerDialog.constructor.name})`);
                 })();
-        const rootStatus = rootDialog.status;
+        const rootStatus = mainDialog.status;
         if (rootStatus !== 'running') {
-            throw new Error(`createSubDialog invariant violation: root dialog must be running (rootId=${rootDialog.id.rootId}, status=${rootStatus})`);
-        }
-        const subdialogId = new dialog_1.DialogID(generatedId, rootDialog.id.rootId);
-        // Prepare subdialog store
-        const subdialogStore = new DiskFileDialogStore(subdialogId);
-        const subdialog = new dialog_1.SubDialog(subdialogStore, rootDialog, callerDialog.taskDocPath, subdialogId, targetAgentId, {
-            callName: options.callName,
-            mentionList,
-            tellaskContent,
-            originMemberId: options.originMemberId,
-            callerDialogId: options.callerDialogId,
-            callId: options.callId,
-            collectiveTargets: options.collectiveTargets,
-            effectiveFbrEffort: options.effectiveFbrEffort,
-        }, options.sessionSlug);
-        // Initial subdialog user prompt is now persisted at first drive (driver.ts)
-        // Ensure subdialog directory and persist metadata under supdialog/.subdialogs/
-        await this.ensureSubdialogDirectory(subdialogId);
-        const metadata = {
-            id: subdialogId.selfId,
-            agentId: targetAgentId,
-            taskDocPath: callerDialog.taskDocPath,
-            createdAt: nowTs,
-            supdialogId: callerDialog.id.selfId,
-            sessionSlug: options.sessionSlug,
-            assignmentFromSup: {
+            throw new Error(`createSideDialog invariant violation: main dialog must be running (rootId=${mainDialog.id.rootId}, status=${rootStatus})`);
+        }
+        const sideDialogId = new dialog_1.DialogID(generatedId, mainDialog.id.rootId);
+        // Prepare sideDialog store
+        const sideDialogStore = new DiskFileDialogStore(sideDialogId);
+        const sideDialog = new dialog_1.SideDialog(sideDialogStore, mainDialog, askerDialog.taskDocPath, sideDialogId, targetAgentId, (0, dialog_1.buildSideDialogAskerStack)({
+            askerDialogId: options.askerDialogId,
+            assignment: {
                 callName: options.callName,
                 mentionList,
                 tellaskContent,
                 originMemberId: options.originMemberId,
-                callerDialogId: options.callerDialogId,
+                askerDialogId: options.askerDialogId,
                 callId: options.callId,
                 collectiveTargets: options.collectiveTargets,
                 effectiveFbrEffort: options.effectiveFbrEffort,
             },
+        }), options.sessionSlug);
+        // Initial sideDialog user prompt is now persisted at first drive (driver.ts)
+        // Ensure sideDialog directory and persist metadata under askerDialog/.sideDialogs/
+        await this.ensureSideDialogDirectory(sideDialogId);
+        const metadata = {
+            id: sideDialogId.selfId,
+            agentId: targetAgentId,
+            taskDocPath: askerDialog.taskDocPath,
+            createdAt: nowTs,
+            sessionSlug: options.sessionSlug,
         };
-        await DialogPersistence.saveSubdialogMetadata(subdialogId, metadata);
-        const rootAnchor = resolveRootGenerationAnchor(callerDialog);
-        const parentCourse = callerDialog.activeGenCourseOrUndefined ?? callerDialog.currentCourse;
-        const subdialogCreatedRecord = {
+        await DialogPersistence.saveSideDialogAskerStackState(sideDialogId, sideDialog.askerStack);
+        await DialogPersistence.saveSideDialogMetadata(sideDialogId, metadata);
+        const rootAnchor = resolveRootGenerationAnchor(askerDialog);
+        const parentCourse = askerDialog.activeGenCourseOrUndefined ?? askerDialog.currentCourse;
+        const sideDialogCreatedRecord = {
             ts: nowTs,
-            type: 'subdialog_created_record',
+            type: 'sideDialog_created_record',
             ...cloneRootGenerationAnchor(rootAnchor),
-            subdialogId: subdialogId.selfId,
-            supdialogId: callerDialog.id.selfId,
+            sideDialogId: sideDialogId.selfId,
+            askerDialogId: askerDialog.id.selfId,
             agentId: targetAgentId,
-            taskDocPath: callerDialog.taskDocPath,
+            taskDocPath: askerDialog.taskDocPath,
             createdAt: nowTs,
             sessionSlug: options.sessionSlug,
-            assignmentFromSup: {
+            assignmentFromAsker: {
                 callName: options.callName,
                 mentionList,
                 tellaskContent,
                 originMemberId: options.originMemberId,
-                callerDialogId: options.callerDialogId,
+                askerDialogId: options.askerDialogId,
                 callId: options.callId,
                 collectiveTargets: options.collectiveTargets,
                 effectiveFbrEffort: options.effectiveFbrEffort,
             },
         };
-        await this.appendEvent(callerDialog, parentCourse, subdialogCreatedRecord);
+        await this.appendEvent(askerDialog, parentCourse, sideDialogCreatedRecord);
         // Initialize latest.yaml via the mutation API (write-back will flush).
-        await DialogPersistence.mutateDialogLatest(subdialogId, () => ({
+        await DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
             kind: 'replace',
             next: {
                 currentCourse: 1,
@@ -1683,61 +1791,61 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 status: 'active',
                 messageCount: 0,
                 functionCallCount: 0,
-                subdialogCount: 0,
+                sideDialogCount: 0,
                 displayState: { kind: 'idle_waiting_user' },
                 disableDiligencePush: false,
             },
         }));
-        // Supdialog clarification context is persisted in subdialog metadata (supdialogCall)
-        const rootSubdialogCount = await DialogPersistence.countAllSubdialogsUnderRoot(rootDialog.id, rootStatus);
-        const subdialogCreatedEvt = {
-            type: 'subdialog_created_evt',
+        // AskerDialog clarification context is persisted in sideDialog metadata (askerDialogCall)
+        const rootSideDialogCount = await DialogPersistence.countAllSideDialogsUnderRoot(mainDialog.id, rootStatus);
+        const sideDialogCreatedEvt = {
+            type: 'sideDialog_created_evt',
             dialog: {
-                selfId: subdialogId.selfId,
-                rootId: subdialogId.rootId,
+                selfId: sideDialogId.selfId,
+                rootId: sideDialogId.rootId,
             },
             timestamp: new Date().toISOString(),
             course: parentCourse,
             parentDialog: {
-                selfId: callerDialog.id.selfId,
-                rootId: callerDialog.id.rootId,
+                selfId: askerDialog.id.selfId,
+                rootId: askerDialog.id.rootId,
             },
-            subDialog: {
-                selfId: subdialogId.selfId,
-                rootId: subdialogId.rootId,
+            sideDialog: {
+                selfId: sideDialogId.selfId,
+                rootId: sideDialogId.rootId,
             },
             targetAgentId,
             callName: options.callName,
             mentionList,
             tellaskContent,
-            rootSubdialogCount,
-            subDialogNode: {
-                selfId: subdialogId.selfId,
-                rootId: subdialogId.rootId,
-                supdialogId: callerDialog.id.selfId,
+            rootSideDialogCount,
+            sideDialogNode: {
+                selfId: sideDialogId.selfId,
+                rootId: sideDialogId.rootId,
+                askerDialogId: askerDialog.id.selfId,
                 agentId: targetAgentId,
-                taskDocPath: callerDialog.taskDocPath,
+                taskDocPath: askerDialog.taskDocPath,
                 status: rootStatus,
                 currentCourse: 1,
                 createdAt: nowTs,
                 lastModified: nowTs,
                 displayState: { kind: 'idle_waiting_user' },
                 sessionSlug: options.sessionSlug,
-                assignmentFromSup: {
+                assignmentFromAsker: {
                     callName: options.callName,
                     mentionList,
                     tellaskContent,
                     originMemberId: options.originMemberId,
-                    callerDialogId: options.callerDialogId,
+                    askerDialogId: options.askerDialogId,
                     callId: options.callId,
                     effectiveFbrEffort: options.effectiveFbrEffort,
                 },
             },
         };
-        // Post subdialog_created_evt to PARENT's PubChan so frontend can receive it
-        // The frontend subscribes to the parent's events, not the subdialog's
-        (0, evt_registry_1.postDialogEvent)(callerDialog, subdialogCreatedEvt);
-        return subdialog;
+        // Post sideDialog_created_evt to PARENT's PubChan so frontend can receive it
+        // The frontend subscribes to the parent's events, not the sideDialog's
+        (0, evt_registry_1.postDialogEvent)(askerDialog, sideDialogCreatedEvt);
+        return sideDialog;
     }
     /**
      * Receive and handle function call results (includes logging)
@@ -1815,10 +1923,10 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskCarryoverEvent(normalizedResult, course));
     }
     /**
-     * Ensure subdialog directory exists (delegate to DialogPersistence)
+     * Ensure sideDialog directory exists (delegate to DialogPersistence)
      */
-    async ensureSubdialogDirectory(dialogId) {
-        return await DialogPersistence.ensureSubdialogDirectory(dialogId);
+    async ensureSideDialogDirectory(dialogId) {
+        return await DialogPersistence.ensureSideDialogDirectory(dialogId);
     }
     async findExistingFuncResultRecord(dialog, callId) {
         const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
@@ -1837,6 +1945,22 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         }
         return undefined;
     }
+    async findExistingCallRecord(dialog, callId) {
+        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
+        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
+        for (let course = 1; course <= maxCourse; course += 1) {
+            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+            for (const event of events) {
+                if (event.type === 'func_call_record' && event.id === callId) {
+                    return { course, record: event };
+                }
+                if (event.type === 'tellask_call_record' && event.id === callId) {
+                    return { course, record: event };
+                }
+            }
+        }
+        return undefined;
+    }
     async findExistingTellaskResultRecord(dialog, callId) {
         const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
         const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
@@ -1854,10 +1978,41 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         }
         return undefined;
     }
+    async raiseDuplicateCallInvariantViolation(args) {
+        const err = new Error(`${args.kind} duplicate callId invariant violation: rootId=${args.dialog.id.rootId} selfId=${args.dialog.id.selfId} ` +
+            `callId=${args.callId} callName=${args.callName} existingName=${args.existingName} ` +
+            `existingCourse=${args.existingCourse} existingGenseq=${args.existingGenseq} ` +
+            `incomingCourse=${args.incomingCourse} incomingGenseq=${args.incomingGenseq}`);
+        log_1.log.error('Duplicate call detected; rejecting second write', err, {
+            rootId: args.dialog.id.rootId,
+            selfId: args.dialog.id.selfId,
+            callId: args.callId,
+            callName: args.callName,
+            kind: args.kind,
+            existingName: args.existingName,
+            existingCourse: args.existingCourse,
+            existingGenseq: args.existingGenseq,
+            incomingCourse: args.incomingCourse,
+            incomingGenseq: args.incomingGenseq,
+        });
+        try {
+            await this.streamError(args.dialog, err.message);
+        }
+        catch (streamErr) {
+            log_1.log.warn('Failed to emit stream_error_evt for duplicate call', streamErr, {
+                rootId: args.dialog.id.rootId,
+                selfId: args.dialog.id.selfId,
+                callId: args.callId,
+                callName: args.callName,
+                kind: args.kind,
+            });
+        }
+        throw err;
+    }
     async raiseDuplicateCallResultInvariantViolation(args) {
         // Duplicate final results are not harmless transcript noise. They mean two different program
         // paths both believed they owned the same business-level completion fact for one callId.
-        // In ask-back flows this usually points to identity confusion between requester/responder or
+        // In ask-back flows this usually points to identity confusion between asker/tellaskee or
         // canonical reply-tool delivery versus another mistaken write path. We fail fast here so the
         // second writer keeps its own stack trace instead of silently corrupting the dialog transcript.
         const err = new Error(`${args.kind} duplicate callId invariant violation: rootId=${args.dialog.id.rootId} selfId=${args.dialog.id.selfId} ` +
@@ -2141,19 +2296,6 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         })();
         (0, evt_registry_1.postDialogEvent)(dialog, evt);
     }
-    // Function call events (non-streaming mode - single event captures entire call)
-    async funcCallRequested(dialog, funcId, funcName, argumentsStr) {
-        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const funcCallEvt = {
-            type: 'func_call_requested_evt',
-            funcId,
-            funcName,
-            arguments: argumentsStr,
-            course,
-            genseq: dialog.activeGenSeq,
-        };
-        (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
-    }
     async webSearchCall(dialog, payload) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         const itemId = payload.itemId.trim();
@@ -2545,6 +2687,10 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (deferredReplyReassertion?.directive.targetCallId === payload.targetCallId) {
             await DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
         }
+        const activeObligation = await DialogPersistence.loadActiveTellaskReplyObligation(dialog.id, dialog.status);
+        if (activeObligation?.targetCallId === payload.targetCallId) {
+            await DialogPersistence.setActiveTellaskReplyObligation(dialog.id, undefined, dialog.status);
+        }
     }
     /**
      * Persist an assistant message to storage
@@ -2593,13 +2739,54 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      */
     async persistFunctionCall(dialog, id, name, rawArgumentsText, genseq) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        if (!Number.isFinite(genseq) || genseq <= 0) {
+            throw new Error(`persistFunctionCall invariant violation: missing valid genseq for func call ${id}`);
+        }
+        const existingCall = await this.findExistingCallRecord(dialog, id);
+        if (existingCall) {
+            await this.raiseDuplicateCallInvariantViolation({
+                dialog,
+                kind: 'func_call',
+                callId: id,
+                callName: name,
+                incomingCourse: course,
+                incomingGenseq: genseq,
+                existingCourse: existingCall.course,
+                existingGenseq: existingCall.record.genseq,
+                existingName: existingCall.record.name,
+            });
+        }
         const funcCallEvent = buildFuncCallRecord({ id, name, rawArgumentsText, genseq });
         await this.appendEvent(dialog, course, funcCallEvent);
-        // NOTE: func_call_evt REMOVED - persistence uses FuncCallRecord directly
-        // UI display uses func_call_requested_evt instead
+        const funcCallEvt = {
+            type: 'func_call_requested_evt',
+            funcId: id,
+            funcName: name,
+            arguments: rawArgumentsText,
+            course,
+            genseq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
     }
     async persistTellaskCall(dialog, id, name, rawArgumentsText, genseq, options) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        if (!Number.isFinite(genseq) || genseq <= 0) {
+            throw new Error(`persistTellaskCall invariant violation: missing valid genseq for tellask call ${id}`);
+        }
+        const existingCall = await this.findExistingCallRecord(dialog, id);
+        if (existingCall) {
+            await this.raiseDuplicateCallInvariantViolation({
+                dialog,
+                kind: 'tellask_call',
+                callId: id,
+                callName: name,
+                incomingCourse: course,
+                incomingGenseq: genseq,
+                existingCourse: existingCall.course,
+                existingGenseq: existingCall.record.genseq,
+                existingName: existingCall.record.name,
+            });
+        }
         const tellaskCallEvent = buildTellaskCallRecord({
             id,
             name,
@@ -2609,81 +2796,17 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 (isReplyTellaskCallRecordName(name) ? 'func_call_requested' : 'tellask_call_start'),
         });
         await this.appendEvent(dialog, course, tellaskCallEvent);
-        if (isReplyTellaskCallRecordName(name)) {
+        if (tellaskCallEvent.deliveryMode === 'func_call_requested') {
             const funcCallEvt = {
                 type: 'func_call_requested_evt',
                 funcId: id,
                 funcName: name,
                 arguments: formatTellaskCallArguments(tellaskCallEvent),
                 course,
-                genseq: dialog.activeGenSeqOrUndefined ?? genseq,
-            };
-            (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
-        }
-    }
-    async persistFunctionCallResultPair(dialog, id, name, rawArgumentsText, genseq, result) {
-        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const resultGenseq = dialog.activeGenSeqOrUndefined ?? result.genseq;
-        if (!Number.isFinite(resultGenseq) || resultGenseq <= 0) {
-            throw new Error(`persistFunctionCallResultPair invariant violation: missing valid genseq for func result ${result.id}`);
-        }
-        await this.appendEvents(dialog, course, [
-            buildFuncCallRecord({ id, name, rawArgumentsText, genseq }),
-            buildFuncResultRecord(result, resultGenseq),
-        ]);
-        if (!isSuppressedTellaskPlaceholderFuncResult({
-            name: result.name,
-            content: result.content,
-        })) {
-            const funcResultEvt = {
-                type: 'func_result_evt',
-                id: result.id,
-                name: result.name,
-                content: result.content,
-                contentItems: result.contentItems,
-                course,
                 genseq,
             };
-            (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
-        }
-    }
-    async persistTellaskCallResultPair(dialog, args) {
-        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const callRecord = buildTellaskCallRecord({
-            id: args.id,
-            name: args.name,
-            rawArgumentsText: args.rawArgumentsText,
-            genseq: args.genseq,
-            deliveryMode: args.deliveryMode,
-        });
-        if (args.result.type === 'func_result_msg') {
-            const resultGenseq = dialog.activeGenSeqOrUndefined ?? args.result.genseq;
-            if (!Number.isFinite(resultGenseq) || resultGenseq <= 0) {
-                throw new Error(`persistTellaskCallResultPair invariant violation: missing valid genseq for func result ${args.result.id}`);
-            }
-            await this.appendEvents(dialog, course, [
-                callRecord,
-                buildFuncResultRecord(args.result, resultGenseq),
-            ]);
-            if (!isSuppressedTellaskPlaceholderFuncResult({
-                name: args.result.name,
-                content: args.result.content,
-            })) {
-                const funcResultEvt = {
-                    type: 'func_result_evt',
-                    id: args.result.id,
-                    name: args.result.name,
-                    content: args.result.content,
-                    contentItems: args.result.contentItems,
-                    course,
-                    genseq: resultGenseq,
-                };
-                (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
-            }
-            return;
+            (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
         }
-        await this.appendEvents(dialog, course, [callRecord, buildTellaskResultRecord(args.result)]);
-        (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskResultEvent(args.result, course));
     }
     /**
      * Update questions for human state (exceptional overwrite pattern)
@@ -2701,162 +2824,168 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     async loadDialogMetadata(dialogId, status) {
         return await DialogPersistence.loadDialogMetadata(dialogId, status);
     }
-    async loadPendingSubdialogs(rootDialogId, status) {
-        const records = await DialogPersistence.loadPendingSubdialogs(rootDialogId, status);
+    async loadSideDialogAssignmentFromAsker(dialogId, status) {
+        if (dialogId.rootId === dialogId.selfId)
+            return null;
+        return await DialogPersistence.loadSideDialogAssignmentFromAsker(dialogId, status);
+    }
+    async loadPendingSideDialogs(mainDialogId, status) {
+        const records = await DialogPersistence.loadPendingSideDialogs(mainDialogId, status);
         return records.map((record) => ({
-            subdialogId: new dialog_1.DialogID(record.subdialogId, rootDialogId.rootId),
+            sideDialogId: new dialog_1.DialogID(record.sideDialogId, mainDialogId.rootId),
             createdAt: record.createdAt,
             mentionList: record.mentionList,
             tellaskContent: record.tellaskContent,
             targetAgentId: record.targetAgentId,
             callId: record.callId,
-            callingCourse: record.callingCourse,
+            callSiteCourse: record.callSiteCourse,
+            callSiteGenseq: record.callSiteGenseq,
             callType: record.callType,
             sessionSlug: record.sessionSlug,
         }));
     }
-    async saveSubdialogRegistry(dialog, rootDialogId, entries, status) {
-        await DialogPersistence.saveSubdialogRegistry(rootDialogId, entries, status);
-        await DialogPersistence.appendSubdialogRegistryReconciledRecord(rootDialogId, entries.map((entry) => ({
+    async saveSideDialogRegistry(dialog, mainDialogId, entries, status) {
+        await DialogPersistence.saveSideDialogRegistry(mainDialogId, entries, status);
+        await DialogPersistence.appendSideDialogRegistryReconciledRecord(mainDialogId, entries.map((entry) => ({
             key: entry.key,
-            subdialogId: entry.subdialogId.selfId,
+            sideDialogId: entry.sideDialogId.selfId,
             agentId: entry.agentId,
             sessionSlug: entry.sessionSlug,
         })), resolveReconciledRecordWriteTarget(dialog), status);
     }
-    async loadSubdialogRegistry(rootDialog, status) {
-        const entries = await DialogPersistence.loadSubdialogRegistry(rootDialog.id, status);
+    async loadSideDialogRegistry(mainDialog, status) {
+        const entries = await DialogPersistence.loadSideDialogRegistry(mainDialog.id, status);
         const shouldPruneDead = status === 'running';
         let prunedDeadRegistryEntries = false;
-        const restoringSubdialogs = new Map();
-        const ensureSubdialogLoaded = async (subdialogId, ancestry = new Set()) => {
-            if (ancestry.has(subdialogId.selfId)) {
-                throw new Error(`Subdialog registry restore invariant violation: cyclic parent chain ` +
-                    `(rootId=${rootDialog.id.rootId}, selfId=${subdialogId.selfId})`);
+        const restoringSideDialogs = new Map();
+        const ensureSideDialogLoaded = async (sideDialogId, ancestry = new Set()) => {
+            if (ancestry.has(sideDialogId.selfId)) {
+                throw new Error(`SideDialog registry restore invariant violation: cyclic parent chain ` +
+                    `(rootId=${mainDialog.id.rootId}, selfId=${sideDialogId.selfId})`);
             }
-            const existing = rootDialog.lookupDialog(subdialogId.selfId);
+            const existing = mainDialog.lookupDialog(sideDialogId.selfId);
             if (existing) {
-                if (!(existing instanceof dialog_1.SubDialog)) {
-                    throw new Error(`Dialog registry type invariant violation: expected SubDialog ` +
-                        `(rootId=${rootDialog.id.rootId}, selfId=${subdialogId.selfId})`);
+                if (!(existing instanceof dialog_1.SideDialog)) {
+                    throw new Error(`Dialog registry type invariant violation: expected SideDialog ` +
+                        `(rootId=${mainDialog.id.rootId}, selfId=${sideDialogId.selfId})`);
                 }
                 return existing;
             }
-            const inFlight = restoringSubdialogs.get(subdialogId.selfId);
+            const inFlight = restoringSideDialogs.get(sideDialogId.selfId);
             if (inFlight) {
                 return await inFlight;
             }
             const task = (async () => {
                 const nextAncestry = new Set(ancestry);
-                nextAncestry.add(subdialogId.selfId);
-                const subdialogState = await DialogPersistence.restoreDialog(subdialogId, status);
-                if (!subdialogState) {
-                    throw new Error(`Subdialog registry restore invariant violation: missing dialog state ` +
-                        `(rootId=${rootDialog.id.rootId}, selfId=${subdialogId.selfId})`);
+                nextAncestry.add(sideDialogId.selfId);
+                const sideDialogState = await DialogPersistence.restoreDialog(sideDialogId, status);
+                if (!sideDialogState) {
+                    throw new Error(`SideDialog registry restore invariant violation: missing dialog state ` +
+                        `(rootId=${mainDialog.id.rootId}, selfId=${sideDialogId.selfId})`);
                 }
-                const metadata = subdialogState.metadata;
-                if (!isSubdialogMetadataFile(metadata)) {
-                    throw new Error(`Subdialog registry restore invariant violation: expected subdialog metadata ` +
-                        `(rootId=${rootDialog.id.rootId}, selfId=${subdialogId.selfId})`);
+                const metadata = sideDialogState.metadata;
+                if (!isSideDialogMetadataFile(metadata)) {
+                    throw new Error(`SideDialog registry restore invariant violation: expected sideDialog metadata ` +
+                        `(rootId=${mainDialog.id.rootId}, selfId=${sideDialogId.selfId})`);
                 }
-                const assignmentFromSup = metadata.assignmentFromSup;
-                if (!assignmentFromSup) {
-                    throw new Error(`Subdialog registry restore invariant violation: missing assignmentFromSup ` +
-                        `(rootId=${rootDialog.id.rootId}, selfId=${subdialogId.selfId})`);
+                const askerStack = await DialogPersistence.loadSideDialogAskerStackState(sideDialogId, status);
+                if (!askerStack) {
+                    throw new Error(`SideDialog registry restore invariant violation: missing asker stack ` +
+                        `(rootId=${mainDialog.id.rootId}, selfId=${sideDialogId.selfId})`);
                 }
+                const assignmentFromAsker = getDialogAskerStackCurrentAssignment(askerStack);
                 const parentIds = [];
                 const maybePushParentId = (candidate) => {
                     if (!candidate)
                         return;
-                    if (candidate === rootDialog.id.rootId)
+                    if (candidate === mainDialog.id.rootId)
                         return;
-                    if (candidate === subdialogId.selfId)
+                    if (candidate === sideDialogId.selfId)
                         return;
                     if (parentIds.includes(candidate))
                         return;
                     parentIds.push(candidate);
                 };
-                maybePushParentId(metadata.supdialogId);
-                maybePushParentId(assignmentFromSup.callerDialogId);
+                maybePushParentId(assignmentFromAsker.askerDialogId);
                 for (const parentId of parentIds) {
-                    if (rootDialog.lookupDialog(parentId)) {
+                    if (mainDialog.lookupDialog(parentId)) {
                         continue;
                     }
-                    const parentDialogId = new dialog_1.DialogID(parentId, rootDialog.id.rootId);
+                    const parentDialogId = new dialog_1.DialogID(parentId, mainDialog.id.rootId);
                     const parentMeta = await DialogPersistence.loadDialogMetadata(parentDialogId, status);
                     if (!parentMeta) {
-                        throw new Error(`Subdialog registry restore invariant violation: missing parent metadata ` +
-                            `(rootId=${rootDialog.id.rootId}, childId=${subdialogId.selfId}, parentId=${parentId})`);
+                        throw new Error(`SideDialog registry restore invariant violation: missing parent metadata ` +
+                            `(rootId=${mainDialog.id.rootId}, childId=${sideDialogId.selfId}, parentId=${parentId})`);
                     }
-                    if (!isSubdialogMetadataFile(parentMeta)) {
-                        throw new Error(`Subdialog registry restore invariant violation: parent is not a subdialog ` +
-                            `(rootId=${rootDialog.id.rootId}, childId=${subdialogId.selfId}, parentId=${parentId})`);
+                    if (!isSideDialogMetadataFile(parentMeta)) {
+                        throw new Error(`SideDialog registry restore invariant violation: parent is not a sideDialog ` +
+                            `(rootId=${mainDialog.id.rootId}, childId=${sideDialogId.selfId}, parentId=${parentId})`);
                     }
-                    await ensureSubdialogLoaded(parentDialogId, nextAncestry);
-                    if (!rootDialog.lookupDialog(parentId)) {
-                        throw new Error(`Subdialog registry restore invariant violation: parent restore failed ` +
-                            `(rootId=${rootDialog.id.rootId}, childId=${subdialogId.selfId}, parentId=${parentId})`);
+                    await ensureSideDialogLoaded(parentDialogId, nextAncestry);
+                    if (!mainDialog.lookupDialog(parentId)) {
+                        throw new Error(`SideDialog registry restore invariant violation: parent restore failed ` +
+                            `(rootId=${mainDialog.id.rootId}, childId=${sideDialogId.selfId}, parentId=${parentId})`);
                     }
                 }
-                const subdialogStore = new DiskFileDialogStore(subdialogId);
-                const subdialog = new dialog_1.SubDialog(subdialogStore, rootDialog, metadata.taskDocPath, new dialog_1.DialogID(subdialogId.selfId, rootDialog.id.rootId), metadata.agentId, assignmentFromSup, metadata.sessionSlug, {
-                    messages: subdialogState.messages,
-                    reminders: subdialogState.reminders,
-                    currentCourse: subdialogState.currentCourse,
-                    contextHealth: subdialogState.contextHealth,
+                const sideDialogStore = new DiskFileDialogStore(sideDialogId);
+                const sideDialog = new dialog_1.SideDialog(sideDialogStore, mainDialog, metadata.taskDocPath, new dialog_1.DialogID(sideDialogId.selfId, mainDialog.id.rootId), metadata.agentId, askerStack, metadata.sessionSlug, {
+                    messages: sideDialogState.messages,
+                    reminders: sideDialogState.reminders,
+                    currentCourse: sideDialogState.currentCourse,
+                    contextHealth: sideDialogState.contextHealth,
                 });
-                const latest = await DialogPersistence.loadDialogLatest(subdialogId, status);
-                subdialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
-                if (subdialog.sessionSlug) {
-                    rootDialog.registerSubdialog(subdialog);
+                const latest = await DialogPersistence.loadDialogLatest(sideDialogId, status);
+                sideDialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
+                if (sideDialog.sessionSlug) {
+                    mainDialog.registerSideDialog(sideDialog);
                 }
-                return subdialog;
+                return sideDialog;
             })();
-            restoringSubdialogs.set(subdialogId.selfId, task);
+            restoringSideDialogs.set(sideDialogId.selfId, task);
             try {
                 return await task;
             }
             finally {
-                restoringSubdialogs.delete(subdialogId.selfId);
+                restoringSideDialogs.delete(sideDialogId.selfId);
             }
         };
         for (const entry of entries) {
             if (!entry.sessionSlug)
                 continue;
             if (shouldPruneDead) {
-                const latest = await DialogPersistence.loadDialogLatest(entry.subdialogId, status);
+                const latest = await DialogPersistence.loadDialogLatest(entry.sideDialogId, status);
                 const executionMarker = latest?.executionMarker;
                 if (executionMarker && executionMarker.kind === 'dead') {
                     prunedDeadRegistryEntries = true;
-                    rootDialog.unregisterSubdialog(entry.agentId, entry.sessionSlug);
-                    log_1.log.debug('Skip dead subdialog while loading Type B registry', undefined, {
-                        rootId: rootDialog.id.rootId,
-                        subdialogId: entry.subdialogId.selfId,
+                    mainDialog.unregisterSideDialog(entry.agentId, entry.sessionSlug);
+                    log_1.log.debug('Skip dead sideDialog while loading Type B registry', undefined, {
+                        rootId: mainDialog.id.rootId,
+                        sideDialogId: entry.sideDialogId.selfId,
                         agentId: entry.agentId,
                         sessionSlug: entry.sessionSlug,
                     });
                     continue;
                 }
             }
-            const subdialog = await ensureSubdialogLoaded(entry.subdialogId);
-            if (!subdialog.sessionSlug) {
-                throw new Error(`Subdialog registry invariant violation: missing sessionSlug on loaded subdialog ` +
-                    `(rootId=${rootDialog.id.rootId}, selfId=${entry.subdialogId.selfId}, expectedSessionSlug=${entry.sessionSlug})`);
+            const sideDialog = await ensureSideDialogLoaded(entry.sideDialogId);
+            if (!sideDialog.sessionSlug) {
+                throw new Error(`SideDialog registry invariant violation: missing sessionSlug on loaded sideDialog ` +
+                    `(rootId=${mainDialog.id.rootId}, selfId=${entry.sideDialogId.selfId}, expectedSessionSlug=${entry.sessionSlug})`);
             }
-            if (subdialog.sessionSlug !== entry.sessionSlug) {
-                throw new Error(`Subdialog registry invariant violation: sessionSlug mismatch ` +
-                    `(rootId=${rootDialog.id.rootId}, selfId=${entry.subdialogId.selfId}, ` +
-                    `expected=${entry.sessionSlug}, actual=${subdialog.sessionSlug})`);
+            if (sideDialog.sessionSlug !== entry.sessionSlug) {
+                throw new Error(`SideDialog registry invariant violation: sessionSlug mismatch ` +
+                    `(rootId=${mainDialog.id.rootId}, selfId=${entry.sideDialogId.selfId}, ` +
+                    `expected=${entry.sessionSlug}, actual=${sideDialog.sessionSlug})`);
             }
-            if (subdialog.agentId !== entry.agentId) {
-                throw new Error(`Subdialog registry invariant violation: agentId mismatch ` +
-                    `(rootId=${rootDialog.id.rootId}, selfId=${entry.subdialogId.selfId}, ` +
-                    `expected=${entry.agentId}, actual=${subdialog.agentId})`);
+            if (sideDialog.agentId !== entry.agentId) {
+                throw new Error(`SideDialog registry invariant violation: agentId mismatch ` +
+                    `(rootId=${mainDialog.id.rootId}, selfId=${entry.sideDialogId.selfId}, ` +
+                    `expected=${entry.agentId}, actual=${sideDialog.agentId})`);
             }
-            rootDialog.registerSubdialog(subdialog);
+            mainDialog.registerSideDialog(sideDialog);
         }
         if (prunedDeadRegistryEntries) {
-            await rootDialog.saveSubdialogRegistry();
+            await mainDialog.saveSideDialogRegistry();
         }
     }
     /**
@@ -3514,8 +3643,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                     callId: event.callId,
                     status: event.status,
                     content: event.content,
-                    ...(event.originCourse !== undefined ? { originCourse: event.originCourse } : {}),
-                    ...(event.calling_genseq !== undefined ? { calling_genseq: event.calling_genseq } : {}),
+                    ...(event.callSiteCourse !== undefined ? { callSiteCourse: event.callSiteCourse } : {}),
+                    ...(event.callSiteGenseq !== undefined ? { callSiteGenseq: event.callSiteGenseq } : {}),
                     responder: event.responder,
                     ...(event.route ? { route: event.route } : {}),
                     dialog: {
@@ -3546,68 +3675,64 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
-            case 'quest_for_sup_record': {
-                // Handle subdialog creation requests
-                const persistedStatus = assertPersistableDialogStatus(status, 'sendEventDirectlyToWebSocket:quest_for_sup_record');
-                const subdialogId = new dialog_1.DialogID(event.subDialogId, dialog.id.rootId);
-                const metadata = await DialogPersistence.loadDialogMetadata(subdialogId, status);
-                if (!metadata || !isSubdialogMetadataFile(metadata)) {
-                    throw new Error(`subdialog_created_evt replay invariant violation: metadata missing for ${subdialogId.valueOf()} in ${status}`);
+            case 'sideDialog_request_record': {
+                // Handle sideDialog creation requests
+                const persistedStatus = assertPersistableDialogStatus(status, 'sendEventDirectlyToWebSocket:sideDialog_request_record');
+                const sideDialogId = new dialog_1.DialogID(event.sideDialogId, dialog.id.rootId);
+                const metadata = await DialogPersistence.loadDialogMetadata(sideDialogId, status);
+                if (!metadata || !isSideDialogMetadataFile(metadata)) {
+                    throw new Error(`sideDialog_created_evt replay invariant violation: metadata missing for ${sideDialogId.valueOf()} in ${status}`);
                 }
-                const subMeta = metadata;
-                const subLatest = await DialogPersistence.loadDialogLatest(subdialogId, status);
-                const derivedSupdialogId = subMeta.assignmentFromSup?.callerDialogId &&
-                    subMeta.assignmentFromSup.callerDialogId.trim() !== ''
-                    ? subMeta.assignmentFromSup.callerDialogId
-                    : typeof subMeta.supdialogId === 'string' && subMeta.supdialogId.trim() !== ''
-                        ? subMeta.supdialogId
-                        : dialog.id.selfId;
-                const callName = subMeta.assignmentFromSup?.callName;
+                const sideMeta = metadata;
+                const sideLatest = await DialogPersistence.loadDialogLatest(sideDialogId, status);
+                const assignmentFromAsker = await DialogPersistence.loadSideDialogAssignmentFromAsker(sideDialogId, status);
+                const derivedAskerDialogId = assignmentFromAsker.askerDialogId.trim();
+                const callName = assignmentFromAsker.callName;
                 if (callName !== 'tellask' &&
                     callName !== 'tellaskSessionless' &&
                     callName !== 'freshBootsReasoning') {
-                    throw new Error(`subdialog_created_evt replay invariant violation: missing assignment callName for ${subdialogId.valueOf()} in ${status}`);
+                    throw new Error(`sideDialog_created_evt replay invariant violation: missing assignment callName for ${sideDialogId.valueOf()} in ${status}`);
                 }
-                const rootSubdialogCount = await DialogPersistence.countAllSubdialogsUnderRoot(new dialog_1.DialogID(subdialogId.rootId), persistedStatus);
-                const subdialogCreatedEvent = {
-                    type: 'subdialog_created_evt',
+                const rootSideDialogCount = await DialogPersistence.countAllSideDialogsUnderRoot(new dialog_1.DialogID(sideDialogId.rootId), persistedStatus);
+                const sideDialogCreatedEvent = {
+                    type: 'sideDialog_created_evt',
                     course,
                     dialog: {
                         // Add dialog field for proper event routing
-                        selfId: subdialogId.selfId,
-                        rootId: subdialogId.rootId,
+                        selfId: sideDialogId.selfId,
+                        rootId: sideDialogId.rootId,
                     },
                     parentDialog: {
                         selfId: dialog.id.selfId,
                         rootId: dialog.id.rootId,
                     },
-                    subDialog: {
-                        selfId: subdialogId.selfId,
-                        rootId: subdialogId.rootId,
+                    sideDialog: {
+                        selfId: sideDialogId.selfId,
+                        rootId: sideDialogId.rootId,
                     },
-                    targetAgentId: subMeta.agentId,
+                    targetAgentId: sideMeta.agentId,
                     callName,
                     mentionList: event.mentionList,
                     tellaskContent: event.tellaskContent,
-                    rootSubdialogCount,
-                    subDialogNode: {
-                        selfId: subMeta.id,
-                        rootId: subdialogId.rootId,
-                        supdialogId: derivedSupdialogId,
-                        agentId: subMeta.agentId,
-                        taskDocPath: subMeta.taskDocPath,
+                    rootSideDialogCount,
+                    sideDialogNode: {
+                        selfId: sideMeta.id,
+                        rootId: sideDialogId.rootId,
+                        askerDialogId: derivedAskerDialogId,
+                        agentId: sideMeta.agentId,
+                        taskDocPath: sideMeta.taskDocPath,
                         status: persistedStatus,
-                        currentCourse: subLatest?.currentCourse || 1,
-                        createdAt: subMeta.createdAt,
-                        lastModified: subLatest?.lastModified || subMeta.createdAt,
-                        displayState: subLatest?.displayState,
-                        sessionSlug: subMeta.sessionSlug,
-                        assignmentFromSup: subMeta.assignmentFromSup,
+                        currentCourse: sideLatest?.currentCourse || 1,
+                        createdAt: sideMeta.createdAt,
+                        lastModified: sideLatest?.lastModified || sideMeta.createdAt,
+                        displayState: sideLatest?.displayState,
+                        sessionSlug: sideMeta.sessionSlug,
+                        assignmentFromAsker,
                     },
                     timestamp: event.ts,
                 };
                 if (ws.readyState === 1) {
-                    ws.send(JSON.stringify(subdialogCreatedEvent));
+                    ws.send(JSON.stringify(sideDialogCreatedEvent));
                 }
                 break;
             }
@@ -3635,8 +3760,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         callId: event.callId,
                         assignmentCourse: event.assignmentCourse,
                         assignmentGenseq: event.assignmentGenseq,
-                        callerDialogId: event.callerDialogId,
-                        callerCourse: event.callerCourse,
+                        askerDialogId: event.askerDialogId,
+                        askerCourse: event.askerCourse,
                         dialog: {
                             selfId: dialog.id.selfId,
                             rootId: dialog.id.rootId,
@@ -3648,19 +3773,19 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
-            case 'subdialog_created_record':
+            case 'sideDialog_created_record':
             case 'reminders_reconciled_record':
             case 'questions4human_reconciled_record':
-            case 'pending_subdialogs_reconciled_record':
-            case 'subdialog_registry_reconciled_record':
-            case 'subdialog_responses_reconciled_record':
+            case 'pending_sideDialogs_reconciled_record':
+            case 'sideDialog_registry_reconciled_record':
+            case 'sideDialog_responses_reconciled_record':
                 break;
             case 'tellask_carryover_record': {
                 const base = {
                     type: 'tellask_carryover_evt',
                     course,
                     genseq: event.genseq,
-                    originCourse: event.originCourse,
+                    callSiteCourse: event.callSiteCourse,
                     carryoverCourse: event.carryoverCourse,
                     responderId: event.responderId,
                     tellaskContent: event.tellaskContent,
@@ -3727,7 +3852,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
 exports.DiskFileDialogStore = DiskFileDialogStore;
 class DialogWriteBackCanceledError extends Error {
     constructor(token, phase) {
-        super(`Dialog writeback canceled for ${token.rootDialogId} (${token.status}) during ${phase}`);
+        super(`Dialog writeback canceled for ${token.mainDialogId} (${token.status}) during ${phase}`);
         this.name = 'DialogWriteBackCanceledError';
     }
 }
@@ -3765,12 +3890,12 @@ class DialogPersistence {
     static getCourseAppendMutexKey(dialogId, course, status) {
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|course:${course}`;
     }
-    static getPendingSubdialogsWriteBackMutex(key) {
-        const existing = this.pendingSubdialogsWriteBackMutexes.get(key);
+    static getPendingSideDialogsWriteBackMutex(key) {
+        const existing = this.pendingSideDialogsWriteBackMutexes.get(key);
         if (existing)
             return existing;
         const created = new async_fifo_mutex_1.AsyncFifoMutex();
-        this.pendingSubdialogsWriteBackMutexes.set(key, created);
+        this.pendingSideDialogsWriteBackMutexes.set(key, created);
         return created;
     }
     static getLatestWriteBackKey(dialogId, status) {
@@ -3781,27 +3906,27 @@ class DialogPersistence {
         // Include dialogs root dir to avoid cross-test/process.cwd collisions.
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|q4h`;
     }
-    static getPendingSubdialogsWriteBackKey(rootDialogId, status) {
-        return `${this.getDialogsRootDir()}|${status}|${rootDialogId.valueOf()}|pending-subdialogs`;
+    static getPendingSideDialogsWriteBackKey(mainDialogId, status) {
+        return `${this.getDialogsRootDir()}|${status}|${mainDialogId.valueOf()}|pending-sideDialogs`;
     }
-    static getRootDialogWriteBackCancelScopeKey(rootDialogId, status) {
-        return `${this.getDialogsRootDir()}|${status}|${rootDialogId.selfId}|writeback-cancel`;
+    static getMainDialogWriteBackCancelScopeKey(mainDialogId, status) {
+        return `${this.getDialogsRootDir()}|${status}|${mainDialogId.selfId}|writeback-cancel`;
     }
-    static createRootDialogWriteBackCancellationToken(dialogId, status) {
-        const rootDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
-        const scopeKey = this.getRootDialogWriteBackCancelScopeKey(rootDialogId, status);
+    static createMainDialogWriteBackCancellationToken(dialogId, status) {
+        const mainDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
+        const scopeKey = this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status);
         return {
             scopeKey,
-            generation: this.rootDialogWriteBackCancelGenerations.get(scopeKey) ?? 0,
-            rootDialogId: rootDialogId.selfId,
+            generation: this.mainDialogWriteBackCancelGenerations.get(scopeKey) ?? 0,
+            mainDialogId: mainDialogId.selfId,
             status,
         };
     }
-    static assertRootDialogWriteBackNotCanceled(token, phase) {
-        if (this.quarantinedRootDialogScopes.has(token.scopeKey)) {
+    static assertMainDialogWriteBackNotCanceled(token, phase) {
+        if (this.quarantinedMainDialogScopes.has(token.scopeKey)) {
             throw new DialogWriteBackCanceledError(token, phase);
         }
-        const currentGeneration = this.rootDialogWriteBackCancelGenerations.get(token.scopeKey) ?? 0;
+        const currentGeneration = this.mainDialogWriteBackCancelGenerations.get(token.scopeKey) ?? 0;
         if (currentGeneration !== token.generation) {
             throw new DialogWriteBackCanceledError(token, phase);
         }
@@ -3811,45 +3936,51 @@ class DialogPersistence {
             throw error;
         }
         if (cancellationToken) {
-            this.assertRootDialogWriteBackNotCanceled(cancellationToken, phase);
+            this.assertMainDialogWriteBackNotCanceled(cancellationToken, phase);
             if (!(await this.pathExists(dialogPath))) {
                 throw new DialogWriteBackCanceledError(cancellationToken, `${phase}:dialog-path-missing`);
             }
         }
         throw error;
     }
-    static cancelRootDialogWriteBacks(rootDialogId, status) {
-        const scopeKey = this.getRootDialogWriteBackCancelScopeKey(rootDialogId, status);
-        const nextGeneration = (this.rootDialogWriteBackCancelGenerations.get(scopeKey) ?? 0) + 1;
-        this.rootDialogWriteBackCancelGenerations.set(scopeKey, nextGeneration);
-        this.clearWriteBackEntriesForRootDialog(rootDialogId, status);
+    static cancelMainDialogWriteBacks(mainDialogId, status) {
+        const scopeKey = this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status);
+        const nextGeneration = (this.mainDialogWriteBackCancelGenerations.get(scopeKey) ?? 0) + 1;
+        this.mainDialogWriteBackCancelGenerations.set(scopeKey, nextGeneration);
+        this.clearWriteBackEntriesForMainDialog(mainDialogId, status);
     }
     static getDialogMetadataPath(dialogId, status) {
         const dialogPath = dialogId.rootId === dialogId.selfId
-            ? this.getRootDialogPath(dialogId, status)
-            : this.getSubdialogPath(dialogId, status);
+            ? this.getMainDialogPath(dialogId, status)
+            : this.getSideDialogPath(dialogId, status);
         return path.join(dialogPath, 'dialog.yaml');
     }
+    static getDialogAskerStackPath(dialogId, status) {
+        const dialogPath = dialogId.rootId === dialogId.selfId
+            ? this.getMainDialogPath(dialogId, status)
+            : this.getSideDialogPath(dialogId, status);
+        return path.join(dialogPath, 'asker-stack.jsonl');
+    }
     static async assertDialogMetadataExistsForAppend(dialogId, status, cancellationToken, phase) {
-        this.assertRootDialogWriteBackNotCanceled(cancellationToken, phase);
+        this.assertMainDialogWriteBackNotCanceled(cancellationToken, phase);
         const metadataPath = this.getDialogMetadataPath(dialogId, status);
         try {
             await fs.promises.access(metadataPath);
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
-                this.assertRootDialogWriteBackNotCanceled(cancellationToken, `${phase}:metadata-missing`);
+                this.assertMainDialogWriteBackNotCanceled(cancellationToken, `${phase}:metadata-missing`);
                 throw new Error(`Refusing to append events for dialog ${dialogId.valueOf()}: missing dialog metadata at ${metadataPath}`);
             }
             throw error;
         }
     }
     static async cleanupCanceledAppendPlaceholder(dialogId, status) {
-        const rootDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
-        const rootPath = this.getRootDialogPath(rootDialogId, status);
+        const mainDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
+        const rootPath = this.getMainDialogPath(mainDialogId, status);
         await fs.promises.rm(rootPath, { recursive: true, force: true });
     }
-    static clonePendingSubdialogRecords(records) {
+    static clonePendingSideDialogRecords(records) {
         return records.map((record) => ({
             ...record,
             mentionList: record.mentionList ? [...record.mentionList] : undefined,
@@ -3866,7 +3997,7 @@ class DialogPersistence {
             ...entry,
         }));
     }
-    static cloneSubdialogResponses(responses) {
+    static cloneSideDialogResponses(responses) {
         return responses.map((response) => ({
             ...response,
             mentionList: response.mentionList ? [...response.mentionList] : undefined,
@@ -3890,30 +4021,30 @@ class DialogPersistence {
         };
         await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
     }
-    static async appendPendingSubdialogsReconciledRecord(dialogId, pendingSubdialogs, writeTarget, status) {
+    static async appendPendingSideDialogsReconciledRecord(dialogId, pendingSideDialogs, writeTarget, status) {
         const record = {
             ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'pending_subdialogs_reconciled_record',
+            type: 'pending_sideDialogs_reconciled_record',
             ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
-            pendingSubdialogs: this.clonePendingSubdialogRecords(pendingSubdialogs),
+            pendingSideDialogs: this.clonePendingSideDialogRecords(pendingSideDialogs),
         };
         await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
     }
-    static async appendSubdialogRegistryReconciledRecord(dialogId, entries, writeTarget, status) {
+    static async appendSideDialogRegistryReconciledRecord(dialogId, entries, writeTarget, status) {
         const record = {
             ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'subdialog_registry_reconciled_record',
+            type: 'sideDialog_registry_reconciled_record',
             ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
             entries: this.cloneRegistryEntries(entries),
         };
         await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
     }
-    static async appendSubdialogResponsesReconciledRecord(dialogId, responses, writeTarget, status) {
+    static async appendSideDialogResponsesReconciledRecord(dialogId, responses, writeTarget, status) {
         const record = {
             ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'subdialog_responses_reconciled_record',
+            type: 'sideDialog_responses_reconciled_record',
             ...cloneRootGenerationAnchor(writeTarget.rootAnchor),
-            responses: this.cloneSubdialogResponses(responses),
+            responses: this.cloneSideDialogResponses(responses),
         };
         await this.appendEvent(dialogId, resolveTargetCourseFromWriteTarget(writeTarget), record, status);
     }
@@ -3926,42 +4057,42 @@ class DialogPersistence {
     /**
      * Get the full path for a dialog directory
      */
-    static getRootDialogPath(dialogId, status = 'running') {
+    static getMainDialogPath(dialogId, status = 'running') {
         if (dialogId.rootId !== dialogId.selfId) {
-            throw new Error('Expected root dialog id');
+            throw new Error('Expected main dialog id');
         }
-        const statusDir = getPersistableStatusDirName(status, 'DialogPersistence.getRootDialogPath');
+        const statusDir = getPersistableStatusDirName(status, 'DialogPersistence.getMainDialogPath');
         return path.join(this.getDialogsRootDir(), statusDir, dialogId.selfId);
     }
     /**
-     * Get the events/state directory for a dialog (composite ID for subdialogs)
+     * Get the events/state directory for a dialog (composite ID for sideDialogs)
      */
     static getDialogEventsPath(dialogId, status = 'running') {
-        // Root dialogs store events under their own directory.
-        // Subdialogs store events under the root's subdialogs/<self> directory.
+        // Main dialogs store events under their own directory.
+        // SideDialogs store events under the root's sideDialogs/<self> directory.
         if (dialogId.rootId === dialogId.selfId) {
-            return this.getRootDialogPath(dialogId, status);
+            return this.getMainDialogPath(dialogId, status);
         }
-        return this.getSubdialogPath(dialogId, status);
+        return this.getSideDialogPath(dialogId, status);
     }
     /**
-     * Get the path for a subdialog within a supdialog
+     * Get the path for a sideDialog within an askerDialog
      */
-    static getSubdialogPath(dialogId, status = 'running') {
+    static getSideDialogPath(dialogId, status = 'running') {
         if (dialogId.rootId === dialogId.selfId) {
-            throw new Error('Expected subdialog id (self differs from root)');
+            throw new Error('Expected sideDialog id (self differs from root)');
         }
-        const rootPath = this.getRootDialogPath(new dialog_1.DialogID(dialogId.rootId), status);
-        return path.join(rootPath, this.SUBDIALOGS_DIR, dialogId.selfId);
+        const rootPath = this.getMainDialogPath(new dialog_1.DialogID(dialogId.rootId), status);
+        return path.join(rootPath, this.SIDE_DIALOGS_DIR, dialogId.selfId);
     }
-    static getMalformedRootDialogPath(dialogId, status) {
+    static getMalformedMainDialogPath(dialogId, status) {
         if (dialogId.rootId !== dialogId.selfId) {
-            throw new Error('Expected root dialog id');
+            throw new Error('Expected main dialog id');
         }
         void status;
         return path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, dialogId.selfId);
     }
-    static inferRootDialogIdFromMetadataRelativeDir(relativeDir) {
+    static inferMainDialogIdFromMetadataRelativeDir(relativeDir) {
         const dir = relativeDir.trim();
         if (dir === '' || dir === '.' || dir === path.sep) {
             return null;
@@ -3970,8 +4101,8 @@ class DialogPersistence {
         if (segments.length === 0) {
             return null;
         }
-        const subdialogsIndex = segments.indexOf(this.SUBDIALOGS_DIR);
-        const rootSegments = subdialogsIndex === -1 ? segments : segments.slice(0, subdialogsIndex);
+        const sideDialogsIndex = segments.indexOf(this.SIDE_DIALOGS_DIR);
+        const rootSegments = sideDialogsIndex === -1 ? segments : segments.slice(0, sideDialogsIndex);
         if (rootSegments.length === 0) {
             return null;
         }
@@ -3986,19 +4117,19 @@ class DialogPersistence {
         if (segments.length === 0) {
             return null;
         }
-        const subdialogsIndex = segments.indexOf(this.SUBDIALOGS_DIR);
-        if (subdialogsIndex === -1) {
+        const sideDialogsIndex = segments.indexOf(this.SIDE_DIALOGS_DIR);
+        if (sideDialogsIndex === -1) {
             return segments.join('/');
         }
-        const subdialogSegments = segments.slice(subdialogsIndex + 1);
-        if (subdialogSegments.length === 0) {
+        const sideDialogSegments = segments.slice(sideDialogsIndex + 1);
+        if (sideDialogSegments.length === 0) {
             return null;
         }
-        return subdialogSegments.join('/');
+        return sideDialogSegments.join('/');
     }
-    static async listSubdialogIdsUnderRoot(rootDialogId, status) {
-        const subdialogsPath = path.join(this.getRootDialogPath(rootDialogId, status), this.SUBDIALOGS_DIR);
-        const subdialogIds = new Set();
+    static async listSideDialogIdsUnderRoot(mainDialogId, status) {
+        const sideDialogsPath = path.join(this.getMainDialogPath(mainDialogId, status), this.SIDE_DIALOGS_DIR);
+        const sideDialogIds = new Set();
         const visit = async (dirPath, relativePath = '') => {
             let entries;
             try {
@@ -4019,11 +4150,11 @@ class DialogPersistence {
                 const dialogYamlPath = path.join(fullPath, 'dialog.yaml');
                 try {
                     await fs.promises.access(dialogYamlPath);
-                    const inferredId = this.inferExpectedDialogIdFromMetadataRelativeDir(path.join(this.SUBDIALOGS_DIR, entryRelativePath));
+                    const inferredId = this.inferExpectedDialogIdFromMetadataRelativeDir(path.join(this.SIDE_DIALOGS_DIR, entryRelativePath));
                     if (!inferredId) {
-                        throw new Error(`Failed to infer subdialog id from relative path ${entryRelativePath} under root ${rootDialogId.selfId}`);
+                        throw new Error(`Failed to infer sideDialog id from relative path ${entryRelativePath} under root ${mainDialogId.selfId}`);
                     }
-                    subdialogIds.add(inferredId);
+                    sideDialogIds.add(inferredId);
                     continue;
                 }
                 catch (error) {
@@ -4034,8 +4165,8 @@ class DialogPersistence {
                 await visit(fullPath, entryRelativePath);
             }
         };
-        await visit(subdialogsPath);
-        return [...subdialogIds];
+        await visit(sideDialogsPath);
+        return [...sideDialogIds];
     }
     static async pathExists(targetPath) {
         try {
@@ -4058,11 +4189,11 @@ class DialogPersistence {
         this.latestWriteBack.delete(key);
         this.latestWriteBackMutexes.delete(key);
     }
-    static clearWriteBackEntriesForRootDialog(rootDialogId, status) {
-        const basePrefix = `${this.getDialogsRootDir()}|${status}|${rootDialogId.selfId}`;
-        const matchesRootDialogKey = (key) => key === basePrefix || key.startsWith(`${basePrefix}#`) || key.startsWith(`${basePrefix}|`);
+    static clearWriteBackEntriesForMainDialog(mainDialogId, status) {
+        const basePrefix = `${this.getDialogsRootDir()}|${status}|${mainDialogId.selfId}`;
+        const matchesMainDialogKey = (key) => key === basePrefix || key.startsWith(`${basePrefix}#`) || key.startsWith(`${basePrefix}|`);
         for (const [key, entry] of this.latestWriteBack.entries()) {
-            if (!matchesRootDialogKey(key))
+            if (!matchesMainDialogKey(key))
                 continue;
             if (entry.kind === 'scheduled') {
                 clearTimeout(entry.timer);
@@ -4070,12 +4201,12 @@ class DialogPersistence {
             this.latestWriteBack.delete(key);
         }
         for (const key of this.latestWriteBackMutexes.keys()) {
-            if (matchesRootDialogKey(key)) {
+            if (matchesMainDialogKey(key)) {
                 this.latestWriteBackMutexes.delete(key);
             }
         }
         for (const [key, entry] of this.q4hWriteBack.entries()) {
-            if (!matchesRootDialogKey(key))
+            if (!matchesMainDialogKey(key))
                 continue;
             if (entry.kind === 'scheduled') {
                 clearTimeout(entry.timer);
@@ -4083,72 +4214,72 @@ class DialogPersistence {
             this.q4hWriteBack.delete(key);
         }
         for (const key of this.q4hWriteBackMutexes.keys()) {
-            if (matchesRootDialogKey(key)) {
+            if (matchesMainDialogKey(key)) {
                 this.q4hWriteBackMutexes.delete(key);
             }
         }
-        for (const [key, entry] of this.pendingSubdialogsWriteBack.entries()) {
-            if (!matchesRootDialogKey(key))
+        for (const [key, entry] of this.pendingSideDialogsWriteBack.entries()) {
+            if (!matchesMainDialogKey(key))
                 continue;
             if (entry.kind === 'scheduled') {
                 clearTimeout(entry.timer);
             }
-            this.pendingSubdialogsWriteBack.delete(key);
+            this.pendingSideDialogsWriteBack.delete(key);
         }
-        for (const key of this.pendingSubdialogsWriteBackMutexes.keys()) {
-            if (matchesRootDialogKey(key)) {
-                this.pendingSubdialogsWriteBackMutexes.delete(key);
+        for (const key of this.pendingSideDialogsWriteBackMutexes.keys()) {
+            if (matchesMainDialogKey(key)) {
+                this.pendingSideDialogsWriteBackMutexes.delete(key);
             }
         }
         for (const key of this.courseAppendMutexes.keys()) {
-            if (matchesRootDialogKey(key)) {
+            if (matchesMainDialogKey(key)) {
                 this.courseAppendMutexes.delete(key);
             }
         }
     }
     static async quarantineMalformedDialog(dialogId, status, reason, error) {
-        const rootDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
-        const quarantineKey = `${status}|${rootDialogId.selfId}`;
-        if (quarantiningRootDialogs.has(quarantineKey)) {
+        const mainDialogId = dialogId.rootId === dialogId.selfId ? dialogId : new dialog_1.DialogID(dialogId.rootId);
+        const quarantineKey = `${status}|${mainDialogId.selfId}`;
+        if (quarantiningMainDialogs.has(quarantineKey)) {
             return;
         }
-        quarantiningRootDialogs.add(quarantineKey);
+        quarantiningMainDialogs.add(quarantineKey);
         let quarantined = false;
         try {
             await prepareDialogQuarantineHook?.({
                 dialogId,
-                rootDialogId,
+                mainDialogId,
                 status,
                 reason,
                 error,
             });
-            this.quarantinedRootDialogScopes.add(this.getRootDialogWriteBackCancelScopeKey(rootDialogId, status));
-            this.cancelRootDialogWriteBacks(rootDialogId, status);
-            const sourcePath = this.getRootDialogPath(rootDialogId, status);
+            this.quarantinedMainDialogScopes.add(this.getMainDialogWriteBackCancelScopeKey(mainDialogId, status));
+            this.cancelMainDialogWriteBacks(mainDialogId, status);
+            const sourcePath = this.getMainDialogPath(mainDialogId, status);
             if (!(await this.pathExists(sourcePath))) {
                 return;
             }
-            let destinationPath = this.getMalformedRootDialogPath(rootDialogId, status);
+            let destinationPath = this.getMalformedMainDialogPath(mainDialogId, status);
             if (await this.pathExists(destinationPath)) {
-                destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${rootDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
+                destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${mainDialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
             }
             await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
             await fs.promises.rename(sourcePath, destinationPath);
             quarantined = true;
-            log_1.log.warn(`Quarantined malformed dialog ${rootDialogId.selfId}`, undefined, {
+            log_1.log.warn(`Quarantined malformed dialog ${mainDialogId.selfId}`, undefined, {
                 status,
                 reason,
                 sourcePath,
                 destinationPath,
                 errorMessage: error.message,
                 dialogId: dialogId.valueOf(),
-                rootDialogId: rootDialogId.valueOf(),
+                mainDialogId: mainDialogId.valueOf(),
             });
             dialogsQuarantinedBroadcaster?.({
                 type: 'dialogs_quarantined',
                 status: 'quarantining',
                 fromStatus: assertPersistableDialogStatus(status, 'DialogPersistence.quarantineMalformedDialog(fromStatus)'),
-                rootId: rootDialogId.selfId,
+                rootId: mainDialogId.selfId,
                 dialogId: dialogId.selfId,
                 reason,
                 timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
@@ -4158,7 +4289,7 @@ class DialogPersistence {
             try {
                 await finalizeDialogQuarantineHook?.({
                     dialogId,
-                    rootDialogId,
+                    mainDialogId,
                     status,
                     reason,
                     error,
@@ -4166,7 +4297,7 @@ class DialogPersistence {
                 });
             }
             finally {
-                quarantiningRootDialogs.delete(quarantineKey);
+                quarantiningMainDialogs.delete(quarantineKey);
             }
         }
     }
@@ -4197,8 +4328,8 @@ class DialogPersistence {
     /**
      * Ensure dialog directory structure exists
      */
-    static async ensureRootDialogDirectory(dialogId, status = 'running') {
-        const dialogPath = this.getRootDialogPath(dialogId, status);
+    static async ensureMainDialogDirectory(dialogId, status = 'running') {
+        const dialogPath = this.getMainDialogPath(dialogId, status);
         try {
             await fs.promises.mkdir(dialogPath, { recursive: true });
             return dialogPath;
@@ -4209,16 +4340,16 @@ class DialogPersistence {
         }
     }
     /**
-     * Ensure subdialog directory structure exists
+     * Ensure sideDialog directory structure exists
      */
-    static async ensureSubdialogDirectory(dialogId, status = 'running') {
-        const subdialogPath = this.getSubdialogPath(dialogId, status);
+    static async ensureSideDialogDirectory(dialogId, status = 'running') {
+        const sideDialogPath = this.getSideDialogPath(dialogId, status);
         try {
-            await fs.promises.mkdir(subdialogPath, { recursive: true });
-            return subdialogPath;
+            await fs.promises.mkdir(sideDialogPath, { recursive: true });
+            return sideDialogPath;
         }
         catch (error) {
-            log_1.log.error(`Failed to create subdialog directory ${subdialogPath}:`, error);
+            log_1.log.error(`Failed to create sideDialog directory ${sideDialogPath}:`, error);
             throw error;
         }
     }
@@ -4227,8 +4358,8 @@ class DialogPersistence {
      */
     static async markDialogCompleted(dialogId) {
         try {
-            const dialogPath = this.getRootDialogPath(dialogId, 'running');
-            const completedPath = this.getRootDialogPath(dialogId, 'completed');
+            const dialogPath = this.getMainDialogPath(dialogId, 'running');
+            const completedPath = this.getMainDialogPath(dialogId, 'completed');
             await fs.promises.mkdir(completedPath, { recursive: true });
             // Move files from current to completed
             const files = await fs.promises.readdir(dialogPath);
@@ -4244,7 +4375,7 @@ class DialogPersistence {
         }
     }
     /**
-     * List candidate root dialog IDs by scanning `dialog.yaml`.
+     * List candidate main dialog IDs by scanning `dialog.yaml`.
      *
      * This scanner intentionally stays lightweight: it only validates the path<->id identity needed
      * for safe enumeration, and leaves full metadata shape validation to the subsequent lazy-load
@@ -4301,9 +4432,9 @@ class DialogPersistence {
                             catch (yamlError) {
                                 const persistenceError = (0, persistence_errors_1.findDomindsPersistenceFileError)(yamlError);
                                 if (persistenceError) {
-                                    const rootDialogId = this.inferRootDialogIdFromMetadataRelativeDir(path.dirname(entryRelativePath));
-                                    if (rootDialogId) {
-                                        await this.quarantineMalformedDialog(rootDialogId, status, 'listDialogs', persistenceError);
+                                    const mainDialogId = this.inferMainDialogIdFromMetadataRelativeDir(path.dirname(entryRelativePath));
+                                    if (mainDialogId) {
+                                        await this.quarantineMalformedDialog(mainDialogId, status, 'listDialogs', persistenceError);
                                     }
                                 }
                                 log_1.log.warn(`🔍 listDialogs: Failed to parse dialog.yaml at ${fullPath}:`, yamlError);
@@ -4347,8 +4478,8 @@ class DialogPersistence {
         }
     }
     /**
-     * List all dialog IDs (root + subdialogs) together with their root IDs.
-     * This is the only safe way to enumerate subdialogs because their directory names
+     * List all dialog IDs (main dialogs + sideDialogs) together with their root IDs.
+     * This is the only safe way to enumerate sideDialogs because their directory names
      * are not guaranteed to be their selfId.
      *
      * Like `listDialogs()`, this is a candidate scanner rather than a full metadata validator.
@@ -4359,9 +4490,9 @@ class DialogPersistence {
         const statusDir = this.getDialogsRootDir();
         const specificDir = path.join(statusDir, getPersistableStatusDirName(status, 'DialogPersistence.listAllDialogIds'));
         const result = [];
-        const rootDialogIdByDialogYamlPath = new Map();
+        const mainDialogIdByDialogYamlPath = new Map();
         const readDialogYamlId = async (dialogYamlPath) => {
-            const cached = rootDialogIdByDialogYamlPath.get(dialogYamlPath);
+            const cached = mainDialogIdByDialogYamlPath.get(dialogYamlPath);
             if (cached !== undefined)
                 return cached;
             try {
@@ -4391,19 +4522,19 @@ class DialogPersistence {
                     });
                 }
                 const normalized = idValue.trim();
-                rootDialogIdByDialogYamlPath.set(dialogYamlPath, normalized);
+                mainDialogIdByDialogYamlPath.set(dialogYamlPath, normalized);
                 return normalized;
             }
             catch (error) {
                 const persistenceError = (0, persistence_errors_1.findDomindsPersistenceFileError)(error);
                 if (persistenceError) {
                     const relativeDir = path.relative(specificDir, path.dirname(dialogYamlPath));
-                    const rootDialogId = this.inferRootDialogIdFromMetadataRelativeDir(relativeDir);
-                    if (rootDialogId) {
-                        await this.quarantineMalformedDialog(rootDialogId, status, 'listAllDialogIds:readDialogYamlId', persistenceError);
+                    const mainDialogId = this.inferMainDialogIdFromMetadataRelativeDir(relativeDir);
+                    if (mainDialogId) {
+                        await this.quarantineMalformedDialog(mainDialogId, status, 'listAllDialogIds:readDialogYamlId', persistenceError);
                     }
                 }
-                rootDialogIdByDialogYamlPath.set(dialogYamlPath, null);
+                mainDialogIdByDialogYamlPath.set(dialogYamlPath, null);
                 return null;
             }
         };
@@ -4414,11 +4545,11 @@ class DialogPersistence {
             const segments = dir.split(path.sep).filter((seg) => seg.length > 0 && seg !== '.');
             if (segments.length === 0)
                 return null;
-            // Root dialog IDs in this repo can contain path separators (e.g. "f4/44/cd85c4e2").
-            // The root dialog directory is therefore nested (RUN_DIR/<rootId>/dialog.yaml).
+            // Main dialog IDs in this repo can contain path separators (e.g. "f4/44/cd85c4e2").
+            // The main dialog directory is therefore nested (RUN_DIR/<rootId>/dialog.yaml).
             //
-            // To infer the rootId for any dialog.yaml we find (root or subdialog), scan prefixes of the
-            // directory path and pick the first prefix that is itself a valid root dialog directory:
+            // To infer the rootId for any dialog.yaml we find (main dialog or sideDialog), scan prefixes of the
+            // directory path and pick the first prefix that is itself a valid main dialog directory:
             // - it has a dialog.yaml
             // - its dialog.yaml id matches the prefix joined with '/'
             for (let i = 1; i <= segments.length; i++) {
@@ -4495,9 +4626,9 @@ class DialogPersistence {
                 catch (yamlError) {
                     const persistenceError = (0, persistence_errors_1.findDomindsPersistenceFileError)(yamlError);
                     if (persistenceError) {
-                        const rootDialogId = this.inferRootDialogIdFromMetadataRelativeDir(relDir);
-                        if (rootDialogId) {
-                            await this.quarantineMalformedDialog(rootDialogId, status, 'listAllDialogIds', persistenceError);
+                        const mainDialogId = this.inferMainDialogIdFromMetadataRelativeDir(relDir);
+                        if (mainDialogId) {
+                            await this.quarantineMalformedDialog(mainDialogId, status, 'listAllDialogIds', persistenceError);
                         }
                     }
                     log_1.log.warn(`🔍 listAllDialogIds: Failed to parse dialog.yaml at ${fullPath}:`, yamlError);
@@ -4525,7 +4656,7 @@ class DialogPersistence {
     static async appendEvents(dialogId, course, events, status = 'running') {
         const appendMutexKey = this.getCourseAppendMutexKey(dialogId, course, status);
         const release = await this.getCourseAppendMutex(appendMutexKey).acquire();
-        const cancellationToken = this.createRootDialogWriteBackCancellationToken(dialogId, status);
+        const cancellationToken = this.createMainDialogWriteBackCancellationToken(dialogId, status);
         try {
             if (events.length === 0) {
                 return;
@@ -5021,7 +5152,7 @@ class DialogPersistence {
                 if (entry.kind !== 'scheduled')
                     return;
                 clearTimeout(entry.timer);
-                const cancellationToken = this.createRootDialogWriteBackCancellationToken(entry.dialogId, entry.status);
+                const cancellationToken = this.createMainDialogWriteBackCancellationToken(entry.dialogId, entry.status);
                 const inFlight = this.writeQ4HStateToDisk(entry.dialogId, entry.state, entry.status, cancellationToken);
                 captured = {
                     dialogId: entry.dialogId,
@@ -5107,7 +5238,7 @@ class DialogPersistence {
     }
     static async writeQ4HStateToDisk(dialogId, state, status, cancellationToken) {
         if (cancellationToken) {
-            this.assertRootDialogWriteBackNotCanceled(cancellationToken, 'writeQ4HStateToDisk:start');
+            this.assertMainDialogWriteBackNotCanceled(cancellationToken, 'writeQ4HStateToDisk:start');
         }
         const dialogPath = this.getDialogEventsPath(dialogId, status);
         const questionsFilePath = path.join(dialogPath, 'q4h.yaml');
@@ -5132,7 +5263,7 @@ class DialogPersistence {
      */
     static async loadAllQ4HState() {
         try {
-            // Get all running dialogs (root + subdialogs) with correct rootId association.
+            // Get all running dialogs (main dialogs + sideDialogs) with correct rootId association.
             const dialogIds = await this.listAllDialogIds('running');
             const allQuestions = [];
             for (const dialogIdObj of dialogIds) {
@@ -5183,36 +5314,35 @@ class DialogPersistence {
             log_1.log.error(`Failed to clear q4h.yaml for dialog ${dialogId}:`, error);
         }
     }
-    // === PHASE 6: SUBDIALOG SUPPLY PERSISTENCE ===
+    // === PHASE 6: SIDE DIALOG PENDING PERSISTENCE ===
     /**
-     * Save pending subdialogs for Type A supply mechanism.
-     * Tracks subdialogs that were created but not yet completed.
+     * Save pending sideDialogs that have an outstanding tellask/reply delivery.
      */
-    static async savePendingSubdialogs(rootDialogId, pendingSubdialogs, rootAnchor, status = 'running') {
-        const next = pendingSubdialogs.map((r) => ({ ...r }));
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'replace', records: next }), rootAnchor, status);
+    static async savePendingSideDialogs(mainDialogId, pendingSideDialogs, rootAnchor, status = 'running') {
+        const next = pendingSideDialogs.map((r) => ({ ...r }));
+        await this.mutatePendingSideDialogs(mainDialogId, () => ({ kind: 'replace', records: next }), rootAnchor, status);
     }
     /**
-     * Load pending subdialogs for Type A supply mechanism.
+     * Load pending sideDialogs that have an outstanding tellask/reply delivery.
      */
-    static async loadPendingSubdialogs(rootDialogId, status = 'running') {
-        const key = this.getPendingSubdialogsWriteBackKey(rootDialogId, status);
-        const staged = this.pendingSubdialogsWriteBack.get(key);
+    static async loadPendingSideDialogs(mainDialogId, status = 'running') {
+        const key = this.getPendingSideDialogsWriteBackKey(mainDialogId, status);
+        const staged = this.pendingSideDialogsWriteBack.get(key);
         if (staged) {
             return staged.state.kind === 'deleted' ? [] : staged.state.records;
         }
         try {
-            return await this.loadPendingSubdialogsFromDisk(rootDialogId, status);
+            return await this.loadPendingSideDialogsFromDisk(mainDialogId, status);
         }
         catch (error) {
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(rootDialogId, status, 'loadPendingSubdialogs', error);
-            throw new Error('unreachable after loadPendingSubdialogs persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(mainDialogId, status, 'loadPendingSideDialogs', error);
+            throw new Error('unreachable after loadPendingSideDialogs persistence rethrow');
         }
     }
-    static isPendingSubdialogRecord(value) {
+    static isPendingSideDialogRecord(value) {
         if (!isRecord(value))
             return false;
-        if (typeof value.subdialogId !== 'string')
+        if (typeof value.sideDialogId !== 'string')
             return false;
         if (typeof value.createdAt !== 'string')
             return false;
@@ -5242,28 +5372,18 @@ class DialogPersistence {
             return false;
         if (typeof value.callId !== 'string')
             return false;
-        if ('callingCourse' in value) {
-            const callingCourse = value.callingCourse;
-            if (callingCourse !== undefined) {
-                if (typeof callingCourse !== 'number')
-                    return false;
-                if (!Number.isFinite(callingCourse))
-                    return false;
-                if (Math.floor(callingCourse) <= 0)
-                    return false;
-            }
-        }
-        if ('callingGenseq' in value) {
-            const callingGenseq = value.callingGenseq;
-            if (callingGenseq !== undefined) {
-                if (typeof callingGenseq !== 'number')
-                    return false;
-                if (!Number.isFinite(callingGenseq))
-                    return false;
-                if (Math.floor(callingGenseq) <= 0)
-                    return false;
-            }
-        }
+        if (typeof value.callSiteCourse !== 'number')
+            return false;
+        if (!Number.isInteger(value.callSiteCourse))
+            return false;
+        if (value.callSiteCourse <= 0)
+            return false;
+        if (typeof value.callSiteGenseq !== 'number')
+            return false;
+        if (!Number.isInteger(value.callSiteGenseq))
+            return false;
+        if (value.callSiteGenseq <= 0)
+            return false;
         if (value.callType !== 'A' && value.callType !== 'B' && value.callType !== 'C')
             return false;
         if ('sessionSlug' in value) {
@@ -5273,27 +5393,56 @@ class DialogPersistence {
         }
         return true;
     }
-    static async loadPendingSubdialogsFromDisk(rootDialogId, status) {
-        const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
-        const filePath = path.join(dialogPath, 'pending-subdialogs.json');
+    static assertNoDuplicateSessionedTellaskPendingRecords(records, context) {
+        const seen = new Map();
+        for (const record of records) {
+            if (record.callType !== 'B')
+                continue;
+            if (record.callName !== 'tellask')
+                continue;
+            if (record.sessionSlug === undefined)
+                continue;
+            const sessionSlug = record.sessionSlug.trim();
+            if (sessionSlug === '')
+                continue;
+            const key = `${record.targetAgentId}\0${sessionSlug}`;
+            const previous = seen.get(key);
+            if (previous) {
+                throw new Error(`pending-sideDialogs invariant violation: duplicate sessioned tellask pending record ` +
+                    `(rootId=${context.rootId}, selfId=${context.selfId}, status=${context.status}, ` +
+                    `targetAgentId=${record.targetAgentId}, sessionSlug=${sessionSlug}, ` +
+                    `previousSideDialogId=${previous.sideDialogId}, previousCallId=${previous.callId}, ` +
+                    `duplicateSideDialogId=${record.sideDialogId}, duplicateCallId=${record.callId})`);
+            }
+            seen.set(key, record);
+        }
+    }
+    static async loadPendingSideDialogsFromDisk(mainDialogId, status) {
+        const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
+        const filePath = path.join(dialogPath, 'pending-sideDialogs.json');
         try {
             const content = await readPersistenceTextFile({
                 filePath,
-                source: 'pending_subdialogs',
+                source: 'pending_sideDialogs',
                 format: 'json',
             });
             const parsed = parsePersistenceJson({
                 content,
                 filePath,
-                source: 'pending_subdialogs',
+                source: 'pending_sideDialogs',
             });
-            if (!Array.isArray(parsed) || !parsed.every((item) => this.isPendingSubdialogRecord(item))) {
+            if (!Array.isArray(parsed) || !parsed.every((item) => this.isPendingSideDialogRecord(item))) {
                 throw buildInvalidPersistenceFileError({
-                    source: 'pending_subdialogs',
+                    source: 'pending_sideDialogs',
                     format: 'json',
                     filePath,
                 });
             }
+            this.assertNoDuplicateSessionedTellaskPendingRecords(parsed, {
+                rootId: mainDialogId.rootId,
+                selfId: mainDialogId.selfId,
+                status,
+            });
             return parsed;
         }
         catch (error) {
@@ -5302,17 +5451,17 @@ class DialogPersistence {
             throw error;
         }
     }
-    static async mutatePendingSubdialogs(rootDialogId, mutator, rootAnchor, status = 'running') {
-        const key = this.getPendingSubdialogsWriteBackKey(rootDialogId, status);
-        const mutex = this.getPendingSubdialogsWriteBackMutex(key);
+    static async mutatePendingSideDialogs(mainDialogId, mutator, rootAnchor, status = 'running') {
+        const key = this.getPendingSideDialogsWriteBackKey(mainDialogId, status);
+        const mutex = this.getPendingSideDialogsWriteBackMutex(key);
         const release = await mutex.acquire();
         try {
-            const staged = this.pendingSubdialogsWriteBack.get(key);
+            const staged = this.pendingSideDialogsWriteBack.get(key);
             const previousRecords = staged && staged.state.kind === 'file'
                 ? staged.state.records
                 : staged && staged.state.kind === 'deleted'
                     ? []
-                    : await this.loadPendingSubdialogsFromDisk(rootDialogId, status);
+                    : await this.loadPendingSideDialogsFromDisk(mainDialogId, status);
             const mutation = mutator(previousRecords);
             let nextRecords = previousRecords;
             const removedRecords = [];
@@ -5322,20 +5471,20 @@ class DialogPersistence {
             else if (mutation.kind === 'append') {
                 nextRecords = [...previousRecords, mutation.record];
             }
-            else if (mutation.kind === 'removeBySubdialogId') {
+            else if (mutation.kind === 'removeBySideDialogId') {
                 for (const r of previousRecords) {
-                    if (r.subdialogId === mutation.subdialogId)
+                    if (r.sideDialogId === mutation.sideDialogId)
                         removedRecords.push(r);
                 }
-                nextRecords = previousRecords.filter((r) => r.subdialogId !== mutation.subdialogId);
+                nextRecords = previousRecords.filter((r) => r.sideDialogId !== mutation.sideDialogId);
             }
-            else if (mutation.kind === 'removeBySubdialogIds') {
-                const remove = new Set(mutation.subdialogIds);
+            else if (mutation.kind === 'removeBySideDialogIds') {
+                const remove = new Set(mutation.sideDialogIds);
                 for (const r of previousRecords) {
-                    if (remove.has(r.subdialogId))
+                    if (remove.has(r.sideDialogId))
                         removedRecords.push(r);
                 }
-                nextRecords = previousRecords.filter((r) => !remove.has(r.subdialogId));
+                nextRecords = previousRecords.filter((r) => !remove.has(r.sideDialogId));
             }
             else if (mutation.kind === 'replace') {
                 nextRecords = [...mutation.records];
@@ -5346,17 +5495,28 @@ class DialogPersistence {
             }
             else {
                 const _exhaustive = mutation;
-                throw new Error(`Unhandled pending-subdialogs mutation: ${String(_exhaustive)}`);
+                throw new Error(`Unhandled pending-sideDialogs mutation: ${String(_exhaustive)}`);
+            }
+            for (let index = 0; index < nextRecords.length; index += 1) {
+                if (!this.isPendingSideDialogRecord(nextRecords[index])) {
+                    throw new Error(`pending-sideDialogs write invariant violation: malformed record at index ${index} ` +
+                        `(rootId=${mainDialogId.rootId}, selfId=${mainDialogId.selfId}, status=${status})`);
+                }
             }
+            this.assertNoDuplicateSessionedTellaskPendingRecords(nextRecords, {
+                rootId: mainDialogId.rootId,
+                selfId: mainDialogId.selfId,
+                status,
+            });
             const nextState = nextRecords.length === 0 ? { kind: 'deleted' } : { kind: 'file', records: nextRecords };
-            const pending = this.pendingSubdialogsWriteBack.get(key);
+            const pending = this.pendingSideDialogsWriteBack.get(key);
             if (!pending) {
                 const timer = setTimeout(() => {
-                    void this.flushPendingSubdialogsWriteBack(key);
-                }, this.PENDING_SUBDIALOGS_WRITEBACK_WINDOW_MS);
-                this.pendingSubdialogsWriteBack.set(key, {
+                    void this.flushPendingSideDialogsWriteBack(key);
+                }, this.PENDING_SIDE_DIALOGS_WRITEBACK_WINDOW_MS);
+                this.pendingSideDialogsWriteBack.set(key, {
                     kind: 'scheduled',
-                    dialogId: rootDialogId,
+                    dialogId: mainDialogId,
                     status,
                     state: nextState,
                     timer,
@@ -5368,7 +5528,7 @@ class DialogPersistence {
                     pending.dirty = true;
             }
             if (rootAnchor) {
-                await this.appendPendingSubdialogsReconciledRecord(rootDialogId, nextRecords, rootAnchorWriteTarget(rootAnchor), status);
+                await this.appendPendingSideDialogsReconciledRecord(mainDialogId, nextRecords, rootAnchorWriteTarget(rootAnchor), status);
             }
             return { previousRecords, records: nextRecords, removedRecords };
         }
@@ -5376,22 +5536,22 @@ class DialogPersistence {
             release();
         }
     }
-    static async appendPendingSubdialog(rootDialogId, record, rootAnchor, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'append', record }), rootAnchor, status);
+    static async appendPendingSideDialog(mainDialogId, record, rootAnchor, status = 'running') {
+        await this.mutatePendingSideDialogs(mainDialogId, () => ({ kind: 'append', record }), rootAnchor, status);
     }
-    static async removePendingSubdialog(rootDialogId, subdialogId, rootAnchor, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'removeBySubdialogId', subdialogId }), rootAnchor, status);
+    static async removePendingSideDialog(mainDialogId, sideDialogId, rootAnchor, status = 'running') {
+        await this.mutatePendingSideDialogs(mainDialogId, () => ({ kind: 'removeBySideDialogId', sideDialogId }), rootAnchor, status);
     }
-    static async clearPendingSubdialogs(rootDialogId, rootAnchor, status = 'running') {
-        await this.mutatePendingSubdialogs(rootDialogId, () => ({ kind: 'clear' }), rootAnchor, status);
+    static async clearPendingSideDialogs(mainDialogId, rootAnchor, status = 'running') {
+        await this.mutatePendingSideDialogs(mainDialogId, () => ({ kind: 'clear' }), rootAnchor, status);
     }
-    static async flushPendingSubdialogsWriteBack(key) {
-        const mutex = this.getPendingSubdialogsWriteBackMutex(key);
+    static async flushPendingSideDialogsWriteBack(key) {
+        const mutex = this.getPendingSideDialogsWriteBackMutex(key);
         let captured;
         {
             const release = await mutex.acquire();
             try {
-                const entry = this.pendingSubdialogsWriteBack.get(key);
+                const entry = this.pendingSideDialogsWriteBack.get(key);
                 if (!entry)
                     return;
                 if (entry.kind === 'flushing')
@@ -5399,15 +5559,15 @@ class DialogPersistence {
                 if (entry.kind !== 'scheduled')
                     return;
                 clearTimeout(entry.timer);
-                const cancellationToken = this.createRootDialogWriteBackCancellationToken(entry.dialogId, entry.status);
-                const inFlight = this.writePendingSubdialogsToDisk(entry.dialogId, entry.state, entry.status, cancellationToken);
+                const cancellationToken = this.createMainDialogWriteBackCancellationToken(entry.dialogId, entry.status);
+                const inFlight = this.writePendingSideDialogsToDisk(entry.dialogId, entry.state, entry.status, cancellationToken);
                 captured = {
                     dialogId: entry.dialogId,
                     status: entry.status,
                     stateToWrite: entry.state,
                     inFlight,
                 };
-                this.pendingSubdialogsWriteBack.set(key, {
+                this.pendingSideDialogsWriteBack.set(key, {
                     kind: 'flushing',
                     dialogId: entry.dialogId,
                     status: entry.status,
@@ -5428,7 +5588,7 @@ class DialogPersistence {
         catch (error) {
             const release = await mutex.acquire();
             try {
-                const entry = this.pendingSubdialogsWriteBack.get(key);
+                const entry = this.pendingSideDialogsWriteBack.get(key);
                 if (!entry)
                     return;
                 if (entry.kind !== 'flushing')
@@ -5436,13 +5596,13 @@ class DialogPersistence {
                 if (entry.inFlight !== captured.inFlight)
                     return;
                 if (isDialogWriteBackCanceledError(error)) {
-                    this.pendingSubdialogsWriteBack.delete(key);
+                    this.pendingSideDialogsWriteBack.delete(key);
                     return;
                 }
                 const timer = setTimeout(() => {
-                    void this.flushPendingSubdialogsWriteBack(key);
-                }, this.PENDING_SUBDIALOGS_WRITEBACK_WINDOW_MS);
-                this.pendingSubdialogsWriteBack.set(key, {
+                    void this.flushPendingSideDialogsWriteBack(key);
+                }, this.PENDING_SIDE_DIALOGS_WRITEBACK_WINDOW_MS);
+                this.pendingSideDialogsWriteBack.set(key, {
                     kind: 'scheduled',
                     dialogId: entry.dialogId,
                     status: entry.status,
@@ -5457,7 +5617,7 @@ class DialogPersistence {
         }
         const release = await mutex.acquire();
         try {
-            const entry = this.pendingSubdialogsWriteBack.get(key);
+            const entry = this.pendingSideDialogsWriteBack.get(key);
             if (!entry)
                 return;
             if (entry.kind !== 'flushing')
@@ -5465,13 +5625,13 @@ class DialogPersistence {
             if (entry.inFlight !== captured.inFlight)
                 return;
             if (!entry.dirty) {
-                this.pendingSubdialogsWriteBack.delete(key);
+                this.pendingSideDialogsWriteBack.delete(key);
                 return;
             }
             const timer = setTimeout(() => {
-                void this.flushPendingSubdialogsWriteBack(key);
-            }, this.PENDING_SUBDIALOGS_WRITEBACK_WINDOW_MS);
-            this.pendingSubdialogsWriteBack.set(key, {
+                void this.flushPendingSideDialogsWriteBack(key);
+            }, this.PENDING_SIDE_DIALOGS_WRITEBACK_WINDOW_MS);
+            this.pendingSideDialogsWriteBack.set(key, {
                 kind: 'scheduled',
                 dialogId: entry.dialogId,
                 status: entry.status,
@@ -5483,12 +5643,12 @@ class DialogPersistence {
             release();
         }
     }
-    static async writePendingSubdialogsToDisk(rootDialogId, state, status, cancellationToken) {
+    static async writePendingSideDialogsToDisk(mainDialogId, state, status, cancellationToken) {
         if (cancellationToken) {
-            this.assertRootDialogWriteBackNotCanceled(cancellationToken, 'writePendingSubdialogsToDisk:start');
+            this.assertMainDialogWriteBackNotCanceled(cancellationToken, 'writePendingSideDialogsToDisk:start');
         }
-        const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
-        const filePath = path.join(dialogPath, 'pending-subdialogs.json');
+        const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
+        const filePath = path.join(dialogPath, 'pending-sideDialogs.json');
         if (state.kind === 'deleted') {
             await fs.promises.rm(filePath, { force: true });
             return;
@@ -5499,75 +5659,75 @@ class DialogPersistence {
             await fs.promises.writeFile(tempFile, jsonContent, 'utf-8');
         }
         catch (error) {
-            await this.rethrowWriteBackPathMissingAsCanceled(error, dialogPath, cancellationToken, 'writePendingSubdialogsToDisk:write-temp');
+            await this.rethrowWriteBackPathMissingAsCanceled(error, dialogPath, cancellationToken, 'writePendingSideDialogsToDisk:write-temp');
             throw error;
         }
         await this.renameWithRetry(tempFile, filePath, 5, cancellationToken);
     }
     /**
-     * Get the path for storing subdialog responses (supports both root and subdialog parents).
-     * For Type C subdialogs created inside another subdialog, responses are stored at the parent's level.
+     * Get the path for storing sideDialog responses (supports both main dialog and sideDialog tellaskers).
+     * For Type C sideDialogs created inside another sideDialog, responses are stored at the parent's level.
      */
     static getDialogResponsesPath(dialogId, status = 'running') {
-        // Root dialogs store responses in their own directory.
-        // Subdialogs store responses in the parent's location (root or subdialog).
+        // Main dialogs store responses in their own directory.
+        // SideDialogs store responses in the tellasker's location (main dialog or sideDialog).
         if (dialogId.rootId === dialogId.selfId) {
-            // Root dialog: use root's directory
-            return this.getRootDialogPath(dialogId, status);
+            // Main dialog: use root's directory
+            return this.getMainDialogPath(dialogId, status);
         }
-        // Subdialog: store in parent's subdialogs directory
-        // The parent is always identified by rootId (could be root or parent subdialog)
+        // SideDialog: store in parent's sideDialogs directory
+        // The parent is always identified by rootId (could be root or parent sideDialog)
         const parentSelfId = dialogId.rootId;
-        const rootPath = this.getRootDialogPath(new dialog_1.DialogID(parentSelfId), status);
-        return path.join(rootPath, this.SUBDIALOGS_DIR, dialogId.selfId);
+        const rootPath = this.getMainDialogPath(new dialog_1.DialogID(parentSelfId), status);
+        return path.join(rootPath, this.SIDE_DIALOGS_DIR, dialogId.selfId);
     }
     /**
-     * Save subdialog responses for Type A supply mechanism.
-     * Tracks responses from completed subdialogs.
+     * Save responses delivered back from completed sideDialogs.
      */
-    static async saveSubdialogResponses(rootDialogId, responses, rootAnchor, status = 'running') {
+    static async saveSideDialogResponses(mainDialogId, responses, rootAnchor, status = 'running') {
         try {
-            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
-            const filePath = path.join(dialogPath, 'subdialog-responses.json');
+            assertUniqueSideDialogResponseIds(responses, `save rootId=${mainDialogId.rootId}`);
+            const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
+            const filePath = path.join(dialogPath, 'sideDialog-responses.json');
             // Atomic write operation
             const jsonContent = JSON.stringify(responses, null, 2);
             const tempFile = path.join(dialogPath, `.${path.basename(filePath)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
             await fs.promises.writeFile(tempFile, jsonContent, 'utf-8');
             await this.renameWithRetry(tempFile, filePath);
             if (rootAnchor) {
-                await this.appendSubdialogResponsesReconciledRecord(rootDialogId, responses, rootAnchorWriteTarget(rootAnchor), status);
+                await this.appendSideDialogResponsesReconciledRecord(mainDialogId, responses, rootAnchorWriteTarget(rootAnchor), status);
             }
         }
         catch (error) {
-            log_1.log.error(`Failed to save subdialog responses for dialog ${rootDialogId}:`, error);
+            log_1.log.error(`Failed to save sideDialog responses for dialog ${mainDialogId}:`, error);
             throw error;
         }
     }
     /**
-     * Load subdialog responses for Type A supply mechanism.
+     * Load responses delivered back from completed sideDialogs.
      */
-    static async loadSubdialogResponses(rootDialogId, status = 'running') {
+    static async loadSideDialogResponses(mainDialogId, status = 'running') {
         try {
-            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
-            const filePath = path.join(dialogPath, 'subdialog-responses.json');
-            const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+            const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
+            const filePath = path.join(dialogPath, 'sideDialog-responses.json');
+            const inflightPath = path.join(dialogPath, 'sideDialog-responses.processing.json');
             try {
                 const results = [];
                 const tryReadArray = async (p) => {
                     try {
                         const content = await readPersistenceTextFile({
                             filePath: p,
-                            source: 'subdialog_responses',
+                            source: 'sideDialog_responses',
                             format: 'json',
                         });
                         const parsed = parsePersistenceJson({
                             content,
                             filePath: p,
-                            source: 'subdialog_responses',
+                            source: 'sideDialog_responses',
                         });
                         if (!Array.isArray(parsed)) {
                             throw buildInvalidPersistenceFileError({
-                                source: 'subdialog_responses',
+                                source: 'sideDialog_responses',
                                 format: 'json',
                                 filePath: p,
                             });
@@ -5584,21 +5744,17 @@ class DialogPersistence {
                 const primary = await tryReadArray(filePath);
                 const inflight = await tryReadArray(inflightPath);
                 for (const item of [...primary, ...inflight]) {
-                    if (!isSubdialogResponseRecord(item)) {
+                    if (!isSideDialogResponseRecord(item)) {
                         throw buildInvalidPersistenceFileError({
-                            source: 'subdialog_responses',
+                            source: 'sideDialog_responses',
                             format: 'json',
                             filePath,
                         });
                     }
                     results.push(item);
                 }
-                // Deduplicate by responseId (primary wins over inflight order is irrelevant)
-                const byId = new Map();
-                for (const r of results) {
-                    byId.set(r.responseId, r);
-                }
-                return Array.from(byId.values());
+                assertUniqueSideDialogResponseIds(results, `load rootId=${mainDialogId.rootId} status=${status}`);
+                return results;
             }
             catch (error) {
                 if (getErrorCode(error) === 'ENOENT') {
@@ -5608,51 +5764,52 @@ class DialogPersistence {
             }
         }
         catch (error) {
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(rootDialogId, status, 'loadSubdialogResponses', error);
-            throw new Error('unreachable after loadSubdialogResponses persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(mainDialogId, status, 'loadSideDialogResponses', error);
+            throw new Error('unreachable after loadSideDialogResponses persistence rethrow');
         }
     }
-    static async loadSubdialogResponsesQueue(dialogId, status = 'running') {
+    static async loadSideDialogResponsesQueue(dialogId, status = 'running') {
         try {
             const dialogPath = this.getDialogResponsesPath(dialogId, status);
-            const filePath = path.join(dialogPath, 'subdialog-responses.json');
+            const filePath = path.join(dialogPath, 'sideDialog-responses.json');
             const content = await readPersistenceTextFile({
                 filePath,
-                source: 'subdialog_responses',
+                source: 'sideDialog_responses',
                 format: 'json',
             });
             const parsed = parsePersistenceJson({
                 content,
                 filePath,
-                source: 'subdialog_responses',
+                source: 'sideDialog_responses',
             });
-            if (!Array.isArray(parsed) || !parsed.every((item) => isSubdialogResponseRecord(item))) {
+            if (!Array.isArray(parsed) || !parsed.every((item) => isSideDialogResponseRecord(item))) {
                 throw buildInvalidPersistenceFileError({
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                     format: 'json',
                     filePath,
                 });
             }
+            assertUniqueSideDialogResponseIds(parsed, `load queue rootId=${dialogId.rootId} selfId=${dialogId.selfId} status=${status}`);
             return parsed;
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
                 return [];
             }
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadSubdialogResponsesQueue', error);
-            throw new Error('unreachable after loadSubdialogResponsesQueue persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadSideDialogResponsesQueue', error);
+            throw new Error('unreachable after loadSideDialogResponsesQueue persistence rethrow');
         }
     }
-    static async appendSubdialogResponse(dialogId, response, rootAnchor, status = 'running') {
-        const existing = await this.loadSubdialogResponsesQueue(dialogId, status);
+    static async appendSideDialogResponse(dialogId, response, rootAnchor, status = 'running') {
+        const existing = await this.loadSideDialogResponsesQueue(dialogId, status);
         existing.push(response);
-        await this.saveSubdialogResponses(dialogId, existing, rootAnchor, status);
+        await this.saveSideDialogResponses(dialogId, existing, rootAnchor, status);
     }
-    static async takeSubdialogResponses(dialogId, status = 'running') {
+    static async takeSideDialogResponses(dialogId, status = 'running') {
         try {
             const dialogPath = this.getDialogResponsesPath(dialogId, status);
-            const filePath = path.join(dialogPath, 'subdialog-responses.json');
-            const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+            const filePath = path.join(dialogPath, 'sideDialog-responses.json');
+            const inflightPath = path.join(dialogPath, 'sideDialog-responses.processing.json');
             // If a previous processing file exists, merge it back so it will be re-processed.
             try {
                 await fs.promises.access(inflightPath);
@@ -5663,7 +5820,7 @@ class DialogPersistence {
                 }
             }
             if (await this.pathExists(inflightPath)) {
-                await this.rollbackTakenSubdialogResponses(dialogId, status);
+                await this.rollbackTakenSideDialogResponses(dialogId, status);
             }
             try {
                 await fs.promises.rename(filePath, inflightPath);
@@ -5676,56 +5833,57 @@ class DialogPersistence {
             }
             const raw = await readPersistenceTextFile({
                 filePath: inflightPath,
-                source: 'subdialog_responses',
+                source: 'sideDialog_responses',
                 format: 'json',
             });
             const parsed = parsePersistenceJson({
                 content: raw,
                 filePath: inflightPath,
-                source: 'subdialog_responses',
+                source: 'sideDialog_responses',
             });
-            if (!Array.isArray(parsed) || !parsed.every((item) => isSubdialogResponseRecord(item))) {
+            if (!Array.isArray(parsed) || !parsed.every((item) => isSideDialogResponseRecord(item))) {
                 throw buildInvalidPersistenceFileError({
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                     format: 'json',
                     filePath: inflightPath,
                 });
             }
+            assertUniqueSideDialogResponseIds(parsed, `take rootId=${dialogId.rootId} selfId=${dialogId.selfId} status=${status}`);
             return parsed;
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
                 return [];
             }
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'takeSubdialogResponses', error);
-            throw new Error('unreachable after takeSubdialogResponses persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'takeSideDialogResponses', error);
+            throw new Error('unreachable after takeSideDialogResponses persistence rethrow');
         }
     }
-    static async commitTakenSubdialogResponses(dialogId, status = 'running') {
+    static async commitTakenSideDialogResponses(dialogId, status = 'running') {
         const dialogPath = this.getDialogResponsesPath(dialogId, status);
-        const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+        const inflightPath = path.join(dialogPath, 'sideDialog-responses.processing.json');
         await fs.promises.rm(inflightPath, { force: true });
     }
-    static async rollbackTakenSubdialogResponses(dialogId, status = 'running') {
+    static async rollbackTakenSideDialogResponses(dialogId, status = 'running') {
         try {
             const dialogPath = this.getDialogResponsesPath(dialogId, status);
-            const filePath = path.join(dialogPath, 'subdialog-responses.json');
-            const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+            const filePath = path.join(dialogPath, 'sideDialog-responses.json');
+            const inflightPath = path.join(dialogPath, 'sideDialog-responses.processing.json');
             let inflight = [];
             try {
                 const raw = await readPersistenceTextFile({
                     filePath: inflightPath,
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                     format: 'json',
                 });
                 const parsed = parsePersistenceJson({
                     content: raw,
                     filePath: inflightPath,
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                 });
-                if (!Array.isArray(parsed) || !parsed.every((item) => isSubdialogResponseRecord(item))) {
+                if (!Array.isArray(parsed) || !parsed.every((item) => isSideDialogResponseRecord(item))) {
                     throw buildInvalidPersistenceFileError({
-                        source: 'subdialog_responses',
+                        source: 'sideDialog_responses',
                         format: 'json',
                         filePath: inflightPath,
                     });
@@ -5742,17 +5900,17 @@ class DialogPersistence {
             try {
                 const raw = await readPersistenceTextFile({
                     filePath,
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                     format: 'json',
                 });
                 const parsed = parsePersistenceJson({
                     content: raw,
                     filePath,
-                    source: 'subdialog_responses',
+                    source: 'sideDialog_responses',
                 });
-                if (!Array.isArray(parsed) || !parsed.every((item) => isSubdialogResponseRecord(item))) {
+                if (!Array.isArray(parsed) || !parsed.every((item) => isSideDialogResponseRecord(item))) {
                     throw buildInvalidPersistenceFileError({
-                        source: 'subdialog_responses',
+                        source: 'sideDialog_responses',
                         format: 'json',
                         filePath,
                     });
@@ -5764,12 +5922,8 @@ class DialogPersistence {
                     throw error;
                 }
             }
-            const merged = [...inflight, ...primary];
-            const byId = new Map();
-            for (const r of merged) {
-                byId.set(r.responseId, r);
-            }
-            const result = Array.from(byId.values());
+            const result = [...inflight, ...primary];
+            assertUniqueSideDialogResponseIds(result, `rollback rootId=${dialogId.rootId} selfId=${dialogId.selfId} status=${status}`);
             const jsonContent = JSON.stringify(result, null, 2);
             const tempFile = path.join(dialogPath, `.${path.basename(filePath)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
             await fs.promises.writeFile(tempFile, jsonContent, 'utf-8');
@@ -5777,16 +5931,25 @@ class DialogPersistence {
             await fs.promises.rm(inflightPath, { force: true });
         }
         catch (error) {
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'rollbackTakenSubdialogResponses', error);
-            throw new Error('unreachable after rollbackTakenSubdialogResponses persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'rollbackTakenSideDialogResponses', error);
+            throw new Error('unreachable after rollbackTakenSideDialogResponses persistence rethrow');
         }
     }
     /**
-     * Save root dialog metadata (write-once pattern)
+     * Save main dialog metadata (write-once pattern)
      */
-    static async saveRootDialogMetadata(dialogId, metadata, status = 'running') {
+    static async saveMainDialogMetadata(dialogId, metadata, status = 'running') {
         try {
-            const dialogPath = this.getRootDialogPath(dialogId, status);
+            if (dialogId.rootId !== dialogId.selfId) {
+                throw new Error(`saveMainDialogMetadata expects a main dialog id: ${dialogId.valueOf()}`);
+            }
+            if (!isMainDialogMetadataFile(metadata)) {
+                throw new Error(`Invalid main dialog metadata for ${dialogId.selfId}`);
+            }
+            if (metadata.id !== dialogId.selfId) {
+                throw new Error(`Main dialog metadata id mismatch: dialogId=${dialogId.selfId} metadataId=${metadata.id}`);
+            }
+            const dialogPath = this.getMainDialogPath(dialogId, status);
             // Ensure dialog directory exists first
             await fs.promises.mkdir(dialogPath, { recursive: true });
             // Atomic write operation
@@ -5806,30 +5969,32 @@ class DialogPersistence {
      */
     static async saveDialogMetadata(dialogId, metadata, status = 'running') {
         if (dialogId.rootId === dialogId.selfId) {
-            if (!isRootDialogMetadataFile(metadata)) {
-                throw new Error(`Expected root dialog metadata for ${dialogId.selfId}`);
+            if (!isMainDialogMetadataFile(metadata)) {
+                throw new Error(`Expected main dialog metadata for ${dialogId.selfId}`);
             }
-            return this.saveRootDialogMetadata(dialogId, metadata, status);
+            return this.saveMainDialogMetadata(dialogId, metadata, status);
         }
-        // For subdialogs, delegate to saveSubdialogMetadata
-        if (!isSubdialogMetadataFile(metadata)) {
-            throw new Error(`Expected subdialog metadata for ${dialogId.selfId}`);
+        // For sideDialogs, delegate to saveSideDialogMetadata
+        if (!isSideDialogMetadataFile(metadata)) {
+            throw new Error(`Expected sideDialog metadata for ${dialogId.selfId}`);
         }
-        return this.saveSubdialogMetadata(dialogId, metadata, status);
-    }
-    /**
-     * Save dialog metadata (legacy - use saveRootDialogMetadata instead)
-     * @deprecated
-     */
-    static async _saveDialogMetadata(dialogId, metadata, status = 'running') {
-        return this.saveRootDialogMetadata(dialogId, metadata, status);
+        return this.saveSideDialogMetadata(dialogId, metadata, status);
     }
     /**
-     * Save subdialog metadata under the supdialog's .subdialogs directory
+     * Save sideDialog metadata under the root dialog's sideDialogs directory.
      */
-    static async saveSubdialogMetadata(dialogId, metadata, status = 'running') {
+    static async saveSideDialogMetadata(dialogId, metadata, status = 'running') {
         try {
-            const subPath = this.getSubdialogPath(dialogId, status);
+            if (dialogId.rootId === dialogId.selfId) {
+                throw new Error(`saveSideDialogMetadata expects a sideDialog id: ${dialogId.valueOf()}`);
+            }
+            if (!isSideDialogMetadataFile(metadata)) {
+                throw new Error(`Invalid sideDialog metadata for ${dialogId.selfId}`);
+            }
+            if (metadata.id !== dialogId.selfId) {
+                throw new Error(`sideDialog metadata id mismatch: dialogId=${dialogId.selfId} metadataId=${metadata.id}`);
+            }
+            const subPath = this.getSideDialogPath(dialogId, status);
             const metadataFilePath = path.join(subPath, 'dialog.yaml');
             // Creation sites must ensure the directory exists first. Update paths intentionally do not
             // recreate missing directories so quarantine can use "directory disappeared" as cancellation.
@@ -5839,33 +6004,259 @@ class DialogPersistence {
             await this.renameWithRetry(tempFile, metadataFilePath);
         }
         catch (error) {
-            log_1.log.error(`Failed to save subdialog YAML for ${dialogId.selfId} under root dialog ${dialogId.rootId}:`, error);
+            log_1.log.error(`Failed to save sideDialog YAML for ${dialogId.selfId} under main dialog ${dialogId.rootId}:`, error);
             throw error;
         }
     }
+    static async saveSideDialogAskerStackState(dialogId, state, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            throw new Error('saveSideDialogAskerStackState expects a sideDialog id');
+        }
+        if (!isDialogAskerStackState(state)) {
+            throw new Error(`Invalid asker stack for dialog ${dialogId.selfId}`);
+        }
+        await this.saveDialogAskerStack(dialogId, state, status);
+    }
+    static async loadSideDialogAskerStackState(dialogId, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            return null;
+        }
+        const stack = await this.loadDialogAskerStack(dialogId, status);
+        return stack.askerStack.length === 0 ? null : stack;
+    }
+    static async loadSideDialogAssignmentFromAsker(dialogId, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            throw new Error('loadSideDialogAssignmentFromAsker expects a sideDialog id');
+        }
+        const stack = await this.loadSideDialogAskerStackState(dialogId, status);
+        if (!stack) {
+            throw new Error(`Missing asker stack for sideDialog ${dialogId.selfId}`);
+        }
+        return getDialogAskerStackCurrentAssignment(stack);
+    }
+    static parseDialogAskerStackJsonlRows(args) {
+        const askerStack = [];
+        const rows = [];
+        const rawLines = args.content.split(/(?<=\n)/u);
+        let byteOffset = 0;
+        for (let index = 0; index < rawLines.length; index += 1) {
+            const rawLine = rawLines[index];
+            const line = rawLine.endsWith('\n') ? rawLine.slice(0, -1) : rawLine;
+            const startOffset = byteOffset;
+            const endOffset = startOffset + Buffer.byteLength(rawLine, 'utf-8');
+            byteOffset = endOffset;
+            if (line.trim() === '')
+                continue;
+            const parsed = parsePersistenceJson({
+                content: line,
+                filePath: args.filePath,
+                source: 'dialog_asker_stack',
+                lineNumber: index + 1,
+            });
+            if (!isAskerDialogStackFrame(parsed)) {
+                throw buildInvalidPersistenceFileError({
+                    source: 'dialog_asker_stack',
+                    format: 'jsonl',
+                    filePath: args.filePath,
+                    lineNumber: index + 1,
+                });
+            }
+            askerStack.push(parsed);
+            rows.push({
+                frame: parsed,
+                startOffset,
+                endOffset,
+            });
+        }
+        return { state: { askerStack }, rows };
+    }
+    static async appendDialogAskerStackFrames(dialogId, frames, status) {
+        if (frames.length === 0)
+            return;
+        const filePath = this.getDialogAskerStackPath(dialogId, status);
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        const content = frames.map((frame) => `${JSON.stringify(frame)}\n`).join('');
+        await fs.promises.appendFile(filePath, content, 'utf-8');
+    }
+    static async saveDialogAskerStack(dialogId, state, status = 'running') {
+        if (!isDialogAskerStackState(state)) {
+            throw new Error(`Invalid asker stack for dialog ${dialogId.selfId}`);
+        }
+        const filePath = this.getDialogAskerStackPath(dialogId, status);
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.promises.truncate(filePath, 0).catch(async (error) => {
+            if (getErrorCode(error) === 'ENOENT') {
+                await fs.promises.writeFile(filePath, '', 'utf-8');
+                return;
+            }
+            throw error;
+        });
+        await this.appendDialogAskerStackFrames(dialogId, state.askerStack, status);
+    }
+    static async loadDialogAskerStack(dialogId, status = 'running') {
+        return (await this.loadDialogAskerStackRows(dialogId, status)).state;
+    }
+    static async loadDialogAskerStackRows(dialogId, status) {
+        const filePath = this.getDialogAskerStackPath(dialogId, status);
+        try {
+            const content = await readPersistenceTextFile({
+                filePath,
+                source: 'dialog_asker_stack',
+                format: 'jsonl',
+            });
+            return { filePath, ...this.parseDialogAskerStackJsonlRows({ content, filePath }) };
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return { filePath, state: { askerStack: [] }, rows: [] };
+            }
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadDialogAskerStack', error);
+            throw new Error('unreachable after loadDialogAskerStack persistence rethrow');
+        }
+    }
+    static async truncateDialogAskerStackToDepth(dialogId, depth, status) {
+        const loaded = await this.loadDialogAskerStackRows(dialogId, status);
+        if (!Number.isInteger(depth) || depth < 0 || depth > loaded.rows.length) {
+            throw new Error(`asker stack truncate invariant violation: invalid depth ` +
+                `(rootId=${dialogId.rootId}, selfId=${dialogId.selfId}, depth=${String(depth)}, size=${String(loaded.rows.length)})`);
+        }
+        const truncateOffset = depth === loaded.rows.length
+            ? (loaded.rows[loaded.rows.length - 1]?.endOffset ?? 0)
+            : (loaded.rows[depth]?.startOffset ?? 0);
+        await fs.promises.mkdir(path.dirname(loaded.filePath), { recursive: true });
+        await fs.promises.truncate(loaded.filePath, truncateOffset).catch(async (error) => {
+            if (getErrorCode(error) === 'ENOENT' && truncateOffset === 0) {
+                await fs.promises.writeFile(loaded.filePath, '', 'utf-8');
+                return;
+            }
+            throw error;
+        });
+        return { askerStack: loaded.rows.slice(0, depth).map((row) => row.frame) };
+    }
+    static async replaceDialogAskerStackFrameAndAppend(args) {
+        const loaded = await this.loadDialogAskerStackRows(args.dialogId, args.status);
+        const matchingIndexes = loaded.rows
+            .map((row, index) => (args.findFrame(row.frame) ? index : -1))
+            .filter((index) => index >= 0);
+        if (matchingIndexes.length === 0) {
+            throw new Error(args.missingFrameMessage);
+        }
+        if (matchingIndexes.length > 1) {
+            throw new Error(`replace pending asker stack invariant violation: duplicate old frames ` +
+                `(rootId=${args.dialogId.rootId}, selfId=${args.dialogId.selfId}, matches=${String(matchingIndexes.length)})`);
+        }
+        const replaceIndex = matchingIndexes[0];
+        const replacedRow = loaded.rows[replaceIndex];
+        await fs.promises.truncate(loaded.filePath, replacedRow.startOffset);
+        const retainedBefore = loaded.rows.slice(0, replaceIndex).map((row) => row.frame);
+        const retainedAfter = loaded.rows.slice(replaceIndex + 1).map((row) => row.frame);
+        await this.appendDialogAskerStackFrames(args.dialogId, [args.appendFrame, ...retainedAfter], args.status);
+        return {
+            askerStack: [...retainedBefore, args.appendFrame, ...retainedAfter],
+        };
+    }
+    static async pushTellaskReplyObligation(dialogId, obligation, status = 'running') {
+        const frame = {
+            kind: 'asker_dialog_stack_frame',
+            askerDialogId: obligation.targetDialogId,
+            tellaskReplyObligation: obligation,
+        };
+        if (dialogId.rootId === dialogId.selfId) {
+            await this.appendDialogAskerStackFrames(dialogId, [frame], status);
+            return;
+        }
+        const state = await this.loadSideDialogAskerStackState(dialogId, status);
+        if (!state) {
+            throw new Error(`Missing asker stack for sideDialog ${dialogId.selfId}`);
+        }
+        await this.appendDialogAskerStackFrames(dialogId, [frame], status);
+    }
+    static async setActiveTellaskReplyObligation(dialogId, obligation, status = 'running') {
+        if (obligation !== undefined) {
+            await this.pushTellaskReplyObligation(dialogId, obligation, status);
+            return;
+        }
+        if (dialogId.rootId === dialogId.selfId) {
+            const stackFile = await this.loadDialogAskerStack(dialogId, status);
+            if (stackFile.askerStack.length === 0)
+                return;
+            await this.truncateDialogAskerStackToDepth(dialogId, stackFile.askerStack.length - 1, status);
+            return;
+        }
+        const state = await this.loadSideDialogAskerStackState(dialogId, status);
+        if (!state) {
+            throw new Error(`Missing asker stack for sideDialog ${dialogId.selfId}`);
+        }
+        if (state.askerStack.length > 1) {
+            await this.truncateDialogAskerStackToDepth(dialogId, state.askerStack.length - 1, status);
+            return;
+        }
+        const top = getDialogAskerStackTop(state);
+        await this.truncateDialogAskerStackToDepth(dialogId, 0, status);
+        if (top.assignmentFromAsker === undefined) {
+            return;
+        }
+        await this.appendDialogAskerStackFrames(dialogId, [
+            {
+                kind: 'asker_dialog_stack_frame',
+                askerDialogId: top.askerDialogId,
+                assignmentFromAsker: top.assignmentFromAsker,
+            },
+        ], status);
+    }
+    static async loadActiveTellaskReplyObligation(dialogId, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            const stack = (await this.loadDialogAskerStack(dialogId, status)).askerStack;
+            return stack[stack.length - 1]?.tellaskReplyObligation;
+        }
+        return getDialogAskerStackTop(await this.requireSideDialogAskerStackState(dialogId, status))
+            .tellaskReplyObligation;
+    }
+    static async requireSideDialogAskerStackState(dialogId, status) {
+        const state = await this.loadSideDialogAskerStackState(dialogId, status);
+        if (!state) {
+            throw new Error(`Missing asker stack for sideDialog ${dialogId.selfId}`);
+        }
+        return state;
+    }
     /**
-     * Update assignmentFromSup for an existing subdialog.
+     * Update assignmentFromAsker for an existing sideDialog.
      */
-    static async updateSubdialogAssignment(dialogId, assignment, status = 'running') {
+    static async updateSideDialogAssignment(dialogId, assignment, status = 'running', options) {
         if (dialogId.rootId === dialogId.selfId) {
-            throw new Error('updateSubdialogAssignment expects a subdialog id');
+            throw new Error('updateSideDialogAssignment expects a sideDialog id');
         }
         const metadata = await this.loadDialogMetadata(dialogId, status);
-        if (!metadata || !isSubdialogMetadataFile(metadata)) {
-            throw new Error(`Missing dialog metadata for subdialog ${dialogId.selfId}`);
+        if (!metadata || !isSideDialogMetadataFile(metadata)) {
+            throw new Error(`Missing dialog metadata for sideDialog ${dialogId.selfId}`);
+        }
+        const nextAssignmentFrame = buildAssignmentAskerStackFrame({
+            askerDialogId: assignment.askerDialogId,
+            assignment,
+        });
+        if (options?.replacePendingCallId === undefined) {
+            await this.requireSideDialogAskerStackState(dialogId, status);
+            await this.appendDialogAskerStackFrames(dialogId, [nextAssignmentFrame], status);
+        }
+        else {
+            const replacePendingAskerDialogId = options.replacePendingAskerDialogId ?? assignment.askerDialogId;
+            await this.replaceDialogAskerStackFrameAndAppend({
+                dialogId,
+                status,
+                findFrame: (frame) => frame.assignmentFromAsker?.askerDialogId === replacePendingAskerDialogId &&
+                    frame.assignmentFromAsker.callId === options.replacePendingCallId,
+                missingFrameMessage: `replace pending asker stack invariant violation: missing old frame ` +
+                    `(rootId=${dialogId.rootId}, selfId=${dialogId.selfId}, askerDialogId=${replacePendingAskerDialogId}, callId=${options.replacePendingCallId})`,
+                appendFrame: nextAssignmentFrame,
+            });
         }
-        const next = {
-            ...metadata,
-            assignmentFromSup: assignment,
-        };
-        await this.saveSubdialogMetadata(dialogId, next, status);
     }
     /**
-     * Load root dialog metadata
+     * Load main dialog metadata
      */
-    static async loadRootDialogMetadata(dialogId, status = 'running') {
+    static async loadMainDialogMetadata(dialogId, status = 'running') {
         try {
-            const dialogPath = this.getRootDialogPath(dialogId, status);
+            const dialogPath = this.getMainDialogPath(dialogId, status);
             const metadataFilePath = path.join(dialogPath, 'dialog.yaml');
             try {
                 const content = await readPersistenceTextFile({
@@ -5878,7 +6269,7 @@ class DialogPersistence {
                     filePath: metadataFilePath,
                     source: 'dialog_metadata',
                 });
-                if (!isDialogMetadataFile(parsed)) {
+                if (!isMainDialogMetadataFile(parsed)) {
                     throw buildInvalidPersistenceFileError({
                         source: 'dialog_metadata',
                         format: 'yaml',
@@ -5899,8 +6290,8 @@ class DialogPersistence {
                 if (getErrorCode(error) === 'ENOENT') {
                     return null;
                 }
-                await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadRootDialogMetadata', error);
-                throw new Error('unreachable after loadRootDialogMetadata persistence rethrow');
+                await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadMainDialogMetadata', error);
+                throw new Error('unreachable after loadMainDialogMetadata persistence rethrow');
             }
         }
         catch (error) {
@@ -5909,17 +6300,14 @@ class DialogPersistence {
         }
     }
     /**
-     * Load dialog metadata (universal - works with any DialogID)
+     * Load dialog metadata from the path implied by the DialogID.
      */
     static async loadDialogMetadata(dialogId, status = 'running') {
-        // For root dialogs, use the selfId
-        // For subdialogs, this is more complex - we need to find the root metadata
         if (dialogId.rootId === dialogId.selfId) {
-            return this.loadRootDialogMetadata(dialogId, status);
+            return this.loadMainDialogMetadata(dialogId, status);
         }
-        // For subdialogs, we need to load from the subdialog location
-        const subdialogPath = this.getSubdialogPath(dialogId, status);
-        const metadataFilePath = path.join(subdialogPath, 'dialog.yaml');
+        const sideDialogPath = this.getSideDialogPath(dialogId, status);
+        const metadataFilePath = path.join(sideDialogPath, 'dialog.yaml');
         try {
             const content = await readPersistenceTextFile({
                 filePath: metadataFilePath,
@@ -5931,13 +6319,29 @@ class DialogPersistence {
                 filePath: metadataFilePath,
                 source: 'dialog_metadata',
             });
-            if (!isDialogMetadataFile(parsed)) {
+            if (!isSideDialogMetadataFile(parsed)) {
                 throw buildInvalidPersistenceFileError({
                     source: 'dialog_metadata',
                     format: 'yaml',
                     filePath: metadataFilePath,
                 });
             }
+            if (parsed.id !== dialogId.selfId) {
+                throw buildInvalidPersistenceFileError({
+                    source: 'dialog_metadata',
+                    format: 'yaml',
+                    filePath: metadataFilePath,
+                });
+            }
+            const askerStack = await this.loadSideDialogAskerStackState(dialogId, status);
+            if (!askerStack) {
+                throw buildInvalidPersistenceFileError({
+                    source: 'dialog_asker_stack',
+                    format: 'jsonl',
+                    filePath: this.getDialogAskerStackPath(dialogId, status),
+                });
+            }
+            getDialogAskerStackCurrentAssignment(askerStack);
             return parsed;
         }
         catch (error) {
@@ -5954,7 +6358,7 @@ class DialogPersistence {
     static async writeDialogLatestToDisk(dialogId, latest, status = 'running', cancellationToken) {
         try {
             if (cancellationToken) {
-                this.assertRootDialogWriteBackNotCanceled(cancellationToken, 'writeDialogLatestToDisk:start');
+                this.assertMainDialogWriteBackNotCanceled(cancellationToken, 'writeDialogLatestToDisk:start');
             }
             const dialogPath = this.getDialogEventsPath(dialogId, status);
             const latestFilePath = path.join(dialogPath, 'latest.yaml');
@@ -5989,7 +6393,7 @@ class DialogPersistence {
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
                 if (cancellationToken) {
-                    this.assertRootDialogWriteBackNotCanceled(cancellationToken, `renameWithRetry:${path.basename(destination)}:before-rename`);
+                    this.assertMainDialogWriteBackNotCanceled(cancellationToken, `renameWithRetry:${path.basename(destination)}:before-rename`);
                 }
                 await fs.promises.rename(source, destination);
                 return;
@@ -6045,10 +6449,10 @@ class DialogPersistence {
     static async mutateDialogLatest(dialogId, mutator, status = 'running', cancellationToken) {
         const key = this.getLatestWriteBackKey(dialogId, status);
         const mutex = this.getLatestWriteBackMutex(key);
-        const effectiveCancellationToken = cancellationToken ?? this.createRootDialogWriteBackCancellationToken(dialogId, status);
+        const effectiveCancellationToken = cancellationToken ?? this.createMainDialogWriteBackCancellationToken(dialogId, status);
         const release = await mutex.acquire();
         try {
-            this.assertRootDialogWriteBackNotCanceled(effectiveCancellationToken, 'mutateDialogLatest');
+            this.assertMainDialogWriteBackNotCanceled(effectiveCancellationToken, 'mutateDialogLatest');
             const staged = this.latestWriteBack.get(key);
             const latestFromDisk = staged ? null : await this.loadDialogLatestFromDisk(dialogId, status);
             const existing = (staged ? staged.latest : latestFromDisk) || {
@@ -6089,7 +6493,7 @@ class DialogPersistence {
                 latestSource: staged ? 'staged' : latestFromDisk ? 'disk' : 'default_bootstrap',
                 latestWriteBackKey: key,
             });
-            this.assertRootDialogWriteBackNotCanceled(effectiveCancellationToken, 'mutateDialogLatest:before-stage');
+            this.assertMainDialogWriteBackNotCanceled(effectiveCancellationToken, 'mutateDialogLatest:before-stage');
             const pending = this.latestWriteBack.get(key);
             if (!pending) {
                 const timer = setTimeout(() => {
@@ -6149,7 +6553,7 @@ class DialogPersistence {
                     return;
                 clearTimeout(entry.timer);
                 const latestToWrite = entry.latest;
-                const cancellationToken = this.createRootDialogWriteBackCancellationToken(entry.dialogId, entry.status);
+                const cancellationToken = this.createMainDialogWriteBackCancellationToken(entry.dialogId, entry.status);
                 const inFlight = this.writeDialogLatestToDisk(entry.dialogId, latestToWrite, entry.status, cancellationToken);
                 captured = {
                     dialogId: entry.dialogId,
@@ -6340,18 +6744,18 @@ class DialogPersistence {
         };
     }
     /**
-     * Count subdialogs under a root dialog (no single-layer listing exposed)
+     * Count sideDialogs under a main dialog (no single-layer listing exposed)
      */
-    static async countAllSubdialogsUnderRoot(rootDialogId, status = 'running') {
-        if (rootDialogId.rootId !== rootDialogId.selfId) {
-            throw new Error(`countAllSubdialogsUnderRoot invariant violation: expected root dialog id, got ${rootDialogId.valueOf()}`);
+    static async countAllSideDialogsUnderRoot(mainDialogId, status = 'running') {
+        if (mainDialogId.rootId !== mainDialogId.selfId) {
+            throw new Error(`countAllSideDialogsUnderRoot invariant violation: expected main dialog id, got ${mainDialogId.valueOf()}`);
         }
         try {
             const dialogIds = await this.listAllDialogIds(status);
-            return dialogIds.filter((dialogId) => dialogId.rootId === rootDialogId.rootId && dialogId.selfId !== dialogId.rootId).length;
+            return dialogIds.filter((dialogId) => dialogId.rootId === mainDialogId.rootId && dialogId.selfId !== dialogId.rootId).length;
         }
         catch (error) {
-            log_1.log.error(`Failed to count all subdialogs under root ${rootDialogId.selfId}:`, error);
+            log_1.log.error(`Failed to count all sideDialogs under root ${mainDialogId.selfId}:`, error);
             throw error;
         }
     }
@@ -6359,22 +6763,22 @@ class DialogPersistence {
     /**
      * Restore complete dialog tree from disk
      */
-    static async restoreDialogTree(rootDialogId, status = 'running') {
+    static async restoreDialogTree(mainDialogId, status = 'running') {
         try {
-            // First restore the root dialog
-            const rootState = await this.restoreDialog(rootDialogId, status);
+            // First restore the main dialog
+            const rootState = await this.restoreDialog(mainDialogId, status);
             if (!rootState) {
                 return null;
             }
-            // Recursively restore subdialogs
-            const subdialogIds = await this.listSubdialogIdsUnderRoot(rootDialogId, status);
-            for (const subdialogId of subdialogIds) {
-                await this.restoreDialogTree(new dialog_1.DialogID(subdialogId, rootDialogId.rootId), status);
+            // Recursively restore sideDialogs
+            const sideDialogIds = await this.listSideDialogIdsUnderRoot(mainDialogId, status);
+            for (const sideDialogId of sideDialogIds) {
+                await this.restoreDialogTree(new dialog_1.DialogID(sideDialogId, mainDialogId.rootId), status);
             }
             return rootState;
         }
         catch (error) {
-            log_1.log.error(`Failed to restore dialog tree for ${rootDialogId.valueOf()}:`, error);
+            log_1.log.error(`Failed to restore dialog tree for ${mainDialogId.valueOf()}:`, error);
             return null;
         }
     }
@@ -6532,8 +6936,8 @@ class DialogPersistence {
                         status: event.status,
                         content: event.content,
                         contentItems: event.contentItems,
-                        ...(event.originCourse !== undefined ? { originCourse: event.originCourse } : {}),
-                        ...(event.calling_genseq !== undefined ? { calling_genseq: event.calling_genseq } : {}),
+                        ...(event.callSiteCourse !== undefined ? { callSiteCourse: event.callSiteCourse } : {}),
+                        ...(event.callSiteGenseq !== undefined ? { callSiteGenseq: event.callSiteGenseq } : {}),
                         call: event.call,
                         responder: event.responder,
                         ...(event.route ? { route: event.route } : {}),
@@ -6564,7 +6968,7 @@ class DialogPersistence {
                         genseq: event.genseq,
                         content: event.content,
                         contentItems: event.contentItems,
-                        originCourse: event.originCourse,
+                        callSiteCourse: event.callSiteCourse,
                         carryoverCourse: event.carryoverCourse,
                         responderId: event.responderId,
                         callName: event.callName,
@@ -6599,23 +7003,23 @@ class DialogPersistence {
                         contextHealth = event.contextHealth;
                     }
                     break;
-                case 'quest_for_sup_record':
+                case 'sideDialog_request_record':
                     // These events are handled separately in dialog restoration
                     // Skip them for message reconstruction
                     break;
                 case 'tellask_call_anchor_record':
-                    // This record is UI navigation metadata for deep links in callee dialogs.
+                    // This record is UI navigation metadata for deep links in tellaskee dialogs.
                     // It does not contribute to model context or chat transcript reconstruction.
                     break;
                 case 'ui_only_markdown_record':
                     // UI-only records are replay-only rendering facts. They do not enter dialog messages or ctx.
                     break;
-                case 'subdialog_created_record':
+                case 'sideDialog_created_record':
                 case 'reminders_reconciled_record':
                 case 'questions4human_reconciled_record':
-                case 'pending_subdialogs_reconciled_record':
-                case 'subdialog_registry_reconciled_record':
-                case 'subdialog_responses_reconciled_record':
+                case 'pending_sideDialogs_reconciled_record':
+                case 'sideDialog_registry_reconciled_record':
+                case 'sideDialog_responses_reconciled_record':
                     break;
                 default:
                     log_1.log.warn(`Unknown event type in rebuildFromEvents`, undefined, { event });
@@ -6655,36 +7059,36 @@ class DialogPersistence {
         }
     }
     /**
-     * Delete a root dialog directory (including subdialogs) from disk.
+     * Delete a main dialog directory (including sideDialogs) from disk.
      * Caller must provide the source status explicitly.
      */
-    static async deleteRootDialog(rootDialogId, fromStatus) {
-        if (rootDialogId.selfId !== rootDialogId.rootId) {
-            throw new Error('deleteRootDialog expects a root dialog id');
+    static async deleteMainDialog(mainDialogId, fromStatus) {
+        if (mainDialogId.selfId !== mainDialogId.rootId) {
+            throw new Error('deleteMainDialog expects a main dialog id');
         }
-        const exists = await this.loadRootDialogMetadata(rootDialogId, fromStatus);
+        const exists = await this.loadMainDialogMetadata(mainDialogId, fromStatus);
         if (!exists)
             return false;
         // Best-effort cleanup: remove the dialog from all status directories to avoid leaving behind
         // orphaned placeholder paths (e.g. `run/<id>/latest.yaml`) after a delete.
         for (const candidate of PERSISTABLE_DIALOG_STATUSES) {
-            this.cancelRootDialogWriteBacks(rootDialogId, candidate);
-            const candidatePath = this.getRootDialogPath(rootDialogId, candidate);
+            this.cancelMainDialogWriteBacks(mainDialogId, candidate);
+            const candidatePath = this.getMainDialogPath(mainDialogId, candidate);
             await fs.promises.rm(candidatePath, { recursive: true, force: true });
         }
         return true;
     }
     // === REGISTRY PERSISTENCE ===
     /**
-     * Save subdialog registry (TYPE B entries).
+     * Save sideDialog registry (TYPE B entries).
      */
-    static async saveSubdialogRegistry(rootDialogId, entries, status = 'running') {
+    static async saveSideDialogRegistry(mainDialogId, entries, status = 'running') {
         try {
-            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
             const registryFilePath = path.join(dialogPath, 'registry.yaml');
             const serializableEntries = entries.map((entry) => ({
                 key: entry.key,
-                subdialogId: entry.subdialogId.selfId,
+                sideDialogId: entry.sideDialogId.selfId,
                 agentId: entry.agentId,
                 sessionSlug: entry.sessionSlug,
             }));
@@ -6694,30 +7098,30 @@ class DialogPersistence {
             await this.renameWithRetry(tempFile, registryFilePath);
         }
         catch (error) {
-            log_1.log.error(`Failed to save subdialog registry for dialog ${rootDialogId}:`, error);
+            log_1.log.error(`Failed to save sideDialog registry for dialog ${mainDialogId}:`, error);
             throw error;
         }
     }
     /**
-     * Load subdialog registry.
+     * Load sideDialog registry.
      */
-    static async loadSubdialogRegistry(rootDialogId, status = 'running') {
+    static async loadSideDialogRegistry(mainDialogId, status = 'running') {
         try {
-            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const dialogPath = this.getDialogResponsesPath(mainDialogId, status);
             const registryFilePath = path.join(dialogPath, 'registry.yaml');
             const content = await readPersistenceTextFile({
                 filePath: registryFilePath,
-                source: 'subdialog_registry',
+                source: 'sideDialog_registry',
                 format: 'yaml',
             });
             const parsed = parsePersistenceYaml({
                 content,
                 filePath: registryFilePath,
-                source: 'subdialog_registry',
+                source: 'sideDialog_registry',
             });
             if (!isRecord(parsed) || !Array.isArray(parsed.entries)) {
                 throw buildInvalidPersistenceFileError({
-                    source: 'subdialog_registry',
+                    source: 'sideDialog_registry',
                     format: 'yaml',
                     filePath: registryFilePath,
                 });
@@ -6725,18 +7129,18 @@ class DialogPersistence {
             const entries = parsed.entries.map((entry) => {
                 if (!isRecord(entry) ||
                     typeof entry.key !== 'string' ||
-                    typeof entry.subdialogId !== 'string' ||
+                    typeof entry.sideDialogId !== 'string' ||
                     typeof entry.agentId !== 'string' ||
                     (entry.sessionSlug !== undefined && typeof entry.sessionSlug !== 'string')) {
                     throw buildInvalidPersistenceFileError({
-                        source: 'subdialog_registry',
+                        source: 'sideDialog_registry',
                         format: 'yaml',
                         filePath: registryFilePath,
                     });
                 }
                 return {
                     key: entry.key,
-                    subdialogId: new dialog_1.DialogID(entry.subdialogId, rootDialogId.rootId),
+                    sideDialogId: new dialog_1.DialogID(entry.sideDialogId, mainDialogId.rootId),
                     agentId: entry.agentId,
                     sessionSlug: entry.sessionSlug,
                 };
@@ -6747,8 +7151,8 @@ class DialogPersistence {
             if (getErrorCode(error) === 'ENOENT') {
                 return [];
             }
-            await this.rethrowAfterQuarantiningDialogPersistenceProblem(rootDialogId, status, 'loadSubdialogRegistry', error);
-            throw new Error('unreachable after loadSubdialogRegistry persistence rethrow');
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(mainDialogId, status, 'loadSideDialogRegistry', error);
+            throw new Error('unreachable after loadSideDialogRegistry persistence rethrow');
         }
     }
 }
@@ -6758,16 +7162,16 @@ DialogPersistence.MALFORMED_DIR = 'malformed';
 DialogPersistence.RUN_DIR = 'run';
 DialogPersistence.DONE_DIR = 'done';
 DialogPersistence.ARCHIVE_DIR = 'archive';
-DialogPersistence.SUBDIALOGS_DIR = 'subdialogs';
-DialogPersistence.quarantinedRootDialogScopes = new Set();
+DialogPersistence.SIDE_DIALOGS_DIR = 'sideDialogs';
+DialogPersistence.quarantinedMainDialogScopes = new Set();
 DialogPersistence.LATEST_WRITEBACK_WINDOW_MS = 300;
 DialogPersistence.Q4H_WRITEBACK_WINDOW_MS = 300;
-DialogPersistence.PENDING_SUBDIALOGS_WRITEBACK_WINDOW_MS = 300;
+DialogPersistence.PENDING_SIDE_DIALOGS_WRITEBACK_WINDOW_MS = 300;
 DialogPersistence.latestWriteBackMutexes = new Map();
 DialogPersistence.latestWriteBack = new Map();
 DialogPersistence.q4hWriteBackMutexes = new Map();
 DialogPersistence.q4hWriteBack = new Map();
-DialogPersistence.pendingSubdialogsWriteBackMutexes = new Map();
-DialogPersistence.pendingSubdialogsWriteBack = new Map();
+DialogPersistence.pendingSideDialogsWriteBackMutexes = new Map();
+DialogPersistence.pendingSideDialogsWriteBack = new Map();
 DialogPersistence.courseAppendMutexes = new Map();
-DialogPersistence.rootDialogWriteBackCancelGenerations = new Map();
+DialogPersistence.mainDialogWriteBackCancelGenerations = new Map();