dominds 1.26.5 → 1.27.0

package/dist/llm/kernel-driver/tellask-special.js

@@ -9,6 +9,7 @@ exports.formatTellaskInvalidCallResult = formatTellaskInvalidCallResult;
 exports.formatPendingTellaskFuncResultContent = formatPendingTellaskFuncResultContent;
 exports.formatResolvedTellaskFuncResultContent = formatResolvedTellaskFuncResultContent;
 exports.formatResolvedAskHumanResultContent = formatResolvedAskHumanResultContent;
+exports.recordAnswerToHuman = recordAnswerToHuman;
 exports.executeTellaskCalls = executeTellaskCalls;
 exports.processTellaskFunctionRound = processTellaskFunctionRound;
 const util_1 = require("util");
@@ -37,6 +38,7 @@ const TELLASK_SPECIAL_FUNCTION_NAMES = [
     'replyTellaskSessionless',
     'replyTellaskBack',
     'askHuman',
+    'answerHuman',
     'freshBootsReasoning',
 ];
 const MULTIPLE_ASKHUMAN_CALLS_ERROR = '不允许一轮多次调用 askHuman，必须单次调用问所有问题。 Do not call askHuman multiple times in one round; ask all questions in a single askHuman call.';
@@ -47,6 +49,9 @@ function isTellaskCallFunctionName(name) {
 function isReplyTellaskCallName(name) {
     return (name === 'replyTellask' || name === 'replyTellaskSessionless' || name === 'replyTellaskBack');
 }
+function usesFuncRequestedSpecialLifecycle(name) {
+    return isReplyTellaskCallName(name) || name === 'answerHuman';
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -420,6 +425,20 @@ function parseTellaskCall(call) {
                 },
             };
         }
+        case 'answerHuman': {
+            const answerContent = readRequiredStringField(args, 'answerContent');
+            if (!answerContent.ok) {
+                return answerContent;
+            }
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'answerHuman',
+                    answerContent: answerContent.value,
+                },
+            };
+        }
         case 'freshBootsReasoning': {
             const tellaskContent = readRequiredStringField(args, 'tellaskContent');
             if (!tellaskContent.ok) {
@@ -2079,6 +2098,85 @@ async function executeReplyTellaskCall(args) {
         }
     }
 }
