dominds 1.27.2 → 1.27.4

package/dist/tools/ctrl.js

@@ -13,6 +13,7 @@
  * - add_reminder: Add a reminder
  * - delete_reminder: Delete a reminder by id
  * - update_reminder: Update reminder content
+ * - migrate_reminder: Move a visible shared reminder back into the current dialog
  * - clear_mind: Start a new course, optionally add a reminder
  * - do_mind: Main Dialog only; create a new `.tsk/` Taskdoc section without starting a new course
  * - change_mind: Main Dialog only; update a `.tsk/` Taskdoc section without starting a new course
@@ -63,12 +64,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recallTaskdocTool = exports.mindMoreTool = exports.neverMindTool = exports.doMindTool = exports.changeMindTool = exports.clearMindTool = exports.updateReminderTool = exports.addReminderTool = exports.deleteReminderTool = void 0;
+exports.recallTaskdocTool = exports.mindMoreTool = exports.neverMindTool = exports.doMindTool = exports.changeMindTool = exports.clearMindTool = exports.migrateReminderTool = exports.updateReminderTool = exports.addReminderTool = exports.deleteReminderTool = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const dialog_1 = require("../dialog");
 const rtws_1 = require("../rtws");
 const driver_messages_1 = require("../runtime/driver-messages");
+const shared_reminder_update_impact_1 = require("../runtime/shared-reminder-update-impact");
 const tool_result_messages_1 = require("../runtime/tool-result-messages");
 const work_language_1 = require("../runtime/work-language");
 const shared_reminders_1 = require("../shared-reminders");
@@ -276,6 +278,87 @@ function replaceReminderContent(reminder, content, meta, renderMode) {
         renderMode: renderMode ?? reminder.renderMode,
     });
 }
