dominds 1.27.1 → 1.27.3

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

@@ -46,6 +46,7 @@ const KERNEL_DRIVER_DEFAULT_RETRY_POLICY = {
     backoffMultiplier: 1.5,
     maxDelayMs: 30 * 60 * 1000, // 30 minutes
 };
+const CLEAR_MIND_TOOL_NAME = 'clear_mind';
 const KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
 // Wrapper isolation boundary:
 // - Wrappers emit provider-native web-search events.
@@ -246,6 +247,35 @@ function buildKernelDriverFbrPrompt(dlg, state) {
         origin: 'runtime',
     };
 }
+function resolveLatestModelOutputGenseq(dlg) {
+    for (let index = dlg.msgs.length - 1; index >= 0; index -= 1) {
+        const msg = dlg.msgs[index];
+        if (msg === undefined) {
+            continue;
+        }
+        switch (msg.type) {
+            case 'saying_msg':
+            case 'thinking_msg':
+            case 'func_call_msg': {
+                const genseq = Math.floor(msg.genseq);
+                if (Number.isFinite(genseq) && genseq > 0) {
+                    return genseq;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return undefined;
+}
+function resolveProgrammaticFbrConclusionGenseq(args) {
+    return (args.lastAssistantSayingGenseq ??
+        args.lastFunctionCallGenseq ??
+        resolveLatestModelOutputGenseq(args.dlg) ??
+        args.dlg.activeGenSeqOrUndefined ??
+        1);
+}
 function normalizeQ4HAnswerCallId(raw) {
     if (typeof raw !== 'string')
         return undefined;
@@ -750,7 +780,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
                 '1. 把需要回传给主线对话的结论、证据定位和风险整理清楚。',
                 '2. 对于下一程恢复工作需要的信息，写入提醒项。',
                 '',
-                '然后尽快完成当前支线回复；如果你有 clear_mind({})，再调用它开启新一程。',
+                '然后调用 clear_mind({}) 开启新一程，并尽快完成当前支线回复。',
                 '',
                 `详情：本次返回约 ${approxBytes} 字节。`,
             ].join('\n');
@@ -775,7 +805,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
             '1. Organize the conclusions, evidence pointers, and risks that need to go back to the Mainline dialog.',
             '2. Write any details needed to resume the next course into reminders.',
             '',
-            'Then finish the current Sideline dialog reply as soon as possible; if you have clear_mind({}), call it to start a new course.',
+            'Then call clear_mind({}) to start a new course, and finish the current Sideline dialog reply as soon as possible.',
             '',
             `Detail: this return was about ${approxBytes} bytes.`,
         ].join('\n');
@@ -814,6 +844,9 @@ function countToolResultVisibleBytes(output) {
     return bytes;
 }
 function applyContextHealthToolResultVisibilityLimit(args) {
+    if (isFbrSideDialog(args.dlg)) {
+        return { output: args.output, largeReturnUnavailable: false };
+    }
     if ((0, context_health_1.getContextHealthRemediationLevel)(args.contextHealth) === undefined) {
         return { output: args.output, largeReturnUnavailable: false };
     }
@@ -1381,6 +1414,161 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
         .filter((line) => line.length > 0)
         .join('\n');
 }
+function stableJsonStringify(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJsonStringify(entry)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableJsonStringify(record[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(String(value));
+}
+function canonicalizeToolCallArguments(rawArguments) {
+    try {
+        return stableJsonStringify(JSON.parse(rawArguments));
+    }
+    catch {
+        return rawArguments;
+    }
+}
+function canonicalizeToolResult(result) {
+    return stableJsonStringify({
+        content: result.content,
+        contentItems: result.contentItems ?? null,
+    });
+}
+function buildToolResultFingerprint(call, result) {
+    return {
+        toolName: call.name,
+        argumentsFingerprint: canonicalizeToolCallArguments(call.arguments),
+        resultFingerprint: canonicalizeToolResult(result),
+    };
+}
+function sameToolResultFingerprint(left, right) {
+    return (left.toolName === right.toolName &&
+        left.argumentsFingerprint === right.argumentsFingerprint &&
+        left.resultFingerprint === right.resultFingerprint);
+}
+function formatRepeatedToolCallRuntimeGuide(args) {
+    const resultPreview = args.resultContent.length > 800
+        ? `${args.resultContent.slice(0, 800)}\n...`
+        : args.resultContent;
+    if (args.language === 'en') {
+        return [
+            '[Runtime notice] You have just made the same tool call three times, with identical arguments, and Dominds observed the exact same tool result each time.',
+            '',
+            `- tool: ${args.toolName}`,
+            `- callIds: ${args.callIds.join(', ')}`,
+            '- arguments:',
+            '```json',
+            args.argumentsFingerprint,
+            '```',
+            '- repeated result:',
+            '```text',
+            resultPreview,
+            '```',
+            '',
+            'Question this behavior before calling tools again. The repeated result strongly suggests the same call will not produce new information. Re-read the user request and the tool result, then correct course: answer from the available information, choose a different action, or explain what is blocked.',
+        ].join('\n');
+    }
+    return [
+        '[Dominds 提示] 你刚才连续三次调用了同一个工具，参数完全相同，Dominds 观察到三次工具返回值也完全相同。',
+        '',
+        `- 工具: ${args.toolName}`,
+        `- callIds: ${args.callIds.join(', ')}`,
+        '- 参数:',
+        '```json',
+        args.argumentsFingerprint,
+        '```',
+        '- 重复返回值:',
+        '```text',
+        resultPreview,
+        '```',
+        '',
+        '请先质疑这个行为，不要机械地再次调用同一个工具。同样的调用大概率不会产生新信息。请重新阅读用户诉求和工具返回值，然后自行纠正：基于已有信息作答、换一种行动，或明确说明当前阻塞点。',
+    ].join('\n');
+}
+function formatRepeatedToolCallStoppedDetail(args) {
+    if (args.language === 'en') {
+        return (`Stopped because the LLM ignored Dominds' repeated-tool-call correction notice and again made ` +
+            `the same tool call three times with identical results. This indicates an LLM behavior/personality problem: ` +
+            `it is looping on ${args.toolName} instead of reconsidering the task. callIds=${args.callIds.join(', ')}`);
+    }
+    return (`已停止：LLM 已收到 Dominds 的重复工具调用纠正提醒，但仍然再次连续三次调用同一个工具并得到完全相同的结果。` +
+        `这说明当前 LLM 存在行为/个性问题：它在 ${args.toolName} 上机械循环，而不是重新判断任务。` +
+        `callIds=${args.callIds.join(', ')}`);
+}
+const REPEATED_TOOL_CALL_STOP_WINDOW_GENSEQS = 5;
+function inspectRepeatedToolCallRound(args) {
+    ensureRepeatedToolCallMonitorCourse(args.state, args.currentCourse);
+    const recentPairs = [];
+    for (let index = 0; index < args.pairedMessages.length - 1; index += 1) {
+        const call = args.pairedMessages[index];
+        const result = args.pairedMessages[index + 1];
+        if (call?.type !== 'func_call_msg' || result?.type !== 'func_result_msg') {
+            continue;
+        }
+        if (result.id !== call.id) {
+            continue;
+        }
+        recentPairs.push({
+            call,
+            result,
+            fingerprint: buildToolResultFingerprint(call, result),
+        });
+    }
+    for (const pair of recentPairs) {
+        const currentSequence = args.state.sequence;
+        if (currentSequence !== undefined &&
+            sameToolResultFingerprint(currentSequence.fingerprint, pair.fingerprint)) {
+            currentSequence.callIds.push(pair.call.id);
+            if (currentSequence.callIds.length > 3) {
+                currentSequence.callIds.splice(0, currentSequence.callIds.length - 3);
+            }
+            currentSequence.resultContent = pair.result.content;
+        }
+        else {
+            args.state.sequence = {
+                fingerprint: pair.fingerprint,
+                callIds: [pair.call.id],
+                resultContent: pair.result.content,
+            };
+        }
+        const sequence = args.state.sequence;
+        if (sequence === undefined || sequence.callIds.length < 3) {
+            continue;
+        }
+        const recentReminder = args.state.lastReminderGenseq !== undefined &&
+            pair.call.genseq > args.state.lastReminderGenseq &&
+            pair.call.genseq - args.state.lastReminderGenseq <= REPEATED_TOOL_CALL_STOP_WINDOW_GENSEQS;
+        const callIds = [...sequence.callIds];
+        return {
+            toolName: pair.call.name,
+            callIds,
+            argumentsFingerprint: pair.fingerprint.argumentsFingerprint,
+            resultContent: sequence.resultContent,
+            reminderContent: formatRepeatedToolCallRuntimeGuide({
+                language: args.language,
+                toolName: pair.call.name,
+                callIds,
+                argumentsFingerprint: pair.fingerprint.argumentsFingerprint,
+                resultContent: sequence.resultContent,
+            }),
+            repeatedAfterReminder: recentReminder,
+        };
+    }
+    return undefined;
+}
 async function persistInvalidFuncCallRuntimeGuide(args) {
     const { dlg, call } = args;
     const sourceText = args.source === 'streamed' ? 'streamed' : 'batch';
@@ -1405,6 +1593,17 @@ async function persistInvalidFuncCallRuntimeGuide(args) {
     });
     await persistAndPostRuntimeGuide(dlg, content);
 }
+function resetRepeatedToolCallMonitor(state) {
+    state.sequence = undefined;
+    state.lastReminderGenseq = undefined;
+}
+function ensureRepeatedToolCallMonitorCourse(state, course) {
+    if (state.course === course) {
+        return;
+    }
+    resetRepeatedToolCallMonitor(state);
+    state.course = course;
+}
 function isQueuedNewCourseRuntimePrompt(prompt) {
     return (prompt?.kind === 'new_course_runtime_guide' ||
         prompt?.kind === 'new_course_runtime_reply' ||
@@ -1458,6 +1657,7 @@ function summarizeRoutedFunctionResult(routed) {
         immediateFollowupCallIds: routed.immediateFollowupCallIds,
         immediateTellaskOutputCallIds: routed.immediateTellaskOutputCallIds,
         invalidTellaskCallIds: routed.invalidTellaskCallIds,
+        repeatedToolCallReminderCallIds: routed.repeatedToolCallReminderCallIds,
         shouldStopAfterReplyTool: routed.shouldStopAfterReplyTool,
         shouldStopAfterPendingTellaskWait: routed.shouldStopAfterPendingTellaskWait,
         pairedMessageTypes: routed.pairedMessages.map((msg) => msg.type),
@@ -1511,6 +1711,8 @@ function shouldCaptureUnexpectedIdleAfterToolRound(args) {
         return true;
     if (diagnostics.routed.immediateTellaskOutputCallIds.length > 0)
         return true;
+    if (diagnostics.routed.repeatedToolCallReminderCallIds.length > 0)
+        return true;
     return false;
 }
 function sanitizeDebugFileSegment(value) {
@@ -1694,6 +1896,12 @@ function buildImmediateFollowupTriggerExpectation(args) {
             callIds: [...invalidRecoveryCallIds],
         });
     }
+    if (args.routed.repeatedToolCallReminderCallIds.length > 0) {
+        reasons.push({
+            kind: 'repeated_tool_call_reminder',
+            callIds: args.routed.repeatedToolCallReminderCallIds,
+        });
+    }
     if (reasons.length === 0) {
         return undefined;
     }
@@ -1786,6 +1994,30 @@ function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
     }
     return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
 }
+function isFailedToolOutcome(outcome) {
+    return outcome === 'failure' || outcome === 'partial_failure';
+}
+function formatClearMindBlockedByFailedSiblingTools(failedTools) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const details = failedTools
+        .map((tool) => `- ${tool.toolName} (callId=${tool.callId}, outcome=${String(tool.outcome)})`)
+        .join('\n');
+    return language === 'zh'
+        ? [
+            '错误：本轮 clear_mind 与其它工具一起调用，但其它工具返回了失败结果。',
+            '',
+            details,
+            '',
+            'clear_mind 已拒绝开启新一程。请先确保其它工具调用正常完成（必要时修正参数、重试或处理失败），然后再次调用 clear_mind。',
+        ].join('\n')
+        : [
+            'Error: clear_mind was called in the same round as other tools, and at least one other tool returned a failure result.',
+            '',
+            details,
+            '',
+            'clear_mind refused to start a new course. Ensure the other tool calls complete normally first (fix arguments, retry, or handle the failure), then call clear_mind again.',
+        ].join('\n');
+}
 function trimOptionalCallId(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -1958,7 +2190,7 @@ async function executeFunctionCalls(args) {
         throwIfAborted(args.abortSignal, args.dlg);
         await args.dlg.persistFunctionCall(prepared.func.id, prepared.func.name, prepared.argsStr, prepared.callGenseq, prepared.func.rawId);
     }
-    const functionPromises = preparedCalls.map(async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
+    const executePreparedCall = async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
         let result;
         let outcome = 'success';
         let forceImmediateFollowup = false;
@@ -2051,8 +2283,54 @@ async function executeFunctionCalls(args) {
             throw rethrowError;
         }
         return { func, originalFunc, outcome, forceImmediateFollowup, result };
-    });
-    return await Promise.all(functionPromises);
+    };
+    const blockClearMindCall = async (prepared, failedTools) => {
+        const output = (0, tool_1.toolFailure)(formatClearMindBlockedByFailedSiblingTools(failedTools));
+        const result = {
+            type: 'func_result_msg',
+            id: prepared.func.id,
+            rawId: prepared.func.rawId,
+            effectiveId: prepared.func.effectiveId,
+            name: prepared.func.name,
+            content: output.content,
+            role: 'tool',
+            genseq: prepared.callGenseq,
+        };
+        await args.dlg.receiveFuncResult(result);
+        return {
+            func: prepared.func,
+            originalFunc: prepared.originalFunc,
+            outcome: output.outcome,
+            forceImmediateFollowup: false,
+            result,
+        };
+    };
+    const clearMindCalls = preparedCalls.filter((call) => call.func.name === CLEAR_MIND_TOOL_NAME);
+    const siblingCalls = preparedCalls.filter((call) => call.func.name !== CLEAR_MIND_TOOL_NAME);
+    const failedPriorToolResults = args.failedPriorToolResults ?? [];
+    if (clearMindCalls.length === 0 || siblingCalls.length === 0) {
+        if (clearMindCalls.length > 0 && failedPriorToolResults.length > 0) {
+            return await Promise.all(clearMindCalls.map((call) => blockClearMindCall(call, failedPriorToolResults)));
+        }
+        return await Promise.all(preparedCalls.map((call) => executePreparedCall(call)));
+    }
+    const siblingExecutions = await Promise.all(siblingCalls.map((call) => executePreparedCall(call)));
+    const failedSiblingToolResults = [
+        ...failedPriorToolResults,
+        ...siblingExecutions
+            .filter((execution) => isFailedToolOutcome(execution.outcome))
+            .map((execution) => ({
+            callId: execution.result.id,
+            toolName: execution.result.name,
+            outcome: execution.outcome,
+        })),
+    ];
+    if (failedSiblingToolResults.length > 0) {
+        const clearMindExecutions = await Promise.all(clearMindCalls.map((call) => blockClearMindCall(call, failedSiblingToolResults)));
+        return [...siblingExecutions, ...clearMindExecutions];
+    }
+    const clearMindExecutions = await Promise.all(clearMindCalls.map((call) => executePreparedCall(call)));
+    return [...siblingExecutions, ...clearMindExecutions];
 }
 async function executeFunctionRound(args) {
     if (args.funcCalls.length === 0) {
@@ -2062,6 +2340,7 @@ async function executeFunctionRound(args) {
             immediateFollowupCallIds: [],
             immediateTellaskOutputCallIds: [],
             invalidTellaskCallIds: [],
+            repeatedToolCallReminderCallIds: [],
             shouldStopAfterReplyTool: false,
             shouldStopAfterPendingTellaskWait: false,
             pairedMessages: [],
@@ -2094,6 +2373,17 @@ async function executeFunctionRound(args) {
         activePromptReplyDirective: args.activePromptReplyDirective,
     });
     throwIfAborted(args.abortSignal, args.dlg);
+    const failedTellaskToolResults = tellaskRound.invalidTellaskCallIds.map((callId) => {
+        const call = args.funcCalls.find((candidate) => candidate.id === callId);
+        if (call === undefined) {
+            throw new Error(`kernel-driver tellask result invariant violation: missing invalid tellask call '${callId}'`);
+        }
+        return {
+            callId,
+            toolName: call.name,
+            outcome: 'failure',
+        };
+    });
     const genericExecutions = await executeFunctionCalls({
         dlg: args.dlg,
         agent: args.agent,
@@ -2101,6 +2391,7 @@ async function executeFunctionRound(args) {
         funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
         contextHealthForToolResultVisibility: args.contextHealthForToolResultVisibility,
+        failedPriorToolResults: failedTellaskToolResults,
     });
     const genericExecutionByOriginalCall = new Map(genericExecutions.map((execution) => [execution.originalFunc, execution]));
     const funcToolByName = new Map(args.agentTools
@@ -2180,6 +2471,7 @@ async function executeFunctionRound(args) {
         immediateFollowupCallIds,
         immediateTellaskOutputCallIds: tellaskRound.immediateTellaskOutputCallIds,
         invalidTellaskCallIds: tellaskRound.invalidTellaskCallIds,
+        repeatedToolCallReminderCallIds: [],
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         shouldStopAfterPendingTellaskWait: tellaskRound.shouldStopAfterPendingTellaskWait,
         pairedMessages,
@@ -2390,6 +2682,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let lastToolRoundStopDiagnostics;
+    const repeatedToolCallMonitor = {};
     let pendingPrompt = humanPrompt;
     let resolvingImmediateToolResultForUserPrompt = false;
     let resolvingImmediateToolResultUserPromptMsgId;
@@ -2424,8 +2717,41 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
             for (;;) {
                 genIterNo += 1;
                 throwIfAborted(abortSignal, dlg);
-                const activeFbrState = await loadDialogFbrState(dlg);
+                let activeFbrState = await loadDialogFbrState(dlg);
                 if (isFbrSideDialog(dlg)) {
+                    const fbrContextHealthLevel = (0, context_health_1.getContextHealthRemediationLevel)(dlg.getLastContextHealth());
+                    if (activeFbrState !== undefined && fbrContextHealthLevel === 'critical') {
+                        log_1.log.warn('kernel-driver ending FBR with critical context fixed conclusion', undefined, {
+                            rootId: dlg.id.rootId,
+                            selfId: dlg.id.selfId,
+                            course: dlg.currentCourse,
+                            phase: activeFbrState.phase,
+                            iteration: activeFbrState.iteration,
+                        });
+                        fbrConclusion = {
+                            responseText: (0, fbr_1.buildProgrammaticFbrContextCriticalContent)({
+                                language: (0, work_language_1.getWorkLanguage)(),
+                            }),
+                            responseGenseq: resolveProgrammaticFbrConclusionGenseq({
+                                dlg,
+                                lastAssistantSayingGenseq,
+                                lastFunctionCallGenseq,
+                            }),
+                            replyResolutionCallId: `fbr-context-critical-${(0, id_1.generateShortId)()}`,
+                        };
+                        await persistDialogFbrState(dlg, undefined);
+                        dlg.setFbrConclusionToolsEnabled(false);
+                        finalDisplayState = await (0, dialog_display_state_1.computeIdleDisplayState)(dlg);
+                        break driveCoreLoop;
+                    }
+                    if (activeFbrState !== undefined &&
+                        fbrContextHealthLevel === 'caution' &&
+                        !(0, fbr_1.isFbrContextCautionFinalizationState)(activeFbrState) &&
+                        (pendingPrompt === undefined || pendingPrompt.origin === 'runtime')) {
+                        activeFbrState = (0, fbr_1.forceFbrContextCautionFinalizationState)(activeFbrState);
+                        await persistDialogFbrState(dlg, activeFbrState);
+                        pendingPrompt = buildKernelDriverFbrPrompt(dlg, activeFbrState);
+                    }
                     dlg.setFbrConclusionToolsEnabled(activeFbrState !== undefined && (0, fbr_1.isFbrFinalizationState)(activeFbrState));
                     if (pendingPrompt === undefined &&
                         activeFbrState &&
@@ -2591,6 +2917,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 let llmGenModelForGen = model;
                 const currentPrompt = pendingPrompt;
                 const currentReplyTarget = currentPrompt?.calleeDialogReplyTarget;
+                if (currentGenerationBelongsToUserPrompt) {
+                    resetRepeatedToolCallMonitor(repeatedToolCallMonitor);
+                }
                 let currentBusinessContinuation = driveOptions?.businessContinuation ?? { kind: 'none' };
                 if (currentPrompt?.tellaskReplyDirective !== undefined) {
                     currentBusinessContinuation = {
@@ -2605,7 +2934,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 let currentRuntimeGuideMsg;
                 const currentPromptFromFbrState = currentPrompt !== undefined &&
                     currentFbrState !== undefined &&
-                    currentFbrState.promptDelivered !== true;
+                    currentFbrState.promptDelivered !== true &&
+                    isFbrSideDialog(dlg) &&
+                    currentPrompt.origin === 'runtime' &&
+                    currentPrompt.content === buildKernelDriverFbrPrompt(dlg, currentFbrState).content;
                 pendingPrompt = undefined;
                 if (currentPrompt) {
                     const diligenceSkipReason = await shouldSkipDiligencePromptBeforeGeneration({
@@ -3472,7 +3804,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : currentGenerationBelongsToUserToolChain
                             ? currentUserPromptMsgId
                             : undefined;
-                    const routed = await executeFunctionRound({
+                    let routed = await executeFunctionRound({
                         dlg,
                         agent,
                         agentTools,
@@ -3518,6 +3850,41 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         newMsgs.push(...routed.pairedMessages);
                     }
                     await dlg.addChatMessages(...newMsgs);
+                    const repeatedToolCallInspection = inspectRepeatedToolCallRound({
+                        state: repeatedToolCallMonitor,
+                        currentCourse: dlg.activeGenCourseOrUndefined ?? dlg.currentCourse,
+                        pairedMessages: routed.pairedMessages,
+                        language: (0, work_language_1.getWorkLanguage)(),
+                    });
+                    if (repeatedToolCallInspection !== undefined) {
+                        if (repeatedToolCallInspection.repeatedAfterReminder) {
+                            const detail = formatRepeatedToolCallStoppedDetail({
+                                language: (0, work_language_1.getWorkLanguage)(),
+                                toolName: repeatedToolCallInspection.toolName,
+                                callIds: repeatedToolCallInspection.callIds,
+                            });
+                            log_1.log.error('kernel-driver stopped after repeated identical tool calls ignored guidance', undefined, {
+                                rootId: dlg.id.rootId,
+                                selfId: dlg.id.selfId,
+                                course: dlg.activeGenCourseOrUndefined ?? dlg.currentCourse,
+                                genseq: dlg.activeGenSeq,
+                                toolName: repeatedToolCallInspection.toolName,
+                                callIds: repeatedToolCallInspection.callIds,
+                            });
+                            await dlg.streamError(detail);
+                            throw new gen_1.LlmStreamErrorEmittedError({
+                                detail,
+                                i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({ detail }),
+                            });
+                        }
+                        await persistAndEmitRuntimeGuide(dlg, repeatedToolCallInspection.reminderContent);
+                        repeatedToolCallMonitor.lastReminderGenseq = dlg.activeGenSeq;
+                        repeatedToolCallMonitor.sequence = undefined;
+                        routed = {
+                            ...routed,
+                            repeatedToolCallReminderCallIds: repeatedToolCallInspection.callIds,
+                        };
+                    }
                     const persistedFbrState = await loadDialogFbrState(dlg);
                     if (persistedFbrState) {
                         if (persistedFbrState.phase === 'finalization') {
@@ -3564,10 +3931,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 language: (0, work_language_1.getWorkLanguage)(),
                                 finalizationAttempts: persistedFbrState.effort,
                             }),
-                            responseGenseq: lastAssistantSayingGenseq ??
-                                lastFunctionCallGenseq ??
-                                dlg.activeGenSeqOrUndefined ??
-                                1,
+                            responseGenseq: resolveProgrammaticFbrConclusionGenseq({
+                                dlg,
+                                lastAssistantSayingGenseq,
+                                lastFunctionCallGenseq,
+                            }),
                             replyResolutionCallId: `fbr-conclusion-${(0, id_1.generateShortId)()}`,
                         };
                         if (!isFbrSideDialog(dlg)) {
@@ -3608,6 +3976,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     // trigger another immediate generation round by themselves.
                     const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls ||
                         routed.hasImmediateTellaskOutputs ||
+                        routed.repeatedToolCallReminderCallIds.length > 0 ||
                         invalidFuncCallCount > 0;
                     if (shouldStartImmediatePostToolGeneration) {
                         const expectation = buildImmediateFollowupTriggerExpectation({
@@ -3622,6 +3991,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 `(dialog=${dlg.id.valueOf()}, course=${String(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse)}, ` +
                                 `genseq=${String(dlg.activeGenSeq)}, immediateToolCalls=${String(routed.hasImmediateFollowupToolCalls)}, ` +
                                 `immediateTellaskOutputs=${String(routed.hasImmediateTellaskOutputs)}, ` +
+                                `repeatedToolCallReminderCallIds=${routed.repeatedToolCallReminderCallIds.join('+')}, ` +
                                 `invalidFuncCallCount=${String(invalidFuncCallCount)})`);
                         }
                         immediateFollowupTriggerExpectation = expectation;

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

@@ -32,6 +32,13 @@ export declare function buildFbrFinalizationPrompt(args: {
     total: number;
     language: LanguageCode;
 }): string;
+export declare function buildFbrContextCautionFinalizationPrompt(args: {
+    attempt: number;
+    language: LanguageCode;
+}): string;
+export declare function buildProgrammaticFbrContextCriticalContent(args: {
+    language: LanguageCode;
+}): string;
 export declare function buildProgrammaticFbrUnreasonableSituationContent(args: {
     language: LanguageCode;
     finalizationAttempts: number;
@@ -40,6 +47,8 @@ export declare function inspectFbrConclusionAttempt(messages: readonly ChatMessa
 export declare function createInitialFbrState(effort: number): DialogFbrState;
 export declare function markFbrPromptDelivered(state: DialogFbrState): DialogFbrState;
 export declare function isFbrFinalizationState(state: DialogFbrState): boolean;
+export declare function isFbrContextCautionFinalizationState(state: DialogFbrState): boolean;
+export declare function forceFbrContextCautionFinalizationState(state: DialogFbrState): DialogFbrState;
 export declare function advanceFbrState(state: DialogFbrState): DialogFbrState | undefined;
 export declare function buildFbrPromptForState(args: {
     state: DialogFbrState;