dominds 1.11.1 → 1.11.2

package/dist/dialog-fork.js

@@ -97,6 +97,7 @@ function isPersistedMessageRecord(record) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'human_text_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
@@ -172,6 +173,7 @@ function rewriteRecordForFork(record, newRootId) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
         case 'web_search_call_record':

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

@@ -12,6 +12,7 @@ const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
 const driver_messages_1 = require("../../runtime/driver-messages");
+const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tool_1 = require("../../tool");
 const taskdoc_1 = require("../../utils/taskdoc");
@@ -1368,6 +1369,19 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     if (replyGuidance.promptContent === undefined) {
                         throw new Error(`kernel-driver reply guidance invariant violation: missing prompt content for dialog=${dlg.id.valueOf()} msgId=${currentPrompt.msgId}`);
                     }
+                    const renderPromptAsRuntimeGuideBubble = origin === 'runtime' &&
+                        (0, reply_prompt_copy_1.isStandaloneRuntimeGuidePromptContent)(replyGuidance.promptContent);
+                    if (currentRuntimeGuideMsg) {
+                        await dlg.addChatMessages(currentRuntimeGuideMsg);
+                        await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, currentRuntimeGuideMsg.content, dlg.activeGenSeq);
+                        (0, evt_registry_1.postDialogEvent)(dlg, {
+                            type: 'runtime_guide_evt',
+                            course: dlg.currentCourse,
+                            genseq: dlg.activeGenSeq,
+                            content: currentRuntimeGuideMsg.content,
+                        });
+                        currentRuntimeGuideMsg = undefined;
+                    }
                     await dlg.addChatMessages({
                         type: 'prompting_msg',
                         role: 'user',
@@ -1377,20 +1391,30 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         content: replyGuidance.promptContent,
                     });
                     await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallIds, replyGuidance.persistedTellaskReplyDirective);
-                    // Emit the live user-side boundary event for UI generation bubbles.
-                    // Without this, realtime turns can miss user content + divider (<hr/>),
-                    // while replay (from persisted human_text_record) still looks correct.
-                    (0, evt_registry_1.postDialogEvent)(dlg, {
-                        type: 'end_of_user_saying_evt',
-                        course: dlg.currentCourse,
-                        genseq: dlg.activeGenSeq,
-                        msgId: currentPrompt.msgId,
-                        content: replyGuidance.promptContent,
-                        grammar: 'markdown',
-                        origin,
-                        userLanguageCode: persistedUserLanguageCode,
-                        q4hAnswerCallIds,
-                    });
+                    if (renderPromptAsRuntimeGuideBubble) {
+                        (0, evt_registry_1.postDialogEvent)(dlg, {
+                            type: 'runtime_guide_evt',
+                            course: dlg.currentCourse,
+                            genseq: dlg.activeGenSeq,
+                            content: replyGuidance.promptContent,
+                        });
+                    }
+                    else {
+                        // Emit the live user-side boundary event for UI generation bubbles.
+                        // Without this, realtime turns can miss user content + divider (<hr/>),
+                        // while replay (from persisted human_text_record) still looks correct.
+                        (0, evt_registry_1.postDialogEvent)(dlg, {
+                            type: 'end_of_user_saying_evt',
+                            course: dlg.currentCourse,
+                            genseq: dlg.activeGenSeq,
+                            msgId: currentPrompt.msgId,
+                            content: replyGuidance.promptContent,
+                            grammar: 'markdown',
+                            origin,
+                            userLanguageCode: persistedUserLanguageCode,
+                            q4hAnswerCallIds,
+                        });
+                    }
                     if (currentPromptFromFbrState && currentFbrState) {
                         await persistDialogFbrState(dlg, (0, fbr_1.markFbrPromptDelivered)(currentFbrState));
                     }

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

@@ -4,23 +4,22 @@ exports.resolvePromptReplyGuidance = resolvePromptReplyGuidance;
 exports.buildReplyObligationSuppressionGuide = buildReplyObligationSuppressionGuide;
 exports.buildReplyObligationReassertionPrompt = buildReplyObligationReassertionPrompt;
 const dialog_1 = require("../../dialog");
