dominds 1.18.2 → 1.19.2

package/dist/dialog-instance-registry.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrRestoreRootDialog = getOrRestoreRootDialog;
+exports.getOrRestoreMainDialog = getOrRestoreMainDialog;
 exports.ensureDialogLoaded = ensureDialogLoaded;
 const diligence_1 = require("@longrun-ai/kernel/diligence");
 const dialog_1 = require("./dialog");
@@ -40,25 +40,22 @@ async function resolvePendingCourseStartPromptForRestore(args) {
     }
     return { pendingCourseStartPrompt: pending };
 }
-async function getOrRestoreRootDialog(rootId, status) {
+async function getOrRestoreMainDialog(rootId, status) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
         existing.setPersistenceStatus(status);
-        await existing.loadSubdialogRegistry();
-        await existing.loadPendingSubdialogsFromPersistence();
+        await existing.loadSideDialogRegistry();
+        await existing.loadPendingSideDialogsFromPersistence();
         return existing;
     }
-    const rootDialogId = new dialog_1.DialogID(rootId);
-    const rootState = await persistence_1.DialogPersistence.restoreDialog(rootDialogId, status);
+    const mainDialogId = new dialog_1.DialogID(rootId);
+    const rootState = await persistence_1.DialogPersistence.restoreDialog(mainDialogId, status);
     if (!rootState)
         return undefined;
     const rootMetadata = rootState.metadata;
-    if (rootMetadata.supdialogId !== undefined) {
-        return undefined;
-    }
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialogId, status);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(mainDialogId, status);
     const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
-        dialogId: rootDialogId,
+        dialogId: mainDialogId,
         status,
         messages: rootState.messages,
         latest,
@@ -72,8 +69,8 @@ async function getOrRestoreRootDialog(rootId, status) {
         diligencePushMax = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
     }
     const defaultDisableDiligencePush = diligencePushMax <= 0;
