dominds 1.26.1 → 1.26.3

package/README.md

@@ -257,6 +257,8 @@ Platform note:
 
 Dominds always keeps an HTTP listener. When a valid certificate matching the current `--host` exists under `~/.dominds/certs/`, Dominds also starts HTTPS. Certificates match DNS/IP hostnames, not ports, so one certificate covers all Dominds WebUI ports on that host.
 
+Dominds generates certificates through npm dependencies, so no separate `openssl` command is required.
+
 ```bash
 # Create a 10-year self-signed certificate for detected non-loopback LAN hosts
 dominds cert create

package/README.zh.md

@@ -196,6 +196,8 @@ dominds
 
 Dominds 默认始终提供 HTTP 监听；当 `~/.dominds/certs/` 下存在匹配当前 `--host` 的有效证书时，会额外启用 HTTPS。证书按 DNS/IP 主机名匹配，不绑定端口，因此同一张证书可覆盖该主机上的所有 Dominds WebUI 端口。
 
+证书由 Dominds 通过 npm 依赖生成，无需额外安装 `openssl` 等系统命令。
+
 ```bash
 # 自动为检测到的一个或多个非 loopback LAN 主机创建 10 年有效的自签名证书
 dominds cert create

package/dist/cli/webui.js

@@ -164,17 +164,19 @@ async function main(args = process.argv.slice(2)) {
             host: started.urlHost,
             port: started.port,
         })}`);
+        let httpsEndpoint;
         if (started.httpsPort !== undefined && started.httpsUrlHost !== undefined) {
+            httpsEndpoint = { host: started.httpsUrlHost, port: started.httpsPort };
             const httpsBaseUrl = (0, auth_1.formatServerOrigin)({
                 scheme: 'https',
-                host: started.httpsUrlHost,
-                port: started.httpsPort,
+                host: httpsEndpoint.host,
+                port: httpsEndpoint.port,
             });
             log.info(`HTTPS WebUI ready: ${httpsBaseUrl}`);
             log.debug(`HTTPS WebSocket endpoint: ${formatWebSocketEndpoint({
                 scheme: 'wss',
-                host: started.httpsUrlHost,
-                port: started.httpsPort,
+                host: httpsEndpoint.host,
+                port: httpsEndpoint.port,
             })}`);
         }
         if (auth.kind === 'enabled') {
@@ -185,6 +187,14 @@ async function main(args = process.argv.slice(2)) {
                 authKey: auth.key,
             });
             log.info(`auto auth url (sensitive): ${autoAuthUrl}`);
+            if (httpsEndpoint !== undefined) {
+                log.info(`HTTPS auto auth url (sensitive): ${(0, auth_1.formatAutoAuthUrl)({
+                    scheme: 'https',
+                    host: httpsEndpoint.host,
+                    port: httpsEndpoint.port,
+                    authKey: auth.key,
+                })}`);
+            }
             if (shouldOpen) {
                 log.debug(`Opening browser: ${autoAuthUrl}`);
                 openInBrowser(autoAuthUrl);

package/dist/docs/cli-usage.md

@@ -153,7 +153,7 @@ dominds cert create [--host <host>] [--days <days>] [--force]
 dominds cert status [--host <host>] [--port <port>] [--origin]
 ```
 
-Create or inspect local HTTPS certificates for the Dominds WebUI. Certificates live in `~/.dominds/certs/` and match DNS/IP hostnames, not ports; one certificate covers every WebUI port on that host.
+Create or inspect local HTTPS certificates for the Dominds WebUI. Dominds generates certificates through npm dependencies, so no separate `openssl` command is required. Certificates live in `~/.dominds/certs/` and match DNS/IP hostnames, not ports; one certificate covers every WebUI port on that host.
 
 **Options:**
 

package/dist/docs/cli-usage.zh.md

@@ -160,7 +160,7 @@ dominds cert create [--host <host>] [--days <days>] [--force]
 dominds cert status [--host <host>] [--port <port>] [--origin]
 ```
 
-创建或检查 Dominds WebUI 的本机 HTTPS 证书。证书保存在 `~/.dominds/certs/`，按 DNS/IP 主机名匹配，不绑定端口；同一张证书可覆盖该主机上的所有 WebUI 端口。
+创建或检查 Dominds WebUI 的本机 HTTPS 证书。证书由 Dominds 通过 npm 依赖生成，无需额外安装 `openssl` 等系统命令。证书保存在 `~/.dominds/certs/`，按 DNS/IP 主机名匹配，不绑定端口；同一张证书可覆盖该主机上的所有 WebUI 端口。
 
 **选项：**
 

package/dist/llm/gen/mock.js

@@ -326,9 +326,17 @@ class MockGen {
             if (trimmed !== '') {
                 variants.add(trimmed.toLowerCase());
             }
-            const tellaskStatusIndexZh = trimmed.lastIndexOf('\n[Dominds 诉请状态]\n');
-            const tellaskStatusIndexEn = trimmed.lastIndexOf('\n[Dominds tellask status]\n');
-            const tellaskStatusIndex = Math.max(tellaskStatusIndexZh, tellaskStatusIndexEn);
+            const tellaskStatusPrefixes = [
+                '\n[Dominds 诉请状态]\n',
+                '\n[Dominds tellask status]\n',
+                '\n[Dominds 等待人类回复]\n',
+                '\n[Dominds waiting for human answer]\n',
+                '\n[Dominds 等待队友回贴]\n',
+                '\n[Dominds waiting for teammate reply]\n',
+                '\n[Dominds 队友回贴状态]\n',
+                '\n[Dominds teammate reply status]\n',
+            ];
+            const tellaskStatusIndex = Math.max(...tellaskStatusPrefixes.map((prefix) => trimmed.lastIndexOf(prefix)));
             if (tellaskStatusIndex >= 0) {
                 const strippedTellaskStatus = trimmed.slice(0, tellaskStatusIndex).trim();
                 if (strippedTellaskStatus !== '') {

package/dist/llm/kernel-driver/context-health.d.ts

@@ -7,6 +7,7 @@ export type KernelDriverContextHealthDecision = Readonly<{
 }>;
 export declare const KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 export declare const KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
+export declare function getContextHealthRemediationLevel(snapshot: ContextHealthSnapshot | undefined): 'caution' | 'critical' | undefined;
 export declare function resetContextHealthRoundState(dialogKey: string): void;
 export declare function resolveCriticalCountdownRemaining(dialogKey: string, snapshot: ContextHealthSnapshot | undefined): number;
 export declare function consumeCriticalCountdown(dialogKey: string): number;

package/dist/llm/kernel-driver/context-health.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = exports.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = void 0;
+exports.getContextHealthRemediationLevel = getContextHealthRemediationLevel;
 exports.resetContextHealthRoundState = resetContextHealthRoundState;
 exports.resolveCriticalCountdownRemaining = resolveCriticalCountdownRemaining;
 exports.consumeCriticalCountdown = consumeCriticalCountdown;
@@ -9,6 +10,12 @@ exports.decideKernelDriverContextHealth = decideKernelDriverContextHealth;
 exports.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 exports.KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
 const stateByDialogKey = new Map();
+function getContextHealthRemediationLevel(snapshot) {
+    if (snapshot?.kind !== 'available') {
+        return undefined;
+    }
+    return snapshot.level === 'caution' || snapshot.level === 'critical' ? snapshot.level : undefined;
+}
 function getOrCreateState(dialogKey) {
     const existing = stateByDialogKey.get(dialogKey);
     if (existing)

package/dist/llm/kernel-driver/drive.js

@@ -34,6 +34,7 @@ const context_health_1 = require("./context-health");
 const events_1 = require("./events");
 const fbr_1 = require("./fbr");
 const guardrails_1 = require("./guardrails");
+const reminder_context_1 = require("./reminder-context");
 const reply_guidance_1 = require("./reply-guidance");
 const runtime_1 = require("./runtime");
 const tellask_special_1 = require("./tellask-special");
@@ -254,31 +255,29 @@ function isUserOriginPrompt(prompt) {
         return false;
     return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined;
 }
-function resolveReminderContextFollowingDialogState(prompt, currentTurnDialogMsgsForContext) {
-    if (prompt === undefined || currentTurnDialogMsgsForContext.length === 0)
-        return 'none';
-    return prompt.origin === 'user' ? 'user_message' : 'runtime_notice';
-}
-function resolveReminderContextHealthState(snapshot) {
-    const remediationLevel = getContextHealthRemediationLevel(snapshot);
-    return remediationLevel === undefined ? 'normal' : remediationLevel;
-}
 async function resolveReminderContextFooterState(args) {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dlg.id, args.dlg.status);
     const deferredReplyReassertion = latest?.deferredReplyReassertion;
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dlg.id, args.dlg.status);
     const pendingUserInterjectionReply = latest?.pendingUserInterjectionReply !== undefined;
-    const interDialogReplyObligation = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task'
-        ? 'parked_by_user_interjection'
-        : activeReplyObligation !== undefined
-            ? 'active'
-            : 'none';
-    return {
-        followingDialogState: resolveReminderContextFollowingDialogState(args.prompt, args.currentTurnDialogMsgsForContext),
+    const hasDeferredReplyReassertion = deferredReplyReassertion?.reason === 'user_interjection_with_parked_original_task';
+    const hasActiveReplyObligation = activeReplyObligation !== undefined;
+    // Business scenario: a user can reopen a completed Side Dialog to ask a follow-up. A recorded
+    // final response with no active/parked reply task means the old handoff has already been
+    // reported back; if a real user message is now present, the footer should say "talk with the
+    // user now" instead of making the model infer that from old transcript/reminder context.
+    const hasCompletedHandoffWithoutPendingReply = latest?.sideDialogFinalResponse !== undefined &&
+        !hasDeferredReplyReassertion &&
+        !hasActiveReplyObligation;
+    return (0, reminder_context_1.resolveReminderContextFooterStateFromSignals)({
+        prompt: args.prompt,
+        currentTurnDialogMsgsForContext: args.currentTurnDialogMsgsForContext,
+        contextHealth: args.dlg.getLastContextHealth(),
         pendingUserInterjectionReply,
-        interDialogReplyObligation,
-        contextHealthState: resolveReminderContextHealthState(args.dlg.getLastContextHealth()),
-    };
+        hasCompletedHandoffWithoutPendingReply,
+        hasDeferredReplyReassertion,
+        hasActiveReplyObligation,
+    });
 }
 function splitDialogMsgsForReminderInsertion(args) {
     const msgId = args.currentPrompt?.msgId;
@@ -722,12 +721,6 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
 const CONTEXT_HEALTH_TOOL_RESULT_VISIBLE_BYTE_LIMIT = 2000;
 const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_ZH = '这次函数返回内容太大，清理头脑之前不会显示给你。';
 const CONTEXT_HEALTH_LARGE_TOOL_RETURN_UNAVAILABLE_EN = 'This function returned too much content. It will not be shown to you before you clear your mind.';
-function getContextHealthRemediationLevel(snapshot) {
-    if (snapshot?.kind !== 'available') {
-        return undefined;
-    }
-    return snapshot.level === 'caution' || snapshot.level === 'critical' ? snapshot.level : undefined;
-}
 function pickContextHealthForLargeToolResultVisibility(args) {
     if (args.current?.kind === 'available') {
         return args.current;
@@ -809,7 +802,7 @@ function countToolResultVisibleBytes(output) {
     return bytes;
 }
 function applyContextHealthToolResultVisibilityLimit(args) {
-    if (getContextHealthRemediationLevel(args.contextHealth) === undefined) {
+    if ((0, context_health_1.getContextHealthRemediationLevel)(args.contextHealth) === undefined) {
         return { output: args.output, largeReturnUnavailable: false };
     }
     const visibleBytes = countToolResultVisibleBytes(args.output);
@@ -1336,7 +1329,7 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
     const indexLine = call.toolCallIndex === undefined ? undefined : `- toolCallIndex: ${String(call.toolCallIndex)}`;
     if (language === 'en') {
         return [
-            '[Runtime notice] The previous model output contained an invalid tool-call payload that could not be represented as a normal provider tool call in the next generation context.',
+            '[Runtime notice] Your previous response tried to call a tool, but the tool call was malformed and could not be run.',
             '',
             `- provider: ${call.provider}`,
             `- callId: ${call.callId}`,
@@ -1348,13 +1341,13 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
             '```',
             ...(indexLine === undefined ? [] : [indexLine]),
             '',
-            'Treat that payload as failed. Do not assume the tool ran. Continue from the current task, and if a tool call is still needed, emit a new valid tool call with a non-empty function name and valid arguments.',
+            'Treat that tool call as failed. Do not assume the tool ran. Continue the current task; if you still need a tool, call it again with a real tool name and valid arguments.',
         ]
             .filter((line) => line.length > 0)
             .join('\n');
     }
     return [
-        '[运行时提示] 上一轮模型输出包含一个无效工具调用载荷，无法按正常 provider tool call 形态进入下一轮生成上下文。',
+        '[Dominds 提示] 你上一轮尝试调用工具，但工具调用格式无效，Dominds 没有执行它。',
         '',
         `- provider: ${call.provider}`,
         `- callId: ${call.callId}`,
@@ -1366,7 +1359,7 @@ function formatInvalidFuncCallRuntimeGuide(language, call) {
         '```',
         ...(indexLine === undefined ? [] : [indexLine]),
         '',
-        '请把该载荷视为调用失败，不要假设工具已经执行。继续当前任务；如果仍需要调用工具，请重新发起一个函数名非空、参数有效的新工具调用。',
+        '请把这次工具调用视为失败，不要假设工具已经执行。继续当前任务；如果仍需要工具，请重新发起一次工具名明确、参数有效的调用。',
     ]
         .filter((line) => line.length > 0)
         .join('\n');

package/dist/llm/kernel-driver/idle-reminder-wake.js

@@ -89,15 +89,19 @@ function buildAggregatedWakePromptContent(events) {
         return `${String(index + 1)}. ${eventText}`;
     })
         .join('\n\n');
+    // Business scenario: several reminder/environment wakes arrived while the dialog was idle.
+    // The model needs the events as state updates, but they are not a new human request and should
+    // not trigger a standalone acknowledgement. Say the product meaning plainly instead of exposing
+    // internal "runtime event" wording.
     return language === 'zh'
         ? `${prefix}
-以下是对话空闲期间发生的 runtime 环境事件。这些事件不是新的用户指令。
+以下是对话空闲期间 Dominds 收到的环境事件。这些事件不是新的用户指令。
 
 ${body}
 
 请结合当前任务上下文继续推进；若这些事件不影响当前工作，不要发送占位式确认。`
         : `${prefix}
-The following runtime environment events happened while the dialog was idle. These events are not new user instructions.
+The following environment events reached Dominds while the dialog was idle. These events are not new user instructions.
 
 ${body}
 

package/dist/llm/kernel-driver/reminder-context.d.ts

@@ -0,0 +1,25 @@
+import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
+import type { ReminderContextBusiness, ReminderContextFollowingMessage, ReminderContextFooterState, ReminderContextHealth } from '../../runtime/driver-messages';
+import type { ChatMessage } from '../client';
+import type { KernelDriverPrompt } from './types';
+export declare function resolveReminderContextFollowingMessage(args: {
+    prompt: KernelDriverPrompt | undefined;
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
+}): ReminderContextFollowingMessage;
+export declare function resolveReminderContextHealth(snapshot: ContextHealthSnapshot | undefined): ReminderContextHealth;
+export declare function resolveReminderContextBusinessState(args: {
+    followingMessage: ReminderContextFollowingMessage;
+    pendingUserInterjectionReply: boolean;
+    hasCompletedHandoffWithoutPendingReply: boolean;
+    hasDeferredReplyReassertion: boolean;
+    hasActiveReplyObligation: boolean;
+}): ReminderContextBusiness;
+export declare function resolveReminderContextFooterStateFromSignals(args: {
+    prompt: KernelDriverPrompt | undefined;
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
+    contextHealth: ContextHealthSnapshot | undefined;
+    pendingUserInterjectionReply: boolean;
+    hasCompletedHandoffWithoutPendingReply: boolean;
+    hasDeferredReplyReassertion: boolean;
+    hasActiveReplyObligation: boolean;
+}): ReminderContextFooterState;

package/dist/llm/kernel-driver/reminder-context.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveReminderContextFollowingMessage = resolveReminderContextFollowingMessage;
+exports.resolveReminderContextHealth = resolveReminderContextHealth;
+exports.resolveReminderContextBusinessState = resolveReminderContextBusinessState;
+exports.resolveReminderContextFooterStateFromSignals = resolveReminderContextFooterStateFromSignals;
+const context_health_1 = require("./context-health");
+function resolveReminderContextFollowingMessage(args) {
+    if (args.prompt === undefined || args.currentTurnDialogMsgsForContext.length === 0) {
+        return { kind: 'none' };
+    }
+    if (args.prompt.origin !== 'user') {
+        return { kind: 'runtime_notice' };
+    }
+    return typeof args.prompt.q4hAnswerCallId === 'string' &&
+        args.prompt.q4hAnswerCallId.trim() !== ''
+        ? { kind: 'human_answer' }
+        : { kind: 'user_message' };
+}
+function resolveReminderContextHealth(snapshot) {
+    const remediationLevel = (0, context_health_1.getContextHealthRemediationLevel)(snapshot);
+    return remediationLevel === undefined ? { kind: 'normal' } : { kind: remediationLevel };
+}
+function resolveReminderContextBusinessState(args) {
+    if (args.followingMessage.kind === 'human_answer') {
+        // askHuman answers resume a waiting task. They are not fresh user follow-ups and should not
+        // inherit interjection or completed-handoff wording from adjacent durable state.
+        return { kind: 'none' };
+    }
+    if (args.followingMessage.kind === 'user_message' &&
+        args.hasCompletedHandoffWithoutPendingReply) {
+        // Business scenario: the requester-side work has already received its final report, and now a
+        // user is speaking again inside that completed Side Dialog. Dominds can know this from durable
+        // handoff state; the model should hear the simple product meaning directly instead of guessing
+        // from older task context or reminder-maintenance references.
+        return { kind: 'user_followup_after_completed_handoff' };
+    }
+    if (args.pendingUserInterjectionReply) {
+        // User-visible reply gaps take priority over handoff continuation state. The completed
+        // handoff case is most specific: Dominds already knows the old delegated task is done. The
+        // footer should say there is no old handoff to advance and the model should handle the current
+        // user message normally. Do not narrow this to "only answer" or "do not organize reminders":
+        // a user may explicitly ask for reminder cleanup/correction as the current conversation topic.
+        //
+        // This branch may run on a later tool-followup turn where no user message immediately
+        // follows the reminder block anymore. That is still the same pending user follow-up; do not
+        // demote it to generic auto-continuation wording just because the prompt itself is absent
+        // on this retry/continuation round.
+        if (args.hasCompletedHandoffWithoutPendingReply) {
+            return { kind: 'user_followup_after_completed_handoff' };
+        }
+        if (args.hasDeferredReplyReassertion) {
+            return { kind: 'pending_user_interjection_with_parked_reply' };
+        }
+        if (args.hasActiveReplyObligation) {
+            return { kind: 'pending_user_interjection_with_active_reply' };
+        }
+        return { kind: 'pending_user_interjection' };
+    }
+    if (args.hasActiveReplyObligation) {
+        return { kind: 'active_reply_obligation' };
+    }
+    return { kind: 'none' };
+}
+function resolveReminderContextFooterStateFromSignals(args) {
+    const followingMessage = resolveReminderContextFollowingMessage({
+        prompt: args.prompt,
+        currentTurnDialogMsgsForContext: args.currentTurnDialogMsgsForContext,
+    });
+    return {
+        followingMessage,
+        contextHealth: resolveReminderContextHealth(args.contextHealth),
+        business: resolveReminderContextBusinessState({
+            followingMessage,
+            pendingUserInterjectionReply: args.pendingUserInterjectionReply,
+            hasCompletedHandoffWithoutPendingReply: args.hasCompletedHandoffWithoutPendingReply,
+            hasDeferredReplyReassertion: args.hasDeferredReplyReassertion,
+            hasActiveReplyObligation: args.hasActiveReplyObligation,
+        }),
+    };
+}

package/dist/llm/kernel-driver/reply-guidance.js

@@ -38,6 +38,12 @@ function buildPromptContentWithExactReplyToolName(args) {
     ];
     const directive = args.activeReplyDirective;
     if (!directive) {
+        // Business scenario: a user can come back to a Side Dialog after its final reply has already
+        // been delivered to the requester. At that point the business obligation is complete and the
+        // visible user is simply asking a follow-up in this dialog. Old assignment text and reply tool
+        // names remain in transcript history, so the model may otherwise "finish" the old request
+        // again. Dominds has already checked durable reply state here; the prompt says the current
+        // business expectation directly: answer/continue this conversation normally.
         if (isFbrSideDialog) {
             return args.prompt.content;
         }
@@ -50,13 +56,13 @@ function buildPromptContentWithExactReplyToolName(args) {
         const note = args.language === 'zh'
             ? [
                 noActivePrefix,
-                '当前没有待完成的跨对话回复义务。',
-                '这轮不要调用任何 `reply*`；直接按当前本地对话继续即可。',
+                'Dominds 已经判断好：当前没有别的对话在等你发送最终回贴。',
+                '本轮按当前对话正常交流即可；如果用户提出了问题，就直接回答这个问题。',
             ].join('\n')
             : [
                 noActivePrefix,
-                'There is no active inter-dialog reply obligation right now.',
-                'Do not call any `reply*` tool in this turn; just continue the current local conversation.',
+                'Dominds has already decided that no other dialog is waiting for your final reply right now.',
+                'Handle this as a normal turn in the current conversation; if the user asked a question, answer that question directly.',
             ].join('\n');
         return `${note}\n\n${args.prompt.content}`;
     }

package/dist/llm/kernel-driver/tellask-special.js

@@ -40,7 +40,7 @@ const TELLASK_SPECIAL_FUNCTION_NAMES = [
     'freshBootsReasoning',
 ];
 const MULTIPLE_ASKHUMAN_CALLS_ERROR = '不允许一轮多次调用 askHuman，必须单次调用问所有问题。 Do not call askHuman multiple times in one round; ask all questions in a single askHuman call.';
-const MULTIPLE_REPLY_TELLASK_CALLS_ERROR = '不允许一轮多次调用 replyTellask*，必须只用当前诉请要求的唯一 reply special 完成交付。 Do not call multiple replyTellask* functions in one round; deliver with exactly one reply special required by the current tellask.';
+const MULTIPLE_REPLY_TELLASK_CALLS_ERROR = '不允许一轮多次调用回复工具；只能用当前诉请要求的那个回复工具发送最终结果。 Do not call multiple reply tools in one round; send the final result with the one reply tool required by the current tellask.';
 function isTellaskCallFunctionName(name) {
     return TELLASK_SPECIAL_FUNCTION_NAMES.includes(name);
 }
@@ -63,6 +63,11 @@ function formatReplyFuncResult(args) {
         ? `已通过 \`${args.replyCallName}\` 送达回复。`
         : `Reply delivered via \`${args.replyCallName}\`.`;
 }
