dominds 1.16.1 → 1.16.2

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

@@ -7,6 +7,7 @@ const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("../../dialog");
 const dialog_display_state_1 = require("../../dialog-display-state");
+const dialog_interruption_1 = require("../../dialog-interruption");
 const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
@@ -16,9 +17,12 @@ const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tool_1 = require("../../tool");
 const taskdoc_1 = require("../../utils/taskdoc");
+const api_quirks_1 = require("../api-quirks");
 const client_1 = require("../client");
+const gen_1 = require("../gen");
 const registry_1 = require("../gen/registry");
 const tool_call_context_1 = require("../gen/tool-call-context");
+const stop_reason_i18n_1 = require("../stop-reason-i18n");
 const tools_projection_1 = require("../tools-projection");
 const context_1 = require("./context");
 const context_health_1 = require("./context-health");
@@ -94,7 +98,17 @@ class KernelDriverInterruptedError extends Error {
     }
 }
 function resolveStoppedContinueEnabled(reason) {
-    return reason.kind !== 'llm_retry_stopped';
+    return (0, dialog_interruption_1.isInterruptionReasonManualResumeEligible)(reason);
+}
+function buildAbortedSystemStopReason() {
+    return {
+        kind: 'system_stop',
+        detail: 'Aborted.',
+        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+            detail: 'Aborted.',
+            kind: 'aborted',
+        }),
+    };
 }
 function throwIfAborted(abortSignal, dlg) {
     if (!abortSignal?.aborted)
@@ -106,7 +120,7 @@ function throwIfAborted(abortSignal, dlg) {
     if (stopRequested === 'user_stop') {
         throw new KernelDriverInterruptedError({ kind: 'user_stop' });
     }
-    throw new KernelDriverInterruptedError({ kind: 'system_stop', detail: 'Aborted.' });
+    throw new KernelDriverInterruptedError(buildAbortedSystemStopReason());
 }
 function isFbrSubdialogDialog(dlg) {
     return dlg instanceof dialog_1.SubDialog && dlg.assignmentFromSup.callName === 'freshBootsReasoning';
@@ -916,6 +930,7 @@ async function executeFunctionRound(args) {
             shouldStopAfterReplyTool: false,
             pairedMessages: [],
             tellaskToolOutputs: [],
+            updatePlanOnlyRound: false,
         };
     }
     throwIfAborted(args.abortSignal, args.dlg);
@@ -959,26 +974,23 @@ async function executeFunctionRound(args) {
         }
         return shouldImmediatelyFollowUpToolOutcome(tool, outcome);
     });
