dominds 1.27.1 → 1.27.2

package/dist/dialog.d.ts

@@ -14,7 +14,7 @@
  */
 import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
 import type { DialogEvent, NativeToolCallPayload, ReminderContent, WebSearchCallAction, WebSearchCallSource } from '@longrun-ai/kernel/types/dialog';
-import type { DialogCalleeReplyTarget, DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
+import type { DialogCalleeReplyTarget, DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogRuntimeSideDialogPrompt, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { ActiveCalleesFile, CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogLatestFile, DialogMetadataFile, DialogNextStepTrigger, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
@@ -130,6 +130,7 @@ export declare function buildSideDialogAskerStack(args: {
     askerDialogId: string;
     assignment: AssignmentFromAsker;
 }): DialogAskerStackState;
+export declare function buildSideDialogAssignmentPromptMeta(sideDialog: SideDialog): Pick<DialogRuntimeSideDialogPrompt, 'tellaskReplyDirective' | 'calleeDialogReplyTarget'>;
 /**
  * Abstract base class for all dialog types.
  * Contains common properties and methods shared between MainDialog and SideDialog.

package/dist/dialog.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DialogStore = exports.MainDialog = exports.SideDialog = exports.Dialog = exports.DialogID = exports.InvalidReminderIndexError = void 0;
 exports.scheduleGlobalDialogMutexCleanupForRoot = scheduleGlobalDialogMutexCleanupForRoot;
 exports.buildSideDialogAskerStack = buildSideDialogAskerStack;
+exports.buildSideDialogAssignmentPromptMeta = buildSideDialogAssignmentPromptMeta;
 const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const util_1 = require("util");

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

@@ -1381,6 +1381,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 +1560,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 +1624,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 +1678,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 +1863,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;
     }
@@ -2062,6 +2237,7 @@ async function executeFunctionRound(args) {
             immediateFollowupCallIds: [],
             immediateTellaskOutputCallIds: [],
             invalidTellaskCallIds: [],
+            repeatedToolCallReminderCallIds: [],
             shouldStopAfterReplyTool: false,
             shouldStopAfterPendingTellaskWait: false,
             pairedMessages: [],
@@ -2180,6 +2356,7 @@ async function executeFunctionRound(args) {
         immediateFollowupCallIds,
         immediateTellaskOutputCallIds: tellaskRound.immediateTellaskOutputCallIds,
         invalidTellaskCallIds: tellaskRound.invalidTellaskCallIds,
+        repeatedToolCallReminderCallIds: [],
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         shouldStopAfterPendingTellaskWait: tellaskRound.shouldStopAfterPendingTellaskWait,
         pairedMessages,
@@ -2390,6 +2567,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;
@@ -2591,6 +2769,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 = {
@@ -3472,7 +3653,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : currentGenerationBelongsToUserToolChain
                             ? currentUserPromptMsgId
                             : undefined;
-                    const routed = await executeFunctionRound({
+                    let routed = await executeFunctionRound({
                         dlg,
                         agent,
                         agentTools,
@@ -3518,6 +3699,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') {
@@ -3608,6 +3824,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 +3839,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/flow.js

@@ -69,12 +69,6 @@ async function queueReplyReminderFollowUp(args) {
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
-function hasSameReplyDirective(left, right) {
-    return (left.expectedReplyCallName === right.expectedReplyCallName &&
-        left.targetDialogId === right.targetDialogId &&
-        left.targetCallId === right.targetCallId &&
-        left.tellaskContent === right.tellaskContent);
-}
 function hasSameCalleeReplyTarget(left, right) {
     return (left.callerDialogId === right.callerDialogId &&
         left.callId === right.callId &&
@@ -82,29 +76,6 @@ function hasSameCalleeReplyTarget(left, right) {
         left.callSiteCourse === right.callSiteCourse &&
         left.callSiteGenseq === right.callSiteGenseq);
 }
-function buildCurrentSideDialogAssignmentReplyDirective(dialog) {
-    switch (dialog.assignmentFromAsker.callName) {
-        case 'tellask':
-            return {
-                expectedReplyCallName: 'replyTellask',
-                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
-                targetCallId: dialog.assignmentFromAsker.callId,
-                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
-            };
-        case 'tellaskSessionless':
-        case 'freshBootsReasoning':
-            return {
-                expectedReplyCallName: 'replyTellaskSessionless',
-                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
-                targetCallId: dialog.assignmentFromAsker.callId,
-                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
-            };
-        default: {
-            const _exhaustive = dialog.assignmentFromAsker.callName;
-            throw new Error(`Unsupported sideDialog assignment callName: ${_exhaustive}`);
-        }
-    }
-}
 function isQueuedReplyObligationContinuation(prompt) {
     return ((prompt.kind === 'new_course_runtime_reply' ||
         prompt.kind === 'new_course_runtime_sideDialog') &&
@@ -151,8 +122,8 @@ async function claimQueuedReplyObligationContinuation(args) {
         return 'stale';
     }
     if (args.dialog instanceof dialog_1.SideDialog) {
-        const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
-        if (hasSameReplyDirective(assignmentDirective, directive)) {
+        const assignmentDirective = (0, dialog_1.buildSideDialogAssignmentPromptMeta)(args.dialog).tellaskReplyDirective;
+        if ((0, reply_guidance_1.hasSameReplyDirective)(assignmentDirective, directive)) {
             return 'claimed';
         }
     }
@@ -163,7 +134,7 @@ async function claimQueuedReplyObligationContinuation(args) {
     if (activeDirective.targetCallId !== directive.targetCallId) {
         return 'stale';
     }
-    if (!hasSameReplyDirective(activeDirective, directive)) {
+    if (!(0, reply_guidance_1.hasSameReplyDirective)(activeDirective, directive)) {
         throw new Error(`reply obligation continuation invariant violation: active obligation changed for callId=${directive.targetCallId} ` +
             `(dialog=${args.dialog.id.valueOf()}, expectedReplyCallName=${directive.expectedReplyCallName}, ` +
             `activeReplyCallName=${activeDirective.expectedReplyCallName}, targetDialogId=${directive.targetDialogId}, ` +
@@ -190,7 +161,7 @@ async function resolveSideDialogReplyDirectiveForAssistantOutput(args) {
     if (latestHasTellaskResultForCallId(latest, targetCallId)) {
         return args.currentDirective;
     }
-    const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
+    const assignmentDirective = (0, dialog_1.buildSideDialogAssignmentPromptMeta)(args.dialog).tellaskReplyDirective;
     if (assignmentDirective.targetCallId !== targetCallId) {
         return args.currentDirective;
     }
@@ -204,7 +175,7 @@ async function resolveSideDialogReplyDirectiveForAssistantOutput(args) {
         return args.currentDirective;
     }
     const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
-    if (activeDirective && !hasSameReplyDirective(activeDirective, assignmentDirective)) {
+    if (activeDirective && !(0, reply_guidance_1.hasSameReplyDirective)(activeDirective, assignmentDirective)) {
         throw new Error(`sideDialog assistant output reply directive invariant violation: active obligation does not match latest assignment ` +
             `(dialog=${args.dialog.id.valueOf()}, targetCallId=${targetCallId}, ` +
             `activeTargetCallId=${activeDirective.targetCallId}, assignmentTargetCallId=${assignmentDirective.targetCallId})`);
@@ -796,7 +767,7 @@ function pendingRuntimePromptMatchesQueuePrompt(args) {
         return args.prompt.kind === 'new_course_runtime_guide';
     }
     if (args.prompt.kind === 'new_course_runtime_guide' ||
-        !hasSameReplyDirective(args.pendingRuntimePrompt.tellaskReplyDirective, args.prompt.tellaskReplyDirective)) {
+        !(0, reply_guidance_1.hasSameReplyDirective)(args.pendingRuntimePrompt.tellaskReplyDirective, args.prompt.tellaskReplyDirective)) {
         return false;
     }
     if (args.pendingRuntimePrompt.calleeDialogReplyTarget === undefined) {
@@ -1135,6 +1106,8 @@ async function executeDriveRound(args) {
     };
     let calleeDialogReplyTarget = replyContinuationScope.target();
     let activeTellaskReplyDirective = replyContinuationScope.directive();
+    let suppressedCalleeDialogReplyTargetAfterUserInterjection;
+    let suppressedTellaskReplyDirectiveAfterUserInterjection;
     let activePromptWasReplyToolReminder = false;
     let shouldPauseAfterLocalUserInterjection = false;
     let resumeFromInterjectionPause = false;
@@ -1559,6 +1532,14 @@ async function executeDriveRound(args) {
                 replyGuidance.suppressInterDialogReplyGuidance;
         activeTellaskReplyDirective =
             replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
+        suppressedTellaskReplyDirectiveAfterUserInterjection =
+            replyGuidance.suppressInterDialogReplyGuidance
+                ? replyGuidance.suppressedTellaskReplyDirective
+                : undefined;
+        suppressedCalleeDialogReplyTargetAfterUserInterjection =
+            replyGuidance.suppressInterDialogReplyGuidance
+                ? replyGuidance.suppressedCalleeDialogReplyTarget
+                : undefined;
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
         let activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
             activeTellaskReplyDirective !== undefined &&
@@ -1666,29 +1647,50 @@ async function executeDriveRound(args) {
                         backgroundCalleeBlocksImplicitReply,
                     });
                 }
-                else if (activeTellaskReplyDirective === undefined) {
-                    log_1.log.debug('kernel-driver skip sideDialog answering reminder because no active tellask reply directive is bound to this drive', undefined, {
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                    });
-                }
                 else {
-                    const language = (0, work_language_1.getWorkLanguage)();
-                    followUp = buildRuntimeReplyReminderFollowUp({
-                        directive: activeTellaskReplyDirective,
-                        prompt: await buildAnsweringReplyReminderPrompt({
-                            dlg: dialog,
-                            directive: activeTellaskReplyDirective,
+                    const replyDirectiveForAnswering = activeTellaskReplyDirective ?? suppressedTellaskReplyDirectiveAfterUserInterjection;
+                    if (replyDirectiveForAnswering === undefined) {
+                        log_1.log.debug('kernel-driver skip sideDialog answering reminder because no active tellask reply directive is bound to this drive', undefined, {
+                            rootId: dialog.id.rootId,
+                            selfId: dialog.id.selfId,
+                        });
+                    }
+                    else {
+                        if (calleeDialogReplyTarget !== undefined &&
+                            calleeDialogReplyTarget.callId !== replyDirectiveForAnswering.targetCallId) {
+                            throw new Error(`sideDialog answering reminder invariant violation: reply target callId does not match directive ` +
+                                `(dialog=${dialog.id.valueOf()}, targetCallId=${calleeDialogReplyTarget.callId}, ` +
+                                `directiveTargetCallId=${replyDirectiveForAnswering.targetCallId})`);
+                        }
+                        const currentAssignmentPromptMeta = (0, dialog_1.buildSideDialogAssignmentPromptMeta)(dialog);
+                        const currentAssignmentReplyTarget = (0, reply_guidance_1.hasSameReplyDirective)(replyDirectiveForAnswering, currentAssignmentPromptMeta.tellaskReplyDirective)
+                            ? currentAssignmentPromptMeta.calleeDialogReplyTarget
+                            : undefined;
+                        const replyTargetForAnswering = calleeDialogReplyTarget ??
+                            (suppressedTellaskReplyDirectiveAfterUserInterjection !== undefined &&
+                                (0, reply_guidance_1.hasSameReplyDirective)(replyDirectiveForAnswering, suppressedTellaskReplyDirectiveAfterUserInterjection)
+                                ? suppressedCalleeDialogReplyTargetAfterUserInterjection
+                                : undefined) ??
+                            currentAssignmentReplyTarget;
+                        const language = (0, work_language_1.getWorkLanguage)();
+                        followUp = buildRuntimeReplyReminderFollowUp({
+                            directive: replyDirectiveForAnswering,
+                            prompt: await buildAnsweringReplyReminderPrompt({
+                                dlg: dialog,
+                                directive: replyDirectiveForAnswering,
+                                language,
+                            }),
                             language,
-                        }),
-                        language,
-                        calleeDialogReplyTarget,
-                    });
-                    log_1.log.debug('kernel-driver queued sideDialog replyTellask reminder after answering-only output', undefined, {
-                        dialogId: dialog.id.valueOf(),
-                        targetCallId: activeTellaskReplyDirective.targetCallId,
-                        targetCallerDialogId: calleeDialogReplyTarget?.callerDialogId,
-                    });
+                            calleeDialogReplyTarget: replyTargetForAnswering,
+                        });
+                        log_1.log.debug('kernel-driver queued sideDialog replyTellask reminder after answering-only output', undefined, {
+                            dialogId: dialog.id.valueOf(),
+                            targetCallId: replyDirectiveForAnswering.targetCallId,
+                            targetCallerDialogId: replyTargetForAnswering?.callerDialogId,
+                            resumedAfterUserInterjection: activeTellaskReplyDirective === undefined &&
+                                suppressedTellaskReplyDirectiveAfterUserInterjection !== undefined,
+                        });
+                    }
                 }
             }
             if (dialog instanceof dialog_1.SideDialog &&

package/dist/llm/kernel-driver/reply-guidance.d.ts

@@ -5,6 +5,7 @@ export declare function resolveReplyTargetAgentId(args: {
     dlg: Dialog;
     directive: TellaskReplyDirective;
 }): Promise<string | undefined>;
+export declare function hasSameReplyDirective(left: TellaskReplyDirective | undefined, right: TellaskReplyDirective | undefined): boolean;
 export declare function resolvePromptReplyGuidance(args: {
     dlg: Dialog;
     prompt: KernelDriverPrompt | undefined;
@@ -14,6 +15,8 @@ export declare function resolvePromptReplyGuidance(args: {
     isQ4HAnswerPrompt: boolean;
     promptContent: string | undefined;
     persistedTellaskReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
+    suppressedCalleeDialogReplyTarget: KernelDriverPrompt['calleeDialogReplyTarget'];
+    suppressedTellaskReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
     suppressInterDialogReplyGuidance: boolean;
     transientGuideContent: string | undefined;
 }>;

package/dist/llm/kernel-driver/reply-guidance.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveReplyTargetAgentId = resolveReplyTargetAgentId;
+exports.hasSameReplyDirective = hasSameReplyDirective;
 exports.resolvePromptReplyGuidance = resolvePromptReplyGuidance;
 exports.buildReplyObligationSuppressionGuide = buildReplyObligationSuppressionGuide;
 const dialog_1 = require("../../dialog");
@@ -91,40 +92,17 @@ function hasSameReplyDirective(left, right) {
     }
     return true;
 }
-function buildCurrentSideDialogAssignmentDirective(dlg) {
-    switch (dlg.assignmentFromAsker.callName) {
-        case 'tellask':
-            return {
-                expectedReplyCallName: 'replyTellask',
-                targetDialogId: dlg.assignmentFromAsker.askerDialogId,
-                targetCallId: dlg.assignmentFromAsker.callId,
-                tellaskContent: dlg.assignmentFromAsker.tellaskContent,
-            };
-        case 'tellaskSessionless':
-        case 'freshBootsReasoning':
-            return {
-                expectedReplyCallName: 'replyTellaskSessionless',
-                targetDialogId: dlg.assignmentFromAsker.askerDialogId,
-                targetCallId: dlg.assignmentFromAsker.callId,
-                tellaskContent: dlg.assignmentFromAsker.tellaskContent,
-            };
-        default: {
-            const _exhaustive = dlg.assignmentFromAsker.callName;
-            throw new Error(`Unsupported sideDialog assignment callName: ${_exhaustive}`);
-        }
-    }
-}
-async function resolveFreshCurrentSideDialogAssignmentDirective(args) {
+async function resolveFreshCurrentSideDialogAssignmentPromptMeta(args) {
     if (!(args.dlg instanceof dialog_1.SideDialog)) {
         return undefined;
     }
-    const currentAssignmentDirective = buildCurrentSideDialogAssignmentDirective(args.dlg);
+    const currentAssignmentPromptMeta = (0, dialog_1.buildSideDialogAssignmentPromptMeta)(args.dlg);
     if (args.prompt?.origin === 'runtime') {
         const promptDirective = args.prompt.tellaskReplyDirective;
         if (!promptDirective) {
             return undefined;
         }
-        if (!hasSameReplyDirective(promptDirective, currentAssignmentDirective)) {
+        if (!hasSameReplyDirective(promptDirective, currentAssignmentPromptMeta.tellaskReplyDirective)) {
             return undefined;
         }
     }
@@ -135,14 +113,14 @@ async function resolveFreshCurrentSideDialogAssignmentDirective(args) {
     if (!latest) {
         return undefined;
     }
-    if (latest.sideDialogFinalResponse?.callId === currentAssignmentDirective.targetCallId.trim()) {
+    const targetCallId = currentAssignmentPromptMeta.tellaskReplyDirective.targetCallId.trim();
+    if (latest.sideDialogFinalResponse?.callId === targetCallId) {
         return undefined;
     }
-    const targetCallId = currentAssignmentDirective.targetCallId.trim();
     if (latest.tellaskResults.results.some((entry) => entry.callId.trim() === targetCallId)) {
         return undefined;
     }
-    return currentAssignmentDirective;
+    return currentAssignmentPromptMeta;
 }
 async function resolveFreshPendingAskBackReplyDirective(args) {
     const prompt = args.prompt;
@@ -241,7 +219,7 @@ async function resolvePromptReplyGuidance(args) {
     const prompt = args.prompt;
     const isQ4HAnswerPrompt = typeof prompt?.q4hAnswerCallId === 'string' && prompt.q4hAnswerCallId.trim() !== '';
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
-    const persistedCurrentSideDialogAssignmentDirective = await resolveFreshCurrentSideDialogAssignmentDirective({
+    const persistedCurrentSideDialogAssignmentPromptMeta = await resolveFreshCurrentSideDialogAssignmentPromptMeta({
         dlg: args.dlg,
         prompt,
     });
@@ -255,7 +233,7 @@ async function resolvePromptReplyGuidance(args) {
         ? latest.pendingRuntimePrompt.tellaskReplyDirective
         : undefined;
     const persistedActiveReplyObligation = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dlg);
-    const persistedActiveReplyDirective = persistedCurrentSideDialogAssignmentDirective ??
+    const persistedActiveReplyDirective = persistedCurrentSideDialogAssignmentPromptMeta?.tellaskReplyDirective ??
         persistedPendingAskBackReplyDirective ??
         persistedPendingRuntimePromptDirective ??
         persistedActiveReplyObligation;
@@ -290,6 +268,12 @@ async function resolvePromptReplyGuidance(args) {
             promptDirective: prompt?.tellaskReplyDirective,
             persistedDirective: persistedActiveReplyDirective,
         }),
+        suppressedCalleeDialogReplyTarget: suppressInterDialogReplyGuidance
+            ? persistedCurrentSideDialogAssignmentPromptMeta?.calleeDialogReplyTarget
+            : undefined,
+        suppressedTellaskReplyDirective: suppressInterDialogReplyGuidance
+            ? persistedActiveReplyDirective
+            : undefined,
         suppressInterDialogReplyGuidance,
         transientGuideContent: suppressInterDialogReplyGuidance && prompt !== undefined
             ? buildReplyObligationSuppressionGuide({

package/dist/persistence.js

@@ -1564,6 +1564,10 @@ function parseDialogFollowupReason(value) {
             const callIds = parseStringArrayField(value.callIds);
             return callIds === null ? null : { kind: 'invalid_tool_recovery', callIds };
         }
+        case 'repeated_tool_call_reminder': {
+            const callIds = parseStringArrayField(value.callIds);
+            return callIds === null ? null : { kind: 'repeated_tool_call_reminder', callIds };
+        }
         case 'reply_delivery_result':
             if (typeof value.replyDeliveryId !== 'string' ||
                 value.replyDeliveryId.trim() === '' ||