dominds 1.26.6 → 1.27.0

package/dist/docs/dialog-system.md

@@ -159,34 +159,37 @@ This ensures crash recovery and enables the backend to resume from any persisted
 
 When a dialog still carries an inter-dialog reply obligation, but the user temporarily interjects and asks it to handle a local question first, the system must distinguish between the **UI projection** and the **true driving source state**.
 
-Plainly: the system should answer the user's interjection first. Once the user receives a visible answer, the backend records that answer as A2H (Answer to Human) in Human Attention so the user can find and acknowledge it even if the dialog immediately continues automatically.
+Plainly: the system should answer the user's interjection first. Once the user receives a visible answer, the backend records that answer as A2H (Answer to Human) in Human Attention so the user can find and acknowledge it even if the dialog immediately continues automatically. In addition to recovering A2H from visible `saying`, the LLM may also produce structured `answering` output (or call the equivalent `answerHuman` tool entry) to create A2H directly.
 
 **Normative semantics**:
 
 1. Every user interjection message is driven as a complete normal round.
 2. If that round needs tools, the system MUST finish the full tool round and any post-tool follow-up before treating the interjection as answered.
 3. A visible assistant `saying` settles the pending user-interjection reply only when no same-round function/tellask call remains after that `saying`.
-4. Settling the interjection appends an A2H item to the dialog's `a2h.yaml`. A2H is an acknowledgement queue, not a problem report and not durable drive work.
-5. If an inter-dialog reply obligation still exists after the interjection is answered, the backend automatically reasserts that obligation and continues. The user should not need to click `Continue` merely because the interjection answer completed.
-6. A2H disappears when the user acknowledges it. This is intentionally "read then burn"; the canonical answer remains in the dialog transcript at `answerRef`.
+4. The model may also produce structured `answering` output (or call `answerHuman({ answerContent })`) to express "this is an answer for the human." That output is always appended to the dialog's `a2h.yaml`, but it is not the same thing as a Side Dialog's formal reply to its requester.
+5. If an inter-dialog reply obligation still exists after the interjection is answered, it remains ordinary durable reply-obligation state. Subsequent continuation is driven by the normal business paths: queued prompts, reply reminders, diligence push, or explicit resume when the dialog is genuinely blocked.
+6. A2H disappears when the user acknowledges it. This is intentionally "read then burn"; `answerRef` only links back to the course/genseq that produced the answer. When A2H comes from visible `saying`, the canonical text remains in the transcript; when it comes from structured `answering`, the A2H item itself carries that one-way output text.
 7. The Human Attention panel shows Q4H and A2H together. Q4H waits for a human answer; A2H waits only for human acknowledgement.
 
 **Strict boundary**: a formal `askHuman` answer is not part of this "user interjection" category. As soon as a prompt carries a real `q4hAnswerCallId`, it belongs to the askHuman reply channel and semantically continues an already-materialized question/answer chain; it must never be downgraded into temporary local side-chat.
 
+**Modeling boundary**: Dominds does not structurally model "current human question context", does not maintain coordinates for "which human question this A2H answers", and does not store `userInterjection` coordinates in A2H. `a2h` / `answering` is only one-way structured modeling at the LLM output layer: the model produced text meant for the human, and the runtime put it into the human-acknowledgement queue. Questions, interjections, task obligations, and continuation duties remain represented by existing business facts such as prompts, Q4H, reply obligations, and queued prompts.
+
 **Key point**: pending user-interjection reply and inter-dialog reply obligation are independent business facts. Reminder/footer copy can use those two facts directly: if the interjection is still pending, prioritize answering the user; if it is settled and the reply obligation remains active, continue toward the required inter-dialog closure.
 
 **Mental-model warning**:
 
 - Do not flatten every `origin === 'user'` prompt into "interjection"; a non-empty `q4hAnswerCallId` means askHuman answer continuation and follows a different semantic path.
 - Do not treat A2H as Q4H. A2H does not block drive and does not route input to an agent.
+- Do not treat A2H as a "human question context" database. A2H only carries answer text, acknowledgement state, and answer provenance.
 - Do not store A2H in the Problems panel. It belongs to Human Attention and is removed by Ack.
 
 You need all of the following together to understand the behavior correctly:
 
-- reply-guidance suppression / deferred reassertion for interjection turns
+- reply-guidance suppression for interjection turns
 - pending user-interjection reply settlement after visible final `saying`
 - A2H persistence and Ack flow
