dominds 1.9.3 → 1.10.1

package/dist/dialog-fork.js

@@ -106,6 +106,7 @@ function isPersistedMessageRecord(record) {
             return true;
         case 'web_search_call_record':
         case 'quest_for_sup_record':
+        case 'tellask_reply_resolution_record':
         case 'tellask_call_carryover_record':
         case 'tellask_call_anchor_record':
         case 'gen_start_record':
@@ -175,6 +176,7 @@ function rewriteRecordForFork(record, newRootId) {
         case 'human_text_record':
         case 'quest_for_sup_record':
         case 'tellask_call_result_record':
+        case 'tellask_reply_resolution_record':
         case 'tellask_call_carryover_record':
         case 'tellask_call_anchor_record':
         case 'tellask_response_record':

package/dist/dialog.d.ts

@@ -16,7 +16,7 @@ import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-hea
 import type { DialogEvent, ReminderContent, WebSearchCallAction } from '@longrun-ai/kernel/types/dialog';
 import type { DialogPrompt, DialogRunControlSpec, DialogSubdialogReplyTarget, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
-import type { CalleeCourseNumber, CalleeGenerationSeqNumber, CallingCourseNumber, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, ToolArguments as StoredToolArguments } from '@longrun-ai/kernel/types/storage';
+import type { CalleeCourseNumber, CalleeGenerationSeqNumber, CallingCourseNumber, DialogMetadataFile, HumanQuestion, ProviderData, ReasoningPayload, ToolArguments as StoredToolArguments, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg } from './llm/client';
 import type { JsonValue } from './tool';
 import { Reminder, ReminderOptions, ReminderOwner } from './tool';
@@ -35,6 +35,7 @@ type UpNextPromptState = {
     userLanguageCode?: LanguageCode;
     origin: 'user' | 'diligence_push' | 'runtime';
     q4hAnswerCallIds?: string[];
+    tellaskReplyDirective?: TellaskReplyDirective;
     skipTaskdoc?: boolean;
     subdialogReplyTarget?: DialogSubdialogReplyTarget;
     runControl?: DialogRunControlSpec;
@@ -328,6 +329,7 @@ export declare abstract class Dialog {
         grammar: 'markdown';
         userLanguageCode?: LanguageCode;
         q4hAnswerCallIds?: string[];
+        tellaskReplyDirective?: TellaskReplyDirective;
         skipTaskdoc?: boolean;
         subdialogReplyTarget?: DialogSubdialogReplyTarget;
     }): UpNextPromptState;
@@ -398,7 +400,12 @@ export declare abstract class Dialog {
         calleeGenseq?: CalleeGenerationSeqNumber;
     }): Promise<void>;
     updateQuestions4Human(questions: HumanQuestion[]): Promise<void>;
-    persistUserMessage(content: string, msgId: string, grammar: 'markdown', origin: 'user' | 'diligence_push' | 'runtime' | undefined, userLanguageCode?: LanguageCode, q4hAnswerCallIds?: string[]): Promise<void>;
+    persistUserMessage(content: string, msgId: string, grammar: 'markdown', origin: 'user' | 'diligence_push' | 'runtime' | undefined, userLanguageCode?: LanguageCode, q4hAnswerCallIds?: string[], tellaskReplyDirective?: TellaskReplyDirective): Promise<void>;
+    appendTellaskReplyResolution(payload: {
+        callId: string;
+        replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+        targetCallId: string;
+    }): Promise<void>;
     persistAgentMessage(content: string, genseq: number, type: 'thinking_msg' | 'saying_msg', provider_data?: ProviderData, reasoning?: ReasoningPayload): Promise<void>;
     persistUiOnlyMarkdown(content: string, genseq: number): Promise<void>;
     persistFunctionCall(id: string, name: string, arguments_: StoredToolArguments, genseq: number): Promise<void>;
@@ -614,7 +621,12 @@ export declare abstract class DialogStore {
     /**
      * Persist a user message to storage
      */
-    persistUserMessage(_dialog: Dialog, _content: string, _msgId: string, _grammar: 'markdown', _origin: 'user' | 'diligence_push' | 'runtime' | undefined, _userLanguageCode?: LanguageCode, _q4hAnswerCallIds?: string[]): Promise<void>;
+    persistUserMessage(_dialog: Dialog, _content: string, _msgId: string, _grammar: 'markdown', _origin: 'user' | 'diligence_push' | 'runtime' | undefined, _userLanguageCode?: LanguageCode, _q4hAnswerCallIds?: string[], _tellaskReplyDirective?: TellaskReplyDirective): Promise<void>;
+    appendTellaskReplyResolution(_dialog: Dialog, _payload: {
+        callId: string;
+        replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+        targetCallId: string;
+    }): Promise<void>;
     /**
      * Persist an assistant message to storage
      */

package/dist/dialog.js

@@ -526,6 +526,7 @@ class Dialog {
             userLanguageCode: prompt.userLanguageCode,
             origin: prompt.origin,
             q4hAnswerCallIds: prompt.q4hAnswerCallIds,
+            tellaskReplyDirective: prompt.tellaskReplyDirective,
             skipTaskdoc: prompt.skipTaskdoc,
             subdialogReplyTarget: prompt.subdialogReplyTarget,
             runControl,
@@ -550,6 +551,7 @@ class Dialog {
                     grammar: nextPrompt.grammar ?? 'markdown',
                     userLanguageCode: nextPrompt.userLanguageCode,
                     q4hAnswerCallIds: nextPrompt.q4hAnswerCallIds,
+                    tellaskReplyDirective: nextPrompt.tellaskReplyDirective,
                     skipTaskdoc: nextPrompt.skipTaskdoc,
                     subdialogReplyTarget: nextPrompt.subdialogReplyTarget,
                 },
@@ -612,6 +614,7 @@ class Dialog {
                 userLanguageCode: state.userLanguageCode ?? this._lastUserLanguageCode,
                 origin: state.origin,
                 q4hAnswerCallIds: state.q4hAnswerCallIds,
+                tellaskReplyDirective: state.tellaskReplyDirective,
                 skipTaskdoc: state.skipTaskdoc,
                 subdialogReplyTarget: state.subdialogReplyTarget,
             },
@@ -688,6 +691,7 @@ class Dialog {
                 userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
                 origin: 'runtime',
                 q4hAnswerCallIds: options.q4hAnswerCallIds,
+                tellaskReplyDirective: options.tellaskReplyDirective,
                 skipTaskdoc: options.skipTaskdoc,
                 subdialogReplyTarget: options.subdialogReplyTarget,
                 runControl: undefined,
@@ -702,6 +706,7 @@ class Dialog {
             grammar: options.grammar,
             userLanguageCode: options.userLanguageCode ?? existing.userLanguageCode ?? this._lastUserLanguageCode,
             q4hAnswerCallIds: this.mergePromptQ4HAnswerCallIds(existing.q4hAnswerCallIds, options.q4hAnswerCallIds),
+            tellaskReplyDirective: options.tellaskReplyDirective ?? existing.tellaskReplyDirective,
             skipTaskdoc: options.skipTaskdoc ?? existing.skipTaskdoc,
             subdialogReplyTarget: options.subdialogReplyTarget ?? existing.subdialogReplyTarget,
             runControl: undefined,
@@ -908,8 +913,11 @@ class Dialog {
     async updateQuestions4Human(questions) {
         return await this.dlgStore.updateQuestions4Human(this, questions);
     }
-    async persistUserMessage(content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds) {
-        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds);
+    async persistUserMessage(content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds, tellaskReplyDirective) {
+        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds, tellaskReplyDirective);
+    }
+    async appendTellaskReplyResolution(payload) {
+        await this.dlgStore.appendTellaskReplyResolution(this, payload);
     }
     async persistAgentMessage(content, genseq, type, provider_data, reasoning) {
         return await this.dlgStore.persistAgentMessage(this, content, genseq, type, provider_data, reasoning);
@@ -1307,7 +1315,8 @@ class DialogStore {
     /**
      * Persist a user message to storage
      */
-    async persistUserMessage(_dialog, _content, _msgId, _grammar, _origin, _userLanguageCode, _q4hAnswerCallIds) { }
+    async persistUserMessage(_dialog, _content, _msgId, _grammar, _origin, _userLanguageCode, _q4hAnswerCallIds, _tellaskReplyDirective) { }
+    async appendTellaskReplyResolution(_dialog, _payload) { }
     /**
      * Persist an assistant message to storage
      */

package/dist/docs/memory-system.md

@@ -124,10 +124,15 @@ Taskdocs are the canonical task contract shared by the team. They answer: what w
 - `constraints`: hard rules (safety/style/process/compliance)
 - `progress`: distilled progress (key decisions, current status, next steps)
 
+#### Section semantics
+
+- `progress` is the team’s shared milestone bulletin board: key decisions, current status, and next steps. It is not a raw log and not a personal work record.
+- `goals` / `constraints` are the more stable task contract: every update must preserve still-valid entries from others instead of turning shared state into personal notes.
+
 #### Practical rules (keep only the essentials)
 
 - Treat `goals / constraints / progress` as a **shared bulletin board**, not a personal scratchpad.
-- `progress` is a distilled snapshot; high-frequency details belong in reminders (working set).
+- `progress` is a distilled snapshot; each update should preserve a complete current picture that teammates can scan quickly; high-frequency details belong in reminders (working set).
 - Don’t paste huge tool outputs into Taskdocs. Distill conclusions/evidence, or keep a curated excerpt in reminders.
 
 For extra sections and `*.tsk/` packaging semantics, see: [encapsulated-taskdoc.md](./encapsulated-taskdoc.md).
@@ -150,6 +155,8 @@ Never treat “I saw it earlier” as a durable assumption.
 Some reminders are generated by the runtime (e.g. background process status, MCP rentals/expiration). Treat them as signals:
 
 - read and adjust behavior
+- if they do not materially change your judgment/plan/risk, make no user-visible reply at all (do not send filler like “silently noted” or “received”)
+- if they do matter, reflect that only inside the next substantive reply rather than acknowledging them separately
 - but don’t treat them as your personal worklog (their lifecycle is typically system-managed)
 - in message semantics, these should be treated as **system notices**: they typically appear on the `role=user` side with an explicit notice prefix, so they do not get mistaken for self-authored work notes
 

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

@@ -123,10 +123,15 @@ TL;DR：
 - `constraints`：硬规则（安全/风格/流程/合规）
 - `progress`：精炼进展（关键决策、当前状态、下一步）
 
+#### 章节语义约定
+
+- `progress` 是全队共享的里程碑公告牌：记录关键决策、当前状态与下一步；不是流水账，不是个人工作记录。
+- `goals` / `constraints` 是较稳定的任务契约：每次更新都要保留仍然有效的他人条目，不要把共享约定误改成个人笔记。
+
 #### 使用要点（只保留最重要的约束）
 
 - 把 `goals / constraints / progress` 当作**团队共享公告板**，不是个人草稿本。
-- `progress` 只写“足以让下一程继续推进”的精炼状态；高频细节放到提醒项（工作集）。
+- `progress` 只写“足以让下一程继续推进”的精炼状态；每次更新都应保持“当前全貌快照”完整可扫读；高频细节放到提醒项（工作集）。
 - 不要把长工具输出塞进差遣牒：要么提炼成结论/证据，要么放到提醒项里做精炼摘录。
 
 差遣牒附加章节（非自动注入）与 `*.tsk/` 封装语义，详见：[encapsulated-taskdoc.zh.md](./encapsulated-taskdoc.zh.md)
@@ -149,7 +154,8 @@ TL;DR：
 有一类提醒项来自运行时环境（例如后台进程状态、MCP 租用/到期等）。它们更像信号灯：
 
 - 你应该阅读并据此调整行为
-- 默认应“静默吸收”这类状态信号；除非它实际改变当前判断/计划/风险，否则不要在回复里专门确认、复述或总结它
+- 若它没有实质改变当前判断/计划/风险，就禁止做任何用户可见回应（禁止写“静默吸收”“已收到”等占位语句）
+- 若它确实改变了当前判断/计划/风险，也无需单独回一条“收到”；只需在下一条有实质内容的回复中体现
 - 但它们的生命周期通常由系统管理（自动更新/自动清理），不要把它们当成个人工作日志
 - 在消息语义上，这类提醒应视为**系统提示**：通常落在 `role=user` 侧，并带显眼头标（如 `【系统提示】`），避免与个人工作提醒混淆
 

package/dist/docs/team_mgmt-toolset.md

@@ -6,6 +6,9 @@ This document specifies a dedicated **team management toolset** whose only job i
 rtws’s “mindset” configuration files under `.minds/` (team roster, LLM providers, and agent
 minds files), without granting broad rtws access.
 
+> Historical note: the runtime/manual entrypoint has since been unified to
+> `man({ "toolsetId": "team_mgmt" })`, which now renders the authoritative handbook content.
+
 The outer repository root is the **rtws** (runtime workspace). All paths below are relative to the
 rtws root.
 
@@ -33,18 +36,18 @@ This document is a **design spec** for the new `team_mgmt` toolset. It is not so
 ever tell an agent to “look up” at runtime.
 
 Instead, the runtime “single source of truth” for team management guidance should be
-the function tool `team_mgmt_manual`.
+`man({ "toolsetId": "team_mgmt" })`.
 
 Historically, some of the guidance lived in a legacy builtin “team manager” mind set inside the
 `dominds/` source tree. That legacy builtin is being removed. The runtime “single source of truth”
-should be the `team_mgmt_manual` tool output.
+should be the `man({ "toolsetId": "team_mgmt" })` output.
 
 Planned change:
 
-- Add a new function tool `team_mgmt_manual` whose responses cover the team-management topics (file
-  formats, workflows, safety).
+- Route team-management handbook content through the generic `man` tool under
+  `man({ "toolsetId": "team_mgmt" })`, covering file formats, workflows, and safety.
 - Remove legacy builtin guidance to avoid duplication. If any stub remains, it must point to
-  `team_mgmt_manual` (and not to this design document).
+  `man({ "toolsetId": "team_mgmt" })` (and not to this design document).
 
 Rationale:
 
@@ -82,7 +85,7 @@ The `team_mgmt` toolset mirrors a minimal subset of `fs`/`txt`, but **hard-scope
 
 ### Naming Conventions (Human / UI)
 
-- **Tools** use `snake_case` (underscore-separated) for tool IDs (e.g. `team_mgmt_manual`). Avoid
+- **Tools** use `snake_case` (underscore-separated) for tool IDs (e.g. `team_mgmt_validate_team_cfg`). Avoid
   `kebab-case` aliases for tool IDs; if UX needs a friendlier label, treat that as presentation-only.
 - **Teammates** use either `kebab-case` (hyphen-separated) or an “internet name” (dot-separated).
 - This is a convention for docs/UI/readability only; do not enforce it via validation or other
@@ -111,7 +114,7 @@ Recommended tools (names are suggestions; use `snake_case` to match existing too
 | `team_mgmt_rm_dir`                     | `fs`     | Delete directories under `.minds/`                                                | `.minds/**`             |
 | `team_mgmt_validate_priming_scripts`   | new      | Validate path constraints and script format under `.minds/priming/**.md`          | `.minds/**`             |
 | `team_mgmt_validate_team_cfg`          | new      | Validate `.minds/team.yaml` and publish issues to the Problems panel              | `.minds/**`             |
-| `team_mgmt_manual`                     | new      | Built-in “how-to” manual (see below)                                              | N/A                     |
+| `man({ "toolsetId": "team_mgmt" })`    | builtin  | Handbook entrypoint for the `team_mgmt` toolset (see below)                       | N/A                     |
 
 Notes:
 
@@ -143,32 +146,32 @@ may not exist during bootstrap. A dedicated `team_mgmt` toolset:
 - Makes it easy to grant _just_ team management capabilities to an ad-hoc agent without full rtws
   access.
 
-## `team_mgmt_manual`
+## Team Handbook via `man({ "toolsetId": "team_mgmt" })`
 
 We need a single in-chat manual tool so the team manager can reliably self-serve guidance without
 reading source code.
 
 ### Command shape
 
-- `team_mgmt_manual({ "topics": [] })` → show a short index (topics).
-- `team_mgmt_manual({ "topics": ["topics"] })` → list topics.
-- `team_mgmt_manual({ "topics": ["llm"] })` → how to manage `.minds/llm.yaml` (+ templates).
-- `team_mgmt_manual({ "topics": ["llm", "builtin-defaults"] })` → show builtin providers/models (from defaults).
-- `team_mgmt_manual({ "topics": ["mcp"] })` → how to manage `.minds/mcp.yaml` (+ templates).
-- `team_mgmt_manual({ "topics": ["mcp"] })` → how to manage `.minds/mcp.yaml` (transports, env/headers, tools whitelist/blacklist, naming transforms, hot reload, leasing).
-- `team_mgmt_manual({ "topics": ["mcp", "troubleshooting"] })` → common MCP failure modes and how to recover.
-- `team_mgmt_manual({ "topics": ["team"] })` → how to manage `.minds/team.yaml` (+ templates).
-- `team_mgmt_manual({ "topics": ["team", "member-properties"] })` → list supported member fields and meanings.
-- `team_mgmt_manual({ "topics": ["minds"] })` → how to manage `.minds/team/<id>/*.md` (persona/knowledge/lessons).
-- `team_mgmt_manual({ "topics": ["priming"] })` → how to manage startup scripts under `.minds/priming/*`.
-- `team_mgmt_manual({ "topics": ["permissions"] })` → how `read_dirs`/`write_dirs` and deny-lists work.
-- `team_mgmt_manual({ "topics": ["troubleshooting"] })` → common failure modes and how to recover.
+- `man({ "toolsetId": "team_mgmt" })` → show a short index (topics).
+- `man({ "toolsetId": "team_mgmt", "topics": ["topics"] })` → list topics.
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm"] })` → how to manage `.minds/llm.yaml` (+ templates).
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm", "builtin-defaults"] })` → show builtin providers/models (from defaults).
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })` → how to manage `.minds/mcp.yaml` (+ templates).
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })` → how to manage `.minds/mcp.yaml` (transports, env/headers, tools whitelist/blacklist, naming transforms, hot reload, leasing).
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp", "troubleshooting"] })` → common MCP failure modes and how to recover.
+- `man({ "toolsetId": "team_mgmt", "topics": ["team"] })` → how to manage `.minds/team.yaml` (+ templates).
+- `man({ "toolsetId": "team_mgmt", "topics": ["team", "member-properties"] })` → list supported member fields and meanings.
+- `man({ "toolsetId": "team_mgmt", "topics": ["minds"] })` → how to manage `.minds/team/<id>/*.md` (persona/knowledge/lessons).
+- `man({ "toolsetId": "team_mgmt", "topics": ["priming"] })` → how to manage startup scripts under `.minds/priming/*`.
+- `man({ "toolsetId": "team_mgmt", "topics": ["permissions"] })` → how `read_dirs`/`write_dirs` and deny-lists work.
+- `man({ "toolsetId": "team_mgmt", "topics": ["troubleshooting"] })` → common failure modes and how to recover.
 
 The manual should accept **multiple** `topics` entries (a simple topic “path”); the tool should
 select the most specific match and fall back to the nearest parent when needed.
 
-If UX wants a friendlier label than `team_mgmt_manual`, treat that as presentation-only; the
-canonical tool ID remains `team_mgmt_manual`.
+If UX wants a friendlier label than `man`, treat that as presentation-only; the
+canonical runtime entrypoint remains `man({ "toolsetId": "team_mgmt" })`.
 
 ## Manual Coverage Requirements (legacy coverage)
 
@@ -209,12 +212,12 @@ This keeps the manual accurate when the framework changes, and avoids documentat
 
 Recommended sources by topic:
 
-- `team_mgmt_manual({ "topics": ["llm", "builtin-defaults"] })`
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm", "builtin-defaults"] })`
   - Load from the same installation resource the runtime uses for defaults:
     `dominds/main/llm/defaults.yaml` (via `__dirname` resolution in the backend build output).
   - Prefer reusing `LlmConfig.load()` and formatting its merged view, or adding a helper that returns
     both “defaults-only” and “merged” provider maps.
-- `team_mgmt_manual({ "topics": ["toolsets"] })` (if added)
+- `man({ "toolsetId": "team_mgmt", "topics": ["toolsets"] })` (if added)
   - Load from the in-memory registries at runtime (`listToolsets()` / `listTools()` in
     `dominds/main/tools/registry.ts`), rather than maintaining a separate list.
 

package/dist/docs/team_mgmt-toolset.zh.md

@@ -4,6 +4,9 @@
 
 本文档指定了一个专用的**团队管理工具集**，其唯一职责是管理 rtws（运行时工作区）`.minds/` 下的"心智"配置文件（团队名单、LLM 提供商和智能体心智文件），而不授予广泛的运行时工作区访问权限。
 
+> 历史说明：运行时/手册入口现已统一为
+> `man({ "toolsetId": "team_mgmt" })`，它才是当前权威的团队管理手册入口。
+
 外部仓库根目录是 **rtws**（运行时工作区）。以下所有路径均相对于 rtws 根目录。
 
 ## 动机
@@ -25,14 +28,14 @@
 
 本文档是新的 `team_mgmt` 工具集的**设计规范**。这不是我们应该在运行时让智能体"查阅"的内容。
 
-相反，运行时团队管理的"单一事实来源"应该是函数工具 `team_mgmt_manual` 的输出。
+相反，运行时团队管理的"单一事实来源"应该是 `man({ "toolsetId": "team_mgmt" })` 的输出。
 
-历史上，部分指导内容位于 `dominds/` 源代码树中的传统内置"团队管理者"心智集中。该传统内置内容正在被移除。运行时的"单一事实来源"应该是 `team_mgmt_manual` 工具的输出。
+历史上，部分指导内容位于 `dominds/` 源代码树中的传统内置"团队管理者"心智集中。该传统内置内容正在被移除。运行时的"单一事实来源"应该是 `man({ "toolsetId": "team_mgmt" })` 的输出。
 
 计划变更：
 
-- 添加一个新的函数工具 `team_mgmt_manual`，其响应涵盖团队管理主题（文件格式、工作流、安全性）
-- 移除传统的内置指导以避免重复。如果保留任何存根，必须指向 `team_mgmt_manual`（而不是本文档）
+- 通过通用 `man` 工具的 `man({ "toolsetId": "team_mgmt" })` 入口承载团队管理主题（文件格式、工作流、安全性）
+- 移除传统的内置指导以避免重复。如果保留任何存根，必须指向 `man({ "toolsetId": "team_mgmt" })`（而不是本文档）
 
 理由：
 
@@ -67,7 +70,7 @@
 
 ### 命名约定（人类 / UI）
 
-- **工具**使用 `snake_case`（下划线分隔）作为工具 ID（例如 `team_mgmt_manual`）。避免为工具 ID 使用 `kebab-case` 别名；如果 UX 需要更友好的标签，将其视为仅展示层。
+- **工具**使用 `snake_case`（下划线分隔）作为工具 ID（例如 `team_mgmt_validate_team_cfg`）。避免为工具 ID 使用 `kebab-case` 别名；如果 UX 需要更友好的标签，将其视为仅展示层。
 - **队友**使用 `kebab-case`（连字符分隔）或"互联网名称"（点分隔）。
 - 这只是文档/UI/可读性的约定；不要通过验证或其他技术机制强制执行。
 
@@ -94,7 +97,7 @@
 | `team_mgmt_rm_dir`                     | `fs`  | 删除 `.minds/` 下的目录                                     | `.minds/**`      |
 | `team_mgmt_validate_priming_scripts`   | 新建  | 校验 `.minds/priming/**.md` 的路径约束与脚本格式            | `.minds/**`      |
 | `team_mgmt_validate_team_cfg`          | 新建  | 验证 `.minds/team.yaml` 并将问题发布到问题面板              | `.minds/**`      |
-| `team_mgmt_manual`                     | 新建  | 内置"操作指南"手册（见下文）                                | N/A              |
+| `man({ "toolsetId": "team_mgmt" })`    | 内置  | `team_mgmt` 工具集的手册入口（见下文）                      | N/A              |
 
 注意：
 
@@ -117,29 +120,29 @@
 - 即使成员的目录允许/拒绝列表为空，也保持作用域边界
 - 便于授予临时智能体仅团队管理能力而无需完整的 rtws 访问
 
-## `team_mgmt_manual`
+## 通过 `man({ "toolsetId": "team_mgmt" })` 查看团队手册
 
 我们需要单一的聊天内手册工具，以便团队管理者能够可靠地自助指导，而无需阅读源代码。
 
 ### 命令形状
 
-- `team_mgmt_manual({ "topics": [] })` → 显示简短索引（主题）
-- `team_mgmt_manual({ "topics": ["topics"] })` → 列出主题
-- `team_mgmt_manual({ "topics": ["llm"] })` → 如何管理 `.minds/llm.yaml`（+ 模板）
-- `team_mgmt_manual({ "topics": ["llm", "builtin-defaults"] })` → 显示内置提供商/模型（来自默认值）
-- `team_mgmt_manual({ "topics": ["mcp"] })` → 如何管理 `.minds/mcp.yaml`（+ 模板）
-- `team_mgmt_manual({ "topics": ["mcp"] })` → 如何管理 `.minds/mcp.yaml`（传输、env/headers、工具白名单/黑名单、命名转换、热重载、租赁）
-- `team_mgmt_manual({ "topics": ["mcp", "troubleshooting"] })` → 常见 MCP 故障模式及如何恢复
-- `team_mgmt_manual({ "topics": ["team"] })` → 如何管理 `.minds/team.yaml`（+ 模板）
-- `team_mgmt_manual({ "topics": ["team", "member-properties"] })` → 列出支持的成员字段及其含义
-- `team_mgmt_manual({ "topics": ["minds"] })` → 如何管理 `.minds/team/<id>/*.md`（persona/knowledge/lessons）
-- `team_mgmt_manual({ "topics": ["priming"] })` → 如何管理 `.minds/priming/*` 启动脚本（格式、维护、复用）
-- `team_mgmt_manual({ "topics": ["permissions"] })` → `read_dirs`/`write_dirs` 和拒绝列表如何工作
-- `team_mgmt_manual({ "topics": ["troubleshooting"] })` → 常见故障模式及如何恢复
+- `man({ "toolsetId": "team_mgmt" })` → 显示简短索引（主题）
+- `man({ "toolsetId": "team_mgmt", "topics": ["topics"] })` → 列出主题
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm"] })` → 如何管理 `.minds/llm.yaml`（+ 模板）
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm", "builtin-defaults"] })` → 显示内置提供商/模型（来自默认值）
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })` → 如何管理 `.minds/mcp.yaml`（+ 模板）
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })` → 如何管理 `.minds/mcp.yaml`（传输、env/headers、工具白名单/黑名单、命名转换、热重载、租赁）
+- `man({ "toolsetId": "team_mgmt", "topics": ["mcp", "troubleshooting"] })` → 常见 MCP 故障模式及如何恢复
+- `man({ "toolsetId": "team_mgmt", "topics": ["team"] })` → 如何管理 `.minds/team.yaml`（+ 模板）
+- `man({ "toolsetId": "team_mgmt", "topics": ["team", "member-properties"] })` → 列出支持的成员字段及其含义
+- `man({ "toolsetId": "team_mgmt", "topics": ["minds"] })` → 如何管理 `.minds/team/<id>/*.md`（persona/knowledge/lessons）
+- `man({ "toolsetId": "team_mgmt", "topics": ["priming"] })` → 如何管理 `.minds/priming/*` 启动脚本（格式、维护、复用）
+- `man({ "toolsetId": "team_mgmt", "topics": ["permissions"] })` → `read_dirs`/`write_dirs` 和拒绝列表如何工作
+- `man({ "toolsetId": "team_mgmt", "topics": ["troubleshooting"] })` → 常见故障模式及如何恢复
 
 该手册应接受**多个**`topics` 条目（简单的主题"路径"）；工具应选择最具体的匹配，并在需要时回退到最近的父主题。
 
-如果 UX 需要比 `team_mgmt_manual` 更友好的标签，将其视为仅展示层；规范的工具 ID 保持为 `team_mgmt_manual`。
+如果 UX 需要比 `man` 更友好的标签，将其视为仅展示层；规范的运行时入口保持为 `man({ "toolsetId": "team_mgmt" })`。
 
 ## 手册覆盖要求（传统覆盖）
 
@@ -172,10 +175,10 @@
 
 按主题推荐的来源：
 
-- `team_mgmt_manual({ "topics": ["llm", "builtin-defaults"] })`
+- `man({ "toolsetId": "team_mgmt", "topics": ["llm", "builtin-defaults"] })`
   - 从运行时用于默认值的同一安装资源加载：`dominds/main/llm/defaults.yaml`（通过后端构建输出中的 `__dirname` 解析）
   - 优先重用 `LlmConfig.load()` 并格式化其合并视图，或添加一个返回"仅默认值"和"合并"提供商映射的助手
-- `team_mgmt_manual({ "topics": ["toolsets"] })`（如果添加）
+- `man({ "toolsetId": "team_mgmt", "topics": ["toolsets"] })`（如果添加）
   - 在运行时从内存中注册表加载（`dominds/main/tools/registry.ts` 中的 `listToolsets()` / `listTools()`），而不是维护单独的列表
 
 将这些保持为**静态/手册文本**（而非动态加载）：

package/dist/llm/gen/mock.d.ts

@@ -64,6 +64,8 @@ export declare class MockGen implements LlmGenerator {
     private loadResponseDatabase;
     private responseMatchesContext;
     private normalizeFuncCallArgs;
+    private extractLastAssistantSaying;
+    private buildReplyToolReminderAutoResponse;
     /**
      * Find matching response using EXACT last message only.
      * NO fallback to message-only matching - if exact match fails, return null.

package/dist/llm/gen/mock.js

@@ -63,6 +63,10 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const log_1 = require("../../log");
+const REPLY_TOOL_REMINDER_PREFIXES = [
+    '[Dominds replyTellask required]',
+    '[Dominds 必须调用回复工具]',
+];
 function normalizeDelayMs(value) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return 0;
@@ -251,6 +255,44 @@ class MockGen {
         }
         return JSON.stringify(args);
     }
+    extractLastAssistantSaying(context) {
+        for (let i = context.length - 1; i >= 0; i -= 1) {
+            const msg = context[i];
+            if (msg?.type !== 'saying_msg') {
+                continue;
+            }
+            const trimmed = msg.content.trim();
+            if (trimmed !== '') {
+                return trimmed;
+            }
+        }
+        return null;
+    }
+    buildReplyToolReminderAutoResponse(input, role, context) {
+        if (role !== 'user' ||
+            !REPLY_TOOL_REMINDER_PREFIXES.some((prefix) => input.startsWith(prefix))) {
+            return null;
+        }
+        const toolMatch = input.match(/`(replyTellask(?:Sessionless|Back)?)`/);
+        if (!toolMatch) {
+            return null;
+        }
+        const replyContent = this.extractLastAssistantSaying(context);
+        if (!replyContent) {
+            return null;
+        }
+        return {
+            message: input,
+            role,
+            response: '',
+            funcCalls: [
+                {
+                    name: toolMatch[1],
+                    arguments: { replyContent },
+                },
+            ],
+        };
+    }
     /**
      * Find matching response using EXACT last message only.
      * NO fallback to message-only matching - if exact match fails, return null.
@@ -300,7 +342,8 @@ responses:
             throw new Error('AbortError');
         }
         const db = await this.loadResponseDatabase(dbPath, modelName);
-        const matched = this.findMatchingResponse(db, content, role, context);
+        const matched = this.findMatchingResponse(db, content, role, context) ??
+            this.buildReplyToolReminderAutoResponse(content, role, context);
         await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
         await receiver.thinkingStart();
         await receiver.thinkingChunk(`[${modelName}] `);
@@ -358,19 +401,21 @@ responses:
                 totalTokens: promptTokens + completionTokens,
             };
         }
-        await receiver.sayingStart();
-        const chunkDelayMs = normalizeDelayMs(matched?.chunkDelayMs ?? 0);
-        const words = responseText.split(/(\s+)/);
-        for (const word of words) {
-            if (abortSignal?.aborted) {
-                throw new Error('AbortError');
-            }
-            await receiver.sayingChunk(word);
-            if (chunkDelayMs > 0) {
-                await delayWithAbort(chunkDelayMs, abortSignal);
+        if (responseText !== '') {
+            await receiver.sayingStart();
+            const chunkDelayMs = normalizeDelayMs(matched?.chunkDelayMs ?? 0);
+            const words = responseText.split(/(\s+)/);
+            for (const word of words) {
+                if (abortSignal?.aborted) {
+                    throw new Error('AbortError');
+                }
+                await receiver.sayingChunk(word);
+                if (chunkDelayMs > 0) {
+                    await delayWithAbort(chunkDelayMs, abortSignal);
+                }
             }
+            await receiver.sayingFinish();
         }
-        await receiver.sayingFinish();
         const funcCalls = matched?.funcCalls ?? [];
         for (let i = 0; i < funcCalls.length; i++) {
             const call = funcCalls[i];
@@ -396,7 +441,8 @@ responses:
         const { content, role } = this.resolveInputForMatching(context);
         try {
             const db = await this.loadResponseDatabase(dbPath, modelName);
-            const matched = this.findMatchingResponse(db, content, role, context);
+            const matched = this.findMatchingResponse(db, content, role, context) ??
+                this.buildReplyToolReminderAutoResponse(content, role, context);
             await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
             const responseText = matched?.response ?? this.makeFallbackResponse(dbPath, content, role, modelName);
             const thinking = {
@@ -405,12 +451,16 @@ responses:
                 genseq,
                 content: `[${modelName}] ${content.substring(0, 100)}`,
             };
-            const saying = {
-                type: 'saying_msg',
-                role: 'assistant',
-                genseq,
-                content: matched?.streamError ? `❌ Mock Error: ${matched.streamError}` : responseText,
-            };
+            const saying = matched?.streamError || responseText !== ''
+                ? {
+                    type: 'saying_msg',
+                    role: 'assistant',
+                    genseq,
+                    content: matched?.streamError
+                        ? `❌ Mock Error: ${matched.streamError}`
+                        : responseText,
+                }
+                : undefined;
             let usage = { kind: 'unavailable' };
             if (matched && matched.usageUnavailable === true) {
                 usage = { kind: 'unavailable' };
@@ -474,7 +524,11 @@ responses:
                     arguments: this.normalizeFuncCallArgs(call.arguments),
                 };
             }) ?? [];
-            return { messages: [thinking, saying, ...funcMsgs], usage, llmGenModel: modelName };
+            return {
+                messages: saying ? [thinking, saying, ...funcMsgs] : [thinking, ...funcMsgs],
+                usage,
+                llmGenModel: modelName,
+            };
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);