dominds 1.18.2 → 1.19.2

package/dist/dialog.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DialogStore = exports.RootDialog = exports.SubDialog = exports.Dialog = exports.DialogID = void 0;
+exports.DialogStore = exports.MainDialog = exports.SideDialog = exports.Dialog = exports.DialogID = void 0;
+exports.buildSideDialogAskerStack = buildSideDialogAskerStack;
 const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const util_1 = require("util");
@@ -67,18 +68,53 @@ function getGlobalDialogMutex(dialogId) {
 function compareVisibleReminderTargetOrder(a, b) {
     return (0, tool_1.compareReminderDisplayOrder)(a.reminder, b.reminder);
 }
-function buildSubdialogAssignmentPromptMeta(subdialog) {
-    const assignment = subdialog.assignmentFromSup;
+function buildSideDialogAskerStack(args) {
+    const expectedReplyCallName = args.assignment.callName === 'tellask' ? 'replyTellask' : 'replyTellaskSessionless';
+    return {
+        askerStack: [
+            {
+                kind: 'asker_dialog_stack_frame',
+                askerDialogId: args.askerDialogId,
+                assignmentFromAsker: args.assignment,
+                tellaskReplyObligation: {
+                    expectedReplyCallName,
+                    targetDialogId: args.assignment.askerDialogId,
+                    targetCallId: args.assignment.callId,
+                    tellaskContent: args.assignment.tellaskContent,
+                },
+            },
+        ],
+    };
+}
+function getSideDialogAskerStackTop(askerStack) {
+    const top = askerStack.askerStack[askerStack.askerStack.length - 1];
+    if (!top) {
+        throw new Error('SideDialog askerStack invariant violation: empty reply obligation stack');
+    }
+    return top;
+}
+function getSideDialogAskerStackCurrentAssignment(askerStack) {
+    for (let index = askerStack.askerStack.length - 1; index >= 0; index -= 1) {
+        const frame = askerStack.askerStack[index];
+        if (frame?.assignmentFromAsker !== undefined) {
+            return frame.assignmentFromAsker;
+        }
+    }
+    throw new Error('SideDialog askerStack invariant violation: missing assignment frame');
+}
+function buildSideDialogAssignmentPromptMeta(sideDialog) {
+    const assignment = sideDialog.assignmentFromAsker;
     switch (assignment.callName) {
         case 'tellask':
             return {
                 tellaskReplyDirective: {
                     expectedReplyCallName: 'replyTellask',
+                    targetDialogId: assignment.askerDialogId,
                     targetCallId: assignment.callId,
                     tellaskContent: assignment.tellaskContent,
                 },
-                subdialogReplyTarget: {
-                    ownerDialogId: assignment.callerDialogId,
+                sideDialogReplyTarget: {
+                    ownerDialogId: assignment.askerDialogId,
                     callType: 'B',
                     callId: assignment.callId,
                 },
@@ -88,11 +124,12 @@ function buildSubdialogAssignmentPromptMeta(subdialog) {
             return {
                 tellaskReplyDirective: {
                     expectedReplyCallName: 'replyTellaskSessionless',
+                    targetDialogId: assignment.askerDialogId,
                     targetCallId: assignment.callId,
                     tellaskContent: assignment.tellaskContent,
                 },
-                subdialogReplyTarget: {
-                    ownerDialogId: assignment.callerDialogId,
+                sideDialogReplyTarget: {
+                    ownerDialogId: assignment.askerDialogId,
                     callType: 'C',
                     callId: assignment.callId,
                 },
@@ -101,7 +138,7 @@ function buildSubdialogAssignmentPromptMeta(subdialog) {
 }
 /**
  * Abstract base class for all dialog types.
- * Contains common properties and methods shared between RootDialog and SubDialog.
+ * Contains common properties and methods shared between MainDialog and SideDialog.
  */
 class Dialog {
     constructor(dlgStore, taskDocPath, id, agentId, initialState) {
@@ -118,18 +155,18 @@ class Dialog {
         this._coursePrefixMsgs = [];
         this._courseRuntimeNoticeMsgs = [];
         // Track whether the current course's initial events (user_text, generating_start)
-        // have been fully processed. Used to ensure subdialog_final_response_evt arrives
+        // have been fully processed. Used to ensure sideDialog_final_response_evt arrives
         // only after parent events are emitted.
         this._generationStarted = false;
         // Track the generation sequence when _generationStarted was set
         // Used to ensure proper ordering when multiple generations occur
         this._generationStartedGenseq = 0;
-        // Pending subdialog IDs (for auto-revive tracking)
-        this._pendingSubdialogIds = [];
-        // Phase 11: Suspension state for Type A subdialog mechanism
+        // Pending sideDialog IDs (for auto-revive tracking)
+        this._pendingSideDialogIds = [];
+        // Phase 11: Suspension state for Type A sideDialog mechanism
         // Tracks whether this dialog is in normal state, suspended, or resuming from suspension
         this._suspensionState = 'active';
-        // Diligence Push (diligence auto-continue) budget counter (root-dialog state).
+        // Diligence Push (diligence auto-continue) budget counter (main-dialog state).
         // Persisted via latest.yaml so restarts and UI navigation can restore correct remaining budget.
         this.diligencePushRemainingBudget = 0;
         // Diligence Push disable switch (persisted via latest.yaml; default = false).
@@ -138,7 +175,7 @@ class Dialog {
         // - Set when tellask-special call results are finalized
         // - Retrieved during inline call-result emission (for receiveTellaskCallResult callId parameter)
         // - Enables frontend to attach result INLINE to the calling section
-        // - NOT used for sideline-response bubbles (which use calleeDialogId instead)
+        // - NOT used for Side Dialog-response bubbles (which use calleeDialogId instead)
         this._currentCallId = null;
         // Validate required parameters
         if (!taskDocPath || taskDocPath.trim() === '') {
@@ -189,7 +226,7 @@ class Dialog {
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
         this._remindersVer++;
     }
-    get supdialog() {
+    get askerDialog() {
         return undefined;
     }
     getUiLanguage() {
@@ -227,7 +264,7 @@ class Dialog {
      *
      * Call Types:
      * - tellask-special function call: callId is set when call results are finalized and used for inline result correlation
-     * - Subdialog response bubbles: use calleeDialogId instead of callId
+     * - SideDialog response bubbles: use calleeDialogId instead of callId
      *
      * @returns The current callId for call correlation, or null if no active call
      */
@@ -292,15 +329,15 @@ class Dialog {
         }
     }
     /**
-     * Check if dialog has pending subdialogs.
+     * Check if dialog has pending sideDialogs.
      */
-    async hasPendingSubdialogs() {
+    async hasPendingSideDialogs() {
         try {
-            const pending = await this.dlgStore.loadPendingSubdialogs(this.id, this.status);
+            const pending = await this.dlgStore.loadPendingSideDialogs(this.id, this.status);
             return pending.length > 0;
         }
         catch (err) {
-            log_1.log.warn('Failed to load pending subdialogs for pending check', undefined, {
+            log_1.log.warn('Failed to load pending sideDialogs for pending check', undefined, {
                 dialogId: this.id.selfId,
                 error: err,
             });
@@ -308,7 +345,7 @@ class Dialog {
         }
     }
     /**
-     * Check if dialog can be driven (not suspended for Q4H or subdialogs).
+     * Check if dialog can be driven (not suspended for Q4H or sideDialogs).
      */
     async canDrive(options) {
         const suspension = await this.getSuspensionStatus(options);
@@ -319,39 +356,39 @@ class Dialog {
      */
     async getSuspensionStatus(options) {
         const hasQ4H = await this.hasPendingQ4H();
-        const hasSubdialogs = await this.hasPendingSubdialogs();
-        const blockingSubdialogs = hasSubdialogs && options?.allowPendingSubdialogs !== true;
+        const hasSideDialogs = await this.hasPendingSideDialogs();
+        const blockingSideDialogs = hasSideDialogs && options?.allowPendingSideDialogs !== true;
         return {
             q4h: hasQ4H,
-            subdialogs: hasSubdialogs,
-            blockingSubdialogs,
-            canDrive: !hasQ4H && !blockingSubdialogs,
+            sideDialogs: hasSideDialogs,
+            blockingSideDialogs,
+            canDrive: !hasQ4H && !blockingSideDialogs,
         };
     }
-    get pendingSubdialogIds() {
-        return this._pendingSubdialogIds;
+    get pendingSideDialogIds() {
+        return this._pendingSideDialogIds;
     }
-    addPendingSubdialogs(ids) {
-        this._pendingSubdialogIds.push(...ids);
+    addPendingSideDialogs(ids) {
+        this._pendingSideDialogIds.push(...ids);
     }
-    removePendingSubdialog(id) {
-        this._pendingSubdialogIds = this._pendingSubdialogIds.filter((pending) => pending.selfId !== id.selfId);
+    removePendingSideDialog(id) {
+        this._pendingSideDialogIds = this._pendingSideDialogIds.filter((pending) => pending.selfId !== id.selfId);
     }
-    clearPendingSubdialogs() {
-        this._pendingSubdialogIds = [];
+    clearPendingSideDialogs() {
+        this._pendingSideDialogIds = [];
     }
     /**
-     * Load pending subdialogs from persistence into memory.
+     * Load pending sideDialogs from persistence into memory.
      * Used during crash recovery to restore suspension state.
      */
-    async loadPendingSubdialogsFromPersistence() {
+    async loadPendingSideDialogsFromPersistence() {
         try {
-            const pending = await this.dlgStore.loadPendingSubdialogs(this.id, this.status);
-            this.clearPendingSubdialogs();
-            this.addPendingSubdialogs(pending.map((record) => record.subdialogId));
+            const pending = await this.dlgStore.loadPendingSideDialogs(this.id, this.status);
+            this.clearPendingSideDialogs();
+            this.addPendingSideDialogs(pending.map((record) => record.sideDialogId));
         }
         catch (err) {
-            log_1.log.warn('Failed to load pending subdialogs from persistence', undefined, {
+            log_1.log.warn('Failed to load pending sideDialogs from persistence', undefined, {
                 dialogId: this.id.selfId,
                 error: err,
             });
@@ -591,14 +628,14 @@ class Dialog {
     }
     /**
      * Check if generation has started for the current course.
-     * Used to ensure subdialog_final_response_evt arrives after parent events.
+     * Used to ensure sideDialog_final_response_evt arrives after parent events.
      */
     get generationStarted() {
         return this._generationStarted;
     }
     /**
      * Mark generation as started (after user_text event has been emitted).
-     * This ensures subdialog_final_response_evt waits for this signal.
+     * This ensures sideDialog_final_response_evt waits for this signal.
      * @param genseq The generation sequence number when this flag is set
      */
     markGenerationStarted(genseq) {
@@ -665,7 +702,7 @@ class Dialog {
                             return prompt;
                         }
                         case 'registered_assignment_update':
-                        case 'new_course_runtime_subdialog': {
+                        case 'new_course_runtime_sideDialog': {
                             const prompt = {
                                 ...promptCommon,
                                 origin: 'runtime',
@@ -673,7 +710,7 @@ class Dialog {
                                     ? {}
                                     : { skipTaskdoc: nextPrompt.skipTaskdoc }),
                                 tellaskReplyDirective: nextPrompt.tellaskReplyDirective,
-                                subdialogReplyTarget: nextPrompt.subdialogReplyTarget,
+                                sideDialogReplyTarget: nextPrompt.sideDialogReplyTarget,
                             };
                             return prompt;
                         }
@@ -732,12 +769,12 @@ class Dialog {
             origin: 'runtime',
             ...(prepared.skipTaskdoc === undefined ? {} : { skipTaskdoc: prepared.skipTaskdoc }),
         };
-        const normalized = prepared.subdialogReplyTarget !== undefined
+        const normalized = prepared.sideDialogReplyTarget !== undefined
             ? (() => {
                 const prompt = {
                     ...runtimeCommon,
                     tellaskReplyDirective: prepared.tellaskReplyDirective,
-                    subdialogReplyTarget: prepared.subdialogReplyTarget,
+                    sideDialogReplyTarget: prepared.sideDialogReplyTarget,
                 };
                 return prompt;
             })()
@@ -754,9 +791,9 @@ class Dialog {
                     return prompt;
                 })();
         this._upNextQueue = [
-            normalized.subdialogReplyTarget !== undefined
+            normalized.sideDialogReplyTarget !== undefined
                 ? {
-                    kind: 'new_course_runtime_subdialog',
+                    kind: 'new_course_runtime_sideDialog',
                     prompt: normalized.content,
                     msgId: normalized.msgId,
                     grammar: normalized.grammar,
@@ -764,7 +801,7 @@ class Dialog {
                     origin: 'runtime',
                     tellaskReplyDirective: normalized.tellaskReplyDirective,
                     skipTaskdoc: normalized.skipTaskdoc,
-                    subdialogReplyTarget: normalized.subdialogReplyTarget,
+                    sideDialogReplyTarget: normalized.sideDialogReplyTarget,
                 }
                 : normalized.tellaskReplyDirective !== undefined
                     ? {
@@ -829,13 +866,13 @@ class Dialog {
                         return prompt;
                     }
                     case 'registered_assignment_update':
-                    case 'new_course_runtime_subdialog': {
+                    case 'new_course_runtime_sideDialog': {
                         const prompt = {
                             ...promptCommon,
                             origin: 'runtime',
                             ...(state.skipTaskdoc === undefined ? {} : { skipTaskdoc: state.skipTaskdoc }),
                             tellaskReplyDirective: state.tellaskReplyDirective,
-                            subdialogReplyTarget: state.subdialogReplyTarget,
+                            sideDialogReplyTarget: state.sideDialogReplyTarget,
                         };
                         return prompt;
                     }
@@ -943,7 +980,7 @@ class Dialog {
                 origin: 'runtime',
                 tellaskReplyDirective: options.tellaskReplyDirective,
                 skipTaskdoc: options.skipTaskdoc,
-                subdialogReplyTarget: options.subdialogReplyTarget,
+                sideDialogReplyTarget: options.sideDialogReplyTarget,
                 runControl: undefined,
             };
             this.enqueueQueuedPromptState(created);
@@ -957,7 +994,7 @@ class Dialog {
             userLanguageCode: options.userLanguageCode ?? existing.userLanguageCode ?? this._lastUserLanguageCode,
             tellaskReplyDirective: options.tellaskReplyDirective,
             skipTaskdoc: options.skipTaskdoc ?? existing.skipTaskdoc,
-            subdialogReplyTarget: options.subdialogReplyTarget,
+            sideDialogReplyTarget: options.sideDialogReplyTarget,
             runControl: undefined,
         };
         this.replaceQueuedPromptState(existing.msgId, merged);
@@ -1005,25 +1042,25 @@ class Dialog {
         if (!trimmedPrompt) {
             throw new Error('newCoursePrompt is required to start a new course');
         }
-        const combinedPrompt = this instanceof SubDialog
-            ? `${(0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
-                fromAgentId: this.assignmentFromSup.originMemberId,
+        const combinedPrompt = this instanceof SideDialog
+            ? `${(0, inter_dialog_format_1.formatAssignmentFromAskerDialog)({
+                fromAgentId: this.assignmentFromAsker.originMemberId,
                 toAgentId: this.agentId,
-                callName: this.assignmentFromSup.callName,
-                mentionList: this.assignmentFromSup.mentionList,
-                tellaskContent: this.assignmentFromSup.tellaskContent,
+                callName: this.assignmentFromAsker.callName,
+                mentionList: this.assignmentFromAsker.mentionList,
+                tellaskContent: this.assignmentFromAsker.tellaskContent,
                 language: (0, work_language_1.getWorkLanguage)(),
-                collectiveTargets: this.assignmentFromSup.collectiveTargets ?? [this.agentId],
+                collectiveTargets: this.assignmentFromAsker.collectiveTargets ?? [this.agentId],
             })}\n---\n${trimmedPrompt}`
             : trimmedPrompt;
-        const basePrompt = this instanceof SubDialog
+        const basePrompt = this instanceof SideDialog
             ? {
                 content: combinedPrompt,
                 msgId: (0, id_1.generateShortId)(),
                 grammar: 'markdown',
                 userLanguageCode: this._lastUserLanguageCode,
                 origin: 'runtime',
-                ...buildSubdialogAssignmentPromptMeta(this),
+                ...buildSideDialogAssignmentPromptMeta(this),
             }
             : {
                 content: combinedPrompt,
@@ -1088,9 +1125,11 @@ class Dialog {
                 callName,
                 status,
                 content: result,
-                ...(options?.originCourse !== undefined ? { originCourse: options.originCourse } : {}),
-                ...(options?.calling_genseq !== undefined
-                    ? { calling_genseq: options.calling_genseq }
+                ...(options?.callSiteCourse !== undefined
+                    ? { callSiteCourse: options.callSiteCourse }
+                    : {}),
+                ...(options?.callSiteGenseq !== undefined
+                    ? { callSiteGenseq: options.callSiteGenseq }
                     : {}),
                 call: {
                     tellaskContent,
@@ -1108,11 +1147,11 @@ class Dialog {
                     callName,
                     status,
                     content: result,
-                    ...(options?.originCourse !== undefined
-                        ? { originCourse: options.originCourse }
+                    ...(options?.callSiteCourse !== undefined
+                        ? { callSiteCourse: options.callSiteCourse }
                         : {}),
-                    ...(options?.calling_genseq !== undefined
-                        ? { calling_genseq: options.calling_genseq }
+                    ...(options?.callSiteGenseq !== undefined
+                        ? { callSiteGenseq: options.callSiteGenseq }
                         : {}),
                     call: {
                         tellaskContent,
@@ -1129,11 +1168,11 @@ class Dialog {
                     callName,
                     status,
                     content: result,
-                    ...(options?.originCourse !== undefined
-                        ? { originCourse: options.originCourse }
+                    ...(options?.callSiteCourse !== undefined
+                        ? { callSiteCourse: options.callSiteCourse }
                         : {}),
-                    ...(options?.calling_genseq !== undefined
-                        ? { calling_genseq: options.calling_genseq }
+                    ...(options?.callSiteGenseq !== undefined
+                        ? { callSiteGenseq: options.callSiteGenseq }
                         : {}),
                     call: {
                         tellaskContent,
@@ -1144,22 +1183,22 @@ class Dialog {
                 };
         await this.receiveTellaskResult(tellaskResult);
     }
-    async receiveTellaskResponse(responderId, callName, mentionList, tellaskContent, status, subdialogId, options) {
+    async receiveTellaskResponse(responderId, callName, mentionList, tellaskContent, status, sideDialogId, options) {
         const currentCourse = this.activeGenCourseOrUndefined ?? this.currentCourse;
         const resultRoute = {
-            ...(subdialogId ? { calleeDialogId: subdialogId.selfId } : {}),
+            ...(sideDialogId ? { calleeDialogId: sideDialogId.selfId } : {}),
             ...(typeof options.calleeCourse === 'number' ? { calleeCourse: options.calleeCourse } : {}),
             ...(typeof options.calleeGenseq === 'number' ? { calleeGenseq: options.calleeGenseq } : {}),
         };
-        const carryoverOriginCourse = options.originCourse;
-        const isCrossCourseResponse = carryoverOriginCourse !== undefined && carryoverOriginCourse !== currentCourse;
+        const carryoverCallSiteCourse = options.callSiteCourse;
+        const isCrossCourseResponse = carryoverCallSiteCourse !== undefined && carryoverCallSiteCourse !== currentCourse;
         if (isCrossCourseResponse) {
             // Cross-course completion is not represented as a tool-result pair in the latest course.
             // Instead we write a canonical current-course carryover message that restates the older
             // tellask plus its resolution so the latest-course LLM context can read it directly.
             if (typeof options.carryoverContent !== 'string') {
                 throw new Error(`receiveTellaskResponse invariant violation: missing carryover content for cross-course response ` +
-                    `(callId=${options.callId}, callName=${callName}, originCourse=${options.originCourse}, currentCourse=${currentCourse})`);
+                    `(callId=${options.callId}, callName=${callName}, callSiteCourse=${options.callSiteCourse}, currentCourse=${currentCourse})`);
             }
             if (options.carryoverContent.trim() === '') {
                 throw new Error(`receiveTellaskResponse invariant violation: empty carryover content ` +
@@ -1178,7 +1217,7 @@ class Dialog {
                 genseq: this.activeGenSeqOrUndefined ?? 1,
                 content: options.carryoverContent,
                 ...(options.contentItems === undefined ? {} : { contentItems: options.contentItems }),
-                originCourse: carryoverOriginCourse,
+                callSiteCourse: carryoverCallSiteCourse,
                 carryoverCourse: currentCourse,
                 responderId,
                 callName,
@@ -1212,9 +1251,11 @@ class Dialog {
                 status,
                 content: options.response,
                 ...(options.contentItems === undefined ? {} : { contentItems: options.contentItems }),
-                ...(options.originCourse !== undefined ? { originCourse: options.originCourse } : {}),
-                ...(options.calling_genseq !== undefined
-                    ? { calling_genseq: options.calling_genseq }
+                ...(options.callSiteCourse !== undefined
+                    ? { callSiteCourse: options.callSiteCourse }
+                    : {}),
+                ...(options.callSiteGenseq !== undefined
+                    ? { callSiteGenseq: options.callSiteGenseq }
                     : {}),
                 call: {
                     tellaskContent,
@@ -1237,9 +1278,11 @@ class Dialog {
                     status,
                     content: options.response,
                     ...(options.contentItems === undefined ? {} : { contentItems: options.contentItems }),
-                    ...(options.originCourse !== undefined ? { originCourse: options.originCourse } : {}),
-                    ...(options.calling_genseq !== undefined
-                        ? { calling_genseq: options.calling_genseq }
+                    ...(options.callSiteCourse !== undefined
+                        ? { callSiteCourse: options.callSiteCourse }
+                        : {}),
+                    ...(options.callSiteGenseq !== undefined
+                        ? { callSiteGenseq: options.callSiteGenseq }
                         : {}),
                     call: {
                         tellaskContent,
@@ -1260,9 +1303,11 @@ class Dialog {
                     status,
                     content: options.response,
                     ...(options.contentItems === undefined ? {} : { contentItems: options.contentItems }),
-                    ...(options.originCourse !== undefined ? { originCourse: options.originCourse } : {}),
-                    ...(options.calling_genseq !== undefined
-                        ? { calling_genseq: options.calling_genseq }
+                    ...(options.callSiteCourse !== undefined
+                        ? { callSiteCourse: options.callSiteCourse }
+                        : {}),
+                    ...(options.callSiteGenseq !== undefined
+                        ? { callSiteGenseq: options.callSiteGenseq }
                         : {}),
                     call: {
                         tellaskContent,
@@ -1291,7 +1336,7 @@ class Dialog {
             this._activeGenSeq = genseq;
         }
         // Mark generation as started with the actual genseq
-        // This ensures subdialog_final_response_evt waits for both user_text and generating_start_evt
+        // This ensures sideDialog_final_response_evt waits for both user_text and generating_start_evt
         this.markGenerationStarted();
         await this.dlgStore.notifyGeneratingStart(this, msgId);
     }
@@ -1347,10 +1392,6 @@ class Dialog {
     async sayingFinish() {
         await this.dlgStore.sayingFinish(this);
     }
-    // Function call events (non-streaming mode - single event captures entire call)
-    async funcCallRequested(funcId, funcName, argumentsStr) {
-        await this.dlgStore.funcCallRequested(this, funcId, funcName, argumentsStr);
-    }
     async webSearchCall(payload) {
         await this.dlgStore.webSearchCall(this, payload);
     }
@@ -1404,65 +1445,40 @@ class Dialog {
     async persistTellaskCall(id, name, rawArgumentsText, genseq, options) {
         return await this.dlgStore.persistTellaskCall(this, id, name, rawArgumentsText, genseq, options);
     }
-    async persistFunctionCallResultPair(id, name, rawArgumentsText, genseq, result) {
-        return await this.dlgStore.persistFunctionCallResultPair(this, id, name, rawArgumentsText, genseq, result);
-    }
-    async persistTellaskCallResultPair(args) {
-        return await this.dlgStore.persistTellaskCallResultPair(this, args);
-    }
     /**
-     * Post subdialog completion response to this dialog.
-     * Phase 14: No wait - emit immediately with virtual gen markers for Type C subdialogs
+     * Post sideDialog completion response to this dialog.
+     * Phase 14: No wait - emit immediately with virtual gen markers for Type C sideDialogs
      */
-    async postSubdialogResponse(subdialogId, response) {
+    async postSideDialogResponse(sideDialogId, response) {
         try {
-            let responderId = subdialogId.rootId;
-            let responderAgentId;
-            let callName = 'tellaskSessionless';
-            let mentionList;
-            let tellaskContent = response;
-            let originMemberId = responderId;
-            let callId = '';
-            let sessionSlug;
-            try {
-                const metadata = await this.dlgStore.loadDialogMetadata(subdialogId, 'running');
-                if (metadata) {
-                    if (metadata.agentId) {
-                        responderId = metadata.agentId;
-                        responderAgentId = metadata.agentId;
-                        originMemberId = metadata.agentId;
-                    }
-                    if (metadata.assignmentFromSup) {
-                        callName = metadata.assignmentFromSup.callName;
-                        mentionList = metadata.assignmentFromSup.mentionList;
-                        tellaskContent = metadata.assignmentFromSup.tellaskContent;
-                        originMemberId = metadata.assignmentFromSup.originMemberId;
-                        callId = metadata.assignmentFromSup.callId;
-                    }
-                    if (typeof metadata.sessionSlug === 'string' && metadata.sessionSlug.trim() !== '') {
-                        sessionSlug = metadata.sessionSlug.trim();
-                    }
-                }
+            const metadata = await this.dlgStore.loadDialogMetadata(sideDialogId, 'running');
+            if (!metadata) {
+                throw new Error(`Missing sideDialog metadata for ${sideDialogId.valueOf()}`);
             }
-            catch (err) {
-                log_1.log.warn('Failed to load subdialog metadata for response labeling', undefined, {
-                    dialogId: this.id.selfId,
-                    subdialogId: subdialogId.selfId,
-                    error: err,
-                });
+            const assignmentFromAsker = await this.dlgStore.loadSideDialogAssignmentFromAsker(sideDialogId, 'running');
+            if (!assignmentFromAsker) {
+                throw new Error(`Missing sideDialog assignment for ${sideDialogId.valueOf()}`);
             }
-            if (callId.trim() === '') {
-                log_1.log.warn('Missing callId for subdialog response', undefined, {
-                    dialogId: this.id.selfId,
-                    subdialogId: subdialogId.selfId,
-                });
+            let responderId = sideDialogId.rootId;
+            let responderAgentId;
+            if (metadata.agentId.trim() !== '') {
+                responderId = metadata.agentId;
+                responderAgentId = metadata.agentId;
             }
+            const callName = assignmentFromAsker.callName;
+            let mentionList = assignmentFromAsker.mentionList;
+            const tellaskContent = assignmentFromAsker.tellaskContent;
+            const originMemberId = assignmentFromAsker.originMemberId;
+            const callId = assignmentFromAsker.callId;
+            const sessionSlug = typeof metadata.sessionSlug === 'string' && metadata.sessionSlug.trim() !== ''
+                ? metadata.sessionSlug.trim()
+                : undefined;
             if ((callName === 'tellask' || callName === 'tellaskSessionless') &&
                 (!Array.isArray(mentionList) || mentionList.length < 1)) {
                 mentionList = [`@${responderId}`];
             }
             // NO WAIT - emit immediately with virtual gen markers
-            // Emit virtual generating_start_evt for subdialog response bubble
+            // Emit virtual generating_start_evt for sideDialog response bubble
             await this.notifyGeneratingStart();
             const rawResponse = response;
             // Emit TellaskResultEvent
@@ -1470,8 +1486,8 @@ class Dialog {
                 switch (callName) {
                     case 'tellask':
                         if (!sessionSlug) {
-                            throw new Error(`postSubdialogResponse invariant violation: missing sessionSlug for tellask ` +
-                                `(dialogId=${this.id.selfId}, subdialogId=${subdialogId.selfId}, callId=${callId})`);
+                            throw new Error(`postSideDialogResponse invariant violation: missing sessionSlug for tellask ` +
+                                `(dialogId=${this.id.selfId}, sideDialogId=${sideDialogId.selfId}, callId=${callId})`);
                         }
                         return {
                             type: 'tellask_result_evt',
@@ -1491,7 +1507,7 @@ class Dialog {
                                 originMemberId,
                             },
                             route: {
-                                calleeDialogId: subdialogId.selfId,
+                                calleeDialogId: sideDialogId.selfId,
                             },
                         };
                     case 'tellaskSessionless':
@@ -1512,7 +1528,7 @@ class Dialog {
                                 originMemberId,
                             },
                             route: {
-                                calleeDialogId: subdialogId.selfId,
+                                calleeDialogId: sideDialogId.selfId,
                             },
                         };
                     case 'freshBootsReasoning':
@@ -1532,7 +1548,7 @@ class Dialog {
                                 originMemberId,
                             },
                             route: {
-                                calleeDialogId: subdialogId.selfId,
+                                calleeDialogId: sideDialogId.selfId,
                             },
                         };
                 }
@@ -1542,44 +1558,70 @@ class Dialog {
             await this.notifyGeneratingFinish();
         }
         catch (err) {
-            log_1.log.warn('Failed to post tellask_result_evt event', undefined, {
+            log_1.log.error('Failed to post tellask_result_evt event', err, {
                 error: err,
                 message: err instanceof Error ? err.message : String(err),
             });
+            throw err;
         }
     }
 }
 exports.Dialog = Dialog;
 /**
- * SubDialog - A subdialog created by a RootDialog for autonomous tellask sideline work.
- * Stores the root dialog for registry and lookup, and resolves its effective supdialog dynamically.
+ * SideDialog - A sideDialog created by a MainDialog for autonomous tellask Side Dialog work.
+ * Stores the main dialog for registry and lookup, and resolves its effective askerDialog dynamically.
  */
-class SubDialog extends Dialog {
-    constructor(dlgStore, rootDialog, taskDocPath, id, agentId, assignmentFromSup, sessionSlug, initialState) {
+class SideDialog extends Dialog {
+    constructor(dlgStore, mainDialog, taskDocPath, id, agentId, askerStack, sessionSlug, initialState) {
         super(dlgStore, taskDocPath, id, agentId, initialState);
         this._fbrConclusionToolsEnabled = false;
-        this.rootDialog = rootDialog;
+        this.mainDialog = mainDialog;
         this.sessionSlug = sessionSlug;
-        this.assignmentFromSup = assignmentFromSup;
-        const resolvedSupdialog = rootDialog.lookupDialog(assignmentFromSup.callerDialogId);
-        if (resolvedSupdialog && resolvedSupdialog.id.selfId === this.id.selfId) {
-            throw new Error(`SubDialog supdialog invariant violation: caller resolved to self ` +
-                `(rootId=${rootDialog.id.rootId}, selfId=${this.id.selfId}, callerDialogId=${assignmentFromSup.callerDialogId})`);
+        this.askerStack = askerStack;
+        const top = getSideDialogAskerStackTop(askerStack);
+        const assignmentFromAsker = getSideDialogAskerStackCurrentAssignment(askerStack);
+        if (top.assignmentFromAsker !== undefined &&
+            top.askerDialogId !== assignmentFromAsker.askerDialogId) {
+            throw new Error(`SideDialog askerStack invariant violation: askerDialogId must match assignment askerDialogId ` +
+                `(rootId=${mainDialog.id.rootId}, selfId=${this.id.selfId}, frameAskerDialogId=${top.askerDialogId}, assignmentAskerDialogId=${assignmentFromAsker.askerDialogId})`);
         }
-        else if (resolvedSupdialog) {
-            this._supdialog = resolvedSupdialog;
+        const resolvedAskerDialog = mainDialog.lookupDialog(top.askerDialogId);
+        if (resolvedAskerDialog && resolvedAskerDialog.id.selfId === this.id.selfId) {
+            throw new Error(`SideDialog askerDialog invariant violation: asker resolved to self ` +
+                `(rootId=${mainDialog.id.rootId}, selfId=${this.id.selfId}, askerDialogId=${top.askerDialogId})`);
         }
-        else {
-            throw new Error(`SubDialog supdialog invariant violation: caller missing from root registry ` +
-                `(rootId=${rootDialog.id.rootId}, selfId=${this.id.selfId}, callerDialogId=${assignmentFromSup.callerDialogId})`);
+        else if (!resolvedAskerDialog) {
+            throw new Error(`SideDialog askerDialog invariant violation: asker missing from root registry ` +
+                `(rootId=${mainDialog.id.rootId}, selfId=${this.id.selfId}, askerDialogId=${top.askerDialogId})`);
+        }
+        this.mainDialog.registerDialog(this);
+    }
+    get assignmentFromAsker() {
+        return getSideDialogAskerStackCurrentAssignment(this.askerStack);
+    }
+    set assignmentFromAsker(assignment) {
+        const nextFrame = buildSideDialogAskerStack({
+            askerDialogId: assignment.askerDialogId,
+            assignment,
+        }).askerStack[0];
+        if (!nextFrame) {
+            throw new Error(`SideDialog assignment stack invariant violation: empty generated frame`);
         }
-        this.rootDialog.registerDialog(this);
+        this.askerStack = {
+            askerStack: [...this.askerStack.askerStack, nextFrame],
+        };
     }
-    get supdialog() {
-        return this._supdialog;
+    get askerDialog() {
+        const askerDialogId = getSideDialogAskerStackTop(this.askerStack).askerDialogId;
+        const resolved = this.mainDialog.lookupDialog(askerDialogId);
+        if (!resolved || resolved.id.selfId === this.id.selfId) {
+            throw new Error(`SideDialog askerDialog invariant violation: asker missing or self ` +
+                `(rootId=${this.mainDialog.id.rootId}, selfId=${this.id.selfId}, askerDialogId=${askerDialogId})`);
+        }
+        return resolved;
     }
     get status() {
-        return this.rootDialog.status;
+        return this.mainDialog.status;
     }
     setFbrConclusionToolsEnabled(enabled) {
         this._fbrConclusionToolsEnabled = enabled;
@@ -1588,26 +1630,26 @@ class SubDialog extends Dialog {
         return this._fbrConclusionToolsEnabled;
     }
     /**
-     * Create a subdialog under the same root dialog tree.
-     * The new subdialog's effective supdialog is resolved via AssignmentFromSup.callerDialogId.
+     * Create a sideDialog under the same main dialog tree.
+     * The new sideDialog's effective askerDialog is resolved via AssignmentFromAsker.askerDialogId.
      */
-    async createSubDialog(targetAgentId, mentionList, tellaskContent, options) {
-        return await this.dlgStore.createSubDialog(this, targetAgentId, mentionList, tellaskContent, options);
+    async createSideDialog(targetAgentId, mentionList, tellaskContent, options) {
+        return await this.dlgStore.createSideDialog(this, targetAgentId, mentionList, tellaskContent, options);
     }
 }
-exports.SubDialog = SubDialog;
+exports.SideDialog = SideDialog;
 /**
- * RootDialog - The main/root dialog that can create and manage subdialogs.
+ * MainDialog - The main/main dialog that can create and manage sideDialogs.
  * Uses in-memory registries for O(1) dialog and Type B lookup.
  */
-class RootDialog extends Dialog {
+class MainDialog extends Dialog {
     constructor(dlgStore, taskDocPath, id, agentId, initialState) {
         super(dlgStore, taskDocPath, id, agentId, initialState);
         this._status = 'running';
         // Tracks all dialogs in this dialog tree for O(1) lookup
         this._localRegistry = new Map();
-        // Tracks Type-B registered subdialogs by agentId!sessionSlug
-        this._subdialogRegistry = new Map();
+        // Tracks Type-B registered sideDialogs by agentId!sessionSlug
+        this._sideDialogRegistry = new Map();
         this.registerDialog(this);
     }
     get status() {
@@ -1617,7 +1659,7 @@ class RootDialog extends Dialog {
         this._status = status;
     }
     /**
-     * Register a dialog (self or subdialog) in the local registry.
+     * Register a dialog (self or sideDialog) in the local registry.
      */
     registerDialog(dialog) {
         this._localRegistry.set(dialog.id.selfId, dialog);
@@ -1643,71 +1685,71 @@ class RootDialog extends Dialog {
     /**
      * Generate a registry key from agentId and sessionSlug.
      */
-    static makeSubdialogKey(agentId, sessionSlug) {
+    static makeSideDialogKey(agentId, sessionSlug) {
         return `${agentId}!${sessionSlug}`;
     }
     /**
-     * Register a Type-B subdialog for resumption.
+     * Register a Type-B sideDialog for resumption.
      */
-    registerSubdialog(subdialog) {
-        if (!subdialog.sessionSlug) {
+    registerSideDialog(sideDialog) {
+        if (!sideDialog.sessionSlug) {
             return;
         }
-        const key = RootDialog.makeSubdialogKey(subdialog.agentId, subdialog.sessionSlug);
-        this._subdialogRegistry.set(key, subdialog);
-        this.registerDialog(subdialog);
+        const key = MainDialog.makeSideDialogKey(sideDialog.agentId, sideDialog.sessionSlug);
+        this._sideDialogRegistry.set(key, sideDialog);
+        this.registerDialog(sideDialog);
     }
     /**
-     * Lookup a Type-B subdialog by agentId and sessionSlug.
+     * Lookup a Type-B sideDialog by agentId and sessionSlug.
      */
-    lookupSubdialog(agentId, sessionSlug) {
-        const key = RootDialog.makeSubdialogKey(agentId, sessionSlug);
-        return this._subdialogRegistry.get(key);
+    lookupSideDialog(agentId, sessionSlug) {
+        const key = MainDialog.makeSideDialogKey(agentId, sessionSlug);
+        return this._sideDialogRegistry.get(key);
     }
     /**
-     * Remove a Type-B subdialog from registry.
+     * Remove a Type-B sideDialog from registry.
      */
-    unregisterSubdialog(agentId, sessionSlug) {
-        const key = RootDialog.makeSubdialogKey(agentId, sessionSlug);
-        const subdialog = this._subdialogRegistry.get(key);
-        if (subdialog) {
-            this._localRegistry.delete(subdialog.id.selfId);
-            return this._subdialogRegistry.delete(key);
+    unregisterSideDialog(agentId, sessionSlug) {
+        const key = MainDialog.makeSideDialogKey(agentId, sessionSlug);
+        const sideDialog = this._sideDialogRegistry.get(key);
+        if (sideDialog) {
+            this._localRegistry.delete(sideDialog.id.selfId);
+            return this._sideDialogRegistry.delete(key);
         }
         return false;
     }
     /**
-     * Get all registered subdialogs.
+     * Get all registered sideDialogs.
      */
-    getRegisteredSubdialogs() {
-        return Array.from(this._subdialogRegistry.values());
+    getRegisteredSideDialogs() {
+        return Array.from(this._sideDialogRegistry.values());
     }
     /**
-     * Create a new subdialog for autonomous tellask sideline work.
+     * Create a new sideDialog for autonomous tellask Side Dialog work.
      */
-    async createSubDialog(targetAgentId, mentionList, tellaskContent, options) {
-        return await this.dlgStore.createSubDialog(this, targetAgentId, mentionList, tellaskContent, options);
+    async createSideDialog(targetAgentId, mentionList, tellaskContent, options) {
+        return await this.dlgStore.createSideDialog(this, targetAgentId, mentionList, tellaskContent, options);
     }
     /**
-     * Save subdialog registry to disk (registry.yaml).
+     * Save sideDialog registry to disk (registry.yaml).
      */
-    async saveSubdialogRegistry() {
-        const entries = Array.from(this._subdialogRegistry.entries()).map(([key, subdialog]) => ({
+    async saveSideDialogRegistry() {
+        const entries = Array.from(this._sideDialogRegistry.entries()).map(([key, sideDialog]) => ({
             key,
-            subdialogId: subdialog.id,
-            agentId: subdialog.agentId,
-            sessionSlug: subdialog.sessionSlug,
+            sideDialogId: sideDialog.id,
+            agentId: sideDialog.agentId,
+            sessionSlug: sideDialog.sessionSlug,
         }));
-        await this.dlgStore.saveSubdialogRegistry(this, this.id, entries, this.status);
+        await this.dlgStore.saveSideDialogRegistry(this, this.id, entries, this.status);
     }
     /**
-     * Load subdialog registry from disk (registry.yaml).
+     * Load sideDialog registry from disk (registry.yaml).
      */
-    async loadSubdialogRegistry() {
-        await this.dlgStore.loadSubdialogRegistry(this, this.status);
+    async loadSideDialogRegistry() {
+        await this.dlgStore.loadSideDialogRegistry(this, this.status);
     }
 }
-exports.RootDialog = RootDialog;
+exports.MainDialog = MainDialog;
 /**
  * The UI showing a dialog in realtime
  */
@@ -1717,32 +1759,36 @@ class DialogStore {
      *
      * impl here serves for demo purpose only
      *
-     * @param callerDialog
+     * @param askerDialog
      * @param targetAgentId
      * @param mentionList
      * @param tellaskContent
      * @returns
      */
-    async createSubDialog(callerDialog, targetAgentId, mentionList, tellaskContent, options) {
+    async createSideDialog(askerDialog, targetAgentId, mentionList, tellaskContent, options) {
         const generatedId = (0, id_2.generateDialogID)();
-        const rootDialog = callerDialog instanceof RootDialog
-            ? callerDialog
-            : callerDialog instanceof SubDialog
-                ? callerDialog.rootDialog
+        const mainDialog = askerDialog instanceof MainDialog
+            ? askerDialog
+            : askerDialog instanceof SideDialog
+                ? askerDialog.mainDialog
                 : (() => {
-                    throw new Error(`createSubDialog invariant violation: unsupported caller dialog type (${callerDialog.constructor.name})`);
+                    throw new Error(`createSideDialog invariant violation: unsupported asker type (${askerDialog.constructor.name})`);
                 })();
-        const subdialogId = new DialogID(generatedId, rootDialog.id.rootId);
-        return new SubDialog(this, rootDialog, callerDialog.taskDocPath, subdialogId, targetAgentId, {
+        const sideDialogId = new DialogID(generatedId, mainDialog.id.rootId);
+        const 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);
+        };
+        return new SideDialog(this, mainDialog, askerDialog.taskDocPath, sideDialogId, targetAgentId, buildSideDialogAskerStack({
+            askerDialogId: options.askerDialogId,
+            assignment,
+        }), options.sessionSlug);
     }
     /**
      * Receive and handle LLM generation streams (Markdown stream + tellask call stream)
@@ -1779,19 +1825,20 @@ class DialogStore {
     async loadDialogMetadata(_dialogId, _status) {
         return null;
     }
-    async loadPendingSubdialogs(_dialogId, _status) {
+    async loadSideDialogAssignmentFromAsker(_dialogId, _status) {
+        return null;
+    }
+    async loadPendingSideDialogs(_dialogId, _status) {
         return [];
     }
-    async saveSubdialogRegistry(_dialog, _rootDialogId, _entries, _status) { }
-    async loadSubdialogRegistry(_rootDialog, _status) { }
+    async saveSideDialogRegistry(_dialog, _mainDialogId, _entries, _status) { }
+    async loadSideDialogRegistry(_mainDialog, _status) { }
     /**
      * Clear Questions for Human state in storage
      */
     async clearQuestions4Human(_dialog) { }
     // Tellask-special call lifecycle methods
     async callingStart(_dialog, _payload) { }
-    // Function call event (non-streaming mode - single event)
-    async funcCallRequested(_dialog, _funcId, _funcName, _argumentsStr) { }
     async webSearchCall(_dialog, _payload) { }
     async nativeToolCall(_dialog, _payload) { }
     async toolResultImageIngest(_dialog, _payload) { }
@@ -1835,8 +1882,6 @@ class DialogStore {
      */
     async persistFunctionCall(_dialog, _id, _name, _rawArgumentsText, _genseq) { }
     async persistTellaskCall(_dialog, _id, _name, _rawArgumentsText, _genseq, _options) { }
-    async persistFunctionCallResultPair(_dialog, _id, _name, _rawArgumentsText, _genseq, _result) { }
-    async persistTellaskCallResultPair(_dialog, _args) { }
     /**
      * Start a new course in storage
      */