dominds 1.18.2 → 1.19.2

package/dist/runtime/driver-messages.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSystemNoticePrefix = formatSystemNoticePrefix;
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
 exports.formatUserLanguagePreferenceChangedNotice = formatUserLanguagePreferenceChangedNotice;
-exports.formatRegisteredTellaskCallerUpdateNotice = formatRegisteredTellaskCallerUpdateNotice;
-exports.formatRegisteredTellaskCalleeUpdateNotice = formatRegisteredTellaskCalleeUpdateNotice;
+exports.formatRegisteredTellaskTellaskerUpdateNotice = formatRegisteredTellaskTellaskerUpdateNotice;
+exports.formatRegisteredTellaskTellaskeeUpdateNotice = formatRegisteredTellaskTellaskeeUpdateNotice;
 exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatDiligenceAutoContinuePrompt = formatDiligenceAutoContinuePrompt;
 exports.formatReminderContextGuide = formatReminderContextGuide;
+exports.formatReminderContextFooter = formatReminderContextFooter;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
@@ -74,7 +75,7 @@ function formatUserLanguagePreferenceChangedNotice(workingLanguage, previousUiLa
         'Continue the current task itself.',
     ].join('\n');
 }
-function formatRegisteredTellaskCallerUpdateNotice(language) {
+function formatRegisteredTellaskTellaskerUpdateNotice(language) {
     const prefix = formatSystemNoticePrefix(language);
     if (language === 'zh') {
         return [
@@ -87,7 +88,7 @@ function formatRegisteredTellaskCallerUpdateNotice(language) {
         'You no longer need to wait on that earlier request. The teammate will continue under your updated request, so treat the latest request as the one now in effect.',
     ].join('\n');
 }
-function formatRegisteredTellaskCalleeUpdateNotice(language) {
+function formatRegisteredTellaskTellaskeeUpdateNotice(language) {
     const prefix = formatSystemNoticePrefix(language);
     if (language === 'zh') {
         return [
@@ -153,21 +154,26 @@ function formatDiligenceAutoContinuePrompt(language, diligenceText) {
 function formatReminderContextGuide(language) {
     if (language === 'zh') {
         return [
-            formatSystemNoticePrefix(language),
-            '以下是当前可见提醒项的运行时上下文投影。它们会按各自语义进入模型上下文（例如 self-reminder 保持 assistant-side 工作集语义），但不是我刚刚生成给用户的聊天正文。',
+            `${formatSystemNoticePrefix(language)} 提醒项上下文块开始`,
+            '以下是当前可见提醒项的运行时上下文投影。由于当前 LLM Provider 通常不支持 role=environment，Dominds 默认把系统运行时提醒包装投影为 role=user；个别提醒项可由其 owner 按自身契约选择 role。无论最终 role 如何，它们都不是新的用户指令/诉求，也不是聊天正文。',
             '在 WebUI 中，用户通过独立的 Reminder 小组件/面板项看到这些提醒，并能把它们和聊天正文区分开。',
-            '提醒项只作为工作集/状态参考；只有实际改变当前判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。',
+            '请把提醒项作为工作集/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
         ].join('\n');
     }
     return [
-        formatSystemNoticePrefix(language),
-        'The following visible reminders are runtime-added context projections. They enter model context according to their own semantics (for example, self-reminders keep assistant-side workset semantics), but they are not chat text I just generated for the user.',
+        `${formatSystemNoticePrefix(language)} Reminder context block begins`,
+        'The following visible reminders are runtime-added context projections. Because current LLM providers usually do not support role=environment, Dominds projects default system-runtime reminder wrappers as role=user; individual reminder owners may choose the role required by their own contract. Regardless of their final role, these reminders are not new user instructions or requests, and not chat transcript text.',
         'In the WebUI, the user sees these reminders through a separate Reminder widget/panel item and can distinguish them from the chat transcript.',
-        'Use reminders as workset/state references; only carry information into a later substantive outward reply when it materially changes current judgment, plan, or risk.',
+        'Use reminders as workset/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
     ].join('\n');
 }
 function formatReminderItemProjectionNote(language) {
-    return language === 'zh' ? 'Reminder 上下文投影条目：' : 'Reminder context projection item:';
+    return language === 'zh' ? '运行时提醒项投影：' : 'Runtime reminder projection:';
+}
+function formatReminderContextFooter(language) {
+    return language === 'zh'
+        ? `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户指令；该块之外的后续对话消息不受此说明影响。真正的用户指令（若有）在后续对话消息中的用户消息里。`
+        : `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between "Reminder context block begins" and "Reminder context block ends" are system reminders, not user instructions; this note does not apply to subsequent dialog messages outside this block. Any real user instruction, if present, is in the user messages that follow.`;
 }
 function formatReminderItemGuide(language, reminderId, content, options) {
     function isRecord(value) {
@@ -201,28 +207,31 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         : undefined;
     const deleteInstruction = language === 'zh'
         ? deleteAltInstruction
-            ? `如果我要删除这条提醒项，不能用 delete_reminder；请执行：${deleteAltInstruction}`
+            ? `如果你要删除这条提醒项，不能用 delete_reminder；请执行：${deleteAltInstruction}`
             : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `如果我已确认这里只是清理噪音、并非要推进动作，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `如果我要删除这条提醒项，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
+                ? `如果你已确认这里只是清理噪音、并非要推进动作，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
+                : `如果你要删除这条提醒项，可执行：delete_reminder({ "reminder_id": "${reminderId}" })`
         : deleteAltInstruction
-            ? `If I need to delete this reminder, I must not use delete_reminder; run: ${deleteAltInstruction}`
+            ? `If you need to delete this reminder, do not use delete_reminder; run: ${deleteAltInstruction}`
             : isPendingTellaskReminder && pendingTellaskCount === 0
-                ? `If I have confirmed this is only noise cleanup and not an action step, I may run: delete_reminder({ "reminder_id": "${reminderId}" })`
-                : `If I need to delete this reminder, run: delete_reminder({ "reminder_id": "${reminderId}" })`;
+                ? `If you have confirmed this is only noise cleanup and not an action step, you may run: delete_reminder({ "reminder_id": "${reminderId}" })`
+                : `If you need to delete this reminder, run: delete_reminder({ "reminder_id": "${reminderId}" })`;
     const projectionNote = formatReminderItemProjectionNote(language);
     const enProjectionPrefix = `${projectionNote} `;
+    const systemPrefix = formatSystemNoticePrefix(language);
     if (language === 'zh') {
         if (managementTool) {
             const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
             return [
-                `提醒项 [${reminderId}]（工具状态）`,
+                `${systemPrefix} 提醒项 [${reminderId}]（工具状态）`,
+                '',
+                `${projectionNote}当前运行环境中有一条由工具 ${managementTool} 管理的状态提醒项。请把它当作环境/工具状态参考，不要当作你自己写的工作便签。`,
                 '',
-                `${projectionNote}我把这条当作工具维护的状态参考。默认不在对外回复里专门确认、复述或总结它；只有它实际改变当前判断、计划或风险时，我才提炼真正相关的部分。`,
+                '默认不要在对外回复里专门确认、复述或总结它；只有它实际改变你的判断、计划或风险时，才提炼真正相关的部分。',
                 '',
-                `这条提醒项由工具 ${managementTool} 管理；如果我要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
+                `这条提醒项由工具 ${managementTool} 管理；如果你要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
                 '',
-                `如果我要更新这条提醒项，可执行：${updateInstructionSafe}`,
+                `如果你要更新这条提醒项，可执行：${updateInstructionSafe}`,
                 deleteInstruction,
                 '',
                 '---',
@@ -231,11 +240,11 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         }
         if (updateInstruction) {
             return [
-                `提醒项 [${reminderId}]`,
+                `${systemPrefix} 提醒项 [${reminderId}]`,
                 '',
-                `${projectionNote}这是带有 meta 控制更新规则的提醒项。我仍把它当作状态参考，但不要用 update_reminder 直接改写内容。`,
+                `${projectionNote}当前运行环境中有一条带有 meta 控制更新规则的提醒项。请把它当作状态参考，不要用 update_reminder 直接改写内容。`,
                 '',
-                `如果我要更新这条提醒项，不能用 update_reminder；请按此处理：${updateInstruction}`,
+                `如果你要更新这条提醒项，不能用 update_reminder；请按此处理：${updateInstruction}`,
                 deleteInstruction,
                 '',
                 '---',
@@ -244,13 +253,13 @@ function formatReminderItemGuide(language, reminderId, content, options) {
         }
         if (isContinuationPackageReminder) {
             return [
-                `提醒项 [${reminderId}]（换程接续信息）`,
+                `${systemPrefix} 提醒项 [${reminderId}]（换程接续信息）`,
                 '',
-                `${projectionNote}我把这条当作换程后快速恢复工作的接续包，不把它自动当成当前必须立刻执行的指令。`,
+                `${projectionNote}你设置了换程接续提醒项，让运行时系统在新一程提醒你恢复工作。请把它当作快速恢复工作的接续包，不要自动当成当前必须立刻执行的新指令。`,
                 '',
-                '我应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，我的第一步就是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后我必须尽快收敛。',
+                '你应优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，你的第一步是以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
                 '',
-                `如果我要更新这份接续包，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
+                `如果你要更新这份接续包，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
                 deleteInstruction,
                 '',
                 '---',
@@ -258,17 +267,17 @@ function formatReminderItemGuide(language, reminderId, content, options) {
             ].join('\n');
         }
         return [
-            `提醒项 [${reminderId}]${scope === 'personal' ? '（个人范围）' : ''}`,
+            `${systemPrefix} 提醒项 [${reminderId}]${scope === 'personal' ? '（个人范围）' : ''}`,
             '',
             scope === 'personal'
-                ? `${projectionNote}这是我给自己的个人范围显眼提示；在所有由我主理的后续对话里都会看到它。我不把它自动当成系统下发的下一步动作。`
-                : `${projectionNote}这是我给自己的显眼提示，用于保留当前对话里容易丢的工作信息；我不把它自动当成系统下发的下一步动作。`,
+                ? `${projectionNote}你设置了个人范围提醒项，让运行时系统在所有由你主理的后续对话里提醒你。请把它当作你的工作集提示，不要自动当成系统下发的下一步动作。`
+                : `${projectionNote}你设置了提醒项，让运行时系统提醒你。请把它当作用来保留当前对话里容易丢的工作信息的工作集提示，不要自动当成系统下发的下一步动作。`,
             '',
             scope === 'personal'
-                ? '我应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒而不是长期堆在个人范围里。'
-                : '我应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。',
+                ? '你应保持简洁、及时更新；不再需要时就删除。若它只对当前对话有效，应改写成 dialog 范围提醒而不是长期堆在个人范围里。'
+                : '你应保持简洁、及时更新；不再需要时就删除。若后续准备换程，也可以把它整理成接续包。',
             '',
-            `如果我要更新这条提醒项，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
+            `如果你要更新这条提醒项，可执行：update_reminder({ "reminder_id": "${reminderId}", "content": "..." })`,
             deleteInstruction,
             '',
             '---',
@@ -277,50 +286,52 @@ function formatReminderItemGuide(language, reminderId, content, options) {
     }
     if (managementTool) {
         const updateInstructionSafe = updateInstruction ?? `${managementTool}({ ... })`;
-        return `REMINDER [${reminderId}] (TOOL STATE)
+        return `${systemPrefix} REMINDER [${reminderId}] (TOOL STATE)
+
+${enProjectionPrefix}The current runtime environment has a tool-managed state reminder from ${managementTool}. Treat it as environment/tool state, not as your self-authored work note.
 
-${enProjectionPrefix}I treat this as a tool-maintained state reference. By default I should not explicitly acknowledge, restate, or summarize it in my outward reply; I should only extract the parts that materially change my current judgment, plan, or risk.
+By default, do not explicitly acknowledge, restate, or summarize it in your outward reply; only extract the parts that materially change your current judgment, plan, or risk.
 
-This reminder is managed by tool ${managementTool}; if I need to change it, I should use ${managementTool} instead of update_reminder.
+This reminder is managed by tool ${managementTool}; if you need to change it, use ${managementTool} instead of update_reminder.
 
-If I need to update this reminder, run: ${updateInstructionSafe}
+If you need to update this reminder, run: ${updateInstructionSafe}
 ${deleteInstruction}
 ---
 ${content}`;
     }
     if (updateInstruction) {
-        return `REMINDER [${reminderId}]
+        return `${systemPrefix} REMINDER [${reminderId}]
 
-${enProjectionPrefix}This reminder has a meta-controlled update path. I should still treat it as state/reference, and I must not rewrite it directly with update_reminder.
+${enProjectionPrefix}The current runtime environment has a reminder with a meta-controlled update path. Treat it as state/reference, and do not rewrite it directly with update_reminder.
 
-If I need to update this reminder, I must not use update_reminder; follow instead: ${updateInstruction}
+If you need to update this reminder, do not use update_reminder; follow instead: ${updateInstruction}
 ${deleteInstruction}
 ---
 ${content}`;
     }
     if (isContinuationPackageReminder) {
-        return `REMINDER [${reminderId}] (CONTINUATION PACKAGE)
+        return `${systemPrefix} REMINDER [${reminderId}] (CONTINUATION PACKAGE)
 
-${enProjectionPrefix}I treat this as resume information for the next course, not as an automatic must-do command.
+${enProjectionPrefix}You set a continuation reminder so the runtime system can remind you when work resumes in a new course. Treat it as resume information for the next course, not as an automatic must-do command.
 
-I should keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. I should not duplicate Taskdoc content. In the new course, my first step is to review and rewrite this with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress it into a high-quality reminder. If this is only a rough bridge note, I should reconcile it early in the new course.
+Keep the next step, key pointers, run/verify info, and easy-to-lose volatile details here. Do not duplicate Taskdoc content. In the new course, your first step is to review and rewrite this with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress it into a high-quality reminder. If this is only a rough bridge note, reconcile it early in the new course.
 
-If I need to update this package, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
+If you need to update this package, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
 ${deleteInstruction}
 ---
 ${content}`;
     }
-    return `REMINDER [${reminderId}]${scope === 'personal' ? ' (PERSONAL SCOPE)' : ''}
+    return `${systemPrefix} REMINDER [${reminderId}]${scope === 'personal' ? ' (PERSONAL SCOPE)' : ''}
 
 ${scope === 'personal'
-        ? `${enProjectionPrefix}This is my conspicuous personal-scope reminder. I will keep seeing it in all later dialogs I lead, and I do not treat it as an automatically assigned next action.`
-        : `${enProjectionPrefix}This is my conspicuous self-reminder for easy-to-lose work details in the current dialog. I do not treat it as an automatically assigned next action.`}
+        ? `${enProjectionPrefix}You set a personal-scope reminder so the runtime system can remind you in every later dialog you lead. Treat it as your workset reference, not as an automatically assigned next action.`
+        : `${enProjectionPrefix}You set a reminder so the runtime system can remind you. Treat it as your workset reference for easy-to-lose work details in the current dialog, not as an automatically assigned next action.`}
 
 ${scope === 'personal'
-        ? 'I should keep it concise, refresh it when needed, and delete it when obsolete. If it is only useful for the current dialog, I should rewrite it into dialog scope instead of letting personal scope accumulate noise.'
-        : 'I should keep it concise, refresh it when needed, and delete it when obsolete. If I am preparing a new course, I can also rewrite it into a continuation package.'}
+        ? 'Keep it concise, refresh it when needed, and delete it when obsolete. If it is only useful for the current dialog, rewrite it into dialog scope instead of letting personal scope accumulate noise.'
+        : 'Keep it concise, refresh it when needed, and delete it when obsolete. If you are preparing a new course, you can also rewrite it into a continuation package.'}
 
-If I need to update this reminder, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
+If you need to update this reminder, run: update_reminder({ "reminder_id": "${reminderId}", "content": "..." })
 ${deleteInstruction}
 ---
 ${content}`;
@@ -470,18 +481,18 @@ function formatDomindsNoteFbrToollessViolation(language, args) {
         ].join('\n');
     }
     const detail = kind === 'tellask'
-        ? 'Detected a tellask-special invocation attempt inside an FBR sideline dialog.'
+        ? 'Detected a tellask-special invocation attempt inside an FBR Side Dialog.'
         : kind === 'tool'
-            ? 'Detected a function tool call attempt inside an FBR sideline dialog.'
+            ? 'Detected a function tool call attempt inside an FBR Side Dialog.'
             : kind === 'tellask_and_tool'
-                ? 'Detected both tellask-special and tool-call attempts inside an FBR sideline dialog.'
-                : 'Internal error: cannot safely drive the FBR sideline dialog.';
+                ? 'Detected both tellask-special and tool-call attempts inside an FBR Side Dialog.'
+                : 'Internal error: cannot safely drive the FBR Side Dialog.';
     return [
         'ERR_FBR_TOOLLESS_VIOLATION',
-        `Dominds note: this is a tool-less FBR sideline dialog (triggered by \`freshBootsReasoning\`). ${detail}`,
+        `Dominds note: this is a tool-less FBR Side Dialog (triggered by \`freshBootsReasoning\`). ${detail}`,
         '',
         '- No tools are available: do not emit function tool calls.',
         '- No tellask-special functions are allowed (`tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`).',
-        '- Provide pure reasoning and a summary grounded in the tellask body (and this sideline dialog’s own tellaskSession history, if any).',
+        '- Provide pure reasoning and a summary grounded in the tellask body (and this Side Dialog’s own tellaskSession history, if any).',
     ].join('\n');
 }

package/dist/runtime/inter-dialog-format.d.ts

@@ -21,7 +21,7 @@ export type InterDialogParticipants = {
     fromAgentId: string;
     toAgentId: string;
 };
-export type SubdialogAssignmentFormatInput = InterDialogParticipants & InterDialogCallContent & {
+export type SideDialogAssignmentFormatInput = InterDialogParticipants & InterDialogCallContent & {
     language?: LanguageCode;
     collectiveTargets?: string[];
     sessionSlug?: string;
@@ -30,17 +30,18 @@ export type SubdialogAssignmentFormatInput = InterDialogParticipants & InterDial
         total: number;
     };
 };
-export type SupdialogCallPromptInput = {
+export type AskerDialogCallPromptInput = {
     fromAgentId: string;
     toAgentId: string;
-    subdialogRequest: InterDialogCallContent;
-    supdialogAssignment: InterDialogCallContent;
+    sideDialogRequest: InterDialogCallContent;
+    askerDialogAssignment: InterDialogCallContent;
     language?: LanguageCode;
 };
 export type TellaskResponseFormatInput = {
     callName: 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
+    callId: string;
     responderId: string;
-    requesterId: string;
+    tellaskerId: string;
     mentionList?: string[];
     sessionSlug?: string;
     tellaskContent: string;
@@ -51,7 +52,7 @@ export type TellaskResponseFormatInput = {
 };
 export type TellaskReplacementNoticeFormatInput = {
     responderId: string;
-    requesterId: string;
+    tellaskerId: string;
     mentionList?: string[];
     sessionSlug?: string;
     tellaskContent: string;
@@ -59,8 +60,9 @@ export type TellaskReplacementNoticeFormatInput = {
     language?: LanguageCode;
 };
 export type TellaskCarryoverResultFormatInput = {
-    originCourse: number;
+    callSiteCourse: number;
     callName: 'tellask' | 'tellaskSessionless' | 'askHuman' | 'freshBootsReasoning';
+    callId: string;
     responderId: string;
     mentionList?: string[];
     sessionSlug?: string;
@@ -76,9 +78,9 @@ export type RuntimeTransferMarkers = Readonly<{
     fbrReasoningOnly: string;
 }>;
 export declare function getRuntimeTransferMarkers(language: LanguageCode): RuntimeTransferMarkers;
-export declare function formatAssignmentFromSupdialog(input: SubdialogAssignmentFormatInput): string;
-export declare function formatUpdatedAssignmentFromSupdialog(input: SubdialogAssignmentFormatInput): string;
-export declare function formatSupdialogCallPrompt(input: SupdialogCallPromptInput): string;
+export declare function formatAssignmentFromAskerDialog(input: SideDialogAssignmentFormatInput): string;
+export declare function formatUpdatedAssignmentFromAskerDialog(input: SideDialogAssignmentFormatInput): string;
+export declare function formatAskerDialogCallPrompt(input: AskerDialogCallPromptInput): string;
 export declare function formatTellaskResponseContent(input: TellaskResponseFormatInput): string;
 export declare function formatTeammateResponseContent(input: TellaskResponseFormatInput): string;
 export declare function formatTellaskReplacementNoticeContent(input: TellaskReplacementNoticeFormatInput): string;

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

@@ -14,9 +14,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeTransferMarkers = getRuntimeTransferMarkers;
-exports.formatAssignmentFromSupdialog = formatAssignmentFromSupdialog;
-exports.formatUpdatedAssignmentFromSupdialog = formatUpdatedAssignmentFromSupdialog;
-exports.formatSupdialogCallPrompt = formatSupdialogCallPrompt;
+exports.formatAssignmentFromAskerDialog = formatAssignmentFromAskerDialog;
+exports.formatUpdatedAssignmentFromAskerDialog = formatUpdatedAssignmentFromAskerDialog;
+exports.formatAskerDialogCallPrompt = formatAskerDialogCallPrompt;
 exports.formatTellaskResponseContent = formatTellaskResponseContent;
 exports.formatTeammateResponseContent = formatTeammateResponseContent;
 exports.formatTellaskReplacementNoticeContent = formatTellaskReplacementNoticeContent;
@@ -75,15 +75,15 @@ function getExpectedReplyToolName(callName) {
             return undefined;
     }
 }
-function buildSubdialogRoleHeader(input) {
+function buildSideDialogRoleHeader(input) {
     if (input.callName === 'freshBootsReasoning') {
         return '';
     }
-    const requesterId = requireNonEmpty(input.fromAgentId, 'fromAgentId');
+    const tellaskerId = requireNonEmpty(input.fromAgentId, 'fromAgentId');
     const expectedReplyTool = getExpectedReplyToolName(input.callName);
-    return (0, reply_prompt_copy_1.buildSubdialogRoleHeaderCopy)({
+    return (0, reply_prompt_copy_1.buildSideDialogRoleHeaderCopy)({
         language: input.language,
-        requesterId,
+        tellaskerId,
         expectedReplyTool,
     });
 }
@@ -112,13 +112,36 @@ function formatQuotedRequestBlock(args) {
     lines.push((0, markdown_format_1.markdownQuote)(requireNonEmpty(args.body, 'body')));
     return lines.join('\n');
 }
-function formatAssignmentFromSupdialog(input) {
+function formatTellaskStatusFootnote(args) {
+    const callId = requireNonEmpty(args.callId, 'callId');
+    if (args.language === 'zh') {
+        const explanation = args.crossCourse === true
+            ? '这是前序诉请的跨程回贴事实，不是新的用户请求，也不是当前程新发起的函数调用。'
+            : '这是前序诉请的回贴事实，不是新的用户请求，也不是当前程新发起的函数调用。';
+        return [
+            '[Dominds 诉请状态]',
+            `- 函数: \`${args.callName}\``,
+            `- callId: ${callId}`,
+            `- 说明: ${explanation}`,
+        ].join('\n');
+    }
+    const explanation = args.crossCourse === true
+        ? '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]',
+        `- Function: \`${args.callName}\``,
+        `- callId: ${callId}`,
+        `- Note: ${explanation}`,
+    ].join('\n');
+}
+function formatAssignmentFromAskerDialog(input) {
     const language = input.language ?? 'en';
     const runtimeMarkers = getRuntimeTransferMarkers(language);
     requireNonEmpty(input.toAgentId, 'toAgentId');
     requireNonEmpty(input.fromAgentId, 'fromAgentId');
     const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
-    const roleHeader = buildSubdialogRoleHeader({
+    const roleHeader = buildSideDialogRoleHeader({
         callName: input.callName,
         fromAgentId: input.fromAgentId,
         language,
@@ -149,7 +172,7 @@ function formatAssignmentFromSupdialog(input) {
             : [
                 '# Fresh Boots Reasoning (FBR) request',
                 '',
-                '- Constraint: this is a self-tellask FBR sideline dialog; reason independently and produce conclusions.',
+                '- 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.',
@@ -179,23 +202,23 @@ function formatAssignmentFromSupdialog(input) {
         body: tellaskContent,
     })}\n`;
 }
-function formatUpdatedAssignmentFromSupdialog(input) {
+function formatUpdatedAssignmentFromAskerDialog(input) {
     const language = input.language ?? 'en';
     return [
-        (0, driver_messages_1.formatRegisteredTellaskCalleeUpdateNotice)(language),
+        (0, driver_messages_1.formatRegisteredTellaskTellaskeeUpdateNotice)(language),
         '',
         '---',
         '',
-        formatAssignmentFromSupdialog(input).trimEnd(),
+        formatAssignmentFromAskerDialog(input).trimEnd(),
         '',
     ].join('\n');
 }
-function formatSupdialogCallPrompt(input) {
+function formatAskerDialogCallPrompt(input) {
     const language = input.language ?? 'en';
     const supMention = (() => {
-        if (input.supdialogAssignment.callName === 'tellask' ||
-            input.supdialogAssignment.callName === 'tellaskSessionless') {
-            return requireMentionLine(input.supdialogAssignment.mentionList ?? []);
+        if (input.askerDialogAssignment.callName === 'tellask' ||
+            input.askerDialogAssignment.callName === 'tellaskSessionless') {
+            return requireMentionLine(input.askerDialogAssignment.mentionList ?? []);
         }
         return '';
     })();
@@ -203,9 +226,9 @@ function formatSupdialogCallPrompt(input) {
     const toAgentId = requireNonEmpty(input.toAgentId, 'toAgentId');
     const askBackLabel = (0, tellask_labels_1.getTellaskKindLabel)({ language, name: 'tellaskBack', bracketed: true });
     const subMention = (() => {
-        if (input.subdialogRequest.callName === 'tellask' ||
-            input.subdialogRequest.callName === 'tellaskSessionless') {
-            return requireMentionLine(input.subdialogRequest.mentionList ?? []);
+        if (input.sideDialogRequest.callName === 'tellask' ||
+            input.sideDialogRequest.callName === 'tellaskSessionless') {
+            return requireMentionLine(input.sideDialogRequest.mentionList ?? []);
         }
         return '';
     })();
@@ -220,13 +243,13 @@ function formatSupdialogCallPrompt(input) {
         formatQuotedRequestBlock({
             title: originalTitle,
             mentionLine: supMention,
-            body: requireNonEmpty(input.supdialogAssignment.tellaskContent, 'assignmentTellaskContent'),
+            body: requireNonEmpty(input.askerDialogAssignment.tellaskContent, 'assignmentTellaskContent'),
         }),
         '',
         formatQuotedRequestBlock({
             title: askBackTitle,
             mentionLine: subMention,
-            body: requireNonEmpty(input.subdialogRequest.tellaskContent, 'requestTellaskContent'),
+            body: requireNonEmpty(input.sideDialogRequest.tellaskContent, 'requestTellaskContent'),
         }),
         '',
     ].join('\n');
@@ -239,12 +262,17 @@ function formatTellaskResponseContent(input) {
     const markerPrefix = marker ? `${marker}\n\n` : '';
     const deliveryNotice = input.deliveryMode === 'direct_fallback'
         ? language === 'zh'
-            ? '> 系统提示：本次回贴未调用 replyTellask* 工具，当前按“直接回复 fallback”投递；请留意这只是过渡期兼容路径。\n\n'
-            : '> System note: this reply did not use a replyTellask* tool. It is being delivered via direct-reply fallback for now; treat this as a temporary compatibility path.\n\n'
+            ? '> 系统提示：本次回贴未调用 replyTellask* 工具，Dominds 已按 direct-reply fallback 投递，并保留此标记便于追踪。\n\n'
+            : '> System note: this reply did not use a replyTellask* tool. Dominds delivered it via direct-reply fallback and kept this marker for traceability.\n\n'
         : '';
     if (isFbr) {
-        const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR sideline response]';
-        return `${markerPrefix}${deliveryNotice}${title}\n\n${input.responseBody}\n`;
+        const title = language === 'zh' ? '【扪心自问（FBR）支线对话回贴】' : '[FBR Side Dialog response]';
+        const statusFootnote = formatTellaskStatusFootnote({
+            language,
+            callName: input.callName,
+            callId: input.callId,
+        });
+        return `${markerPrefix}${deliveryNotice}${title}\n\n${input.responseBody}\n\n${statusFootnote}\n`;
     }
     if (input.callName !== 'tellask' &&
         input.callName !== 'tellaskSessionless' &&
@@ -256,7 +284,7 @@ function formatTellaskResponseContent(input) {
             .map((item) => stripMentionPrefix(item))
             .filter((item) => item !== '');
         if (mentionIds.length === 0) {
-            return `@${requireNonEmpty(input.requesterId, 'requesterId')}`;
+            return `@${requireNonEmpty(input.tellaskerId, 'tellaskerId')}`;
         }
         return mentionIds.map((mentionId) => `@${mentionId}`).join(' ');
     })();
@@ -271,7 +299,12 @@ function formatTellaskResponseContent(input) {
         : sessionSlug === ''
             ? `regarding the original tellask: ${mentionLine}`
             : `regarding the original tellask: ${mentionLine} • ${sessionSlug}`;
-    return `${markerPrefix}${deliveryNotice}${hello}\n\n${(0, markdown_format_1.markdownQuote)(input.responseBody)}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
+    const statusFootnote = formatTellaskStatusFootnote({
+        language,
+        callName: input.callName,
+        callId: input.callId,
+    });
+    return `${markerPrefix}${deliveryNotice}${hello}\n\n${(0, markdown_format_1.markdownQuote)(input.responseBody)}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n\n${statusFootnote}\n`;
 }
 function formatTeammateResponseContent(input) {
     return formatTellaskResponseContent(input);
@@ -284,7 +317,7 @@ function formatTellaskReplacementNoticeContent(input) {
         .map((item) => stripMentionPrefix(item))
         .filter((item) => item !== '');
     const mentionLine = mentionIds.length === 0
-        ? `@${requireNonEmpty(input.requesterId, 'requesterId')}`
+        ? `@${requireNonEmpty(input.tellaskerId, 'tellaskerId')}`
         : mentionIds.map((mentionId) => `@${mentionId}`).join(' ');
     const sessionSlug = input.sessionSlug?.trim() ?? '';
     const tail = language === 'zh'
@@ -328,11 +361,17 @@ function formatTellaskCarryoverResultContent(input) {
             ? `- 对象: ${mentionLine}`
             : `- Target: ${mentionLine}`;
     if (language === 'zh') {
+        const statusFootnote = formatTellaskStatusFootnote({
+            language,
+            callName: input.callName,
+            callId: input.callId,
+            crossCourse: true,
+        });
         const lines = [
             '### 旧程诉请结果补入',
             '',
-            `- 来源程: C${String(Math.floor(input.originCourse))}`,
-            `- 响应者: @${requireNonEmpty(input.responderId, 'responderId')}`,
+            `- 调用点程: C${String(Math.floor(input.callSiteCourse))}`,
+            `- 被诉请者: @${requireNonEmpty(input.responderId, 'responderId')}`,
             `- 状态: ${statusLabel}`,
             targetLine,
             sessionLine,
@@ -345,16 +384,22 @@ function formatTellaskCarryoverResultContent(input) {
             '',
             (0, markdown_format_1.markdownQuote)(responseBody),
             '',
-            '注意：这不是新的用户请求，也不是当前程新发起的函数调用，而是旧 pending tellask 的异步完成结果。',
+            statusFootnote,
             '',
         ];
         return lines.join('\n');
     }
+    const statusFootnote = formatTellaskStatusFootnote({
+        language,
+        callName: input.callName,
+        callId: input.callId,
+        crossCourse: true,
+    });
     const lines = [
         '### Carry-over tellask result',
         '',
-        `- Origin course: C${String(Math.floor(input.originCourse))}`,
-        `- Responder: @${requireNonEmpty(input.responderId, 'responderId')}`,
+        `- Call-site course: C${String(Math.floor(input.callSiteCourse))}`,
+        `- Tellaskee: @${requireNonEmpty(input.responderId, 'responderId')}`,
         `- Status: ${statusLabel}`,
         targetLine,
         sessionLine,
@@ -367,7 +412,7 @@ function formatTellaskCarryoverResultContent(input) {
         '',
         (0, markdown_format_1.markdownQuote)(responseBody),
         '',
-        'Note: this is not a new user request or a newly initiated function call in the current course; it is the canonical current-course carryover of an older pending tellask completion.',
+        statusFootnote,
         '',
     ];
     return lines.join('\n');

package/dist/runtime/interjection-pause-stop.js

@@ -17,7 +17,7 @@ const USER_INTERJECTION_PAUSE_STOP_DETAIL = 'user_interjection_pause_resume_orig
 // this paused-original-task stop semantics.
 //
 // Do not change this file in isolation. The complete behavior depends on coordinated logic across:
-// - `reply-guidance.ts`          suppressing upstream reply obligation during interjection chat
+// - `reply-guidance.ts`          suppressing tellasker reply obligation during interjection chat
 // - `flow.ts`                   parking after the local reply, then re-running fresh-fact resume
 // - `dialog-display-state.ts`   preserving this paused projection until explicit Continue
 // - `websocket-handler.ts`      treating Continue as "resume attempt" rather than immediate success

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

@@ -15,10 +15,14 @@ export declare function buildActiveReplyToolNote(args: {
     language: LanguageCode;
     toolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
 }): string;
-export declare function buildSidelineCompletionRule(language: LanguageCode): string;
-export declare function buildSubdialogRoleHeaderCopy(args: {
+export declare function buildActiveReplyObligationContextText(args: {
     language: LanguageCode;
-    requesterId: string;
+    directive: TellaskReplyDirective;
+}): string;
+export declare function buildSideDialogCompletionRule(language: LanguageCode): string;
+export declare function buildSideDialogRoleHeaderCopy(args: {
+    language: LanguageCode;
+    tellaskerId: string;
     expectedReplyTool?: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | undefined;
 }): string;
 export declare function buildReplyObligationSuppressionGuideText(language: LanguageCode): string;