dominds 1.25.15 → 1.25.16

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

@@ -302,28 +302,28 @@ function getUserOriginPromptMsgId(prompt) {
         ? prompt.msgId
         : undefined;
 }
-function samePendingUserInterjectionMsg(pending, msgId) {
-    return pending.msgId === msgId;
+function samePendingUserInterjectionCoordinate(left, right) {
+    return left.msgId === right.msgId && left.course === right.course && left.genseq === right.genseq;
 }
 async function maybeResolveAnsweredUserInterjection(args) {
     if (args.userPromptMsgId === undefined ||
         args.assistantSayingContent === null ||
         args.assistantSayingContent.trim() === '' ||
         args.assistantSayingGenseq === null) {
-        return;
+        return undefined;
     }
     for (const rawGenseq of args.functionCallGenseqs) {
         if (!Number.isFinite(rawGenseq) || rawGenseq <= 0) {
             continue;
         }
         if (args.assistantSayingGenseq <= Math.floor(rawGenseq)) {
-            return;
+            return undefined;
         }
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
     const pending = latest?.pendingUserInterjectionReply;
-    if (pending === undefined || !samePendingUserInterjectionMsg(pending, args.userPromptMsgId)) {
-        return;
+    if (pending === undefined || pending.msgId !== args.userPromptMsgId) {
+        return undefined;
     }
     const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
     const answerIdSource = [
@@ -369,14 +369,18 @@ async function maybeResolveAnsweredUserInterjection(args) {
         const userPromptMsgId = args.userPromptMsgId;
         if (previousPending === undefined ||
             userPromptMsgId === undefined ||
-            !samePendingUserInterjectionMsg(previousPending, userPromptMsgId)) {
+            userPromptMsgId !== pending.msgId ||
+            !samePendingUserInterjectionCoordinate(previousPending, pending)) {
             return { kind: 'noop' };
         }
+        const next = { ...previous };
+        delete next.pendingUserInterjectionReply;
         return {
-            kind: 'patch',
-            patch: { pendingUserInterjectionReply: undefined },
+            kind: 'replace',
+            next,
         };
     }, args.dlg.status);
+    return answer;
 }
 async function persistAndEmitRuntimeGuide(dlg, content) {
     await dlg.addChatMessages({
@@ -2207,6 +2211,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let lastFunctionCallGenseq = null;
     let lastAssistantReplyTarget;
     let lastBusinessContinuation = { kind: 'none' };
+    let answeredUserInterjection;
+    let currentPromptIsUserInterjection = false;
+    let currentUserInterjectionReply;
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let lastToolRoundStopDiagnostics;
@@ -2455,6 +2462,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     }
                 }
                 lastBusinessContinuation = currentBusinessContinuation;
+                currentPromptIsUserInterjection = false;
+                currentUserInterjectionReply = undefined;
                 let generationBodyError;
                 let immediateFollowupTriggerExpectation;
                 const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt?.q4hAnswerCallId);
@@ -2476,9 +2485,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             language: promptLanguage,
                         });
                         const deferredReplyReassertionDirective = replyGuidance.deferredReplyReassertionDirective;
-                        const currentPromptIsUserInterjection = currentPrompt.origin === 'user' &&
-                            replyGuidance.suppressInterDialogReplyGuidance &&
-                            deferredReplyReassertionDirective !== undefined;
+                        currentPromptIsUserInterjection =
+                            currentPrompt.origin === 'user' &&
+                                replyGuidance.suppressInterDialogReplyGuidance &&
+                                deferredReplyReassertionDirective !== undefined;
                         if (currentPromptIsUserInterjection) {
                             // WARNING:
                             // User interjection suppression is a reversible state transition, not a one-shot
@@ -2490,13 +2500,29 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             // Legacy blocked-Continue paths may also re-enter here. A repeated interjection MUST
                             // re-arm the deferred state and re-materialize the suppression guide, even when the
                             // underlying reply directive itself did not change.
+                            const deferredDirective = deferredReplyReassertionDirective;
+                            if (deferredDirective === undefined) {
+                                throw new Error(`kernel-driver user interjection invariant violation: missing deferred reply directive for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
+                            }
                             const existingDeferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dlg.id, dlg.status);
+                            currentUserInterjectionReply = {
+                                msgId: currentPrompt.msgId,
+                                course: (0, storage_1.toDialogCourseNumber)(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse),
+                                genseq: (0, storage_1.toCallSiteGenseqNo)(dlg.activeGenSeq),
+                            };
                             const nextDeferredReplyReassertion = {
                                 reason: 'user_interjection_with_parked_original_task',
-                                directive: deferredReplyReassertionDirective,
+                                directive: deferredDirective,
+                                userInterjection: currentUserInterjectionReply,
                             };
                             const mustRearmDeferredReplyReassertion = existingDeferredReplyReassertion === undefined ||
                                 existingDeferredReplyReassertion.resumeGuideSurfaced === true ||
+                                existingDeferredReplyReassertion.userInterjection.msgId !==
+                                    nextDeferredReplyReassertion.userInterjection.msgId ||
+                                existingDeferredReplyReassertion.userInterjection.course !==
+                                    nextDeferredReplyReassertion.userInterjection.course ||
+                                existingDeferredReplyReassertion.userInterjection.genseq !==
+                                    nextDeferredReplyReassertion.userInterjection.genseq ||
                                 !hasSameReplyDirective(existingDeferredReplyReassertion.directive, nextDeferredReplyReassertion.directive);
                             if (mustRearmDeferredReplyReassertion) {
                                 await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, nextDeferredReplyReassertion, dlg.status);
@@ -2528,13 +2554,15 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
                         }
                         if (currentPromptIsUserInterjection) {
+                            if (currentUserInterjectionReply === undefined) {
+                                throw new Error(`kernel-driver user interjection invariant violation: missing pending reply coordinate for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
+                            }
+                            const pendingUserInterjectionReply = currentUserInterjectionReply;
                             await persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
                                 kind: 'patch',
                                 patch: {
                                     pendingUserInterjectionReply: {
-                                        msgId: currentPrompt.msgId,
-                                        course: (0, storage_1.toDialogCourseNumber)(dlg.activeGenCourseOrUndefined ?? dlg.currentCourse),
-                                        genseq: (0, storage_1.toCallSiteGenseqNo)(dlg.activeGenSeq),
+                                        ...pendingUserInterjectionReply,
                                     },
                                 },
                             }), dlg.status);
