dominds 1.26.2 → 1.26.4

package/dist/runtime/driver-messages.js

@@ -93,13 +93,13 @@ function formatRegisteredTellaskTellaskerUpdateNotice(language) {
     if (language === 'zh') {
         return [
             prefix,
-            '刚才那轮诉请已被你后续发出的新要求取代；运行时已登记这次更新。',
+            '刚才那轮诉请已被你后续发出的新要求取代；Dominds 已登记这次更新。',
             '如果目标支线正忙，更新会在下一次安全推进边界进入目标支线；请把目标支线里的更新气泡作为可见确认点。',
         ].join('\n');
     }
     return [
         prefix,
-        'That earlier request has been superseded by your later updated request; runtime has registered the update.',
+        'That earlier request has been superseded by your later updated request; Dominds has registered the update.',
         'If the target Side Dialog is busy, the update will enter it at the next safe drive boundary. Use the target Side Dialog update bubble as the visible confirmation point.',
     ].join('\n');
 }
@@ -122,20 +122,25 @@ function formatRegisteredTellaskTellaskeeUpdateNotice(language) {
 }
 function formatNewCourseStartPrompt(language, args) {
     const noticePrefix = formatSystemNoticePrefix(language);
+    // Business scenario: after clear_mind or critical auto-clear, the model is in a fresh course
+    // but still sees a Dominds-inserted notice as the latest "user" message. If the copy sounds
+    // like an implementation command ("runtime instruction"), models tend to acknowledge it or churn
+    // reminders as a task. Say the user-visible business state instead: Dominds started a new course,
+    // this is not a user request, first reconcile bridge reminders only if needed, then resume work.
     if (language === 'zh') {
         const prefix = args.source === 'clear_mind'
             ? `你刚清理头脑，开启了第 ${args.nextCourse} 程对话。`
-            : `系统因上下文已告急（critical）而自动开启了第 ${args.nextCourse} 程对话。`;
+            : `Dominds 因上下文已告急而自动开启了第 ${args.nextCourse} 程对话。`;
         return (`${noticePrefix} ${prefix} ` +
-            '这是一条运行时换程指令，不是新的用户诉求；不要把这条提示当成新的待办，也不要只回复“收到/好的/我会先整理提醒项”。' +
+            '这是 Dominds 的换程提示，不是新的用户诉求；不要把这条提示当成新的待办，也不要只回复“收到/好的/我会先整理提醒项”。' +
             '现在已经进入新一程：上下文已经不再吃紧，告急状况已改观。第一步先复核并在必要时整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；若提醒项已经足够清晰，就不要为了整理而整理。' +
             '完成这一步后，直接继续推进原任务本身；除非任务自然需要对用户交付结果，否则不要为这条提示单独回复。');
     }
     const prefix = args.source === 'clear_mind'
         ? `This is dialog course #${args.nextCourse}. You just cleared your mind.`
-        : `System auto-started dialog course #${args.nextCourse} because context health is critical.`;
+        : `Dominds auto-started dialog course #${args.nextCourse} because context was critical.`;
     return (`${noticePrefix} ${prefix} ` +
-        'This is a runtime course-transition instruction, not a new user request; do not treat it as a new to-do, and do not reply with a standalone "acknowledged/ok/I will reorganize the reminders first". ' +
+        'This is a Dominds course-transition notice, not a new user request; do not treat it as a new to-do, and do not reply with a standalone "acknowledged/ok/I will reorganize the reminders first". ' +
         'You are now in a new course: your first step is to review and, if needed, rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders; if the reminders are already clear enough, do not churn on them. ' +
         'After that, continue the underlying task itself directly; unless the task naturally calls for a user-facing delivery, do not send a standalone reply just for this notice.');
 }