+const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tellask_special_1 = require("./tellask-special");
 const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
 const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
-const REPLY_REASSERTION_PREFIX_EN = '[Dominds long-line reminder]';
-const REPLY_REASSERTION_PREFIX_ZH = '[Dominds 长线提醒]';
 function buildPromptContentWithExactReplyToolName(args) {
     const isFbrSubdialog = args.dlg instanceof dialog_1.SubDialog && args.dlg.assignmentFromSup.callName === 'freshBootsReasoning';
     const noActivePrefix = args.language === 'zh'
         ? '[Dominds 当前无跨对话回复义务]'
         : '[Dominds no active inter-dialog reply]';
-    const activePrefix = args.language === 'zh' ? '[Dominds 当前回复工具]' : '[Dominds active reply tool]';
+    const activePrefix = args.language === 'zh' ? reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH : reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN;
     const reminderPrefixes = [
         REPLY_TOOL_REMINDER_PREFIX_EN,
         REPLY_TOOL_REMINDER_PREFIX_ZH,
-        REPLY_REASSERTION_PREFIX_EN,
-        REPLY_REASSERTION_PREFIX_ZH,
+        reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
+        reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
     ];
     const directive = args.activeReplyDirective;
     if (!directive) {
@@ -53,17 +52,10 @@ function buildPromptContentWithExactReplyToolName(args) {
     if (reminderPrefixes.some((prefix) => args.prompt.content.startsWith(prefix))) {
         return args.prompt.content;
     }
-    const note = args.language === 'zh'
-        ? [
-            activePrefix,
-            `当前这轮若完成交付，精确应调用 \`${toolName}\`。`,
-            '不要自己判断该选哪个 `reply*`；以上述函数名为准。',
-        ].join('\n')
-        : [
-            activePrefix,
-            `If this round is ready for final delivery, the exact reply tool is \`${toolName}\`.`,
-            'Do not decide among `reply*` variants by yourself; follow that exact function name.',
-        ].join('\n');
+    const note = (0, reply_prompt_copy_1.buildActiveReplyToolNote)({
+        language: args.language,
+        toolName,
+    });
     return `${note}\n\n${args.prompt.content}`;
 }
 async function shouldSuppressInterDialogReplyGuidanceForUserInterjection(args) {
@@ -115,35 +107,11 @@ async function resolvePromptReplyGuidance(args) {
     };
 }
 function buildReplyObligationSuppressionGuide(args) {
-    if (args.language === 'zh') {
-        return [
-            '[Dominds 先接住这轮]',
-            '先把用户刚插进来的这轮正常接住，按眼前的话题继续回答。',
-            '原来那条长线先放一放，别急着顺着它往下收口。',
-            '等相关支线结果回来后，运行时会再提醒你把那条线接回去。',
-        ].join('\n');
-    }
-    return [
-        '[Dominds handle this interjection first]',
-        "First, handle the user's interjection normally and keep answering the topic in front of you.",
-        'Set the earlier long-line thread aside for now; do not rush to close it yet.',
-        'When the related sideline result comes back, runtime will remind you to pick that thread up again.',
-    ].join('\n');
+    return (0, reply_prompt_copy_1.buildReplyObligationSuppressionGuideText)(args.language);
 }
 function buildReplyObligationReassertionPrompt(args) {
-    const toolName = args.directive.expectedReplyCallName;
-    if (args.language === 'zh') {
-        return [
-            REPLY_REASSERTION_PREFIX_ZH,
-            '刚才为了接住用户插话，先把那条长线放在一边了。',
-            '现在把它重新记回心里，后续继续推进时别把它丢了。',
-            `等走到需要收口的时候，按 \`${toolName}\` 来处理就行；这条提醒不是在催你立刻回复。`,
-        ].join('\n');
-    }
-    return [
-        REPLY_REASSERTION_PREFIX_EN,
-        'The user interjection was handled first, so that longer thread was set aside for a moment.',
-        'Bring it back into mind now and do not lose it as you continue.',
-        `When the time comes to close that thread, use \`${toolName}\`; this reminder is not telling you to reply immediately.`,
-    ].join('\n');
+    return (0, reply_prompt_copy_1.buildReplyObligationReassertionText)({
+        language: args.language,
+        toolName: args.directive.expectedReplyCallName,
+    });
 }

package/dist/minds/system-prompt.js

@@ -4,6 +4,7 @@ exports.formatTeamIntro = formatTeamIntro;
 exports.formatMcpToolsetRuntimeNote = formatMcpToolsetRuntimeNote;
 exports.buildSystemPrompt = buildSystemPrompt;
 const inter_dialog_format_1 = require("../runtime/inter-dialog-format");
+const reply_prompt_copy_1 = require("../runtime/reply-prompt-copy");
 function formatTeamIntro(team, selfAgentId, language) {
     const callSignLabel = language === 'zh' ? '呼号' : 'Call Sign';
     const selfSuffix = language === 'zh' ? '（本人）' : ' (self)';
@@ -167,7 +168,7 @@ function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
                     '- 若你在正文中给下游写“回贴格式”，必须写明“Dominds 自动注入标记，禁止手写”；不得要求下游手写任何标记。',
                     '- `tellaskBack` 只允许用于回问/澄清/阻塞说明；禁止用 `tellaskBack` 发送最终结果。',
                     '- 当前支线未完成/不确定/阻塞/需要澄清时：必须调用 `tellaskBack({ tellaskContent: "..." })`，不得发普通文本中间汇报。',
-                    '- 当前支线已完成并能给出最终交付时：只服从运行时程序化给出的当前指令。若运行时点名了精确 reply 函数，就调用那个函数；不要自行改选其他 `reply*` 变体，也不要再走 `tellaskBack`。',
+                    `- ${(0, reply_prompt_copy_1.buildSidelineCompletionRule)('zh')}`,
                     `- 仅当运行时当前明确点名了某个精确 reply 函数，且你通过那个函数回复时，运行时才会把该回复投递给上游并标注 ${runtimeMarkers.finalCompleted}。`,
                     '- 若运行时当前明确提示“没有待完成的跨对话回复义务”，说明这轮不是待你收口的跨对话回复义务；不要重复调用 `reply*`。',
                 ],
@@ -176,7 +177,7 @@ function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
                     '- If you define a reply format for downstream, you must state “Dominds auto-injects markers; do not hand-write them”; do not require downstream to hand-write any marker.',
                     '- `tellaskBack` is allowed only for ask-back / clarification / blocked-state reporting; do not use `tellaskBack` to send final results.',
                     '- If the current sideline is unfinished, uncertain, blocked, or needs clarification: you must call `tellaskBack({ tellaskContent: "..." })` instead of posting a plain-text progress update.',
-                    '- If the current sideline is complete and can deliver the final result: follow only the current programmatic runtime instruction. If runtime names an exact reply function, call that function; do not switch among `reply*` variants yourself, and do not use `tellaskBack` for final delivery.',
+                    `- ${(0, reply_prompt_copy_1.buildSidelineCompletionRule)('en')}`,
                     `- Runtime marks ${runtimeMarkers.finalCompleted} and delivers upstream only when runtime currently names an exact reply function and you reply through that named function.`,
                     '- If runtime currently tells you there is no active inter-dialog reply obligation, then this turn is not awaiting another inter-dialog closure from you; do not call `reply*` again.',
                 ],

package/dist/persistence.d.ts

@@ -171,6 +171,7 @@ export declare class DiskFileDialogStore extends DialogStore {
      */
     persistAgentMessage(dialog: Dialog, content: string, genseq: number, type: 'thinking_msg' | 'saying_msg', provider_data?: ProviderData, reasoning?: ReasoningPayload): Promise<void>;
     persistUiOnlyMarkdown(dialog: Dialog, content: string, genseq: number): Promise<void>;
+    persistRuntimeGuide(dialog: Dialog, content: string, genseq: number): Promise<void>;
     /**
      * Persist a function call to storage
      */
@@ -373,6 +374,7 @@ export declare class DialogPersistence {
      * Append event to course JSONL file (append-only pattern)
      */
     static appendEvent(dialogId: DialogID, course: number, event: PersistedDialogRecord, status?: 'running' | 'completed' | 'archived'): Promise<void>;
+    static persistRuntimeGuide(dialog: Dialog, content: string, genseq: number): Promise<void>;
     /**
      * Capture the current byte offset of a course JSONL file.
      * Used as rollback checkpoint before a streaming LLM attempt.

package/dist/persistence.js

@@ -50,6 +50,7 @@ const dialog_1 = require("./dialog");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const async_fifo_mutex_1 = require("./runtime/async-fifo-mutex");
+const reply_prompt_copy_1 = require("./runtime/reply-prompt-copy");
 const work_language_1 = require("./runtime/work-language");
 const registry_1 = require("./tools/registry");
 function getErrorCode(error) {
@@ -1719,6 +1720,16 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         await this.appendEvent(dialog, course, ev);
     }
+    async persistRuntimeGuide(dialog, content, genseq) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const ev = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'runtime_guide_record',
+            genseq,
+            content: content || '',
+        };
+        await this.appendEvent(dialog, course, ev);
+    }
     /**
      * Persist a function call to storage
      */
@@ -2024,6 +2035,23 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 const grammar = 'markdown';
                 const origin = event.origin === 'diligence_push' || event.origin === 'runtime' ? event.origin : 'user';
                 const userLanguageCode = event.userLanguageCode;
+                const renderAsStandaloneRuntimeGuide = origin === 'runtime' && (0, reply_prompt_copy_1.isStandaloneRuntimeGuidePromptContent)(content);
+                if (renderAsStandaloneRuntimeGuide) {
+                    if (ws.readyState === 1) {
+                        const runtimeGuideEvt = {
+                            type: 'runtime_guide_evt',
+                            course,
+                            genseq,
+                            content,
+                        };
+                        ws.send(JSON.stringify({
+                            ...runtimeGuideEvt,
+                            dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                            timestamp: event.ts,
+                        }));
+                    }
+                    break;
+                }
                 if (content) {
                     if (ws.readyState === 1) {
                         ws.send(JSON.stringify({
@@ -2209,6 +2237,25 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
+            case 'runtime_guide_record': {
+                const content = event.content || '';
+                if (!content.trim())
+                    break;
+                if (ws.readyState === 1) {
+                    const runtimeGuideEvt = {
+                        type: 'runtime_guide_evt',
+                        course,
+                        genseq: event.genseq,
+                        content,
+                    };
+                    ws.send(JSON.stringify({
+                        ...runtimeGuideEvt,
+                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                        timestamp: event.ts,
+                    }));
+                }
+                break;
+            }
             case 'ui_only_markdown_record': {
                 const content = event.content || '';
                 if (!content.trim())
@@ -3249,6 +3296,16 @@ class DialogPersistence {
             release();
         }
     }
+    static async persistRuntimeGuide(dialog, content, genseq) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const ev = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'runtime_guide_record',
+            genseq,
+            content,
+        };
+        await this.appendEvent(dialog.id, course, ev, dialog.status);
+    }
     /**
      * Capture the current byte offset of a course JSONL file.
      * Used as rollback checkpoint before a streaming LLM attempt.
@@ -4915,6 +4972,14 @@ class DialogPersistence {
                     });
                     break;
                 }
+                case 'runtime_guide_record': {
+                    messages.push({
+                        type: 'transient_guide_msg',
+                        role: 'assistant',
+                        content: event.content,
+                    });
+                    break;
+                }
                 case 'human_text_record': {
                     // Convert human text to prompting message
                     messages.push({

package/dist/priming.js

@@ -223,6 +223,7 @@ function isPrimingRecordType(raw) {
     return (raw === 'agent_thought_record' ||
         raw === 'agent_words_record' ||
         raw === 'ui_only_markdown_record' ||
+        raw === 'runtime_guide_record' ||
         raw === 'func_call_record' ||
         raw === 'tellask_special_call_record' ||
         raw === 'web_search_call_record' ||
@@ -243,6 +244,7 @@ function getRecordMarkdownTextField(type) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'human_text_record':
         case 'func_result_record':
         case 'tellask_special_call_record':
@@ -620,6 +622,18 @@ function normalizePrimingRecordFromJson(raw) {
             const { ts: _unusedTs, ...withoutTs } = record;
             return withoutTs;
         }
+        case 'runtime_guide_record': {
+            const record = {
+                ts: '',
+                type,
+                genseq: expectIntegerField(raw, 'genseq', context),
+                content: expectStringField(raw, 'content', context, true),
+            };
+            if (sourceTag)
+                record.sourceTag = sourceTag;
+            const { ts: _unusedTs, ...withoutTs } = record;
+            return withoutTs;
+        }
         case 'func_call_record': {
             const argumentsRaw = raw['arguments'];
             if (!isRecord(argumentsRaw)) {
@@ -1562,6 +1576,7 @@ function remapRecordGenseq(record, mapGenseq) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
         case 'web_search_call_record':
@@ -1629,6 +1644,7 @@ function addPrimingSourceTag(record) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
         case 'web_search_call_record':
@@ -1655,6 +1671,7 @@ function withTimestamp(record, ts) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
         case 'web_search_call_record':
@@ -1701,6 +1718,12 @@ function primingRecordToChatMessage(record) {
                 genseq: record.genseq,
                 content: record.content,
             };
+        case 'runtime_guide_record':
+            return {
+                type: 'transient_guide_msg',
+                role: 'assistant',
+                content: record.content,
+            };
         case 'human_text_record':
             return {
                 type: 'prompting_msg',
@@ -1926,6 +1949,11 @@ function formatScriptMarkdown(args) {
                 blockBody = record.content;
                 break;
             }
+            case 'runtime_guide_record': {
+                blockMeta['genseq'] = record.genseq;
+                blockBody = record.content;
+                break;
+            }
             case 'web_search_call_record': {
                 blockMeta['genseq'] = record.genseq;
                 blockMeta['phase'] = record.phase;
@@ -2161,6 +2189,7 @@ function stripTimestampFromRecord(event) {
         case 'agent_thought_record':
         case 'agent_words_record':
         case 'ui_only_markdown_record':
+        case 'runtime_guide_record':
         case 'func_call_record':
         case 'tellask_special_call_record':
         case 'web_search_call_record':

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

@@ -23,6 +23,7 @@ exports.formatTellaskReplacementNoticeContent = formatTellaskReplacementNoticeCo
 exports.formatTellaskCarryoverResultContent = formatTellaskCarryoverResultContent;
 const driver_messages_1 = require("./driver-messages");
 const markdown_format_1 = require("./markdown-format");
+const reply_prompt_copy_1 = require("./reply-prompt-copy");
 function getRuntimeTransferMarkers(language) {
     if (language === 'zh') {
         return {
@@ -79,14 +80,11 @@ function buildSubdialogRoleHeader(input) {
     }
     const requesterId = requireNonEmpty(input.fromAgentId, 'fromAgentId');
     const expectedReplyTool = getExpectedReplyToolName(input.callName);
-    if (!expectedReplyTool) {
-        return input.language === 'zh'
-            ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${requesterId}（当前发起本次诉请）。只有在需要回问上游时才调用 \`tellaskBack\`。`
-            : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${requesterId} (the current caller). Call \`tellaskBack\` only when you need to ask back upstream.`;
-    }
-    return input.language === 'zh'
-        ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${requesterId}（当前发起本次诉请）。本轮精确完成回复函数名是 \`${expectedReplyTool}\`；不要自行改选其他 \`reply*\` 变体。完成任务时必须调用 \`${expectedReplyTool}\`；只有在需要回问上游时才调用 \`tellaskBack\`。`
-        : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${requesterId} (the current caller). The exact completion reply function for this round is \`${expectedReplyTool}\`; do not switch to another \`reply*\` variant by yourself. When the task is complete, you must call \`${expectedReplyTool}\`; call \`tellaskBack\` only when you need to ask back upstream.`;
+    return (0, reply_prompt_copy_1.buildSubdialogRoleHeaderCopy)({
+        language: input.language,
+        requesterId,
+        expectedReplyTool,
+    });
 }
 function requireMentionLine(mentionList) {
     const mentionLine = mentionList

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

@@ -0,0 +1,23 @@
+import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+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 REPLY_REASSERTION_PREFIX_EN = "[Dominds long-line reminder]";
+export declare const REPLY_REASSERTION_PREFIX_ZH = "[Dominds \u957F\u7EBF\u63D0\u9192]";
+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]";
+export declare function buildActiveReplyToolNote(args: {
+    language: LanguageCode;
+    toolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+}): string;
+export declare function buildSidelineCompletionRule(language: LanguageCode): string;
+export declare function buildSubdialogRoleHeaderCopy(args: {
+    language: LanguageCode;
+    requesterId: string;
+    expectedReplyTool?: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | undefined;
+}): string;
+export declare function buildReplyObligationSuppressionGuideText(language: LanguageCode): string;
+export declare function buildReplyObligationReassertionText(args: {
+    language: LanguageCode;
+    toolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+}): string;
+export declare function isStandaloneRuntimeGuidePromptContent(content: string): boolean;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPLY_SUPPRESSION_PREFIX_ZH = exports.REPLY_SUPPRESSION_PREFIX_EN = exports.REPLY_REASSERTION_PREFIX_ZH = exports.REPLY_REASSERTION_PREFIX_EN = exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = exports.ACTIVE_REPLY_TOOL_PREFIX_EN = void 0;
+exports.buildActiveReplyToolNote = buildActiveReplyToolNote;
+exports.buildSidelineCompletionRule = buildSidelineCompletionRule;
+exports.buildSubdialogRoleHeaderCopy = buildSubdialogRoleHeaderCopy;
+exports.buildReplyObligationSuppressionGuideText = buildReplyObligationSuppressionGuideText;
+exports.buildReplyObligationReassertionText = buildReplyObligationReassertionText;
+exports.isStandaloneRuntimeGuidePromptContent = isStandaloneRuntimeGuidePromptContent;
+exports.ACTIVE_REPLY_TOOL_PREFIX_EN = '[Dominds active reply tool]';
+exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = '[Dominds 当前回复工具]';
+exports.REPLY_REASSERTION_PREFIX_EN = '[Dominds long-line reminder]';
+exports.REPLY_REASSERTION_PREFIX_ZH = '[Dominds 长线提醒]';
+exports.REPLY_SUPPRESSION_PREFIX_EN = '[Dominds handle this interjection first]';
+exports.REPLY_SUPPRESSION_PREFIX_ZH = '[Dominds 先接住这轮]';
+function buildActiveReplyToolNote(args) {
+    if (args.language === 'zh') {
+        return [
+            exports.ACTIVE_REPLY_TOOL_PREFIX_ZH,
+            '先专注处理眼前这轮任务，不要被 `reply*` 选择分心。',
+            `若这轮最终需要对上游完成交付，精确调用 \`${args.toolName}\`；不要改选其他 \`reply*\`，也不要提前收口。`,
+        ].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 upstream, call \`${args.toolName}\` exactly; do not switch to another \`reply*\` variant or close early.`,
+    ].join('\n');
+}
+function buildSidelineCompletionRule(language) {
+    return language === 'zh'
+        ? '当前支线已完成并能给出最终交付时：先专注把当前任务做对；若运行时点名了精确 reply 函数，就只在最终交付收口时调用那个函数，不要改选其他 `reply*`，也不要再走 `tellaskBack`。'
+        : 'If the current sideline 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 upstream delivery, do not switch among `reply*` variants, and do not use `tellaskBack` for final delivery.';
+}
+function buildSubdialogRoleHeaderCopy(args) {
+    if (args.expectedReplyTool === undefined) {
+        return args.language === 'zh'
+            ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${args.requesterId}（当前发起本次诉请）。只有在需要回问上游时才调用 \`tellaskBack\`。`
+            : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${args.requesterId} (the current caller). Call \`tellaskBack\` only when you need to ask back upstream.`;
+    }
+    return args.language === 'zh'
+        ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${args.requesterId}（当前发起本次诉请）。先把当前任务做对；若本轮最终需要对上游完成交付，必须精确调用 \`${args.expectedReplyTool}\` 收口，不要改选其他 \`reply*\`。只有在需要回问上游时才调用 \`tellaskBack\`。`
+        : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${args.requesterId} (the current caller). First, do the current task correctly; if this round ultimately needs final delivery back upstream, you must close with \`${args.expectedReplyTool}\` exactly and must not switch to another \`reply*\` variant. Call \`tellaskBack\` only when you need to ask back upstream.`;
+}
+function buildReplyObligationSuppressionGuideText(language) {
+    if (language === 'zh') {
+        return [
+            exports.REPLY_SUPPRESSION_PREFIX_ZH,
+            '先把用户刚插进来的这轮正常接住，按眼前的话题继续回答。',
+            '原来那条长线先放一放，别急着顺着它往下收口。',
+            '等相关支线结果回来后，运行时会再提醒你把那条线接回去。',
+        ].join('\n');
+    }
+    return [
+        exports.REPLY_SUPPRESSION_PREFIX_EN,
+        "First, handle the user's interjection normally and keep answering the topic in front of you.",
+        'Set the earlier long-line thread aside for now; do not rush to close it yet.',
+        'When the related sideline result comes back, runtime will remind you to pick that thread up again.',
+    ].join('\n');
+}
+function buildReplyObligationReassertionText(args) {
+    if (args.language === 'zh') {
+        return [
+            exports.REPLY_REASSERTION_PREFIX_ZH,
+            '刚才那轮用户插话已经先接住了，现在继续原来那条长线任务本身。',
+            '继续做该做的事，别只盯着 `reply*` 工具名。',
+            `真走到需要对上游完成交付的时候，再精确调用 \`${args.toolName}\`；这条提醒不是在催你立刻收口。`,
+        ].join('\n');
+    }
+    return [
+        exports.REPLY_REASSERTION_PREFIX_EN,
+        'The user interjection has already been handled first; now continue the original longer-running task itself.',
+        'Keep doing the actual work instead of fixating on the `reply*` tool name.',
+        `Only when that work truly reaches final delivery upstream should you call \`${args.toolName}\`; this reminder is not asking you to close immediately.`,
+    ].join('\n');
+}
+function isStandaloneRuntimeGuidePromptContent(content) {
+    return (content.startsWith(exports.REPLY_REASSERTION_PREFIX_ZH) ||
+        content.startsWith(exports.REPLY_REASSERTION_PREFIX_EN) ||
+        content.startsWith(exports.REPLY_SUPPRESSION_PREFIX_ZH) ||
+        content.startsWith(exports.REPLY_SUPPRESSION_PREFIX_EN));
+}

package/dist/shared/utils/fbr.js

@@ -15,20 +15,24 @@ function appendDistinctPerspectiveFbrBody(input) {
         if (input.language === 'zh') {
             return [
                 iteration === 1
-                    ? `【第 ${iteration}/${total} 轮 FBR】请开启首轮独立推理角度。`
-                    : `【第 ${iteration}/${total} 轮 FBR】请切换到与前 ${iteration - 1} 轮不同的推理角度。`,
+                    ? `【第 ${iteration}/${total} 轮 FBR 发散】请开启首轮独立推理角度。`
+                    : `【第 ${iteration}/${total} 轮 FBR 发散】请切换到与前 ${iteration - 1} 轮不同的推理角度。`,
+                '这一阶段要对反直觉、离谱、少数派、最后可能被淘汰的想法保持开放，把它们先当作待检验候选，而不是急着压成共识。',
                 isFinalRound
-                    ? '最后一轮也不能复述前文结论，必须补充新的切入点与新增证据。'
-                    : '要求：不复述上一轮已结论文本，补充本轮独立切入点与未覆盖证据。',
+                    ? '最后一轮发散也不能复述前文结论；必须继续补充新的切入点、额外证据或新的解释路径。'
+                    : '要求：不复述前几轮已结论文本；补充本轮独立切入点、未覆盖证据或新的解释路径。',
+                '此时不要急于收敛或下最终结论。',
             ].join('\n');
         }
         return [
             iteration === 1
-                ? `[FBR round ${iteration}/${total}] start with a first independent reasoning angle.`
-                : `[FBR round ${iteration}/${total}] switch to an angle different from the previous ${iteration - 1} rounds.`,
+                ? `[FBR divergence round ${iteration}/${total}] start with a first independent reasoning angle.`
+                : `[FBR divergence round ${iteration}/${total}] switch to an angle different from the previous ${iteration - 1} rounds.`,
+            'In this phase, stay open to counterintuitive, wild, minority, or eventually-discarded ideas; treat them as candidates to test instead of forcing early consensus.',
             isFinalRound
-                ? 'The final round must also avoid repeating prior-round conclusions and provide new angles and additional evidence.'
-                : 'Requirement: do not repeat prior-round conclusion text; add a distinct independent approach and missing evidence.',
+                ? 'The final divergence round must still avoid repeating prior-round conclusions and add new angles, extra evidence, or alternative explanations.'
+                : 'Requirement: do not repeat prior-round conclusion text; add a distinct approach, missing evidence, or a genuinely new explanatory path.',
+            'Do not converge or produce a final conclusion yet.',
         ].join('\n');
     })();
     if (iteration <= 1) {

package/dist/shared/utils/inter-dialog-format.js

@@ -111,9 +111,10 @@ function formatAssignmentFromSupdialog(input) {
                 '# 扪心自问（FBR）自诉请',
                 '',
                 '- 约束：这是一个扪心自问（self tellask）支线对话；请独立推理与总结。',
-                '- 系统规则：本支线对话为函数禁用模式，不允许任何函数调用（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`）。',
+                '- 系统规则：当前仍处于 FBR 的无工具阶段；这一阶段不允许任何函数调用。',
+                '- 后续只有在完成既定的发散轮与收敛轮之后，运行时才会开放两个“结论函数”供你正式收口。',
                 '- 协议：回贴标记由 Dominds 运行时自动注入，禁止手写。',
-                '- 系统提示：不要受诉请正文中的定调、分析方向或维度清单约束；请聚焦总体目标，自由发挥并开辟新的分析切入角度。',
+                '- 系统提示：不要受诉请正文中的定调、分析方向或维度清单约束；请聚焦总体目标，自由发挥并开辟新的分析切入角度，对离谱想法保持开放，但不要过早收敛。',
                 '',
                 '---',
             ].join('\n')
@@ -121,9 +122,10 @@ function formatAssignmentFromSupdialog(input) {
                 '# Fresh Boots Reasoning (FBR) request',
                 '',
                 '- Constraint: this is a self-tellask FBR sideline dialog; reason independently and produce conclusions.',
-                '- System rule: this sideline runs with function-calls disabled; do not emit any function call (including `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
+                '- 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.',
-                '- System prompt: do not be constrained by framing, analysis directions, or dimension checklists embedded in the tellask body; stay focused on the overall objective and open new analytical entry points freely.',
+                '- 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.',
                 '',
                 '---',
             ].join('\n');

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

@@ -82,6 +82,7 @@ Taskdoc is a **task contract** defining goals, constraints, and progress.
 
 ### Low-Burden Rule
 
+- Focus on doing the current task correctly first; use `reply*` only when final upstream 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