@@ -3217,6 +3245,31 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             lastFunctionCallGenseq = callGenseq;
                         }
                     }
+                    const userInterjectionMsgIdForVisibleAnswer = currentPrompt?.origin === 'user' && !isQ4HAnswerPrompt
+                        ? currentPrompt.msgId
+                        : currentGenerationBelongsToUserToolChain
+                            ? currentUserPromptMsgId
+                            : undefined;
+                    if (userInterjectionMsgIdForVisibleAnswer !== undefined) {
+                        const streamedCurrentRoundSayingContent = batchOutputs.length === 0 &&
+                            lastAssistantSayingGenseq !== previousAssistantSayingGenseq
+                            ? lastAssistantSayingContent
+                            : null;
+                        const streamedCurrentRoundSayingGenseq = batchOutputs.length === 0 &&
+                            lastAssistantSayingGenseq !== previousAssistantSayingGenseq
+                            ? lastAssistantSayingGenseq
+                            : null;
+                        const answer = await maybeResolveAnsweredUserInterjection({
+                            dlg,
+                            userPromptMsgId: userInterjectionMsgIdForVisibleAnswer,
+                            assistantSayingContent: currentRoundAssistantSayingContent ?? streamedCurrentRoundSayingContent,
+                            assistantSayingGenseq: currentRoundAssistantSayingGenseq ?? streamedCurrentRoundSayingGenseq,
+                            functionCallGenseqs: currentRoundFunctionCallGenseqs,
+                        });
+                        if (answer !== undefined) {
+                            answeredUserInterjection = answer;
+                        }
+                    }
                     const routed = await executeFunctionRound({
                         dlg,
                         agent,
@@ -3234,21 +3287,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         newMsgs.push(...routed.pairedMessages);
                     }
                     await dlg.addChatMessages(...newMsgs);
-                    const streamedCurrentRoundSayingContent = batchOutputs.length === 0 && lastAssistantSayingGenseq !== previousAssistantSayingGenseq
-                        ? lastAssistantSayingContent
-                        : null;
-                    const streamedCurrentRoundSayingGenseq = batchOutputs.length === 0 && lastAssistantSayingGenseq !== previousAssistantSayingGenseq
-                        ? lastAssistantSayingGenseq
-                        : null;
-                    if (currentPrompt?.origin === 'user' && !isQ4HAnswerPrompt) {
-                        await maybeResolveAnsweredUserInterjection({
-                            dlg,
-                            userPromptMsgId: currentPrompt.msgId,
-                            assistantSayingContent: currentRoundAssistantSayingContent ?? streamedCurrentRoundSayingContent,
-                            assistantSayingGenseq: currentRoundAssistantSayingGenseq ?? streamedCurrentRoundSayingGenseq,
-                            functionCallGenseqs: currentRoundFunctionCallGenseqs,
-                        });
-                    }
                     const persistedFbrState = await loadDialogFbrState(dlg);
                     if (persistedFbrState) {
                         if (persistedFbrState.phase === 'finalization') {
@@ -3674,6 +3712,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
         lastFunctionCallGenseq,
         lastAssistantReplyTarget,
         lastBusinessContinuation,
+        answeredUserInterjection,
         fbrConclusion,
     };
 }

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

@@ -25,6 +25,79 @@ const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
+async function confirmAnsweredUserInterjectionCredential(args) {
+    const credential = args.credential;
+    if (credential === undefined) {
+        return undefined;
+    }
+    const dialog = args.dialog;
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
+    const answers = await persistence_1.DialogPersistence.loadAnswersToHumanState(dialog.id, dialog.status);
+    const persistedCredential = answers.find((answer) => answer.id === credential.id);
+    if (persistedCredential === undefined) {
+        return undefined;
+    }
+    if (persistedCredential.userInterjection.msgId !== credential.userInterjection.msgId ||
+        persistedCredential.userInterjection.course !== credential.userInterjection.course ||
+        persistedCredential.userInterjection.genseq !== credential.userInterjection.genseq ||
+        persistedCredential.answerRef.course !== credential.answerRef.course ||
+        persistedCredential.answerRef.genseq !== credential.answerRef.genseq) {
+        return undefined;
+    }
+    if (persistedCredential.userInterjection.msgId !== args.userInterjection.msgId ||
+        persistedCredential.userInterjection.course !== args.userInterjection.course ||
+        persistedCredential.userInterjection.genseq !== args.userInterjection.genseq) {
+        return undefined;
+    }
+    const pending = latest?.pendingUserInterjectionReply;
+    if (pending === undefined) {
+        return persistedCredential;
+    }
+    if (pending.msgId !== persistedCredential.userInterjection.msgId ||
+        pending.course !== persistedCredential.userInterjection.course ||
+        pending.genseq !== persistedCredential.userInterjection.genseq) {
+        return undefined;
+    }
+    await persistence_1.DialogPersistence.mutateDialogLatest(dialog.id, (previous) => {
+        const previousPending = previous.pendingUserInterjectionReply;
+        if (previousPending === undefined ||
+            previousPending.msgId !== persistedCredential.userInterjection.msgId ||
+            previousPending.course !== persistedCredential.userInterjection.course ||
+            previousPending.genseq !== persistedCredential.userInterjection.genseq) {
+            return { kind: 'noop' };
+        }
+        const next = { ...previous };
+        delete next.pendingUserInterjectionReply;
+        return { kind: 'replace', next };
+    }, dialog.status);
+    return persistedCredential;
+}
+async function resolveLatestAnsweredUserInterjectionCredential(dialog, userInterjection) {
+    const answers = await persistence_1.DialogPersistence.loadAnswersToHumanState(dialog.id, dialog.status);
+    for (let index = answers.length - 1; index >= 0; index -= 1) {
+        const answer = answers[index];
+        if (answer.userInterjection.msgId === userInterjection.msgId &&
+            answer.userInterjection.course === userInterjection.course &&
+            answer.userInterjection.genseq === userInterjection.genseq) {
+            return answer;
+        }
+    }
+    return undefined;
+}
+async function resolveAnsweredUserInterjectionCredentialForPrompt(args) {
+    const userPromptMsgId = args.userPromptMsgId;
+    if (userPromptMsgId === undefined) {
+        return undefined;
+    }
+    const answers = await persistence_1.DialogPersistence.loadAnswersToHumanState(args.dialog.id, args.dialog.status);
+    for (let index = answers.length - 1; index >= 0; index -= 1) {
+        const answer = answers[index];
+        if (answer.userInterjection.msgId === userPromptMsgId) {
+            return answer;
+        }
+    }
+    return undefined;
+}
 function buildRuntimeReplyReminderFollowUp(args) {
     const common = {
         prompt: args.prompt,
@@ -961,6 +1034,10 @@ async function inspectSideDialogBusinessContinuationDrive(args) {
     };
 }
 async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
+    if (latest?.pendingUserInterjectionReply !== undefined) {
+        return undefined;
+    }
     const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
     if (!deferredReplyReassertion) {
         return undefined;
@@ -980,6 +1057,14 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
         await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
         return undefined;
     }
+    const answeredUserInterjection = await confirmAnsweredUserInterjectionCredential({
+        dialog,
+        credential: await resolveLatestAnsweredUserInterjectionCredential(dialog, deferredReplyReassertion.userInterjection),
+        userInterjection: deferredReplyReassertion.userInterjection,
+    });
+    if (answeredUserInterjection === undefined) {
+        return undefined;
+    }
     await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
     const language = (0, work_language_1.getWorkLanguage)();
     return {
@@ -987,6 +1072,7 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
             dlg: dialog,
             directive: deferredReplyReassertion.directive,
             language,
+            answeredUserInterjection,
         }),
         msgId: (0, id_1.generateShortId)(),
         grammar: 'markdown',
@@ -1007,12 +1093,20 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
         return;
     }
     const language = (0, work_language_1.getWorkLanguage)();
