dominds 0.3.2 → 0.3.4

package/dist/dialog-instance-registry.js

@@ -5,6 +5,25 @@ exports.ensureDialogLoaded = ensureDialogLoaded;
 const dialog_1 = require("./dialog");
 const dialog_global_registry_1 = require("./dialog-global-registry");
 const persistence_1 = require("./persistence");
+const diligence_1 = require("./shared/diligence");
+const team_1 = require("./team");
+function resolveMemberDiligencePushMax(team, agentId) {
+    const member = team.getMember(agentId);
+    if (member && member.diligence_push_max !== undefined) {
+        return member.diligence_push_max;
+    }
+    return diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+}
+function normalizeDiligencePushMax(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.floor(value);
+}
+function clampNonNegativeFiniteInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(0, Math.floor(value));
+}
 async function getOrRestoreRootDialog(rootId, status) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
@@ -18,6 +37,15 @@ async function getOrRestoreRootDialog(rootId, status) {
     if (!rootState)
         return undefined;
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialogId, status);
+    let diligencePushMax = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+    try {
+        const team = await team_1.Team.load();
+        diligencePushMax = normalizeDiligencePushMax(resolveMemberDiligencePushMax(team, rootState.metadata.agentId));
+    }
+    catch (_err) {
+        diligencePushMax = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+    }
+    const defaultDisableDiligencePush = diligencePushMax <= 0;
     const rootStore = new persistence_1.DiskFileDialogStore(rootDialogId);
     const rootDialog = new dialog_1.RootDialog(rootStore, rootState.metadata.taskDocPath, rootDialogId, rootState.metadata.agentId, {
         messages: rootState.messages,
@@ -25,7 +53,18 @@ async function getOrRestoreRootDialog(rootId, status) {
         currentCourse: rootState.currentCourse,
         contextHealth: rootState.contextHealth,
     });
-    rootDialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
+    const persistedDisableDiligencePush = latest && typeof latest.disableDiligencePush === 'boolean'
+        ? latest.disableDiligencePush
+        : defaultDisableDiligencePush;
+    rootDialog.disableDiligencePush = persistedDisableDiligencePush;
+    const persistedRemainingBudget = latest && typeof latest.diligencePushRemainingBudget === 'number'
+        ? latest.diligencePushRemainingBudget
+        : undefined;
+    const normalizedRemainingBudget = clampNonNegativeFiniteInt(persistedRemainingBudget, diligencePushMax > 0 ? diligencePushMax : 0);
+    rootDialog.diligencePushRemainingBudget =
+        diligencePushMax > 0
+            ? Math.min(normalizedRemainingBudget, diligencePushMax)
+            : normalizedRemainingBudget;
     rootDialog.setPersistenceStatus(status);
     dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
     // Keep the in-memory root dialog fully hydrated regardless of persistence status

package/dist/dialog.js

@@ -96,8 +96,8 @@ class Dialog {
         // Phase 11: Suspension state for Type A subdialog mechanism
         // Tracks whether this dialog is in normal state, suspended, or resuming from suspension
         this._suspensionState = 'active';
-        // Diligence Push (diligence auto-continue) budget counter (runtime-only).
-        // Intentionally not persisted: this is a per-process safety valve, not dialog state.
+        // Diligence Push (diligence auto-continue) budget counter (root-dialog state).
+        // Persisted via latest.yaml so restarts and UI navigation can restore correct remaining budget.
         this.diligencePushRemainingBudget = 0;
         // Diligence Push disable switch (persisted via latest.yaml; default = false).
         this.disableDiligencePush = false;

package/dist/docs/dialog-system.md

@@ -64,6 +64,12 @@ The **subdialog registry** is a root dialog-scoped Map that maintains persistent
 
 A **teammate Tellask** is a Dominds specific syntax that triggers communication with another agent as subdialog. Teammate Tellasks have three distinct patterns with different semantics (see Section 3).
 
+**Tellask block structure** (see also `dominds/docs/dominds-terminology.md`):
+
+- **Tellask headline**: the first line `!?@<name> ...` (additional `!?@...` lines in the same block are appended to the headline).
+- **Tellask body**: subsequent lines that start with `!?` but not `!?@`.
+- Structured directives like `!tellaskSession <slug>` MUST be in the headline.
+
 ---
 
 ## Backend-Driven Architecture

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

@@ -64,6 +64,12 @@
 
 **队友 Tellask** 是 Dominds 特定的语法，触发与另一个作为子对话的代理的通信。队友 Tellask 有三种不同模式，具有不同语义（见第 3 节）。
 
+**诉请块结构**（另见 `dominds/docs/dominds-terminology.md`）：
+
+- **诉请头（Tellask headline）**：诉请块第一行 `!?@<name> ...`（同一诉请块内，后续以 `!?@...` 开头的行会并入诉请头）。
+- **诉请内容（Tellask body）**：后续以 `!?` 开头但不以 `!?@` 开头的行。
+- `!tellaskSession <slug>` 等结构化指令必须写在诉请头中。
+
 ---
 
 ## 后端驱动架构

package/dist/docs/dominds-terminology.md

@@ -156,6 +156,8 @@
 ### 快速对照（Quick Glossary）
 
 - EN: `Tellask` | ZH: `诉请`
+- EN: `Tellask headline` | ZH: `诉请头`
+- EN: `Tellask body` | ZH: `诉请内容`
 - EN: `TellaskBack` | ZH: `回问诉请`
 - EN: `Tellask Session` | ZH: `长线诉请`
 - EN: `Fresh Tellask` | ZH: `一次性诉请`
@@ -171,6 +173,22 @@
 - EN: A Tellask is not casual chat; it is a collaboration action that Dominds can drive, route, and coordinate (including suspend/resume).
 - ZH: Tellask 不是随意聊天，而是一种可被 Dominds 驱动、路由、并由系统协调（包括挂起/恢复）的协作动作。
 
+#### Tellask headline（诉请头）
+
+- EN: The first line of a Tellask block, starting with `!?@<name> ...`.
+- ZH: 诉请块的第一行，以 `!?@<name> ...` 开头。
+
+- EN: Additional lines starting with `!?@...` in the same block are appended to the headline (they do not start a new Tellask).
+- ZH: 同一诉请块内，后续以 `!?@...` 开头的行会被并入诉请头（不会开启新的诉请）。
+
+- EN: Put structured directives such as `!tellaskSession <slug>` in the headline.
+- ZH: 结构化指令（例如 `!tellaskSession <slug>`）必须放在诉请头中。
+
+#### Tellask body（诉请内容）
+
+- EN: Lines in the Tellask block that start with `!?` but do not start with `!?@`. They carry the request context (steps, constraints, acceptance criteria, etc.).
+- ZH: 诉请块内以 `!?` 开头但不以 `!?@` 开头的行，用于承载诉请内容（步骤、上下文、约束、验收标准等）。
+
 ### 3 种诉请形态（Three Tellask Modes）
 
 - EN: These names are intended to replace implementation-heavy labels like “Type A/B/C” in user-facing prompts.

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/llm/driver.js

@@ -754,8 +754,8 @@ function createSayingEventsReceiver(dlg) {
         callBodyFinish: async () => {
             await dlg.callingBodyFinish();
         },
-        callFinish: async (callId) => {
-            await dlg.callingFinish(callId);
+        callFinish: async (call, _upstreamEndOffset) => {
+            await dlg.callingFinish(call.callId);
         },
     };
 }
@@ -908,8 +908,6 @@ async function runBackendDriver() {
             for (const rootDialog of dialogsToDrive) {
                 try {
                     if (!(await rootDialog.canDrive())) {
-                        dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
-                        await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
                         continue;
                     }
                     const release = await rootDialog.acquire();
@@ -919,7 +917,9 @@ async function runBackendDriver() {
                     finally {
                         release();
                     }
-                    if (rootDialog.hasUpNext()) {
+                    const status = await rootDialog.getSuspensionStatus();
+                    const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
+                    if (shouldStayQueued) {
                         dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId);
                         await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
                     }
@@ -927,7 +927,6 @@ async function runBackendDriver() {
                         dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
                         await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
                     }
-                    const status = await rootDialog.getSuspensionStatus();
                     if (status.subdialogs) {
                         log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`);
                     }
@@ -1067,6 +1066,46 @@ async function _driveDialogStream(dlg, humanPrompt) {
                 log_1.log.warn(`Provider not found for agent ${dlg.agentId}`, error);
                 throw error;
             }
+            const modelsUnknown = providerCfg.models;
+            const models = typeof modelsUnknown === 'object' && modelsUnknown !== null && !Array.isArray(modelsUnknown)
+                ? modelsUnknown
+                : undefined;
+            const modelInfo = models ? models[model] : undefined;
+            if (!modelInfo) {
+                const uiLanguage = dlg.getUiLanguage();
+                const msg = uiLanguage === 'zh'
+                    ? [
+                        '配置错误：当前成员的模型配置无效。',
+                        '',
+                        `- member: ${agent.name} (${dlg.agentId})`,
+                        `- provider: ${provider}`,
+                        `- model: ${model}（这是 model key；在该 provider 的 models 列表中不存在，或该 provider 缺少 models 配置）`,
+                        '',
+                        '请联系团队管理者修复：',
+                        `- 在 .minds/team.yaml 中把该成员的 provider/model 改成有效 key；或`,
+                        `- 在 .minds/llm.yaml 的 providers.${provider}.models 下补齐该 model key。`,
+                        '',
+                        '提示：你也可以打开 WebUI 的 `/setup` 查看当前工作区可用的 provider/model 列表。',
+                        '',
+                        '团队管理者修复后建议运行：`team_mgmt_validate_team_cfg({})`。',
+                    ].join('\n')
+                    : [
+                        'Configuration error: invalid model selection for this member.',
+                        '',
+                        `- member: ${agent.name} (${dlg.agentId})`,
+                        `- provider: ${provider}`,
+                        `- model: ${model} (this is a model key; not found under this provider's models list, or the provider has no models configured)`,
+                        '',
+                        'Please contact your team manager to fix:',
+                        `- Update the member's provider/model keys in .minds/team.yaml, or`,
+                        `- Add the model key under .minds/llm.yaml providers.${provider}.models.`,
+                        '',
+                        'Tip: you can also open the WebUI `/setup` page to see available provider/model keys for this workspace.',
+                        '',
+                        'After the fix, the team manager should run: `team_mgmt_validate_team_cfg({})`.',
+                    ].join('\n');
+                throw new Error(msg);
+            }
             const llmGen = (0, registry_1.getLlmGenerator)(providerCfg.apiType);
             if (!llmGen) {
                 const error = new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
@@ -1471,6 +1510,10 @@ async function _driveDialogStream(dlg, humanPrompt) {
                                 else {
                                     dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
                                 }
+                                void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                    kind: 'patch',
+                                    patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                }));
                             }
                         }
                         catch (err) {
@@ -1500,6 +1543,10 @@ async function _driveDialogStream(dlg, humanPrompt) {
                                     else {
                                         dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
                                     }
+                                    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                        kind: 'patch',
+                                        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                    }));
                                 }
                                 break;
                             }
