dominds 1.25.14 → 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({
@@ -804,10 +808,15 @@ async function renderRemindersForContext(dlg) {
         return [];
     const language = (0, work_language_1.getWorkLanguage)();
     const renderedItems = [];
+    const maintenanceReferenceItems = [];
     for (const reminder of reminders) {
         if (!reminder || !(0, tool_1.reminderEchoBackEnabled)(reminder)) {
             continue;
         }
+        maintenanceReferenceItems.push({
+            id: reminder.id,
+            meta: reminder.meta,
+        });
         if (reminder.owner) {
             renderedItems.push(await reminder.owner.renderReminder(dlg, reminder));
             continue;
@@ -823,12 +832,22 @@ async function renderRemindersForContext(dlg) {
     }
     if (renderedItems.length === 0)
         return [];
+    const maintenanceReference = (0, driver_messages_1.formatReminderMaintenanceReference)(language, maintenanceReferenceItems);
     return [
         {
             type: 'environment_msg',
             role: 'user',
             content: (0, driver_messages_1.formatReminderContextGuide)(language),
         },
+        ...(maintenanceReference === undefined
+            ? []
+            : [
+                {
+                    type: 'transient_guide_msg',
+                    role: 'assistant',
+                    content: maintenanceReference,
+                },
+            ]),
         ...renderedItems,
     ];
 }
@@ -2192,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;
@@ -2440,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);
@@ -2461,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
@@ -2475,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);
@@ -2513,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);
@@ -3202,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,
@@ -3219,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') {
@@ -3659,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/mcp/supervisor.js

@@ -101,14 +101,12 @@ function ensureLeaseReminder(dlg, serverId) {
         ? [
             `已租用 MCP 工具集：${serverId}`,
             '',
-            '该 MCP server 被视为非“真正无状态”。当你确认短期内不再需要它时，请释放以回收底层进程/连接：',
-            `mcp_release({"serverId":"${serverId}"})`,
+            '该 MCP server 被视为非“真正无状态”；当前对话持有一个需要显式生命周期管理的底层进程/连接。',
         ].join('\n')
         : [
             `MCP toolset leased: ${serverId}`,
             '',
-            `This MCP server is treated as non-stateless. When you are confident you won't need it again soon, release it:`,
-            `mcp_release({"serverId":"${serverId}"})`,
+            `This MCP server is treated as non-stateless; the current dialog holds an underlying process/connection with explicit lifecycle management.`,
         ].join('\n');
     dlg.addReminder(content, owner, makeLeaseReminderMeta(serverId));
 }

package/dist/minds/system-prompt.js

@@ -99,8 +99,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“回贴已送达后，对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 `tellask` 复用同一 `sessionSlug`）。',
             '- 若被诉请者在回贴送达前因 `clear_mind` 开启新一程，同一进行中诉请默认继续有效；新一程会自然承接，直到产生回贴或明确失败。不要仅因对方换程就把该轮诉请当作失效重发。',
-            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护；仅 0 路时可手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
-            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面：内容不可手改；当存在非 0 路进行中诉请时，不可删除，误删会被拒绝并返回引导文案。若某一路诉请需要改要求、提前收口或纠偏，只能更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
+            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动维护）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- “⏳ 进行中诉请”提醒项只是系统状态窗，不是控制面；用它判断是否确实存在仍在执行的诉请。若某一路诉请需要改要求、提前收口或纠偏，更新那一路诉请的“任务安排”（对长线诉请通常复用同一 `sessionSlug` 再发 `tellask`），让对应主理人按最新安排自行最终回复并自然结束。',
             '- 只有长线诉请（`tellask` + `sessionSlug`）能接着同一件事说、更新同一件正在做的事；一次性诉请（`tellaskSessionless`）做不到。再次发起 `tellaskSessionless` 只是另一件独立任务，不会更新、更不会要求旧任务停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友可以同时做多件独立任务，系统会分开处理。记住这个简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。只要任务独立、目标清楚，就直接并行诉请。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
@@ -112,8 +112,8 @@ function buildTeammateTellaskPhaseContract(language) {
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
             '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background after the reply is already delivered” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually `tellask` with the same `sessionSlug`).',
             '- If the tellaskee starts a new course via `clear_mind` before delivering the reply, the same in-flight Tellask stays live by default; the new course naturally continues it until a reply is delivered or an explicit failure is returned. Do not re-tellask solely because the tellaskee changed course.',
-            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained; manually deletable only at zero in-flight)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
-            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface: its content is not hand-editable; while any Tellask is still active, it is not deletable, and mistaken deletion will be rejected with guidance. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment instead (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
+            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-maintained)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- The “⏳ In-flight Tellasks” reminder is only a system status window, not a control surface; use it to determine whether any Tellask is truly still in flight. If one Tellask needs a changed scope, earlier closure, or correction, update that Tellask’s assignment (for a sessioned Tellask, usually send another `tellask` with the same `sessionSlug`) so the tellaskee can deliver a final reply naturally under the latest assignment.',
             '- Only a sessioned Tellask (`tellask` + `sessionSlug`) can continue the same task and update that task. A one-shot Tellask (`tellaskSessionless`) cannot: another `tellaskSessionless` is a separate task and does not update, stop, or instruct the earlier task to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
             '- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. The same teammate can work on several independent tasks at once, and the system keeps them separate. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task. When tasks are independent and clear, tellask in parallel.',
             '- Do not use `askHuman` as a relay for executable teammate work. If you write “ask @X to do Y”, emit `tellask` or `tellaskSessionless` in the same response.',