dominds 1.26.6 → 1.27.0

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

@@ -9,7 +9,6 @@ const dialog_drive_work_1 = require("../../dialog-drive-work");
 const dialog_global_registry_1 = require("../../dialog-global-registry");
 const dialog_interruption_1 = require("../../dialog-interruption");
 const dialog_latest_state_1 = require("../../dialog-latest-state");
-const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
@@ -25,79 +24,6 @@ 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,
@@ -353,6 +279,16 @@ async function buildReplyToolReminderPrompt(args) {
         }),
     });
 }
+async function buildAnsweringReplyReminderPrompt(args) {
+    return (0, reply_prompt_copy_1.buildAnsweringReplyReminderText)({
+        language: args.language,
+        directive: args.directive,
+        replyTargetAgentId: await (0, reply_guidance_1.resolveReplyTargetAgentId)({
+            dlg: args.dlg,
+            directive: args.directive,
+        }),
+    });
+}
 function isPositiveInteger(value) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0;
 }
@@ -1033,112 +969,6 @@ async function inspectSideDialogBusinessContinuationDrive(args) {
         sideDialogFinalResponseCallId,
     };
 }
-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;
-    }
-    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(dialog);
-    if (!activeDirective ||
-        activeDirective.targetCallId !== deferredReplyReassertion.directive.targetCallId) {
-        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
-        return undefined;
-    }
-    // WARNING:
-    // `resumeGuideSurfaced` means the reply-obligation reassertion has already been materialized as a
-    // runtime guide and injected into both dialog.msgs and persisted course history at blocked
-    // Continue time. Once that has happened, later real resume must not emit a second visible prompt:
-    // normal context replay is now the source of truth for the model-facing reminder.
-    if (deferredReplyReassertion.resumeGuideSurfaced === true) {
-        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 {
-        content: await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
-            dlg: dialog,
-            directive: deferredReplyReassertion.directive,
-            language,
-            answeredUserInterjection,
-        }),
-        msgId: (0, id_1.generateShortId)(),
-        grammar: 'markdown',
-        origin: 'runtime',
-        userLanguageCode: language,
-        tellaskReplyDirective: deferredReplyReassertion.directive,
-    };
-}
-async function maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog) {
-    const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
-    if (!deferredReplyReassertion || deferredReplyReassertion.resumeGuideSurfaced === true) {
-        return;
-    }
-    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(dialog);
-    if (!activeDirective ||
-        activeDirective.targetCallId !== deferredReplyReassertion.directive.targetCallId) {
-        await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
-        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,
-    });
-    // 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;
-    // 2. persist a runtime_guide_record so reload/replay reconstructs the same context;
-    // 3. emit runtime_guide_evt so the user immediately sees the reassertion bubble after Continue.
-    //
-    // Do not "optimize" this into only an event or only a deferred prompt. The whole point is that
-    // once a legacy blocked Continue path surfaces the guide, it becomes a first-class historical
-    // context fact and later real driving should need no special duplicate reassertion path.
-    await surfaceRuntimeGuide(dialog, content);
-    await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, {
-        reason: 'user_interjection_with_parked_original_task',
-        directive: deferredReplyReassertion.directive,
-        userInterjection: deferredReplyReassertion.userInterjection,
-        resumeGuideSurfaced: true,
-    }, dialog.status);
-}
-async function surfaceRuntimeGuide(dialog, content) {
-    const genseq = dialog.activeGenSeqOrUndefined ?? 1;
-    await dialog.addChatMessages({
-        type: 'transient_guide_msg',
-        role: 'assistant',
-        content,
-    });
-    await persistence_1.DialogPersistence.persistRuntimeGuide(dialog, content, genseq);
-    (0, evt_registry_1.postDialogEvent)(dialog, {
-        type: 'runtime_guide_evt',
-        course: dialog.currentCourse,
-        genseq,
-        content,
-    });
-}
 async function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
         return { prompt: humanPrompt, fromQueuedPrompt: false, droppedStaleQueuedContinuation: false };
