dominds 1.23.2 → 1.23.3

package/dist/llm/kernel-driver/context-health.d.ts

@@ -3,10 +3,7 @@ export type KernelDriverContextHealthDecision = Readonly<{
     kind: 'proceed';
 }> | Readonly<{
     kind: 'continue';
-    reason: 'caution_soft_remediation' | 'critical_countdown_remediation' | 'critical_force_new_course';
-}> | Readonly<{
-    kind: 'suspend';
-    reason: 'critical_wait_human';
+    reason: 'caution_soft_remediation' | 'critical_countdown_remediation' | 'critical_user_prompt_remediation' | 'critical_force_new_course';
 }>;
 export declare const KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 export declare const KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
@@ -18,6 +15,8 @@ export declare function decideKernelDriverContextHealth(args: {
     dialogKey: string;
     snapshot?: ContextHealthSnapshot;
     hadUserPromptThisGen: boolean;
+    hadUserPromptInImmediateToolChain?: boolean;
+    userPromptCriticalRemediationAlreadyApplied?: boolean;
     canInjectPromptThisGen: boolean;
     cautionRemediationCadenceGenerations: number;
     criticalCountdownRemaining: number;

package/dist/llm/kernel-driver/context-health.js

@@ -111,8 +111,11 @@ function decideKernelDriverContextHealth(args) {
         if (args.criticalCountdownRemaining <= 0) {
             return { kind: 'continue', reason: 'critical_force_new_course' };
         }
-        return args.hadUserPromptThisGen
-            ? { kind: 'suspend', reason: 'critical_wait_human' }
+        if (args.userPromptCriticalRemediationAlreadyApplied === true) {
+            return { kind: 'proceed' };
+        }
+        return args.hadUserPromptThisGen || args.hadUserPromptInImmediateToolChain === true
+            ? { kind: 'continue', reason: 'critical_user_prompt_remediation' }
             : { kind: 'continue', reason: 'critical_countdown_remediation' };
     }
     const _exhaustive = snapshot.level;

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

@@ -4,19 +4,15 @@ export type DriveBaseContextParts = Readonly<{
     memories: readonly ChatMessage[];
     taskDocMsg?: ChatMessage;
     coursePrefixMsgs: readonly ChatMessage[];
-    dialogMsgsForContext: readonly ChatMessage[];
-}>;
-export type DriveEphemeralContextParts = Readonly<{
-    sideDialogResponseContextMsgs?: readonly ChatMessage[];
-    runtimeGuideMsgs?: readonly ChatMessage[];
+    historicalDialogMsgsForContext: readonly ChatMessage[];
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
 }>;
 export type DriveTailContextParts = Readonly<{
     renderedReminders: readonly ChatMessage[];
+    activeReplyObligationContext: readonly ChatMessage[];
+    runtimeGuideMsgs: readonly ChatMessage[];
 }>;
-export declare function buildDriveBaseContextMessages(parts: DriveBaseContextParts): ChatMessage[];
-export declare function appendDriveEphemeralContext(base: readonly ChatMessage[], parts: DriveEphemeralContextParts): ChatMessage[];
 export declare function assembleDriveContextMessages(args: {
     base: DriveBaseContextParts;
-    ephemeral: DriveEphemeralContextParts;
     tail: DriveTailContextParts;
 }): ChatMessage[];

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

@@ -1,36 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDriveBaseContextMessages = buildDriveBaseContextMessages;
-exports.appendDriveEphemeralContext = appendDriveEphemeralContext;
 exports.assembleDriveContextMessages = assembleDriveContextMessages;
-function buildDriveBaseContextMessages(parts) {
-    return [
-        ...parts.prependedContextMessages,
-        ...parts.memories,
-        ...(parts.taskDocMsg ? [parts.taskDocMsg] : []),
-        ...parts.coursePrefixMsgs,
-        ...parts.dialogMsgsForContext,
-    ];
-}
-function appendDriveEphemeralContext(base, parts) {
-    const next = [...base];
-    if (Array.isArray(parts.sideDialogResponseContextMsgs) &&
-        parts.sideDialogResponseContextMsgs.length > 0) {
-        next.push(...parts.sideDialogResponseContextMsgs);
-    }
-    if (Array.isArray(parts.runtimeGuideMsgs) && parts.runtimeGuideMsgs.length > 0) {
-        next.push(...parts.runtimeGuideMsgs);
-    }
-    return next;
-}
 function assembleDriveContextMessages(args) {
-    const baseMsgs = [
+    return [
         ...args.base.prependedContextMessages,
         ...args.base.memories,
         ...(args.base.taskDocMsg ? [args.base.taskDocMsg] : []),
         ...args.base.coursePrefixMsgs,
+        ...args.base.historicalDialogMsgsForContext,
         ...args.tail.renderedReminders,
-        ...args.base.dialogMsgsForContext,
+        ...args.tail.activeReplyObligationContext,
+        ...args.tail.runtimeGuideMsgs,
+        ...args.base.currentTurnDialogMsgsForContext,
     ];
-    return appendDriveEphemeralContext(baseMsgs, args.ephemeral);
 }

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

@@ -165,7 +165,53 @@ function normalizeQ4HAnswerCallId(raw) {
 function isUserOriginPrompt(prompt) {
     if (!prompt)
         return false;
-    return prompt.origin === 'user';
+    return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined;
+}
+function resolveReminderContextFollowingDialogState(prompt, currentTurnDialogMsgsForContext) {
+    if (prompt === undefined || currentTurnDialogMsgsForContext.length === 0)
+        return 'none';
+    return prompt.origin === 'user' ? 'user_message' : 'runtime_notice';
+}
+function splitDialogMsgsForReminderInsertion(args) {
+    const msgId = args.currentPrompt?.msgId;
+    if (typeof msgId !== 'string' || msgId.trim() === '') {
+        return {
+            historicalDialogMsgsForContext: [...args.msgs],
+            currentTurnDialogMsgsForContext: [],
+        };
+    }
+    const currentTurnStart = args.msgs.findIndex((msg) => msg.type === 'prompting_msg' && msg.msgId === msgId);
+    if (currentTurnStart < 0) {
+        return {
+            historicalDialogMsgsForContext: [...args.msgs],
+            currentTurnDialogMsgsForContext: [],
+        };
+    }
+    return {
+        historicalDialogMsgsForContext: args.msgs.slice(0, currentTurnStart),
+        currentTurnDialogMsgsForContext: args.msgs.slice(currentTurnStart),
+    };
+}
+function getUserOriginPromptMsgId(prompt) {
+    if (!prompt)
+        return undefined;
+    return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined
+        ? prompt.msgId
+        : undefined;
+}
+async function persistAndEmitRuntimeGuide(dlg, content) {
+    await dlg.addChatMessages({
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content,
+    });
+    await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, content, dlg.activeGenSeq);
+    (0, evt_registry_1.postDialogEvent)(dlg, {
+        type: 'runtime_guide_evt',
+        course: dlg.currentCourse,
+        genseq: dlg.activeGenSeq,
+        content,
+    });
 }
 function resolveToolUseRequirement(dlg, policy) {
     // FBR middle rounds are deliberately isolated from callable tools. Final closure is the opposite:
@@ -804,26 +850,28 @@ async function projectTellaskFuncResultsForContext(args) {
         messages: projected,
     };
 }
+async function buildActiveReplyObligationContext(dlg) {
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+    if (activeReplyObligation === undefined)
+        return [];
+    return [
+        {
+            type: 'environment_msg',
+            role: 'user',
+            content: (0, reply_prompt_copy_1.buildActiveReplyObligationContextText)({
+                language: (0, work_language_1.getWorkLanguage)(),
+                directive: activeReplyObligation,
+            }),
+        },
+    ];
+}
 async function buildDialogMsgsForContext(dlg) {
     const rawDialogMsgsForContext = dlg.msgs.filter((m) => !!m);
     const projected = await projectTellaskFuncResultsForContext({
         dialog: dlg,
         dialogMsgsForContext: rawDialogMsgsForContext,
     });
-    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
-    const activeReplyObligationContext = activeReplyObligation === undefined
-        ? []
-        : [
-            {
-                type: 'environment_msg',
-                role: 'user',
-                content: (0, reply_prompt_copy_1.buildActiveReplyObligationContextText)({
-                    language: (0, work_language_1.getWorkLanguage)(),
-                    directive: activeReplyObligation,
-                }),
-            },
-        ];
-    const businessFiltered = [...activeReplyObligationContext, ...projected.messages].filter((msg) => {
+    const businessFiltered = projected.messages.filter((msg) => {
         return msg.type !== 'tellask_result_msg' || msg.content.trim() !== '';
     });
     const sanitized = (0, tool_call_context_1.sanitizeToolContextForProvider)(businessFiltered);
@@ -1252,38 +1300,39 @@ async function preserveDiligenceBudgetAcrossQ4H(dlg) {
 }
 async function maybeContinueWithDiligencePrompt(args) {
     const { dlg, team, suppressDiligencePushForDrive, allowPendingSideDialogs, ignoreBudgetExhaustion, } = args;
-    if (!(dlg instanceof dialog_1.MainDialog)) {
-        return { kind: 'break' };
-    }
     const suspension = await dlg.getSuspensionStatus({
         allowPendingSideDialogs: allowPendingSideDialogs === true,
     });
     if (!suspension.canDrive) {
-        if (suspension.q4h) {
+        if (suspension.q4h && dlg instanceof dialog_1.MainDialog) {
             await preserveDiligenceBudgetAcrossQ4H(dlg);
         }
         return { kind: 'break' };
     }
     const prepared = await (0, runtime_1.maybePrepareDiligenceAutoContinuePrompt)({
         dlg,
-        isMainDialog: true,
         remainingBudget: dlg.diligencePushRemainingBudget,
         diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
         suppressDiligencePush: suppressDiligencePushForDrive,
         ignoreBudgetExhaustion,
     });
-    dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
-    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
-        kind: 'patch',
-        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
-    }));
-    if (prepared.kind !== 'disabled') {
+    if (dlg instanceof dialog_1.MainDialog) {
+        dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+        void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+            kind: 'patch',
+            patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+        }));
+    }
+    if (dlg instanceof dialog_1.MainDialog && prepared.kind !== 'disabled') {
         emitDiligenceBudgetEvent(dlg, {
             maxInjectCount: prepared.maxInjectCount,
             nextRemainingBudget: prepared.nextRemainingBudget,
         });
     }
     if (prepared.kind === 'budget_exhausted') {
+        if (!(dlg instanceof dialog_1.MainDialog)) {
+            throw new Error(`kernel-driver Diligence Push invariant violation: non-main dialog returned budget_exhausted (${dlg.id.valueOf()})`);
+        }
         await (0, runtime_1.suspendForKeepGoingBudgetExhausted)({
             dlg,
             maxInjectCount: prepared.maxInjectCount,
@@ -1333,9 +1382,6 @@ async function maybeContinueWithHealthPromptBeforeDiligence(args) {
         cautionRemediationCadenceGenerations,
         criticalCountdownRemaining,
     });
-    if (healthDecision.kind === 'suspend') {
-        return { kind: 'health_suspend' };
-    }
     if (healthDecision.kind !== 'continue') {
         return { kind: 'no_health_prompt' };
     }
@@ -1389,13 +1435,22 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     const suppressDiligencePushForDrive = driveOptions?.suppressDiligencePush === true && dlg.disableDiligencePush;
     const abortSignal = (0, dialog_display_state_1.getActiveRunSignal)(dlg.id) ?? (0, dialog_display_state_1.createActiveRun)(dlg.id);
     let finalDisplayState;
+    let criticalUserInterjectionRuntimeGuide = driveOptions?.criticalUserInterjectionRuntimeGuide;
     let lastAssistantSayingContent = null;
     let lastAssistantSayingGenseq = null;
+    let lastAssistantThinkingContent = null;
+    let lastAssistantThinkingGenseq = null;
     let lastFunctionCallGenseq = null;
     let lastAssistantReplyTarget;
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let pendingPrompt = humanPrompt;
+    let resolvingImmediateToolResultForUserPrompt = false;
+    let resolvingImmediateToolResultUserPromptMsgId;
+    let criticalRemediationAppliedUserPromptMsgId = driveOptions?.criticalUserInterjectionRuntimeGuide !== undefined &&
+        humanPrompt?.origin === 'user'
+        ? humanPrompt.msgId
+        : undefined;
     let retryStoppedRecoveryPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
     let genIterNo = 0;
@@ -1507,7 +1562,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     : canonicalFuncTools;
                 const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
                 const funcTools = projected.tools;
+                const currentPendingPrompt = pendingPrompt;
+                let currentGenerationBelongsToUserPrompt = isUserOriginPrompt(currentPendingPrompt);
+                let currentGenerationBelongsToUserToolChain = false;
+                let currentUserPromptMsgId = getUserOriginPromptMsgId(currentPendingPrompt);
                 if (genIterNo > 1) {
+                    currentGenerationBelongsToUserToolChain = resolvingImmediateToolResultForUserPrompt;
+                    if (currentUserPromptMsgId === undefined) {
+                        currentUserPromptMsgId = resolvingImmediateToolResultUserPromptMsgId;
+                    }
+                    resolvingImmediateToolResultForUserPrompt = false;
+                    resolvingImmediateToolResultUserPromptMsgId = undefined;
                     const snapshot = dlg.getLastContextHealth();
                     const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
                     const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
@@ -1516,21 +1581,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
                         dialogKey: dlg.id.key(),
                         snapshot,
-                        hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
+                        hadUserPromptThisGen: currentGenerationBelongsToUserPrompt,
+                        hadUserPromptInImmediateToolChain: currentGenerationBelongsToUserToolChain,
+                        userPromptCriticalRemediationAlreadyApplied: criticalRemediationAppliedUserPromptMsgId !== undefined &&
+                            criticalRemediationAppliedUserPromptMsgId === currentUserPromptMsgId,
                         canInjectPromptThisGen: !hasQueuedUpNext,
                         cautionRemediationCadenceGenerations,
                         criticalCountdownRemaining,
                     });
-                    if (healthDecision.kind === 'suspend') {
-                        log_1.log.debug('kernel-driver suspend iterative generation due to critical context while waiting for human prompt', undefined, {
-                            dialogId: dlg.id.valueOf(),
-                            rootId: dlg.id.rootId,
-                            selfId: dlg.id.selfId,
-                            genIterNo,
-                            pendingPromptOrigin: pendingPrompt?.origin ?? null,
-                        });
-                        break;
-                    }
                     if (healthDecision.kind === 'continue') {
                         if (healthDecision.reason === 'critical_force_new_course') {
                             const language = (0, work_language_1.getWorkLanguage)();
@@ -1548,6 +1606,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             pendingPrompt = nextPrompt;
                             skipTaskdocForThisDrive = false;
                         }
+                        else if (healthDecision.reason === 'critical_user_prompt_remediation') {
+                            const language = (0, work_language_1.getWorkLanguage)();
+                            const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
+                            criticalUserInterjectionRuntimeGuide =
+                                (0, driver_messages_1.formatAgentFacingCriticalUserInterjectionRemediationGuide)(language, {
+                                    dialogScope,
+                                    promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                                });
+                            criticalRemediationAppliedUserPromptMsgId = currentUserPromptMsgId;
+                        }
                         else if (!hasQueuedUpNext) {
                             const language = (0, work_language_1.getWorkLanguage)();
                             const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
@@ -1586,6 +1654,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 pendingPrompt = undefined;
                 await dlg.notifyGeneratingStart(currentPrompt?.msgId);
                 try {
+                    if (criticalUserInterjectionRuntimeGuide !== undefined) {
+                        await persistAndEmitRuntimeGuide(dlg, criticalUserInterjectionRuntimeGuide);
+                        criticalUserInterjectionRuntimeGuide = undefined;
+                    }
                     if (currentPrompt) {
                         const origin = currentPrompt.origin;
                         if (origin === 'diligence_push' &&
@@ -1665,14 +1737,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         const renderPromptAsRuntimeGuideBubble = origin === 'runtime' &&
                             (0, reply_prompt_copy_1.isStandaloneRuntimeGuidePromptContent)(replyGuidance.promptContent);
                         if (currentRuntimeGuideMsg) {
-                            await dlg.addChatMessages(currentRuntimeGuideMsg);
-                            await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, currentRuntimeGuideMsg.content, dlg.activeGenSeq);
-                            (0, evt_registry_1.postDialogEvent)(dlg, {
-                                type: 'runtime_guide_evt',
-                                course: dlg.currentCourse,
-                                genseq: dlg.activeGenSeq,
-                                content: currentRuntimeGuideMsg.content,
-                            });
+                            await persistAndEmitRuntimeGuide(dlg, currentRuntimeGuideMsg.content);
                             currentRuntimeGuideMsg = undefined;
                         }
                         if (isQ4HAnswerPrompt) {
@@ -1796,13 +1861,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : undefined;
                     const renderedReminders = await renderRemindersForContext(dlg);
                     const dialogMsgsForContext = await buildDialogMsgsForContext(dlg);
+                    const activeReplyObligationContext = await buildActiveReplyObligationContext(dlg);
+                    const splitDialogMsgs = splitDialogMsgsForReminderInsertion({
+                        msgs: dialogMsgsForContext,
+                        currentPrompt,
+                    });
                     const reminderContextBlock = renderedReminders.length > 0
                         ? [
                             ...renderedReminders,
                             {
                                 type: 'environment_msg',
                                 role: 'user',
-                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)()),
+                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)(), resolveReminderContextFollowingDialogState(currentPrompt, splitDialogMsgs.currentTurnDialogMsgsForContext)),
                             },
                         ]
                         : renderedReminders;
@@ -1812,12 +1882,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             memories: minds.memories,
                             taskDocMsg,
                             coursePrefixMsgs: dlg.getCoursePrefixMsgs(),
-                            dialogMsgsForContext,
+                            historicalDialogMsgsForContext: splitDialogMsgs.historicalDialogMsgsForContext,
+                            currentTurnDialogMsgsForContext: splitDialogMsgs.currentTurnDialogMsgsForContext,
                         },
-                        ephemeral: {
-                            runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : undefined,
+                        tail: {
+                            renderedReminders: reminderContextBlock,
+                            activeReplyObligationContext,
+                            runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : [],
                         },
-                        tail: { renderedReminders: reminderContextBlock },
                     });
                     const newMsgs = [];
                     const streamedFuncCalls = [];
@@ -1906,6 +1978,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         let streamAttemptCheckpointOffset;
                         let streamAttemptSayingContent;
                         let streamAttemptSayingGenseq;
+                        let streamAttemptThinkingContent;
+                        let streamAttemptThinkingGenseq;
                         let streamActive = { kind: 'idle' };
                         const rollbackStreamAttempt = async () => {
                             if (streamAttemptCourse === undefined ||
@@ -1925,6 +1999,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             currentSayingContent = '';
                             streamAttemptSayingContent = undefined;
                             streamAttemptSayingGenseq = undefined;
+                            streamAttemptThinkingContent = undefined;
+                            streamAttemptThinkingGenseq = undefined;
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
                             streamedFuncCalls.length = 0;
@@ -1975,13 +2051,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     currentThinkingReasoning = reasoning;
                                 await dlg.thinkingFinish(reasoning);
                                 if (currentThinkingContent.length > 0 || currentThinkingReasoning !== undefined) {
-                                    newMsgs.push({
+                                    const thinkingMessage = {
                                         type: 'thinking_msg',
                                         role: 'assistant',
                                         genseq: dlg.activeGenSeq,
                                         content: currentThinkingContent,
                                         reasoning: currentThinkingReasoning,
-                                    });
+                                    };
+                                    newMsgs.push(thinkingMessage);
+                                    streamAttemptThinkingContent = currentThinkingContent;
+                                    streamAttemptThinkingGenseq = thinkingMessage.genseq;
                                 }
                                 currentThinkingContent = '';
                                 currentThinkingReasoning = undefined;
@@ -2093,6 +2172,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 currentSayingContent = '';
                                 streamAttemptSayingContent = undefined;
                                 streamAttemptSayingGenseq = undefined;
+                                streamAttemptThinkingContent = undefined;
+                                streamAttemptThinkingGenseq = undefined;
                                 sawWebSearchSideChannelOutput = false;
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
@@ -2128,6 +2209,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 streamAttemptSayingGenseq === undefined ? null : streamAttemptSayingGenseq;
                             lastAssistantReplyTarget = currentReplyTarget;
                         }
+                        if (streamAttemptThinkingContent !== undefined) {
+                            lastAssistantThinkingContent = streamAttemptThinkingContent;
+                            lastAssistantThinkingGenseq =
+                                streamAttemptThinkingGenseq === undefined ? null : streamAttemptThinkingGenseq;
+                            if (streamAttemptSayingContent === undefined) {
+                                lastAssistantReplyTarget = currentReplyTarget;
+                            }
+                        }
                         return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
                     const llmOutput = await streamOrBatch();
@@ -2152,6 +2241,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 if (msg.type === 'thinking_msg' || msg.type === 'saying_msg') {
                                     newMsgs.push(msg);
                                     if (msg.type === 'thinking_msg') {
+                                        lastAssistantThinkingContent = msg.content;
+                                        lastAssistantThinkingGenseq = msg.genseq;
+                                        lastAssistantReplyTarget = currentReplyTarget;
                                         await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
                                     }
                                     else {
@@ -2225,6 +2317,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             return {
                                 lastAssistantSayingContent,
                                 lastAssistantSayingGenseq,
+                                lastAssistantThinkingContent,
+                                lastAssistantThinkingGenseq,
                                 lastFunctionCallGenseq,
                                 lastAssistantReplyTarget,
                             };
@@ -2388,9 +2482,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             }
                             continue;
                         }
-                        if (healthFirst.kind === 'health_suspend') {
-                            break;
-                        }
                         const next = await maybeContinueWithDiligencePrompt({
                             dlg,
                             team,
@@ -2403,6 +2494,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         break;
                     }
                     if (shouldStartImmediatePostToolGeneration) {
+                        resolvingImmediateToolResultForUserPrompt =
+                            currentGenerationBelongsToUserPrompt ||
+                                currentGenerationBelongsToUserToolChain ||
+                                isUserOriginPrompt(currentPrompt);
+                        resolvingImmediateToolResultUserPromptMsgId = resolvingImmediateToolResultForUserPrompt
+                            ? currentUserPromptMsgId
+                            : undefined;
                         continue;
                     }
                 }
@@ -2543,6 +2641,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     return {
         lastAssistantSayingContent,
         lastAssistantSayingGenseq,
+        lastAssistantThinkingContent,
+        lastAssistantThinkingGenseq,
         lastFunctionCallGenseq,
         lastAssistantReplyTarget,
         fbrConclusion,

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

@@ -7,4 +7,4 @@ export declare function driveDialogStreamCore(dlg: Dialog, callbacks: KernelDriv
 export declare function supplyResponseToSideDialogBridge(parentDialog: Dialog, sideDialogId: DialogID, responseText: string, callType: 'A' | 'B' | 'C', callId?: string, status?: 'completed' | 'failed', calleeResponseRef?: {
     course: number;
     genseq: number;
-}): Promise<void>;
+}, directFallbackSource?: 'saying' | 'thinking_only'): Promise<void>;

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

@@ -25,7 +25,7 @@ async function driveDialogStream(...driveArgs) {
             void dispatchDrive(dialog, options);
         },
         driveDialog: async (dialog, options) => {
-            await dispatchDrive(dialog, options);
+            return await dispatchDrive(dialog, options);
         },
     });
 }
@@ -34,7 +34,7 @@ async function emitSayingEventsBridge(...args) {
     return await (0, events_1.emitSayingEvents)(dlg, content);
 }
 async function supplyResponseToAskerDialog(...args) {
-    const [parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef] = args;
+    const [parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef, directFallbackSource,] = args;
     return await (0, sideDialog_1.supplyResponseToAskerDialog)({
         parentDialog,
         sideDialogId,
@@ -43,6 +43,7 @@ async function supplyResponseToAskerDialog(...args) {
         callId,
         status,
         calleeResponseRef,
+        directFallbackSource,
         scheduleDrive: (dialog, options) => {
             void dispatchDrive(dialog, options);
         },
@@ -51,7 +52,7 @@ async function supplyResponseToAskerDialog(...args) {
 async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions) {
     return await (0, drive_1.driveDialogStreamCore)(dlg, callbacks, humanPrompt, driveOptions);
 }
-async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef) {
+async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef, directFallbackSource) {
     await (0, sideDialog_1.supplyResponseToAskerDialog)({
         parentDialog,
         sideDialogId,
@@ -60,6 +61,7 @@ async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, resp
         callId,
         status,
         calleeResponseRef,
+        directFallbackSource,
         scheduleDrive: (dialog, options) => {
             void dispatchDrive(dialog, options);
         },