+    const answeredUserInterjection = await confirmAnsweredUserInterjectionCredential({
+        dialog,
+        credential: await resolveLatestAnsweredUserInterjectionCredential(dialog, deferredReplyReassertion.userInterjection),
+        userInterjection: deferredReplyReassertion.userInterjection,
+    });
+    if (answeredUserInterjection === undefined) {
+        return;
+    }
     const content = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
         dlg: dialog,
         directive: deferredReplyReassertion.directive,
         language,
+        answeredUserInterjection,
     });
-    const genseq = dialog.activeGenSeqOrUndefined ?? 1;
     // WARNING:
     // This helper intentionally does three things at once:
     // 1. append the guide into dialog.msgs so an in-memory later resume sees it naturally;
@@ -1026,6 +1120,7 @@ async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialo
     await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
         reason: 'user_interjection_with_parked_original_task',
         directive: deferredReplyReassertion.directive,
+        userInterjection: deferredReplyReassertion.userInterjection,
         resumeGuideSurfaced: true,
     }, dialog.status);
 }
@@ -1639,15 +1734,6 @@ async function executeDriveRound(args) {
                 !replyGuidance.isQ4HAnswerPrompt &&
                 replyGuidance.suppressInterDialogReplyGuidance &&
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
-        if (effectivePrompt?.origin === 'user' &&
-            !replyGuidance.isQ4HAnswerPrompt &&
-            !replyGuidance.suppressInterDialogReplyGuidance &&
-            replyGuidance.deferredReplyReassertionDirective !== undefined) {
-            await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
-                reason: 'user_interjection_with_parked_original_task',
-                directive: replyGuidance.deferredReplyReassertionDirective,
-            }, dialog.status);
-        }
         activeTellaskReplyDirective =
             replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
