dominds 1.25.13 → 1.25.15

package/dist/server/websocket-handler.js

@@ -1908,14 +1908,9 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
         if (msg.fromStatus !== 'running') {
             return;
         }
-        void (0, dialog_display_state_1.getRunControlCountsSnapshot)()
-            .then((counts) => {
-            broadcastToClients({
-                type: 'run_control_counts_evt',
-                proceeding: counts.proceeding,
-                resumable: counts.resumable,
-                timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            });
+        void (0, dialog_display_state_1.createRunControlCountsMessage)()
+            .then((message) => {
+            broadcastToClients(message);
         })
             .catch((error) => {
             log.warn('Failed to broadcast run-control counts after dialog quarantine', error, {
@@ -1977,6 +1972,7 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
                     message: 'Connected to dialog server',
                     serverWorkLanguage,
                     supportedLanguageCodes: [...language_1.supportedLanguageCodes],
+                    runControlCountsSnapshotEpoch: (0, dialog_display_state_1.getRunControlCountsSnapshotEpoch)(),
                     runtimeStatus,
                     timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 }));
@@ -2005,13 +2001,7 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
                 }
             })();
             try {
-                const counts = await (0, dialog_display_state_1.getRunControlCountsSnapshot)();
-                ws.send(JSON.stringify({
-                    type: 'run_control_counts_evt',
-                    proceeding: counts.proceeding,
-                    resumable: counts.resumable,
-                    timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                }));
+                ws.send(JSON.stringify(await (0, dialog_display_state_1.createRunControlCountsMessage)()));
             }
             catch (error) {
                 log.warn('Failed to send initial run-control counts snapshot', error);

package/dist/tools/app-reminders.js

@@ -168,16 +168,16 @@ function fallbackRenderedReminder(reminder) {
         }),
     };
 }
