dominds 1.18.2 → 1.19.2

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

@@ -11,10 +11,10 @@
 3. [三类队友诉请分类](#三类队友诉请分类)
 4. [核心机制](#核心机制)
 5. [Q4H：向人请示](#q4h向人请示)
-6. [对话层级与子对话](#对话层级与子对话)
+6. [对话关系与支线对话](#对话关系与支线对话)
 7. [思维清晰工具](#思维清晰工具)
 8. [提醒管理](#提醒管理)
-9. [子对话注册表](#子对话注册表)
+9. [支线对话注册表](#支线对话注册表)
 10. [技术架构](#技术架构)
 11. [对话管理](#对话管理)
 12. [内存管理](#内存管理)
@@ -27,54 +27,54 @@
 ## 术语
 
 本章定义本文档中使用的面向实现的术语。
-关于双语/面向用户的命名约定（主线对话/支线对话；诉请者对话/被诉请者对话），请参阅 [`dominds-terminology.md`](./dominds-terminology.md)。
+关于双语/面向用户的命名约定（主线对话/支线对话；诉请者/被诉请者），请参阅 [`dominds-terminology.md`](./dominds-terminology.md)。
 关于差遣牒任务包结构和封装规则，请参阅 [`encapsulated-taskdoc.zh.md`](./encapsulated-taskdoc.zh.md)。
 
-### 上位对话
+### askerDialog（诉请者）
 
-**上位对话**是层级对话关系中的上位对话。它编排和管理子对话，提供上下文、目标和指导，同时接收来自子对话的结果、问题和升级。上位对话维护整体任务上下文，并决定何时不再需要子对话。
+**askerDialog（诉请者）**是在实现语境中当前拥有某个支线 assignment 或 reply obligation 的对话。它可以是主线对话，也可以是另一个支线对话；这是诉请/回复关系，不天然表示层级上位。
 
-注意：**上位对话**是层级结构里的父对话，并不等同于**诉请者对话**（本次诉请的发起者）。TYPE A（`tellaskBack`）时，诉请者对话就是直接上位对话；TYPE B/C 时，诉请者对话可能是不同的对话。
+注意：**askerDialog** 不是结构诉请者的同义词。TYPE A（`tellaskBack`）时，诉请者就是直接 askerDialog；TYPE B/C 时，诉请者可能是不同的对话。
 
-上位对话可以在子对话执行期间接收来自子对话的**回问诉请**。当子对话需要指导或额外上下文时，它可以用 `tellaskBack({ tellaskContent: "..." })` 回问，并将响应反馈到子对话上下文。
+askerDialog 可以在执行期间接收来自当前需向它回复的支线对话的**回问诉请**。当支线对话需要指导或额外上下文时，它可以用 `tellaskBack({ tellaskContent: "..." })` 回问，并将响应反馈到支线对话上下文。
 
-### 子对话
+### SideDialog（支线对话）
 
-**子对话** 是由上位对话生成的专门对话，用于处理特定子任务。子对话使用新的上下文操作，专注于定向目标，同时保持与上位对话的通信链接。
+**sideDialog（支线对话）** 是由 askerDialog 生成的专门对话，用于处理特定支线任务。支线对话使用新的上下文操作，专注于定向目标，同时保持与 askerDialog 的通信链接。
 
-**回问诉请**：子对话可以在任务执行期间向**诉请者对话**回问澄清。TYPE A 中诉请者对话就是直接上位对话。此机制允许子对话在保持自身上下文和进度的同时提问并接收指导。
+**回问诉请**：支线对话可以在任务执行期间向**诉请者**回问澄清。TYPE A 中诉请者就是直接 askerDialog。此机制允许支线对话在保持自身上下文和进度的同时提问并接收指导。
 
-### 诉请者对话 / 被诉请者对话（调用角色）
+### 诉请者 / 被诉请者（调用角色）
 
-**诉请者对话**是发起本次诉请的对话（caller），**被诉请者对话**是处理本次诉请的对话（当前对话）。这是**调用角色**，不是层级关系：
+**诉请者**是发起本次诉请的一侧，**被诉请者**是处理本次诉请的一侧（当前对话）。这是 **Tellask 角色**，不是层级关系：
 
-- TYPE A（`tellaskBack`）时，诉请者对话是直接上位对话。
-- TYPE B/C 时，诉请者对话可能是主线对话，也可能是其他支线对话。
-- 回贴会路由到 `assignmentFromSup` 中记录的**当前诉请者对话**。
+- TYPE A（`tellaskBack`）时，诉请者是直接 askerDialog。
+- TYPE B/C 时，诉请者可能是主线对话，也可能是其他支线对话。
+- 回贴会路由到 `assignmentFromAsker` 中记录的**当前诉请者**。
 
-### 主对话
+### 主线对话
 
-**主对话** (也称为 **根对话**) 是对话层级中的顶级对话，没有上位对话关系。它作为任务执行的主要入口点，可以生成多级子对话。这些术语在系统中可互换使用。
+**主线对话**是没有 askerDialog 关系的顶层对话。它作为任务执行的主要入口点，可以生成多级支线对话。
 
 ### 向人请示（Q4H）
 
-**Q4H** 是由对话（主对话或子对话）提出的待处理问题，需要人工输入才能继续。Q4H 被索引在对话的 `q4h.yaml` 文件中（一个索引，不是真理之源），并由 `clear_mind` 操作清除。实际的问题内容存储在对话的对话消息中，其中记录了 `askHuman({ tellaskContent: "..." })` 诉请。
+**Q4H** 是由对话（主线对话或支线对话）提出的待处理问题，需要人工输入才能继续。Q4H 被索引在对话的 `q4h.yaml` 文件中（一个索引，不是真理之源），并由 `clear_mind` 操作清除。实际的问题内容存储在对话的对话消息中，其中记录了 `askHuman({ tellaskContent: "..." })` 诉请。
 
-### 子对话索引 (subdlg.yaml)
+### 支线对话索引 (subdlg.yaml)
 
-**subdlg.yaml** 文件索引上位对话正在等待的待处理子对话。与 `q4h.yaml` 类似，它是一个索引文件，不是真理之源：
+**subdlg.yaml** 文件索引诉请者正在等待的待处理支线对话。与 `q4h.yaml` 类似，它是一个索引文件，不是真理之源：
 
-- 索引跟踪父对话正在等待哪些子对话 ID
-- 实际的子对话状态从磁盘 (done/ 目录) 验证
+- 索引跟踪诉请者正在等待哪些支线对话 ID
+- 实际的支线对话状态从磁盘 (done/ 目录) 验证
 - 用于后端协程的崩溃恢复和自动重启
 
-### 子对话注册表
+### 支线对话注册表
 
-**子对话注册表** 是根对话作用域的 Map，维护对已注册子对话的持久引用。注册表使用 `agentId!sessionSlug` 作为其键格式。当根完成时，它随根移动到 `done/`，并在根加载时通过扫描 done/ 子对话 YAML 重建。若某个支线对话被宣布卡死，其对应的 TYPE B 注册表条目会被移除，以便后续可用同一 `agentId!sessionSlug` 创建全新的支线对话。
+**支线对话注册表** 是主线对话作用域的 Map，维护对已注册支线对话的持久引用。注册表使用 `agentId!sessionSlug` 作为其键格式。当主线完成时，它随主线移动到 `done/`，并在主线加载时通过扫描 done/ 支线对话 YAML 重建。若某个支线对话被宣布卡死，其对应的 TYPE B 注册表条目会被移除，以便后续可用同一 `agentId!sessionSlug` 创建全新的支线对话。
 
 ### 队友诉请
 
-**队友诉请** 是 Dominds 特定的语法，触发与另一个作为子对话的智能体的通信。队友诉请有三种不同模式，具有不同语义（见第 3 节）。
+**队友诉请** 是 Dominds 特定的语法，触发与另一个作为支线对话的智能体的通信。队友诉请有三种不同模式，具有不同语义（见第 3 节）。
 
 **诉请块结构**（另见 [`dominds-terminology.md`](./dominds-terminology.md)）：
 
@@ -90,18 +90,18 @@
 
 对话驱动是一个**唯一的后端算法**。前端/客户端从不驱动对话。所有对话状态转换、恢复逻辑和生成循环都在后端协程中完全执行。前端只订阅发布频道 (PubChan) 以进行实时 UI 更新。
 
-### 注册表层级
+### 注册表结构
 
 系统维护三个级别的注册表用于对话管理：
 
 **全局注册表（服务器作用域）**
-`rootId → RootDialog` 对象的服务器范围映射。这是所有活动根对话的单一真理之源。后端协程扫描此注册表以找到需要驱动的对话。
+`rootId → MainDialog` 对象的服务器范围映射。这是所有活动主线对话的单一真理之源。后端协程扫描此注册表以找到需要驱动的对话。
 
-**本地注册表（每个根对话）**
-每个根的 `selfId → Dialog` 对象映射。此注册表包含根对话本身以及所有已加载的子对话，支持在层级内对任何对话进行 O(1) 查找。
+**本地注册表（每个主线对话）**
+每个主线的 `selfId → Dialog` 对象映射。此注册表包含主线对话本身以及所有已加载的支线对话，支持在同一对话树内对任何对话进行 O(1) 查找。
 
-**子对话注册表（每个根对话）**
-每个根的 `agentId!sessionSlug → Subdialog` 对象映射。此注册表跟踪用于在多次交互中恢复的 TYPE B 已注册子对话。TYPE C 瞬态子对话永远不会被注册。
+**支线对话注册表（每个主线对话）**
+每个主线的 `agentId!sessionSlug → SideDialog` 对象映射。此注册表跟踪用于在多次交互中恢复的 TYPE B 已注册支线对话。TYPE C 瞬态支线对话永远不会被注册。
 
 ### 每对话互斥锁
 
@@ -111,14 +111,14 @@
 
 后端协程使用以下模式驱动对话：
 
-1. 扫描全局注册表以识别需要驱动的根对话
-2. 对于每个候选者，检查恢复条件（Q4H 已回答，子对话完成已接收）
+1. 扫描全局注册表以识别需要驱动的主线对话
+2. 对于每个候选者，检查恢复条件（Q4H 已回答，支线对话完成已接收）
 3. 在驱动之前获取对话的互斥锁
 4. 执行生成循环直到挂起点或完成
 5. 释放互斥锁
 6. 将所有状态变更持久化到存储
 
-驱动循环持续进行，直到对话挂起（等待 Q4H 或子对话）或完成。当条件变化时（用户回答 Q4H，子对话完成），后端通过存储检查检测这些变化并自动恢复驱动。
+驱动循环持续进行，直到对话挂起（等待 Q4H 或支线对话）或完成。当条件变化时（用户回答 Q4H，支线对话完成），后端通过存储检查检测这些变化并自动恢复驱动。
 
 ### 前端集成
 
@@ -133,7 +133,7 @@
 
 ### 全局对话事件广播器
 
-有一类对话事件属于 rtws 全局状态，而不是某个对话自己的局部流，包括 `new_q4h_asked`、`q4h_answered`、`subdialog_created_evt`、`dlg_touched_evt`。
+有一类对话事件属于 rtws 全局状态，而不是某个对话自己的局部流，包括 `new_q4h_asked`、`q4h_answered`、`sideDialog_created_evt`、`dlg_touched_evt`。
 
 这些事件要求 runtime 在任何对话驱动逻辑开始前，就先完成**全局对话事件广播器**的 bootstrap。它是必要基础设施，不是可选优化：
 
@@ -148,8 +148,8 @@
 对话状态在关键点持久化到存储：
 
 - 每次消息生成后
-- 挂起时（Q4H 提出，子对话创建）
-- 恢复时（Q4H 已回答，子对话完成）
+- 挂起时（Q4H 提出，支线对话创建）
+- 恢复时（Q4H 已回答，支线对话完成）
 - 完成时
 
 这确保了崩溃恢复，并使后端能够从任何持久化状态恢复，而不依赖于前端状态。
@@ -176,7 +176,7 @@
 - **情况 1：当前对话没有回复义务**
   这时若也没有其他 blocker，就应直接继续 drive；若已回到普通待用户输入态，则 `resume_dialog` 不应再被视为可继续。
 - **情况 2：当前对话仍有回复义务，但处于 suspend 状态**
-  常见于仍在等待 Q4H / pending subdialogs。此时 `Continue` 应退出插话 paused projection，并恢复成真实的 `blocked`。
+  常见于仍在等待 Q4H / pending sideDialogs。此时 `Continue` 应退出插话 paused projection，并恢复成真实的 `blocked`。
 - **情况 3：当前对话仍有回复义务，但已不再 suspend，具备继续推进条件**
   例如 blocker 已消失，或存在允许继续的 queued prompt。此时 `Continue` 不应先落一个中间 `blocked/idle` 占位态，而应直接继续 drive。
 
@@ -211,38 +211,36 @@
 
 ```mermaid
 flowchart TD
-  M["LLM 发出 tellaskSessionless(...)"] --> Q{"这是子对话回问其直接上位对话（TYPE A 的诉请者对话）吗？"}
+  M["LLM 发出 tellaskSessionless(...)"] --> Q{"这是支线对话回问其直接 askerDialog（TYPE A 的诉请者）吗？"}
   Q -- 是 --> A["TYPE A：回问诉请<br/>主要：tellaskBack(...)（无 sessionSlug）"]
   Q -- 否 --> T{是否存在 sessionSlug？}
-  T -- 是 --> B["TYPE B：已注册子对话诉请<br/>(长线诉请)<br/>tellask(..., sessionSlug=...)"]
-  T -- 否 --> C["TYPE C：瞬态子对话诉请<br/>(一次性诉请)<br/>tellaskSessionless(...)"]
+  T -- 是 --> B["TYPE B：已注册支线对话诉请<br/>(长线诉请)<br/>tellask(..., sessionSlug=...)"]
+  T -- 否 --> C["TYPE C：瞬态支线对话诉请<br/>(一次性诉请)<br/>tellaskSessionless(...)"]
 ```
 
 ### TYPE A：回问诉请
 
 **主要语法**：`tellaskBack({ tellaskContent: "..." })`（无 `sessionSlug`）— `tellaskBack({ tellaskContent: "..." }) sessionSlug ...` 是**语法错误**
 
-**可容忍的回退**：`tellaskBack({ tellaskContent: "..." })`（无 `sessionSlug`）
-
 **行为**：
 
-1. 当前子对话**挂起**
-2. 驱动程序切换到驱动**诉请者对话**（TYPE A 中为直接上位对话；使用 `subdialog.supdialog` 引用）
-3. 诉请者对话的响应流回子对话
-4. 子对话**恢复**，诉请者对话的响应在上下文中
+1. 当前支线对话**挂起**
+2. 驱动程序切换到驱动**诉请者**（TYPE A 中为直接 askerDialog；使用 `sideDialog.askerDialog` 引用）
+3. 诉请者的响应流回支线对话
+4. 支线对话**恢复**，诉请者的响应在上下文中
 
 **关键特征**：
 
-- 使用 `subdialog.supdialog` 引用（无注册表查找）
-- 无需注册 — 上位对话关系是固有的
-- 上位对话始终是层级中的直接父级（TYPE A 的诉请者对话）
+- 使用 `sideDialog.askerDialog` 引用（无注册表查找）
+- 无需注册 — 诉请者关系是固有的
+- TYPE A 始终指向直接 askerDialog（本次诉请的诉请者）
 - `tellaskBack({ tellaskContent: "..." })` 是**规范**的 TYPE A 语法：它始终路由到“诉请者”（发起本次诉请的对话），避免自行猜测。
 
 **支线交付规则（规范）**：
 
-- 只有当所有目标完成时，支线对话才可直接正常回复诉请者对话。
+- 只有当所有目标完成时，支线对话才可直接正常回复诉请者。
 - 若目标尚未完成，不要默认直接 `tellaskBack`；应先按团队规程 / SOP / 职责卡判断能否明确负责人，若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人。
-- 只有当必须由上游诉请者补充需求、澄清目标、做业务裁决、确认验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者对话再继续。
+- 只有当必须由诉请者补充需求、澄清目标、做业务裁决、确认验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者再继续。
 - **FBR 例外**：FBR 支线对话禁止一切 tellask（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`），只能列出缺口与阻塞原因并直接回复。
 
 **跨对话传递与标记（强制）**：
@@ -263,13 +261,13 @@ flowchart TD
 
 **协议澄清**：
 
-- 需要回问上游时必须真实调用 `tellaskBack({ tellaskContent: "..." })`；但在此之前应先判断是否已有团队规程可直接判责到其他负责人。不得发送普通文本中间汇报。
+- 需要回问诉请者时必须真实调用 `tellaskBack({ tellaskContent: "..." })`；但在此之前应先判断是否已有团队规程可直接判责到其他负责人。不得发送普通文本中间汇报。
 
 **示例**：
 
 ```
 当前对话：sub-001（agentId: "backend-dev"）
-父上位对话："orchestrator"（agentId）
+诉请者："orchestrator"（agentId）
 
 LLM 发出：tellaskSessionless({ targetAgentId: "orchestrator", tellaskContent: "..." }) 我应该如何处理数据库迁移？
 
@@ -280,7 +278,7 @@ LLM 发出：tellaskSessionless({ targetAgentId: "orchestrator", tellaskContent:
 - sub-001 恢复，Orchestrator 的响应在上下文中
 ```
 
-### TYPE B：已注册子对话诉请（长线诉请）
+### TYPE B：已注册支线对话诉请（长线诉请）
 
 **语法**：`tellask({ targetAgentId: "<anyAgentId>", sessionSlug: "<tellaskSession>", tellaskContent: "..." })`（注意 `sessionSlug` 前的空格）
 
@@ -296,50 +294,50 @@ LLM 发出：tellaskSessionless({ targetAgentId: "orchestrator", tellaskContent:
 
 **行为**：
 
-1. 检查注册表中是否存在键为 `agentId!sessionSlug` 的现有子对话
-2. **如果存在**：恢复已注册的子对话
-3. **如果不存在**：创建新的子对话并使用键 `agentId!sessionSlug` 注册它
-4. 父对话在子对话运行时**挂起**
-5. 子对话的响应流回父级
-6. 父级**恢复**，子对话的响应在上下文中
+1. 检查注册表中是否存在键为 `agentId!sessionSlug` 的现有支线对话
+2. **如果存在**：恢复已注册的支线对话
+3. **如果不存在**：创建新的支线对话并使用键 `agentId!sessionSlug` 注册它
+4. 诉请者在支线对话运行时**挂起**
+5. 支线对话的响应流回诉请者
+6. 诉请者**恢复**，支线对话的响应在上下文中
 
-**当前调用者跟踪（对复用很重要）：**
+**当前诉请者跟踪（对复用很重要）：**
 
-当已注册的子对话再次收到诉请（相同的 `agentId!sessionSlug`）时，调用者可能是**不同的对话**（根对话或其他支线对话）。在每次 TYPE B 诉请时，子对话的元数据都会更新为：
+当已注册的支线对话再次收到诉请（相同的 `agentId!sessionSlug`）时，诉请者可能是**不同的对话**（主线对话或其他支线对话）。在每次 TYPE B 诉请时，支线对话的元数据都会更新为：
 
-- **当前调用者对话 ID**（这样响应就会路由回*最新*的调用者）
+- **当前诉请者 ID**（这样响应就会路由回*最新*的诉请者）
 - **诉请信息**（标题/正文、来源角色、来源成员、callId）
 
-这使得 TYPE B 子对话可以在多个诉请站点复用，而不会丢失正确的响应路由。
+这使得 TYPE B 支线对话可以在多个诉请站点复用，而不会丢失正确的响应路由。
 
 **恢复时的诉请上下文**：
 
-- 在每次 TYPE B 诉请（新的或恢复的）时，父级提供的 `mentionList`/`tellaskContent`
-  在驱动子对话之前作为新用户消息追加到子对话中。
-  这确保子对话在每次诉请时都能收到最新的请求上下文。
+- 在每次 TYPE B 诉请（新的或恢复的）时，诉请者提供的 `mentionList`/`tellaskContent`
+  在驱动支线对话之前作为新用户消息追加到支线对话中。
+  这确保支线对话在每次诉请时都能收到最新的请求上下文。
 - 系统注入的恢复提示仅用于上下文，**不会被解析**为队友诉请或工具调用。
 
 **关键特征**：
 
 - 每次诉请都会执行注册表查找
-- 支持**恢复**先前的子对话
-- 已注册的子对话在正常流程中会保留；若支线被宣布卡死，其条目会从注册表移除
-- 注册表是根对话作用域的（子对话无法访问）
+- 支持**恢复**先前的支线对话
+- 已注册的支线对话在正常流程中会保留；若支线被宣布卡死，其条目会从注册表移除
+- 注册表是主线对话作用域的（支线对话无法访问）
 
 **示例**：
 
 ```
-根对话：orchestrator
+主线对话：orchestrator
 注册表：{}（空）
 
 LLM 发出：tellask({ targetAgentId: "researcher", sessionSlug: "market-analysis", tellaskContent: "..." })
 
 结果（第一次调用）：
 - 注册表查找：不存在 "researcher!market-analysis"
-- 创建新的子对话 "researcher!market-analysis"
-- 在根的注册表中注册它
+- 创建新的支线对话 "researcher!market-analysis"
+- 在主线的注册表中注册它
 - orchestrator 挂起
-- 驱动 researcher 子对话
+- 驱动 researcher 支线对话
 - 响应流回 orchestrator
 - orchestrator 恢复
 
@@ -347,41 +345,41 @@ LLM 再次发出：tellask({ targetAgentId: "researcher", sessionSlug: "market-a
 
 结果（第二次调用）：
 - 注册表查找："researcher!market-analysis" 存在
-- 恢复现有的子对话
+- 恢复现有的支线对话
 - orchestrator 挂起
-- 从离开的地方继续驱动现有的 researcher 子对话
+- 从离开的地方继续驱动现有的 researcher 支线对话
 - 响应流回 orchestrator
 - orchestrator 恢复
 ```
 
-### TYPE C：瞬态子对话诉请（一次性诉请）
+### TYPE C：瞬态支线对话诉请（一次性诉请）
 
-**语法**：`tellaskSessionless({ targetAgentId: "<nonSupdialogAgentId>", tellaskContent: "..." })`（无 `sessionSlug`）
+**语法**：`tellaskSessionless({ targetAgentId: "<nonAskerDialogAgentId>", tellaskContent: "..." })`（无 `sessionSlug`）
 
 **扪心自问 (FBR) 自调用语法（默认；最常见）**：`freshBootsReasoning({ tellaskContent: "..." })`
 
-- `freshBootsReasoning({ tellaskContent: "..." })` 指向当前对话的 agentId，并创建一条路由到同一 agentId 的**新的临时子对话**。
+- `freshBootsReasoning({ tellaskContent: "..." })` 指向当前对话的 agentId，并创建一条路由到同一 agentId 的**新的临时支线对话**。
 - 由 `freshBootsReasoning({ tellaskContent: "..." })` 创建的支线对话属于 FBR，并以更严格的“无工具”策略驱动；详见 [`fbr.zh.md`](./fbr.zh.md)。
 - 对于大多数扪心自问 会话使用此方式：隔离单个子问题，产生答案，然后返回。
 
 **行为**：
 
 1. 当前对话**挂起**
-2. 使用指定的 agentId 创建**新的子对话**
-3. 驱动新的子对话：
-   - 一般 TYPE C 子对话是“完整能力”的（可上位调用、队友诉请、按配置使用工具）。
+2. 使用指定的 agentId 创建**新的支线对话**
+3. 驱动新的支线对话：
+   - 一般 TYPE C 支线对话是“完整能力”的（可回问诉请者、队友诉请、按配置使用工具）。
    - `freshBootsReasoning({ tellaskContent: "..." })` 属于 FBR 特例：无工具、禁止任何诉请（见 `fbr.zh.md`）。
-4. 子对话的响应流回父级
-5. 父级**恢复**，子对话的响应在上下文中
+4. 支线对话的响应流回诉请者
+5. 诉请者**恢复**，支线对话的响应在上下文中
 
 **关键特征**：
 
-- **无注册表查找** - 总是创建新的子对话
+- **无注册表查找** - 总是创建新的支线对话
 - **不注册** - 在各次诉请之间不持久化
 - **无任务安排更新通道** - 发出后不能像 TYPE B 那样就地更新同一路诉请要求
-- 再次发起 `tellaskSessionless` 只会创建**另一条新的瞬态子对话**，不会更新、更不会要求先前那条 TYPE C 支线停止
+- 再次发起 `tellaskSessionless` 只会创建**另一条新的瞬态支线对话**，不会更新、更不会要求先前那条 TYPE C 支线停止
 - 若你后续可能需要改要求、纠偏或提前收口，应该从一开始就选择带 `sessionSlug` 的 TYPE B `tellask`
-- 子对话本身一般是“完整能力”的；但 `freshBootsReasoning({ tellaskContent: "..." })` FBR 是特例：无工具且禁止任何诉请（见 `fbr.zh.md`）。
+- 支线对话本身一般是“完整能力”的；但 `freshBootsReasoning({ tellaskContent: "..." })` FBR 是特例：无工具且禁止任何诉请（见 `fbr.zh.md`）。
 - 与 TYPE B 的唯一区别：无注册表查找/恢复能力
 - 用于一次性的、独立的任务
 
@@ -394,8 +392,8 @@ LLM 发出：@code-reviewer 请审查这个 PR
 
 结果：
 - orchestrator 挂起
-- 使用 agentId "code-reviewer" 创建新的子对话
-- 驱动 code-reviewer 子对话（它可以进行自己的诉请、工具等）
+- 使用 agentId "code-reviewer" 创建新的支线对话
+- 驱动 code-reviewer 支线对话（它可以进行自己的诉请、工具等）
 - code-reviewer 完成并返回审查结果
 - orchestrator 恢复，审查结果在上下文中
 
@@ -403,23 +401,23 @@ LLM 再次发出：@code-reviewer 审查这个其他 PR
 
 结果：
 - orchestrator 挂起
-- 创建另一个新的子对话（与之前的不同！）
-- 驱动新的 code-reviewer 子对话
+- 创建另一个新的支线对话（与之前的不同！）
+- 驱动新的 code-reviewer 支线对话
 - orchestrator 恢复，新的审查结果在上下文中
 ```
 
 ### 对比总结
 
-| 方面            | TYPE A：回问诉请                         | TYPE B：已注册子对话诉请（长线诉请）                                                     | TYPE C：瞬态子对话诉请（一次性诉请）                                                    |
-| --------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
-| **语法**        | `tellaskBack({ tellaskContent: "..." })` | `tellask({ targetAgentId: "<anyAgentId>", sessionSlug: "<id>", tellaskContent: "..." })` | `tellaskSessionless({ targetAgentId: "<nonSupdialogAgentId>", tellaskContent: "..." })` |
-| **sessionSlug** | 不允许                                   | 必须                                                                                     | 不允许                                                                                  |
-| **注册表查找**  | 否（使用 `subdialog.supdialog`）         | 是（`agentId!sessionSlug`）                                                              | 否（永不注册）                                                                          |
-| **恢复**        | 否（上位对话不是子对话）                 | 是（查找找到现有的）                                                                     | 否（总是新的）                                                                          |
-| **注册**        | 不适用                                   | 创建并注册                                                                               | 永不注册                                                                                |
-| **父级行为**    | 子对话挂起                               | 父级挂起                                                                                 | 父级挂起                                                                                |
-| **子对话能力**  | 完整（上位调用、队友、工具）             | 完整（上位调用、队友、工具）                                                             | 完整（上位调用、队友、工具）                                                            |
-| **用例**        | 从父级澄清                               | 恢复持久子任务                                                                           | 一次性独立任务                                                                          |
+| 方面             | TYPE A：回问诉请                         | TYPE B：已注册支线对话诉请（长线诉请）                                                   | TYPE C：瞬态支线对话诉请（一次性诉请）                                                    |
+| ---------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| **语法**         | `tellaskBack({ tellaskContent: "..." })` | `tellask({ targetAgentId: "<anyAgentId>", sessionSlug: "<id>", tellaskContent: "..." })` | `tellaskSessionless({ targetAgentId: "<nonAskerDialogAgentId>", tellaskContent: "..." })` |
+| **sessionSlug**  | 不允许                                   | 必须                                                                                     | 不允许                                                                                    |
+| **注册表查找**   | 否（使用 `sideDialog.askerDialog`）      | 是（`agentId!sessionSlug`）                                                              | 否（永不注册）                                                                            |
+| **恢复**         | 否（诉请者不是支线对话）                 | 是（查找找到现有的）                                                                     | 否（总是新的）                                                                            |
+| **注册**         | 不适用                                   | 创建并注册                                                                               | 永不注册                                                                                  |
+| **诉请者行为**   | 支线对话挂起                             | 诉请者挂起                                                                               | 诉请者挂起                                                                                |
+| **支线对话能力** | 完整（回问诉请者、队友、工具）           | 完整（回问诉请者、队友、工具）                                                           | 完整（回问诉请者、队友、工具）                                                            |
+| **用例**         | 从诉请者澄清                             | 恢复持久支线任务                                                                         | 一次性独立任务                                                                            |
 
 ---
 
@@ -429,7 +427,7 @@ Dominds 对话系统建立在四个相互关联的核心机制之上，这些机
 
 ```mermaid
 flowchart TD
-  H[对话层级<br/>(root ↔ 子对话)] <--> S[子对话供应<br/>(响应、待处理列表、注册表)]
+  H[对话关系<br/>(main ↔ 支线对话)] <--> S[支线对话供应<br/>(响应、待处理列表、注册表)]
   H --> Q["Q4H（askHuman(...)）<br/>(q4h.yaml 索引)"]
   S --> Q
 
@@ -439,27 +437,27 @@ flowchart TD
 
   清晰度[clear_mind] -->|清除| Q
   清晰度 -->|保留| R[提醒]
-  清晰度 -->|保留| Reg[注册表（仅根）]
+  清晰度 -->|保留| Reg[注册表（仅主线）]
 ```
 
 ### 关键设计原则
 
 1. **Q4H 索引在 `q4h.yaml` 中**：Q4H 问题被索引在 `q4h.yaml` 中（作为索引，不是真理之源），并由思维清晰操作清除。实际的问题内容在对话的对话消息中，其中记录了 `askHuman({ tellaskContent: "..." })` 诉请。它们不会在 `clear_mind` 中存活。
 
-2. **层级 Q4H**：层级中的任何对话都可以自行提出 Q4H（根对话或子对话）。问题被索引在提出问题的对话中，而不是向上传递。
+2. **对话作用域 Q4H**：对话树中的任何对话都可以自行提出 Q4H（主线对话或支线对话）。问题被索引在提出问题的对话中，而不是转交给诉请者。
 
-3. **子对话 Q4H 自主性**：子对话可以直接提出 Q4H 问题，而不是作为父级的智能体。用户导航到子对话的对话中以内联回答。
+3. **支线对话 Q4H 自主性**：支线对话可以直接提出 Q4H 问题，而不是作为诉请者的智能体。用户导航到支线对话的对话中以内联回答。
 
 4. **UI 将 Q4H 呈现为队友诉请**：UI 类似于其他队友诉请处理 Q4H，具有导航链接到对话中的诉请站点。用户使用与常规消息相同的输入文本区域内联回答。
 
-5. **子对话响应供应**：子对话通过持久化将响应写入*当前诉请者*的上下文（不是回调）。对于 TYPE B，每次诉请都会用最新的诉请者 + tellaskInfo 更新子对话的 `assignmentFromSup`，因此响应被路由到最近的诉请者（根或子对话）。这支持分离操作、复用和崩溃恢复。
+5. **支线对话响应供应**：支线对话通过持久化将响应写入*当前诉请者*的上下文（不是回调）。对于 TYPE B，每次诉请都会用最新的诉请者 + tellaskInfo 更新支线对话的 `assignmentFromAsker`，因此响应被路由到最近的诉请者（主线或支线对话）。这支持分离操作、复用和崩溃恢复。
 
-6. **子对话注册表**：已注册的子对话（TYPE B 长线诉请）在根对话作用域的注册表中跟踪。注册表在 `clear_mind` 操作中持续存在，并在根加载时重建。
+6. **支线对话注册表**：已注册的支线对话（TYPE B 长线诉请）在主线对话作用域的注册表中跟踪。注册表在 `clear_mind` 操作中持续存在，并在主线加载时重建。
 
 7. **状态保留契约**：
    - `clear_mind`：清除消息，清除 Q4H 索引，保留提醒，保留注册表
-   - 子对话完成：向当前诉请者对话写入响应，从待处理列表中删除（注册表不变）
-   - 子对话宣布卡死：将 runState 标记为 dead，并移除对应 TYPE B 注册表条目；同一 slug 可作为全新支线重新发起
+   - 支线对话完成：向当前诉请者写入响应，从待处理列表中删除（注册表不变）
+   - 支线对话宣布卡死：将 runState 标记为 dead，并移除对应 TYPE B 注册表条目；同一 slug 可作为全新支线重新发起
    - Q4H 回答：从索引中清除已回答的问题，继续对话
 
 ---
@@ -468,7 +466,7 @@ flowchart TD
 
 ### 概述
 
-Q4H（向人类提问）是对话可以暂停执行并请求人工输入的机制。它是一个核心的、完整的机制，与子对话、提醒和思维清晰工具无缝协作。
+Q4H（向人类提问）是对话可以暂停执行并请求人工输入的机制。它是一个核心的、完整的机制，与支线对话、提醒和思维清晰工具无缝协作。
 
 ### Q4H 数据结构
 
@@ -495,7 +493,7 @@ interface HumanQuestion {
 
 ```mermaid
 sequenceDiagram
-  participant D as 对话（根或子对话）
+  participant D as 对话（主线或支线对话）
   participant P as 持久化（q4h.yaml）
   participant UI as 前端 UI
   participant WS as WebSocket 处理器
@@ -513,7 +511,7 @@ sequenceDiagram
 
 ### 对话何时提出 Q4H？
 
-当 `askHuman({ tellaskContent: "..." })` tellask 函数被任何对话（根或子对话）自行调用时，会提出 Q4H：
+当 `askHuman({ tellaskContent: "..." })` tellask 函数被任何对话（主线或支线对话）自行调用时，会提出 Q4H：
 
 ```typescript
 // 来自 main/llm/kernel-driver/tellask-special.ts
@@ -627,34 +625,34 @@ interface DriveDialogByUserAnswerRequest {
 | 后端操作   | 只需驱动对话            | 先清除 q4h.yaml → 驱动对话    |
 | 继续类型   | N/A                     | `'answer'`                    |
 
-### 子对话 Q4H 处理
+### 支线对话 Q4H 处理
 
 **关键原则**：
 
-1. Q4H 被索引在提出问题的对话中，而不是向上传递给上位对话
-2. 子对话自行提出 Q4H（不是作为父级的智能体）
-3. 用户导航到子对话的对话中以内联回答
+1. Q4H 被索引在提出问题的对话中，而不是转交给诉请者
+2. 支线对话自行提出 Q4H（不是作为诉请者的智能体）
+3. 用户导航到支线对话的对话中以内联回答
 4. `q4h.yaml` 文件是索引，不是真理之源
 
 ```mermaid
 sequenceDiagram
-  participant Sup as 上位对话
-  participant Sub as 子对话
+  participant Asker as 诉请者
+  participant Side as 支线对话
   participant UI as 前端 UI
   participant WS as WebSocket 处理器
   participant Driver as driveDialogStream
 
-  Sup->>Sub: 创建子对话（TYPE B 或 C）
-  Note over Sup: 上位对话因待处理子对话而阻塞
+  Asker->>Side: 创建支线对话（TYPE B 或 C）
+  Note over Asker: 诉请者因待处理支线对话而阻塞
 
-  Sub->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题
+  Side->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题
   WS-->>UI: questions_count_update
-  Note over Sub: 子对话在回答之前无法继续
+  Note over Side: 支线对话在回答之前无法继续
 
-  UI->>WS: drive_dialog_by_user_answer(dialog=subdialogId, questionId, content)
-  WS->>Driver: driveDialogStream(subdialog, human answer)
-  Driver-->>Sub: 子对话恢复
-  Sub-->>Sup: 响应供应（清除待处理子对话）
+  UI->>WS: drive_dialog_by_user_answer(dialog=sideDialogId, questionId, content)
+  WS->>Driver: driveDialogStream(sideDialog, human answer)
+  Driver-->>Side: 支线对话恢复
+  Side-->>Asker: 响应供应（清除待处理支线对话）
 ```
 
 ### Q4H 与思维清晰操作
@@ -669,20 +667,20 @@ flowchart LR
 
 ---
 
-## 对话层级与子对话
+## 对话关系与支线对话
 
-### 层级概述
+### 对话树概述
 
 ```mermaid
 flowchart TD
-  Root[根对话] --> S1[子对话 sub-001]
-  Root --> S2[子对话 sub-002]
-  Root --> S3[子对话 sub-003]
+  Main[主线对话] --> S1[支线对话 sub-001]
+  Main --> S2[支线对话 sub-002]
+  Main --> S3[支线对话 sub-003]
 
-  S1 --> N1[嵌套子对话 sub-001-001]
+  S1 --> N1[嵌套支线对话 sub-001-001]
 
-  Root -.-> Reg["registry.yaml<br/>(根作用域，仅 TYPE B)"]
-  Root -.-> QRoot[q4h.yaml (根)]
+  Main -.-> Reg["registry.yaml<br/>(主线作用域，仅 TYPE B)"]
+  Main -.-> QRoot[q4h.yaml (根)]
   S1 -.-> QS1[q4h.yaml (sub-001)]
   N1 -.-> QN1[q4h.yaml (sub-001-001)]
 ```
@@ -694,55 +692,55 @@ flowchart TD
 - `.dialogs/run/<root-id>/reminders.json`
 - `.dialogs/run/<root-id>/q4h.yaml`
 - `.dialogs/run/<root-id>/course-001.jsonl`（第 1 程对话，还可以有编号递增的后续多程）
-- `.dialogs/run/<root-id>/subdialogs/<sub-id>/dialog.yaml`
-- `.dialogs/run/<root-id>/subdialogs/<sub-id>/q4h.yaml`
-- `.dialogs/run/<root-id>/registry.yaml`（仅根；TYPE B 注册表）
+- `.dialogs/run/<root-id>/sideDialogs/<sub-id>/dialog.yaml`
+- `.dialogs/run/<root-id>/sideDialogs/<sub-id>/q4h.yaml`
+- `.dialogs/run/<root-id>/registry.yaml`（仅主线；TYPE B 注册表）
 
-### 子对话响应供应机制
+### 支线对话响应供应机制
 
-**核心原则**：子对话通过持久化向**当前诉请者对话**的上下文供应响应，而不是通过回调（TYPE A 时诉请者对话为直接上位对话）。
+**核心原则**：支线对话通过持久化向**当前诉请者**的上下文供应响应，而不是通过回调（TYPE A 时诉请者为直接 askerDialog）。
 
 ```mermaid
 sequenceDiagram
-  participant Sup as 诉请者对话
+  participant Asker as 诉请者
   participant Driver as 后端驱动程序
-  participant Sub as 子对话
+  participant Side as 支线对话
   participant Store as 持久化
 
-  Sup->>Driver: 创建子对话（添加到待处理列表）
-  Driver->>Sub: 驱动子对话（分离执行）
-  Sub-->>Store: 持久化最终响应
-  Driver-->>Sup: 供应响应 + 清除待处理子对话
-  opt 诉请者对话是根且现在已解除阻塞
-    Driver-->>Sup: 设置 needsDrive=true（自动重启）
+  Asker->>Driver: 创建支线对话（添加到待处理列表）
+  Driver->>Side: 驱动支线对话（分离执行）
+  Side-->>Store: 持久化最终响应
+  Driver-->>Asker: 供应响应 + 清除待处理支线对话
+  opt 诉请者是主线且现在已解除阻塞
+    Driver-->>Asker: 设置 needsDrive=true（自动重启）
   end
 ```
 
-### 子对话 Q4H 和上位对话恢复
+### 支线对话 Q4H 和诉请者恢复
 
-当子对话提出 Q4H 并等待人工输入时，上位对话的自动重启逻辑必须处理这种情况：
+当支线对话提出 Q4H 并等待人工输入时，诉请者的自动重启逻辑必须处理这种情况：
 
 ```typescript
-// 上位对话检查子对话完成状态
-async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
-  const pending = await loadPendingSubdialogs(supdialog.id);
+// 诉请者检查支线对话完成状态
+async function checkSideDialogRevival(askerDialog: Dialog): Promise<void> {
+  const pending = await loadPendingSideDialogs(askerDialog.id);
 
   for (const p of pending) {
-    // 检查子对话是否有未解决的 Q4H
-    const subdialogQ4H = await DialogPersistence.loadQuestions4HumanState(p.subdialogId);
+    // 检查支线对话是否有未解决的 Q4H
+    const sideDialogQ4H = await DialogPersistence.loadQuestions4HumanState(p.sideDialogId);
 
-    if (subdialogQ4H.length > 0) {
-      // 子对话正在等待人工输入
+    if (sideDialogQ4H.length > 0) {
+      // 支线对话正在等待人工输入
       // 不要自动重启 - 等待人工回答 Q4H
-      log.debug(`子对话 ${p.subdialogId} 有 ${subdialogQ4H.length} 个 Q4H，跳过自动重启`);
+      log.debug(`支线对话 ${p.sideDialogId} 有 ${sideDialogQ4H.length} 个 Q4H，跳过自动重启`);
       continue;
     }
 
-    // 子对话没有 Q4H，检查是否完成
-    const isDone = await isSubdialogCompleted(p.subdialogId);
+    // 支线对话没有 Q4H，检查是否完成
+    const isDone = await isSideDialogCompleted(p.sideDialogId);
     if (isDone) {
       // 合并响应并自动重启
-      await incorporateSubdialogResponse(supdialog, p.subdialogId);
+      await incorporateSideDialogResponse(askerDialog, p.sideDialogId);
     }
   }
 }
@@ -779,8 +777,8 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 - 清除当前对话中的所有聊天消息
 - 保留所有提醒
 - **清除所有 Q4H 问题**（关键！）
-- 保留子对话注册表（仅限根对话）
-- 对上位对话没有影响
+- 保留支线对话注册表（仅限主线对话）
+- 对诉请者没有影响
 - 将注意力重定向到差遣牒
 - 系统生成的“开启新一程对话”提示已排队，作为新一程的首个 role=user 消息
 - 开启新一程对话
@@ -788,7 +786,7 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 **实现说明**：
 
 - 操作仅作用于当前对话
-- 子对话不受父级 `clear_mind` 的影响
+- 支线对话不受诉请者 `clear_mind` 的影响
 - 差遣牒保持不变且可访问
 - 提醒在清晰操作中提供连续性
 
@@ -814,12 +812,12 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 - 更新的文件立即对引用它的所有对话可用
 - **不开启新一程对话。** 如需开启新一程对话，请单独使用 `clear_mind`。
 - 本身不清除消息、提醒、Q4H 或注册表
-- 影响引用相同差遣牒的所有参与智能体（主对话和子对话）
+- 影响引用相同差遣牒的所有参与智能体（主线对话和支线对话）
 - 关键决策/当前状态/下一步写回 `progress`；硬约束写回 `constraints`（不要只留在对话/提醒项里）。
 
 **实现说明**：
 
-- `change_mind` 仅在根对话中可用（不在子对话中）；子对话必须通过回问诉请（`tellaskBack({ tellaskContent: "..." })`）询问诉请者以更新共享差遣牒。
+- `change_mind` 仅在主线对话中可用（不在支线对话中）；支线对话必须通过回问诉请（`tellaskBack({ tellaskContent: "..." })`）询问诉请者以更新共享差遣牒。
 - 对于 `*.tsk/` 差遣牒任务包，差遣牒是封装的：通用文件工具不得读取/写入/列出/删除 `*.tsk/` 下的任何内容。请参阅 [`encapsulated-taskdoc.zh.md`](./encapsulated-taskdoc.zh.md)。
 
 ---
@@ -848,22 +846,22 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 
 ---
 
-## 子对话注册表
+## 支线对话注册表
 
 ### 概述
 
-**子对话注册表** 是根对话作用域的数据结构，维护通过 TYPE B（已注册子对话诉请 / 长线诉请）创建的已注册子对话的持久引用。
+**支线对话注册表** 是主线对话作用域的数据结构，维护通过 TYPE B（已注册支线对话诉请 / 长线诉请）创建的已注册支线对话的持久引用。
 
 ### 关键特征
 
-| 方面         | 描述                                       |
-| ------------ | ------------------------------------------ |
-| **作用域**   | 仅限根对话（子对话无法访问）               |
-| **键格式**   | `agentId!sessionSlug`（单级 Map）          |
-| **存储**     | 根对话目录中的 `registry.yaml`             |
-| **生命周期** | 正常流程保留；被宣布卡死的子对话条目会移除 |
-| **持久化**   | 根完成时随根移动到 `done/`                 |
-| **恢复**     | 在根加载时通过扫描 done/ 子对话 YAML 重建  |
+| 方面         | 描述                                          |
+| ------------ | --------------------------------------------- |
+| **作用域**   | 仅限主线对话（支线对话无法访问）              |
+| **键格式**   | `agentId!sessionSlug`（单级 Map）             |
+| **存储**     | 主线对话目录中的 `registry.yaml`              |
+| **生命周期** | 正常流程保留；被宣布卡死的支线对话条目会移除  |
+| **持久化**   | 根完成时随主线移动到 `done/`                  |
+| **恢复**     | 在主线加载时通过扫描 done/ 支线对话 YAML 重建 |
 
 ### 注册表操作
 
@@ -871,7 +869,7 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 
 ```yaml
 researcher!market-analysis:
-  subdialogId: uuid-123
+  sideDialogId: uuid-123
   agentId: researcher
   tellaskSession: market-analysis
   createdAt: 2025-12-27T10:00:00Z
@@ -882,51 +880,51 @@ researcher!market-analysis:
 flowchart TD
   Tellask["TYPE B 长线诉请: tellask(..., sessionSlug=...)"] --> Key[计算键：agentId!sessionSlug]
   Key --> Lookup{注册表命中？}
-  Lookup -- 是 --> Resume[恢复 + 驱动现有子对话]
-  Lookup -- 否 --> Create[创建 + 注册 + 驱动新的子对话]
-  Resume --> Supply[向调用者供应响应]
+  Lookup -- 是 --> Resume[恢复 + 驱动现有支线对话]
+  Lookup -- 否 --> Create[创建 + 注册 + 驱动新的支线对话]
+  Resume --> Supply[向诉请者供应响应]
   Create --> Supply
 ```
 
 **前一轮仍在等待时又收到更新诉请（规范）**：
 
-- 对同一个已注册支线（同一 `agentId!sessionSlug`），运行时只维护一个“当前等待中的 caller round”。
+- 对同一个已注册支线（同一 `agentId!sessionSlug`），运行时只维护一个“当前等待中的诉请者轮次”。
 - 如果新的 TYPE B 诉请在上一轮回复前到达，运行时会立刻用一条系统生成的失败回贴结束上一轮等待；文案必须从业务事实描述，不使用协议/实现术语。
 - 被诉请侧不会被强行打断。运行时会在它下一次收到的提示里说明“工作要求已更新”，明确要求不要单独回复“收到/好的”，并直接附上最新完整诉请。
 - 这条更新后的 assignment 提示要按顺序排进“下一条待处理提示”队列，在安全的 turn 边界送达；不能仅仅因为队列里已经有另一条正常提示，就拒绝这次更新写入。
-- 如果子对话在最新 assignment 提示真正落到本地之前先产出了回复，这条回复不得作为新一轮的结果回贴给 caller。
+- 如果支线对话在最新 assignment 提示真正落到本地之前先产出了回复，这条回复不得作为新一轮的结果回贴给诉请者。
 
-### 类设计：RootDialog vs SubDialog
+### 类设计：MainDialog vs SideDialog
 
-**关键设计原则**：子对话注册表仅由 `RootDialog` 管理，**子对话实例无法访问**。
+**关键设计原则**：支线对话注册表仅由 `MainDialog` 管理，**支线对话实例无法访问**。
 
 **职责**：
 
-- `RootDialog`
-  - 拥有 TYPE B 子对话注册表（`registry.yaml`）
-  - 创建/注册/查找已注册的子对话（`agentId!sessionSlug`）
-- `SubDialog`
-  - 有一个 `supdialog` 引用（直接父级）并将其用于 TYPE A（`tellaskBack({ tellaskContent: "..." })`）
-  - 无法访问或更改根注册表（按设计）
+- `MainDialog`
+  - 拥有 TYPE B 支线对话注册表（`registry.yaml`）
+  - 创建/注册/查找已注册的支线对话（`agentId!sessionSlug`）
+- `SideDialog`
+  - 有一个 `askerDialog` 引用（直接诉请者）并将其用于 TYPE A（`tellaskBack({ tellaskContent: "..." })`）
+  - 无法访问或更改主线注册表（按设计）
 
 **互斥锁语义**：
 
-- `locked: true` → 子对话当前正在被驱动（持有互斥锁）
-- `locked: false` → 条目存在但子对话未锁定（可以恢复）
+- `locked: true` → 支线对话当前正在被驱动（持有互斥锁）
+- `locked: false` → 条目存在但支线对话未锁定（可以恢复）
 - 注册表不跟踪：'active' | 'completed' | 'suspended' 生命周期状态
 
-**设计原则**：注册表跟踪"锁定"（正在被驱动）与"未锁定"（可以恢复）状态。它不跟踪对话生命周期状态（active/completed/suspended）。这些是 Dialog 的关注点，不是 Registry 的关注点。已注册的子对话可能未锁定（当前未被驱动）但仍然作为已完成或已暂停的对话存在。
+**设计原则**：注册表跟踪"锁定"（正在被驱动）与"未锁定"（可以恢复）状态。它不跟踪对话生命周期状态（active/completed/suspended）。这些是 Dialog 的关注点，不是 Registry 的关注点。已注册的支线对话可能未锁定（当前未被驱动）但仍然作为已完成或已暂停的对话存在。
 
 ### 注册表持久化
 
-**文件位置**：`<root-dialog-path>/registry.yaml`
+**文件位置**：`<main-dialog-path>/registry.yaml`
 
 **格式**：
 
 ```typescript
-interface SubdialogRegistry {
+interface SideDialogRegistry {
   [key: string]: {
-    subdialogId: string; // 子对话的 UUID
+    sideDialogId: string; // 支线对话的 UUID
     agentId: string; // 智能体标识符
     tellaskSession: string; // 诉请会话键
     createdAt: string; // ISO 时间戳
@@ -941,8 +939,8 @@ interface SubdialogRegistry {
 1. **注册时**：新条目添加到注册表，文件保存
 2. **恢复时**：`lastAccessed` 更新，文件保存
 3. **Clear Mind 时**：注册表保留（不被清除）
-4. **根完成时**：注册表随根移动到 `done/`
-5. **根加载时**：注册表从 done/ 子对话 YAML 重建
+4. **根完成时**：注册表随主线移动到 `done/`
+5. **主线加载时**：注册表从 done/ 支线对话 YAML 重建
 
 ---
 
@@ -954,17 +952,17 @@ interface SubdialogRegistry {
 
 **关键组件**：
 
-- **层级支持**：用于子对话管理的父子关系
+- **层级支持**：用于支线对话管理的诉请/响应关系
 - **内存管理**：持久化提醒和临时聊天消息
 - **清理头脑操作**：`startNewCourse(newCoursePrompt)` 方法（清除消息，清除 Q4H，开启新一程对话，并为下一次驱动排队开启提示）
-- **子对话管理**：专门子任务的创建和协调
+- **支线对话管理**：专门支线任务的创建和协调
 - **Q4H 管理**：用于问题跟踪的 `updateQuestions4Human()` 方法
 - **内存访问**：与差遣牒和团队/智能体内存的集成
-- **注册表管理**（仅限 RootDialog）：子对话的注册和查找
+- **注册表管理**（仅限 MainDialog）：支线对话的注册和查找
 
-### 主对话解析
+### 主线对话解析
 
-对于需要与主对话（根对话）通信的子对话，请参阅 `dominds/main/dialog.ts` 中的实现，该实现提供了遍历对话层级的方法。
+对于需要与主线对话通信的支线对话，请参阅 `dominds/main/dialog.ts` 中的实现，该实现提供了遍历对话关系的方法。
 
 ### 持久化层
 
@@ -974,7 +972,7 @@ interface SubdialogRegistry {
 - **Q4H 存储**：每个对话的 `q4h.yaml`（被 clear_mind 清除）
 - **提醒存储**：每个对话的 `reminders.json`
 - **事件持久化**：按程分文件的 JSONL 事件流
-- **注册表存储**：每个根对话的 `registry.yaml`
+- **注册表存储**：每个主线对话的 `registry.yaml`
 
 **Q4H 持久化方法**：
 
@@ -997,13 +995,13 @@ static async clearQuestions4HumanState(
 **注册表持久化方法**：
 
 ```typescript
-// 在 RootDialog（dialog.ts）中
+// 在 MainDialog（dialog.ts）中
 interface RegistryMethods {
-  loadRegistry(): Promise<SubdialogRegistry>;
-  saveRegistry(registry: SubdialogRegistry): Promise<void>;
-  registerSubdialog(key: string, metadata: SubdialogMetadata): void;
-  lookupSubdialog(key: string): SubdialogMetadata | undefined;
-  getRegistry(): SubdialogRegistry;
+  loadRegistry(): Promise<SideDialogRegistry>;
+  saveRegistry(registry: SideDialogRegistry): Promise<void>;
+  registerSideDialog(key: string, metadata: SideDialogMetadata): void;
+  lookupSideDialog(key: string): SideDialogMetadata | undefined;
+  getRegistry(): SideDialogRegistry;
 }
 ```
 
@@ -1011,65 +1009,65 @@ interface RegistryMethods {
 
 ## 对话管理
 
-### 层级管理
+### 对话树管理
 
-**创建**：当智能体需要委派专门任务或复杂问题需要分解时，会创建子对话。
+**创建**：当智能体需要委派专门任务或复杂问题需要分解时，会创建支线对话。
 
-**上下文继承**：新的子对话自动接收：
+**上下文继承**：新的支线对话自动接收：
 
 - 对相同 rtws（运行时工作区）差遣牒的引用（推荐：`tasks/feature-auth.tsk/`）；`dlg.taskDocPath` 在对话创建时固定，永不重新分配
-- 诉请者对话的诉请上下文（mentionList + tellaskContent）解释其目的
+- 诉请者的诉请上下文（mentionList + tellaskContent）解释其目的
 - 访问共享团队内存
 - 访问其智能体的个人内存
 
-**存储**：所有子对话都平铺存储在主对话（根对话）的 `subdialogs/` 目录下，无论嵌套深度如何。
+**存储**：所有支线对话都平铺存储在主线对话的 `sideDialogs/` 目录下，无论嵌套深度如何。
 
-**导航**：每个子对话都保持对其父级的引用，向上遍历到主对话。
+**导航**：每个支线对话都保持对其诉请者的引用，可沿对话树回到主线对话。
 
-**注册表**：已注册的子对话（TYPE B 长线诉请）在根对话的注册表中跟踪，并在重启后持久化；若子对话被宣布卡死，其条目会被裁剪，不再参与后续同 slug 复用。
+**注册表**：已注册的支线对话（TYPE B 长线诉请）在主线对话的注册表中跟踪，并在重启后持久化；若支线对话被宣布卡死，其条目会被裁剪，不再参与后续同 slug 复用。
 
-### Root dialog fork（根对话分叉）
+### Main dialog fork（主线对话分叉）
 
-运行中的一个完整 root dialog tree 可以在某个 root generation 起点处被 fork 成新的 root dialog。该能力用于“保留此前上下文，但从某个历史分叉点重新走后续主线/支线”。
+运行中的一个完整 main dialog tree 可以在某个 root generation 起点处被 fork 成新的 main dialog。该能力用于“保留此前上下文，但从某个历史分叉点重新走后续主线/支线”。
 
 **入口**：
 
-- UI 仅对 root dialog（`selfId === rootId`）的 generation bubble 显示 `Fork 对话`
+- UI 仅对 main dialog（`selfId === rootId`）的 generation bubble 显示 `Fork 对话`
 - 后端 API：`POST /api/dialogs/:rootId/fork`
 - 请求体：`{ course, genseq, status? }`
 
 **语义（强制）**：
 
-- 选中的 generation bubble **不会**被复制到 fork 后的新 root；fork 切点语义是“从该 generation 开始前分叉”
-- 复制范围不是单个对话，而是**整棵 root dialog tree**
-- 子对话是否纳入 fork，取决于它是否已经在切点之前被根对话显式记录为已创建
-- 子对话 transcript 的保留边界由 root generation anchor 决定，而不是子对话自身的本地 `genseq`
+- 选中的 generation bubble **不会**被复制到 fork 后的新主线；fork 切点语义是“从该 generation 开始前分叉”
+- 复制范围不是单个对话，而是**整棵 main dialog tree**
+- 支线对话是否纳入 fork，取决于它是否已经在切点之前被主线对话显式记录为已创建
+- 支线对话 transcript 的保留边界由 root generation anchor 决定，而不是支线对话自身的本地 `genseq`
 
 **fork 后动作**（由后端返回给 UI）：
 
 - `draft_user_text`：若目标 generation 是一条用户输入，则把该文本回填到新对话输入框中，等待用户决定是否发送
-- `restore_pending`：若切点之前存在待处理 Q4H 或待处理子对话，则恢复这些阻塞态，让新 root 继续处于阻塞状态
-- `auto_continue`：若切点之前没有待处理阻塞，则新 root 以 `interrupted(system_stop: fork_dialog_continue)` 初始化，UI 随后立即发送 `resume_dialog`
+- `restore_pending`：若切点之前存在待处理 Q4H 或待处理支线对话，则恢复这些阻塞态，让新主线继续处于阻塞状态
+- `auto_continue`：若切点之前没有待处理阻塞，则新主线以 `interrupted(system_stop: fork_dialog_continue)` 初始化，UI 随后立即发送 `resume_dialog`
 
 **一致性要求**：
 
 - fork 必须保留同一差遣牒引用
-- fork 后的 root/subdialog 都落到 `running/`，并拥有新的 rootId
-- 前端不得对 sideline dialog 暴露该入口；当前实现仅支持 fork root dialog
+- fork 后的 main/sideDialog 都落到 `running/`，并拥有新的 rootId
+- 前端不得对 Side Dialog 暴露该入口；当前实现仅支持 fork main dialog
 
 ### 支线对话起始角色提示（强制）
 
 每当支线对话进入新一程时，运行时必须在 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).`
+- ZH：`你是当前对话的对话主理人；诉请者为 @xxx（当前发起本次诉请）。`
+- EN：`You are the Dialog Responder for this dialog; the tellasker is @xxx (current tellasker).`
 
 **FBR 特例**（示例）：
 
-- ZH：`这是一次 FBR 支线对话；诉请者对话为 @xxx（可能与当前对话同一 agent）。`
-- EN：`This is an FBR sideline dialog; the tellasker dialog is @xxx (may be the same agent).`
+- ZH：`这是一次 FBR 支线对话；诉请者为 @xxx（可能与当前对话同一 agent）。`
+- EN：`This is an FBR Side Dialog; the tellasker is @xxx (may be the same agent).`
 
-**插入点**：优先通过 `formatAssignmentFromSupdialog()` 单点注入（覆盖 `dialog.ts` / `tellask-bridge`）。现在不再保留单独的前端 twin；权威格式化实现位于 [`main/runtime/inter-dialog-format.ts`](../main/runtime/inter-dialog-format.ts)。
+**插入点**：优先通过 `formatAssignmentFromAskerDialog()` 单点注入（覆盖 `dialog.ts` / `tellask-bridge`）。现在不再保留单独的前端 twin；权威格式化实现位于 [`main/runtime/inter-dialog-format.ts`](../main/runtime/inter-dialog-format.ts)。
 
 ### 生命周期管理
 
@@ -1079,28 +1077,28 @@ interface RegistryMethods {
 
 - 任务成功完成
 - 智能体明确标记它们完成
-- 上位对话确定子任务不再需要
-- 所有待处理的子对话都完成且所有 Q4H 已回答
+- 诉请者确定支线任务不再需要
+- 所有待处理的支线对话都完成且所有 Q4H 已回答
 
-**完成时的注册表**：当根对话完成时，其注册表随它移动到 `done/` 目录，并保留以供潜在恢复。
+**完成时的注册表**：当主线对话完成时，其注册表随它移动到 `done/` 目录，并保留以供潜在恢复。
 
 **清理**：完成的对话可以根据保留策略进行归档或清理。
 
 ### 通信模式
 
-**向上通信**：子对话向诉请者对话通信结果、问题和升级。
+**面向诉请者的通信**：支线对话向诉请者通信结果、问题和升级。
 
-- **澄清请求（TYPE A / 回问诉请）**：子对话在处理其子任务时可能向诉请者对话发起诉请以请求澄清。TYPE A 中诉请者对话为直接上位对话。诉请者对话提供指导，子对话在新上下文中继续。
-- **子任务响应**：当子对话产生最终的 "saying" 内容块（没有待处理的 Q4H）时，该消息被视为对**当前调用者**的响应，记录在 `assignmentFromSup` 中（根或另一个子对话）。这使响应与最新的诉请站点保持一致。
-- **Q4H 升级**：如果子对话有 Q4H，它会暂停。用户可以通过 UI 回答，这只会触发子对话的继续。
-- **已注册的子对话（TYPE B / 长线诉请）**：父级可以恢复先前创建的已注册子对话，实现持续的任务继续。
-- **瞬态子对话（TYPE C / 一次性诉请）**：父级可以生成一次性子对话用于不需要持久化的独立任务。
+- **澄清请求（TYPE A / 回问诉请）**：支线对话在处理其支线任务时可能向诉请者发起诉请以请求澄清。TYPE A 中诉请者为直接 askerDialog。诉请者提供指导，支线对话在新上下文中继续。
+- **支线任务响应**：当支线对话产生最终的 "saying" 内容块（没有待处理的 Q4H）时，该消息被视为对 `assignmentFromAsker` 中记录的**当前诉请者**的响应（主线对话或另一个支线对话）。这使响应与最新的诉请站点保持一致。
+- **Q4H 升级**：如果支线对话有 Q4H，它会暂停。用户可以通过 UI 回答，这只会触发支线对话的继续。
+- **已注册的支线对话（TYPE B / 长线诉请）**：诉请者可以恢复先前创建的已注册支线对话，实现持续的任务继续。
+- **瞬态支线对话（TYPE C / 一次性诉请）**：诉请者可以生成一次性支线对话用于不需要持久化的独立任务。
 
-**向下通信**：上位对话向子对话提供上下文、目标和指导。
+**面向支线的通信**：诉请者向支线对话提供上下文、目标和指导。
 
-**横向通信**：兄弟子对话通过共享上位对话进行协调。
+**横向通信**：兄弟支线对话通过共享诉请者进行协调。
 
-**广播通信**：主对话（根对话）可以通过差遣牒引用将更改（如 rtws 差遣牒文件更新）传达给所有对话。
+**广播通信**：主线对话可以通过差遣牒引用将更改（如 rtws 差遣牒文件更新）传达给所有对话。
 
 ---
 
@@ -1114,9 +1112,9 @@ interface RegistryMethods {
 
 **Q4H 问题**：需要人工输入的临时问题，被思维清晰操作**清除**。
 
-**父级调用上下文**：解释为什么创建子对话的不可变上下文。
+**诉请者上下文**：解释为什么创建支线对话的不可变上下文。
 
-**子对话注册表**：根对话作用域的已注册子对话持久映射（在清晰操作中存活）。
+**支线对话注册表**：主线对话作用域的已注册支线对话持久映射（在清晰操作中存活）。
 
 ### rtws 持久化内存
 
@@ -1132,7 +1130,7 @@ interface RegistryMethods {
 
 **Q4H 持久化**：Q4H 问题在创建时持久化，在回答时或调用 clear_mind 时原子地清除。
 
-**注册表持久化**：注册表在每次修改后持久化，并在根对话加载时恢复。
+**注册表持久化**：注册表在每次修改后持久化，并在主线对话加载时恢复。
 
 ---
 
@@ -1146,15 +1144,15 @@ interface RegistryMethods {
 - `<dialog-root>/latest.yaml` — 当前对话过程跟踪和状态
 - `<dialog-root>/reminders.json` — 持久化提醒存储
 - `<dialog-root>/q4h.yaml` — Q4H 索引（被清晰工具清除）
-- `<dialog-root>/registry.yaml` — 子对话注册表（仅限根对话）
+- `<dialog-root>/registry.yaml` — 支线对话注册表（仅限主线对话）
 - `<dialog-root>/course-001.jsonl`（第 1 程对话，还可以有编号递增的后续多程）— 流式消息文件
-- `<dialog-root>/subdialogs/<subdialog-id>/dialog.yaml`
-- `<dialog-root>/subdialogs/<subdialog-id>/q4h.yaml` — 每个子对话的 Q4H 索引（被清晰清除）
+- `<dialog-root>/sideDialogs/<sideDialog-id>/dialog.yaml`
+- `<dialog-root>/sideDialogs/<sideDialog-id>/q4h.yaml` — 每个支线对话的 Q4H 索引（被清晰清除）
 
 **差遣牒存储**：差遣牒是对话通过路径引用的 rtws 产物。差遣牒必须是封装的 `*.tsk/` 任务包。
 
 **内存存储**：团队和智能体内存存储在 rtws 内的专用文件中。
-**注册表存储**：子对话注册表（`registry.yaml`）存储在根对话目录中，并在根完成时移动到 `done/`。
+**注册表存储**：支线对话注册表（`registry.yaml`）存储在主线对话目录中，并在根完成时移动到 `done/`。
 
 ### 流式生成子流顺序契约（Thinking / Saying）
 
@@ -1173,8 +1171,8 @@ Dominds 内部持久化的消息粒度较细（thinking/saying/tool call/tool re
 - **理想目标**：Provider 协议能够原生支持 `role='environment'`（或等价机制）来承载运行时注入的环境/系统信息（例如 reminders、transient guide 等），从而避免把“环境信息”伪装成用户发言。
 - **当前现实**：大多数 Provider 不支持 `role='environment'`。因此 Dominds 在投影到 Provider 请求 payload 时，必须把内部消息类型压平到 Provider 可接受的角色集合中。
   - 运行时/系统提示（`environment_msg`）投影为 `role='user'` 的文本块。
-  - 智能体自写的短指导/自我提醒（`transient_guide_msg`）投影为 `role='assistant'` 的文本块。
-  - reminders 不再一刀切：系统托管的状态型提醒（如运行时状态信号）应落在 `user` 侧并带明确系统提示头标；智能体自维护的工作提醒项则保留在 `assistant` 侧，以第一人称工作便签的语义出现。
+  - 智能体自写的短指导（`transient_guide_msg`）投影为 `role='assistant'` 的文本块。
+  - 默认提醒项上下文包装属于运行时/系统提示：Dominds 内置和 fallback 包装落在 `role=user` 侧，带明确系统提示头标（例如 `【系统提示】`），并使用对 LLM 说话的第二人称口吻。自定义 reminder owner 仍按自身契约决定输出 role。无论 owner 具体选择什么 role，外围 reminder 块都应被理解为 environment 风格运行时上下文，而不是新的用户指令，也不是 assistant 自己刚发出的聊天轮次。提醒项投影应插入在真实对话消息之前，并使用成对的提醒块 header/footer；footer 必须把“并非用户指令”的说明限定在该 header/footer 之间的内容，避免误伤对话历史里的真实用户指令。
 
 另外，一些 Provider（尤其是 Anthropic-compatible endpoint）对 **role 交替** 与 **tool_use/tool_result 的边界** 有更严格的结构校验。Dominds 的投影层需要把内部细粒度条目组装为更“turn 化”的 Provider 消息序列（turn assembly），而不是把内部条目逐条 1:1 发送。
 
@@ -1184,19 +1182,19 @@ Dominds 内部持久化的消息粒度较细（thinking/saying/tool call/tool re
 
 **工具调用**：思维清晰工具通过 CLI 命令或智能体操作调用。
 
-**状态监控**：对话状态、待处理子对话、Q4H 计数和已注册的子对话可以通过 CLI 工具检查。
+**状态监控**：对话状态、待处理支线对话、Q4H 计数和已注册的支线对话可以通过 CLI 工具检查。
 
 ### 智能体集成
 
-**自主操作**：智能体可以独立创建子对话（TYPE B 和 C）、管理提醒、提出 Q4H 并触发清晰操作。
+**自主操作**：智能体可以独立创建支线对话（TYPE B 和 C）、管理提醒、提出 Q4H 并触发清晰操作。
 
-**上下文感知**：智能体可以完全访问其对话上下文、内存、层级位置、来自子对话的待处理 Q4H，以及（对于根对话）子对话注册表。
+**上下文感知**：智能体可以完全访问其对话上下文、内存、对话关系位置、来自支线对话的待处理 Q4H，以及（对于主线对话）支线对话注册表。
 
 **队友诉请能力**：智能体可以调用所有三种类型的队友诉请：
 
-- TYPE A / 回问诉请：向上位对话发起诉请以请求澄清
-- TYPE B / 长线诉请：诉请或恢复已注册的子对话
-- TYPE C / 一次性诉请：生成瞬态子对话
+- TYPE A / 回问诉请：向诉请者发起诉请以请求澄清
+- TYPE B / 长线诉请：诉请或恢复已注册的支线对话
+- TYPE C / 一次性诉请：生成瞬态支线对话
 
 **工具访问**：所有思维清晰工具、Q4H 能力和队友诉请工具都可用于智能体进行自主认知管理。
 
@@ -1207,7 +1205,7 @@ Dominds 的运行时**不**持久化单一的类似枚举的 "awaiting …" 状
 
 - 持久化状态（API/索引）：`running | completed | archived`
 - 持久化 `latest.yaml`：`status`、`needsDrive`、`generating`
-- 派生的门控：`hasPendingQ4H()` 和 `hasPendingSubdialogs()`
+- 派生的门控：`hasPendingQ4H()` 和 `hasPendingSideDialogs()`
 
 **持久化状态生命周期**：
 
@@ -1219,13 +1217,13 @@ stateDiagram-v2
   completed --> archived: 归档
 ```
 
-**根驱动程序门控（概念性）**：
+**主线驱动程序门控（概念性）**：
 
 ```mermaid
 flowchart TD
-  A[status=running] --> B{可以驱动？\\n（没有待处理的 Q4H\\n且没有待处理的子对话）}
-  B -- 否 --> S[已暂停\\n（等待 Q4H 和/或子对话）]
-  S -->|Q4H 回答\\n或子对话响应供应| C{需要驱动？}
+  A[status=running] --> B{可以驱动？\\n（没有待处理的 Q4H\\n且没有待处理的支线对话）}
+  B -- 否 --> S[已暂停\\n（等待 Q4H 和/或支线对话）]
+  S -->|Q4H 回答\\n或支线对话响应供应| C{需要驱动？}
   B -- 是 --> C{需要驱动？}
   C -- 否 --> I[空闲\\n（等待触发器）]
   C -- 是 --> D[驱动循环\\n（流式传输时 generating=true）]
@@ -1242,58 +1240,58 @@ flowchart TD
 
 ```mermaid
 sequenceDiagram
-  participant Sub as 子对话
+  participant Side as 支线对话
   participant Driver as 后端驱动程序
-  participant Sup as 上位对话（直接父级）
+  participant Asker as 诉请者（直接诉请者）
 
-  Sub->>Driver: 发出 `tellaskBack({ tellaskContent: "..." })` + 问题
-  Driver->>Sup: 驱动上位对话以回答
-  Sup-->>Driver: 响应文本
-  Driver-->>Sub: 恢复子对话，响应在上下文中
+  Side->>Driver: 发出 `tellaskBack({ tellaskContent: "..." })` + 问题
+  Driver->>Asker: 驱动诉请者以回答
+  Asker-->>Driver: 响应文本
+  Driver-->>Side: 恢复支线对话，响应在上下文中
 ```
 
-#### TYPE B：已注册子对话诉请（长线诉请）（`tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })`）
+#### TYPE B：已注册支线对话诉请（长线诉请）（`tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })`）
 
 ```mermaid
 sequenceDiagram
-  participant Caller as 调用者对话
+  participant Tellasker as 诉请者
   participant Driver as 后端驱动程序
-  participant Reg as 根子对话注册表
-  participant Sub as 已注册的子对话
+  participant Reg as 主线支线对话注册表
+  participant Side as 已注册的支线对话
 
-  Caller->>Driver: 发出 `tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })`
+  Tellasker->>Driver: 发出 `tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })`
   Driver->>Reg: 查找 `agentId!sessionSlug`
   alt 注册表命中
-    Reg-->>Driver: 现有子对话 selfId
+    Reg-->>Driver: 现有支线对话 selfId
     opt 前一轮仍在等待
-      Driver-->>Caller: 用系统生成的业务化文案结束前一轮等待
-      Driver->>Sub: 排入“要求已更新”通知 + 最新完整诉请
+      Driver-->>Tellasker: 用系统生成的业务化文案结束前一轮等待
+      Driver->>Side: 排入“要求已更新”通知 + 最新完整诉请
     end
-    Driver->>Sub: 恢复 + 驱动
+    Driver->>Side: 恢复 + 驱动
   else 注册表未命中
     Reg-->>Driver: 无
-    Driver->>Sub: 创建 + 注册 + 驱动
+    Driver->>Side: 创建 + 注册 + 驱动
   end
-  Sub-->>Driver: 最终响应
-  Driver-->>Caller: 供应响应 + 清除待处理子对话
-  opt 调用者是根且现在已解除阻塞
-    Driver-->>Caller: 设置 needsDrive=true（自动重启调度）
+  Side-->>Driver: 最终响应
+  Driver-->>Tellasker: 供应响应 + 清除待处理支线对话
+  opt 诉请者是主线且现在已解除阻塞
+    Driver-->>Tellasker: 设置 needsDrive=true（自动重启调度）
   end
 ```
 
-#### TYPE C：瞬态子对话诉请（一次性诉请）（`tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })`，或 `freshBootsReasoning({ tellaskContent: "..." })`）
+#### TYPE C：瞬态支线对话诉请（一次性诉请）（`tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })`，或 `freshBootsReasoning({ tellaskContent: "..." })`）
 
 ```mermaid
 sequenceDiagram
-  participant Caller as 调用者对话
+  participant Tellasker as 诉请者
   participant Driver as 后端驱动程序
-  participant Sub as 瞬态子对话
+  participant Side as 瞬态支线对话
 
-  Caller->>Driver: 发出 tellaskSessionless(...)
-  Driver->>Sub: 创建（不注册）
-  Driver->>Sub: 驱动
-  Sub-->>Driver: 最终响应
-  Driver-->>Caller: 供应响应（无注册表更新）
+  Tellasker->>Driver: 发出 tellaskSessionless(...)
+  Driver->>Side: 创建（不注册）
+  Driver->>Side: 驱动
+  Side-->>Driver: 最终响应
+  Driver-->>Tellasker: 供应响应（无注册表更新）
 ```
 
 ### Q4H 生命周期状态
@@ -1312,31 +1310,31 @@ flowchart TD
 
 `q4h.yaml` 被视为索引；真理之源"提出的问题"内容存在于对话的消息流中，由 `callSiteRef` 引用。
 
-### 子对话 + Q4H 交互
+### 支线对话 + Q4H 交互
 
 ```mermaid
 sequenceDiagram
-  participant Sup as 上位对话
-  participant Sub as 子对话
+  participant Asker as 诉请者
+  participant Side as 支线对话
   participant UI as 前端 UI
   participant WS as WebSocket 处理器
   participant Driver as driveDialogStream
 
-  Sup->>Sub: 创建子对话（TYPE B 或 C）
-  Note over Sup,Sub: 上位对话因待处理子对话而阻塞
-  Sub->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题（Q4H）
+  Asker->>Side: 创建支线对话（TYPE B 或 C）
+  Note over Asker,Side: 诉请者因待处理支线对话而阻塞
+  Side->>WS: 发出 askHuman({ tellaskContent: "..." }) 问题（Q4H）
   WS-->>UI: questions_count_update（全局）
 
-  Note over Sub: 子对话在回答之前无法继续
+  Note over Side: 支线对话在回答之前无法继续
 
-  UI->>WS: drive_dialog_by_user_answer (dialogId=subdialogId, questionId, content)
-  WS->>Sub: 清除 q4h.yaml 条目
-  WS->>Driver: driveDialogStream(subdialog, user answer)
-  Driver-->>Sub: 子对话恢复并继续
-  Sub-->>Sup: 子对话响应供应给调用者（清除待处理子对话）
+  UI->>WS: drive_dialog_by_user_answer (dialogId=sideDialogId, questionId, content)
+  WS->>Side: 清除 q4h.yaml 条目
+  WS->>Driver: driveDialogStream(sideDialog, user answer)
+  Driver-->>Side: 支线对话恢复并继续
+  Side-->>Asker: 支线对话响应供应给诉请者（清除待处理支线对话）
 
-  opt 上位对话是根且现在已解除阻塞
-    Sup-->>Sup: 设置 needsDrive=true（自动重启）
+  opt 诉请者是主线且现在已解除阻塞
+    Asker-->>Asker: 设置 needsDrive=true（自动重启）
   end
 ```
 
@@ -1344,19 +1342,19 @@ sequenceDiagram
 
 ## 完整流程参考
 
-### 1. 主对话提出 Q4H
+### 1. 主线对话提出 Q4H
 
 ```mermaid
 sequenceDiagram
 	  participant User as 用户/智能体
-  participant Main as 主对话
+  participant Main as 主线对话
   participant Store as 持久化（q4h.yaml）
   participant UI as 前端
 
   User->>Main: askHuman({ tellaskContent: "..." }) 问题
   Main->>Store: recordQuestionForHuman()
   Main-->>UI: questions_count_update
-  Main-->>Main: 暂停根驱动循环
+  Main-->>Main: 暂停主线驱动循环
 
   User->>UI: 选择 Q4H
   User->>Main: 提交答案
@@ -1365,64 +1363,64 @@ sequenceDiagram
   Main-->>Main: driveDialogStream(answer)
 ```
 
-### 2. 子对话提出 Q4H，用户通过根回答
+### 2. 支线对话提出 Q4H，用户通过主线回答
 
 ```mermaid
 sequenceDiagram
   participant User as 用户
-  participant Sup as 上位对话（根）
-  participant Sub as 子对话
-  participant Store as 持久化（sub/q4h.yaml, sub/response.yaml）
+  participant Asker as AskerDialog（主线）
+  participant Side as SideDialog
+  participant Store as 持久化（side/q4h.yaml, side/response.yaml）
   participant UI as 前端
 
-  Sup->>Sub: createSubDialog()
-  Sub->>Store: recordQuestionForHuman()
+  Asker->>Side: createSideDialog()
+  Side->>Store: recordQuestionForHuman()
 ```
 
-### 2. 子对话发起 Q4H，用户通过根对话回答
+### 2. 支线对话发起 Q4H，用户通过主线对话回答
 
 ```mermaid
 sequenceDiagram
   participant User as 用户
-  participant Sup as 父对话（根）
-  participant Sub as 子对话
-  participant Store as 持久化（sub/q4h.yaml, sub/response.yaml）
+  participant Asker as AskerDialog（主线）
+  participant Side as SideDialog
+  participant Store as 持久化（side/q4h.yaml, side/response.yaml）
   participant UI as 前端
 
-  Sup->>Sub: createSubDialog()
-  Sub->>Store: recordQuestionForHuman()
-  Sub-->>UI: questions_count_update（子对话）
-  Sup-->>Sup: suspended（等待 Q4H/子对话）
-
-  User->>UI: 选择子对话 Q4H
-  User->>Sup: drive_dialog_by_user_answer(targetSubdialogId)
-  Sup->>Sub: handleDriveDialogByUserAnswer(...)
-  Sub->>Store: loadQuestions4HumanState()
-  Sub->>Store: clearQuestions4HumanState()
-  Sub-->>Sub: driveDialogStream(answer)
-  Sub->>Store: write response.yaml
-  Sub-->>Sup: supply response（恢复根对话）
+  Asker->>Side: createSideDialog()
+  Side->>Store: recordQuestionForHuman()
+  Side-->>UI: questions_count_update（支线对话）
+  Asker-->>Asker: suspended（等待 Q4H/支线对话）
+
+  User->>UI: 选择支线对话 Q4H
+  User->>Asker: drive_dialog_by_user_answer(targetSideDialogId)
+  Asker->>Side: handleDriveDialogByUserAnswer(...)
+  Side->>Store: loadQuestions4HumanState()
+  Side->>Store: clearQuestions4HumanState()
+  Side-->>Side: driveDialogStream(answer)
+  Side->>Store: write response.yaml
+  Side-->>Asker: supply response（恢复主线对话）
 ```
 
-### 3. 已注册子对话诉请（TYPE B / 长线诉请）
+### 3. 已注册支线对话诉请（TYPE B / 长线诉请）
 
 ```mermaid
 sequenceDiagram
-  participant Root as 根对话
+  participant Main as 主线对话
   participant Store as 持久化（registry.yaml + dialogs/）
-  participant Sub as 子对话（@researcher sessionSlug market）
+  participant Side as 支线对话（@researcher sessionSlug market）
 
-  Root->>Store: lookup registry key "researcher!market"
+  Main->>Store: lookup registry key "researcher!market"
   alt not found
-    Root->>Store: create subdialog + save registry.yaml
-    Root->>Sub: drive（根暂停）
+    Main->>Store: create sideDialog + save registry.yaml
+    Main->>Side: drive（主线暂停）
   else found
-    Root->>Store: load subdialog + update lastAccessed
-    Root->>Sub: drive（根暂停）
+    Main->>Store: load sideDialog + update lastAccessed
+    Main->>Side: drive（主线暂停）
   end
 
-  Sub->>Store: write response.yaml
-  Sub-->>Root: supply response（根恢复）
+  Side->>Store: write response.yaml
+  Side-->>Main: supply response（主线恢复）
 ```
 
 ### 4. 清晰度操作保留注册表
@@ -1442,9 +1440,9 @@ sequenceDiagram
 
 ### 可扩展性
 
-**扁平存储**：子对话扁平存储防止深层目录嵌套问题。
+**扁平存储**：支线对话扁平存储防止深层目录嵌套问题。
 
-**注册表效率**：已注册子对话的单级 Map 查找为 O(1)。
+**注册表效率**：已注册支线对话的单级 Map 查找为 O(1)。
 
 **内存效率**：共享内存在对话之间减少重复。
 
@@ -1462,7 +1460,7 @@ sequenceDiagram
 
 **性能指标**：系统跟踪对话创建、完成、注册表大小、资源使用和 Q4H 计数。
 
-**健康检查**：定期验证对话层次结构完整性、Q4H 持久化、注册表一致性和内存。
+**健康检查**：定期验证对话树完整性、Q4H 持久化、注册表一致性和内存。
 
 **调试支持**：全面的日志记录和检查工具，用于排查队友诉请、注册表操作和 Q4H 流程。
 
@@ -1470,17 +1468,17 @@ sequenceDiagram
 
 ## 总结
 
-Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强大的框架：
+Dominds 对话系统为树状协作、人在回路的 AI 协作提供了一个强大的框架：
 
 ### 四个核心机制
 
-| 机制             | 目的             | 存活于清晰度 | 清除方式                                  |
-| ---------------- | ---------------- | ------------ | ----------------------------------------- |
-| **对话层次结构** | 父子任务委托     | N/A          | N/A                                       |
-| **Q4H**          | 人机交互请求     | 否           | clear_mind                                |
-| **心智清晰度**   | 上下文重置工具   | N/A          | N/A                                       |
-| **提醒项**       | 持久化工作内存   | 是           | N/A                                       |
-| **子对话注册表** | 已注册子对话跟踪 | 是           | `declare_subdialog_dead` 时裁剪 dead 条目 |
+| 机制               | 目的                | 存活于清晰度 | 清除方式                                   |
+| ------------------ | ------------------- | ------------ | ------------------------------------------ |
+| **对话树**         | 诉请者/支线任务委托 | N/A          | N/A                                        |
+| **Q4H**            | 人机交互请求        | 否           | clear_mind                                 |
+| **心智清晰度**     | 上下文重置工具      | N/A          | N/A                                        |
+| **提醒项**         | 持久化工作内存      | 是           | N/A                                        |
+| **支线对话注册表** | 已注册支线对话跟踪  | 是           | `declare_sideDialog_dead` 时裁剪 dead 条目 |
 
 ### 三种队友诉请类型
 
@@ -1492,12 +1490,12 @@ Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强
 
 ### 类职责
 
-- **根对话**：管理注册表，可以发起所有三种队友诉请类型
-- **子对话**：拥有父对话引用，可以直接发起 TYPE A 和 TYPE C；TYPE B 通过根注册表路由，并在每次诉请时更新调用者上下文
+- **主线对话**：管理注册表，可以发起所有三种队友诉请类型
+- **支线对话**：拥有诉请者引用，可以直接发起 TYPE A 和 TYPE C；TYPE B 通过主线注册表路由，并在每次诉请时更新诉请者上下文
 
 ### 持久化保证
 
 - **Q4H**：持久化，由清晰度操作清除
 - **提醒项**：持久化，在清晰度操作中存活
 - **注册表**：持久化，在清晰度操作中存活，完成时移至 done/；dead 条目会在宣布卡死时被裁剪
-- **子对话**：已注册的子对话在注册表中持久化；临时子对话不会被注册
+- **支线对话**：已注册的支线对话在注册表中持久化；临时支线对话不会被注册