dominds 1.17.7 → 1.18.2

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

@@ -238,6 +238,9 @@ function hasMeaningfulBatchOutput(batch) {
             if (output.kind === 'tool_result_image_ingest') {
                 continue;
             }
+            if (output.kind === 'user_image_ingest') {
+                continue;
+            }
             if (output.kind !== 'message') {
                 return true;
             }
@@ -346,7 +349,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'tellaskBack',
-        description: 'Ask back to the requester dialog in sideline context.',
+        description: 'Ask back to the requester dialog in sideline context when upstream clarification/decision is required or ownership cannot be determined from SOP.',
         parameters: {
             type: 'object',
             properties: {
@@ -565,34 +568,70 @@ function resolveUpNextPrompt(dlg) {
             q4h: runControl.q4h,
         };
     })();
-    return {
+    const common = {
         content: upNext.prompt,
         msgId: upNext.msgId,
         grammar: upNext.grammar ?? 'markdown',
-        origin: upNext.origin,
-        userLanguageCode: upNext.userLanguageCode,
-        q4hAnswerCallId: upNext.q4hAnswerCallId,
-        tellaskReplyDirective: upNext.tellaskReplyDirective,
-        skipTaskdoc: upNext.skipTaskdoc,
-        subdialogReplyTarget: upNext.subdialogReplyTarget,
-        runControl: normalizedRunControl,
+        ...(upNext.userLanguageCode === undefined ? {} : { userLanguageCode: upNext.userLanguageCode }),
+        ...(normalizedRunControl === undefined ? {} : { runControl: normalizedRunControl }),
     };
+    switch (upNext.kind) {
+        case 'user_generation_boundary':
+        case 'deferred_q4h_answer': {
+            const prompt = {
+                ...common,
+                origin: 'user',
+                ...(upNext.q4hAnswerCallId === undefined
+                    ? {}
+                    : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
+            };
+            return prompt;
+        }
+        case 'registered_assignment_update':
+        case 'new_course_runtime_guide':
+        case 'new_course_runtime_reply':
+        case 'new_course_runtime_subdialog': {
+            const runtimeCommon = {
+                ...common,
+                origin: 'runtime',
+                ...(upNext.skipTaskdoc === undefined ? {} : { skipTaskdoc: upNext.skipTaskdoc }),
+            };
+            if (upNext.kind === 'registered_assignment_update' ||
+                upNext.kind === 'new_course_runtime_subdialog') {
+                const prompt = {
+                    ...runtimeCommon,
+                    tellaskReplyDirective: upNext.tellaskReplyDirective,
+                    subdialogReplyTarget: upNext.subdialogReplyTarget,
+                };
+                return prompt;
+            }
+            if (upNext.kind === 'new_course_runtime_reply') {
+                const prompt = {
+                    ...runtimeCommon,
+                    tellaskReplyDirective: upNext.tellaskReplyDirective,
+                };
+                return prompt;
+            }
+            const prompt = runtimeCommon;
+            return prompt;
+        }
+    }
 }
 async function renderRemindersForContext(dlg) {
     const reminders = await dlg.listVisibleReminders();
     if (reminders.length === 0)
         return [];
     const language = (0, work_language_1.getWorkLanguage)();
-    const rendered = [];
+    const renderedItems = [];
     for (const reminder of reminders) {
         if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
             continue;
         }
         if (reminder.owner) {
-            rendered.push(await reminder.owner.renderReminder(dlg, reminder));
+            renderedItems.push(await reminder.owner.renderReminder(dlg, reminder));
             continue;
         }
-        rendered.push({
+        renderedItems.push({
             type: 'transient_guide_msg',
             role: 'assistant',
             content: (0, driver_messages_1.formatReminderItemGuide)(language, reminder.id, reminder.content, {
@@ -601,7 +640,16 @@ async function renderRemindersForContext(dlg) {
             }),
         });
     }
-    return rendered;
+    if (renderedItems.length === 0)
+        return [];
+    return [
+        {
+            type: 'environment_msg',
+            role: 'user',
+            content: (0, driver_messages_1.formatReminderContextGuide)(language),
+        },
+        ...renderedItems,
+    ];
 }
 function hasSameReplyDirective(left, right) {
     if (!left || !right) {
@@ -835,7 +883,7 @@ async function executeFunctionCalls(args) {
             if (!preparedInvocationArgs || !preparedInvocationArgs.ok) {
                 outcome = 'failure';
                 const errorText = preparedInvocationArgs?.error ?? 'Arguments could not be prepared for tool invocation';
-                log_1.log.warn('kernel-driver rejected function call arguments before execution', undefined, {
+                log_1.log.debug('kernel-driver rejected function call arguments before execution', undefined, {
                     funcName: func.name,
                     arguments: argsStr,
                     error: errorText,
@@ -929,6 +977,7 @@ async function executeFunctionRound(args) {
         funcCalls: args.funcCalls,
         allowedSpecials,
         callbacks: args.callbacks,
+        activePromptReplyDirective: args.activePromptReplyDirective,
     });
     throwIfAborted(args.abortSignal, args.dlg);
     const genericExecutions = await executeFunctionCalls({
@@ -1464,8 +1513,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 msgId: currentPrompt.msgId,
                                 grammar: 'markdown',
                                 content: replyGuidance.promptContent,
+                                ...(currentPrompt.contentItems === undefined
+                                    ? {}
+                                    : { contentItems: currentPrompt.contentItems }),
                             });
-                            await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective);
+                            await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective, currentPrompt.contentItems);
                             await persistence_1.DialogPersistence.clearPendingCourseStartPrompt(dlg.id, currentPrompt.msgId, dlg.status);
                         }
                         if (renderPromptAsRuntimeGuideBubble) {
@@ -1485,6 +1537,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 genseq: dlg.activeGenSeq,
                                 msgId: currentPrompt.msgId,
                                 content: replyGuidance.promptContent,
+                                ...(currentPrompt.contentItems === undefined
+                                    ? {}
+                                    : { contentItems: currentPrompt.contentItems }),
                                 grammar: 'markdown',
                                 origin,
                                 userLanguageCode: persistedUserLanguageCode,
@@ -1768,6 +1823,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 throwIfAborted(abortSignal, dlg);
                                 await dlg.toolResultImageIngest(ingest);
                             },
+                            userImageIngest: async (ingest) => {
+                                throwIfAborted(abortSignal, dlg);
+                                await dlg.userImageIngest(ingest);
+                            },
                         };
                         const res = await (0, runtime_1.runLlmRequestWithRetry)({
                             dlg,
@@ -1882,6 +1941,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 await dlg.toolResultImageIngest(output.ingest);
                                 break;
                             }
+                            case 'user_image_ingest': {
+                                await dlg.userImageIngest(output.ingest);
+                                break;
+                            }
                             default: {
                                 const _exhaustive = output;
                                 throw new Error(`Unhandled batch output kind: ${String(_exhaustive)}`);
@@ -1967,6 +2030,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         callbacks,
                         abortSignal,
                         allowTellaskFunctions: policy.allowTellaskFunctions,
+                        activePromptReplyDirective: currentPrompt?.tellaskReplyDirective,
                     });
                     if (routed.tellaskToolOutputs.length > 0) {
                         newMsgs.push(...routed.tellaskToolOutputs);

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

@@ -140,6 +140,18 @@ function hasNoPromptSubdialogResumeEntitlement(dialog, driveOptions) {
     }
     return entitlement.ownerDialogId === dialog.id.selfId;
 }
+function shouldAllowPendingSubdialogsForParentRevive(dialog, driveOptions) {
+    if (!(dialog instanceof dialog_1.SubDialog)) {
+        return false;
+    }
+    const entitlement = driveOptions?.noPromptSubdialogResumeEntitlement;
+    if (!entitlement) {
+        return false;
+    }
+    return (driveOptions?.source === 'kernel_driver_supply_response_parent_revive' &&
+        entitlement.ownerDialogId === dialog.id.selfId &&
+        entitlement.reason === 'reply_tellask_back_delivered');
+}
 function resolveDriveRequestSource(humanPrompt, driveOptions) {
     if (driveOptions?.source) {
         return driveOptions.source;
@@ -355,20 +367,59 @@ async function resolveEffectivePrompt(dialog, humanPrompt) {
     }
     return {
         fromUpNext: true,
-        prompt: {
-            content: upNext.prompt,
-            msgId: upNext.msgId,
-            grammar: upNext.grammar ?? 'markdown',
-            origin: upNext.origin,
-            userLanguageCode: upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
+        prompt: (() => {
+            const normalizedUserLanguageCode = upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
                 ? upNext.userLanguageCode
-                : undefined,
-            q4hAnswerCallId: upNext.q4hAnswerCallId,
-            tellaskReplyDirective: upNext.tellaskReplyDirective,
-            skipTaskdoc: upNext.skipTaskdoc,
-            subdialogReplyTarget: upNext.subdialogReplyTarget,
-            runControl: upNext.runControl,
-        },
+                : 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 = {
+                        ...common,
+                        origin: 'user',
+                        ...(upNext.q4hAnswerCallId === undefined
+                            ? {}
+                            : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
+                    };
+                    return prompt;
+                }
+                case 'registered_assignment_update':
+                case 'new_course_runtime_guide':
+                case 'new_course_runtime_reply':
+                case 'new_course_runtime_subdialog': {
+                    const runtimeCommon = {
+                        ...common,
+                        origin: 'runtime',
+                        ...(upNext.skipTaskdoc === undefined ? {} : { skipTaskdoc: upNext.skipTaskdoc }),
+                    };
+                    if (upNext.kind === 'registered_assignment_update' ||
+                        upNext.kind === 'new_course_runtime_subdialog') {
+                        const prompt = {
+                            ...runtimeCommon,
+                            tellaskReplyDirective: upNext.tellaskReplyDirective,
+                            subdialogReplyTarget: upNext.subdialogReplyTarget,
+                        };
+                        return prompt;
+                    }
+                    if (upNext.kind === 'new_course_runtime_reply') {
+                        const prompt = {
+                            ...runtimeCommon,
+                            tellaskReplyDirective: upNext.tellaskReplyDirective,
+                        };
+                        return prompt;
+                    }
+                    const prompt = runtimeCommon;
+                    return prompt;
+                }
+            }
+        })(),
     };
 }
 async function executeDriveRound(args) {
@@ -484,9 +535,12 @@ 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 suspension = resumeFromInterjectionPause
                 ? await loadFreshSuspensionStatusFromPersistence(dialog)
-                : await dialog.getSuspensionStatus();
+                : await dialog.getSuspensionStatus({
+                    allowPendingSubdialogs: allowPendingSubdialogsForParentRevive,
+                });
             const queuedPrompt = dialog.peekUpNext();
             const queuedSubdialogPromptCanResume = dialog instanceof dialog_1.SubDialog && queuedPrompt !== undefined;
             if (!suspension.canDrive && !queuedSubdialogPromptCanResume) {
@@ -714,25 +768,44 @@ async function executeDriveRound(args) {
                                 });
                             }
                             else {
-                                if (!activePromptWasReplyToolReminder) {
+                                const shouldDirectFallbackAfterAskBackParentRevive = shouldAllowPendingSubdialogsForParentRevive(dialog, driveOptions);
+                                if (!activePromptWasReplyToolReminder &&
+                                    !shouldDirectFallbackAfterAskBackParentRevive) {
                                     const language = (0, work_language_1.getWorkLanguage)();
-                                    followUp = {
-                                        prompt: await buildReplyToolReminderPrompt({
-                                            dlg: dialog,
-                                            directive: activeTellaskReplyDirective,
-                                            language,
-                                        }),
-                                        msgId: (0, id_1.generateShortId)(),
-                                        grammar: 'markdown',
-                                        origin: 'runtime',
-                                        userLanguageCode: language,
-                                        tellaskReplyDirective: activeTellaskReplyDirective,
-                                        subdialogReplyTarget,
-                                    };
+                                    followUp =
+                                        subdialogReplyTarget === undefined
+                                            ? {
+                                                kind: 'runtime_reply_reminder',
+                                                prompt: await buildReplyToolReminderPrompt({
+                                                    dlg: dialog,
+                                                    directive: activeTellaskReplyDirective,
+                                                    language,
+                                                }),
+                                                msgId: (0, id_1.generateShortId)(),
+                                                grammar: 'markdown',
+                                                origin: 'runtime',
+                                                userLanguageCode: language,
+                                                tellaskReplyDirective: activeTellaskReplyDirective,
+                                            }
+                                            : {
+                                                kind: 'runtime_subdialog_reply_reminder',
+                                                prompt: await buildReplyToolReminderPrompt({
+                                                    dlg: dialog,
+                                                    directive: activeTellaskReplyDirective,
+                                                    language,
+                                                }),
+                                                msgId: (0, id_1.generateShortId)(),
+                                                grammar: 'markdown',
+                                                origin: 'runtime',
+                                                userLanguageCode: language,
+                                                tellaskReplyDirective: activeTellaskReplyDirective,
+                                                subdialogReplyTarget,
+                                            };
                                     log_1.log.debug('kernel-driver queued subdialog replyTellask reminder after plain reply', undefined, {
                                         dialogId: dialog.id.valueOf(),
                                         targetCallId: activeTellaskReplyDirective.targetCallId,
                                         targetOwnerDialogId: subdialogReplyTarget?.ownerDialogId,
+                                        directFallbackAfterAskBackParentRevive: shouldDirectFallbackAfterAskBackParentRevive,
                                     });
                                 }
                                 else {
@@ -821,6 +894,7 @@ async function executeDriveRound(args) {
                     if (!activePromptWasReplyToolReminder) {
                         const language = (0, work_language_1.getWorkLanguage)();
                         followUp = {
+                            kind: 'runtime_reply_reminder',
                             prompt: await buildReplyToolReminderPrompt({
                                 dlg: dialog,
                                 directive: activeTellaskReplyDirective,
@@ -863,20 +937,63 @@ async function executeDriveRound(args) {
                         source: 'kernel_driver_follow_up',
                         reason: 'follow_up_prompt',
                     },
-                    humanPrompt: {
-                        content: followUp.prompt,
-                        msgId: followUp.msgId,
-                        grammar: followUp.grammar ?? 'markdown',
-                        origin: followUp.origin,
-                        userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
+                    humanPrompt: (() => {
+                        const normalizedUserLanguageCode = followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
                             ? followUp.userLanguageCode
-                            : undefined,
-                        q4hAnswerCallId: followUp.q4hAnswerCallId,
-                        tellaskReplyDirective: followUp.tellaskReplyDirective,
-                        skipTaskdoc: followUp.skipTaskdoc,
-                        subdialogReplyTarget: followUp.subdialogReplyTarget,
-                        runControl: followUp.runControl,
-                    },
+                            : undefined;
+                        const common = {
+                            content: followUp.prompt,
+                            msgId: followUp.msgId,
+                            grammar: followUp.grammar ?? 'markdown',
+                            userLanguageCode: normalizedUserLanguageCode,
+                            runControl: followUp.runControl,
+                        };
+                        switch (followUp.kind) {
+                            case 'user_generation_boundary':
+                            case 'deferred_q4h_answer': {
+                                const prompt = {
+                                    ...common,
+                                    origin: 'user',
+                                    ...(followUp.q4hAnswerCallId === undefined
+                                        ? {}
+                                        : { q4hAnswerCallId: followUp.q4hAnswerCallId }),
+                                };
+                                return prompt;
+                            }
+                            case 'registered_assignment_update':
+                            case 'new_course_runtime_guide':
+                            case 'new_course_runtime_reply':
+                            case 'new_course_runtime_subdialog':
+                            case 'runtime_reply_reminder':
+                            case 'runtime_subdialog_reply_reminder': {
+                                const runtimeCommon = {
+                                    ...common,
+                                    origin: 'runtime',
+                                    ...(followUp.skipTaskdoc === undefined
+                                        ? {}
+                                        : { skipTaskdoc: followUp.skipTaskdoc }),
+                                };
+                                if (followUp.kind === 'registered_assignment_update' ||
+                                    followUp.kind === 'new_course_runtime_subdialog') {
+                                    const prompt = {
+                                        ...runtimeCommon,
+                                        tellaskReplyDirective: followUp.tellaskReplyDirective,
+                                        subdialogReplyTarget: followUp.subdialogReplyTarget,
+                                    };
+                                    return prompt;
+                                }
+                                if (followUp.kind === 'new_course_runtime_reply') {
+                                    const prompt = {
+                                        ...runtimeCommon,
+                                        tellaskReplyDirective: followUp.tellaskReplyDirective,
+                                    };
+                                    return prompt;
+                                }
+                                const prompt = runtimeCommon;
+                                return prompt;
+                            }
+                        }
+                    })(),
                 });
             }
             if (shouldPauseAfterLocalUserInterjection &&

package/dist/llm/kernel-driver/reply-guidance.d.ts

@@ -1,20 +1,20 @@
 import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
-import type { KernelDriverHumanPrompt } from './types';
+import type { KernelDriverPrompt } from './types';
 export declare function resolveReplyTargetAgentId(args: {
     dlg: Dialog;
     directive: TellaskReplyDirective;
 }): Promise<string | undefined>;
 export declare function resolvePromptReplyGuidance(args: {
     dlg: Dialog;
-    prompt: KernelDriverHumanPrompt | undefined;
+    prompt: KernelDriverPrompt | undefined;
     language?: 'zh' | 'en';
 }): Promise<{
-    activeReplyDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
-    deferredReplyReassertionDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
+    activeReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
+    deferredReplyReassertionDirective: KernelDriverPrompt['tellaskReplyDirective'];
     isQ4HAnswerPrompt: boolean;
     promptContent: string | undefined;
-    persistedTellaskReplyDirective: KernelDriverHumanPrompt['tellaskReplyDirective'];
+    persistedTellaskReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
     suppressInterDialogReplyGuidance: boolean;
     transientGuideContent: string | undefined;
 }>;
@@ -23,6 +23,6 @@ export declare function buildReplyObligationSuppressionGuide(args: {
 }): string;
 export declare function buildReplyObligationReassertionPrompt(args: {
     dlg: Dialog;
-    directive: NonNullable<KernelDriverHumanPrompt['tellaskReplyDirective']>;
+    directive: NonNullable<KernelDriverPrompt['tellaskReplyDirective']>;
     language: 'zh' | 'en';
 }): Promise<string>;

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

@@ -82,6 +82,149 @@ function buildPromptContentWithExactReplyToolName(args) {
     });
     return `${note}\n\n${args.prompt.content}`;
 }
+function hasSameReplyDirective(left, right) {
+    if (!left || !right) {
+        return left === right;
+    }
+    if (left.expectedReplyCallName !== right.expectedReplyCallName) {
+        return false;
+    }
+    if (left.targetCallId !== right.targetCallId || left.tellaskContent !== right.tellaskContent) {
+        return false;
+    }
+    if (left.expectedReplyCallName === 'replyTellaskBack') {
+        return (right.expectedReplyCallName === 'replyTellaskBack' &&
+            left.targetDialogId === right.targetDialogId);
+    }
+    return true;
+}
+function buildCurrentSubdialogAssignmentDirective(dlg) {
+    switch (dlg.assignmentFromSup.callName) {
+        case 'tellask':
+            return {
+                expectedReplyCallName: 'replyTellask',
+                targetCallId: dlg.assignmentFromSup.callId,
+                tellaskContent: dlg.assignmentFromSup.tellaskContent,
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                expectedReplyCallName: 'replyTellaskSessionless',
+                targetCallId: dlg.assignmentFromSup.callId,
+                tellaskContent: dlg.assignmentFromSup.tellaskContent,
+            };
+        default: {
+            const _exhaustive = dlg.assignmentFromSup.callName;
+            throw new Error(`Unsupported subdialog assignment callName: ${_exhaustive}`);
+        }
+    }
+}
+async function hasCurrentCourseHumanPromptRecord(args) {
+    const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dlg.id, args.dlg.currentCourse, args.dlg.status);
+    for (const event of events) {
+        if (event.type === 'human_text_record' && event.msgId === args.msgId) {
+            return true;
+        }
+    }
+    return false;
+}
+async function resolveFreshCurrentSubdialogAssignmentDirective(args) {
+    if (!(args.dlg instanceof dialog_1.SubDialog) || args.prompt?.origin !== 'runtime') {
+        return undefined;
+    }
+    const promptDirective = args.prompt.tellaskReplyDirective;
+    if (!promptDirective) {
+        return undefined;
+    }
+    const currentAssignmentDirective = buildCurrentSubdialogAssignmentDirective(args.dlg);
+    if (!hasSameReplyDirective(promptDirective, currentAssignmentDirective)) {
+        return undefined;
+    }
+    if (await hasCurrentCourseHumanPromptRecord({
+        dlg: args.dlg,
+        msgId: args.prompt.msgId,
+    })) {
+        return undefined;
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    if (!latest) {
+        return undefined;
+    }
+    const targetCallId = currentAssignmentDirective.targetCallId.trim();
+    for (let course = latest.currentCourse; course >= 1; course -= 1) {
+        const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dlg.id, course, args.dlg.status);
+        for (const event of events) {
+            if (event.type === 'tellask_reply_resolution_record' &&
+                event.targetCallId.trim() === targetCallId) {
+                return undefined;
+            }
+        }
+    }
+    return currentAssignmentDirective;
+}
+async function resolveFreshPendingAskBackReplyDirective(args) {
+    const prompt = args.prompt;
+    if (prompt?.origin !== 'runtime' ||
+        prompt.tellaskReplyDirective?.expectedReplyCallName !== 'replyTellaskBack') {
+        return undefined;
+    }
+    if (await hasCurrentCourseHumanPromptRecord({
+        dlg: args.dlg,
+        msgId: prompt.msgId,
+    })) {
+        return undefined;
+    }
+    const rootDialog = args.dlg instanceof dialog_1.RootDialog
+        ? args.dlg
+        : args.dlg instanceof dialog_1.SubDialog
+            ? args.dlg.rootDialog
+            : undefined;
+    if (!rootDialog) {
+        return undefined;
+    }
+    const requesterDialogId = new dialog_1.DialogID(prompt.tellaskReplyDirective.targetDialogId, rootDialog.id.rootId);
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(requesterDialogId, rootDialog.status);
+    if (!latest) {
+        return undefined;
+    }
+    const targetCallId = prompt.tellaskReplyDirective.targetCallId.trim();
+    let sawAskBackCall = false;
+    for (let course = latest.currentCourse; course >= 1; course -= 1) {
+        const events = await persistence_1.DialogPersistence.loadCourseEvents(requesterDialogId, course, rootDialog.status);
+        for (const event of events) {
+            if (event.type === 'tellask_result_record' && event.callId.trim() === targetCallId) {
+                return undefined;
+            }
+            if (event.type === 'tellask_call_record' &&
+                event.id.trim() === targetCallId &&
+                event.name === 'tellaskBack') {
+                sawAskBackCall = true;
+            }
+        }
+    }
+    return sawAskBackCall ? prompt.tellaskReplyDirective : undefined;
+}
+function resolveFreshReplyDirective(args) {
+    const promptDirective = args.promptDirective;
+    const persistedDirective = args.persistedDirective;
+    if (!promptDirective) {
+        return persistedDirective;
+    }
+    if (!persistedDirective) {
+        return undefined;
+    }
+    return hasSameReplyDirective(promptDirective, persistedDirective)
+        ? promptDirective
+        : persistedDirective;
+}
+function resolvePromptPersistedReplyDirective(args) {
+    const promptDirective = args.promptDirective;
+    const persistedDirective = args.persistedDirective;
+    if (!promptDirective || !persistedDirective) {
+        return undefined;
+    }
+    return hasSameReplyDirective(promptDirective, persistedDirective) ? promptDirective : undefined;
+}
 async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     // WARNING:
     // This suppression decision is not a cosmetic prompt tweak. It is one leg of the full
@@ -126,13 +269,34 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
 async function resolvePromptReplyGuidance(args) {
     const prompt = args.prompt;
     const isQ4HAnswerPrompt = typeof prompt?.q4hAnswerCallId === 'string' && prompt.q4hAnswerCallId.trim() !== '';
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
+    const persistedCurrentSubdialogAssignmentDirective = await resolveFreshCurrentSubdialogAssignmentDirective({
+        dlg: args.dlg,
+        prompt,
+    });
+    const persistedPendingAskBackReplyDirective = await resolveFreshPendingAskBackReplyDirective({
+        dlg: args.dlg,
+        prompt,
+    });
+    const persistedPendingCourseStartDirective = prompt !== undefined &&
+        latest?.pendingCourseStartPrompt?.msgId === prompt.msgId &&
+        latest.pendingCourseStartPrompt.origin === 'runtime'
+        ? latest.pendingCourseStartPrompt.tellaskReplyDirective
+        : undefined;
+    const persistedActiveReplyDirective = persistedCurrentSubdialogAssignmentDirective ??
+        persistedPendingAskBackReplyDirective ??
+        persistedPendingCourseStartDirective ??
+        (await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg));
     const suppressInterDialogReplyGuidance = isQ4HAnswerPrompt
         ? false
         : await shouldSuppressInterDialogReplyGuidanceForUserInterjection({
             dlg: args.dlg,
             prompt,
         });
-    const availableReplyDirective = prompt?.tellaskReplyDirective ?? (await (0, tellask_special_1.loadLatestActiveTellaskReplyDirective)(args.dlg));
+    const availableReplyDirective = resolveFreshReplyDirective({
+        promptDirective: prompt?.tellaskReplyDirective,
+        persistedDirective: persistedActiveReplyDirective,
+    });
     const activeReplyDirective = suppressInterDialogReplyGuidance
         ? undefined
         : availableReplyDirective;
@@ -153,7 +317,10 @@ async function resolvePromptReplyGuidance(args) {
             : undefined,
         isQ4HAnswerPrompt,
         promptContent,
-        persistedTellaskReplyDirective: prompt?.tellaskReplyDirective ?? activeReplyDirective,
+        persistedTellaskReplyDirective: resolvePromptPersistedReplyDirective({
+            promptDirective: prompt?.tellaskReplyDirective,
+            persistedDirective: persistedActiveReplyDirective,
+        }),
         suppressInterDialogReplyGuidance,
         transientGuideContent: suppressInterDialogReplyGuidance && prompt !== undefined
             ? buildReplyObligationSuppressionGuide({