dominds 0.8.7 → 0.8.8

package/dist/docs/dialog-system.md

@@ -27,20 +27,30 @@ This document provides detailed implementation specifications for the Dominds di
 ## Terminology
 
 This chapter defines the implementation-facing terms used throughout this document.
-For bilingual / user-facing naming conventions (mainline dialog / sideline dialog; tellasker / tellaskee), see [`dominds-terminology.md`](./dominds-terminology.md).
+For bilingual / user-facing naming conventions (mainline dialog / sideline dialog; tellasker dialog / tellaskee dialog), see [`dominds-terminology.md`](./dominds-terminology.md).
 For Taskdoc package structure and encapsulation rules, see [`encapsulated-taskdoc.md`](./encapsulated-taskdoc.md).
 
 ### Supdialog
 
 A **supdialog** (short for "super dialog") is the supdialog in a hierarchical dialog relationship. It orchestrates and manages subdialogs, providing context, objectives, and guidance while receiving results, questions, and escalations from its subdialogs. The supdialog maintains the overall task context and determines when subdialogs are no longer needed.
 
+Note: **supdialog** is a structural parent in the dialog hierarchy. It is not the same as the **tellasker dialog** (the caller for the current Tellask). For TYPE A (`tellaskBack`), the tellasker dialog is the direct supdialog; for TYPE B/C, the tellasker dialog may be a different dialog.
+
 A supdialog may receive **TellaskBack** from its subdialogs during their task execution. When a subdialog needs guidance or additional context, it can Tellask back via `tellaskBack({ tellaskContent: "..." })` (TYPE A / `TellaskBack` / 回问诉请), which provides responses that feed back into the subdialog's context.
 
 ### Subdialog
 
 A **subdialog** is a specialized dialog spawned by a supdialog to handle specific subtasks. Subdialogs operate with fresh context, focusing on targeted objectives while maintaining a communication link back to their supdialog.
 
-**TellaskBack**: A subdialog can Tellask its supdialog (tellasker) to request clarification during task execution. This allows the subdialog to ask questions and receive guidance while maintaining its own context and progress.
+**TellaskBack**: A subdialog can Tellask its **tellasker dialog** to request clarification during task execution. In TYPE A, the tellasker dialog is the direct supdialog. This allows the subdialog to ask questions and receive guidance while maintaining its own context and progress.
+
+### Tellasker dialog / Tellaskee dialog (caller roles)
+
+A **tellasker dialog** is the dialog that issued the current Tellask (the caller). A **tellaskee dialog** is the dialog handling that Tellask (this dialog). These are **call roles**, not hierarchy:
+
+- For TYPE A (`tellaskBack`), the tellasker dialog is the direct supdialog.
+- For TYPE B/C, the tellasker dialog may be a different dialog (root dialog or another sideline dialog).
+- Responses route to the **current tellasker dialog** recorded in `assignmentFromSup`.
 
 ### Main Dialog (Root Dialog)
 
@@ -48,7 +58,7 @@ The **main dialog** (also called **root dialog**) is the top-level dialog in a d
 
 ### Q4H (Questions for Human)
 
-A **Q4H** is a pending question raised by a dialog (main or subdialog) that requires human input to proceed. Q4Hs are indexed in the dialog's `q4h.yaml` file (an index, not source of truth) and are **cleared by `clear_mind` operations**. The actual question content is stored in the dialog's messages where the `!?askHuman()` Tellask was recorded.
+A **Q4H** is a pending question raised by a dialog (main or subdialog) that requires human input to proceed. Q4Hs are indexed in the dialog's `q4h.yaml` file (an index, not source of truth) and are **cleared by `clear_mind` operations**. The actual question content is stored in the dialog's messages where the `askHuman({ tellaskContent: "..." })` Tellask was recorded.
 
 ### Subdialog Index (subdlg.yaml)
 
@@ -141,14 +151,14 @@ This section documents the three distinct types of teammate Tellasks in the Domi
 
 ```mermaid
 flowchart TD
-  M[LLM emits tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{Is this a subdialog telling its direct supdialog?}
+  M[LLM emits tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{Is this a subdialog Tellasking its direct supdialog (tellasker dialog for TYPE A)?}
   Q -- yes --> A[TYPE A: TellaskBack<br/>(`TellaskBack` / 回问诉请)<br/>Primary: tellaskBack({ tellaskContent: "..." }) (NO sessionSlug)]
   Q -- no --> T{Is sessionSlug present?}
   T -- yes --> B[TYPE B: Registered subdialog Tellask<br/>(`Tellask Session` / 长线诉请)<br/>tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })]
   T -- no --> C[TYPE C: Transient subdialog Tellask<br/>(`Fresh Tellask` / 一次性诉请)<br/>tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })]
 ```
 
-### TYPE A: Supdialog Tellask (Type A / `TellaskBack` / 回问诉请)
+### TYPE A: TellaskBack (Type A / `TellaskBack` / 回问诉请)
 
 **Primary syntax**: `tellaskBack({ tellaskContent: "..." })` (NO `sessionSlug`) — `tellaskBack({ tellaskContent: "..." }) sessionSlug ...` is a **syntax error**
 
