dominds 1.18.2 → 1.19.2

package/dist/llm/kernel-driver/loop.js

@@ -21,62 +21,62 @@ function formatDriveTriggerForLog(trigger) {
 }
 async function driveQueuedDialogsOnce() {
     const dialogsToDrive = dialog_global_registry_1.globalDialogRegistry.getDialogsNeedingDrive();
-    for (const rootDialog of dialogsToDrive) {
+    for (const mainDialog of dialogsToDrive) {
         try {
-            const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(mainDialog.id, 'running');
             const executionMarker = latest?.executionMarker;
-            const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(rootDialog.id);
+            const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(mainDialog.id);
             const interruptedRequiresExplicitResume = executionMarker?.kind === 'interrupted' &&
                 (0, dialog_interruption_1.doesInterruptionReasonRequireExplicitResume)(executionMarker.reason);
             if (interruptedRequiresExplicitResume || stopRequested !== undefined) {
-                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(mainDialog.id.rootId, {
                     source: 'kernel_driver_backend_loop',
                     reason: interruptedRequiresExplicitResume
                         ? 'execution_marker_blocked:interrupted'
                         : `stop_requested:${stopRequested}`,
                 });
-                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                await persistence_1.DialogPersistence.setNeedsDrive(mainDialog.id, false, mainDialog.status);
                 continue;
             }
-            if ((0, dialog_display_state_1.hasActiveRun)(rootDialog.id)) {
+            if ((0, dialog_display_state_1.hasActiveRun)(mainDialog.id)) {
                 log_1.log.debug('Backend driver deferred queued root drive because dialog already has an active run', undefined, {
-                    dialogId: rootDialog.id.valueOf(),
-                    rootId: rootDialog.id.rootId,
+                    dialogId: mainDialog.id.valueOf(),
+                    rootId: mainDialog.id.rootId,
                 });
-                dialog_global_registry_1.globalDialogRegistry.noteActiveRunBlockedQueuedDrive(rootDialog.id.rootId);
+                dialog_global_registry_1.globalDialogRegistry.noteActiveRunBlockedQueuedDrive(mainDialog.id.rootId);
                 continue;
             }
-            if (!(await rootDialog.canDrive())) {
+            if (!(await mainDialog.canDrive())) {
                 continue;
             }
-            await (0, engine_1.driveDialogStream)(rootDialog, undefined, true, {
+            await (0, engine_1.driveDialogStream)(mainDialog, undefined, true, {
                 source: 'kernel_driver_backend_loop',
                 reason: 'global_dialog_registry_needs_drive',
             });
-            const status = await rootDialog.getSuspensionStatus();
-            const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
+            const status = await mainDialog.getSuspensionStatus();
+            const shouldStayQueued = mainDialog.hasUpNext() || !status.canDrive;
             if (shouldStayQueued) {
-                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId, {
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(mainDialog.id.rootId, {
                     source: 'kernel_driver_backend_loop',
-                    reason: rootDialog.hasUpNext() ? 'post_drive_upnext_pending' : 'post_drive_suspended',
+                    reason: mainDialog.hasUpNext() ? 'post_drive_upnext_pending' : 'post_drive_suspended',
                 });
-                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
+                await persistence_1.DialogPersistence.setNeedsDrive(mainDialog.id, true, mainDialog.status);
             }
             else {
-                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(mainDialog.id.rootId, {
                     source: 'kernel_driver_backend_loop',
                     reason: 'post_drive_idle',
                 });
-                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                await persistence_1.DialogPersistence.setNeedsDrive(mainDialog.id, false, mainDialog.status);
             }
-            const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(rootDialog.id.rootId);
+            const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(mainDialog.id.rootId);
             const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
-            if (status.subdialogs) {
-                log_1.log.debug(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`, undefined, {
-                    rootId: rootDialog.id.rootId,
+            if (status.sideDialogs) {
+                log_1.log.debug(`Dialog ${mainDialog.id.rootId} suspended, waiting for sideDialogs`, undefined, {
+                    rootId: mainDialog.id.rootId,
                     waitingQ4H: status.q4h,
-                    waitingSubdialogs: status.subdialogs,
-                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    waitingSideDialogs: status.sideDialogs,
+                    hasQueuedUpNext: mainDialog.hasUpNext(),
                     lastDriveTrigger: lastTrigger
                         ? {
                             action: lastTrigger.action,
@@ -92,11 +92,11 @@ async function driveQueuedDialogsOnce() {
                 });
             }
             if (status.q4h) {
-                log_1.log.debug(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`, undefined, {
-                    rootId: rootDialog.id.rootId,
+                log_1.log.debug(`Dialog ${mainDialog.id.rootId} awaiting Q4H answer`, undefined, {
+                    rootId: mainDialog.id.rootId,
                     waitingQ4H: status.q4h,
-                    waitingSubdialogs: status.subdialogs,
-                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    waitingSideDialogs: status.sideDialogs,
+                    hasQueuedUpNext: mainDialog.hasUpNext(),
                     lastDriveTrigger: lastTrigger
                         ? {
                             action: lastTrigger.action,
@@ -113,8 +113,8 @@ async function driveQueuedDialogsOnce() {
             }
         }
         catch (err) {
-            log_1.log.error(`Error driving dialog ${rootDialog.id.rootId}:`, err, undefined, {
-                dialogId: rootDialog.id.rootId,
+            log_1.log.error(`Error driving dialog ${mainDialog.id.rootId}:`, err, undefined, {
+                dialogId: mainDialog.id.rootId,
             });
         }
     }

package/dist/llm/kernel-driver/reply-guidance.js

@@ -14,28 +14,22 @@ const tellask_special_1 = require("./tellask-special");
 const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
 const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
 async function resolveReplyTargetAgentId(args) {
-    switch (args.directive.expectedReplyCallName) {
-        case 'replyTellaskBack': {
-            const rootDialog = args.dlg instanceof dialog_1.RootDialog
-                ? args.dlg
-                : args.dlg instanceof dialog_1.SubDialog
-                    ? args.dlg.rootDialog
-                    : undefined;
-            if (!rootDialog) {
-                return undefined;
-            }
-            const targetDialogId = new dialog_1.DialogID(args.directive.targetDialogId, rootDialog.id.rootId);
-            const targetDialog = rootDialog.lookupDialog(targetDialogId.selfId) ??
-                (await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, targetDialogId, rootDialog.status));
-            return targetDialog?.agentId;
-        }
-        case 'replyTellask':
-        case 'replyTellaskSessionless':
-            return args.dlg instanceof dialog_1.SubDialog ? args.dlg.assignmentFromSup.originMemberId : undefined;
+    const mainDialog = args.dlg instanceof dialog_1.MainDialog
+        ? args.dlg
+        : args.dlg instanceof dialog_1.SideDialog
+            ? args.dlg.mainDialog
+            : undefined;
+    if (!mainDialog) {
+        return undefined;
     }
+    const targetDialogId = new dialog_1.DialogID(args.directive.targetDialogId, mainDialog.id.rootId);
+    const targetDialog = mainDialog.lookupDialog(targetDialogId.selfId) ??
+        (await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, targetDialogId, mainDialog.status));
+    return targetDialog?.agentId;
 }
 function buildPromptContentWithExactReplyToolName(args) {
-    const isFbrSubdialog = args.dlg instanceof dialog_1.SubDialog && args.dlg.assignmentFromSup.callName === 'freshBootsReasoning';
+    const isFbrSideDialog = args.dlg instanceof dialog_1.SideDialog &&
+        args.dlg.assignmentFromAsker.callName === 'freshBootsReasoning';
     const noActivePrefix = args.language === 'zh'
         ? '[Dominds 当前无跨对话回复义务]'
         : '[Dominds no active inter-dialog reply]';
@@ -48,10 +42,10 @@ function buildPromptContentWithExactReplyToolName(args) {
     ];
     const directive = args.activeReplyDirective;
     if (!directive) {
-        if (isFbrSubdialog) {
+        if (isFbrSideDialog) {
             return args.prompt.content;
         }
-        if (!(args.dlg instanceof dialog_1.SubDialog)) {
+        if (!(args.dlg instanceof dialog_1.SideDialog)) {
             return args.prompt.content;
         }
         if (args.prompt.content.startsWith(noActivePrefix)) {
@@ -89,33 +83,33 @@ function hasSameReplyDirective(left, right) {
     if (left.expectedReplyCallName !== right.expectedReplyCallName) {
         return false;
     }
-    if (left.targetCallId !== right.targetCallId || left.tellaskContent !== right.tellaskContent) {
+    if (left.targetDialogId !== right.targetDialogId ||
+        left.targetCallId !== right.targetCallId ||
+        left.tellaskContent !== right.tellaskContent) {
         return false;
     }
-    if (left.expectedReplyCallName === 'replyTellaskBack') {
-        return (right.expectedReplyCallName === 'replyTellaskBack' &&
-            left.targetDialogId === right.targetDialogId);
-    }
     return true;
 }
-function buildCurrentSubdialogAssignmentDirective(dlg) {
-    switch (dlg.assignmentFromSup.callName) {
+function buildCurrentSideDialogAssignmentDirective(dlg) {
+    switch (dlg.assignmentFromAsker.callName) {
         case 'tellask':
             return {
                 expectedReplyCallName: 'replyTellask',
-                targetCallId: dlg.assignmentFromSup.callId,
-                tellaskContent: dlg.assignmentFromSup.tellaskContent,
+                targetDialogId: dlg.assignmentFromAsker.askerDialogId,
+                targetCallId: dlg.assignmentFromAsker.callId,
+                tellaskContent: dlg.assignmentFromAsker.tellaskContent,
             };
         case 'tellaskSessionless':
         case 'freshBootsReasoning':
             return {
                 expectedReplyCallName: 'replyTellaskSessionless',
-                targetCallId: dlg.assignmentFromSup.callId,
-                tellaskContent: dlg.assignmentFromSup.tellaskContent,
+                targetDialogId: dlg.assignmentFromAsker.askerDialogId,
+                targetCallId: dlg.assignmentFromAsker.callId,
+                tellaskContent: dlg.assignmentFromAsker.tellaskContent,
             };
         default: {
-            const _exhaustive = dlg.assignmentFromSup.callName;
-            throw new Error(`Unsupported subdialog assignment callName: ${_exhaustive}`);
+            const _exhaustive = dlg.assignmentFromAsker.callName;
+            throw new Error(`Unsupported sideDialog assignment callName: ${_exhaustive}`);
         }
     }
 }
@@ -128,15 +122,15 @@ async function hasCurrentCourseHumanPromptRecord(args) {
     }
     return false;
 }
-async function resolveFreshCurrentSubdialogAssignmentDirective(args) {
-    if (!(args.dlg instanceof dialog_1.SubDialog) || args.prompt?.origin !== 'runtime') {
+async function resolveFreshCurrentSideDialogAssignmentDirective(args) {
+    if (!(args.dlg instanceof dialog_1.SideDialog) || args.prompt?.origin !== 'runtime') {
         return undefined;
     }
     const promptDirective = args.prompt.tellaskReplyDirective;
     if (!promptDirective) {
         return undefined;
     }
-    const currentAssignmentDirective = buildCurrentSubdialogAssignmentDirective(args.dlg);
+    const currentAssignmentDirective = buildCurrentSideDialogAssignmentDirective(args.dlg);
     if (!hasSameReplyDirective(promptDirective, currentAssignmentDirective)) {
         return undefined;
     }
@@ -174,23 +168,23 @@ async function resolveFreshPendingAskBackReplyDirective(args) {
     })) {
         return undefined;
     }
-    const rootDialog = args.dlg instanceof dialog_1.RootDialog
+    const mainDialog = args.dlg instanceof dialog_1.MainDialog
         ? args.dlg
-        : args.dlg instanceof dialog_1.SubDialog
-            ? args.dlg.rootDialog
+        : args.dlg instanceof dialog_1.SideDialog
+            ? args.dlg.mainDialog
             : undefined;
-    if (!rootDialog) {
+    if (!mainDialog) {
         return undefined;
     }
-    const requesterDialogId = new dialog_1.DialogID(prompt.tellaskReplyDirective.targetDialogId, rootDialog.id.rootId);
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(requesterDialogId, rootDialog.status);
+    const askBackAskerDialogId = new dialog_1.DialogID(prompt.tellaskReplyDirective.targetDialogId, mainDialog.id.rootId);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(askBackAskerDialogId, mainDialog.status);
     if (!latest) {
         return undefined;
     }
     const targetCallId = prompt.tellaskReplyDirective.targetCallId.trim();
     let sawAskBackCall = false;
     for (let course = latest.currentCourse; course >= 1; course -= 1) {
-        const events = await persistence_1.DialogPersistence.loadCourseEvents(requesterDialogId, course, rootDialog.status);
+        const events = await persistence_1.DialogPersistence.loadCourseEvents(askBackAskerDialogId, course, mainDialog.status);
         for (const event of events) {
             if (event.type === 'tellask_result_record' && event.callId.trim() === targetCallId) {
                 return undefined;
@@ -234,7 +228,7 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     // 3. manual Continue later decides from fresh persistence facts whether the dialog should stay
     //    blocked or resume real driving.
     //
-    // Do not "simplify" this into a pure display-state check or a pure pending-subdialog check.
+    // Do not "simplify" this into a pure display-state check or a pure pending-sideDialog check.
     // Proceeding dialogs with a still-active reply obligation are part of the same rule: a fresh
     // user interjection should still suppress the live reply obligation and answer locally first.
     // The business anchor is the deferred reply reassertion, while the paused execution marker keeps
@@ -257,20 +251,20 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
         (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
         return true;
     }
-    const activeReplyDirective = await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg);
+    const activeReplyDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dlg);
     if (activeReplyDirective) {
         return true;
     }
     // Use strict persistence reads here. This branch changes business behavior, so a read failure
-    // must loud-fail the round instead of being silently treated as "pending subdialogs exist".
-    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(args.dlg.id, args.dlg.status);
-    return pendingSubdialogs.length > 0;
+    // must loud-fail the round instead of being silently treated as "pending sideDialogs exist".
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(args.dlg.id, args.dlg.status);
+    return pendingSideDialogs.length > 0;
 }
 async function resolvePromptReplyGuidance(args) {
     const prompt = args.prompt;
     const isQ4HAnswerPrompt = typeof prompt?.q4hAnswerCallId === 'string' && prompt.q4hAnswerCallId.trim() !== '';
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
-    const persistedCurrentSubdialogAssignmentDirective = await resolveFreshCurrentSubdialogAssignmentDirective({
+    const persistedCurrentSideDialogAssignmentDirective = await resolveFreshCurrentSideDialogAssignmentDirective({
         dlg: args.dlg,
         prompt,
     });
@@ -283,10 +277,11 @@ async function resolvePromptReplyGuidance(args) {
         latest.pendingCourseStartPrompt.origin === 'runtime'
         ? latest.pendingCourseStartPrompt.tellaskReplyDirective
         : undefined;
-    const persistedActiveReplyDirective = persistedCurrentSubdialogAssignmentDirective ??
+    const persistedActiveReplyObligation = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dlg);
+    const persistedActiveReplyDirective = persistedCurrentSideDialogAssignmentDirective ??
         persistedPendingAskBackReplyDirective ??
         persistedPendingCourseStartDirective ??
-        (await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg));
+        persistedActiveReplyObligation;
     const suppressInterDialogReplyGuidance = isQ4HAnswerPrompt
         ? false
         : await shouldSuppressInterDialogReplyGuidanceForUserInterjection({

package/dist/llm/kernel-driver/restore.d.ts

@@ -5,9 +5,9 @@ type RestoreSummary = {
     totalCourses: number;
     completionStatus: 'incomplete' | 'complete' | 'failed';
 };
-export declare function restoreDialogHierarchy(rootDialogId: string, status?: RestoreStatus): Promise<{
-    rootDialog: Dialog;
-    subdialogs: Map<string, Dialog>;
+export declare function restoreDialogHierarchy(mainDialogId: string, status?: RestoreStatus): Promise<{
+    mainDialog: Dialog;
+    sideDialogs: Map<string, Dialog>;
     summary: RestoreSummary;
 }>;
 export {};

package/dist/llm/kernel-driver/restore.js

@@ -11,45 +11,40 @@ const dialog_global_registry_1 = require("../../dialog-global-registry");
 const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
-async function restoreDialogHierarchy(rootDialogId, status = 'running') {
+async function restoreDialogHierarchy(mainDialogId, status = 'running') {
     try {
-        const rootDialogIdent = new dialog_1.DialogID(rootDialogId);
-        const rootMeta = await persistence_1.DialogPersistence.loadRootDialogMetadata(rootDialogIdent, status);
-        if (rootMeta?.supdialogId) {
-            throw new Error(`Expected root dialog ${rootDialogId} but found subdialog metadata with supdialogId: ${rootMeta.supdialogId}`);
+        const mainDialog = await (0, dialog_instance_registry_1.getOrRestoreMainDialog)(mainDialogId, status);
+        if (!mainDialog) {
+            throw new Error(`Failed to restore dialog hierarchy for ${mainDialogId} from status ${status}`);
         }
-        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootDialogId, status);
-        if (!rootDialog) {
-            throw new Error(`Failed to restore dialog hierarchy for ${rootDialogId} from status ${status}`);
-        }
-        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
-        const subdialogs = new Map();
-        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(rootDialogIdent, status);
-        const subdialogsPath = path_1.default.join(rootPath, 'subdialogs');
-        let allSubdialogIds = [];
+        dialog_global_registry_1.globalDialogRegistry.register(mainDialog);
+        const sideDialogs = new Map();
+        const rootPath = persistence_1.DialogPersistence.getMainDialogPath(mainDialog.id, status);
+        const sideDialogsPath = path_1.default.join(rootPath, 'sideDialogs');
+        let allSideDialogIds = [];
         try {
-            const entries = await fs_1.default.promises.readdir(subdialogsPath, { withFileTypes: true });
-            allSubdialogIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+            const entries = await fs_1.default.promises.readdir(sideDialogsPath, { withFileTypes: true });
+            allSideDialogIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
         }
         catch (err) {
             const code = typeof err === 'object' && err !== null && 'code' in err
                 ? err.code
                 : undefined;
             if (code !== 'ENOENT') {
-                log_1.log.warn(`Failed to read subdialogs directory: ${subdialogsPath}, returning empty array`, err);
+                log_1.log.warn(`Failed to read sideDialogs directory: ${sideDialogsPath}, returning empty array`, err);
             }
-            allSubdialogIds = [];
+            allSideDialogIds = [];
         }
-        for (const subdialogId of allSubdialogIds) {
-            const restoredSubdialogId = new dialog_1.DialogID(subdialogId, rootDialog.id.rootId);
-            const dialog = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, restoredSubdialogId, status);
+        for (const sideDialogId of allSideDialogIds) {
+            const restoredSideDialogId = new dialog_1.DialogID(sideDialogId, mainDialog.id.rootId);
+            const dialog = await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, restoredSideDialogId, status);
             if (dialog && dialog.id.selfId !== dialog.id.rootId) {
-                subdialogs.set(subdialogId, dialog);
+                sideDialogs.set(sideDialogId, dialog);
             }
         }
-        let totalMessages = rootDialog.msgs.length;
-        let totalCourses = rootDialog.currentCourse;
-        for (const dialog of subdialogs.values()) {
+        let totalMessages = mainDialog.msgs.length;
+        let totalCourses = mainDialog.currentCourse;
+        for (const dialog of sideDialogs.values()) {
             totalMessages += dialog.msgs.length;
             if (dialog.currentCourse > totalCourses) {
                 totalCourses = dialog.currentCourse;
@@ -61,13 +56,13 @@ async function restoreDialogHierarchy(rootDialogId, status = 'running') {
             completionStatus: 'incomplete',
         };
         return {
-            rootDialog,
-            subdialogs,
+            mainDialog,
+            sideDialogs,
             summary,
         };
     }
     catch (error) {
-        log_1.log.error(`Failed to restore dialog hierarchy for ${rootDialogId}:`, error);
+        log_1.log.error(`Failed to restore dialog hierarchy for ${mainDialogId}:`, error);
         throw error;
     }
 }

package/dist/llm/kernel-driver/runtime.d.ts

@@ -22,7 +22,7 @@ export declare class LlmRequestFailedError extends Error {
 }
 export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
     dlg: Dialog;
-    isRootDialog: boolean;
+    isMainDialog: boolean;
     remainingBudget: number;
     diligencePushMax: number;
     suppressDiligencePush?: boolean;

package/dist/llm/kernel-driver/runtime.js

@@ -122,7 +122,7 @@ async function resolveRtwsDiligenceConfig() {
     };
 }
 async function maybePrepareDiligenceAutoContinuePrompt(options) {
-    if (!options.isRootDialog) {
+    if (!options.isMainDialog) {
         return { kind: 'disabled', nextRemainingBudget: options.remainingBudget };
     }
     if (options.dlg.disableDiligencePush || options.suppressDiligencePush === true) {

package/dist/llm/kernel-driver/sideDialog-txn.d.ts

@@ -0,0 +1,8 @@
+import type { DialogID } from '../../dialog';
+import { DialogPersistence } from '../../persistence';
+export type TakenSideDialogResponse = Awaited<ReturnType<typeof DialogPersistence.takeSideDialogResponses>>[number];
+export declare function takeSideDialogResponses(dialogId: DialogID): Promise<TakenSideDialogResponse[]>;
+export declare function commitTakenSideDialogResponses(dialogId: DialogID): Promise<void>;
+export declare function rollbackTakenSideDialogResponses(dialogId: DialogID): Promise<void>;
+export declare function withSideDialogTxnLock<T>(dialogId: DialogID, fn: () => Promise<T>): Promise<T>;
+export declare function withSideDialogTxnLocks<T>(dialogIds: readonly DialogID[], fn: () => Promise<T>): Promise<T>;

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.takeSubdialogResponses = takeSubdialogResponses;
-exports.commitTakenSubdialogResponses = commitTakenSubdialogResponses;
-exports.rollbackTakenSubdialogResponses = rollbackTakenSubdialogResponses;
-exports.withSubdialogTxnLock = withSubdialogTxnLock;
-exports.withSubdialogTxnLocks = withSubdialogTxnLocks;
+exports.takeSideDialogResponses = takeSideDialogResponses;
+exports.commitTakenSideDialogResponses = commitTakenSideDialogResponses;
+exports.rollbackTakenSideDialogResponses = rollbackTakenSideDialogResponses;
+exports.withSideDialogTxnLock = withSideDialogTxnLock;
+exports.withSideDialogTxnLocks = withSideDialogTxnLocks;
 const persistence_1 = require("../../persistence");
 const async_fifo_mutex_1 = require("../../runtime/async-fifo-mutex");
 const suspensionStateMutexes = new Map();
@@ -23,25 +23,25 @@ async function withSuspensionStateLock(dialogId, fn) {
         release();
     }
 }
-async function takeSubdialogResponses(dialogId) {
+async function takeSideDialogResponses(dialogId) {
     return await withSuspensionStateLock(dialogId, async () => {
-        return await persistence_1.DialogPersistence.takeSubdialogResponses(dialogId);
+        return await persistence_1.DialogPersistence.takeSideDialogResponses(dialogId);
     });
 }
-async function commitTakenSubdialogResponses(dialogId) {
+async function commitTakenSideDialogResponses(dialogId) {
     await withSuspensionStateLock(dialogId, async () => {
-        await persistence_1.DialogPersistence.commitTakenSubdialogResponses(dialogId);
+        await persistence_1.DialogPersistence.commitTakenSideDialogResponses(dialogId);
     });
 }
-async function rollbackTakenSubdialogResponses(dialogId) {
+async function rollbackTakenSideDialogResponses(dialogId) {
     await withSuspensionStateLock(dialogId, async () => {
-        await persistence_1.DialogPersistence.rollbackTakenSubdialogResponses(dialogId);
+        await persistence_1.DialogPersistence.rollbackTakenSideDialogResponses(dialogId);
     });
 }
-async function withSubdialogTxnLock(dialogId, fn) {
+async function withSideDialogTxnLock(dialogId, fn) {
     return await withSuspensionStateLock(dialogId, fn);
 }
-async function withSubdialogTxnLocks(dialogIds, fn) {
+async function withSideDialogTxnLocks(dialogIds, fn) {
     const ordered = [
         ...new Map(dialogIds.map((dialogId) => [dialogId.key(), dialogId])).values(),
     ].sort((left, right) => left.key().localeCompare(right.key()));

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

@@ -1,11 +1,11 @@
-import { type CallerCourseNumber } from '@longrun-ai/kernel/types/storage';
-import { Dialog, DialogID, SubDialog } from '../../dialog';
-import type { KernelDriverDriveCallOptions, KernelDriverSubdialogReplyTarget } from './types';
-export type SubdialogReplyTarget = KernelDriverSubdialogReplyTarget;
+import { type AskerCourseNumber } from '@longrun-ai/kernel/types/storage';
+import { Dialog, DialogID, SideDialog } from '../../dialog';
+import type { KernelDriverDriveCallOptions, KernelDriverSideDialogReplyTarget } from './types';
+export type SideDialogReplyTarget = KernelDriverSideDialogReplyTarget;
 export type ScheduleDriveFn = (dialog: Dialog, options: KernelDriverDriveCallOptions) => void;
-export declare function supplyResponseToSupdialog(args: {
+export declare function supplyResponseToAskerDialog(args: {
     parentDialog: Dialog;
-    subdialogId: DialogID;
+    sideDialogId: DialogID;
     responseText: string;
     callType: 'A' | 'B' | 'C';
     callId?: string;
@@ -19,15 +19,15 @@ export declare function supplyResponseToSupdialog(args: {
         course: number;
         genseq: number;
     };
-    callerCourseOverride?: CallerCourseNumber;
+    askerCourseOverride?: AskerCourseNumber;
     scheduleDrive: ScheduleDriveFn;
-    subdialog?: SubDialog;
+    sideDialog?: SideDialog;
 }): Promise<void>;
-export declare function supplySubdialogResponseToSpecificCallerIfPendingV2(args: {
-    subdialog: SubDialog;
+export declare function supplySideDialogResponseToSpecificAskerIfPendingV2(args: {
+    sideDialog: SideDialog;
     responseText: string;
     responseGenseq: number;
-    target: SubdialogReplyTarget;
+    target: SideDialogReplyTarget;
     deliveryMode?: 'reply_tool' | 'direct_fallback';
     replyResolution?: {
         callId: string;
@@ -35,8 +35,8 @@ export declare function supplySubdialogResponseToSpecificCallerIfPendingV2(args:
     };
     scheduleDrive: ScheduleDriveFn;
 }): Promise<boolean>;
-export declare function supplySubdialogResponseToAssignedCallerIfPendingV2(args: {
-    subdialog: SubDialog;
+export declare function supplySideDialogResponseToAssignedAskerIfPendingV2(args: {
+    sideDialog: SideDialog;
     responseText: string;
     responseGenseq: number;
     deliveryMode?: 'reply_tool' | 'direct_fallback';