dominds 1.23.2 → 1.23.3

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

@@ -26,8 +26,46 @@ const tellask_special_1 = require("./tellask-special");
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
-function isIgnorablePostResponseAnchorTailEvent(type) {
-    return type === 'tellask_reply_resolution_record' || type === 'gen_finish_record';
+function hasQ4HAnswerCallId(callId) {
+    return typeof callId === 'string' && callId.trim() !== '';
+}
+function isEffectiveUserPromptForContextHealth(prompt) {
+    return prompt?.origin === 'user' && !hasQ4HAnswerCallId(prompt.q4hAnswerCallId);
+}
+function isQueuedUserPromptForContextHealth(prompt) {
+    return prompt?.kind === 'user_generation_boundary' && !hasQ4HAnswerCallId(prompt.q4hAnswerCallId);
+}
+function isNonIdleDisplayProjection(state) {
+    return state !== undefined && state.kind !== 'idle_waiting_user';
+}
+function resolveDirectFallbackResponse(args) {
+    if (args.driveResult.lastAssistantSayingContent !== null &&
+        args.driveResult.lastAssistantSayingContent.trim() !== '') {
+        if (typeof args.driveResult.lastAssistantSayingGenseq !== 'number' ||
+            !Number.isFinite(args.driveResult.lastAssistantSayingGenseq) ||
+            args.driveResult.lastAssistantSayingGenseq <= 0) {
+            throw new Error(`Direct reply fallback invariant violation: missing lastAssistantSayingGenseq for dialog=${args.dialog.id.valueOf()}`);
+        }
+        return {
+            responseText: args.driveResult.lastAssistantSayingContent,
+            responseGenseq: Math.floor(args.driveResult.lastAssistantSayingGenseq),
+            source: 'saying',
+        };
+    }
+    if (args.driveResult.lastAssistantThinkingContent !== null &&
+        args.driveResult.lastAssistantThinkingContent.trim() !== '') {
+        if (typeof args.driveResult.lastAssistantThinkingGenseq !== 'number' ||
+            !Number.isFinite(args.driveResult.lastAssistantThinkingGenseq) ||
+            args.driveResult.lastAssistantThinkingGenseq <= 0) {
+            throw new Error(`Direct reply fallback invariant violation: missing lastAssistantThinkingGenseq for dialog=${args.dialog.id.valueOf()}`);
+        }
+        return {
+            responseText: args.driveResult.lastAssistantThinkingContent,
+            responseGenseq: Math.floor(args.driveResult.lastAssistantThinkingGenseq),
+            source: 'thinking_only',
+        };
+    }
+    return undefined;
 }
 async function buildReplyToolReminderPrompt(args) {
     return (0, reply_prompt_copy_1.buildReplyToolReminderText)({
@@ -157,6 +195,36 @@ async function clearConsumedDeferredRootQueueIfIdle(dialog) {
         reason: 'root_idle_after_consuming_deferred_queue',
     });
 }
+async function clearStaleSideDialogRunControlForFinalResponse(args) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    if (!latest ||
+        (latest.needsDrive !== true &&
+            latest.generating !== true &&
+            latest.executionMarker?.kind !== 'interrupted' &&
+            !isNonIdleDisplayProjection(latest.displayState)) ||
+        latest.executionMarker?.kind === 'dead' ||
+        latest.pendingCourseStartPrompt) {
+        return {
+            cleared: false,
+            previousGenerating: latest?.generating ?? null,
+            previousNeedsDrive: latest?.needsDrive ?? null,
+        };
+    }
+    await persistence_1.DialogPersistence.mutateDialogLatest(args.dialog.id, () => ({
+        kind: 'patch',
+        patch: {
+            generating: false,
+            needsDrive: false,
+            displayState: { kind: 'idle_waiting_user' },
+            executionMarker: undefined,
+        },
+    }), args.dialog.status);
+    return {
+        cleared: true,
+        previousGenerating: latest.generating ?? null,
+        previousNeedsDrive: latest.needsDrive ?? null,
+    };
+}
 function hasNoPromptSideDialogResumeEntitlement(dialog, driveOptions) {
     const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
     if (!entitlement) {
@@ -259,20 +327,18 @@ async function inspectNoPromptSideDialogDrive(args) {
     const rawCourse = latest?.currentCourse ?? args.dialog.currentCourse;
     const currentCourse = Number.isFinite(rawCourse) && rawCourse > 0 ? Math.floor(rawCourse) : 1;
     const courseEvents = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, currentCourse, args.dialog.status);
-    const rawLastEvent = (() => {
+    const rawLastTellaskAnchor = (() => {
         for (let index = courseEvents.length - 1; index >= 0; index -= 1) {
             const event = courseEvents[index];
-            if (!isIgnorablePostResponseAnchorTailEvent(event.type)) {
+            if (event.type === 'tellask_anchor_record') {
                 return event;
             }
         }
-        return courseEvents[courseEvents.length - 1];
+        return undefined;
     })();
-    const lastEvent = rawLastEvent?.type === 'tellask_anchor_record'
-        ? { type: rawLastEvent.type, anchorRole: rawLastEvent.anchorRole }
-        : rawLastEvent
-            ? { type: rawLastEvent.type }
-            : undefined;
+    const lastEvent = rawLastTellaskAnchor === undefined
+        ? undefined
+        : { type: rawLastTellaskAnchor.type, anchorRole: rawLastTellaskAnchor.anchorRole };
     const explicitInterruptedResumeAllowed = args.driveOptions?.allowResumeFromInterrupted === true &&
         latest?.executionMarker?.kind === 'interrupted';
     const inProgressGenerationResumeAllowed = args.driveOptions?.resumeInProgressGeneration === true;
@@ -370,6 +436,15 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
     // Do not "optimize" this into only an event or only a deferred prompt. The whole point is that
     // once blocked Continue is clicked, the guide becomes a first-class historical context fact and
     // later real driving should need no special duplicate reassertion path.
+    await surfaceRuntimeGuide(dialog, content);
+    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
+        reason: 'user_interjection_with_parked_original_task',
+        directive: deferredReplyReassertion.directive,
+        resumeGuideSurfaced: true,
+    }, dialog.status);
+}
+async function surfaceRuntimeGuide(dialog, content) {
+    const genseq = dialog.activeGenSeqOrUndefined ?? 1;
     await dialog.addChatMessages({
         type: 'transient_guide_msg',
         role: 'assistant',
@@ -382,11 +457,6 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
         genseq,
         content,
     });
-    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
-        reason: 'user_interjection_with_parked_original_task',
-        directive: deferredReplyReassertion.directive,
-        resumeGuideSurfaced: true,
-    }, dialog.status);
 }
 async function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
@@ -491,6 +561,29 @@ async function executeDriveRound(args) {
                 latest.executionMarker.kind === 'dead') {
                 return;
             }
+            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
+                const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
+                if (inspection.shouldReject && inspection.rejection === 'finalized_after_response_anchor') {
+                    const cleanup = await clearStaleSideDialogRunControlForFinalResponse({ dialog });
+                    log_1.log.warn('Dropped stale no-prompt sideDialog drive after final response anchor', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        source: inspection.source,
+                        reason: driveOptions?.reason ?? null,
+                        rejection: inspection.rejection,
+                        allowResumeFromInterrupted: driveOptions?.allowResumeFromInterrupted === true,
+                        displayState: inspection.displayState ?? null,
+                        currentCourse: inspection.currentCourse,
+                        lastEvent: inspection.lastEvent ?? null,
+                        clearedStaleRunControl: cleanup.cleared,
+                        previousGenerating: cleanup.previousGenerating,
+                        previousNeedsDrive: cleanup.previousNeedsDrive,
+                        waitInQue,
+                    });
+                    return;
+                }
+            }
             const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(dialog.id);
             if (stopRequested !== undefined) {
                 log_1.log.debug('kernel-driver skip drive while stop request is still being processed', undefined, {
@@ -646,7 +739,8 @@ async function executeDriveRound(args) {
             throw new Error(`kernel-driver policy invariant violation: ${policyResult.detail}`);
         }
         const snapshot = dialog.getLastContextHealth();
-        const hasQueuedUpNext = dialog.hasUpNext();
+        const queuedUpNextBeforeHealth = dialog.peekUpNext();
+        const hasQueuedUpNext = queuedUpNextBeforeHealth !== undefined;
         const provider = policy.effectiveAgent.provider ?? minds.team.memberDefaults.provider;
         const model = policy.effectiveAgent.model ?? minds.team.memberDefaults.model;
         let cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(undefined);
@@ -659,15 +753,15 @@ async function executeDriveRound(args) {
         const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
             dialogKey: dialog.id.key(),
             snapshot,
-            hadUserPromptThisGen: humanPrompt !== undefined,
+            hadUserPromptThisGen: isEffectiveUserPromptForContextHealth(humanPrompt) ||
+                (humanPrompt === undefined && isQueuedUserPromptForContextHealth(queuedUpNextBeforeHealth)),
+            userPromptCriticalRemediationAlreadyApplied: false,
             canInjectPromptThisGen: !hasQueuedUpNext,
             cautionRemediationCadenceGenerations,
             criticalCountdownRemaining,
         });
-        if (healthDecision.kind === 'suspend') {
-            return;
-        }
         let healthPrompt;
+        let criticalUserInterjectionRuntimeGuide;
         if (healthDecision.kind === 'continue') {
             if (healthDecision.reason === 'critical_force_new_course') {
                 const language = (0, work_language_1.getWorkLanguage)();
@@ -679,6 +773,15 @@ async function executeDriveRound(args) {
                 dialog.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
                 (0, context_health_1.resetContextHealthRoundState)(dialog.id.key());
             }
+            else if (healthDecision.reason === 'critical_user_prompt_remediation') {
+                const language = (0, work_language_1.getWorkLanguage)();
+                const dialogScope = dialog instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
+                criticalUserInterjectionRuntimeGuide =
+                    (0, driver_messages_1.formatAgentFacingCriticalUserInterjectionRemediationGuide)(language, {
+                        dialogScope,
+                        promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dialog.id.key()),
+                    });
+            }
             else if (!hasQueuedUpNext) {
                 const language = (0, work_language_1.getWorkLanguage)();
                 const dialogScope = dialog instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
@@ -748,10 +851,19 @@ async function executeDriveRound(args) {
         if (effectivePrompt && effectivePrompt.userLanguageCode) {
             dialog.setLastUserLanguageCode(effectivePrompt.userLanguageCode);
         }
+        const coreDriveOptions = criticalUserInterjectionRuntimeGuide === undefined
+            ? driveOptions
+            : {
+                ...(driveOptions ?? {
+                    source: driveSource,
+                    reason: 'critical_user_prompt_remediation',
+                }),
+                criticalUserInterjectionRuntimeGuide,
+            };
         driveResult = await (0, drive_1.driveDialogStreamCore)(dialog, {
             scheduleDrive: args.scheduleDrive,
             driveDialog: args.driveDialog,
-        }, effectivePrompt, driveOptions);
+        }, effectivePrompt, coreDriveOptions);
         sideDialogReplyTarget = driveResult.lastAssistantReplyTarget ?? sideDialogReplyTarget;
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
@@ -762,7 +874,8 @@ async function executeDriveRound(args) {
             if (dialog instanceof dialog_1.SideDialog &&
                 driveResult &&
                 !interruptedBySignal &&
-                (driveResult.fbrConclusion !== undefined || driveResult.lastAssistantSayingContent !== null)) {
+                (driveResult.fbrConclusion !== undefined ||
+                    resolveDirectFallbackResponse({ driveResult, dialog }) !== undefined)) {
                 if (driveResult.fbrConclusion) {
                     await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
                         sideDialog: dialog,
@@ -771,20 +884,23 @@ async function executeDriveRound(args) {
                         scheduleDrive: args.scheduleDrive,
                     });
                 }
-                else if (driveResult.lastAssistantSayingContent !== null) {
+                else {
+                    const directFallbackResponse = resolveDirectFallbackResponse({ driveResult, dialog });
+                    if (directFallbackResponse === undefined) {
+                        throw new Error(`SideDialog response supply invariant violation: missing direct fallback response for dialog=${dialog.id.valueOf()}`);
+                    }
                     const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
                         Number.isFinite(driveResult.lastFunctionCallGenseq) &&
                         driveResult.lastFunctionCallGenseq > 0 &&
-                        (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                            driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                        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.
-                        log_1.log.debug('kernel-driver skip sideDialog response supply because latest saying is not after function calls', undefined, {
+                        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,
-                            lastAssistantSayingGenseq: driveResult.lastAssistantSayingGenseq,
+                            responseGenseq: directFallbackResponse.responseGenseq,
+                            responseSource: directFallbackResponse.source,
                             lastFunctionCallGenseq: driveResult.lastFunctionCallGenseq,
                         });
                     }
@@ -846,21 +962,16 @@ async function executeDriveRound(args) {
                                     });
                                 }
                                 else {
-                                    if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                                        !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                                        driveResult.lastAssistantSayingGenseq <= 0) {
-                                        throw new Error(`SideDialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
-                                    }
-                                    const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
                                     const directFallbackCallId = `direct-fallback-${(0, id_1.generateShortId)()}`;
                                     let supplied = false;
                                     if (sideDialogReplyTarget) {
                                         supplied = await (0, sideDialog_1.supplySideDialogResponseToSpecificAskerIfPendingV2)({
                                             sideDialog: dialog,
-                                            responseText: driveResult.lastAssistantSayingContent,
-                                            responseGenseq,
+                                            responseText: directFallbackResponse.responseText,
+                                            responseGenseq: directFallbackResponse.responseGenseq,
                                             target: sideDialogReplyTarget,
                                             deliveryMode: 'direct_fallback',
+                                            directFallbackSource: directFallbackResponse.source,
                                             replyResolution: {
                                                 callId: directFallbackCallId,
                                                 replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
@@ -870,9 +981,10 @@ async function executeDriveRound(args) {
                                         if (!supplied) {
                                             supplied = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
                                                 sideDialog: dialog,
-                                                responseText: driveResult.lastAssistantSayingContent,
-                                                responseGenseq,
+                                                responseText: directFallbackResponse.responseText,
+                                                responseGenseq: directFallbackResponse.responseGenseq,
                                                 deliveryMode: 'direct_fallback',
+                                                directFallbackSource: directFallbackResponse.source,
                                                 replyResolution: {
                                                     callId: directFallbackCallId,
                                                     replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
@@ -884,9 +996,10 @@ async function executeDriveRound(args) {
                                     else {
                                         supplied = await (0, sideDialog_1.supplySideDialogResponseToAssignedAskerIfPendingV2)({
                                             sideDialog: dialog,
-                                            responseText: driveResult.lastAssistantSayingContent,
-                                            responseGenseq,
+                                            responseText: directFallbackResponse.responseText,
+                                            responseGenseq: directFallbackResponse.responseGenseq,
                                             deliveryMode: 'direct_fallback',
+                                            directFallbackSource: directFallbackResponse.source,
                                             replyResolution: {
                                                 callId: directFallbackCallId,
                                                 replyCallName: activeTellaskReplyDirective.expectedReplyCallName,
@@ -918,15 +1031,17 @@ async function executeDriveRound(args) {
             if (!(dialog instanceof dialog_1.SideDialog) &&
                 driveResult &&
                 !interruptedBySignal &&
-                driveResult.lastAssistantSayingContent !== null &&
+                resolveDirectFallbackResponse({ driveResult, dialog }) !== undefined &&
                 activeTellaskReplyDirective?.expectedReplyCallName === 'replyTellaskBack' &&
                 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()}`);
+                }
                 const hasInProgressFunctionCall = typeof driveResult.lastFunctionCallGenseq === 'number' &&
                     Number.isFinite(driveResult.lastFunctionCallGenseq) &&
                     driveResult.lastFunctionCallGenseq > 0 &&
-                    (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
-                        !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
-                        driveResult.lastAssistantSayingGenseq <= driveResult.lastFunctionCallGenseq);
+                    directFallbackResponse.responseGenseq <= driveResult.lastFunctionCallGenseq;
                 if (!hasInProgressFunctionCall) {
                     if (!activePromptWasReplyToolReminder) {
                         const language = (0, work_language_1.getWorkLanguage)();
@@ -952,12 +1067,13 @@ async function executeDriveRound(args) {
                         await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
                             replyingDialog: dialog,
                             directive: activeTellaskReplyDirective,
-                            replyContent: driveResult.lastAssistantSayingContent,
+                            replyContent: directFallbackResponse.responseText,
                             callbacks: {
                                 scheduleDrive: args.scheduleDrive,
                                 driveDialog: args.driveDialog,
                             },
                             deliveryMode: 'direct_fallback',
+                            directFallbackSource: directFallbackResponse.source,
                         });
                         await dialog.appendTellaskReplyResolution({
                             callId: `direct-fallback-${(0, id_1.generateShortId)()}`,
@@ -1074,6 +1190,7 @@ async function executeDriveRound(args) {
         if (tailError !== undefined) {
             throw tailError;
         }
+        return driveResult;
     }
     finally {
         if (activeRunPrimed && ownsActiveRun) {

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

@@ -4,7 +4,7 @@ import type { FuncTool, ToolArguments } from '../../tool';
 import { type LlmFailureQuirkHandlerSession } from '../api-quirks';
 import type { ProviderConfig } from '../client';
 import { type LlmFailureClassifier } from '../gen';
-import type { KernelDriverDiligencePrompt } from './types';
+import type { KernelDriverPrompt } from './types';
 export declare class LlmRetryStoppedError extends Error {
     readonly reason: DialogLlmRetryExhaustedReason;
     constructor(reason: DialogLlmRetryExhaustedReason, message: string);
@@ -20,14 +20,7 @@ export declare class LlmRequestFailedError extends Error {
         i18nStopReason?: DialogDisplayTextI18n;
     });
 }
-export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
-    dlg: Dialog;
-    isMainDialog: boolean;
-    remainingBudget: number;
-    diligencePushMax: number;
-    suppressDiligencePush?: boolean;
-    ignoreBudgetExhaustion?: boolean;
-}): Promise<{
+type DiligencePromptPreparation = {
     kind: 'disabled';
     nextRemainingBudget: number;
 } | {
@@ -36,10 +29,17 @@ export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
     nextRemainingBudget: number;
 } | {
     kind: 'prompt';
-    prompt: KernelDriverDiligencePrompt;
+    prompt: KernelDriverPrompt;
     maxInjectCount: number;
     nextRemainingBudget: number;
-}>;
+};
+export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
+    dlg: Dialog;
+    remainingBudget: number;
+    diligencePushMax: number;
+    suppressDiligencePush?: boolean;
+    ignoreBudgetExhaustion?: boolean;
+}): Promise<DiligencePromptPreparation>;
 export declare function suspendForKeepGoingBudgetExhausted(options: {
     dlg: Dialog;
     maxInjectCount: number;
@@ -70,3 +70,4 @@ export declare function runLlmRequestWithRetry<T>(params: {
     onRetryStopped?: (reason: DialogLlmRetryExhaustedReason) => Promise<'continue' | 'stop'> | 'continue' | 'stop';
     doRequest: () => Promise<T>;
 }): Promise<T>;
+export {};

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

@@ -43,8 +43,10 @@ const path = __importStar(require("path"));
 const diligence_1 = require("@longrun-ai/kernel/diligence");
 const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
+const dialog_1 = require("../../dialog");
 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");
@@ -121,29 +123,119 @@ async function resolveRtwsDiligenceConfig() {
         diligenceText: diligence_1.DILIGENCE_FALLBACK_TEXT[workLanguage],
     };
 }
+function normalizeDiligenceRemainingBudget(remainingBudget) {
+    return typeof remainingBudget === 'number' && Number.isFinite(remainingBudget)
+        ? Math.max(0, Math.floor(remainingBudget))
+        : 0;
+}
+async function maybePrepareSideDialogDiligenceRecoveryPrompt(options) {
+    if (options.ignoreBudgetExhaustion !== true) {
+        return { kind: 'disabled', nextRemainingBudget: 0 };
+    }
+    if (options.dlg.disableDiligencePush || options.suppressDiligencePush === true) {
+        return {
+            kind: 'disabled',
+            nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
+        };
+    }
+    const assignment = options.dlg.assignmentFromAsker;
+    const activeReplyDirective = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(options.dlg.id, options.dlg.status);
+    if (!activeReplyDirective) {
+        return { kind: 'disabled', nextRemainingBudget: 0 };
+    }
+    const activeTargetCallId = activeReplyDirective.targetCallId.trim();
+    const activeTargetDialogId = activeReplyDirective.targetDialogId.trim();
+    const assignmentCallId = assignment.callId.trim();
+    const assignmentAskerDialogId = assignment.askerDialogId.trim();
+    if (activeTargetCallId === '' ||
+        activeTargetDialogId === '' ||
+        assignmentCallId === '' ||
+        assignmentAskerDialogId === '') {
+        throw new Error(`sideDialog diligence recovery invariant violation: empty reply/assignment correlation field for ${options.dlg.id.valueOf()}`);
+    }
+    const activeMatchesAssignment = activeTargetDialogId === assignmentAskerDialogId &&
+        activeTargetCallId === assignmentCallId &&
+        activeReplyDirective.tellaskContent === assignment.tellaskContent;
+    const activeReplyToolMatchesAssignment = (activeReplyDirective.expectedReplyCallName === 'replyTellask' &&
+        assignment.callName === 'tellask') ||
+        (activeReplyDirective.expectedReplyCallName === 'replyTellaskSessionless' &&
+            (assignment.callName === 'tellaskSessionless' ||
+                assignment.callName === 'freshBootsReasoning'));
+    if (activeReplyDirective.expectedReplyCallName !== 'replyTellaskBack' &&
+        (!activeMatchesAssignment || !activeReplyToolMatchesAssignment)) {
+        throw new Error(`sideDialog diligence recovery invariant violation: active reply obligation does not match current assignment for ${options.dlg.id.valueOf()}`);
+    }
+    const variant = (Math.floor(Math.random() * 3) % 3);
+    const commonPrompt = {
+        content: (0, driver_messages_1.formatSideDialogDiligenceAutoContinuePrompt)((0, work_language_1.getWorkLanguage)(), {
+            now: new Date(),
+            tellaskContent: activeReplyDirective.tellaskContent,
+            replyToolName: activeReplyDirective.expectedReplyCallName,
+            variant,
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'runtime',
+        tellaskReplyDirective: activeReplyDirective,
+    };
+    if (activeReplyDirective.expectedReplyCallName === 'replyTellaskBack') {
+        const prompt = commonPrompt;
+        return {
+            kind: 'prompt',
+            prompt,
+            maxInjectCount: 0,
+            nextRemainingBudget: 0,
+        };
+    }
+    const prompt = {
+        ...commonPrompt,
+        sideDialogReplyTarget: {
+            ownerDialogId: assignment.askerDialogId,
+            callType: assignment.callName === 'tellask' ? 'B' : 'C',
+            callId: assignment.callId,
+            callSiteCourse: assignment.callSiteCourse,
+            callSiteGenseq: assignment.callSiteGenseq,
+        },
+    };
+    return {
+        kind: 'prompt',
+        prompt,
+        maxInjectCount: 0,
+        nextRemainingBudget: 0,
+    };
+}
 async function maybePrepareDiligenceAutoContinuePrompt(options) {
-    if (!options.isMainDialog) {
-        return { kind: 'disabled', nextRemainingBudget: options.remainingBudget };
+    if (!(options.dlg instanceof dialog_1.MainDialog)) {
+        if (!(options.dlg instanceof dialog_1.SideDialog)) {
+            return {
+                kind: 'disabled',
+                nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
+            };
+        }
+        return await maybePrepareSideDialogDiligenceRecoveryPrompt({
+            dlg: options.dlg,
+            remainingBudget: options.remainingBudget,
+            suppressDiligencePush: options.suppressDiligencePush,
+            ignoreBudgetExhaustion: options.ignoreBudgetExhaustion,
+        });
     }
     if (options.dlg.disableDiligencePush || options.suppressDiligencePush === true) {
-        const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
-            ? Math.max(0, Math.floor(options.remainingBudget))
-            : 0;
-        return { kind: 'disabled', nextRemainingBudget: normalizedRemaining };
+        return {
+            kind: 'disabled',
+            nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
+        };
     }
     const resolved = await resolveRtwsDiligenceConfig();
     if (resolved.kind === 'disabled') {
-        const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
-            ? Math.max(0, Math.floor(options.remainingBudget))
-            : 0;
-        return { kind: 'disabled', nextRemainingBudget: normalizedRemaining };
+        return {
+            kind: 'disabled',
+            nextRemainingBudget: normalizeDiligenceRemainingBudget(options.remainingBudget),
+        };
     }
     const maxInjectCount = typeof options.diligencePushMax === 'number' && Number.isFinite(options.diligencePushMax)
         ? Math.floor(options.diligencePushMax)
         : 0;
-    const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
-        ? Math.max(0, Math.floor(options.remainingBudget))
-        : 0;
+    const normalizedRemaining = normalizeDiligenceRemainingBudget(options.remainingBudget);
     const bypassBudget = options.ignoreBudgetExhaustion === true;
     // `diligencePushMax` is only the per-member default used when a dialog instance is created or
     // reset. Runtime business decisions must be based on this dialog's persisted remaining budget so
@@ -168,10 +260,6 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
             nextRemainingBudget: 0,
         };
     }
-    const currentRemaining = normalizedRemaining;
-    if (currentRemaining < 1 && !bypassBudget) {
-        return { kind: 'budget_exhausted', maxInjectCount, nextRemainingBudget: 0 };
-    }
     const prompt = {
         content: (0, driver_messages_1.formatDiligenceAutoContinuePrompt)((0, work_language_1.getWorkLanguage)(), resolved.diligenceText),
         msgId: (0, id_1.generateShortId)(),
@@ -182,7 +270,7 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
         kind: 'prompt',
         prompt,
         maxInjectCount,
-        nextRemainingBudget: Math.max(0, currentRemaining - 1),
+        nextRemainingBudget: Math.max(0, normalizedRemaining - 1),
     };
 }
 async function suspendForKeepGoingBudgetExhausted(options) {

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

@@ -20,6 +20,7 @@ export declare function supplyResponseToAskerDialog(args: {
     callId?: string;
     status?: 'completed' | 'failed';
     deliveryMode?: 'reply_tool' | 'direct_fallback';
+    directFallbackSource?: 'saying' | 'thinking_only';
     replyResolution?: {
         callId: string;
         replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
@@ -38,6 +39,7 @@ export declare function supplySideDialogResponseToSpecificAskerIfPendingV2(args:
     responseGenseq: number;
     target: SideDialogReplyTarget;
     deliveryMode?: 'reply_tool' | 'direct_fallback';
+    directFallbackSource?: 'saying' | 'thinking_only';
     replyResolution?: {
         callId: string;
         replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
@@ -49,6 +51,7 @@ export declare function supplySideDialogResponseToAssignedAskerIfPendingV2(args:
     responseText: string;
     responseGenseq: number;
     deliveryMode?: 'reply_tool' | 'direct_fallback';
+    directFallbackSource?: 'saying' | 'thinking_only';
     replyResolution?: {
         callId: string;
         replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';

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

@@ -149,7 +149,7 @@ async function resolveLatestAssignmentAnchorRef(args) {
     return undefined;
 }
 async function supplyResponseToAskerDialog(args) {
-    const { parentDialog, sideDialogId, responseText, callType, callId, status = 'completed', deliveryMode = 'reply_tool', calleeResponseRef, askerCourseOverride, scheduleDrive, sideDialog: maybeSideDialog, } = args;
+    const { parentDialog, sideDialogId, responseText, callType, callId, status = 'completed', deliveryMode = 'reply_tool', directFallbackSource, calleeResponseRef, askerCourseOverride, scheduleDrive, sideDialog: maybeSideDialog, } = args;
     try {
         const result = await (0, sideDialog_txn_1.withSideDialogTxnLock)(parentDialog.id, async () => {
             const pendingSideDialogs = await persistence_1.DialogPersistence.loadPendingSideDialogs(parentDialog.id, parentDialog.status);
@@ -270,6 +270,7 @@ async function supplyResponseToAskerDialog(args) {
             responseBody: tellaskerResponseBody,
             status,
             deliveryMode,
+            directFallbackSource,
             language: (0, work_language_1.getWorkLanguage)(),
         });
         const carryoverCallSiteCourse = result.callSiteCourse;
@@ -594,6 +595,7 @@ async function supplySideDialogResponseToSpecificAskerIfPendingV2(args) {
         callId: target.callId,
         status: 'completed',
         deliveryMode: args.deliveryMode,
+        directFallbackSource: args.directFallbackSource,
         replyResolution: args.replyResolution,
         calleeResponseRef: { course: sideDialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,
@@ -664,6 +666,7 @@ async function supplySideDialogResponseToAssignedAskerIfPendingV2(args) {
         callId: assignment.callId,
         status: 'completed',
         deliveryMode: args.deliveryMode,
+        directFallbackSource: args.directFallbackSource,
         replyResolution: args.replyResolution,
         calleeResponseRef: { course: sideDialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -78,6 +78,7 @@ export declare function deliverTellaskBackReplyFromDirective(args: {
     replyContent: string;
     callbacks: KernelDriverDriveCallbacks;
     deliveryMode?: 'reply_tool' | 'direct_fallback';
+    directFallbackSource?: 'saying' | 'thinking_only';
 }): Promise<TellaskBackReplyDeliveryResult>;
 export declare function recoverPendingReplyTellaskCalls(args: {
     dlg: Dialog;