dominds 1.24.3 → 1.24.4

package/dist/apps/runtime.js

@@ -98,9 +98,6 @@ async function resolveTargetDialog(sourceDlg, target) {
             matches.push(dialog);
         };
         pushMatch(await ensureDialogLoadedBySelfId(sourceRoot, target.dialogId));
-        for (const loadedRoot of dialog_global_registry_1.globalDialogRegistry.getAll()) {
-            pushMatch(await ensureDialogLoadedBySelfId(loadedRoot, target.dialogId));
-        }
         if (target.dialogId !== sourceRoot.id.rootId) {
             pushMatch(await ensureMainDialogLoaded(target.dialogId));
         }

package/dist/dialog-display-state.js

@@ -255,10 +255,12 @@ function clearActiveRun(dialogId, options) {
         return;
     }
     clearQuarantiningMainDialogIfIdle(dialogId.rootId);
-    if (dialogId.selfId === dialogId.rootId && options?.notifyBackendLoop !== false) {
+    if (options?.notifyBackendLoop !== false) {
         dialog_global_registry_1.globalDialogRegistry.notifyActiveRunCleared(dialogId.rootId, {
             source: 'dialog_display_state_active_run_clear',
-            reason: 'root_active_run_cleared',
+            reason: dialogId.selfId === dialogId.rootId
+                ? 'root_active_run_cleared'
+                : 'sideDialog_active_run_cleared',
         });
     }
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);

package/dist/dialog-global-registry.d.ts