@@ -1510,6 +1557,10 @@ async function _driveDialogStream(dlg, humanPrompt) {
                                 diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
                             });
                             dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+                            void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                kind: 'patch',
+                                patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                            }));
                             if (prepared.kind !== 'disabled') {
                                 (0, evt_registry_1.postDialogEvent)(dlg, {
                                     type: 'diligence_budget_evt',
@@ -1880,6 +1931,10 @@ async function _driveDialogStream(dlg, humanPrompt) {
                                     else {
                                         dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
                                     }
+                                    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                        kind: 'patch',
+                                        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                    }));
                                 }
                                 break;
                             }
@@ -1890,6 +1945,10 @@ async function _driveDialogStream(dlg, humanPrompt) {
                                 diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
                             });
                             dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+                            void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                kind: 'patch',
+                                patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                            }));
                             if (prepared.kind !== 'disabled') {
                                 (0, evt_registry_1.postDialogEvent)(dlg, {
                                     type: 'diligence_budget_evt',
@@ -2457,9 +2516,7 @@ async function supplyResponseToSupdialog(parentDialog, subdialogId, responseText
             if (parentDialog instanceof dialog_1.RootDialog) {
                 dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId);
             }
-            else {
-                void driveDialogStream(parentDialog, undefined, true);
-            }
+            void driveDialogStream(parentDialog, undefined, true);
         }
     }
     catch (error) {

package/dist/llm/gen/codex.js

@@ -395,6 +395,17 @@ class CodexGen {
                         }
                         return;
                     }
+                    case 'response.reasoning_summary_text.done':
+                    case 'response.reasoning_text.done':
+                    case 'response.reasoning_summary_part.done': {
+                        if (thinkingStarted) {
+                            await receiver.thinkingFinish();
+                            thinkingStarted = false;
+                            if (activeStream === 'thinking')
+                                activeStream = 'idle';
+                        }
+                        return;
+                    }
                     case 'response.output_item.added':
                         return;
                     case 'response.output_item.done': {

package/dist/persistence.js

@@ -138,6 +138,9 @@ function parseDialogLatestFile(value) {
         return null;
     if (value.disableDiligencePush !== undefined && typeof value.disableDiligencePush !== 'boolean')
         return null;
+    if (value.diligencePushRemainingBudget !== undefined &&
+        typeof value.diligencePushRemainingBudget !== 'number')
+        return null;
     if (value.messageCount !== undefined && typeof value.messageCount !== 'number')
         return null;
     if (value.functionCallCount !== undefined && typeof value.functionCallCount !== 'number')
@@ -224,6 +227,7 @@ function parseDialogLatestFile(value) {
         needsDrive: value.needsDrive,
         runState,
         disableDiligencePush: value.disableDiligencePush,
+        diligencePushRemainingBudget: value.diligencePushRemainingBudget,
     };
 }
 function isSubdialogResponseRecord(value) {
@@ -1100,11 +1104,11 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                                     }));
                                 }
                             },
