dominds 1.19.2 → 1.19.3

package/dist/mcp/supervisor.js

@@ -40,12 +40,14 @@ exports.getMcpDeclaredServerRuntimeStatuses = getMcpDeclaredServerRuntimeStatuse
 exports.startMcpSupervisor = startMcpSupervisor;
 exports.stopMcpSupervisor = stopMcpSupervisor;
 exports.requestMcpServerRestart = requestMcpServerRestart;
+exports.requestMcpServerDisable = requestMcpServerDisable;
 exports.requestMcpConfigReload = requestMcpConfigReload;
 exports.buildHttpHeaders = buildHttpHeaders;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const fs = __importStar(require("fs"));
 const node_crypto_1 = require("node:crypto");
 const path = __importStar(require("path"));
+const yaml_1 = __importStar(require("yaml"));
 const log_1 = require("../log");
 const persistence_1 = require("../persistence");
 const problems_1 = require("../problems");
@@ -151,6 +153,7 @@ class McpServerDispatch {
         for (const rt of this.leasesByDialogKey.values()) {
             rt.requestStop({ forceKillAfterMs: 3000 });
         }
+        this.leasesByDialogKey.clear();
         for (const [dialogKey, init] of this.leaseInitByDialogKey.entries()) {
             this.canceledLeaseDialogs.add(dialogKey);
             void init
@@ -159,6 +162,7 @@ class McpServerDispatch {
                 // ignore
             });
         }
+        this.leaseInitByDialogKey.clear();
     }
     async callToolForDialog(dlg, mcpToolName, args) {
         const serverId = this.serverId;
@@ -323,6 +327,13 @@ function getMcpDeclaredServerRuntimeStatuses() {
                 errorText: catalogEntry.configErrorText,
             };
         }
+        if (catalogEntry?.disabled) {
+            return {
+                serverId,
+                transport: catalogEntry.transport,
+                status: 'disabled',
+            };
+        }
         if (serverStateById.has(serverId)) {
             return {
                 serverId,
@@ -435,6 +446,27 @@ function requestMcpServerRestart(serverId) {
         });
     });
 }