@@ -16,7 +16,18 @@ export type DriveTriggerMeta = Readonly<{
 }>;
 declare class GlobalDialogRegistry {
     private static instance;
+    /**
+     * Runtime-owned roots keyed by rootId.
+     *
+     * Do not add an API that enumerates this map for backend driving. A dialog becomes driveable only
+     * through an explicit business/runtime wake (`wakeDrive`, result arrival, active-run clear, etc.).
+     * Reintroducing "scan every loaded root and see what happens" makes hidden polling loops easy to
+     * create and obscures the business event that should own the next action.
+     */
     private readonly entries;
+    private readonly queuedRootIds;
+    private readonly queuedRootIdSet;
+    private queuedRootIdReadIndex;
     private readonly lastDriveTriggerByRootId;
     private readonly driveTriggerPubChan;
     private driveTriggerSubChan;
@@ -24,6 +35,9 @@ declare class GlobalDialogRegistry {
     get(rootId: string): MainDialog | undefined;
     register(mainDialog: MainDialog): void;
     unregister(rootId: string): void;
+    private enqueueRoot;
+    private compactQueuedRootsIfNeeded;
+    private compactSparseQueuedRootsIfNeeded;
     private publishDriveTrigger;
     waitForDriveTrigger(): Promise<DriveTriggerEvent>;
     wakeDrive(rootId: string, meta?: DriveTriggerMeta): void;
@@ -33,7 +47,7 @@ declare class GlobalDialogRegistry {
     hasPendingActiveRunClearedWake(rootId: string): boolean;
     isDriveWakeQueued(rootId: string): boolean;
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
-    getAll(): MainDialog[];
+    consumeQueuedMainDialogs(): MainDialog[];
     get size(): number;
 }
 export declare const globalDialogRegistry: GlobalDialogRegistry;

package/dist/dialog-global-registry.js

@@ -8,7 +8,18 @@ const persistence_1 = require("./persistence");
 const log = (0, log_1.createLogger)('dialog-global-registry');
 class GlobalDialogRegistry {
     constructor() {
+        /**
+         * Runtime-owned roots keyed by rootId.
+         *
+         * Do not add an API that enumerates this map for backend driving. A dialog becomes driveable only
+         * through an explicit business/runtime wake (`wakeDrive`, result arrival, active-run clear, etc.).
+         * Reintroducing "scan every loaded root and see what happens" makes hidden polling loops easy to
+         * create and obscures the business event that should own the next action.
+         */
         this.entries = new Map();
+        this.queuedRootIds = [];
+        this.queuedRootIdSet = new Set();
+        this.queuedRootIdReadIndex = 0;
         this.lastDriveTriggerByRootId = new Map();
         this.driveTriggerPubChan = (0, evt_1.createPubChan)();
         this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
@@ -60,9 +71,45 @@ class GlobalDialogRegistry {
     }
     unregister(rootId) {
         this.entries.delete(rootId);
+        this.queuedRootIdSet.delete(rootId);
         this.lastDriveTriggerByRootId.delete(rootId);
         (0, dialog_1.scheduleGlobalDialogMutexCleanupForRoot)(rootId);
     }
+    enqueueRoot(rootId) {
+        if (this.queuedRootIdSet.has(rootId)) {
+            return;
+        }
+        this.queuedRootIdSet.add(rootId);
+        this.queuedRootIds.push(rootId);
+    }
+    compactQueuedRootsIfNeeded() {
+        if (this.queuedRootIdReadIndex === 0) {
+            return;
+        }
+        if (this.queuedRootIdReadIndex < 256 &&
+            this.queuedRootIdReadIndex * 2 < this.queuedRootIds.length) {
+            return;
+        }
+        this.queuedRootIds.splice(0, this.queuedRootIdReadIndex);
+        this.queuedRootIdReadIndex = 0;
+    }
+    compactSparseQueuedRootsIfNeeded() {
+        if (this.queuedRootIds.length < 512) {
+            return;
+        }
+        if (this.queuedRootIdSet.size * 2 >= this.queuedRootIds.length - this.queuedRootIdReadIndex) {
+            return;
+        }
+        const compacted = [];
+        for (let index = this.queuedRootIdReadIndex; index < this.queuedRootIds.length; index += 1) {
+            const rootId = this.queuedRootIds[index];
+            if (rootId !== undefined && this.queuedRootIdSet.has(rootId)) {
+                compacted.push(rootId);
+            }
+        }
+        this.queuedRootIds.splice(0, this.queuedRootIds.length, ...compacted);
+        this.queuedRootIdReadIndex = 0;
+    }
     publishDriveTrigger(args) {
         const trigger = {
             type: 'drive_trigger_evt',
@@ -99,6 +146,7 @@ class GlobalDialogRegistry {
             entry.wakeQueued = true;
             // A fresh queueing trigger supersedes any earlier "wake me once active run clears" debt.
             entry.activeRunClearedWakePending = false;
+            this.enqueueRoot(rootId);
         }
         this.publishDriveTrigger({
             action: 'wake_drive',
@@ -119,6 +167,8 @@ class GlobalDialogRegistry {
         if (entry) {
             entry.wakeQueued = false;
             entry.activeRunClearedWakePending = false;
+            this.queuedRootIdSet.delete(rootId);
+            this.compactSparseQueuedRootsIfNeeded();
         }
         this.publishDriveTrigger({
             action: 'clear_drive_wake',
@@ -138,12 +188,14 @@ class GlobalDialogRegistry {
         if (!entry) {
             return;
         }
-        if (!entry.activeRunClearedWakePending || !entry.wakeQueued) {
+        if (!entry.activeRunClearedWakePending) {
             entry.activeRunClearedWakePending = false;
             return;
         }
-        const currentWakeQueued = entry ? entry.wakeQueued : null;
+        const currentWakeQueued = entry.wakeQueued;
         entry.activeRunClearedWakePending = false;
+        entry.wakeQueued = true;
+        this.enqueueRoot(rootId);
         this.publishDriveTrigger({
             action: 'active_run_cleared',
             rootId,
@@ -155,7 +207,7 @@ class GlobalDialogRegistry {
     }
     noteActiveRunBlockedQueuedDrive(rootId) {
         const entry = this.entries.get(rootId);
-        if (!entry || !entry.wakeQueued) {
+        if (!entry) {
             return;
         }
         entry.activeRunClearedWakePending = true;
@@ -169,8 +221,24 @@ class GlobalDialogRegistry {
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);
     }
-    getAll() {
-        return Array.from(this.entries.values()).map((entry) => entry.mainDialog);
+    consumeQueuedMainDialogs() {
+        const queued = [];
+        while (this.queuedRootIdReadIndex < this.queuedRootIds.length) {
+            const rootId = this.queuedRootIds[this.queuedRootIdReadIndex];
+            this.queuedRootIdReadIndex += 1;
+            if (rootId === undefined || !this.queuedRootIdSet.has(rootId)) {
+                continue;
+            }
+            this.queuedRootIdSet.delete(rootId);
+            const entry = this.entries.get(rootId);
+            if (!entry) {
+                continue;
+            }
+            entry.wakeQueued = false;
+            queued.push(entry.mainDialog);
+        }
+        this.compactQueuedRootsIfNeeded();
+        return queued;
     }
     get size() {
         return this.entries.size;

package/dist/dialog.d.ts

@@ -16,7 +16,7 @@ import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-hea
 import type { DialogEvent, NativeToolCallPayload, ReminderContent, WebSearchCallAction, WebSearchCallSource } from '@longrun-ai/kernel/types/dialog';
 import type { DialogCalleeReplyTarget, DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
-import type { ActiveCalleesFile, CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogLatestFile, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
+import type { ActiveCalleesFile, CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogLatestFile, DialogMetadataFile, DialogNextStepTrigger, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
 import type { ToolResultImageIngest, UserImageIngest } from './llm/gen';
 import type { JsonValue } from './tool';
@@ -413,7 +413,7 @@ export declare abstract class Dialog {
         calleeCourse?: CalleeCourseNumber;
         calleeGenseq?: CalleeGenerationSeqNumber;
     }): Promise<TellaskResultMsg | TellaskCarryoverMsg>;
-    notifyGeneratingStart(msgId?: string): Promise<void>;
+    notifyGeneratingStart(msgId?: string): Promise<readonly DialogNextStepTrigger[]>;
     notifyGeneratingFinish(contextHealth?: ContextHealthSnapshot, llmGenModel?: string): Promise<void>;
     streamError(error: string): Promise<void>;
     thinkingStart(): Promise<void>;
@@ -600,7 +600,7 @@ export declare abstract class DialogStore {
     /**
      * Notify start of LLM generation lifecycle (generating_start_evt)
      */
-    notifyGeneratingStart(_dialog: Dialog, _msgId?: string): Promise<void>;
+    notifyGeneratingStart(_dialog: Dialog, _msgId?: string): Promise<readonly DialogNextStepTrigger[]>;
     /**
      * Notify end of LLM generation lifecycle (generating_finish_evt)
      */

package/dist/dialog.js

@@ -1498,7 +1498,7 @@ class Dialog {
         // Mark generation as started with the actual genseq
         // This ensures sideDialog_final_response_evt waits for both user_text and generating_start_evt
         this.markGenerationStarted();
-        await this.dlgStore.notifyGeneratingStart(this, msgId);
+        return this.dlgStore.notifyGeneratingStart(this, msgId);
     }
     async notifyGeneratingFinish(contextHealth, llmGenModel) {
         if (contextHealth) {
@@ -1958,7 +1958,9 @@ class DialogStore {
     /**
      * Notify start of LLM generation lifecycle (generating_start_evt)
      */
-    async notifyGeneratingStart(_dialog, _msgId) { }
+    async notifyGeneratingStart(_dialog, _msgId) {
+        return [];
+    }
     /**
      * Notify end of LLM generation lifecycle (generating_finish_evt)
      */

package/dist/llm/gen/mock.js

@@ -67,6 +67,8 @@ const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const gen_1 = require("../gen");
 const stop_reason_i18n_1 = require("../stop-reason-i18n");
 const RUNTIME_PROMPT_WRAPPER_PREFIXES = [
+    '[System notice] Context state: 🔴 critical; user interjection received',
+    '【系统提示】 上下文状态：🔴 告急；收到用户插话',
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN,
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH,
     reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_EN,

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

@@ -138,6 +138,40 @@ function buildInterruptedFuncResult(args) {
         genseq: args.callGenseq,
     };
 }
+function sameDialogBusinessContinuation(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    switch (left.kind) {
+        case 'none':
+            return true;
+        case 'inter_dialog_reply': {
+            if (right.kind !== 'inter_dialog_reply')
+                return false;
+            return (sameTellaskReplyDirective(left.tellaskReplyDirective, right.tellaskReplyDirective) &&
+                sameDialogCalleeReplyTarget(left.calleeDialogReplyTarget, right.calleeDialogReplyTarget));
+        }
+        default: {
+            const _exhaustive = left;
+            throw new Error(`Unhandled business continuation kind: ${String(_exhaustive)}`);
+        }
+    }
+}
+function sameTellaskReplyDirective(left, right) {
+    return (left.expectedReplyCallName === right.expectedReplyCallName &&
+        left.targetDialogId === right.targetDialogId &&
+        left.targetCallId === right.targetCallId &&
+        left.tellaskContent === right.tellaskContent);
+}
+function sameDialogCalleeReplyTarget(left, right) {
+    if (left === undefined || right === undefined) {
+        return left === right;
+    }
+    return (left.callerDialogId === right.callerDialogId &&
+        left.callType === right.callType &&
+        left.callId === right.callId &&
+        left.callSiteCourse === right.callSiteCourse &&
+        left.callSiteGenseq === right.callSiteGenseq);
+}
 function isFbrSideDialog(dlg) {
     return dlg instanceof dialog_1.SideDialog && dlg.assignmentFromAsker.callName === 'freshBootsReasoning';
 }
@@ -1171,6 +1205,7 @@ async function upsertImmediateFollowupTrigger(args) {
             genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
         },
         reasons,
+        continuation: args.continuation,
     });
 }
 function shouldImmediatelyFollowUpSuccessfulToolResult(tool) {
@@ -1753,20 +1788,20 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     const suppressDiligencePushForDrive = driveOptions?.suppressDiligencePush === true && dlg.disableDiligencePush;
     const abortSignal = (0, dialog_display_state_1.getActiveRunSignal)(dlg.id) ?? (0, dialog_display_state_1.createActiveRun)(dlg.id);
     let finalDisplayState;
-    let criticalUserInterjectionRuntimeGuide = driveOptions?.criticalUserInterjectionRuntimeGuide;
     let lastAssistantSayingContent = null;
     let lastAssistantSayingGenseq = null;
     let lastAssistantThinkingContent = null;
     let lastAssistantThinkingGenseq = null;
     let lastFunctionCallGenseq = null;
     let lastAssistantReplyTarget;
+    let lastBusinessContinuation = { kind: 'none' };
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let pendingPrompt = humanPrompt;
     let resolvingImmediateToolResultForUserPrompt = false;
     let resolvingImmediateToolResultUserPromptMsgId;
-    let criticalRemediationAppliedUserPromptMsgId = driveOptions?.criticalUserInterjectionRuntimeGuide !== undefined &&
-        humanPrompt?.origin === 'user'
+    let criticalRemediationAppliedUserPromptMsgId = humanPrompt?.origin === 'user' &&
+        (0, driver_messages_1.isAgentFacingCriticalUserInterjectionRemediationGuideContent)(humanPrompt.content)
         ? humanPrompt.msgId
         : undefined;
     let retryStoppedRecoveryPrompt;
@@ -1901,8 +1936,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         snapshot,
                         hadUserPromptThisGen: currentGenerationBelongsToUserPrompt,
                         hadUserPromptInImmediateToolChain: currentGenerationBelongsToUserToolChain,
-                        userPromptCriticalRemediationAlreadyApplied: criticalRemediationAppliedUserPromptMsgId !== undefined &&
-                            criticalRemediationAppliedUserPromptMsgId === currentUserPromptMsgId,
+                        userPromptCriticalRemediationAlreadyApplied: (criticalRemediationAppliedUserPromptMsgId !== undefined &&
+                            criticalRemediationAppliedUserPromptMsgId === currentUserPromptMsgId) ||
+                            (currentPendingPrompt?.origin === 'user' &&
+                                (0, driver_messages_1.isAgentFacingCriticalUserInterjectionRemediationGuideContent)(currentPendingPrompt.content)),
                         canInjectPromptThisGen: !hasQueuedUpNext,
                         cautionRemediationCadenceGenerations,
                         criticalCountdownRemaining,
@@ -1925,13 +1962,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             skipTaskdocForThisDrive = false;
                         }
                         else if (healthDecision.reason === 'critical_user_prompt_remediation') {
-                            const language = (0, work_language_1.getWorkLanguage)();
-                            const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
-                            criticalUserInterjectionRuntimeGuide =
-                                (0, driver_messages_1.formatAgentFacingCriticalUserInterjectionRemediationGuide)(language, {
-                                    dialogScope,
-                                    promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                            if (currentPendingPrompt === undefined ||
+                                !(0, driver_messages_1.isAgentFacingCriticalUserInterjectionRemediationGuideContent)(currentPendingPrompt.content)) {
+                                log_1.log.warn('kernel-driver observed unwrapped critical user prompt; critical user interjection wrapping must happen at ingress', undefined, {
+                                    dialogId: dlg.id.valueOf(),
+                                    msgId: currentUserPromptMsgId ?? null,
                                 });
+                            }
                             criticalRemediationAppliedUserPromptMsgId = currentUserPromptMsgId;
                         }
                         else if (!hasQueuedUpNext) {
@@ -1964,6 +2001,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 let llmGenModelForGen = model;
                 const currentPrompt = pendingPrompt;
                 const currentReplyTarget = currentPrompt?.calleeDialogReplyTarget;
+                let currentBusinessContinuation = driveOptions?.businessContinuation ?? { kind: 'none' };
+                if (currentPrompt?.tellaskReplyDirective !== undefined) {
+                    currentBusinessContinuation = {
+                        kind: 'inter_dialog_reply',
+                        tellaskReplyDirective: currentPrompt.tellaskReplyDirective,
+                        ...(currentPrompt.calleeDialogReplyTarget === undefined
+                            ? {}
+                            : { calleeDialogReplyTarget: currentPrompt.calleeDialogReplyTarget }),
+                    };
+                }
                 const currentFbrState = await loadDialogFbrState(dlg);
                 let currentRuntimeGuideMsg;
                 const currentPromptFromFbrState = currentPrompt !== undefined &&
@@ -1985,12 +2032,20 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         break;
                     }
                 }
-                await dlg.notifyGeneratingStart(currentPrompt?.msgId);
-                try {
-                    if (criticalUserInterjectionRuntimeGuide !== undefined) {
-                        await persistAndEmitRuntimeGuide(dlg, criticalUserInterjectionRuntimeGuide);
-                        criticalUserInterjectionRuntimeGuide = undefined;
+                const acceptedTriggers = await dlg.notifyGeneratingStart(currentPrompt?.msgId);
+                for (const trigger of acceptedTriggers) {
+                    if (trigger.kind === 'followup' && trigger.continuation !== undefined) {
+                        if (currentBusinessContinuation.kind !== 'none' &&
+                            !sameDialogBusinessContinuation(currentBusinessContinuation, trigger.continuation)) {
+                            throw new Error(`Business continuation invariant violation: conflicting accepted followup continuations ` +
+                                `(dialog=${dlg.id.valueOf()}, course=${String(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse)}, ` +
+                                `genseq=${String(dlg.activeGenSeq)}, triggerId=${trigger.triggerId})`);
+                        }
+                        currentBusinessContinuation = trigger.continuation;
                     }
+                }
+                lastBusinessContinuation = currentBusinessContinuation;
+                try {
                     if (currentPrompt) {
                         if (currentPrompt.skipTaskdoc === true) {
                             skipTaskdocForThisDrive = true;
@@ -2682,6 +2737,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 lastAssistantThinkingGenseq,
                                 lastFunctionCallGenseq,
                                 lastAssistantReplyTarget,
+                                lastBusinessContinuation,
                             };
                         }
                         const nextFbrState = (0, fbr_1.advanceFbrState)(persistedFbrState);
@@ -2871,6 +2927,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             routed,
                             invalidFuncCallCount,
                             streamedFuncCalls,
+                            continuation: currentBusinessContinuation,
                         });
                         resolvingImmediateToolResultForUserPrompt =
                             currentGenerationBelongsToUserPrompt ||
@@ -3023,6 +3080,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
         lastAssistantThinkingGenseq,
         lastFunctionCallGenseq,
         lastAssistantReplyTarget,
+        lastBusinessContinuation,
         fbrConclusion,
     };
 }

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

@@ -416,6 +416,9 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
 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) {
@@ -527,9 +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 backendLoopDurableWorkAllowed = source === 'kernel_driver_backend_loop' &&
+        (resultArrivalTriggerPresent || followupNextActionPresent);
     const finalResponseResultArrivalReviveAllowed = sideDialogFinalResponseCallId !== undefined &&
         ((resolvedPendingSideDialogReplyEntitlement && resultArrivalTriggerPresent) ||
             backendLoopDurableWorkAllowed ||
@@ -765,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;
@@ -997,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)();
@@ -1021,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)();
@@ -1092,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,
@@ -1110,7 +1164,8 @@ async function executeDriveRound(args) {
                 !replyGuidance.isQ4HAnswerPrompt &&
                 replyGuidance.suppressInterDialogReplyGuidance &&
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
-        activeTellaskReplyDirective = replyGuidance.activeReplyDirective;
+        activeTellaskReplyDirective =
+            replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
         let activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
             activeTellaskReplyDirective !== undefined &&
@@ -1119,19 +1174,10 @@ async function executeDriveRound(args) {
         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({
@@ -1140,7 +1186,12 @@ 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) {
             const queuedFollowUp = dialog.takeUpNext();
@@ -1224,8 +1275,10 @@ async function executeDriveRound(args) {
                         if (replyDirectiveForAssistantOutput !== undefined &&
                             replyDirectiveForAssistantOutput.targetCallId !==
                                 activeTellaskReplyDirective?.targetCallId) {
-                            // `driveDialogStreamCore` may already have consumed a queued assignment-update prompt
-                            // inside the same drive, so rebind the tail decision to the assistant output target.
+                            // 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,
@@ -1409,11 +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',
+                            businessContinuation,
                         },
                     });
                     return driveResult;