dominds 1.23.4 → 1.23.6

package/dist/dialog-display-state.js

@@ -96,6 +96,25 @@ function isSideDialogResponseAnchor(record) {
 function isNonIdleDisplayProjection(state) {
     return state !== undefined && state.kind !== 'idle_waiting_user';
 }
+function pendingReplyObligationDisplayState() {
+    return {
+        kind: 'stopped',
+        reason: { kind: 'pending_reply_obligation' },
+        continueEnabled: true,
+    };
+}
+function blockerDisplayState(args) {
+    if (args.hasQ4H && args.hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    }
+    if (args.hasQ4H) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (args.hasSideDialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    }
+    return undefined;
+}
 async function hasSideDialogFinalResponseAnchor(dialogId, latest) {
     if (dialogId.selfId === dialogId.rootId) {
         return false;
@@ -111,6 +130,35 @@ async function hasSideDialogFinalResponseAnchor(dialogId, latest) {
     }
     return false;
 }
+async function hasActiveSideDialogReplyObligation(dialogId) {
+    if (dialogId.selfId === dialogId.rootId) {
+        return false;
+    }
+    const activeObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+    return activeObligation !== undefined;
+}
+async function coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState) {
+    if (displayState.kind !== 'idle_waiting_user') {
+        return displayState;
+    }
+    if (!(await hasActiveSideDialogReplyObligation(dialogId))) {
+        return displayState;
+    }
+    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+    const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
+    const blocked = blockerDisplayState({
+        hasQ4H: q4h.length > 0,
+        hasSideDialogs: pendingSideDialogs.length > 0,
+    });
+    const healedDisplayState = blocked ?? pendingReplyObligationDisplayState();
+    log.warn('Prevented sideDialog with active reply obligation from entering idle display state', new Error('sideDialog idle display-state invariant violation'), {
+        dialogId: dialogId.valueOf(),
+        rootId: dialogId.rootId,
+        selfId: dialogId.selfId,
+        healedDisplayState,
+    });
+    return healedDisplayState;
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -345,6 +393,7 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
     await setDialogExecutionMarker(dialogId, undefined);
 }
 async function setDialogDisplayState(dialogId, displayState) {
+    displayState = await coerceIdleDisplayStateForActiveSideDialogReplyObligation(dialogId, displayState);
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -441,7 +490,8 @@ async function computeIdleDisplayState(dlg) {
         latest.executionMarker.kind === 'dead') {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
-    if (latest?.executionMarker?.kind === 'interrupted') {
+    if (latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
         return {
             kind: 'stopped',
             reason: latest.executionMarker.reason,
@@ -457,14 +507,12 @@ async function computeIdleDisplayState(dlg) {
     }
     const hasQ4H = await dlg.hasPendingQ4H();
     const hasSideDialogs = await dlg.hasPendingSideDialogs();
-    if (hasQ4H && hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+    if (blocked) {
+        return blocked;
     }
-    if (hasQ4H) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
-    }
-    if (hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    if (await hasActiveSideDialogReplyObligation(dlg.id)) {
+        return pendingReplyObligationDisplayState();
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -480,7 +528,8 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         latest.executionMarker.kind === 'dead') {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
-    if (latest?.executionMarker?.kind === 'interrupted') {
+    if (latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
         return {
             kind: 'stopped',
             reason: latest.executionMarker.reason,
@@ -494,21 +543,19 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: true,
         };
     }
-    if (latest && (await hasSideDialogFinalResponseAnchor(dialogId, latest))) {
-        return { kind: 'idle_waiting_user' };
-    }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
     const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
     const hasSideDialogs = pendingSideDialogs.length > 0;
-    if (hasQ4H && hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+    const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+    if (blocked) {
+        return blocked;
     }
-    if (hasQ4H) {
-        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    if (await hasActiveSideDialogReplyObligation(dialogId)) {
+        return pendingReplyObligationDisplayState();
     }
-    if (hasSideDialogs) {
-        return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+    if (latest && (await hasSideDialogFinalResponseAnchor(dialogId, latest))) {
+        return { kind: 'idle_waiting_user' };
     }
     return { kind: 'idle_waiting_user' };
 }
@@ -602,23 +649,22 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: true,
             };
         }
-        if (await hasSideDialogFinalResponseAnchor(dialogId, latest)) {
-            return { kind: 'idle_waiting_user' };
-        }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
         const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
         const hasSideDialogs = pendingSideDialogs.length > 0;
-        if (hasQ4H && hasSideDialogs) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_sideDialogs' } };
+        const blocked = blockerDisplayState({ hasQ4H, hasSideDialogs });
+        if (blocked) {
+            return blocked;
         }
-        if (hasQ4H) {
-            return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+        if (await hasActiveSideDialogReplyObligation(dialogId)) {
+            return pendingReplyObligationDisplayState();
         }
-        if (hasSideDialogs) {
-            return { kind: 'blocked', reason: { kind: 'waiting_for_sideDialogs' } };
+        if (await hasSideDialogFinalResponseAnchor(dialogId, latest)) {
+            return { kind: 'idle_waiting_user' };
         }
-        if (latest.executionMarker?.kind === 'interrupted') {
+        if (latest.executionMarker?.kind === 'interrupted' &&
+            latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
             return {
                 kind: 'stopped',
                 reason: latest.executionMarker.reason,
@@ -673,7 +719,9 @@ function isRecoverableGeneratingLatest(latest) {
     if (marker.kind === 'dead') {
         return false;
     }
-    return marker.kind !== 'interrupted' || marker.reason.kind === 'pending_course_start';
+    return (marker.kind !== 'interrupted' ||
+        marker.reason.kind === 'pending_course_start' ||
+        marker.reason.kind === 'pending_reply_obligation');
 }
 async function reconcileDisplayStatesAfterRestart() {
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
@@ -743,7 +791,8 @@ async function reconcileDisplayStatesAfterRestart() {
                         needsDrive: true,
                         displayState: { kind: 'proceeding' },
                         executionMarker: existingMarker?.kind === 'interrupted' &&
-                            existingMarker.reason.kind === 'pending_course_start'
+                            (existingMarker.reason.kind === 'pending_course_start' ||
+                                existingMarker.reason.kind === 'pending_reply_obligation')
                             ? undefined
                             : existingMarker,
                     },

package/dist/dialog-interruption.js

@@ -24,6 +24,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'emergency_stop':
         case 'server_restart':
         case 'pending_course_start':
+        case 'pending_reply_obligation':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':
@@ -37,6 +38,7 @@ function isInterruptionReasonManualResumeEligible(reason) {
 function doesInterruptionReasonRequireExplicitResume(reason) {
     switch (reason.kind) {
         case 'pending_course_start':
+        case 'pending_reply_obligation':
             return false;
         case 'user_stop':
         case 'emergency_stop':

package/dist/dialog.d.ts

@@ -354,6 +354,25 @@ export declare abstract class Dialog {
         skipTaskdoc?: boolean;
         sideDialogReplyTarget: DialogSideDialogReplyTarget;
     }): DialogQueuedPromptState;
+    private persistPendingRuntimePrompt;
+    private runtimePromptCommon;
+    queueRuntimeReplyPrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        tellaskReplyDirective: TellaskReplyDirective;
+        skipTaskdoc?: boolean;
+    }): Promise<DialogQueuedPromptState>;
+    queueRuntimeSideDialogPrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        tellaskReplyDirective: TellaskReplyDirective;
+        skipTaskdoc?: boolean;
+        sideDialogReplyTarget: DialogSideDialogReplyTarget;
+    }): Promise<DialogQueuedPromptState>;
     hasUpNext(): boolean;
     peekUpNext(): DialogQueuedPromptState | undefined;
     takeUpNext(): DialogQueuedPromptState | undefined;
@@ -678,6 +697,7 @@ export declare abstract class DialogStore {
      * Start a new course in storage
      */
     startNewCourse(_dialog: Dialog, _newCoursePrompt: DialogRuntimePrompt): Promise<void>;
+    persistPendingRuntimePrompt(_dialog: Dialog, _prompt: DialogRuntimePrompt): Promise<void>;
     /**
      * Handle stream error
      */

package/dist/dialog.js

@@ -1018,6 +1018,65 @@ class Dialog {
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
         return merged;
     }
+    async persistPendingRuntimePrompt(prompt) {
+        await this.dlgStore.persistPendingRuntimePrompt(this, prompt);
+    }
+    runtimePromptCommon(options) {
+        const trimmed = options.prompt.trim();
+        if (!trimmed) {
+            throw new Error('Prompt is required to queue runtime prompt');
+        }
+        return {
+            prompt: trimmed,
+            msgId: options.msgId,
+            grammar: options.grammar,
+            userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
+            origin: 'runtime',
+            runControl: undefined,
+        };
+    }
+    async queueRuntimeReplyPrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_reply',
+            tellaskReplyDirective: options.tellaskReplyDirective,
+            skipTaskdoc: options.skipTaskdoc,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            tellaskReplyDirective: created.tellaskReplyDirective,
+            skipTaskdoc: created.skipTaskdoc,
+        });
+        return created;
+    }
+    async queueRuntimeSideDialogPrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_sideDialog',
+            tellaskReplyDirective: options.tellaskReplyDirective,
+            skipTaskdoc: options.skipTaskdoc,
+            sideDialogReplyTarget: options.sideDialogReplyTarget,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            tellaskReplyDirective: created.tellaskReplyDirective,
+            skipTaskdoc: created.skipTaskdoc,
+            sideDialogReplyTarget: created.sideDialogReplyTarget,
+        });
+        return created;
+    }
     hasUpNext() {
         return this._upNextQueue.length > 0;
     }
@@ -1905,6 +1964,7 @@ class DialogStore {
      * Start a new course in storage
      */
     async startNewCourse(_dialog, _newCoursePrompt) { }
+    async persistPendingRuntimePrompt(_dialog, _prompt) { }
     /**
      * Handle stream error
      */

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

@@ -23,6 +23,48 @@ const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
+function buildRuntimeReplyReminderFollowUp(args) {
+    const common = {
+        prompt: args.prompt,
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'runtime',
+        userLanguageCode: args.language,
+        tellaskReplyDirective: args.directive,
+    };
+    return args.sideDialogReplyTarget === undefined
+        ? {
+            kind: 'runtime_reply_reminder',
+            ...common,
+        }
+        : {
+            kind: 'runtime_sideDialog_reply_reminder',
+            ...common,
+            sideDialogReplyTarget: args.sideDialogReplyTarget,
+        };
+}
+async function queueReplyReminderFollowUp(args) {
+    if (args.followUp.kind === 'runtime_sideDialog_reply_reminder') {
+        await args.dialog.queueRuntimeSideDialogPrompt({
+            prompt: args.followUp.prompt,
+            msgId: args.followUp.msgId,
+            grammar: args.followUp.grammar ?? 'markdown',
+            userLanguageCode: args.followUp.userLanguageCode,
+            tellaskReplyDirective: args.followUp.tellaskReplyDirective,
+            skipTaskdoc: args.followUp.skipTaskdoc,
+            sideDialogReplyTarget: args.followUp.sideDialogReplyTarget,
+        });
+        return;
+    }
+    await args.dialog.queueRuntimeReplyPrompt({
+        prompt: args.followUp.prompt,
+        msgId: args.followUp.msgId,
+        grammar: args.followUp.grammar ?? 'markdown',
+        userLanguageCode: args.followUp.userLanguageCode,
+        tellaskReplyDirective: args.followUp.tellaskReplyDirective,
+        skipTaskdoc: args.followUp.skipTaskdoc,
+    });
+}
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
@@ -52,6 +94,10 @@ function resolveDirectFallbackResponse(args) {
             source: 'saying',
         };
     }
+    // Thinking-only output is intentionally a fallback candidate: some providers/models can finish a
+    // Side Dialog with useful content in thinking and no public saying. This helper only extracts the
+    // candidate; callers below must still reject it when a same-round function/tellask call needs
+    // auto-continuation, when the dialog is suspended, or when another follow-up prompt is queued.
     if (args.driveResult.lastAssistantThinkingContent !== null &&
         args.driveResult.lastAssistantThinkingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantThinkingGenseq !== 'number' ||
@@ -163,6 +209,79 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
+async function hasAssistantOutputAfterAssignmentAnchor(args) {
+    const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, args.dialog.currentCourse, args.dialog.status);
+    let assignmentGenseq;
+    for (const event of events) {
+        if (event.type === 'tellask_anchor_record' &&
+            event.anchorRole === 'assignment' &&
+            event.callId === args.callId) {
+            assignmentGenseq = event.genseq;
+            continue;
+        }
+        if (assignmentGenseq !== undefined &&
+            (event.type === 'agent_thought_record' || event.type === 'agent_words_record') &&
+            event.genseq >= assignmentGenseq &&
+            event.content.trim() !== '') {
+            return true;
+        }
+    }
+    return false;
+}
+async function resolveStrandedSideDialogReplyReminderFollowUp(args) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    const displayState = latest?.displayState;
+    const isRecoverableProjection = displayState?.kind === 'idle_waiting_user' ||
+        (displayState?.kind === 'stopped' && displayState.reason.kind === 'pending_reply_obligation');
+    if (!latest ||
+        !isRecoverableProjection ||
+        latest.pendingCourseStartPrompt !== undefined ||
+        latest.executionMarker?.kind === 'dead') {
+        return undefined;
+    }
+    const directive = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (!directive) {
+        return undefined;
+    }
+    const ownerDialogId = directive.targetDialogId.trim();
+    if (ownerDialogId === '') {
+        throw new Error(`stranded sideDialog reply recovery invariant violation: empty targetDialogId ` +
+            `(dialogId=${args.dialog.id.valueOf()}, targetCallId=${directive.targetCallId})`);
+    }
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(new dialog_1.DialogID(ownerDialogId, args.dialog.id.rootId), args.dialog.status);
+    const pendingRecord = pending.find((record) => record.sideDialogId === args.dialog.id.selfId && record.callId === directive.targetCallId);
+    if (!pendingRecord) {
+        return undefined;
+    }
+    if (!(await hasAssistantOutputAfterAssignmentAnchor({
+        dialog: args.dialog,
+        callId: pendingRecord.callId,
+    }))) {
+        return undefined;
+    }
+    const language = (0, work_language_1.getWorkLanguage)();
+    const sideDialogReplyTarget = {
+        ownerDialogId,
+        callType: pendingRecord.callType,
+        callId: pendingRecord.callId,
+        callSiteCourse: pendingRecord.callSiteCourse,
+        callSiteGenseq: pendingRecord.callSiteGenseq,
+    };
+    return {
+        kind: 'runtime_sideDialog_reply_reminder',
+        prompt: await buildReplyToolReminderPrompt({
+            dlg: args.dialog,
+            directive,
+            language,
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'runtime',
+        userLanguageCode: language,
+        tellaskReplyDirective: directive,
+        sideDialogReplyTarget,
+    };
+}
 async function clearConsumedDeferredRootQueueIfIdle(dialog) {
     if (dialog.id.selfId !== dialog.id.rootId) {
         return;
@@ -344,6 +463,8 @@ async function inspectNoPromptSideDialogDrive(args) {
     const inProgressGenerationResumeAllowed = args.driveOptions?.resumeInProgressGeneration === true;
     const supplyResponseParentReviveAllowed = source === 'kernel_driver_supply_response_parent_revive' &&
         hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
+    const pendingReplyObligationResumeAllowed = latest?.executionMarker?.kind === 'interrupted' &&
+        latest.executionMarker.reason.kind === 'pending_reply_obligation';
     if (lastEvent?.type === 'tellask_anchor_record' && lastEvent.anchorRole === 'response') {
         return {
             shouldReject: true,
@@ -356,7 +477,8 @@ async function inspectNoPromptSideDialogDrive(args) {
     }
     if (!explicitInterruptedResumeAllowed &&
         !inProgressGenerationResumeAllowed &&
-        !supplyResponseParentReviveAllowed) {
+        !supplyResponseParentReviveAllowed &&
+        !pendingReplyObligationResumeAllowed) {
         return {
             shouldReject: true,
             source,
@@ -618,6 +740,29 @@ async function executeDriveRound(args) {
         // suspended by pending Q4H or sideDialogs. This prevents duplicate generations when
         // multiple wake-ups race around the same sideDialog completion boundary.
         if (!humanPrompt) {
+            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
+                const strandedReplyReminder = await resolveStrandedSideDialogReplyReminderFollowUp({
+                    dialog,
+                });
+                if (strandedReplyReminder !== undefined) {
+                    await queueReplyReminderFollowUp({ dialog, followUp: strandedReplyReminder });
+                    args.scheduleDrive(dialog, {
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_follow_up',
+                            reason: 'follow_up_prompt',
+                        },
+                    });
+                    log_1.log.warn('kernel-driver recovered stranded sideDialog reply obligation by queueing reply reminder', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        targetCallId: strandedReplyReminder.tellaskReplyDirective.targetCallId,
+                        targetOwnerDialogId: strandedReplyReminder.sideDialogReplyTarget.ownerDialogId,
+                    });
+                    return;
+                }
+            }
             if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
@@ -894,8 +1039,10 @@ async function executeDriveRound(args) {
                         driveResult.lastFunctionCallGenseq > 0 &&
                         directFallbackResponse.responseGenseq <= driveResult.lastFunctionCallGenseq;
                     if (hasInProgressFunctionCall) {
-                        // Any function call means execution is still in-progress. Only supply when the tellaskee
-                        // has produced a newer assistant saying after the latest function call.
+                        // A candidate direct fallback, including thinking-only output, must be newer than the
+                        // latest same-round function/tellask call. Otherwise the call is still the active move
+                        // and may auto-continue; the candidate is merely pre-tool reasoning/progress, not final
+                        // tellasker delivery.
                         log_1.log.debug('kernel-driver skip sideDialog response supply because latest assistant output is not after function calls', undefined, {
                             rootId: dialog.id.rootId,
                             selfId: dialog.id.selfId,
@@ -926,35 +1073,16 @@ async function executeDriveRound(args) {
                             else {
                                 if (!activePromptWasReplyToolReminder) {
                                     const language = (0, work_language_1.getWorkLanguage)();
-                                    followUp =
-                                        sideDialogReplyTarget === 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_sideDialog_reply_reminder',
-                                                prompt: await buildReplyToolReminderPrompt({
-                                                    dlg: dialog,
-                                                    directive: activeTellaskReplyDirective,
-                                                    language,
-                                                }),
-                                                msgId: (0, id_1.generateShortId)(),
-                                                grammar: 'markdown',
-                                                origin: 'runtime',
-                                                userLanguageCode: language,
-                                                tellaskReplyDirective: activeTellaskReplyDirective,
-                                                sideDialogReplyTarget,
-                                            };
+                                    followUp = buildRuntimeReplyReminderFollowUp({
+                                        directive: activeTellaskReplyDirective,
+                                        prompt: await buildReplyToolReminderPrompt({
+                                            dlg: dialog,
+                                            directive: activeTellaskReplyDirective,
+                                            language,
+                                        }),
+                                        language,
+                                        sideDialogReplyTarget,
+                                    });
                                     log_1.log.debug('kernel-driver queued sideDialog replyTellask reminder after plain reply', undefined, {
                                         dialogId: dialog.id.valueOf(),
                                         targetCallId: activeTellaskReplyDirective.targetCallId,
@@ -1042,6 +1170,8 @@ async function executeDriveRound(args) {
                     Number.isFinite(driveResult.lastFunctionCallGenseq) &&
                     driveResult.lastFunctionCallGenseq > 0 &&
                     directFallbackResponse.responseGenseq <= driveResult.lastFunctionCallGenseq;
+                // Same rule as Side Dialog final delivery: direct fallback is allowed only after the
+                // candidate content is known to be post-tool and no same-round call is waiting to continue.
                 if (!hasInProgressFunctionCall) {
                     if (!activePromptWasReplyToolReminder) {
                         const language = (0, work_language_1.getWorkLanguage)();
@@ -1084,6 +1214,18 @@ async function executeDriveRound(args) {
                 }
             }
             if (followUp) {
+                if (followUp.kind === 'runtime_reply_reminder' ||
+                    followUp.kind === 'runtime_sideDialog_reply_reminder') {
+                    await queueReplyReminderFollowUp({ dialog, followUp });
+                    args.scheduleDrive(dialog, {
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_follow_up',
+                            reason: 'follow_up_prompt',
+                        },
+                    });
+                    return driveResult;
+                }
                 args.scheduleDrive(dialog, {
                     waitInQue: true,
                     driveOptions: {
@@ -1116,9 +1258,7 @@ async function executeDriveRound(args) {
                             case 'registered_assignment_update':
                             case 'new_course_runtime_guide':
                             case 'new_course_runtime_reply':
-                            case 'new_course_runtime_sideDialog':
-                            case 'runtime_reply_reminder':
-                            case 'runtime_sideDialog_reply_reminder': {
+                            case 'new_course_runtime_sideDialog': {
                                 const runtimeCommon = {
                                     ...common,
                                     origin: 'runtime',
@@ -1127,8 +1267,7 @@ async function executeDriveRound(args) {
                                         : { skipTaskdoc: followUp.skipTaskdoc }),
                                 };
                                 if (followUp.kind === 'registered_assignment_update' ||
-                                    followUp.kind === 'new_course_runtime_sideDialog' ||
-                                    followUp.kind === 'runtime_sideDialog_reply_reminder') {
+                                    followUp.kind === 'new_course_runtime_sideDialog') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,
@@ -1136,8 +1275,7 @@ async function executeDriveRound(args) {
                                     };
                                     return prompt;
                                 }
-                                if (followUp.kind === 'new_course_runtime_reply' ||
-                                    followUp.kind === 'runtime_reply_reminder') {
+                                if (followUp.kind === 'new_course_runtime_reply') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,