@@ -1148,7 +978,7 @@ async function resolveEffectivePrompt(dialog, humanPrompt) {
         const queuedPrompt = dialog.peekQueuedPrompt();
         if (!queuedPrompt) {
             return {
-                prompt: await maybeResolveDeferredReplyReassertionPrompt(dialog),
+                prompt: undefined,
                 fromQueuedPrompt: false,
                 droppedStaleQueuedContinuation,
             };
@@ -1523,7 +1353,7 @@ async function executeDriveRound(args) {
             //
             // Do not refactor this branch using only `displayState` or only the previous interrupted
             // marker. The correct behavior emerges from combining fresh suspension facts, queued prompt
-            // state, and the deferred reply reassertion logic elsewhere.
+            // state, and ordinary reply-obligation state.
             const hasSupplyResponseContinuation = hasSupplyResponseBusinessContinuation(dialog, driveOptions);
             const suspension = resumeFromInterjectionPause
                 ? await loadFreshSuspensionStatusFromPersistence(dialog)
@@ -1536,7 +1366,6 @@ async function executeDriveRound(args) {
                 if (resumeFromInterjectionPause) {
                     const restoredState = await (0, dialog_display_state_1.computeIdleDisplayState)(dialog);
                     await (0, dialog_display_state_1.setDialogDisplayState)(dialog.id, restoredState);
-                    await maybeSurfaceDeferredReplyReassertionGuideForBlockedContinue(dialog);
                     log_1.log.debug('kernel-driver continue after interjection pause restored true suspended state from fresh persistence facts', undefined, {
                         dialogId: dialog.id.valueOf(),
                         restoredState,
@@ -1721,19 +1550,13 @@ async function executeDriveRound(args) {
             dlg: dialog,
             prompt: effectivePrompt,
         });
-        // Only park into the special interjection resumption-panel state when this user turn has
-        // suppressed a still-pending inter-dialog reply obligation that must be reasserted later.
-        // User interjections without a parked original task should simply finish and fall back to the
-        // dialog's true underlying state, without showing the special resumption panel.
-        //
         // Q4H answers are explicitly outside this branch even though they also come from the human.
         // They belong to the askHuman reply channel and must continue the suspended askHuman round,
         // never be mistaken for ad hoc interjection chat.
         shouldPauseAfterLocalUserInterjection =
             effectivePrompt?.origin === 'user' &&
                 !replyGuidance.isQ4HAnswerPrompt &&
-                replyGuidance.suppressInterDialogReplyGuidance &&
-                replyGuidance.deferredReplyReassertionDirective !== undefined;
+                replyGuidance.suppressInterDialogReplyGuidance;
         activeTellaskReplyDirective =
             replyGuidance.activeReplyDirective ?? replyContinuationScope.directive();
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
@@ -1822,50 +1645,50 @@ async function executeDriveRound(args) {
         }
         let tailError;
         try {
-            if (shouldPauseAfterLocalUserInterjection &&
-                effectivePrompt?.origin === 'user' &&
+            if (dialog instanceof dialog_1.SideDialog &&
+                driveResult &&
                 !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,
+                driveResult.fbrConclusion === undefined &&
+                driveResult.lastAssistantAnsweringContent !== null &&
+                driveResult.lastAssistantAnsweringContent.trim() !== '' &&
+                resolveDirectFallbackResponse({ driveResult, dialog }) === undefined &&
+                followUp === undefined) {
+                const suspension = await dialog.getSuspensionStatus();
+                const backgroundCalleeBlocksImplicitReply = suspension.backgroundCalleeDialogs &&
+                    !activePromptWasReplyToolReminder &&
+                    !activePromptCarriesReplyDirective;
+                if (!suspension.canDrive || backgroundCalleeBlocksImplicitReply) {
+                    log_1.log.debug('kernel-driver skip sideDialog answering reminder while tellaskee is not finalized', undefined, {
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        waitingQ4H: suspension.q4h,
+                        backgroundCalleeDialogs: suspension.backgroundCalleeDialogs,
+                        backgroundCalleeBlocksImplicitReply,
                     });
-                    if (answeredUserInterjection !== undefined) {
-                        const language = (0, work_language_1.getWorkLanguage)();
-                        const prompt = await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+                }
+                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: deferredReplyReassertion.directive,
+                            directive: activeTellaskReplyDirective,
                             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,
-                        });
-                    }
+                        }),
+                        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,
+                    });
                 }
             }
             if (dialog instanceof dialog_1.SideDialog &&

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

@@ -11,7 +11,6 @@ export declare function resolveReminderContextBusinessState(args: {
     followingMessage: ReminderContextFollowingMessage;
     pendingUserInterjectionReply: boolean;
     hasCompletedHandoffWithoutPendingReply: boolean;
-    hasDeferredReplyReassertion: boolean;
     hasActiveReplyObligation: boolean;
 }): ReminderContextBusiness;
 export declare function resolveReminderContextFooterStateFromSignals(args: {
@@ -21,6 +20,5 @@ export declare function resolveReminderContextFooterStateFromSignals(args: {
     contextHealth: ContextHealthSnapshot | undefined;
     pendingUserInterjectionReply: boolean;
     hasCompletedHandoffWithoutPendingReply: boolean;
-    hasDeferredReplyReassertion: boolean;
     hasActiveReplyObligation: boolean;
 }): ReminderContextFooterState;

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

@@ -49,9 +49,6 @@ function resolveReminderContextBusinessState(args) {
         if (args.hasCompletedHandoffWithoutPendingReply) {
             return { kind: 'user_followup_after_completed_handoff' };
         }
-        if (args.hasDeferredReplyReassertion) {
-            return { kind: 'pending_user_interjection_with_parked_reply' };
-        }
         if (args.hasActiveReplyObligation) {
             return { kind: 'pending_user_interjection_with_active_reply' };
         }
@@ -75,7 +72,6 @@ function resolveReminderContextFooterStateFromSignals(args) {
             followingMessage,
             pendingUserInterjectionReply: args.pendingUserInterjectionReply,
             hasCompletedHandoffWithoutPendingReply: args.hasCompletedHandoffWithoutPendingReply,
-            hasDeferredReplyReassertion: args.hasDeferredReplyReassertion,
             hasActiveReplyObligation: args.hasActiveReplyObligation,
         }),
     };

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

@@ -1,4 +1,4 @@
-import type { AnswerToHumanItem, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
+import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
 import type { KernelDriverPrompt } from './types';
 export declare function resolveReplyTargetAgentId(args: {
@@ -11,7 +11,6 @@ export declare function resolvePromptReplyGuidance(args: {
     language?: 'zh' | 'en';
 }): Promise<{
     activeReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
-    deferredReplyReassertionDirective: KernelDriverPrompt['tellaskReplyDirective'];
     isQ4HAnswerPrompt: boolean;
     promptContent: string | undefined;
     persistedTellaskReplyDirective: KernelDriverPrompt['tellaskReplyDirective'];
@@ -21,9 +20,3 @@ export declare function resolvePromptReplyGuidance(args: {
 export declare function buildReplyObligationSuppressionGuide(args: {
     language: 'zh' | 'en';
 }): string;
-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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveReplyTargetAgentId = resolveReplyTargetAgentId;
 exports.resolvePromptReplyGuidance = resolvePromptReplyGuidance;
 exports.buildReplyObligationSuppressionGuide = buildReplyObligationSuppressionGuide;
-exports.buildReplyObligationReassertionPrompt = buildReplyObligationReassertionPrompt;
 const dialog_1 = require("../../dialog");
 const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const persistence_1 = require("../../persistence");
@@ -33,8 +32,8 @@ function buildPromptContentWithExactReplyToolName(args) {
     const reminderPrefixes = [
         reply_prompt_copy_1.REPLY_TOOL_REMINDER_PREFIX_EN,
         reply_prompt_copy_1.REPLY_TOOL_REMINDER_PREFIX_ZH,
-        reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
-        reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
+        reply_prompt_copy_1.ANSWERING_REPLY_REMINDER_PREFIX_EN,
+        reply_prompt_copy_1.ANSWERING_REPLY_REMINDER_PREFIX_ZH,
     ];
     const directive = args.activeReplyDirective;
     if (!directive) {
@@ -204,18 +203,16 @@ function resolvePromptPersistedReplyDirective(args) {
 }
 async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
     // WARNING:
-    // This suppression decision is not a cosmetic prompt tweak. It is one leg of the full
-    // interjection-pause state machine:
-    // 1. user interjection suppresses the live reply obligation here;
-    // 2. `flow.ts` answers locally and stores a deferred reply reassertion;
-    // 3. after a visible local answer, the driver reasserts the reply obligation automatically.
+    // This suppression decision is not a cosmetic prompt tweak. A real user interjection should be
+    // answered locally before old reply obligations or pending callee work pull the model back into
+    // earlier handoff closure.
     //
     // Do not "simplify" this into a pure display-state check or a pure active-callee check.
     // Proceeding dialogs with a still-active reply obligation are part of the same rule: a fresh
     // user interjection should still suppress the live reply obligation and answer locally first.
-    // The business anchor is the deferred reply reassertion. A stale paused execution marker still
-    // means a repeated interjection should behave as local side conversation, but it is not durable
-    // drive work and must not force a manual Continue after the answer is visible.
+    // A stale paused execution marker still means a repeated interjection should behave as local
+    // side conversation, but it is not durable drive work and must not force a manual Continue after
+    // the answer is visible.
     const prompt = args.prompt;
     if (!prompt) {
         return false;
@@ -227,9 +224,6 @@ async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
         return false;
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
-    if (latest?.deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task') {
-        return true;
-    }
     if (latest?.executionMarker?.kind === 'interrupted' &&
         (0, interjection_pause_stop_1.isUserInterjectionPauseStopReason)(latest.executionMarker.reason)) {
         return true;
@@ -290,9 +284,6 @@ async function resolvePromptReplyGuidance(args) {
             });
     return {
         activeReplyDirective,
-        deferredReplyReassertionDirective: suppressInterDialogReplyGuidance
-            ? availableReplyDirective
-            : undefined,
         isQ4HAnswerPrompt,
         promptContent,
         persistedTellaskReplyDirective: resolvePromptPersistedReplyDirective({
@@ -310,13 +301,3 @@ async function resolvePromptReplyGuidance(args) {
 function buildReplyObligationSuppressionGuide(args) {
     return (0, reply_prompt_copy_1.buildReplyObligationSuppressionGuideText)(args.language);
 }
-async function buildReplyObligationReassertionPrompt(args) {
-    return (0, reply_prompt_copy_1.buildReplyObligationReassertionText)({
-        language: args.language,
-        directive: args.directive,
-        replyTargetAgentId: await resolveReplyTargetAgentId({
-            dlg: args.dlg,
-            directive: args.directive,
-        }),
-    });
-}

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

@@ -331,10 +331,6 @@ async function supplyResponseToAskerDialog(args) {
                 };
                 await persistence_1.DialogPersistence.appendEvent(sideDialogId, calleeResponseRef.course, replyResolutionRecord, callerDialog.status);
                 await persistence_1.DialogPersistence.markReplyDeliveryDelivered(sideDialogId, args.replyResolution.callId, replyResolutionRecord.ts, callerDialog.status);
-                const deferredReplyReassertion = await persistence_1.DialogPersistence.getDeferredReplyReassertion(sideDialogId, callerDialog.status);
-                if (deferredReplyReassertion?.directive.targetCallId === resolvedCallId) {
-                    await persistence_1.DialogPersistence.setDeferredReplyReassertion(sideDialogId, undefined, callerDialog.status);
-                }
                 const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(sideDialogId, callerDialog.status);
                 if (activeReplyObligation?.targetCallId === resolvedCallId) {
                     await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(sideDialogId, undefined, callerDialog.status);

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -1,4 +1,4 @@
-import { type DialogReplyDeliveryState, type TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
+import { type AnswerToHumanItem, type DialogReplyDeliveryState, type TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
 import type { ChatMessage, FuncCallMsg, FuncResultMsg } from '../client';
 import type { KernelDriverDriveCallbacks } from './types';
@@ -13,7 +13,7 @@ export type TellaskRoutingParseResult = {
     type: 'C';
     agentId: string;
 };
-declare const TELLASK_SPECIAL_FUNCTION_NAMES: readonly ["tellaskBack", "tellask", "tellaskSessionless", "replyTellask", "replyTellaskSessionless", "replyTellaskBack", "askHuman", "freshBootsReasoning"];
+declare const TELLASK_SPECIAL_FUNCTION_NAMES: readonly ["tellaskBack", "tellask", "tellaskSessionless", "replyTellask", "replyTellaskSessionless", "replyTellaskBack", "askHuman", "answerHuman", "freshBootsReasoning"];
 export type TellaskCallFunctionName = (typeof TELLASK_SPECIAL_FUNCTION_NAMES)[number];
 export type TellaskCall = Readonly<{
     callId: string;
@@ -48,6 +48,10 @@ export type TellaskCall = Readonly<{
     callId: string;
     callName: 'askHuman';
     tellaskContent: string;
+}> | Readonly<{
+    callId: string;
+    callName: 'answerHuman';
+    answerContent: string;
 }> | Readonly<{
     callId: string;
     callName: 'freshBootsReasoning';
@@ -103,6 +107,20 @@ export declare function formatResolvedTellaskFuncResultContent(args: {
     status: 'pending' | 'completed' | 'failed';
 }): string;
 export declare function formatResolvedAskHumanResultContent(): string;
+export type AnswerHumanStructuredOutput = Readonly<{
+    callId: string;
+    answerContent: string;
+    course: number;
+    genseq: number;
+    answer: AnswerToHumanItem;
+}>;
+export declare function recordAnswerToHuman(args: {
+    dlg: Dialog;
+    answerContent: string;
+    course: number;
+    genseq: number;
+    answerIdSource: string;
+}): Promise<AnswerToHumanItem>;
 export declare function executeTellaskCalls(args: {
     dlg: Dialog;
     calls: readonly TellaskCall[];
@@ -111,6 +129,7 @@ export declare function executeTellaskCalls(args: {
 }): Promise<{
     toolOutputs: ChatMessage[];
     successfulReplyCallIds: string[];
+    answerHumanOutputs: AnswerHumanStructuredOutput[];
 }>;
 export type TellaskFunctionRoundResult = Readonly<{
     normalCalls: readonly FuncCallMsg[];
@@ -122,6 +141,7 @@ export type TellaskFunctionRoundResult = Readonly<{
     hasImmediateTellaskOutputs: boolean;
     immediateTellaskOutputCallIds: readonly string[];
     invalidTellaskCallIds: readonly string[];
+    answerHumanOutputs: readonly AnswerHumanStructuredOutput[];
     shouldStopAfterReplyTool: boolean;
     shouldStopAfterPendingTellaskWait: boolean;
 }>;