-- automatic reply-obligation reassertion after the user-visible answer
+- ordinary continuation through active reply obligations, diligence push, and queued prompts after the user-visible answer
 
 This is an intentionally cross-module semantic contract. Do not locally "simplify" one piece based only on its surface meaning.
 

package/dist/docs/dialog-system.zh.md

@@ -158,34 +158,37 @@ askerDialog 可以在执行期间接收来自当前需向它回复的支线对
 
 当某个对话仍带有跨对话回复义务，但用户临时插话要求它先处理本地问题时，系统必须区分**UI 投影**与**真实驱动源状态**。
 
-直白地说：先把用户这次插话接住并答完。用户看到可见答复后，后端把这条答复记录成 A2H（Answer to Human）放进“待人处理”，这样即使对话马上自动续推，用户也能找到并确认已阅。
+直白地说：先把用户这次插话接住并答完。用户看到可见答复后，后端把这条答复记录成 A2H（Answer to Human）放进“待人处理”，这样即使对话马上自动续推，用户也能找到并确认已阅。除了从可见 `saying` 恢复 A2H 之外，LLM 还可以产生结构化 `answering` 输出（或调用等价的 `answerHuman` 工具入口）直接形成 A2H。
 
 **规范语义**：
 
 1. 每条用户插话消息都按正常驱动轮完整执行。
 2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up，之后才可认为插话已答完。
-3. 只有当模型产生可见 `saying`，且该 `saying` 后同轮没有普通 function/tellask call 继续挂起时，才清除“待回复用户插话”。
-4. 清除该状态时，把答复追加到该对话的 `a2h.yaml`。A2H 是待人确认队列，不是 Problems，也不是持久驱动工作。
-5. 如果插话答完后仍有跨对话回复义务，后端自动重申并继续推进；用户不应仅因为插话答完而需要手工点 `Continue`。
-6. 用户 Ack 以后 A2H 立即消失，语义是“阅后即焚”；答复正文的真源仍在对话 transcript 中，由 `answerRef` 回链定位。
+3. 只有当模型产生可见 `saying`，且该 `saying` 后同轮没有普通 function/tellask call 继续挂起时，才用这条 `saying` 结算“待回复用户插话”。
+4. 模型也可以产生结构化 `answering` 输出（或调用 `answerHuman({ answerContent })`）来表达“这是给人类看的答复”。该输出无条件追加到该对话的 `a2h.yaml`，但它不等价于支线对话对诉请者的正式回贴。
+5. 如果插话答完后仍有跨对话回复义务，它保持为普通的 durable reply-obligation 状态；后续由正常业务路径推进：queued prompt、回贴提醒、鞭策续推，或在对话确实阻塞时由显式 resume 触发。
+6. 用户 Ack 以后 A2H 立即消失，语义是“阅后即焚”；`answerRef` 只回链到产生答复的 course/genseq，用于定位来源生成轮。若 A2H 来自可见 `saying`，正文真源仍在 transcript 中；若来自结构化 `answering`，A2H 条目本身承载该单向输出正文。
 7. “待人处理”面板同时显示 Q4H 与 A2H：Q4H 等人回答，A2H 只等人确认已阅。
 
 **严格边界**：`askHuman` 的正式回答不属于这里的“用户插话”。只要一条 prompt 带着真实的 `q4hAnswerCallId`，它就属于 askHuman 回复通道，语义上是在继续已 materialize 的提问/应答链路，绝不能被压入“本地临时插话聊天”。
 
+**建模边界**：Dominds 不对“当前人类问题上下文”做结构化业务建模，不维护“这个 A2H 回答的是哪一个人类问题”的坐标，也不把 `userInterjection` 坐标写进 A2H。`a2h` / `answering` 只是 LLM 输出层面的单向结构化建模：模型产生一段给人类看的答复，运行时把它放入待人确认队列。问题/插话/任务义务本身仍由既有 prompt、Q4H、reply obligation、queued prompt 等业务事实表达。
+
 **关键点**：“是否还有用户插话待可见回复”和“是否还有跨对话回复义务”是两个独立业务事实。提醒项 footer 可以直接用这两个事实定制：插话尚未答复时优先答人；插话已答复且回复义务仍 active 时，继续按跨对话回贴要求收口。
 
 **心智模型提醒**：
 
 - 更不能把所有 `origin === 'user'` 的输入都笼统视作“用户插话”；`q4hAnswerCallId` 非空的 prompt 是 askHuman answer continuation，必须按另一条语义链处理。
 - 不能把 A2H 当成 Q4H；A2H 不阻塞 drive，也不把输入路由给智能体。
