dominds 1.18.2 → 1.19.2

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

@@ -20,7 +20,7 @@ const context_health_1 = require("./context-health");
 const drive_1 = require("./drive");
 const guardrails_1 = require("./guardrails");
 const reply_guidance_1 = require("./reply-guidance");
-const subdialog_1 = require("./subdialog");
+const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
 const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
 const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
@@ -43,45 +43,73 @@ async function buildReplyToolReminderPrompt(args) {
         }),
     });
 }
-async function loadFreshSuspensionStatusFromPersistence(dialog) {
+function entitlementAllowsPendingSideDialog(args) {
+    const entitlement = args.driveOptions?.noPromptSideDialogResumeEntitlement;
+    if (args.driveOptions?.source !== 'kernel_driver_supply_response_parent_revive' ||
+        entitlement?.ownerDialogId !== args.dialog.id.selfId) {
+        return false;
+    }
+    if (entitlement.reason === 'reply_tellask_back_delivered') {
+        return true;
+    }
+    if (entitlement.reason === 'replaced_pending_sideDialog_reply') {
+        return false;
+    }
+    if (entitlement.reason !== 'resolved_pending_sideDialog_reply') {
+        return false;
+    }
+    if (!isPositiveInteger(entitlement.callSiteCourse)) {
+        return false;
+    }
+    if (!isPositiveInteger(entitlement.callSiteGenseq)) {
+        return false;
+    }
+    return (args.pending.callSiteCourse !== entitlement.callSiteCourse ||
+        args.pending.callSiteGenseq !== entitlement.callSiteGenseq);
+}
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+async function loadFreshSuspensionStatusFromPersistence(dialog, driveOptions) {
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialog.id, dialog.status);
-    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialog.id, dialog.status);
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialog.id, dialog.status);
     const hasQ4H = q4h.length > 0;