+function requestMcpServerDisable(serverId) {
+    return new Promise((resolve) => {
+        reloadChain = reloadChain
+            .then(async () => {
+            try {
+                const res = await disableServerNow(serverId);
+                resolve(res);
+            }
+            catch (err) {
+                const errorText = err instanceof Error ? err.message : String(err);
+                log.warn(`MCP server disable failed`, err, { serverId });
+                resolve({ ok: false, errorText });
+            }
+        })
+            .catch((err) => {
+            const errorText = err instanceof Error ? err.message : String(err);
+            log.warn(`MCP server disable enqueue failed`, err, { serverId });
+            resolve({ ok: false, errorText });
+        });
+    });
+}
 function requestMcpConfigReload(reason = 'manual') {
     const normalizedReason = reason.trim() === '' ? 'manual' : reason.trim();
     return new Promise((resolve) => {
@@ -554,7 +586,7 @@ async function reloadNow(reason) {
         const code = isRecord(err) && 'code' in err ? err.code : undefined;
         if (code === 'ENOENT') {
             // Deletion is treated as empty config.
-            await applyWorkspaceConfig({ version: 1, servers: {} }, [], [], [], `missing file (${reason})`);
+            await applyWorkspaceConfig({ version: 1, servers: {} }, [], [], [], [], null, `missing file (${reason})`);
             clearWorkspaceConfigProblem();
             await reconcileMcpManualProblemsForRuntime([], null);
             return;
@@ -572,10 +604,19 @@ async function reloadNow(reason) {
         return;
     }
     clearWorkspaceConfigProblem();
-    await applyWorkspaceConfig(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.validServerIdsInYamlOrder, reason);
+    await applyWorkspaceConfig(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.validServerIdsInYamlOrder, parsed.disabledServerIdsInYamlOrder, rawText, reason);
     await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
 }
 async function restartServerNow(serverId) {
+    let removedPlaceholder = false;
+    const notifyPlaceholderRemovalOnFailure = (trigger) => {
+        if (!removedPlaceholder)
+            return;
+        (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
+            reason: 'registry_changed',
+            trigger,
+        });
+    };
     let rawText;
     try {
         rawText = await fs.promises.readFile(MCP_YAML_PATH, 'utf8');
@@ -592,23 +633,51 @@ async function restartServerNow(serverId) {
         upsertWorkspaceConfigProblem(`Failed to read ${MCP_YAML_PATH}: ${String(err)}`);
         return { ok: false, errorText: `Failed to read ${MCP_YAML_PATH}: ${String(err)}` };
     }
-    const parsed = (0, config_1.parseMcpYaml)(rawText);
+    let activeRawText = rawText;
+    let parsed = (0, config_1.parseMcpYaml)(activeRawText);
     if (!parsed.ok) {
         await reconcileMcpManualProblemsForRuntime([], null);
         upsertWorkspaceConfigProblem(parsed.errorText);
         return { ok: false, errorText: parsed.errorText };
     }
     clearWorkspaceConfigProblem();
+    const disabledServer = parsed.serverIdsInYamlOrder.includes(serverId) &&
+        parsed.invalidServers.every((s) => s.serverId !== serverId) &&
+        parsed.config.servers[serverId] === undefined;
+    if (disabledServer) {
+        const enableRes = setServerEnabledInMcpYaml(rawText, serverId, true);
+        if (!enableRes.ok) {
+            await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
+            return { ok: false, errorText: enableRes.errorText };
+        }
+        if (enableRes.changed) {
+            await fs.promises.writeFile(MCP_YAML_PATH, enableRes.rawText, 'utf8');
+            lastSeenMcpYamlSig = await readMcpYamlSig();
+            removedPlaceholder = unregisterMcpToolsetPlaceholder(serverId) || removedPlaceholder;
+        }
+        activeRawText = enableRes.rawText;
+        parsed = (0, config_1.parseMcpYaml)(activeRawText);
+        if (!parsed.ok) {
+            clearDeclaredServerRuntimeCatalog();
+            await reconcileMcpManualProblemsForRuntime([], null);
+            upsertWorkspaceConfigProblem(parsed.errorText);
+            notifyPlaceholderRemovalOnFailure(`mcp:restart:${serverId}:parse-failed`);
+            return { ok: false, errorText: parsed.errorText };
+        }
+        clearWorkspaceConfigProblem();
+    }
     const invalid = parsed.invalidServers.find((s) => s.serverId === serverId);
     if (invalid) {
-        replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder);
-        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
+        replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.disabledServerIdsInYamlOrder);
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, activeRawText);
         upsertMcpServerConfigInvalidProblem(serverId, invalid.errorText);
+        notifyPlaceholderRemovalOnFailure(`mcp:restart:${serverId}:config-invalid`);
         return { ok: false, errorText: invalid.errorText };
     }
     const serverCfg = parsed.config.servers[serverId];
     if (!serverCfg) {
-        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, activeRawText);
+        notifyPlaceholderRemovalOnFailure(`mcp:restart:${serverId}:not-configured`);
         return {
             ok: false,
             errorText: `MCP server '${serverId}' is not configured in ${MCP_YAML_PATH}`,
@@ -618,25 +687,28 @@ async function restartServerNow(serverId) {
     const fingerprint = fingerprintServerConfig(serverCfg);
     const existing = serverStateById.get(serverId);
     const runtimeLeaseChanged = existing !== undefined;
-    replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder);
+    replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.disabledServerIdsInYamlOrder);
+    if (!existing) {
+        removedPlaceholder = unregisterMcpToolsetPlaceholder(serverId) || removedPlaceholder;
+    }
     const res = await tryBuildServerState(serverCfg, desiredToolsetName, fingerprint);
     if (!res.ok) {
-        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, activeRawText);
         upsertDeclaredServerRuntimeError(serverId, res.errorText);
         upsertMcpServerRuntimeUnavailableProblem(serverId, res.errorText, res.detailTextI18n);
+        notifyPlaceholderRemovalOnFailure(`mcp:restart:${serverId}:runtime-unavailable`);
         return { ok: false, errorText: res.errorText };
     }
     clearDeclaredServerRuntimeError(serverId);
     (0, problems_1.removeProblemsByPrefix)(`${problemPrefixForServer(serverId)}server_error`);
     if (existing) {
-        unregisterServer(existing);
-        existing.dispatch.requestStop();
+        stopLoadedServer(serverId);
     }
     registerServer(res.state);
     serverStateById.set(serverId, res.state);
     (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), res.state.problems);
     reorderMcpToolsetsInRegistry(parsed.serverIdsInYamlOrder);