-                            callFinish: async (_callId) => {
+                            callFinish: async (call) => {
                                 if (ws.readyState === 1) {
                                     ws.send(JSON.stringify({
                                         type: 'tool_call_finish_evt',
-                                        callId: _callId,
+                                        callId: call.callId,
                                         course,
                                         genseq,
                                         dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
@@ -1402,11 +1406,11 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                                 }));
                             }
                         },
-                        callFinish: async (callId) => {
+                        callFinish: async (call) => {
                             if (ws.readyState === 1) {
                                 ws.send(JSON.stringify({
                                     type: 'tool_call_finish_evt',
-                                    callId,
+                                    callId: call.callId,
                                     course,
                                     genseq: event.genseq,
                                     dialog: {

package/dist/server/api-routes.js

@@ -62,6 +62,18 @@ const snippets_routes_1 = require("./snippets-routes");
 // Dialog lookup is performed via file-backed persistence; no in-memory registry
 const log = (0, log_1.createLogger)('api-routes');
 let cachedDomindsVersion;
+function resolveMemberDiligencePushMax(team, agentId) {
+    const member = team.getMember(agentId);
+    if (member && member.diligence_push_max !== undefined) {
+        return member.diligence_push_max;
+    }
+    return diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+}
+function normalizeDiligencePushMax(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.floor(value);
+}
 async function readDomindsPackageVersion() {
     if (cachedDomindsVersion !== undefined)
         return cachedDomindsVersion;
@@ -800,6 +812,11 @@ async function handleCreateDialog(req, res, context) {
         // Create RootDialog
         const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, agentId);
         dialog_global_registry_1.globalDialogRegistry.register(dialog);
+        const team = await team_1.Team.load();
+        const diligencePushMax = normalizeDiligencePushMax(resolveMemberDiligencePushMax(team, agentId));
+        const defaultDisableDiligencePush = diligencePushMax <= 0;
+        dialog.disableDiligencePush = defaultDisableDiligencePush;
+        dialog.diligencePushRemainingBudget = diligencePushMax > 0 ? diligencePushMax : 0;
         // Persist dialog metadata and latest.yaml (write-once pattern)
         const metadata = {
             id: dialogId.selfId,
@@ -819,7 +836,8 @@ async function handleCreateDialog(req, res, context) {
                 functionCallCount: 0,
                 subdialogCount: 0,
                 runState: { kind: 'idle_waiting_user' },
-                disableDiligencePush: false,
+                disableDiligencePush: defaultDisableDiligencePush,
+                diligencePushRemainingBudget: dialog.diligencePushRemainingBudget,
             },
         }));
         // Dialog is registered with the global registry on creation

package/dist/server/setup-routes.js

@@ -15,6 +15,7 @@ const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const client_1 = require("../llm/client");
 const log_1 = require("../log");
+const team_config_updates_1 = require("../team-config-updates");
 const log = (0, log_1.createLogger)('setup-routes');
 const TEAM_YAML_PATH = path_1.default.join('.minds', 'team.yaml');
 const WORKSPACE_LLM_YAML_PATH = path_1.default.join('.minds', 'llm.yaml');
@@ -165,6 +166,7 @@ async function handleWriteTeamYaml(rawBody) {
         await promises_1.default.mkdir(path_1.default.dirname(outPath), { recursive: true });
         const content = buildMinimalTeamYaml(req);
         await promises_1.default.writeFile(outPath, content, 'utf-8');
+        (0, team_config_updates_1.notifyTeamConfigUpdated)(`setup.write_team_yaml/${exists ? 'overwritten' : 'created'}`);
         return {
             kind: 'ok',
             response: {

package/dist/server/websocket-handler.js

@@ -19,6 +19,7 @@ const runtime_language_1 = require("../shared/runtime-language");
 const language_1 = require("../shared/types/language");
 const time_1 = require("../shared/utils/time");
 const team_1 = require("../team");
+const team_config_updates_1 = require("../team-config-updates");
 const id_1 = require("../utils/id");
 const task_package_1 = require("../utils/task-package");
 const auth_1 = require("./auth");
@@ -305,6 +306,10 @@ async function handleRefillDiligencePushBudget(ws, packet) {
         rootDialog.diligencePushRemainingBudget =
             clampNonNegativeFiniteInt(rootDialog.diligencePushRemainingBudget, 0) + 3;
     }
+    await persistence_1.DialogPersistence.mutateDialogLatest(rootDialogId, () => ({
+        kind: 'patch',
+        patch: { diligencePushRemainingBudget: rootDialog.diligencePushRemainingBudget },
+    }), foundStatus);
     (0, evt_registry_1.postDialogEvent)(rootDialog, {
         type: 'diligence_budget_evt',
         maxInjectCount: configuredMax > 0 ? configuredMax : 0,
@@ -404,6 +409,7 @@ async function handleCreateDialog(ws, packet) {
                 subdialogCount: 0,
                 runState: { kind: 'idle_waiting_user' },
                 disableDiligencePush: defaultDisableDiligencePush,
+                diligencePushRemainingBudget: dialog.diligencePushRemainingBudget,
             },
         }));
         // Send dialog_ready with full info so frontend can track the active dialog
@@ -417,6 +423,7 @@ async function handleCreateDialog(ws, packet) {
             taskDocPath: taskDocPath,
             disableDiligencePush: defaultDisableDiligencePush,
             diligencePushMax,
+            diligencePushRemainingBudget: dialog.diligencePushRemainingBudget,
         };
         ws.send(JSON.stringify(response));
         broadcastDialogsIndexMessage?.({
@@ -559,6 +566,7 @@ async function handleDisplayDialog(ws, packet) {
             assignmentFromSup: metadata.assignmentFromSup,
             disableDiligencePush: effectiveDisableDiligencePush,
             diligencePushMax,
+            diligencePushRemainingBudget: clampNonNegativeFiniteInt(rootDialog.diligencePushRemainingBudget, diligencePushMax > 0 ? diligencePushMax : 0),
         };
         ws.send(JSON.stringify(dialogReadyResponse));
         // Send authoritative run state for this dialog so the client can render Send↔Stop and Continue.
@@ -1026,6 +1034,16 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage) {
             }
         }
     });
+    // Broadcast `.minds/team.yaml` updates so multi-tab clients can refresh cached team config.
+    (0, team_config_updates_1.setTeamConfigBroadcaster)((msg) => {
+        const data = JSON.stringify(msg);
+        for (const ws of clients) {
+            if (ws.readyState === 1) {
+                ws.send(data);
+            }
+        }
+    });
+    (0, team_config_updates_1.startTeamConfigWatcher)();
     wss.on('connection', (ws, req) => {
         const authCheck = (0, auth_1.getWebSocketAuthCheck)(req, auth);
         if (authCheck.kind !== 'ok') {