-    const hasSubdialogs = pendingSubdialogs.length > 0;
+    const hasSideDialogs = pendingSideDialogs.length > 0;
+    const blockingSideDialogs = pendingSideDialogs.some((pending) => !entitlementAllowsPendingSideDialog({ pending, driveOptions, dialog }));
     return {
         q4h: hasQ4H,
-        subdialogs: hasSubdialogs,
-        blockingSubdialogs: hasSubdialogs,
-        canDrive: !hasQ4H && !hasSubdialogs,
+        sideDialogs: hasSideDialogs,
+        blockingSideDialogs,
+        canDrive: !hasQ4H && !blockingSideDialogs,
     };
 }
 function buildDisplayStateFromSuspensionStatus(args) {
-    if (args.q4h && args.subdialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    if (args.q4h && args.sideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
     }
     if (args.q4h) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
-    if (args.subdialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    if (args.sideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
     }
     return { kind: 'idle_waiting_user' };
 }
 async function loadPendingDiagnosticsSnapshot(args) {
     const ownerDialogIdObj = new dialog_1.DialogID(args.ownerDialogId, args.rootId);
     try {
-        const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(ownerDialogIdObj, args.status);
-        const matchedSubdialogIds = pending
-            .filter((record) => record.subdialogId === args.expectedSubdialogId)
-            .map((record) => record.subdialogId);
+        const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(ownerDialogIdObj, args.status);
+        const matchedSideDialogIds = pending
+            .filter((record) => record.sideDialogId === args.expectedSideDialogId)
+            .map((record) => record.sideDialogId);
         return {
             kind: 'loaded',
             ownerDialogId: args.ownerDialogId,
             status: args.status,
             totalCount: pending.length,
-            matchedSubdialogIds,
+            matchedSideDialogIds,
             records: pending.map((record) => ({
-                subdialogId: record.subdialogId,
+                sideDialogId: record.sideDialogId,
                 callType: record.callType,
                 targetAgentId: record.targetAgentId,
                 sessionSlug: record.sessionSlug,
@@ -133,24 +161,31 @@ async function clearConsumedDeferredRootQueueIfIdle(dialog) {
         reason: 'root_idle_after_consuming_deferred_queue',
     });
 }
-function hasNoPromptSubdialogResumeEntitlement(dialog, driveOptions) {
-    const entitlement = driveOptions?.noPromptSubdialogResumeEntitlement;
+function hasNoPromptSideDialogResumeEntitlement(dialog, driveOptions) {
+    const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
     if (!entitlement) {
         return false;
     }
     return entitlement.ownerDialogId === dialog.id.selfId;
 }
-function shouldAllowPendingSubdialogsForParentRevive(dialog, driveOptions) {
-    if (!(dialog instanceof dialog_1.SubDialog)) {
+function hasParentReviveEntitlement(dialog, driveOptions) {
+    const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
+    if (!entitlement) {
         return false;
     }
-    const entitlement = driveOptions?.noPromptSubdialogResumeEntitlement;
-    if (!entitlement) {
+    if (driveOptions?.source !== 'kernel_driver_supply_response_parent_revive' ||
+        entitlement.ownerDialogId !== dialog.id.selfId) {
         return false;
     }
-    return (driveOptions?.source === 'kernel_driver_supply_response_parent_revive' &&
-        entitlement.ownerDialogId === dialog.id.selfId &&
-        entitlement.reason === 'reply_tellask_back_delivered');
+    if (entitlement.reason === 'reply_tellask_back_delivered') {
+        return true;
+    }
+    if (entitlement.reason === 'replaced_pending_sideDialog_reply') {
+        return true;
+    }
+    return (entitlement.reason === 'resolved_pending_sideDialog_reply' &&
+        isPositiveInteger(entitlement.callSiteCourse) &&
+        isPositiveInteger(entitlement.callSiteGenseq));
 }
 function resolveDriveRequestSource(humanPrompt, driveOptions) {
     if (driveOptions?.source) {
@@ -221,7 +256,7 @@ async function applyRegisteredDialogRunControlsBeforeDrive(args) {
         throw new Error((0, run_control_1.renderAppRunControlBlockForPreDrive)(result.block));
     }
 }
-async function inspectNoPromptSubdialogDrive(args) {
+async function inspectNoPromptSideDialogDrive(args) {
     const source = resolveDriveRequestSource(undefined, args.driveOptions);
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
     const displayState = latest?.displayState;
@@ -245,7 +280,7 @@ async function inspectNoPromptSubdialogDrive(args) {
     const explicitInterruptedResumeAllowed = args.driveOptions?.allowResumeFromInterrupted === true &&
         latest?.executionMarker?.kind === 'interrupted';
     const supplyResponseParentReviveAllowed = source === 'kernel_driver_supply_response_parent_revive' &&
-        hasNoPromptSubdialogResumeEntitlement(args.dialog, args.driveOptions);
+        hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
     if (lastEvent?.type === 'tellask_call_anchor_record' && lastEvent.anchorRole === 'response') {
         return {
             shouldReject: true,
@@ -279,7 +314,7 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
     if (!deferredReplyReassertion) {
         return undefined;
     }
-    const activeDirective = await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(dialog);
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(dialog);
     if (!activeDirective ||
         activeDirective.targetCallId !== deferredReplyReassertion.directive.targetCallId) {
         await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
@@ -314,7 +349,7 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
     if (!deferredReplyReassertion || deferredReplyReassertion.resumeGuideSurfaced === true) {
         return;
     }
-    const activeDirective = await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(dialog);
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(dialog);
     if (!activeDirective ||
         activeDirective.targetCallId !== deferredReplyReassertion.directive.targetCallId) {
         await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
@@ -393,18 +428,18 @@ async function resolveEffectivePrompt(dialog, humanPrompt) {
                 case 'registered_assignment_update':
                 case 'new_course_runtime_guide':
                 case 'new_course_runtime_reply':
-                case 'new_course_runtime_subdialog': {
+                case 'new_course_runtime_sideDialog': {
                     const runtimeCommon = {
                         ...common,
                         origin: 'runtime',
                         ...(upNext.skipTaskdoc === undefined ? {} : { skipTaskdoc: upNext.skipTaskdoc }),
                     };
                     if (upNext.kind === 'registered_assignment_update' ||
-                        upNext.kind === 'new_course_runtime_subdialog') {
+                        upNext.kind === 'new_course_runtime_sideDialog') {
                         const prompt = {
                             ...runtimeCommon,
                             tellaskReplyDirective: upNext.tellaskReplyDirective,
-                            subdialogReplyTarget: upNext.subdialogReplyTarget,
+                            sideDialogReplyTarget: upNext.sideDialogReplyTarget,
                         };
                         return prompt;
                     }
@@ -433,7 +468,7 @@ async function executeDriveRound(args) {
     let interruptedBySignal = false;
     let followUp;
     let driveResult;
-    let subdialogReplyTarget;
+    let sideDialogReplyTarget;
     let activeTellaskReplyDirective;
     let activePromptWasReplyToolReminder = false;
     let shouldPauseAfterLocalUserInterjection = false;
@@ -447,7 +482,7 @@ async function executeDriveRound(args) {
         (0, dialog_display_state_1.createActiveRun)(dialog.id);
         activeRunPrimed = true;
         ownsActiveRun = !hadActiveRunBefore;
-        // "dead" is irreversible for subdialogs. Skip drive if marked dead.
+        // "dead" is irreversible for sideDialogs. Skip drive if marked dead.
         try {
             const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, 'running');
             if (dialog.id.selfId !== dialog.id.rootId &&
@@ -487,14 +522,14 @@ async function executeDriveRound(args) {
             });
         }
         // Queued/auto drive (without fresh human input) must not proceed while dialog is
-        // suspended by pending Q4H or subdialogs. This prevents duplicate generations when
-        // multiple wake-ups race around the same subdialog completion boundary.
+        // suspended by pending Q4H or sideDialogs. This prevents duplicate generations when
+        // multiple wake-ups race around the same sideDialog completion boundary.
         if (!humanPrompt) {
-            if (dialog instanceof dialog_1.SubDialog && !dialog.hasUpNext()) {
+            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
                 try {
-                    const inspection = await inspectNoPromptSubdialogDrive({ dialog, driveOptions });
+                    const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
                     if (inspection.shouldReject) {
-                        log_1.log.error('Rejected unexpected no-prompt subdialog drive request', undefined, {
+                        log_1.log.error('Rejected unexpected no-prompt sideDialog drive request', undefined, {
                             dialogId: dialog.id.valueOf(),
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
@@ -511,7 +546,7 @@ async function executeDriveRound(args) {
                     }
                 }
                 catch (err) {
-                    log_1.log.error('Failed to inspect unexpected no-prompt subdialog drive request', err, {
+                    log_1.log.error('Failed to inspect unexpected no-prompt sideDialog drive request', err, {
                         dialogId: dialog.id.valueOf(),
                         rootId: dialog.id.rootId,
                         selfId: dialog.id.selfId,
@@ -535,19 +570,21 @@ async function executeDriveRound(args) {
             // Do not refactor this branch using only `displayState` or only the previous interrupted
             // marker. The correct behavior emerges from combining fresh blocker facts, queued prompt
             // state, and the deferred reply reassertion logic elsewhere.
-            const allowPendingSubdialogsForParentRevive = shouldAllowPendingSubdialogsForParentRevive(dialog, driveOptions);
+            const hasEntitledParentRevive = hasParentReviveEntitlement(dialog, driveOptions);
             const suspension = resumeFromInterjectionPause
-                ? await loadFreshSuspensionStatusFromPersistence(dialog)
-                : await dialog.getSuspensionStatus({
-                    allowPendingSubdialogs: allowPendingSubdialogsForParentRevive,
-                });
+                ? await loadFreshSuspensionStatusFromPersistence(dialog, driveOptions)
+                : hasEntitledParentRevive
+                    ? await loadFreshSuspensionStatusFromPersistence(dialog, driveOptions)
+                    : await dialog.getSuspensionStatus({
+                        allowPendingSideDialogs: false,
+                    });
             const queuedPrompt = dialog.peekUpNext();
-            const queuedSubdialogPromptCanResume = dialog instanceof dialog_1.SubDialog && queuedPrompt !== undefined;
-            if (!suspension.canDrive && !queuedSubdialogPromptCanResume) {
+            const queuedSideDialogPromptCanResume = dialog instanceof dialog_1.SideDialog && queuedPrompt !== undefined;
+            if (!suspension.canDrive && !queuedSideDialogPromptCanResume) {
                 if (resumeFromInterjectionPause) {
                     const restoredState = buildDisplayStateFromSuspensionStatus({
                         q4h: suspension.q4h,
-                        subdialogs: suspension.subdialogs,
+                        sideDialogs: suspension.sideDialogs,
                     });
                     await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, restoredState);
                     await maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog);
@@ -555,7 +592,7 @@ async function executeDriveRound(args) {
                         dialogId: dialog.id.valueOf(),
                         restoredState,
                         waitingQ4H: suspension.q4h,
-                        waitingSubdialogs: suspension.subdialogs,
+                        waitingSideDialogs: suspension.sideDialogs,
                     });
                     return;
                 }
@@ -568,7 +605,7 @@ async function executeDriveRound(args) {
                     waitInQue,
                     hasQueuedUpNext: dialog.hasUpNext(),
                     waitingQ4H: suspension.q4h,
-                    waitingSubdialogs: suspension.subdialogs,
+                    waitingSideDialogs: suspension.sideDialogs,
                     lastDriveTrigger: lastTrigger
                         ? {
                             action: lastTrigger.action,
@@ -590,9 +627,9 @@ async function executeDriveRound(args) {
                 log_1.log.debug('kernel-driver continue after interjection pause passed fresh fact scan and will keep driving', undefined, {
                     dialogId: dialog.id.valueOf(),
                     waitingQ4H: suspension.q4h,
-                    waitingSubdialogs: suspension.subdialogs,
+                    waitingSideDialogs: suspension.sideDialogs,
                     hasQueuedUpNext: dialog.hasUpNext(),
-                    queuedSubdialogPromptCanResume,
+                    queuedSideDialogPromptCanResume,
                 });
             }
         }
@@ -685,7 +722,7 @@ async function executeDriveRound(args) {
                 throw new Error(`kernel-driver upNext invariant violation: expected queued prompt ${effectivePrompt?.msgId ?? 'unknown'} before drive`);
             }
         }
-        subdialogReplyTarget = effectivePrompt?.subdialogReplyTarget;
+        sideDialogReplyTarget = effectivePrompt?.sideDialogReplyTarget;
         const replyGuidance = await (0, reply_guidance_1.resolvePromptReplyGuidance)({
             dlg: dialog,
             prompt: effectivePrompt,
@@ -712,20 +749,20 @@ async function executeDriveRound(args) {
             scheduleDrive: args.scheduleDrive,
             driveDialog: args.driveDialog,
         }, effectivePrompt, driveOptions);
-        subdialogReplyTarget = driveResult.lastAssistantReplyTarget ?? subdialogReplyTarget;
+        sideDialogReplyTarget = driveResult.lastAssistantReplyTarget ?? sideDialogReplyTarget;
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
             followUp = dialog.takeUpNext();
         }
         let tailError;
         try {
-            if (dialog instanceof dialog_1.SubDialog &&
+            if (dialog instanceof dialog_1.SideDialog &&
                 driveResult &&
                 !interruptedBySignal &&
                 (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
                 if (driveResult.fbrConclusion) {
-                    await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                        subdialog: dialog,
+                    await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                        sideDialog: dialog,
                         responseText: driveResult.fbrConclusion.responseText,
                         responseGenseq: driveResult.fbrConclusion.responseGenseq,
                         scheduleDrive: args.scheduleDrive,
@@ -739,9 +776,9 @@ async function executeDriveRound(args) {
                             !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
                             driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
                     if (hasInProgressFunctionCall) {
-                        // Any function call means execution is still in-progress. Only supply when the callee
+                        // Any function call means execution is still in-progress. Only supply when the tellaskee
                         // has produced a newer assistant saying after the latest function call.
-                        log_1.log.debug('kernel-driver skip subdialog response supply because latest saying is not after function calls', undefined, {
+                        log_1.log.debug('kernel-driver skip sideDialog response supply because latest saying is not after function calls', undefined, {
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
                             lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
@@ -752,28 +789,27 @@ async function executeDriveRound(args) {
                         const hasFollowUp = followUp !== undefined;
                         const suspension = await dialog.getSuspensionStatus();
                         if (!suspension.canDrive || hasFollowUp) {
-                            log_1.log.debug('kernel-driver skip subdialog response supply while callee is not finalized', undefined, {
+                            log_1.log.debug('kernel-driver skip sideDialog response supply while tellaskee is not finalized', undefined, {
                                 rootId: dialog.id.rootId,
                                 selfId: dialog.id.selfId,
                                 waitingQ4H: suspension.q4h,
-                                waitingSubdialogs: suspension.subdialogs,
+                                waitingSideDialogs: suspension.sideDialogs,
                                 hasFollowUp,
                             });
                         }
                         if (suspension.canDrive && !hasFollowUp) {
                             if (!activeTellaskReplyDirective) {
-                                log_1.log.debug('kernel-driver skip implicit subdialog reply because no active tellask reply directive is bound to this drive', undefined, {
+                                log_1.log.debug('kernel-driver skip implicit sideDialog reply because no active tellask reply directive is bound to this drive', undefined, {
                                     rootId: dialog.id.rootId,
                                     selfId: dialog.id.selfId,
                                 });
                             }
                             else {
-                                const shouldDirectFallbackAfterAskBackParentRevive = shouldAllowPendingSubdialogsForParentRevive(dialog, driveOptions);
-                                if (!activePromptWasReplyToolReminder &&
-                                    !shouldDirectFallbackAfterAskBackParentRevive) {
+                                const shouldDirectFallbackAfterParentRevive = hasParentReviveEntitlement(dialog, driveOptions);
+                                if (!activePromptWasReplyToolReminder && !shouldDirectFallbackAfterParentRevive) {
                                     const language = (0, work_language_1.getWorkLanguage)();
                                     followUp =
-                                        subdialogReplyTarget === undefined
+                                        sideDialogReplyTarget === undefined
                                             ? {
                                                 kind: 'runtime_reply_reminder',
                                                 prompt: await buildReplyToolReminderPrompt({
@@ -788,7 +824,7 @@ async function executeDriveRound(args) {
                                                 tellaskReplyDirective: activeTellaskReplyDirective,
                                             }
                                             : {
-                                                kind: 'runtime_subdialog_reply_reminder',
+                                                kind: 'runtime_sideDialog_reply_reminder',
                                                 prompt: await buildReplyToolReminderPrompt({
                                                     dlg: dialog,
                                                     directive: activeTellaskReplyDirective,
@@ -799,30 +835,30 @@ async function executeDriveRound(args) {
                                                 origin: 'runtime',
                                                 userLanguageCode: language,
                                                 tellaskReplyDirective: activeTellaskReplyDirective,
-                                                subdialogReplyTarget,
+                                                sideDialogReplyTarget,
                                             };
-                                    log_1.log.debug('kernel-driver queued subdialog replyTellask reminder after plain reply', undefined, {
+                                    log_1.log.debug('kernel-driver queued sideDialog replyTellask reminder after plain reply', undefined, {
                                         dialogId: dialog.id.valueOf(),
                                         targetCallId: activeTellaskReplyDirective.targetCallId,
-                                        targetOwnerDialogId: subdialogReplyTarget?.ownerDialogId,
-                                        directFallbackAfterAskBackParentRevive: shouldDirectFallbackAfterAskBackParentRevive,
+                                        targetOwnerDialogId: sideDialogReplyTarget?.ownerDialogId,
+                                        directFallbackAfterParentRevive: shouldDirectFallbackAfterParentRevive,
                                     });
                                 }
                                 else {
                                     if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
                                         !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
                                         driveResult.lastAssistantSayingGenseq <= 0) {
-                                        throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
+                                        throw new Error(`SideDialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
                                     }
                                     const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
                                     const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
                                     let supplied = false;
-                                    if (subdialogReplyTarget) {
-                                        supplied = await (0, subdialog_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
-                                            subdialog: dialog,
+                                    if (sideDialogReplyTarget) {
+                                        supplied = await (0, sideDialog_1.supplySideDialogResponseToSpecificAskerIfPendingV2)({
+                                            sideDialog: dialog,
                                             responseText: driveResult.lastAssistantSayingContent,
                                             responseGenseq,
-                                            target: subdialogReplyTarget,
+                                            target: sideDialogReplyTarget,
                                             deliveryMode: 'direct_fallback',
                                             replyResolution: {
                                                 callId: directFallbackCallId,
@@ -831,8 +867,8 @@ async function executeDriveRound(args) {
                                             scheduleDrive: args.scheduleDrive,
                                         });
                                         if (!supplied) {
-                                            supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                                subdialog: dialog,
+                                            supplied = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                                                sideDialog: dialog,
                                                 responseText: driveResult.lastAssistantSayingContent,
                                                 responseGenseq,
                                                 deliveryMode: 'direct_fallback',
@@ -845,8 +881,8 @@ async function executeDriveRound(args) {
                                         }
                                     }
                                     else {
-                                        supplied = await (0, subdialog_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
-                                            subdialog: dialog,
+                                        supplied = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
+                                            sideDialog: dialog,
                                             responseText: driveResult.lastAssistantSayingContent,
                                             responseGenseq,
                                             deliveryMode: 'direct_fallback',
@@ -857,18 +893,18 @@ async function executeDriveRound(args) {
                                             scheduleDrive: args.scheduleDrive,
                                         });
                                     }
-                                    if (!supplied && subdialogReplyTarget) {
+                                    if (!supplied && sideDialogReplyTarget) {
                                         const diagnostics = await loadPendingDiagnosticsSnapshot({
                                             rootId: dialog.id.rootId,
-                                            ownerDialogId: subdialogReplyTarget.ownerDialogId,
-                                            expectedSubdialogId: dialog.id.selfId,
+                                            ownerDialogId: sideDialogReplyTarget.ownerDialogId,
+                                            expectedSideDialogId: dialog.id.selfId,
                                             status: dialog.status,
                                         });
-                                        log_1.log.debug('kernel-driver failed to supply subdialog response to specific caller', undefined, {
+                                        log_1.log.debug('kernel-driver failed to supply sideDialog response to specific asker', undefined, {
                                             calleeId: dialog.id.valueOf(),
-                                            targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
-                                            targetCallType: subdialogReplyTarget.callType,
-                                            targetCallId: subdialogReplyTarget.callId,
+                                            targetOwnerDialogId: sideDialogReplyTarget.ownerDialogId,
+                                            targetCallType: sideDialogReplyTarget.callType,
+                                            targetCallId: sideDialogReplyTarget.callId,
                                             diagnostics,
                                         });
                                     }
@@ -878,7 +914,7 @@ async function executeDriveRound(args) {
                     }
                 }
             }
-            if (!(dialog instanceof dialog_1.SubDialog) &&
+            if (!(dialog instanceof dialog_1.SideDialog) &&
                 driveResult &&
                 !interruptedBySignal &&
                 driveResult.lastAssistantSayingContent !== null &&
@@ -963,9 +999,9 @@ async function executeDriveRound(args) {
                             case 'registered_assignment_update':
                             case 'new_course_runtime_guide':
                             case 'new_course_runtime_reply':
-                            case 'new_course_runtime_subdialog':
+                            case 'new_course_runtime_sideDialog':
                             case 'runtime_reply_reminder':
-                            case 'runtime_subdialog_reply_reminder': {
+                            case 'runtime_sideDialog_reply_reminder': {
                                 const runtimeCommon = {
                                     ...common,
                                     origin: 'runtime',
@@ -974,11 +1010,11 @@ async function executeDriveRound(args) {
                                         : { skipTaskdoc: followUp.skipTaskdoc }),
                                 };
                                 if (followUp.kind === 'registered_assignment_update' ||
-                                    followUp.kind === 'new_course_runtime_subdialog') {
+                                    followUp.kind === 'new_course_runtime_sideDialog') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,
-                                        subdialogReplyTarget: followUp.subdialogReplyTarget,
+                                        sideDialogReplyTarget: followUp.sideDialogReplyTarget,
                                     };
                                     return prompt;
                                 }

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

@@ -5,10 +5,10 @@ exports.validateKernelDriverPolicyInvariants = validateKernelDriverPolicyInvaria
 exports.resolveKernelDriverPolicyViolationKind = resolveKernelDriverPolicyViolationKind;
 const dialog_1 = require("../../dialog");
 const fbr_1 = require("./fbr");
-function isToollessFbrSelfSubdialog(dlg) {
-    if (!(dlg instanceof dialog_1.SubDialog))
+function isToollessFbrSelfSideDialog(dlg) {
+    if (!(dlg instanceof dialog_1.SideDialog))
         return false;
-    return dlg.assignmentFromSup.callName === 'freshBootsReasoning';
+    return dlg.assignmentFromAsker.callName === 'freshBootsReasoning';
 }
 function mergeModelParams(base, overlay) {
     if (!base && !overlay)
@@ -26,7 +26,7 @@ function mergeModelParams(base, overlay) {
 }
 function buildKernelDriverPolicy(args) {
     const { dlg, agent, systemPrompt, agentTools, language } = args;
-    if (!isToollessFbrSelfSubdialog(dlg)) {
+    if (!isToollessFbrSelfSideDialog(dlg)) {
         return {
             mode: 'default',
             effectiveAgent: agent,

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

@@ -1,4 +1,4 @@
-export { driveDialogStream, emitSayingEventsBridge as emitSayingEvents, supplyResponseToSupdialog, } from './engine';
+export { driveDialogStream, emitSayingEventsBridge as emitSayingEvents, supplyResponseToAskerDialog, } from './engine';
 export { runBackendDriver } from './loop';
 export { restoreDialogHierarchy } from './restore';
 export type { KernelDriverDriveArgs, KernelDriverDriveResult, KernelDriverEmitSayingArgs, KernelDriverEmitSayingResult, KernelDriverRunBackendResult, KernelDriverSupplyResponseArgs, KernelDriverSupplyResponseResult, } from './types';

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreDialogHierarchy = exports.runBackendDriver = exports.supplyResponseToSupdialog = exports.emitSayingEvents = exports.driveDialogStream = void 0;
+exports.restoreDialogHierarchy = exports.runBackendDriver = exports.supplyResponseToAskerDialog = exports.emitSayingEvents = exports.driveDialogStream = void 0;
 var engine_1 = require("./engine");
 Object.defineProperty(exports, "driveDialogStream", { enumerable: true, get: function () { return engine_1.driveDialogStream; } });
 Object.defineProperty(exports, "emitSayingEvents", { enumerable: true, get: function () { return engine_1.emitSayingEventsBridge; } });
-Object.defineProperty(exports, "supplyResponseToSupdialog", { enumerable: true, get: function () { return engine_1.supplyResponseToSupdialog; } });
+Object.defineProperty(exports, "supplyResponseToAskerDialog", { enumerable: true, get: function () { return engine_1.supplyResponseToAskerDialog; } });
 var loop_1 = require("./loop");
 Object.defineProperty(exports, "runBackendDriver", { enumerable: true, get: function () { return loop_1.runBackendDriver; } });
 var restore_1 = require("./restore");