dominds 1.27.2 → 1.27.3

package/dist/tools/os.js

@@ -24,6 +24,7 @@ const fs_1 = __importDefault(require("fs"));
 const module_1 = require("module");
 const net_1 = __importDefault(require("net"));
 const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
 const util_1 = require("util");
 const rtws_1 = require("../rtws");
 const driver_messages_1 = require("../runtime/driver-messages");
@@ -572,6 +573,8 @@ function getOsToolMessages(language) {
             daemonOutputHeader: (pid, streamLabel) => `📤 守护进程 ${pid} ${streamLabel} 输出：\n`,
             noOutput: '(无输出)',
             scrolledOutNotice: (lines) => `\n\n⚠️  有 ${lines} 行已滚出可视范围`,
+            daemonOutputWaitTimedOut: (pid, streamLabel, timeoutMs) => `⏱️ 等待守护进程 ${pid} 的 ${streamLabel} 新输出已超时（timeout_ms=${timeoutMs}）。以下是当前快照。\n\n`,
+            daemonOutputWaitExited: (pid, streamLabel) => `⏹️ 等待守护进程 ${pid} 的 ${streamLabel} 新输出期间进程已退出；未观察到新的所选流输出。以下是最终快照。\n\n`,
         };
     }
     return {
@@ -587,6 +590,8 @@ function getOsToolMessages(language) {
         daemonOutputHeader: (pid, streamLabel) => `📤 Daemon ${pid} ${streamLabel} output:\n`,
         noOutput: '(no output)',
         scrolledOutNotice: (lines) => `\n\n⚠️  ${lines} lines have scrolled out of view`,
+        daemonOutputWaitTimedOut: (pid, streamLabel, timeoutMs) => `⏱️ Timed out waiting for new ${streamLabel} output from daemon ${pid} (timeout_ms=${timeoutMs}). Current snapshot follows.\n\n`,
+        daemonOutputWaitExited: (pid, streamLabel) => `⏹️ Daemon ${pid} exited while waiting for new ${streamLabel} output; no new requested-stream output was observed. Final snapshot follows.\n\n`,
     };
 }
 function disconnectRunnerProcess(runnerProcess) {
@@ -818,12 +823,38 @@ function parseGetDaemonOutputArgs(args) {
     if (stderrRaw !== undefined && typeof stderrRaw !== 'boolean') {
         throw new Error('get_daemon_output.stderr must be a boolean if provided');
     }
+    const waitForNewOutputRaw = args.wait_for_new_output;
+    if (waitForNewOutputRaw !== undefined && typeof waitForNewOutputRaw !== 'boolean') {
+        throw new Error('get_daemon_output.wait_for_new_output must be a boolean if provided');
+    }
+    const timeoutMsRaw = args.timeout_ms;
+    if (timeoutMsRaw !== undefined && typeof timeoutMsRaw !== 'number') {
+        throw new Error('get_daemon_output.timeout_ms must be a number if provided');
+    }
+    const timeoutMs = timeoutMsRaw === undefined
+        ? undefined
+        : Number.isInteger(timeoutMsRaw) &&
+            timeoutMsRaw >= 0 &&
+            timeoutMsRaw <= cmd_runner_protocol_1.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS
+            ? timeoutMsRaw
+            : (() => {
+                throw new Error(`get_daemon_output.timeout_ms must be a non-negative integer <= ${String(cmd_runner_protocol_1.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS)}`);
+            })();
     const stdout = stdoutRaw ?? true;
     const stderr = stderrRaw ?? true;
     if (!stdout && !stderr) {
         throw new Error('get_daemon_output requires at least one of stdout/stderr to be true');
     }
-    return { pid, stdout, stderr };
+    if (waitForNewOutputRaw === false && timeoutMs !== undefined) {
+        throw new Error('get_daemon_output.timeout_ms cannot be provided when wait_for_new_output is false');
+    }
+    return {
+        pid,
+        stdout,
+        stderr,
+        waitForNewOutput: waitForNewOutputRaw ?? timeoutMs !== undefined,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    };
 }
 function getWindowsShellLabel(shell) {
     if (typeof shell !== 'string') {
@@ -945,8 +976,8 @@ function resolveCmdRunnerEntrypointAbs() {
     }
     const tsCandidate = path_1.default.resolve(__dirname, 'cmd-runner.ts');
     if (fs_1.default.existsSync(tsCandidate)) {
-        const tsxLoaderAbs = requireFn.resolve('tsx');
-        return { ok: true, scriptAbs: tsCandidate, execArgv: ['--import', tsxLoaderAbs] };
+        const tsxLoaderUrl = (0, url_1.pathToFileURL)(requireFn.resolve('tsx')).href;
+        return { ok: true, scriptAbs: tsCandidate, execArgv: ['--import', tsxLoaderUrl] };
     }
     return {
         ok: false,
@@ -991,21 +1022,30 @@ async function callRunner(endpoint, request, timeoutMs = 5_000) {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timeoutHandle);
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+            }
             socket.destroy();
             fn();
         };
-        const timeoutHandle = setTimeout(() => {
-            finalize(() => {
-                reject(new Error(`cmd_runner request timed out for endpoint ${endpoint}`));
-            });
-        }, timeoutMs);
+        const timeoutHandle = timeoutMs === null
+            ? undefined
+            : setTimeout(() => {
+                finalize(() => {
+                    reject(new Error(`cmd_runner request timed out for endpoint ${endpoint}`));
+                });
+            }, timeoutMs);
         socket.setEncoding('utf8');
         socket.once('error', (error) => {
             finalize(() => {
                 reject(error);
             });
         });
+        socket.once('close', () => {
+            finalize(() => {
+                reject(new Error(`cmd_runner connection closed before response for endpoint ${endpoint}`));
+            });
+        });
         socket.on('data', (chunk) => {
             buffer += chunk;
             const newlineIndex = buffer.indexOf('\n');
@@ -1101,6 +1141,45 @@ async function resolveDaemonFromMeta(meta) {
         };
     }
 }
+function getRunnerRequestTimeoutForDaemonOutput(args) {
+    if (!args.waitForNewOutput) {
+        return undefined;
+    }
+    if (args.timeoutMs !== undefined) {
+        return Math.max(5_000, args.timeoutMs + 5_000);
+    }
+    return null;
+}
+async function resolveDaemonOutputFromMeta(meta, args) {
+    if (meta.runnerEndpoint !== undefined && meta.runnerEndpoint.trim() !== '') {
+        try {
+            const response = await callRunner(meta.runnerEndpoint, {
+                type: 'get_output',
+                stdout: args.stdout,
+                stderr: args.stderr,
+                waitForNewOutput: args.waitForNewOutput,
+                ...(args.timeoutMs === undefined ? {} : { timeoutMs: args.timeoutMs }),
+            }, getRunnerRequestTimeoutForDaemonOutput(args));
+            if (response.ok &&
+                response.type === 'output' &&
+                runnerResponseMatchesReminder(meta, response)) {
+                return {
+                    kind: 'live',
+                    daemon: buildRunnerBackedDaemon(meta, response),
+                    ...(response.waitStatus === undefined ? {} : { waitStatus: response.waitStatus }),
+                };
+            }
+        }
+        catch {
+            // Fall through to stale-or-gone detection.
+        }
+    }
+    const resolved = await resolveDaemonFromMeta(meta);
+    if (resolved.kind !== 'live') {
+        return resolved;
+    }
+    return { kind: 'live', daemon: resolved.daemon };
+}
 function formatRunnerBackedDaemonStatusDetails(daemon, language) {
     const uptime = Math.floor((Date.now() - daemon.startTime.getTime()) / 1000);
     const status = language === 'zh'
@@ -1248,6 +1327,14 @@ const getDaemonOutputSchema = {
             type: 'boolean',
             description: 'Whether to include stderr output (default: true unless stdout is explicitly set)',
         },
+        wait_for_new_output: {
+            type: 'boolean',
+            description: 'Whether to wait until at least one requested stream receives new output before returning (default: false, or true when timeout_ms is provided)',
+        },
+        timeout_ms: {
+            type: 'integer',
+            description: 'Optional non-negative maximum time in milliseconds to wait for new output, up to 86400000 (24h); providing this implies wait_for_new_output=true unless wait_for_new_output is explicitly false, which is rejected',
+        },
     },
     required: ['pid'],
     additionalProperties: false,
@@ -2788,26 +2875,33 @@ exports.stopDaemonTool = {
         }
     },
 };