@@ -157,21 +167,35 @@ flowchart TD
 **Behavior**:
 
 1. Current subdialog **suspends**
-2. Driver switches to drive the **supdialog** (using `subdialog.supdialog` reference)
-3. Supdialog response flows back to the subdialog
-4. Subdialog **resumes** with supdialog's response in context
+2. Driver switches to drive the **tellasker dialog** (direct supdialog for TYPE A; uses `subdialog.supdialog` reference)
+3. Tellasker dialog response flows back to the subdialog
+4. Subdialog **resumes** with tellasker dialog's response in context
 
 **Key Characteristics**:
 
 - Uses `subdialog.supdialog` reference (no registry lookup)
 - No registration - supdialog relationship is inherent
-- Supdialog is always the direct parent in the hierarchy
+- Supdialog is always the direct parent in the hierarchy (the tellasker dialog for TYPE A)
 - `tellaskBack({ tellaskContent: "..." })` is the canonical Type A syntax: it always routes to the tellasker (the dialog that issued the current Tellask).
 - This matters especially when the supdialog’s `agentId` is identical to the subdialog’s `agentId` (common when a sideline
   is created via `freshBootsReasoning({ tellaskContent: "..." })`), where an explicit `tellaskBack({ tellaskContent: "..." })` is easier to get wrong by accident.
 - The explicit `tellaskBack({ tellaskContent: "..." })` form is accepted as a semantic fallback for backwards compatibility, but is more
   error-prone in FBR/self-subdialog cases.
 
+**Sideline delivery rule (normative)**:
+
+- A sideline dialog may reply directly to the tellasker dialog **only when all assigned goals are complete**.
+- If any goal is incomplete or critical context is missing, it MUST issue `tellaskBack({ tellaskContent: "..." })` to request clarification or next-step confirmation before proceeding.
+- **FBR exception**: FBR sideline dialogs are tellask-free (no `tellaskBack`); they must list missing context and return.
+
+**Content markers (first line required)**:
+
+- `【tellaskBack】` — required when asking the tellasker dialog for clarification / next-step confirmation.
+- `【最终完成】` — required for final delivery when all goals are complete.
+- FBR-only: `【FBR-直接回复】` or `【FBR-仅推理】` for FBR sideline responses.
+
+Note: no extra "Status: ..." line is required; the first-line marker is the stage reminder.
+
 **Example**:
 
 ```
@@ -214,7 +238,7 @@ headline text is ignored for tellaskSession parsing.
 
 **Current Caller Tracking (important for reuse):**
 
-When a registered subdialog is Tellasked again (same `agentId!sessionSlug`), the caller can be a **different dialog** (mainline or another sideline). On every Type B Tellask, the subdialog’s metadata is updated with:
+When a registered subdialog is Tellasked again (same `agentId!sessionSlug`), the caller can be a **different dialog** (root dialog or another sideline dialog). On every Type B Tellask, the subdialog’s metadata is updated with:
 
 - The **current caller dialog ID** (so responses route back to the _latest_ caller)
 - The **Tellask info** (headline/body, origin role, origin member, callId)
@@ -279,7 +303,7 @@ Result (second call):
 2. Create **NEW subdialog** with the specified agentId
 3. Drive the new subdialog:
    - For general Type C, the subdialog is full-fledged (supcalls, teammate Tellasks, tools per config).
-   - For `freshBootsReasoning({ tellaskContent: "..." })`, runtime applies the FBR tool-less policy (no tools; restricted Tellasks).
+   - For `freshBootsReasoning({ tellaskContent: "..." })`, runtime applies the FBR tool-less policy (no tools; no Tellasks).
 4. Subdialog response flows back to parent
 5. Parent **resumes** with subdialog's response
 
@@ -287,7 +311,7 @@ Result (second call):
 
 - **No registry lookup** - always creates a new subdialog
 - **Not registered** - no persistence across Tellasks
-- The subdialog itself is fully capable **except** for `freshBootsReasoning({ tellaskContent: "..." })` FBR, which is tool-less and Tellask-restricted (see `fbr.md`).
+- The subdialog itself is fully capable **except** for `freshBootsReasoning({ tellaskContent: "..." })` FBR, which is tool-less and tellask-free (see `fbr.md`).
 - Only difference from TYPE B: no registry lookup/resume capability
 - Used for one-off, independent tasks
 
@@ -336,7 +360,7 @@ The Dominds dialog system is built on four interconnected core mechanisms that w
 ```mermaid
 flowchart TD
   H[Dialog hierarchy<br/>(root ↔ subdialogs)] <--> S[Subdialog supply<br/>(responses, pending list, registry)]
-  H --> Q[Q4H (!?askHuman())<br/>(q4h.yaml index)]
+  H --> Q[Q4H (askHuman({ tellaskContent: "..." }))<br/>(q4h.yaml index)]
   S --> Q
 
   Q --> UI[Frontend Q4H panel<br/>(questions_count_update)]
@@ -350,7 +374,7 @@ flowchart TD
 
 ### Key Design Principles
 
