dominds 1.8.0 → 1.8.1

package/dist/course-transition.js

@@ -39,14 +39,15 @@ const dialog_global_registry_1 = require("./dialog-global-registry");
 const dialog_instance_registry_1 = require("./dialog-instance-registry");
 const log_1 = require("./log");
 const persistence_1 = require("./persistence");
+const driver_messages_1 = require("./shared/i18n/driver-messages");
 const runtime_language_1 = require("./shared/runtime-language");
 const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
 const pending_tellask_reminder_1 = require("./tools/pending-tellask-reminder");
 function buildClearedMindInvalidationNotice(language) {
     if (language === 'zh') {
-        return '系统反馈：诉请对象已清理头脑并开启新一程对话；本轮诉请已失效，请基于最新完整上下文重新诉请祂。';
+        return `${(0, driver_messages_1.formatSystemNoticePrefix)(language)} 诉请对象已清理头脑并开启新一程对话；本轮诉请已失效，请基于最新完整上下文重新诉请祂。`;
     }
-    return 'System notice: the callee cleared its mind and started a new course; this tellask round is no longer valid. Re-tellask with the latest complete context.';
+    return `${(0, driver_messages_1.formatSystemNoticePrefix)(language)} the callee cleared its mind and started a new course; this tellask round is no longer valid. Re-tellask with the latest complete context.`;
 }
 async function loadWaitingOwnerRecords(dialog) {
     const allDialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');

package/dist/docs/context-health.md

@@ -148,6 +148,10 @@ When `level === 'caution'`, the driver auto-inserts a **role=user** guidance pro
 LLM generation turn, and **persists it as a normal user message** so the UI renders it as a normal
 user instruction.
 
+The runtime prefix for this class of message is an explicit system-notice header (currently
+`[System notice]` in English and `【系统提示】` in Chinese), so the agent should treat it as
+system-directed runtime guidance rather than as a self-authored reminder.
+
 Current behavior:
 
 - On entering `caution`, Dominds inserts the prompt once (entry injection).

package/dist/docs/context-health.zh.md

@@ -120,6 +120,8 @@ Dominds 计算比率：
 
 当 `level === 'caution'` 时，驱动程序在**下一个** LLM 生成轮次自动插入一条 **role=user** 指导提示，并**将其持久化为普通用户消息**，以便 UI 将其渲染为正常的用户指令。
 
+这类消息在运行时会带明确的系统提示头标（当前英文为 `[System notice]`，中文为 `【系统提示】`），语义上应视为系统投递的运行时提示，而不是智能体给自己写的提醒项。
+
 当前行为：
 
 - 进入 `caution` 时，Dominds 插入一次提示（入口注入）。

package/dist/docs/dialog-system.md

@@ -1116,7 +1116,10 @@ To make the UI **faithfully reflect the original generation order**, and to ensu
 Dominds persists fine-grained message entries (thinking/saying/tool call/tool result, etc.). In contrast, most mainstream LLM provider chat protocols only support `role=user|assistant` (plus limited tool-specific variants).
 
 - **Ideal target**: Provider SDKs/protocols should natively support `role='environment'` (or an equivalent mechanism) for runtime-injected environment/system content (e.g. reminders, transient guides), so we don't have to disguise environment content as user messages.
-- **Current reality**: Most providers do not support `role='environment'`. Therefore, when projecting Dominds messages into provider request payloads, Dominds must temporarily project `environment_msg` / `transient_guide_msg` / reminders as `role='user'` text blocks to keep requests valid.
+- **Current reality**: Most providers do not support `role='environment'`. Therefore, when projecting Dominds messages into provider request payloads, Dominds must flatten internal message kinds into provider-supported roles.
+  - Runtime/system notices (`environment_msg`) are projected as `role='user'` text blocks.
+  - Self-authored guides / self-reminders (`transient_guide_msg`) are projected as `role='assistant'` text blocks.
+  - Reminders follow their source semantics rather than one blanket rule: system-maintained reminders (for example runtime status signals) should land on the `user` side as explicit system notices, while self-maintained work reminders stay on the `assistant` side as first-person work notes.
 
 Additionally, some providers (especially Anthropic-compatible endpoints) enforce stricter validation around **role alternation** and **tool_use/tool_result boundaries**. Dominds' projection layer must assemble internal fine-grained entries into provider-friendly turns (turn assembly), rather than sending a 1:1 mapping of persisted entries.
 

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

@@ -1097,7 +1097,10 @@ Dominds 将 LLM 输出拆分为多个“子流”（thinking、saying，以及
 Dominds 内部持久化的消息粒度较细（thinking/saying/tool call/tool result 等会以独立条目出现），而当前主流 LLM Provider 的对话协议一般仅支持 `role=user|assistant`（以及少量实现把工具结果视作特殊的 tool/user 变体）。
 
 - **理想目标**：Provider 协议能够原生支持 `role='environment'`（或等价机制）来承载运行时注入的环境/系统信息（例如 reminders、transient guide 等），从而避免把“环境信息”伪装成用户发言。
-- **当前现实**：大多数 Provider 不支持 `role='environment'`。因此 Dominds 在投影到 Provider 请求 payload 时，必须把 `environment_msg` / `transient_guide_msg` / reminders 等内容暂时投影为 `role='user'` 的文本块，以保证请求结构可被接受。
+- **当前现实**：大多数 Provider 不支持 `role='environment'`。因此 Dominds 在投影到 Provider 请求 payload 时，必须把内部消息类型压平到 Provider 可接受的角色集合中。
+  - 运行时/系统提示（`environment_msg`）投影为 `role='user'` 的文本块。
+  - 智能体自写的短指导/自我提醒（`transient_guide_msg`）投影为 `role='assistant'` 的文本块。
+  - reminders 不再一刀切：系统托管的状态型提醒（如运行时状态信号）应落在 `user` 侧并带明确系统提示头标；智能体自维护的工作提醒项则保留在 `assistant` 侧，以第一人称工作便签的语义出现。
 
 另外，一些 Provider（尤其是 Anthropic-compatible endpoint）对 **role 交替** 与 **tool_use/tool_result 的边界** 有更严格的结构校验。Dominds 的投影层需要把内部细粒度条目组装为更“turn 化”的 Provider 消息序列（turn assembly），而不是把内部条目逐条 1:1 发送。
 

package/dist/docs/memory-system.md

@@ -151,11 +151,14 @@ Some reminders are generated by the runtime (e.g. background process status, MCP
 
 - read and adjust behavior
 - but don’t treat them as your personal worklog (their lifecycle is typically system-managed)
+- in message semantics, these should be treated as **system notices**: they typically appear on the `role=user` side with an explicit notice prefix, so they do not get mistaken for self-authored work notes
 
 #### 3) Curated by the agent: work reminders (working set / worklog)
 
 Reminders are your tiny working set: injected every turn, and preserved across `clear_mind`.
 
+In message semantics, these should be treated as **self reminders**: they belong on the `role=assistant` side and should read like first-person working notes rather than fresh external instructions.
+
 Guidelines:
 
 - keep it to 1–3 items; update-in-place whenever possible

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

@@ -150,11 +150,14 @@ TL;DR：
 
 - 你应该阅读并据此调整行为
 - 但它们的生命周期通常由系统管理（自动更新/自动清理），不要把它们当成个人工作日志
+- 在消息语义上，这类提醒应视为**系统提示**：通常落在 `role=user` 侧，并带显眼头标（如 `【系统提示】`），避免与个人工作提醒混淆
 
 #### 3) 智能体自主增删改：工作提醒项（工作集/工作日志）
 
 提醒项是你为自己维护的“超小工作集”：它会在每次生成时注入上下文，并能跨 `clear_mind` 保留。
 
+在消息语义上，这类提醒应视为**自我提醒**：落在 `role=assistant` 侧，并使用第一人称口吻，避免伪装成新的外部指令。
+
 建议：
 
 - 总量保持 1–3 条；能原地更新就不要新建

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

@@ -418,8 +418,8 @@ async function renderRemindersForContext(dlg) {
             continue;
         }
         rendered.push({
-            type: 'environment_msg',
-            role: 'user',
+            type: 'transient_guide_msg',
+            role: 'assistant',
             content: (0, driver_messages_1.formatReminderItemGuide)(language, reminderNo, reminder.content, {
                 meta: reminder.meta,
             }),
@@ -1133,8 +1133,8 @@ async function driveDialogStreamCore(dlg, humanPrompt, driveOptions, callbacks)
                 const uiLanguage = dlg.getLastUserLanguageCode();
                 const workingLanguage = (0, runtime_language_1.getWorkLanguage)();
                 const guideMsg = {
-                    type: 'transient_guide_msg',
-                    role: 'assistant',
+                    type: 'environment_msg',
+                    role: 'user',
                     content: (0, driver_messages_1.formatCurrentUserLanguagePreference)(workingLanguage, uiLanguage),
                 };
                 const ctxMsgs = (0, context_1.assembleDriveContextMessages)({

package/dist/minds/system-prompt.js

@@ -294,8 +294,8 @@ function buildSystemPrompt(input) {
 - 你可能会收到一条短的引导信息，形如"用户可见回复语言：X"。当你对用户作答时，请优先遵循该引导；若未给出引导，则使用工作语言作答。
 
 ## 消息类型
-- 以 \`[系统通知]\` 或 \`[System notification]\` 开头的消息是**系统通知**，不是用户输入。
-- 系统通知不需要你直接回复给用户，但需要你根据通知内容执行相应的操作（如维护提醒项、调用 clear_mind 等）。
+- 以 \`【系统提示】\` 或 \`[System notice]\` 开头的消息是**系统提示**，不是用户输入。
+- 系统提示不需要你直接回复给用户，但需要你根据提示内容执行相应的操作（如维护提醒项、调用 clear_mind 等）。
 
 ## 指令优先级与冲突处理
 - 优先级：系统 > 差遣牒 > 用户 > 工具回执。
@@ -387,8 +387,8 @@ ${functionToolRules}
 - You may receive a short guide message like "User-visible response language: X". When replying to the user, follow that guide; if absent, respond in the working language.
 
 ## Message Types
-- Messages starting with \`[系统通知]\` or \`[System notification]\` are **system notifications**, not user input.
-System notifications convey important state changes (e.g., context caution/critical, Diligence Push triggered). Read carefully and follow the instructions.
+- Messages starting with \`【系统提示】\` or \`[System notice]\` are **system notices**, not user input.
+System notices convey important state changes (e.g., context caution/critical, Diligence Push triggered). Read carefully and follow the instructions.
 
 ## Instruction Priority & Conflicts
 - Priority order: system > taskdoc > user > tool outputs.

package/dist/server/websocket-handler.js

@@ -18,6 +18,7 @@ const priming_1 = require("../priming");
 const problems_1 = require("../problems");
 const diligence_1 = require("../shared/diligence");
 const evt_1 = require("../shared/evt");
+const driver_messages_1 = require("../shared/i18n/driver-messages");
 const runtime_language_1 = require("../shared/runtime-language");
 const language_1 = require("../shared/types/language");
 const time_1 = require("../shared/utils/time");
@@ -334,8 +335,8 @@ async function handleDeclareSubdialogDead(ws, packet) {
     }
     const parentDialog = await restoreDialogForDrive(callerDialogIdObj, 'running');
     const responseText = (0, runtime_language_1.getWorkLanguage)() === 'zh'
-        ? `系统反馈：支线对话 ${dialogIdObj.valueOf()} 已被用户宣布卡死（不可逆）。后续可以重用相同的 slug 发起全新支线对话；只是之前的上下文已不再，诉请正文请提供最新的完整上下文信息。`
-        : `System notice: sideline dialog ${dialogIdObj.valueOf()} has been declared dead by the user (irreversible). You may reuse the same slug to start a brand-new sideline dialog, but previous context is no longer retained; include the latest complete context in the tellask body.`;
+        ? `${(0, driver_messages_1.formatSystemNoticePrefix)('zh')} 支线对话 ${dialogIdObj.valueOf()} 已被用户宣布卡死（不可逆）。后续可以重用相同的 slug 发起全新支线对话；只是之前的上下文已不再，诉请正文请提供最新的完整上下文信息。`
+        : `${(0, driver_messages_1.formatSystemNoticePrefix)('en')} sideline dialog ${dialogIdObj.valueOf()} has been declared dead by the user (irreversible). You may reuse the same slug to start a brand-new sideline dialog, but previous context is no longer retained; include the latest complete context in the tellask body.`;
     const responseTextWithNote = note === ''
         ? responseText
         : (0, runtime_language_1.getWorkLanguage)() === 'zh'

package/dist/shared/i18n/driver-messages.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSystemNoticePrefix = formatSystemNoticePrefix;
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
 exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatReminderItemGuide = formatReminderItemGuide;
@@ -11,19 +12,23 @@ exports.formatDomindsNoteDirectSelfCall = formatDomindsNoteDirectSelfCall;
 exports.formatDomindsNoteFbrDisabled = formatDomindsNoteFbrDisabled;
 exports.formatDomindsNoteFbrToollessViolation = formatDomindsNoteFbrToollessViolation;
 const language_1 = require("../types/language");
+function formatSystemNoticePrefix(language) {
+    return language === 'zh' ? '【系统提示】' : '[System notice]';
+}
 function formatCurrentUserLanguagePreference(workingLanguage, uiLanguage) {
     const uiName = (0, language_1.formatLanguageName)(uiLanguage, workingLanguage);
     const workingName = (0, language_1.formatLanguageName)(workingLanguage, workingLanguage);
+    const prefix = formatSystemNoticePrefix(workingLanguage);
     if (workingLanguage === 'zh') {
         if (uiLanguage === workingLanguage) {
-            return `用户可见回复语言：${uiName}。`;
+            return `${prefix}\n你对用户的可见回复语言应使用：${uiName}。`;
         }
-        return `用户可见回复语言：${uiName}。内部工作语言保持为：${workingName}（用于系统提示、队友诉请与工具调用）。`;
+        return `${prefix}\n你对用户的可见回复语言应使用：${uiName}。\n你的内部工作语言保持为：${workingName}（用于系统提示、队友诉请与工具调用）。`;
     }
     if (uiLanguage === workingLanguage) {
-        return `User-visible response language: ${uiName}.`;
+        return `${prefix}\nYour user-visible reply language should be: ${uiName}.`;
     }
-    return `User-visible response language: ${uiName}. Internal work language remains: ${workingName} (system prompt, teammate comms, function tools).`;
+    return `${prefix}\nYour user-visible reply language should be: ${uiName}.\nYour internal work language remains: ${workingName} (system prompt, teammate comms, function tools).`;
 }
 function formatNewCourseStartPrompt(language, args) {
     if (language === 'zh') {
@@ -78,12 +83,12 @@ function formatReminderItemGuide(language, index, content, options) {
             return [
                 `提醒项 #${index}（工具状态）`,
                 '',
-                '说明：这是由工具维护的提醒展示，可视为当前状态参考；它不自动等于你现在必须立刻执行的指令。',
+                '我把这条当作工具维护的状态参考，不把它自动当成我现在必须立刻执行的指令。',
                 '',
-                `提示：该提醒项由工具 ${managementTool} 管理；如需调整，请使用 ${managementTool}（不要用 update_reminder）。`,
+                `这条提醒项由工具 ${managementTool} 管理；如果我要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
                 '',
-                `如需更新此提醒项，可执行：${updateExampleSafe}`,
-                `如需删除此提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
+                `如果我要更新这条提醒项，可执行：${updateExampleSafe}`,
+                `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
                 '',
                 '---',
                 content,
@@ -93,12 +98,12 @@ function formatReminderItemGuide(language, index, content, options) {
             return [
                 `提醒项 #${index}（换程接续信息）`,
                 '',
-                '说明：这是用于换程后快速恢复工作的接续包，不自动等于当前必须立刻执行的指令。',
+                '我把这条当作换程后快速恢复工作的接续包，不把它自动当成当前必须立刻执行的指令。',
                 '',
-                '建议：优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，第一步就要以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
+                '我应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，我的第一步就是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后我必须尽快收敛。',
                 '',
-                `如需更新此接续包，可执行：update_reminder({ "reminder_no": ${index}, "content": "..." })`,
-                `如需删除此提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
+                `如果我要更新这份接续包，可执行：update_reminder({ "reminder_no": ${index}, "content": "..." })`,
+                `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
                 '',
                 '---',
                 content,
@@ -107,12 +112,12 @@ function formatReminderItemGuide(language, index, content, options) {
         return [
             `提醒项 #${index}`,
             '',
-            '说明：这是你给自己的显眼提示，用于保留当前对话里容易丢的工作信息；它不自动等于系统下发的下一步动作。',
+            '这是我给自己的显眼提示，用于保留当前对话里容易丢的工作信息；我不把它自动当成系统下发的下一步动作。',
             '',
-            '建议：保持简洁、及时更新；不再需要时删除。若后续准备换程，也可以把它整理成接续包。',
+            '我应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。',
             '',
-            `如需更新此提醒项，可执行：update_reminder({ "reminder_no": ${index}, "content": "..." })`,
-            `如需删除此提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
+            `如果我要更新这条提醒项，可执行：update_reminder({ "reminder_no": ${index}, "content": "..." })`,
+            `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
             '',
             '---',
             content,
@@ -122,45 +127,47 @@ function formatReminderItemGuide(language, index, content, options) {
         const updateExampleSafe = updateExample ?? `${managementTool}({ ... })`;
         return `REMINDER ITEM #${index} (TOOL STATE)
 
-Note: this is a tool-maintained reminder display. Treat it as state reference, not as an automatic must-do command.
+I treat this as a tool-maintained state reference, not as an automatic must-do command.
 
-This reminder is managed by tool ${managementTool}; if you need to change it, use ${managementTool} instead of update_reminder.
+This reminder is managed by tool ${managementTool}; if I need to change it, I should use ${managementTool} instead of update_reminder.
 
-If you need to update this reminder, run: ${updateExampleSafe}
-If you need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
+If I need to update this reminder, run: ${updateExampleSafe}
+If I need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
 ---
 ${content}`;
     }
     if (isContinuationPackageReminder) {
         return `REMINDER ITEM #${index} (CONTINUATION PACKAGE)
 
-Note: this is resume information for the next course, not an automatic must-do command.
+I treat this as resume information for the next course, not as an automatic must-do command.
 
-Guidance: keep the next step, key pointers, run/verify info, and easy-to-lose volatile details. 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.
+I should keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. I should not duplicate Taskdoc content. In the new course, my 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, I should reconcile it early in the new course.
 
-If you need to update this package, run: update_reminder({ "reminder_no": ${index}, "content": "..." })
-If you need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
+If I need to update this package, run: update_reminder({ "reminder_no": ${index}, "content": "..." })
+If I need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
 ---
 ${content}`;
     }
     return `REMINDER ITEM #${index}
 
-Note: this is a conspicuous reminder to yourself for easy-to-lose work details in the current dialog. It is not an automatically assigned next action.
+This is my conspicuous self-reminder for easy-to-lose work details in the current dialog. I do not treat it as an automatically assigned next action.
 
-Guidance: keep it concise, refresh it when needed, and delete it when obsolete. If you are preparing a new course, you can also rewrite it into a continuation package.
+I should keep it concise, refresh it when needed, and delete it when obsolete. If I am preparing a new course, I can also rewrite it into a continuation package.
 
-If you need to update this reminder, run: update_reminder({ "reminder_no": ${index}, "content": "..." })
-If you need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
+If I need to update this reminder, run: update_reminder({ "reminder_no": ${index}, "content": "..." })
+If I need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
 ---
 ${content}`;
 }
 function formatQ4HDiligencePushBudgetExhausted(language, args) {
     const maxInjectCount = args.maxInjectCount;
     if (language === 'zh') {
-        return [`[系统通知] 已经鞭策了 ${maxInjectCount} 次，智能体仍不听劝。`].join('\n');
+        return [
+            `${formatSystemNoticePrefix(language)} 已经鞭策了 ${maxInjectCount} 次，智能体仍不听劝。`,
+        ].join('\n');
     }
     return [
-        `[System notification] After ${maxInjectCount} Diligence Push attempts, the agent is still not moved.`,
+        `${formatSystemNoticePrefix(language)} After ${maxInjectCount} Diligence Push attempts, the agent is still not moved.`,
     ].join('\n');
 }
 function formatDomindsNoteTellaskForTeammatesOnly(language, args) {
@@ -191,7 +198,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
     if (language === 'zh') {
         if (args.kind === 'caution' && args.mode === 'soft') {
             return [
-                '[系统通知] 上下文状态：🟡 吃紧',
+                `${formatSystemNoticePrefix(language)} 上下文状态：🟡 吃紧`,
                 '',
                 '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                 '',
@@ -205,7 +212,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             ].join('\n');
         }
         return [
-            '[系统通知] 上下文状态：🔴 告急',
+            `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急`,
             '',
             `系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
@@ -221,7 +228,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
     }
     if (args.kind === 'caution' && args.mode === 'soft') {
         return [
-            '[System notification] Context state: 🟡 caution',
+            `${formatSystemNoticePrefix(language)} Context state: 🟡 caution`,
             '',
             'Impact: stale call/results in dialog history are creating cognitive noise.',
             '',
@@ -235,7 +242,7 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         ].join('\n');
     }
     return [
-        '[System notification] Context state: 🔴 critical',
+        `${formatSystemNoticePrefix(language)} Context state: 🔴 critical`,
         '',
         `System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',

package/dist/tools/mcp.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mcpLeaseReminderOwner = exports.mcpReleaseTool = exports.mcpRestartTool = void 0;
 const log_1 = require("../log");
 const supervisor_1 = require("../mcp/supervisor");
+const driver_messages_1 = require("../shared/i18n/driver-messages");
 const runtime_language_1 = require("../shared/runtime-language");
 const log = (0, log_1.createLogger)('tools/mcp');
 function parseMcpRestartArgs(args) {
@@ -137,38 +138,38 @@ exports.mcpLeaseReminderOwner = {
         return { treatment: 'keep' };
     },
     async renderReminder(dlg, reminder, index) {
+        const workLanguage = (0, runtime_language_1.getWorkLanguage)();
+        const prefix = (0, driver_messages_1.formatSystemNoticePrefix)(workLanguage);
         if (reminder.owner !== exports.mcpLeaseReminderOwner || !isMcpLeaseReminderMeta(reminder.meta)) {
-            const workLanguage = (0, runtime_language_1.getWorkLanguage)();
             return {
-                type: 'transient_guide_msg',
-                role: 'assistant',
+                type: 'environment_msg',
+                role: 'user',
                 content: workLanguage === 'zh'
-                    ? `系统提醒 #${index + 1}\n\n${reminder.content}`
-                    : `System Reminder #${index + 1}\n\n${reminder.content}`,
+                    ? `${prefix} MCP 工具集租约提醒 #${index + 1}\n你正在查看系统维护的 MCP 租约状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
+                    : `${prefix} MCP toolset lease reminder #${index + 1}\nYou are looking at system-maintained MCP lease state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
             };
         }
         const serverId = reminder.meta.serverId;
-        const workLanguage = (0, runtime_language_1.getWorkLanguage)();
         return {
-            type: 'transient_guide_msg',
-            role: 'assistant',
+            type: 'environment_msg',
+            role: 'user',
             content: workLanguage === 'zh'
                 ? [
-                    `MCP 工具集租约 #${index + 1}: \`${serverId}\``,
+                    `${prefix} MCP 工具集租约 #${index + 1}: \`${serverId}\``,
                     '',
-                    `该 MCP server 被视为非“真正无状态”。此对话已租用一个专用的 MCP client 实例。`,
+                    `你当前看到的是系统维护的 MCP 租约状态。该 MCP server 被视为非“真正无状态”；此对话已租用一个专用的 MCP client 实例。`,
                     '',
-                    `当你确认近期不再需要这个工具集时，请释放以停止/回收底层 MCP 进程/连接：`,
+                    `当你确认近期不再需要这个工具集时，请释放它，以停止/回收底层 MCP 进程或连接：`,
                     `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,
                     '',
                     `如果另一个对话同时使用同一个 MCP 工具集，Dominds 会为那个对话启动一个独立的 MCP client 实例。`,
                 ].join('\n')
                 : [
-                    `MCP toolset lease #${index + 1}: \`${serverId}\``,
+                    `${prefix} MCP toolset lease #${index + 1}: \`${serverId}\``,
                     '',
-                    `This MCP server is treated as non-stateless. A dedicated MCP client instance is leased to this dialog.`,
+                    `You are looking at system-maintained MCP lease state. This MCP server is treated as non-stateless, and a dedicated MCP client instance is leased to this dialog.`,
                     '',
-                    `When you are confident you won't need this toolset in the near future, release it to stop the underlying MCP process/connection:`,
+                    `When you are confident you will not need this toolset soon, release it to stop the underlying MCP process/connection:`,
                     `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,
                     '',
                     `If another dialog uses the same MCP toolset concurrently, Dominds will spawn a separate MCP client instance for that dialog.`,

package/dist/tools/os.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemonOutputTool = exports.stopDaemonTool = exports.readonlyShellTool = exports.shellCmdTool = exports.shellCmdReminderOwner = void 0;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
+const driver_messages_1 = require("../shared/i18n/driver-messages");
 const runtime_language_1 = require("../shared/runtime-language");
 const time_1 = require("../shared/utils/time");
 // Scrolling buffer that maintains a fixed number of lines like a terminal
@@ -467,13 +468,20 @@ exports.shellCmdReminderOwner = {
         };
     },
     async renderReminder(dlg, reminder, index) {
+        const language = (0, runtime_language_1.getWorkLanguage)();
+        const prefix = (0, driver_messages_1.formatSystemNoticePrefix)(language);
         if (reminder.owner !== exports.shellCmdReminderOwner || !isShellCmdReminderMeta(reminder.meta)) {
             // Fallback to default rendering if this reminder doesn't belong to this tool
             return {
-                type: 'transient_guide_msg',
-                role: 'assistant',
-                content: `🔔 **System-managed reminder item #${index + 1}** - Process Management
-This reminder is system-managed and should update/drop automatically based on the underlying process lifecycle.
+                type: 'environment_msg',
+                role: 'user',
+                content: language === 'zh'
+                    ? `${prefix} 后台进程状态提醒 #${index + 1}
+你正在查看系统维护的后台进程状态，不要把它当成你自己写的工作便签。该提醒会随进程生命周期自动更新或删除。
+---
+${reminder.content}`
+                    : `${prefix} Background process status reminder #${index + 1}
+You are looking at system-maintained background process state. Do not treat it as a self-authored work note. This reminder will update or disappear automatically with the process lifecycle.
 ---
 ${reminder.content}`,
             };
@@ -483,10 +491,13 @@ ${reminder.content}`,
         if (!daemon) {
             // Daemon no longer exists, render as completed
             return {
-                type: 'transient_guide_msg',
-                role: 'assistant',
-                content: `⚰️ **Process Lifecycle Alert #${index + 1}** - Daemon Terminated (PID ${pid})
-This daemon process has completed its lifecycle and is no longer running. This reminder should auto-drop (or can be ignored).`,
+                type: 'environment_msg',
+                role: 'user',
+                content: language === 'zh'
+                    ? `${prefix} 进程生命周期提醒 #${index + 1} - 后台进程已结束（PID ${pid}）
+该后台进程的生命周期已经结束，当前不再运行。这条提醒应当很快自动消失；你也可以直接忽略它。`
+                    : `${prefix} Process lifecycle reminder #${index + 1} - daemon terminated (PID ${pid})
+This daemon process has finished its lifecycle and is no longer running. This reminder should disappear automatically soon, and you may also ignore it.`,
             };
         }
         // Render with current daemon status - fully dynamic
@@ -498,12 +509,18 @@ This daemon process has completed its lifecycle and is no longer running. This r
                 : `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`;
         const statusInfo = formatDaemonStatus(daemon);
         return {
-            type: 'transient_guide_msg',
-            role: 'assistant',
-            content: `🔄 **Active Daemon Monitor #${index + 1}** - PID ${pid} (Uptime: ${uptimeStr})
-This daemon process is actively running and requires periodic assessment. I should check its health, resource usage, and operational status. This reminder is system-managed and will update/drop automatically.
+            type: 'environment_msg',
+            role: 'user',
+            content: language === 'zh'
+                ? `🔄 ${prefix} 运行中后台进程监控 #${index + 1} - PID ${pid}（已运行 ${uptimeStr}）
+你当前有一个仍在运行的后台进程。请按需要检查它的健康状态、资源占用和输出情况；这条提醒由系统自动维护，会随进程状态变化自动更新或删除。
+
+**当前状态：**
+${statusInfo}`
+                : `🔄 ${prefix} Active daemon monitor #${index + 1} - PID ${pid} (uptime: ${uptimeStr})
+You currently have a background process that is still running. Check its health, resource usage, and output as needed. This reminder is system-maintained and will update or disappear automatically as the process state changes.
 
-**Current Status:**
+**Current status:**
 ${statusInfo}`,
         };
     },

package/dist/tools/pending-tellask-reminder.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pendingTellaskReminderOwner = void 0;
 exports.syncPendingTellaskReminderState = syncPendingTellaskReminderState;
 const persistence_1 = require("../persistence");
+const driver_messages_1 = require("../shared/i18n/driver-messages");
 const runtime_language_1 = require("../shared/runtime-language");
 const time_1 = require("../shared/utils/time");
 function isRecord(value) {
@@ -166,20 +167,23 @@ exports.pendingTellaskReminderOwner = {
         return { treatment: 'update', updatedContent, updatedMeta };
     },
     async renderReminder(_dlg, reminder, index) {
+        const language = (0, runtime_language_1.getWorkLanguage)();
+        const prefix = (0, driver_messages_1.formatSystemNoticePrefix)(language);
         if (reminder.owner !== exports.pendingTellaskReminderOwner) {
-            const language = (0, runtime_language_1.getWorkLanguage)();
             return {
-                type: 'transient_guide_msg',
-                role: 'assistant',
+                type: 'environment_msg',
+                role: 'user',
                 content: language === 'zh'
-                    ? `系统提醒 #${index + 1}\n\n${reminder.content}`
-                    : `System reminder #${index + 1}\n\n${reminder.content}`,
+                    ? `${prefix} 自动维护诉请状态提醒 #${index + 1}\n你正在查看系统自动维护的诉请状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
+                    : `${prefix} Auto-maintained tellask status reminder #${index + 1}\nYou are looking at system-maintained tellask state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
             };
         }
         return {
-            type: 'transient_guide_msg',
-            role: 'assistant',
-            content: reminder.content,
+            type: 'environment_msg',
+            role: 'user',
+            content: language === 'zh'
+                ? `${prefix} 自动维护诉请状态提醒 #${index + 1}\n你正在查看系统自动维护的诉请状态，不要把它当成你自己写的工作便签。\n\n${reminder.content}`
+                : `${prefix} Auto-maintained tellask status reminder #${index + 1}\nYou are looking at system-maintained tellask state. Do not treat it as a self-authored work note.\n\n${reminder.content}`,
         };
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "DevOps Mindsets — Sustainable Agentic Product Lifecycle",
   "type": "commonjs",
   "private": false,