+function formatRequestedDaemonOutputStreams(stdout, stderr) {
+    if (stdout && stderr) {
+        return 'stdout/stderr';
+    }
+    return stdout ? 'stdout' : 'stderr';
+}
 // Get daemon output tool implementation
 exports.getDaemonOutputTool = {
     type: 'func',
     name: 'get_daemon_output',
-    description: 'Retrieve captured stdout/stderr output from a tracked daemon process by PID. By default both streams are returned together; you may disable either stream explicitly. Returns (no output) if a requested stream has not produced output yet.',
+    description: 'Retrieve captured stdout/stderr output from a tracked daemon process by PID. By default both streams are returned together; you may disable either stream explicitly. Set wait_for_new_output=true to wait until a requested stream receives new output before returning; timeout_ms optionally bounds that wait. Returns (no output) if a requested stream has not produced output yet.',
     descriptionI18n: {
-        en: 'Retrieve captured stdout/stderr output from a tracked daemon process by PID. By default both streams are returned together; you may disable either stream explicitly. Returns (no output) if a requested stream has not produced output yet.',
-        zh: '根据 PID 获取已追踪守护进程的 stdout/stderr 输出。默认会同时返回两个流，也可显式关闭其中一个；若所请求的流尚无输出，则返回 (no output)。',
+        en: 'Retrieve captured stdout/stderr output from a tracked daemon process by PID. By default both streams are returned together; you may disable either stream explicitly. Set wait_for_new_output=true to wait until a requested stream receives new output before returning; timeout_ms optionally bounds that wait. Returns (no output) if a requested stream has not produced output yet.',
+        zh: '根据 PID 获取已追踪守护进程的 stdout/stderr 输出。默认会同时返回两个流，也可显式关闭其中一个；设置 wait_for_new_output=true 时会等到所请求流出现新输出后再返回，timeout_ms 可选用于限制等待毫秒数；若所请求的流尚无输出，则返回 (no output)。',
     },
     parameters: getDaemonOutputSchema,
     async call(dlg, caller, args) {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getOsToolMessages(language);
-        const { pid, stdout, stderr } = parseGetDaemonOutputArgs(args);
+        const parsedArgs = parseGetDaemonOutputArgs(args);
+        const { pid, stdout, stderr } = parsedArgs;
         const reminders = await (0, shared_reminders_1.loadSharedReminders)({ kind: 'agent', agentId: dlg.agentId });
         const reminder = reminders.find((candidate) => isShellCmdReminder(candidate) && candidate.meta.pid === pid);
         if (!reminder || !isShellCmdReminder(reminder)) {
             return (0, tool_1.toolFailure)(t.noDaemonFound(pid));
         }
-        const resolved = await resolveDaemonFromMeta(reminder.meta);
+        const resolved = await resolveDaemonOutputFromMeta(reminder.meta, parsedArgs);
         if (resolved.kind === 'gone') {
             await removeDaemonRemindersForPid(dlg, pid);
             return (0, tool_1.toolFailure)(t.noDaemonFound(pid));
@@ -2819,6 +2913,13 @@ exports.getDaemonOutputTool = {
         let result = '';
         const fenceConsole = '```console';
         const fenceEnd = '```';
+        const requestedStreams = formatRequestedDaemonOutputStreams(stdout, stderr);
+        if (resolved.waitStatus === 'timeout') {
+            result += t.daemonOutputWaitTimedOut(pid, requestedStreams, parsedArgs.timeoutMs ?? 0);
+        }
+        else if (resolved.waitStatus === 'exited') {
+            result += t.daemonOutputWaitExited(pid, requestedStreams);
+        }
         if (stdout) {
             const stdoutContent = (0, output_limit_1.truncateToolOutputText)(daemon.stdoutContent, {
                 toolName: 'get_daemon_output_stdout',

package/dist/tools/process-kill.js

@@ -30,10 +30,59 @@ async function bestEffortTaskkill(pid, force) {
         // Best effort only.
     }
 }
+async function bestEffortListWindowsDescendantPids(pid) {
+    assertValidPid(pid);
+    try {
+        const command = `
+$processes = Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId
+$frontier = @(${String(pid)})
+$result = @()
+while ($frontier.Count -gt 0) {
+  $next = @()
+  foreach ($parentPid in $frontier) {
+    foreach ($child in $processes | Where-Object { $_.ParentProcessId -eq $parentPid }) {
+      $childPid = [int]$child.ProcessId
+      $result += $childPid
+      $next += $childPid
+    }
+  }
+  $frontier = $next
+}
+$result | ForEach-Object { [Console]::Out.WriteLine($_) }
+`;
+        const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', command], {
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+        });
+        const parsed = [];
+        for (const line of stdout.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (trimmed === '') {
+                continue;
+            }
+            const parsedPid = Number(trimmed);
+            if (Number.isInteger(parsedPid) && parsedPid > 0) {
+                parsed.push(parsedPid);
+            }
+        }
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
 async function bestEffortKillWindowsProcessTree(pid) {
     assertValidPid(pid);
+    const descendantPids = await bestEffortListWindowsDescendantPids(pid);
+    for (const descendantPid of descendantPids.slice().reverse()) {
+        await bestEffortTaskkill(descendantPid, false);
+    }
     await bestEffortTaskkill(pid, false);
     await sleepMs(1_000);
+    for (const descendantPid of descendantPids.slice().reverse()) {
+        await bestEffortTaskkill(descendantPid, true);
+        bestEffortKillPid(descendantPid);
+    }
     await bestEffortTaskkill(pid, true);
     bestEffortKillPid(pid);
 }

package/dist/tools/prompts/control/en/errors.md

@@ -73,7 +73,7 @@
 
 ### Q: What's the difference between dialog, task, agent reminders, and memory?
 
-A: `dialog` reminders are only for the current dialog's current work. `task` reminders are for current work under the same Taskdoc and are the default for `add_reminder`. `agent` reminders stay visible in all later dialogs you lead, but only for urgent, short-lived, globally visible cues. None of them are long-term knowledge. `personal_memory` is for durable facts and reusable knowledge saved to disk; if the information should synchronize the team's current effective state, key decisions, next step, or still-active blockers, write it to Taskdoc `progress` instead of a reminder.
+A: `dialog` reminders are only for the current dialog's current work. `task` reminders are for current work under the same Taskdoc and are the default for `add_reminder`. `agent` reminders stay visible in later dialogs you lead, but only for urgent, short-lived, globally visible cues. None of them are long-term knowledge. `personal_memory` is for durable facts and reusable knowledge saved to disk; if the information should synchronize the team's current effective state, key decisions, next step, or still-active blockers, write it to Taskdoc `progress` instead of a reminder.
 
 ### Q: How do I choose `dialog`, `task`, and `agent`?
 

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

@@ -64,7 +64,7 @@ Scope rule:
 
 - `dialog`: current-dialog current work
 - `task`: current work under the current Taskdoc, and the default scope
-- `agent`: urgent, short-lived, globally visible cues you should keep seeing in all later dialogs you lead
+- `agent`: urgent, short-lived, globally visible cues you should keep seeing across later dialogs you lead
 
 ### Taskdoc
 

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

@@ -30,8 +30,8 @@
 Reminders are temporary current-work notes with three scopes:
 
 - `dialog`: current-dialog only
-- `task`: visible in every dialog you lead for the current Taskdoc
-- `agent`: visible in all dialogs you lead, but only for urgent, short-lived, globally visible cues
+- `task`: visible across dialogs for the current Taskdoc
+- `agent`: visible in later dialogs you lead, but only for urgent, short-lived, globally visible cues
 
 Default to `task`. Use `dialog` only when the note is truly dialog-local; use `agent` only when the note is urgent, short-lived, and globally visible.
 
@@ -39,7 +39,7 @@ Default to `task`. Use `dialog` only when the note is truly dialog-local; use `a
 
 - `dialog` reminders stay in the current dialog only
 - `task` reminders stay visible under the current Taskdoc
-- `agent` reminders stay visible in all later dialogs you lead
+- `agent` reminders stay visible in later dialogs you lead
 - Can be added, modified, or deleted at any time
 - Should stay compact, scannable, and directly actionable by default
 - Before `clear_mind`, the Main Dialog first records undocumented discussion details the next course needs to know into Taskdoc, then creates a structured continuation-package reminder; a Side Dialog directly maintains sufficiently detailed continuation-package reminders. If Dominds has already warned that context is tight or critical, Side Dialog reminders have no fixed length limit and rough multi-reminder carry-over is acceptable
@@ -47,7 +47,7 @@ Default to `task`. Use `dialog` only when the note is truly dialog-local; use `a
 **Difference from memory:**
 | Feature | dialog reminder | task reminder | agent reminder | personal memory |
 |---------|-----------------|---------------|----------------|-----------------|
-| Persistence | Current dialog only | Current Taskdoc | Across all later dialogs you lead | Long-term / file-backed |
+| Persistence | Current dialog only | Current Taskdoc | Across later dialogs you lead | Long-term / file-backed |
 | Visibility | Current dialog | Current-task dialogs | Current Dialog Responder | Current agent |
 | Best for | Current next step, blocker, volatile clue | Current work under one task | Urgent, short-lived, global cue | Stable facts / reusable knowledge |
 
@@ -61,7 +61,7 @@ Default to `task`. Use `dialog` only when the note is truly dialog-local; use `a
   - current blockers
   - temporary paths, ids, commands, sample inputs
   - bridge notes that matter only for this dialog / current course
-- Use `agent` only for urgent, short-lived, globally visible cues that should appear in every dialog you lead.
+- Use `agent` only for urgent, short-lived, globally visible cues that should appear across dialogs you lead.
 - If the content is a durable fact or knowledge asset rather than an active current-work cue, it likely belongs in `personal_memory`, not in any reminder scope.
 
 ### 2. Taskdoc
@@ -85,16 +85,17 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 
 ## Tool Overview
 
-| Tool            | Function                                         |
-| --------------- | ------------------------------------------------ |
-| add_reminder    | Add reminder                                     |
-| delete_reminder | Delete reminder                                  |
-| update_reminder | Update reminder content                          |
-| do_mind         | Create new Taskdoc section                       |
-| mind_more       | Append entries to Taskdoc (defaults to progress) |
-| change_mind     | Replace existing Taskdoc section                 |
-| never_mind      | Delete Taskdoc section file                      |
-| recall_taskdoc  | Read taskdoc chapter                             |
+| Tool             | Function                                         |
+| ---------------- | ------------------------------------------------ |
+| add_reminder     | Add reminder                                     |
+| delete_reminder  | Delete reminder                                  |
+| update_reminder  | Update reminder content                          |
+| migrate_reminder | Move an over-shared reminder back to this dialog |
+| do_mind          | Create new Taskdoc section                       |
+| mind_more        | Append entries to Taskdoc (defaults to progress) |
+| change_mind      | Replace existing Taskdoc section                 |
+| never_mind       | Delete Taskdoc section file                      |
+| recall_taskdoc   | Read taskdoc chapter                             |
 
 ## Inter-dialog Reply Routing
 
@@ -125,7 +126,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 - **Easy-to-lose details**: temporary paths, ids, commands, sample inputs
 - **Course transition**: continuation-package notes before `clear_mind`, including rough multi-reminder carry-over when already degraded
 - **Task carry-over**: if you should keep seeing the note under the current Taskdoc, use `task`
-- **Global urgent cue**: if you should keep seeing it in all later dialogs you lead, and it is urgent, short-lived, and globally visible, use `agent`
+- **Global urgent cue**: if you should keep seeing it across later dialogs you lead, and it is urgent, short-lived, and globally visible, use `agent`
 
 ### 2. Taskdoc Update Timing
 
@@ -161,7 +162,7 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 
 ## Limitations and Notes
 
-1. `dialog` reminders end with the dialog; `task` reminders stay visible under the current Taskdoc; `agent` reminders stay visible in all later dialogs you lead
+1. `dialog` reminders end with the dialog; `task` reminders stay visible under the current Taskdoc; `agent` reminders stay visible in later dialogs you lead
 2. Use `do_mind` to create missing Taskdoc sections; use `mind_more` for small Taskdoc additions; use `change_mind` for full-section replacement of existing sections only after merging existing content and calling `recall_taskdoc` for the current `content_hash`; use `never_mind` when a whole section file should be deleted. Do not treat `mind_more` as a chronology tool; when cleanup, stale-entry removal, or same-topic consolidation is needed, use `recall_taskdoc` then `change_mind`
 3. `do_mind` / `mind_more` / `change_mind` / `never_mind` do not start a new course
 4. A continuation-package reminder should keep only details still not covered by Taskdoc but easy to lose during resume; in the Main Dialog, undocumented discussion details from current dialog history that the next course needs to know should be written to the appropriate Taskdoc sections first; in a Side Dialog after Dominds warns that context is tight or critical, maintain sufficiently detailed continuation-package reminders only

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

@@ -112,7 +112,30 @@ updated_at: <update timestamp>
 
 - `REMINDER_NOT_FOUND`: Reminder id does not exist
 
-### 4. clear_mind
+### 4. migrate_reminder
+
+Move a visible shared reminder back into the current dialog scope.
+
+Use when:
+
+- You just updated a task/agent shared reminder and then realize the new content belongs only to this dialog
+- Dominds warned that the shared update affected same-agent parallel dialogs and you need to withdraw it from those dialogs
+
+**Parameters:**
+
+- `reminder_id` (required): Reminder id
+- `scope` (required): Must be `dialog`
+
+**Example:**
+
+```js
+migrate_reminder({
+  reminder_id: 'abc123de',
+  scope: 'dialog',
+});
+```
+
+### 5. clear_mind
 
 Start a new dialog course.
 

package/dist/tools/prompts/control/zh/errors.md

@@ -73,7 +73,7 @@
 
 ### Q: `dialog` / `task` / `agent` 提醒和 memory 有什么区别？
 
-A: `dialog` 提醒只用于当前对话的手头工作；`task` 提醒用于同一差遣牒任务内的手头工作，也是 `add_reminder` 默认范围；`agent` 提醒会在所有由你主理的后续对话里继续可见，只适合紧急、短期、全局刺眼提醒。它们都不是长期知识库。`personal_memory` 用于保存持久稳定事实和可复用知识；如果信息需要向全队同步当前有效状态、关键决策、下一步或仍成立阻塞，应写入 Taskdoc `progress`，而不是提醒项。
+A: `dialog` 提醒只用于当前对话的手头工作；`task` 提醒用于同一差遣牒任务内的手头工作，也是 `add_reminder` 默认范围；`agent` 提醒会在由你主理的后续对话里继续可见，只适合紧急、短期、全局刺眼提醒。它们都不是长期知识库。`personal_memory` 用于保存持久稳定事实和可复用知识；如果信息需要向全队同步当前有效状态、关键决策、下一步或仍成立阻塞，应写入 Taskdoc `progress`，而不是提醒项。
 
 ### Q: `dialog`、`task` 和 `agent` 怎么选？
 

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

@@ -64,7 +64,7 @@ scope 规则：
 
 - `dialog`：当前对话手头工作
 - `task`：当前差遣牒任务下的手头工作，默认范围
-- `agent`：在所有由你主理的后续对话里也应继续看到的紧急、短期、全局刺眼提醒
+- `agent`：在由你主理的后续对话里也应继续看到的紧急、短期、全局刺眼提醒
 
 ### 差遣牒
 

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

@@ -30,8 +30,8 @@
 提醒是临时手头工作提示，但现在分成三个 scope：
 
 - `dialog`：仅当前对话可见
-- `task`：当前差遣牒任务内、所有由你主理的对话里都可见
-- `agent`：所有由你主理的对话里都可见，但只用于紧急、短期、全局刺眼提醒
+- `task`：当前差遣牒任务内跨对话可见
+- `agent`：由你主理的后续对话会继续看到，但只用于紧急、短期、全局刺眼提醒
 
 默认用 `task`。只有当这条提醒只对当前对话局部有效时，才降到 `dialog`；只有当它是紧急、短期、全局刺眼提醒时，才升到 `agent`。
 
@@ -39,7 +39,7 @@
 
 - `dialog` 提醒只留在当前对话
 - `task` 提醒会在当前差遣牒任务内继续可见
-- `agent` 提醒会在所有由你主理的后续对话里继续可见
+- `agent` 提醒会在由你主理的后续对话里继续可见
 - 可随时添加、修改、删除
 - 默认应保持少量、可扫读、可直接指导下一步
 - 准备 `clear_mind` 时，主线对话先把应由下一程知会的未落文档讨论细节补进差遣牒，再压缩成结构化接续包提醒项；支线对话直接维护足够详尽的接续包提醒项。若 Dominds 已提醒上下文吃紧/告急，支线提醒项没有固定长度限制，也可先保留多条粗略提醒项过桥
@@ -47,7 +47,7 @@
 **与 memory 的区别：**
 | 特性 | dialog reminder | task reminder | agent reminder | personal memory |
 |------|-----------------|---------------|----------------|-----------------|
-| 持久性 | 仅当前对话 | 当前差遣牒任务 | 跨所有由你主理的后续对话 | 长期 / 文件持久化 |
+| 持久性 | 仅当前对话 | 当前差遣牒任务 | 跨由你主理的后续对话 | 长期 / 文件持久化 |
 | 可见性 | 当前对话 | 当前任务相关对话 | 你当前可见的提醒范围 | 当前智能体 |
 | 最适合 | 当前下一步、阻塞、易丢线索 | 同一任务下的手头工作 | 紧急、短期、全局刺眼提醒 | 稳定事实 / 可复用知识 |
 
@@ -84,16 +84,17 @@
 
 ## 工具概览
 
-| 工具            | 功能                              |
-| --------------- | --------------------------------- |
-| add_reminder    | 添加提醒                          |
-| delete_reminder | 删除提醒                          |
-| update_reminder | 更新提醒内容                      |
-| do_mind         | 创建新差遣牒章节                  |
-| mind_more       | 向差遣牒追加条目（默认 progress） |
-| change_mind     | 整章替换已有差遣牒章节            |
-| never_mind      | 删除差遣牒章节文件                |
-| recall_taskdoc  | 读取差遣牒章节                    |
+| 工具             | 功能                              |
+| ---------------- | --------------------------------- |
+| add_reminder     | 添加提醒                          |
+| delete_reminder  | 删除提醒                          |
+| update_reminder  | 更新提醒内容                      |
+| migrate_reminder | 将误扩散的共享提醒迁回当前对话    |
+| do_mind          | 创建新差遣牒章节                  |
+| mind_more        | 向差遣牒追加条目（默认 progress） |
+| change_mind      | 整章替换已有差遣牒章节            |
+| never_mind       | 删除差遣牒章节文件                |
+| recall_taskdoc   | 读取差遣牒章节                    |
 
 ## 跨对话回复路由
 
@@ -124,7 +125,7 @@
 - **易丢细节**：临时路径、id、命令、样例输入
 - **换程接续**：在 `clear_mind` 前整理接续包；若 Dominds 已提醒当前程吃紧/告急，可先保留多条粗略提醒项
 - **任务延续提示**：如果在当前差遣牒任务内都应该继续看到它，用 `task`
-- **全局刺眼提示**：如果它应该在所有由你主理的后续对话里继续看到，而且是短期、紧急、全局刺眼提醒，用 `agent`
+- **全局刺眼提示**：如果它应该在由你主理的后续对话里继续看到，而且是短期、紧急、全局刺眼提醒，用 `agent`
 
 ### 2. 差遣牒更新时机
 
@@ -160,7 +161,7 @@
 
 ## 限制与注意事项
 
-1. `dialog` 提醒会随对话结束而结束；`task` 提醒会在当前差遣牒任务内继续可见；`agent` 提醒会在所有由你主理的后续对话里继续可见
+1. `dialog` 提醒会随对话结束而结束；`task` 提醒会在当前差遣牒任务内继续可见；`agent` 提醒会在由你主理的后续对话里继续可见
 2. 缺失差遣牒章节用 `do_mind` 创建；差遣牒少量新增可用 `mind_more` 追加；已有章节整段替换用 `change_mind`，请确保合并已有内容，并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash`；确需删除整章文件时用 `never_mind`。不要把 `mind_more` 当流水账工具；需要整理、去旧、合并同主题记录时先 `recall_taskdoc` 再 `change_mind`
 3. `do_mind` / `mind_more` / `change_mind` / `never_mind` 不开启新 course
 4. 接续包提醒项只保留差遣牒仍未覆盖、但恢复工作容易丢的细节；主线对话应先把当前对话历史中应由下一程知会的未落文档讨论细节写入差遣牒合适章节；支线对话在吃紧/告急时只维护足够详尽的接续包提醒项

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

@@ -112,7 +112,30 @@ updated_at: <更新时间戳>
 
 - `REMINDER_NOT_FOUND`：提醒 id 不存在
 
-### 4. clear_mind
+### 4. migrate_reminder
+
+把当前可见的共享 reminder 迁回当前对话范围。
+
+**适用：**
+
+- 你刚更新 task/agent 共享提醒项后，发现新内容其实只属于当前对话
+- Dominds 已提醒这次共享更新影响了同智能体并行对话，需要从其它并行对话撤下
+
+**参数：**
+
+- `reminder_id`（必需）：提醒 id
+- `scope`（必需）：只能是 `dialog`
+
+**示例：**
+
+```js
+migrate_reminder({
+  reminder_id: 'abc123de',
+  scope: 'dialog',
+});
+```
+
+### 5. clear_mind
 
 开启新一程对话。
 

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

@@ -79,6 +79,8 @@ Get daemon process output.
 - `pid` (required): Daemon process ID (number)
 - `stdout` (optional): Whether to include stdout output (default: `true`)
 - `stderr` (optional): Whether to include stderr output (default: `true`)
+- `wait_for_new_output` (optional): Whether to wait until a requested stdout/stderr stream receives new output before returning (default: `false`; providing `timeout_ms` implies `true`)
+- `timeout_ms` (optional): Maximum milliseconds to wait for new output, capped at `86400000` (24h); on timeout, returns the current snapshot with a timeout notice; cannot be combined with `wait_for_new_output:false`
 
 **Returns:**
 

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

@@ -79,6 +79,8 @@ stopped_at: <停止时间戳>
 - `pid`（必需）：守护进程 PID（数字）
 - `stdout`（可选）：是否包含 stdout 输出（默认 `true`）
 - `stderr`（可选）：是否包含 stderr 输出（默认 `true`）
+- `wait_for_new_output`（可选）：是否等待所请求的 stdout/stderr 流出现新输出后再返回（默认 `false`；提供 `timeout_ms` 时默认视为 `true`）
+- `timeout_ms`（可选）：等待新输出的最长毫秒数，最大 `86400000`（24 小时）；超时后返回当前快照并提示超时；不可与 `wait_for_new_output:false` 同时使用
 
 **返回：**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.27.2",
+  "version": "1.27.3",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -54,9 +54,9 @@
     "ws": "^8.21.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@longrun-ai/kernel": "1.17.2",
-    "@longrun-ai/shell": "1.17.2",
-    "@longrun-ai/codex-auth": "0.14.0"
+    "@longrun-ai/codex-auth": "0.14.0",
+    "@longrun-ai/kernel": "1.17.3",
+    "@longrun-ai/shell": "1.17.3"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",