-    const updatePlanOnlyRawArgumentsSignature = (() => {
+    const updatePlanOnlyRound = (() => {
         if (tellaskRound.normalCalls.length === 0) {
-            return undefined;
+            return false;
         }
         if (tellaskRound.handledCallIds.length > 0 || tellaskRound.toolOutputs.length > 0) {
-            return undefined;
+            return false;
         }
-        const signatures = [];
         for (const call of tellaskRound.normalCalls) {
             if (call.name !== 'update_plan') {
-                return undefined;
+                return false;
             }
             const outcome = genericOutcomeByCallId.get(call.id);
             if (outcome !== 'success') {
-                return undefined;
+                return false;
             }
-            const argsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
-            signatures.push(argsStr);
         }
-        return JSON.stringify(signatures);
+        return true;
     })();
     const resultByCallId = new Map();
     const register = (result) => {
@@ -1028,7 +1040,7 @@ async function executeFunctionRound(args) {
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
-        updatePlanOnlyRawArgumentsSignature,
+        updatePlanOnlyRound,
     };
 }
 async function resetDiligenceBudgetAfterQ4H(dlg, team) {
@@ -1100,6 +1112,16 @@ async function maybeContinueWithDiligencePrompt(args) {
     }
     return { kind: 'break' };
 }
+async function maybePrepareRetryStoppedRecoveryPrompt(args) {
+    if (args.reason.recoveryAction.kind !== 'diligence_push_once') {
+        return { kind: 'break' };
+    }
+    return await maybeContinueWithDiligencePrompt({
+        dlg: args.dlg,
+        team: args.team,
+        suppressDiligencePushForDrive: args.suppressDiligencePushForDrive,
+    });
+}
 async function maybeContinueWithHealthPromptBeforeDiligence(args) {
     const { dlg, providerCfg, model } = args;
     // This path is only used as a higher-priority alternative to Diligence Push.
@@ -1174,10 +1196,15 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let pendingPrompt = humanPrompt;
+    let retryStoppedRecoveryPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
     let genIterNo = 0;
     let consecutiveIdenticalUpdatePlanOnlyRounds = 0;
     let lastIdenticalUpdatePlanRoundSignature;
+    // Quirk retry state intentionally spans multiple request invocations in the same driver run,
+    // including course changes. Provider/API retry heuristics are tracked independently from
+    // user-facing course boundaries.
+    const retryQuirkSessionByProviderModel = new Map();
     if (!humanPrompt) {
         try {
             const executionMarker = await (0, dialog_display_state_1.loadDialogExecutionMarker)(dlg.id, 'running');
@@ -1193,332 +1220,564 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     }
     await (0, dialog_display_state_1.clearDialogInterruptedExecutionMarker)(dlg.id);
     await (0, dialog_display_state_1.setDialogDisplayState)(dlg.id, { kind: 'proceeding' });
-    try {
-        for (;;) {
-            genIterNo += 1;
-            throwIfAborted(abortSignal, dlg);
-            const activeFbrState = await loadDialogFbrState(dlg);
-            if (isFbrSubdialogDialog(dlg)) {
-                dlg.setFbrConclusionToolsEnabled(activeFbrState !== undefined && (0, fbr_1.isFbrFinalizationState)(activeFbrState));
-                if (pendingPrompt === undefined &&
-                    activeFbrState &&
-                    activeFbrState.promptDelivered !== true) {
-                    pendingPrompt = buildKernelDriverFbrPrompt(dlg, activeFbrState);
+    driveCoreLoop: for (;;) {
+        try {
+            for (;;) {
+                genIterNo += 1;
+                throwIfAborted(abortSignal, dlg);
+                const activeFbrState = await loadDialogFbrState(dlg);
+                if (isFbrSubdialogDialog(dlg)) {
+                    dlg.setFbrConclusionToolsEnabled(activeFbrState !== undefined && (0, fbr_1.isFbrFinalizationState)(activeFbrState));
+                    if (pendingPrompt === undefined &&
+                        activeFbrState &&
+                        activeFbrState.promptDelivered !== true) {
+                        pendingPrompt = buildKernelDriverFbrPrompt(dlg, activeFbrState);
+                    }
                 }
-            }
-            const minds = await (0, load_1.loadAgentMinds)(dlg.agentId, dlg);
-            const team = minds.team;
-            const policy = (0, guardrails_1.buildKernelDriverPolicy)({
-                dlg,
-                agent: minds.agent,
-                systemPrompt: minds.systemPrompt,
-                agentTools: minds.agentTools,
-                language: (0, work_language_1.getWorkLanguage)(),
-            });
-            const policyValidation = (0, guardrails_1.validateKernelDriverPolicyInvariants)(policy, (0, work_language_1.getWorkLanguage)());
-            if (!policyValidation.ok) {
-                throw new Error(`kernel-driver policy invariant violation: ${policyValidation.detail}`);
-            }
-            const agent = policy.effectiveAgent;
-            const systemPrompt = policy.effectiveSystemPrompt;
-            const agentTools = policy.effectiveAgentTools;
-            const provider = agent.provider ?? team.memberDefaults.provider;
-            const model = agent.model ?? team.memberDefaults.model;
-            if (!provider) {
-                throw new Error(`Configuration Error: No provider configured for agent '${dlg.agentId}'. Please specify a provider in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
-            }
-            if (!model) {
-                throw new Error(`Configuration Error: No model configured for agent '${dlg.agentId}'. Please specify a model in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
-            }
-            const llmCfg = await client_1.LlmConfig.load();
-            const providerCfg = llmCfg.getProvider(provider);
-            if (!providerCfg) {
-                throw new Error(`Provider configuration error: Provider '${provider}' not found for agent '${dlg.agentId}'. Please check .minds/llm.yaml and .minds/team.yaml configuration.`);
-            }
-            if (!providerCfg.models || !providerCfg.models[model]) {
-                throw new Error(`Configuration error: invalid model '${model}' for provider '${provider}' (agent='${dlg.agentId}').`);
-            }
-            const llmGen = (0, registry_1.getLlmGenerator)(providerCfg.apiType);
-            if (!llmGen) {
-                throw new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
-            }
-            const retryPolicy = resolveKernelDriverRetryPolicy(providerCfg);
-            const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
-            const isSubdialog = dlg.id.rootId !== dlg.id.selfId;
-            const fbrEffortDefault = resolveFbrEffortDefaultForTool(agent);
-            const effectiveFuncTools = policy.mode === 'default'
-                ? mergeTellaskVirtualTools(canonicalFuncTools, {
-                    includeTellaskBack: isSubdialog,
-                    fbrEffortDefault,
-                })
-                : canonicalFuncTools;
-            const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
-            const funcTools = projected.tools;
-            if (genIterNo > 1) {
-                const snapshot = dlg.getLastContextHealth();
-                const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
-                const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
-                const cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(modelInfoForRemediation?.caution_remediation_cadence_generations);
-                const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dlg.id.key(), snapshot);
-                const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
-                    dialogKey: dlg.id.key(),
-                    snapshot,
-                    hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
-                    canInjectPromptThisGen: !hasQueuedUpNext,
-                    cautionRemediationCadenceGenerations,
-                    criticalCountdownRemaining,
+                const minds = await (0, load_1.loadAgentMinds)(dlg.agentId, dlg);
+                const team = minds.team;
+                const policy = (0, guardrails_1.buildKernelDriverPolicy)({
+                    dlg,
+                    agent: minds.agent,
+                    systemPrompt: minds.systemPrompt,
+                    agentTools: minds.agentTools,
+                    language: (0, work_language_1.getWorkLanguage)(),
                 });
-                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,
+                const policyValidation = (0, guardrails_1.validateKernelDriverPolicyInvariants)(policy, (0, work_language_1.getWorkLanguage)());
+                if (!policyValidation.ok) {
+                    throw new Error(`kernel-driver policy invariant violation: ${policyValidation.detail}`);
+                }
+                const agent = policy.effectiveAgent;
+                const systemPrompt = policy.effectiveSystemPrompt;
+                const agentTools = policy.effectiveAgentTools;
+                const prepareRetryStoppedRecovery = async (reason) => {
+                    retryStoppedRecoveryPrompt = undefined;
+                    const recovery = await maybePrepareRetryStoppedRecoveryPrompt({
+                        dlg,
+                        team,
+                        suppressDiligencePushForDrive,
+                        reason,
                     });
-                    break;
+                    if (recovery.kind !== 'continue') {
+                        return 'stop';
+                    }
+                    retryStoppedRecoveryPrompt = recovery.prompt;
+                    return 'continue';
+                };
+                const provider = agent.provider ?? team.memberDefaults.provider;
+                const model = agent.model ?? team.memberDefaults.model;
+                if (!provider) {
+                    throw new Error(`Configuration Error: No provider configured for agent '${dlg.agentId}'. Please specify a provider in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
                 }
-                if (healthDecision.kind === 'continue') {
-                    if (healthDecision.reason === 'critical_force_new_course') {
-                        const language = (0, work_language_1.getWorkLanguage)();
-                        const newCoursePrompt = (0, driver_messages_1.formatNewCourseStartPrompt)(language, {
-                            nextCourse: dlg.currentCourse + 1,
-                            source: 'critical_auto_clear',
-                        });
-                        await dlg.startNewCourse(newCoursePrompt);
-                        dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
-                        (0, context_health_1.resetContextHealthRoundState)(dlg.id.key());
-                        const nextPrompt = resolveUpNextPrompt(dlg);
-                        if (!nextPrompt) {
-                            throw new Error(`kernel-driver critical force-new-course invariant violation: missing upNext prompt after startNewCourse for dialog=${dlg.id.valueOf()}`);
-                        }
-                        pendingPrompt = nextPrompt;
-                        skipTaskdocForThisDrive = false;
+                if (!model) {
+                    throw new Error(`Configuration Error: No model configured for agent '${dlg.agentId}'. Please specify a model in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
+                }
+                const llmCfg = await client_1.LlmConfig.load();
+                const providerCfg = llmCfg.getProvider(provider);
+                if (!providerCfg) {
+                    throw new Error(`Provider configuration error: Provider '${provider}' not found for agent '${dlg.agentId}'. Please check .minds/llm.yaml and .minds/team.yaml configuration.`);
+                }
+                if (!providerCfg.models || !providerCfg.models[model]) {
+                    throw new Error(`Configuration error: invalid model '${model}' for provider '${provider}' (agent='${dlg.agentId}').`);
+                }
+                const llmGen = (0, registry_1.getLlmGenerator)(providerCfg.apiType);
+                if (!llmGen) {
+                    throw new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
+                }
+                const resolveRetryQuirkSession = () => {
+                    const key = `${provider}::${model}`;
+                    const existing = retryQuirkSessionByProviderModel.get(key);
+                    if (existing) {
+                        return existing;
                     }
-                    else if (!hasQueuedUpNext) {
-                        const language = (0, work_language_1.getWorkLanguage)();
-                        const guideText = healthDecision.reason === 'caution_soft_remediation'
-                            ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
-                                kind: 'caution',
-                                mode: 'soft',
-                            })
-                            : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
-                                kind: 'critical',
-                                mode: 'countdown',
-                                promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
-                                promptsTotal: context_health_1.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
-                            });
-                        pendingPrompt = {
-                            content: guideText,
-                            msgId: (0, id_1.generateShortId)(),
-                            grammar: 'markdown',
-                            origin: 'runtime',
-                            userLanguageCode: language,
-                        };
+                    const created = (0, api_quirks_1.createLlmFailureQuirkHandlerSession)(providerCfg);
+                    if (!created) {
+                        return undefined;
                     }
-                }
-            }
-            let contextHealthForGen;
-            let llmGenModelForGen = model;
-            const currentPrompt = pendingPrompt;
-            const currentReplyTarget = currentPrompt?.subdialogReplyTarget;
-            const currentFbrState = await loadDialogFbrState(dlg);
-            let currentRuntimeGuideMsg;
-            const currentPromptFromFbrState = currentPrompt !== undefined &&
-                currentFbrState !== undefined &&
-                currentFbrState.promptDelivered !== true;
-            pendingPrompt = undefined;
-            await dlg.notifyGeneratingStart(currentPrompt?.msgId);
-            try {
-                if (currentPrompt) {
-                    const origin = currentPrompt.origin;
-                    if (origin === 'diligence_push' &&
-                        (dlg.disableDiligencePush || suppressDiligencePushForDrive)) {
-                        log_1.log.debug('kernel-driver skip diligence prompt after disable toggle', undefined, {
+                    retryQuirkSessionByProviderModel.set(key, created);
+                    return created;
+                };
+                const retryPolicy = resolveKernelDriverRetryPolicy(providerCfg);
+                const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
+                const isSubdialog = dlg.id.rootId !== dlg.id.selfId;
+                const fbrEffortDefault = resolveFbrEffortDefaultForTool(agent);
+                const effectiveFuncTools = policy.mode === 'default'
+                    ? mergeTellaskVirtualTools(canonicalFuncTools, {
+                        includeTellaskBack: isSubdialog,
+                        fbrEffortDefault,
+                    })
+                    : canonicalFuncTools;
+                const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
+                const funcTools = projected.tools;
+                if (genIterNo > 1) {
+                    const snapshot = dlg.getLastContextHealth();
+                    const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
+                    const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
+                    const cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(modelInfoForRemediation?.caution_remediation_cadence_generations);
+                    const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dlg.id.key(), snapshot);
+                    const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
+                        dialogKey: dlg.id.key(),
+                        snapshot,
+                        hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
+                        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(),
-                            msgId: currentPrompt.msgId,
+                            rootId: dlg.id.rootId,
+                            selfId: dlg.id.selfId,
+                            genIterNo,
+                            pendingPromptOrigin: pendingPrompt?.origin ?? null,
                         });
                         break;
                     }
-                    if (currentPrompt.skipTaskdoc === true) {
-                        skipTaskdocForThisDrive = true;
-                    }
-                    const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
-                    const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt.q4hAnswerCallId);
-                    // `q4hAnswerCallId` marks a continuation input for an already-materialized askHuman
-                    // answer. It is not a second business-level user prompt that should re-enter transcript.
-                    const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
-                    const promptLanguage = persistedUserLanguageCode === 'zh' || persistedUserLanguageCode === 'en'
-                        ? persistedUserLanguageCode
-                        : (0, work_language_1.getWorkLanguage)();
-                    const replyGuidance = await (0, reply_guidance_1.resolvePromptReplyGuidance)({
-                        dlg,
-                        prompt: currentPrompt,
-                        language: promptLanguage,
-                    });
-                    if (currentPrompt.origin === 'user' &&
-                        replyGuidance.suppressInterDialogReplyGuidance &&
-                        replyGuidance.deferredReplyReassertionDirective !== undefined) {
-                        const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
-                        const nextDeferredReplyReassertion = {
-                            reason: 'user_interjection_while_pending_subdialog',
-                            directive: replyGuidance.deferredReplyReassertionDirective,
-                        };
-                        if (existingDeferredReplyReassertion === undefined ||
-                            !hasSameReplyDirective(existingDeferredReplyReassertion.directive, nextDeferredReplyReassertion.directive)) {
-                            await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, nextDeferredReplyReassertion, dlg.status);
+                    if (healthDecision.kind === 'continue') {
+                        if (healthDecision.reason === 'critical_force_new_course') {
+                            const language = (0, work_language_1.getWorkLanguage)();
+                            const newCoursePrompt = (0, driver_messages_1.formatNewCourseStartPrompt)(language, {
+                                nextCourse: dlg.currentCourse + 1,
+                                source: 'critical_auto_clear',
+                            });
+                            await dlg.startNewCourse(newCoursePrompt);
+                            dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+                            (0, context_health_1.resetContextHealthRoundState)(dlg.id.key());
+                            const nextPrompt = resolveUpNextPrompt(dlg);
+                            if (!nextPrompt) {
+                                throw new Error(`kernel-driver critical force-new-course invariant violation: missing upNext prompt after startNewCourse for dialog=${dlg.id.valueOf()}`);
+                            }
+                            pendingPrompt = nextPrompt;
+                            skipTaskdocForThisDrive = false;
                         }
-                        if (existingDeferredReplyReassertion === undefined) {
-                            currentRuntimeGuideMsg = replyGuidance.transientGuideContent
-                                ? {
-                                    type: 'transient_guide_msg',
-                                    role: 'assistant',
-                                    content: replyGuidance.transientGuideContent,
-                                }
-                                : undefined;
+                        else if (!hasQueuedUpNext) {
+                            const language = (0, work_language_1.getWorkLanguage)();
+                            const guideText = healthDecision.reason === 'caution_soft_remediation'
+                                ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+                                    kind: 'caution',
+                                    mode: 'soft',
+                                })
+                                : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+                                    kind: 'critical',
+                                    mode: 'countdown',
+                                    promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                                    promptsTotal: context_health_1.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
+                                });
+                            pendingPrompt = {
+                                content: guideText,
+                                msgId: (0, id_1.generateShortId)(),
+                                grammar: 'markdown',
+                                origin: 'runtime',
+                                userLanguageCode: language,
+                            };
                         }
                     }
-                    else if (currentPrompt.origin === 'user' &&
-                        !replyGuidance.suppressInterDialogReplyGuidance) {
-                        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, undefined, dlg.status);
-                    }
-                    if (!replyGuidance.suppressInterDialogReplyGuidance &&
-                        !currentRuntimeGuideMsg &&
-                        replyGuidance.transientGuideContent) {
-                        currentRuntimeGuideMsg = {
-                            type: 'transient_guide_msg',
-                            role: 'assistant',
-                            content: replyGuidance.transientGuideContent,
-                        };
-                    }
-                    if (replyGuidance.promptContent === undefined) {
-                        throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
-                    }
-                    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,
-                        });
-                        currentRuntimeGuideMsg = undefined;
-                    }
-                    if (isQ4HAnswerPrompt) {
-                        // Record only the answered call correlation / user language for the resumed round.
-                        // The actual human answer fact was already persisted via askHuman tellask result flow.
-                        await dlg.receiveHumanReply({
-                            content: replyGuidance.promptContent,
-                            userLanguageCode: persistedUserLanguageCode,
-                            q4hAnswerCallId,
-                        });
-                    }
-                    else {
-                        await dlg.addChatMessages({
-                            type: 'prompting_msg',
-                            role: 'user',
-                            genseq: dlg.activeGenSeq,
-                            msgId: currentPrompt.msgId,
-                            grammar: 'markdown',
-                            content: replyGuidance.promptContent,
-                        });
-                        await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective);
-                    }
-                    if (renderPromptAsRuntimeGuideBubble) {
-                        (0, evt_registry_1.postDialogEvent)(dlg, {
-                            type: 'runtime_guide_evt',
-                            course: dlg.currentCourse,
-                            genseq: dlg.activeGenSeq,
-                            content: replyGuidance.promptContent,
-                        });
-                    }
-                    else if (!isQ4HAnswerPrompt) {
-                        // Emit the live user-side boundary event for UI generation bubbles.
-                        // Without this, realtime turns can miss user content + divider (<hr/>).
-                        (0, evt_registry_1.postDialogEvent)(dlg, {
-                            type: 'end_of_user_saying_evt',
-                            course: dlg.currentCourse,
-                            genseq: dlg.activeGenSeq,
-                            msgId: currentPrompt.msgId,
-                            content: replyGuidance.promptContent,
-                            grammar: 'markdown',
-                            origin,
-                            userLanguageCode: persistedUserLanguageCode,
-                            q4hAnswerCallId,
+                }
+                let contextHealthForGen;
+                let llmGenModelForGen = model;
+                const currentPrompt = pendingPrompt;
+                const currentReplyTarget = currentPrompt?.subdialogReplyTarget;
+                const currentFbrState = await loadDialogFbrState(dlg);
+                let currentRuntimeGuideMsg;
+                const currentPromptFromFbrState = currentPrompt !== undefined &&
+                    currentFbrState !== undefined &&
+                    currentFbrState.promptDelivered !== true;
+                pendingPrompt = undefined;
+                await dlg.notifyGeneratingStart(currentPrompt?.msgId);
+                try {
+                    if (currentPrompt) {
+                        const origin = currentPrompt.origin;
+                        if (origin === 'diligence_push' &&
+                            (dlg.disableDiligencePush || suppressDiligencePushForDrive)) {
+                            log_1.log.debug('kernel-driver skip diligence prompt after disable toggle', undefined, {
+                                dialogId: dlg.id.valueOf(),
+                                msgId: currentPrompt.msgId,
+                            });
+                            break;
+                        }
+                        if (currentPrompt.skipTaskdoc === true) {
+                            skipTaskdocForThisDrive = true;
+                        }
+                        const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
+                        const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt.q4hAnswerCallId);
+                        // `q4hAnswerCallId` marks a continuation input for an already-materialized askHuman
+                        // answer. It is not a second business-level user prompt that should re-enter transcript.
+                        const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
+                        const promptLanguage = persistedUserLanguageCode === 'zh' || persistedUserLanguageCode === 'en'
+                            ? persistedUserLanguageCode
+                            : (0, work_language_1.getWorkLanguage)();
+                        const replyGuidance = await (0, reply_guidance_1.resolvePromptReplyGuidance)({
+                            dlg,
+                            prompt: currentPrompt,
+                            language: promptLanguage,
                         });
-                    }
-                    if (currentPromptFromFbrState && currentFbrState) {
-                        await persistDialogFbrState(dlg, (0, fbr_1.markFbrPromptDelivered)(currentFbrState));
-                    }
-                    // Ideal: provider SDKs should support a dedicated role='environment' for runtime
-                    // metadata. Today, most providers only accept user/assistant (and tool as a special
-                    // case), so Dominds must project environment/system-like content as role='user'.
-                    const replyTarget = currentPrompt.subdialogReplyTarget;
-                    if (replyTarget) {
-                        const normalizedCallId = replyTarget.callId.trim();
-                        if (normalizedCallId === '') {
-                            throw new Error(`kernel-driver assignment anchor invariant violation: empty callId (dialog=${dlg.id.valueOf()})`);
+                        if (currentPrompt.origin === 'user' &&
+                            replyGuidance.suppressInterDialogReplyGuidance &&
+                            replyGuidance.deferredReplyReassertionDirective !== undefined) {
+                            const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
+                            const nextDeferredReplyReassertion = {
+                                reason: 'user_interjection_while_pending_subdialog',
+                                directive: replyGuidance.deferredReplyReassertionDirective,
+                            };
+                            if (existingDeferredReplyReassertion === undefined ||
+                                !hasSameReplyDirective(existingDeferredReplyReassertion.directive, nextDeferredReplyReassertion.directive)) {
+                                await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, nextDeferredReplyReassertion, dlg.status);
+                            }
+                            if (existingDeferredReplyReassertion === undefined) {
+                                currentRuntimeGuideMsg = replyGuidance.transientGuideContent
+                                    ? {
+                                        type: 'transient_guide_msg',
+                                        role: 'assistant',
+                                        content: replyGuidance.transientGuideContent,
+                                    }
+                                    : undefined;
+                            }
+                        }
+                        else if (currentPrompt.origin === 'user' &&
+                            !replyGuidance.suppressInterDialogReplyGuidance) {
+                            await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, undefined, dlg.status);
+                        }
+                        if (!replyGuidance.suppressInterDialogReplyGuidance &&
+                            !currentRuntimeGuideMsg &&
+                            replyGuidance.transientGuideContent) {
+                            currentRuntimeGuideMsg = {
+                                type: 'transient_guide_msg',
+                                role: 'assistant',
+                                content: replyGuidance.transientGuideContent,
+                            };
+                        }
+                        if (replyGuidance.promptContent === undefined) {
+                            throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
+                        }
+                        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,
+                            });
+                            currentRuntimeGuideMsg = undefined;
+                        }
+                        if (isQ4HAnswerPrompt) {
+                            // Record only the answered call correlation / user language for the resumed round.
+                            // The actual human answer fact was already persisted via askHuman tellask result flow.
+                            await dlg.receiveHumanReply({
+                                content: replyGuidance.promptContent,
+                                userLanguageCode: persistedUserLanguageCode,
+                                q4hAnswerCallId,
+                            });
+                        }
+                        else {
+                            await dlg.addChatMessages({
+                                type: 'prompting_msg',
+                                role: 'user',
+                                genseq: dlg.activeGenSeq,
+                                msgId: currentPrompt.msgId,
+                                grammar: 'markdown',
+                                content: replyGuidance.promptContent,
+                            });
+                            await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective);
+                        }
+                        if (renderPromptAsRuntimeGuideBubble) {
+                            (0, evt_registry_1.postDialogEvent)(dlg, {
+                                type: 'runtime_guide_evt',
+                                course: dlg.currentCourse,
+                                genseq: dlg.activeGenSeq,
+                                content: replyGuidance.promptContent,
+                            });
+                        }
+                        else if (!isQ4HAnswerPrompt) {
+                            // Emit the live user-side boundary event for UI generation bubbles.
+                            // Without this, realtime turns can miss user content + divider (<hr/>).
+                            (0, evt_registry_1.postDialogEvent)(dlg, {
+                                type: 'end_of_user_saying_evt',
+                                course: dlg.currentCourse,
+                                genseq: dlg.activeGenSeq,
+                                msgId: currentPrompt.msgId,
+                                content: replyGuidance.promptContent,
+                                grammar: 'markdown',
+                                origin,
+                                userLanguageCode: persistedUserLanguageCode,
+                                q4hAnswerCallId,
+                            });
+                        }
+                        if (currentPromptFromFbrState && currentFbrState) {
+                            await persistDialogFbrState(dlg, (0, fbr_1.markFbrPromptDelivered)(currentFbrState));
+                        }
+                        // Ideal: provider SDKs should support a dedicated role='environment' for runtime
+                        // metadata. Today, most providers only accept user/assistant (and tool as a special
+                        // case), so Dominds must project environment/system-like content as role='user'.
+                        const replyTarget = currentPrompt.subdialogReplyTarget;
+                        if (replyTarget) {
+                            const normalizedCallId = replyTarget.callId.trim();
+                            if (normalizedCallId === '') {
+                                throw new Error(`kernel-driver assignment anchor invariant violation: empty callId (dialog=${dlg.id.valueOf()})`);
+                            }
+                            const record = {
+                                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                                type: 'tellask_call_anchor_record',
+                                anchorRole: 'assignment',
+                                callId: normalizedCallId,
+                                genseq: dlg.activeGenSeq,
+                                ...(0, storage_1.toRootGenerationAnchor)({
+                                    rootCourse: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).currentCourse,
+                                    rootGenseq: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).activeGenSeqOrUndefined ?? 0,
+                                }),
+                            };
+                            const course = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                            await persistence_1.DialogPersistence.appendEvent(dlg.id, course, record, dlg.status);
                         }