-    await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
+    await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, activeRawText);
     (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
         reason: 'registry_changed',
         trigger: `mcp:restart:${serverId}`,
@@ -646,6 +718,119 @@ async function restartServerNow(serverId) {
     }
     return { ok: true };
 }
+async function disableServerNow(serverId) {
+    const stoppedExisting = stopLoadedServer(serverId);
+    let rawText;
+    try {
+        rawText = await fs.promises.readFile(MCP_YAML_PATH, 'utf8');
+    }
+    catch (err) {
+        const code = isRecord(err) && 'code' in err ? err.code : undefined;
+        if (stoppedExisting) {
+            (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
+                reason: 'registry_changed',
+                trigger: `mcp:disable:${serverId}:read-failed`,
+            });
+            (0, tool_availability_updates_1.notifyToolAvailabilityRuntimeLeaseChanged)(`mcp:disable:${serverId}:read-failed`);
+        }
+        if (code === 'ENOENT') {
+            return { ok: false, errorText: `Cannot disable '${serverId}': ${MCP_YAML_PATH} is missing` };
+        }
+        return { ok: false, errorText: `Failed to read ${MCP_YAML_PATH}: ${String(err)}` };
+    }
+    const disableRes = setServerEnabledInMcpYaml(rawText, serverId, false);
+    if (!disableRes.ok) {
+        if (stoppedExisting) {
+            (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
+                reason: 'registry_changed',
+                trigger: `mcp:disable:${serverId}:disable-failed`,
+            });
+            (0, tool_availability_updates_1.notifyToolAvailabilityRuntimeLeaseChanged)(`mcp:disable:${serverId}:disable-failed`);
+        }
+        return { ok: false, errorText: disableRes.errorText };
+    }
+    if (disableRes.changed) {
+        await fs.promises.writeFile(MCP_YAML_PATH, disableRes.rawText, 'utf8');
+        lastSeenMcpYamlSig = await readMcpYamlSig();
+    }
+    const parsed = (0, config_1.parseMcpYaml)(disableRes.rawText);
+    if (!parsed.ok) {
+        clearDeclaredServerRuntimeCatalog();
+        await reconcileMcpManualProblemsForRuntime([], null);
+        upsertWorkspaceConfigProblem(parsed.errorText);
+        if (stoppedExisting) {
+            (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
+                reason: 'registry_changed',
+                trigger: `mcp:disable:${serverId}:parse-failed`,
+            });
+            (0, tool_availability_updates_1.notifyToolAvailabilityRuntimeLeaseChanged)(`mcp:disable:${serverId}:parse-failed`);
+        }
+        return { ok: false, errorText: parsed.errorText };
+    }
+    clearWorkspaceConfigProblem();
+    await applyWorkspaceConfig(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.validServerIdsInYamlOrder, parsed.disabledServerIdsInYamlOrder, disableRes.rawText, `mcp_disable:${serverId}`);
+    await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, disableRes.rawText);
+    if (stoppedExisting) {
+        (0, tool_availability_updates_1.notifyToolAvailabilityRuntimeLeaseChanged)(`mcp:disable:${serverId}`);
+    }
+    return { ok: true };
+}
+function setServerEnabledInMcpYaml(rawText, serverId, enabled) {
+    const doc = yaml_1.default.parseDocument(rawText, { prettyErrors: true });
+    if (doc.errors.length > 0) {
+        return { ok: false, errorText: doc.errors.map((e) => String(e)).join('\n') };
+    }
+    const parsed = doc.toJS();
+    if (!isRecord(parsed)) {
+        return { ok: false, errorText: `Invalid mcp.yaml: expected object at mcp.yaml root` };
+    }
+    if (parsed.version !== 1) {
+        return { ok: false, errorText: `Invalid mcp.yaml: expected version: 1` };
+    }
+    const servers = parsed.servers;
+    const server = isRecord(servers) ? servers[serverId] : undefined;
+    if (!isRecord(server)) {
+        return {
+            ok: false,
+            errorText: `MCP server '${serverId}' is not configured in ${MCP_YAML_PATH}`,
+        };
+    }
+    const currentEnabled = server.enabled;
+    if (currentEnabled !== undefined && typeof currentEnabled !== 'boolean') {
+        return {
+            ok: false,
+            errorText: `Invalid mcp.yaml: servers.${serverId}.enabled must be a boolean`,
+        };
+    }
+    if (currentEnabled === enabled) {
+        return { ok: true, rawText, changed: false };
+    }
+    const serverNode = doc.getIn(['servers', serverId], true);
+    if (!(0, yaml_1.isMap)(serverNode)) {
+        return {
+            ok: false,
+            errorText: `Invalid mcp.yaml: servers.${serverId} must be an object`,
+        };
+    }
+    const existingEnabledPair = serverNode.items.find((pair) => (0, yaml_1.isScalar)(pair.key) && pair.key.value === 'enabled');
+    if (existingEnabledPair) {
+        existingEnabledPair.value = doc.createNode(enabled);
+    }
+    else {
+        serverNode.items.unshift(doc.createPair('enabled', enabled));
+    }
+    return { ok: true, rawText: String(doc), changed: true };
+}
+function stopLoadedServer(serverId) {
+    const existing = serverStateById.get(serverId);
+    if (!existing)
+        return false;
+    unregisterServer(existing);
+    existing.dispatch.requestStop();
+    serverStateById.delete(serverId);
+    (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), []);
+    return true;
+}
 async function reconcileMcpManualProblemsForRuntime(serverIdsInYamlOrder, rawText) {
     const manualInfo = rawText === null ? (0, manual_problems_1.emptyMcpToolsetManualByServer)() : (0, manual_problems_1.parseMcpManualByServer)(rawText);
     await (0, manual_problems_1.reconcileMcpToolsetManualProblems)({
@@ -711,13 +896,15 @@ function upsertMcpToolCallProblem(args) {
     const hintLines = workLanguage === 'zh'
         ? [
             '建议排查：',
-            `- 先释放租约：mcp_release({"serverId":"${args.serverId}"})`,
+            `- 如果需要全局重建该 MCP server，直接调用 mcp_restart({"serverId":"${args.serverId}"})；它成功后会清理旧 runtime 的全部 lease`,
+            `- 如果只想丢弃当前对话的连接，再调用 mcp_release({"serverId":"${args.serverId}"})`,
             `- 重新打开/关闭浏览器窗口，避免 Playwright persistent context 残留`,
             `- 查看 ${MCP_YAML_PATH} 是否已加载且配置正确（Problems 面板 / 后端日志）`,
         ]
         : [
             'Suggested checks:',
-            `- Release the lease first: mcp_release({"serverId":"${args.serverId}"})`,
+            `- To rebuild this MCP server globally, call mcp_restart({"serverId":"${args.serverId}"}) directly; a successful restart clears all leases on the old runtime`,
+            `- To discard only this dialog's connection, call mcp_release({"serverId":"${args.serverId}"})`,
             `- Close/reopen browser windows to avoid leftover Playwright persistent contexts`,
             `- Verify ${MCP_YAML_PATH} is loaded and valid (Problems panel / backend logs)`,
         ];
@@ -746,12 +933,13 @@ function upsertMcpToolCallProblem(args) {
 function clearMcpToolCallProblem(serverId) {
     (0, problems_1.removeProblemsByPrefix)(`${MCP_TOOL_CALL_PROBLEM_PREFIX}${sanitizePathSegment(serverId)}`);
 }
-async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder, validServerIdsInYamlOrder, reason) {
+async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder, validServerIdsInYamlOrder, disabledServerIdsInYamlOrder, rawText, reason) {
     log.info(`Applying MCP rtws config (${reason})`);
-    replaceDeclaredServerRuntimeCatalog(config, invalidServers, serverIdsInYamlOrder);
+    replaceDeclaredServerRuntimeCatalog(config, invalidServers, serverIdsInYamlOrder, disabledServerIdsInYamlOrder);
     let runtimeLeaseChanged = false;
     const invalidIds = new Set(invalidServers.map((s) => s.serverId));
     const desiredIds = new Set([...Object.keys(config.servers), ...invalidIds]);
+    const declaredIds = new Set(serverIdsInYamlOrder);
     // Remove deleted servers first.
     for (const [serverId, state] of serverStateById.entries()) {
         if (desiredIds.has(serverId))
@@ -762,8 +950,18 @@ async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder
         serverStateById.delete(serverId);
         (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), []);
     }
+    // Remove disabled/deleted MCP placeholders that are no longer declared.
+    for (const [toolsetName, owner] of Array.from(toolsetOwnerByName.entries())) {
+        if (owner.kind !== 'mcp')
+            continue;
+        if (declaredIds.has(owner.serverId))
+            continue;
+        (0, registry_1.unregisterToolset)(toolsetName);
+        toolsetOwnerByName.delete(toolsetName);
+    }
     // Surface invalid server config errors (while keeping last-known-good runtimes registered).
     for (const s of invalidServers) {
+        unregisterMcpToolsetPlaceholder(s.serverId);
         upsertMcpServerConfigInvalidProblem(s.serverId, s.errorText);
     }
     // Apply desired servers independently (deterministic order).
@@ -775,6 +973,9 @@ async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder
         const fingerprint = fingerprintServerConfig(serverCfg);
         const existing = serverStateById.get(serverId);
         if (!existing || existing.configFingerprint !== fingerprint) {
+            if (!existing) {
+                unregisterMcpToolsetPlaceholder(serverId);
+            }
             const res = await tryBuildServerState(serverCfg, desiredToolsetName, fingerprint);
             if (!res.ok) {
                 upsertDeclaredServerRuntimeError(serverId, res.errorText);
@@ -827,6 +1028,11 @@ async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder
         if (!changed)
             break;
     }
+    const manualInfo = rawText === null ? (0, manual_problems_1.emptyMcpToolsetManualByServer)() : (0, manual_problems_1.parseMcpManualByServer)(rawText);
+    for (const serverId of disabledServerIdsInYamlOrder) {
+        (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), []);
+        registerDisabledServerToolset(serverId, manualInfo);
+    }
     reorderMcpToolsetsInRegistry(serverIdsInYamlOrder);
     (0, tool_availability_updates_1.notifyToolAvailabilityRegistryMaybeChanged)({
         reason: 'registry_changed',
@@ -849,7 +1055,7 @@ function clearDeclaredServerRuntimeCatalog() {
     declaredServerIdsInYamlOrder = [];
     declaredServerRuntimeCatalogById.clear();
 }
-function replaceDeclaredServerRuntimeCatalog(config, invalidServers, serverIdsInYamlOrder) {
+function replaceDeclaredServerRuntimeCatalog(config, invalidServers, serverIdsInYamlOrder, disabledServerIdsInYamlOrder) {
     const previousRuntimeErrors = new Map();
     for (const [serverId, entry] of declaredServerRuntimeCatalogById.entries()) {
         if (typeof entry.runtimeErrorText === 'string' && entry.runtimeErrorText.trim() !== '') {
@@ -858,7 +1064,15 @@ function replaceDeclaredServerRuntimeCatalog(config, invalidServers, serverIdsIn
     }
     declaredServerIdsInYamlOrder = [...serverIdsInYamlOrder];
     declaredServerRuntimeCatalogById.clear();
+    const disabledIds = new Set(disabledServerIdsInYamlOrder);
     for (const serverId of serverIdsInYamlOrder) {
+        if (disabledIds.has(serverId)) {
+            declaredServerRuntimeCatalogById.set(serverId, {
+                transport: 'unknown',
+                disabled: true,
+            });
+            continue;
+        }
         const cfg = config.servers[serverId];
         if (!cfg)
             continue;
@@ -945,6 +1159,74 @@ function registerServer(state) {
     });
     toolsetOwnerByName.set(state.toolsetName, { kind: 'mcp', serverId: state.serverId });
 }
+function registerDisabledServerToolset(serverId, manualInfo) {
+    const existingToolset = registry_1.toolsetsRegistry.get(serverId);
+    const existingOwner = toolsetOwnerByName.get(serverId);
+    if (existingToolset && (!existingOwner || existingOwner.serverId !== serverId)) {
+        upsertMcpServerConfigInvalidProblem(serverId, `Toolset name collision: ${serverId}`);
+        return;
+    }
+    (0, registry_1.registerToolset)(serverId, []);
+    const manual = manualInfo.manualByServerId.get(serverId);
+    const manualSpec = manual?.contentFile
+        ? (0, spec_1.buildMcpManualSpec)(manual.contentFile)
+        : {
+            topics: ['index'],
+            warnOnMissing: false,
+            includeSchemaToolsSection: false,
+        };
+    const inlineManual = manual ? renderInlineMcpToolsetManual(manual) : '';
+    const disabledNoticeEn = [
+        `This MCP server is configured but disabled in \`.minds/mcp.yaml\` (\`enabled: false\`).`,
+        `It intentionally exposes zero tools until an MCP administrator enables it with \`mcp_restart({"serverId":"${serverId}"})\`.`,
+        inlineManual,
+    ]
+        .filter((part) => part.trim() !== '')
+        .join('\n\n');
+    const disabledNoticeZh = [
+        `该 MCP server 已在 \`.minds/mcp.yaml\` 中配置，但当前为禁用状态（\`enabled: false\`）。`,
+        `它会刻意暴露为 0 工具的 toolset；需要 MCP 排障/管理员用 \`mcp_restart({"serverId":"${serverId}"})\` 启用后才会加载工具。`,
+        inlineManual,
+    ]
+        .filter((part) => part.trim() !== '')
+        .join('\n\n');
+    (0, registry_1.setToolsetMeta)(serverId, {
+        source: 'mcp',
+        descriptionI18n: {
+            en: `MCP server: ${serverId} (disabled)`,
+            zh: `MCP 服务器：${serverId}（已禁用）`,
+        },
+        manualNoticeI18n: {
+            en: disabledNoticeEn,
+            zh: disabledNoticeZh,
+        },
+        ...(manualSpec !== undefined ? { manualSpec } : {}),
+    });
+    toolsetOwnerByName.set(serverId, { kind: 'mcp', serverId });
+}
+function renderInlineMcpToolsetManual(manual) {
+    const parts = [];
+    if (manual.content) {
+        parts.push(manual.content);
+    }
+    for (const section of manual.sections) {
+        parts.push(`#### ${section.title}\n\n${section.content}`);
+    }
+    return parts.join('\n\n');
+}
+function unregisterMcpToolsetPlaceholder(serverId) {
+    if (serverStateById.has(serverId))
+        return false;
+    const owner = toolsetOwnerByName.get(serverId);
+    if (owner?.kind !== 'mcp' || owner.serverId !== serverId)
+        return false;
+    const tools = registry_1.toolsetsRegistry.get(serverId);
+    if (tools && tools.length > 0)
+        return false;
+    (0, registry_1.unregisterToolset)(serverId);
+    toolsetOwnerByName.delete(serverId);
+    return true;
+}
 function unregisterServer(state) {
     // Unregister toolset first so Team.Member.listTools doesn't resolve stale tools.
     if (toolsetOwnerByName.get(state.toolsetName)?.serverId === state.serverId) {

package/dist/minds/load.js

@@ -116,6 +116,11 @@ function buildAgentMcpToolsetRuntimeNotices(params) {
         notices.push({
             toolsetName,
             transport: runtimeStatus?.transport ?? 'unknown',
+            status: runtimeStatus?.status === 'disabled'
+                ? 'disabled'
+                : runtimeStatus?.status === 'config_invalid'
+                    ? 'config_invalid'
+                    : 'temporarily_unavailable',
             errorText: runtimeStatus?.errorText,
         });
     }

package/dist/minds/system-prompt.d.ts

@@ -22,6 +22,7 @@ export type BuildSystemPromptInput = {
 export type McpToolsetRuntimeNotice = Readonly<{
     toolsetName: string;
     transport: 'stdio' | 'streamable_http' | 'invalid' | 'unknown';
+    status: 'temporarily_unavailable' | 'config_invalid' | 'disabled';
     errorText?: string;
 }>;
 export declare function formatMcpToolsetRuntimeNote(language: LanguageCode, notices: readonly McpToolsetRuntimeNotice[]): string;

package/dist/minds/system-prompt.js

@@ -312,24 +312,32 @@ function formatMcpToolsetRuntimeNote(language, notices) {
         return '';
     const lines = language === 'zh'
         ? [
-            '以下 MCP toolset 已配置给你，且在 `.minds/mcp.yaml` 中有声明，但当前没有加载进运行时工具注册表。',
-            '请将它们视为“当前暂时不可达”的运行时情况，例如 stdio transport 进程暂时启动失败，或 streamable HTTP transport 当前无法连接；这不代表你的权限被撤销，也不应视为系统级功能降级。',
+            '以下 MCP toolset 已配置给你，且在 `.minds/mcp.yaml` 中有声明，但当前不提供可调用的运行时 MCP 工具。',
+            '其中有些可能是暂时不可达（例如 stdio transport 进程启动失败，或 streamable HTTP transport 当前无法连接），有些可能是被明确禁用；这不代表你的权限被撤销，也不应视为系统级功能降级。',
             ...notices.map((notice) => {
+                if (notice.status === 'disabled') {
+                    return `- \`${notice.toolsetName}\`：状态=已禁用；这是一个已配置但当前刻意暴露为 0 工具的 MCP toolset。如任务依赖它，请按团队职责速查表联系 MCP 排障/管理员处理。`;
+                }
                 const reason = typeof notice.errorText === 'string' && notice.errorText.trim() !== ''
                     ? `；最近错误：${notice.errorText}`
                     : '';
-                return `- \`${notice.toolsetName}\`：transport=${formatTransportLabel(language, notice.transport)}；状态=暂时不可达${reason}`;
+                const status = notice.status === 'config_invalid' ? '配置无效' : '暂时不可达';
+                return `- \`${notice.toolsetName}\`：transport=${formatTransportLabel(language, notice.transport)}；状态=${status}${reason}`;
             }),
             '若当前任务依赖这些能力，应明确说明对应 MCP toolset 眼下不可用，并优先继续使用其余可用工具/路径推进。',
         ]
         : [
-            'The following MCP toolsets are assigned to you and declared in `.minds/mcp.yaml`, but they are not currently loaded into the runtime tool registry.',
-            'Treat this as a temporary runtime-availability condition, for example a stdio transport process failing to start right now, or a streamable HTTP transport being unreachable right now. This does not mean your permission was revoked, and it should not be treated as a system-level capability downgrade.',
+            'The following MCP toolsets are assigned to you and declared in `.minds/mcp.yaml`, but they do not currently provide callable runtime MCP tools.',
+            'Some may be temporarily unavailable (for example a stdio transport process failing to start right now, or a streamable HTTP transport being unreachable right now), and some may be explicitly disabled. This does not mean your permission was revoked, and it should not be treated as a system-level capability downgrade.',
             ...notices.map((notice) => {
+                if (notice.status === 'disabled') {
+                    return `- \`${notice.toolsetName}\`: status=disabled; this is a configured MCP toolset intentionally exposed with zero tools. If the task depends on it, use the team responsibility quick table to contact the MCP troubleshooter or administrator.`;
+                }
                 const reason = typeof notice.errorText === 'string' && notice.errorText.trim() !== ''
                     ? `; latest error: ${notice.errorText}`
                     : '';
-                return `- \`${notice.toolsetName}\`: transport=${formatTransportLabel(language, notice.transport)}; status=temporarily unavailable${reason}`;
+                const status = notice.status === 'config_invalid' ? 'config invalid' : 'temporarily unavailable';
+                return `- \`${notice.toolsetName}\`: transport=${formatTransportLabel(language, notice.transport)}; status=${status}${reason}`;
             }),
             'If the current task depends on one of these capabilities, say that the corresponding MCP toolset is unavailable right now and continue with other available tools or paths first.',
         ];

package/dist/tools/builtins.js

@@ -81,6 +81,7 @@ function manualSpecFor(toolsetId) {
 // MCP tools (local testing/ops)
 (0, registry_1.registerTool)(mcp_1.mcpRestartTool);
 (0, registry_1.registerTool)(mcp_1.mcpReleaseTool);
+(0, registry_1.registerTool)(mcp_1.mcpDisableTool);
 // Memory tools
 (0, registry_1.registerTool)(mem_1.addPersonalMemoryTool);
 (0, registry_1.registerTool)(mem_1.dropPersonalMemoryTool);
@@ -169,6 +170,7 @@ for (const tool of team_mgmt_1.teamMgmtTools) {
 (0, registry_1.registerToolset)('mcp_admin', [
     mcp_1.mcpRestartTool,
     mcp_1.mcpReleaseTool,
+    mcp_1.mcpDisableTool,
     env_1.envGetTool,
     env_1.envSetTool,
     env_1.envUnsetTool,