dominds 1.18.2 → 1.19.3

package/dist/tool-availability.js

@@ -116,7 +116,7 @@ async function buildAppDynamicLayer(params) {
         taskDocPath: params.taskDocPath,
         agentId: params.agentId,
         dialogId: params.dialog?.selfId,
-        rootDialogId: params.dialog?.rootId,
+        mainDialogId: params.dialog?.rootId,
         sessionSlug: params.dialog?.sessionSlug,
     });
     if (result.status === 'not_applicable') {

package/dist/tools/app-reminders.js

@@ -5,6 +5,7 @@ exports.ensureAppReminderOwnersRegistered = ensureAppReminderOwnersRegistered;
 exports.unregisterAppReminderOwnersForApps = unregisterAppReminderOwnersForApps;
 exports.applyAppReminderRequests = applyAppReminderRequests;
 const evt_registry_1 = require("../evt-registry");
+const log_1 = require("../log");
 const driver_messages_1 = require("../runtime/driver-messages");
 const work_language_1 = require("../runtime/work-language");
 const shared_reminders_1 = require("../shared-reminders");
@@ -159,8 +160,8 @@ function findOwnedReminderEntries(dlg, descriptor, owner) {
 function fallbackRenderedReminder(reminder) {
     const language = (0, work_language_1.getWorkLanguage)();
     return {
-        type: 'transient_guide_msg',
-        role: 'assistant',
+        type: 'environment_msg',
+        role: 'user',
         content: (0, driver_messages_1.formatReminderItemGuide)(language, reminder.id, reminder.content, {
             meta: reminder.meta,
             scope: reminder.scope,
@@ -212,7 +213,13 @@ function createAppReminderOwner(params) {
                         : reminder.meta,
                 };
             }
-            catch {
+            catch (error) {
+                log_1.log.warn('App reminder update failed; keeping existing reminder state', error, {
+                    appId: descriptor.appId,
+                    ownerRef: descriptor.ownerRef,
+                    dialogId: dlg.id.selfId,
+                    reminderId: reminder.id,
+                });
                 return { treatment: 'keep' };
             }
         },
@@ -229,7 +236,13 @@ function createAppReminderOwner(params) {
                     workLanguage: (0, work_language_1.getWorkLanguage)(),
                 });
             }
-            catch {
+            catch (error) {
+                log_1.log.warn('App reminder render failed; using generic reminder rendering', error, {
+                    appId: descriptor.appId,
+                    ownerRef: descriptor.ownerRef,
+                    dialogId: dlg.id.selfId,
+                    reminderId: reminder.id,
+                });
                 return fallbackRenderedReminder(reminder);
             }
         },

package/dist/tools/builtins.js

@@ -81,6 +81,7 @@ function manualSpecFor(toolsetId) {
 // MCP tools (local testing/ops)
 (0, registry_1.registerTool)(mcp_1.mcpRestartTool);
 (0, registry_1.registerTool)(mcp_1.mcpReleaseTool);
+(0, registry_1.registerTool)(mcp_1.mcpDisableTool);
 // Memory tools
 (0, registry_1.registerTool)(mem_1.addPersonalMemoryTool);
 (0, registry_1.registerTool)(mem_1.dropPersonalMemoryTool);
@@ -169,6 +170,7 @@ for (const tool of team_mgmt_1.teamMgmtTools) {
 (0, registry_1.registerToolset)('mcp_admin', [
     mcp_1.mcpRestartTool,
     mcp_1.mcpReleaseTool,
+    mcp_1.mcpDisableTool,
     env_1.envGetTool,
     env_1.envSetTool,
     env_1.envUnsetTool,

package/dist/tools/ctrl.js

@@ -634,9 +634,9 @@ exports.clearMindTool = {
 exports.changeMindTool = {
     type: 'func',
     name: 'change_mind',
-    description: 'Replace one shared Taskdoc section in the mainline dialog.',
+    description: 'Replace one shared Taskdoc section in the Main Dialog.',
     descriptionI18n: {
-        en: 'Replace one shared Taskdoc section in the mainline dialog.',
+        en: 'Replace one shared Taskdoc section in the Main Dialog.',
         zh: '在主线对话中替换一段共享差遣牒章节。',
     },
     parameters: {
@@ -659,13 +659,13 @@ exports.changeMindTool = {
     async call(dlg, caller, args) {
         const language = (0, work_language_1.getWorkLanguage)();
         const t = getCtrlMessages(language);
-        if (dlg.supdialog !== undefined) {
-            const maintainerId = dlg instanceof dialog_1.SubDialog ? dlg.rootDialog.agentId : dlg.agentId;
+        if (dlg.askerDialog !== undefined) {
+            const maintainerId = dlg instanceof dialog_1.SideDialog ? dlg.mainDialog.agentId : dlg.agentId;
             if (language === 'zh') {
                 return (0, tool_1.toolFailure)(`错误：\`change_mind\` 仅允许在主线对话中使用（支线对话中不可用）。\n` +
                     `请诉请差遣牒维护人 @${maintainerId} 在其对话中执行 \`change_mind\`，并提供你已合并好的“分段全文替换稿”（禁止覆盖/抹掉他人条目）。`);
             }
-            return (0, tool_1.toolFailure)(`Error: \`change_mind\` is only available in the mainline dialog (not in sideline dialogs).\n` +
+            return (0, tool_1.toolFailure)(`Error: \`change_mind\` is only available in the Main Dialog (not in Side Dialogs).\n` +
                 `Ask the Taskdoc maintainer @${maintainerId} to run \`change_mind\` and provide a fully merged full-section replacement draft (do not overwrite/delete other contributors).`);
         }
         const selectorValue = args['selector'];

package/dist/tools/env.js

@@ -13,47 +13,20 @@ const log_1 = require("../log");
 const tool_1 = require("../tool");
 const log = (0, log_1.createLogger)('tools/env');
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const DEFAULT_ALLOWED_PREFIXES = ['MCP_', 'UX_', 'DOMINDS_TEST_'];
-const DEFAULT_ALLOWED_EXACT = ['DOMINDS_LOG_LEVEL'];
-function isAllowedEnvKey(key) {
-    if (!ENV_KEY_RE.test(key))
-        return false;
-    if (DEFAULT_ALLOWED_EXACT.includes(key))
-        return true;
-    for (const p of DEFAULT_ALLOWED_PREFIXES) {
-        if (key.startsWith(p))
-            return true;
-    }
-    return false;
-}
-function isSensitiveKeyName(key) {
-    const upper = key.toUpperCase();
-    return (upper.includes('KEY') ||
-        upper.includes('TOKEN') ||
-        upper.includes('SECRET') ||
-        upper.includes('PASSWORD'));
-}
-function redactValue(value) {
-    if (value.length <= 4)
-        return '<redacted>';
-    return `<redacted len=${value.length} prefix=${JSON.stringify(value.slice(0, 2))} suffix=${JSON.stringify(value.slice(-2))}>`;
-}
 function parseEnvGetArgs(args) {
     const key = args.key;
     if (typeof key !== 'string' || !key.trim()) {
         throw new Error(`env_get.key must be a non-empty string`);
     }
-    const revealVal = args.reveal;
-    if (revealVal !== undefined && typeof revealVal !== 'boolean') {
-        throw new Error(`env_get.reveal must be a boolean if provided`);
-    }
-    return { key, reveal: revealVal };
+    assertValidEnvKey('env_get', key);
+    return { key };
 }
 function parseEnvSetArgs(args) {
     const key = args.key;
     if (typeof key !== 'string' || !key.trim()) {
         throw new Error(`env_set.key must be a non-empty string`);
     }
+    assertValidEnvKey('env_set', key);
     const value = args.value;
     if (typeof value !== 'string') {
         throw new Error(`env_set.value must be a string`);
@@ -65,16 +38,13 @@ function parseEnvUnsetArgs(args) {
     if (typeof key !== 'string' || !key.trim()) {
         throw new Error(`env_unset.key must be a non-empty string`);
     }
+    assertValidEnvKey('env_unset', key);
     return { key };
 }
 const envGetSchema = {
     type: 'object',
     properties: {
         key: { type: 'string', description: 'Environment variable name to read' },
-        reveal: {
-            type: 'boolean',
-            description: 'When true, returns the raw value. For keys that look like secrets, default is redacted unless reveal=true.',
-        },
     },
     required: ['key'],
     additionalProperties: false,
@@ -96,12 +66,9 @@ const envUnsetSchema = {
     required: ['key'],
     additionalProperties: false,
 };
-function assertAllowedKey(key) {
-    if (!isAllowedEnvKey(key)) {
-        throw new Error(`env key '${key}' is not allowed. Allowed: ${[
-            ...DEFAULT_ALLOWED_EXACT,
-            ...DEFAULT_ALLOWED_PREFIXES.map((p) => `${p}*`),
-        ].join(', ')}`);
+function assertValidEnvKey(toolName, key) {
+    if (!ENV_KEY_RE.test(key)) {
+        throw new Error(`${toolName}.key must be a valid environment variable name matching ${ENV_KEY_RE.source}`);
     }
 }
 exports.envGetTool = {
@@ -116,7 +83,6 @@ exports.envGetTool = {
     argsValidation: 'dominds',
     call: async (_dlg, caller, args) => {
         const parsed = parseEnvGetArgs(args);
-        assertAllowedKey(parsed.key);
         const raw = process.env[parsed.key];
         const value = raw === undefined ? undefined : String(raw);
         log.debug('env_get', undefined, {
@@ -126,10 +92,6 @@ exports.envGetTool = {
         });
         if (value === undefined)
             return (0, tool_1.toolSuccess)('(unset)');
-        if (parsed.reveal === true)
-            return (0, tool_1.toolSuccess)(value);
-        if (isSensitiveKeyName(parsed.key))
-            return (0, tool_1.toolSuccess)(redactValue(value));
         return (0, tool_1.toolSuccess)(value);
     },
 };
@@ -145,7 +107,6 @@ exports.envSetTool = {
     argsValidation: 'dominds',
     call: async (_dlg, caller, args) => {
         const parsed = parseEnvSetArgs(args);
-        assertAllowedKey(parsed.key);
         const prev = process.env[parsed.key];
         process.env[parsed.key] = parsed.value;
         log.warn('env_set', undefined, {
@@ -154,12 +115,8 @@ exports.envSetTool = {
             prevSet: prev !== undefined,
             nextLen: parsed.value.length,
         });
-        const prevStr = prev === undefined
-            ? '(unset)'
-            : isSensitiveKeyName(parsed.key)
-                ? redactValue(String(prev))
-                : String(prev);
-        const nextStr = isSensitiveKeyName(parsed.key) ? redactValue(parsed.value) : parsed.value;
+        const prevStr = prev === undefined ? '(unset)' : String(prev);
+        const nextStr = parsed.value;
         return (0, tool_1.toolSuccess)(`ok: ${parsed.key}\nprev: ${prevStr}\nnext: ${nextStr}`);
     },
 };
@@ -175,7 +132,6 @@ exports.envUnsetTool = {
     argsValidation: 'dominds',
     call: async (_dlg, caller, args) => {
         const parsed = parseEnvUnsetArgs(args);
-        assertAllowedKey(parsed.key);
         const prev = process.env[parsed.key];
         delete process.env[parsed.key];
         log.warn('env_unset', undefined, {
@@ -183,11 +139,7 @@ exports.envUnsetTool = {
             key: parsed.key,
             prevSet: prev !== undefined,
         });
-        const prevStr = prev === undefined
-            ? '(unset)'
-            : isSensitiveKeyName(parsed.key)
-                ? redactValue(String(prev))
-                : String(prev);
+        const prevStr = prev === undefined ? '(unset)' : String(prev);
         return (0, tool_1.toolSuccess)(`ok: ${parsed.key}\nprev: ${prevStr}\nnext: (unset)`);
     },
 };

package/dist/tools/manual/render.js

@@ -84,6 +84,10 @@ function renderToolsetManual(input) {
         }
     }
     const sections = [];
+    const notice = meta.manualNoticeI18n?.[input.language]?.trim();
+    if (notice) {
+        sections.push(notice);
+    }
     if (missingTopics.length > 0) {
         sections.push(renderMissingTopicsWarning(input.language, input.toolsetId, missingTopics));
     }

package/dist/tools/mcp.d.ts

@@ -6,4 +6,5 @@
 import type { FuncTool, ReminderOwner } from '../tool';
 export declare const mcpRestartTool: FuncTool;
 export declare const mcpReleaseTool: FuncTool;
+export declare const mcpDisableTool: FuncTool;
 export declare const mcpLeaseReminderOwner: ReminderOwner;

package/dist/tools/mcp.js

@@ -5,7 +5,7 @@
  * Local MCP supervisor control tools for testing and operations.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mcpLeaseReminderOwner = exports.mcpReleaseTool = exports.mcpRestartTool = void 0;
+exports.mcpLeaseReminderOwner = exports.mcpDisableTool = exports.mcpReleaseTool = exports.mcpRestartTool = void 0;
 const log_1 = require("../log");
 const supervisor_1 = require("../mcp/supervisor");
 const driver_messages_1 = require("../runtime/driver-messages");
@@ -27,6 +27,13 @@ function parseMcpReleaseArgs(args) {
     }
     return { serverId };
 }
+function parseMcpDisableArgs(args) {
+    const serverId = args.serverId;
+    if (typeof serverId !== 'string' || !serverId.trim()) {
+        throw new Error(`mcp_disable.serverId must be a non-empty string`);
+    }
+    return { serverId };
+}
 function isMcpLeaseReminderMeta(value) {
     if (!isRecord(value) || Array.isArray(value))
         return false;
@@ -39,7 +46,7 @@ const mcpRestartSchema = {
     properties: {
         serverId: {
             type: 'string',
-            description: "MCP server id from `.minds/mcp.yaml` (e.g., 'sdk_stdio'). Restarts this server only.",
+            description: "MCP server id from `.minds/mcp.yaml` (e.g., 'sdk_stdio'). Enables the server if needed, then restarts this server only.",
         },
     },
     required: ['serverId'],
@@ -56,13 +63,24 @@ const mcpReleaseSchema = {
     required: ['serverId'],
     additionalProperties: false,
 };
+const mcpDisableSchema = {
+    type: 'object',
+    properties: {
+        serverId: {
+            type: 'string',
+            description: "MCP server id from `.minds/mcp.yaml` (e.g., 'playwright'). Stops any loaded runtime/leases and writes servers.<id>.enabled=false.",
+        },
+    },
+    required: ['serverId'],
+    additionalProperties: false,
+};
 exports.mcpRestartTool = {
     type: 'func',
     name: 'mcp_restart',
-    description: 'Restart a configured MCP server using the current `.minds/mcp.yaml` config (best-effort).',
+    description: 'Enable a configured MCP server if needed, then restart it using the current `.minds/mcp.yaml` config.',
     descriptionI18n: {
-        en: 'Restart a configured MCP server using the current `.minds/mcp.yaml` config (best-effort).',
-        zh: '使用当前的 `.minds/mcp.yaml` 配置重启指定的 MCP 服务器（尽力而为）。',
+        en: 'Enable a configured MCP server if needed, then restart it using the current `.minds/mcp.yaml` config.',
+        zh: '按需启用指定 MCP 服务器，然后使用当前 `.minds/mcp.yaml` 配置重启它。',
     },
     parameters: mcpRestartSchema,
     argsValidation: 'dominds',
@@ -126,6 +144,38 @@ exports.mcpReleaseTool = {
         return (0, tool_1.toolSuccess)(`ok: released ${parsed.serverId} for dialog ${dialogKey}`);
     },
 };
+exports.mcpDisableTool = {
+    type: 'func',
+    name: 'mcp_disable',
+    description: 'Disable a configured MCP server, clear its loaded runtime/leases, and persist enabled=false in `.minds/mcp.yaml`.',
+    descriptionI18n: {
+        en: 'Disable a configured MCP server, clear its loaded runtime/leases, and persist enabled=false in `.minds/mcp.yaml`.',
+        zh: '禁用指定 MCP 服务器，清理其已加载运行时/租约，并在 `.minds/mcp.yaml` 中持久写入 enabled=false。',
+    },
+    parameters: mcpDisableSchema,
+    argsValidation: 'dominds',
+    call: async (_dlg, caller, args) => {
+        const parsed = parseMcpDisableArgs(args);
+        const res = await (0, supervisor_1.requestMcpServerDisable)(parsed.serverId);
+        if (res.ok) {
+            log.info('mcp_disable', undefined, {
+                caller: caller.id,
+                serverId: parsed.serverId,
+                ok: true,
+            });
+        }
+        else {
+            log.warn('mcp_disable failed', undefined, {
+                caller: caller.id,
+                serverId: parsed.serverId,
+                ok: false,
+                errorText: res.errorText,
+            });
+            return (0, tool_1.toolFailure)(`error: ${res.errorText}`);
+        }
+        return (0, tool_1.toolSuccess)(`ok: disabled ${parsed.serverId} and set enabled=false`);
+    },
+};
 exports.mcpLeaseReminderOwner = {
     name: 'mcpLease',
     async updateReminder(dlg, reminder) {

package/dist/tools/os.js

@@ -403,7 +403,7 @@ function stripDaemonLifecyclePhaseSummary(content) {
 function getOsToolMessages(language) {
     if (language === 'zh') {
         return {
-            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一张生命周期状态卡持续刷新：系统维护 / 实时真源 / 不可删除。\n\n需要时可使用 stop_daemon({"pid": ${pid}}) 终止该进程。`,
+            daemonStarted: (pid, timeoutSeconds, command) => `🟢 ${command} 已转入后台持续运行（PID: ${pid}）\n该进程在 ${timeoutSeconds} 秒内未完成，现已作为守护进程继续执行。你将看到同一条生命周期提醒持续刷新：系统维护 / 实时真源 / 不可删除。\n\n需要时可使用 stop_daemon({"pid": ${pid}}) 终止该进程。`,
             commandCompleted: (exitCode, scrollNotice) => `✅ 命令已完成（退出码：${exitCode ?? 'unknown'}）${scrollNotice}\n\n`,
             scrolledLinesNotice: (lines) => `\n⚠️  执行期间有 ${lines} 行已滚出可视范围`,
             stdoutLabel: '📤 stdout：',
@@ -418,7 +418,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 card keep updating: system-maintained / live source of truth / not deletable.\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 / not deletable.\n\nUse stop_daemon({"pid": ${pid}}) to terminate it when needed.`,
         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:',
@@ -1171,12 +1171,12 @@ exports.shellCmdReminderOwner = {
                 type: 'environment_msg',
                 role: 'user',
                 content: language === 'zh'
-                    ? `${prefix} 后台进程生命周期状态卡 [${reminder.id}]
-这是系统维护的后台进程状态快照。把它当成环境信号，不是你自己写的工作便签。若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态，等待你确认后手动删除。
+                    ? `${prefix} 后台进程生命周期提醒 [${reminder.id}]
+当前运行环境中有一条系统维护的后台进程状态提醒。请把它当成环境信号，不要当成你自己写的工作便签。若它没有实质改变你的判断/计划/风险，则禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）；只有它实际影响后续动作时，才在下一条有实质内容的回复中体现相关事实。该提醒在进程运行期间会自动更新；进程结束后会保留终态，等待你确认后手动删除。
 ---
 ${reminder.content}`
-                    : `${prefix} Background process lifecycle card [${reminder.id}]
-This is a system-maintained background process snapshot. Treat it as an environment signal, not a self-authored work note. If it does not materially change your judgment/plan/risk, make no user-visible reply at all (do not send filler like “silently noted” or “received”); only reflect it inside the next substantive reply when it actually affects the next action. This reminder auto-updates while the process is running; after exit it keeps the terminal state until you delete it manually.
+                    : `${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. 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.
 ---
 ${reminder.content}`,
             };
@@ -1193,12 +1193,12 @@ ${reminder.content}`,
                     type: 'environment_msg',
                     role: 'user',
                     content: language === 'zh'
-                        ? `${prefix} 守护进程生命周期状态卡 [${reminder.id}] - ${exitedSummary}｜PID ${pid}
-该后台进程已退出。若需要再核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
+                        ? `${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${exitedSummary}｜PID ${pid}
+当前运行环境中 daemon 已退出。若需要再核对最后 stdout/stderr，可先按需调用 get_daemon_output({ "pid": ${pid} })；若该调用已不可用，则以下是最后一次已知快照。确认已知悉后，请手动删除这条提醒。
 ---
 ${reminder.content}`
-                        : `${prefix} Daemon lifecycle card [${reminder.id}] - ${exitedSummary} | PID ${pid}
-This daemon has exited. 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.
+                        : `${prefix} Daemon lifecycle reminder [${reminder.id}] - ${exitedSummary} | PID ${pid}
+The current runtime environment shows that this daemon has exited. 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.
 ---
 ${reminder.content}`,
                 };
@@ -1208,9 +1208,9 @@ ${reminder.content}`,
                 role: 'user',
                 content: language === 'zh'
                     ? `${prefix} 进程生命周期提醒 [${reminder.id}] - 后台进程已结束（PID ${pid}）
-该后台进程的生命周期已经结束，当前不再运行。`
+当前运行环境中该后台进程的生命周期已经结束，当前不再运行。`
                     : `${prefix} Process lifecycle reminder [${reminder.id}] - daemon terminated (PID ${pid})
-This daemon process has finished its lifecycle and is no longer running.`,
+The current runtime environment shows that this daemon process has finished its lifecycle and is no longer running.`,
             };
         }
         if (resolved.kind === 'error') {
@@ -1233,13 +1233,13 @@ This daemon process has finished its lifecycle and is no longer running.`,
             type: 'environment_msg',
             role: 'user',
             content: language === 'zh'
-                ? `🔄 ${prefix} 守护进程生命周期状态卡 [${reminder.id}] - ${runningSummary}｜PID ${pid}，已运行 ${uptimeStr}
-这是系统维护的状态快照，不是新的用户诉求，也不是默认需要单独汇报的事项。若下面的信息没有实质改变你的判断、计划、风险，且不需要调用守护进程相关工具，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
+                ? `🔄 ${prefix} 守护进程生命周期提醒 [${reminder.id}] - ${runningSummary}｜PID ${pid}，已运行 ${uptimeStr}
+当前运行环境中 daemon 仍在运行。这是系统维护的状态提醒，不是默认需要单独汇报的事项。若下面的信息没有实质改变你的判断、计划、风险，且不需要调用守护进程相关工具，则禁止做任何用户可见回应；若它有实质影响，只在下一条有实质内容的回复中体现，禁止单独发送“静默吸收”“已收到”等占位语句。
 
 **状态快照：**
 ${statusInfo}`
-                : `🔄 ${prefix} Daemon lifecycle card [${reminder.id}] - ${runningSummary} | PID ${pid}, uptime: ${uptimeStr}
-This is a system-maintained snapshot, not a new user request and not something that normally deserves a standalone mention. If the information below does not materially change your judgment, plan, risk, or require a daemon-management action, make no user-visible reply at all; if it does matter, reflect it only inside the next substantive reply instead of sending filler like “silently noted” or “received”.
+                : `🔄 ${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. 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".
 
 **State snapshot:**
 ${statusInfo}`,

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

@@ -37,12 +37,12 @@ function isPendingTellaskReminderMeta(value) {
 function getPendingTellaskUpdateAltInstruction(language) {
     return language === 'zh'
         ? '不要手改这条系统提醒。若要改变某一路诉请，只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
-        : 'Do not hand-edit this system reminder. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the responder can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient sideline and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
+        : 'Do not hand-edit this system reminder. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
 }
 function getPendingTellaskDeleteAltInstruction(language) {
     return language === 'zh'
         ? '这条系统提醒不可删除。若要改变某一路诉请，只有长线诉请（`tellask` + `sessionSlug`）才能更新那一路诉请的“任务安排”：复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。一次性诉请（`tellaskSessionless`）没有这个通道；新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不能要求旧主理人停止。其余情况等待系统按真实诉请状态自动刷新。'
-        : 'This system reminder is not deletable. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the responder can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient sideline and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
+        : 'This system reminder is not deletable. If you need to change one tellask, only a sessioned tellask (`tellask` + `sessionSlug`) can be updated in place: send another `tellask` with the same `sessionSlug` so the tellaskee can finish naturally under the latest assignment. A one-shot tellask (`tellaskSessionless`) has no such channel; another `tellaskSessionless` only creates a new transient Side Dialog and cannot tell the earlier owner to stop. Otherwise wait for system refresh from real tellask state.';
 }
 function callKindLabel(language, view) {
     if (view.callType === 'A') {
@@ -52,9 +52,7 @@ function callKindLabel(language, view) {
 }
 function pendingTargetLabel(language, view) {
     if (view.callType === 'A') {
-        return language === 'zh'
-            ? `上游诉请者 @${view.targetAgentId}`
-            : `upstream requester @${view.targetAgentId}`;
+        return language === 'zh' ? `诉请者 @${view.targetAgentId}` : `tellasker @${view.targetAgentId}`;
     }
     switch (view.callName) {
         case 'freshBootsReasoning':
@@ -76,7 +74,14 @@ function summarizeTellask(view) {
 }
 function makePendingSignature(pending) {
     return pending
-        .map((p) => [p.subdialogId, p.targetAgentId, p.callType, p.sessionSlug ?? '', summarizeTellask(p)].join('|'))
+        .map((p) => [
+        p.sideDialogId,
+        p.targetAgentId,
+        p.callType,
+        p.callId,
+        p.sessionSlug ?? '',
+        summarizeTellask(p),
+    ].join('|'))
         .sort()
         .join('||');
 }
@@ -117,7 +122,7 @@ function buildReminderContent(language, pending) {
     }
     const summary = language === 'zh'
         ? '以下诉请仍在执行中；除这些条目外，当前没有其它仍在执行中的诉请。该提醒项只是系统状态窗，不是控制面：自动维护、不可手改，且在非 0 路进行中时不可删除。只有长线诉请（`tellask` + `sessionSlug`）才能更新“任务安排”；一次性诉请（`tellaskSessionless`）没有这个通道。新开一个 `tellaskSessionless` 只会再创建新的瞬态支线，不会影响旧支线继续执行，更不能要求旧主理人停止。若某一路长线诉请的要求变化，才可复用同一 `sessionSlug` 再发 `tellask`，让对应主理人按最新安排自行最终回复并自然结束。误删会被拒绝，并返回同样的引导文案。'
-        : '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. Only a sessioned tellask (`tellask` + `sessionSlug`) has an assignment-update channel; a one-shot tellask (`tellaskSessionless`) does not. Opening another `tellaskSessionless` only creates another transient sideline; it does not affect the earlier one and cannot tell the earlier owner to stop. If a sessioned tellask needs to change, reuse the same `sessionSlug` in another `tellask` so the responder can finish naturally under the latest assignment. 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: auto-maintained, not hand-editable, and non-deletable while any tellask is still active. Only a sessioned tellask (`tellask` + `sessionSlug`) has an assignment-update channel; a one-shot tellask (`tellaskSessionless`) does not. Opening another `tellaskSessionless` only creates another transient Side Dialog; it does not affect the earlier one and cannot tell the earlier owner to stop. If a sessioned tellask needs to change, reuse the same `sessionSlug` in another `tellask` so the tellaskee can finish naturally under the latest assignment. Mistaken deletion will be rejected with the same guidance.';
     const lines = pending.map((p, idx) => {
         const base = language === 'zh'
             ? `${idx + 1}. ${pendingTargetLabel(language, p)} | ${callKindLabel(language, p)} | ${summarizeTellask(p)}`
@@ -148,17 +153,18 @@ function assertSingleOwnedReminder(dlg) {
         return indices[0] ?? null;
     throw new Error(`pendingTellask reminder invariant violated: expected <=1 owner reminder, got ${indices.length} (dialog=${dlg.id.valueOf()})`);
 }
-async function loadPendingSubdialogView(dlg) {
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(dlg.id, dlg.status);
+async function loadPendingSideDialogView(dlg) {
+    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(dlg.id, dlg.status);
     return await Promise.all(pending.map(async (p) => {
-        const subdialogId = new dialog_1.DialogID(p.subdialogId, dlg.id.rootId);
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(subdialogId, dlg.status);
+        const sideDialogId = new dialog_1.DialogID(p.sideDialogId, dlg.id.rootId);
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(sideDialogId, dlg.status);
         return {
-            subdialogId: p.subdialogId,
+            sideDialogId: p.sideDialogId,
             latestActivityAt: latest?.lastModified ?? p.createdAt,
             mentionList: p.mentionList,
             tellaskContent: p.tellaskContent,
             targetAgentId: p.targetAgentId,
+            callId: p.callId,
             callType: p.callType,
             callName: p.callName,
             sessionSlug: p.sessionSlug,
@@ -172,7 +178,7 @@ async function withDialogLockIfNeeded(dlg, fn) {
     return await dlg.withLock(fn);
 }
 async function syncPendingTellaskReminderState(dlg) {
-    const pending = await loadPendingSubdialogView(dlg);
+    const pending = await loadPendingSideDialogView(dlg);
     return await withDialogLockIfNeeded(dlg, async () => {
         const reminderIndex = assertSingleOwnedReminder(dlg);
         const language = (0, work_language_1.getWorkLanguage)();
@@ -210,7 +216,7 @@ exports.pendingTellaskReminderOwner = {
         if (reminder.owner !== exports.pendingTellaskReminderOwner) {
             return { treatment: 'keep' };
         }
-        const pending = await loadPendingSubdialogView(dlg);
+        const pending = await loadPendingSideDialogView(dlg);
         const language = (0, work_language_1.getWorkLanguage)();
         const updatedContent = buildReminderContent(language, pending);
         const currentMeta = isPendingTellaskReminderMeta(reminder.meta) ? reminder.meta : undefined;

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

@@ -29,7 +29,7 @@ control is Dominds' **dialog control toolset** for managing dialog state, remind
 - **Reminder management**: Two reminder scopes. Default to dialog-local working set; use `personal` only for responsibility-linked notes that you should keep seeing in all later dialogs you lead
 - **Taskdoc operations**: Update task contracts (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 `tellaskBack`, `replyTellask*`, and plain text by responsibility in sideline / ask-back flows
+- **Reply routing**: Separate `tellaskBack`, `replyTellask*`, and plain text by responsibility in Side Dialog / ask-back flows
 
 ## Quick Navigation
 

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

@@ -46,7 +46,7 @@ Default to `dialog`. Use `personal` only when you should keep seeing that note i
 | Feature | dialog reminder | personal reminder | personal memory |
 |---------|-----------------|-------------------|-----------------|
 | Persistence | Current dialog only | Across all later dialogs you lead | Long-term / file-backed |
-| Visibility | Current dialog | Current responder agent | Current agent |
+| Visibility | Current dialog | Current Dialog Responder | Current agent |
 | Best for | Current next step, blocker, volatile clue | Responsibility-linked operating cue | Stable facts / reusable knowledge |
 
 ### 1.1 Scope Choice Rule
@@ -92,21 +92,21 @@ Taskdoc is a **task contract** and the task's **team-shared source of current tr
 
 ### Decision Rules
 
-- If the current sideline is unfinished, first judge whether team SOP / role ownership already identifies the responsible owner; if yes and the issue is execution work, directly use `tellask` / `tellaskSessionless` for that owner
-- Call `tellaskBack({ tellaskContent })` only when upstream must clarify the request, decide a tradeoff, confirm acceptance criteria, provide missing input, or current SOP cannot determine ownership
+- If the current Side Dialog is unfinished, first judge whether team SOP / role ownership already identifies the responsible owner; if yes and the issue is execution work, directly use `tellask` / `tellaskSessionless` for that owner
+- Call `tellaskBack({ tellaskContent })` only when the tellasker must clarify the request, decide a tradeoff, confirm acceptance criteria, provide missing input, or current SOP cannot determine ownership
 - If a human must personally perform login / GUI / captcha / high-risk authorization: call `askHuman({ tellaskContent })`
-- If the current sideline is complete and the assignment header says `replyTellask`: call `replyTellask({ replyContent })`
-- If the current sideline is complete and the assignment header says `replyTellaskSessionless`: call `replyTellaskSessionless({ replyContent })`
-- If you are answering an upstream `tellaskBack` follow-up and runtime exposes `replyTellaskBack`: call `replyTellaskBack({ replyContent })`
+- If the current Side Dialog is complete and the assignment header says `replyTellask`: call `replyTellask({ replyContent })`
+- If the current Side Dialog is complete and the assignment header says `replyTellaskSessionless`: call `replyTellaskSessionless({ replyContent })`
+- If you are answering a tellasker `tellaskBack` follow-up and runtime exposes `replyTellaskBack`: call `replyTellaskBack({ replyContent })`
 - Plain text is not the normal completion channel for inter-dialog delivery; if you emit plain text instead of the reply tool, runtime may temporarily inject a `role=user` reminder telling you to use the correct reply function
 
 ### Low-Burden Rule
 
-- Focus on doing the current task correctly first; use `reply*` only when final upstream delivery is actually ready
+- Focus on doing the current task correctly first; use `reply*` only when final tellasker delivery is actually ready
 - Do not memorize reply variants by yourself; follow the current assignment header and the function currently exposed by runtime
 - `reply*` tool descriptions are intentionally minimal and spec-like; use this manual's principles / scenarios for situational guidance
 - If runtime exposes only one `reply*`, that is the only correct completion path for the current state
-- `tellaskBack` is the fallback when ownership cannot be determined from existing SOP, or when upstream must answer; it is not the default first move for every blocked state
+- `tellaskBack` is valid only when ownership cannot be determined from existing SOP, or when the tellasker must answer; it is not the default first move for every blocked state
 
 ## Best Practices