dominds 1.27.3 → 1.27.5

package/dist/dialog-fork.js

@@ -483,9 +483,10 @@ async function appendForkBaselineState(plan, baselineSideDialogCreatedRecords) {
             ownerName: reminder.owner?.name,
             meta: reminder.meta,
             echoback: reminder.echoback,
-            scope: reminder.scope ?? 'dialog',
+            scope: reminder.scope,
             createdAt: reminder.createdAt ?? baselineTs,
             priority: reminder.priority ?? 'medium',
+            renderMode: reminder.renderMode,
         })),
     };
     const q4hRecord = {

package/dist/dialog.d.ts

@@ -21,7 +21,7 @@ import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } fro
 import type { ToolResultImageIngest, UserImageIngest } from './llm/gen';
 import { type SharedReminderTarget } from './shared-reminders';
 import type { JsonValue } from './tool';
-import { Reminder, ReminderOptions, ReminderOwner } from './tool';
+import { Reminder, ReminderOptions, ReminderOwner, ReminderUpdateOptions } from './tool';
 export declare class InvalidReminderIndexError extends Error {
     readonly index: number;
     readonly total: number;
@@ -265,9 +265,9 @@ export declare abstract class Dialog {
      * Post a dialog event using the standard event registry.
      */
     postEvent(event: DialogEvent): void;
-    addReminder(content: string, owner?: ReminderOwner, meta?: JsonValue, position?: number, options?: ReminderOptions): Reminder;
+    addReminder(content: string, owner: ReminderOwner | undefined, meta: JsonValue | undefined, position: number | undefined, options: ReminderOptions): Reminder;
     deleteReminder(index: number): Reminder;
-    updateReminder(index: number, content: string, meta?: JsonValue, options?: ReminderOptions): Reminder;
+    updateReminder(index: number, content: string, meta?: JsonValue, options?: ReminderUpdateOptions): Reminder;
     clearReminders(): void;
     listVisibleReminderTargets(): Promise<VisibleReminderTarget[]>;
     listVisibleReminders(): Promise<Reminder[]>;

package/dist/dialog.js

@@ -478,13 +478,16 @@ class Dialog {
     //
     // Reminder management methods
     addReminder(content, owner, meta, position, options) {
+        if (options === undefined) {
+            throw new Error('Dialog.addReminder requires explicit reminder options');
+        }
         const reminder = (0, tool_1.materializeReminder)({
             content,
             owner,
             meta,
-            echoback: options?.echoback,
-            scope: options?.scope ?? 'dialog',
-            renderMode: options?.renderMode,
+            echoback: options.echoback,
+            scope: options.scope,
+            renderMode: options.renderMode,
         });
         const insertIndex = position !== undefined ? position : this.reminders.length;
         if (insertIndex < 0 || insertIndex > this.reminders.length) {
@@ -651,7 +654,7 @@ class Dialog {
             renderRevision: (0, tool_1.computeReminderRenderRevision)(r),
             echoback: (0, tool_1.reminderEchoBackEnabled)(r),
             scope: r.scope,
-            renderMode: r.renderMode ?? 'markdown',
+            renderMode: r.renderMode,
         }));
     }
     emitFullRemindersUpdate(reminders) {

package/dist/docs/dialog-system.md

@@ -159,21 +159,21 @@ 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. 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.
+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. A2H may also carry a human-facing status explanation when the expected action is to stop and wait, such as while pending active callees are still running.
 
 **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. 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.
+4. The model may also produce structured `answering` output (or call `answerHuman({ answerContent })`) to express "this is an answer or status 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.
+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 A2H item. 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.
+**Modeling boundary**: Dominds does not structurally model "current human question context", does not maintain coordinates for "which human question or status boundary this A2H addresses", 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, wait boundaries, task obligations, and continuation duties remain represented by existing business facts such as prompts, Q4H, reply obligations, active callees, 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.
 

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

@@ -158,21 +158,21 @@ askerDialog 可以在执行期间接收来自当前需向它回复的支线对
 
 当某个对话仍带有跨对话回复义务，但用户临时插话要求它先处理本地问题时，系统必须区分**UI 投影**与**真实驱动源状态**。
 
-直白地说：先把用户这次插话接住并答完。用户看到可见答复后，后端把这条答复记录成 A2H（Answer to Human）放进“待人处理”，这样即使对话马上自动续推，用户也能找到并确认已阅。除了从可见 `saying` 恢复 A2H 之外，LLM 还可以产生结构化 `answering` 输出（或调用等价的 `answerHuman` 工具入口）直接形成 A2H。
+直白地说：先把用户这次插话接住并答完。用户看到可见答复后，后端把这条答复记录成 A2H（Answer to Human）放进“待人处理”，这样即使对话马上自动续推，用户也能找到并确认已阅。除了从可见 `saying` 恢复 A2H 之外，LLM 还可以产生结构化 `answering` 输出（或调用等价的 `answerHuman` 工具入口）直接形成 A2H。当预期动作是停下来等待时，A2H 也可以承载给人类看的状态说明，例如仍有 pending active callees 在运行。
 
 **规范语义**：
 
 1. 每条用户插话消息都按正常驱动轮完整执行。
 2. 若该轮需要工具，则必须先完整跑完该工具轮及其 post-tool follow-up，之后才可认为插话已答完。
 3. 只有当模型产生可见 `saying`，且该 `saying` 后同轮没有普通 function/tellask call 继续挂起时，才用这条 `saying` 结算“待回复用户插话”。
-4. 模型也可以产生结构化 `answering` 输出（或调用 `answerHuman({ answerContent })`）来表达“这是给人类看的答复”。该输出无条件追加到该对话的 `a2h.yaml`，但它不等价于支线对话对诉请者的正式回贴。
+4. 模型也可以产生结构化 `answering` 输出（或调用 `answerHuman({ answerContent })`）来表达“这是给人类看的答复或状态说明”。该输出无条件追加到该对话的 `a2h.yaml`，但它不等价于支线对话对诉请者的正式回贴。
 5. 如果插话答完后仍有跨对话回复义务，它保持为普通的 durable reply-obligation 状态；后续由正常业务路径推进：queued prompt、回贴提醒、鞭策续推，或在对话确实阻塞时由显式 resume 触发。
-6. 用户 Ack 以后 A2H 立即消失，语义是“阅后即焚”；`answerRef` 只回链到产生答复的 course/genseq，用于定位来源生成轮。若 A2H 来自可见 `saying`，正文真源仍在 transcript 中；若来自结构化 `answering`，A2H 条目本身承载该单向输出正文。
+6. 用户 Ack 以后 A2H 立即消失，语义是“阅后即焚”；`answerRef` 只回链到产生该 A2H 条目的 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 等业务事实表达。
+**建模边界**：Dominds 不对“当前人类问题上下文”做结构化业务建模，不维护“这个 A2H 对应哪一个人类问题或等待边界”的坐标，也不把 `userInterjection` 坐标写进 A2H。`a2h` / `answering` 只是 LLM 输出层面的单向结构化建模：模型产生一段给人类看的文本，运行时把它放入待人确认队列。问题/插话/等待边界/任务义务本身仍由既有 prompt、Q4H、reply obligation、active callees、queued prompt 等业务事实表达。
 
 **关键点**：“是否还有用户插话待可见回复”和“是否还有跨对话回复义务”是两个独立业务事实。提醒项 footer 可以直接用这两个事实定制：插话尚未答复时优先答人；插话已答复且回复义务仍 active 时，继续按跨对话回贴要求收口。
 

package/dist/docs/diligence-push.md

@@ -21,9 +21,12 @@ This document specifies two related runtime controls:
 - **Required tool-use control**: for ordinary main and side dialog rounds, the Diligence Push
   checkbox controls whether the provider request must end through a Dominds tool call. When checked,
   the model is expected to call a tool such as `askHuman`, `tellask*`, `replyTellask*`, or another
-  runtime-provided function instead of stopping with a plain-text question/final answer. FBR middle
-  rounds are the intentional exception: they may run with no callable tools; FBR closure requires one
-  of the conclusion tools.
+  runtime-provided function instead of stopping with a plain-text question/final answer. If no
+  substantive tool should be called, `answerHuman` is the expected completion path for that required
+  tool round. This is intentional for wait boundaries such as pending active callees: the model
+  should explain the wait state through `answerHuman` and then stop for the reply to arrive, rather
+  than continue spinning through ordinary tool calls. FBR middle rounds are the intentional
+  exception: they may run with no callable tools; FBR closure requires one of the conclusion tools.
 
 ## Goals
 

package/dist/docs/diligence-push.zh.md

@@ -12,7 +12,7 @@ Dominds 主线对话旨在长期运行。主线对话"停止"（变为空闲）
 本文档指定两个相关但不同的运行时控制：
 
 - **自动续推注入**：仅针对**主线对话**，当驱动程序即将停止、且没有 Q4H 或 pending active callee dispatch 时，运行时会自动发送一个简短的鞭策语（渲染为正常的用户气泡）并继续生成。pending tellask 是后台被诉请者事实，不是阻塞态；但在没有其它具体驱动来源时，它表示主线已经到达可 idle 的后台等待边界，不应靠鞭策语保持主线空转。
-- **强制工具调用控制**：对于普通的主线/支线对话轮次，`鞭策` 勾选项控制本轮 provider 请求是否必须通过 Dominds 工具结束。勾选时，模型应通过 `askHuman`、`tellask*`、`replyTellask*` 或其他运行时函数完成这一轮，而不是用普通文本直接收尾。FBR 中间轮是刻意例外：它们可以处于无可调用工具状态；FBR 收口阶段则必须调用两个结论工具之一。
+- **强制工具调用控制**：对于普通的主线/支线对话轮次，`鞭策` 勾选项控制本轮 provider 请求是否必须通过 Dominds 工具结束。勾选时，模型应通过 `askHuman`、`tellask*`、`replyTellask*` 或其他运行时函数完成这一轮，而不是用普通文本直接收尾。若确实没有其它实质工具应调用，`answerHuman` 就是该强制工具轮次的预期收口路径。等待 pending active callees 这类边界属于预期场景：模型应通过 `answerHuman` 说明当前等待状态，然后停止等待回贴到达，而不是继续调用普通工具空转。FBR 中间轮是刻意例外：它们可以处于无可调用工具状态；FBR 收口阶段则必须调用两个结论工具之一。
 
 ## 目标
 

package/dist/llm/api-quirks.d.ts

@@ -5,6 +5,7 @@ import type { LlmRetryStrategy } from './gen';
 export type LlmFailureKind = 'retriable' | 'rejected' | 'fatal';
 export declare const KIMI_CODE_API_QUIRK = "kimi-code";
 export declare const MINIMAX_REASONING_DETAILS_API_QUIRK = "minimax-reasoning-details";
+export declare const MINIMAX_THINKING_TYPE_API_QUIRK = "minimax-thinking-type";
 export declare const SAME_CONTEXT_EMPTY_RESPONSE_API_QUIRK = "same-context-empty-response";
 export declare const VOLCENGINE_INVALID_PARAMETER_AGGRESSIVE_RETRY_API_QUIRK = "volcengine-invalid-parameter-aggressive-retry";
 export type LlmFailureSummary = {

package/dist/llm/api-quirks.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XCODE_BEST_STREAM_INTERNAL_ERROR_CODE = exports.VOLCENGINE_INVALID_PARAMETER_AGGRESSIVE_RETRY_API_QUIRK = exports.SAME_CONTEXT_EMPTY_RESPONSE_API_QUIRK = exports.MINIMAX_REASONING_DETAILS_API_QUIRK = exports.KIMI_CODE_API_QUIRK = void 0;
+exports.XCODE_BEST_STREAM_INTERNAL_ERROR_CODE = exports.VOLCENGINE_INVALID_PARAMETER_AGGRESSIVE_RETRY_API_QUIRK = exports.SAME_CONTEXT_EMPTY_RESPONSE_API_QUIRK = exports.MINIMAX_THINKING_TYPE_API_QUIRK = exports.MINIMAX_REASONING_DETAILS_API_QUIRK = exports.KIMI_CODE_API_QUIRK = void 0;
 exports.normalizeProviderApiQuirks = normalizeProviderApiQuirks;
 exports.createLlmFailureQuirkHandlerSession = createLlmFailureQuirkHandlerSession;
 const persistence_errors_1 = require("../persistence-errors");
 exports.KIMI_CODE_API_QUIRK = 'kimi-code';
 exports.MINIMAX_REASONING_DETAILS_API_QUIRK = 'minimax-reasoning-details';
+// MiniMax's `/v1` API rejects `thinking.type: 'enabled'`; rewrites the request `thinking` form to use `adaptive` instead.
+exports.MINIMAX_THINKING_TYPE_API_QUIRK = 'minimax-thinking-type';
 exports.SAME_CONTEXT_EMPTY_RESPONSE_API_QUIRK = 'same-context-empty-response';
 exports.VOLCENGINE_INVALID_PARAMETER_AGGRESSIVE_RETRY_API_QUIRK = 'volcengine-invalid-parameter-aggressive-retry';
 const DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';

package/dist/llm/defaults.yaml

@@ -177,6 +177,7 @@ providers:
     apiType: openai-compatible
     apiQuirks:
       - minimax-reasoning-details
+      - minimax-thinking-type
     baseUrl: https://api.minimaxi.com/v1
     apiKeyEnvVar: MINIMAX_CN_TP_API_KEY
     tech_spec_url: https://platform.minimaxi.com/docs/api-reference/text-openai-api
@@ -186,7 +187,7 @@ providers:
         thinking:
           prominent: true
           type: boolean|object
-          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=enabled, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
+          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=adaptive, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
         reasoning_split:
           prominent: true
           type: boolean
@@ -245,6 +246,7 @@ providers:
     apiType: openai-compatible
     apiQuirks:
       - minimax-reasoning-details
+      - minimax-thinking-type
     baseUrl: https://api.minimaxi.com/v1
     apiKeyEnvVar: MINIMAX_CN_API_KEY
     tech_spec_url: https://platform.minimaxi.com/docs/api-reference/text-openai-api
@@ -254,7 +256,7 @@ providers:
         thinking:
           prominent: true
           type: boolean|object
-          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=enabled, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
+          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=adaptive, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
         reasoning_split:
           prominent: true
           type: boolean
@@ -313,6 +315,7 @@ providers:
     apiType: openai-compatible
     apiQuirks:
       - minimax-reasoning-details
+      - minimax-thinking-type
     baseUrl: https://api.minimax.io/v1
     apiKeyEnvVar: MINIMAX_TP_API_KEY
     tech_spec_url: https://platform.minimax.io/docs/api-reference/text-openai-api
@@ -322,7 +325,7 @@ providers:
         thinking:
           prominent: true
           type: boolean|object
-          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=enabled, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
+          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=adaptive, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
         reasoning_split:
           prominent: true
           type: boolean
@@ -381,6 +384,7 @@ providers:
     apiType: openai-compatible
     apiQuirks:
       - minimax-reasoning-details
+      - minimax-thinking-type
     baseUrl: https://api.minimax.io/v1
     apiKeyEnvVar: MINIMAX_API_KEY
     tech_spec_url: https://platform.minimax.io/docs/api-reference/text-openai-api
@@ -390,7 +394,7 @@ providers:
         thinking:
           prominent: true
           type: boolean|object
-          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=enabled, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
+          description: OpenAI-compatible MiniMax thinking control. Set true to send thinking.type=adaptive, false to send thinking.type=disabled, or provide the provider-specific thinking object documented by MiniMax. Leave unset to use the provider/model default.
         reasoning_split:
           prominent: true
           type: boolean

package/dist/llm/gen/openai-compatible.js

@@ -641,6 +641,11 @@ function isMiniMaxReasoningDetailsProvider(providerConfig) {
         return false;
     return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(api_quirks_1.MINIMAX_REASONING_DETAILS_API_QUIRK);
 }
+function isMiniMaxThinkingTypeProvider(providerConfig) {
+    if (providerConfig === undefined)
+        return false;
+    return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(api_quirks_1.MINIMAX_THINKING_TYPE_API_QUIRK);
+}
 function isKimiCodeReasoningEffort(value) {
     return typeof value === 'string' && KIMI_CODE_REASONING_EFFORTS.has(value);
 }
@@ -841,7 +846,15 @@ function buildOpenAiCompatibleExtraParams(args) {
     if (thinking === undefined && reasoningEffort === undefined && reasoningSplit === undefined) {
         return {};
     }
-    const thinkingPayload = typeof thinking === 'boolean' ? { type: thinking ? 'enabled' : 'disabled' } : thinking;
+    // `thinking` is narrowed to `boolean | Record<string, unknown> | undefined` because the
+    // `string` branch threw above. MiniMax rejects `type: 'enabled'`; rewrite both the
+    // boolean true form and the explicit object form to `adaptive`.
+    const isMiniMaxThinkingType = isMiniMaxThinkingTypeProvider(args.providerConfig);
+    const thinkingPayload = typeof thinking === 'boolean'
+        ? { type: thinking ? (isMiniMaxThinkingType ? 'adaptive' : 'enabled') : 'disabled' }
+        : thinking !== undefined && isMiniMaxThinkingType && thinking.type === 'enabled'
+            ? { ...thinking, type: 'adaptive' }
+            : thinking;
     return {
         ...(thinkingPayload !== undefined ? { thinking: thinkingPayload } : {}),
         ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),

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

@@ -359,38 +359,41 @@ async function maybeResolveAnsweredUserInterjection(args) {
         return undefined;
     }
     const course = args.dlg.activeGenCourseOrUndefined ?? args.dlg.currentCourse;
-    const answerIdSource = [
-        args.dlg.id.rootId,
-        args.dlg.id.selfId,
-        `c${String(course)}`,
-        `g${String(args.assistantSayingGenseq)}`,
-        pending.msgId,
-    ].join('|');
-    const answer = {
-        id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
-        content: args.assistantSayingContent,
-        answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        answerRef: {
-            course,
-            genseq: args.assistantSayingGenseq,
-        },
-    };
-    const existingAnswers = await persistence_1.DialogPersistence.loadAnswersToHumanState(args.dlg.id, args.dlg.status);
-    if (!existingAnswers.some((item) => item.id === answer.id)) {
-        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,
+    const answer = args.recordAnswerToHuman
+        ? {
+            id: `a2h-${Buffer.from([
+                args.dlg.id.rootId,
+                args.dlg.id.selfId,
+                `c${String(course)}`,
+                `g${String(args.assistantSayingGenseq)}`,
+                pending.msgId,
+            ].join('|')).toString('base64url')}`,
+            content: args.assistantSayingContent,
+            answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            answerRef: {
+                course,
+                genseq: args.assistantSayingGenseq,
             },
-        };
-        (0, evt_registry_1.postDialogEvent)(args.dlg, event);
+        }
+        : undefined;
+    if (answer !== undefined) {
+        const existingAnswers = await persistence_1.DialogPersistence.loadAnswersToHumanState(args.dlg.id, args.dlg.status);
+        if (!existingAnswers.some((item) => item.id === answer.id)) {
+            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;
@@ -437,7 +440,7 @@ function resolveToolUseRequirement(dlg, policy) {
     // For ordinary Dominds dialog rounds, the Diligence Push checkbox controls the provider-level
     // obligation directly. The numeric Diligence Push budget only limits automatic runtime prompts;
     // it must not downgrade the round into ordinary chat where the model can stop by asking/answering
-    // in plain text instead of calling askHuman/tellask/reply tools.
+    // in plain text instead of calling askHuman/answerHuman/tellask/reply tools.
     return dlg.disableDiligencePush ? 'auto' : 'required';
 }
 function resolveModelInfo(providerCfg, model) {
@@ -746,7 +749,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
         type: 'func',
         name: 'answerHuman',
         followupMode: 'deferred',
-        description: 'Record the current human-facing answer for human attention.',
+        description: 'Record the current human-facing answer or status for human attention. Use this to finish the current required-tool round when no other substantive tool should be called, especially to explain that this dialog is waiting for pending active callees or tellask replies.',
         parameters: {
             type: 'object',
             properties: {
@@ -778,7 +781,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
                 '',
                 '不要再尝试获取各种大段的输出，都不会显示给你。现在先做两件事：',
                 '1. 把需要回传给主线对话的结论、证据定位和风险整理清楚。',
-                '2. 对于下一程恢复工作需要的信息，写入提醒项。',
+                '2. 用当前对话范围（scope=dialog）提醒项写明本路对话任务目标，并把下一程恢复当前支线工作需要的信息带过桥。',
                 '',
                 '然后调用 clear_mind({}) 开启新一程，并尽快完成当前支线回复。',
                 '',
@@ -790,7 +793,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
             '',
             '不要再尝试获取各种大段的输出，都不会显示给你。现在先做两件事：',
             '1. 把下一程对话需要知道的此程细节信息写入差遣牒合适章节。',
-            '2. 对于不适合差遣牒章节覆盖、但下一程恢复工作需要的信息写入提醒项。',
+            '2. 对于不适合差遣牒章节覆盖、但下一程恢复当前对话需要的信息，用当前对话范围（scope=dialog）提醒项写明本路对话任务目标并带过桥。',
             '',
             '然后调用 clear_mind({}) 开启新一程。',
             '',
@@ -803,7 +806,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
             '',
             'Do not try again to fetch any kind of large output; it still will not be shown. Do two things now:',
             '1. Organize the conclusions, evidence pointers, and risks that need to go back to the Mainline dialog.',
-            '2. Write any details needed to resume the next course into reminders.',
+            '2. Use current-dialog scoped (scope=dialog) reminders to state this dialog task goal and carry over the details needed to resume this Sideline dialog in the next course.',
             '',
             'Then call clear_mind({}) to start a new course, and finish the current Sideline dialog reply as soon as possible.',
             '',
@@ -815,7 +818,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
         '',
         'Do not try again to fetch any kind of large output; it still will not be shown. Do two things now:',
         '1. Write the details from this course that the next course needs into the appropriate Taskdoc sections.',
-        '2. Write information that does not fit a Taskdoc section, but is needed to resume the next course, into reminders.',
+        '2. For information that does not fit a Taskdoc section but is needed to resume this dialog in the next course, use current-dialog scoped (scope=dialog) reminders to state this dialog task goal and carry it over.',
         '',
         'Then call clear_mind({}) to start a new course.',
         '',
@@ -3825,6 +3828,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     const currentRoundAnsweringGenseq = dlg.activeGenSeqOrUndefined;
                     const hasCurrentRoundAnsweringOutput = currentRoundAnsweringGenseq !== undefined &&
                         lastAssistantAnsweringGenseq === currentRoundAnsweringGenseq;
+                    let pendingVisibleUserInterjectionAnswer;
                     if (userInterjectionMsgIdForVisibleAnswer !== undefined &&
                         !hasCurrentRoundAnsweringOutput) {
                         const streamedCurrentRoundSayingContent = batchOutputs.length === 0 &&
@@ -3835,14 +3839,25 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             lastAssistantSayingGenseq !== previousAssistantSayingGenseq
                             ? lastAssistantSayingGenseq
                             : null;
-                        await maybeResolveAnsweredUserInterjection({
-                            dlg,
+                        pendingVisibleUserInterjectionAnswer = {
                             userPromptMsgId: userInterjectionMsgIdForVisibleAnswer,
                             assistantSayingContent: currentRoundAssistantSayingContent ?? streamedCurrentRoundSayingContent,
                             assistantSayingGenseq: currentRoundAssistantSayingGenseq ?? streamedCurrentRoundSayingGenseq,
                             functionCallGenseqs: currentRoundFunctionCallGenseqs,
-                        });
+                        };
                     }
+                    const settleVisibleUserInterjectionAnswer = async (recordAnswerToHuman) => {
+                        const pendingAnswer = pendingVisibleUserInterjectionAnswer;
+                        if (pendingAnswer === undefined) {
+                            return;
+                        }
+                        pendingVisibleUserInterjectionAnswer = undefined;
+                        await maybeResolveAnsweredUserInterjection({
+                            dlg,
+                            ...pendingAnswer,
+                            recordAnswerToHuman,
+                        });
+                    };
                     if (routed.tellaskToolOutputs.length > 0) {
                         newMsgs.push(...routed.tellaskToolOutputs);
                     }
@@ -3905,6 +3920,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 }
                                 await persistDialogFbrState(dlg, undefined);
                                 dlg.setFbrConclusionToolsEnabled(false);
+                                await settleVisibleUserInterjectionAnswer(false);
                                 break;
                             }
                             if (inspection.kind === 'rejected') {
@@ -3924,6 +3940,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             await persistDialogFbrState(dlg, nextFbrState);
                             dlg.setFbrConclusionToolsEnabled((0, fbr_1.isFbrFinalizationState)(nextFbrState));
                             pendingPrompt = buildKernelDriverFbrPrompt(dlg, nextFbrState);
+                            await settleVisibleUserInterjectionAnswer(true);
                             continue;
                         }
                         fbrConclusion = {
@@ -3943,6 +3960,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         }
                         await persistDialogFbrState(dlg, undefined);
                         dlg.setFbrConclusionToolsEnabled(false);
+                        await settleVisibleUserInterjectionAnswer(false);
                         break;
                     }
                     if (routed.shouldStopAfterReplyTool) {
@@ -3962,12 +3980,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 call.name === 'replyTellaskBack')
                                 .map((call) => call.name),
                         });
+                        await settleVisibleUserInterjectionAnswer(false);
                         break;
                     }
                     const queuedNewCoursePrompt = await consumeQueuedNewCourseRuntimePromptForSameDrive(dlg);
                     if (queuedNewCoursePrompt !== undefined) {
                         pendingPrompt = queuedNewCoursePrompt;
                         skipTaskdocForThisDrive = false;
+                        await settleVisibleUserInterjectionAnswer(true);
                         continue;
                     }
                     // Start an immediate post-tool generation only when this round produced tool outputs that
@@ -4009,6 +4029,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             remindersVer: dlg.remindersVer,
                             pubRemindersVer,
                         });
+                        await settleVisibleUserInterjectionAnswer(true);
                         break;
                     }
                     if (dlg.remindersVer > pubRemindersVer) {
@@ -4032,6 +4053,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             pubRemindersVer,
                         });
                         await preserveDiligenceBudgetAcrossQ4H(dlg);