-                        const record = {
-                            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                            type: 'tellask_call_anchor_record',
-                            anchorRole: 'assignment',
-                            callId: normalizedCallId,
-                            genseq: dlg.activeGenSeq,
-                            ...(0, storage_1.toRootGenerationAnchor)({
-                                rootCourse: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).currentCourse,
-                                rootGenseq: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).activeGenSeqOrUndefined ?? 0,
-                            }),
-                        };
-                        const course = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
-                        await persistence_1.DialogPersistence.appendEvent(dlg.id, course, record, dlg.status);
                     }
-                }
-                await dlg.processReminderUpdates();
-                pubRemindersVer = dlg.remindersVer;
-                const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
-                const renderedReminders = await renderRemindersForContext(dlg);
-                const ctxMsgs = (0, context_1.assembleDriveContextMessages)({
-                    base: {
-                        prependedContextMessages: policy.prependedContextMessages,
-                        memories: minds.memories,
-                        taskDocMsg,
-                        coursePrefixMsgs: dlg.getCoursePrefixMsgs(),
-                        dialogMsgsForContext: await buildDialogMsgsForContext(dlg),
-                    },
-                    ephemeral: {
-                        runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : undefined,
-                    },
-                    tail: { renderedReminders },
-                });
-                const newMsgs = [];
-                const streamedFuncCalls = [];
-                let sawWebSearchSideChannelOutput = false;
-                let sawNativeToolSideChannelOutput = false;
-                const streamOrBatch = async () => {
-                    let batchAttemptCourse;
-                    let batchAttemptCheckpointOffset;
-                    const rollbackBatchAttempt = async () => {
-                        if (batchAttemptCourse === undefined || batchAttemptCheckpointOffset === undefined) {
-                            throw new Error(`kernel-driver batch retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                    await dlg.processReminderUpdates();
+                    pubRemindersVer = dlg.remindersVer;
+                    const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive
+                        ? await (0, taskdoc_1.formatTaskDocContent)(dlg)
+                        : undefined;
+                    const renderedReminders = await renderRemindersForContext(dlg);
+                    const ctxMsgs = (0, context_1.assembleDriveContextMessages)({
+                        base: {
+                            prependedContextMessages: policy.prependedContextMessages,
+                            memories: minds.memories,
+                            taskDocMsg,
+                            coursePrefixMsgs: dlg.getCoursePrefixMsgs(),
+                            dialogMsgsForContext: await buildDialogMsgsForContext(dlg),
+                        },
+                        ephemeral: {
+                            runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : undefined,
+                        },
+                        tail: { renderedReminders },
+                    });
+                    const newMsgs = [];
+                    const streamedFuncCalls = [];
+                    let sawWebSearchSideChannelOutput = false;
+                    let sawNativeToolSideChannelOutput = false;
+                    const streamOrBatch = async () => {
+                        let batchAttemptCourse;
+                        let batchAttemptCheckpointOffset;
+                        const rollbackBatchAttempt = async () => {
+                            if (batchAttemptCourse === undefined || batchAttemptCheckpointOffset === undefined) {
+                                throw new Error(`kernel-driver batch retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                            }
+                            await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, batchAttemptCourse, batchAttemptCheckpointOffset, dlg.status);
+                            (0, evt_registry_1.postDialogEvent)(dlg, {
+                                type: 'genseq_discard_evt',
+                                course: batchAttemptCourse,
+                                genseq: dlg.activeGenSeq,
+                                reason: 'retry',
+                            });
+                            sawWebSearchSideChannelOutput = false;
+                            sawNativeToolSideChannelOutput = false;
+                            streamedFuncCalls.length = 0;
+                            newMsgs.length = 0;
+                        };
+                        if (agent.streaming === false) {
+                            const batch = await (0, runtime_1.runLlmRequestWithRetry)({
+                                dlg,
+                                provider,
+                                modelId: model,
+                                providerConfig: providerCfg,
+                                abortSignal,
+                                maxRetries: retryPolicy.maxRetries,
+                                retryInitialDelayMs: retryPolicy.initialDelayMs,
+                                retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
+                                retryBackoffMultiplier: retryPolicy.backoffMultiplier,
+                                retryMaxDelayMs: retryPolicy.maxDelayMs,
+                                classifyFailure: llmGen.classifyFailure?.bind(llmGen),
+                                quirkFailureHandlerSession: resolveRetryQuirkSession(),
+                                canRetry: () => true,
+                                onRetry: rollbackBatchAttempt,
+                                onGiveUp: rollbackBatchAttempt,
+                                onRetryStopped: prepareRetryStoppedRecovery,
+                                doRequest: async () => {
+                                    batchAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                                    batchAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, batchAttemptCourse, dlg.status);
+                                    sawWebSearchSideChannelOutput = false;
+                                    sawNativeToolSideChannelOutput = false;
+                                    streamedFuncCalls.length = 0;
+                                    newMsgs.length = 0;
+                                    const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, {
+                                        dialogSelfId: dlg.id.selfId,
+                                        dialogRootId: dlg.id.rootId,
+                                        promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
+                                    }, ctxMsgs, dlg.activeGenSeq, abortSignal);
+                                    if (!hasMeaningfulBatchOutput(batchResult)) {
+                                        throw {
+                                            status: 503,
+                                            code: KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE,
+                                            message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=false).`,
+                                        };
+                                    }
+                                    return batchResult;
+                                },
+                            });
+                            return {
+                                usage: batch.usage,
+                                llmGenModel: batch.llmGenModel,
+                                batchMessages: batch.messages,
+                                batchOutputs: batch.outputs,
+                            };
                         }
-                        await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, batchAttemptCourse, batchAttemptCheckpointOffset, dlg.status);
-                        (0, evt_registry_1.postDialogEvent)(dlg, {
-                            type: 'genseq_discard_evt',
-                            course: batchAttemptCourse,
-                            genseq: dlg.activeGenSeq,
-                            reason: 'retry',
-                        });
-                        sawWebSearchSideChannelOutput = false;
-                        sawNativeToolSideChannelOutput = false;
-                        streamedFuncCalls.length = 0;
-                        newMsgs.length = 0;
-                    };
-                    if (agent.streaming === false) {
-                        const batch = await (0, runtime_1.runLlmRequestWithRetry)({
+                        let currentSayingContent = '';
+                        let currentThinkingContent = '';
+                        let currentThinkingReasoning = undefined;
+                        let streamAttemptCourse;
+                        let streamAttemptCheckpointOffset;
+                        let streamAttemptSayingContent;
+                        let streamAttemptSayingGenseq;
+                        let streamActive = { kind: 'idle' };
+                        const rollbackStreamAttempt = async () => {
+                            if (streamAttemptCourse === undefined ||
+                                streamAttemptCheckpointOffset === undefined) {
+                                throw new Error(`kernel-driver stream retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                            }
+                            await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, streamAttemptCourse, streamAttemptCheckpointOffset, dlg.status);
+                            (0, evt_registry_1.postDialogEvent)(dlg, {
+                                type: 'genseq_discard_evt',
+                                course: streamAttemptCourse,
+                                genseq: dlg.activeGenSeq,
+                                reason: 'retry',
+                            });
+                            streamActive = { kind: 'idle' };
+                            currentThinkingContent = '';
+                            currentThinkingReasoning = undefined;
+                            currentSayingContent = '';
+                            streamAttemptSayingContent = undefined;
+                            streamAttemptSayingGenseq = undefined;
+                            sawWebSearchSideChannelOutput = false;
+                            sawNativeToolSideChannelOutput = false;
+                            streamedFuncCalls.length = 0;
+                            newMsgs.length = 0;
+                        };
+                        const receiver = {
+                            streamError: async (detail) => {
+                                await dlg.streamError(detail);
+                            },
+                            thinkingStart: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'idle') {
+                                    const detail = `Protocol violation: thinkingStart while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                streamActive = { kind: 'thinking' };
+                                currentThinkingContent = '';
+                                currentThinkingReasoning = undefined;
+                                await dlg.thinkingStart();
+                            },
+                            thinkingChunk: async (chunk) => {
+                                throwIfAborted(abortSignal, dlg);
+                                currentThinkingContent += chunk;
+                                await dlg.thinkingChunk(chunk);
+                            },
+                            thinkingFinish: async (reasoning) => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'thinking') {
+                                    const detail = `Protocol violation: thinkingFinish while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                streamActive = { kind: 'idle' };
+                                if (reasoning)
+                                    currentThinkingReasoning = reasoning;
+                                await dlg.thinkingFinish(reasoning);
+                                if (currentThinkingContent.length > 0 || currentThinkingReasoning !== undefined) {
+                                    newMsgs.push({
+                                        type: 'thinking_msg',
+                                        role: 'assistant',
+                                        genseq: dlg.activeGenSeq,
+                                        content: currentThinkingContent,
+                                        reasoning: currentThinkingReasoning,
+                                    });
+                                }
+                                currentThinkingContent = '';
+                                currentThinkingReasoning = undefined;
+                            },
+                            sayingStart: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'idle') {
+                                    const detail = `Protocol violation: sayingStart while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                streamActive = { kind: 'saying' };
+                                currentSayingContent = '';
+                                await dlg.sayingStart();
+                            },
+                            sayingChunk: async (chunk) => {
+                                throwIfAborted(abortSignal, dlg);
+                                currentSayingContent += chunk;
+                                await dlg.sayingChunk(chunk);
+                            },
+                            sayingFinish: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'saying') {
+                                    const detail = `Protocol violation: sayingFinish while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                streamActive = { kind: 'idle' };
+                                await dlg.sayingFinish();
+                                const sayingMessage = {
+                                    type: 'saying_msg',
+                                    role: 'assistant',
+                                    genseq: dlg.activeGenSeq,
+                                    content: currentSayingContent,
+                                };
+                                newMsgs.push(sayingMessage);
+                                streamAttemptSayingContent = currentSayingContent;
+                                streamAttemptSayingGenseq = sayingMessage.genseq;
+                            },
+                            funcCall: async (callId, name, argsStr) => {
+                                throwIfAborted(abortSignal, dlg);
+                                streamedFuncCalls.push({
+                                    type: 'func_call_msg',
+                                    role: 'assistant',
+                                    genseq: dlg.activeGenSeq,
+                                    id: callId,
+                                    name,
+                                    arguments: argsStr,
+                                });
+                            },
+                            webSearchCall: async (call) => {
+                                throwIfAborted(abortSignal, dlg);
+                                sawWebSearchSideChannelOutput = true;
+                                await dlg.webSearchCall(projectLlmWebSearchCall(call));
+                            },
+                            nativeToolCall: async (call) => {
+                                throwIfAborted(abortSignal, dlg);
+                                sawNativeToolSideChannelOutput = true;
+                                await dlg.nativeToolCall(call);
+                            },
+                        };
+                        const res = await (0, runtime_1.runLlmRequestWithRetry)({
                             dlg,
                             provider,
                             modelId: model,
@@ -1530,620 +1789,489 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             retryBackoffMultiplier: retryPolicy.backoffMultiplier,
                             retryMaxDelayMs: retryPolicy.maxDelayMs,
                             classifyFailure: llmGen.classifyFailure?.bind(llmGen),
+                            quirkFailureHandlerSession: resolveRetryQuirkSession(),
                             canRetry: () => true,
-                            onRetry: rollbackBatchAttempt,
-                            onGiveUp: rollbackBatchAttempt,
+                            onRetry: rollbackStreamAttempt,
+                            onGiveUp: rollbackStreamAttempt,
+                            onRetryStopped: prepareRetryStoppedRecovery,
                             doRequest: async () => {
-                                batchAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
-                                batchAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, batchAttemptCourse, dlg.status);
+                                streamAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                                streamAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, streamAttemptCourse, dlg.status);
+                                streamActive = { kind: 'idle' };
+                                currentThinkingContent = '';
+                                currentThinkingReasoning = undefined;
+                                currentSayingContent = '';
+                                streamAttemptSayingContent = undefined;
+                                streamAttemptSayingGenseq = undefined;
                                 sawWebSearchSideChannelOutput = false;
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
                                 newMsgs.length = 0;
-                                const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, {
+                                const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
                                     dialogSelfId: dlg.id.selfId,
                                     dialogRootId: dlg.id.rootId,
                                     promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
-                                }, ctxMsgs, dlg.activeGenSeq, abortSignal);
-                                if (!hasMeaningfulBatchOutput(batchResult)) {
+                                }, ctxMsgs, receiver, dlg.activeGenSeq, abortSignal);
+                                const hasThinkingContent = currentThinkingContent.trim() !== '';
+                                const hasSayingContent = (streamAttemptSayingContent ?? '').trim() !== '';
+                                const hasFunctionCall = streamedFuncCalls.length > 0;
+                                if (!hasThinkingContent &&
+                                    !hasSayingContent &&
+                                    !hasFunctionCall &&
+                                    !sawWebSearchSideChannelOutput &&
+                                    !sawNativeToolSideChannelOutput) {
                                     throw {
                                         status: 503,
                                         code: KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE,
-                                        message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=false).`,
+                                        message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=true).`,
                                     };
                                 }