+function resolveSharedReminderUpdateImpactScope(target) {
+    if (target.source !== 'runtime') {
+        return undefined;
+    }
+    if (target.target.kind === 'task') {
+        return 'task';
+    }
+    return target.reminder.scope === 'runtime' ? 'runtime' : 'agent';
+}
+function appendSharedReminderUpdateImpactToToolResult(output, language, reminderId, dispatch) {
+    if (dispatch === undefined) {
+        return output;
+    }
+    const notice = (0, driver_messages_1.formatSharedReminderUpdateImpactNotice)(language, {
+        reminderId,
+        scope: dispatch.scope,
+        audience: 'updater',
+    });
+    const dispatchLine = language === 'zh'
+        ? `已向 ${dispatch.dispatchedDialogCount}/${dispatch.peerDialogCount} 个受影响的并行对话派发提醒。`
+        : `Dispatched notices to ${dispatch.dispatchedDialogCount}/${dispatch.peerDialogCount} affected parallel dialog(s).`;
+    return {
+        ...output,
+        content: `${output.content}\n\n${notice}\n${dispatchLine}`,
+    };
+}
+function appendSharedReminderMigrationImpactToToolResult(output, language, dispatch) {
+    if (dispatch === undefined) {
+        return output;
+    }
+    const dispatchLine = language === 'zh'
+        ? `已向 ${dispatch.dispatchedDialogCount}/${dispatch.peerDialogCount} 个受影响的并行对话派发撤下提醒。`
+        : `Dispatched withdrawal notices to ${dispatch.dispatchedDialogCount}/${dispatch.peerDialogCount} affected parallel dialog(s).`;
+    return {
+        ...output,
+        content: `${output.content}\n${dispatchLine}`,
+    };
+}
+async function formatUpdateReminderSuccessResult(args) {
+    const scope = resolveSharedReminderUpdateImpactScope(args.target);
+    const dispatch = scope === undefined
+        ? undefined
+        : await (0, shared_reminder_update_impact_1.dispatchSharedReminderUpdateImpact)({
+            updater: args.dlg,
+            reminderId: args.target.reminder.id,
+            scope,
+            language: args.language,
+        });
+    return appendSharedReminderUpdateImpactToToolResult((0, tool_result_messages_1.formatToolActionResult)(args.language, 'updated'), args.language, args.target.reminder.id, dispatch);
+}
+async function migrateSharedReminderTargetToDialog(args) {
+    const reminderId = args.target.reminder.id;
+    const existingDialogIndex = findReminderIndexById('dialog', args.dlg.reminders, reminderId);
+    if (existingDialogIndex !== null) {
+        throw new Error(`Duplicate visible reminder_id before migration: ${reminderId}`);
+    }
+    let migratedReminder;
+    await (0, shared_reminders_1.mutateSharedReminders)(args.target.target, (sharedReminders) => {
+        const index = findReminderIndexById('shared', sharedReminders, reminderId);
+        if (index === null)
+            return;
+        migratedReminder = sharedReminders[index];
+        sharedReminders.splice(index, 1);
+    });
+    if (migratedReminder === undefined) {
+        return false;
+    }
+    args.dlg.reminders.push((0, tool_1.materializeReminder)({
+        id: migratedReminder.id,
+        content: migratedReminder.content,
+        owner: migratedReminder.owner,
+        meta: migratedReminder.meta,
+        echoback: migratedReminder.echoback,
+        scope: 'dialog',
+        createdAt: migratedReminder.createdAt,
+        priority: migratedReminder.priority,
+        renderMode: migratedReminder.renderMode,
+    }));
+    args.dlg.touchReminders();
+    return true;
+}
 async function deleteResolvedReminderTarget(dlg, target) {
     switch (target.source) {
         case 'dialog': {
@@ -325,6 +408,9 @@ function getCtrlMessages(language) {
             invalidFormatAdd: '参数格式不对。用法：add_reminder({ content: string, scope?: "dialog" | "task" | "agent" })（省略 scope 表示 task）',
             reminderContentEmpty: '提醒内容不能为空',
             invalidFormatUpdate: '参数格式不对。用法：update_reminder({ reminder_id: string, content: string })',
+            invalidFormatMigrate: '参数格式不对。用法：migrate_reminder({ reminder_id: string, scope: "dialog" })',
+            reminderAlreadyDialogScope: (reminderId) => `reminder_id=${reminderId} 已经是当前对话范围提醒项，不需要迁移。`,
+            reminderMigrateManagedBlocked: (managerTool) => `错误：该提醒项由工具 ${managerTool} 管理，不能用 migrate_reminder 迁移；请使用 ${managerTool} 更新。`,
             invalidFormatDoMind: '参数格式不对。用法：do_mind({ selector: string, category?: string, content: string })',
             invalidFormatChangeMind: '参数格式不对。用法：change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
             tooManyArgsChangeMind: '参数格式不对。用法：change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
@@ -372,6 +458,9 @@ function getCtrlMessages(language) {
         invalidFormatAdd: 'Error: Invalid args. Use: add_reminder({ content: string, scope?: "dialog" | "task" | "agent" }) (omitting scope means task).',
         reminderContentEmpty: 'Error: Reminder content cannot be empty',
         invalidFormatUpdate: 'Error: Invalid args. Use: update_reminder({ reminder_id: string, content: string })',
+        invalidFormatMigrate: 'Error: Invalid args. Use: migrate_reminder({ reminder_id: string, scope: "dialog" })',
+        reminderAlreadyDialogScope: (reminderId) => `reminder_id=${reminderId} is already dialog-scope in the current dialog; no migration is needed.`,
+        reminderMigrateManagedBlocked: (managerTool) => `Error: This reminder is managed by tool ${managerTool}. Do not migrate it via migrate_reminder; use ${managerTool} instead.`,
         invalidFormatDoMind: 'Error: Invalid args. Use: do_mind({ selector: string, category?: string, content: string })',
         invalidFormatChangeMind: 'Error: Invalid args. Use: change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
         tooManyArgsChangeMind: 'Error: Invalid args. Use: change_mind({ selector: string, category?: string, content: string, previous_content_hash: string })',
@@ -456,7 +545,7 @@ exports.addReminderTool = {
     description: 'Add a manually maintained reminder for current work. Scope defaults to task so the reminder survives continuing the same Taskdoc in another dialog; dialog is only for truly dialog-local notes; agent is visible to this agent across dialogs and should be reserved for urgent short-lived global cues. Do not manually record runtime-maintained environment state such as background process status or in-flight background asks.',
     descriptionI18n: {
         en: 'Add a manually maintained reminder for current work. Scope defaults to task so the reminder survives continuing the same Taskdoc in another dialog; dialog is only for truly dialog-local notes; agent is visible to this agent across dialogs and should be reserved for urgent short-lived global cues. Do not manually record runtime-maintained environment state such as background process status or in-flight background asks.',
-        zh: '添加手工维护的手头工作提醒。scope 默认 task，以便同一差遣牒任务换新对话继续时仍可见；dialog 只用于真正对话局部的事项；agent 会在本智能体所有对话中可见，仅用于紧急、短期、全局刺眼提醒。不要手工记录后台进程状态、后台进行中诉请等 runtime 会自动维护的环境状态。',
+        zh: '添加手工维护的手头工作提醒。scope 默认 task，以便同一差遣牒任务换新对话继续时仍可见；dialog 只用于真正对话局部的事项；agent 会在本智能体后续对话中继续可见，仅用于紧急、短期、全局刺眼提醒。不要手工记录后台进程状态、后台进行中诉请等 runtime 会自动维护的环境状态。',
     },
     parameters: {
         type: 'object',
@@ -592,12 +681,20 @@ exports.updateReminderTool = {
                 const updated = await updateResolvedReminderTarget(dlg, resolved.target, reminderContent, stripResult.nextMeta, reminderRenderMode);
                 if (!updated)
                     return (0, tool_1.toolFailure)(t.reminderTargetChanged);
-                return (0, tool_result_messages_1.formatToolActionResult)(language, 'updated');
+                return await formatUpdateReminderSuccessResult({
+                    dlg,
+                    target: resolved.target,
+                    language,
+                });
             }
             const updated = await updateResolvedReminderTarget(dlg, resolved.target, reminderContent, undefined, reminderRenderMode);
             if (!updated)
                 return (0, tool_1.toolFailure)(t.reminderTargetChanged);
-            return (0, tool_result_messages_1.formatToolActionResult)(language, 'updated');
+            return await formatUpdateReminderSuccessResult({
+                dlg,
+                target: resolved.target,
+                language,
+            });
         }
         const reminderMeta = buildContinuationPackageReminderMeta({
             existingMeta: reminder?.meta,
@@ -607,7 +704,84 @@ exports.updateReminderTool = {
         const updated = await updateResolvedReminderTarget(dlg, resolved.target, reminderContent, reminderMeta, reminderRenderMode);
         if (!updated)
             return (0, tool_1.toolFailure)(t.reminderTargetChanged);
-        return (0, tool_result_messages_1.formatToolActionResult)(language, 'updated');
+        return await formatUpdateReminderSuccessResult({
+            dlg,
+            target: resolved.target,
+            language,
+        });
+    },
+};
+exports.migrateReminderTool = {
+    type: 'func',
+    name: 'migrate_reminder',
+    description: 'Move a visible shared reminder back into the current dialog scope. Use this after a task/agent shared reminder update turns out to belong only to the updater dialog, so Dominds withdraws it from affected parallel dialogs.',
+    descriptionI18n: {
+        en: 'Move a visible shared reminder back into the current dialog scope. Use this after a task/agent shared reminder update turns out to belong only to the updater dialog, so Dominds withdraws it from affected parallel dialogs.',
+        zh: '把当前可见的共享提醒项迁回当前对话范围。用于 task/agent 共享提醒更新后发现内容只属于更新者对话时，将它从受影响并行对话中撤下。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['reminder_id', 'scope'],
+        properties: {
+            reminder_id: { type: 'string', description: 'Stable reminder id.' },
+            scope: {
+                type: 'string',
+                enum: ['dialog'],
+                description: 'Target scope. Currently only dialog is supported.',
+            },
+        },
+    },
+    argsValidation: 'dominds',
+    async call(dlg, _caller, args) {
+        const language = (0, work_language_1.getWorkLanguage)();
+        const t = getCtrlMessages(language);
+        if (args['scope'] !== 'dialog') {
+            return (0, tool_1.toolFailure)(t.invalidFormatMigrate);
+        }
+        const resolved = await resolveReminderTarget(dlg, args['reminder_id']);
+        if (!resolved.ok) {
+            const reminderId = resolved.reminderId.trim();
+            if (reminderId === '')
+                return (0, tool_1.toolFailure)(t.invalidFormatMigrate);
+            return (0, tool_1.toolFailure)(t.reminderDoesNotExist(reminderId));
+        }
+        const targetReminder = resolved.target.reminder;
+        if (resolved.target.source === 'dialog') {
+            return (0, tool_1.toolSuccess)(t.reminderAlreadyDialogScope(targetReminder.id));
+        }
+        const deleteAltInstruction = getDeleteAltInstruction(targetReminder.meta);
+        if (deleteAltInstruction !== undefined) {
+            return (0, tool_1.toolFailure)(formatManualDeleteBlockedError(language, deleteAltInstruction));
+        }
+        const managerTool = getManagerTool(targetReminder.meta);
+        if (managerTool !== undefined) {
+            return (0, tool_1.toolFailure)(t.reminderMigrateManagedBlocked(managerTool));
+        }
+        if (targetReminder.owner?.updateReminder !== undefined) {
+            return (0, tool_1.toolFailure)(language === 'zh'
+                ? '错误：该提醒项由 reminder owner 自动维护，不能用 migrate_reminder 迁移。'
+                : 'Error: This reminder is automatically maintained by a reminder owner and cannot be migrated via migrate_reminder.');
+        }
+        const scope = resolveSharedReminderUpdateImpactScope(resolved.target);
+        const migrated = await migrateSharedReminderTargetToDialog({
+            dlg,
+            target: resolved.target,
+        });
+        if (!migrated)
+            return (0, tool_1.toolFailure)(t.reminderTargetChanged);
+        const baseOutput = (0, tool_1.toolSuccess)(language === 'zh'
+            ? `已迁移：reminder_id=${targetReminder.id} 已从共享范围撤下，并保留为当前对话范围提醒项。`
+            : `Migrated: reminder_id=${targetReminder.id} has been withdrawn from shared scope and kept as a current-dialog reminder.`);
+        const dispatch = scope === undefined
+            ? undefined
+            : await (0, shared_reminder_update_impact_1.dispatchSharedReminderMigrationImpact)({
+                updater: dlg,
+                reminderId: targetReminder.id,
+                scope,
+                language,
+            });
+        return appendSharedReminderMigrationImpactToToolResult(baseOutput, language, dispatch);
     },
 };
 exports.clearMindTool = {
@@ -641,7 +815,10 @@ exports.clearMindTool = {
                 createdBy: 'clear_mind',
                 contextHealthLevel,
             });
-            dlg.addReminder(reminderContent, undefined, continuationMeta);
+            dlg.addReminder(reminderContent, undefined, continuationMeta, undefined, {
+                scope: 'dialog',
+                renderMode: 'markdown',
+            });
         }
         await dlg.startNewCourse(t.clearedCoursePrompt(dlg.currentCourse + 1));
         // Context health snapshot is inherently tied to the previous prompt/context.

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/pending-tellask-reminder.js

@@ -193,6 +193,7 @@ async function syncPendingTellaskReminderState(dlg) {
                 return false;
             }
             dlg.addReminder(content, exports.pendingTellaskReminderOwner, nextMeta, 0, {
+                scope: 'dialog',
                 renderMode: 'markdown',
             });
             return true;

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

@@ -26,7 +26,7 @@
 
 control is Dominds' **dialog control toolset** for managing dialog state, reminders, taskdocs, and inter-dialog reply closure semantics:
 
-- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for current work under the same Taskdoc; use `dialog` only for truly dialog-local notes; use `agent` only for urgent, short-lived, globally visible cues
+- **Reminder management**: Three reminder scopes: `dialog` / `task` / `agent`. Default to `task` for ordinary current work under the same Taskdoc; use `dialog` for truly dialog-local notes, and continuation packages before `clear_mind` must explicitly use `scope=dialog` and state this dialog task goal; use `agent` only for urgent, short-lived, globally visible cues
 - **Taskdoc operations**: Append to, replace, or delete task contract sections (goals/constraints/progress); within Taskdoc, `progress` is the team-shared, quasi-real-time, scannable task bulletin board
 - **Context maintenance**: Reduce cognitive load without losing key resume state
 - **Reply routing**: Separate asking the tellasker back, sending the final reply, and ordinary plain text in Side Dialog / ask-back flows
@@ -56,15 +56,15 @@ Reminders are temporary current-work information for:
 - Marking pending tasks
 - Tracking current next steps / blockers
 - Recording blocking issues
-- Holding continuation-package bridge notes before `clear_mind`
+- Holding current-dialog scoped continuation-package bridge notes before `clear_mind`
 
 Reminders are not for manually copying environment state automatically maintained by Dominds, such as background process status, in-flight background asks/collaboration, or browser/session attachment state. Dominds-managed reminders, panels, and tool outputs are the authoritative place for that state; manual notes go stale easily and create cognitive noise.
 
 Scope rule:
 
-- `dialog`: current-dialog current work
+- `dialog`: current-dialog current work; continuation packages before `clear_mind` must explicitly use this scope and state this dialog task goal
 - `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