dominds 1.7.0 → 1.7.2

package/dist/minds/system-prompt.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatTeamIntro = formatTeamIntro;
 exports.buildSystemPrompt = buildSystemPrompt;
+const inter_dialog_format_1 = require("../shared/utils/inter-dialog-format");
 function formatTeamIntro(team, selfAgentId, language) {
     const callSignLabel = language === 'zh' ? '呼号' : 'Call Sign';
     const selfSuffix = language === 'zh' ? '（本人）' : ' (self)';
@@ -37,16 +38,36 @@ function formatTeamIntro(team, selfAgentId, language) {
 function pickLocalized(language, localized) {
     return language === 'zh' ? localized.zh : localized.en;
 }
-function buildFbrContextHealthScopeRule(scope, language) {
+function buildFbrContextHealthScopeRule(scope, language, contextHealthPromptMode) {
+    if (contextHealthPromptMode === 'critical') {
+        return pickLocalized(language, {
+            zh: scope === 'mainline'
+                ? '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。先按处置要求保信息、维护提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR 与差遣牒更新。'
+                : '- 当前上下文处于系统告急处置态：本程禁止发起 FBR。先按处置要求保信息、维护提醒项，并立即 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
+            en: scope === 'mainline'
+                ? '- Current context is under system critical remediation: do not start FBR in this course. Preserve volatile information, maintain reminders, and clear immediately; resume FBR and Taskdoc updates only after the system starts the new course and the continuation package has been reviewed.'
+                : '- Current context is under system critical remediation: do not start FBR in this course. Preserve volatile information, maintain reminders, and clear immediately; resume FBR only after the system starts the new course and the continuation package has been reviewed.',
+        });
+    }
+    if (contextHealthPromptMode === 'caution') {
+        return pickLocalized(language, {
+            zh: scope === 'mainline'
+                ? '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。先按处置要求提炼提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR 与差遣牒更新。'
+                : '- 当前上下文处于系统吃紧处置态：本程不要发起 FBR。先按处置要求提炼提醒项并尽快 `clear_mind`；系统真正开启新一程并完成接续包复核后，再恢复 FBR。',
+            en: scope === 'mainline'
+                ? '- Current context is under system caution remediation: do not start FBR in this course. Distill reminders and clear soon; resume FBR and Taskdoc updates only after the system starts the new course and the continuation package has been reviewed.'
+                : '- Current context is under system caution remediation: do not start FBR in this course. Distill reminders and clear soon; resume FBR only after the system starts the new course and the continuation package has been reviewed.',
+        });
+    }
     if (scope === 'mainline') {
         return pickLocalized(language, {
-            zh: '- 系统会持续自动监控上下文健康度：没有吃紧/告急提示时，可以安全进行 FBR。如果有吃紧/告急提示，系统会提醒你，应先处理（提炼 + clear_mind）。随后基于当前可观测事实调用 \\`change_mind\\` 更新差遣牒，体现任务最新进展情况。FBR 自诉请正文不要冗余包含差遣牒已有信息。',
-            en: '- Before every FBR, the system will automatically alert on context health status: if there are no yellow/red alerts, you can safely proceed with FBR. If there are yellow/red alerts, handle them first (distill + clear_mind). Then call \\`change_mind\\` based on currently observable facts to update the Taskdoc with the latest task progress; do not redundantly include information already present in the Taskdoc in the FBR FBR body.',
+            zh: '- 当前没有生效中的上下文健康处置指令，可以按正常流程进行 FBR。完成 FBR 后，基于当前可观测事实调用 \\`change_mind\\` 更新差遣牒，体现任务最新进展情况。FBR 自诉请正文不要冗余包含差遣牒已有信息。',
+            en: '- There is no active context-health remediation instruction in effect, so FBR may proceed normally. After FBR, call \\`change_mind\\` based on currently observable facts to update the Taskdoc with the latest progress; do not redundantly include information already present in the Taskdoc in the FBR body.',
         });
     }
     return pickLocalized(language, {
-        zh: '- 系统会持续自动监控上下文健康度：没有吃紧/告急提示时，可以安全进行 FBR。如果有吃紧/告急提示，系统会提醒你，应先处理。随后基于当前可观测事实分析是否与差遣牒内容存在差异，并将发现的情况包含在 FBR 自诉请正文中。',
-        en: '- Before every FBR, the system will automatically alert on context health status: if there are no yellow/red alerts, you can safely proceed with FBR. If there are yellow/red alerts, handle them first. Then analyze whether currently observable facts differ from the Taskdoc, and include the findings in the FBR FBR body.',
+        zh: '- 当前没有生效中的上下文健康处置指令，可以按正常流程进行 FBR。随后基于当前可观测事实分析是否与差遣牒内容存在差异，并将发现的情况包含在 FBR 自诉请正文中。',
+        en: '- There is no active context-health remediation instruction in effect, so FBR may proceed normally. Then analyze whether currently observable facts differ from the Taskdoc, and include the findings in the FBR body.',
     });
 }
 function buildFbrPhaseContract(language) {
@@ -67,68 +88,79 @@ function buildFbrPhaseContract(language) {
     return lines.join('\n');
 }
 function buildTeammateTellaskPhaseContract(language) {
+    const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
     const lines = pickLocalized(language, {
         zh: [
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 \\`tellask\\` 复用同一 \\`sessionSlug\\`）。',
             '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（自动添加，手动删除）”提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
             '- 能由队友诉请完成的执行性工作，禁止转交 \\`askHuman\\` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 \\`tellask\\` 或 \\`tellaskSessionless\\`。',
-            '- 当你在诉请正文里定义“回贴格式/交付格式”时，必须明确写入：`Dominds 会自动注入回贴标记，禁止手写标记`；不得要求被诉请者手写 `【最终完成】` / `【tellaskBack】` / FBR 标记。',
+            `- 当你在诉请正文里定义“回贴格式/交付格式”时，必须明确写入：\`Dominds 会自动注入回贴标记，禁止手写标记\`；不得要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）。`,
             '- 当你处于队友诉请触发的支线且需要澄清时，必须使用 \\`tellaskBack\\` 回问上游诉请者；\\`tellaskBack\\` 不携带 \\`sessionSlug\\`。',
-            '- 回贴文本标记由运行时在跨对话传递正文中按语义自动添加（例如 `tellaskBack` / `最终完成` / FBR 标记）；该传递正文会进入目标智能体上下文，且 UI 与其一致。你不应手写这些标记。',
+            `- 回贴文本标记由运行时在跨对话传递正文中按语义自动添加（例如 \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR 标记 \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）；该传递正文会进入目标智能体上下文，且 UI 与其一致。你不应手写这些标记。`,
         ],
         en: [
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
             '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually \\`tellask\\` with the same \\`sessionSlug\\`).',
             '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in the “⏳ In-flight Tellasks (auto-added, manually deleted)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
             '- Do not use \\`askHuman\\` as a relay for executable teammate work. If you write “ask @X to do Y”, emit \\`tellask\\` or \\`tellaskSessionless\\` in the same response.',
-            '- When you define a “reply/delivery format” inside tellask body, you must explicitly include: `Dominds auto-injects reply markers; do not hand-write markers`; do not require the responder to hand-write `【最终完成】` / `【tellaskBack】` / FBR markers.',
+            `- When you define a “reply/delivery format” inside tellask body, you must explicitly include: \`Dominds auto-injects reply markers; do not hand-write markers\`; do not require the responder to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`).`,
             '- When you are in a teammate-triggered sideline and need clarification, you MUST issue \\`tellaskBack\\` to ask back upstream; \\`tellaskBack\\` must not carry \\`sessionSlug\\`.',
-            '- Reply markers are auto-added by runtime in the inter-dialog transfer payload (for example ask-back / final delivery / FBR markers); that same transfer payload is what the target agent receives in context and what UI shows. Do not hand-write markers.',
+            `- Reply markers are auto-added by runtime in the inter-dialog transfer payload (for example \`${runtimeMarkers.tellaskBack}\` / \`${runtimeMarkers.finalCompleted}\` / FBR markers \`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`); that same transfer payload is what the target agent receives in context and what UI shows. Do not hand-write markers.`,
         ],
     });
     return lines.join('\n');
 }
 function buildSidelineUpstreamReplyMarkerRules(language) {
+    const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
     const lines = pickLocalized(language, {
         zh: [
             '- 本规则仅用于当前支线向上游诉请者回贴，不适用于你发起新的 tellask。',
             '- 当前支线未完成/不确定/阻塞/需要澄清时：必须发起 \\`tellaskBack({ tellaskContent: "..." })\\`，并在 \\`tellaskContent\\` 中给出具体问题。',
             '- 当前支线已完成并可交付最终结果时：必须直接回复正文；禁止调用 \\`tellaskBack\\` 发送最终结果。',
-            '- 运行时会自动把这条直接回复作为完成结果投递给上游，并在传递正文中添加【最终完成】。',
+            `- 运行时会自动把这条直接回复作为完成结果投递给上游，并在传递正文中添加 ${runtimeMarkers.finalCompleted}。`,
             '- “不得发普通文本中间汇报”只针对未完成态；若你已经完成任务并能给出最终交付，就应直接回复正文，不要使用 \\`tellaskBack\\`。',
-            '- 例外：FBR 支线为工具禁用模式（不得调用 \\`tellaskBack\\`）；其回贴标记也由运行时在传递正文中注入。',
+            '- 例外：FBR 支线为工具禁用模式（不得调用 \\`tellaskBack\\`）；其回贴标记（`' +
+                runtimeMarkers.fbrDirectReply +
+                '` / `' +
+                runtimeMarkers.fbrReasoningOnly +
+                '`)也由运行时在传递正文中注入。',
         ],
         en: [
             '- This rule applies only when posting upstream from the current sideline, not when initiating a new tellask.',
             '- If the current sideline is unfinished, uncertain, blocked, or needs clarification: you must emit \\`tellaskBack({ tellaskContent: "..." })\\` and put concrete questions in \\`tellaskContent\\`.',
             '- If the current sideline is complete and ready to deliver a final result: you must reply with the response body directly; do not use \\`tellaskBack\\` to send final delivery.',
-            '- Runtime will deliver that direct reply upstream as the completion result and inject 【最终完成】 into the transfer payload.',
+            `- Runtime will deliver that direct reply upstream as the completion result and inject ${runtimeMarkers.finalCompleted} into the transfer payload.`,
             '- “Do not post a plain-text progress update” only applies to unfinished states; if the task is done and you can deliver the final result, reply directly instead of using \\`tellaskBack\\`.',
-            '- Exception: FBR sideline is tool-less (no \\`tellaskBack\\`); its reply marker is also injected by runtime into the transfer payload.',
+            '- Exception: FBR sideline is tool-less (no \\`tellaskBack\\`); its reply markers (`' +
+                runtimeMarkers.fbrDirectReply +
+                '` / `' +
+                runtimeMarkers.fbrReasoningOnly +
+                '`) are also injected by runtime into the transfer payload.',
         ],
     });
     return lines.join('\n');
 }
 function buildTellaskReplyMarkerScopePolicy(language, dialogScope) {
+    const runtimeMarkers = (0, inter_dialog_format_1.getRuntimeTransferMarkers)(language);
     if (dialogScope === 'sideline') {
         return [
             ...pickLocalized(language, {
                 zh: [
-                    '- 回贴文本标记由运行时在跨对话传递正文中自动添加（常规完成=【最终完成】；FBR=【FBR-直接回复】或【FBR-仅推理】）；该正文直接进入上游上下文，且 UI 展示与其一致。你无需、也不应手写标记。',
+                    `- 回贴文本标记由运行时在跨对话传递正文中自动添加（常规完成=${runtimeMarkers.finalCompleted}；FBR=${runtimeMarkers.fbrDirectReply} 或 ${runtimeMarkers.fbrReasoningOnly}）；该正文直接进入上游上下文，且 UI 展示与其一致。你无需、也不应手写标记。`,
                     '- 若你在正文中给下游写“回贴格式”，必须写明“Dominds 自动注入标记，禁止手写”；不得要求下游手写任何标记。',
                     '- `tellaskBack` 只允许用于回问/澄清/阻塞说明；禁止用 \\`tellaskBack\\` 发送最终结果。',
                     '- 当前支线未完成/不确定/阻塞/需要澄清时：必须调用 \\`tellaskBack({ tellaskContent: "..." })\\`，不得发普通文本中间汇报。',
                     '- 当前支线已完成并能给出最终交付时：必须直接回复正文；这条直接回复就是完成交付通道，不要再走 \\`tellaskBack\\`。',
-                    '- 仅当确认当前支线已完成全部目标并直接回复时，运行时才会把该回复投递给上游并标注【最终完成】。',
+                    `- 仅当确认当前支线已完成全部目标并直接回复时，运行时才会把该回复投递给上游并标注 ${runtimeMarkers.finalCompleted}。`,
                 ],
                 en: [
-                    '- Reply markers are runtime-added in the inter-dialog transfer payload (regular completed reply = 【最终完成】; FBR = 【FBR-直接回复】 or 【FBR-仅推理】); this payload is delivered to upstream context and shown identically in UI. Do not hand-write markers.',
+                    `- Reply markers are runtime-added in the inter-dialog transfer payload (regular completed reply = ${runtimeMarkers.finalCompleted}; FBR = ${runtimeMarkers.fbrDirectReply} or ${runtimeMarkers.fbrReasoningOnly}); this payload is delivered to upstream context and shown identically in UI. Do not hand-write markers.`,
                     '- 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: you must reply with the response body directly; that direct reply is the completion-delivery path, not \\`tellaskBack\\`.',
-                    '- Runtime marks 【最终完成】 and delivers upstream only when the current sideline has fully completed its objectives and directly replies.',
+                    `- Runtime marks ${runtimeMarkers.finalCompleted} and delivers upstream only when the current sideline has fully completed its objectives and directly replies.`,
                 ],
             }),
         ];
@@ -169,8 +201,8 @@ function buildTellaskCollaborationProtocol(language, dialogScope) {
     }
     return lines.join('\n');
 }
-function buildFbrGuidelines(language, dialogScope) {
-    const fbrContextHealthRule = buildFbrContextHealthScopeRule(dialogScope, language);
+function buildFbrGuidelines(language, dialogScope, contextHealthPromptMode) {
+    const fbrContextHealthRule = buildFbrContextHealthScopeRule(dialogScope, language, contextHealthPromptMode);
     const fbrPhaseContract = buildFbrPhaseContract(language);
     const lines = pickLocalized(language, {
         zh: [
@@ -246,7 +278,7 @@ function buildFunctionToolRules(language, funcToolRulesText) {
 }
 function buildSystemPrompt(input) {
     const collaborationProtocol = buildTellaskCollaborationProtocol(input.language, input.dialogScope);
-    const fbrGuidelines = buildFbrGuidelines(input.language, input.dialogScope);
+    const fbrGuidelines = buildFbrGuidelines(input.language, input.dialogScope, input.contextHealthPromptMode);
     const tellaskInteractionRules = buildTellaskInteractionRules(input.language);
     const functionToolRules = buildFunctionToolRules(input.language, input.funcToolRulesText);
     if (input.language === 'zh') {
@@ -271,20 +303,20 @@ function buildSystemPrompt(input) {
 
 ## 术语表
 
-- 诉请（Tellask）：对智能体的结构化请求。
+- 诉请：对智能体的结构化请求。
 - 提及列表（mentionList）：仅用于 \`tellask\` / \`tellaskSessionless\` 的队友目标列表（\`@<agentId>\`）。
 - 诉请内容（tellaskContent）：tellask 系列函数的正文参数，用于承载上下文/约束/验收。
-- 对话主理人（Dialog Responder）：负责当前对话推进与输出的智能体。
-- 诉请者（tellasker）：发出诉请的对话主理人。
-- 被诉请者（tellaskee）：接收诉请的对话主理人/队友。
-- 回问诉请（TellaskBack）：支线对话用 \`tellaskBack\` 回问诉请者以澄清。
+- 对话主理人：负责当前对话推进与输出的智能体。
+- 诉请者：发出诉请的对话主理人。
+- 被诉请者：接收诉请的对话主理人/队友。
+- 回问诉请：支线对话用 \`tellaskBack\` 回问诉请者以澄清。
 - 扪心自问（FBR）：由 \`freshBootsReasoning\` 触发的“无工具”支线推理机制。
-- Q4H（Question for Human）：通过 \`askHuman\` 向人类请求必要的澄清/决策/授权/缺失输入。
-- 长线诉请（Tellask Session）：使用 \`tellask\` + \`sessionSlug\` 的可恢复多轮协作。
-- 一次性诉请（Fresh Tellask）：一次性、不可恢复的诉请。
-- 主线对话（Mainline dialog）：承载共享差遣牒并负责整体推进的对话。
-- 支线对话（Sideline dialog）：为分项任务临时创建的工作对话。
-- 差遣牒（Taskdoc）：共享任务契约，包含必要的 goals/constraints/progress 章节以及可选更多的额外章节。
+- 向人请示（Q4H）：通过 \`askHuman\` 向人类请求必要的澄清/决策/授权/缺失输入。
+- 长线诉请：使用 \`tellask\` + \`sessionSlug\` 的可恢复多轮协作。
+- 一次性诉请：一次性、不可恢复的诉请。
+- 主线对话：承载共享差遣牒并负责整体推进的对话。
+- 支线对话：为分项任务临时创建的工作对话。
+- 差遣牒：共享任务契约，包含必要的 goals/constraints/progress 章节以及可选更多的额外章节。
 
 ## 角色设定
 

package/dist/persistence.js

@@ -642,7 +642,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      *   - Uses callId for correlation between call_start and response
      *   - Uses receiveTellaskCallResult() + callId parameter
      *
-     * - Teammate Tellask (subdialog response bubble)
+     * - Tellask sideline response (subdialog response bubble)
      *   - Result displays in SEPARATE bubble (subdialog response)
      *   - Uses calleeDialogId for correlation
      *   - Uses receiveTellaskResponse() instead
@@ -730,18 +730,18 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         (0, evt_registry_1.postDialogEvent)(dialog, toolResponseEvt);
     }
     /**
-     * Receive and handle TEAMMATE TELLASK responses (separate bubble for subdialog/supdialog replies)
+     * Receive and handle tellask responses (separate bubble for subdialog/supdialog replies)
      *
      * Call Types:
-     * - Teammate Tellask response
+     * - Tellask sideline response
      *   - Result displays in SEPARATE bubble (subdialog or supdialog response)
      *   - Uses calleeDialogId for correlation (not callId)
      *   - Uses this method (receiveTellaskResponse)
      *
      * @param dialog - The dialog receiving the response
-     * @param responderId - ID of the teammate agent (e.g., "coder")
-     * @param mentionList - Mention list of the original teammate tellask
-     * @param tellaskContent - Tellask content of the original teammate tellask
+     * @param responderId - ID of the responder agent (e.g., "coder")
+     * @param mentionList - Mention list of the original tellask
+     * @param tellaskContent - Tellask content of the original tellask
      * @param status - Response status ('completed' | 'failed')
      * @param calleeDialogId - ID of the callee dialog (subdialog OR supdialog) for navigation links
      */
@@ -2159,7 +2159,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 break;
             }
             case 'tellask_call_result_record': {
-                // Handle teammate-call inline results
+                // Handle tellask-call inline results
                 const responseEvent = (() => {
                     switch (event.callName) {
                         case 'tellask':
@@ -2338,7 +2338,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             case 'subdialog_responses_reconciled_record':
                 break;
             case 'tellask_response_record': {
-                // Handle teammate response events (separate bubble for @teammate tellasks)
+                // Handle tellask response events (separate bubble for tellask sideline replies)
                 const mentionList = (() => {
                     switch (event.callName) {
                         case 'tellask':
@@ -4625,7 +4625,7 @@ class DialogPersistence {
                     break;
                 }
                 case 'tellask_call_result_record': {
-                    // Convert teammate-call inline result to ChatMessage
+                    // Convert tellask-call inline result to ChatMessage
                     const mentionList = (() => {
                         switch (event.callName) {
                             case 'tellask':
@@ -4652,8 +4652,8 @@ class DialogPersistence {
                 case 'tellask_call_carryover_record':
                     break;
                 case 'tellask_response_record': {
-                    // Convert teammate response to ChatMessage (teammate - separate bubble)
-                    // Note: Teammate responses are stored as separate records but use same message type
+                    // Convert tellask response to ChatMessage (separate bubble)
+                    // Note: Tellask responses are stored as separate records but use same message type
                     const mentionList = (() => {
                         switch (event.callName) {
                             case 'tellask':

package/dist/priming.js

@@ -805,10 +805,10 @@ function normalizePrimingRecordFromJson(raw) {
                 switch (callName) {
                     case 'tellask': {
                         if (!Array.isArray(mentionList) || mentionList.length < 1) {
-                            throw new Error(`${context}.mentionList is required for tellask teammate response`);
+                            throw new Error(`${context}.mentionList is required for tellask response`);
                         }
                         if (typeof sessionSlug !== 'string' || sessionSlug.trim() === '') {
-                            throw new Error(`${context}.sessionSlug is required for tellask teammate response`);
+                            throw new Error(`${context}.sessionSlug is required for tellask response`);
                         }
                         return {
                             ...base,
@@ -819,10 +819,10 @@ function normalizePrimingRecordFromJson(raw) {
                     }
                     case 'tellaskSessionless': {
                         if (!Array.isArray(mentionList) || mentionList.length < 1) {
-                            throw new Error(`${context}.mentionList is required for tellaskSessionless teammate response`);
+                            throw new Error(`${context}.mentionList is required for tellaskSessionless response`);
                         }
                         if (sessionSlug !== undefined) {
-                            throw new Error(`${context}.sessionSlug must be undefined for tellaskSessionless teammate response`);
+                            throw new Error(`${context}.sessionSlug must be undefined for tellaskSessionless response`);
                         }
                         return {
                             ...base,

package/dist/shared/i18n/driver-messages.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
+exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
 exports.formatDomindsNoteTellaskForTeammatesOnly = formatDomindsNoteTellaskForTeammatesOnly;
@@ -24,6 +25,20 @@ function formatCurrentUserLanguagePreference(workingLanguage, uiLanguage) {
     }
     return `User-visible response language: ${uiName}. Internal work language remains: ${workingName} (system prompt, teammate comms, function tools).`;
 }
+function formatNewCourseStartPrompt(language, args) {
+    if (language === 'zh') {
+        const prefix = args.source === 'clear_mind'
+            ? `你刚清理头脑，开启了第 ${args.nextCourse} 程对话。`
+            : `系统因上下文已告急（critical）而自动开启了第 ${args.nextCourse} 程对话。`;
+        return (`${prefix} ` +
+            '现在已经进入新一程：第一步先复核并整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；再继续推进任务。');
+    }
+    const prefix = args.source === 'clear_mind'
+        ? `This is course #${args.nextCourse} of the dialog. You just cleared your mind.`
+        : `System auto-started course #${args.nextCourse} of the dialog because context health is critical.`;
+    return (`${prefix} ` +
+        'You are now in a new course: your first step is to review and rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, compress them into high-quality reminders, and then continue the task.');
+}
 function formatReminderItemGuide(language, index, content, options) {
     function isRecord(value) {
         return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -80,7 +95,7 @@ function formatReminderItemGuide(language, index, content, options) {
                 '',
                 '说明：这是用于换程后快速恢复工作的接续包，不自动等于当前必须立刻执行的指令。',
                 '',
-                '建议：优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，尽快以清醒头脑重新审视、整理更新。若目前只是粗略过桥笔记，进入新一程后尽快收敛。',
+                '建议：优先保留下一步行动、关键定位、运行/验证信息、容易丢的临时细节；不要重复差遣牒已覆盖的内容。进入新一程后，第一步就要以清醒头脑重新审视并整理更新：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。若目前只是粗略过桥笔记，进入新一程后必须尽快收敛。',
                 '',
                 `如需更新此接续包，可执行：update_reminder({ "reminder_no": ${index}, "content": "..." })`,
                 `如需删除此提醒项，可执行：delete_reminder({ "reminder_no": ${index} })`,
@@ -121,7 +136,7 @@ ${content}`;
 
 Note: this is resume information for the next course, not an automatic must-do command.
 
-Guidance: keep the next step, key pointers, run/verify info, and easy-to-lose volatile details. Do not duplicate Taskdoc content. In the new course, review this again with a clear head and reorganize it promptly. If this is only a rough bridge note, reconcile it early in the new course.
+Guidance: keep the next step, key pointers, run/verify info, and easy-to-lose volatile details. 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 you need to update this package, run: update_reminder({ "reminder_no": ${index}, "content": "..." })
 If you need to delete this reminder, run: delete_reminder({ "reminder_no": ${index} })
@@ -180,9 +195,9 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
                 '',
                 '影响：对话历史中的工具调用/结果信息很多已经过时，成为你的思考负担。',
                 '',
-                '行动：先尽量保住易丢信息；如头脑还清楚，优先整理成结构化接续包提醒项（下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）。',
+                '行动：先尽量保住易丢信息，并优先把已经掌握的事实压缩成结构化接续包提醒项（下一步行动 + 关键定位信息 + 运行/验证信息 + 容易丢的临时细节）；若不额外继续阅读/分析就做不到，允许先记成多条粗略提醒项。',
                 '',
-                '若你已经发乱，允许先记成多条粗略提醒项带到新一程；求稳比求整洁更重要。进入新一程后，第一步就是复核提醒项、收敛冗余、再继续工作。接续包只保留差遣牒未覆盖、但恢复工作会丢的信息。然后主动 clear_mind，开启新一程对话继续工作。',
+                '当前已处于吃紧处置阶段：不要继续扩张上下文，也不要提前进入“按接续包做清醒复核”的模式；那是系统真正开启新一程后的第一步。接续包只保留差遣牒未覆盖、但恢复工作会丢的信息。然后主动 clear_mind，开启新一程对话继续工作。',
                 '',
                 '操作：',
                 '- update_reminder({ "reminder_no": 1, "content": "..." })（推荐）',
@@ -194,14 +209,14 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             `系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
-            '行动：尽快保住易丢信息，然后 clear_mind。能整理就整理成结构化接续包提醒项；若已经发乱，先保留多条粗略提醒项也可以。',
+            '行动：尽快保住易丢信息，然后 clear_mind。若能直接基于已掌握事实压缩成结构化接续包提醒项，就这样做；否则先保留多条粗略提醒项也可以。',
             '',
             '操作：',
             '- update_reminder({ "reminder_no": 1, "content": "..." })',
             '- add_reminder({ "content": "..." })',
             '- clear_mind({})',
             '',
-            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容。若先带多条粗略提醒项过桥，新一程第一步就要重新审视并收敛。',
+            '接续包要点：下一步行动 + 关键定位信息 + 运行验证方式 + 容易丢的临时细节；不要重复差遣牒已有内容。当前处于告急处置阶段时，不要提前做“新一程清醒复核”；系统真正开启新一程后，第一步才是重新审视并整理：删除冗余、纠正偏激/失真思路、压缩成高质量提醒项。',
         ].join('\n');
     }
     if (args.kind === 'caution' && args.mode === 'soft') {
@@ -210,9 +225,9 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
             '',
             'Impact: stale call/results in dialog history are creating cognitive noise.',
             '',
-            'Action: first preserve easy-to-lose information; if you are still clear-headed, prefer a structured continuation-package reminder (next step + key pointers + run/verify info + easy-to-lose volatile details).',
+            'Action: first preserve easy-to-lose information, and prefer compressing already observed facts into a structured continuation-package reminder (next step + key pointers + run/verify info + easy-to-lose volatile details). If that cannot be done without more reading/analysis, rough multi-reminder carry-over is acceptable.',
             '',
-            'If you are already muddled, multiple rough reminders are acceptable as a bridge; survival matters more than neatness. In the new course, your first step is to review reminders, remove redundancy, and then continue. Keep only details not already covered by Taskdoc. Then proactively clear_mind to start a new dialog course.',
+            'You are already in caution remediation for the current course, so do not keep expanding context and do not switch early into “clear-headed continuation-package review” mode; that is the first step only after the system actually starts the new course. Keep only details not already covered by Taskdoc. Then proactively clear_mind to start a new dialog course.',
             '',
             'Operations:',
             '- update_reminder({ "reminder_no": 1, "content": "..." })',
@@ -224,14 +239,14 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
         '',
         `System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',
-        'Action: preserve easy-to-lose information, then clear_mind. Prefer a structured continuation-package reminder if you can still think clearly; otherwise multiple rough reminders are acceptable as a bridge.',
+        'Action: preserve easy-to-lose information, then clear_mind. If you can compress already observed facts into one structured continuation-package reminder without more reading/analysis, do that; otherwise multiple rough reminders are acceptable as a bridge.',
         '',
         'Operations:',
         '- update_reminder({ "reminder_no": 1, "content": "..." })',
         '- add_reminder({ "content": "..." })',
         '- clear_mind({})',
         '',
-        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content. If you bridge with multiple rough reminders first, reconcile them at the start of the new course.',
+        'Continuation package: next step + key pointers + run/verify info + easy-to-lose volatile details. Do not duplicate Taskdoc content. During critical remediation in the current course, do not start the new-course cleanup early; once the system actually starts the new course, the first step is to reconcile rough bridge reminders by removing redundancy, correcting biased or distorted bridge notes, and compressing them into high-quality reminders.',
     ].join('\n');
 }
 function formatDomindsNoteDirectSelfCall(language) {

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

@@ -9,25 +9,44 @@
  *
  * Transfer payload contract:
  * - Assignment/call payloads are generated from mention list + tellask content.
- * - Teammate-response payloads include runtime markers + response body + call-site summary.
+ * - Tellask-response payloads include runtime markers + response body + call-site summary.
  * - The same transfer payload should be used for both model context and UI rendering.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeTransferMarkers = getRuntimeTransferMarkers;
 exports.formatAssignmentFromSupdialog = formatAssignmentFromSupdialog;
 exports.formatSupdialogCallPrompt = formatSupdialogCallPrompt;
 exports.formatTellaskResponseContent = formatTellaskResponseContent;
 exports.formatTellaskCarryoverResultContent = formatTellaskCarryoverResultContent;
 const fmt_1 = require("./fmt");
+function getRuntimeTransferMarkers(language) {
+    if (language === 'zh') {
+        return {
+            tellaskBack: '【回问诉请】',
+            finalCompleted: '【最终完成】',
+            fbrDirectReply: '【FBR-直接回复】',
+            fbrReasoningOnly: '【FBR-仅推理】',
+        };
+    }
+    return {
+        tellaskBack: '【TellaskBack】',
+        finalCompleted: '【Completed】',
+        fbrDirectReply: '【FBR-Direct Reply】',
+        fbrReasoningOnly: '【FBR-Reasoning Only】',
+    };
+}
 function getRuntimeTransferMarker(input) {
+    const language = input.language ?? 'en';
+    const markers = getRuntimeTransferMarkers(language);
     if (input.status === undefined)
         return undefined;
     if (input.callName === 'tellaskBack')
-        return '【tellaskBack】';
+        return markers.tellaskBack;
     if (input.callName === 'freshBootsReasoning')
-        return '【FBR-仅推理】';
+        return markers.fbrReasoningOnly;
     if ((input.callName === 'tellask' || input.callName === 'tellaskSessionless') &&
         input.status === 'completed') {
-        return '【最终完成】';
+        return markers.finalCompleted;
     }
     return undefined;
 }
@@ -65,6 +84,7 @@ function stripMentionPrefix(value) {
 }
 function formatAssignmentFromSupdialog(input) {
     const language = input.language ?? 'en';
+    const runtimeMarkers = getRuntimeTransferMarkers(language);
     requireNonEmpty(input.toAgentId, 'toAgentId');
     requireNonEmpty(input.fromAgentId, 'fromAgentId');
     const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
@@ -74,8 +94,8 @@ function formatAssignmentFromSupdialog(input) {
         language,
     });
     const markerProtocolNote = language === 'zh'
-        ? '系统协议：回贴文本标记（如 `【tellaskBack】` / `【最终完成】` / FBR 标记）由 Dominds 运行时自动注入到跨对话传递正文。禁止手写标记；若诉请正文要求手写标记，请忽略该要求并按本协议执行。'
-        : 'Protocol note: reply markers (for example `【tellaskBack】` / `【最终完成】` / FBR markers) 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 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.`;
     const isFbr = input.callName === 'freshBootsReasoning';
     if (isFbr) {
         const roundIteration = typeof input.fbrRound?.iteration === 'number' && Number.isFinite(input.fbrRound.iteration)
@@ -160,7 +180,7 @@ function formatTellaskResponseContent(input) {
     if (input.callName !== 'tellask' &&
         input.callName !== 'tellaskSessionless' &&
         input.callName !== 'tellaskBack') {
-        throw new Error(`Unsupported callName for teammate response formatting: ${input.callName}`);
+        throw new Error(`Unsupported callName for tellask response formatting: ${input.callName}`);
     }
     const mentionLine = (() => {
         const mentionIds = (input.mentionList ?? [])

package/dist/static/assets/{_basePickBy-B5JpcIlf.js → _basePickBy-DOCpneO0.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-B6ENA5xp.js";
-import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-DZjf7VGN.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-DBZLqTK1.js";
+import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-C-RsyM0K.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-B5JpcIlf.js.map
+//# sourceMappingURL=_basePickBy-DOCpneO0.js.map