-    const rootStore = new persistence_1.DiskFileDialogStore(rootDialogId);
-    const rootDialog = new dialog_1.RootDialog(rootStore, rootMetadata.taskDocPath, rootDialogId, rootMetadata.agentId, {
+    const rootStore = new persistence_1.DiskFileDialogStore(mainDialogId);
+    const mainDialog = new dialog_1.MainDialog(rootStore, rootMetadata.taskDocPath, mainDialogId, rootMetadata.agentId, {
         messages: rootState.messages,
         reminders: rootState.reminders,
         currentCourse: rootState.currentCourse,
@@ -83,27 +80,27 @@ async function getOrRestoreRootDialog(rootId, status) {
     const persistedDisableDiligencePush = latest && typeof latest.disableDiligencePush === 'boolean'
         ? latest.disableDiligencePush
         : defaultDisableDiligencePush;
-    rootDialog.disableDiligencePush = persistedDisableDiligencePush;
+    mainDialog.disableDiligencePush = persistedDisableDiligencePush;
     const persistedRemainingBudget = latest && typeof latest.diligencePushRemainingBudget === 'number'
         ? latest.diligencePushRemainingBudget
         : undefined;
     const normalizedRemainingBudget = clampNonNegativeFiniteInt(persistedRemainingBudget, diligencePushMax > 0 ? diligencePushMax : 0);
-    rootDialog.diligencePushRemainingBudget =
+    mainDialog.diligencePushRemainingBudget =
         diligencePushMax > 0
             ? Math.min(normalizedRemainingBudget, diligencePushMax)
             : normalizedRemainingBudget;
-    rootDialog.setPersistenceStatus(status);
-    dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
-    // Keep the in-memory root dialog fully hydrated regardless of persistence status
-    // (running/completed/archived) so subdialog lookup is stable across UI navigation.
-    await rootDialog.loadSubdialogRegistry();
-    await rootDialog.loadPendingSubdialogsFromPersistence();
-    return rootDialog;
+    mainDialog.setPersistenceStatus(status);
+    dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
+    // Keep the in-memory main dialog fully hydrated regardless of persistence status
+    // (running/completed/archived) so sideDialog lookup is stable across UI navigation.
+    await mainDialog.loadSideDialogRegistry();
+    await mainDialog.loadPendingSideDialogsFromPersistence();
+    return mainDialog;
 }
-async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds = new Set()) {
+async function ensureDialogLoaded(mainDialog, targetId, status, visitedSelfIds = new Set()) {
     if (targetId.selfId === targetId.rootId)
-        return rootDialog;
-    const existing = rootDialog.lookupDialog(targetId.selfId);
+        return mainDialog;
+    const existing = mainDialog.lookupDialog(targetId.selfId);
     if (existing)
         return existing;
     if (visitedSelfIds.has(targetId.selfId))
@@ -112,9 +109,17 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
     const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(targetId, status);
     if (!metadata)
         return undefined;
-    // Ensure parent dialog (supdialog) exists in root registry for SubDialog.supdialog resolution.
-    if (metadata.supdialogId && metadata.supdialogId !== targetId.rootId) {
-        await ensureDialogLoaded(rootDialog, new dialog_1.DialogID(metadata.supdialogId, targetId.rootId), status, visitedSelfIds);
+    const askerStack = await persistence_1.DialogPersistence.loadSideDialogAskerStackState(targetId, status);
+    if (!askerStack) {
+        throw new Error(`ensureDialogLoaded invariant violation: missing asker stack for ${targetId.valueOf()}`);
+    }
+    const askerStackTop = askerStack.askerStack[askerStack.askerStack.length - 1];
+    if (!askerStackTop) {
+        throw new Error(`ensureDialogLoaded invariant violation: empty askerDialog stack for ${targetId.valueOf()}`);
+    }
+    // Ensure asker dialog exists in root registry for dynamic asker/askerDialog resolution.
+    if (askerStackTop.askerDialogId !== targetId.rootId) {
+        await ensureDialogLoaded(mainDialog, new dialog_1.DialogID(askerStackTop.askerDialogId, targetId.rootId), status, visitedSelfIds);
     }
     const state = await persistence_1.DialogPersistence.restoreDialog(targetId, status);
     if (!state)
@@ -126,26 +131,32 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
         messages: state.messages,
         latest,
     });
-    const assignmentFromSup = state.metadata.assignmentFromSup;
-    if (!assignmentFromSup)
-        return undefined;
-    // Ensure the caller dialog exists so SubDialog can resolve its effective supdialog.
-    if (assignmentFromSup.callerDialogId &&
-        assignmentFromSup.callerDialogId !== targetId.rootId &&
-        assignmentFromSup.callerDialogId !== targetId.selfId) {
-        await ensureDialogLoaded(rootDialog, new dialog_1.DialogID(assignmentFromSup.callerDialogId, targetId.rootId), status, visitedSelfIds);
+    const assignmentFromAsker = (() => {
+        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(`ensureDialogLoaded invariant violation: missing assignment frame in asker stack for ${targetId.valueOf()}`);
+    })();
+    // Ensure the tellasker exists so SideDialog can resolve its effective askerDialog.
+    if (assignmentFromAsker.askerDialogId &&
+        assignmentFromAsker.askerDialogId !== targetId.rootId &&
+        assignmentFromAsker.askerDialogId !== targetId.selfId) {
+        await ensureDialogLoaded(mainDialog, new dialog_1.DialogID(assignmentFromAsker.askerDialogId, targetId.rootId), status, visitedSelfIds);
     }
     const store = new persistence_1.DiskFileDialogStore(targetId);
-    const subdialog = new dialog_1.SubDialog(store, rootDialog, state.metadata.taskDocPath, targetId, state.metadata.agentId, assignmentFromSup, state.metadata.sessionSlug, {
+    const sideDialog = new dialog_1.SideDialog(store, mainDialog, metadata.taskDocPath, targetId, metadata.agentId, askerStack, metadata.sessionSlug, {
         messages: state.messages,
         reminders: state.reminders,
         currentCourse: state.currentCourse,
         contextHealth: state.contextHealth,
         pendingCourseStartPrompt,
     });
-    subdialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
-    if (subdialog.sessionSlug) {
-        rootDialog.registerSubdialog(subdialog);
+    sideDialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
+    if (sideDialog.sessionSlug) {
+        mainDialog.registerSideDialog(sideDialog);
     }
-    return subdialog;
+    return sideDialog;
 }

package/dist/dialog.d.ts

@@ -2,21 +2,21 @@
  * Module: dialog
  *
  * Provides the `Dialog` object for orchestrating conversations:
- * - Tracks messages, agent identity, optional supdialog/subdialog relationships
+ * - Tracks messages, agent identity, optional askerDialog/sideDialog relationships
  * - Receivers for streaming LLM output and tool results
- * - Helpers for spawning subdialogs and prompting human input
+ * - Helpers for spawning sideDialogs and prompting human input
  * - Persistence support for dialog state and message history
  *
  * Architecture (Phase 2):
  * - `Dialog` - Abstract base class for all dialogs
- * - `RootDialog` - Root dialog with subdialog registry
- * - `SubDialog` - Subdialog with root dialog reference and dynamic supdialog resolution
+ * - `MainDialog` - Main dialog with sideDialog registry
+ * - `SideDialog` - SideDialog with main dialog reference and dynamic askerDialog resolution
  */
 import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
 import type { DialogEvent, NativeToolCallPayload, ReminderContent, WebSearchCallAction, WebSearchCallSource } from '@longrun-ai/kernel/types/dialog';
-import type { DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogSubdialogReplyTarget, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
+import type { DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogSideDialogReplyTarget, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
-import type { CalleeCourseNumber, CalleeGenerationSeqNumber, CallingCourseNumber, CallingGenerationSeqNumber, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
+import type { CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
 import type { ToolResultImageIngest, UserImageIngest } from './llm/gen';
 import type { JsonValue } from './tool';
@@ -34,7 +34,7 @@ type NewCourseHook = (args: {
     runControl?: DialogRunControlSpec;
 }) => Promise<NewCourseHookResult>;
 export type DialogSuspensionStatusOptions = Readonly<{
-    allowPendingSubdialogs?: boolean;
+    allowPendingSideDialogs?: boolean;
 }>;
 export declare class DialogID {
     readonly selfId: string;
@@ -56,32 +56,33 @@ export declare class DialogID {
     hashCode(): string;
 }
 /**
- * Phase 6: Pending subdialog record for Type A subdialog supply mechanism.
- * Tracks a subdialog that was created but not yet completed.
+ * Phase 6: Pending sideDialog record for Type A sideDialog supply mechanism.
+ * Tracks a sideDialog that was created but not yet completed.
  */
-export interface PendingSubdialog {
-    subdialogId: DialogID;
+export interface PendingSideDialog {
+    sideDialogId: DialogID;
     createdAt: string;
     mentionList?: string[];
     tellaskContent: string;
     targetAgentId: string;
     callId: string;
-    callingCourse?: CallingCourseNumber;
+    callSiteCourse: CallSiteCourseNo;
+    callSiteGenseq: CallSiteGenseqNo;
     callType: 'A' | 'B' | 'C';
     sessionSlug?: string;
 }
 /**
- * Phase 6: Subdialog response record for Type A subdialog supply mechanism.
- * Tracks the response from a completed subdialog.
+ * Phase 6: SideDialog response record for Type A sideDialog supply mechanism.
+ * Tracks the response from a completed sideDialog.
  */
-export interface SubdialogResponse {
-    subdialogId: DialogID;
+export interface SideDialogResponse {
+    sideDialogId: DialogID;
     response: string;
     completedAt: string;
     callType: 'A' | 'B' | 'C';
 }
 /**
- * Common dialog initialization parameters (shared between RootDialog and SubDialog)
+ * Common dialog initialization parameters (shared between MainDialog and SideDialog)
  */
 export interface DialogInitParams {
     taskDocPath: string;
@@ -107,21 +108,25 @@ export type VisibleReminderTarget = Readonly<{
     agentId: string;
 }>;
 /**
- * Assignment from supdialog for subdialogs
+ * Assignment from askerDialog for sideDialogs
  */
-export interface AssignmentFromSup {
+export interface AssignmentFromAsker {
     callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
     mentionList?: string[];
     tellaskContent: string;
     originMemberId: string;
-    callerDialogId: string;
+    askerDialogId: string;
     callId: string;
     collectiveTargets?: string[];
     effectiveFbrEffort?: number;
 }
+export declare function buildSideDialogAskerStack(args: {
+    askerDialogId: string;
+    assignment: AssignmentFromAsker;
+}): DialogAskerStackState;
 /**
  * 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.
  */
 export declare abstract class Dialog {
     readonly dlgStore: DialogStore;
@@ -149,7 +154,7 @@ export declare abstract class Dialog {
     protected _courseRuntimeNoticeMsgs: ChatMessage[];
     protected _generationStarted: boolean;
     protected _generationStartedGenseq: number;
-    protected _pendingSubdialogIds: DialogID[];
+    protected _pendingSideDialogIds: DialogID[];
     protected _suspensionState: 'active' | 'suspended' | 'resumed';
     diligencePushRemainingBudget: number;
     disableDiligencePush: boolean;
@@ -161,7 +166,7 @@ export declare abstract class Dialog {
     getLastContextHealthGenseq(): number | undefined;
     get remindersVer(): number;
     touchReminders(): void;
-    get supdialog(): Dialog | undefined;
+    get askerDialog(): Dialog | undefined;
     getUiLanguage(): LanguageCode;
     setUiLanguage(language: LanguageCode): void;
     getLastUserLanguageCode(): LanguageCode;
@@ -174,7 +179,7 @@ export declare abstract 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
      */
@@ -209,11 +214,11 @@ export declare abstract class Dialog {
      */
     hasPendingQ4H(): Promise<boolean>;
     /**
-     * Check if dialog has pending subdialogs.
+     * Check if dialog has pending sideDialogs.
      */
-    hasPendingSubdialogs(): Promise<boolean>;
+    hasPendingSideDialogs(): Promise<boolean>;
     /**
-     * Check if dialog can be driven (not suspended for Q4H or subdialogs).
+     * Check if dialog can be driven (not suspended for Q4H or sideDialogs).
      */
     canDrive(options?: DialogSuspensionStatusOptions): Promise<boolean>;
     /**
@@ -221,31 +226,31 @@ export declare abstract class Dialog {
      */
     getSuspensionStatus(options?: DialogSuspensionStatusOptions): Promise<{
         q4h: boolean;
-        subdialogs: boolean;
-        blockingSubdialogs: boolean;
+        sideDialogs: boolean;
+        blockingSideDialogs: boolean;
         canDrive: boolean;
     }>;
-    get pendingSubdialogIds(): ReadonlyArray<DialogID>;
-    addPendingSubdialogs(ids: DialogID[]): void;
-    removePendingSubdialog(id: DialogID): void;
-    clearPendingSubdialogs(): void;
+    get pendingSideDialogIds(): ReadonlyArray<DialogID>;
+    addPendingSideDialogs(ids: DialogID[]): void;
+    removePendingSideDialog(id: DialogID): void;
+    clearPendingSideDialogs(): void;
     /**
-     * Load pending subdialogs from persistence into memory.
+     * Load pending sideDialogs from persistence into memory.
      * Used during crash recovery to restore suspension state.
      */
-    loadPendingSubdialogsFromPersistence(): Promise<void>;
+    loadPendingSideDialogsFromPersistence(): Promise<void>;
     /**
-     * Abstract method for creating subdialogs.
-     * Implemented by RootDialog to create SubDialog instances.
+     * Abstract method for creating sideDialogs.
+     * Implemented by MainDialog to create SideDialog instances.
      */
-    abstract createSubDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
+    abstract createSideDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
         callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
         originMemberId: string;
-        callerDialogId: string;
+        askerDialogId: string;
         callId: string;
         sessionSlug?: string;
         collectiveTargets?: string[];
-    }): Promise<SubDialog>;
+    }): Promise<SideDialog>;
     /**
      * Post a dialog event using the standard event registry.
      */
@@ -284,12 +289,12 @@ export declare abstract class Dialog {
     get hasActiveGeneration(): boolean;
     /**
      * 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(): boolean;
     /**
      * 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?: number): void;
@@ -337,7 +342,7 @@ export declare abstract class Dialog {
         userLanguageCode?: LanguageCode;
         tellaskReplyDirective: TellaskReplyDirective;
         skipTaskdoc?: boolean;
-        subdialogReplyTarget: DialogSubdialogReplyTarget;
+        sideDialogReplyTarget: DialogSideDialogReplyTarget;
     }): DialogQueuedPromptState;
     hasUpNext(): boolean;
     peekUpNext(): DialogQueuedPromptState | undefined;
@@ -364,16 +369,16 @@ export declare abstract class Dialog {
     receiveTellaskResult(result: TellaskResultMsg): Promise<void>;
     receiveTellaskCarryover(result: TellaskCarryoverMsg): Promise<void>;
     receiveTellaskCallResult(responderId: string, callName: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning', mentionList: string[] | undefined, tellaskContent: string, result: string, status: 'completed' | 'failed', callId: string, options?: {
-        originCourse?: CallingCourseNumber;
-        calling_genseq?: CallingGenerationSeqNumber;
+        callSiteCourse?: CallSiteCourseNo;
+        callSiteGenseq?: CallSiteGenseqNo;
     }): Promise<void>;
-    receiveTellaskResponse(responderId: string, callName: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning', mentionList: string[] | undefined, tellaskContent: string, status: 'completed' | 'failed', subdialogId: DialogID | undefined, options: {
+    receiveTellaskResponse(responderId: string, callName: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning', mentionList: string[] | undefined, tellaskContent: string, status: 'completed' | 'failed', sideDialogId: DialogID | undefined, options: {
         response: string;
         agentId: string;
         callId: string;
         originMemberId: string;
-        originCourse?: CallingCourseNumber;
-        calling_genseq?: CallingGenerationSeqNumber;
+        callSiteCourse?: CallSiteCourseNo;
+        callSiteGenseq?: CallSiteGenseqNo;
         carryoverContent?: string;
         contentItems?: DialogUserPrompt['contentItems'];
         sessionSlug?: string;
@@ -392,7 +397,6 @@ export declare abstract class Dialog {
     sayingStart(): Promise<void>;
     sayingChunk(chunk: string): Promise<void>;
     sayingFinish(): Promise<void>;
-    funcCallRequested(funcId: string, funcName: string, argumentsStr: string): Promise<void>;
     webSearchCall(payload: {
         source?: WebSearchCallSource;
         phase: 'added' | 'done';
@@ -428,63 +432,55 @@ export declare abstract class Dialog {
     persistTellaskCall(id: string, name: TellaskCallRecordName, rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
     }): Promise<void>;
-    persistFunctionCallResultPair(id: string, name: string, rawArgumentsText: string, genseq: number, result: FuncResultMsg): Promise<void>;
-    persistTellaskCallResultPair(args: {
-        id: string;
-        name: TellaskCallRecordName;
-        rawArgumentsText: string;
-        genseq: number;
-        result: TellaskResultMsg | FuncResultMsg;
-        deliveryMode: 'tellask_call_start' | 'func_call_requested';
-    }): Promise<void>;
     /**
-     * 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
      */
-    postSubdialogResponse(subdialogId: DialogID, response: string): Promise<void>;
+    postSideDialogResponse(sideDialogId: DialogID, response: string): Promise<void>;
 }
 /**
- * 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.
  */
-export declare class SubDialog extends Dialog {
-    readonly rootDialog: RootDialog;
+export declare class SideDialog extends Dialog {
+    readonly mainDialog: MainDialog;
     readonly sessionSlug?: string;
-    assignmentFromSup: AssignmentFromSup;
-    protected readonly _supdialog: Dialog;
+    askerStack: DialogAskerStackState;
     private _fbrConclusionToolsEnabled;
-    constructor(dlgStore: DialogStore, rootDialog: RootDialog, taskDocPath: string, id: DialogID | undefined, agentId: string, assignmentFromSup: AssignmentFromSup, sessionSlug?: string, initialState?: DialogInitParams['initialState']);
-    get supdialog(): Dialog;
+    constructor(dlgStore: DialogStore, mainDialog: MainDialog, taskDocPath: string, id: DialogID | undefined, agentId: string, askerStack: DialogAskerStackState, sessionSlug?: string, initialState?: DialogInitParams['initialState']);
+    get assignmentFromAsker(): AssignmentFromAsker;
+    set assignmentFromAsker(assignment: AssignmentFromAsker);
+    get askerDialog(): Dialog;
     get status(): 'running' | 'completed' | 'archived';
     setFbrConclusionToolsEnabled(enabled: boolean): void;
     areFbrConclusionToolsEnabled(): boolean;
     /**
-     * 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.
      */
-    createSubDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
+    createSideDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
         callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
         originMemberId: string;
-        callerDialogId: string;
+        askerDialogId: string;
         callId: string;
         sessionSlug?: string;
         collectiveTargets?: string[];
         effectiveFbrEffort?: number;
-    }): Promise<SubDialog>;
+    }): Promise<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.
  */
-export declare class RootDialog extends Dialog {
+export declare class MainDialog extends Dialog {
     private _status;
     private _localRegistry;
-    private _subdialogRegistry;
+    private _sideDialogRegistry;
     constructor(dlgStore: DialogStore, taskDocPath: string, id: DialogID | undefined, agentId: string, initialState?: DialogInitParams['initialState']);
     get status(): 'running' | 'completed' | 'archived';
     setPersistenceStatus(status: 'running' | 'completed' | 'archived'): void;
     /**
-     * Register a dialog (self or subdialog) in the local registry.
+     * Register a dialog (self or sideDialog) in the local registry.
      */
     registerDialog(dialog: Dialog): void;
     /**
@@ -502,43 +498,43 @@ export declare class RootDialog extends Dialog {
     /**
      * Generate a registry key from agentId and sessionSlug.
      */
-    static makeSubdialogKey(agentId: string, sessionSlug: string): string;
+    static makeSideDialogKey(agentId: string, sessionSlug: string): string;
     /**
-     * Register a Type-B subdialog for resumption.
+     * Register a Type-B sideDialog for resumption.
      */
-    registerSubdialog(subdialog: SubDialog): void;
+    registerSideDialog(sideDialog: SideDialog): void;
     /**
-     * Lookup a Type-B subdialog by agentId and sessionSlug.
+     * Lookup a Type-B sideDialog by agentId and sessionSlug.
      */
-    lookupSubdialog(agentId: string, sessionSlug: string): SubDialog | undefined;
+    lookupSideDialog(agentId: string, sessionSlug: string): SideDialog | undefined;
     /**
-     * Remove a Type-B subdialog from registry.
+     * Remove a Type-B sideDialog from registry.
      */
-    unregisterSubdialog(agentId: string, sessionSlug: string): boolean;
+    unregisterSideDialog(agentId: string, sessionSlug: string): boolean;
     /**
-     * Get all registered subdialogs.
+     * Get all registered sideDialogs.
      */
-    getRegisteredSubdialogs(): SubDialog[];
+    getRegisteredSideDialogs(): SideDialog[];
     /**
-     * Create a new subdialog for autonomous tellask sideline work.
+     * Create a new sideDialog for autonomous tellask Side Dialog work.
      */
-    createSubDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
+    createSideDialog(targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
         callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
         originMemberId: string;
-        callerDialogId: string;
+        askerDialogId: string;
         callId: string;
         sessionSlug?: string;
         collectiveTargets?: string[];
         effectiveFbrEffort?: number;
-    }): Promise<SubDialog>;
+    }): Promise<SideDialog>;
     /**
-     * Save subdialog registry to disk (registry.yaml).
+     * Save sideDialog registry to disk (registry.yaml).
      */
-    saveSubdialogRegistry(): Promise<void>;
+    saveSideDialogRegistry(): Promise<void>;
     /**
-     * Load subdialog registry from disk (registry.yaml).
+     * Load sideDialog registry from disk (registry.yaml).
      */
-    loadSubdialogRegistry(): Promise<void>;
+    loadSideDialogRegistry(): Promise<void>;
 }
 /**
  * The UI showing a dialog in realtime
@@ -549,21 +545,21 @@ export declare abstract class DialogStore {
      *
      * impl here serves for demo purpose only
      *
-     * @param callerDialog
+     * @param askerDialog
      * @param targetAgentId
      * @param mentionList
      * @param tellaskContent
      * @returns
      */
-    createSubDialog(callerDialog: Dialog, targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
+    createSideDialog(askerDialog: Dialog, targetAgentId: string, mentionList: string[] | undefined, tellaskContent: string, options: {
         callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
         originMemberId: string;
-        callerDialogId: string;
+        askerDialogId: string;
         callId: string;
         sessionSlug?: string;
         collectiveTargets?: string[];
         effectiveFbrEffort?: number;
-    }): Promise<SubDialog>;
+    }): Promise<SideDialog>;
     /**
      * Receive and handle LLM generation streams (Markdown stream + tellask call stream)
      */
@@ -593,14 +589,15 @@ export declare abstract class DialogStore {
      */
     loadQuestions4Human(_dialogId: DialogID, _status: 'running' | 'completed' | 'archived'): Promise<HumanQuestion[]>;
     loadDialogMetadata(_dialogId: DialogID, _status: 'running' | 'completed' | 'archived'): Promise<DialogMetadataFile | null>;
-    loadPendingSubdialogs(_dialogId: DialogID, _status: 'running' | 'completed' | 'archived'): Promise<PendingSubdialog[]>;
-    saveSubdialogRegistry(_dialog: RootDialog, _rootDialogId: DialogID, _entries: Array<{
+    loadSideDialogAssignmentFromAsker(_dialogId: DialogID, _status: 'running' | 'completed' | 'archived'): Promise<AssignmentFromAsker | null>;
+    loadPendingSideDialogs(_dialogId: DialogID, _status: 'running' | 'completed' | 'archived'): Promise<PendingSideDialog[]>;
+    saveSideDialogRegistry(_dialog: MainDialog, _mainDialogId: DialogID, _entries: Array<{
         key: string;
-        subdialogId: DialogID;
+        sideDialogId: DialogID;
         agentId: string;
         sessionSlug?: string;
     }>, _status: 'running' | 'completed' | 'archived'): Promise<void>;
-    loadSubdialogRegistry(_rootDialog: RootDialog, _status: 'running' | 'completed' | 'archived'): Promise<void>;
+    loadSideDialogRegistry(_mainDialog: MainDialog, _status: 'running' | 'completed' | 'archived'): Promise<void>;
     /**
      * Clear Questions for Human state in storage
      */
@@ -612,7 +609,6 @@ export declare abstract class DialogStore {
         sessionSlug?: string;
         tellaskContent: string;
     }): Promise<void>;
-    funcCallRequested(_dialog: Dialog, _funcId: string, _funcName: string, _argumentsStr: string): Promise<void>;
     webSearchCall(_dialog: Dialog, _payload: {
         source?: WebSearchCallSource;
         phase: 'added' | 'done';
@@ -662,15 +658,6 @@ export declare abstract class DialogStore {
     persistTellaskCall(_dialog: Dialog, _id: string, _name: TellaskCallRecordName, _rawArgumentsText: string, _genseq: number, _options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
     }): Promise<void>;
-    persistFunctionCallResultPair(_dialog: Dialog, _id: string, _name: string, _rawArgumentsText: string, _genseq: number, _result: FuncResultMsg): Promise<void>;
-    persistTellaskCallResultPair(_dialog: Dialog, _args: {
-        id: string;
-        name: TellaskCallRecordName;
-        rawArgumentsText: string;
-        genseq: number;
-        result: TellaskResultMsg | FuncResultMsg;
-        deliveryMode: 'tellask_call_start' | 'func_call_requested';
-    }): Promise<void>;
     /**
      * Start a new course in storage
      */