dominds 1.13.2 → 1.15.2

package/dist/dialog.js

@@ -597,7 +597,7 @@ class Dialog {
             grammar: prompt.grammar,
             userLanguageCode: prompt.userLanguageCode,
             origin: prompt.origin,
-            q4hAnswerCallIds: prompt.q4hAnswerCallIds,
+            q4hAnswerCallId: prompt.q4hAnswerCallId,
             tellaskReplyDirective: prompt.tellaskReplyDirective,
             skipTaskdoc: prompt.skipTaskdoc,
             subdialogReplyTarget: prompt.subdialogReplyTarget,
@@ -622,7 +622,7 @@ class Dialog {
                     msgId: nextPrompt.msgId,
                     grammar: nextPrompt.grammar ?? 'markdown',
                     userLanguageCode: nextPrompt.userLanguageCode,
-                    q4hAnswerCallIds: nextPrompt.q4hAnswerCallIds,
+                    q4hAnswerCallId: nextPrompt.q4hAnswerCallId,
                     tellaskReplyDirective: nextPrompt.tellaskReplyDirective,
                     skipTaskdoc: nextPrompt.skipTaskdoc,
                     subdialogReplyTarget: nextPrompt.subdialogReplyTarget,
@@ -657,23 +657,20 @@ class Dialog {
         this._upNextQueue = [this.buildUpNextPromptState(normalized, 'new_course_start')];
         return normalized;
     }
-    mergePromptQ4HAnswerCallIds(existing, incoming) {
-        if (!existing || existing.length === 0) {
-            return incoming && incoming.length > 0 ? [...incoming] : undefined;
+    mergePromptQ4HAnswerCallId(existing, incoming) {
+        const normalizedExisting = typeof existing === 'string' ? existing.trim() : '';
+        const normalizedIncoming = typeof incoming === 'string' ? incoming.trim() : '';
+        if (normalizedExisting === '') {
+            return normalizedIncoming !== '' ? normalizedIncoming : undefined;
         }
-        if (!incoming || incoming.length === 0) {
-            return [...existing];
+        if (normalizedIncoming === '') {
+            return normalizedExisting;
         }
-        const seen = new Set();
-        const merged = [];
-        for (const raw of [...existing, ...incoming]) {
-            const callId = raw.trim();
-            if (callId === '' || seen.has(callId))
-                continue;
-            seen.add(callId);
-            merged.push(callId);
+        if (normalizedExisting !== normalizedIncoming) {
+            throw new Error(`Q4H answer continuation invariant violation: conflicting callIds cannot be merged ` +
+                `(dialog=${this.id.valueOf()} existing=${normalizedExisting} incoming=${normalizedIncoming})`);
         }
-        return merged.length > 0 ? merged : undefined;
+        return normalizedExisting;
     }
     enqueueQueuedPromptState(state) {
         this._upNextQueue.push(state);
@@ -685,7 +682,7 @@ class Dialog {
                 grammar: state.grammar ?? 'markdown',
                 userLanguageCode: state.userLanguageCode ?? this._lastUserLanguageCode,
                 origin: state.origin,
-                q4hAnswerCallIds: state.q4hAnswerCallIds,
+                q4hAnswerCallId: state.q4hAnswerCallId,
                 tellaskReplyDirective: state.tellaskReplyDirective,
                 skipTaskdoc: state.skipTaskdoc,
                 subdialogReplyTarget: state.subdialogReplyTarget,
@@ -714,7 +711,7 @@ class Dialog {
                 grammar: options.grammar,
                 userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
                 origin: 'user',
-                q4hAnswerCallIds: options.q4hAnswerCallIds,
+                q4hAnswerCallId: options.q4hAnswerCallId,
             };
             this.enqueueQueuedPromptState(created);
             return created;
@@ -724,7 +721,7 @@ class Dialog {
             prompt: `${existing.prompt}\n\n---\n\n${trimmed}`,
             grammar: options.grammar,
             userLanguageCode: options.userLanguageCode ?? existing.userLanguageCode ?? this._lastUserLanguageCode,
-            q4hAnswerCallIds: this.mergePromptQ4HAnswerCallIds(existing.q4hAnswerCallIds, options.q4hAnswerCallIds),
+            q4hAnswerCallId: this.mergePromptQ4HAnswerCallId(existing.q4hAnswerCallId, options.q4hAnswerCallId),
         };
         this.replaceQueuedPromptState(existing.msgId, merged);
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
@@ -733,8 +730,10 @@ class Dialog {
     queueDeferredQ4HAnswerPrompt(options) {
         const trimmed = options.prompt.trim();
         if (!trimmed) {
-            throw new Error('Prompt is required to queue deferred Q4H answer');
+            throw new Error('Continuation input is required to queue deferred Q4H answer');
         }
+        // This queue item only carries the already-answered askHuman call correlation into the next
+        // resumed drive. The answer itself has already been persisted as tellask result/carryover.
         const created = {
             kind: 'deferred_q4h_answer',
             prompt: trimmed,
@@ -742,7 +741,7 @@ class Dialog {
             grammar: options.grammar,
             userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
             origin: 'user',
-            q4hAnswerCallIds: options.q4hAnswerCallIds,
+            q4hAnswerCallId: options.q4hAnswerCallId,
             runControl: undefined,
         };
         this.enqueueQueuedPromptState(created);
@@ -762,7 +761,7 @@ class Dialog {
                 grammar: options.grammar,
                 userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
                 origin: 'runtime',
-                q4hAnswerCallIds: options.q4hAnswerCallIds,
+                q4hAnswerCallId: options.q4hAnswerCallId,
                 tellaskReplyDirective: options.tellaskReplyDirective,
                 skipTaskdoc: options.skipTaskdoc,
                 subdialogReplyTarget: options.subdialogReplyTarget,
@@ -777,7 +776,7 @@ class Dialog {
             msgId: options.msgId,
             grammar: options.grammar,
             userLanguageCode: options.userLanguageCode ?? existing.userLanguageCode ?? this._lastUserLanguageCode,
-            q4hAnswerCallIds: this.mergePromptQ4HAnswerCallIds(existing.q4hAnswerCallIds, options.q4hAnswerCallIds),
+            q4hAnswerCallId: this.mergePromptQ4HAnswerCallId(existing.q4hAnswerCallId, options.q4hAnswerCallId),
             tellaskReplyDirective: options.tellaskReplyDirective ?? existing.tellaskReplyDirective,
             skipTaskdoc: options.skipTaskdoc ?? existing.skipTaskdoc,
             subdialogReplyTarget: options.subdialogReplyTarget ?? existing.subdialogReplyTarget,
@@ -887,6 +886,184 @@ class Dialog {
     async receiveFuncResult(result) {
         return await this.dlgStore.receiveFuncResult(this, result);
     }
+    async receiveTellaskResult(result) {
+        return await this.dlgStore.receiveTellaskResult(this, result);
+    }
+    async receiveTellaskCarryover(result) {
+        return await this.dlgStore.receiveTellaskCarryover(this, result);
+    }
+    async receiveTellaskCallResult(responderId, callName, mentionList, tellaskContent, result, status, callId) {
+        const tellaskResult = callName === 'tellask'
+            ? {
+                type: 'tellask_result_msg',
+                role: 'tool',
+                genseq: this.activeGenSeqOrUndefined ?? 1,
+                callId,
+                callName,
+                status,
+                content: result,
+                call: {
+                    tellaskContent,
+                    mentionList: mentionList ?? [],
+                },
+                responder: {
+                    responderId,
+                },
+            }
+            : callName === 'tellaskSessionless'
+                ? {
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    genseq: this.activeGenSeqOrUndefined ?? 1,
+                    callId,
+                    callName,
+                    status,
+                    content: result,
+                    call: {
+                        tellaskContent,
+                        mentionList: mentionList ?? [],
+                    },
+                    responder: {
+                        responderId,
+                    },
+                }
+                : {
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    genseq: this.activeGenSeqOrUndefined ?? 1,
+                    callId,
+                    callName,
+                    status,
+                    content: result,
+                    call: {
+                        tellaskContent,
+                    },
+                    responder: {
+                        responderId,
+                    },
+                };
+        await this.receiveTellaskResult(tellaskResult);
+    }
+    async receiveTellaskResponse(responderId, callName, mentionList, tellaskContent, status, subdialogId, options) {
+        const currentCourse = this.activeGenCourseOrUndefined ?? this.currentCourse;
+        const resultRoute = {
+            ...(subdialogId ? { calleeDialogId: subdialogId.selfId } : {}),
+            ...(typeof options.calleeCourse === 'number' ? { calleeCourse: options.calleeCourse } : {}),
+            ...(typeof options.calleeGenseq === 'number' ? { calleeGenseq: options.calleeGenseq } : {}),
+        };
+        const carryoverOriginCourse = options.originCourse;
+        const isCrossCourseResponse = carryoverOriginCourse !== undefined && carryoverOriginCourse !== currentCourse;
+        if (isCrossCourseResponse) {
+            // Cross-course completion is not represented as a tool-result pair in the latest course.
+            // Instead we write a canonical current-course carryover message that restates the older
+            // tellask plus its resolution so the latest-course LLM context can read it directly.
+            if (typeof options.carryoverContent !== 'string') {
+                throw new Error(`receiveTellaskResponse invariant violation: missing carryover content for cross-course response ` +
+                    `(callId=${options.callId}, callName=${callName}, originCourse=${options.originCourse}, currentCourse=${currentCourse})`);
+            }
+            if (options.carryoverContent.trim() === '') {
+                throw new Error(`receiveTellaskResponse invariant violation: empty carryover content ` +
+                    `(callId=${options.callId}, callName=${callName})`);
+            }
+            if (options.response.trim() === '') {
+                throw new Error(`receiveTellaskResponse invariant violation: empty carryover response body ` +
+                    `(callId=${options.callId}, callName=${callName})`);
+            }
+            if (callName === 'tellaskBack') {
+                throw new Error(`receiveTellaskResponse invariant violation: tellaskBack does not support carryover (callId=${options.callId})`);
+            }
+            const carryoverResult = {
+                type: 'tellask_carryover_msg',
+                role: 'user',
+                genseq: this.activeGenSeqOrUndefined ?? 1,
+                content: options.carryoverContent,
+                originCourse: carryoverOriginCourse,
+                carryoverCourse: currentCourse,
+                responderId,
+                callName,
+                tellaskContent,
+                status,
+                response: options.response,
+                agentId: options.agentId,
+                callId: options.callId,
+                originMemberId: options.originMemberId,
+                ...(callName === 'tellask'
+                    ? {
+                        mentionList: mentionList ?? [],
+                        sessionSlug: options.sessionSlug,
+                    }
+                    : callName === 'tellaskSessionless'
+                        ? {
+                            mentionList: mentionList ?? [],
+                        }
+                        : {}),
+                ...resultRoute,
+            };
+            await this.receiveTellaskCarryover(carryoverResult);
+            return carryoverResult;
+        }
+        const tellaskResult = callName === 'tellask'
+            ? {
+                type: 'tellask_result_msg',
+                role: 'tool',
+                genseq: this.activeGenSeqOrUndefined ?? 1,
+                callId: options.callId,
+                callName,
+                status,
+                content: options.response,
+                call: {
+                    tellaskContent,
+                    mentionList: mentionList ?? [],
+                    ...(options.sessionSlug ? { sessionSlug: options.sessionSlug } : {}),
+                },
+                responder: {
+                    responderId,
+                    agentId: options.agentId,
+                    originMemberId: options.originMemberId,
+                },
+                route: resultRoute,
+            }
+            : callName === 'tellaskSessionless'
+                ? {
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    genseq: this.activeGenSeqOrUndefined ?? 1,
+                    callId: options.callId,
+                    callName,
+                    status,
+                    content: options.response,
+                    call: {
+                        tellaskContent,
+                        mentionList: mentionList ?? [],
+                    },
+                    responder: {
+                        responderId,
+                        agentId: options.agentId,
+                        originMemberId: options.originMemberId,
+                    },
+                    route: resultRoute,
+                }
+                : {
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    genseq: this.activeGenSeqOrUndefined ?? 1,
+                    callId: options.callId,
+                    callName,
+                    status,
+                    content: options.response,
+                    call: {
+                        tellaskContent,
+                    },
+                    responder: {
+                        responderId,
+                        agentId: options.agentId,
+                        originMemberId: options.originMemberId,
+                    },
+                    route: resultRoute,
+                };
+        await this.receiveTellaskResult(tellaskResult);
+        return tellaskResult;
+    }
     async notifyGeneratingStart(msgId) {
         // Capture the generation's starting course so any events emitted during this generation
         // remain attributed to the correct course even if a tool mutates dialog.currentCourse
@@ -964,29 +1141,34 @@ class Dialog {
     async webSearchCall(payload) {
         await this.dlgStore.webSearchCall(this, payload);
     }
+    async nativeToolCall(payload) {
+        await this.dlgStore.nativeToolCall(this, payload);
+    }
     // Tellask-special call lifecycle events
     async callingStart(payload) {
         // Store callId for inline call-result correlation
         this.setCurrentCallId(payload.callId);
         await this.dlgStore.callingStart(this, payload);
     }
-    /**
-     * Receive call result with callId for inline correlation
-     */
-    async receiveTellaskCallResult(responderId, callName, mentionList, tellaskContent, result, status, callId) {
-        return await this.dlgStore.receiveTellaskCallResult(this, responderId, callName, mentionList, tellaskContent, result, status, callId);
-    }
-    /**
-     * Receive tellask response (separate bubble for tellask sideline replies)
-     */
-    async receiveTellaskResponse(responderId, callName, mentionList, tellaskContent, status, subdialogId, options) {
-        return await this.dlgStore.receiveTellaskResponse(this, responderId, callName, mentionList, tellaskContent, status, subdialogId, options);
-    }
     async updateQuestions4Human(questions) {
         return await this.dlgStore.updateQuestions4Human(this, questions);
     }
-    async persistUserMessage(content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds, tellaskReplyDirective) {
-        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds, tellaskReplyDirective);
+    async persistUserMessage(content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallId, tellaskReplyDirective) {
+        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallId, tellaskReplyDirective);
+    }
+    async receiveHumanReply(args) {
+        if (args.content.trim() === '') {
+            throw new Error(`receiveHumanReply invariant violation: empty human reply content ` +
+                `(rootId=${this.id.rootId} selfId=${this.id.selfId})`);
+        }
+        const callId = args.q4hAnswerCallId.trim();
+        if (callId === '') {
+            throw new Error(`receiveHumanReply invariant violation: empty q4hAnswerCallId ` +
+                `(rootId=${this.id.rootId} selfId=${this.id.selfId})`);
+        }
+        if (args.userLanguageCode === 'zh' || args.userLanguageCode === 'en') {
+            this.setLastUserLanguageCode(args.userLanguageCode);
+        }
     }
     async appendTellaskReplyResolution(payload) {
         await this.dlgStore.appendTellaskReplyResolution(this, payload);
@@ -997,11 +1179,17 @@ class Dialog {
     async persistUiOnlyMarkdown(content, genseq) {
         return await this.dlgStore.persistUiOnlyMarkdown(this, content, genseq);
     }
-    async persistFunctionCall(id, name, arguments_, genseq) {
-        return await this.dlgStore.persistFunctionCall(this, id, name, arguments_, genseq);
+    async persistFunctionCall(id, name, rawArgumentsText, genseq) {
+        return await this.dlgStore.persistFunctionCall(this, id, name, rawArgumentsText, genseq);
+    }
+    async persistTellaskCall(id, name, rawArgumentsText, genseq, options) {
+        return await this.dlgStore.persistTellaskCall(this, id, name, rawArgumentsText, genseq, options);
+    }
+    async persistFunctionCallResultPair(id, name, rawArgumentsText, genseq, result) {
+        return await this.dlgStore.persistFunctionCallResultPair(this, id, name, rawArgumentsText, genseq, result);
     }
-    async persistTellaskSpecialCall(id, name, arguments_, genseq) {
-        return await this.dlgStore.persistTellaskSpecialCall(this, id, name, arguments_, genseq);
+    async persistTellaskCallResultPair(args) {
+        return await this.dlgStore.persistTellaskCallResultPair(this, args);
     }
     /**
      * Post subdialog completion response to this dialog.
@@ -1058,7 +1246,7 @@ class Dialog {
             // Emit virtual generating_start_evt for subdialog response bubble
             await this.notifyGeneratingStart();
             const rawResponse = response;
-            // Emit TellaskResponseEvent
+            // Emit TellaskResultEvent
             const evt = (() => {
                 switch (callName) {
                     case 'tellask':
@@ -1067,48 +1255,69 @@ class Dialog {
                                 `(dialogId=${this.id.selfId}, subdialogId=${subdialogId.selfId}, callId=${callId})`);
                         }
                         return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            calleeDialogId: subdialogId.selfId,
+                            type: 'tellask_result_evt',
                             callName,
-                            sessionSlug,
-                            mentionList: mentionList ?? [],
-                            tellaskContent,
+                            call: {
+                                sessionSlug,
+                                mentionList: mentionList ?? [],
+                                tellaskContent,
+                            },
                             status: 'completed',
                             course: this.currentCourse,
-                            response: rawResponse,
-                            agentId: responderAgentId ?? responderId,
                             callId,
-                            originMemberId,
+                            genseq: this.activeGenSeqOrUndefined ?? 1,
+                            content: rawResponse,
+                            responder: {
+                                responderId,
+                                agentId: responderAgentId ?? responderId,
+                                originMemberId,
+                            },
+                            route: {
+                                calleeDialogId: subdialogId.selfId,
+                            },
                         };
                     case 'tellaskSessionless':
                         return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            calleeDialogId: subdialogId.selfId,
+                            type: 'tellask_result_evt',
                             callName,
-                            mentionList: mentionList ?? [],
-                            tellaskContent,
+                            call: {
+                                mentionList: mentionList ?? [],
+                                tellaskContent,
+                            },
                             status: 'completed',
                             course: this.currentCourse,
-                            response: rawResponse,
-                            agentId: responderAgentId ?? responderId,
                             callId,
-                            originMemberId,
+                            genseq: this.activeGenSeqOrUndefined ?? 1,
+                            content: rawResponse,
+                            responder: {
+                                responderId,
+                                agentId: responderAgentId ?? responderId,
+                                originMemberId,
+                            },
+                            route: {
+                                calleeDialogId: subdialogId.selfId,
+                            },
                         };
                     case 'freshBootsReasoning':
                         return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            calleeDialogId: subdialogId.selfId,
+                            type: 'tellask_result_evt',
                             callName,
-                            tellaskContent,
+                            call: {
+                                tellaskContent,
+                            },
                             status: 'completed',
                             course: this.currentCourse,
-                            response: rawResponse,
-                            agentId: responderAgentId ?? responderId,
                             callId,
-                            originMemberId,
+                            genseq: this.activeGenSeqOrUndefined ?? 1,
+                            content: rawResponse,
+                            responder: {
+                                responderId,
+                                agentId: responderAgentId ?? responderId,
+                                originMemberId,
+                            },
+                            route: {
+                                calleeDialogId: subdialogId.selfId,
+                            },
                         };
                 }
             })();
@@ -1117,7 +1326,7 @@ class Dialog {
             await this.notifyGeneratingFinish();
         }
         catch (err) {
-            log_1.log.warn('Failed to post tellask_response_evt event', undefined, {
+            log_1.log.warn('Failed to post tellask_result_evt event', undefined, {
                 error: err,
                 message: err instanceof Error ? err.message : String(err),
             });
@@ -1342,14 +1551,8 @@ class DialogStore {
     sayingChunk(_dialog, _chunk) { }
     sayingFinish(_dialog) { }
     async receiveFuncResult(_dialog, _funcResult) { }
-    /**
-     * Receive call result with callId for inline correlation
-     */
-    async receiveTellaskCallResult(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _result, _status, _callId) { }
-    /**
-     * Receive tellask response (separate bubble for tellask sideline replies)
-     */
-    async receiveTellaskResponse(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _status, _subdialogId, _options) { }
+    async receiveTellaskResult(_dialog, _funcResult) { }
+    async receiveTellaskCarryover(_dialog, _result) { }
     async updateQuestions4Human(_dialog, _questions) { }
     /**
      * Load Questions for Human state from storage
@@ -1374,6 +1577,7 @@ class DialogStore {
     // Function call event (non-streaming mode - single event)
     async funcCallRequested(_dialog, _funcId, _funcName, _argumentsStr) { }
     async webSearchCall(_dialog, _payload) { }
+    async nativeToolCall(_dialog, _payload) { }
     /**
      * Load current course number from persisted metadata
      * This method should be implemented by subclasses to read from storage
@@ -1397,7 +1601,7 @@ class DialogStore {
     /**
      * Persist a user message to storage
      */
-    async persistUserMessage(_dialog, _content, _msgId, _grammar, _origin, _userLanguageCode, _q4hAnswerCallIds, _tellaskReplyDirective) { }
+    async persistUserMessage(_dialog, _content, _msgId, _grammar, _origin, _userLanguageCode, _q4hAnswerCallId, _tellaskReplyDirective) { }
     async appendTellaskReplyResolution(_dialog, _payload) { }
     /**
      * Persist an assistant message to storage
@@ -1411,8 +1615,10 @@ class DialogStore {
     /**
      * Persist a function call to storage
      */
-    async persistFunctionCall(_dialog, _id, _name, _arguments, _genseq) { }
-    async persistTellaskSpecialCall(_dialog, _id, _name, _arguments, _genseq) { }
+    async persistFunctionCall(_dialog, _id, _name, _rawArgumentsText, _genseq) { }
+    async persistTellaskCall(_dialog, _id, _name, _rawArgumentsText, _genseq, _options) { }
+    async persistFunctionCallResultPair(_dialog, _id, _name, _rawArgumentsText, _genseq, _result) { }
+    async persistTellaskCallResultPair(_dialog, _args) { }
     /**
      * Start a new course in storage
      */

package/dist/docs/dialog-system.md

@@ -132,6 +132,18 @@ Frontend clients never drive dialogs. Instead, they:
 
 All driving logic, resumption decisions, and state management remain purely backend concerns.
 
+### Global Dialog Event Broadcaster
+
+Some dialog events are rtws-global rather than dialog-scoped, including `new_q4h_asked`, `q4h_answered`, `subdialog_created_evt`, and `dlg_touched_evt`.
+
+These events require a **global dialog event broadcaster** to be installed during runtime bootstrap before any dialog-driving logic runs. This broadcaster is mandatory infrastructure, not an optional optimization:
+
+- WebUI server runtime installs a WebSocket fanout broadcaster
+- Script / test / future runtimes must also install a broadcaster, typically a recording broadcaster
+- Tests should bootstrap the broadcaster at runtime entry and then either assert on captured events or ignore them
+
+Missing broadcaster is therefore a runtime bootstrap invariant violation, not a Q4H/business-layer condition.
+
 ### State Persistence
 
 Dialog state is persisted to storage at key points:

package/dist/docs/dialog-system.zh.md

@@ -131,6 +131,18 @@
 
 所有驱动逻辑、恢复决策和状态管理仍然是纯粹的后端关注点。
 
+### 全局对话事件广播器
+
+有一类对话事件属于 rtws 全局状态，而不是某个对话自己的局部流，包括 `new_q4h_asked`、`q4h_answered`、`subdialog_created_evt`、`dlg_touched_evt`。
+
+这些事件要求 runtime 在任何对话驱动逻辑开始前，就先完成**全局对话事件广播器**的 bootstrap。它是必要基础设施，不是可选优化：
+
+- WebUI server runtime 安装 WebSocket fanout broadcaster
+- script / test / future runtime 也必须安装 broadcaster，通常使用 recording broadcaster
+- tests 应在 runtime 入口完成 broadcaster bootstrap；需要验证广播时断言捕获内容，不需要时可直接忽略
+
+因此，“缺少 broadcaster”应被视为 runtime bootstrap 不变式被破坏，而不是 Q4H/业务层条件。
+
 ### 状态持久化
 
 对话状态在关键点持久化到存储：

package/dist/docs/dominds-terminology.md

@@ -91,6 +91,23 @@
 - EN: A Tellask is not casual chat; it is a collaboration action that Dominds can drive, route, and coordinate (including suspend/resume).
 - ZH: Tellask 不是随意聊天，而是一种可被 Dominds 驱动、路由、并由系统协调（包括挂起/恢复）的协作动作。
 
+### Tellask Carryover（诉请补全）
+
+- EN: **Tellask carryover** is the canonical way to represent, in the **latest/current course**, the completion of a Tellask that was originally asked in an older course.
+- ZH: **Tellask carryover（诉请补全）** 是把“旧 course 中发起、但对当前推进仍然重要的诉请完成结果”规范化写入 **最新/当前 course** 的方式。
+
+- EN: The LLM reads only the latest/current course during normal restore/drive. Carryover exists specifically so the latest course can still see the old request context plus its resolved result without reloading the older course transcript.
+- ZH: 正常的 restore/drive 中，LLM 只读取最新/当前 course。carryover 的存在，就是为了让最新 course 在**不重新加载旧 course transcript** 的前提下，仍能看到旧提问的必要上下文及其完成结果。
+
+- EN: `originCourse` is provenance only: it tells you where the original Tellask was issued.
+- ZH: `originCourse` 只表示来源（provenance）：原始诉请是在哪个 course 发起的。
+
+- EN: `carryoverCourse` and event `course` are owner-course fields: they tell you which current/latest course now contains the usable context.
+- ZH: `carryoverCourse` 和事件里的 `course` 表示归属 course：当前哪一个最新 course 持有这段可直接使用的上下文。
+
+- EN: Carryover is **not** a technical tool-result pair for the old call. It is ordinary current-course context that happens to preserve the semantics of an older Tellask completion.
+- ZH: carryover **不是** 旧 call 的技术性 tool-result 配对；它是当前 course 中的普通规范化上下文，只是语义上保留了那次旧诉请的完成结果。
+
 #### Tellask headline（诉请头）
 
 - EN: The first line of a Tellask block, starting with `tellaskSessionless({ targetAgentId: "<name>", tellaskContent: "..." })`.