@@ -1736,6 +1822,52 @@ async function executeDriveRound(args) {
         }
         let tailError;
         try {
+            if (shouldPauseAfterLocalUserInterjection &&
+                effectivePrompt?.origin === 'user' &&
+                !interruptedBySignal &&
+                followUp === undefined &&
+                driveResult?.lastAssistantSayingContent !== undefined &&
+                driveResult.lastAssistantSayingContent !== null &&
+                driveResult.lastAssistantSayingContent.trim() !== '') {
+                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
+                if (deferredReplyReassertion !== undefined &&
+                    deferredReplyReassertion.reason === 'user_interjection_with_parked_original_task') {
+                    const answeredUserInterjection = await confirmAnsweredUserInterjectionCredential({
+                        dialog,
+                        credential: driveResult.answeredUserInterjection ??
+                            (await resolveAnsweredUserInterjectionCredentialForPrompt({
+                                dialog,
+                                userPromptMsgId: effectivePrompt?.msgId,
+                            })),
+                        userInterjection: deferredReplyReassertion.userInterjection,
+                    });
+                    if (answeredUserInterjection !== undefined) {
+                        const language = (0, work_language_1.getWorkLanguage)();
+                        const prompt = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+                            dlg: dialog,
+                            directive: deferredReplyReassertion.directive,
+                            language,
+                            answeredUserInterjection,
+                        });
+                        followUp = {
+                            kind: 'runtime_reply_reminder',
+                            prompt,
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            origin: 'runtime',
+                            userLanguageCode: language,
+                            tellaskReplyDirective: deferredReplyReassertion.directive,
+                        };
+                        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
+                        log_1.log.debug('kernel-driver queued automatic reply-obligation reassertion after user interjection answer', undefined, {
+                            dialogId: dialog.id.valueOf(),
+                            rootId: dialog.id.rootId,
+                            selfId: dialog.id.selfId,
+                            targetCallId: deferredReplyReassertion.directive.targetCallId,
+                        });
+                    }
+                }
+            }
             if (dialog instanceof dialog_1.SideDialog &&
                 driveResult &&
                 !interruptedBySignal &&
@@ -1978,36 +2110,6 @@ async function executeDriveRound(args) {
                     }
                 }
             }