-function formatAppReminderWrapperPrelude(language) {
+function formatAppReminderWrapperPrelude(language, reminderId) {
     return language === 'zh'
-        ? `这是 app 自动维护的状态提醒，不是你自己写的工作便签。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`
-        : `This is app-maintained state, not a work note you wrote. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`;
+        ? `这是 app 自动维护的状态提醒 [${reminderId}]，不是你自己写的工作便签。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`
+        : `This is app-maintained state [${reminderId}], not a work note you wrote. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}`;
 }
-function wrapAppRenderedReminder(message, language) {
+function wrapAppRenderedReminder(reminderId, message, language) {
     return {
         type: 'environment_msg',
         role: 'user',
-        content: `${formatAppReminderWrapperPrelude(language)}\n\n${message.content}`,
+        content: `${formatAppReminderWrapperPrelude(language, reminderId)}\n\n${message.content}`,
     };
 }
 async function persistAndPublishReminders(dlg) {
@@ -254,7 +254,7 @@ function createAppReminderOwner(params) {
                     reminderId: reminder.id,
                     workLanguage: language,
                 });
-                return wrapAppRenderedReminder(rendered, language);
+                return wrapAppRenderedReminder(reminder.id, rendered, language);
             }
             catch (error) {
                 log_1.log.warn('App reminder render failed; using generic reminder rendering', error, {

package/dist/tools/cmd-runner-protocol.d.ts

@@ -40,6 +40,7 @@ export type CmdRunnerRequest = Readonly<{
     stderr: boolean;
 }> | Readonly<{
     type: 'stop';
+    entirePg: boolean;
 }>;
 export type CmdRunnerStreamSnapshot = Readonly<{
     content: string;

package/dist/tools/cmd-runner-protocol.js

@@ -226,9 +226,16 @@ function parseCmdRunnerRequestLine(line) {
         throw new Error('Invalid cmd_runner request: expected object');
     }
     const type = asString(raw['type']);
-    if (type === 'ping' || type === 'get_status' || type === 'stop') {
+    if (type === 'ping' || type === 'get_status') {
         return { type };
     }
+    if (type === 'stop') {
+        const entirePg = asBoolean(raw['entirePg']);
+        if (entirePg === null) {
+            throw new Error('Invalid cmd_runner stop request: entirePg must be boolean');
+        }
+        return { type, entirePg };
+    }
     if (type === 'get_output') {
         const stdout = asBoolean(raw['stdout']);
         const stderr = asBoolean(raw['stderr']);

package/dist/tools/cmd-runner.js

@@ -10,6 +10,7 @@ const node_net_1 = __importDefault(require("node:net"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const cmd_runner_protocol_1 = require("./cmd-runner-protocol");
+const process_kill_1 = require("./process-kill");
 const shell_capture_env_1 = require("./shell-capture-env");
 const execFileAsync = (0, node_util_1.promisify)(child_process_1.execFile);
 class ScrollingBuffer {
@@ -113,8 +114,8 @@ async function ensureSocketParentDir(endpoint) {
         }
     }
 }
-function writeSocketResponse(socket, response) {
-    socket.end(`${JSON.stringify(response)}\n`);
+function writeSocketResponse(socket, response, callback) {
+    socket.end(`${JSON.stringify(response)}\n`, callback);
 }
 function isProcessAlive(pid) {
     try {
@@ -126,6 +127,11 @@ function isProcessAlive(pid) {
         return code !== 'ESRCH';
     }
 }
+function markDaemonMissing(state) {
+    state.isRunning = false;
+    state.exitCode = null;
+    state.exitSignal = 'SIGKILL';
+}
 async function main() {
     const initMessage = await new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
@@ -335,11 +341,12 @@ async function main() {
                         return;
                     }
                     await handleStopRequest(request, state, childProcess);
+                    const shouldExitAfterResponse = !state.isRunning;
                     writeSocketResponse(socket, {
                         type: 'stop_result',
                         ok: true,
                         ...buildStatusPayload(state),
-                    });
+                    }, shouldExitAfterResponse ? () => closeServerAndExit(0) : undefined);
                 }
                 catch (error) {
                     writeSocketResponse(socket, {
@@ -412,8 +419,24 @@ async function handleStopRequest(request, state, childProcess) {
     if (!state.isRunning) {
         return;
     }
-    process.kill(state.daemonPid, 'SIGTERM');
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    if (request.entirePg && process.platform === 'win32') {
+        await (0, process_kill_1.bestEffortKillWindowsProcessTree)(state.daemonPid);
+        await (0, process_kill_1.sleepMs)(100);
+        if (!state.isRunning || !isProcessAlive(state.daemonPid)) {
+            if (!state.isRunning) {
+                return;
+            }
+            markDaemonMissing(state);
+            return;
+        }
+    }
+    try {
+        process.kill(state.daemonPid, 'SIGTERM');
+    }
+    catch {
+        return;
+    }
+    await (0, process_kill_1.sleepMs)(1000);
     if (!state.isRunning) {
         return;
     }
@@ -423,13 +446,17 @@ async function handleStopRequest(request, state, childProcess) {
     catch {
         // Process may have exited during grace period.
     }
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await (0, process_kill_1.sleepMs)(100);
     if (!state.isRunning) {
         return;
     }
     if (typeof childProcess.kill === 'function') {
         childProcess.kill('SIGKILL');
     }
+    await (0, process_kill_1.sleepMs)(100);
+    if (state.isRunning && !isProcessAlive(state.daemonPid)) {
+        markDaemonMissing(state);
+    }
 }
 void main().catch((error) => {
     void flushIpc({

package/dist/tools/mcp.js

@@ -213,10 +213,7 @@ exports.mcpLeaseReminderOwner = {
                     `你当前看到的是系统维护的 MCP 租约状态。该 MCP server 被视为非“真正无状态”；当前对话持有一个 MCP 运行时实例（HTTP 连接或 stdio 进程）。`,
                     (0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage),
                     '',
-                    `当你确认近期不再需要这个运行时实例时，请释放它，以停止/回收底层 MCP 进程或连接：`,
-                    `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,
-                    '',
-                    `这只影响当前对话持有的运行时实例，不决定该 server 的全局工具注册/可见性。`,
+                    `该提醒项只说明当前对话持有的运行时实例；它不决定该 server 的全局工具注册/可见性。`,
                 ].join('\n')
                 : [
                     `${prefix} MCP toolset lease [${reminder.id}]: \`${serverId}\``,
@@ -224,10 +221,7 @@ exports.mcpLeaseReminderOwner = {
                     `You are looking at system-maintained MCP lease state. This MCP server is treated as non-stateless, and the current dialog holds one MCP runtime instance for it (an HTTP connection or stdio process).`,
                     (0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(workLanguage),
                     '',
-                    `When you are confident you will not need this runtime instance soon, release it to stop the underlying MCP process/connection:`,
-                    `- \`mcp_release({\"serverId\":\"${serverId}\"})\``,
-                    '',
-                    `This only affects the runtime instance held by the current dialog; it does not determine global tool registration/visibility for that server.`,
+                    `This reminder only describes the runtime instance held by the current dialog; it does not determine global tool registration/visibility for that server.`,
                 ].join('\n'),
         };
     },

package/dist/tools/os.js

@@ -31,6 +31,7 @@ const shared_reminders_1 = require("../shared-reminders");
 const tool_1 = require("../tool");
 const cmd_runner_protocol_1 = require("./cmd-runner-protocol");
 const output_limit_1 = require("./output-limit");
+const process_kill_1 = require("./process-kill");
 const shell_capture_env_1 = require("./shell-capture-env");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const requireFn = (0, module_1.createRequire)(__filename);
@@ -382,25 +383,25 @@ function buildShellCmdFinalizedMeta(previousMeta, lastUpdated) {
 function formatDaemonLifecyclePhaseSummary(command, phase, language) {
     if (language === 'zh') {
         return phase === 'running'
-            ? `🟢 ${command} 运行中（系统维护 / 实时真源 / 不可删除）`
-            : `🟡 ${command} 已退出（退出事件提示 / 确认看到后可删除）`;
+            ? `🟢 ${command} 运行中（系统维护 / 实时真源）`
+            : `🟡 ${command} 已退出（退出事件提示）`;
     }
     return phase === 'running'
-        ? `🟢 ${command} running (system-maintained / live source of truth / not deletable)`
-        : `🟡 ${command} exited (exit event notice / delete after acknowledgment)`;
+        ? `🟢 ${command} running (system-maintained / live source of truth)`
+        : `🟡 ${command} exited (exit event notice)`;
 }
 function formatExitedDaemonReminderContent(command, pid, language, lastKnownSnapshot) {
     const phaseSummary = formatDaemonLifecyclePhaseSummary(command, 'exited', language);
     return language === 'zh'
         ? `${phaseSummary}
 
-如需核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下保留的是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
+以下保留最后一次已知 stdout/stderr 快照；该提醒项只表达 daemon 终态，不是当前轮必须立即处理的动作。
 
 最后一次已知状态快照：
 ${lastKnownSnapshot}`
         : `${phaseSummary}
 
-If you need to verify the final stdout/stderr, first call get_daemon_output({ "pid": ${pid} }) if it is still available; otherwise use the last known snapshot below. After you have acknowledged the exit, delete this reminder manually.
+The last known stdout/stderr snapshot is retained below; this reminder only represents the daemon terminal state, not an action I must perform immediately in this turn.
 
 Last known status snapshot:
 ${lastKnownSnapshot}`;
@@ -554,7 +555,7 @@ async function waitForShellCmdReminderWakeEvent(reminder, signal) {
 function getOsToolMessages(language) {
     if (language === 'zh') {
         return {
-            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一条生命周期提醒持续刷新：系统维护 / 实时真源 / 不可删除。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\n需要时可使用 stop_daemon({"pid": ${pid}}) 终止该进程。`,
+            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一条生命周期提醒持续刷新：系统维护 / 实时真源。${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\n这条结果只说明进程已转入后台；对应 daemon reminder 的维护参考会描述后续管理通道。`,
             commandCompleted: (exitCode, scrollNotice) => `✅ 命令已完成（退出码：${exitCode ?? 'unknown'}）${scrollNotice}\n\n`,
             scrolledLinesNotice: (lines) => `\n⚠️  执行期间有 ${lines} 行已滚出可视范围`,
             stdoutLabel: '📤 stdout：',
@@ -569,7 +570,7 @@ function getOsToolMessages(language) {
         };
     }
     return {
-        daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} is now running in the background (PID: ${pid})\nThe process did not finish within ${timeoutSeconds} seconds and has transitioned into a daemon. You will see the same lifecycle reminder keep updating: system-maintained / live source of truth / not deletable. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\nUse stop_daemon({"pid": ${pid}}) to terminate it when needed.`,
+        daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} is now running in the background (PID: ${pid})\nThe process did not finish within ${timeoutSeconds} seconds and has transitioned into a daemon. You will see the same lifecycle reminder keep updating: system-maintained / live source of truth. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}\n\nThis result only reports that the process moved into the background; the corresponding daemon reminder maintenance reference describes later management paths.`,
         commandCompleted: (exitCode, scrollNotice) => `✅ Command completed (exit code: ${exitCode ?? 'unknown'})${scrollNotice}\n\n`,
         scrolledLinesNotice: (lines) => `\n⚠️  ${lines} lines scrolled out of view during execution`,
         stdoutLabel: '📤 stdout:',
@@ -794,12 +795,9 @@ function parseStopDaemonArgs(args) {
     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',
+        entirePg: entirePg ?? true,
     };
 }
 function parseGetDaemonOutputArgs(args) {
@@ -1026,6 +1024,13 @@ async function callRunner(endpoint, request, timeoutMs = 5000) {
 }
 async function bestEffortKillDaemonProcessGroup(meta, options) {
     const includeEntirePg = options?.includeEntirePg ?? true;
+    if (includeEntirePg && process.platform === 'win32') {
+        await (0, process_kill_1.bestEffortKillWindowsProcessTree)(meta.pid);
+        if (meta.runnerPid !== undefined && meta.runnerPid !== meta.pid) {
+            (0, process_kill_1.bestEffortKillPid)(meta.runnerPid);
+        }
+        return;
+    }
     if (includeEntirePg && process.platform !== 'win32' && meta.processGroupId !== undefined) {
         try {
             process.kill(-meta.processGroupId, 'SIGTERM');
@@ -1033,7 +1038,7 @@ async function bestEffortKillDaemonProcessGroup(meta, options) {
         catch {
             // Best effort only.
         }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
+        await (0, process_kill_1.sleepMs)(1000);
         try {
             process.kill(-meta.processGroupId, 'SIGKILL');
         }
@@ -1047,7 +1052,7 @@ async function bestEffortKillDaemonProcessGroup(meta, options) {
     catch {
         // Best effort only.
     }
-    await new Promise((resolve) => setTimeout(resolve, 250));
+    await (0, process_kill_1.sleepMs)(250);
     try {
         process.kill(meta.pid, 'SIGKILL');
     }
@@ -1216,7 +1221,7 @@ const stopDaemonSchema = {
         },
         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)',
+            description: 'Whether to stop the entire process group/process tree instead of only the tracked PID (default: true)',
         },
     },
     required: ['pid'],
@@ -1444,11 +1449,11 @@ exports.shellCmdReminderOwner = {
                     ? `${prefix} 后台进程生命周期提醒 [${reminder.id}]
 当前运行环境中有一条系统维护的后台进程状态提醒。请把它当成环境信号，不要当成你自己写的工作便签。
 ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
-若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态，等待你确认后手动删除。
+若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态作为运行时上下文。
 ---
 ${reminder.content}`
                     : `${prefix} Background process lifecycle reminder [${reminder.id}]
-The current runtime environment has a system-maintained background-process state reminder. Treat it as an environment signal, not as your self-authored work note. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} 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 auto-updates while the process is running; after exit it keeps the terminal state until you delete it manually.
+The current runtime environment has a system-maintained background-process state reminder. Treat it as an environment signal, not as your self-authored work note. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} 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 auto-updates while the process is running; after exit it keeps the terminal state as runtime context.
 ---
 ${reminder.content}`,
             };
@@ -1468,11 +1473,11 @@ ${reminder.content}`,
                         ? `${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${exitedSummary}｜PID ${pid}
 当前运行环境中 daemon 已退出。
 ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
-若需要再核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
+以下是最后一次已知 stdout/stderr 快照；该提醒项只表达 daemon 终态，不是当前轮必须立即处理的动作。
 ---
 ${reminder.content}`
                         : `${prefix} Daemon lifecycle reminder [${reminder.id}] - ${exitedSummary} | PID ${pid}
-The current runtime environment shows that this daemon has exited. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} If you still need to inspect the final stdout/stderr, first call get_daemon_output({ "pid": ${pid} }) if it is still available; otherwise use the last known snapshot below. After you have acknowledged the exit, delete this reminder manually.
+The current runtime environment shows that this daemon has exited. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} The last known stdout/stderr snapshot is retained below; this reminder only represents the daemon terminal state, not an action I must perform immediately in this turn.
 ---
 ${reminder.content}`,
                 };
@@ -1510,12 +1515,12 @@ The current runtime environment shows that this daemon process has finished its
                 ? `🔄 ${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${runningSummary}｜PID ${pid}，已运行 ${uptimeStr}
 当前运行环境中 daemon 仍在运行。这是系统维护的状态提醒，不是默认需要单独汇报的事项。
 ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)}
-若下面的信息没有实质改变你的判断、计划、风险，且不需要调用守护进程相关工具，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
+若下面的信息没有实质改变你的判断、计划或风险，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
 
 **状态快照：**
 ${statusInfo}`
                 : `🔄 ${prefix} Daemon lifecycle reminder [${reminder.id}] - ${runningSummary} | PID ${pid}, uptime: ${uptimeStr}
-The current runtime environment shows that this daemon is still running. This is a system-maintained state reminder and not something that normally deserves a standalone mention. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} 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".
+The current runtime environment shows that this daemon is still running. This is a system-maintained state reminder and not something that normally deserves a standalone mention. ${(0, driver_messages_1.formatAutoMaintainedReminderManualMirrorBan)(language)} If the information below does not materially change your judgment, plan, or risk, 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".
 
 **State snapshot:**
 ${statusInfo}`,
@@ -2752,7 +2757,7 @@ exports.stopDaemonTool = {
             if (reminder.meta.runnerEndpoint !== undefined &&
                 reminder.meta.runnerEndpoint.trim() !== '') {
                 try {
-                    const stopResponse = await callRunner(reminder.meta.runnerEndpoint, { type: 'stop' }, 10000);
+                    const stopResponse = await callRunner(reminder.meta.runnerEndpoint, { type: 'stop', entirePg }, 10000);
                     if (stopResponse.ok && runnerResponseMatchesReminder(reminder.meta, stopResponse)) {
                         if (stopResponse.isRunning) {
                             await bestEffortKillDaemonProcessGroup(reminder.meta, { includeEntirePg: entirePg });

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

@@ -36,13 +36,13 @@ function isPendingTellaskReminderMeta(value) {
 }
 function getPendingTellaskUpdateAltInstruction(language) {
     return language === 'zh'
-        ? '不要手改这条系统提醒。诉请更改规则很简单：同一路长线诉请要改要求，就复用同一 `sessionSlug` 再发 `tellask`；`tellaskSessionless` 是另一件一次性独立任务，不能改旧任务，也不能要求旧任务停止。其它情况等待系统按真实诉请状态自动刷新。'
-        : 'Do not hand-edit this system reminder. The change rule is simple: to change a sessioned task, send another `tellask` with the same `sessionSlug`; `tellaskSessionless` is another one-shot independent task, so it cannot change or stop an earlier task. Otherwise wait for system refresh from real tellask state.';
+        ? '我不手改这条系统提醒。诉请更改规则：同一路长线诉请要改要求时，我复用同一 `sessionSlug` 再发 `tellask`；`tellaskSessionless` 是另一件一次性独立任务，不能改旧任务，也不能要求旧任务停止。其它情况我等待系统按真实诉请状态自动刷新。'
+        : 'I do not hand-edit this system reminder. To change a sessioned task, I send another `tellask` with the same `sessionSlug`; `tellaskSessionless` is another one-shot independent task, so it cannot change or stop an earlier task. Otherwise I wait for system refresh from real tellask state.';
 }
 function getPendingTellaskDeleteAltInstruction(language) {
     return language === 'zh'
-        ? '这条系统提醒不可删除。诉请更改规则很简单：同一路长线诉请要改要求，就复用同一 `sessionSlug` 再发 `tellask`；`tellaskSessionless` 是另一件一次性独立任务，不能改旧任务，也不能要求旧任务停止。其它情况等待系统按真实诉请状态自动刷新。'
-        : 'This system reminder is not deletable. The change rule is simple: to change a sessioned task, send another `tellask` with the same `sessionSlug`; `tellaskSessionless` is another one-shot independent task, so it cannot change or stop an earlier task. Otherwise wait for system refresh from real tellask state.';
+        ? '我不能删除这条系统提醒。诉请更改规则：同一路长线诉请要改要求时，我复用同一 `sessionSlug` 再发 `tellask`；`tellaskSessionless` 是另一件一次性独立任务，不能改旧任务，也不能要求旧任务停止。其它情况我等待系统按真实诉请状态自动刷新。'
+        : 'I cannot delete this system reminder. To change a sessioned task, I send another `tellask` with the same `sessionSlug`; `tellaskSessionless` is another one-shot independent task, so it cannot change or stop an earlier task. Otherwise I wait for system refresh from real tellask state.';
 }
 function callKindLabel(language, view) {
     if (view.callType === 'A') {
@@ -112,17 +112,17 @@ function buildReminderMeta(pending, previousMeta) {
 }
 function buildReminderContent(language, pending) {
     const heading = language === 'zh'
-        ? `⏳ 进行中诉请（共 ${pending.length} 路，自动维护${pending.length === 0 ? '，0 路时可手动删除' : '，进行中不可删除'}）`
-        : `⏳ In-flight Tellasks (${pending.length} total, auto-maintained${pending.length === 0 ? ', deletable only at zero in-flight' : ', non-deletable while active'})`;
+        ? `⏳ 进行中诉请（共 ${pending.length} 路，自动维护）`
+        : `⏳ In-flight Tellasks (${pending.length} total, auto-maintained)`;
     if (pending.length === 0) {
         const noneRunningText = language === 'zh'
-            ? '当前没有任何执行中的诉请，没有其祂智能体仍在后台工作，任何“等待”想法和行为都是错误的。该提醒项仍是系统状态窗，内容不可手改；但因为当前为 0 路进行中，若你已明确知晓这一点，可手动删除以免碍眼。后续需要推进时，只能直接执行下一步本地动作，或发起新的诉请。'
-            : 'There are no in-flight Tellasks, and no other agents are still working in the background. Any “wait” thought or behavior is wrong. This reminder is still a system status window and its content must not be hand-edited; however, because there are currently zero in-flight Tellasks, you may delete it manually once you are sure. To continue later, take the next local action directly or issue a new Tellask.';
+            ? '当前没有任何执行中的诉请，没有其祂智能体仍在后台工作，任何“等待”想法和行为都是错误的。该提醒项只是系统状态窗；后续需要推进时，只能直接执行下一步本地动作，或发起新的诉请。'
+            : 'There are no in-flight Tellasks, and no other agents are still working in the background. Any “wait” thought or behavior is wrong. This reminder is only a system status window; to continue later, take the next local action directly or issue a new Tellask.';
         return [heading, '', noneRunningText].join('\n');
     }
     const summary = language === 'zh'
-        ? '以下诉请仍在执行中；除这些条目外，当前没有其它仍在执行中的诉请。该提醒项只是系统状态窗，不是控制面：自动维护、不可手改，且在非 0 路进行中时不可删除。不要把智能体队友当成真人同事：同一个队友可以同时做多件独立任务。简单规则：同一个队友 + 同一个 `sessionSlug` = 接着同一件事说，并更新那件正在做的事；`tellaskSessionless` 或不同 `sessionSlug` = 另一件独立任务，不会影响旧任务，也不能要求旧任务停止。误删会被拒绝，并返回同样的引导文案。'
-        : 'Only the Tellasks listed below are still in flight; besides them, no other Tellasks are currently executing. This reminder is only a system status window, not a control surface: auto-maintained, not hand-editable, and non-deletable while any tellask is still active. Do not treat an agent teammate like a human coworker who can only handle one conversation at a time: the same teammate can work on several independent tasks at once. Simple rule: same teammate + same `sessionSlug` = continue the same task and update that task; `tellaskSessionless` or a different `sessionSlug` = another independent task, so it will not affect or stop the earlier task. Mistaken deletion will be rejected with the same guidance.';
+        ? '以下诉请仍在执行中；除这些条目外，当前没有其它仍在执行中的诉请。该提醒项只是系统状态窗，不是控制面。不要把智能体队友当成真人同事：同一个队友可以同时做多件独立任务。'
+        : 'Only the Tellasks listed below are still in flight; besides them, no other Tellasks are currently executing. This reminder is only a system status window, not a control surface. Do not treat an agent teammate like a human coworker who can only handle one conversation at a time: the same teammate can work on several independent tasks at once.';
     const lines = pending.map((p, idx) => {
         const base = language === 'zh'
             ? `${idx + 1}. ${activeCalleeTargetLabel(language, p)} | ${callKindLabel(language, p)} | ${summarizeTellask(p)}`

package/dist/tools/process-kill.d.ts

@@ -0,0 +1,4 @@
+export declare function sleepMs(milliseconds: number): Promise<void>;
+export declare function buildWindowsTaskkillArgs(pid: number, force: boolean): string[];
+export declare function bestEffortKillWindowsProcessTree(pid: number): Promise<void>;
+export declare function bestEffortKillPid(pid: number): void;

package/dist/tools/process-kill.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleepMs = sleepMs;
+exports.buildWindowsTaskkillArgs = buildWindowsTaskkillArgs;
+exports.bestEffortKillWindowsProcessTree = bestEffortKillWindowsProcessTree;
+exports.bestEffortKillPid = bestEffortKillPid;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function sleepMs(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function buildWindowsTaskkillArgs(pid, force) {
+    assertValidPid(pid);
+    return force ? ['/PID', String(pid), '/T', '/F'] : ['/PID', String(pid), '/T'];
+}
+function assertValidPid(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        throw new Error(`Invalid process pid: ${String(pid)}`);
+    }
+}
+async function bestEffortTaskkill(pid, force) {
+    try {
+        await execFileAsync('taskkill.exe', buildWindowsTaskkillArgs(pid, force), {
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+        });
+    }
+    catch {
+        // Best effort only.
+    }
+}
+async function bestEffortKillWindowsProcessTree(pid) {
+    assertValidPid(pid);
+    await bestEffortTaskkill(pid, false);
+    await sleepMs(1000);
+    await bestEffortTaskkill(pid, true);
+    bestEffortKillPid(pid);
+}
+function bestEffortKillPid(pid) {
+    assertValidPid(pid);
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // Best effort only.
+    }
+}

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

@@ -55,7 +55,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`)
+- `entire_pg` (optional): Whether to stop the entire process group/process tree (default: `true`; on Windows this stops the tracked shell process and its child processes)
 
 **Returns:**
 
@@ -151,7 +151,7 @@ stop_daemon({
   pid: 12345,
 });
 
-// On Unix-like systems, you can explicitly terminate the whole process group
+// Explicitly stop the whole process group/process tree
 stop_daemon({
   pid: 12345,
   entire_pg: true,

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

@@ -55,7 +55,7 @@ executed_at: <执行时间戳>
 **参数：**
 
 - `pid`（必需）：守护进程 PID（数字）
-- `entire_pg`（可选）：是否对整个进程组发终止信号（默认：Linux/macOS 为 `true`，Windows 为 `false`；Windows 不支持显式传 `true`）
+- `entire_pg`（可选）：是否停止整个进程组/进程树（默认：`true`；Windows 上会停止被追踪的 shell 进程及其子进程）
 
 **返回：**
 
@@ -151,7 +151,7 @@ stop_daemon({
   pid: 12345,
 });
 
-// Unix-like 平台可显式要求终止整个进程组
+// 显式要求停止整个进程组/进程树
 stop_daemon({
   pid: 12345,
   entire_pg: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.13",
+  "version": "1.25.15",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,9 +52,9 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@longrun-ai/kernel": "1.15.9",
-    "@longrun-ai/shell": "1.15.9",
-    "@longrun-ai/codex-auth": "0.13.0"
+    "@longrun-ai/codex-auth": "0.13.0",
+    "@longrun-ai/kernel": "1.15.11",
+    "@longrun-ai/shell": "1.15.11"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/webapp/dist/assets/{_basePickBy-B1-brAPU.js → _basePickBy-bB-pfQPi.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-BuB0jmKD.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-DLTS_eOh.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CGrWBZre.js";
+import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-r4An5YoX.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-B1-brAPU.js.map
+//# sourceMappingURL=_basePickBy-bB-pfQPi.js.map