dominds 1.9.2 → 1.9.3

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

@@ -149,6 +149,7 @@ TL;DR：
 有一类提醒项来自运行时环境（例如后台进程状态、MCP 租用/到期等）。它们更像信号灯：
 
 - 你应该阅读并据此调整行为
+- 默认应“静默吸收”这类状态信号；除非它实际改变当前判断/计划/风险，否则不要在回复里专门确认、复述或总结它
 - 但它们的生命周期通常由系统管理（自动更新/自动清理），不要把它们当成个人工作日志
 - 在消息语义上，这类提醒应视为**系统提示**：通常落在 `role=user` 侧，并带显眼头标（如 `【系统提示】`），避免与个人工作提醒混淆
 

package/dist/docs/txt-editing-tools.md

@@ -114,6 +114,7 @@ Chinese version: [中文版](./txt-editing-tools.zh.md)
 
 - 每个 plan hunk 带 TTL（输出 `expires_at_ms`）。
 - hunk 存储于进程内内存；进程重启后丢失。
+- prepare 结果在 apply 前不会落盘；此时再次读取文件仍只能看到旧内容。若想基于该结果继续下一笔修改，必须先 apply 当前 hunk，再重新 prepare。
 - `apply_file_modification` 会检查：
   - hunk 是否存在且未过期
   - hunk 是否由当前成员规划（`WRONG_OWNER` 拒绝）
@@ -278,6 +279,7 @@ This is the design doc for `ws_mod` text editing as implemented.
 - Function tool calls in one message run in parallel → **prepare → apply must be two messages**.
 - Applies are serialized per file in-process (queue by `createdAtMs`, then `hunkId`).
 - `hunk_id` is TTL-limited and in-memory; apply checks ownership and access.
+- Before apply, the prepared change is not persisted, so re-reading still returns the old file content; if you want the next edit based on that prepared result, apply the current hunk first, then prepare again.
 - `create_new_file` creates a new file (empty content allowed) and refuses to overwrite existing files (YAML-only output).
 - `overwrite_entire_file` is the exception full-file overwrite tool, guarded by `known_old_total_lines/known_old_total_bytes`, and it refuses diff/patch-like content by default unless `content_format='diff'|'patch'`.
 - Some providers (e.g. Codex) may require “all fields present” in function calls; for those providers only, use sentinels like empty strings / 0 to express “unset/default”. For most providers, omit optional fields naturally.

package/dist/docs/txt-editing-tools.zh.md

@@ -114,6 +114,7 @@ updated: 2026-01-24
 
 - 每个 plan hunk 带 TTL（输出 `expires_at_ms`）。
 - hunk 存储于进程内内存；进程重启后丢失。
+- prepare 结果在 apply 前不会落盘；此时再次读取文件仍只能看到旧内容。若想基于该结果继续下一笔修改，必须先 apply 当前 hunk，再重新 prepare。
 - `apply_file_modification` 会检查：
   - hunk 是否存在且未过期
   - hunk 是否由当前成员规划（`WRONG_OWNER` 拒绝）

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

