dominds 1.9.2 → 1.9.4

package/dist/tools/ctrl.js

@@ -90,6 +90,35 @@ function isJsonValue(value) {
 function isJsonObject(value) {
     return isRecord(value) && Object.values(value).every((item) => isJsonValue(item));
 }
+function getManagerTool(meta) {
+    if (!isRecord(meta)) {
+        return undefined;
+    }
+    const manager = meta['manager'];
+    if (!isRecord(manager)) {
+        return undefined;
+    }
+    const tool = manager['tool'];
+    return typeof tool === 'string' && tool.trim().length > 0 ? tool.trim() : undefined;
+}
+function getDeleteAltInstruction(meta) {
+    if (!isRecord(meta)) {
+        return undefined;
+    }
+    const deleteValue = meta['delete'];
+    if (!isRecord(deleteValue)) {
+        return undefined;
+    }
+    const altInstruction = deleteValue['altInstruction'];
+    return typeof altInstruction === 'string' && altInstruction.trim().length > 0
+        ? altInstruction.trim()
+        : undefined;
+}
+function formatManualDeleteBlockedError(language, altInstruction) {
+    return language === 'zh'
+        ? `错误：该提醒项不能用 delete_reminder 删除；请改为执行：${altInstruction}`
+        : `Error: This reminder cannot be deleted via delete_reminder. Use instead: ${altInstruction}`;
+}
 function listNumberedReminderIndices(reminders) {
     const indices = [];
     for (let index = 0; index < reminders.length; index += 1) {
@@ -289,6 +318,10 @@ exports.deleteReminderTool = {
         if (targetIndex < 0) {
             return t.reminderDoesNotExist(String(reminderNoValue), numberedReminders.length);
         }
+        const deleteAltInstruction = getDeleteAltInstruction(targetReminder.meta);
+        if (deleteAltInstruction !== undefined) {
+            return formatManualDeleteBlockedError(language, deleteAltInstruction);
+        }
         dlg.deleteReminder(targetIndex);
         return (0, tool_result_messages_1.formatToolActionResult)(language, 'deleted');
     },
@@ -390,14 +423,11 @@ exports.updateReminderTool = {
         // `reminder.meta` is persisted JSON. Runtime shape checks are unavoidable here because tools
         // may attach arbitrary metadata for reminder ownership/management.
         const meta = reminder?.meta;
-        if (isRecord(meta)) {
-            const managedByToolValue = meta['managedByTool'];
-            const managedByTool = typeof managedByToolValue === 'string' ? managedByToolValue.trim() : undefined;
-            if (managedByTool && managedByTool.length > 0) {
-                return language === 'zh'
-                    ? `错误：该提醒项由工具 ${managedByTool} 管理，不能用 update_reminder 修改；请使用 ${managedByTool} 更新。`
-                    : `Error: This reminder is managed by tool ${managedByTool}. Do not edit it via update_reminder; use ${managedByTool} instead.`;
-            }
+        const managerTool = getManagerTool(meta);
+        if (managerTool !== undefined) {
+            return language === 'zh'
+                ? `错误：该提醒项由工具 ${managerTool} 管理，不能用 update_reminder 修改；请使用 ${managerTool} 更新。`
+                : `Error: This reminder is managed by tool ${managerTool}. Do not edit it via update_reminder; use ${managerTool} instead.`;
         }
         const contentValue = args['content'];
         const reminderContent = typeof contentValue === 'string' ? contentValue.trim() : '';

package/dist/tools/manual/spec.js

@@ -82,15 +82,14 @@ function shouldIncludeSchemaToolsSection(spec) {
  * No heuristics — `toolsetId` is an explicit parameter.
  */
 function builtinManualTopicPaths(toolsetId, language) {
-    const suffix = language === 'en' ? '.en' : '';
     const langDir = language;
     const baseDir = `prompts/${toolsetId}`;
     return {
-        index: path.join(baseDir, langDir, `index${suffix}.md`),
-        principles: path.join(baseDir, langDir, `principles${suffix}.md`),
-        tools: path.join(baseDir, langDir, `tools${suffix}.md`),
-        scenarios: path.join(baseDir, langDir, `scenarios${suffix}.md`),
-        errors: path.join(baseDir, langDir, `errors${suffix}.md`),
+        index: path.join(baseDir, langDir, 'index.md'),
+        principles: path.join(baseDir, langDir, 'principles.md'),
+        tools: path.join(baseDir, langDir, 'tools.md'),
+        scenarios: path.join(baseDir, langDir, 'scenarios.md'),
+        errors: path.join(baseDir, langDir, 'errors.md'),
     };
 }
 /**

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. Treat it as an environment signal, not a self-authored work note. If it does not materially change your judgment/plan/risk, make no user-visible reply at all (do not send filler like “silently noted” or “received”); only reflect it inside the next substantive reply when it actually affects the 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. If the information below does not materially change your judgment, plan, risk, or require a daemon-management action, make no user-visible reply at all; if it does matter, reflect it only inside the next substantive reply instead of sending filler like “silently noted” or “received”.
 
-**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,
@@ -574,11 +665,14 @@ exports.shellCmdTool = {
                 // Add reminder for daemon process
                 const reminderContent = `[Daemon PID ${pid} - This content should not be visible, check dynamic rendering]`;
                 dlg.addReminder(reminderContent, exports.shellCmdReminderOwner, {
-                    type: 'daemon',
+                    kind: 'daemon',
                     pid,
                     command,
                     shell: spawnSpec.shellLabel,
                     startTime: (0, time_1.formatUnifiedTimestamp)(startTime),
+                    delete: {
+                        altInstruction: `stop_daemon({ "pid": ${pid} })`,
+                    },
                 });
                 resolve(t.daemonStarted(pid, timeoutSeconds, command));
             }, timeoutSeconds * 1000);
@@ -1308,19 +1402,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/pending-tellask-reminder.js

@@ -22,19 +22,42 @@ function isPendingTellaskReminderMeta(value) {
         return false;
     return true;
 }
-function callTypeLabel(language, callType) {
+function callKindLabel(language, view) {
+    if (view.callType === 'A') {
+        return language === 'zh' ? '回问诉请' : 'TellaskBack';
+    }
     if (language === 'zh') {
-        if (callType === 'A')
-            return '回问诉请';
-        if (callType === 'B')
-            return '长线诉请';
-        return '一次性诉请';
+        switch (view.callName) {
+            case 'tellask':
+                return '长线诉请';
+            case 'tellaskSessionless':
+                return '一次性诉请';
+            case 'freshBootsReasoning':
+                return '扪心自问（FBR）';
+        }
+    }
+    switch (view.callName) {
+        case 'tellask':
+            return 'Tellask Session';
+        case 'tellaskSessionless':
+            return 'Fresh Tellask';
+        case 'freshBootsReasoning':
+            return 'Fresh Boots Reasoning (FBR)';
+    }
+}
+function pendingTargetLabel(language, view) {
+    if (view.callType === 'A') {
+        return language === 'zh'
+            ? `上游诉请者 @${view.targetAgentId}`
+            : `upstream requester @${view.targetAgentId}`;
+    }
+    switch (view.callName) {
+        case 'freshBootsReasoning':
+            return language === 'zh' ? '本对话自身' : 'this dialog itself';
+        case 'tellask':
+        case 'tellaskSessionless':
+            return `@${view.targetAgentId}`;
     }
-    if (callType === 'A')
-        return 'TellaskBack';
-    if (callType === 'B')
-        return 'Tellask Session';
-    return 'Fresh Tellask';
 }
 function summarizeTellask(view) {
     const mentionPrefix = Array.isArray(view.mentionList) ? view.mentionList.join(' ') : '';
@@ -75,8 +98,8 @@ function buildReminderContent(language, pending) {
         : 'Only the Tellasks listed below are still in flight; besides them, no other Tellasks are currently executing. This reminder is auto-added/refreshed and not auto-deleted.';
     const lines = pending.map((p, idx) => {
         const base = language === 'zh'
-            ? `${idx + 1}. @${p.targetAgentId} | ${callTypeLabel(language, p.callType)} | ${summarizeTellask(p)}`
-            : `${idx + 1}. @${p.targetAgentId} | ${callTypeLabel(language, p.callType)} | ${summarizeTellask(p)}`;
+            ? `${idx + 1}. ${pendingTargetLabel(language, p)} | ${callKindLabel(language, p)} | ${summarizeTellask(p)}`
+            : `${idx + 1}. ${pendingTargetLabel(language, p)} | ${callKindLabel(language, p)} | ${summarizeTellask(p)}`;
         if (!p.sessionSlug)
             return base;
         return language === 'zh'

package/dist/tools/plan.js

@@ -130,10 +130,11 @@ exports.updatePlanTool = {
             kind: 'plan',
             schemaVersion: 1,
             updatedAt: now,
-            source: 'update_plan',
-            managedByTool: 'update_plan',
-            edit: {
-                updateExample: 'update_plan({ "plan": [ { "step": "...", "status": "in_progress" } ] })',
+            manager: {
+                tool: 'update_plan',
+            },
+            update: {
+                altInstruction: 'update_plan({ "plan": [ { "step": "...", "status": "in_progress" } ] })',
             },
         };
         let existingIndex;

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: