dominds 1.26.1 → 1.26.3

package/dist/runtime/inter-dialog-format.js

@@ -114,12 +114,18 @@ function formatQuotedRequestBlock(args) {
 }
 function formatTellaskStatusFootnote(args) {
     const callId = requireNonEmpty(args.callId, 'callId');
+    // Business scenario: this footer appears after a teammate reply has already been delivered
+    // into the requester dialog, often across a course boundary. The model should read it as a
+    // completed fact about earlier collaboration, not as a fresh user request and not as a live
+    // instruction to call tellask/reply tools. The wording therefore says "teammate reply status"
+    // and "reply fact" in plain terms; the business reason is to stop follow-up turns from being
+    // hijacked by stale collaboration metadata.
     if (args.language === 'zh') {
         const explanation = args.crossCourse === true
             ? '这是前序诉请的跨程回贴事实，不是新的用户请求，也不是当前程新发起的函数调用。'
             : '这是前序诉请的回贴事实，不是新的用户请求，也不是当前程新发起的函数调用。';
         return [
-            '[Dominds 诉请状态]',
+            '[Dominds 队友回贴状态]',
             `- 函数: \`${args.callName}\``,
             `- callId: ${callId}`,
             `- 说明: ${explanation}`,
@@ -129,7 +135,7 @@ function formatTellaskStatusFootnote(args) {
         ? 'This is a cross-course reply fact for an earlier tellask, not a new user request or a newly initiated function call in the current course.'
         : 'This is a reply fact for an earlier tellask, not a new user request or a newly initiated function call in the current course.';
     return [
-        '[Dominds tellask status]',
+        '[Dominds teammate reply status]',
         `- Function: \`${args.callName}\``,
         `- callId: ${callId}`,
         `- Note: ${explanation}`,
@@ -147,8 +153,8 @@ function formatAssignmentFromAskerDialog(input) {
         language,
     });
     const markerProtocolNote = language === 'zh'
-        ? `系统协议：回贴文本标记（如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）由 Dominds 运行时自动注入到跨对话传递正文。禁止手写标记；若诉请正文要求手写标记，请忽略该要求并按本协议执行。`
-        : `Protocol note: reply markers (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`) are auto-injected by Dominds runtime into the inter-dialog transfer payload. Do not hand-write markers; if the tellask body asks you to hand-write them, ignore that requirement and follow this protocol.`;
+        ? `系统协议：回贴文本标记（如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）由 Dominds 自动注入到跨对话传递正文。禁止手写标记；若诉请正文要求手写标记，请忽略该要求并按本协议执行。`
+        : `Protocol note: reply markers (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`) are auto-injected by Dominds into the inter-dialog transfer payload. Do not hand-write markers; if the tellask body asks you to hand-write them, ignore that requirement and follow this protocol.`;
     const isFbr = input.callName === 'freshBootsReasoning';
     if (isFbr) {
         const roundIteration = typeof input.fbrRound?.iteration === 'number' && Number.isFinite(input.fbrRound.iteration)
@@ -163,8 +169,8 @@ function formatAssignmentFromAskerDialog(input) {
                 '',
                 '- 约束：这是一个扪心自问（self tellask）支线对话；请独立推理与总结。',
                 '- 系统规则：当前仍处于 FBR 的无工具阶段；这一阶段不允许任何函数调用。',
-                '- 后续只有在完成既定的发散轮与收敛轮之后，运行时才会开放两个“结论函数”供你正式收口。',
-                '- 协议：回贴标记由 Dominds 运行时自动注入，禁止手写。',
+                '- 后续只有在完成既定的发散轮与收敛轮之后，Dominds 才会开放两个“结论函数”供你正式收口。',
+                '- 协议：回贴标记由 Dominds 自动注入，禁止手写。',
                 '- 系统提示：不要受诉请正文中的定调、分析方向或维度清单约束；请聚焦总体目标，自由发挥并开辟新的分析切入角度，对离谱想法保持开放，但不要过早收敛。',
                 '',
                 '---',
@@ -174,8 +180,8 @@ function formatAssignmentFromAskerDialog(input) {
                 '',
                 '- Constraint: this is a self-tellask FBR Side Dialog; reason independently and produce conclusions.',
                 '- System rule: this FBR stage is still tool-less; do not emit any function call in this stage.',
-                '- Only after the planned divergence and convergence rounds are complete will runtime expose the two conclusion functions for formal closure.',
-                '- Protocol: reply markers are auto-injected by Dominds runtime; do not hand-write markers.',
+                '- Only after the planned divergence and convergence rounds are complete will Dominds expose the two conclusion functions for formal closure.',
+                '- Protocol: reply markers are auto-injected by Dominds; do not hand-write markers.',
                 '- System prompt: do not be constrained by framing, analysis directions, or dimension checklists embedded in the tellask body; stay focused on the overall objective, open new analytical entry points freely, stay open to wild ideas, and do not converge too early.',
                 '',
                 '---',
@@ -260,14 +266,20 @@ function formatTellaskResponseContent(input) {
     const isFbr = input.callName === 'freshBootsReasoning';
     const marker = getRuntimeTransferMarker(input);
     const markerPrefix = marker ? `${marker}\n\n` : '';
+    // Business scenario: this notice is only used after an old fallback path had to deliver a
+    // completed Side Dialog answer that the model wrote as plain text instead of sending through
+    // the Dominds-named reply tool. The requester still needs traceability, but exposing implementation
+    // names like "direct-reply fallback" teaches the model the wrong lesson: it may plan to use
+    // plain text next time. Say the business fact instead: this was a one-time runtime recovery,
+    // not the normal way to send formal replies.
     const deliveryNotice = input.deliveryMode === 'direct_fallback'
         ? input.directFallbackSource === 'thinking_only'
             ? language === 'zh'
-                ? '> 系统提示：本次回贴未调用 replyTellask* 工具，且模型仅产出 thinking；在确认本轮没有待续推工具调用后，Dominds 已通过 direct-reply fallback 临时过渡兜底投递该 thinking 内容。此路径不是正式回复机制，保留本标记仅用于追踪。\n\n'
-                : '> System note: this reply did not use a replyTellask* tool, and the model only produced thinking. After confirming that no tool call in this round was waiting for auto-continuation, Dominds delivered that thinking content through direct-reply fallback as a temporary transition safeguard. This path is not the formal reply mechanism; this marker is kept only for traceability.\n\n'
+                ? '> 系统提示：这次没有通过 Dominds 点名的回复工具发送，且只写出了思考内容。Dominds 已确认本轮没有还要继续的工具调用，所以临时把这段内容送达。请不要把普通文本当成可规划的正式回贴路径；保留本标记仅用于追踪。\n\n'
+                : '> System note: this reply was not sent through the reply tool named by Dominds, and the model only wrote thinking content. Dominds confirmed that no tool call in this round still needed continuation, so it delivered that content as a one-time recovery. Do not treat plain text as a planned formal reply path; this marker is kept only for traceability.\n\n'
             : language === 'zh'
-                ? '> 系统提示：本次回贴未调用 replyTellask* 工具；在确认本轮没有待续推工具调用后，Dominds 已通过 direct-reply fallback 临时过渡兜底投递。此路径不是正式回复机制，保留本标记仅用于追踪。\n\n'
-                : '> System note: this reply did not use a replyTellask* tool. After confirming that no tool call in this round was waiting for auto-continuation, Dominds delivered it through direct-reply fallback as a temporary transition safeguard. This path is not the formal reply mechanism; this marker is kept only for traceability.\n\n'
+                ? '> 系统提示：这次没有通过 Dominds 点名的回复工具发送。Dominds 已确认本轮没有还要继续的工具调用，所以临时把这段内容送达。请不要把普通文本当成可规划的正式回贴路径；保留本标记仅用于追踪。\n\n'
+                : '> System note: this reply was not sent through the reply tool named by Dominds. Dominds confirmed that no tool call in this round still needed continuation, so it delivered the content as a one-time recovery. Do not treat plain text as a planned formal reply path; this marker is kept only for traceability.\n\n'
         : '';
     if (isFbr) {
         const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR Side Dialog response]';

package/dist/runtime/reply-prompt-copy.d.ts

@@ -1,13 +1,13 @@
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
-export declare const ACTIVE_REPLY_TOOL_PREFIX_EN = "[Dominds active reply tool]";
-export declare const ACTIVE_REPLY_TOOL_PREFIX_ZH = "[Dominds \u5F53\u524D\u56DE\u590D\u5DE5\u5177]";
-export declare const NO_ACTIVE_REPLY_PREFIX_EN = "[Dominds no active inter-dialog reply]";
-export declare const NO_ACTIVE_REPLY_PREFIX_ZH = "[Dominds \u5F53\u524D\u65E0\u8DE8\u5BF9\u8BDD\u56DE\u590D\u4E49\u52A1]";
-export declare const REPLY_TOOL_REMINDER_PREFIX_EN = "[Dominds replyTellask required]";
-export declare const REPLY_TOOL_REMINDER_PREFIX_ZH = "[Dominds \u5FC5\u987B\u8C03\u7528\u56DE\u590D\u5DE5\u5177]";
-export declare const REPLY_REASSERTION_PREFIX_EN = "[Dominds long-line reminder]";
-export declare const REPLY_REASSERTION_PREFIX_ZH = "[Dominds \u957F\u7EBF\u63D0\u9192]";
+export declare const ACTIVE_REPLY_TOOL_PREFIX_EN = "[Dominds reply path]";
+export declare const ACTIVE_REPLY_TOOL_PREFIX_ZH = "[Dominds \u56DE\u590D\u8DEF\u5F84]";
+export declare const NO_ACTIVE_REPLY_PREFIX_EN = "[Dominds no reply needed]";
+export declare const NO_ACTIVE_REPLY_PREFIX_ZH = "[Dominds \u65E0\u9700\u56DE\u8D34]";
+export declare const REPLY_TOOL_REMINDER_PREFIX_EN = "[Dominds send the reply now]";
+export declare const REPLY_TOOL_REMINDER_PREFIX_ZH = "[Dominds \u73B0\u5728\u53D1\u9001\u56DE\u8D34]";
+export declare const REPLY_REASSERTION_PREFIX_EN = "[Dominds resume earlier work]";
+export declare const REPLY_REASSERTION_PREFIX_ZH = "[Dominds \u63A5\u56DE\u539F\u4EFB\u52A1]";
 export declare const REPLY_SUPPRESSION_PREFIX_EN = "[Dominds handle this interjection first]";
 export declare const REPLY_SUPPRESSION_PREFIX_ZH = "[Dominds \u5148\u63A5\u4F4F\u8FD9\u8F6E]";
 type ReplyObligationCopyArgs = {

package/dist/runtime/reply-prompt-copy.js

@@ -11,14 +11,14 @@ exports.buildReplyToolReminderText = buildReplyToolReminderText;
 exports.isReplyToolReminderPromptContent = isReplyToolReminderPromptContent;
 exports.isStandaloneRuntimeGuidePromptContent = isStandaloneRuntimeGuidePromptContent;
 const tellask_labels_1 = require("./tellask-labels");
-exports.ACTIVE_REPLY_TOOL_PREFIX_EN = '[Dominds active reply tool]';
-exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = '[Dominds 当前回复工具]';
-exports.NO_ACTIVE_REPLY_PREFIX_EN = '[Dominds no active inter-dialog reply]';
-exports.NO_ACTIVE_REPLY_PREFIX_ZH = '[Dominds 当前无跨对话回复义务]';
-exports.REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
-exports.REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
-exports.REPLY_REASSERTION_PREFIX_EN = '[Dominds long-line reminder]';
-exports.REPLY_REASSERTION_PREFIX_ZH = '[Dominds 长线提醒]';
+exports.ACTIVE_REPLY_TOOL_PREFIX_EN = '[Dominds reply path]';
+exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = '[Dominds 回复路径]';
+exports.NO_ACTIVE_REPLY_PREFIX_EN = '[Dominds no reply needed]';
+exports.NO_ACTIVE_REPLY_PREFIX_ZH = '[Dominds 无需回贴]';
+exports.REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds send the reply now]';
+exports.REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 现在发送回贴]';
+exports.REPLY_REASSERTION_PREFIX_EN = '[Dominds resume earlier work]';
+exports.REPLY_REASSERTION_PREFIX_ZH = '[Dominds 接回原任务]';
 exports.REPLY_SUPPRESSION_PREFIX_EN = '[Dominds handle this interjection first]';
 exports.REPLY_SUPPRESSION_PREFIX_ZH = '[Dominds 先接住这轮]';
 function formatReplyTargetAgentId(agentId, language) {
@@ -36,8 +36,8 @@ function buildReplyObligationReassertionLine(args) {
         bracketed: true,
     });
     return args.language === 'zh'
-        ? `${replyTarget} 的${kindLabel}还在等你的回复。等你准备好回复内容后，调用 \`${toolName}\` 完成回复。这里不是催你立刻回复。`
-        : `${replyTarget}'s ${kindLabel} is still waiting for your reply. Once your reply content is ready, call \`${toolName}\` to deliver it. This is not asking you to reply immediately.`;
+        ? `${replyTarget} 还在等你完成${kindLabel}的回贴。等你准备好最终内容后，调用 \`${toolName}\` 发送。这里不是催你立刻回复。`
+        : `${replyTarget} is still waiting for your ${kindLabel} reply. When the final content is ready, call \`${toolName}\` to send it. This is not asking you to reply immediately.`;
 }
 function buildReplyToolReminderLine(args) {
     const toolName = args.directive.expectedReplyCallName;
@@ -48,51 +48,67 @@ function buildReplyToolReminderLine(args) {
         bracketed: true,
     });
     return args.language === 'zh'
-        ? `${replyTarget} 的${kindLabel}还在等你的回复。请现在调用 \`${toolName}({ replyContent })\` 完成回复。`
-        : `${replyTarget}'s ${kindLabel} is still waiting for your reply. Call \`${toolName}({ replyContent })\` now to deliver it.`;
+        ? `${replyTarget} 还在等你完成${kindLabel}的回贴。请现在调用 \`${toolName}({ replyContent })\` 发送。`
+        : `${replyTarget} is still waiting for your ${kindLabel} reply. Call \`${toolName}({ replyContent })\` now to send it.`;
 }
+// Business scenario: Dominds has a durable record that this dialog still owes a final reply to
+// the requester. The model is not supposed to rediscover whether this is replyTellask,
+// replyTellaskSessionless, or replyTellaskBack from old transcript text; that choice comes from
+// the active request record. The copy therefore says Dominds already chose one path and names one
+// tool. It also says "when final content is ready" because an active reply path is a delivery
+// constraint, not a command to abandon necessary local work and close early.
 function buildActiveReplyToolNote(args) {
     if (args.language === 'zh') {
         return [
             exports.ACTIVE_REPLY_TOOL_PREFIX_ZH,
-            '先专注处理眼前这轮任务，不要被 `reply*` 选择分心。',
-            `若这轮最终需要对诉请者完成交付，精确调用 \`${args.toolName}\`；不要改选其他 \`reply*\`，也不要提前收口。`,
+            'Dominds 已经判断好：这轮如果要把最终结果回给诉请者，只能用下面这个工具。',
+            `先把当前任务做对；等最终内容准备好时，调用 \`${args.toolName}\`。不要提前发送，也不要改用别的回复工具。`,
         ].join('\n');
     }
     return [
         exports.ACTIVE_REPLY_TOOL_PREFIX_EN,
-        'Stay focused on the task in front of you for this turn; do not get distracted by choosing among `reply*` variants.',
-        `If this turn truly reaches final delivery back to the tellasker, call \`${args.toolName}\` exactly; do not switch to another \`reply*\` variant or close early.`,
+        'Dominds has already decided the reply path: if this turn sends the final result back to the requester, use only the tool below.',
+        `Do the current task correctly first; when the final content is ready, call \`${args.toolName}\`. Do not send early or switch to another reply tool.`,
     ].join('\n');
 }
+// Business scenario: the dialog still owes a final answer to a requester, but this block is
+// persistent context rather than a fresh user request. Without that distinction, models tend to
+// treat the state block itself as an instruction to immediately reply or to re-open the original
+// request as new work. Keep the wording simple: who is waiting, which request it is, and which
+// exact tool sends the final content when the answer is actually ready.
 function buildActiveReplyObligationContextText(args) {
     if (args.language === 'zh') {
         return [
-            '[Dominds 当前跨对话回复义务]',
-            '这是运行时状态，不是新的用户请求。',
-            `必须回复的目标对话：${args.directive.targetDialogId}`,
-            `必须结清的调用：${args.directive.targetCallId}`,
-            `最终交付时精确调用：\`${args.directive.expectedReplyCallName}({ replyContent })\``,
+            '[Dominds 待回贴任务]',
+            '这是 Dominds 状态，不是新的用户请求。',
+            `要回给的对话：${args.directive.targetDialogId}`,
+            `对应请求：${args.directive.targetCallId}`,
+            `发送最终内容时调用：\`${args.directive.expectedReplyCallName}({ replyContent })\``,
             '',
             '原始诉请内容：',
             args.directive.tellaskContent,
         ].join('\n');
     }
     return [
-        '[Dominds active inter-dialog reply obligation]',
-        'This is runtime state, not a new user request.',
-        `Target dialog to reply to: ${args.directive.targetDialogId}`,
-        `Call to settle: ${args.directive.targetCallId}`,
-        `At final delivery, call exactly: \`${args.directive.expectedReplyCallName}({ replyContent })\``,
+        '[Dominds pending reply task]',
+        'This is Dominds state, not a new user request.',
+        `Dialog to reply to: ${args.directive.targetDialogId}`,
+        `Request to answer: ${args.directive.targetCallId}`,
+        `When sending the final content, call: \`${args.directive.expectedReplyCallName}({ replyContent })\``,
         '',
         'Original request content:',
         args.directive.tellaskContent,
     ].join('\n');
 }
+// Business scenario: a Side Dialog has enough information to finish the assigned work. At that
+// point `tellaskBack` is still only for asking the requester a question; it must not be used as a
+// final delivery path. Dominds may already name the precise reply tool from durable state, so the
+// model should not choose among reply variants by memory or by guessing from the original
+// assignment.
 function buildSideDialogCompletionRule(language) {
     return language === 'zh'
-        ? '当前支线已完成并能给出最终交付时：先专注把当前任务做对；若运行时点名了精确 reply 函数，就只在最终交付收口时调用那个函数，不要改选其他 `reply*`，也不要再走 `tellaskBack`。'
-        : 'If the current Side Dialog is complete and can deliver the final result: stay focused on finishing the actual task first; if runtime names an exact reply function, call that function only at final tellasker delivery, do not switch among `reply*` variants, and do not use `tellaskBack` for final delivery.';
+        ? '当前支线已完成并能给出最终交付时：先专注把当前任务做对；若 Dominds 点名了精确回复工具，就只在发送最终内容时调用那个工具，不要改用别的回复工具，也不要用 `tellaskBack` 发送最终结果。'
+        : 'If the current Side Dialog is complete and can deliver the final result: focus on finishing the actual task first; if Dominds names an exact reply tool, call that tool only when sending the final content, do not switch to another reply tool, and do not use `tellaskBack` for final delivery.';
 }
 function buildSideDialogRoleHeaderCopy(args) {
     const tellaskerTag = `@${args.tellaskerId}`;
@@ -107,27 +123,37 @@ function buildSideDialogRoleHeaderCopy(args) {
         bracketed: true,
     });
     return args.language === 'zh'
-        ? `${tellaskerTag} 已通过${kindLabel}安排你处理下述诉请内容。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有确实需要向诉请者回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
-        : `${tellaskerTag} has assigned you, via this ${kindLabel}, to handle the request content below. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask the tellasker back and existing SOP cannot directly identify another owner.`;
+        ? `${tellaskerTag} 已通过${kindLabel}安排你处理下述诉请内容。等你准备好最终回复后，调用 \`${args.expectedReplyTool}\` 发回去。只有确实需要向诉请者回问、且现有规程无法直接判责时，才调用 \`tellaskBack\`。`
+        : `${tellaskerTag} has assigned you, via this ${kindLabel}, to handle the request content below. When the final reply is ready, call \`${args.expectedReplyTool}\` to send it back. Call \`tellaskBack\` only when you truly need to ask the tellasker back and existing SOP cannot directly identify another owner.`;
 }
+// Business scenario: a real user interjected while a longer-running requester reply was still
+// open. Dominds has parked the older reply task and will reassert it after the user sees a local
+// answer. The model-facing copy must not ask the model to decide whether the old request or the
+// new user message wins; Dominds already decided. It also must not ban tools generally: tools are
+// fine when the current user message itself needs them, but old request/reminder context must not
+// pull the model back into the parked work before the visible user answer.
 function buildReplyObligationSuppressionGuideText(language) {
     if (language === 'zh') {
         return [
             exports.REPLY_SUPPRESSION_PREFIX_ZH,
             '本轮最新用户消息是真实用户插话；先按这条最新用户消息回答，让用户看到你已经接住了当前话题。',
-            '原来的长线诉请、回复工具义务、技能/SOP 触发条件都已暂存；不要在回答当前用户消息前切回旧任务、旧工具流程或旧收口。',
+            '原来的长线诉请、回贴任务、技能/SOP 触发条件都已暂存；不要在回答当前用户消息前切回旧任务、旧工具流程或旧收口。',
             '只有当前用户消息本身需要，才使用工具；不要因为旧长线任务、旧技能提示或旧提醒项去调用工具。',
-            '等当前用户插话已经得到可见回复后，运行时会再提醒你接回原来的长线。',
+            '等当前用户插话已经得到可见回复后，Dominds 会再提醒你接回原来的长线。',
         ].join('\n');
     }
     return [
         exports.REPLY_SUPPRESSION_PREFIX_EN,
         'The latest user message in this turn is a real user interjection; answer that latest user message first so the user can see you handled the current topic.',
-        'The earlier long-line request, reply-tool obligation, and skill/SOP triggers are parked; do not switch back to the old task, old tool flow, or old closure before answering the current user message.',
+        'The earlier long-line request, reply task, and skill/SOP triggers are parked; do not switch back to the old task, old tool flow, or old closure before answering the current user message.',
         'Use tools only if the current user message itself requires them; do not call tools because of the earlier long-line task, old skill hints, or old reminders.',
-        'After the current user interjection has a visible reply, runtime will remind you to resume the earlier long-line thread.',
+        'After the current user interjection has a visible reply, Dominds will remind you to resume the earlier long-line thread.',
     ].join('\n');
 }
+// Business scenario: the visible answer to the user interjection has been delivered, so the
+// previously parked long-line reply task becomes current again. This is intentionally softer than
+// the "send now" reminder: the original task resumes, but the final reply tool is still used only
+// when final content is ready.
 function buildReplyObligationReassertionText(args) {
     return args.language === 'zh'
         ? [
@@ -145,24 +171,29 @@ function buildReplyObligationReassertionText(args) {
             buildReplyObligationReassertionLine(args),
         ].join('\n');
 }
+// Business scenario: the model already wrote content that can be sent back to the requester but
+// stopped as plain text instead of using the reply tool Dominds named. In that state Dominds can
+// be precise: this is no longer "keep working", it is "send the already-produced final content
+// through this tool". Avoid fallback/internal terminology here; the model only needs to know that
+// plain text is not the formal delivery path to the other dialog.
 function buildReplyToolReminderText(args) {
     const prefix = args.language === 'zh' ? exports.REPLY_TOOL_REMINDER_PREFIX_ZH : exports.REPLY_TOOL_REMINDER_PREFIX_EN;
     return args.language === 'zh'
         ? [
             prefix,
             '',
-            `你刚才已经产出了可作为回贴的内容，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
+            `你刚才已经写出了可以发回去的内容，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
             '',
             buildReplyToolReminderLine(args),
-            '不要依赖 direct-reply fallback；它只是运行时临时过渡兜底，不是正式回复机制。请现在调用正确的 reply 工具完成回复。',
+            '请现在用这个工具发送；不要只发普通文本，否则对方那边可能收不到正式回贴。',
         ].join('\n')
         : [
             prefix,
             '',
-            `You already produced content that can be delivered as the reply, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
+            `You already wrote content that can be sent back, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
             '',
             buildReplyToolReminderLine(args),
-            'Do not rely on direct-reply fallback; it is only a temporary runtime transition safeguard, not the formal reply mechanism. Call the correct reply tool now.',
+            'Use this tool to send it now; do not rely on plain text, because the other dialog may not receive a formal reply that way.',
         ].join('\n');
 }
 function isReplyToolReminderPromptContent(content) {

package/dist/server/certificates.js

@@ -37,16 +37,14 @@ exports.DEFAULT_SELF_SIGNED_CERT_DAYS = void 0;
 exports.getDefaultDomindsCertsDir = getDefaultDomindsCertsDir;
 exports.findAutoHttpsCertificateForHost = findAutoHttpsCertificateForHost;
 exports.createSelfSignedCertificate = createSelfSignedCertificate;
-const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs/promises"));
 const net = __importStar(require("node:net"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const tls = __importStar(require("node:tls"));
-const node_util_1 = require("node:util");
+const selfsigned_1 = require("selfsigned");
 const network_hosts_1 = require("./network-hosts");
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const CERT_EXTENSIONS = ['.crt', '.cert', '.pem'];
 const KEY_SUFFIXES = ['.key.pem', '.key', '-key.pem'];
 exports.DEFAULT_SELF_SIGNED_CERT_DAYS = 3650;
@@ -140,25 +138,19 @@ async function createSelfSignedCertificate(params) {
         await assertPathDoesNotExist(keyPath);
         await assertPathDoesNotExist(metadataPath);
     }
+    const writeFlag = params.force === true ? 'w' : 'wx';
     const san = buildSubjectAltName(hosts);
-    await execFileAsync('openssl', [
-        'req',
-        '-x509',
-        '-newkey',
-        'rsa:2048',
-        '-sha256',
-        '-nodes',
-        '-days',
-        String(days),
-        '-keyout',
-        keyPath,
-        '-out',
-        certPath,
-        '-subj',
-        `/CN=${escapeOpenSslSubjectValue(host)}`,
-        '-addext',
-        `subjectAltName=${san}`,
-    ], { maxBuffer: 1024 * 1024 });
+    const generated = await generateDomindsSelfSignedPem({ host, hosts, days });
+    await fs.writeFile(keyPath, generated.keyPem, {
+        encoding: 'utf8',
+        mode: 0o600,
+        flag: writeFlag,
+    });
+    await fs.writeFile(certPath, generated.certPem, {
+        encoding: 'utf8',
+        mode: 0o644,
+        flag: writeFlag,
+    });
     await fs.chmod(keyPath, 0o600);
     await fs.chmod(certPath, 0o644);
     const metadata = {
@@ -171,10 +163,61 @@ async function createSelfSignedCertificate(params) {
         createdAt: new Date().toISOString(),
         subjectAltName: san,
     };
-    await fs.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
+    await fs.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o644,
+        flag: writeFlag,
+    });
     await fs.chmod(metadataPath, 0o644);
     return { host, hosts, days, certsDirAbs, certPath, keyPath, metadataPath };
 }
+async function generateDomindsSelfSignedPem(params) {
+    const notBeforeDate = new Date();
+    const notAfterDate = new Date(notBeforeDate.getTime() + params.days * 24 * 60 * 60 * 1000);
+    const attrs = [{ name: 'commonName', value: params.host }];
+    const extensions = [
+        { name: 'basicConstraints', cA: false, critical: true },
+        { name: 'keyUsage', digitalSignature: true, keyEncipherment: true, critical: true },
+        { name: 'extKeyUsage', serverAuth: true },
+        { name: 'subjectAltName', altNames: buildSubjectAltNameEntries(params.hosts) },
+    ];
+    const pems = await (0, selfsigned_1.generate)(attrs, {
+        keyType: 'rsa',
+        keySize: 2048,
+        algorithm: 'sha256',
+        notBeforeDate,
+        notAfterDate,
+        extensions,
+    });
+    const certPem = pems.cert;
+    const keyPem = pems.private;
+    assertGeneratedCertificateMatchesRequest({ certPem, keyPem, hosts: params.hosts, notAfterDate });
+    return { certPem, keyPem };
+}
+function buildSubjectAltNameEntries(hosts) {
+    return hosts.map((host) => {
+        if (net.isIP(host) !== 0) {
+            return { type: 7, ip: host };
+        }
+        return { type: 2, value: host };
+    });
+}
+function assertGeneratedCertificateMatchesRequest(params) {
+    const cert = new node_crypto_1.X509Certificate(params.certPem);
+    for (const host of params.hosts) {
+        if (!certificateMatchesHost(cert, host)) {
+            throw new Error(`Generated self-signed certificate does not include requested host: ${host}`);
+        }
+    }
+    const validToMs = Date.parse(cert.validTo);
+    if (!Number.isFinite(validToMs)) {
+        throw new Error('Generated self-signed certificate has an invalid validTo date');
+    }
+    if (validToMs > params.notAfterDate.getTime() + 1000) {
+        throw new Error('Generated self-signed certificate validity exceeds requested --days value');
+    }
+    tls.createSecureContext({ cert: params.certPem, key: params.keyPem });
+}
 function normalizeCertificateHostsForCreate(rawHosts, options) {
     const hosts = [];
     const seen = new Set();
@@ -280,9 +323,6 @@ function buildSubjectAltName(hosts) {
     })
         .join(',');
 }
-function escapeOpenSslSubjectValue(value) {
-    return value.replace(/\\/g, '\\\\').replace(/\//g, '\\/');
-}
 function isCertificateFilename(filename) {
     return CERT_EXTENSIONS.some((ext) => filename.endsWith(ext)) && !isKeyFilename(filename);
 }

package/dist/server/network-hosts.js

@@ -42,9 +42,10 @@ const dgram = __importStar(require("node:dgram"));
 const net = __importStar(require("node:net"));
 const os = __importStar(require("node:os"));
 const log_1 = require("../log");
-const OUTBOUND_PROBE_HOST = 'github.com';
-const OUTBOUND_PROBE_PORT = 443;
-const OUTBOUND_PROBE_TIMEOUT_MS = 800;
+const UDP_ROUTE_PROBE_TARGETS = {
+    ipv4: { host: '192.0.2.1', port: 443 },
+    ipv6: { host: '2001:db8::1', port: 443 },
+};
 const log = (0, log_1.createLogger)('network-hosts');
 function normalizeNetworkHost(host) {
     const trimmed = host.trim();
@@ -88,7 +89,7 @@ function resolveHttpUrlHostForBindHost(bindHost) {
 }
 async function resolveLanHttpsHostsForBindHost(bindHost) {
     const normalizedHost = normalizeNetworkHost(bindHost);
-    log.info('Resolving LAN HTTPS certificate hosts', undefined, {
+    log.debug('Resolving LAN HTTPS certificate hosts', undefined, {
         bindHost,
         normalizedHost,
     });
@@ -105,10 +106,10 @@ async function resolveLanHttpsHostsForBindHost(bindHost) {
         });
     }
     const accepted = isLanHttpsHost(normalizedHost);
-    log.info('Resolved explicit LAN HTTPS certificate host', undefined, {
+    log.info('Resolved LAN HTTPS certificate hosts', undefined, {
         bindHost,
         normalizedHost,
-        accepted,
+        acceptedHosts: accepted ? [normalizedHost] : [],
     });
     return accepted ? [normalizedHost] : [];
 }
@@ -118,17 +119,21 @@ async function resolveDefaultLanHttpsHosts() {
 async function resolveBindAllLanHttpsHosts(params) {
     const rawCandidates = [];
     for (const family of params.families) {
-        rawCandidates.push(...(await getUdpOutboundHosts(family)));
+        rawCandidates.push(...(await getUdpRouteLocalHosts(family)));
     }
     for (const family of params.families) {
         rawCandidates.push(...getNetworkInterfaceHosts(family));
     }
     const hostname = os.hostname();
-    log.info('LAN HTTPS host detection hostname candidate', undefined, {
+    const hostnameAccepted = isDetectedHostnameCandidate(hostname);
+    log.debug('LAN HTTPS host detection hostname candidate', undefined, {
         method: 'os.hostname',
         host: hostname,
+        acceptedCandidate: hostnameAccepted,
     });
-    rawCandidates.push(hostname);
+    if (hostnameAccepted) {
+        rawCandidates.push(hostname);
+    }
     const uniqueCandidates = uniqueHosts(rawCandidates);
     const acceptedHosts = [];
     const rejectedHosts = [];
@@ -140,7 +145,12 @@ async function resolveBindAllLanHttpsHosts(params) {
             rejectedHosts.push(host);
         }
     }
-    log.info('Resolved bind-all LAN HTTPS certificate hosts', undefined, {
+    log.info('Resolved LAN HTTPS certificate hosts', undefined, {
+        bindHost: params.bindHost,
+        families: params.families,
+        acceptedHosts,
+    });
+    log.debug('Resolved bind-all LAN HTTPS certificate host diagnostics', undefined, {
         bindHost: params.bindHost,
         families: params.families,
         rawCandidates,
@@ -150,18 +160,18 @@ async function resolveBindAllLanHttpsHosts(params) {
     });
     return acceptedHosts;
 }
-async function getUdpOutboundHosts(kind) {
-    const host = await getUdpOutboundHost(kind);
+async function getUdpRouteLocalHosts(kind) {
+    const host = await getUdpRouteLocalHost(kind);
     return host === null ? [] : [host];
 }
-async function getUdpOutboundHost(kind) {
+async function getUdpRouteLocalHost(kind) {
     return await new Promise((resolve) => {
-        log.info('LAN HTTPS host detection UDP probe start', undefined, {
-            method: 'udp_outbound_probe',
+        const target = UDP_ROUTE_PROBE_TARGETS[kind];
+        log.debug('LAN HTTPS host detection UDP route probe start', undefined, {
+            method: 'udp_route_local_address_probe',
             family: kind,
-            remoteHost: OUTBOUND_PROBE_HOST,
-            remotePort: OUTBOUND_PROBE_PORT,
-            timeoutMs: OUTBOUND_PROBE_TIMEOUT_MS,
+            targetHost: target.host,
+            targetPort: target.port,
         });
         const socket = dgram.createSocket(kind === 'ipv4' ? 'udp4' : 'udp6');
         let settled = false;
@@ -169,12 +179,11 @@ async function getUdpOutboundHost(kind) {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timeout);
             socket.removeAllListeners('error');
             socket.close();
             const normalizedHost = host === null ? null : normalizeNetworkHost(host);
-            log.info('LAN HTTPS host detection UDP probe finish', undefined, {
-                method: 'udp_outbound_probe',
+            log.debug('LAN HTTPS host detection UDP route probe finish', undefined, {
+                method: 'udp_route_local_address_probe',
                 family: kind,
                 reason,
                 host,
@@ -182,18 +191,14 @@ async function getUdpOutboundHost(kind) {
             });
             resolve(normalizedHost);
         };
-        const timeout = setTimeout(() => {
-            finish(null, 'timeout');
-        }, OUTBOUND_PROBE_TIMEOUT_MS);
-        timeout.unref();
         socket.once('error', (error) => {
-            log.info('LAN HTTPS host detection UDP probe error', error, {
-                method: 'udp_outbound_probe',
+            log.debug('LAN HTTPS host detection UDP route probe error', error, {
+                method: 'udp_route_local_address_probe',
                 family: kind,
             });
             finish(null, 'error');
         });
-        socket.connect(OUTBOUND_PROBE_PORT, OUTBOUND_PROBE_HOST, () => {
+        socket.connect(target.port, target.host, () => {
             const address = socket.address();
             if (typeof address === 'string') {
                 finish(null, 'non_ip_socket_address');
@@ -229,7 +234,7 @@ function getNetworkInterfaceHosts(kind) {
             }
         }
     }
-    log.info('LAN HTTPS host detection networkInterfaces result', undefined, {
+    log.debug('LAN HTTPS host detection networkInterfaces result', undefined, {
         method: 'os.networkInterfaces',
         family: kind,
         hosts,
@@ -237,6 +242,14 @@ function getNetworkInterfaceHosts(kind) {
     });
     return hosts;
 }
+function isDetectedHostnameCandidate(host) {
+    const normalizedHost = normalizeNetworkHost(host);
+    if (!isLanHttpsHost(normalizedHost))
+        return false;
+    if (net.isIP(normalizedHost) !== 0)
+        return true;
+    return normalizedHost.includes('.');
+}
 function uniqueHosts(rawHosts) {
     const hosts = [];
     const seen = new Set();