dominds 1.19.2 → 1.19.3

package/dist/cli/team-definition-audit.d.ts

@@ -8,10 +8,11 @@ export type McpDeclaredToolsets = Readonly<{
     kind: 'loaded';
     declaredServerIds: ReadonlySet<string>;
     invalidServerIds: ReadonlySet<string>;
+    disabledServerIds: ReadonlySet<string>;
 }>;
 export type ToolsetAuditItem = Readonly<{
     toolsetName: string;
-    status: 'registered' | 'mcp_declared_unloaded' | 'mcp_declared_invalid' | 'missing';
+    status: 'registered' | 'mcp_declared_unloaded' | 'mcp_declared_invalid' | 'mcp_declared_disabled' | 'missing';
 }>;
 export type ToolsetAuditReport = Readonly<{
     mcp: McpDeclaredToolsets;

package/dist/cli/team-definition-audit.js

@@ -45,6 +45,7 @@ async function readMcpDeclaredToolsets() {
         kind: 'loaded',
         declaredServerIds: new Set(parsed.serverIdsInYamlOrder),
         invalidServerIds: new Set(parsed.invalidServers.map((s) => s.serverId)),
+        disabledServerIds: new Set(parsed.disabledServerIdsInYamlOrder),
     };
 }
 function buildToolsetAuditReport(params) {
@@ -58,20 +59,28 @@ function buildToolsetAuditReport(params) {
         const explicitToolsets = listExplicitToolsets(member);
         const items = [];
         for (const toolsetName of explicitToolsets) {
-            if (registeredToolsets.has(toolsetName)) {
-                items.push({ toolsetName, status: 'registered' });
-                continue;
-            }
             if (params.mcp.kind === 'loaded' && params.mcp.declaredServerIds.has(toolsetName)) {
                 if (params.mcp.invalidServerIds.has(toolsetName)) {
                     items.push({ toolsetName, status: 'mcp_declared_invalid' });
                     warnings.push(`@${member.id}: toolset '${toolsetName}' is declared in mcp.yaml but server config is invalid.`);
                 }
+                else if (params.mcp.disabledServerIds.has(toolsetName)) {
+                    items.push({ toolsetName, status: 'mcp_declared_disabled' });
+                }
                 else {
-                    items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                    if (registeredToolsets.has(toolsetName)) {
+                        items.push({ toolsetName, status: 'registered' });
+                    }
+                    else {
+                        items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                    }
                 }
                 continue;
             }
+            if (registeredToolsets.has(toolsetName)) {
+                items.push({ toolsetName, status: 'registered' });
+                continue;
+            }
             items.push({ toolsetName, status: 'missing' });
             warnings.push(`@${member.id}: toolset '${toolsetName}' is neither registered nor declared in mcp.yaml.`);
         }
@@ -91,6 +100,7 @@ function countByStatus(report) {
         registered: 0,
         mcp_declared_unloaded: 0,
         mcp_declared_invalid: 0,
+        mcp_declared_disabled: 0,
         missing: 0,
     };
     for (const memberReport of report.byMember) {
@@ -107,6 +117,8 @@ function statusLabel(status) {
         return 'DEFERRED';
     if (status === 'mcp_declared_invalid')
         return 'INVALID';
+    if (status === 'mcp_declared_disabled')
+        return 'DISABLED';
     return 'MISS';
 }
 function hasHardToolsetAuditFailures(report) {
@@ -125,12 +137,12 @@ function printToolsetAudit(report, options) {
         process.stdout.write('- MCP config: invalid (`.minds/mcp.yaml` parse/read failed)\n');
     }
     else {
-        process.stdout.write(`- MCP config: loaded (declared servers: ${report.mcp.declaredServerIds.size}, invalid server configs: ${report.mcp.invalidServerIds.size})\n`);
+        process.stdout.write(`- MCP config: loaded (declared servers: ${report.mcp.declaredServerIds.size}, invalid server configs: ${report.mcp.invalidServerIds.size}, disabled servers: ${report.mcp.disabledServerIds.size})\n`);
     }
-    process.stdout.write(`- Summary: ${counts.registered} OK, ${counts.mcp_declared_unloaded} DEFERRED, ${counts.mcp_declared_invalid} INVALID, ${counts.missing} MISS\n`);
+    process.stdout.write(`- Summary: ${counts.registered} OK, ${counts.mcp_declared_unloaded} DEFERRED, ${counts.mcp_declared_disabled} DISABLED, ${counts.mcp_declared_invalid} INVALID, ${counts.missing} MISS\n`);
     if (options?.includeTransientLegend !== false) {
         process.stdout.write('- Status notes: `DEFERRED` means the toolset is declared via `.minds/mcp.yaml` but is not currently loaded into the registry. This is often temporary (for example MCP server down/unreachable); if the MCP service recovers, rerun validation and it may clear without editing `team.yaml`.\n');
-        process.stdout.write('- Status notes: `INVALID` means the MCP server declaration itself is invalid and needs a config fix. `MISS` means the toolset is neither registered nor declared in `.minds/mcp.yaml`.\n');
+        process.stdout.write('- Status notes: `DISABLED` means the MCP server has `enabled: false`; it remains declared but intentionally exposes zero tools until `mcp_restart` enables it. `INVALID` means the MCP server declaration itself is invalid and needs a config fix. `MISS` means the toolset is neither registered nor declared in `.minds/mcp.yaml`.\n');
     }
     if (report.byMember.length === 0) {
         process.stdout.write('- Members: none\n');

package/dist/cli/validate-team-def.js

@@ -8,10 +8,10 @@ function printUsage() {
     console.log('Usage: dominds validate_team_def [<member-id>]');
     console.log('');
     console.log('Validate explicit toolset declarations in `.minds/team.yaml` against the current toolset registry and `.minds/mcp.yaml` declarations.');
-    console.log('MCP-declared but currently unloaded toolsets are reported as `DEFERRED` because they are often transient runtime availability issues rather than permanent team-definition errors.');
+    console.log('MCP-declared but currently unloaded toolsets are reported as `DEFERRED`; disabled MCP toolsets are reported as `DISABLED` when `enabled: false` is set in `.minds/mcp.yaml`.');
     console.log('');
     console.log('Exit codes:');
-    console.log('  0  No hard definition errors (`OK` / `DEFERRED` only)');
+    console.log('  0  No hard definition errors (`OK` / `DEFERRED` / `DISABLED` only)');
     console.log('  2  Hard definition errors found (`INVALID` / `MISS`)');
     console.log('');
     console.log('Examples:');
@@ -70,7 +70,7 @@ async function main() {
             mcp: await (0, team_definition_audit_1.readMcpDeclaredToolsets)(),
         });
         process.stdout.write('# Team Definition Validation\n');
-        process.stdout.write('This command checks explicit toolset references in `.minds/team.yaml`. `DEFERRED` usually means the toolset is declared through MCP but is not currently loaded; if the MCP service recovers, rerun this command before editing `team.yaml`.\n');
+        process.stdout.write('This command checks explicit toolset references in `.minds/team.yaml`. `DEFERRED` usually means the toolset is declared through MCP but is not currently loaded; `DISABLED` means the server is intentionally `enabled: false` and exposes zero tools until `mcp_restart` enables it.\n');
         (0, team_definition_audit_1.printToolsetAudit)(report, { heading: '## Definition Audit' });
         if ((0, team_definition_audit_1.hasHardToolsetAuditFailures)(report)) {
             process.exit(2);

package/dist/docs/mcp-support.md

@@ -98,6 +98,12 @@ Releasing:
 
 - Agents should call `mcp_release({"serverId":"<serverId>"})` (from `mcp_admin`) to release the
   leased runtime instance for the current dialog.
+- `mcp_restart({"serverId":"<serverId>"})` enables a disabled server (`enabled: true`) before
+  starting it. After a successful restart, Dominds replaces the global runtime and clears all dialog
+  leases on the old runtime.
+- `mcp_disable({"serverId":"<serverId>"})` disables a server (`enabled: false`) and stops any loaded
+  runtime/leases. Disabled servers remain visible as zero-tool MCP toolsets, and their configured
+  manual remains readable with an explicit disabled notice.
 
 ### Shared behavior (`truely-stateless: true`)
 
@@ -397,6 +403,11 @@ This is a Dominds-oriented schema. It is intentionally small and should be easy
 version: 1
 servers:
   <serverId>:
+    # Optional operational switch. `mcp_disable` writes this to false; `mcp_restart`
+    # writes it back to true before starting the server.
+    # Disabled servers start no runtime and expose a zero-tool toolset/manual marked disabled.
+    enabled: true
+
     # Concurrency model (IMPORTANT)
     # - Default false: per-dialog client leasing (safer for stateful servers)
     # - True: shared client across dialogs (only for servers that are truly stateless)

package/dist/docs/mcp-support.zh.md

@@ -75,6 +75,8 @@ Dominds 的行为：
 释放：
 
 - 智能体应调用 `mcp_release({"serverId":"<serverId>"})`（来自 `mcp_admin`）来释放当前对话持有的租赁运行时实例。
+- `mcp_restart({"serverId":"<serverId>"})` 会先启用被禁用的 server（`enabled: true`），再启动它。成功重启后，Dominds 会替换全局 runtime，并清理旧 runtime 上的全部对话 lease。
+- `mcp_disable({"serverId":"<serverId>"})` 会禁用 server（`enabled: false`），并停止已加载 runtime/lease。禁用 server 仍作为 0 工具 MCP toolset 可见，已配置手册也会带明确 disabled 提示继续可读。
 
 ### 共享行为（`truely-stateless: true`）
 
@@ -322,6 +324,11 @@ headers:
 version: 1
 servers:
   <serverId>:
+    # 可选运维开关。`mcp_disable` 会把它写成 false；`mcp_restart`
+    # 会在启动前写回 true。
+    # disabled server 不启动 runtime，并暴露为带 disabled 标记的 0 工具 toolset/手册。
+    enabled: true
+
     # 并发模型（重要）
     # - 默认 false：每对话客户端租赁（对有状态服务器更安全）
     # - True：跨对话共享客户端（仅适用于真正无状态的服务器）

package/dist/docs/team_mgmt-toolset.md

@@ -384,7 +384,9 @@ Notes:
 
 - MCP tool names are global across all toolsets (built-in + MCP). Collisions cause tools to be
   skipped and should surface via Problems + logs.
-- `mcp_admin` is a built-in toolset that contains `mcp_restart` (best-effort per-server restart).
+- `mcp_admin` is a built-in toolset for MCP operations: `mcp_restart` enables/restarts a server,
+  `mcp_disable` disables a server while keeping its zero-tool toolset/manual visible, and
+  `mcp_release` releases the current dialog lease.
 - Optional manual information can live in `.minds/mcp.yaml` at `servers.<serverId>.manual`:
   - `contentFile`: the topic-file directory prefix for the formal runtime manual; the final `man({ "toolsetId": "<serverId>" })` content shown to the LLM is loaded from here
   - `content` / `sections`: inline team-management guidance shown in the `team_mgmt` MCP chapter (`sections` supports `[{ title, content }]` or `{ "<title>": "<content>" }`)
@@ -635,4 +637,5 @@ This avoids needing to grant full rtws access to configure the team.
   - Confirm the teammate is granted the relevant `<serverId>` toolset in `.minds/team.yaml`.
 - **MCP server keeps failing to (re)load**:
   - Check Problems details (missing env var, invalid tool name, collisions, connection errors).
-  - After fixing config, use `mcp_restart` (from `mcp_admin`) for a best-effort per-server restart.
+  - After fixing config, use `mcp_restart` (from `mcp_admin`) to enable/restart the server. Use
+    `mcp_disable` to disable it while keeping the configured manual visible as a zero-tool toolset.

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

@@ -321,7 +321,8 @@ members:
 注意：
 
 - MCP 工具名称在所有工具集（内置 + MCP）中是全局的。冲突导致工具被跳过，应通过问题 + 日志暴露
-- `mcp_admin` 是一个内置工具集，包含 `mcp_restart`（每个服务器最佳努力重启）
+- `mcp_admin` 是 MCP 运维内置工具集：`mcp_restart` 启用/重启 server，`mcp_disable` 禁用
+  server 并保留 0 工具 toolset/手册可见性，`mcp_release` 释放当前对话 lease
 - 可选手册：可在 `.minds/mcp.yaml` 的 `servers.<serverId>.manual` 提供手册相关信息：
   - `contentFile`：正式 runtime 手册的 topic 文件目录前缀；`man({ "toolsetId": "<serverId>" })` 最终给 LLM 看的正文从这里加载
   - `content` / `sections`：补充给 `team_mgmt` MCP 章节看的 inline 团队管理说明（`sections` 支持 `[{ title, content }]` 或 `{ "<title>": "<content>" }`）
@@ -540,4 +541,5 @@ members:
   - 确认队友在 `.minds/team.yaml` 中被授予了相关的 `<serverId>` 工具集
 - **MCP 服务器持续 (re)load 失败**：
   - 检查问题详细信息（缺少 env 变量、无效的工具名称、冲突、连接错误）
-  - 修复配置后，使用 `mcp_admin` 中的 `mcp_restart` 进行每个服务器的最佳努力重启
+  - 修复配置后，使用 `mcp_admin` 中的 `mcp_restart` 启用/重启 server。若需禁用，使用
+    `mcp_disable`，它会保留 0 工具 toolset 和已配置手册可见性

package/dist/docs/tool-availability-protocol.md

@@ -79,7 +79,8 @@ Non-goals:
 Update triggers:
 
 - `.minds/mcp.yaml` reload
-- `mcp_restart`
+- `mcp_restart` (also writes `enabled: true` when a configured MCP server is disabled)
+- `mcp_disable` (writes `enabled: false`; the server remains visible as a zero-tool toolset/manual)
 - MCP collision-resolution re-registration
 
 ### 2. Runtime Lease Protocol
@@ -105,7 +106,8 @@ Update triggers:
 
 - first MCP tool call acquires a lease
 - `mcp_release`
-- restart/stop tears leases down
+- successful `mcp_restart` tears old-runtime leases down
+- `mcp_disable` tears loaded runtime leases down
 
 ### 3. Member Tool-Binding Protocol
 

package/dist/mcp/config.d.ts

@@ -62,6 +62,7 @@ export type McpConfigLoadResult = {
     }>;
     serverIdsInYamlOrder: ReadonlyArray<string>;
     validServerIdsInYamlOrder: ReadonlyArray<string>;
+    disabledServerIdsInYamlOrder: ReadonlyArray<string>;
     rawText: string;
 } | {
     ok: false;

package/dist/mcp/config.js

@@ -26,6 +26,7 @@ function parseMcpYaml(rawText) {
             invalidServers: res.invalidServers,
             serverIdsInYamlOrder: res.serverIdsInYamlOrder,
             validServerIdsInYamlOrder: res.validServerIdsInYamlOrder,
+            disabledServerIdsInYamlOrder: res.disabledServerIdsInYamlOrder,
             rawText,
         };
     }
@@ -45,9 +46,14 @@ function parseWorkspaceConfig(value) {
     const invalidServers = [];
     const serverIdsInYamlOrder = [];
     const validServerIdsInYamlOrder = [];
+    const disabledServerIdsInYamlOrder = [];
     for (const [serverId, serverRaw] of Object.entries(serversRecord)) {
         serverIdsInYamlOrder.push(serverId);
         try {
+            if (isDisabledServerConfig(serverId, serverRaw)) {
+                disabledServerIdsInYamlOrder.push(serverId);
+                continue;
+            }
             servers[serverId] = parseServerConfig(serverId, serverRaw);
             validServerIdsInYamlOrder.push(serverId);
         }
@@ -63,8 +69,18 @@ function parseWorkspaceConfig(value) {
         invalidServers,
         serverIdsInYamlOrder,
         validServerIdsInYamlOrder,
+        disabledServerIdsInYamlOrder,
     };
 }
+function isDisabledServerConfig(serverId, value) {
+    const obj = asRecord(value, `servers.${serverId}`);
+    const enabled = obj.enabled;
+    if (enabled === undefined || enabled === true)
+        return false;
+    if (enabled === false)
+        return true;
+    throw new Error(`Invalid mcp.yaml: servers.${serverId}.enabled must be a boolean`);
+}
 function parseServerConfig(serverId, value) {
     const obj = asRecord(value, `servers.${serverId}`);
     const truelyStatelessVal = obj['truely-stateless'];

package/dist/mcp/supervisor.d.ts

@@ -2,7 +2,7 @@ import type { McpStreamableHttpServerConfig } from './config';
 export type McpDeclaredServerRuntimeStatus = Readonly<{
     serverId: string;
     transport: 'stdio' | 'streamable_http' | 'invalid' | 'unknown';
-    status: 'loaded' | 'temporarily_unavailable' | 'config_invalid';
+    status: 'loaded' | 'temporarily_unavailable' | 'config_invalid' | 'disabled';
     errorText?: string;
 }>;
 export declare function isMcpToolsetLeasedToDialog(serverId: string, dialogKey: string): boolean;
@@ -26,6 +26,12 @@ export declare function requestMcpServerRestart(serverId: string): Promise<{
     ok: false;
     errorText: string;
 }>;
+export declare function requestMcpServerDisable(serverId: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    errorText: string;
+}>;
 export declare function requestMcpConfigReload(reason?: string): Promise<{
     ok: true;
 } | {