@@ -386,15 +386,13 @@ async function finishRegisteredTellaskReplacement(args) {
     const { ownerDialog, subdialog, pendingRecord, responseBody } = args;
     const language = (0, work_language_1.getWorkLanguage)();
     const requesterId = ownerDialog.agentId;
-    const response = (0, inter_dialog_format_1.formatTellaskResponseContent)({
-        callName: pendingRecord.callName,
+    const response = (0, inter_dialog_format_1.formatTellaskReplacementNoticeContent)({
         responderId: subdialog.agentId,
         requesterId,
         mentionList: pendingRecord.mentionList,
         sessionSlug: pendingRecord.sessionSlug,
         tellaskContent: pendingRecord.tellaskContent,
         responseBody,
-        status: 'failed',
         language,
     });
     const carryoverOriginCourse = pendingRecord.callingCourse;

package/dist/runtime/driver-messages.js

@@ -78,12 +78,12 @@ function formatRegisteredTellaskCallerUpdateNotice(language) {
     if (language === 'zh') {
         return [
             prefix,
-            '刚才那轮诉请先不用继续等待了；对方接下来会按你更新后的要求继续处理，请以后续要求为准。',
+            '刚才那轮诉请不用再等了；对方接下来会按你刚更新的要求继续处理，后续请以最新要求为准。',
         ].join('\n');
     }
     return [
         prefix,
-        'You no longer need to wait on that earlier request. The teammate will continue from your updated request, so follow the later request from here.',
+        'You no longer need to wait on that earlier request. The teammate will continue under your updated request, so treat the latest request as the one now in effect.',
     ].join('\n');
 }
 function formatRegisteredTellaskCalleeUpdateNotice(language) {
@@ -188,7 +188,7 @@ function formatReminderItemGuide(language, index, content, options) {
             return [
                 `提醒项 #${index}（工具状态）`,
                 '',
-                '我把这条当作工具维护的状态参考，不把它自动当成我现在必须立刻执行的指令。',
+                '我把这条当作工具维护的状态参考。默认不在对外回复里专门确认、复述或总结它；只有它实际改变当前判断、计划或风险时，我才提炼真正相关的部分。',
                 '',
                 `这条提醒项由工具 ${managementTool} 管理；如果我要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
                 '',
@@ -232,7 +232,7 @@ function formatReminderItemGuide(language, index, content, options) {
         const updateExampleSafe = updateExample ?? `${managementTool}({ ... })`;
         return `REMINDER ITEM #${index} (TOOL STATE)
 
-I treat this as a tool-maintained state reference, not as an automatic must-do command.
+I treat this as a tool-maintained state reference. By default I should not explicitly acknowledge, restate, or summarize it in my outward reply; I should only extract the parts that materially change my current judgment, plan, or risk.
 
 This reminder is managed by tool ${managementTool}; if I need to change it, I should use ${managementTool} instead of update_reminder.
 

package/dist/runtime/inter-dialog-format.d.ts

@@ -48,6 +48,15 @@ export type TellaskResponseFormatInput = {
     status?: 'completed' | 'failed';
     language?: LanguageCode;
 };
+export type TellaskReplacementNoticeFormatInput = {
+    responderId: string;
+    requesterId: string;
+    mentionList?: string[];
+    sessionSlug?: string;
+    tellaskContent: string;
+    responseBody: string;
+    language?: LanguageCode;
+};
 export type TellaskCarryoverResultFormatInput = {
     originCourse: number;
     callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
@@ -70,4 +79,5 @@ export declare function formatAssignmentFromSupdialog(input: SubdialogAssignment
 export declare function formatUpdatedAssignmentFromSupdialog(input: SubdialogAssignmentFormatInput): string;
 export declare function formatSupdialogCallPrompt(input: SupdialogCallPromptInput): string;
 export declare function formatTellaskResponseContent(input: TellaskResponseFormatInput): string;
+export declare function formatTellaskReplacementNoticeContent(input: TellaskReplacementNoticeFormatInput): string;
 export declare function formatTellaskCarryoverResultContent(input: TellaskCarryoverResultFormatInput): string;

package/dist/runtime/inter-dialog-format.js

@@ -18,6 +18,7 @@ exports.formatAssignmentFromSupdialog = formatAssignmentFromSupdialog;
 exports.formatUpdatedAssignmentFromSupdialog = formatUpdatedAssignmentFromSupdialog;
 exports.formatSupdialogCallPrompt = formatSupdialogCallPrompt;
 exports.formatTellaskResponseContent = formatTellaskResponseContent;
+exports.formatTellaskReplacementNoticeContent = formatTellaskReplacementNoticeContent;
 exports.formatTellaskCarryoverResultContent = formatTellaskCarryoverResultContent;
 const driver_messages_1 = require("./driver-messages");
 const markdown_format_1 = require("./markdown-format");
@@ -219,6 +220,26 @@ function formatTellaskResponseContent(input) {
             : `regarding the original tellask: ${mentionLine} • ${sessionSlug}`;
     return `${markerPrefix}${hello}\n\n${(0, markdown_format_1.markdownQuote)(input.responseBody)}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
 }
+function formatTellaskReplacementNoticeContent(input) {
+    const language = input.language ?? 'en';
+    const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
+    const responseBody = requireNonEmpty(input.responseBody, 'responseBody');
+    const mentionIds = (input.mentionList ?? [])
+        .map((item) => stripMentionPrefix(item))
+        .filter((item) => item !== '');
+    const mentionLine = mentionIds.length === 0
+        ? `@${requireNonEmpty(input.requesterId, 'requesterId')}`
+        : mentionIds.map((mentionId) => `@${mentionId}`).join(' ');
+    const sessionSlug = input.sessionSlug?.trim() ?? '';
+    const tail = language === 'zh'
+        ? sessionSlug === ''
+            ? `对应原始诉请： ${mentionLine}`
+            : `对应原始诉请： ${mentionLine} • ${sessionSlug}`
+        : sessionSlug === ''
+            ? `applies to the original tellask: ${mentionLine}`
+            : `applies to the original tellask: ${mentionLine} • ${sessionSlug}`;
+    return `${responseBody}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
+}
 function formatTellaskCarryoverResultContent(input) {
     const language = input.language ?? 'en';
     const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');

package/dist/tools/os.js

@@ -132,6 +132,55 @@ class HeadTailByteBuffer {
 }
 // Global registry for daemon processes
 const daemonProcesses = new Map();
+let trackedDaemonShutdownSigtermSent = false;
+let trackedDaemonShutdownSigkillSent = false;
+function resolveBestEffortDaemonSignalTarget(daemon) {
+    if (process.platform !== 'win32' && daemon.processGroupId !== undefined) {
+        return -daemon.processGroupId;
+    }
+    return daemon.pid;
+}
+function signalTrackedDaemonsForProcessShutdown(signal) {
+    const alreadySent = signal === 'SIGTERM' ? trackedDaemonShutdownSigtermSent : trackedDaemonShutdownSigkillSent;
+    if (alreadySent)
+        return;
+    if (signal === 'SIGTERM') {
+        trackedDaemonShutdownSigtermSent = true;
+    }
+    else {
+        trackedDaemonShutdownSigkillSent = true;
+    }
+    for (const daemon of daemonProcesses.values()) {
+        const signalTarget = resolveBestEffortDaemonSignalTarget(daemon);
+        try {
+            process.kill(signalTarget, signal);
+        }
+        catch (error) {
+            console.error('[os] failed to signal tracked daemon during process shutdown', {
+                pid: daemon.pid,
+                processGroupId: daemon.processGroupId ?? null,
+                signal,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (signal === 'SIGKILL') {
+        daemonProcesses.clear();
+    }
+}
+process.once('beforeExit', () => {
+    signalTrackedDaemonsForProcessShutdown('SIGTERM');
+});
+process.once('exit', () => {
+    signalTrackedDaemonsForProcessShutdown('SIGTERM');
+    signalTrackedDaemonsForProcessShutdown('SIGKILL');
+});
+process.once('SIGINT', () => {
+    signalTrackedDaemonsForProcessShutdown('SIGTERM');
+});
+process.once('SIGTERM', () => {
+    signalTrackedDaemonsForProcessShutdown('SIGTERM');
+});
 function getOsToolMessages(language) {
     if (language === 'zh') {
         return {
@@ -249,7 +298,17 @@ function parseStopDaemonArgs(args) {
     if (typeof pid !== 'number') {
         throw new Error('stop_daemon.pid must be a number');
     }
-    return { pid };
+    const entirePg = args.entire_pg;
+    if (entirePg !== undefined && typeof entirePg !== 'boolean') {
+        throw new Error('stop_daemon.entire_pg must be a boolean if provided');
+    }
+    if (process.platform === 'win32' && entirePg === true) {
+        throw new Error('stop_daemon.entire_pg=true is unsupported on Windows');
+    }
+    return {
+        pid,
+        entirePg: entirePg ?? process.platform !== 'win32',
+    };
 }
 function parseGetDaemonOutputArgs(args) {
     const pid = args.pid;
@@ -356,6 +415,10 @@ const stopDaemonSchema = {
             type: 'number',
             description: 'Process ID of the daemon to stop',
         },
+        entire_pg: {
+            type: 'boolean',
+            description: 'Whether to signal the entire process group instead of only the tracked PID (default: true on Unix-like systems; false on Windows)',
+        },
     },
     required: ['pid'],
     additionalProperties: false,
@@ -377,44 +440,70 @@ const getDaemonOutputSchema = {
     additionalProperties: false,
 };
 // Format daemon status for reminder display
-function formatDaemonStatus(daemon) {
+function formatDaemonStatus(daemon, language) {
     const uptime = Math.floor((Date.now() - daemon.startTime.getTime()) / 1000);
-    const status = daemon.isRunning
-        ? 'running'
-        : `exited (code: ${daemon.exitCode}, signal: ${daemon.exitSignal})`;
+    const status = language === 'zh'
+        ? daemon.isRunning
+            ? '运行中'
+            : `已退出（code: ${daemon.exitCode}, signal: ${daemon.exitSignal}）`
+        : daemon.isRunning
+            ? 'running'
+            : `exited (code: ${daemon.exitCode}, signal: ${daemon.exitSignal})`;
     const stdoutInfo = daemon.stdoutBuffer.getScrollInfo();
     const stderrInfo = daemon.stderrBuffer.getScrollInfo();
     let scrollNotice = '';
     if (stdoutInfo.hasScrolledContent || stderrInfo.hasScrolledContent) {
         const scrolledLines = stdoutInfo.linesScrolledOut + stderrInfo.linesScrolledOut;
-        scrollNotice = `\n⚠️  ${scrolledLines} lines have scrolled out of view`;
+        scrollNotice =
+            language === 'zh'
+                ? `\n注意：已有 ${scrolledLines} 行滚出当前保留缓冲区`
+                : `\nNote: ${scrolledLines} lines have scrolled out of the retained buffer`;
     }
     const stdoutContent = daemon.stdoutBuffer.isEmpty()
-        ? '(no output)'
+        ? language === 'zh'
+            ? '（无输出）'
+            : '(no output)'
         : daemon.stdoutBuffer.getContent();
     const stderrContent = daemon.stderrBuffer.isEmpty()
-        ? '(no errors)'
+        ? language === 'zh'
+            ? '（无 stderr 输出）'
+            : '(no stderr output)'
         : daemon.stderrBuffer.getContent();
     const fenceConsole = '```console';
     const fenceEnd = '```';
-    return `🔄 Daemon Process ${daemon.pid}
-Command: ${daemon.command}
+    return language === 'zh'
+        ? `后台进程 PID: ${daemon.pid}
+命令: ${daemon.command}
 Shell: ${daemon.shell}
-Status: ${status}
-Uptime: ${uptime}s
-Started: ${(0, time_1.formatUnifiedTimestamp)(daemon.startTime)}${scrollNotice}
+生命周期状态: ${status}
+已运行: ${uptime}s
+启动时间: ${(0, time_1.formatUnifiedTimestamp)(daemon.startTime)}${scrollNotice}
 
-📤 Latest stdout:
+stdout 缓冲区快照：
 ${fenceConsole}
 ${stdoutContent}
 ${fenceEnd}
 
-📤 Latest stderr:
+stderr 缓冲区快照：
 ${fenceConsole}
 ${stderrContent}
+${fenceEnd}`
+        : `Daemon PID: ${daemon.pid}
+Command: ${daemon.command}
+Shell: ${daemon.shell}
+Lifecycle status: ${status}
+Uptime: ${uptime}s
+Started at: ${(0, time_1.formatUnifiedTimestamp)(daemon.startTime)}${scrollNotice}
+
+Stdout buffer snapshot:
+${fenceConsole}
+${stdoutContent}
 ${fenceEnd}
 
-💡 Use stop_daemon({"pid": ${daemon.pid}}) to terminate this process`;
+Stderr buffer snapshot:
+${fenceConsole}
+${stderrContent}
+${fenceEnd}`;
 }
 // ReminderOwner implementation for shell command tool
 exports.shellCmdReminderOwner = {
@@ -432,7 +521,7 @@ exports.shellCmdReminderOwner = {
         // Check if process has exited
         if (!daemon.isRunning) {
             // Process has exited, provide final status and drop reminder
-            const finalStatus = formatDaemonStatus(daemon);
+            const finalStatus = formatDaemonStatus(daemon, (0, work_language_1.getWorkLanguage)());
             daemonProcesses.delete(pid);
             return {
                 treatment: 'update',
@@ -457,7 +546,7 @@ exports.shellCmdReminderOwner = {
             daemon.exitSignal = 'UNKNOWN';
         }
         // Update the reminder with current daemon status
-        const updatedContent = formatDaemonStatus(daemon);
+        const updatedContent = formatDaemonStatus(daemon, (0, work_language_1.getWorkLanguage)());
         return {
             treatment: 'update',
             updatedContent,
@@ -477,11 +566,11 @@ exports.shellCmdReminderOwner = {
                 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.
+This is a system-maintained background process snapshot. Consume it silently by default: do not treat it as a self-authored work note, and do not explicitly acknowledge or restate it in your outward reply unless it materially affects your current judgment or next action. This reminder will update or disappear automatically with the process lifecycle.
 ---
 ${reminder.content}`,
             };
@@ -507,20 +596,20 @@ This daemon process has finished its lifecycle and is no longer running. This re
             : uptime < 3600
                 ? `${Math.floor(uptime / 60)}m ${uptime % 60}s`
                 : `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`;
-        const statusInfo = formatDaemonStatus(daemon);
+        const statusInfo = formatDaemonStatus(daemon, language);
         return {
             type: 'environment_msg',
             role: 'user',
             content: language === 'zh'
-                ? `🔄 ${prefix} 运行中后台进程监控 #${index + 1} - PID ${pid}（已运行 ${uptimeStr}）
-你当前有一个仍在运行的后台进程。请按需要检查它的健康状态、资源占用和输出情况；这条提醒由系统自动维护，会随进程状态变化自动更新或删除。
+                ? `🔄 ${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.
+                : `🔄 ${prefix} Active daemon state #${index + 1} - PID ${pid} (uptime: ${uptimeStr})
+This is a system-maintained snapshot, not a new user request and not something that normally deserves a standalone mention. Use the information below only when it materially changes your current judgment, plan, risk, or a daemon-management action; otherwise consume it silently.
 
-**Current status:**
+**State snapshot:**
 ${statusInfo}`,
         };
     },
@@ -546,6 +635,7 @@ exports.shellCmdTool = {
         return new Promise((resolve) => {
             const childProcess = (0, child_process_1.spawn)(spawnSpec.command, spawnSpec.args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
             });
             const pid = childProcess.pid;
             const startTime = new Date();
@@ -564,6 +654,7 @@ exports.shellCmdTool = {
                     command,
                     shell: spawnSpec.shellLabel,
                     process: childProcess,
+                    processGroupId: process.platform === 'win32' ? undefined : pid,
                     startTime,
                     stdoutBuffer,
                     stderrBuffer,
@@ -1308,19 +1399,26 @@ exports.stopDaemonTool = {
     async call(dlg, caller, args) {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getOsToolMessages(language);
-        const { pid } = parseStopDaemonArgs(args);
+        const { pid, entirePg } = parseStopDaemonArgs(args);
         const daemon = daemonProcesses.get(pid);
         if (!daemon) {
             return t.noDaemonFound(pid);
         }
         try {
-            // Kill the process
-            process.kill(pid, 'SIGTERM');
+            let signalTarget = pid;
+            if (entirePg) {
+                if (daemon.processGroupId === undefined) {
+                    throw new Error('daemon has no isolated process group; rerun it after this update, or retry with entire_pg=false');
+                }
+                signalTarget = -daemon.processGroupId;
+            }
+            // Kill the tracked process or its entire process group.
+            process.kill(signalTarget, 'SIGTERM');
             // Wait a bit for graceful shutdown
             await new Promise((resolve) => setTimeout(resolve, 1000));
             // Force kill if still running
             try {
-                process.kill(pid, 'SIGKILL');
+                process.kill(signalTarget, 'SIGKILL');
             }
             catch (e) {
                 // Process already terminated

package/dist/tools/prompts/os/en/tools.md

@@ -48,6 +48,7 @@ Stop daemon process.
 **Parameters:**
 
 - `pid` (required): Daemon process ID (number)
+- `entire_pg` (optional): Whether to signal the entire process group (default: `true` on Unix-like systems, `false` on Windows; Windows does not support explicitly passing `true`)
 
 **Returns:**
 
@@ -151,6 +152,12 @@ shell_cmd({
 stop_daemon({
   pid: 12345,
 });
+
+// On Unix-like systems, you can explicitly terminate the whole process group
+stop_daemon({
+  pid: 12345,
+  entire_pg: true,
+});
 ```
 
 ### Get Daemon Process Output

package/dist/tools/prompts/os/zh/tools.md

@@ -48,6 +48,7 @@ executed_at: <执行时间戳>
 **参数：**
 
 - `pid`（必需）：守护进程 PID（数字）
+- `entire_pg`（可选）：是否对整个进程组发终止信号（默认：Linux/macOS 为 `true`，Windows 为 `false`；Windows 不支持显式传 `true`）
 
 **返回：**
 
@@ -151,6 +152,12 @@ shell_cmd({
 stop_daemon({
   pid: 12345,
 });
+
+// Unix-like 平台可显式要求终止整个进程组
+stop_daemon({
+  pid: 12345,
+  entire_pg: true,
+});
 ```
 
 ### 获取守护进程输出

package/dist/tools/prompts/team_mgmt/en/index.md

@@ -27,6 +27,7 @@
 team_mgmt is Dominds' toolset for managing `.minds/` (team configuration and rtws memory), using **prepare-first + single apply** architecture:
 
 - **Incremental edits (preferred)**: Use `team_mgmt_prepare_*` to generate reviewable YAML + diff + `hunk_id`, then write via `team_mgmt_apply_file_modification`
+- **Hard ordering rule for the LLM**: `team_mgmt_prepare_*` only creates an in-memory preview and does not write the file; before `apply`, re-reading still returns the old content. If you want further edits based on the prepared result, you must call `team_mgmt_apply_file_modification` first, then read/prepare the next change
 - **Only operates in `.minds/`**: This toolset only operates within the `.minds/` subtree and should not touch other rtws files
 - **Shell guardrail**: toolset `os` includes `shell_cmd` / `stop_daemon` / `get_daemon_output`; any member with these shell tools must be listed in top-level `shell_specialists`
 - **Member assets recommended**: strongly recommend `persona/knowledge/lessons` files for every `members.<id>` to define ownership, boundaries, and reusable lessons

package/dist/tools/prompts/team_mgmt/en/principles.md

@@ -27,6 +27,7 @@
 
 - **Incremental edits (preferred)**: Use `team_mgmt_prepare_*` to generate reviewable YAML + diff + `hunk_id`, then write via `team_mgmt_apply_file_modification({ "hunk_id": "<hunk_id>" })`
 - **Parallelism constraint**: Multiple function tool calls in one generation step may run in parallel; **prepare → apply must be two steps**
+- **LLM persistence semantics**: `team_mgmt_prepare_*` only stores a pending in-memory preview and does not modify the file before apply; a `team_mgmt_read_file` before apply still returns the old content. If you only want to revise that pending preview, overwrite the same hunk with `existing_hunk_id`; if you want the next edit based on this change, apply the current hunk first, then read/prepare again
 - **Minimum shell privilege**: toolset `os` includes `shell_cmd` / `stop_daemon` / `get_daemon_output`; grant it only to a small specialist set and list those member ids in top-level `shell_specialists`
 - **Exception (create)**: `team_mgmt_create_new_file` only creates a new file (empty content allowed). It does not do incremental edits and does not use prepare/apply; it refuses to overwrite existing files
 - **Exception (overwrite)**: `team_mgmt_overwrite_entire_file` writes immediately (no prepare/apply). It requires `known_old_total_lines/known_old_total_bytes` guardrails; use `team_mgmt_read_file` to read `total_lines/size_bytes` from the YAML header

package/dist/tools/prompts/team_mgmt/en/scenarios.md

@@ -52,6 +52,8 @@ Call the function tool `team_mgmt_apply_file_modification` with:
 { "hunk_id": "<hunk_id>" }
 ```
 
+Important: before this apply, the prepared diff is not persisted yet; re-reading the file still returns the old content. If you want the next edit based on this change, apply the current hunk first, then prepare the next one.
+
 ### 4. Create New Mind File
 
 ```text

package/dist/tools/prompts/team_mgmt/zh/index.md

@@ -27,6 +27,7 @@
 team_mgmt 是 Dominds 用于管理 `.minds/`（团队配置与 rtws 记忆）的工具集，采用 **prepare-first + single apply** 架构：
 
 - **增量编辑（推荐）**：用 `team_mgmt_prepare_*` 先生成可复核的 YAML + diff + `hunk_id`，再用 `team_mgmt_apply_file_modification` 显式写入
+- **LLM 顺序硬约束**：`team_mgmt_prepare_*` 只生成内存中的预览，不会写盘；在 `apply` 之前再次读取文件仍只能读到旧内容。若要基于本次改动继续修改，必须先 `team_mgmt_apply_file_modification`，再重新 read/prepare 新改动
 - **只操作 `.minds/`**：该 toolset 只允许操作 `.minds/` 子树，不会也不应触碰 rtws 其他文件
 - **shell 权限约束**：`os` toolset 包含 `shell_cmd` / `stop_daemon` / `get_daemon_output`；任何拿到这些工具的成员都必须出现在顶层 `shell_specialists`
 - **成员资产推荐**：强烈建议为每个 `members.<id>` 配置 `persona/knowledge/lessons` 资产文件，显式定义角色职责、边界和经验复用

package/dist/tools/prompts/team_mgmt/zh/principles.md

@@ -27,6 +27,7 @@
 
 - **增量编辑（推荐）**：用 `team_mgmt_prepare_*` 先生成可复核的 YAML + diff + `hunk_id`，再用 `team_mgmt_apply_file_modification({ "hunk_id": "<hunk_id>" })` 显式写入
 - **并行约束**：同一轮生成中的多个工具调用可能并行执行；**prepare → apply 必须分两轮**
+- **LLM 落盘语义**：`team_mgmt_prepare_*` 只保存待应用的内存预览，apply 前不会改动文件；此时再次 `team_mgmt_read_file` 看到的仍是旧内容。若只是修订同一个未落盘预览，可用同一 prepare 工具加 `existing_hunk_id` 覆写；若想继续下一笔修改，必须先 apply 当前 hunk，再重新 read/prepare
 - **shell 最小授权**：`os` toolset 包含 `shell_cmd` / `stop_daemon` / `get_daemon_output`；只授予少数专员成员，并在顶层 `shell_specialists` 显式列出这些成员 id
 - **例外（创建）**：`team_mgmt_create_new_file` 只负责创建新文件（允许空内容），不做增量编辑、不走 prepare/apply；若文件已存在会拒绝（避免误用覆盖写入语义）
 - **例外（整文件覆盖）**：`team_mgmt_overwrite_entire_file` 会直接写盘（不走 prepare/apply），必须提供 `known_old_total_lines/known_old_total_bytes` 作为对账护栏；建议先用 `team_mgmt_read_file` 从 YAML header 读取 `total_lines/size_bytes` 再填写

package/dist/tools/prompts/team_mgmt/zh/scenarios.md

@@ -52,6 +52,8 @@ Call the function tool `team_mgmt_apply_file_modification` with:
 { "hunk_id": "<hunk_id>" }
 ```
 
+注意：这一步之前，prepare 结果还没有落盘；如果此时再次读取文件，读到的仍是旧内容。若要基于这次改动继续修改，先 apply 当前 hunk，再准备下一笔改动。
+
 ### 4. 创建新的 mind 文件
 
 ```text

package/dist/tools/prompts/ws_mod/en/index.md

@@ -28,6 +28,7 @@ ws_mod is Dominds' text editing toolset, using **prepare-first + single apply**
 
 - **prepare-first**: All incremental edits are planned first (output reviewable diff + evidence + hunk_id)
 - **single apply**: All planned edits are persisted only through `apply_file_modification`
+- **Hard ordering rule for the LLM**: Before apply, a prepared hunk exists only in memory; re-reading still returns the old file content. If you want further edits based on that prepared result, apply the current hunk first, then prepare again
 - **Legacy tools removed**: `append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace` are completely removed
 
 ## Quick Navigation

package/dist/tools/prompts/ws_mod/en/principles.md

@@ -35,6 +35,7 @@ Therefore unified to:
 
 - **prepare-first**: All incremental edits are planned first (output reviewable diff + evidence + hunk_id)
 - **single apply**: All planned edits are persisted only through `apply_file_modification({ "hunk_id": "<hunk_id>" })`
+- **LLM persistence semantics**: before apply, a prepared hunk exists only in memory and does not modify the file; a `read_file` at that point still returns the old content. If you only want to revise the same pending preview, overwrite it with the same prepare tool plus `existing_hunk_id`; if you want the next edit based on this change, apply the current hunk first, then read/prepare again
 - **Legacy tools removed**: `append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace` are completely removed (no aliases, no compat layer)
 
 ## 2. Goals & Non-Goals

package/dist/tools/prompts/ws_mod/zh/index.md

@@ -28,6 +28,7 @@ ws_mod 是 Dominds 的文本编辑工具集，采用 **prepare-first + single ap
 
 - **prepare-first**：所有增量编辑先规划（输出可审阅 diff + evidence + hunk_id）
 - **single apply**：所有计划类编辑仅通过 `apply_file_modification` 落盘
+- **LLM 顺序硬约束**：prepare 结果在 apply 前只存在于内存里；此时再次读取文件仍只能读到旧内容。若要基于该结果继续修改，必须先 apply 当前 hunk，再重新 prepare
 - **移除旧工具**：`append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace` 已彻底删除
 
 ## 快速导航

package/dist/tools/prompts/ws_mod/zh/principles.md

@@ -35,6 +35,7 @@
 
 - **prepare-first**：所有增量编辑先规划（输出可审阅 diff + evidence + hunk_id）
 - **single apply**：所有计划类编辑仅通过 `apply_file_modification({ "hunk_id": "<hunk_id>" })` 落盘
+- **LLM 落盘语义**：prepare 结果在 apply 前只保存在内存中，不会改动文件；此时再次 `read_file` 看到的仍是旧内容。若只是修订同一个未落盘预览，可用同一 prepare 工具加 `existing_hunk_id` 覆写；若想继续下一笔修改，必须先 apply 当前 hunk，再重新 read/prepare
 - **移除旧工具**：`append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace` 已彻底删除（无 alias、无兼容层）
 
 ## 2. 目标与非目标

package/dist/tools/prompts/ws_mod.en.md

@@ -5,6 +5,7 @@ You have read/write access to the rtws (runtime workspace), but **all incrementa
 ## Principles
 
 - Incremental edits: use `prepare_*` to generate an applyable hunk, then write via `apply_file_modification`.
+- Hard ordering rule for the LLM: `prepare_*` only creates an in-memory preview and does not write the file; before `apply_file_modification`, re-reading still returns the old content. If you want further edits based on the prepared result, you must apply the current hunk first, then read/prepare the next change.
 - Legacy tools are removed (no compatibility layer): `append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace`.
 - Constraint: paths under `*.tsk/` are encapsulated Taskdocs; file tools cannot access them.
 - Parallelism constraint: multiple function tool calls in one generation step may run in parallel; **prepare → apply must be two steps**.
@@ -35,6 +36,7 @@ You have read/write access to the rtws (runtime workspace), but **all incrementa
 - `prepare_*` generates `hunk_id` (TTL = 1 hour); apply can only use an unexpired hunk.
 - Expired/unused hunks have no side effects; they are cleaned up automatically.
 - Some prepare tools accept `existing_hunk_id` to overwrite the same prepared hunk; **custom new ids are not supported**.
+- If you only want to revise the same not-yet-persisted preview, overwrite that hunk with the same prepare tool plus `existing_hunk_id`; if you want the next edit based on this change, apply the current hunk first, then prepare again.
 
 ## Apply semantics (context_match)
 
@@ -58,6 +60,8 @@ Call the function tool `apply_file_modification` with:
 { "hunk_id": "<hunk_id>" }
 ```
 
+Before this step, the prepared diff is not persisted yet; a `read_file` at that point still returns the old content.
+
 ## Examples
 
 - Append to EOF:

package/dist/tools/prompts/ws_mod.zh.md

@@ -5,6 +5,7 @@
 ## 总原则
 
 - 增量编辑：通过 `prepare_*` 生成可 apply 的 hunk；然后用 `apply_file_modification` 写入。
+- LLM 顺序硬约束：`prepare_*` 只生成内存中的预览，不会写盘；在 `apply_file_modification` 之前再次读取文件仍只能读到旧内容。若要基于本次改动继续修改，必须先 apply 当前 hunk，再重新 read/prepare 新改动。
 - 旧工具已移除（无兼容层）：`append_file` / `insert_after` / `insert_before` / `replace_block` / `apply_block_replace`。
 - 约束：`*.tsk/` 下的路径属于封装差遣牒，文件工具不可访问。
 - 并行约束：同一轮对话中的多个工具调用可能并行执行；**prepare → apply 必须分两轮**（除非未来有顺序编排器）。
@@ -36,6 +37,7 @@
 - `prepare_*` 会生成 `hunk_id`（TTL=1 小时）；apply 只能用仍然存在的 hunk。
 - 过期/未使用的 hunk **不会产生任何副作用**，会在运行时自动清理；只需关注"最后一次准备的那个 `hunk_id`"。
 - 部分 prepare 工具支持 `existing_hunk_id` 作为"覆写同一 prepare"的方式；**不支持自定义新 id**。
+- 若只是修订同一个未落盘预览，可用同一 prepare 工具配合 `existing_hunk_id` 覆写；若想基于这次改动继续做下一笔修改，必须先 apply 当前 hunk，再重新 prepare。
 
 ## apply 语义（context_match）
 
@@ -59,6 +61,8 @@
 { "hunk_id": "<hunk_id>" }
 ```
 
+在这一步之前，prepare 结果还没有落盘；如果此时再次 `read_file`，读到的仍是旧内容。
+
 ## 示例
 
 - 末尾追加：