dominds 1.23.1 → 1.23.3

package/dist/llm/defaults.yaml

@@ -14,6 +14,9 @@
 #   `500 auth_unavailable: no auth available` infrastructure failures.
 #   `apiQuirks: same-context-empty-response` detects repeated empty responses in the same
 #   dialog generation context and stops same-context retry loops with a deadlock-break prompt.
+#   `apiQuirks: volcengine-invalid-parameter-aggressive-retry` classifies Volcano Ark Coding Plan
+#   transient `400 InvalidParameter` failures as aggressive retry when the shape matches that
+#   provider's replay-successful instability.
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload
 #   before Dominds projects it into the provider request. Use this when a provider/gateway enforces
 #   a stricter per-item string limit than Dominds' built-in defaults.
@@ -484,6 +487,7 @@ providers:
     models:
       kimi-for-coding:
         name: Kimi For Coding
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: true
         supports_tool_choice: false
@@ -497,6 +501,7 @@ providers:
     apiType: openai-compatible
     apiQuirks:
       - same-context-empty-response
+      - volcengine-invalid-parameter-aggressive-retry
     baseUrl: https://ark.cn-beijing.volces.com/api/coding/v3
     apiKeyEnvVar: ARK_API_KEY
     tech_spec_url: https://www.volcengine.com/docs/82379/1928261
@@ -603,6 +608,7 @@ providers:
         context_window: '128K'
       kimi-k2.6:
         name: Kimi-K2.6
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: true
         supports_tool_choice: false
@@ -613,6 +619,7 @@ providers:
         context_window: '200K'
       kimi-k2.5:
         name: Kimi-K2.5
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: false
         supports_tool_choice: false

package/dist/llm/gen/mock.js

@@ -66,13 +66,11 @@ const log_1 = require("../../log");
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const gen_1 = require("../gen");
 const stop_reason_i18n_1 = require("../stop-reason-i18n");
-const REPLY_TOOL_REMINDER_PREFIXES = [
-    '[Dominds replyTellask required]',
-    '[Dominds 必须调用回复工具]',
-];
 const RUNTIME_PROMPT_WRAPPER_PREFIXES = [
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN,
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH,
+    reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_EN,
+    reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_ZH,
     reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
     reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
     reply_prompt_copy_1.REPLY_SUPPRESSION_PREFIX_EN,
@@ -277,8 +275,7 @@ class MockGen {
         return null;
     }
     buildReplyToolReminderAutoResponse(input, role, context) {
-        if (role !== 'user' ||
-            !REPLY_TOOL_REMINDER_PREFIXES.some((prefix) => input.startsWith(prefix))) {
+        if (role !== 'user' || !(0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(input)) {
             return null;
         }
         const toolMatch = input.match(/`(replyTellask(?:Sessionless|Back)?)`/);
@@ -382,10 +379,14 @@ responses:
         const matched = this.findMatchingResponse(db, content, role, context) ??
             this.buildReplyToolReminderAutoResponse(content, role, context);
         await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
-        await receiver.thinkingStart();
-        await receiver.thinkingChunk(`[${modelName}] `);
-        await receiver.thinkingChunk(content.substring(0, 50) || '(empty)');
-        await receiver.thinkingFinish();
+        const thinkingText = matched?.omitDefaultThinking === true
+            ? (matched.thinkingResponse ?? '')
+            : (matched?.thinkingResponse ?? `[${modelName}] ${content.substring(0, 50) || '(empty)'}`);
+        if (thinkingText !== '') {
+            await receiver.thinkingStart();
+            await receiver.thinkingChunk(thinkingText);
+            await receiver.thinkingFinish();
+        }
         if (matched?.streamError) {
             if (matched.emitStreamErrorBeforeThrow && receiver.streamError) {
                 await receiver.streamError(matched.streamError);
@@ -491,12 +492,17 @@ responses:
                 this.buildReplyToolReminderAutoResponse(content, role, context);
             await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
             const responseText = matched?.response ?? this.makeFallbackResponse(dbPath, content, role, modelName);
-            const thinking = {
-                type: 'thinking_msg',
-                role: 'assistant',
-                genseq,
-                content: `[${modelName}] ${content.substring(0, 100)}`,
-            };
+            const thinkingText = matched?.omitDefaultThinking === true
+                ? (matched.thinkingResponse ?? '')
+                : (matched?.thinkingResponse ?? `[${modelName}] ${content.substring(0, 100)}`);
+            const thinking = thinkingText === ''
+                ? undefined
+                : {
+                    type: 'thinking_msg',
+                    role: 'assistant',
+                    genseq,
+                    content: thinkingText,
+                };
             const saying = matched?.streamError || responseText !== ''
                 ? {
                     type: 'saying_msg',
@@ -570,7 +576,13 @@ responses:
                 };
             }) ?? [];
             return {
-                messages: saying ? [thinking, saying, ...funcMsgs] : [thinking, ...funcMsgs],
+                messages: thinking !== undefined
+                    ? saying
+                        ? [thinking, saying, ...funcMsgs]
+                        : [thinking, ...funcMsgs]
+                    : saying
+                        ? [saying, ...funcMsgs]
+                        : [...funcMsgs],
                 usage,
                 llmGenModel: modelName,
             };

package/dist/llm/gen/openai-compatible.js

@@ -48,7 +48,6 @@ const OPENAI_COMPATIBLE_REJECTED_REQUEST_ERROR_CODE = 'OPENAI_COMPATIBLE_REJECTE
 const KIMI_CODE_API_QUIRK = 'kimi-code';
 const KIMI_CODE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
 const KIMI_CLI_CLOAK_API_QUIRK = 'kimi-cli-cloak';
-const KIMI_CLI_USER_AGENT = 'KimiCLI/1.41.0';
 const DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK = 'disable-assistant-tool-call-reasoning-content';
 const JSON_SCHEMA_COMBINATOR_KEYS = new Set([
     'anyOf',
@@ -578,7 +577,7 @@ function createOpenAiCompatibleClient(args) {
     };
     if (isKimiCliCloakProvider(args.providerConfig)) {
         options.defaultHeaders = {
-            'User-Agent': KIMI_CLI_USER_AGENT,
+            'User-Agent': `KimiCLI/Dominds/${dominds_running_version_1.DOMINDS_RUNNING_VERSION}`,
         };
     }
     else if (isKimiCodeProvider(args.providerConfig)) {

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

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

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

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

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

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

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

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

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

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