+- 不能把 A2H 当成“人类问题上下文”数据库；A2H 只有答复正文、确认状态与答复来源定位。
 - 不能把 A2H 放进 Problems 面板；它属于“待人处理”，由 Ack 删除。
 
 必须把以下几块一起看，才能形成完整且精确的理解：
 
-- reply-guidance 中对插话轮的回复义务 suppression / deferred reassertion
+- reply-guidance 中对插话轮的回复义务 suppression
 - 可见最终 `saying` 后对 pending user-interjection reply 的结算
 - A2H 持久化与 Ack 流程
-- 用户可见答复后的跨对话回复义务自动重申
+- 用户可见答复后的 active reply obligation、鞭策续推、queued prompt 等普通续推路径
 
 这是一条跨模块协同语义，不允许在单点上做“表面看起来更简单”的局部简化。
 

package/dist/llm/gen/mock.js

@@ -71,10 +71,10 @@ const RUNTIME_PROMPT_WRAPPER_PREFIXES = [
     '【系统提示】 上下文状态：🔴 告急；收到用户插话',
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN,
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH,
+    reply_prompt_copy_1.ANSWERING_REPLY_REMINDER_PREFIX_EN,
+    reply_prompt_copy_1.ANSWERING_REPLY_REMINDER_PREFIX_ZH,
     reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_EN,
     reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_ZH,
-    reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
-    reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
     reply_prompt_copy_1.REPLY_SUPPRESSION_PREFIX_EN,
     reply_prompt_copy_1.REPLY_SUPPRESSION_PREFIX_ZH,
 ];
@@ -485,6 +485,9 @@ responses:
             }
             await receiver.sayingFinish();
         }
+        if (matched?.answeringResponse !== undefined && matched.answeringResponse.trim() !== '') {
+            await receiver.answering?.(matched.answeringResponse);
+        }
         const funcCalls = matched?.funcCalls ?? [];
         for (let i = 0; i < funcCalls.length; i++) {
             const call = funcCalls[i];
@@ -606,6 +609,9 @@ responses:
                 kind: 'invalid_func_call',
                 call,
             }));
+            const answeringOutputs = matched?.answeringResponse !== undefined && matched.answeringResponse.trim() !== ''
+                ? [{ kind: 'answering', content: matched.answeringResponse }]
+                : [];
             const messages = thinking !== undefined
                 ? saying
                     ? [thinking, saying, ...funcMsgs]