-1. **Q4H Index in `q4h.yaml`**: Q4H questions are indexed in `q4h.yaml` (as an index, not source of truth) and cleared by mental clarity operations. The actual question content is in the dialog's messages where the `!?askHuman()` Tellask was recorded. They do not survive `clear_mind`.
+1. **Q4H Index in `q4h.yaml`**: Q4H questions are indexed in `q4h.yaml` (as an index, not source of truth) and cleared by mental clarity operations. The actual question content is in the dialog's messages where the `askHuman({ tellaskContent: "..." })` Tellask was recorded. They do not survive `clear_mind`.
 
 2. **Hierarchical Q4H**: Any dialog in the hierarchy can raise Q4H on its own right (root dialog or subdialog). Questions are indexed in the dialog that asked them, not passed upward.
 
@@ -364,7 +388,7 @@ flowchart TD
 
 7. **State Preservation Contract**:
    - `clear_mind`: Clears messages, clears Q4H index, preserves reminders, preserves registry
-   - Subdialog completion: Writes response to supdialog, removes from pending list (registry unchanged)
+   - Subdialog completion: Writes response to the current tellasker dialog, removes from pending list (registry unchanged)
    - Subdialog declared dead: marks runState dead and removes its Type B registry entry; same slug can be reused as a fresh sideline dialog
    - Q4H answer: Clears the answered question from index, continues the dialog
 
@@ -383,7 +407,7 @@ Q4H (Questions for Human) is the mechanism by which dialogs can suspend executio
  * HumanQuestion - index entry persisted in q4h.yaml per dialog
  * NOTE: This is an INDEX, not the source of truth. The actual question
  * content is in the dialog's messages where the askHuman() Tellask was recorded