+function formatAnswerHumanResultContent(args) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    return language === 'zh'
+        ? `已记录给人类的答复。\n\n${args.answerContent}`
+        : `Recorded the answer for the human.\n\n${args.answerContent}`;
+}
+async function recordAnswerToHuman(args) {
+    const answer = {
+        id: `a2h-${Buffer.from(args.answerIdSource).toString('base64url')}`,
+        content: args.answerContent,
+        answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        answerRef: {
+            course: (0, storage_1.toDialogCourseNumber)(args.course),
+            genseq: (0, storage_1.toCallSiteGenseqNo)(args.genseq),
+        },
+    };
+    await persistence_1.DialogPersistence.appendAnswerToHumanState(args.dlg.id, answer, args.dlg.status);
+    const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(args.dlg.id, args.dlg.status);
+    const taskDocPath = metadata?.taskDocPath ?? args.dlg.taskDocPath ?? '';
+    const event = {
+        type: 'new_a2h_answered',
+        answer: {
+            ...answer,
+            selfId: args.dlg.id.selfId,
+            rootId: args.dlg.id.rootId,
+            agentId: metadata?.agentId ?? args.dlg.agentId,
+            taskDocPath,
+        },
+    };
+    (0, evt_registry_1.postDialogEvent)(args.dlg, event);
+    await persistence_1.DialogPersistence.mutateDialogLatest(args.dlg.id, (previous) => {
+        const previousPending = previous.pendingUserInterjectionReply;
+        if (previousPending === undefined) {
+            return { kind: 'noop' };
+        }
+        const next = { ...previous };
+        delete next.pendingUserInterjectionReply;
+        return { kind: 'replace', next };
+    }, args.dlg.status);
+    return answer;
+}
+async function executeAnswerHumanCall(args) {
+    const genseq = args.dlg.activeGenSeqOrUndefined ?? 1;
+    const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
+    const answerContent = args.call.answerContent;
+    const answer = await recordAnswerToHuman({
+        dlg: args.dlg,
+        answerContent,
+        course,
+        genseq,
+        answerIdSource: [
+            args.dlg.id.rootId,
+            args.dlg.id.selfId,
+            `c${String(course)}`,
+            `g${String(genseq)}`,
+            `answerHuman:${args.call.callId}`,
+            args.call.callId,
+        ].join('|'),
+    });
+    return {
+        messages: [
+            {
+                type: 'func_result_msg',
+                role: 'tool',
+                genseq,
+                id: args.call.callId,
+                name: args.call.callName,
+                content: formatAnswerHumanResultContent({ answerContent }),
+            },
+        ],
+        answering: {
+            callId: args.call.callId,
+            answerContent,
+            course,
+            genseq,
+            answer,
+        },
+    };
+}
 function toExecutableValidTellaskCall(call) {
     switch (call.callName) {
         case 'tellaskBack':
@@ -2118,6 +2216,12 @@ function toExecutableValidTellaskCall(call) {
                 tellaskContent: call.tellaskContent,
                 callId: call.callId,
             };
+        case 'answerHuman':
+            return {
+                callName: call.callName,
+                answerContent: call.answerContent,
+                callId: call.callId,
+            };
         case 'freshBootsReasoning':
             return {
                 callName: call.callName,
@@ -2130,6 +2234,7 @@ function toExecutableValidTellaskCall(call) {
 async function executeValidTellaskCalls(args) {
     const results = [];
     const successfulReplyCallIds = [];
+    const answerHumanOutputs = [];
     const deferredScheduleCalls = [];
     const registrationPhaseCallbacks = {
         driveDialog: args.callbacks.driveDialog,
@@ -2148,11 +2253,12 @@ async function executeValidTellaskCalls(args) {
                 case 'replyTellaskSessionless':
                 case 'replyTellaskBack':
                 case 'askHuman':
+                case 'answerHuman':
                 case 'freshBootsReasoning':
                     return undefined;
             }
         })();
-        if (!isReplyTellaskCallName(call.callName)) {
+        if (!usesFuncRequestedSpecialLifecycle(call.callName)) {
             const nonReplyCall = call;
             const sessionSlug = nonReplyCall.callName === 'tellask' ? nonReplyCall.sessionSlug : undefined;
             await emitTellaskCallEvents({
@@ -2190,6 +2296,15 @@ async function executeValidTellaskCalls(args) {
                 results.push(replyResult.messages);
                 continue;
             }
+            case 'answerHuman': {
+                const answerResult = await executeAnswerHumanCall({
+                    dlg: args.dlg,
+                    call,
+                });
+                results.push(answerResult.messages);
+                answerHumanOutputs.push(answerResult.answering);
+                continue;
+            }
             case 'tellask': {
                 const targetAgentId = call.targetAgentId;
                 if (targetAgentId.trim() === '') {
@@ -2239,11 +2354,12 @@ async function executeValidTellaskCalls(args) {
     return {
         toolOutputs: results.flatMap((result) => result),
         successfulReplyCallIds,
+        answerHumanOutputs,
     };
 }
 async function executeTellaskCalls(args) {
     if (args.calls.length === 0) {
-        return { toolOutputs: [], successfulReplyCallIds: [] };
+        return { toolOutputs: [], successfulReplyCallIds: [], answerHumanOutputs: [] };
     }
     return await executeValidTellaskCalls({
         dlg: args.dlg,
@@ -2316,7 +2432,7 @@ async function processTellaskFunctionRound(args) {
         if (disposition.kind === 'valid') {
             const handled = disposition.handled;
             await args.dlg.persistTellaskCall(handled.originalCall.id, handled.call.callName, getRawArgumentsText(handled.originalCall), handled.originalCall.genseq, {
-                deliveryMode: isReplyTellaskCallName(handled.call.callName)
+                deliveryMode: usesFuncRequestedSpecialLifecycle(handled.call.callName)
                     ? 'func_call_requested'
                     : 'tellask_call_start',
                 ...(isReplyTellaskCallName(handled.call.callName) &&
@@ -2415,7 +2531,8 @@ async function processTellaskFunctionRound(args) {
             tellaskFuncResultByCallId.set(result.id, result);
             tellaskFuncResults.push(result);
             const originatingCall = specialCallById.get(result.id);
-            if (originatingCall !== undefined && isReplyTellaskCallName(originatingCall.callName)) {
+            if (originatingCall !== undefined &&
+                usesFuncRequestedSpecialLifecycle(originatingCall.callName)) {
                 continue;
             }
             hasImmediateTellaskOutputs = true;
@@ -2483,6 +2600,7 @@ async function processTellaskFunctionRound(args) {
         hasImmediateTellaskOutputs,
         immediateTellaskOutputCallIds,
         invalidTellaskCallIds: orderedInvalidCalls.map((issue) => issue.originalCall.id),
+        answerHumanOutputs: tellaskExecution.answerHumanOutputs,
         shouldStopAfterReplyTool: tellaskExecution.successfulReplyCallIds.length > 0,
         shouldStopAfterPendingTellaskWait,
     };

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 { AnswerToHumanItem, CallSiteCourseNo, CallSiteGenseqNo, DialogBusinessContinuation } from '@longrun-ai/kernel/types/storage';
+import type { 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';
@@ -96,10 +96,11 @@ export type KernelDriverCoreResult = {
     lastAssistantSayingGenseq: number | null;
     lastAssistantThinkingContent: string | null;
     lastAssistantThinkingGenseq: number | null;
+    lastAssistantAnsweringContent: string | null;
+    lastAssistantAnsweringGenseq: number | null;
     lastFunctionCallGenseq: number | null;
     lastAssistantReplyTarget?: KernelDriverCalleeReplyTarget;
     lastBusinessContinuation: DialogBusinessContinuation;
-    answeredUserInterjection?: AnswerToHumanItem;
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;

package/dist/minds/system-prompt.js

@@ -212,13 +212,13 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
     const lines = [
         ...pickLocalized(language, {
             zh: [
-                '- Tellask 统一走函数工具通道：`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`。',
+                '- Tellask special 统一走函数工具通道：`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman` / `freshBootsReasoning`。',
                 '- 对队友诉请默认使用 `tellask` 并复用 `sessionSlug`；仅在确认一次性诉请足够、且后续不需要更新任务安排/提前收口时才使用 `tellaskSessionless`，并需说明理由。',
                 '- 并行协调默认允许：不要把智能体队友当成真人同事；祂不会因为你又发一条诉请而被打扰。同一个队友 + 同一个 `sessionSlug` = 接着同一件事说；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。',
                 '- 例外优先级（强制）：`tellaskBack` 仅用于回问诉请者，不适用队友长线默认规则，也不携带 `sessionSlug`。',
             ],
             en: [
-                '- Tellask must use the function-tool channel: `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `freshBootsReasoning`.',
+                '- Tellask special calls must use the function-tool channel: `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman` / `freshBootsReasoning`.',
                 '- For teammate tellasks, default to `tellask` and continue with the same `sessionSlug`; use `tellaskSessionless` only when a one-shot is truly sufficient and later assignment updates / early wrap-up are not needed.',
                 '- Parallel coordination is allowed by default: do not treat an agent teammate like a human coworker who can only handle one conversation at a time. Same teammate + same `sessionSlug` = continue the same task; `tellaskSessionless` or a different `sessionSlug` = another independent task.',
                 '- Mandatory exception precedence: `tellaskBack` is ask-back-only and outside the teammate-session default; it does not carry `sessionSlug`.',
@@ -246,7 +246,7 @@ function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
         zh: [
             '- FBR 由 `freshBootsReasoning` 触发，不属于普通队友诉请分类；请按本节规则执行。',
             '- FBR 不可调用 `tellaskBack`；其回贴标记由 Dominds 在跨对话传递正文中自动注入。',
-            '- FBR 禁止一切 tellask（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
+            '- FBR 禁止一切 tellask-special（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman`）。',
             '- 当用户明确要求“做一次 FBR/扪心自问”，对话主理人必须发起 `freshBootsReasoning`。',
             fbrContextHealthRule,
             '- FBR 的标准入口是 `freshBootsReasoning({ tellaskContent, effort? })`；禁止用 `tellask` / `tellaskSessionless` 对自己发起 self-target 诉请来替代。',
@@ -263,7 +263,7 @@ function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
         en: [
             '- FBR is triggered by `freshBootsReasoning`, not by normal teammate tellasks; follow this section’s rules.',
             '- FBR cannot call `tellaskBack`; its reply marker is injected by Dominds into the inter-dialog transfer payload.',
-            '- FBR forbids all tellask calls (including `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
+            '- FBR forbids all tellask-special calls (including `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman`).',
             '- When the user explicitly requests “do an FBR / fresh boots reasoning”, the Dialog Responder must call `freshBootsReasoning`.',
             fbrContextHealthRule,
             '- The standard FBR entry is `freshBootsReasoning({ tellaskContent, effort? })`; do not emulate FBR via self-targeted `tellask` / `tellaskSessionless`.',
@@ -287,6 +287,7 @@ function buildTellaskInteractionRules(language) {
             '- `tellask`：用于可恢复的长线诉请（必须提供 `targetAgentId` / `sessionSlug` / `tellaskContent`）。',
             '- `tellaskSessionless`：用于一次性诉请（必须提供 `targetAgentId` / `tellaskContent`）；它不能接着旧任务改要求，后续再次调用只是另一件独立任务，不会影响旧任务继续执行，也不会打扰同一队友正在执行的其它独立诉请。不要把智能体队友当成需要排队说话的真人同事。',
             '- `askHuman`：用于 Q4H（向人类请求必要澄清/决策/授权/缺失输入）。',
+            '- `answerHuman`：用于把当前要给人类看的答复记录为 A2H（answer to human）；不要用它向队友回贴。',
             '- `freshBootsReasoning`：用于发起扪心自问（FBR）支线（`tellaskContent` 必填，`effort` 可选）。',
         ],
         en: [
@@ -294,6 +295,7 @@ function buildTellaskInteractionRules(language) {
             '- `tellask`: resumable tellask (requires `targetAgentId` / `sessionSlug` / `tellaskContent`).',
             '- `tellaskSessionless`: one-shot tellask (requires `targetAgentId` / `tellaskContent`); it cannot continue an earlier task or change its requirements. Later calls are separate tasks and do not affect earlier work for the same teammate. Do not treat agent teammates like human coworkers who need you to wait in line to talk.',
             '- `askHuman`: Q4H for necessary clarification/decision/authorization/missing input.',
+            '- `answerHuman`: record the current human-facing answer as A2H (answer to human); do not use it to reply to teammates.',
             '- `freshBootsReasoning`: starts an FBR Side Dialog (requires `tellaskContent`, optional `effort`).',
         ],
     });
@@ -406,6 +408,7 @@ function buildSystemPrompt(input) {
 - 回问诉请：支线对话用 \`tellaskBack\` 回问诉请者以澄清。
 - 扪心自问（FBR）：由 \`freshBootsReasoning\` 触发的“无工具”支线推理机制。
 - 向人请示（Q4H）：通过 \`askHuman\` 向人类请求必要的澄清/决策/授权/缺失输入。
+- 答复人类（A2H）：通过 \`answerHuman\` 记录当前要给人类看的答复。
 - 长线诉请：使用 \`tellask\` + \`sessionSlug\` 的可恢复多轮协作。
 - 一次性诉请：一次性、不可恢复的诉请。
 - 主线对话：承载共享差遣牒并负责整体推进的对话。
@@ -466,7 +469,7 @@ ${input.toolsetManualIntro}
 
 ## 交互协议
 
-### Tellask Special Functions（队友/FBR/Q4H）
+### Tellask Special Functions（队友/FBR/Q4H/A2H）
 ${tellaskInteractionRules}
 
 ### 函数工具（仅原生 function-calling）
@@ -505,6 +508,7 @@ System notices convey important state changes (e.g., context caution/critical, D
 - TellaskBack: a Side Dialog uses \`tellaskBack\` to ask the tellasker for clarification.
 - Fresh Boots Reasoning (FBR): a tool-less Side Dialog reasoning mechanism triggered by \`freshBootsReasoning\`.
 - Q4H (Question for Human): use \`askHuman\` to request necessary clarification/decision/authorization/missing input from a human.
+- A2H (Answer to Human): use \`answerHuman\` to record the current human-facing answer.
 - Tellask Session: resumable multi-turn work using \`tellask\` with \`sessionSlug\`.
 - Fresh Tellask: a one-shot, non-resumable Tellask.
 - Main Dialog: the dialog that owns the shared Taskdoc and overall progress.
@@ -565,7 +569,7 @@ ${input.toolsetManualIntro}
 
 ## Interaction Protocols
 
-### Tellask Special Functions (teammates/FBR/Q4H)
+### Tellask Special Functions (teammates/FBR/Q4H/A2H)
 ${tellaskInteractionRules}
 
 ### Function Tools (native function-calling only)

package/dist/persistence.d.ts

@@ -157,7 +157,7 @@ export declare class DiskFileDialogStore extends DialogStore {
      * Persist a function call to storage
      */
     persistFunctionCall(dialog: Dialog, id: string, name: string, rawArgumentsText: string, genseq: number, rawId?: string): Promise<void>;
-    persistTellaskCall(dialog: Dialog, id: string, name: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | 'askHuman' | 'freshBootsReasoning', rawArgumentsText: string, genseq: number, options?: {
+    persistTellaskCall(dialog: Dialog, id: string, name: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | 'askHuman' | 'answerHuman' | 'freshBootsReasoning', rawArgumentsText: string, genseq: number, options?: {
         deliveryMode?: 'tellask_call_start' | 'func_call_requested';
         replyDirective?: TellaskReplyDirective;
     }): Promise<void>;
@@ -710,8 +710,6 @@ export declare class DialogPersistence {
     static removeNextStepTriggers(dialogId: DialogID, predicate: (trigger: DialogNextStepTrigger) => boolean, status?: DialogStatusKind): Promise<void>;
     static hasPendingNextStepTriggers(dialogId: DialogID, status?: DialogStatusKind): Promise<boolean>;
     static clearPendingRuntimePrompt(dialogId: DialogID, msgId: string, status?: DialogStatusKind): Promise<void>;
-    static setDeferredReplyReassertion(dialogId: DialogID, deferredReplyReassertion: DialogLatestFile['deferredReplyReassertion'], status?: DialogStatusKind): Promise<void>;
-    static getDeferredReplyReassertion(dialogId: DialogID, status?: DialogStatusKind): Promise<DialogLatestFile['deferredReplyReassertion']>;
     /**
      * Get course filename from course number
      */
@@ -752,6 +750,7 @@ export declare class DialogPersistence {
         course: number;
         pending: DialogLatestFile['pendingUserInterjectionReply'];
     }): AnswerToHumanItem | undefined;
+    private static answerRefSettlesPendingUserInterjection;
     private static normalizeDialogLatestPendingUserInterjectionReply;
     /**
      * Reconstruct dialog state from JSONL events (optimized: only latest course needed).

package/dist/persistence.js

@@ -1909,6 +1909,7 @@ function isTellaskCallIndexCallName(value) {
         value === 'replyTellaskSessionless' ||
         value === 'replyTellaskBack' ||
         value === 'askHuman' ||
+        value === 'answerHuman' ||
         value === 'freshBootsReasoning');
 }
 function parseDialogTellaskCallState(value) {
@@ -2243,36 +2244,6 @@ function parseDialogLatestFile(value) {
     })();
     if (fbrState === null)
         return null;
-    const deferredReplyReassertionRaw = value.deferredReplyReassertion;
-    const deferredReplyReassertion = (() => {
-        if (deferredReplyReassertionRaw === undefined)
-            return undefined;
-        if (!isRecord(deferredReplyReassertionRaw))
-            return null;
-        if (deferredReplyReassertionRaw.reason !== 'user_interjection_with_parked_original_task') {
-            return null;
-        }
-        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;
-        }
-        return {
-            reason: 'user_interjection_with_parked_original_task',
-            directive,
-            userInterjection,
-            ...(resumeGuideSurfacedRaw === undefined
-                ? {}
-                : { resumeGuideSurfaced: resumeGuideSurfacedRaw }),
-        };
-    })();
-    if (deferredReplyReassertion === null)
-        return null;
     const pendingRuntimePromptRaw = value.pendingRuntimePrompt;
     const pendingRuntimePrompt = (() => {
         if (pendingRuntimePromptRaw === undefined)
@@ -2301,7 +2272,6 @@ function parseDialogLatestFile(value) {
         latestAssignmentAnchor,
         sideDialogFinalResponse,
         fbrState,
-        deferredReplyReassertion,
         pendingUserInterjectionReply,
         pendingRuntimePrompt,
         disableDiligencePush: value.disableDiligencePush,
@@ -2456,20 +2426,6 @@ function isAnswerToHumanItem(value) {
         return false;
     if (typeof value.answeredAt !== 'string')
         return false;
-    if (!isRecord(value.userInterjection))
-        return false;
-    if (typeof value.userInterjection.msgId !== 'string')
-        return false;
-    if (typeof value.userInterjection.course !== 'number')
-        return false;
-    if (!Number.isInteger(value.userInterjection.course) || value.userInterjection.course <= 0) {
-        return false;
-    }
-    if (typeof value.userInterjection.genseq !== 'number')
-        return false;
-    if (!Number.isInteger(value.userInterjection.genseq) || value.userInterjection.genseq <= 0) {
-        return false;
-    }
     if (!isRecord(value.answerRef))
         return false;
     if (typeof value.answerRef.course !== 'number')
@@ -2595,6 +2551,7 @@ function isTellaskCallFunctionName(name) {
         name === 'replyTellaskSessionless' ||
         name === 'replyTellaskBack' ||
         name === 'askHuman' ||
+        name === 'answerHuman' ||
         name === 'freshBootsReasoning');
 }
 /**
@@ -3635,10 +3592,6 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             targetCallId: payload.targetCallId,
         };
         await this.appendEvent(dialog, course, record);
-        const deferredReplyReassertion = await DialogPersistence.getDeferredReplyReassertion(dialog.id, dialog.status);
-        if (deferredReplyReassertion?.directive.targetCallId === payload.targetCallId) {
-            await DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
-        }
         const activeObligation = await DialogPersistence.loadActiveTellaskReplyObligation(dialog.id, dialog.status);
         if (activeObligation?.targetCallId === payload.targetCallId) {
             await DialogPersistence.setActiveTellaskReplyObligation(dialog.id, undefined, dialog.status);
@@ -6583,7 +6536,15 @@ class DialogPersistence {
                     filePath: answersFilePath,
                 });
             }
-            return parsed.answers;
+            return parsed.answers.map((answer) => ({
+                id: answer.id,
+                content: answer.content,
+                answeredAt: answer.answeredAt,
+                answerRef: {
+                    course: answer.answerRef.course,
+                    genseq: answer.answerRef.genseq,
+                },
+            }));
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT')
@@ -6668,9 +6629,6 @@ class DialogPersistence {
         if (answerId === '') {
             throw new Error(`A2H append invariant violation: empty answer id (dialog=${dialogId.valueOf()})`);
         }
-        if (answer.content.trim() === '') {
-            throw new Error(`A2H append invariant violation: empty answer content (dialog=${dialogId.valueOf()} answerId=${answer.id})`);
-        }
         await this.mutateAnswersToHumanState(dialogId, (previousAnswers) => {
             const existing = previousAnswers.find((item) => item.id === answer.id);
             if (existing) {
@@ -9191,23 +9149,6 @@ class DialogPersistence {
             };
         }, status);
     }
-    static async setDeferredReplyReassertion(dialogId, deferredReplyReassertion, status = 'running') {
-        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);
-        return latest?.deferredReplyReassertion;
-    }
     // === FILE SYSTEM UTILITIES ===
     /**
      * Get course filename from course number
@@ -9400,21 +9341,31 @@ class DialogPersistence {
             id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
             content: lastVisibleAnswer.content,
             answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            userInterjection: {
-                msgId: pendingUserInterjectionReply.msgId,
-                course: pendingUserInterjectionReply.course,
-                genseq: pendingUserInterjectionReply.genseq,
-            },
             answerRef: {
                 course: (0, storage_1.toDialogCourseNumber)(args.course),
                 genseq: (0, storage_1.toCallSiteGenseqNo)(lastVisibleAnswer.genseq),
             },
         };
     }
+    static answerRefSettlesPendingUserInterjection(answerRef, pending) {
+        if (pending === undefined) {
+            return false;
+        }
+        if (answerRef.course > pending.course) {
+            return true;
+        }
+        return answerRef.course === pending.course && answerRef.genseq >= pending.genseq;
+    }
     static async normalizeDialogLatestPendingUserInterjectionReply(dialogId, status, latest) {
         if (latest.pendingUserInterjectionReply === undefined) {
             return latest;
         }
+        const existingAnswers = await this.loadAnswersToHumanState(dialogId, status);
+        if (existingAnswers.some((answer) => this.answerRefSettlesPendingUserInterjection(answer.answerRef, latest.pendingUserInterjectionReply))) {
+            const next = { ...latest };
+            delete next.pendingUserInterjectionReply;
+            return next;
+        }
         const events = await this.readCourseEvents(dialogId, latest.currentCourse, status);
         const normalizedPending = this.resolvePendingUserInterjectionReplyFromCourseEvents(events, latest.currentCourse);
         if (normalizedPending === undefined) {
@@ -9425,7 +9376,6 @@ class DialogPersistence {
                 pending: latest.pendingUserInterjectionReply,
             });
             if (recoveredAnswer !== undefined) {
-                const existingAnswers = await this.loadAnswersToHumanState(dialogId, status);
                 if (!existingAnswers.some((item) => item.id === recoveredAnswer.id)) {
                     await this.appendAnswerToHumanState(dialogId, recoveredAnswer, status);
                 }

package/dist/runtime/driver-messages.d.ts

@@ -41,8 +41,6 @@ export type ReminderContextBusiness = Readonly<{
     kind: 'pending_user_interjection';
 }> | Readonly<{
     kind: 'pending_user_interjection_with_active_reply';
-}> | Readonly<{
-    kind: 'pending_user_interjection_with_parked_reply';
 }> | Readonly<{
     kind: 'user_followup_after_completed_handoff';
 }>;

package/dist/runtime/driver-messages.js

@@ -218,10 +218,6 @@ function formatZhReminderBusinessTail(business) {
             // would block a valid user request and recreate the same kind of over-specific guidance
             // bug in the opposite direction.
             return '现在是用户在追问你。前面那件转交任务已经回报完成了，不需要再推进；请按用户这条消息正常交流和处理。';
-        case 'pending_user_interjection_with_parked_reply':
-            // A real user message interrupted an unfinished handoff. The old handoff is parked,
-            // so the model must not rush back to reply closure before the user sees an answer.
-            return '当前仍有真实用户插话尚未得到可见回复，且原有回贴任务已暂存；先完成对用户插话的回应，不要抢先切回原来的回贴收口。';
         case 'pending_user_interjection':
             // No special handoff state is competing with the user; the shortest useful instruction
             // is simply to answer the still-unanswered user interjection.
@@ -263,10 +259,6 @@ function formatEnReminderBusinessTail(business) {
             // would block a valid user request and recreate the same kind of over-specific guidance
             // bug in the opposite direction.
             return 'The user is asking you a follow-up now. The earlier handed-off task has already been reported back as complete, so there is nothing more to advance there. Talk with the user normally and handle this current message.';
-        case 'pending_user_interjection_with_parked_reply':
-            // A real user message interrupted an unfinished handoff. The old handoff is parked,
-            // so the model must not rush back to reply closure before the user sees an answer.
-            return "There is still a real user interjection without a visible reply, and the earlier handoff is parked; finish answering the user's interjection first, and do not switch back to closing the earlier reply yet.";
         case 'pending_user_interjection':
             // No special handoff state is competing with the user; the shortest useful instruction
             // is simply to answer the still-unanswered user interjection.
@@ -958,7 +950,7 @@ function formatDomindsNoteFbrToollessViolation(language, args) {
             `Dominds 提示：当前是扪心自问（FBR）支线对话（无工具模式）。${detail}`,
             '',
             '- 本对话无任何工具：禁止函数工具调用。',
-            '- 本对话禁止任何 tellask-special 函数（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
+            '- 本对话禁止任何 tellask-special 函数（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman`）。',
             '- 请只基于诉请正文（以及本支线对话自身的会话历史，如有）进行推理与总结。',
         ].join('\n');
     }
@@ -974,7 +966,7 @@ function formatDomindsNoteFbrToollessViolation(language, args) {
         `Dominds note: this is a tool-less FBR Side Dialog (triggered by \`freshBootsReasoning\`). ${detail}`,
         '',
         '- No tools are available: do not emit function tool calls.',
-        '- No tellask-special functions are allowed (`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
+        '- No tellask-special functions are allowed (`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman` / `answerHuman`).',
         '- Provide pure reasoning and a summary grounded in the tellask body (and this Side Dialog’s own tellaskSession history, if any).',
     ].join('\n');
 }

package/dist/runtime/interjection-pause-stop.js

@@ -5,13 +5,12 @@ exports.isUserInterjectionPauseStopReason = isUserInterjectionPauseStopReason;
 const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_original_task';
 // WARNING:
 // This special stop reason is only a UI/run-control projection for legacy paused-interjection
-// state. New answered-interjection flow reasserts the reply obligation automatically instead of
-// depending on this stop reason. It is intentionally encoded as `system_stop`, but it does NOT mean
-// the same thing as ordinary system-stop failure semantics.
+// state. New answered-interjection flow depends on pending interjection settlement plus ordinary
+// drive rules instead of this stop reason. It is intentionally encoded as `system_stop`, but it
+// does NOT mean the same thing as ordinary system-stop failure semantics.
 //
-// Not every user interjection should use this reason. If there is no parked original task to
-// resume afterwards, the interjection should simply complete and the dialog should fall back to
-// its true underlying state without showing this resumption panel.
+// New user interjections should simply complete and the dialog should fall back to its true
+// underlying state without showing this legacy resumption panel.
 //
 // In particular, askHuman answers are NOT "user interjections" for this purpose. A prompt carrying
 // a real `q4hAnswerCallId` belongs to the askHuman reply channel and must never be routed through
@@ -19,8 +18,8 @@ const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_orig
 //
 // Do not change this file in isolation. The complete behavior depends on coordinated logic across:
 // - `reply-guidance.ts`          suppressing tellasker reply obligation during interjection chat
-// - `flow.ts`                   answering locally, then automatically reasserting reply obligation
-// - `dialog-display-state.ts`   preserving legacy paused projection until Continue
+// - `flow.ts`                   answering locally, then using ordinary continuation rules
+// - `dialog-display-state.ts`   preserving legacy paused projection until Continue during recovery
 // - `websocket-handler.ts`      treating Continue as "resume attempt" rather than immediate success
 //
 // Reading only this stop reason or only `displayState.kind === 'stopped'` gives an incomplete and