-            if (shouldPauseAfterLocalUserInterjection &&
-                !interruptedBySignal &&
-                followUp === undefined &&
-                driveResult?.lastAssistantSayingContent !== null) {
-                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
-                if (deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task') {
-                    const language = (0, work_language_1.getWorkLanguage)();
-                    const prompt = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
-                        dlg: dialog,
-                        directive: deferredReplyReassertion.directive,
-                        language,
-                    });
-                    followUp = {
-                        kind: 'runtime_reply_reminder',
-                        prompt,
-                        msgId: (0, id_1.generateShortId)(),
-                        grammar: 'markdown',
-                        origin: 'runtime',
-                        userLanguageCode: language,
-                        tellaskReplyDirective: deferredReplyReassertion.directive,
-                    };
-                    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
-                    log_1.log.debug('kernel-driver queued automatic reply-obligation reassertion after user interjection answer', undefined, {
-                        dialogId: dialog.id.valueOf(),
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                        targetCallId: deferredReplyReassertion.directive.targetCallId,
-                    });
-                }
-            }
             if (followUp) {
                 if (followUp.kind === 'runtime_reply_reminder' ||
                     followUp.kind === 'runtime_sideDialog_reply_reminder') {

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

@@ -1,4 +1,4 @@
-import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
+import type { AnswerToHumanItem, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
 import type { KernelDriverPrompt } from './types';
 export declare function resolveReplyTargetAgentId(args: {
@@ -25,4 +25,5 @@ export declare function buildReplyObligationReassertionPrompt(args: {
     dlg: Dialog;
     directive: NonNullable<KernelDriverPrompt['tellaskReplyDirective']>;
     language: 'zh' | 'en';
+    answeredUserInterjection: AnswerToHumanItem;
 }): Promise<string>;

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

@@ -110,15 +110,20 @@ function buildCurrentSideDialogAssignmentDirective(dlg) {
     }
 }
 async function resolveFreshCurrentSideDialogAssignmentDirective(args) {
-    if (!(args.dlg instanceof dialog_1.SideDialog) || args.prompt?.origin !== 'runtime') {
-        return undefined;
-    }
-    const promptDirective = args.prompt.tellaskReplyDirective;
-    if (!promptDirective) {
+    if (!(args.dlg instanceof dialog_1.SideDialog)) {
         return undefined;
     }
     const currentAssignmentDirective = buildCurrentSideDialogAssignmentDirective(args.dlg);
-    if (!hasSameReplyDirective(promptDirective, currentAssignmentDirective)) {
+    if (args.prompt?.origin === 'runtime') {
+        const promptDirective = args.prompt.tellaskReplyDirective;
+        if (!promptDirective) {
+            return undefined;
+        }
+        if (!hasSameReplyDirective(promptDirective, currentAssignmentDirective)) {
+            return undefined;
+        }
+    }
+    else if (args.prompt?.origin !== 'user') {
         return undefined;
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);

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

@@ -1,6 +1,6 @@
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
 import type { DialogDiligencePrompt, DialogPrompt, DialogRunControlSpec, DialogRuntimeGuidePrompt, DialogRuntimePrompt, DialogRuntimeReplyPrompt, DialogRuntimeSideDialogPrompt, DialogUserPrompt } from '@longrun-ai/kernel/types/drive-intent';
-import type { CallSiteCourseNo, CallSiteGenseqNo, DialogBusinessContinuation } from '@longrun-ai/kernel/types/storage';
+import type { AnswerToHumanItem, CallSiteCourseNo, CallSiteGenseqNo, DialogBusinessContinuation } from '@longrun-ai/kernel/types/storage';
 import type { Dialog, DialogID } from '../../dialog';
 export type KernelDriverRunControl = DialogRunControlSpec;
 export type KernelDriverDriveSource = 'unspecified' | 'ws_user_message' | 'ws_user_answer' | 'ws_diligence_push' | 'ws_resume_dialog' | 'ws_resume_all' | 'kernel_driver_backend_loop' | 'kernel_driver_follow_up' | 'kernel_driver_sideDialog_init' | 'kernel_driver_sideDialog_resume' | 'kernel_driver_fbr_sideDialog_round' | 'kernel_driver_type_a_askerDialog_call' | 'kernel_driver_business_continuation' | 'kernel_driver_idle_reminder_wake';
@@ -99,6 +99,7 @@ export type KernelDriverCoreResult = {
     lastFunctionCallGenseq: number | null;
     lastAssistantReplyTarget?: KernelDriverCalleeReplyTarget;
     lastBusinessContinuation: DialogBusinessContinuation;
+    answeredUserInterjection?: AnswerToHumanItem;
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;

package/dist/persistence.js

@@ -555,6 +555,26 @@ function parsePersistenceJson(args) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function parseDialogPendingUserInterjectionReply(value) {
+    if (!isRecord(value))
+        return null;
+    const msgId = value.msgId;
+    const course = value.course;
+    const genseq = value.genseq;
+    if (typeof msgId !== 'string' || msgId.trim() === '')
+        return null;
+    if (typeof course !== 'number' || !Number.isInteger(course) || course <= 0) {
+        return null;
+    }
+    if (typeof genseq !== 'number' || !Number.isInteger(genseq) || genseq <= 0) {
+        return null;
+    }
+    return {
+        msgId,
+        course: (0, storage_1.toDialogCourseNumber)(course),
+        genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
+    };
+}
 function parseDisplayTextI18n(value) {
     if (value === undefined)
         return undefined;
@@ -2148,24 +2168,7 @@ function parseDialogLatestFile(value) {
     const pendingUserInterjectionReply = (() => {
         if (pendingUserInterjectionReplyRaw === undefined)
             return undefined;
-        if (!isRecord(pendingUserInterjectionReplyRaw))
-            return null;
-        const msgId = pendingUserInterjectionReplyRaw.msgId;
-        const course = pendingUserInterjectionReplyRaw.course;
-        const genseq = pendingUserInterjectionReplyRaw.genseq;
-        if (typeof msgId !== 'string' || msgId.trim() === '')
-            return null;
-        if (typeof course !== 'number' || !Number.isFinite(course) || Math.floor(course) <= 0) {
-            return null;
-        }
-        if (typeof genseq !== 'number' || !Number.isFinite(genseq) || Math.floor(genseq) <= 0) {
-            return null;
-        }
-        return {
-            msgId,
-            course: (0, storage_1.toDialogCourseNumber)(course),
-            genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
-        };
+        return parseDialogPendingUserInterjectionReply(pendingUserInterjectionReplyRaw);
     })();
     if (pendingUserInterjectionReply === null)
         return null;
@@ -2238,6 +2241,9 @@ function parseDialogLatestFile(value) {
         const directive = parseTellaskReplyDirective(deferredReplyReassertionRaw.directive);
         if (directive === null)
             return null;
+        const userInterjection = parseDialogPendingUserInterjectionReply(deferredReplyReassertionRaw.userInterjection);
+        if (userInterjection === null)
+            return null;
         const resumeGuideSurfacedRaw = deferredReplyReassertionRaw.resumeGuideSurfaced;
         if (resumeGuideSurfacedRaw !== undefined && typeof resumeGuideSurfacedRaw !== 'boolean') {
             return null;
@@ -2245,6 +2251,7 @@ function parseDialogLatestFile(value) {
         return {
             reason: 'user_interjection_with_parked_original_task',
             directive,
+            userInterjection,
             ...(resumeGuideSurfacedRaw === undefined
                 ? {}
                 : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
@@ -2441,21 +2448,23 @@ function isAnswerToHumanItem(value) {
         return false;
     if (typeof value.userInterjection.course !== 'number')
         return false;
-    if (!Number.isFinite(value.userInterjection.course))
+    if (!Number.isInteger(value.userInterjection.course) || value.userInterjection.course <= 0) {
         return false;
+    }
     if (typeof value.userInterjection.genseq !== 'number')
         return false;
-    if (!Number.isFinite(value.userInterjection.genseq))
+    if (!Number.isInteger(value.userInterjection.genseq) || value.userInterjection.genseq <= 0) {
         return false;
+    }
     if (!isRecord(value.answerRef))
         return false;
     if (typeof value.answerRef.course !== 'number')
         return false;
-    if (!Number.isFinite(value.answerRef.course))
+    if (!Number.isInteger(value.answerRef.course) || value.answerRef.course <= 0)
         return false;
     if (typeof value.answerRef.genseq !== 'number')
         return false;
-    if (!Number.isFinite(value.answerRef.genseq))
+    if (!Number.isInteger(value.answerRef.genseq) || value.answerRef.genseq <= 0)
         return false;
     return true;
 }
@@ -9103,7 +9112,17 @@ class DialogPersistence {
         }, status);
     }
     static async setDeferredReplyReassertion(dialogId, deferredReplyReassertion, status = 'running') {
-        await this.mutateDialogLatest(dialogId, () => ({ kind: 'patch', patch: { deferredReplyReassertion } }), status);
+        await this.mutateDialogLatest(dialogId, (previous) => {
+            if (deferredReplyReassertion !== undefined) {
+                return { kind: 'patch', patch: { deferredReplyReassertion } };
+            }
+            if (previous.deferredReplyReassertion === undefined) {
+                return { kind: 'noop' };
+            }
+            const next = { ...previous };
+            delete next.deferredReplyReassertion;
+            return { kind: 'replace', next };
+        }, status);
     }
     static async getDeferredReplyReassertion(dialogId, status = 'running') {
         const latest = await this.loadDialogLatest(dialogId, status);
@@ -9330,10 +9349,9 @@ class DialogPersistence {
                 if (!existingAnswers.some((item) => item.id === recoveredAnswer.id)) {
                     await this.appendAnswerToHumanState(dialogId, recoveredAnswer, status);
                 }
-                return {
-                    ...latest,
-                    pendingUserInterjectionReply: undefined,
-                };
+                const next = { ...latest };
+                delete next.pendingUserInterjectionReply;
+                return next;
             }
         }
         if (normalizedPending?.msgId === latest.pendingUserInterjectionReply.msgId &&
@@ -9341,6 +9359,11 @@ class DialogPersistence {
             normalizedPending?.genseq === latest.pendingUserInterjectionReply.genseq) {
             return latest;
         }
+        if (normalizedPending === undefined) {
+            const next = { ...latest };
+            delete next.pendingUserInterjectionReply;
+            return next;
+        }
         return {
             ...latest,
             pendingUserInterjectionReply: normalizedPending,

package/dist/runtime/driver-messages.js

@@ -272,7 +272,9 @@ function getReminderMaintenanceInstructions(language, reminderId, meta) {
     const deleteAltInstruction = isReminderGuideMetaRecord(deleteValue) && typeof deleteValue['altInstruction'] === 'string'
         ? deleteValue['altInstruction'].trim()
         : undefined;
-    const daemonCompleted = metaKind === 'daemon' && isReminderGuideMetaRecord(metaValue) && metaValue['completed'] === true;
+    const daemonCompleted = metaKind === 'daemon' &&
+        isReminderGuideMetaRecord(metaValue) &&
+        metaValue['completed'] === true;
     const deleteInstruction = language === 'zh'
         ? isPendingTellaskReminder && pendingTellaskCount !== undefined && pendingTellaskCount > 0
             ? '删除通道：当前仍有进行中诉请；我不能用 delete_reminder 删除。要改变某一路长线诉请时，我复用同一 sessionSlug 再发 tellask；tellaskSessionless 不能修改或停止旧任务。'

package/dist/runtime/reply-prompt-copy.js

@@ -114,16 +114,18 @@ function buildReplyObligationSuppressionGuideText(language) {
     if (language === 'zh') {
         return [
             exports.REPLY_SUPPRESSION_PREFIX_ZH,
-            '先把用户刚插进来的这轮正常接住，按眼前的话题继续回答。',
-            '原来那条长线先放一放，别急着顺着它往下收口。',
-            '等原任务允许恢复时，运行时会再提醒你把那条线接回去。',
+            '本轮最新用户消息是真实用户插话；先按这条最新用户消息回答，让用户看到你已经接住了当前话题。',
+            '原来的长线诉请、回复工具义务、技能/SOP 触发条件都已暂存；不要在回答当前用户消息前切回旧任务、旧工具流程或旧收口。',
+            '只有当前用户消息本身需要，才使用工具；不要因为旧长线任务、旧技能提示或旧提醒项去调用工具。',
+            '等当前用户插话已经得到可见回复后，运行时会再提醒你接回原来的长线。',
         ].join('\n');
     }
     return [
         exports.REPLY_SUPPRESSION_PREFIX_EN,
-        "First, handle the user's interjection normally and keep answering the topic in front of you.",
-        'Set the earlier long-line thread aside for now; do not rush to close it yet.',
-        'When the original task becomes resumable again, runtime will remind you to pick that thread up again.',
+        'The latest user message in this turn is a real user interjection; answer that latest user message first so the user can see you handled the current topic.',
+        'The earlier long-line request, reply-tool obligation, and skill/SOP triggers are parked; do not switch back to the old task, old tool flow, or old closure before answering the current user message.',
+        'Use tools only if the current user message itself requires them; do not call tools because of the earlier long-line task, old skill hints, or old reminders.',
+        'After the current user interjection has a visible reply, runtime will remind you to resume the earlier long-line thread.',
     ].join('\n');
 }
 function buildReplyObligationReassertionText(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.15",
+  "version": "1.25.16",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -53,8 +53,8 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/kernel": "1.15.11",
-    "@longrun-ai/shell": "1.15.11"
+    "@longrun-ai/kernel": "1.15.12",
+    "@longrun-ai/shell": "1.15.12"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",