dominds 1.25.7 → 1.25.8

package/dist/dialog-display-state.js

@@ -97,21 +97,28 @@ function isNonIdleDisplayProjection(state) {
 function hasPendingNextStepTriggers(latest) {
     return (latest?.nextStep.triggers.length ?? 0) > 0;
 }
-function q4hSuspensionDisplayState(hasQ4H) {
+function waitingHumanInputDisplayState(hasQ4H) {
     if (hasQ4H) {
         return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
     }
     return undefined;
 }
+async function waitingSideDialogDisplayState(dialogId, status, activeReplyObligation) {
+    if (status !== 'running' || activeReplyObligation === undefined) {
+        return undefined;
+    }
+    const activeCallees = await persistence_1.DialogPersistence.loadActiveCallees(dialogId, status);
+    const hasPendingSideDialog = activeCallees.batches.some((batch) => batch.callees.some((callee) => callee.status === 'pending'));
+    if (!hasPendingSideDialog) {
+        return undefined;
+    }
+    return { kind: 'waiting_side_dialog' };
+}
 function pendingReplyObligationDisplayState(activeReplyObligation) {
     if (activeReplyObligation === undefined) {
         return undefined;
     }
-    return {
-        kind: 'stopped',
-        reason: { kind: 'pending_reply_obligation' },
-        continueEnabled: true,
-    };
+    return { kind: 'proceeding' };
 }
 async function resolveSideDialogFinalResponseClosure(args) {
     if (!args.latest) {
@@ -215,7 +222,7 @@ async function getRunControlCountsSnapshot() {
             else if (latest?.executionMarker?.kind === 'interrupted' &&
                 isStoppedReasonResumable(latest.executionMarker.reason)) {
                 // Keep run-control counts aligned with actual Continue affordance:
-                // - ordinary interrupted dialogs count as resumable only when no Q4H suspension remains
+                // - ordinary interrupted dialogs count as resumable only when no Q4H human-input wait remains
                 // - legacy interjection-paused dialogs still count as resumable even if Q4H remains,
                 //   because Continue only re-evaluates the original task from fresh facts
                 if ((0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
@@ -433,28 +440,57 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
             return;
         }
         if (status === 'running' && displayState.kind === 'idle_waiting_user') {
-            const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
+            const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+            if (waitingHumanInput) {
+                nextDisplayState = waitingHumanInput;
+                log.warn('Redirecting idle displayState to waiting-human-input state', undefined, {
+                    dialogId: dialogId.valueOf(),
+                    rootId: dialogId.rootId,
+                    selfId: dialogId.selfId,
+                    status,
+                    nextDisplayState,
+                    previousDisplayState: latest?.displayState ?? null,
+                    previousExecutionMarker: latest?.executionMarker ?? null,
+                });
+            }
+            else if (!(await settleFinalResponseClosureForIdleProjection(dialogId, await resolveSideDialogFinalResponseClosure({
                 dialogId,
                 latest,
-            });
-            const finalResponseClosedForIdle = await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure);
-            if (!finalResponseClosedForIdle) {
+            })))) {
                 const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, status);
-                const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
-                if (pendingReplyObligation) {
-                    nextDisplayState = pendingReplyObligation;
-                    log.warn('Redirecting idle displayState to pending reply obligation projection', undefined, {
+                const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, status, activeReplyObligation);
+                if (waitingSideDialog) {
+                    nextDisplayState = waitingSideDialog;
+                    log.warn('Redirecting idle displayState to waiting-side-dialog state', undefined, {
                         dialogId: dialogId.valueOf(),
                         rootId: dialogId.rootId,
                         selfId: dialogId.selfId,
                         status,
+                        nextDisplayState,
                         targetCallId: activeReplyObligation?.targetCallId ?? null,
                         targetDialogId: activeReplyObligation?.targetDialogId.valueOf() ?? null,
                         previousDisplayState: latest?.displayState ?? null,
                         previousExecutionMarker: latest?.executionMarker ?? null,
-                        sideDialogFinalResponseCallId: latest?.sideDialogFinalResponse?.callId ?? null,
                     });
                 }
+                else {
+                    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+                    if (pendingReplyObligation) {
+                        nextDisplayState = pendingReplyObligation;
+                        log.warn('Redirecting idle displayState to active reply obligation state', undefined, {
+                            dialogId: dialogId.valueOf(),
+                            rootId: dialogId.rootId,
+                            selfId: dialogId.selfId,
+                            status,
+                            nextDisplayState,
+                            targetCallId: activeReplyObligation?.targetCallId ?? null,
+                            targetDialogId: activeReplyObligation?.targetDialogId.valueOf() ?? null,
+                            previousDisplayState: latest?.displayState ?? null,
+                            previousExecutionMarker: latest?.executionMarker ?? null,
+                            sideDialogFinalResponseCallId: latest?.sideDialogFinalResponse?.callId ?? null,
+                        });
+                    }
+                }
             }
         }
     }
@@ -498,7 +534,7 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
     if (broadcastToClients) {
         broadcastToClients(typed);
     }
-    if (shouldBroadcastRunControlCounts(previousDisplayState, displayState)) {
+    if (shouldBroadcastRunControlCounts(previousDisplayState, nextDisplayState)) {
         try {
             await broadcastRunControlCountsSnapshot();
         }
@@ -544,9 +580,9 @@ async function computeIdleDisplayState(dlg) {
             continueEnabled: true,
         };
     }
-    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
-    if (q4hSuspension) {
-        return q4hSuspension;
+    const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (waitingHumanInput) {
+        return waitingHumanInput;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
         dialogId: dlg.id,
@@ -556,6 +592,10 @@ async function computeIdleDisplayState(dlg) {
         return { kind: 'idle_waiting_user' };
     }
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+    const waitingSideDialog = await waitingSideDialogDisplayState(dlg.id, dlg.status, activeReplyObligation);
+    if (waitingSideDialog) {
+        return waitingSideDialog;
+    }
     const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
     if (pendingReplyObligation) {
         return pendingReplyObligation;
@@ -589,15 +629,19 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: true,
         };
     }
-    const q4hSuspension = q4hSuspensionDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
-    if (q4hSuspension) {
-        return q4hSuspension;
+    const waitingHumanInput = waitingHumanInputDisplayState(latest?.userWait?.kind === 'awaiting_user_answer');
+    if (waitingHumanInput) {
+        return waitingHumanInput;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
     if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
         return { kind: 'idle_waiting_user' };
     }
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+    const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, 'running', activeReplyObligation);
+    if (waitingSideDialog) {
+        return waitingSideDialog;
+    }
     const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
     if (pendingReplyObligation) {
         return pendingReplyObligation;
@@ -681,15 +725,15 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
             // WARNING:
             // This is the one place where the projection intentionally preserves legacy
-            // paused-interjection stopped state ahead of the current suspension facts. That is not a bug:
+            // paused-interjection stopped state ahead of the current wait facts. That is not a bug:
             // the UI may still need to show that the original task was paused even if the underlying
             // dialog is now waiting on Q4H.
             //
             // The true source-of-truth decision about what Continue should do next lives in `flow.ts`'s
             // resume path, which performs a fresh fact scan at resume time and then either restores the
-            // Q4H suspension projection or keeps driving immediately.
+            // Q4H waiting-human-input state or keeps driving immediately.
             //
-            // Do not "heal" this branch away by prioritizing suspension facts here; that would collapse the
+            // Do not "heal" this branch away by prioritizing wait facts here; that would collapse the
             // temporary interjection UX and make repeated interjection turns revert too early.
             return {
                 kind: 'stopped',
@@ -704,15 +748,19 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: true,
             };
         }
-        const q4hSuspension = q4hSuspensionDisplayState(latest.userWait?.kind === 'awaiting_user_answer');
-        if (q4hSuspension) {
-            return q4hSuspension;
+        const waitingHumanInput = waitingHumanInputDisplayState(latest.userWait?.kind === 'awaiting_user_answer');
+        if (waitingHumanInput) {
+            return waitingHumanInput;
         }
         const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
         if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
             return { kind: 'idle_waiting_user' };
         }
         const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+        const waitingSideDialog = await waitingSideDialogDisplayState(dialogId, 'running', activeReplyObligation);
+        if (waitingSideDialog) {
+            return waitingSideDialog;
+        }
         const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
         if (pendingReplyObligation) {
             return pendingReplyObligation;
@@ -860,7 +908,10 @@ async function reconcileDisplayStatesAfterRestart() {
             if (!nextIdle) {
                 continue;
             }
-            const next = nextIdle.kind === 'blocked' || nextIdle.kind === 'stopped' || nextIdle.kind === 'dead'
+            const next = nextIdle.kind === 'blocked' ||
+                nextIdle.kind === 'waiting_side_dialog' ||
+                nextIdle.kind === 'stopped' ||
+                nextIdle.kind === 'dead'
                 ? nextIdle
                 : {
                     kind: 'stopped',

package/dist/dialog-fork.js

@@ -274,11 +274,7 @@ function countFunctionCalls(events) {
 function computeRootForkDisplayState(args) {
     const topFrame = args.askerStack?.askerStack[args.askerStack.askerStack.length - 1];
     if (topFrame?.tellaskReplyObligation !== undefined) {
-        return {
-            kind: 'stopped',
-            reason: { kind: 'pending_reply_obligation' },
-            continueEnabled: true,
-        };
+        return { kind: 'proceeding' };
     }
     if (args.action.kind === 'draft_user_text') {
         return { kind: 'idle_waiting_user' };
@@ -292,11 +288,7 @@ function computeRootForkDisplayState(args) {
 function computeSideDialogForkDisplayState(askerStack) {
     const topFrame = askerStack?.askerStack[askerStack.askerStack.length - 1];
     if (topFrame?.tellaskReplyObligation !== undefined) {
-        return {
-            kind: 'stopped',
-            reason: { kind: 'pending_reply_obligation' },
-            continueEnabled: true,
-        };
+        return { kind: 'proceeding' };
     }
     return { kind: 'idle_waiting_user' };
 }

package/dist/dialog-interruption.js

@@ -25,11 +25,12 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'emergency_stop':
         case 'server_restart':
         case 'pending_runtime_prompt':
-        case 'pending_reply_obligation':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':
             return true;
+        case 'pending_reply_obligation':
+            return false;
         default: {
             const _exhaustive = reason;
             return _exhaustive;

package/dist/dialog.d.ts

@@ -375,6 +375,8 @@ export declare abstract class Dialog {
     hasQueuedPrompt(): boolean;
     peekQueuedPrompt(): DialogQueuedPromptState | undefined;
     takeQueuedPrompt(): DialogQueuedPromptState | undefined;
+    removeQueuedPromptByMsgId(msgId: string): boolean;
+    removeQueuedPromptsMatching(predicate: (prompt: DialogQueuedPromptState) => boolean): number;
     setActiveRunControlSpec(spec?: DialogRunControlSpec): void;
     getActiveRunControlSpec(): DialogRunControlSpec | undefined;
     setNewCourseHook(hook?: NewCourseHook): void;
@@ -459,6 +461,7 @@ export declare abstract class Dialog {
     persistFunctionCall(id: string, name: string, rawArgumentsText: string, genseq: number, rawId?: string): Promise<void>;
     persistTellaskCall(id: string, name: TellaskCallRecordName, rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
+        replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
     /**
      * Post sideDialog completion response to this dialog.
@@ -693,6 +696,7 @@ export declare abstract class DialogStore {
     persistFunctionCall(_dialog: Dialog, _id: string, _name: string, _rawArgumentsText: string, _genseq: number, _rawId?: string): Promise<void>;
     persistTellaskCall(_dialog: Dialog, _id: string, _name: TellaskCallRecordName, _rawArgumentsText: string, _genseq: number, _options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
+        replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
     /**
      * Start a new course in storage

package/dist/dialog.js

@@ -1186,6 +1186,20 @@ class Dialog {
     takeQueuedPrompt() {
         return this._queuedPrompts.shift();
     }
+    removeQueuedPromptByMsgId(msgId) {
+        const normalized = msgId.trim();
+        if (normalized === '') {
+            return false;
+        }
+        const before = this._queuedPrompts.length;
+        this._queuedPrompts = this._queuedPrompts.filter((prompt) => prompt.msgId !== normalized);
+        return this._queuedPrompts.length !== before;
+    }
+    removeQueuedPromptsMatching(predicate) {
+        const before = this._queuedPrompts.length;
+        this._queuedPrompts = this._queuedPrompts.filter((prompt) => !predicate(prompt));
+        return before - this._queuedPrompts.length;
+    }
     setActiveRunControlSpec(spec) {
         this._activeRunControlSpec = spec;
     }

package/dist/llm/gen/mock.d.ts

@@ -65,6 +65,7 @@ export declare class MockGen implements LlmGenerator {
     private responseMatchesContext;
     private normalizeFuncCallArgs;
     private extractLastAssistantSaying;
+    private extractCurrentPromptMsgId;
     private buildReplyToolReminderAutoResponse;
     /**
      * Find matching response using EXACT last message only.

package/dist/llm/gen/mock.js

@@ -276,6 +276,16 @@ class MockGen {
         }
         return null;
     }
+    extractCurrentPromptMsgId(context) {
+        for (let index = context.length - 1; index >= 0; index -= 1) {
+            const msg = context[index];
+            if (msg?.type === 'prompting_msg') {
+                const trimmed = msg.msgId.trim();
+                return trimmed === '' ? undefined : trimmed;
+            }
+        }
+        return undefined;
+    }
     buildReplyToolReminderAutoResponse(input, role, context) {
         if (role !== 'user' || !(0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(input)) {
             return null;
@@ -288,12 +298,14 @@ class MockGen {
         if (!replyContent) {
             return null;
         }
+        const promptMsgId = this.extractCurrentPromptMsgId(context);
         return {
             message: input,
             role,
             response: '',
             funcCalls: [
                 {
+                    id: promptMsgId ? `mock_reply_${promptMsgId}` : undefined,
                     name: toolMatch[1],
                     arguments: { replyContent },
                 },

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

@@ -396,8 +396,7 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
             latest.generating !== true &&
             latest.executionMarker?.kind !== 'interrupted' &&
             !isNonIdleDisplayProjection(latest.displayState)) ||
-        latest.executionMarker?.kind === 'dead' ||
-        latest.pendingRuntimePrompt) {
+        latest.executionMarker?.kind === 'dead') {
         return {
             cleared: false,
             previousGenerating: latest?.generating ?? null,
@@ -405,22 +404,31 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
         };
     }
     const finalResponseCallId = latest.sideDialogFinalResponse?.callId.trim();
-    if (finalResponseCallId !== undefined && finalResponseCallId !== '') {
-        const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dialog.id, args.dialog.status);
-        if (activeReplyObligation?.targetCallId.trim() === finalResponseCallId) {
-            await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(args.dialog.id, undefined, args.dialog.status);
-        }
+    if (finalResponseCallId === undefined || finalResponseCallId === '') {
+        return {
+            cleared: false,
+            previousGenerating: latest.generating ?? null,
+            previousNextStepTriggerCount: latest.nextStep.triggers.length,
+        };
     }
-    const displayState = await (0, dialog_display_state_1.computeIdleDisplayState)(args.dialog);
+    const pendingRuntimePromptMsgId = latest.pendingRuntimePrompt?.msgId;
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dialog.id, args.dialog.status);
+    if (activeReplyObligation?.targetCallId.trim() === finalResponseCallId) {
+        await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(args.dialog.id, undefined, args.dialog.status);
+    }
+    const displayState = { kind: 'idle_waiting_user' };
+    if (pendingRuntimePromptMsgId !== undefined) {
+        args.dialog.removeQueuedPromptByMsgId(pendingRuntimePromptMsgId);
+    }
+    args.dialog.removeQueuedPromptsMatching((prompt) => isPendingRuntimePromptFollowUp(prompt));
     await persistence_1.DialogPersistence.mutateDialogLatest(args.dialog.id, () => ({
         kind: 'patch',
         patch: {
             generating: false,
             nextStep: (0, dialog_latest_state_1.createEmptyDialogNextStepState)(),
+            pendingRuntimePrompt: undefined,
             displayState,
-            executionMarker: displayState.kind === 'stopped'
-                ? { kind: 'interrupted', reason: displayState.reason }
-                : undefined,
+            executionMarker: undefined,
         },
     }), args.dialog.status);
     await persistence_1.DialogPersistence.removeWakeQueueEntriesForDialog(args.dialog.id, args.dialog.status);
@@ -912,6 +920,15 @@ async function inspectSideDialogBusinessContinuationDrive(args) {
             sideDialogFinalResponseCallId,
         };
     }
+    if (args.hasQueuedPrompt) {
+        return {
+            shouldReject: false,
+            source,
+            displayState,
+            currentCourse,
+            sideDialogFinalResponseCallId,
+        };
+    }
     if (requestedWorkReplyContinuation && args.requestedWorkReplyClaim.status !== 'claimed') {
         return {
             shouldReject: true,
@@ -1333,13 +1350,14 @@ async function executeDriveRound(args) {
                 driveOptions,
             });
         }
-        if (!humanPrompt && dialog instanceof dialog_1.SideDialog && !dialog.hasQueuedPrompt()) {
+        if (!humanPrompt && dialog instanceof dialog_1.SideDialog) {
             const inspection = await inspectSideDialogBusinessContinuationDrive({
                 dialog,
                 driveOptions,
                 requestedWorkReplyClaim,
                 replyDeliveryRecoveryClaim,
                 toolFollowupClaim,
+                hasQueuedPrompt: dialog.hasQueuedPrompt(),
             });
             if (inspection.shouldReject) {
                 if (inspection.rejection === 'finalized_after_response_anchor') {
@@ -1662,6 +1680,23 @@ async function executeDriveRound(args) {
         if (!interruptedBySignal) {
             const queuedFollowUp = dialog.peekQueuedPrompt();
             if (queuedFollowUp && isPendingRuntimePromptFollowUp(queuedFollowUp)) {
+                const claim = await claimPendingRuntimePromptForDrive({
+                    dialog,
+                    prompt: queuedFollowUp,
+                });
+                if (claim.status === 'stale') {
+                    const discarded = dialog.takeQueuedPrompt();
+                    if (!discarded || discarded.msgId !== queuedFollowUp.msgId) {
+                        throw new Error(`pending runtime prompt invariant violation: expected queued prompt ${queuedFollowUp.msgId} before stale discard after core`);
+                    }
+                    log_1.log.debug('kernel-driver dropped stale pending runtime prompt after core', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        msgId: queuedFollowUp.msgId,
+                        kind: queuedFollowUp.kind,
+                    });
+                }
                 followUp = undefined;
             }
             else if (queuedFollowUp && isQueuedReplyObligationContinuation(queuedFollowUp)) {
@@ -1881,11 +1916,11 @@ async function executeDriveRound(args) {
                 driveResult &&
                 !interruptedBySignal &&
                 resolveDirectFallbackResponse({ driveResult, dialog }) !== undefined &&
-                activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
+                activeTellaskReplyDirective !== undefined &&
                 followUp === undefined) {
                 const directFallbackResponse = resolveDirectFallbackResponse({ driveResult, dialog });
                 if (directFallbackResponse === undefined) {
-                    throw new Error(`replyTellaskBack fallback invariant violation: missing direct fallback response for dialog=${dialog.id.valueOf()}`);
+                    throw new Error(`reply fallback invariant violation: missing direct fallback response for dialog=${dialog.id.valueOf()}`);
                 }
                 const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
                     Number.isFinite(driveResult.lastFunctionCallGenseq) &&
@@ -1909,12 +1944,18 @@ async function executeDriveRound(args) {
                             userLanguageCode: language,
                             tellaskReplyDirective: activeTellaskReplyDirective,
                         };
-                        log_1.log.debug('kernel-driver queued replyTellaskBack reminder prompt after plain reply', undefined, {
+                        log_1.log.debug('kernel-driver queued replyTellask reminder prompt after plain reply', undefined, {
                             dialogId: dialog.id.valueOf(),
+                            expectedReplyCallName: activeTellaskReplyDirective.expectedReplyCallName,
                             targetCallId: activeTellaskReplyDirective.targetCallId,
                         });
                     }
                     else {
+                        if (activeTellaskReplyDirective.expectedReplyCallName !== 'replyTellaskBack') {
+                            throw new Error(`reply fallback invariant violation: unsupported non-sideDialog reply tool ` +
+                                `${activeTellaskReplyDirective.expectedReplyCallName} for dialog=${dialog.id.valueOf()}`);
+                        }
+                        const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
                         await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
                             replyingDialog: dialog,
                             directive: activeTellaskReplyDirective,
@@ -1927,8 +1968,8 @@ async function executeDriveRound(args) {
                             directFallbackSource: directFallbackResponse.source,
                         });
                         await dialog.appendTellaskReplyResolution({
-                            callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
-                            replyCallName: 'replyTellaskBack',
+                            callId: directFallbackCallId,
+                            replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
                             targetCallId: activeTellaskReplyDirective.targetCallId,
                         });
                     }

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

@@ -37,7 +37,7 @@ export type DiligenceAutoContinueGateDecision = {
     kind: 'allowed';
 } | {
     kind: 'blocked';
-    reason: 'not_main_dialog' | 'active_run' | 'stop_requested' | 'execution_interrupted' | 'execution_dead' | 'q4h' | 'active_callee_dispatches';
+    reason: 'not_main_dialog' | 'active_run' | 'stop_requested' | 'execution_interrupted' | 'execution_dead' | 'q4h' | 'active_reply_obligation' | 'active_callee_dispatches';
 };
 export declare function evaluateDiligenceAutoContinueGate(options: {
     dlg: Dialog;

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

@@ -48,6 +48,7 @@ const dialog_1 = require("../../dialog");
 const dialog_display_state_1 = require("../../dialog-display-state");
 const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
+const persistence_1 = require("../../persistence");
 const problems_1 = require("../../problems");
 const driver_messages_1 = require("../../runtime/driver-messages");
 const work_language_1 = require("../../runtime/work-language");
@@ -152,6 +153,10 @@ async function evaluateDiligenceAutoContinueGate(options) {
     if (!suspension.canDrive) {
         return { kind: 'blocked', reason: 'q4h' };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(options.dlg.id, options.dlg.status);
+    if (activeReplyObligation !== undefined) {
+        return { kind: 'blocked', reason: 'active_reply_obligation' };
+    }
     if (suspension.backgroundCalleeDialogs) {
         return { kind: 'blocked', reason: 'active_callee_dispatches' };
     }
@@ -170,6 +175,13 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
             nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
         };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(options.dlg.id, options.dlg.status);
+    if (activeReplyObligation !== undefined) {
+        return {
+            kind: 'disabled',
+            nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
+        };
+    }
     const resolved = await resolveRtwsDiligenceConfig();
     if (resolved.kind === 'disabled') {
         return {

package/dist/llm/kernel-driver/tellask-special.js

@@ -2301,6 +2301,10 @@ async function processTellaskFunctionRound(args) {
                 deliveryMode: isReplyTellaskCallName(handled.call.callName)
                     ? 'func_call_requested'
                     : 'tellask_call_start',
+                ...(isReplyTellaskCallName(handled.call.callName) &&
+                    args.activePromptReplyDirective !== undefined
+                    ? { replyDirective: args.activePromptReplyDirective }
+                    : {}),
             });
             tellaskCallMessages.push({
                 type: 'func_call_msg',

package/dist/persistence.d.ts

@@ -159,6 +159,7 @@ export declare class DiskFileDialogStore extends DialogStore {
     persistFunctionCall(dialog: Dialog, id: string, name: string, rawArgumentsText: string, genseq: number, rawId?: string): Promise<void>;
     persistTellaskCall(dialog: Dialog, id: string, name: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | 'askHuman' | 'freshBootsReasoning', rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
+        replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
     /**
      * Update questions for human state (exceptional overwrite pattern)