dominds 1.8.10 → 1.8.11

package/dist/apps/run-control.d.ts

@@ -1,4 +1,5 @@
-import type { DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
+import type { DomindsAppRunControlBlock, DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
+export declare function renderAppRunControlBlockForPreDrive(block: DomindsAppRunControlBlock): string;
 export declare function applyAppDialogRunControl(params: {
     controlId: string;
     payload: DomindsAppRunControlContext;

package/dist/apps/run-control.js

@@ -1,11 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAppRunControlBlockForPreDrive = renderAppRunControlBlockForPreDrive;
 exports.applyAppDialogRunControl = applyAppDialogRunControl;
 exports.applyRegisteredAppDialogRunControls = applyRegisteredAppDialogRunControls;
 const log_1 = require("../log");
 const dialog_run_controls_1 = require("./dialog-run-controls");
 const runtime_1 = require("./runtime");
 const log = (0, log_1.createLogger)('apps-run-control');
+function formatOwnerRef(block) {
+    const owner = block.owner;
+    if (owner.kind === 'human')
+        return 'the human approver';
+    return owner.memberId;
+}
+function formatTargetRef(block) {
+    return block.targetRef.title ?? block.targetRef.id;
+}
+function canProjectAwaitAppAction(block) {
+    if (block.actionClass === 'select') {
+        return Array.isArray(block.optionsSummary) && block.optionsSummary.length > 0;
+    }
+    return true;
+}
+function projectAppActionLabel(block) {
+    if (block.actionClass === 'input')
+        return 'Provide information';
+    if (block.actionClass === 'confirm')
+        return 'Confirm and continue';
+    return 'Choose an option';
+}
+function renderAppRunControlBlockForPreDrive(block) {
+    if (block.blockKind === 'await_members') {
+        const waitingList = block.waitingFor.map((entry) => entry.memberId).join(', ');
+        return `Blocked while waiting for ${waitingList} on ${formatTargetRef(block)}. ${block.promptSummary}`;
+    }
+    if (block.blockKind === 'await_human') {
+        const suffix = block.question ?? block.promptSummary;
+        return `Blocked: human input is required for ${formatTargetRef(block)}. ${suffix}`;
+    }
+    if (!canProjectAwaitAppAction(block)) {
+        return `View problem details. ${block.title}: ${block.promptSummary}`;
+    }
+    return `${projectAppActionLabel(block)} via ${formatOwnerRef(block)} for ${formatTargetRef(block)}. ${block.promptSummary}`;
+}
 async function applyAppDialogRunControl(params) {
     const controlId = params.controlId.trim();
     if (controlId === '') {
@@ -19,6 +56,7 @@ async function applyAppDialogRunControl(params) {
     return await hostClient.applyRunControl(controlId, params.payload);
 }
 async function applyRegisteredAppDialogRunControls(payload) {
+    let recoveryAction;
     for (const control of (0, dialog_run_controls_1.listAppDialogRunControls)()) {
         let result;
         try {
@@ -42,6 +80,12 @@ async function applyRegisteredAppDialogRunControls(payload) {
         if (result.kind === 'reject') {
             return result;
         }
+        if (result.kind === 'block') {
+            return result;
+        }
+        if (recoveryAction === undefined && result.recoveryAction !== undefined) {
+            recoveryAction = result.recoveryAction;
+        }
     }
-    return { kind: 'continue' };
+    return recoveryAction ? { kind: 'allow', recoveryAction } : { kind: 'allow' };
 }

package/dist/apps-host/client.js

@@ -100,6 +100,22 @@ function parseMessageToKernel(v) {
         const callId = asString(v['callId']);
         if (!callId)
             throw new Error('Invalid run_control_result message: callId required');
+        const ok = v['ok'];
+        if (ok === true) {
+            return {
+                type,
+                callId,
+                ok: true,
+                result: v['result'],
+            };
+        }
+        if (ok === false) {
+            const errorText = asString(v['errorText']);
+            if (!errorText) {
+                throw new Error('Invalid run_control_result message: errorText required when ok=false');
+            }
+            return { type, callId, ok: false, errorText };
+        }
         return v;
     }
     throw new Error(`Invalid IPC message from apps-host: unknown type '${type}'`);

package/dist/apps-host/host.js

@@ -298,12 +298,100 @@ function validateHostInstance(host, appId) {
 function isValidRunControlResult(result) {
     if (!isRecord(result))
         return false;
+    if (result['kind'] === 'allow') {
+        const recoveryAction = result['recoveryAction'];
+        if (recoveryAction === undefined)
+            return true;
+        if (!isRecord(recoveryAction))
+            return false;
+        return (recoveryAction['actionId'] === 'continue' &&
+            typeof recoveryAction['promptSummary'] === 'string' &&
+            recoveryAction['promptSummary'].trim() !== '');
+    }
     if (result['kind'] === 'reject') {
         return typeof result['errorText'] === 'string' && result['errorText'].trim() !== '';
     }
-    if (result['kind'] !== 'continue')
+    if (result['kind'] !== 'block')
         return false;
-    return true;
+    return isValidRunControlBlock(result['block']);
+}
+function isValidRunControlBlock(block) {
+    if (!isRecord(block))
+        return false;
+    if (!isValidRunControlOwner(block['owner']))
+        return false;
+    if (!isValidRunControlTargetRef(block['targetRef']))
+        return false;
+    if (typeof block['title'] !== 'string' || block['title'].trim() === '')
+        return false;
+    if (typeof block['promptSummary'] !== 'string' || block['promptSummary'].trim() === '') {
+        return false;
+    }
+    if (block['blockKind'] === 'await_members') {
+        return isValidRunControlMemberRefs(block['waitingFor']) && block['waitingFor'].length > 0;
+    }
+    if (block['blockKind'] === 'await_human') {
+        const question = block['question'];
+        const optionsSummary = block['optionsSummary'];
+        if (question !== undefined && (typeof question !== 'string' || question.trim() === ''))
+            return false;
+        return optionsSummary === undefined || isStringArray(optionsSummary);
+    }
+    if (block['blockKind'] === 'await_app_action') {
+        if (block['actionClass'] !== 'input' &&
+            block['actionClass'] !== 'select' &&
+            block['actionClass'] !== 'confirm') {
+            return false;
+        }
+        if (typeof block['actionId'] !== 'string' || block['actionId'].trim() === '')
+            return false;
+        if (block['resolutionMode'] !== 'explicit_continue' &&
+            block['resolutionMode'] !== 'auto_resume') {
+            return false;
+        }
+        return block['optionsSummary'] === undefined || isStringArray(block['optionsSummary']);
+    }
+    return false;
+}
+function isValidRunControlOwner(owner) {
+    if (!isRecord(owner))
+        return false;
+    if (owner['kind'] === 'human')
+        return true;
+    if (owner['kind'] !== 'member')
+        return false;
+    if (typeof owner['memberId'] !== 'string' || owner['memberId'].trim() === '')
+        return false;
+    return owner['roleIds'] === undefined || isStringArray(owner['roleIds']);
+}
+function isValidRunControlTargetRef(targetRef) {
+    if (!isRecord(targetRef))
+        return false;
+    const kind = targetRef['kind'];
+    if (kind !== 'taskdoc' &&
+        kind !== 'phase' &&
+        kind !== 'gate' &&
+        kind !== 'change' &&
+        kind !== 'role' &&
+        kind !== 'member') {
+        return false;
+    }
+    if (typeof targetRef['id'] !== 'string' || targetRef['id'].trim() === '')
+        return false;
+    if (targetRef['title'] === undefined)
+        return true;
+    return typeof targetRef['title'] === 'string' && targetRef['title'].trim() !== '';
+}
+function isValidRunControlMemberRefs(value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.every((entry) => {
+        if (!isRecord(entry))
+            return false;
+        if (typeof entry['memberId'] !== 'string' || entry['memberId'].trim() === '')
+            return false;
+        return entry['roleIds'] === undefined || isStringArray(entry['roleIds']);
+    });
 }
 async function initOnce(msg) {
     for (const app of msg.apps) {

package/dist/apps-host/ipc-types.d.ts

@@ -1,3 +1,4 @@
+import type { DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
 import type { DomindsAppDialogReminderRequestBatch, DomindsAppHostReminderUpdateResult, DomindsAppInstallJsonV1, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from '@longrun-ai/kernel/app-json';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { ChatMessage } from '../llm/client';
@@ -180,12 +181,7 @@ export type AppsHostRunControlResultMessage = Readonly<{
     callId: string;
 } & (Readonly<{
     ok: true;
-    result: Readonly<{
-        kind: 'continue';
-    }> | Readonly<{
-        kind: 'reject';
-        errorText: string;
-    }>;
+    result: DomindsAppRunControlResult;
 }> | Readonly<{
     ok: false;
     errorText: string;

package/dist/dialog.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DialogStore = exports.RootDialog = exports.SubDialog = exports.Dialog = exports.DialogID = void 0;
 const util_1 = require("util");
@@ -838,8 +805,6 @@ class Dialog {
                 runControl: runControlSpec,
             });
         }
-        const { notifyWaitingDialogsOfClearedMind } = await Promise.resolve().then(() => __importStar(require('./course-transition')));
-        await notifyWaitingDialogsOfClearedMind(this);
     }
     // Proxy methods for DialogStore - route calls through dialog object instead of direct dlgStore access
     async receiveFuncResult(result) {

package/dist/docs/app-constitution.md

@@ -248,6 +248,49 @@ If the root manifest / team config uses the wrong app id (for example, still dec
 
 So even without `<rtws>/.apps/configuration.yaml` or `<rtws>/.apps/resolution.yaml`, as long as `.minds/app.yaml` declares dependencies, the kernel still resolves local apps via the default strategy; if the root manifest has no dependencies, the effective enabled apps set is empty.
 
+### `phase-gate` first slice: frozen decisions
+
+The following frozen decisions exist to let `phase-gate` become the first recommended TypeScript app without prematurely turning the whole change-governance space into a generic engine. The goal here is to freeze the smallest set of boundaries that would otherwise keep churning kernel contracts, host projection, product recovery actions, and user-facing copy.
+
+This first slice only covers a single change moving through `intake -> routing -> advancement`, plus the two high-value product states `blocked` and `exception in progress`. The only loops included for the first slice are `blocking follow-up`, `exception handling`, and `rollback/recovery`. The first-slice object model stays limited to `change dossier`, `governance decision`, `recovery action`, and `route context`.
+
+#### `Routing` must produce required governance semantics
+
+- `Routing` is not merely “record that the change entered the flow”. It must produce the minimum business truth needed for later governance.
+- For the first slice, that truth must include at least:
+  - the current governance intensity (for example large/medium/small, or an equivalent tiering),
+  - the responsibility boundary (who may continue by default, and who has blocking/approval authority),
+  - whether the default advancement path is allowed.
+- These semantics should live inside the existing `route context + governance decision` surface. Do not introduce a fifth first-slice object just to carry them.
+- Once the flow enters `exception in progress`, the decision must also carry scope, time limit, approving responsibility, and compensating action(s); otherwise a constrained exception degrades into an ungoverned bypass.
+
+#### Minimal formal input contract for `pre-drive decision -> host projection`
+
+- The key first-slice contract is not “push app-private vocabulary into kernel”. It is to freeze how an app expresses whether the host may continue driving.
+- The target direction should widen the current `continue | reject` shape into a formal surface that can express `allow / reject / block`; and for now `block` should carry only mechanism-level orchestration primitives such as `await_members`, `await_human`, and `await_app_action`.
+- For `await_app_action`, the app must provide at least the following stable fields before the host may project it into a product-level recovery action:
+  - `actionClass`
+  - `actionId`
+  - `owner`
+  - `resolutionMode`
+  - `targetRef`
+  - enough target/summary material such as `title`, `promptSummary`, and, for `select`, `optionsSummary`
+- Admission responsibility belongs to host projection: the app provides structured material; the host decides whether the material is sufficient for a concrete recovery action or must be uniformly downgraded to the fallback diagnostic path.
+- This contract should be frozen before implementation starts. `dominds/packages/kernel/src/app-host-contract.ts` still exposes `DomindsAppRunControlResult` as only `continue | reject`, while existing `phase-gate` contract tests already depend on richer blocked / primary-action structures. That gap is the current hard blocker.
+
+#### `Resume advancement` is a product action, not an implicit state jump
+
+- The first slice must expose one explicit, product-level recovery action: `resume advancement`.
+- The reason is simple: `blocking follow-up`, `exception handling`, and `rollback/recovery` only cover “handle the abnormal condition first”. They do not answer “how does the user clearly re-enter the main path once the abnormal condition is resolved?”
+- So after follow-up is completed, an exception is granted/closed, or recovery finishes, host projection must be able to surface a clear “you may now resume advancement” action, instead of hiding that step inside a silent state transition or an implementation detail.
+
+#### Unified fallback label: `View problem details`
+
+- When the app does not provide enough structured material to form a concrete recovery action, the product layer must not surface hollow action classes or implementation placeholders. It should uniformly downgrade to the `inspect_problem` path.
+- The default external label for that path is now fixed as: `View problem details`.
+- Internal identifiers such as `inspect_problem`, `select`, `confirm`, `input`, `driver`, `wiring`, and `host adapter` should not appear in user-facing primary sentences by default.
+- If implementation keeps internal names such as `input`, the projected user copy should still say something like “Provide information” or “Fill in information”, not the raw internal identifier.
+
 ## App-provided `.minds/**` assets
 
 ### Asset types and goals

package/dist/docs/app-constitution.zh.md

@@ -247,6 +247,49 @@ Install JSON 是 app 与 Kernel/CLI 之间的**安装/运行握手载荷**。它
 
 因此，即使缺少 `<rtws>/.apps/configuration.yaml` 或 `<rtws>/.apps/resolution.yaml`，只要 `.minds/app.yaml` 声明了依赖，Kernel 仍会按默认策略去解析本地 app；反之若根 manifest 没有依赖，则最终已启用 app 集合为空。
 
+### `phase-gate` 第一拍最小纵切：冻结说明
+
+以下冻结点服务于 `phase-gate` 作为首个推荐 TypeScript app 的第一拍落地。它们不是要一次性把通用 change-governance 引擎做完，而是先把会反复影响 kernel contract、host projection、产品恢复动作与用户文案的最小边界钉死。
+
+当前第一拍只覆盖单个 change 的 `进入 -> 定向 -> 推进` 主链路，以及 `已阻断` / `例外处理中` 两个高价值主状态；小循环仅先纳入 `阻断补料`、`豁免`、`回退/恢复`。首拍对象收口为：`change dossier`、`governance decision`、`recovery action`、`route context`。
+
+#### `定向` 的必填语义
+
+- `定向` 不是“登记一下 change 已进入流程”，而是必须产出后续治理所需的最小业务真相。
+- 对第一拍而言，这些真相至少包括：
+  - 当前治理强度（例如大/中/小，或等价分级）；
+  - 责任边界（谁可默认推进，谁有阻断/批准职责）；
+  - 是否允许继续沿默认推进路径前进。
+- 这些语义应落在现有 `route context + governance decision` 内，不应再新造“第五类对象”。
+- 一旦进入 `例外处理中`，该 decision 还必须同时带出范围、时效、批准责任与补偿动作；否则“受约束的例外”会退化成“临时放行的口子”。
+
+#### `pre-drive decision -> host projection` 的最小正式输入 contract
+
+- `phase-gate` 第一拍的关键 contract 不是把 app 私有业务词汇直接塞进 kernel，而是冻结 app 如何把“是否允许继续 drive”表达给 host。
+- 目标方向应从当前过窄的 `continue | reject`，收口到能表达 `allow / reject / block` 的正式输入面；其中 `block` 只先承载机制级 orchestration primitives，例如 `await_members`、`await_human`、`await_app_action`。
+- 对 `await_app_action`，app 至少要提供这些稳定字段，host 才能把它投影成产品级恢复动作：
+  - `actionClass`
+  - `actionId`
+  - `owner`
+  - `resolutionMode`
+  - `targetRef`
+  - 足够的目标/摘要材料，例如 `title`、`promptSummary`，以及 `select` 场景所需的 `optionsSummary`
+- 准入责任在 host projection：app 负责提供结构化材料，host 负责判断这些材料是否足以形成明确恢复动作，并决定是投影为产品级动作，还是统一降级到兜底诊断路径。
+- 这层 contract 冻结前，不宜直接开做第一拍实现。当前 `dominds/packages/kernel/src/app-host-contract.ts` 里的 `DomindsAppRunControlResult` 仍只有 `continue | reject`，而现有 `phase-gate` contract tests 已经依赖更丰富的 blocked / primary-action 结构，这正是当前需要先补齐的硬缺口。
+
+#### `继续推进` 是统一恢复动作，不是隐含状态跳转
+
+- 第一拍产品面必须存在一个显式的统一恢复动作：`继续推进`。
+- 原因很直接：`阻断补料`、`豁免`、`回退/恢复` 只覆盖“先处理异常”，并不自动回答“异常处理完后如何回挂主链路”。
+- 因此，补料完成、豁免决议落定、或恢复动作完成之后，host projection 必须能够给出“现在可以继续推进”的明确动作，而不是把这一步隐含在状态切换或实现细节里。
+
+#### 统一兜底文案：`查看问题详情`
+
+- 当 app 提供的材料不足以形成明确恢复动作时，产品层不得显示空心动作类或实现占位词，而应统一降级到 `inspect_problem` 路径。
+- 该路径的对外默认文案现在就固定为：`查看问题详情`。
+- `inspect_problem`、`select`、`confirm`、`input`、`driver`、`wiring`、`host adapter` 等内部实现词，默认不进入用户主句。
+- 若实现层保留 `input` 之类内部类名，对外文案也应投影成“提供信息 / 填写信息”一类用户可理解表达，而不是直接暴露内部标识。
+
 ## App 可提供的 `.minds/**` 资产
 
 ### 资产类型与目标

package/dist/docs/dialog-system.md

@@ -151,11 +151,11 @@ This section documents the three distinct types of teammate Tellasks in the Domi
 
 ```mermaid
 flowchart TD
-  M[LLM emits tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{Is this a subdialog Tellasking its direct supdialog (tellasker dialog for TYPE A)?}
-  Q -- yes --> A[TYPE A: TellaskBack<br/>(`TellaskBack`)<br/>Primary: tellaskBack({ tellaskContent: "..." }) (NO sessionSlug)]
+  M["LLM emits tellaskSessionless(...)"] --> Q{"Is this a subdialog Tellasking its direct supdialog (tellasker dialog for TYPE A)?"}
+  Q -- yes --> A["TYPE A: TellaskBack<br/>(TellaskBack)<br/>Primary: tellaskBack(...) (NO sessionSlug)"]
   Q -- no --> T{Is sessionSlug present?}
-  T -- yes --> B[TYPE B: Registered subdialog Tellask<br/>(`Tellask Session` / Registered Session Tellask)<br/>tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })]
-  T -- no --> C[TYPE C: Transient subdialog Tellask<br/>(`Fresh Tellask` / One-shot Tellask)<br/>tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })]
+  T -- yes --> B["TYPE B: Registered subdialog Tellask<br/>(Tellask Session / Registered Session Tellask)<br/>tellask(..., sessionSlug=...)"]
+  T -- no --> C["TYPE C: Transient subdialog Tellask<br/>(Fresh Tellask / One-shot Tellask)<br/>tellaskSessionless(...)"]
 ```
 
 ### TYPE A: TellaskBack (Type A / `TellaskBack`)
@@ -383,7 +383,7 @@ The Dominds dialog system is built on four interconnected core mechanisms that w
 ```mermaid
 flowchart TD
   H[Dialog hierarchy<br/>(root ↔ subdialogs)] <--> S[Subdialog supply<br/>(responses, pending list, registry)]
-  H --> Q[Q4H (askHuman({ tellaskContent: "..." }))<br/>(q4h.yaml index)]
+  H --> Q["Q4H (askHuman(...))<br/>(q4h.yaml index)"]
   S --> Q
 
   Q --> UI[Frontend Q4H panel<br/>(questions_count_update)]
@@ -839,7 +839,7 @@ researcher!market-analysis:
 
 ```mermaid
 flowchart TD
-  Tellask[TYPE B Tellask: tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })] --> Key[Compute key: agentId!sessionSlug]
+  Tellask["TYPE B Tellask: tellask(..., sessionSlug=...)"] --> Key[Compute key: agentId!sessionSlug]
   Key --> Lookup{Registry hit?}
   Lookup -- yes --> Resume[Restore + drive existing subdialog]
   Lookup -- no --> Create[Create + register + drive new subdialog]
@@ -1254,7 +1254,7 @@ sequenceDiagram
 
 ```mermaid
 flowchart TD
-  A[askHuman({ tellaskContent: "..." }) Tellask emitted] --> B[Append HumanQuestion entry to q4h.yaml]
+  A["askHuman(...) Tellask emitted"] --> B[Append HumanQuestion entry to q4h.yaml]
   B --> C[Emit questions_count_update]
   C --> D[UI shows Q4H badge / list]
   D --> E{How is it cleared?}

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

@@ -150,11 +150,11 @@
 
 ```mermaid
 flowchart TD
-  M[LLM 发出 tellaskSessionless({ targetAgentId: "mention", tellaskContent: "..." })] --> Q{这是子对话回问其直接上位对话（TYPE A 的诉请者对话）吗？}
-  Q -- 是 --> A[TYPE A：回问诉请<br/>主要：`tellaskBack({ tellaskContent: "..." })`（无 sessionSlug）]
+  M["LLM 发出 tellaskSessionless(...)"] --> Q{"这是子对话回问其直接上位对话（TYPE A 的诉请者对话）吗？"}
+  Q -- 是 --> A["TYPE A：回问诉请<br/>主要：tellaskBack(...)（无 sessionSlug）"]
   Q -- 否 --> T{是否存在 sessionSlug？}
-  T -- 是 --> B[TYPE B：已注册子对话诉请<br/>(长线诉请)<br/>tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })]
-  T -- 否 --> C[TYPE C：瞬态子对话诉请<br/>(一次性诉请)<br/>tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })]
+  T -- 是 --> B["TYPE B：已注册子对话诉请<br/>(长线诉请)<br/>tellask(..., sessionSlug=...)"]
+  T -- 否 --> C["TYPE C：瞬态子对话诉请<br/>(一次性诉请)<br/>tellaskSessionless(...)"]
 ```
 
 ### TYPE A：回问诉请
@@ -179,9 +179,9 @@ flowchart TD
 
 **支线交付规则（规范）**：
 
-- 只有当所有目标完成时，支线对话才可直接回贴诉请者对话。
+- 只有当所有目标完成时，支线对话才可直接正常回复诉请者对话。
 - 若任何目标未完成或关键信息缺失，必须先用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者对话再继续。
-- **FBR 例外**：FBR 支线对话禁止任何诉请（包括 `tellaskBack`），只能列出缺口与阻塞原因并直接回贴。
+- **FBR 例外**：FBR 支线对话禁止任何诉请（包括 `tellaskBack`），只能列出缺口与阻塞原因并直接回复。
 
 **跨对话传递与标记（强制）**：
 
@@ -364,7 +364,7 @@ Dominds 对话系统建立在四个相互关联的核心机制之上，这些机
 ```mermaid
 flowchart TD
   H[对话层级<br/>(root ↔ 子对话)] <--> S[子对话供应<br/>(响应、待处理列表、注册表)]
-  H --> Q[Q4H (askHuman({ tellaskContent: "..." }))<br/>(q4h.yaml 索引)]
+  H --> Q["Q4H（askHuman(...)）<br/>(q4h.yaml 索引)"]
   S --> Q
 
   Q --> UI[前端 Q4H 面板<br/>(questions_count_update)]
@@ -437,7 +437,7 @@ sequenceDiagram
 
   D->>P: 将 HumanQuestion 条目追加到 q4h.yaml（索引）
   D-->>UI: questions_count_update
-  注意：对话在回答之前变为不可驱动
+  Note over D: 对话在回答之前变为不可驱动
 
   UI->>WS: drive_dialog_by_user_answer(questionId, content)
   WS->>P: 从 q4h.yaml 中删除问题（如果为空则删除文件）
@@ -814,7 +814,7 @@ researcher!market-analysis:
 
 ```mermaid
 flowchart TD
-  Tellask[TYPE B 长线诉请: tellask({ targetAgentId: "agentId", sessionSlug: "tellaskSession", tellaskContent: "..." })] --> Key[计算键：agentId!sessionSlug]
+  Tellask["TYPE B 长线诉请: tellask(..., sessionSlug=...)"] --> Key[计算键：agentId!sessionSlug]
   Key --> Lookup{注册表命中？}
   Lookup -- 是 --> Resume[恢复 + 驱动现有子对话]
   Lookup -- 否 --> Create[创建 + 注册 + 驱动新的子对话]
@@ -1161,8 +1161,8 @@ flowchart TD
   B -- 否 --> S[已暂停\\n（等待 Q4H 和/或子对话）]
   S -->|Q4H 回答\\n或子对话响应供应| C{需要驱动？}
   B -- 是 --> C{需要驱动？}
-  C -- 否 --> I[空闲\\n（等待触发器）}
-  C -- 是 --> D[驱动循环\\n（流式传输时 generating=true）}
+  C -- 否 --> I[空闲\\n（等待触发器）]
+  C -- 是 --> D[驱动循环\\n（流式传输时 generating=true）]
   D --> E{有下一个？}
   E -- 是 --> C
   E -- 否 --> I
@@ -1211,13 +1211,10 @@ sequenceDiagram
   Sub-->>Driver: 最终响应
   Driver-->>Caller: 供应响应 + 清除待处理子对话
   opt 调用者是根且现在已解除阻塞
-    Driver-->>Caller: 设置 `needsDrive=true`（自动重启调度）
+    Driver-->>Caller: 设置 needsDrive=true（自动重启调度）
+  end
 ```
 
-end
-
-````
-
 #### TYPE C：瞬态子对话诉请（一次性诉请）（`tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })`，或 `freshBootsReasoning({ tellaskContent: "..." })`）
 
 ```mermaid
@@ -1226,18 +1223,18 @@ sequenceDiagram
   participant Driver as 后端驱动程序
   participant Sub as 瞬态子对话
 
-  Caller->>Driver: 发出 `tellaskSessionless({ targetAgentId: "agentId", tellaskContent: "..." })`
+  Caller->>Driver: 发出 tellaskSessionless(...)
   Driver->>Sub: 创建（不注册）
   Driver->>Sub: 驱动
   Sub-->>Driver: 最终响应
   Driver-->>Caller: 供应响应（无注册表更新）
-````
+```
 
 ### Q4H 生命周期状态
 
 ```mermaid
 flowchart TD
-  A[askHuman({ tellaskContent: "..." }) 诉请发出] --> B[将 HumanQuestion 条目追加到 q4h.yaml]
+  A["askHuman(...) 诉请发出"] --> B[将 HumanQuestion 条目追加到 q4h.yaml]
   B --> C[发出 questions_count_update]
   C --> D[UI 显示 Q4H 徽章/列表]
   D --> E{如何清除？}

package/dist/docs/fbr.zh.md

@@ -117,7 +117,7 @@ FBR 支线对话的 system prompt 必须明确包含（措辞可不同，但语
 ### 4.3 诉请限制：一律禁止
 
 FBR 支线对话不得发起任何队友诉请（包括 `tellaskBack({ tellaskContent: "..." })` 或 `askHuman({ tellaskContent: "..." })`）。
-若关键上下文缺失，应**列出缺口与阻塞原因**，然后直接回贴。
+若关键上下文缺失，应**列出缺口与阻塞原因**，然后直接回复。
 
 ### 4.4 输出契约（便于诉请者对话综合）
 

package/dist/docs/tellask-collab.md

@@ -116,6 +116,7 @@ That is a workflow break. The model should send the Tellask directly.
 - Runtime treats that direct reply as the completion delivery to the tellasker dialog and injects the work-language marker automatically (`【Completed】` in English work language, and the localized Chinese completion marker in Chinese work language).
 - If any goal is incomplete, the dialog is blocked, or critical context is missing, it MUST issue `tellaskBack({ tellaskContent: "..." })` before proceeding; do not post plain-text intermediate status updates while unfinished.
 - **FBR exception**: FBR forbids all tellasks (including `tellaskBack` / `askHuman`); list missing context + reasoning and return.
+- If a human user inserts a message or asks a follow-up in the sideline: just reply normally; no need to report back to the upstream requester.
 
 Note: no extra "Status: ..." line is required; the first-line marker is the stage reminder.
 

package/dist/docs/tellask-collab.zh.md

@@ -109,10 +109,10 @@
 
 **支线交付规则**：
 
-- 只有当所有目标完成时，支线对话才可直接回贴诉请者对话。
-- 该直接回贴会被运行时按工作语言自动加上完成标记（英文工作语言为 `【Completed】`，中文工作语言为 `【最终完成】`）。
+- 只有当所有目标完成时，支线对话才可直接正常回复诉请者对话（直接发正文即可，不需要调用 tellaskBack；运行时自动注入完成标记）。
 - 若任何目标未完成或关键信息缺失，必须先用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者对话再继续；不得发送普通文本中间汇报。
-- **FBR 例外**：FBR 禁止任何诉请（包括 `tellaskBack` / `askHuman`）；只列缺口 + 推理与摘要并直接回贴。
+- **FBR 例外**：FBR 禁止任何诉请（包括 `tellaskBack` / `askHuman`）；只列缺口 + 推理与摘要并直接回复。
+- 若人类用户在支线对话中插入消息或补问：直接正常回复，不需要向诉请者汇报。
 
 说明：不需要额外的 “Status: …” 行；首行标记即为阶段提醒。
 

package/dist/llm/defaults.yaml

@@ -172,6 +172,12 @@ providers:
           type: boolean
           description: Force JSON object output via Anthropic tool_choice mode.
     models:
+      MiniMax-M2.7:
+        name: MiniMax M2.7
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.5:
         name: MiniMax M2.5
         context_length: 204800
@@ -219,6 +225,12 @@ providers:
           type: boolean
           description: Force JSON object output via Anthropic tool_choice mode.
     models:
+      MiniMax-M2.7:
+        name: MiniMax M2.7
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.5:
         name: MiniMax M2.5
         context_length: 204800
@@ -266,6 +278,12 @@ providers:
           type: boolean
           description: Force JSON object output via Anthropic tool_choice mode.
     models:
+      MiniMax-M2.7:
+        name: MiniMax M2.7
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.5:
         name: MiniMax M2.5
         context_length: 204800
@@ -313,6 +331,12 @@ providers:
           type: boolean
           description: Force JSON object output via Anthropic tool_choice mode.
     models:
+      MiniMax-M2.7:
+        name: MiniMax M2.7
+        context_length: 204800
+        input_length: 204800
+        output_length: 8192
+        context_window: '204K'
       MiniMax-M2.5:
         name: MiniMax M2.5
         context_length: 204800
@@ -399,17 +423,35 @@ providers:
     name: Volcano Engine Coding Plan
     apiType: anthropic
     baseUrl: https://ark.cn-beijing.volces.com/api/coding
-    apiKeyEnvVar: ARK_API_KEY
-    tech_spec_url: https://api.volcengine.com/api-docs/view?serviceCode=ark&version=2024-01-01
+    apiKeyEnvVar: ARK_CP_API_KEY
+    tech_spec_url: https://www.volcengine.com/docs/82379/1928261
     api_mgmt_url: https://console.volcengine.com/ark
     models:
-      doubao-seed-code-preview-latest:
+      doubao-seed-code:
         name: Doubao Seed Code Preview
         context_length: 256000
         input_length: 256000
         output_length: 8192
         context_window: '256K'
         optimization: 专为Agentic Coding任务优化
+      deepseek-v3.2:
+        name: DeepSeek-V3.2
+        context_length: 128000
+        input_length: 96000
+        output_length: 32000
+        context_window: '128K'
+      glm-4.7:
+        name: GLM 4.7
+        context_length: 256000
+        input_length: 256000
+        output_length: 8192
+        context_window: '256K'
+      kimi-k2.5:
+        name: Kimi K2.5
+        context_length: 200000
+        input_length: 200000
+        output_length: 8192
+        context_window: '200K (约20万汉字)'
   volcano-engine:
     name: Volcano Engine
     apiType: openai-compatible