- * (invoked via !?askHuman()).
+ * (invoked via askHuman({ tellaskContent: "..." })).
  */
 interface HumanQuestion {
   readonly id: string; // Unique identifier (UUID) - matches message ID
@@ -395,7 +419,7 @@ interface HumanQuestion {
 
 **Storage Location**: `<dialog-path>/q4h.yaml` - serves as an index for quick lookup
 
-**Source of Truth**: The actual `!?askHuman()` Tellask is stored in the dialog's messages (course JSONL files), where the question was asked.
+**Source of Truth**: The actual `askHuman({ tellaskContent: "..." })` Tellask is stored in the dialog's messages (course JSONL files), where the question was asked.
 
 ### Q4H Mechanism Flow
 
@@ -419,24 +443,23 @@ sequenceDiagram
 
 ### When Does a Dialog Raise Q4H?
 
-Q4H is raised when the `!?askHuman()` teammate Tellask is invoked by ANY dialog (root or subdialog) on its own right:
+Q4H is raised when the `askHuman({ tellaskContent: "..." })` tellask function is invoked by ANY dialog (root or subdialog) on its own right:
 
 ```typescript
-// From main/llm/driver.ts, executeTellaskCall function
-const isQ4H = callKind === 'askHuman';
+// From main/llm/driver-v2/tellask-bridge.ts
+const isQ4H = callName === 'askHuman';
 ```
 
 **Invocation Pattern**:
 
-```
-!?askHuman() <question headline>
-!?<question body content>
+```typescript
+askHuman({ tellaskContent: "<question headline>\n<question body content>" });
 ```
 
 ### Q4H Recording Process
 
 ```typescript
-// When !?askHuman() is detected as a teammate Tellask
+// When askHuman({ tellaskContent: "..." }) is detected as a teammate Tellask
 async function recordQuestionForHuman(
   dlg: Dialog,
   mentionList: string,
@@ -554,7 +577,7 @@ sequenceDiagram
   Sup->>Sub: creates subdialog (Type B or C)
   Note over Sup: Supdialog is blocked on pending subdialogs
 
-  Sub->>WS: emits !?askHuman() question
+  Sub->>WS: emits askHuman({ tellaskContent: "..." }) question
   WS-->>UI: questions_count_update
   Note over Sub: Subdialog cannot proceed until answered
 
@@ -607,11 +630,11 @@ flowchart TD
 
 ### Subdialog Response Supply Mechanism
 
-**Core Principle**: Subdialogs supply responses to supdialog's context via persistence, not callbacks.
+**Core Principle**: Subdialogs supply responses to the **current tellasker dialog's** context via persistence, not callbacks (the tellasker is the direct supdialog for TYPE A; for TYPE B/C it may be a different dialog).
 
 ```mermaid
 sequenceDiagram
-  participant Sup as Supdialog
+  participant Sup as Tellasker dialog
   participant Driver as Backend driver
   participant Sub as Subdialog
   participant Store as Persistence
@@ -923,10 +946,25 @@ interface RegistryMethods {
 **Context Inheritance**: New subdialogs automatically receive:
 
 - Reference to the same rtws (runtime workspace) Taskdoc (recommended: `tasks/feature-auth.tsk/`); `dlg.taskDocPath` is fixed at dialog creation and never reassigned
-- Supdialog Tellask context (mentionList + tellaskContent) explaining their purpose
+- Tellasker dialog Tellask context (mentionList + tellaskContent) explaining their purpose
 - Access to shared team memories
 - Access to their agent's individual memories
 
+### Subdialog course header (required)
+
+At the start of every subdialog course, the runtime must prepend a role header to the assignment prompt:
+
+- EN: `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @xxx (the current caller).`
+- ZH: `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @xxx（当前发起本次诉请）。`
+
+**FBR special handling**: FBR is a self-subdialog and must keep a dedicated header to avoid confusion:
+
+- EN (example): `This is an FBR sideline dialog; the tellasker dialog is @xxx (may be the same agent).`
+- ZH（示例）: `这是一次 FBR 支线对话；诉请者对话为 @xxx（可能与当前对话同一 agent）。`
+
+**Insertion point**: prefer a single insertion point by updating `formatAssignmentFromSupdialog()` (covers `dialog.ts`, `tellask-bridge`, and `agent-priming`).
+Frontend twin must stay in sync: `dominds/webapp/src/shared/utils/inter-dialog-format.ts`.
+
 **Storage**: All subdialogs are stored flat under the main dialog's (root dialog's) `subdialogs/` directory, regardless of nesting depth.
 
 **Navigation**: Each subdialog maintains a reference to its parent, enabling upward traversal to the main dialog.
@@ -950,9 +988,9 @@ interface RegistryMethods {
 
 ### Communication Patterns
 
-**Upward Communication**: Subdialogs communicate results, questions, and escalations to their supdialogs.
+**Upward Communication**: Subdialogs communicate results, questions, and escalations to their **tellasker dialog** (the caller).
 
-- **Clarification Requests (TYPE A / `TellaskBack`)**: A subdialog may Tellask its supdialog to request clarification while working on its subtask. The supdialog provides guidance, and the subdialog continues with updated context.
+- **Clarification Requests (TYPE A / `TellaskBack`)**: A subdialog may Tellask its tellasker dialog to request clarification while working on its subtask. For TYPE A, the tellasker dialog is the direct supdialog. The tellasker dialog provides guidance, and the subdialog continues with updated context.
 - **Subtask Response**: When a subdialog produces a final "saying" content block (no pending Q4H), that message is treated as the response to the **current caller** recorded in `assignmentFromSup` (root or another subdialog). This keeps responses aligned with the most recent Tellask site.
 - **Q4H Escalation**: If a subdialog has Q4H, it suspends. The user can answer via the UI, which triggers continuation of the subdialog only.
 - **Registered Subdialogs (TYPE B / `Tellask Session`)**: A parent can resume a previously created registered subdialog, enabling ongoing task continuation.
@@ -1045,7 +1083,7 @@ To make the UI **faithfully reflect the original generation order**, and to ensu
 
 **Teammate Tellask Capability**: Agents can invoke all three types of teammate Tellasks:
 
-- TYPE A / `TellaskBack`: Tellask supdialog for clarification
+- TYPE A / `TellaskBack`: Tellask the tellasker dialog for clarification (direct supdialog for TYPE A)
 - TYPE B / `Tellask Session`: Tellask/resume registered subdialogs
 - TYPE C / `Fresh Tellask`: Spawn transient subdialogs
 
@@ -1096,10 +1134,10 @@ rendered in different markdown viewers.
 sequenceDiagram
   participant Sub as Subdialog
   participant Driver as Backend driver
-  participant Sup as Supdialog (direct parent)
+  participant Sup as Tellasker dialog (direct supdialog)
 
   Sub->>Driver: emits `tellaskBack({ tellaskContent: "..." })` + question
-  Driver->>Sup: drive supdialog to answer
+  Driver->>Sup: drive tellasker dialog to answer
   Sup-->>Driver: response text
   Driver-->>Sub: resume subdialog with response in context
 ```
@@ -1148,7 +1186,7 @@ sequenceDiagram
 
 ```mermaid
 flowchart TD
-  A[!?askHuman() Tellask emitted] --> B[Append HumanQuestion entry to q4h.yaml]
+  A[askHuman({ tellaskContent: "..." }) Tellask emitted] --> B[Append HumanQuestion entry to q4h.yaml]
   B --> C[Emit questions_count_update]
   C --> D[UI shows Q4H badge / list]
   D --> E{How is it cleared?}
@@ -1173,7 +1211,7 @@ sequenceDiagram
 
   Sup->>Sub: create subdialog (Type B or C)
   Note over Sup,Sub: Supdialog becomes blocked on pending subdialogs
-  Sub->>WS: emits !?askHuman() question (Q4H)
+  Sub->>WS: emits askHuman({ tellaskContent: "..." }) question (Q4H)
   WS-->>UI: questions_count_update (global)
 
   Note over Sub: Subdialog cannot proceed until answered
@@ -1202,7 +1240,7 @@ sequenceDiagram
   participant Store as Persistence (q4h.yaml)
   participant UI as Frontend
 
-  User->>Main: !?askHuman() question
+  User->>Main: askHuman({ tellaskContent: "..." }) question
   Main->>Store: recordQuestionForHuman()
   Main-->>UI: questions_count_update
   Main-->>Main: suspend root drive loop

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

@@ -27,20 +27,30 @@
 ## 术语
 
 本章定义本文档中使用的面向实现的术语。
-关于双语/面向用户的命名约定，请参阅 [`dominds-terminology.md`](./dominds-terminology.md)。
+关于双语/面向用户的命名约定（主线对话/支线对话；诉请者对话/被诉请者对话），请参阅 [`dominds-terminology.md`](./dominds-terminology.md)。
 关于 Taskdoc 包结构和封装规则，请参阅 [`encapsulated-taskdoc.zh.md`](./encapsulated-taskdoc.zh.md)。
 
 ### 上位对话 (Supdialog)
 
 **上位对话** (supdialog，全称 "super dialog") 是层级对话关系中的上位对话。它编排和管理子对话，提供上下文、目标和指导，同时接收来自子对话的结果、问题和升级。上位对话维护整体任务上下文，并决定何时不再需要子对话。
 
-上位对话可以在子对话执行期间接收**上位 Tellask**。当子对话需要指导或额外上下文时，它可以向上位对话 Tellask（TYPE A / `TellaskBack` / 回问诉请），提供反馈到子对话上下文的响应。
+注意：**上位对话**是层级结构里的父对话，并不等同于**诉请者对话**（本次诉请的发起者）。TYPE A（`tellaskBack`）时，诉请者对话就是直接上位对话；TYPE B/C 时，诉请者对话可能是不同的对话。
+
+上位对话可以在子对话执行期间接收来自子对话的 **TellaskBack（回问诉请）**。当子对话需要指导或额外上下文时，它可以用 `tellaskBack({ tellaskContent: "..." })` 回问（TYPE A / `TellaskBack` / 回问诉请），并将响应反馈到子对话上下文。
 
 ### 子对话 (Subdialog)
 
 **子对话** 是由上位对话生成的专门对话，用于处理特定子任务。子对话使用新的上下文操作，专注于定向目标，同时保持与上位对话的通信链接。
 
-**上位 Tellask**：子对话可以在任务执行期间向上位对话 Tellask 以请求澄清。这允许子对话在保持自身上下文和进度的同时提问并接收指导。
+**TellaskBack（回问诉请）**：子对话可以在任务执行期间向**诉请者对话**回问澄清。TYPE A 中诉请者对话就是直接上位对话。此机制允许子对话在保持自身上下文和进度的同时提问并接收指导。
+
+### 诉请者对话 / 被诉请者对话（调用角色）
+
+**诉请者对话**是发起本次诉请的对话（caller），**被诉请者对话**是处理本次诉请的对话（当前对话）。这是**调用角色**，不是层级关系：
+
+- TYPE A（`tellaskBack`）时，诉请者对话是直接上位对话。
+- TYPE B/C 时，诉请者对话可能是主线对话，也可能是其他支线对话。
+- 回贴会路由到 `assignmentFromSup` 中记录的**当前诉请者对话**。
 
 ### 主对话 (Root Dialog)
 
@@ -48,7 +58,7 @@
 
 ### Q4H (向人类提问)
 
-**Q4H** 是由对话（主对话或子对话）提出的待处理问题，需要人工输入才能继续。Q4H 被索引在对话的 `q4h.yaml` 文件中（一个索引，不是真理之源），并由 `clear_mind` 操作清除。实际的问题内容存储在对话的对话消息中，其中记录了 `!?askHuman()` Tellask。
+**Q4H** 是由对话（主对话或子对话）提出的待处理问题，需要人工输入才能继续。Q4H 被索引在对话的 `q4h.yaml` 文件中（一个索引，不是真理之源），并由 `clear_mind` 操作清除。实际的问题内容存储在对话的对话消息中，其中记录了 `askHuman({ tellaskContent: "..." })` Tellask。
 
 ### 子对话索引 (subdlg.yaml)
 
@@ -140,14 +150,14 @@
 
 ```mermaid
 flowchart TD
-  M[LLM 发出 tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{这是子对话在告诉其直接上位对话吗？}
+  M[LLM 发出 tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{这是子对话回问其直接上位对话（TYPE A 的诉请者对话）吗？}
   Q -- 是 --> A[TYPE A：回问诉请<br/>(`TellaskBack` / 回问诉请)<br/>主要：`tellaskBack({ tellaskContent: "..." })`（无 sessionSlug）]
   Q -- 否 --> T{是否存在 sessionSlug？}
   T -- 是 --> B[TYPE B：已注册子对话 Tellask<br/>(`Tellask Session` / 长线诉请)<br/>tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })]
   T -- 否 --> C[TYPE C：瞬态子对话 Tellask<br/>(`Fresh Tellask` / 一次性诉请)<br/>tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })]
 ```
 
-### TYPE A：上位 Tellask（Type A / `TellaskBack` / 回问诉请）
+### TYPE A：回问诉请（Type A / `TellaskBack` / 回问诉请）
 
 **主要语法**：`tellaskBack({ tellaskContent: "..." })`（无 `sessionSlug`）— `tellaskBack({ tellaskContent: "..." }) sessionSlug ...` 是**语法错误**
 
@@ -156,17 +166,29 @@ flowchart TD
 **行为**：
 
 1. 当前子对话**挂起**
-2. 驱动程序切换到驱动**上位对话**（使用 `subdialog.supdialog` 引用）
-3. 上位对话的响应流回子对话
-4. 子对话**恢复**，上位对话的响应在上下文中
+2. 驱动程序切换到驱动**诉请者对话**（TYPE A 中为直接上位对话；使用 `subdialog.supdialog` 引用）
+3. 诉请者对话的响应流回子对话
+4. 子对话**恢复**，诉请者对话的响应在上下文中
 
 **关键特征**：
 
 - 使用 `subdialog.supdialog` 引用（无注册表查找）
 - 无需注册 — 上位对话关系是固有的
-- 上位对话始终是层级中的直接父级
+- 上位对话始终是层级中的直接父级（TYPE A 的诉请者对话）
 - `tellaskBack({ tellaskContent: "..." })` 是**规范**的 TYPE A 语法：它始终路由到“诉请者”（发起本次诉请的对话），避免自行猜测。
 
+**支线交付规则（规范）**：
+
+- 只有当所有目标完成时，支线对话才可直接回贴诉请者对话。
+- 若任何目标未完成或关键信息缺失，必须先用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者对话再继续。
+- **FBR 例外**：FBR 支线对话禁止任何诉请（包括 `tellaskBack`），只能列出缺口与阻塞原因并直接回贴。
+
+**首行标记（强制）**：
+
+- `【tellaskBack】` — 回问诉请者对话时必须使用（首行）。
+- `【最终完成】` — 完成全部目标后的最终交付（首行）。
+- FBR 专用：`【FBR-直接回复】` 或 `【FBR-仅推理】`（首行）。
+
 **示例**：
 
 ```
@@ -207,7 +229,7 @@ LLM 发出：tellaskSessionless({ targetAgentId: "orchestrator", tellaskContent:
 
 **当前调用者跟踪（对复用很重要）：**
 
-当已注册的子对话被再次 Tellask（相同的 `agentId!sessionSlug`）时，调用者可能是**不同的对话**（主线对话或其他支线对话）。在每次 TYPE B Tellask 时，子对话的元数据都会更新为：
+当已注册的子对话被再次 Tellask（相同的 `agentId!sessionSlug`）时，调用者可能是**不同的对话**（根对话或其他支线对话）。在每次 TYPE B Tellask 时，子对话的元数据都会更新为：
 
 - **当前调用者对话 ID**（这样响应就会路由回*最新*的调用者）
 - **Tellask 信息**（标题/正文、来源角色、来源成员、callId）
@@ -272,7 +294,7 @@ LLM 再次发出：tellask({ targetAgentId: "researcher", sessionSlug: "market-a
 2. 使用指定的 agentId 创建**新的子对话**
 3. 驱动新的子对话：
    - 一般 TYPE C 子对话是“完整能力”的（可上位调用、队友诉请、按配置使用工具）。
-   - `freshBootsReasoning({ tellaskContent: "..." })` 属于 FBR 特例：无工具、诉请受限（见 `fbr.zh.md`）。
+   - `freshBootsReasoning({ tellaskContent: "..." })` 属于 FBR 特例：无工具、禁止任何诉请（见 `fbr.zh.md`）。
 4. 子对话的响应流回父级
 5. 父级**恢复**，子对话的响应在上下文中
 
@@ -280,7 +302,7 @@ LLM 再次发出：tellask({ targetAgentId: "researcher", sessionSlug: "market-a
 
 - **无注册表查找** - 总是创建新的子对话
 - **不注册** - 在 Tellask 之间不持久化
-- 子对话本身一般是“完整能力”的；但 `freshBootsReasoning({ tellaskContent: "..." })` FBR 是特例：无工具且诉请受限（见 `fbr.zh.md`）。
+- 子对话本身一般是“完整能力”的；但 `freshBootsReasoning({ tellaskContent: "..." })` FBR 是特例：无工具且禁止任何诉请（见 `fbr.zh.md`）。
 - 与 TYPE B 的唯一区别：无注册表查找/恢复能力
 - 用于一次性的、独立的任务
 
@@ -309,7 +331,7 @@ LLM 再次发出：@code-reviewer 审查这个其他 PR
 
 ### 对比总结
 
-| 方面            | TYPE A：上位 Tellask (`TellaskBack`)     | TYPE B：已注册子对话 Tellask (`Tellask Session`)                                         | TYPE C：瞬态子对话 Tellask (`Fresh Tellask`)                                            |
+| 方面            | TYPE A：回问诉请 (`TellaskBack`)         | TYPE B：已注册子对话 Tellask (`Tellask Session`)                                         | TYPE C：瞬态子对话 Tellask (`Fresh Tellask`)                                            |
 | --------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
 | **语法**        | `tellaskBack({ tellaskContent: "..." })` | `tellask({ targetAgentId: "<anyAgentId>", sessionSlug: "<id>", tellaskContent: "..." })` | `tellaskSessionless({ targetAgentId: "<nonSupdialogAgentId>", tellaskContent: "..." })` |
 | **sessionSlug** | 不允许                                   | 必须                                                                                     | 不允许                                                                                  |
@@ -329,7 +351,7 @@ Dominds 对话系统建立在四个相互关联的核心机制之上，这些机
 ```mermaid
 flowchart TD
   H[对话层级<br/>(root ↔ 子对话)] <--> S[子对话供应<br/>(响应、待处理列表、注册表)]
-  H --> Q[Q4H (!?askHuman())<br/>(q4h.yaml 索引)]
+  H --> Q[Q4H (askHuman({ tellaskContent: "..." }))<br/>(q4h.yaml 索引)]
   S --> Q
 
   Q --> UI[前端 Q4H 面板<br/>(questions_count_update)]
@@ -343,7 +365,7 @@ flowchart TD
 
 ### 关键设计原则
 
-1. **Q4H 索引在 `q4h.yaml` 中**：Q4H 问题被索引在 `q4h.yaml` 中（作为索引，不是真理之源），并由思维清晰操作清除。实际的问题内容在对话的对话消息中，其中记录了 `!?askHuman()` Tellask。它们不会在 `clear_mind` 中存活。
+1. **Q4H 索引在 `q4h.yaml` 中**：Q4H 问题被索引在 `q4h.yaml` 中（作为索引，不是真理之源），并由思维清晰操作清除。实际的问题内容在对话的对话消息中，其中记录了 `askHuman({ tellaskContent: "..." })` Tellask。它们不会在 `clear_mind` 中存活。
 
 2. **层级 Q4H**：层级中的任何对话都可以自行提出 Q4H（根对话或子对话）。问题被索引在提出问题的对话中，而不是向上传递。
 
@@ -357,7 +379,7 @@ flowchart TD
 
 7. **状态保留契约**：
    - `clear_mind`：清除消息，清除 Q4H 索引，保留提醒，保留注册表
-   - 子对话完成：向父对话写入响应，从待处理列表中删除（注册表不变）
+   - 子对话完成：向当前诉请者对话写入响应，从待处理列表中删除（注册表不变）
    - 子对话宣布卡死：将 runState 标记为 dead，并移除对应 TYPE B 注册表条目；同一 slug 可作为全新支线重新发起
    - Q4H 回答：从索引中清除已回答的问题，继续对话
 
@@ -376,7 +398,7 @@ Q4H（向人类提问）是对话可以暂停执行并请求人工输入的机
  * HumanQuestion - 索引条目持久化在每个对话的 q4h.yaml 中
  * 注意：这是索引，不是真理之源。实际的 question
  * 内容在对话的对话消息中，其中记录了 askHuman() Tellask
- *（通过 !?askHuman() 调用）。
+ *（通过 askHuman({ tellaskContent: "..." }) 调用）。
  */
 interface HumanQuestion {
   readonly id: string; // 唯一标识符（UUID）- 匹配消息 ID
@@ -388,7 +410,7 @@ interface HumanQuestion {
 
 **存储位置**：`<dialog-path>/q4h.yaml` - 作为快速查找的索引
 
-**真理之源**：实际的 `!?askHuman()` Tellask 存储在对话的对话消息中（course JSONL 文件），即提出问题的地方。
+**真理之源**：实际的 `askHuman({ tellaskContent: "..." })` Tellask 存储在对话的对话消息中（course JSONL 文件），即提出问题的地方。
 
 ### Q4H 机制流程
 
@@ -412,24 +434,23 @@ sequenceDiagram
 
 ### 对话何时提出 Q4H？
 
-当 `!?askHuman()` 队友 Tellask 被任何对话（根或子对话）自行调用时，会提出 Q4H：
+当 `askHuman({ tellaskContent: "..." })` tellask 函数被任何对话（根或子对话）自行调用时，会提出 Q4H：
 
 ```typescript
-// 来自 main/llm/driver.ts，executeTellaskCall 函数
-const isQ4H = callKind === 'askHuman';
+// 来自 main/llm/driver-v2/tellask-bridge.ts
+const isQ4H = callName === 'askHuman';
 ```
 
 **调用模式**：
 
-```
-!?askHuman() <问题标题>
-!?<问题正文内容>
+```typescript
+askHuman({ tellaskContent: "<问题标题>\n<问题正文内容>" });
 ```
 
 ### Q4H 记录过程
 
 ```typescript
-// 当检测到 !?askHuman() 作为队友 Tellask 时
+// 当检测到 askHuman({ tellaskContent: "..." }) 作为队友 Tellask 时
 async function recordQuestionForHuman(
   dlg: Dialog,
   mentionList: string,
@@ -547,7 +568,7 @@ sequenceDiagram
   Sup->>Sub: 创建子对话（TYPE B 或 C）
   Note over Sup: 上位对话因待处理子对话而阻塞
 
-  Sub->>WS: 发出 !?askHuman() 问题
+  Sub->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题
   WS-->>UI: questions_count_update
   Note over Sub: 子对话在回答之前无法继续
 
@@ -600,11 +621,11 @@ flowchart TD
 
 ### 子对话响应供应机制
 
-**核心原则**：子对话通过持久化向上位对话的上下文供应响应，而不是通过回调。
+**核心原则**：子对话通过持久化向**当前诉请者对话**的上下文供应响应，而不是通过回调（TYPE A 时诉请者对话为直接上位对话）。
 
 ```mermaid
 sequenceDiagram
-  participant Sup as 上位对话
+  participant Sup as 诉请者对话
   participant Driver as 后端驱动程序
   participant Sub as 子对话
   participant Store as 持久化
@@ -613,7 +634,7 @@ sequenceDiagram
   Driver->>Sub: 驱动子对话（分离执行）
   Sub-->>Store: 持久化最终响应
   Driver-->>Sup: 供应响应 + 清除待处理子对话
-  opt 上位对话是根且现在已解除阻塞
+  opt 诉请者对话是根且现在已解除阻塞
     Driver-->>Sup: 设置 needsDrive=true（自动重启）
   end
 ```
@@ -910,7 +931,7 @@ interface RegistryMethods {
 **上下文继承**：新的子对话自动接收：
 
 - 对相同 rtws（运行时工作区）Taskdoc 的引用（推荐：`tasks/feature-auth.tsk/`）；`dlg.taskDocPath` 在对话创建时固定，永不重新分配
-- 上位 Tellask 上下文（mentionList + tellaskContent）解释其目的
+- 诉请者对话 Tellask 上下文（mentionList + tellaskContent）解释其目的
 - 访问共享团队内存
 - 访问其智能体的个人内存
 
@@ -920,6 +941,20 @@ interface RegistryMethods {
 
 **注册表**：已注册的子对话（TYPE B Tellask）在根对话的注册表中跟踪，并在重启后持久化；若子对话被宣布卡死，其条目会被裁剪，不再参与后续同 slug 复用。
 
+### 子对话课程头（强制）
+
+每次子对话 course 开始时，运行时必须在 assignment prompt 前插入角色头：
+
+- ZH：`你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @xxx（当前发起本次诉请）。`
+- EN：`You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @xxx (the current caller).`
+
+**FBR 特例**（示例）：
+
+- ZH：`这是一次 FBR 支线对话；诉请者对话为 @xxx（可能与当前对话同一 agent）。`
+- EN：`This is an FBR sideline dialog; the tellasker dialog is @xxx (may be the same agent).`
+
+**插入点**：优先通过 `formatAssignmentFromSupdialog()` 单点注入（覆盖 `dialog.ts` / `tellask-bridge` / `agent-priming`），前端 twin 同步：`dominds/webapp/src/shared/utils/inter-dialog-format.ts`。
+
 ### 生命周期管理
 
 **活动状态**：智能体正在工作时，对话保持活动状态。
@@ -937,9 +972,9 @@ interface RegistryMethods {
 
 ### 通信模式
 
-**向上通信**：子对话向上位对话通信结果、问题和升级。
+**向上通信**：子对话向诉请者对话通信结果、问题和升级。
 
-- **澄清请求（TYPE A / `TellaskBack`）**：子对话在处理其子任务时可能向上位对话 Tellask 以请求澄清。上位对话提供指导，子对话在新上下文中继续。
+- **澄清请求（TYPE A / `TellaskBack`）**：子对话在处理其子任务时可能向诉请者对话 Tellask 以请求澄清。TYPE A 中诉请者对话为直接上位对话。诉请者对话提供指导，子对话在新上下文中继续。
 - **子任务响应**：当子对话产生最终的 "saying" 内容块（没有待处理的 Q4H）时，该消息被视为对**当前调用者**的响应，记录在 `assignmentFromSup` 中（根或另一个子对话）。这使响应与最新的 Tellask 站点保持一致。
 - **Q4H 升级**：如果子对话有 Q4H，它会暂停。用户可以通过 UI 回答，这只会触发子对话的继续。
 - **已注册的子对话（TYPE B / `Tellask Session`）**：父级可以恢复先前创建的已注册子对话，实现持续的任务继续。
@@ -1136,7 +1171,7 @@ sequenceDiagram
 
 ```mermaid
 flowchart TD
-  A[!?askHuman() Tellask 发出] --> B[将 HumanQuestion 条目追加到 q4h.yaml]
+  A[askHuman({ tellaskContent: "..." }) Tellask 发出] --> B[将 HumanQuestion 条目追加到 q4h.yaml]
   B --> C[发出 questions_count_update]
   C --> D[UI 显示 Q4H 徽章/列表]
   D --> E{如何清除？}
@@ -1160,7 +1195,7 @@ sequenceDiagram
 
   Sup->>Sub: 创建子对话（TYPE B 或 C）
   Note over Sup,Sub: 上位对话因待处理子对话而阻塞
-  Sub->>WS: 发出 !?askHuman() 问题（Q4H）
+  Sub->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题（Q4H）
   WS-->>UI: questions_count_update（全局）
 
   Note over Sub: 子对话在回答之前无法继续
@@ -1189,7 +1224,7 @@ sequenceDiagram
   participant Store as 持久化（q4h.yaml）
   participant UI as 前端
 
-  User->>Main: !?askHuman() 问题
+  User->>Main: askHuman({ tellaskContent: "..." }) 问题
   Main->>Store: recordQuestionForHuman()
   Main-->>UI: questions_count_update
   Main-->>Main: 暂停根驱动循环