@@ -147,7 +152,7 @@ function formatDiligenceAutoContinuePrompt(language, diligenceText) {
     }
     if (language === 'zh') {
         return [
-            `${noticePrefix} 这是一条运行时自动续推指令，不是新的用户诉求。`,
+            `${noticePrefix} 这是 Dominds 的自动续推提示，不是新的用户诉求。`,
             '不要把这条提示当成新的待办，也不要只回复“收到/好的/我先想想/我会先整理一下”。',
             '请直接按下面的引导继续推进任务；若形成结论，必须尽快落地为实际动作，不要停在“只汇报决定/只确认收到”。',
             '',
@@ -157,7 +162,7 @@ function formatDiligenceAutoContinuePrompt(language, diligenceText) {
         ].join('\n');
     }
     return [
-        `${noticePrefix} This is a runtime auto-continue instruction, not a new user request.`,
+        `${noticePrefix} This is a Dominds auto-continue notice, not a new user request.`,
         'Do not treat this notice as a new to-do, and do not reply with a standalone "acknowledged/ok/I will think first/I will organize things first".',
         'Follow the guidance below and continue the task directly; if you reach a conclusion, turn it into concrete action promptly instead of stopping at a decision report or acknowledgement.',
         '',
@@ -167,95 +172,286 @@ function formatDiligenceAutoContinuePrompt(language, diligenceText) {
     ].join('\n');
 }
 function formatReminderContextGuide(language) {
+    // Business scenario: reminder records are injected near ordinary dialog messages so the model
+    // can keep useful state, but the UI shows them outside the chat transcript. The copy must make
+    // that product fact plain without exposing provider/role plumbing: reminders are current-work
+    // references, not new user requests, and they should not trigger standalone acknowledgements.
     if (language === 'zh') {
         return [
             `${formatSystemNoticePrefix(language)} 提醒项上下文块开始`,
-            '以下是当前可见提醒项的运行时上下文投影。由于当前 LLM Provider 通常不支持 role=environment，Dominds 默认把系统运行时提醒包装投影为 role=user；个别提醒项可由其 owner 按自身契约选择 role。无论最终 role 如何，它们都不是用户的新诉求/指令，也不是聊天正文。',
+            '以下是 Dominds 为你放到当前上下文里的可见提醒项。它们不是用户的新诉求/指令，也不是聊天正文。',
             '在 WebUI 中，用户通过独立的 Reminder 小组件/面板项看到这些提醒，并能把它们和聊天正文区分开。',
             '请把提醒项作为手头工作/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
         ].join('\n');
     }
     return [
         `${formatSystemNoticePrefix(language)} Reminder context block begins`,
-        'The following visible reminders are runtime-added context projections. Because current LLM providers usually do not support role=environment, Dominds projects default system-runtime reminder wrappers as role=user; individual reminder owners may choose the role required by their own contract. Regardless of their final role, these reminders are not new user requests/instructions, and not chat transcript text.',
+        'The following visible reminders were added to the current context by Dominds. They are not new user requests/instructions, and not chat transcript text.',
         'In the WebUI, the user sees these reminders through a separate Reminder widget/panel item and can distinguish them from the chat transcript.',
         'Use reminders as current-work/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
     ].join('\n');
 }
 function formatReminderItemProjectionNote(language) {
-    return language === 'zh' ? '运行时提醒项投影：' : 'Runtime reminder projection:';
+    return language === 'zh' ? 'Dominds 提醒项说明：' : 'Dominds reminder note:';
+}
+function formatZhReminderBusinessTail(business) {
+    switch (business.kind) {
+        case 'none':
+            return '';
+        case 'user_followup_after_completed_handoff':
+            // Runtime has already identified a real user message after the earlier handoff was
+            // reported back as complete. This is not an active reply-obligation state anymore: the
+            // model should simply communicate with the user according to the current message.
+            //
+            // Business reason for this exact footer: a completed Sideline Dialog often still carries
+            // reminder/status text from the long-line handoff. When a user later asks "what happened?"
+            // or gives a new instruction in that same dialog, the model may see those reminders and
+            // keep advancing the old handoff instead of answering the visible user. Runtime can tell
+            // from durable state that the handoff was already delivered, so the footer must say the
+            // business state directly: old handoff done, current message belongs to the user.
+            //
+            // Keep the wording deliberately neutral about reminders and tools. A user may explicitly
+            // ask the agent to reorganize reminders so a later long-running handoff can resume from a
+            // corrected state. If this footer said "do not organize reminders" or "only answer", it
+            // would block a valid user request and recreate the same kind of over-specific guidance
+            // bug in the opposite direction.
+            return '现在是用户在追问你。前面那件转交任务已经回报完成了，不需要再推进；请按用户这条消息正常交流和处理。';
+        case 'pending_user_interjection_with_parked_reply':
+            // A real user message interrupted an unfinished handoff. The old handoff is parked,
+            // so the model must not rush back to reply closure before the user sees an answer.
+            return '当前仍有真实用户插话尚未得到可见回复，且原有回贴任务已暂存；先完成对用户插话的回应，不要抢先切回原来的回贴收口。';
+        case 'pending_user_interjection':
+            // No special handoff state is competing with the user; the shortest useful instruction
+            // is simply to answer the still-unanswered user interjection.
+            return '当前仍有真实用户插话尚未得到可见回复；先完成对用户插话的回应。';
+        case 'pending_user_interjection_with_active_reply':
+            // A user interjection is pending while a handoff is still active. The user still gets the
+            // next visible answer; reply closure only happens if answering that user message naturally
+            // becomes the final handoff delivery.
+            return '当前仍有真实用户插话尚未得到可见回复，同时还有回贴任务未完成；先完成对用户插话的回应，只有在这条用户插话本身已经自然到达最终交付时，才进入回贴收口。';
+        case 'active_reply_obligation':
+            // There is still an unfinished handoff, but no user interjection is pending. Say this is
+            // a final-delivery constraint, not a command to abandon necessary current work.
+            return '当前仍有回贴任务未完成；它是最终交付要求，不是要求你立刻停止当前必要工作，但到达最终交付时必须按 Dominds 指定方式收口。';
+        default: {
+            const _exhaustive = business;
+            throw new Error(`Unhandled zh reminder business state: ${String(_exhaustive)}`);
+        }
+    }
+}
+function formatEnReminderBusinessTail(business) {
+    switch (business.kind) {
+        case 'none':
+            return '';
+        case 'user_followup_after_completed_handoff':
+            // Runtime has already identified a real user message after the earlier handoff was
+            // reported back as complete. This is not an active reply-obligation state anymore: the
+            // model should simply communicate with the user according to the current message.
+            //
+            // Business reason for this exact footer: a completed Sideline Dialog often still carries
+            // reminder/status text from the long-line handoff. When a user later asks "what happened?"
+            // or gives a new instruction in that same dialog, the model may see those reminders and
+            // keep advancing the old handoff instead of answering the visible user. Runtime can tell
+            // from durable state that the handoff was already delivered, so the footer must say the
+            // business state directly: old handoff done, current message belongs to the user.
+            //
+            // Keep the wording deliberately neutral about reminders and tools. A user may explicitly
+            // ask the agent to reorganize reminders so a later long-running handoff can resume from a
+            // corrected state. If this footer said "do not organize reminders" or "only answer", it
+            // would block a valid user request and recreate the same kind of over-specific guidance
+            // bug in the opposite direction.
+            return 'The user is asking you a follow-up now. The earlier handed-off task has already been reported back as complete, so there is nothing more to advance there. Talk with the user normally and handle this current message.';
+        case 'pending_user_interjection_with_parked_reply':
+            // A real user message interrupted an unfinished handoff. The old handoff is parked,
+            // so the model must not rush back to reply closure before the user sees an answer.
+            return "There is still a real user interjection without a visible reply, and the earlier handoff is parked; finish answering the user's interjection first, and do not switch back to closing the earlier reply yet.";
+        case 'pending_user_interjection':
+            // No special handoff state is competing with the user; the shortest useful instruction
+            // is simply to answer the still-unanswered user interjection.
+            return "There is still a real user interjection without a visible reply; finish answering the user's interjection first.";
+        case 'pending_user_interjection_with_active_reply':
+            // A user interjection is pending while a handoff is still active. The user still gets the
+            // next visible answer; reply closure only happens if answering that user message naturally
+            // becomes the final handoff delivery.
+            return "There is still a real user interjection without a visible reply, while a reply task is also unfinished; finish answering the user's interjection first, and enter reply closure only if this user interjection itself naturally reaches final delivery.";
+        case 'active_reply_obligation':
+            // There is still an unfinished handoff, but no user interjection is pending. Say this is
+            // a final-delivery constraint, not a command to abandon necessary current work.
+            return 'A reply task is still unfinished; it is a final-delivery requirement, not a demand to stop necessary current work immediately, but final delivery must close through the path Dominds names.';
+        default: {
+            const _exhaustive = business;
+            throw new Error(`Unhandled en reminder business state: ${String(_exhaustive)}`);
+        }
+    }
+}
+function formatZhReminderContextHealthTail(contextHealth) {
+    switch (contextHealth.kind) {
+        case 'normal':
+            return '';
+        case 'caution':
+            // In tight context, reminders may contain stale next steps that were meant as bridge
+            // notes. The model should preserve/prepare course transition instead of expanding the
+            // same course by following old reminder content.
+            return '当前上下文已吃紧：提醒项正文里的“下一步/接续动作/任务安排”默认都是给下一程以清醒头脑复核后执行的，不是让你在本程继续跑。不要为了执行提醒项里的旧下一步继续扩张上下文；本程最高优先级是按上下文吃紧处置要求保全接续信息，并尽快 `clear_mind`。';
+        case 'critical':
+            // Critical context is stricter than caution: do not do ordinary work from reminders;
+            // preserve what matters and clear the course immediately.
+            return '当前上下文已告急：提醒项正文里的“下一步/接续动作/任务安排”默认都是给下一程以清醒头脑复核后执行的，不是让你在本程继续跑。不要执行提醒项里的旧下一步、旧诉请或旧工具重试；本程最高优先级是按上下文告急处置要求保全接续信息，并立即 `clear_mind`。';
+        default: {
+            const _exhaustive = contextHealth;
+            throw new Error(`Unhandled zh reminder context health state: ${String(_exhaustive)}`);
+        }
+    }
+}
+function formatEnReminderContextHealthTail(contextHealth) {
+    switch (contextHealth.kind) {
+        case 'normal':
+            return '';
+        case 'caution':
+            // In tight context, reminders may contain stale next steps that were meant as bridge
+            // notes. The model should preserve/prepare course transition instead of expanding the
+            // same course by following old reminder content.
+            return 'Context is tight: any "next step", continuation action, or task plan inside reminders is meant for the next course to review and run with a clear head, not for this course to keep executing. Do not expand context by performing old next steps from reminders; this course must first preserve the continuation details required by the tight-context guidance, then call `clear_mind` soon.';
+        case 'critical':
+            // Critical context is stricter than caution: do not do ordinary work from reminders;
+            // preserve what matters and clear the course immediately.
+            return 'Context is critical: any "next step", continuation action, or task plan inside reminders is meant for the next course to review and run with a clear head, not for this course to keep executing. Do not perform old next steps, old handed-off requests, or old tool retries from reminders; this course must first preserve the continuation details required by the critical-context guidance, then call `clear_mind` immediately.';
+        default: {
+            const _exhaustive = contextHealth;
+            throw new Error(`Unhandled en reminder context health state: ${String(_exhaustive)}`);
+        }
+    }
+}
+function joinReminderFooterTails(language, tails) {
+    const nonEmptyTails = tails.filter((tail) => tail !== '');
+    if (nonEmptyTails.length === 0)
+        return '';
+    return language === 'zh' ? nonEmptyTails.join('') : nonEmptyTails.join(' ');
+}
+function formatZhNormalAutoContinueByDialogScope(scope) {
+    switch (scope.kind) {
+        case 'main_dialog':
+            // Main Dialogs own the broad task and do not have a requester to tellaskBack. When the only
+            // apparent action is reminder maintenance, ask the human only for genuinely missing human
+            // input/authorization; otherwise hand control back to the Main Dialog keep-alive setting
+            // instead of making up work.
+            return '当前是主线对话。请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的只是新增、更新、删除、压缩或整理提醒项，不要把提醒项维护当成续推动作。若确实缺少人类本人澄清、裁决、验收口径、授权或输入，才用 `askHuman({ tellaskContent })` 提出一个最小且可回答的问题。若不缺这些信息、也没有真实任务动作，不要为了避免停顿而寻找无关小事；让主线按 Dominds 的主线机制处理，鞭策开启时会继续续推，鞭策关闭且没有真实动作时可以自然收住。';
+        case 'side_dialog':
+            // Side Dialogs are answering a requester. If blocked on requirement clarification, a business
+            // decision, acceptance criteria, or requester-held input, tellaskBack is the local loop and
+            // askHuman is only for information that truly must come from the human.
+            return '当前是支线对话。请基于提醒项之外的已有任务状态判断下一步：若已有明确、相关且有价值的任务动作，就继续执行；若唯一看似可做的只是新增、更新、删除、压缩或整理提醒项，不要把提醒项维护当成续推动作。若缺少需求澄清、业务裁决、验收口径、授权或输入，先判断缺的东西该由谁补：如果诉请者能补需求澄清/业务裁决/验收口径/缺失输入，先按当前工具规则考虑 `tellaskBack({ tellaskContent })` 回问诉请者；只有确实需要人类本人澄清、决策、授权或输入时，才用 `askHuman({ tellaskContent })` 提出一个最小且可回答的问题。若不缺这些信息、也没有真实任务动作，不要为了避免停顿而寻找无关小事；让支线按 Dominds 的支线机制处理：需要回贴时会收到回贴提醒，已完成且无新诉求时可以自然收住。';
+        default: {
+            const _exhaustive = scope;
+            throw new Error(`Unhandled zh reminder dialog scope: ${String(_exhaustive)}`);
+        }
+    }
+}
+function formatEnNormalAutoContinueByDialogScope(scope) {
+    switch (scope.kind) {
+        case 'main_dialog':
+            // Main Dialogs own the broad task and do not have a requester to tellaskBack. When the only
+            // apparent action is reminder maintenance, ask the human only for genuinely missing human
+            // input/authorization; otherwise hand control back to the Main Dialog keep-alive setting
+            // instead of making up work.
+            return "This is a Main Dialog. Judge the next step from existing task state outside the reminder items: if there is a clear, relevant, valuable actual task action, continue with it; if the only apparent action is to add, update, delete, compress, or organize reminders, do not treat reminder maintenance as task progress. Use `askHuman({ tellaskContent })` only when you truly need clarification, a decision, acceptance criteria, authorization, or input from the human; ask one minimal, answerable question. If you do not need any of that and there is no real task action, do not invent unrelated work just to avoid a pause; let the Main Dialog follow Dominds' mainline mechanism: diligence can continue it when enabled, and when diligence is disabled with no real action, it may naturally settle.";
+        case 'side_dialog':
+            // Side Dialogs are answering a requester. If blocked on requirement clarification, a business
+            // decision, acceptance criteria, or requester-held input, tellaskBack is the local loop and
+            // askHuman is only for information that truly must come from the human.
+            return "This is a Side Dialog. Judge the next step from existing task state outside the reminder items: if there is a clear, relevant, valuable actual task action, continue with it; if the only apparent action is to add, update, delete, compress, or organize reminders, do not treat reminder maintenance as task progress. If you are missing clarification, a business decision, acceptance criteria, authorization, or input, first identify who should provide it: when the requester can provide the missing requirement clarification, business decision, acceptance criteria, or missing input, follow the current tool rules and consider `tellaskBack({ tellaskContent })` first; use `askHuman({ tellaskContent })` only when the needed clarification, decision, authorization, or input truly must come from the human. If you do not need any of that and there is no real task action, do not invent unrelated work just to avoid a pause; let the Side Dialog follow Dominds' sideline mechanism: it can receive reply reminders when a reply is needed, and when it is complete with no new request, it may naturally settle.";
+        default: {
+            const _exhaustive = scope;
+            throw new Error(`Unhandled en reminder dialog scope: ${String(_exhaustive)}`);
+        }
+    }
 }
 function formatReminderContextFooter(language, state) {
+    const contextHealthIsNormal = state.contextHealth.kind === 'normal';
     if (language === 'zh') {
         const base = `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户诉求/指令；该块之外的后续对话消息不受此说明影响。`;
-        const contextHealthTail = state.contextHealthState === 'critical'
-            ? '当前上下文已告急：提醒项正文里的“下一步/接续动作/任务安排”默认都是给下一程以清醒头脑复核后执行的，不是让你在本程继续跑。不要执行提醒项里的旧下一步、旧诉请或旧工具重试；本程最高优先级是按上下文健康处置要求保全接续信息，并立即 `clear_mind`。'
-            : state.contextHealthState === 'caution'
-                ? '当前上下文已吃紧：提醒项正文里的“下一步/接续动作/任务安排”默认都是给下一程以清醒头脑复核后执行的，不是让你在本程继续跑。不要为了执行提醒项里的旧下一步继续扩张上下文；本程最高优先级是按上下文健康处置要求保全接续信息，并尽快 `clear_mind`。'
-                : '';
-        const pendingUserInterjectionReply = state.pendingUserInterjectionReply
-            ? state.interDialogReplyObligation === 'parked_by_user_interjection'
-                ? '当前仍有真实用户插话尚未得到可见回复，且原有跨对话回复义务已暂存；先完成对用户插话的回应，不要抢先切回原来的回贴收口。'
-                : state.interDialogReplyObligation === 'active'
-                    ? '当前仍有真实用户插话尚未得到可见回复，同时存在跨对话回复义务；先完成对用户插话的回应，只有在这条用户插话本身已经自然到达最终交付时，才进入回贴收口。'
-                    : '当前仍有真实用户插话尚未得到可见回复；先完成对用户插话的回应。'
-            : '';
-        const activeReplyObligation = !state.pendingUserInterjectionReply && state.interDialogReplyObligation === 'active'
-            ? '当前仍有跨对话回复义务；它是最终交付义务，不是要求你立刻停止当前必要工作，但到达最终交付时必须按运行时指定方式收口。'
-            : '';
-        const businessTail = `${pendingUserInterjectionReply}${activeReplyObligation}`;
-        const statusTail = `${contextHealthTail}${businessTail}`;
-        if (state.followingDialogState === 'user_message') {
-            return (`${base}本轮提醒项块之后会紧接一条本轮真实的新用户消息；后续消息是用户的新诉求/指令，不是提醒项投影。` +
-                '提醒项块说明到此为止，不得外溢到那条消息：不要把后续用户消息称为“系统提示/没有新消息”，也不要因为本块说明而降低它的指令优先级。' +
-                `请按那条用户消息的原始语义继续处理；若它要求更新你的职责、偏好或心智资产，应照常落实；上下文健康处置要求仍按系统提示优先于普通任务动作。${statusTail}`);
-        }
-        if (state.followingDialogState === 'runtime_notice') {
-            return `${base}本轮提醒项块之后会接着出现一条运行时提示；它不是用户的新诉求/指令，请按其中的运行时要求继续推进。${statusTail}`;
-        }
-        if (state.contextHealthState !== 'normal') {
-            return (`${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推。` +
-                `不要把“没有新消息”理解为空系统提示。${statusTail}`);
+        const contextHealthTail = formatZhReminderContextHealthTail(state.contextHealth);
+        const businessTail = formatZhReminderBusinessTail(state.business);
+        const statusTail = joinReminderFooterTails(language, [contextHealthTail, businessTail]);
+        switch (state.followingMessage.kind) {
+            case 'user_message':
+                // The reminder block is inserted immediately before the real user message. This
+                // branch prevents the reminder wrapper from lowering or re-labeling that message.
+                return (`${base}本轮提醒项块之后会紧接一条本轮真实的新用户消息；后续消息是用户的新诉求/指令，不是提醒项投影。` +
+                    '提醒项块说明到此为止，不得外溢到那条消息：不要把后续用户消息称为“系统提示/没有新消息”，也不要因为本块说明而降低它的指令优先级。' +
+                    `请按那条用户消息的原始语义继续处理；若它要求更新你的职责、偏好或心智资产，应照常落实；若系统提示上下文吃紧或告急，先按那条系统要求处理，再做普通任务动作。${statusTail}`);
+            case 'human_answer':
+                // This is a human answer to an askHuman question, not a fresh open-ended request. The
+                // model should use the answer to resume the waiting work without reclassifying it as a
+                // new user instruction.
+                return (`${base}本轮提醒项块之后会接着出现用户对一个提问的回答；那是用来继续等待中的工作，不是新的普通用户诉求/指令。` +
+                    `请用那条回答继续原本等待答案的任务，不要把提醒项块说明外溢到那条回答上。${statusTail}`);
+            case 'runtime_notice':
+                // Dominds notices are deliberate driver instructions. Keep them distinct from user
+                // requests while allowing their own wording to drive the next action.
+                return `${base}本轮提醒项块之后会接着出现一条 Dominds 提示；它不是用户的新诉求/指令，请按其中的要求继续推进。${statusTail}`;
+            case 'none':
+                if (!contextHealthIsNormal) {
+                    // When context is tight/critical, the context-preservation notice owns the turn. Do not add
+                    // ordinary continuation wording that could encourage more work from old reminders.
+                    return (`${base}本轮没有新的用户消息或 Dominds 提示；这是工具调用后的自动续推。` +
+                        `不要把“没有新消息”理解为空系统提示。${statusTail}`);
+                }
+                // Normal tool-followup rounds may continue real business work, but reminder maintenance
+                // paths are merely references. Runtime already knows whether this is a Main Dialog or Side
+                // Dialog, so do not ask the model to self-classify before choosing askHuman vs tellaskBack.
+                const scopeTail = formatZhNormalAutoContinueByDialogScope(state.dialogScope);
+                return (`${base}本轮没有新的用户消息或 Dominds 提示；这是工具调用后的自动续推。` +
+                    scopeTail +
+                    `不要把“没有新消息”理解为空系统提示。${businessTail}`);
+            default: {
+                const _exhaustive = state.followingMessage;
+                throw new Error(`Unhandled zh reminder following-message state: ${String(_exhaustive)}`);
+            }
         }
-        return (`${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推。` +
-            '请基于已有任务状态判断下一步：若已有明确、相关且有价值的动作，就继续执行；若当前确实只能等待外部结果或用户输入，不要为了避免“等待”而寻找无关小事。' +
-            `不要把“没有新消息”理解为空系统提示。${businessTail}`);
     }
     const base = `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between ` +
         '"Reminder context block begins" and "Reminder context block ends" are system reminders, ' +
         'not user requests/instructions; this reminder-block guidance does not apply to subsequent dialog messages outside this block. ';
-    const contextHealthTail = state.contextHealthState === 'critical'
-        ? 'Context health is critical: any "next step", continuation action, or task plan inside reminders is meant for the next course to review and run with a clear head, not for this course to keep executing. Do not perform old next steps, old inter-dialog requests, or old tool retries from reminders; this course must first preserve the continuation details required by the context-health guidance, then call `clear_mind` immediately. '
-        : state.contextHealthState === 'caution'
-            ? 'Context health is tight: any "next step", continuation action, or task plan inside reminders is meant for the next course to review and run with a clear head, not for this course to keep executing. Do not expand context by performing old next steps from reminders; this course must first preserve the continuation details required by the context-health guidance, then call `clear_mind` soon. '
-            : '';
-    const pendingUserInterjectionReply = state.pendingUserInterjectionReply
-        ? state.interDialogReplyObligation === 'parked_by_user_interjection'
-            ? "There is still a real user interjection without a visible reply, and the earlier inter-dialog reply obligation is parked; finish answering the user's interjection first, and do not switch back to closing the earlier reply yet. "
-            : state.interDialogReplyObligation === 'active'
-                ? "There is still a real user interjection without a visible reply, while an inter-dialog reply obligation also exists; finish answering the user's interjection first, and enter reply closure only if this user interjection itself naturally reaches final delivery. "
-                : "There is still a real user interjection without a visible reply; finish answering the user's interjection first. "
-        : '';
-    const activeReplyObligation = !state.pendingUserInterjectionReply && state.interDialogReplyObligation === 'active'
-        ? 'An inter-dialog reply obligation is still active; it is a final delivery obligation, not a demand to stop necessary current work immediately, but final delivery must close through the runtime-specified path. '
-        : '';
-    const businessTail = `${pendingUserInterjectionReply}${activeReplyObligation}`;
-    const statusTail = `${contextHealthTail}${businessTail}`;
-    if (state.followingDialogState === 'user_message') {
-        return (`${base}A real new user message for this round immediately follows this reminder block; the following message is a new user request/instruction, not a reminder projection. ` +
-            'The reminder-block guidance ends here and must not spill over onto that message: do not label the following user message as a "system notice" or "no new message", and do not lower its instruction priority because of this block. ' +
-            `Handle that user message according to its original meaning; if it asks you to update your responsibilities, preferences, or mind assets, carry that out normally. Context-health remediation still takes system-guided priority over ordinary task actions. ${statusTail}`);
-    }
-    if (state.followingDialogState === 'runtime_notice') {
-        return `${base}A runtime notice follows this reminder block in this round; it is not a new user request/instruction, so follow that runtime guidance and continue the work. ${statusTail}`;
-    }
-    if (state.contextHealthState !== 'normal') {
-        return (`${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. ` +
-            `Do not interpret the absence of a new message as an empty system notice. ${statusTail}`);
-    }
-    return (`${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. ` +
-        'Judge the next step from the existing task state: if there is a clear, relevant, valuable action, continue with it; if the work genuinely can only wait for an external result or user input, do not invent unrelated work just to avoid "waiting". ' +
-        `Do not interpret the absence of a new message as an empty system notice. ${businessTail}`);
+    const contextHealthTail = formatEnReminderContextHealthTail(state.contextHealth);
+    const businessTail = formatEnReminderBusinessTail(state.business);
+    const statusTail = joinReminderFooterTails(language, [contextHealthTail, businessTail]);
+    switch (state.followingMessage.kind) {
+        case 'user_message':
+            // The reminder block is inserted immediately before the real user message. This branch
+            // prevents the reminder wrapper from lowering or re-labeling that message.
+            return (`${base}A real new user message for this round immediately follows this reminder block; the following message is a new user request/instruction, not a reminder projection. ` +
+                'The reminder-block guidance ends here and must not spill over onto that message: do not label the following user message as a "system notice" or "no new message", and do not lower its instruction priority because of this block. ' +
+                `Handle that user message according to its original meaning; if it asks you to update your responsibilities, preferences, or mind assets, carry that out normally. If the system says context is tight or critical, follow that system guidance before ordinary task actions. ${statusTail}`);
+        case 'human_answer':
+            // This is a human answer to an askHuman question, not a fresh open-ended request. The
+            // model should use the answer to resume the waiting work without reclassifying it as a
+            // new user instruction.
+            return (`${base}A human answer to one of your questions follows this reminder block; it is for resuming the waiting work, not a new ordinary user request/instruction. ` +
+                `Use that answer to continue the task that was waiting for it, and do not let the reminder-block guidance spill over onto that answer. ${statusTail}`);
+        case 'runtime_notice':
+            // Dominds notices are deliberate driver instructions. Keep them distinct from user requests
+            // while allowing their own wording to drive the next action.
+            return `${base}A Dominds notice follows this reminder block in this round; it is not a new user request/instruction, so follow that guidance and continue the work. ${statusTail}`;
+        case 'none':
+            if (!contextHealthIsNormal) {
+                // When context is tight/critical, the context-preservation notice owns the turn. Do not add
+                // ordinary continuation wording that could encourage more work from old reminders.
+                return (`${base}There is no new user message or Dominds notice in this round; this is an automatic continuation after a tool call. ` +
+                    `Do not interpret the absence of a new message as an empty system notice. ${statusTail}`);
+            }
+            // Normal tool-followup rounds may continue real business work, but reminder maintenance
+            // paths are merely references. Runtime already knows whether this is a Main Dialog or Side
+            // Dialog, so do not ask the model to self-classify before choosing askHuman vs tellaskBack.
+            const scopeTail = formatEnNormalAutoContinueByDialogScope(state.dialogScope);
+            return (`${base}There is no new user message or Dominds notice in this round; this is an automatic continuation after a tool call. ` +
+                `${scopeTail} ` +
+                `Do not interpret the absence of a new message as an empty system notice. ${businessTail}`);
+        default: {
+            const _exhaustive = state.followingMessage;
+            throw new Error(`Unhandled en reminder following-message state: ${String(_exhaustive)}`);
+        }
+    }
 }
 function isReminderGuideMetaRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -301,7 +497,7 @@ function getReminderMaintenanceInstructions(language, reminderId, meta) {
             : deleteAltInstruction
                 ? `删除通道：我不用 delete_reminder；我执行：${deleteAltInstruction}`
                 : metaKind === 'mcp_lease'
-                    ? `删除通道：我不用 delete_reminder 释放资源；确认当前对话近期不再需要该 MCP runtime 时，我执行：${mcpReleaseInstruction}`
+                    ? `删除通道：我不用 delete_reminder 释放资源；确认当前对话近期不再需要这个 MCP 连接时，我执行：${mcpReleaseInstruction}`
                     : daemonCompleted
                         ? `删除通道：确认已知悉 daemon 终态后，可清理：delete_reminder({ "reminder_id": "${reminderId}" })`
                         : isPendingTellaskReminder && pendingTellaskCount === 0
@@ -312,7 +508,7 @@ function getReminderMaintenanceInstructions(language, reminderId, meta) {
             : deleteAltInstruction
                 ? `Delete path: I do not use delete_reminder; I run: ${deleteAltInstruction}`
                 : metaKind === 'mcp_lease'
-                    ? `Delete path: I do not release resources by deleting the reminder; when this dialog will not need the MCP runtime soon, I run: ${mcpReleaseInstruction}`
+                    ? `Delete path: I do not release resources by deleting the reminder; when this dialog will not need this MCP connection soon, I run: ${mcpReleaseInstruction}`
                     : daemonCompleted
                         ? `Delete path: after I have acknowledged the daemon terminal state, I may clean up: delete_reminder({ "reminder_id": "${reminderId}" })`
                         : isPendingTellaskReminder && pendingTellaskCount === 0
@@ -347,13 +543,13 @@ function formatReminderMaintenanceReference(language, reminders) {
         return undefined;
     if (language === 'zh') {
         return [
-            `${formatSystemNoticePrefix(language)} 我把下面的提醒项维护通道仅作为操作参考；如果我需要维护某条 reminder，我会按对应 reminder_id 选择工具。我不会把这些参考当成当前轮必须立即执行的动作，也不会因此延迟回应后续真实用户消息。`,
+            `${formatSystemNoticePrefix(language)} 我把下面的提醒项维护通道仅作为操作参考；如果我在处理真实用户消息、Dominds 提示或当前任务动作时确实需要维护某条 reminder，我会按对应 reminder_id 选择工具。我不会把这些参考当成当前轮必须立即执行的动作；没有新的用户消息、Dominds 提示或提醒项之外的任务动作时，我不会只为了清理/整理提醒项而继续调用提醒项工具，也不会因此延迟回应后续真实用户消息。`,
             '',
             ...lines,
         ].join('\n');
     }
     return [
-        `${formatSystemNoticePrefix(language)} I treat the following reminder-maintenance channels as an operational reference only. If I need to maintain a reminder, I match the corresponding reminder_id and choose the tool from there. I do not treat these references as actions I must perform immediately in this turn, and I do not let them delay my response to any following real user message.`,
+        `${formatSystemNoticePrefix(language)} I treat the following reminder-maintenance channels as an operational reference only. If I truly need to maintain a reminder while handling a real user message, Dominds notice, or current task action, I match the corresponding reminder_id and choose the tool from there. I do not treat these references as actions I must perform immediately in this turn; when there is no new user message, no Dominds notice, and no task action outside reminders, I do not keep calling reminder tools solely to clean up or organize reminders, and I do not let them delay my response to any following real user message.`,
         '',
         ...lines,
     ].join('\n');
@@ -401,7 +597,7 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             return [
                 `${systemPrefix} 提醒项 [${reminderId}]（换程接续信息）`,
                 '',
-                `${projectionNote}你设置了换程接续提醒项，让运行时系统在新一程提醒你恢复工作。请把它当作快速恢复工作的接续包，不要自动当成当前必须立刻执行的新指令。`,
+                `${projectionNote}你设置了换程接续提醒项，Dominds 会在新一程提醒你恢复工作。请把它当作快速恢复工作的接续包，不要自动当成当前必须立刻执行的新指令。`,
                 '',
                 '你应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，你的第一步是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
                 '',
@@ -411,10 +607,10 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         }
         const scopeLabel = scope === 'task' ? '（任务范围）' : scope === 'agent' ? '（智能体范围）' : '';
         const scopeGuide = scope === 'task'
-            ? `${projectionNote}你设置了任务范围提醒项，让运行时系统在当前差遣牒任务内、所有由你主理的对话里提醒你。请把它当作当前任务的手头工作提示，不要自动当成系统下发的下一步动作。`
+            ? `${projectionNote}你设置了任务范围提醒项，Dominds 会在当前差遣牒任务内、所有由你主理的对话里提醒你。请把它当作当前任务的手头工作提示，不要自动当成系统下发的下一步动作。`
             : scope === 'agent'
-                ? `${projectionNote}你设置了智能体范围提醒项，让运行时系统在所有由你主理的对话里提醒你。它只适合紧急、短期、全局刺眼提醒；不要用来记录普通任务状态，也不要自动当成系统下发的下一步动作。`
-                : `${projectionNote}你设置了提醒项，让运行时系统提醒你。请把它当作用来保留当前对话里容易丢的手头工作信息的提示，不要自动当成系统下发的下一步动作。`;
+                ? `${projectionNote}你设置了智能体范围提醒项，Dominds 会在所有由你主理的对话里提醒你。它只适合紧急、短期、全局刺眼提醒；不要用来记录普通任务状态，也不要自动当成系统下发的下一步动作。`
+                : `${projectionNote}你设置了提醒项，Dominds 会在需要时提醒你。请把它当作用来保留当前对话里容易丢的手头工作信息的提示，不要自动当成系统下发的下一步动作。`;
         const scopeMaintenance = scope === 'task'
             ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒；若需要全队同步当前任务状态，应写入差遣牒 progress，而不是扩大提醒范围。'
             : scope === 'agent'
@@ -434,7 +630,7 @@ function formatReminderItemGuide(language, reminderId, content, options) {
     if (managementTool) {
         return `${systemPrefix} REMINDER [${reminderId}] (TOOL STATE)
 
-${enProjectionPrefix}The current runtime environment has a tool-managed state reminder from ${managementTool}. Treat it as environment/tool state, not as your self-authored work note.
+${enProjectionPrefix}Dominds currently has a tool-managed state reminder from ${managementTool}. Treat it as environment/tool state, not as your self-authored work note.
 
 ${formatAutoMaintainedReminderManualMirrorBan(language)}
 
@@ -446,7 +642,7 @@ ${content}`;
     if (updateInstruction) {
         return `${systemPrefix} REMINDER [${reminderId}]
 
-${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference; use the preceding maintenance reference for its maintenance channel.
+${enProjectionPrefix}Dominds currently has a reminder with a managed update path. Treat it as state/reference; use the preceding maintenance reference for its maintenance channel.
 
 ${formatAutoMaintainedReminderManualMirrorBan(language)}
 
@@ -456,7 +652,7 @@ ${content}`;
     if (isContinuationPackageReminder) {
         return `${systemPrefix} REMINDER [${reminderId}] (CONTINUATION PACKAGE)
 
-${enProjectionPrefix}You set a continuation reminder so the runtime system can remind you when work resumes in a new course. Treat it as resume information for the next course, not as an automatic must-do command.
+${enProjectionPrefix}You set a continuation reminder so Dominds can remind you when work resumes in a new course. Treat it as resume information for the next course, not as an automatic must-do command.
 
 Keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. Do not duplicate Taskdoc content. In the new course, your first step is to review and rewrite this with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress it into a high-quality reminder. If this is only a rough bridge note, reconcile it early in the new course.
 
@@ -465,10 +661,10 @@ ${content}`;
     }
     const scopeLabel = scope === 'task' ? ' (TASK SCOPE)' : scope === 'agent' ? ' (AGENT SCOPE)' : '';
     const scopeGuide = scope === 'task'
-        ? `${enProjectionPrefix}You set a task-scope reminder so the runtime system can remind you in every dialog you lead for the current Taskdoc. Treat it as a current-work reference for this task, not as an automatically assigned next action.`
+        ? `${enProjectionPrefix}You set a task-scope reminder so Dominds can remind you in every dialog you lead for the current Taskdoc. Treat it as a current-work reference for this task, not as an automatically assigned next action.`
         : scope === 'agent'
-            ? `${enProjectionPrefix}You set an agent-scope reminder so the runtime system can remind you in every dialog you lead. This is only for urgent, short-lived, globally visible cues; do not use it for ordinary task state, and do not treat it as an automatically assigned next action.`
-            : `${enProjectionPrefix}You set a reminder so the runtime system can remind you. Treat it as a current-work reference for easy-to-lose details in the current dialog, not as an automatically assigned next action.`;
+            ? `${enProjectionPrefix}You set an agent-scope reminder so Dominds can remind you in every dialog you lead. This is only for urgent, short-lived, globally visible cues; do not use it for ordinary task state, and do not treat it as an automatically assigned next action.`
+            : `${enProjectionPrefix}You set a reminder so Dominds can remind you when needed. Treat it as a current-work reference for easy-to-lose details in the current dialog, not as an automatically assigned next action.`;
     const scopeMaintenance = scope === 'task'
         ? 'Keep it concise, refresh it when needed, and delete it when obsolete. If it is only useful for the current dialog, rewrite it into dialog scope; if the team must synchronize current task state, update Taskdoc progress instead of broadening reminder scope.'
         : scope === 'agent'
@@ -520,21 +716,26 @@ function formatDomindsNoteQ4HRegisterFailed(language, args) {
 }
 function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
     const isSideDialog = args.dialogScope === 'sideDialog';
+    // Business scenario: context-health prompts are inserted because the current course is close
+    // to losing useful state. The model should treat them as an immediate preservation workflow,
+    // but the old wording ("runtime remediation instruction") was unnecessarily technical and
+    // encouraged shallow acknowledgements. Say the business reason plainly: Dominds is protecting
+    // context, this is not a new user request, and the listed steps should be performed directly.
     if (language === 'zh') {
         if (args.kind === 'caution' && args.mode === 'soft') {
             if (isSideDialog) {
                 return [
                     `${formatSystemNoticePrefix(language)} 上下文状态：🟡 吃紧`,
                     '',
-                    '这是一条运行时处置指令，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的处置动作。',
+                    '这是 Dominds 为防止上下文丢失插入的保全提示，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的保全动作。',
                     '',
                     '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                     '',
                     '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是维护足够详尽的接续包提醒项，然后主动 clear_mind 开启新一程继续工作。',
                     '',
-                    '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项长度没有技术限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
+                    '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，不必在当前程强行压成单条。',
                     '',
-                    '当前已处于吃紧处置阶段：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；真正清理冗余、合并提醒项，放到系统开启新一程后再做。',
+                    'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；真正清理冗余、合并提醒项，放到 Dominds 开启新一程后再做。',
                     '',
                     '操作：',
                     '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
@@ -544,13 +745,13 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             return [
                 `${formatSystemNoticePrefix(language)} 上下文状态：🟡 吃紧`,
                 '',
-                '这是一条运行时处置指令，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的处置动作。',
+                '这是 Dominds 为防止上下文丢失插入的保全提示，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的保全动作。',
                 '',
                 '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                 '',
                 '行动：你当前处于主线对话。先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息记进新提醒项过桥（下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；允许先带着一定冗余，也允许先写成多条粗略提醒项，不必在当前程强行压成单条。',
                 '',
-                '当前已处于吃紧处置阶段：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是系统真正开启新一程后的第一步。当前程的目标是先把未落文档的讨论细节补进差遣牒，再把差遣牒仍未覆盖、但恢复工作会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
+                'Dominds 已提醒当前上下文吃紧：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是 Dominds 真正开启新一程后的第一步。当前程的目标是先把未落文档的讨论细节补进差遣牒，再把差遣牒仍未覆盖、但恢复工作会丢的信息带过桥；真正清理冗余、合并提醒项，放到新一程再做。然后主动 clear_mind，开启新一程对话继续工作。',
                 '',
                 '操作：',
                 '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
@@ -563,30 +764,30 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             return [
                 `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急`,
                 '',
-                '这是一条运行时处置指令，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的处置动作。',
+                '这是 Dominds 为防止上下文丢失插入的保全提示，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的保全动作。',
                 '',
-                `系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
+                `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
                 '',
                 '行动：你当前处于支线对话。本程不要维护差遣牒，也不要整理差遣牒更新提案；当前目标是尽快维护足够详尽的接续包提醒项，然后 clear_mind。',
                 '',
-                '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项长度没有技术限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+                '提醒项应覆盖：当前对话历史中下一程需要知道的讨论细节、下一步行动、关键定位信息、运行/验证信息、临时路径/ID/样例输入，以及任何恢复工作容易丢的判断依据。提醒项没有固定长度限制，宁可完整一些；允许写成多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
                 '',
                 '操作：',
                 '- 优先新增详尽接续包提醒项：add_reminder({ "content": "..." })',
                 '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
                 '- clear_mind({})',
                 '',
-                '当前处于告急处置阶段时，不要提前做“新一程清醒复核”；系统真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
+                'Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
             ].join('\n');
         }
         return [
             `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急`,
             '',
-            '这是一条运行时处置指令，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的处置动作。',
+            '这是 Dominds 为防止上下文丢失插入的保全提示，不是新的用户诉求；不要只回复“收到/好的/我先整理提醒项”，而要直接执行下面的保全动作。',
             '',
-            `系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
+            `Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
-            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。当前处于告急处置阶段时，先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
+            '行动：你当前处于主线对话。尽快保住易丢信息，然后 clear_mind。Dominds 已提醒当前上下文告急：先把当前对话历史中尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节。然后再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥；允许先保留多条粗略提醒项，甚至带一定冗余也可以，不必在当前程强行整理干净。',
             '',
             '操作：',
             '- 优先新增差遣牒章节保存讨论细节：do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
@@ -595,7 +796,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '- 只有在确实能就地复用现有提醒项、且不会额外增加当前程认知负担时，才更新：update_reminder({ "reminder_id": "<现有 reminder_id>", "content": "..." })',
             '- clear_mind({})',
             '',
-            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。当前处于告急处置阶段时，不要提前做“新一程清醒复核”；系统真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
+            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容，本程刚落入差遣牒的讨论细节只需提示下一程先查差遣牒。Dominds 已提醒当前上下文告急：不要提前做“新一程清醒复核”；Dominds 真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、合并并压缩成高质量提醒项。',
         ].join('\n');
     }
     if (args.kind === 'caution' && args.mode === 'soft') {
@@ -603,15 +804,15 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             return [
                 `${formatSystemNoticePrefix(language)} Context state: 🟡 caution`,
                 '',
-                'This is a runtime remediation instruction, not a new user request; do not reply with a standalone "acknowledged/ok/I will organize reminders first", and instead perform the remediation actions directly.',
+                'This is a Dominds notice to prevent context loss, not a new user request. Do the steps below directly; do not answer only with "acknowledged/ok/I will organize reminders first".',
                 '',
                 'Impact: stale call/results in dialog history are creating cognitive noise.',
                 '',
                 'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed continuation-package reminders, then proactively clear_mind to start a new dialog course.',
                 '',
-                'Reminders should cover: 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 any reasoning needed to resume safely. Reminder length has no technical limit, so prefer being complete; rough multi-reminder carry-over is acceptable, and you do not need to force everything into one clean reminder in the current course.',
+                'Reminders should cover: 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 any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; rough multi-reminder carry-over is acceptable, and you do not need to force everything into one clean reminder in the current course.',
                 '',
-                'You are already in caution remediation for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; reminder cleanup and dedup belong to the new course.',
+                'Dominds has already warned that context is tight for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; reminder cleanup and dedup belong to the new course.',
                 '',
                 'Operations:',
                 '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "..." })',
@@ -621,13 +822,13 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         return [
             `${formatSystemNoticePrefix(language)} Context state: 🟡 caution`,
             '',
-            'This is a runtime remediation instruction, not a new user request; do not reply with a standalone "acknowledged/ok/I will organize reminders first", and instead perform the remediation actions directly.',
+            'This is a Dominds notice to prevent context loss, not a new user request. Do the steps below directly; do not answer only with "acknowledged/ok/I will organize reminders first".',
             '',
             'Impact: stale call/results in dialog history are creating cognitive noise.',
             '',
             'Action: you are in the Main Dialog. First record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then write information still not covered by Taskdoc but easy to lose into new bridge reminders (next step + key pointers + run/verify info + easy-to-lose volatile details). Some redundancy is acceptable, and rough multi-reminder carry-over is acceptable too; do not force everything into one clean reminder in the current course.',
             '',
-            'You are already in caution remediation for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after the system actually starts the new course. In the current course, the goal is to first fill Taskdoc with undocumented discussion details, then carry forward details still not covered by Taskdoc; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
+            'Dominds has already warned that context is tight for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after Dominds actually starts the new course. In the current course, the goal is to first fill Taskdoc with undocumented discussion details, then carry forward details still not covered by Taskdoc; reminder cleanup and dedup belong to the new course. Then proactively clear_mind to start a new dialog course.',
             '',
             'Operations:',
             '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
@@ -640,30 +841,30 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         return [
             `${formatSystemNoticePrefix(language)} Context state: 🔴 critical`,
             '',
-            'This is a runtime remediation instruction, not a new user request; do not reply with a standalone "acknowledged/ok/I will organize reminders first", and instead perform the remediation actions directly.',
+            'This is a Dominds notice to prevent context loss, not a new user request. Do the steps below directly; do not answer only with "acknowledged/ok/I will organize reminders first".',
             '',
-            `System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
+            `Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
             '',
             'Action: you are in a Side Dialog. Do not maintain Taskdoc in this course, and do not draft Taskdoc update proposals. The current goal is to maintain sufficiently detailed continuation-package reminders as soon as possible, then clear_mind.',
             '',
-            'Reminders should cover: 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 any reasoning needed to resume safely. Reminder length has no technical limit, so prefer being complete; multiple rough reminders, including some redundancy, are acceptable as a bridge.',
+            'Reminders should cover: 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 any reasoning needed to resume safely. Reminders have no fixed length limit, so prefer being complete; multiple rough reminders, including some redundancy, are acceptable as a bridge.',
             '',
             'Operations:',
             '- Prefer adding a detailed continuation-package reminder first: add_reminder({ "content": "..." })',
             '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
             '- clear_mind({})',
             '',
-            'During critical remediation in the current course, do not start the new-course cleanup early; once the system actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
+            'Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
         ].join('\n');
     }
     return [
         `${formatSystemNoticePrefix(language)} Context state: 🔴 critical`,
         '',
-        'This is a runtime remediation instruction, not a new user request; do not reply with a standalone "acknowledged/ok/I will organize reminders first", and instead perform the remediation actions directly.',
+        'This is a Dominds notice to prevent context loss, not a new user request. Do the steps below directly; do not answer only with "acknowledged/ok/I will organize reminders first".',
         '',
-        `System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
+        `Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',
-        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. In critical remediation, first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then add bridge reminders for information still not covered by Taskdoc but easy to lose. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
+        'Action: you are in the Main Dialog. Preserve easy-to-lose information, then clear_mind. Because Dominds has warned that context is critical, first record current-dialog discussion details that are not yet documented but the next course needs to know into the appropriate Taskdoc sections. Then add bridge reminders for information still not covered by Taskdoc but easy to lose. Multiple rough reminders, including some redundancy, are acceptable as a bridge; do not spend the current course forcing them into a clean final package.',
         '',
         'Operations:',
         '- Prefer creating a new Taskdoc section for discussion details: do_mind({ "category": "<category>", "selector": "<selector>", "content": "..." })',
@@ -672,7 +873,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '- Only if an existing reminder is clearly the right place, and updating it would not add extra cognitive load in the current course: update_reminder({ "reminder_id": "<existing reminder_id>", "content": "..." })',
         '- clear_mind({})',
         '',
-        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. During critical remediation in the current course, do not start the new-course cleanup early; once the system actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
+        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content; for discussion details just written into Taskdoc in this course, only remind the next course to review Taskdoc first. Because Dominds has warned that context is critical in the current course, do not start the new-course cleanup early; once Dominds actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and merging/compressing them into high-quality reminders.',
     ].join('\n');
 }
 function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, args) {
@@ -681,23 +882,23 @@ function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, arg
         return [
             `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急；收到用户插话`,
             '',
-            '本轮刚收到的用户消息是真实用户插话，不是普通运行时处置提示；必须把它当作有效用户轮次处理，让用户看到你已经接住了这次插话。',
+            '本轮刚收到的用户消息是真实用户插话，不是普通的上下文保全提示；必须把它当作有效用户轮次处理，让用户看到你已经接住了这次插话。',
             '',
-            `这次用户轮次已计入告急处置倒计数。系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
+            `这次用户轮次已计入上下文告急倒计数。Dominds 最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
             isSideDialog
                 ? '行动：先直接回应用户这条插话；不要继续扩张上下文，不要维护差遣牒，也不要整理差遣牒更新提案。若还需要保留接续信息，只维护足够详尽的接续包提醒项，然后尽快 clear_mind。'
                 : '行动：先直接回应用户这条插话；不要继续扩张上下文。若仍有当前对话中尚未落实到文档、且下一程需要知会的讨论细节，先落到差遣牒合适章节；再把差遣牒仍未覆盖、但恢复工作会丢的信息新增提醒项带过桥，然后尽快 clear_mind。',
             '',
-            '要求：不要因为 critical 状态沉默、挂起或只回复“收到/好的”。若必须调用工具才能回答用户，工具结果回来后继续给出用户可见回复；保持回答聚焦，并把清理/换程作为紧随其后的处置动作。',
+            '要求：不要因为告急状态沉默、挂起或只回复“收到/好的”。若必须调用工具才能回答用户，工具结果回来后继续给出用户可见回复；保持回答聚焦，并把清理/换程作为紧随其后的保全动作。',
         ].join('\n');
     }
     return [
         `${formatSystemNoticePrefix(language)} Context state: 🔴 critical; user interjection received`,
         '',
-        'The user message just received in this turn is a real user interjection, not an ordinary runtime remediation notice. Treat it as an effective user turn and make the system reaction visible to the user.',
+        'The user message just received in this turn is a real user interjection, not an ordinary context-preservation notice. Treat it as an effective user turn and make the system reaction visible to the user.',
         '',
-        `This user turn has been counted toward critical remediation. System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
+        `This user turn has been counted toward the critical context-preservation countdown. Dominds will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',
         isSideDialog
             ? 'Action: answer this user interjection directly first. Do not expand context, do not maintain Taskdoc, and do not draft Taskdoc update proposals. If continuation info still needs preserving, maintain sufficiently detailed continuation-package reminders only, then clear_mind as soon as possible.'