dominds 1.26.2 → 1.26.3

package/dist/minds/system-prompt-parts.js

@@ -138,39 +138,39 @@ function getMemoryPromptCopy(ctx) {
     const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(ctx.language);
     const contextHealthLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
-            ? '当前上下文处于系统告急处置态：立即停止继续大实现/大阅读。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，只维护足够详尽的接续包提醒项并 `clear_mind`。提醒项长度没有技术限制。'
-            : '当前上下文处于系统告急处置态：立即停止继续大实现/大阅读。本程只做保信息：先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再提炼接续包提醒项并 `clear_mind`。'
+            ? 'Dominds 已提醒上下文告急：立即停止继续大实现/大阅读。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，只维护足够详尽的接续包提醒项并 `clear_mind`。提醒项没有固定长度限制。'
+            : 'Dominds 已提醒上下文告急：立即停止继续大实现/大阅读。本程只做保信息：先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再提炼接续包提醒项并 `clear_mind`。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
-                ? '当前上下文处于系统吃紧处置态：不要继续扩张上下文。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，优先维护足够详尽的接续包提醒项并尽快 `clear_mind`。提醒项长度没有技术限制。'
-                : '当前上下文处于系统吃紧处置态：不要继续扩张上下文。本程优先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再提炼提醒项并尽快 `clear_mind`，不要继续大实现/大阅读。'
-            : '当前没有生效中的上下文健康处置指令，按正常工作流推进。';
+                ? 'Dominds 已提醒上下文吃紧：不要继续扩张上下文。你当前处于支线对话；本程不维护差遣牒，也不整理差遣牒更新提案，优先维护足够详尽的接续包提醒项并尽快 `clear_mind`。提醒项没有固定长度限制。'
+                : 'Dominds 已提醒上下文吃紧：不要继续扩张上下文。本程优先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再提炼提醒项并尽快 `clear_mind`，不要继续大实现/大阅读。'
+            : '当前没有生效中的上下文保全提示，按正常工作流推进。';
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
-            ? '当前是告急处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            ? 'Dominds 已提醒上下文告急：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项没有固定长度限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文告急：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
-                ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                ? 'Dominds 已提醒上下文吃紧：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项没有固定长度限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。Dominds 已提醒上下文吃紧：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。Dominds 真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
             : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。接续包提醒项默认应保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
-            ? 'Current context is under system critical remediation: stop large implementations/reads immediately. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Only maintain sufficiently detailed continuation-package reminders and `clear_mind`. Reminder length has no technical limit.'
-            : 'Current context is under system critical remediation: stop large implementations/reads immediately. In this course, only preserve information: first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections, then distill continuation-package reminders and `clear_mind`.'
+            ? 'Dominds has warned that context is critical: stop large implementations/reads immediately. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Only maintain sufficiently detailed continuation-package reminders and `clear_mind`. Reminders have no fixed length limit.'
+            : 'Dominds has warned that context is critical: stop large implementations/reads immediately. In this course, only preserve information: first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections, then distill continuation-package reminders and `clear_mind`.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
-                ? 'Current context is under system caution remediation: do not keep expanding context. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Prioritize sufficiently detailed continuation-package reminders and `clear_mind`. Reminder length has no technical limit.'
-                : 'Current context is under system caution remediation: do not keep expanding context. In this course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then distill reminders and `clear_mind`; do not continue large implementations/reads.'
-            : 'There is no active context-health remediation instruction in effect right now; proceed with the normal workflow.';
+                ? 'Dominds has warned that context is tight: do not keep expanding context. You are in a Side Dialog; in this course, do not maintain Taskdoc and do not draft Taskdoc update proposals. Prioritize sufficiently detailed continuation-package reminders and `clear_mind`. Reminders have no fixed length limit.'
+                : 'Dominds has warned that context is tight: do not keep expanding context. In this course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then distill reminders and `clear_mind`; do not continue large implementations/reads.'
+            : 'There is no active context-preservation notice in effect right now; proceed with the normal workflow.';
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
-            ? 'Current mode is critical remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            ? 'Dominds has warned that context is critical: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminders have no fixed length limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is critical: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
-                ? 'Current mode is caution remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                ? 'Dominds has warned that context is tight: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminders have no fixed length limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Dominds has warned that context is tight: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once Dominds actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
             : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps; reminders should also keep only scannable excerpts. Keep continuation-package reminders structured and fast to resume from by default.';
     if (ctx.language === 'zh') {
         return {
@@ -180,29 +180,29 @@ function getMemoryPromptCopy(ctx) {
             taskdocContractLine: '- 差遣牒（`*.tsk/`）：全队共享的任务契约（goals/constraints/progress）；不是个人笔记，保持足够短，每轮都应可通读。',
             taskdocSemanticsLine: '- 章节语义约定：`progress` 是全队共享、准实时、可扫读的任务公告牌，用来记录当前有效状态、关键决策、下一步与仍成立阻塞；不是流水账，也不是个人工作记录。`goals` / `constraints` 是较稳定的任务契约；每次更新都必须保留仍然有效的他人条目。',
             taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
-                ? '- 当前处于支线对话的上下文健康处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
+                ? '- Dominds 已提醒当前上下文吃紧/告急，且你处于支线对话：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
                 : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，先对照上下文中注入的当前内容完成合并，再调用 \`recall_taskdoc\` 取得当前 \`content_hash\`，然后用带 \`previous_content_hash\` 的 \`change_mind\` 整章替换；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
-                ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
+                ? '- Dominds 已提醒当前上下文吃紧/告急，且你处于支线对话：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
             injectedTaskdocLine: '- 重要：差遣牒内容会被系统以内联形式注入到上下文中（本轮生成视角下即为最新；注入内容不包括全局约束）。需要回顾时请直接基于上下文里的差遣牒内容回顾与决策，不要试图用通用文件工具读取 `*.tsk/` 下的文件（会被拒绝）。',
             constraintsLine: '- 约定：`constraints` 只写任务特有的硬要求，不得写入系统提示/工具文档里已明确且由系统强制执行的通用规则（例如 `*.tsk/` 封装禁止通用文件工具）。一经发现重复，必须删除并告知用户。',
             remindersLine: ctx.isSideDialog
-                ? '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，整理“结构化接续包提醒项”；提醒项保留恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，支线对话不要维护差遣牒，也不要整理差遣牒更新提案；只维护足够详尽的接续包提醒项，提醒项长度没有技术限制，允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。'
-                : '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再整理“结构化接续包提醒项”；提醒项只保留差遣牒仍未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
+                ? '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，整理“结构化接续包提醒项”；提醒项保留恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若 Dominds 已提醒当前程吃紧/告急，支线对话不要维护差遣牒，也不要整理差遣牒更新提案；只维护足够详尽的接续包提醒项，提醒项没有固定长度限制，允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有 Dominds 实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。'
+                : '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再整理“结构化接续包提醒项”；提醒项只保留差遣牒仍未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若 Dominds 已提醒当前程吃紧/告急，则允许先保留多条粗略提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有 Dominds 实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             skillsLine: '- Skills：可复用操作指引/检查清单/触发条件与边界。工作区关联强的事实、路径、局部契约进 memory/env；独立于工作区内容的“怎么做”进 skill。skill 不授予工具权限；需要脚本/MCP/外部能力时应配套 app/toolset/权限配置。',
             sideDialogDutyLine: ctx.contextHealthPromptMode === 'normal'
                 ? `你当前处于支线对话：此处不允许 \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出要新增的章节、要追加的条目、已合并好的“新全文/替换稿”，或要删除的章节。不要声称已更新，除非看到回执。`
-                : '你当前处于支线对话，且上下文已进入吃紧/告急处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案。请把下一程需要恢复的讨论细节、定位、验证方式和临时信息写入足够详尽的接续包提醒项。',
+                : '你当前处于支线对话，且 Dominds 已提醒上下文吃紧/告急：本程不要维护差遣牒，也不要整理差遣牒更新提案。请把下一程需要恢复的讨论细节、定位、验证方式和临时信息写入足够详尽的接续包提醒项。',
             mainDialogDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
             teammateTellaskRoundDoneLine: `队友诉请重要语义：当你在诉请者上下文中收到带${runtimeMarkers.finalCompleted}标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。并行语义：不要把智能体队友当成真人同事；祂不会因为你又发一条诉请而被打扰。同一个队友 + 同一个 sessionSlug = 接着同一件事说，并更新那件正在做的事；tellaskSessionless 或不同 sessionSlug = 另一件独立任务。`,
             teamMemoryHintLine: '提示：你具备团队记忆工具（`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`），可在必要时维护团队记忆（谨慎、少量、只写稳定约定）。',
             personalMemoryHintLine: `提示：你具备个人记忆工具（\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`）。个人记忆仅对当前智能体可见，且系统会自动按成员隔离到 \`.minds/memory/individual/<member-id>/...\`；因此 \`path\` 不应包含你的成员 id（不要写 \`${ctx.agentId}/...\`）。首次创建时直接用 \`add_personal_memory\` 即可，目录会由系统自动创建。记忆会在每次生成时自动注入上下文：保持少量、保持准确、按“未来会一起更新的内容”合并；写稳定事实（关键路径 + 最小必要约定），不要写任务进度/当天状态；一旦你修改了相关文件或发现记忆过期/冲突，立刻用 \`replace_personal_memory\` 更新。`,
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
-                : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
+                : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，没有固定长度限制）→ 然后 `clear_mind` 开启新一程。',
             mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             ...(ctx.isSideDialog
                 ? {}
@@ -220,29 +220,29 @@ function getMemoryPromptCopy(ctx) {
         taskdocContractLine: '- Taskdoc (`*.tsk/`): the team-shared task contract (goals/constraints/progress). It is not a personal notebook; keep it small enough to read every course.',
         taskdocSemanticsLine: '- Section semantics: `progress` is the team-shared, quasi-real-time, scannable task bulletin board for current effective state, key decisions, next steps, and still-active blockers; it is not a raw log or personal work record. `goals` / `constraints` are the more stable task contract; every update must preserve still-valid entries from others.',
         taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
-            ? '- Current mode is context-health remediation in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
+            ? '- Dominds has warned that context is tight/critical in this Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
             : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, first merge against the current injected content, then call \`recall_taskdoc\` to get the current \`content_hash\`, then use \`change_mind\` for a full-section replacement with that value as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
         progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
-            ? '- Current mode is context-health remediation in a Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
+            ? '- Dominds has warned that context is tight/critical in this Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
             : '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
         injectedTaskdocLine: '- Important: the Taskdoc content is injected inline into the context (the latest as of this generation; injected content excludes global constraints). Review the injected Taskdoc instead of trying to read files under `*.tsk/` via general file tools (they will be rejected).',
         constraintsLine: '- Convention: Taskdoc `constraints` must contain task-specific requirements only; do not include global, system-enforced rules already stated in system prompt/tool docs (e.g. `.tsk/` encapsulation bans general file tools). If duplication is found, you MUST remove it and notify the user.',
         remindersLine: ctx.isSideDialog
-            ? '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, create a structured continuation-package reminder that preserves details easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, you are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; only maintain sufficiently detailed continuation-package reminders. Reminder length has no technical limit, rough multi-reminder bridge notes are acceptable, and in the current course you should only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
-            : '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then create a structured continuation-package reminder. Reminders should keep only details still not covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
+            ? '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, create a structured continuation-package reminder that preserves details easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If Dominds has warned that the current course is tight/critical, you are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; only maintain sufficiently detailed continuation-package reminders. Reminders have no fixed length limit, rough multi-reminder bridge notes are acceptable, and in the current course you should only preserve volatile information and clear_mind. Only after Dominds actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
+            : '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then create a structured continuation-package reminder. Reminders should keep only details still not covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If Dominds has warned that the current course is tight/critical, rough multi-reminder bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after Dominds actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
         skillsLine: '- Skills: reusable operating guidance, checklists, triggers, and boundaries. Workspace-coupled facts, paths, and local contracts belong in memory/env; workspace-independent “how to do it” procedures belong in skills. Skills do not grant tool permissions; pair scripts/MCP/external capabilities with apps/toolsets/permission configuration.',
         sideDialogDutyLine: ctx.contextHealthPromptMode === 'normal'
             ? `You are currently in a Side Dialog: \`do_mind\` / \`mind_more\` / \`change_mind\` / \`never_mind\` are not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with the new section to create, entries to append, a fully merged replacement draft, or the section to delete. Do not claim it is updated until you see a receipt.`
-            : 'You are currently in a Side Dialog under caution/critical context-health remediation: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course. Put discussion details, pointers, verification method, and volatile resume information into sufficiently detailed continuation-package reminders.',
+            : 'You are currently in a Side Dialog, and Dominds has warned that context is tight/critical: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course. Put discussion details, pointers, verification method, and volatile resume information into sufficiently detailed continuation-package reminders.',
         mainDialogDutyLine: 'You are currently in the Main Dialog: you are responsible for keeping the team-shared Taskdoc coherent and up to date (especially the progress bulletin board). Merge proposals from teammates/Side Dialogs promptly and keep it concise.',
         teammateTellaskRoundDoneLine: `Teammate Tellask semantics: when you receive a tellasker reply with the ${runtimeMarkers.finalCompleted} marker, that Tellask round is finished; the tellaskee will not keep executing the same call in the background. If the objective is not met, “waiting” is wrong: you must explicitly start a new Tellask round to continue. Parallel semantics: 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 and update that task; tellaskSessionless or a different sessionSlug = another independent task.`,
         teamMemoryHintLine: 'Hint: you have team-memory tools (`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`) and may maintain team memory when it is truly stable and worth sharing.',
         personalMemoryHintLine: `Hint: you have personal-memory tools (\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`). Personal memory is private to the current agent and is automatically isolated under \`.minds/memory/individual/<member-id>/...\`; therefore \`path\` MUST NOT include your member id (do not write \`${ctx.agentId}/...\`). For first-time setup, just call \`add_personal_memory\`—the directory will be created automatically. Memory is automatically injected into context on each generation: keep it small, keep it accurate, and group facts that are updated together. Store stable facts (exact key paths + minimal contracts), not daily state/progress. If you changed those files or detect staleness/conflicts, immediately \`replace_personal_memory\` to keep it accurate.`,
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
-            : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
+            : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no fixed length limit) → then `clear_mind` to start a new course.',
         mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; when compression/deletion is needed, first use `recall_taskdoc` to get `content_hash`, then use `change_mind` with `previous_content_hash`; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
         ...(ctx.isSideDialog
             ? {}

package/dist/minds/system-prompt.js

@@ -47,32 +47,32 @@ function buildFbrContextHealthScopeRule(scope, language, contextHealthPromptMode
     if (contextHealthPromptMode === 'critical') {
         return pickLocalized(language, {
             zh: scope === 'mainDialog'
-                ? '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。先按处置要求把尚未落实到差遣牒、且下一程需要知会的讨论细节写入合适章节，再维护接续包提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。'
-                : '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。你当前处于支线对话：不要维护差遣牒，也不要整理差遣牒更新提案；先按处置要求维护足够详尽的接续包提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
+                ? '- Dominds 已提醒上下文告急：本程禁止发起 FBR。先按上下文保全要求把尚未落实到差遣牒、且下一程需要知会的讨论细节写入合适章节，再维护接续包提醒项，并立即 `clear_mind`；Dominds 真正开启新一程并完成接续包复核后，再恢复 FBR。'
+                : '- Dominds 已提醒上下文告急：本程禁止发起 FBR。你当前处于支线对话：不要维护差遣牒，也不要整理差遣牒更新提案；先按上下文保全要求维护足够详尽的接续包提醒项，并立即 `clear_mind`；Dominds 真正开启新一程并完成接续包复核后，再恢复 FBR。',
             en: scope === 'mainDialog'
-                ? '- Current context is under system critical remediation: do not start FBR in this course. First write discussion details not yet in Taskdoc but needed by the next course into the appropriate sections, then maintain continuation-package reminders and clear immediately; resume FBR only after the system starts the new course and the continuation package has been reviewed.'
-                : '- Current context is under system critical remediation: do not start FBR in this course. You are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; first maintain sufficiently detailed continuation-package reminders, then clear immediately. Resume FBR only after the system starts the new course and the continuation package has been reviewed.',
+                ? '- Dominds has warned that context is critical: do not start FBR in this course. First write discussion details not yet in Taskdoc but needed by the next course into the appropriate sections, then maintain continuation-package reminders and clear immediately; resume FBR only after Dominds starts the new course and the continuation package has been reviewed.'
+                : '- Dominds has warned that context is critical: do not start FBR in this course. You are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; first maintain sufficiently detailed continuation-package reminders, then clear immediately. Resume FBR only after Dominds starts the new course and the continuation package has been reviewed.',
         });
     }
     if (contextHealthPromptMode === 'caution') {
         return pickLocalized(language, {
             zh: scope === 'mainDialog'
-                ? '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。先按处置要求把尚未落实到差遣牒、且下一程需要知会的讨论细节写入合适章节，再提炼提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。'
-                : '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。你当前处于支线对话：不要维护差遣牒，也不要整理差遣牒更新提案；先按处置要求维护足够详尽的接续包提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
+                ? '- Dominds 已提醒上下文吃紧：本程不要发起 FBR。先按上下文保全要求把尚未落实到差遣牒、且下一程需要知会的讨论细节写入合适章节，再提炼提醒项并尽快 `clear_mind`；Dominds 真正开启新一程并完成接续包复核后，再恢复 FBR。'
+                : '- Dominds 已提醒上下文吃紧：本程不要发起 FBR。你当前处于支线对话：不要维护差遣牒，也不要整理差遣牒更新提案；先按上下文保全要求维护足够详尽的接续包提醒项并尽快 `clear_mind`；Dominds 真正开启新一程并完成接续包复核后，再恢复 FBR。',
             en: scope === 'mainDialog'
-                ? '- Current context is under system caution remediation: do not start FBR in this course. First write discussion details not yet in Taskdoc but needed by the next course into the appropriate sections, then distill reminders and clear soon; resume FBR only after the system starts the new course and the continuation package has been reviewed.'
-                : '- Current context is under system caution remediation: do not start FBR in this course. You are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; first maintain sufficiently detailed continuation-package reminders, then clear soon. Resume FBR only after the system starts the new course and the continuation package has been reviewed.',
+                ? '- Dominds has warned that context is tight: do not start FBR in this course. First write discussion details not yet in Taskdoc but needed by the next course into the appropriate sections, then distill reminders and clear soon; resume FBR only after Dominds starts the new course and the continuation package has been reviewed.'
+                : '- Dominds has warned that context is tight: do not start FBR in this course. You are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; first maintain sufficiently detailed continuation-package reminders, then clear soon. Resume FBR only after Dominds starts the new course and the continuation package has been reviewed.',
         });
     }
     if (scope === 'mainDialog') {
         return pickLocalized(language, {
-            zh: '- 当前没有生效中的上下文健康处置指令，可以按正常流程进行 FBR。完成 FBR 后，基于当前可观测事实调用 `mind_more` 或 `change_mind` 更新差遣牒，体现任务最新进展情况。FBR 自诉请正文不要冗余包含差遣牒已有信息。',
-            en: '- There is no active context-health remediation instruction in effect, so FBR may proceed normally. After FBR, call `mind_more` or `change_mind` based on currently observable facts to update the Taskdoc with the latest progress; do not redundantly include information already present in the Taskdoc in the FBR body.',
+            zh: '- 当前没有生效中的上下文保全提示，可以按正常流程进行 FBR。完成 FBR 后，基于当前可观测事实调用 `mind_more` 或 `change_mind` 更新差遣牒，体现任务最新进展情况。FBR 自诉请正文不要冗余包含差遣牒已有信息。',
+            en: '- There is no active context-preservation notice in effect, so FBR may proceed normally. After FBR, call `mind_more` or `change_mind` based on currently observable facts to update the Taskdoc with the latest progress; do not redundantly include information already present in the Taskdoc in the FBR body.',
         });
     }
     return pickLocalized(language, {
-        zh: '- 当前没有生效中的上下文健康处置指令，可以按正常流程进行 FBR。随后基于当前可观测事实分析是否与差遣牒内容存在差异，并将发现的情况包含在 FBR 自诉请正文中。',
-        en: '- There is no active context-health remediation instruction in effect, so FBR may proceed normally. Then analyze whether currently observable facts differ from the Taskdoc, and include the findings in the FBR body.',
+        zh: '- 当前没有生效中的上下文保全提示，可以按正常流程进行 FBR。随后基于当前可观测事实分析是否与差遣牒内容存在差异，并将发现的情况包含在 FBR 自诉请正文中。',
+        en: '- There is no active context-preservation notice in effect, so FBR may proceed normally. Then analyze whether currently observable facts differ from the Taskdoc, and include the findings in the FBR body.',
     });
 }
 function buildFbrPhaseContract(language) {
@@ -104,9 +104,9 @@ function buildTeammateTellaskPhaseContract(language) {
             '- 只有长线诉请（`tellask` + `sessionSlug`）能接着同一件事说、更新同一件正在做的事；一次性诉请（`tellaskSessionless`）做不到。再次发起 `tellaskSessionless` 只是另一件独立任务，不会更新、更不会要求旧任务停止；若你后来发现可能需要改要求/提前收口，一开始就不该选择 `tellaskSessionless`。',
             '- 不要把智能体队友当成真人同事：祂不会因为你又发一条诉请而被打扰。同一个队友可以同时做多件独立任务，系统会分开处理。记住这个简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务。只要任务独立、目标清楚，就直接并行诉请。',
             '- 能由队友诉请完成的执行性工作，禁止转交 `askHuman` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 `tellask` 或 `tellaskSessionless`。',
-            `- 当你在诉请正文里定义“回贴格式/交付格式”时，只写业务交付结构即可；不要要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`），这些标记由 Dominds 运行时自动注入。`,
+            `- 当你在诉请正文里定义“回贴格式/交付格式”时，只写业务交付结构即可；不要要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`），这些标记由 Dominds 自动注入。`,
             '- 当你处于队友诉请触发的支线时，不要把“阻塞/不确定”默认等同于 `tellaskBack`：若按当前团队规程/SOP/职责卡已能明确判定执行负责人，直接用 `tellask` / `tellaskSessionless` 诉请对应负责人；只有确实需要诉请者补充需求、做裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack`。`tellaskBack` 不携带 `sessionSlug`。',
-            `- 回贴文本标记由运行时在跨对话传递正文中按语义自动添加（例如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）；该传递正文会进入目标智能体上下文，且 UI 与其一致。你不应手写这些标记。`,
+            `- 回贴文本标记由 Dominds 在跨对话传递正文中按语义自动添加（例如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）；该传递正文会进入目标智能体上下文，且 UI 与其一致。你不应手写这些标记。`,
         ],
         en: [
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
@@ -117,44 +117,50 @@ function buildTeammateTellaskPhaseContract(language) {
             '- Only a sessioned Tellask (`tellask` + `sessionSlug`) can continue the same task and update that task. A one-shot Tellask (`tellaskSessionless`) cannot: another `tellaskSessionless` is a separate task and does not update, stop, or instruct the earlier task to stop. If you may need later correction or earlier wrap-up, do not choose `tellaskSessionless` in the first place.',
             '- Do not treat an agent teammate like a human coworker who can only handle one conversation at a time. The same teammate can work on several independent tasks at once, and the system keeps them separate. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task. When tasks are independent and clear, tellask in parallel.',
             '- Do not use `askHuman` as a relay for executable teammate work. If you write “ask @X to do Y”, emit `tellask` or `tellaskSessionless` in the same response.',
-            `- When you define a “reply/delivery format” inside tellask body, keep it to the business delivery structure; do not require the tellaskee to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`), because Dominds runtime injects those markers automatically.`,
+            `- When you define a “reply/delivery format” inside tellask body, keep it to the business delivery structure; do not require the tellaskee to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`), because Dominds injects those markers automatically.`,
             '- In a teammate-triggered Side Dialog, do not treat “blocked / uncertain” as an automatic `tellaskBack`: if current team SOP / role ownership already identifies the responsible executor, directly use `tellask` / `tellaskSessionless` for that owner; use `tellaskBack` only when you truly need the tellasker to clarify, decide, confirm acceptance criteria, provide missing input, or when existing SOP cannot determine ownership. `tellaskBack` must not carry `sessionSlug`.',
-            `- Reply markers are auto-added by runtime in the inter-dialog transfer payload (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`); that same transfer payload is what the target agent receives in context and what UI shows. Do not hand-write markers.`,
+            `- Reply markers are auto-added by Dominds in the inter-dialog transfer payload (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`); that same transfer payload is what the target agent receives in context and what UI shows. Do not hand-write markers.`,
         ],
     });
     return lines.join('\n');
 }
 function buildSideDialogTellaskerReplyMarkerRules(language) {
     const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
+    // Business scenario: Side Dialogs use the same visible conversation surface for three very
+    // different acts: asking another teammate (`tellask*`), asking the requester a question
+    // (`tellaskBack`), and sending the final answer back through a runtime-selected reply tool.
+    // Models often blur those acts when the prompt names all tools at once. These rules deliberately
+    // make runtime the authority for "is somebody waiting for my final reply" and "which reply tool
+    // sends it", while leaving business ownership/SOP decisions to the model.
     const lines = pickLocalized(language, {
         zh: [
             '- 本规则仅用于当前支线向诉请者回复；`tellask` 用于**发起新的下游诉请对话**（委托队友做事），不用于向诉请者汇报。',
             '- 当前支线未完成时，不要默认直接 `tellaskBack`。先判断当前团队规程/SOP/职责卡能否明确负责人：若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人；只有当必须向诉请者补充需求、做业务裁决、澄清验收口径、提供缺失输入，或现有规程无法明确判责时，才发起 `tellaskBack({ tellaskContent: "..." })`，并在 `tellaskContent` 中给出具体问题。',
-            '- 是否存在“待你收口的跨对话回复义务”、以及精确该调用哪个 reply 函数，均由运行时程序化判断；运行时会在 assignment 或最新 runtime/user 提示里直接点名。',
-            '- 若运行时点名了精确 reply 函数名，你只需调用那个被点名的函数；不要自己判断 `reply*` 变体。禁止调用 `tellaskBack` 发送最终结果，也禁止用 `tellask` 向诉请者发送最终结果。',
-            `- 正式完成路径：只有在运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复作为完成结果投递给诉请者，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。不要依赖 direct-reply fallback；它只是运行时临时过渡兜底，不是正式回复机制。`,
-            '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，就直接继续当前本地对话；不要凭记忆再次调用 `reply*`。',
-            '- "不得发普通文本中间汇报"只针对未完成态；若你已经完成任务并能给出最终交付，就应使用运行时当前点名的精确 reply 函数，不要使用 `tellaskBack` 或 `tellask`。',
+            '- 是否有别的对话正在等你发送最终回贴、以及发送时该用哪个精确回复工具，均由 Dominds 根据当前对话状态判断；Dominds 会在任务开头或最新 Dominds/user 提示里直接点名。',
+            '- 若 Dominds 点名了精确回复工具，你只需调用那个被点名的工具；不要自己从历史上下文猜工具变体。禁止调用 `tellaskBack` 发送最终结果，也禁止用 `tellask` 向诉请者发送最终结果。',
+            `- 正式完成路径：只有在 Dominds 当前明确点名了某个精确回复工具，且你通过那个工具回复时，Dominds 才会把该回复作为完成结果投递给诉请者，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。不要只发普通文本；对方可能收不到正式回贴。`,
+            '- 若 Dominds 当前明确提示“无需回贴”，说明这就是当前对话里的普通回合；按当前用户/Dominds 消息正常交流和处理即可。',
+            '- "不得发普通文本中间汇报"只针对未完成态；若你已经完成任务并能给出最终交付，就应使用 Dominds 当前点名的精确回复工具，不要使用 `tellaskBack` 或 `tellask`。',
             '- 例外：FBR 支线为工具禁用模式（不得调用 `tellaskBack`）；其回贴标记（`' +
                 runtimeMarkers.fbrDirectReply +
                 '` / `' +
                 runtimeMarkers.fbrReasoningOnly +
-                '`)也由运行时在传递正文中注入。',
+                '`)也由 Dominds 在传递正文中注入。',
             '- 若人类用户在支线对话中插入消息或补问：直接正常回复即可，不需要向诉请者汇报（支线不需要主动汇报诉请者，默认行为就是直接回复）。',
         ],
         en: [
             '- This rule applies only when replying to the tellasker from the current Side Dialog; tellask is for initiating a new downstream tellask dialog (delegating work to a teammate), not for reporting back to the tellasker.',
             '- If the current Side Dialog is unfinished, do not default to `tellaskBack`. First judge whether current team SOP / role ownership already identifies the responsible executor: if yes and the issue is execution work, directly use `tellask` / `tellaskSessionless` for that owner; use `tellaskBack({ tellaskContent: "..." })` only when the tellasker must provide clarification, business decision, acceptance-criteria confirmation, missing input, or when existing SOP cannot determine ownership. Put concrete questions in `tellaskContent`.',
-            '- Runtime programmatically decides whether there is an active inter-dialog reply obligation for you, and which exact reply function name applies; runtime will state that directly in the assignment or the latest runtime/user prompt.',
-            '- If runtime names an exact reply function, call that named function and do not choose a `reply*` variant by yourself. Do not use `tellaskBack` or `tellask` to send final delivery.',
-            `- Formal completion path: only replies sent through the exact reply function currently named by runtime are delivered to the tellasker as completion results and marked with ${runtimeMarkers.finalCompleted}. Do not rely on direct-reply fallback; it is only a temporary runtime transition safeguard, not the formal reply mechanism.`,
-            '- If runtime explicitly tells you there is no active inter-dialog reply obligation right now, just continue the current local conversation; do not call `reply*` again from memory.',
-            '- "Do not post a plain-text progress update" only applies to unfinished states; if the task is done and you can deliver the final result, use the exact reply function currently named by runtime instead of `tellaskBack` or `tellask`.',
+            '- Dominds decides from the current dialog state whether another dialog is waiting for your final reply, and which exact reply tool sends it; Dominds will state that directly in the task header or the latest Dominds/user prompt.',
+            '- If Dominds names an exact reply tool, call that named tool and do not choose a variant by yourself. Do not use `tellaskBack` or `tellask` to send final delivery.',
+            `- Formal completion path: only replies sent through the exact reply tool currently named by Dominds are delivered to the tellasker as completion results and marked with ${runtimeMarkers.finalCompleted}. Do not rely on plain text; the other dialog may not receive a formal reply that way.`,
+            '- If Dominds explicitly says no reply is needed right now, this is just a normal turn in the current conversation; handle the current user/Dominds message normally.',
+            '- "Do not post a plain-text progress update" only applies to unfinished states; if the task is done and you can deliver the final result, use the exact reply tool currently named by Dominds instead of `tellaskBack` or `tellask`.',
             '- Exception: FBR Side Dialog is tool-less (no \`tellaskBack\`); its reply markers (`' +
                 runtimeMarkers.fbrDirectReply +
                 '` / `' +
                 runtimeMarkers.fbrReasoningOnly +
-                '`) are also injected by runtime into the transfer payload.',
+                '`) are also injected by Dominds into the transfer payload.',
             '- If a human user inserts a message or asks a follow-up in the Side Dialog: just reply normally; no need to report back to the tellasker (Side Dialog has no standing obligation to report to the tellasker).',
         ],
     });
@@ -163,25 +169,34 @@ function buildSideDialogTellaskerReplyMarkerRules(language) {
 function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
     const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
     if (dialogScope === 'sideDialog') {
+        // Business scenario: this policy is embedded in the standing Side Dialog system prompt, so
+        // it must teach the stable rule without forcing the model to infer the live state. The live
+        // state comes from runtime prompts such as "[Dominds 回复路径]" or "[Dominds 无需回贴]"; this
+        // standing text only says how to obey those runtime facts when they appear.
+        //
+        // The "no reply needed" wording is deliberately phrased as "normal current turn" instead of
+        // as a broad tool/reminder prohibition. A completed Sideline Dialog follow-up may still need
+        // tools, reminder cleanup, or ordinary explanation if the user asks for them; the key business
+        // fact is only that no requester is waiting for formal final delivery anymore.
         return [
             ...pickLocalized(language, {
                 zh: [
-                    `- 回贴文本标记由运行时在跨对话传递正文中自动添加（常规完成=${runtimeMarkers.finalCompleted}；FBR=${runtimeMarkers.fbrDirectReply} 或 ${runtimeMarkers.fbrReasoningOnly}）；该正文直接进入诉请者上下文，且 UI 展示与其一致。你无需、也不应手写标记。`,
-                    '- 若你在正文中给下游写“回贴格式”，只写业务交付结构；不得要求下游手写任何标记，运行时会自动注入。',
+                    `- 回贴文本标记由 Dominds 在跨对话传递正文中自动添加（常规完成=${runtimeMarkers.finalCompleted}；FBR=${runtimeMarkers.fbrDirectReply} 或 ${runtimeMarkers.fbrReasoningOnly}）；该正文直接进入诉请者上下文，且 UI 展示与其一致。你无需、也不应手写标记。`,
+                    '- 若你在正文中给下游写“回贴格式”，只写业务交付结构；不得要求下游手写任何标记，Dominds 会自动注入。',
                     '- `tellaskBack` 只允许用于回问诉请者；仅当必须向诉请者补需求/澄清/裁决/缺失输入，或现有团队规程无法明确判责时才使用。禁止用 `tellaskBack` 发送最终结果。',
                     '- 当前支线未完成时，不得把“阻塞/不确定”机械等同于 `tellaskBack`；若团队规程/SOP/职责卡已明确负责人，应直接 `tellask` / `tellaskSessionless` 对应负责人，不得发普通文本中间汇报。',
                     `- ${(0, reply_prompt_copy_1.buildSideDialogCompletionRule)('zh')}`,
-                    `- 正式完成路径中，仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给诉请者并标注 ${runtimeMarkers.finalCompleted}；不要依赖 direct-reply fallback，它只是运行时临时过渡兜底，不是正式回复机制。`,
-                    '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，说明这轮不是待你收口的跨对话回复义务；不要重复调用 `reply*`。',
+                    `- 正式完成路径中，仅当 Dominds 当前明确点名了某个精确回复工具，且你通过那个工具回复时，Dominds 才会把该回复投递给诉请者并标注 ${runtimeMarkers.finalCompleted}；不要只发普通文本，对方可能收不到正式回贴。`,
+                    '- 若 Dominds 当前明确提示“无需回贴”，说明这轮没有别的对话在等你发送最终回贴；这是当前对话里的普通回合，按当前消息正常交流和处理即可。',
                 ],
                 en: [
-                    `- Reply markers are runtime-added in the inter-dialog transfer payload (regular completed reply = ${runtimeMarkers.finalCompleted}; FBR = ${runtimeMarkers.fbrDirectReply} or ${runtimeMarkers.fbrReasoningOnly}); this payload is delivered to tellasker context and shown identically in UI. Do not hand-write markers.`,
-                    '- If you define a reply format for downstream, keep it to the business delivery structure; do not require downstream to hand-write any marker, because runtime injects markers automatically.',
+                    `- Reply markers are added by Dominds in the inter-dialog transfer payload (regular completed reply = ${runtimeMarkers.finalCompleted}; FBR = ${runtimeMarkers.fbrDirectReply} or ${runtimeMarkers.fbrReasoningOnly}); this payload is delivered to tellasker context and shown identically in UI. Do not hand-write markers.`,
+                    '- If you define a reply format for downstream, keep it to the business delivery structure; do not require downstream to hand-write any marker, because Dominds injects markers automatically.',
                     '- `tellaskBack` is only for asking the tellasker back; use it only when tellasker clarification / decision / missing input is required, or current team SOP cannot determine ownership. Do not use `tellaskBack` to send final results.',
                     '- If the current Side Dialog is unfinished, do not mechanically map “blocked / uncertain” to `tellaskBack`; when team SOP / role ownership already identifies the responsible owner, directly use `tellask` / `tellaskSessionless` for that owner instead of posting a plain-text progress update.',
                     `- ${(0, reply_prompt_copy_1.buildSideDialogCompletionRule)('en')}`,
-                    `- In the formal completion path, runtime marks ${runtimeMarkers.finalCompleted} and delivers to the tellasker only when runtime currently names an exact reply function and you reply through that named function; do not rely on direct-reply fallback, which is only a temporary runtime transition safeguard, not the formal reply mechanism.`,
-                    '- If runtime currently tells you there is no active inter-dialog reply obligation, then this turn is not awaiting another inter-dialog closure from you; do not call `reply*` again.',
+                    `- In the formal completion path, Dominds marks ${runtimeMarkers.finalCompleted} and delivers to the tellasker only when Dominds currently names an exact reply tool and you reply through that named tool; do not rely on plain text, because the other dialog may not receive a formal reply that way.`,
+                    '- If Dominds currently tells you no reply is needed, then no other dialog is waiting for your final reply in this turn; this is a normal turn in the current conversation, so handle the current message normally.',
                 ],
             }),
         ];
@@ -230,7 +245,7 @@ function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
     const lines = pickLocalized(language, {
         zh: [
             '- FBR 由 `freshBootsReasoning` 触发，不属于普通队友诉请分类；请按本节规则执行。',
-            '- FBR 不可调用 `tellaskBack`；其回贴标记由运行时在跨对话传递正文中自动注入。',
+            '- FBR 不可调用 `tellaskBack`；其回贴标记由 Dominds 在跨对话传递正文中自动注入。',
             '- FBR 禁止一切 tellask（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
             '- 当用户明确要求“做一次 FBR/扪心自问”，对话主理人必须发起 `freshBootsReasoning`。',
             fbrContextHealthRule,
@@ -247,7 +262,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 runtime into the inter-dialog transfer payload.',
+            '- 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`).',
             '- When the user explicitly requests “do an FBR / fresh boots reasoning”, the Dialog Responder must call `freshBootsReasoning`.',
             fbrContextHealthRule,
@@ -316,7 +331,7 @@ function formatMcpToolsetRuntimeNote(language, notices) {
         return '';
     const lines = language === 'zh'
         ? [
-            '以下 MCP toolset 已配置给你，且在 `.minds/mcp.yaml` 中有声明，但当前不提供可调用的运行时 MCP 工具。',
+            '以下 MCP toolset 已配置给你，且在 `.minds/mcp.yaml` 中有声明，但当前没有可调用的 MCP 工具。',
             '其中有些可能是暂时不可达（例如 stdio transport 进程启动失败，或 streamable HTTP transport 当前无法连接），有些可能是被明确禁用；这不代表你的权限被撤销，也不应视为系统级功能降级。',
             ...notices.map((notice) => {
                 if (notice.status === 'disabled') {
@@ -331,7 +346,7 @@ function formatMcpToolsetRuntimeNote(language, notices) {
             '若当前任务依赖这些能力，应明确说明对应 MCP toolset 眼下不可用，并优先继续使用其余可用工具/路径推进。',
         ]
         : [
-            'The following MCP toolsets are assigned to you and declared in `.minds/mcp.yaml`, but they do not currently provide callable runtime MCP tools.',
+            'The following MCP toolsets are assigned to you and declared in `.minds/mcp.yaml`, but they do not currently provide callable MCP tools.',
             'Some may be temporarily unavailable (for example a stdio transport process failing to start right now, or a streamable HTTP transport being unreachable right now), and some may be explicitly disabled. This does not mean your permission was revoked, and it should not be treated as a system-level capability downgrade.',
             ...notices.map((notice) => {
                 if (notice.status === 'disabled') {

package/dist/persistence.js

@@ -388,8 +388,14 @@ function isSuppressedTellaskPlaceholderFuncResult(args) {
     if (raw === '') {
         return false;
     }
+    // Business scenario: these generated tool results are only waiting/status placeholders. They
+    // must be suppressed when reconstructing the conversation so the model does not confuse them
+    // with a real teammate/human answer. Keep the old prefixes for persisted records, and include
+    // the newer plain-language prefixes so the suppression logic matches the current copy.
     if (raw === 'Q4H 已结束等待状态，请参考 askHuman 结果气泡。' ||
-        raw === 'Q4H wait is resolved; refer to the askHuman result bubble.') {
+        raw === 'Q4H wait is resolved; refer to the askHuman result bubble.' ||
+        raw === '人类已经回答；请参考 askHuman 结果气泡。' ||
+        raw === 'The human has answered; refer to the askHuman result bubble.') {
         return true;
     }
     if (raw.startsWith('Q4H 仍在等待人类回复，已持续 ') ||
@@ -404,6 +410,14 @@ function isSuppressedTellaskPlaceholderFuncResult(args) {
         (raw.includes('当前仍在等待') || raw.includes('is still waiting'))) {
         return true;
     }
+    if (raw.startsWith('[Dominds 等待人类回复]') ||
+        raw.startsWith('[Dominds waiting for human answer]') ||
+        raw.startsWith('[Dominds 等待队友回贴]') ||
+        raw.startsWith('[Dominds waiting for teammate reply]') ||
+        raw.startsWith('[Dominds 队友回贴状态]') ||
+        raw.startsWith('[Dominds teammate reply status]')) {
+        return true;
+    }
     return false;
 }
 function isYamlUnexpectedEofLikeError(error) {

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

@@ -12,14 +12,39 @@ export declare function formatNewCourseStartPrompt(language: LanguageCode, args:
 }): string;
 export declare function formatDiligenceAutoContinuePrompt(language: LanguageCode, diligenceText: string): string;
 export declare function formatReminderContextGuide(language: LanguageCode): string;
-export type ReminderContextFollowingDialogState = 'user_message' | 'runtime_notice' | 'none';
-export type ReminderContextReplyObligationState = 'none' | 'active' | 'parked_by_user_interjection';
-export type ReminderContextHealthState = 'normal' | 'caution' | 'critical';
+export type ReminderContextFollowingMessage = Readonly<{
+    kind: 'user_message';
+}> | Readonly<{
+    kind: 'human_answer';
+}> | Readonly<{
+    kind: 'runtime_notice';
+}> | Readonly<{
+    kind: 'none';
+}>;
+export type ReminderContextHealth = Readonly<{
+    kind: 'normal';
+}> | Readonly<{
+    kind: 'caution';
+}> | Readonly<{
+    kind: 'critical';
+}>;
+export type ReminderContextBusiness = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'active_reply_obligation';
+}> | 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';
+}>;
 export type ReminderContextFooterState = Readonly<{
-    followingDialogState: ReminderContextFollowingDialogState;
-    pendingUserInterjectionReply: boolean;
-    interDialogReplyObligation: ReminderContextReplyObligationState;
-    contextHealthState: ReminderContextHealthState;
+    followingMessage: ReminderContextFollowingMessage;
+    contextHealth: ReminderContextHealth;
+    business: ReminderContextBusiness;
 }>;
 export declare function formatReminderContextFooter(language: LanguageCode, state: ReminderContextFooterState): string;
 export type ReminderMaintenanceReferenceItem = Readonly<{