+                        await settleVisibleUserInterjectionAnswer(false);
                         break;
                     }
                     if (!shouldStartImmediatePostToolGeneration) {
@@ -4053,6 +4075,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 rootId: dlg.id.rootId,
                                 selfId: dlg.id.selfId,
                             });
+                            await settleVisibleUserInterjectionAnswer(false);
                             break;
                         }
                         const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
@@ -4065,6 +4088,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             if (healthFirst.resetTaskdoc) {
                                 skipTaskdocForThisDrive = false;
                             }
+                            await settleVisibleUserInterjectionAnswer(true);
                             continue;
                         }
                         const next = await maybeContinueWithDiligencePrompt({
@@ -4074,6 +4098,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         });
                         if (next.kind === 'continue') {
                             pendingPrompt = next.prompt;
+                            await settleVisibleUserInterjectionAnswer(true);
                             continue;
                         }
                         lastToolRoundStopDiagnostics = buildToolRoundStopDiagnostics({
@@ -4088,6 +4113,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             remindersVer: dlg.remindersVer,
                             pubRemindersVer,
                         });
+                        await settleVisibleUserInterjectionAnswer(false);
                         break;
                     }
                     await repairMissingImmediateFollowupTrigger({
@@ -4102,6 +4128,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     resolvingImmediateToolResultUserPromptMsgId = resolvingImmediateToolResultForUserPrompt
                         ? currentUserPromptMsgId
                         : undefined;
+                    await settleVisibleUserInterjectionAnswer(true);
                     continue;
                 }
                 catch (err) {

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

@@ -2101,8 +2101,8 @@ 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}`;
+        ? `已记录给人类的答复或状态说明。\n\n${args.answerContent}`
+        : `Recorded the answer or status for the human.\n\n${args.answerContent}`;
 }
 async function recordAnswerToHuman(args) {
     const answer = {

package/dist/mcp/supervisor.js

@@ -109,7 +109,10 @@ function ensureLeaseReminder(dlg, serverId) {
             '',
             `This MCP server is treated as non-stateless; the current dialog holds an underlying process/connection with explicit lifecycle management.`,
         ].join('\n');
-    dlg.addReminder(content, owner, makeLeaseReminderMeta(serverId));
+    dlg.addReminder(content, owner, makeLeaseReminderMeta(serverId), undefined, {
+        scope: 'dialog',
+        renderMode: 'markdown',
+    });
 }
 class McpServerDispatch {
     serverId;