@@ -615,10 +621,11 @@ responses:
                     : [...funcMsgs];
             return {
                 messages,
-                ...(invalidFuncCallOutputs.length > 0
+                ...(invalidFuncCallOutputs.length > 0 || answeringOutputs.length > 0
                     ? {
                         outputs: [
                             ...messages.map((message) => ({ kind: 'message', message })),
+                            ...answeringOutputs,
                             ...invalidFuncCallOutputs,
                         ],
                     }

package/dist/llm/gen.d.ts

@@ -20,6 +20,9 @@ export declare class LlmStreamErrorEmittedError extends Error {
 export type LlmBatchOutput = {
     kind: 'message';
     message: ChatMessage;
+} | {
+    kind: 'answering';
+    content: string;
 } | {
     kind: 'invalid_func_call';
     call: LlmInvalidFuncCall;
@@ -156,6 +159,7 @@ export interface LlmStreamReceiver {
     sayingStart: () => Promise<void>;
     sayingChunk: (chunk: string) => Promise<void>;
     sayingFinish: () => Promise<void>;
+    answering?: (content: string) => Promise<void>;
     funcCall: (callId: string, name: string, args: string, ids?: {
         rawCallId?: string;
         effectiveCallId?: string;

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

@@ -257,18 +257,14 @@ function isUserOriginPrompt(prompt) {
 }
 async function resolveReminderContextFooterState(args) {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
-    const deferredReplyReassertion = latest?.deferredReplyReassertion;
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dlg.id, args.dlg.status);
     const pendingUserInterjectionReply = latest?.pendingUserInterjectionReply !== undefined;
-    const hasDeferredReplyReassertion = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task';
     const hasActiveReplyObligation = activeReplyObligation !== undefined;
     // Business scenario: a user can reopen a completed Side Dialog to ask a follow-up. A recorded
-    // final response with no active/parked reply task means the old handoff has already been
+    // final response with no active reply task means the old handoff has already been
     // reported back; if a real user message is now present, the footer should say "talk with the
     // user now" instead of making the model infer that from old transcript/reminder context.
-    const hasCompletedHandoffWithoutPendingReply = latest?.sideDialogFinalResponse !== undefined &&
-        !hasDeferredReplyReassertion &&
-        !hasActiveReplyObligation;
+    const hasCompletedHandoffWithoutPendingReply = latest?.sideDialogFinalResponse !== undefined && !hasActiveReplyObligation;
     const dialogScope = args.dlg instanceof dialog_1.SideDialog ? { kind: 'side_dialog' } : { kind: 'main_dialog' };
     return (0, reminder_context_1.resolveReminderContextFooterStateFromSignals)({
         dialogScope,
@@ -277,7 +273,6 @@ async function resolveReminderContextFooterState(args) {
         contextHealth: args.dlg.getLastContextHealth(),
         pendingUserInterjectionReply,
         hasCompletedHandoffWithoutPendingReply,
-        hasDeferredReplyReassertion,
         hasActiveReplyObligation,
     });
 }
@@ -343,11 +338,6 @@ async function maybeResolveAnsweredUserInterjection(args) {
         id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
         content: args.assistantSayingContent,
         answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        userInterjection: {
-            msgId: pending.msgId,
-            course: pending.course,
-            genseq: pending.genseq,
-        },
         answerRef: {
             course,
             genseq: args.assistantSayingGenseq,
@@ -706,6 +696,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
         name: 'askHuman',
+        followupMode: 'deferred',
         description: 'Ask for required clarification/decision from human.',
         parameters: {
             type: 'object',
@@ -719,6 +710,23 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
             throw new Error('askHuman is handled by kernel-driver tellask-special channel');
         },
     },
+    {
+        type: 'func',
+        name: 'answerHuman',
+        followupMode: 'deferred',
+        description: 'Record the current human-facing answer for human attention.',
+        parameters: {
+            type: 'object',
+            properties: {
+                answerContent: { type: 'string' },
+            },
+            required: ['answerContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('answerHuman is handled by kernel-driver tellask-special channel');
+        },
+    },
 ];
 const CONTEXT_HEALTH_TOOL_RESULT_VISIBLE_BYTE_LIMIT = 2000;
 const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH = '这次函数返回内容太大，清理头脑之前不会显示给你。';
@@ -991,20 +999,6 @@ async function renderRemindersForContext(dlg) {
         ...renderedItems,
     ];
 }
-function hasSameReplyDirective(left, right) {
-    if (!left || !right) {
-        return left === right;
-    }
-    if (left.expectedReplyCallName !== right.expectedReplyCallName) {
-        return false;
-    }
-    if (left.targetDialogId !== right.targetDialogId ||
-        left.targetCallId !== right.targetCallId ||
-        left.tellaskContent !== right.tellaskContent) {
-        return false;
-    }
-    return true;
-}
 function buildPendingTellaskFuncResult(args) {
     return {
         type: 'func_result_msg',
@@ -1321,6 +1315,25 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
+async function recordStructuredAnswering(args) {
+    if (args.content.trim() === '')
+        return undefined;
+    const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
+    const genseq = args.dlg.activeGenSeqOrUndefined ?? 1;
+    return await (0, tellask_special_1.recordAnswerToHuman)({
+        dlg: args.dlg,
+        answerContent: args.content,
+        course,
+        genseq,
+        answerIdSource: [
+            args.dlg.id.rootId,
+            args.dlg.id.selfId,
+            `c${String(course)}`,
+            `g${String(genseq)}`,
+            args.source,
+        ].join('|'),
+    });
+}
 function formatInvalidFuncCallRuntimeGuide(language, call) {
     const rawName = call.rawFunctionName !== undefined && call.rawFunctionName.trim() !== ''
         ? call.rawFunctionName.trim()
@@ -2051,6 +2064,7 @@ async function executeFunctionRound(args) {
             shouldStopAfterPendingTellaskWait: false,
             pairedMessages: [],
             tellaskToolOutputs: [],
+            answerHumanOutputs: [],
         };
     }
     throwIfAborted(args.abortSignal, args.dlg);
@@ -2064,6 +2078,7 @@ async function executeFunctionRound(args) {
             'replyTellaskSessionless',
             'replyTellaskBack',
             'askHuman',
+            'answerHuman',
             'freshBootsReasoning',
             ...(allowTellaskBack ? ['tellaskBack'] : []),
         ])
@@ -2167,6 +2182,7 @@ async function executeFunctionRound(args) {
         shouldStopAfterPendingTellaskWait: tellaskRound.shouldStopAfterPendingTellaskWait,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
+        answerHumanOutputs: tellaskRound.answerHumanOutputs,
     };
 }
 async function preserveDiligenceBudgetAcrossQ4H(dlg) {
@@ -2362,10 +2378,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let lastAssistantSayingGenseq = null;
     let lastAssistantThinkingContent = null;
     let lastAssistantThinkingGenseq = null;
+    let lastAssistantAnsweringContent = null;
+    let lastAssistantAnsweringGenseq = null;
     let lastFunctionCallGenseq = null;
     let lastAssistantReplyTarget;
     let lastBusinessContinuation = { kind: 'none' };
-    let answeredUserInterjection;
     let currentPromptIsUserInterjection = false;
     let currentUserInterjectionReply;
     let fbrConclusion;
@@ -2639,62 +2656,23 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             prompt: currentPrompt,
                             language: promptLanguage,
                         });
-                        const deferredReplyReassertionDirective = replyGuidance.deferredReplyReassertionDirective;
                         currentPromptIsUserInterjection =
                             currentPrompt.origin === 'user' &&
                                 replyGuidance.suppressInterDialogReplyGuidance &&
-                                deferredReplyReassertionDirective !== undefined;
+                                !replyGuidance.isQ4HAnswerPrompt;
                         if (currentPromptIsUserInterjection) {
-                            // WARNING:
-                            // User interjection suppression is a reversible state transition, not a one-shot
-                            // latch. The normal cycle is:
-                            // - user interjects -> suppress reply obligation
-                            // - the visible local answer auto-reasserts the reply obligation
-                            // - user interjects again -> suppress it again
-                            //
-                            // 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: 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);
-                            }
-                            if (mustRearmDeferredReplyReassertion) {
-                                currentRuntimeGuideMsg = replyGuidance.transientGuideContent
-                                    ? {
-                                        type: 'transient_guide_msg',
-                                        role: 'assistant',
-                                        content: replyGuidance.transientGuideContent,
-                                    }
-                                    : undefined;
-                            }
-                        }
-                        else if (currentPrompt.origin === 'user' &&
-                            !replyGuidance.suppressInterDialogReplyGuidance) {
-                            await persistence_1.DialogPersistence.setDeferredReplyReassertion(dlg.id, undefined, dlg.status);
+                            currentRuntimeGuideMsg = replyGuidance.transientGuideContent
+                                ? {
+                                    type: 'transient_guide_msg',
+                                    role: 'assistant',
+                                    content: replyGuidance.transientGuideContent,
+                                }
+                                : undefined;
                         }
                         if (!replyGuidance.suppressInterDialogReplyGuidance &&
                             !currentRuntimeGuideMsg &&
@@ -2984,6 +2962,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         let streamAttemptSayingGenseq;
                         let streamAttemptThinkingContent;
                         let streamAttemptThinkingGenseq;
+                        let streamAttemptAnsweringContent;
+                        let streamAttemptAnsweringGenseq;
                         let streamActive = { kind: 'idle' };
                         const rollbackStreamAttempt = async () => {
                             if (streamAttemptCourse === undefined ||
@@ -3005,6 +2985,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             streamAttemptSayingGenseq = undefined;
                             streamAttemptThinkingContent = undefined;
                             streamAttemptThinkingGenseq = undefined;
+                            streamAttemptAnsweringContent = undefined;
+                            streamAttemptAnsweringGenseq = undefined;
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
                             streamedFuncCalls.length = 0;
@@ -3117,6 +3099,35 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 streamAttemptSayingContent = currentSayingContent;
                                 streamAttemptSayingGenseq = sayingMessage.genseq;
                             },
+                            answering: async (content) => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'idle') {
+                                    const detail = `Protocol violation: answering while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                if (content.trim() !== '') {
+                                    if (streamAttemptAnsweringContent !== undefined) {
+                                        const detail = 'Protocol violation: multiple answering outputs in one generation';
+                                        await dlg.streamError(detail);
+                                        throw new gen_1.LlmStreamErrorEmittedError({
+                                            detail,
+                                            i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                                detail,
+                                                kind: 'conflicting_stream',
+                                            }),
+                                        });
+                                    }
+                                    streamAttemptAnsweringContent = content;
+                                    streamAttemptAnsweringGenseq = dlg.activeGenSeq;
+                                }
+                            },
                             funcCall: async (callId, name, argsStr, ids) => {
                                 throwIfAborted(abortSignal, dlg);
                                 const rawCallId = trimOptionalCallId(ids?.rawCallId) ?? callId;
@@ -3190,6 +3201,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 streamAttemptSayingGenseq = undefined;
                                 streamAttemptThinkingContent = undefined;
                                 streamAttemptThinkingGenseq = undefined;
+                                streamAttemptAnsweringContent = undefined;
+                                streamAttemptAnsweringGenseq = undefined;
                                 sawWebSearchSideChannelOutput = false;
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
@@ -3208,6 +3221,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     msg.content.trim() !== '');
                                 const hasFunctionCall = streamedFuncCalls.length > 0;
                                 if (!hasFinishedMessageContent &&
+                                    streamAttemptAnsweringContent === undefined &&
                                     !hasFunctionCall &&
                                     invalidFuncCallCount === 0 &&
                                     !sawWebSearchSideChannelOutput &&
@@ -3235,6 +3249,20 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 lastAssistantReplyTarget = currentReplyTarget;
                             }
                         }
+                        if (streamAttemptAnsweringContent !== undefined) {
+                            const answer = await recordStructuredAnswering({
+                                dlg,
+                                content: streamAttemptAnsweringContent,
+                                source: 'structured-answering',
+                            });
+                            if (answer !== undefined) {
+                                lastAssistantAnsweringContent = answer.content;
+                                lastAssistantAnsweringGenseq =
+                                    streamAttemptAnsweringGenseq === undefined
+                                        ? answer.answerRef.genseq
+                                        : streamAttemptAnsweringGenseq;
+                            }
+                        }
                         return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
                     const previousAssistantSayingGenseq = lastAssistantSayingGenseq;
@@ -3256,6 +3284,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : Array.isArray(llmOutput.batchMessages)
                             ? llmOutput.batchMessages.map((message) => ({ kind: 'message', message }))
                             : [];
+                    let batchAnsweringSeen = false;
                     for (const output of batchOutputs) {
                         switch (output.kind) {
                             case 'message': {
@@ -3283,6 +3312,33 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 }
                                 break;
                             }
+                            case 'answering': {
+                                if (output.content.trim() === '') {
+                                    break;
+                                }
+                                if (batchAnsweringSeen) {
+                                    const detail = 'Protocol violation: multiple answering outputs in one generation';
+                                    await dlg.streamError(detail);
+                                    throw new gen_1.LlmStreamErrorEmittedError({
+                                        detail,
+                                        i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                                            detail,
+                                            kind: 'conflicting_stream',
+                                        }),
+                                    });
+                                }
+                                batchAnsweringSeen = true;
+                                const answer = await recordStructuredAnswering({
+                                    dlg,
+                                    content: output.content,
+                                    source: 'structured-answering',
+                                });
+                                if (answer !== undefined) {
+                                    lastAssistantAnsweringContent = answer.content;
+                                    lastAssistantAnsweringGenseq = answer.answerRef.genseq;
+                                }
+                                break;
+                            }
                             case 'invalid_func_call': {
                                 invalidFuncCallCount += 1;
                                 await persistInvalidFuncCallRuntimeGuide({
@@ -3323,6 +3379,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             c.name === 'tellaskSessionless' ||
                             c.name === 'tellaskBack' ||
                             c.name === 'askHuman' ||
+                            c.name === 'answerHuman' ||
                             c.name === 'freshBootsReasoning').length
                         : 0;
                     const policyViolationKind = (0, guardrails_1.resolveKernelDriverPolicyViolationKind)({
@@ -3354,6 +3411,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 lastAssistantSayingGenseq,
                                 lastAssistantThinkingContent,
                                 lastAssistantThinkingGenseq,
+                                lastAssistantAnsweringContent,
+                                lastAssistantAnsweringGenseq,
                                 lastFunctionCallGenseq,
                                 lastAssistantReplyTarget,
                                 lastBusinessContinuation,
@@ -3396,9 +3455,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0)
                             continue;
                         const callGenseq = Math.floor(rawCallGenseq);
-                        currentRoundFunctionCallGenseqs.push(callGenseq);
-                        if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
-                            lastFunctionCallGenseq = callGenseq;
+                        if (call.name !== 'answerHuman') {
+                            currentRoundFunctionCallGenseqs.push(callGenseq);
+                            if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
+                                lastFunctionCallGenseq = callGenseq;
+                            }
                         }
                     }
                     const userInterjectionMsgIdForVisibleAnswer = currentPrompt?.origin === 'user' && !isQ4HAnswerPrompt
@@ -3406,7 +3467,29 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : currentGenerationBelongsToUserToolChain
                             ? currentUserPromptMsgId
                             : undefined;
-                    if (userInterjectionMsgIdForVisibleAnswer !== undefined) {
+                    const routed = await executeFunctionRound({
+                        dlg,
+                        agent,
+                        agentTools,
+                        funcCalls: streamedFuncCalls,
+                        callbacks,
+                        abortSignal,
+                        allowTellaskFunctions: policy.allowTellaskFunctions,
+                        activePromptReplyDirective: currentPrompt?.tellaskReplyDirective,
+                        contextHealthForToolResultVisibility: pickContextHealthForLargeToolResultVisibility({
+                            previous: contextHealthBeforeGen,
+                            current: contextHealthForGen,
+                        }),
+                    });
+                    for (const answering of routed.answerHumanOutputs) {
+                        lastAssistantAnsweringContent = answering.answerContent;
+                        lastAssistantAnsweringGenseq = answering.genseq;
+                    }
+                    const currentRoundAnsweringGenseq = dlg.activeGenSeqOrUndefined;
+                    const hasCurrentRoundAnsweringOutput = currentRoundAnsweringGenseq !== undefined &&
+                        lastAssistantAnsweringGenseq === currentRoundAnsweringGenseq;
+                    if (userInterjectionMsgIdForVisibleAnswer !== undefined &&
+                        !hasCurrentRoundAnsweringOutput) {
                         const streamedCurrentRoundSayingContent = batchOutputs.length === 0 &&
                             lastAssistantSayingGenseq !== previousAssistantSayingGenseq
                             ? lastAssistantSayingContent
@@ -3415,31 +3498,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             lastAssistantSayingGenseq !== previousAssistantSayingGenseq
                             ? lastAssistantSayingGenseq
                             : null;
-                        const answer = await maybeResolveAnsweredUserInterjection({
+                        await maybeResolveAnsweredUserInterjection({
                             dlg,
                             userPromptMsgId: userInterjectionMsgIdForVisibleAnswer,
                             assistantSayingContent: currentRoundAssistantSayingContent ?? streamedCurrentRoundSayingContent,
                             assistantSayingGenseq: currentRoundAssistantSayingGenseq ?? streamedCurrentRoundSayingGenseq,
                             functionCallGenseqs: currentRoundFunctionCallGenseqs,
                         });
-                        if (answer !== undefined) {
-                            answeredUserInterjection = answer;
-                        }
                     }
-                    const routed = await executeFunctionRound({
-                        dlg,
-                        agent,
-                        agentTools,
-                        funcCalls: streamedFuncCalls,
-                        callbacks,
-                        abortSignal,
-                        allowTellaskFunctions: policy.allowTellaskFunctions,
-                        activePromptReplyDirective: currentPrompt?.tellaskReplyDirective,
-                        contextHealthForToolResultVisibility: pickContextHealthForLargeToolResultVisibility({
-                            previous: contextHealthBeforeGen,
-                            current: contextHealthForGen,
-                        }),
-                    });
                     if (routed.tellaskToolOutputs.length > 0) {
                         newMsgs.push(...routed.tellaskToolOutputs);
                     }
@@ -3869,10 +3935,11 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
         lastAssistantSayingGenseq,
         lastAssistantThinkingContent,
         lastAssistantThinkingGenseq,
+        lastAssistantAnsweringContent,
+        lastAssistantAnsweringGenseq,
         lastFunctionCallGenseq,
         lastAssistantReplyTarget,
         lastBusinessContinuation,
-        answeredUserInterjection,
         fbrConclusion,
     };
 }