dominds 0.8.3 → 0.8.5

package/dist/dialog.js

@@ -519,6 +519,7 @@ class Dialog {
             msgId: options.msgId,
             grammar: options.grammar,
             userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
+            q4hAnswerCallIds: options.q4hAnswerCallIds,
         };
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
     }
@@ -670,8 +671,8 @@ class Dialog {
     async updateQuestions4Human(questions) {
         return await this.dlgStore.updateQuestions4Human(this, questions);
     }
-    async persistUserMessage(content, msgId, grammar, userLanguageCode) {
-        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, userLanguageCode);
+    async persistUserMessage(content, msgId, grammar, userLanguageCode, q4hAnswerCallIds) {
+        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, userLanguageCode, q4hAnswerCallIds);
     }
     async persistAgentMessage(content, genseq, type, provider_data) {
         return await this.dlgStore.persistAgentMessage(this, content, genseq, type, provider_data);
@@ -1047,7 +1048,7 @@ class DialogStore {
     /**
      * Persist a user message to storage
      */
-    async persistUserMessage(_dialog, _content, _msgId, _grammar, _userLanguageCode) { }
+    async persistUserMessage(_dialog, _content, _msgId, _grammar, _userLanguageCode, _q4hAnswerCallIds) { }
     /**
      * Persist an assistant message to storage
      */

package/dist/docs/keep-going.zh.md

@@ -0,0 +1,162 @@
+# Keep-Going（鞭策）— 设计文档
+
+## 概述
+
+Dominds 根对话旨在长期运行。根对话"停止"（变为空闲）通常不是操作员想要的：他们希望智能体持续推进，直到：
+
+- 合法地暂停等待人类决策（Q4H），或
+- 合法地暂停等待子对话（tellask/backfill）。
+
+本文档指定了一个运行时机制（"keep-going"），仅针对**根/主对话**，防止对话停止：每当驱动程序即将停止时，它会自动发送一个简短的鞭策语（渲染为正常的用户气泡）并继续生成，除非对话处于合法暂停状态（Q4H 或待处理的子对话）。
+
+## 目标
+
+- 防止根对话停止，除非处于合法暂停状态（Q4H / 子对话）。
+- 保持行为可预测和有界（无无限循环）。
+- 使鞭策语文本可按工作区（rtws）和语言配置。
+- 提供清晰的用户控制的"禁用"机制。
+
+## 非目标
+
+- 自动完成/自动将对话标记为完成。
+- 将此行为应用于子对话（子对话保持范围，应向其调用者报告）。
+
+## 定义
+
+- **根/主对话**：`RootDialog`（`dlg.id.rootId === dlg.id.selfId`），主要对话线程。
+- **子对话**：`SubDialog`，为 tellask / 作用域工作创建。
+- **Q4H**："Questions for Human"，通过 `!?@human` 发起，暂停对话进度直到人类响应。
+
+## 预期的"正常"完成路径（推荐）
+
+当智能体需要人类决策来结束时（例如，确认选择或决定是否将对话标记为完成），正确的路径是：
+
+1. 智能体发出 Q4H（`!?@human`）并提供必要的上下文和明确的决策请求。
+2. WebUI 清楚地呈现 Q4H。
+3. 人类决定并：
+   - 手动将根对话标记为"完成"，或
+   - 提供请求的信息以便对话继续。
+
+这是"受控收敛"路径。keep-going 机制不应覆盖合法的暂停状态。
+
+## Keep-Going 行为（"自动继续"回退）
+
+### 触发条件（必须全部满足）
+
+- 对话是**根/主对话**（绝不会是子对话）。
+- 对话**未暂停**：
+  - 没有待处理的 Q4H，并且
+  - 没有待处理的子对话（等待回填）。
+- 驱动程序即将停止生成循环（即没有工具/函数输出需要另一次迭代）。
+
+### 操作
+
+运行时自动发送一个鞭策语（渲染为正常的用户气泡）并运行另一次生成迭代。
+
+### 有界性
+
+为避免无限循环，keep-going 有一个按对话的预算（每个成员的 `diligence-push-max`），控制对于给定对话在运行时强制 Q4H 暂停之前可以注入多少个自动继续的鞭策语。
+
+- 默认值：**3**
+- 如果 `< 1`，则该成员的 keep-going 有效禁用
+- 可通过 `.minds/team.yaml` 中的 `diligence-push-max` 按成员配置
+
+### Q4H 时重置
+
+当对话因待处理的 Q4H（Questions for Human）而暂停时，keep-going 注入计数器会被重置。这确保在人类回答 Q4H 并恢复对话后，对话会获得新的 keep-going 预算。
+
+### 预算耗尽 → 强制 Q4H
+
+当 keep-going 预算耗尽时，运行时会创建一个 Q4H 条目，询问人类是否继续或停止。这将"有界性"转换为合法的暂停点，并避免无限自动继续循环。
+
+### 禁用开关
+
+可以通过以下任一方式按 rtws 禁用 keep-going：
+
+- 如果选中的鞭策语文件存在但其内容为空/仅空白，则禁用 keep-going（不注入）。
+
+可以通过以下任一方式按成员禁用 keep-going：
+
+- 如果 `diligence-push-max < 1`，则该成员的 keep-going 被禁用（不注入）。
+
+## 鞭策语解析
+
+让 `<rtws>` 为当前运行时工作区（即 `process.cwd()`）。
+
+解析顺序：
+
+1. `<rtws>/.minds/diligence.<work-lang-id>.md`（例如，`diligence.zh.md`）
+2. `<rtws>/.minds/diligence.md`（语言无关的回退）
+3. 内置回退文本（硬编码的 i18n；`zh` 是规范的并嵌入在源代码中）
+
+如果上述顺序中第一个存在的文件具有空/空白内容，则**禁用** keep-going。
+
+注意：鞭策语文件中的 YAML frontmatter 会被运行时忽略。如果存在，它被视为非内容元数据并从提示正文中剥离。
+
+### 团队成员上限：`diligence-push-max`
+
+每个团队成员可以选择通过 `.minds/team.yaml` 限制 keep-going：
+
+```yaml
+members:
+  alice:
+    diligence-push-max: 10
+```
+
+规则：
+
+- 如果缺失，`diligence-push-max` 对于该成员默认为 **3**。
+- 如果 `diligence-push-max < 1`，则该成员的 keep-going 被禁用（不注入），即使鞭策语文件存在。
+- 内置影子成员 `fuxi` 和 `pangu` 默认为 `diligence-push-max: 0`，除非在 team.yaml 中显式覆盖。
+
+## UX 备注
+
+- Keep-going 是一个仅运行时的提示，但它应该是**可见的**：鞭策语渲染为正常的用户消息气泡（由运行时自动发送），以便操作员理解为什么会出现额外的迭代。
+- 用户应该观察到智能体在仅工具操作后继续简短的跟进。
+- 当智能体真正需要用户干预时，它应该使用 Q4H。Keep-going 不应试图"假装"完成。
+
+## 实现（后端）
+
+### 位置
+
+在 LLM 驱动程序循环中实现（`dominds/main/llm/driver.ts`），作为迭代后的小检查：
+
+1. 如果 `suspendForHuman` 为 true，则停止（Q4H / 子对话待处理）。
+2. 如果有任何工具反馈，则正常继续。
+3. 否则（仅限根），尝试 keep-going 自动继续：
+   - 如果禁用 → 正常停止。
+   - 如果预算耗尽 → 创建 Q4H 并停止。
+   - 否则 → 自动发送鞭策语并继续。
+
+### 消息类型
+
+我们将鞭策语作为自动发送的用户消息注入：
+
+- 类型为 `prompting_msg`、角色为 `'user'` 的 `ChatMessage`
+
+这确保了：
+
+- 它存在于模型上下文中
+- 它作为人类消息记录持久化
+- 它在聊天时间线中渲染为正常的用户气泡（像任何其他用户消息一样）
+
+## 可观察性
+
+建议的后续步骤（初始实现不需要）：
+
+- 当触发 keep-going 时添加结构化日志行，包括：
+  - 对话 id
+  - 语言
+  - 使用的鞭策语来源（语言特定/通用/内置/禁用）
+- 为"keep-going 触发"和"keep-going 因空文件禁用"添加可选的指标计数器。
+
+## 测试
+
+回归测试应覆盖：
+
+- 根对话：仅工具输出 → 鞭策语注入 → 继续响应
+- 根对话：空助手输出 → 鞭策语注入 → 继续响应
+- 子对话：无鞭策语注入
+- 工作区配置：
+  - 当语言特定文件缺失时，`.minds/diligence.md` 被遵守
+  - 空的鞭策语文件禁用 keep-going

package/dist/docs/showing-by-doing.md

@@ -0,0 +1,208 @@
+# Showing-by-Doing (做给祂看): Make Tellask Real
+
+Chinese version: [中文版](./showing-by-doing.zh.md)
+
+## Summary
+
+Dominds has a real, runtime-enforced Tellask mechanism (`!?@...`) and a real, runtime-enforced Fresh Boots Reasoning
+(FBR) mechanism (`!?@self`). Even if system prompts explain these mechanisms in detail, most foundation models were not
+trained in a world where “asking a teammate to run a shell command” is actually possible, so they often treat such text
+as aspirational or hypothetical.
+
+**Showing-by-Doing (做给祂看)** is a tiny, highly realistic “first impression” procedure executed at dialog creation
+time. It runs a short, real Tellask + real FBR round-trip so the model gains _felt-sense_ that:
+
+- teammate Tellasks are real and will be executed
+- tool outputs are real and will be returned
+- FBR is real and will produce a report back to the caller
+
+This makes subsequent use of Tellasks and `!?@self` FBR more reliable across the entire dialog lifecycle.
+
+As a consequence, we can **dramatically simplify system prompts**: keep only short, accurate statements of the Tellask/FBR
+contracts, and rely on Showing-by-Doing to establish “this is real and works here”.
+
+Related docs:
+
+- Tellask runtime: `dominds/docs/dialog-system.md`
+- Terminology (Mainline/Sideline): `dominds/docs/dominds-terminology.md`
+- FBR (`!?@self`): `dominds/docs/fbr.md`
+- Work language vs UI language: `dominds/docs/i18n.md`
+
+---
+
+## Goals
+
+- Establish immediate trust that **Tellask is not “just prompt text”**: it is an executable, backend-driven mechanism.
+- Establish immediate trust that **FBR is not “just reasoning”**: it is a concrete sideline dialog that reports back.
+- Keep the procedure safe, small, and deterministic (default command: `uname -a`).
+- Persist and display the interaction so it is credible from multiple angles (backend record + frontend transcript).
+
+## Non-goals
+
+- Running arbitrary user-provided commands as part of dialog creation.
+- Collecting sensitive system information (beyond minimal OS/kernel identification).
+- Replacing proper documentation: this is an experiential supplement, not the main spec.
+
+---
+
+## Definitions (user-facing)
+
+- **Mainline dialog**: the primary thread where the user and the main agent interact.
+- **Sideline dialog**: a temporary work thread created by Tellask / FBR, reporting results back to the mainline.
+- **Tellask**: a structured request (`!?@<memberId> ...`) from a tellasker to a tellaskee.
+- **Shell specialist**: a teammate designated to run shell commands safely (configured via `shell_specialists`).
+- **FBR**: Fresh Boots Reasoning, implemented as `!?@self` (a tool-less sideline dialog). See `dominds/docs/fbr.md`.
+
+---
+
+## Runtime flow (at dialog creation)
+
+Showing-by-Doing runs **before** the first user message is processed (a “prelude”), unless the user opts out.
+
+### 1) Choose the shell execution path
+
+1. If the team config includes at least one `shell_specialists` member, pick one deterministically (e.g. the first).
+2. Otherwise, let the **Dominds runtime** execute the baseline command directly (not via agent tools).
+
+Note: team config validation normally requires `shell_specialists` to be non-empty if any teammate has shell tools, and
+also requires that only listed shell specialists have shell tools. In other words, “no `shell_specialists` configured”
+usually means “shell tools are disabled for all user-facing teammates”.
+
+Baseline command:
+
+- `uname -a`
+
+If `uname -a` fails (e.g. non-POSIX host), the runtime should fall back to a platform-appropriate equivalent, but the
+default “muscle memory” path is intentionally `uname -a` because it is common, low-risk, and quick.
+
+### 2) Real teammate Tellask: ask for `uname -a`
+
+If a shell specialist exists, the main agent (tellasker) issues **a real Tellask** to the shell specialist (tellaskee),
+in the server-wide **work language** (see `dominds/docs/i18n.md`).
+
+The Tellask body should be short and operational:
+
+- ask the shell specialist to run `uname -a`
+- ask them to return the raw output verbatim
+- ask them to include an error + alternative command if `uname` is not available
+
+The result must be recorded as a normal, debuggable transcript that clearly shows:
+
+- the Tellask headline + body
+- the shell specialist’s command execution
+- the returned output
+
+Minimal configuration example:
+
+```yaml
+# .minds/team.yaml
+shell_specialists:
+  - cmdr
+```
+
+### 3) Real FBR: reflect on what the environment implies
+
+After obtaining the environment snapshot (from the shell specialist or direct tool run), the main agent issues a real
+`!?@self` Tellask to trigger **FBR**.
+
+The FBR Tellask body should include:
+
+- the exact `uname -a` output
+- the main agent’s tool availability assumptions (e.g. “in mainline I may have `fs`/`os`/`mem`; in FBR you have no tools”)
+- the question: “What should I be careful about in this environment? Which CLI tools should I prioritize, and why?”
+
+The FBR response should return a compact report that the main agent can reuse, typically:
+
+- environment notes (OS family, kernel, container/VM hints if any)
+- do/don’t list (pitfalls)
+- a short “preferred commands” shortlist (e.g. `rg`, `sed`, `jq`, `tar`, `ps`, `lsof`, depending on host)
+
+### 4) Summarize into an “Environment Quickstart” note
+
+The main agent then writes a short, user-visible summary to the mainline dialog so the knowledge is explicit and
+searchable in the transcript.
+
+---
+
+## Fallback behavior
+
+Showing-by-Doing should degrade gracefully:
+
+- **No `shell_specialists` configured**: the Dominds runtime runs `uname -a` directly, then do FBR.
+- **Shell specialist fails or times out**: the Dominds runtime runs `uname -a` directly and continue, marking the
+  specialist attempt as failed in the transcript.
+- **`uname` not available / command fails**: run FBR with “environment unknown”; the report should explicitly list what
+  is missing and suggest what to gather later.
+
+---
+
+## Persistence, caching, and reuse
+
+### 1) Persist as real dialog records (backend + frontend)
+
+All Showing-by-Doing steps must be persisted as standard dialog artifacts (messages + events) so they remain credible:
+
+- they survive restarts (subject to normal dialog persistence rules)
+- they are debuggable in logs/storage
+- they are rendered in the WebUI transcript (ideally as a collapsible “Prelude” section)
+
+### 2) Process-wide cache (per teammate)
+
+To avoid repeating `uname -a` + FBR on every new dialog, the backend process may maintain a **server-scoped cache** keyed
+by (at minimum):
+
+- tellasker teammate id (the agent whose dialogs are being created)
+- an environment fingerprint derived from the `uname -a` output (exact string or hashed)
+
+Cache payload (recommended):
+
+- the full Showing-by-Doing transcript (Tellask + output + FBR + summary)
+- a short “Environment Quickstart” distilled form (for compact context injection)
+- timestamps + a version tag for future schema changes
+
+Reuse policy:
+
+- If a valid cache entry exists, a new dialog may **reuse** the cached transcript instead of re-running.
+- Reused entries should still be visible in the new dialog’s transcript, clearly labeled as “Reused from cache”.
+
+Invalidation (recommended):
+
+- invalidate when the environment fingerprint changes
+- allow a manual “Refresh environment snapshot” action for debugging
+
+### 3) Carry across `clear_mind`
+
+After each `clear_mind` (entering the next “journey stage”), do **not** rely on reminders for this.
+
+Instead, inject a small, stable **course prefix** into the model context at the start of each new course (i.e. the first
+few messages in the historical dialog section). This prefix should be a condensed transcript distilled from the original
+Showing-by-Doing run (shell snapshot + FBR highlights + quickstart), so the agent keeps its “felt-sense” of Tellask/FBR
+and environment constraints without re-running the prelude.
+
+---
+
+## UX requirements (WebUI)
+
+### Display
+
+- Render Showing-by-Doing as a realistic transcript the user can inspect.
+- Prefer a collapsible “Prelude” section at the top of the dialog, with clear labels:
+  - “Teammate Tellask (shell)”
+  - “FBR (`!?@self`)”
+  - “Environment Quickstart”
+
+### Opt-out
+
+The dialog creation UI should include an explicit opt-out, e.g.:
+
+- Checkbox: “Skip Showing-by-Doing (do not run environment prelude)”
+
+If opted out, no prelude actions are executed and no prelude transcript is generated.
+
+---
+
+## Safety notes
+
+- Default to a single, low-risk command (`uname -a`).
+- Do not run anything that modifies the filesystem or network as part of this prelude.
+- Treat the prelude transcript as user-visible by default; avoid including secrets or personally identifying details.

package/dist/docs/showing-by-doing.zh.md

@@ -0,0 +1,177 @@
+# 做给祂看（Showing-by-Doing）：把诉请机制变成“体感”
+
+英文版：[English](./showing-by-doing.md)
+
+## 摘要
+
+Dominds 的诉请（Tellask，`!?@...`）与扪心自问（FBR，`!?@self`）并不是“写在系统提示里的约定”，而是**后端真实可驱动、可执行、可回传、可持久化**的机制。
+
+问题在于：即使系统提示把诉请机制写得再细，大多数基础模型也并未在“真的可以随时拉一个队友去跑 shell 命令并把结果带回来”的世界里被训练过，因此容易把这些提示当成“说说而已 / 仅供参考”。这会直接削弱诉请与 FBR 的可用性。
+
+因此引入 **“做给祂看”**：在一个对话创建之初，运行一段极短、极拟真的“真实诉请 + 真实 FBR”往返，让智能体产生明确的体感：
+
+- 诉请是真的，会被执行
+- 工具输出是真的，会被带回并写入对话记录
+- `!?@self` FBR 也是真的，会作为支线对话产出报告并回传
+
+体感建立后，系统提示可以**大幅简化**：只保留“短而准确”的契约说明即可，把“这在本环境里真实可用”的可信度交给做给祂看来完成。
+
+相关文档：
+
+- 诉请机制与子对话：`dominds/docs/dialog-system.md`
+- 术语约定（主线/支线；诉请方/应答方）：`dominds/docs/dominds-terminology.md`
+- FBR（`!?@self`）：`dominds/docs/fbr.md`
+- 工作语言 vs UI 语言：`dominds/docs/i18n.md`
+
+---
+
+## 目标
+
+- 在对话一开始就建立“诉请/回传/持久化都是真的”的信任。
+- 在对话一开始就跑通一次 `!?@self` 的 FBR 回路。
+- 过程足够小、可控、低风险（默认只执行 `uname -a`）。
+- 记录从多角度都高度拟真：后端存档 + 前端可见的对话转录。
+
+## 非目标
+
+- 不在创建对话时执行任意用户输入的命令。
+- 不收集敏感信息（默认只采集最小的 OS/Kernel 识别信息）。
+- 不替代系统提示/设计文档：这是“体感补强”，不是完整规范的主载体。
+
+---
+
+## 概念（用户视角）
+
+- **主线对话**：用户与主要智能体交互的那条线。
+- **支线对话**：由诉请 / FBR 触发的临时工作线，产出结果回传主线。
+- **诉请（Tellask）**：以 `!?@<memberId> ...` 向队友/对话发起的结构化请求。
+- **Shell 专家（shell specialist）**：被允许执行 shell 命令并回传结果的队友（由 `shell_specialists` 配置指定）。
+- **FBR（扪心自问）**：以 `!?@self` 触发的“无工具支线推理”，产出报告回传主线。
+
+---
+
+## 运行流程（对话创建时）
+
+做给祂看发生在**第一条用户消息被处理之前**（可视为一个 Prelude / 序幕），除非用户在创建对话时明确选择跳过。
+
+### 1）选择执行路径
+
+1. 如果 team 配置里存在 `shell_specialists`，选择一个 shell 专员（建议确定性选择：列表第一个）。
+2. 否则，由 **Dominds 运行时**直接执行基线命令（不通过智能体工具）。
+
+补充：team 配置校验一般会要求——只要有队友拥有 shell 工具，就必须配置非空的 `shell_specialists`；同时，非 shell 专员不应持有 shell 工具。因此“没有配置 `shell_specialists`”通常意味着“对用户可见的队友都没有 shell 工具可用”。
+
+基线命令（默认）：
+
+- `uname -a`
+
+`uname -a` 失败时（例如非 POSIX 环境），可以改用平台等价命令；但默认肌肉记忆路径保留 `uname -a`，因为它低风险、快、且信息量刚好够用。
+
+### 2）真实队友诉请：让 shell 专员执行 `uname -a`
+
+若存在 shell 专员，则主线智能体（诉请方）以**工作语言**（server-wide，见 `dominds/docs/i18n.md`）向 shell 专员（应答方）发起真实诉请，要求：
+
+- 执行 `uname -a`
+- 原样返回输出
+- 若命令不可用，返回错误信息，并给出替代命令建议
+
+结果必须以正常对话转录的方式落盘并展示，至少清晰体现：
+
+- 诉请的 headline + body
+- shell 专员实际执行了命令
+- 返回的原始输出
+
+最小配置示例：
+
+```yaml
+# .minds/team.yaml
+shell_specialists:
+  - cmdr
+```
+
+### 3）真实 FBR：基于环境信息做一次“扪心自问”
+
+拿到环境快照（来自 shell 专员或直接运行）后，主线智能体触发一次 `!?@self` FBR，并在 FBR 的诉请正文里带上：
+
+- `uname -a` 的完整输出
+- 主线可用工具的假设（例如“主线可能有 `fs`/`os`/`mem`；但 FBR 你没有任何工具”）
+- 问题：在这个环境里要注意什么？优先用哪些命令行工具，为什么？
+
+FBR 产出应尽量短而可复用，典型包括：
+
+- 环境判断（OS 家族、内核、是否容器/VM 线索）
+- 注意事项（坑点清单）
+- “优先工具/命令” shortlist（例如 `rg`、`sed`、`jq`、`tar`、`ps`、`lsof` 等，视环境而定）
+
+### 4）把结果收敛成“环境速记”
+
+主线智能体在主线对话里追加一条短总结（Environment Quickstart），让关键信息显性化、可检索。
+
+---
+
+## 降级策略
+
+- **未配置 `shell_specialists`**：由 Dominds 运行时直接执行 `uname -a`，然后进入 FBR。
+- **shell 专员失败/超时**：记录失败原因，由 Dominds 运行时直接执行 `uname -a`，继续进入 FBR。
+- **`uname` 不存在/执行失败**：跳过命令执行，直接让 FBR 以“环境未知”输出：缺什么信息、为什么关键、后续如何补齐。
+
+---
+
+## 持久化、缓存与复用
+
+### 1）记录必须“像真的一样”
+
+做给祂看的每一步都必须作为标准对话记录落盘（消息 + 事件），并在 WebUI 中可见：
+
+- 可跨重启（遵循常规对话持久化）
+- 可 debug（日志/存储都有迹可循）
+- 前端可查看转录（建议 UI 上做一个可折叠 Prelude 区域）
+
+### 2）仅进程内缓存（按智能体维度）
+
+为了避免每次新对话都重复跑 `uname -a` + FBR，后端进程可以维护一个**进程内缓存**（重启失效），按（至少）主线智能体 id 做 key。
+
+缓存内容建议包含：
+
+- 完整转录（诉请 + shell 输出 + FBR + 速记）
+- 一份更短的 distilled “环境速记”（用于注入上下文）
+- 时间戳 + 版本号（未来 schema 变化用）
+
+复用策略：
+
+- 若命中缓存，新对话可以直接复用首次的转录与速记，不再重复执行。
+- 复用的记录在新对话里仍应可见，并清楚标记“来自缓存复用”。
+
+### 3）跨 `clear_mind` 携带
+
+每次 `clear_mind` 进入下一程时，不要依赖 reminder 来承载这件事。
+
+改为：在每一程对话的上下文里，注入一段小而稳定的 **course prefix**（可理解为“历史消息区最开头的几条 msg”），内容是从首次做给祂看中提炼出的压缩转录（shell 快照 + FBR 摘要 + 环境速记）。这样智能体能持续保留“体感”和环境约束，而无需重复执行 Prelude，也不必每次把整段长转录重新塞进上下文。
+
+---
+
+## WebUI 需求
+
+### 展示
+
+- 做给祂看应以真实对话转录展示，用户可展开查看细节。
+- 建议在对话顶部提供一个可折叠 Prelude 区域，并带上清晰标签：
+  - “队友诉请（shell）”
+  - “FBR（`!?@self`）”
+  - “环境速记（Environment Quickstart）”
+
+### 创建对话时可选择跳过（opt-out）
+
+创建对话框上提供明确开关，例如：
+
+- Checkbox：“跳过做给祂看（不执行环境序幕）”
+
+若选择跳过，则不执行任何 Prelude 行为，也不生成 Prelude 转录。
+
+---
+
+## 安全注意事项
+
+- 默认只执行 `uname -a`（低风险、只读、快）。
+- Prelude 禁止任何会改写文件/网络/系统状态的操作。
+- 由于 Prelude 默认用户可见，严禁输出密钥/敏感信息。

package/dist/llm/defaults.yaml

@@ -121,6 +121,12 @@ providers:
           max: 1
           description: Fully supported. Nucleus sampling parameter.
     models:
+      MiniMax-M2.5:
+        name: MiniMax M2.5
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.1:
         name: MiniMax M2.1
         context_length: 204800
@@ -159,6 +165,12 @@ providers:
           max: 1
           description: Fully supported. Nucleus sampling parameter.
     models:
+      MiniMax-M2.5:
+        name: MiniMax M2.5
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.1:
         name: MiniMax M2.1
         context_length: 204800
@@ -197,6 +209,12 @@ providers:
           max: 1
           description: Fully supported. Nucleus sampling parameter.
     models:
+      MiniMax-M2.5:
+        name: MiniMax M2.5
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.1:
         name: MiniMax M2.1
         context_length: 204800
@@ -235,6 +253,12 @@ providers:
           max: 1
           description: Fully supported. Nucleus sampling parameter.
     models:
+      MiniMax-M2.5:
+        name: MiniMax M2.5
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.1:
         name: MiniMax M2.1
         context_length: 204800

package/dist/llm/driver-v2/core.js

@@ -58,6 +58,7 @@ function resolveUpNextPrompt(dlg) {
         msgId: upNext.msgId,
         grammar: upNext.grammar ?? 'markdown',
         userLanguageCode: upNext.userLanguageCode,
+        q4hAnswerCallIds: upNext.q4hAnswerCallIds,
     };
 }
 function isUserOriginPrompt(prompt) {
@@ -66,6 +67,20 @@ function isUserOriginPrompt(prompt) {
     }
     return (prompt.origin ?? 'user') === 'user';
 }
+function normalizeQ4HAnswerCallIds(raw) {
+    if (!raw || raw.length === 0)
+        return undefined;
+    const seen = new Set();
+    const normalized = [];
+    for (const value of raw) {
+        const callId = value.trim();
+        if (callId === '' || seen.has(callId))
+            continue;
+        seen.add(callId);
+        normalized.push(callId);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
 async function emitUserMarkdown(dlg, content) {
     if (!content.trim()) {
         return;
@@ -860,6 +875,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     const msgId = currentPrompt.msgId;
                     const promptGrammar = currentPrompt.grammar;
                     const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
+                    const q4hAnswerCallIds = normalizeQ4HAnswerCallIds(currentPrompt.q4hAnswerCallIds);
                     const requestedPersistMode = currentPrompt.persistMode ?? 'persist';
                     const persistMode = isDiligencePrompt ? 'persist' : requestedPersistMode;
                     if (persistMode === 'internal') {
@@ -881,7 +897,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                             msgId,
                             grammar: promptGrammar,
                         });
-                        await dlg.persistUserMessage(promptContent, msgId, promptGrammar, persistedUserLanguageCode);
+                        await dlg.persistUserMessage(promptContent, msgId, promptGrammar, persistedUserLanguageCode, q4hAnswerCallIds);
                         if (currentPrompt.subdialogReplyTarget) {
                             const normalizedCallId = currentPrompt.subdialogReplyTarget.callId.trim();
                             if (normalizedCallId === '') {
@@ -918,6 +934,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                                 content: promptContent,
                                 grammar: promptGrammar,
                                 userLanguageCode: persistedUserLanguageCode,
+                                q4hAnswerCallIds,
                             });
                         }
                         catch (err) {

package/dist/llm/driver-v2/round.js

@@ -61,6 +61,7 @@ function resolveEffectivePrompt(dialog, humanPrompt) {
         userLanguageCode: upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
             ? upNext.userLanguageCode
             : undefined,
+        q4hAnswerCallIds: upNext.q4hAnswerCallIds,
     };
 }
 async function executeDriveRound(args) {