dominds 1.24.2 → 1.24.4

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

@@ -70,6 +70,125 @@ async function queueReplyReminderFollowUp(args) {
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
+function hasSameReplyDirective(left, right) {
+    return (left.expectedReplyCallName === right.expectedReplyCallName &&
+        left.targetDialogId === right.targetDialogId &&
+        left.targetCallId === right.targetCallId &&
+        left.tellaskContent === right.tellaskContent);
+}
+function buildCurrentSideDialogAssignmentReplyDirective(dialog) {
+    switch (dialog.assignmentFromAsker.callName) {
+        case 'tellask':
+            return {
+                expectedReplyCallName: 'replyTellask',
+                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
+                targetCallId: dialog.assignmentFromAsker.callId,
+                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                expectedReplyCallName: 'replyTellaskSessionless',
+                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
+                targetCallId: dialog.assignmentFromAsker.callId,
+                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
+            };
+        default: {
+            const _exhaustive = dialog.assignmentFromAsker.callName;
+            throw new Error(`Unsupported sideDialog assignment callName: ${_exhaustive}`);
+        }
+    }
+}
+function isQueuedReplyObligationContinuation(prompt) {
+    return ((prompt.kind === 'new_course_runtime_reply' ||
+        prompt.kind === 'new_course_runtime_sideDialog') &&
+        (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.prompt));
+}
+function latestHasTellaskResultForCallId(latest, targetCallId) {
+    return (latest?.tellaskResults.results.some((entry) => entry.callId.trim() === targetCallId) === true);
+}
+async function claimQueuedReplyObligationContinuation(args) {
+    const directive = args.prompt.tellaskReplyDirective;
+    const targetCallId = directive.targetCallId.trim();
+    const targetDialogId = directive.targetDialogId.trim();
+    if (targetCallId === '' || targetDialogId === '') {
+        throw new Error(`reply obligation continuation invariant violation: empty target identity ` +
+            `(dialog=${args.dialog.id.valueOf()}, targetDialogId=${directive.targetDialogId}, targetCallId=${directive.targetCallId})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    if (latest?.sideDialogFinalResponse?.callId.trim() === targetCallId) {
+        return 'stale';
+    }
+    if (latestHasTellaskResultForCallId(latest, targetCallId)) {
+        return 'stale';
+    }
+    const targetLatest = targetDialogId === args.dialog.id.selfId
+        ? latest
+        : await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(targetDialogId, args.dialog.id.rootId), args.dialog.status);
+    if (latestHasTellaskResultForCallId(targetLatest, targetCallId)) {
+        return 'stale';
+    }
+    if (args.dialog instanceof dialog_1.SideDialog) {
+        const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
+        if (hasSameReplyDirective(assignmentDirective, directive)) {
+            return 'claimed';
+        }
+    }
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (!activeDirective) {
+        return 'stale';
+    }
+    if (activeDirective.targetCallId !== directive.targetCallId) {
+        return 'stale';
+    }
+    if (!hasSameReplyDirective(activeDirective, directive)) {
+        throw new Error(`reply obligation continuation invariant violation: active obligation changed for callId=${directive.targetCallId} ` +
+            `(dialog=${args.dialog.id.valueOf()}, expectedReplyCallName=${directive.expectedReplyCallName}, ` +
+            `activeReplyCallName=${activeDirective.expectedReplyCallName}, targetDialogId=${directive.targetDialogId}, ` +
+            `activeTargetDialogId=${activeDirective.targetDialogId})`);
+    }
+    return 'claimed';
+}
+async function resolveSideDialogReplyDirectiveForAssistantOutput(args) {
+    const replyTarget = args.replyTarget;
+    const targetCallId = replyTarget?.callId.trim();
+    if (!replyTarget || !targetCallId) {
+        return args.currentDirective;
+    }
+    if (args.currentDirective?.targetCallId === targetCallId) {
+        return args.currentDirective;
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    if (!latest) {
+        return args.currentDirective;
+    }
+    if (latest.sideDialogFinalResponse?.callId.trim() === targetCallId) {
+        return args.currentDirective;
+    }
+    if (latestHasTellaskResultForCallId(latest, targetCallId)) {
+        return args.currentDirective;
+    }
+    const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
+    if (assignmentDirective.targetCallId !== targetCallId) {
+        return args.currentDirective;
+    }
+    if (assignmentDirective.targetDialogId !== replyTarget.callerDialogId ||
+        assignmentDirective.targetCallId !== replyTarget.callId) {
+        return args.currentDirective;
+    }
+    const latestAssignmentAnchor = latest.latestAssignmentAnchor;
+    if (latestAssignmentAnchor?.callId !== targetCallId ||
+        args.responseGenseq < latestAssignmentAnchor.assignmentGenseq) {
+        return args.currentDirective;
+    }
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (activeDirective && !hasSameReplyDirective(activeDirective, assignmentDirective)) {
+        throw new Error(`sideDialog assistant output reply directive invariant violation: active obligation does not match latest assignment ` +
+            `(dialog=${args.dialog.id.valueOf()}, targetCallId=${targetCallId}, ` +
+            `activeTargetCallId=${activeDirective.targetCallId}, assignmentTargetCallId=${assignmentDirective.targetCallId})`);
+    }
+    return activeDirective ?? assignmentDirective;
+}
 function hasQ4HAnswerCallId(callId) {
     return typeof callId === 'string' && callId.trim() !== '';
 }
@@ -294,16 +413,12 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
         previousNextStepTriggerCount: latest.nextStep.triggers.length,
     };
 }
-function hasNoPromptSideDialogResumeEntitlement(dialog, driveOptions) {
-    const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
-    if (!entitlement) {
-        return false;
-    }
-    return entitlement.callerDialogId === dialog.id.selfId;
-}
 function hasResultArrivalTrigger(latest) {
     return latest?.nextStep.triggers.some((trigger) => trigger.kind === 'result_arrival') === true;
 }
+function hasFollowupNextAction(latest) {
+    return latest?.nextStep.triggers.some((trigger) => trigger.kind === 'followup') === true;
+}
 function hasCallerReviveEntitlement(dialog, driveOptions) {
     const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
     if (!entitlement) {
@@ -415,13 +530,11 @@ async function inspectNoPromptSideDialogDrive(args) {
         (0, dialog_drive_work_1.hasRecoverableGenerationBeyondFinalResponse)(latest);
     const resolvedPendingSideDialogReplyEntitlement = hasResolvedPendingSideDialogReplyEntitlement(args.dialog, args.driveOptions);
     const resultArrivalTriggerPresent = hasResultArrivalTrigger(latest);
+    const followupNextActionPresent = hasFollowupNextAction(latest);
     const supplyResponseCallerReviveAllowed = hasCallerReviveEntitlement(args.dialog, args.driveOptions) &&
         (!resolvedPendingSideDialogReplyEntitlement || resultArrivalTriggerPresent);
-    const backendLoopDurableWorkAllowed = source === 'kernel_driver_backend_loop' && resultArrivalTriggerPresent;
-    const replyObligationFollowUpAllowed = source === 'kernel_driver_follow_up' &&
-        args.driveOptions?.noPromptSideDialogResumeEntitlement?.reason ===
-            'reply_obligation_follow_up' &&
-        hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
+    const backendLoopDurableWorkAllowed = source === 'kernel_driver_backend_loop' &&
+        (resultArrivalTriggerPresent || followupNextActionPresent);
     const finalResponseResultArrivalReviveAllowed = sideDialogFinalResponseCallId !== undefined &&
         ((resolvedPendingSideDialogReplyEntitlement && resultArrivalTriggerPresent) ||
             backendLoopDurableWorkAllowed ||
@@ -436,11 +549,20 @@ async function inspectNoPromptSideDialogDrive(args) {
             sideDialogFinalResponseCallId,
         };
     }
+    if (resolvedPendingSideDialogReplyEntitlement && !resultArrivalTriggerPresent) {
+        return {
+            shouldReject: true,
+            source,
+            rejection: 'stale_consumed_result_arrival',
+            displayState,
+            currentCourse,
+            sideDialogFinalResponseCallId,
+        };
+    }
     if (!explicitInterruptedResumeAllowed &&
         !inProgressGenerationResumeAllowed &&
         !supplyResponseCallerReviveAllowed &&
-        !backendLoopDurableWorkAllowed &&
-        !replyObligationFollowUpAllowed) {
+        !backendLoopDurableWorkAllowed) {
         return {
             shouldReject: true,
             source,
@@ -544,71 +666,96 @@ async function surfaceRuntimeGuide(dialog, content) {
 }
 async function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
-        return { prompt: humanPrompt, fromUpNext: false };
+        return { prompt: humanPrompt, fromUpNext: false, droppedStaleQueuedContinuation: false };
     }
-    const upNext = dialog.peekUpNext();
-    if (!upNext) {
-        return {
-            prompt: await maybeResolveDeferredReplyReassertionPrompt(dialog),
-            fromUpNext: false,
-        };
-    }
-    return {
-        fromUpNext: true,
-        prompt: (() => {
-            const normalizedUserLanguageCode = upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
-                ? upNext.userLanguageCode
-                : undefined;
-            const common = {
-                content: upNext.prompt,
-                msgId: upNext.msgId,
-                grammar: upNext.grammar ?? 'markdown',
-                userLanguageCode: normalizedUserLanguageCode,
-                runControl: upNext.runControl,
+    let droppedStaleQueuedContinuation = false;
+    for (;;) {
+        const upNext = dialog.peekUpNext();
+        if (!upNext) {
+            return {
+                prompt: await maybeResolveDeferredReplyReassertionPrompt(dialog),
+                fromUpNext: false,
+                droppedStaleQueuedContinuation,
             };
-            switch (upNext.kind) {
-                case 'user_generation_boundary':
-                case 'deferred_q4h_answer': {
-                    const prompt = {
-                        ...common,
-                        origin: 'user',
-                        ...(upNext.q4hAnswerCallId === undefined
-                            ? {}
-                            : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
-                    };
-                    return prompt;
+        }
+        if (isQueuedReplyObligationContinuation(upNext)) {
+            const claim = await claimQueuedReplyObligationContinuation({ dialog, prompt: upNext });
+            if (claim === 'stale') {
+                const discarded = dialog.takeUpNext();
+                if (!discarded || discarded.msgId !== upNext.msgId) {
+                    throw new Error(`reply obligation continuation invariant violation: expected queued prompt ${upNext.msgId} before stale discard`);
                 }
-                case 'registered_assignment_update':
-                case 'new_course_runtime_guide':
-                case 'new_course_runtime_reply':
-                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_sideDialog') {
+                await persistence_1.DialogPersistence.clearPendingRuntimePrompt(dialog.id, upNext.msgId, dialog.status);
+                log_1.log.debug('kernel-driver dropped stale reply obligation continuation', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                    msgId: upNext.msgId,
+                    targetCallId: upNext.tellaskReplyDirective.targetCallId,
+                    expectedReplyCallName: upNext.tellaskReplyDirective.expectedReplyCallName,
+                });
+                droppedStaleQueuedContinuation = true;
+                continue;
+            }
+        }
+        return {
+            fromUpNext: true,
+            droppedStaleQueuedContinuation,
+            prompt: (() => {
+                const normalizedUserLanguageCode = upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
+                    ? upNext.userLanguageCode
+                    : undefined;
+                const common = {
+                    content: upNext.prompt,
+                    msgId: upNext.msgId,
+                    grammar: upNext.grammar ?? 'markdown',
+                    userLanguageCode: normalizedUserLanguageCode,
+                    runControl: upNext.runControl,
+                };
+                switch (upNext.kind) {
+                    case 'user_generation_boundary':
+                    case 'deferred_q4h_answer': {
                         const prompt = {
-                            ...runtimeCommon,
-                            tellaskReplyDirective: upNext.tellaskReplyDirective,
-                            calleeDialogReplyTarget: upNext.calleeDialogReplyTarget,
+                            ...common,
+                            origin: 'user',
+                            ...(upNext.q4hAnswerCallId === undefined
+                                ? {}
+                                : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
                         };
                         return prompt;
                     }
-                    if (upNext.kind === 'new_course_runtime_reply') {
-                        const prompt = {
-                            ...runtimeCommon,
-                            tellaskReplyDirective: upNext.tellaskReplyDirective,
+                    case 'registered_assignment_update':
+                    case 'new_course_runtime_guide':
+                    case 'new_course_runtime_reply':
+                    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_sideDialog') {
+                            const prompt = {
+                                ...runtimeCommon,
+                                tellaskReplyDirective: upNext.tellaskReplyDirective,
+                                calleeDialogReplyTarget: upNext.calleeDialogReplyTarget,
+                            };
+                            return prompt;
+                        }
+                        if (upNext.kind === 'new_course_runtime_reply') {
+                            const prompt = {
+                                ...runtimeCommon,
+                                tellaskReplyDirective: upNext.tellaskReplyDirective,
+                            };
+                            return prompt;
+                        }
+                        const prompt = runtimeCommon;
                         return prompt;
                     }
-                    const prompt = runtimeCommon;
-                    return prompt;
                 }
-            }
-        })(),
-    };
+            })(),
+        };
+    }
 }
 async function executeDriveRound(args) {
     const [dialog, humanPrompt, waitInQue, driveOptions] = args.driveArgs;
@@ -623,8 +770,38 @@ async function executeDriveRound(args) {
     let shouldRefreshDisplayStateAfterActiveRunCleared = false;
     let followUp;
     let driveResult;
-    let calleeDialogReplyTarget;
-    let activeTellaskReplyDirective;
+    let activeBusinessContinuation = driveOptions?.businessContinuation ?? { kind: 'none' };
+    const replyContinuationScope = {
+        refresh(continuation) {
+            activeBusinessContinuation = continuation;
+        },
+        directive() {
+            switch (activeBusinessContinuation.kind) {
+                case 'none':
+                    return undefined;
+                case 'inter_dialog_reply':
+                    return activeBusinessContinuation.tellaskReplyDirective;
+                default: {
+                    const _exhaustive = activeBusinessContinuation;
+                    throw new Error(`Unhandled business continuation kind: ${String(_exhaustive)}`);
+                }
+            }
+        },
+        target() {
+            switch (activeBusinessContinuation.kind) {
+                case 'none':
+                    return undefined;
+                case 'inter_dialog_reply':
+                    return activeBusinessContinuation.calleeDialogReplyTarget;
+                default: {
+                    const _exhaustive = activeBusinessContinuation;
+                    throw new Error(`Unhandled business continuation kind: ${String(_exhaustive)}`);
+                }
+            }
+        },
+    };
+    let calleeDialogReplyTarget = replyContinuationScope.target();
+    let activeTellaskReplyDirective = replyContinuationScope.directive();
     let activePromptWasReplyToolReminder = false;
     let shouldPauseAfterLocalUserInterjection = false;
     let resumeFromInterjectionPause = false;
@@ -656,7 +833,7 @@ async function executeDriveRound(args) {
                     if (!cleanup.cleared) {
                         await persistence_1.DialogPersistence.removeDriveWatchForDialog(dialog.id, dialog.status);
                     }
-                    log_1.log.warn('Dropped stale no-prompt sideDialog drive after final response anchor', undefined, {
+                    log_1.log.debug('Dropped stale no-prompt sideDialog drive after final response anchor', undefined, {
                         dialogId: dialog.id.valueOf(),
                         rootId: dialog.id.rootId,
                         selfId: dialog.id.selfId,
@@ -713,6 +890,22 @@ async function executeDriveRound(args) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
                     if (inspection.shouldReject) {
+                        if (inspection.rejection === 'stale_consumed_result_arrival') {
+                            log_1.log.debug('Dropped stale no-prompt sideDialog caller revive after result arrival', undefined, {
+                                dialogId: dialog.id.valueOf(),
+                                rootId: dialog.id.rootId,
+                                selfId: dialog.id.selfId,
+                                source: inspection.source,
+                                reason: driveOptions?.reason ?? null,
+                                rejection: inspection.rejection,
+                                allowResumeFromInterrupted: driveOptions?.allowResumeFromInterrupted === true,
+                                displayState: inspection.displayState ?? null,
+                                currentCourse: inspection.currentCourse,
+                                sideDialogFinalResponseCallId: inspection.sideDialogFinalResponseCallId ?? null,
+                                waitInQue,
+                            });
+                            return;
+                        }
                         log_1.log.error('Rejected unexpected no-prompt sideDialog drive request', undefined, {
                             dialogId: dialog.id.valueOf(),
                             rootId: dialog.id.rootId,
@@ -839,18 +1032,23 @@ async function executeDriveRound(args) {
             cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(providerCfg?.models[model]?.caution_remediation_cadence_generations);
         }
         const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dialog.id.key(), snapshot);
+        const userPromptContentForHealth = humanPrompt?.origin === 'user'
+            ? humanPrompt.content
+            : queuedUpNextBeforeHealth?.origin === 'user'
+                ? queuedUpNextBeforeHealth.prompt
+                : undefined;
         const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
             dialogKey: dialog.id.key(),
             snapshot,
             hadUserPromptThisGen: isEffectiveUserPromptForContextHealth(humanPrompt) ||
                 (humanPrompt === undefined && isQueuedUserPromptForContextHealth(queuedUpNextBeforeHealth)),
-            userPromptCriticalRemediationAlreadyApplied: false,
+            userPromptCriticalRemediationAlreadyApplied: userPromptContentForHealth !== undefined &&
+                (0, driver_messages_1.isAgentFacingCriticalUserInterjectionRemediationGuideContent)(userPromptContentForHealth),
             canInjectPromptThisGen: !hasQueuedUpNext,
             cautionRemediationCadenceGenerations,
             criticalCountdownRemaining,
         });
         let healthPrompt;
-        let criticalUserInterjectionRuntimeGuide;
         if (healthDecision.kind === 'continue') {
             if (healthDecision.reason === 'critical_force_new_course') {
                 const language = (0, work_language_1.getWorkLanguage)();
@@ -863,13 +1061,17 @@ async function executeDriveRound(args) {
                 (0, context_health_1.resetContextHealthRoundState)(dialog.id.key());
             }
             else if (healthDecision.reason === 'critical_user_prompt_remediation') {
-                const language = (0, work_language_1.getWorkLanguage)();
-                const dialogScope = dialog instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
-                criticalUserInterjectionRuntimeGuide =
-                    (0, driver_messages_1.formatAgentFacingCriticalUserInterjectionRemediationGuide)(language, {
-                        dialogScope,
-                        promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dialog.id.key()),
+                if (userPromptContentForHealth === undefined ||
+                    !(0, driver_messages_1.isAgentFacingCriticalUserInterjectionRemediationGuideContent)(userPromptContentForHealth)) {
+                    log_1.log.warn('kernel-driver observed unwrapped critical user prompt; critical user interjection wrapping must happen at ingress', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        msgId: humanPrompt?.origin === 'user'
+                            ? humanPrompt.msgId
+                            : queuedUpNextBeforeHealth?.origin === 'user'
+                                ? queuedUpNextBeforeHealth.msgId
+                                : null,
                     });
+                }
             }
             else if (!hasQueuedUpNext) {
                 const language = (0, work_language_1.getWorkLanguage)();
@@ -909,6 +1111,18 @@ async function executeDriveRound(args) {
             dialog,
             latest: latestBeforeCore,
         }));
+        if (resolvedPrompt.droppedStaleQueuedContinuation &&
+            effectivePrompt === undefined &&
+            !(0, dialog_drive_work_1.hasDurableDriveWork)(latestBeforeCore)) {
+            log_1.log.debug('kernel-driver stopped after dropping stale queued continuation', undefined, {
+                dialogId: dialog.id.valueOf(),
+                rootId: dialog.id.rootId,
+                selfId: dialog.id.selfId,
+                source: driveSource,
+                reason: driveOptions?.reason ?? null,
+            });
+            return;
+        }
         await applyRegisteredDialogRunControlsBeforeDrive({
             dialog,
             humanPrompt,
@@ -922,7 +1136,17 @@ async function executeDriveRound(args) {
                 throw new Error(`kernel-driver upNext invariant violation: expected queued prompt ${effectivePrompt?.msgId ?? 'unknown'} before drive`);
             }
         }
-        calleeDialogReplyTarget = effectivePrompt?.calleeDialogReplyTarget;
+        if (effectivePrompt?.tellaskReplyDirective !== undefined) {
+            replyContinuationScope.refresh({
+                kind: 'inter_dialog_reply',
+                tellaskReplyDirective: effectivePrompt.tellaskReplyDirective,
+                ...(effectivePrompt.calleeDialogReplyTarget === undefined
+                    ? {}
+                    : { calleeDialogReplyTarget: effectivePrompt.calleeDialogReplyTarget }),
+            });
+        }
+        calleeDialogReplyTarget =
+            effectivePrompt?.calleeDialogReplyTarget ?? replyContinuationScope.target();
         const replyGuidance = await (0, reply_guidance_1.resolvePromptReplyGuidance)({
             dlg: dialog,
             prompt: effectivePrompt,
@@ -940,28 +1164,20 @@ async function executeDriveRound(args) {
                 !replyGuidance.isQ4HAnswerPrompt &&
                 replyGuidance.suppressInterDialogReplyGuidance &&
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
-        activeTellaskReplyDirective = replyGuidance.activeReplyDirective;
+        activeTellaskReplyDirective =
+            replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
-        const activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
+        let activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
             activeTellaskReplyDirective !== undefined &&
             effectivePrompt.tellaskReplyDirective.targetCallId ===
                 activeTellaskReplyDirective.targetCallId;
         if (effectivePrompt && effectivePrompt.userLanguageCode) {
             dialog.setLastUserLanguageCode(effectivePrompt.userLanguageCode);
         }
-        const coreDriveOptions = criticalUserInterjectionRuntimeGuide === undefined
-            ? driveOptions
-            : {
-                ...(driveOptions ?? {
-                    source: driveSource,
-                    reason: 'critical_user_prompt_remediation',
-                }),
-                criticalUserInterjectionRuntimeGuide,
-            };
         driveResult = await (0, drive_1.driveDialogStreamCore)(dialog, {
             scheduleDrive: args.scheduleDrive,
             driveDialog: args.driveDialog,
-        }, effectivePrompt, coreDriveOptions);
+        }, effectivePrompt, driveOptions);
         const latestAfterCore = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
         coreEndedInterrupted = latestAfterCore?.executionMarker?.kind === 'interrupted';
         await restoreAcceptedRootDriveWakeAfterDriveFailure({
@@ -970,10 +1186,39 @@ async function executeDriveRound(args) {
             reason: 'core_stopped',
             hadRootDriveWakeBeforeCore,
         });
-        calleeDialogReplyTarget = driveResult.lastAssistantReplyTarget ?? calleeDialogReplyTarget;
+        replyContinuationScope.refresh(driveResult.lastBusinessContinuation);
+        calleeDialogReplyTarget =
+            driveResult.lastAssistantReplyTarget ??
+                replyContinuationScope.target() ??
+                calleeDialogReplyTarget;
+        activeTellaskReplyDirective = activeTellaskReplyDirective ?? replyContinuationScope.directive();
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
-            followUp = dialog.takeUpNext();
+            const queuedFollowUp = dialog.takeUpNext();
+            if (queuedFollowUp && isQueuedReplyObligationContinuation(queuedFollowUp)) {
+                const claim = await claimQueuedReplyObligationContinuation({
+                    dialog,
+                    prompt: queuedFollowUp,
+                });
+                if (claim === 'stale') {
+                    await persistence_1.DialogPersistence.clearPendingRuntimePrompt(dialog.id, queuedFollowUp.msgId, dialog.status);
+                    log_1.log.debug('kernel-driver dropped stale reply obligation follow-up after core', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        msgId: queuedFollowUp.msgId,
+                        targetCallId: queuedFollowUp.tellaskReplyDirective.targetCallId,
+                        expectedReplyCallName: queuedFollowUp.tellaskReplyDirective.expectedReplyCallName,
+                    });
+                    followUp = undefined;
+                }
+                else {
+                    followUp = queuedFollowUp;
+                }
+            }
+            else {
+                followUp = queuedFollowUp;
+            }
         }
         let tailError;
         try {
@@ -1021,6 +1266,33 @@ async function executeDriveRound(args) {
                         });
                     }
                     else {
+                        const replyDirectiveForAssistantOutput = await resolveSideDialogReplyDirectiveForAssistantOutput({
+                            dialog,
+                            responseGenseq: directFallbackResponse.responseGenseq,
+                            replyTarget: driveResult.lastAssistantReplyTarget,
+                            currentDirective: activeTellaskReplyDirective,
+                        });
+                        if (replyDirectiveForAssistantOutput !== undefined &&
+                            replyDirectiveForAssistantOutput.targetCallId !==
+                                activeTellaskReplyDirective?.targetCallId) {
+                            // Business continuation identity should already come from the accepted next-step
+                            // trigger or the current runtime prompt. This branch only handles an explicit
+                            // assistant-output reply target surfaced by the core; do not broaden it into
+                            // transcript/assignment-anchor reconstruction.
+                            log_1.log.debug('kernel-driver rebound sideDialog reply directive to latest assistant output target', undefined, {
+                                dialogId: dialog.id.valueOf(),
+                                previousTargetCallId: activeTellaskReplyDirective?.targetCallId ?? null,
+                                nextTargetCallId: replyDirectiveForAssistantOutput.targetCallId,
+                                responseGenseq: directFallbackResponse.responseGenseq,
+                                replyTargetCallId: driveResult.lastAssistantReplyTarget?.callId ?? null,
+                            });
+                        }
+                        activeTellaskReplyDirective = replyDirectiveForAssistantOutput;
+                        activePromptCarriesReplyDirective =
+                            activePromptCarriesReplyDirective ||
+                                (activeTellaskReplyDirective !== undefined &&
+                                    driveResult.lastAssistantReplyTarget?.callId ===
+                                        activeTellaskReplyDirective.targetCallId);
                         const hasFollowUp = followUp !== undefined;
                         const suspension = await dialog.getSuspensionStatus();
                         const backgroundCalleeBlocksImplicitReply = suspension.backgroundCalleeDialogs &&
@@ -1190,17 +1462,20 @@ async function executeDriveRound(args) {
                 if (followUp.kind === 'runtime_reply_reminder' ||
                     followUp.kind === 'runtime_sideDialog_reply_reminder') {
                     await queueReplyReminderFollowUp({ dialog, followUp });
+                    const businessContinuation = {
+                        kind: 'inter_dialog_reply',
+                        tellaskReplyDirective: followUp.tellaskReplyDirective,
+                        ...(followUp.kind === 'runtime_sideDialog_reply_reminder' &&
+                            followUp.calleeDialogReplyTarget !== undefined
+                            ? { calleeDialogReplyTarget: followUp.calleeDialogReplyTarget }
+                            : {}),
+                    };
                     args.scheduleDrive(dialog, {
                         waitInQue: true,
                         driveOptions: {
                             source: 'kernel_driver_follow_up',
                             reason: 'follow_up_prompt',
-                            noPromptSideDialogResumeEntitlement: dialog instanceof dialog_1.SideDialog
-                                ? {
-                                    callerDialogId: dialog.id.selfId,
-                                    reason: 'reply_obligation_follow_up',
-                                }
-                                : undefined,
+                            businessContinuation,
                         },
                     });
                     return driveResult;