+// Business scenario: the model called a reply tool when Dominds durable state says either "wrong
+// reply path" or "nothing is waiting for this reply anymore". These are programmatic facts from the
+// active reply record, not something the model should infer from transcript history. Keep the
+// tool result actionable: name the exact tool to use, or tell the model to stop trying to send a
+// reply and continue the current local conversation.
 function formatReplyFuncErrorResult(args) {
     const language = (0, work_language_1.getWorkLanguage)();
     if (language === 'zh') {
@@ -74,11 +79,11 @@ function formatReplyFuncErrorResult(args) {
                 return (`错误：当前精确应调用 \`${args.expectedCallName}\`，而不是 \`${args.attemptedCallName}\`。\n\n` +
                     `请改用 \`${args.expectedCallName}({ replyContent })\`。`);
             case 'no_active':
-                return (`错误：当前没有待完成的跨对话回复义务。\n\n` +
-                    `不要调用 \`${args.attemptedCallName}\`；请直接继续当前本地对话。`);
+                return (`错误：当前没有别的对话在等你发送最终回贴。\n\n` +
+                    `你刚才调用的 \`${args.attemptedCallName}\` 这次不会送达给别的对话。请按当前对话正常交流；如果用户提出了问题，就直接回答这个问题。`);
             case 'no_pending':
-                return (`错误：当前已没有待本对话送达的跨对话回复义务（可能已回复或已失效）。\n\n` +
-                    `不要再次调用 \`${args.attemptedCallName}\`；请直接继续当前本地对话。`);
+                return (`错误：这条回贴任务已经不再等待本对话送达（可能已回复或已失效）。\n\n` +
+                    `你刚才调用的 \`${args.attemptedCallName}\` 这次不会送达给别的对话。请按当前对话正常交流；如果用户提出了问题，就直接回答这个问题。`);
         }
     }
     switch (args.reason) {
@@ -89,11 +94,11 @@ function formatReplyFuncErrorResult(args) {
             return (`Error: the exact reply tool for the current state is \`${args.expectedCallName}\`, not \`${args.attemptedCallName}\`.\n\n` +
                 `Call \`${args.expectedCallName}({ replyContent })\` instead.`);
         case 'no_active':
-            return ('Error: there is no active inter-dialog reply obligation right now.\n\n' +
-                `Do not call \`${args.attemptedCallName}\`; continue the current local conversation instead.`);
+            return ('Error: no other dialog is waiting for your final reply right now.\n\n' +
+                `Your \`${args.attemptedCallName}\` call will not deliver anything to another dialog this time. Handle this as a normal turn in the current conversation; if the user asked a question, answer that question directly.`);
         case 'no_pending':
-            return ('Error: there is no longer a pending inter-dialog reply obligation for this dialog (it may already be resolved or no longer valid).\n\n' +
-                `Do not call \`${args.attemptedCallName}\` again; continue the current local conversation instead.`);
+            return ('Error: this reply task is no longer waiting for delivery from this dialog; it may already be resolved or no longer valid.\n\n' +
+                `Your \`${args.attemptedCallName}\` call will not deliver anything to another dialog this time. Handle this as a normal turn in the current conversation; if the user asked a question, answer that question directly.`);
     }
 }
 function buildAssignmentReplyDirective(args) {
@@ -554,49 +559,54 @@ function formatPendingTellaskFuncResultContent(name, startedAtMs, callId) {
         const elapsedSec = Math.floor(elapsedMs / 1000);
         return language === 'zh' ? `${elapsedSec} 秒` : `${elapsedSec}s`;
     })();
+    // Business scenario: a tool call has been accepted and dispatched, but no answer has arrived
+    // yet. This tool result is a waiting status, not the teammate/human answer body. If the copy
+    // exposes only call IDs and "tellask status", models often treat it as a result and continue
+    // with invented content. Say plainly who we are waiting for and that Dominds will add the real
+    // answer later.
     if (name === 'askHuman') {
         return language === 'zh'
             ? [
-                '[Dominds 诉请状态]',
+                '[Dominds 等待人类回复]',
                 '',
-                '`askHuman` 诉请已发出，当前仍在等待人类回复。',
+                '你已经向人类提问，当前仍在等待回答。',
                 '',
                 ...(callId ? [`- callId: ${callId}`] : []),
                 `- 已等待: ${elapsed}`,
                 '',
-                '这不是回贴内容。若后续收到回复，运行时会在后续上下文中用同一 callId 补入对应回复事实。',
+                '这不是回答正文。若人类稍后回复，Dominds 会把对应结果补入后续上下文。',
             ].join('\n')
             : [
-                '[Dominds tellask status]',
+                '[Dominds waiting for human answer]',
                 '',
-                '`askHuman` has been issued and is still waiting for human reply.',
+                'You already asked the human and are still waiting for their answer.',
                 '',
                 ...(callId ? [`- callId: ${callId}`] : []),
                 `- Elapsed: ${elapsed}`,
                 '',
-                'This is not reply content. If a reply arrives later, runtime will append the corresponding reply fact in later context with the same callId.',
+                'This is not the answer body. If the human replies later, Dominds will add the result to later context.',
             ].join('\n');
     }
     return language === 'zh'
         ? [
-            '[Dominds 诉请状态]',
+            '[Dominds 等待队友回贴]',
             '',
-            `\`${name}\` 诉请已发出，当前仍在等待回贴。`,
+            `你已经发出 \`${name}\`，当前仍在等待队友回贴。`,
             '',
             ...(callId ? [`- callId: ${callId}`] : []),
             `- 已等待: ${elapsed}`,
             '',
-            '这不是回贴内容。若后续收到回贴，运行时会在后续上下文中用同一 callId 补入对应回贴事实。',
+            '这不是回贴正文。若稍后收到回贴，Dominds 会把对应结果补入后续上下文。',
         ].join('\n')
         : [
-            '[Dominds tellask status]',
+            '[Dominds waiting for teammate reply]',
             '',
-            `\`${name}\` has been issued and is still waiting for a reply.`,
+            `You already sent \`${name}\` and are still waiting for the teammate's reply.`,
             '',
             ...(callId ? [`- callId: ${callId}`] : []),
             `- Elapsed: ${elapsed}`,
             '',
-            'This is not reply content. If a reply arrives later, runtime will append the corresponding reply fact in later context with the same callId.',
+            'This is not the reply body. If a reply arrives later, Dominds will add the result to later context.',
         ].join('\n');
 }
 function formatResolvedTellaskFuncResultContent(args) {
@@ -605,55 +615,60 @@ function formatResolvedTellaskFuncResultContent(args) {
     if (callId === '') {
         throw new Error(`tellask status formatter invariant violation: empty callId for ${args.name}`);
     }
+    // Business scenario: a previously dispatched teammate request is being summarized back into
+    // context as status. For `pending`, there is still no reply body. For `completed`/`failed`, the
+    // actual reply/failure fact is injected separately. The model-facing text must keep those
+    // separate so the model neither hallucinates a pending result nor treats this status line as the
+    // teammate's answer.
     if (language === 'zh') {
         if (args.status === 'pending') {
             return [
-                '[Dominds 诉请状态]',
+                '[Dominds 等待队友回贴]',
                 '',
-                `\`${args.name}\` 诉请仍在等待回贴，当前没有回贴正文。`,
+                `\`${args.name}\` 仍在等待队友回贴，当前没有回贴正文。`,
                 '',
                 `- callId: ${callId}`,
                 '',
-                '不要把本工具结果当作回贴正文；若后续收到回贴，运行时会用同一 callId 补入对应回贴事实。',
+                '不要把这条状态当作回贴正文；若稍后收到回贴，Dominds 会补入对应结果。',
             ].join('\n');
         }
         const statusLabel = args.status === 'completed' ? '已收到回贴' : '已失败收口';
         return [
-            '[Dominds 诉请状态]',
+            '[Dominds 队友回贴状态]',
             '',
-            `\`${args.name}\` 诉请${statusLabel}，对应回贴事实已作为独立上下文事实补入。`,
+            `\`${args.name}\` ${statusLabel}，对应结果已作为独立上下文补入。`,
             '',
             `- callId: ${callId}`,
             '',
-            '请以同一 callId 的独立回贴事实为准；不要把本工具结果当作回贴正文。',
+            '请以那条独立结果为准；不要把这条状态当作回贴正文。',
         ].join('\n');
     }
     if (args.status === 'pending') {
         return [
-            '[Dominds tellask status]',
+            '[Dominds waiting for teammate reply]',
             '',
-            `\`${args.name}\` is still waiting for a reply; there is no reply body yet.`,
+            `\`${args.name}\` is still waiting for the teammate's reply; there is no reply body yet.`,
             '',
             `- callId: ${callId}`,
             '',
-            'Do not treat this tool result as reply content. If a reply arrives later, runtime will append the corresponding reply fact with the same callId.',
+            'Do not treat this status as the reply body. If a reply arrives later, Dominds will add the result.',
         ].join('\n');
     }
     const statusLabel = args.status === 'completed' ? 'has received a reply' : 'has failed/closed';
     return [
-        '[Dominds tellask status]',
+        '[Dominds teammate reply status]',
         '',
-        `\`${args.name}\` ${statusLabel}; the corresponding reply fact is present separately in context.`,
+        `\`${args.name}\` ${statusLabel}; the corresponding result is present separately in context.`,
         '',
         `- callId: ${callId}`,
         '',
-        'Use the separate reply fact with the same callId as authoritative; do not treat this tool result as reply content.',
+        'Use that separate result as authoritative; do not treat this status as the reply body.',
     ].join('\n');
 }
 function formatResolvedAskHumanResultContent() {
     return (0, work_language_1.getWorkLanguage)() === 'zh'
-        ? 'Q4H 已结束等待状态，请参考 askHuman 结果气泡。'
-        : 'Q4H wait is resolved; refer to the askHuman result bubble.';
+        ? '人类已经回答；请参考 askHuman 结果气泡。'
+        : 'The human has answered; refer to the askHuman result bubble.';
 }
 function buildPendingTellaskFuncResult(args) {
     return {

package/dist/mcp/supervisor.js

@@ -927,14 +927,14 @@ function upsertMcpToolCallProblem(args) {
     const hintLines = workLanguage === 'zh'
         ? [
             '建议排查：',
-            `- 如果需要全局重建该 MCP server，直接调用 mcp_restart({"serverId":"${args.serverId}"})；它成功后会清理旧 runtime 的全部 lease`,
+            `- 如果需要全局重建该 MCP server，直接调用 mcp_restart({"serverId":"${args.serverId}"})；它成功后会清理旧连接/进程的全部 lease`,
             `- 如果只想丢弃当前对话的连接，再调用 mcp_release({"serverId":"${args.serverId}"})`,
             `- 重新打开/关闭浏览器窗口，避免 Playwright persistent context 残留`,
             `- 查看 ${MCP_YAML_PATH} 是否已加载且配置正确（Problems 面板 / 后端日志）`,
         ]
         : [
             'Suggested checks:',
-            `- To rebuild this MCP server globally, call mcp_restart({"serverId":"${args.serverId}"}) directly; a successful restart clears all leases on the old runtime`,
+            `- To rebuild this MCP server globally, call mcp_restart({"serverId":"${args.serverId}"}) directly; a successful restart clears all leases on the old connection/process`,
             `- To discard only this dialog's connection, call mcp_release({"serverId":"${args.serverId}"})`,
             `- Close/reopen browser windows to avoid leftover Playwright persistent contexts`,
             `- Verify ${MCP_YAML_PATH} is loaded and valid (Problems panel / backend logs)`,