-                                return batchResult;
+                                return streamResult;
                             },
                         });
-                        return {
-                            usage: batch.usage,
-                            llmGenModel: batch.llmGenModel,
-                            batchMessages: batch.messages,
-                            batchOutputs: batch.outputs,
-                        };
-                    }
-                    let currentSayingContent = '';
-                    let currentThinkingContent = '';
-                    let currentThinkingReasoning = undefined;
-                    let streamAttemptCourse;
-                    let streamAttemptCheckpointOffset;
-                    let streamAttemptSayingContent;
-                    let streamAttemptSayingGenseq;
-                    let streamActive = { kind: 'idle' };
-                    const rollbackStreamAttempt = async () => {
-                        if (streamAttemptCourse === undefined || streamAttemptCheckpointOffset === undefined) {
-                            throw new Error(`kernel-driver stream retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                        if (streamAttemptSayingContent !== undefined) {
+                            lastAssistantSayingContent = streamAttemptSayingContent;
+                            lastAssistantSayingGenseq =
+                                streamAttemptSayingGenseq === undefined ? null : streamAttemptSayingGenseq;
+                            lastAssistantReplyTarget = currentReplyTarget;
                         }
-                        await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, streamAttemptCourse, streamAttemptCheckpointOffset, dlg.status);
-                        (0, evt_registry_1.postDialogEvent)(dlg, {
-                            type: 'genseq_discard_evt',
-                            course: streamAttemptCourse,
-                            genseq: dlg.activeGenSeq,
-                            reason: 'retry',
-                        });
-                        streamActive = { kind: 'idle' };
-                        currentThinkingContent = '';
-                        currentThinkingReasoning = undefined;
-                        currentSayingContent = '';
-                        streamAttemptSayingContent = undefined;
-                        streamAttemptSayingGenseq = undefined;
-                        sawWebSearchSideChannelOutput = false;
-                        sawNativeToolSideChannelOutput = false;
-                        streamedFuncCalls.length = 0;
-                        newMsgs.length = 0;
+                        return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
-                    const receiver = {
-                        streamError: async (detail) => {
-                            await dlg.streamError(detail);
-                        },
-                        thinkingStart: async () => {
-                            throwIfAborted(abortSignal, dlg);
-                            if (streamActive.kind !== 'idle') {
-                                const detail = `Protocol violation: thinkingStart while ${streamActive.kind} is active`;
-                                await dlg.streamError(detail);
-                                throw new Error(detail);
-                            }
-                            streamActive = { kind: 'thinking' };
-                            currentThinkingContent = '';
-                            currentThinkingReasoning = undefined;
-                            await dlg.thinkingStart();
-                        },
-                        thinkingChunk: async (chunk) => {
-                            throwIfAborted(abortSignal, dlg);
-                            currentThinkingContent += chunk;
-                            await dlg.thinkingChunk(chunk);
-                        },
-                        thinkingFinish: async (reasoning) => {
-                            throwIfAborted(abortSignal, dlg);
-                            if (streamActive.kind !== 'thinking') {
-                                const detail = `Protocol violation: thinkingFinish while ${streamActive.kind} is active`;
-                                await dlg.streamError(detail);
-                                throw new Error(detail);
-                            }
-                            streamActive = { kind: 'idle' };
-                            if (reasoning)
-                                currentThinkingReasoning = reasoning;
-                            await dlg.thinkingFinish(reasoning);
-                            if (currentThinkingContent.length > 0 || currentThinkingReasoning !== undefined) {
-                                newMsgs.push({
-                                    type: 'thinking_msg',
-                                    role: 'assistant',
-                                    genseq: dlg.activeGenSeq,
-                                    content: currentThinkingContent,
-                                    reasoning: currentThinkingReasoning,
-                                });
-                            }
-                            currentThinkingContent = '';
-                            currentThinkingReasoning = undefined;
-                        },
-                        sayingStart: async () => {
-                            throwIfAborted(abortSignal, dlg);
-                            if (streamActive.kind !== 'idle') {
-                                const detail = `Protocol violation: sayingStart while ${streamActive.kind} is active`;
-                                await dlg.streamError(detail);
-                                throw new Error(detail);
-                            }
-                            streamActive = { kind: 'saying' };
-                            currentSayingContent = '';
-                            await dlg.sayingStart();
-                        },
-                        sayingChunk: async (chunk) => {
-                            throwIfAborted(abortSignal, dlg);
-                            currentSayingContent += chunk;
-                            await dlg.sayingChunk(chunk);
-                        },
-                        sayingFinish: async () => {
-                            throwIfAborted(abortSignal, dlg);
-                            if (streamActive.kind !== 'saying') {
-                                const detail = `Protocol violation: sayingFinish while ${streamActive.kind} is active`;
-                                await dlg.streamError(detail);
-                                throw new Error(detail);
-                            }
-                            streamActive = { kind: 'idle' };
-                            await dlg.sayingFinish();
-                            const sayingMessage = {
-                                type: 'saying_msg',
-                                role: 'assistant',
-                                genseq: dlg.activeGenSeq,
-                                content: currentSayingContent,
-                            };
-                            newMsgs.push(sayingMessage);
-                            streamAttemptSayingContent = currentSayingContent;
-                            streamAttemptSayingGenseq = sayingMessage.genseq;
-                        },
-                        funcCall: async (callId, name, argsStr) => {
-                            throwIfAborted(abortSignal, dlg);
-                            streamedFuncCalls.push({
-                                type: 'func_call_msg',
-                                role: 'assistant',
-                                genseq: dlg.activeGenSeq,
-                                id: callId,
-                                name,
-                                arguments: argsStr,
-                            });
-                        },
-                        webSearchCall: async (call) => {
-                            throwIfAborted(abortSignal, dlg);
-                            sawWebSearchSideChannelOutput = true;
-                            await dlg.webSearchCall(projectLlmWebSearchCall(call));
-                        },
-                        nativeToolCall: async (call) => {
-                            throwIfAborted(abortSignal, dlg);
-                            sawNativeToolSideChannelOutput = true;
-                            await dlg.nativeToolCall(call);
-                        },
-                    };
-                    const res = await (0, runtime_1.runLlmRequestWithRetry)({
-                        dlg,
-                        provider,
-                        modelId: model,
-                        providerConfig: providerCfg,
-                        abortSignal,
-                        maxRetries: retryPolicy.maxRetries,
-                        retryInitialDelayMs: retryPolicy.initialDelayMs,
-                        retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
-                        retryBackoffMultiplier: retryPolicy.backoffMultiplier,
-                        retryMaxDelayMs: retryPolicy.maxDelayMs,
-                        classifyFailure: llmGen.classifyFailure?.bind(llmGen),
-                        canRetry: () => true,
-                        onRetry: rollbackStreamAttempt,
-                        onGiveUp: rollbackStreamAttempt,
-                        doRequest: async () => {
-                            streamAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
-                            streamAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, streamAttemptCourse, dlg.status);
-                            streamActive = { kind: 'idle' };
-                            currentThinkingContent = '';
-                            currentThinkingReasoning = undefined;
-                            currentSayingContent = '';
-                            streamAttemptSayingContent = undefined;
-                            streamAttemptSayingGenseq = undefined;
-                            sawWebSearchSideChannelOutput = false;
-                            sawNativeToolSideChannelOutput = false;
-                            streamedFuncCalls.length = 0;
-                            newMsgs.length = 0;
-                            const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
-                                dialogSelfId: dlg.id.selfId,
-                                dialogRootId: dlg.id.rootId,
-                                promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
-                            }, ctxMsgs, receiver, dlg.activeGenSeq, abortSignal);
-                            const hasThinkingContent = currentThinkingContent.trim() !== '';
-                            const hasSayingContent = (streamAttemptSayingContent ?? '').trim() !== '';
-                            const hasFunctionCall = streamedFuncCalls.length > 0;
-                            if (!hasThinkingContent &&
-                                !hasSayingContent &&
-                                !hasFunctionCall &&
-                                !sawWebSearchSideChannelOutput &&
-                                !sawNativeToolSideChannelOutput) {
-                                throw {
-                                    status: 503,
-                                    code: KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE,
-                                    message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=true).`,
-                                };
-                            }
-                            return streamResult;
-                        },
-                    });
-                    if (streamAttemptSayingContent !== undefined) {
-                        lastAssistantSayingContent = streamAttemptSayingContent;
-                        lastAssistantSayingGenseq =
-                            streamAttemptSayingGenseq === undefined ? null : streamAttemptSayingGenseq;
-                        lastAssistantReplyTarget = currentReplyTarget;
+                    const llmOutput = await streamOrBatch();
+                    if (typeof llmOutput.llmGenModel === 'string' && llmOutput.llmGenModel.trim() !== '') {
+                        llmGenModelForGen = llmOutput.llmGenModel.trim();
                     }
-                    return { usage: res.usage, llmGenModel: res.llmGenModel };
-                };
-                const llmOutput = await streamOrBatch();
-                if (typeof llmOutput.llmGenModel === 'string' && llmOutput.llmGenModel.trim() !== '') {
-                    llmGenModelForGen = llmOutput.llmGenModel.trim();
-                }
-                contextHealthForGen = computeContextHealthSnapshot({
-                    providerCfg,
-                    model,
-                    usage: llmOutput.usage,
-                });
-                dlg.setLastContextHealth(contextHealthForGen);
-                const batchOutputs = Array.isArray(llmOutput.batchOutputs) && llmOutput.batchOutputs.length > 0
-                    ? llmOutput.batchOutputs
-                    : Array.isArray(llmOutput.batchMessages)
-                        ? llmOutput.batchMessages.map((message) => ({ kind: 'message', message }))
-                        : [];
-                for (const output of batchOutputs) {
-                    switch (output.kind) {
-                        case 'message': {
-                            const msg = output.message;
-                            if (msg.type === 'thinking_msg' || msg.type === 'saying_msg') {
-                                newMsgs.push(msg);
-                                if (msg.type === 'thinking_msg') {
-                                    await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
+                    contextHealthForGen = computeContextHealthSnapshot({
+                        providerCfg,
+                        model,
+                        usage: llmOutput.usage,
+                    });
+                    dlg.setLastContextHealth(contextHealthForGen);
+                    const batchOutputs = Array.isArray(llmOutput.batchOutputs) && llmOutput.batchOutputs.length > 0
+                        ? llmOutput.batchOutputs
+                        : Array.isArray(llmOutput.batchMessages)
+                            ? llmOutput.batchMessages.map((message) => ({ kind: 'message', message }))
+                            : [];
+                    for (const output of batchOutputs) {
+                        switch (output.kind) {
+                            case 'message': {
+                                const msg = output.message;
+                                if (msg.type === 'thinking_msg' || msg.type === 'saying_msg') {
+                                    newMsgs.push(msg);
+                                    if (msg.type === 'thinking_msg') {
+                                        await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
+                                    }
+                                    else {
+                                        lastAssistantSayingContent = msg.content;
+                                        lastAssistantSayingGenseq = msg.genseq;
+                                        lastAssistantReplyTarget = currentReplyTarget;
+                                        await emitAssistantSaying(dlg, msg.content);
+                                    }
+                                    break;
                                 }
-                                else {
-                                    lastAssistantSayingContent = msg.content;
-                                    lastAssistantSayingGenseq = msg.genseq;
-                                    lastAssistantReplyTarget = currentReplyTarget;
-                                    await emitAssistantSaying(dlg, msg.content);
+                                if (msg.type === 'func_call_msg') {
+                                    streamedFuncCalls.push(msg);
                                 }
                                 break;
                             }
-                            if (msg.type === 'func_call_msg') {
-                                streamedFuncCalls.push(msg);
+                            case 'web_search_call': {
+                                sawWebSearchSideChannelOutput = true;
+                                await dlg.webSearchCall(projectLlmWebSearchCall(output.call));
+                                break;
+                            }
+                            case 'native_tool_call': {
+                                sawNativeToolSideChannelOutput = true;
+                                await dlg.nativeToolCall(output.call);
+                                break;
+                            }
+                            default: {
+                                const _exhaustive = output;
+                                throw new Error(`Unhandled batch output kind: ${String(_exhaustive)}`);
                             }
-                            break;
-                        }
-                        case 'web_search_call': {
-                            sawWebSearchSideChannelOutput = true;
-                            await dlg.webSearchCall(projectLlmWebSearchCall(output.call));
-                            break;
-                        }
-                        case 'native_tool_call': {
-                            sawNativeToolSideChannelOutput = true;
-                            await dlg.nativeToolCall(output.call);
-                            break;
-                        }
-                        default: {
-                            const _exhaustive = output;
-                            throw new Error(`Unhandled batch output kind: ${String(_exhaustive)}`);
                         }
                     }
-                }
-                const tellaskCallCount = policy.allowTellaskFunctions
-                    ? streamedFuncCalls.filter((c) => c.name === 'tellask' ||
-                        c.name === 'tellaskSessionless' ||
-                        c.name === 'tellaskBack' ||
-                        c.name === 'askHuman' ||
-                        c.name === 'freshBootsReasoning').length
-                    : 0;
-                const policyViolationKind = (0, guardrails_1.resolveKernelDriverPolicyViolationKind)({
-                    policy,
-                    tellaskCallCount,
-                    functionCallCount: streamedFuncCalls.length,
-                });
-                if (policyViolationKind) {
-                    const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, work_language_1.getWorkLanguage)(), {
-                        kind: policyViolationKind,
+                    const tellaskCallCount = policy.allowTellaskFunctions
+                        ? streamedFuncCalls.filter((c) => c.name === 'tellask' ||
+                            c.name === 'tellaskSessionless' ||
+                            c.name === 'tellaskBack' ||
+                            c.name === 'askHuman' ||
+                            c.name === 'freshBootsReasoning').length
+                        : 0;
+                    const policyViolationKind = (0, guardrails_1.resolveKernelDriverPolicyViolationKind)({
+                        policy,
+                        tellaskCallCount,
+                        functionCallCount: streamedFuncCalls.length,
                     });
-                    const genseq = dlg.activeGenSeq;
-                    const violationMsg = {
-                        type: 'saying_msg',
-                        role: 'assistant',
-                        genseq,
-                        content: violationText,
-                    };
-                    await emitAssistantSaying(dlg, violationText);
-                    newMsgs.push(violationMsg);
-                    await dlg.addChatMessages(...newMsgs);
-                    lastAssistantSayingContent = violationText;
-                    lastAssistantSayingGenseq = genseq;
-                    lastAssistantReplyTarget = currentReplyTarget;
-                    const persistedFbrState = await loadDialogFbrState(dlg);
-                    if (!persistedFbrState) {
-                        return {
-                            lastAssistantSayingContent,
-                            lastAssistantSayingGenseq,
-                            lastFunctionCallGenseq,
-                            lastAssistantReplyTarget,
+                    if (policyViolationKind) {
+                        const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, work_language_1.getWorkLanguage)(), {
+                            kind: policyViolationKind,
+                        });
+                        const genseq = dlg.activeGenSeq;
+                        const violationMsg = {
+                            type: 'saying_msg',
+                            role: 'assistant',
+                            genseq,
+                            content: violationText,
+                        };
+                        await emitAssistantSaying(dlg, violationText);
+                        newMsgs.push(violationMsg);
+                        await dlg.addChatMessages(...newMsgs);
+                        lastAssistantSayingContent = violationText;
+                        lastAssistantSayingGenseq = genseq;
+                        lastAssistantReplyTarget = currentReplyTarget;
+                        const persistedFbrState = await loadDialogFbrState(dlg);
+                        if (!persistedFbrState) {
+                            return {
+                                lastAssistantSayingContent,
+                                lastAssistantSayingGenseq,
+                                lastFunctionCallGenseq,
+                                lastAssistantReplyTarget,
+                            };
+                        }
+                        const nextFbrState = (0, fbr_1.advanceFbrState)(persistedFbrState);
+                        if (nextFbrState) {
+                            if (!isFbrSubdialogDialog(dlg)) {
+                                throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
+                            }
+                            await persistDialogFbrState(dlg, nextFbrState);
+                            dlg.setFbrConclusionToolsEnabled((0, fbr_1.isFbrFinalizationState)(nextFbrState));
+                            pendingPrompt = buildKernelDriverFbrPrompt(dlg, nextFbrState);
+                            continue;
+                        }
+                        fbrConclusion = {
+                            responseText: (0, fbr_1.buildProgrammaticFbrUnreasonableSituationContent)({
+                                language: (0, work_language_1.getWorkLanguage)(),
+                                finalizationAttempts: persistedFbrState.effort,
+                            }),
+                            responseGenseq: genseq,
                         };
-                    }
-                    const nextFbrState = (0, fbr_1.advanceFbrState)(persistedFbrState);
-                    if (nextFbrState) {
                         if (!isFbrSubdialogDialog(dlg)) {
                             throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
                         }
-                        await persistDialogFbrState(dlg, nextFbrState);
-                        dlg.setFbrConclusionToolsEnabled((0, fbr_1.isFbrFinalizationState)(nextFbrState));
-                        pendingPrompt = buildKernelDriverFbrPrompt(dlg, nextFbrState);
-                        continue;
+                        await persistDialogFbrState(dlg, undefined);
+                        dlg.setFbrConclusionToolsEnabled(false);
+                        break;
                     }
-                    fbrConclusion = {
-                        responseText: (0, fbr_1.buildProgrammaticFbrUnreasonableSituationContent)({
-                            language: (0, work_language_1.getWorkLanguage)(),
-                            finalizationAttempts: persistedFbrState.effort,
-                        }),
-                        responseGenseq: genseq,
-                    };
-                    if (!isFbrSubdialogDialog(dlg)) {
-                        throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
+                    for (const call of streamedFuncCalls) {
+                        const rawCallGenseq = call.genseq;
+                        if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0)
+                            continue;
+                        const callGenseq = Math.floor(rawCallGenseq);
+                        if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
+                            lastFunctionCallGenseq = callGenseq;
+                        }
                     }
-                    await persistDialogFbrState(dlg, undefined);
-                    dlg.setFbrConclusionToolsEnabled(false);
-                    break;
-                }
-                for (const call of streamedFuncCalls) {
-                    const rawCallGenseq = call.genseq;
-                    if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0)
-                        continue;
-                    const callGenseq = Math.floor(rawCallGenseq);
-                    if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
-                        lastFunctionCallGenseq = callGenseq;
+                    const routed = await executeFunctionRound({
+                        dlg,
+                        agent,
+                        agentTools,
+                        funcCalls: streamedFuncCalls,
+                        callbacks,
+                        abortSignal,
+                        allowTellaskFunctions: policy.allowTellaskFunctions,
+                    });
+                    if (routed.tellaskToolOutputs.length > 0) {
+                        newMsgs.push(...routed.tellaskToolOutputs);
                     }
-                }
-                const routed = await executeFunctionRound({
-                    dlg,
-                    agent,
-                    agentTools,
-                    funcCalls: streamedFuncCalls,
-                    callbacks,
-                    abortSignal,
-                    allowTellaskFunctions: policy.allowTellaskFunctions,
-                });
-                if (routed.tellaskToolOutputs.length > 0) {
-                    newMsgs.push(...routed.tellaskToolOutputs);
-                }
-                if (routed.pairedMessages.length > 0) {
-                    newMsgs.push(...routed.pairedMessages);
-                }
-                await dlg.addChatMessages(...newMsgs);
-                const assistantSayingRoundSignature = extractAssistantSayingRoundSignature(newMsgs);
-                const identicalUpdatePlanRoundSignature = routed.updatePlanOnlyRawArgumentsSignature !== undefined &&
-                    assistantSayingRoundSignature !== undefined
-                    ? JSON.stringify({
-                        assistantSayingRoundSignature,
-                        updatePlanRawArgumentsSignature: routed.updatePlanOnlyRawArgumentsSignature,
-                    })
-                    : undefined;
-                if (identicalUpdatePlanRoundSignature !== undefined) {
-                    if (identicalUpdatePlanRoundSignature === lastIdenticalUpdatePlanRoundSignature) {
-                        consecutiveIdenticalUpdatePlanOnlyRounds += 1;
+                    if (routed.pairedMessages.length > 0) {
+                        newMsgs.push(...routed.pairedMessages);
+                    }
+                    await dlg.addChatMessages(...newMsgs);
+                    const assistantSayingRoundSignature = extractAssistantSayingRoundSignature(newMsgs);
+                    const identicalUpdatePlanRoundSignature = routed.updatePlanOnlyRound
+                        ? JSON.stringify({
+                            assistantSayingRoundSignature: assistantSayingRoundSignature ?? '',
+                        })
+                        : undefined;
+                    if (identicalUpdatePlanRoundSignature !== undefined) {
+                        if (identicalUpdatePlanRoundSignature === lastIdenticalUpdatePlanRoundSignature) {
+                            consecutiveIdenticalUpdatePlanOnlyRounds += 1;
+                        }
+                        else {
+                            consecutiveIdenticalUpdatePlanOnlyRounds = 1;
+                            lastIdenticalUpdatePlanRoundSignature = identicalUpdatePlanRoundSignature;
+                        }
                     }
                     else {
-                        consecutiveIdenticalUpdatePlanOnlyRounds = 1;
-                        lastIdenticalUpdatePlanRoundSignature = identicalUpdatePlanRoundSignature;
+                        consecutiveIdenticalUpdatePlanOnlyRounds = 0;
+                        lastIdenticalUpdatePlanRoundSignature = undefined;
                     }
-                }
-                else {
-                    consecutiveIdenticalUpdatePlanOnlyRounds = 0;
-                    lastIdenticalUpdatePlanRoundSignature = undefined;
-                }
-                const persistedFbrState = await loadDialogFbrState(dlg);
-                if (persistedFbrState) {
-                    if (persistedFbrState.phase === 'finalization') {
-                        const inspection = (0, fbr_1.inspectFbrConclusionAttempt)(newMsgs);
-                        if (inspection.kind === 'accepted') {
-                            log_1.log.debug('kernel-driver accepted FBR conclusion attempt', undefined, {
-                                dialogId: dlg.id.valueOf(),
-                                toolName: inspection.toolName,
-                                callId: inspection.callId,
-                            });
-                            fbrConclusion = {
-                                responseText: inspection.content,
-                                responseGenseq: inspection.genseq,
-                            };
+                    const persistedFbrState = await loadDialogFbrState(dlg);
+                    if (persistedFbrState) {
+                        if (persistedFbrState.phase === 'finalization') {
+                            const inspection = (0, fbr_1.inspectFbrConclusionAttempt)(newMsgs);
+                            if (inspection.kind === 'accepted') {
+                                log_1.log.debug('kernel-driver accepted FBR conclusion attempt', undefined, {
+                                    dialogId: dlg.id.valueOf(),
+                                    toolName: inspection.toolName,
+                                    callId: inspection.callId,
+                                });
+                                fbrConclusion = {
+                                    responseText: inspection.content,
+                                    responseGenseq: inspection.genseq,
+                                };
+                                if (!isFbrSubdialogDialog(dlg)) {
+                                    throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
+                                }
+                                await persistDialogFbrState(dlg, undefined);
+                                dlg.setFbrConclusionToolsEnabled(false);
+                                break;
+                            }
+                            if (inspection.kind === 'rejected') {
+                                const detail = `FBR conclusion attempt rejected: ${inspection.reason}`;
+                                await dlg.streamError(detail);
+                                log_1.log.warn(detail, undefined, {
+                                    rootId: dlg.id.rootId,
+                                    selfId: dlg.id.selfId,
+                                });
+                            }
+                        }
+                        const nextFbrState = (0, fbr_1.advanceFbrState)(persistedFbrState);
+                        if (nextFbrState) {
                             if (!isFbrSubdialogDialog(dlg)) {
                                 throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
                             }
-                            await persistDialogFbrState(dlg, undefined);
-                            dlg.setFbrConclusionToolsEnabled(false);
-                            break;
-                        }
-                        if (inspection.kind === 'rejected') {
-                            const detail = `FBR conclusion attempt rejected: ${inspection.reason}`;
-                            await dlg.streamError(detail);
-                            log_1.log.warn(detail, undefined, {
-                                rootId: dlg.id.rootId,
-                                selfId: dlg.id.selfId,
-                            });
+                            await persistDialogFbrState(dlg, nextFbrState);
+                            dlg.setFbrConclusionToolsEnabled((0, fbr_1.isFbrFinalizationState)(nextFbrState));
+                            pendingPrompt = buildKernelDriverFbrPrompt(dlg, nextFbrState);
+                            continue;
                         }
-                    }
-                    const nextFbrState = (0, fbr_1.advanceFbrState)(persistedFbrState);
-                    if (nextFbrState) {
+                        fbrConclusion = {
+                            responseText: (0, fbr_1.buildProgrammaticFbrUnreasonableSituationContent)({
+                                language: (0, work_language_1.getWorkLanguage)(),
+                                finalizationAttempts: persistedFbrState.effort,
+                            }),
+                            responseGenseq: lastAssistantSayingGenseq ??
+                                lastFunctionCallGenseq ??
+                                dlg.activeGenSeqOrUndefined ??
+                                1,
+                        };
                         if (!isFbrSubdialogDialog(dlg)) {
                             throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
                         }
-                        await persistDialogFbrState(dlg, nextFbrState);
-                        dlg.setFbrConclusionToolsEnabled((0, fbr_1.isFbrFinalizationState)(nextFbrState));
-                        pendingPrompt = buildKernelDriverFbrPrompt(dlg, nextFbrState);
+                        await persistDialogFbrState(dlg, undefined);
+                        dlg.setFbrConclusionToolsEnabled(false);
+                        break;
+                    }
+                    if (routed.shouldStopAfterReplyTool) {
+                        log_1.log.debug('kernel-driver stop round after explicit replyTellask* tool', undefined, {
+                            dialogId: dlg.id.valueOf(),
+                            toolNames: streamedFuncCalls
+                                .filter((call) => call.name === 'replyTellask' ||
+                                call.name === 'replyTellaskSessionless' ||
+                                call.name === 'replyTellaskBack')
+                                .map((call) => call.name),
+                        });
+                        break;
+                    }
+                    if (dlg.hasUpNext()) {
+                        pendingPrompt = resolveUpNextPrompt(dlg);
                         continue;
                     }
-                    fbrConclusion = {
-                        responseText: (0, fbr_1.buildProgrammaticFbrUnreasonableSituationContent)({
-                            language: (0, work_language_1.getWorkLanguage)(),
-                            finalizationAttempts: persistedFbrState.effort,
-                        }),
-                        responseGenseq: lastAssistantSayingGenseq ??
-                            lastFunctionCallGenseq ??
-                            dlg.activeGenSeqOrUndefined ??
-                            1,
-                    };
-                    if (!isFbrSubdialogDialog(dlg)) {
-                        throw new Error(`kernel-driver FBR invariant violation: persisted FBR state on non-FBR dialog (${dlg.id.valueOf()})`);
+                    if (dlg.remindersVer > pubRemindersVer) {
+                        await dlg.processReminderUpdates();
+                        pubRemindersVer = dlg.remindersVer;
                     }
-                    await persistDialogFbrState(dlg, undefined);
-                    dlg.setFbrConclusionToolsEnabled(false);
-                    break;
-                }
-                if (routed.shouldStopAfterReplyTool) {
-                    log_1.log.debug('kernel-driver stop round after explicit replyTellask* tool', undefined, {
-                        dialogId: dlg.id.valueOf(),
-                        toolNames: streamedFuncCalls
-                            .filter((call) => call.name === 'replyTellask' ||
-                            call.name === 'replyTellaskSessionless' ||
-                            call.name === 'replyTellaskBack')
-                            .map((call) => call.name),
-                    });
-                    break;
-                }
-                if (dlg.hasUpNext()) {
-                    pendingPrompt = resolveUpNextPrompt(dlg);
-                    continue;
-                }
-                if (dlg.remindersVer > pubRemindersVer) {
-                    await dlg.processReminderUpdates();
-                    pubRemindersVer = dlg.remindersVer;
-                }
-                // Tool execution may have created pending Q4H/subdialogs mid-round. Respect the
-                // dialog's actual suspension state here so auto-continue is decided in one place.
-                const suspensionAfterToolRound = await dlg.getSuspensionStatus({
-                    allowPendingSubdialogs: routed.hasImmediateFollowupToolCalls,
-                });
-                if (!suspensionAfterToolRound.canDrive) {
-                    await resetDiligenceBudgetAfterQ4H(dlg, team);
-                    break;
-                }
-                if (consecutiveIdenticalUpdatePlanOnlyRounds >=
-                    KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD) {
-                    const detail = formatIdenticalUpdatePlanLoopStopDetail((0, work_language_1.getWorkLanguage)());
-                    log_1.log.error(detail, new Error('kernel_driver_identical_update_plan_loop_stopped'), {
-                        dialogId: dlg.id.valueOf(),
-                        rootId: dlg.id.rootId,
-                        selfId: dlg.id.selfId,
-                        course: dlg.currentCourse,
-                        genseq: dlg.activeGenSeqOrUndefined ?? null,
-                        consecutiveIdenticalUpdatePlanOnlyRounds,
-                        identicalUpdatePlanRoundSignature,
-                    });
-                    throw new KernelDriverInterruptedError({ kind: 'system_stop', detail });
-                }
-                // Start an immediate post-tool generation only when this round produced tool outputs that
-                // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
-                // meaningful output, but they are not transcript/context inputs and therefore must not
-                // trigger another immediate generation round by themselves.
-                const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls || routed.tellaskToolOutputs.length > 0;
-                if (!shouldStartImmediatePostToolGeneration) {
-                    const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
-                        dlg,
-                        providerCfg,
-                        model,
+                    // Tool execution may have created pending Q4H/subdialogs mid-round. Respect the
+                    // dialog's actual suspension state here so auto-continue is decided in one place.
+                    const suspensionAfterToolRound = await dlg.getSuspensionStatus({
+                        allowPendingSubdialogs: routed.hasImmediateFollowupToolCalls,
                     });
-                    if (healthFirst.kind === 'health_continue') {
-                        pendingPrompt = healthFirst.prompt;
-                        if (healthFirst.resetTaskdoc) {
-                            skipTaskdocForThisDrive = false;
-                        }
-                        continue;
+                    if (!suspensionAfterToolRound.canDrive) {
+                        await resetDiligenceBudgetAfterQ4H(dlg, team);
+                        break;
+                    }
+                    if (consecutiveIdenticalUpdatePlanOnlyRounds >=
+                        KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD) {
+                        const detail = formatIdenticalUpdatePlanLoopStopDetail((0, work_language_1.getWorkLanguage)());
+                        log_1.log.error(detail, new Error('kernel_driver_identical_update_plan_loop_stopped'), {
+                            dialogId: dlg.id.valueOf(),
+                            rootId: dlg.id.rootId,
+                            selfId: dlg.id.selfId,
+                            course: dlg.currentCourse,
+                            genseq: dlg.activeGenSeqOrUndefined ?? null,
+                            consecutiveIdenticalUpdatePlanOnlyRounds,
+                            identicalUpdatePlanRoundSignature,
+                        });
+                        throw new KernelDriverInterruptedError({
+                            kind: 'system_stop',
+                            detail,
+                            i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                detail,
+                                kind: 'identical_update_plan_loop',
+                            }),
+                        });
                     }
-                    if (healthFirst.kind === 'health_suspend') {
+                    // Start an immediate post-tool generation only when this round produced tool outputs that
+                    // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
+                    // meaningful output, but they are not transcript/context inputs and therefore must not
+                    // trigger another immediate generation round by themselves.
+                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls || routed.tellaskToolOutputs.length > 0;
+                    if (!shouldStartImmediatePostToolGeneration) {
+                        const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
+                            dlg,
+                            providerCfg,
+                            model,
+                        });
+                        if (healthFirst.kind === 'health_continue') {
+                            pendingPrompt = healthFirst.prompt;
+                            if (healthFirst.resetTaskdoc) {
+                                skipTaskdocForThisDrive = false;
+                            }
+                            continue;
+                        }
+                        if (healthFirst.kind === 'health_suspend') {
+                            break;
+                        }
+                        const next = await maybeContinueWithDiligencePrompt({
+                            dlg,
+                            team,
+                            suppressDiligencePushForDrive: suppressDiligencePushForDrive,
+                        });
+                        if (next.kind === 'continue') {
+                            pendingPrompt = next.prompt;
+                            continue;
+                        }
                         break;
                     }
-                    const next = await maybeContinueWithDiligencePrompt({
-                        dlg,
-                        team,
-                        suppressDiligencePushForDrive: suppressDiligencePushForDrive,
-                    });
-                    if (next.kind === 'continue') {
-                        pendingPrompt = next.prompt;
+                    if (shouldStartImmediatePostToolGeneration) {
                         continue;
                     }
-                    break;
                 }
-                if (shouldStartImmediatePostToolGeneration) {
-                    continue;
+                finally {
+                    await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
                 }
             }
-            finally {
-                await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
-            }
-        }
-        throwIfAborted(abortSignal, dlg);
-        finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
-    }
-    catch (err) {
-        const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(dlg.id);
-        const interruptedReason = err instanceof runtime_1.LlmRetryStoppedError
-            ? err.reason
-            : err instanceof KernelDriverInterruptedError
-                ? err.reason
-                : abortSignal.aborted
-                    ? stopRequested === 'emergency_stop'
-                        ? { kind: 'emergency_stop' }
-                        : stopRequested === 'user_stop'
-                            ? { kind: 'user_stop' }
-                            : { kind: 'system_stop', detail: 'Aborted.' }
-                    : undefined;
-        if (interruptedReason) {
-            finalDisplayState = {
-                kind: 'stopped',
-                reason: interruptedReason,
-                continueEnabled: resolveStoppedContinueEnabled(interruptedReason),
-            };
-            (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
+            throwIfAborted(abortSignal, dlg);
+            finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
+            break driveCoreLoop;
         }
-        else {
-            const errText = (0, log_1.extractErrorDetails)(err).message;
-            try {
-                await dlg.streamError(errText);
-            }
-            catch {
-                // best-effort
+        catch (err) {
+            if (err instanceof runtime_1.LlmRetryStoppedError && retryStoppedRecoveryPrompt !== undefined) {
+                pendingPrompt = retryStoppedRecoveryPrompt;
+                retryStoppedRecoveryPrompt = undefined;
+                continue driveCoreLoop;
             }
-            finalDisplayState = {
-                kind: 'stopped',
-                reason: { kind: 'system_stop', detail: errText },
-                continueEnabled: true,
-            };
-            (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, {
-                kind: 'interrupted',
-                reason: { kind: 'system_stop', detail: errText },
-            });
-        }
-    }
-    finally {
-        if (!finalDisplayState) {
-            try {
-                finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
+            retryStoppedRecoveryPrompt = undefined;
+            const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(dlg.id);
+            const interruptedReason = err instanceof runtime_1.LlmRetryStoppedError
+                ? err.reason
+                : err instanceof KernelDriverInterruptedError
+                    ? err.reason
+                    : abortSignal.aborted
+                        ? stopRequested === 'emergency_stop'
+                            ? { kind: 'emergency_stop' }
+                            : stopRequested === 'user_stop'
+                                ? { kind: 'user_stop' }
+                                : buildAbortedSystemStopReason()
+                        : undefined;
+            if (interruptedReason) {
+                finalDisplayState = {
+                    kind: 'stopped',
+                    reason: interruptedReason,
+                    continueEnabled: resolveStoppedContinueEnabled(interruptedReason),
+                };
+                (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
             }
-            catch (stateErr) {
-                log_1.log.warn('kernel-driver failed to compute final display-state projection; falling back to idle', stateErr, {
-                    dialogId: dlg.id.valueOf(),
+            else {
+                const llmRequestFailure = err instanceof runtime_1.LlmRequestFailedError ? err : undefined;
+                const emittedStreamError = err instanceof gen_1.LlmStreamErrorEmittedError ? err : undefined;
+                const errText = llmRequestFailure?.detail ??
+                    emittedStreamError?.detail ??
+                    (0, log_1.extractErrorDetails)(err).message;
+                if (!llmRequestFailure?.streamErrorEmitted && !emittedStreamError) {
+                    try {
+                        await dlg.streamError(errText);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                finalDisplayState = {
+                    kind: 'stopped',
+                    reason: (llmRequestFailure?.i18nStopReason ?? emittedStreamError?.i18nStopReason) !== undefined
+                        ? {
+                            kind: 'system_stop',
+                            detail: errText,
+                            i18nStopReason: llmRequestFailure?.i18nStopReason ??
+                                emittedStreamError?.i18nStopReason ??
+                                (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({ detail: errText }),
+                        }
+                        : {
+                            kind: 'system_stop',
+                            detail: errText,
+                            i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({ detail: errText }),
+                        },
+                    continueEnabled: true,
+                };
+                (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, {
+                    kind: 'interrupted',
+                    reason: (llmRequestFailure?.i18nStopReason ?? emittedStreamError?.i18nStopReason) !== undefined
+                        ? {
+                            kind: 'system_stop',
+                            detail: errText,
+                            i18nStopReason: llmRequestFailure?.i18nStopReason ??
+                                emittedStreamError?.i18nStopReason ??
+                                (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({ detail: errText }),
+                        }
+                        : {
+                            kind: 'system_stop',
+                            detail: errText,
+                            i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({ detail: errText }),
+                        },
                 });
-                finalDisplayState = { kind: 'idle_waiting_user' };
             }
+            break driveCoreLoop;
         }
-        if (abortSignal.aborted &&
-            finalDisplayState.kind !== 'stopped' &&
-            finalDisplayState.kind !== 'dead') {
-            const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(dlg.id);
-            const lateInterruptedReason = stopRequested === 'emergency_stop'
-                ? { kind: 'emergency_stop' }
-                : stopRequested === 'user_stop'
-                    ? { kind: 'user_stop' }
-                    : { kind: 'system_stop', detail: 'Aborted.' };
-            finalDisplayState = {
-                kind: 'stopped',
-                reason: lateInterruptedReason,
-                continueEnabled: resolveStoppedContinueEnabled(lateInterruptedReason),
-            };
-            (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, { kind: 'interrupted', reason: lateInterruptedReason });
-        }
+    }
+    if (!finalDisplayState) {
         try {
-            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
-            if (dlg.id.selfId !== dlg.id.rootId && latest?.executionMarker?.kind === 'dead') {
-                finalDisplayState = { kind: 'dead', reason: latest.executionMarker.reason };
-            }
+            finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
         }
-        catch (err) {
-            log_1.log.warn('kernel-driver failed to re-check displayState before finalizing', err, {
+        catch (stateErr) {
+            log_1.log.warn('kernel-driver failed to compute final display-state projection; falling back to idle', stateErr, {
                 dialogId: dlg.id.valueOf(),
             });
+            finalDisplayState = { kind: 'idle_waiting_user' };
         }
-        if (finalDisplayState.kind === 'stopped') {
-            await (0, dialog_display_state_1.setDialogExecutionMarker)(dlg.id, {
-                kind: 'interrupted',
-                reason: finalDisplayState.reason,
-            });
-        }
-        else if (finalDisplayState.kind !== 'dead') {
-            await (0, dialog_display_state_1.clearDialogInterruptedExecutionMarker)(dlg.id);
+    }
+    if (abortSignal.aborted &&
+        finalDisplayState.kind !== 'stopped' &&
+        finalDisplayState.kind !== 'dead') {
+        const stopRequested = (0, dialog_display_state_1.getStopRequestedReason)(dlg.id);
+        const lateInterruptedReason = stopRequested === 'emergency_stop'
+            ? { kind: 'emergency_stop' }
+            : stopRequested === 'user_stop'
+                ? { kind: 'user_stop' }
+                : buildAbortedSystemStopReason();
+        finalDisplayState = {
+            kind: 'stopped',
+            reason: lateInterruptedReason,
+            continueEnabled: resolveStoppedContinueEnabled(lateInterruptedReason),
+        };
+        (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, { kind: 'interrupted', reason: lateInterruptedReason });
+    }
+    try {
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
+        if (dlg.id.selfId !== dlg.id.rootId && latest?.executionMarker?.kind === 'dead') {
+            finalDisplayState = { kind: 'dead', reason: latest.executionMarker.reason };
         }
-        await (0, dialog_display_state_1.setDialogDisplayState)(dlg.id, finalDisplayState);
     }
+    catch (err) {
+        log_1.log.warn('kernel-driver failed to re-check displayState before finalizing', err, {
+            dialogId: dlg.id.valueOf(),
+        });
+    }
+    if (finalDisplayState.kind === 'stopped') {
+        await (0, dialog_display_state_1.setDialogExecutionMarker)(dlg.id, {
+            kind: 'interrupted',
+            reason: finalDisplayState.reason,
+        });
+    }
+    else if (finalDisplayState.kind !== 'dead') {
+        await (0, dialog_display_state_1.clearDialogInterruptedExecutionMarker)(dlg.id);
+    }
+    await (0, dialog_display_state_1.setDialogDisplayState)(dlg.id, finalDisplayState);
     return {
         lastAssistantSayingContent,
         lastAssistantSayingGenseq,