dominds 1.17.3 → 1.17.4

package/dist/apps-host/host.js

@@ -82,7 +82,16 @@ function parseReminderRequest(value) {
         if (echoback === null) {
             throw new Error('Invalid app tool reminder request: upsert.echoback must be boolean');
         }
-        return { kind: 'upsert', ownerRef, content, meta, position, echoback };
+        const renderModeRaw = value['renderMode'];
+        const renderMode = renderModeRaw === undefined
+            ? undefined
+            : renderModeRaw === 'plain' || renderModeRaw === 'markdown'
+                ? renderModeRaw
+                : null;
+        if (renderMode === null) {
+            throw new Error('Invalid app tool reminder request: upsert.renderMode must be plain|markdown');
+        }
+        return { kind: 'upsert', ownerRef, content, meta, position, echoback, renderMode };
     }
     throw new Error(`Invalid app tool reminder request kind: ${String(kind)}`);
 }
@@ -138,7 +147,9 @@ function isReminderState(value) {
     if (meta !== undefined && !isJsonValue(meta))
         return false;
     const echoback = value['echoback'];
-    return echoback === undefined || typeof echoback === 'boolean';
+    const renderMode = value['renderMode'];
+    return ((echoback === undefined || typeof echoback === 'boolean') &&
+        (renderMode === undefined || renderMode === 'plain' || renderMode === 'markdown'));
 }
 function isReminderApplyResult(value) {
     if (!isRecord(value))

package/dist/apps-host/ipc-types.js

@@ -46,7 +46,15 @@ function parseReminderState(v, at) {
     const echoback = echobackRaw === undefined ? undefined : typeof echobackRaw === 'boolean' ? echobackRaw : null;
     if (echoback === null)
         throw new Error(`Invalid ${at}.echoback: must be boolean`);
-    return { content, meta: metaRaw, echoback };
+    const renderModeRaw = v['renderMode'];
+    const renderMode = renderModeRaw === undefined
+        ? undefined
+        : renderModeRaw === 'plain' || renderModeRaw === 'markdown'
+            ? renderModeRaw
+            : null;
+    if (renderMode === null)
+        throw new Error(`Invalid ${at}.renderMode: must be plain|markdown`);
+    return { content, meta: metaRaw, echoback, renderMode };
 }
 function parseReminderApplyRequest(v, at) {
     if (!isRecord(v))
@@ -75,6 +83,14 @@ function parseReminderApplyRequest(v, at) {
         const echoback = echobackRaw === undefined ? undefined : typeof echobackRaw === 'boolean' ? echobackRaw : null;
         if (echoback === null)
             throw new Error(`Invalid ${at}.echoback: must be boolean`);
+        const renderModeRaw = v['renderMode'];
+        const renderMode = renderModeRaw === undefined
+            ? undefined
+            : renderModeRaw === 'plain' || renderModeRaw === 'markdown'
+                ? renderModeRaw
+                : null;
+        if (renderMode === null)
+            throw new Error(`Invalid ${at}.renderMode: must be plain|markdown`);
         return {
             kind: 'upsert',
             ownerRef,
@@ -82,6 +98,7 @@ function parseReminderApplyRequest(v, at) {
             meta: metaRaw,
             position,
             echoback,
+            renderMode,
         };
     }
     if (kind === 'delete') {

package/dist/dialog-fork.js

@@ -38,6 +38,7 @@ function cloneReminderSnapshot(snapshot) {
         meta: snapshot.meta,
         echoback: snapshot.echoback,
         scope: snapshot.scope ?? 'dialog',
+        renderMode: snapshot.renderMode ?? 'markdown',
         createdAt: snapshot.createdAt,
         priority: snapshot.priority,
     });

package/dist/dialog.js

@@ -374,6 +374,7 @@ class Dialog {
             meta,
             echoback: options?.echoback,
             scope: options?.scope ?? 'dialog',
+            renderMode: options?.renderMode,
         });
         const insertIndex = position !== undefined ? position : this.reminders.length;
         if (insertIndex < 0 || insertIndex > this.reminders.length) {
@@ -405,6 +406,7 @@ class Dialog {
             scope: oldReminder.scope,
             createdAt: oldReminder.createdAt,
             priority: oldReminder.priority,
+            renderMode: options?.renderMode ?? oldReminder.renderMode,
         });
         this.reminders[index] = updatedReminder;
         this.touchReminders();
@@ -479,6 +481,7 @@ class Dialog {
                             scope: reminder.scope,
                             createdAt: reminder.createdAt,
                             priority: reminder.priority,
+                            renderMode: reminder.renderMode,
                         });
                         const contentChanged = updatedReminder.content !== reminder.content;
                         const metaChanged = updatedReminder.meta !== reminder.meta;
@@ -539,8 +542,10 @@ class Dialog {
             content: r.content,
             meta: r.meta,
             reminder_id: r.id,
+            renderRevision: (0, tool_1.computeReminderRenderRevision)(r),
             echoback: (0, tool_1.reminderEchoBackEnabled)(r),
             scope: r.scope,
+            renderMode: r.renderMode ?? 'markdown',
         }));
         // Emit full_reminders_update event with complete reminder list including metadata
         const fullRemindersEvt = {

package/dist/docs/mcp-support.md

@@ -423,9 +423,12 @@ servers:
     # Tool name transforms (optional)
     transform: []
 
-    # Optional per-toolset manual shown to agents
+    # Optional manual information
+    # - contentFile: formal runtime manual for man({ "toolsetId": "<serverId>" })
+    # - content/sections: extra inline team-management guidance
     # (missing manual does NOT make the toolset unavailable)
     manual:
+      contentFile: ".minds/manuals/<serverId>"
       content: "What this MCP toolset is for"
       sections:
         - title: "When To Use"

package/dist/docs/team_mgmt-toolset.md

@@ -385,15 +385,15 @@ 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).
-- Optional per-toolset manual can live in `.minds/mcp.yaml` at `servers.<serverId>.manual` using:
-  - `content`: overview text
-  - `sections`: chapterized guidance (`[{ title, content }]` or `{ "<title>": "<content>" }`)
+- 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>" }`)
 - Missing manual does **not** mean the toolset is unavailable; it means team-manager documentation
   is incomplete. Agents should continue by reading each tool’s own description/arguments.
 - Team-manager recommendation: after MCP config validation passes, carefully read each exposed tool
-  description, discuss intended rtws usage with the human user, then write
-  `servers.<serverId>.manual` that captures typical usage patterns, primary intent directions, and
-  unavailable-case business handling rules.
+  description, discuss intended rtws usage with the human user, then write the formal manual into
+  `manual.contentFile`; if extra team-management interpretation is still useful, add inline
+  `content + sections` alongside it.
 - Use a semi-structured chapter shape: high-value sections often include `When To Use`,
   `Guardrails`, and `Business Handling When Unavailable`, but do not force every toolset into one
   fixed template. Start from the real business goal, then decide which sections deserve depth,
@@ -431,8 +431,9 @@ servers:
     # Tool name transforms
     transform: [] # optional
 
-    # Optional toolset manual for agents
+    # Optional manual information
     manual:
+      contentFile: ".minds/manuals/<serverId>" # formal runtime manual for man({ "toolsetId": "<serverId>" })
       content: "What this MCP toolset is for"
       sections:
         - title: "When To Use"

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

@@ -322,11 +322,11 @@ members:
 
 - MCP 工具名称在所有工具集（内置 + MCP）中是全局的。冲突导致工具被跳过，应通过问题 + 日志暴露
 - `mcp_admin` 是一个内置工具集，包含 `mcp_restart`（每个服务器最佳努力重启）
-- 可选手册：可在 `.minds/mcp.yaml` 的 `servers.<serverId>.manual` 为每个 MCP toolset 提供手册：
-  - `content`：总说明
-  - `sections`：章节化指导（`[{ title, content }]` 或 `{ "<title>": "<content>" }`）
+- 可选手册：可在 `.minds/mcp.yaml` 的 `servers.<serverId>.manual` 提供手册相关信息：
+  - `contentFile`：正式 runtime 手册的 topic 文件目录前缀；`man({ "toolsetId": "<serverId>" })` 最终给 LLM 看的正文从这里加载
+  - `content` / `sections`：补充给 `team_mgmt` MCP 章节看的 inline 团队管理说明（`sections` 支持 `[{ title, content }]` 或 `{ "<title>": "<content>" }`）
 - 没有手册 **不代表** 该 toolset 不可用；这只表示团队管理文档覆盖不足。智能体应继续依据每个工具自身的 description/参数来使用。
-- 建议团队管理者在 MCP 配置验证通过后：先精读该 server 暴露的每个工具说明，再与人类用户讨论本 rtws 的使用意图，最后把“典型用法 + 主要意图方向 + 不可用时业务处置规约”沉淀为 `servers.<serverId>.manual`。
+- 建议团队管理者在 MCP 配置验证通过后：先精读该 server 暴露的每个工具说明，再与人类用户讨论本 rtws 的使用意图，然后把正式手册沉淀到 `manual.contentFile`；如仍需额外写团队管理层解释，再补 inline `content + sections`。
 - 章节组织建议采用“半结构化”：可优先考虑 `何时使用`、`安全边界`、`不可用时业务处置` 这类高价值章节，但不要求所有 toolset 都照抄同一模板。应从真实业务目标出发，决定哪些章节需要展开、哪些只需一句话、哪些可以合并或改名成更贴切的标题。
 - 对每个 MCP toolset，建议刻意写明“不可用时业务处置规约”，至少回答：
   - 当前 toolset 暂不可达时，是否必须找协调者/专员接手
@@ -360,8 +360,9 @@ servers:
     # 工具名称转换
     transform: [] # 可选
 
-    # 可选：给智能体看的 toolset 手册
+    # 可选：手册相关信息
     manual:
+      contentFile: ".minds/manuals/<serverId>" # 正式 runtime 手册（供 man({ "toolsetId": "<serverId>" }) 读取）
       content: "该 MCP toolset 的用途说明"
       sections:
         - title: "何时使用"

package/dist/mcp/manual-problems.d.ts

@@ -0,0 +1,33 @@
+export type McpToolsetManualSection = {
+    title: string;
+    content: string;
+};
+export type McpToolsetManual = {
+    content?: string;
+    contentFile?: string;
+    sections: ReadonlyArray<McpToolsetManualSection>;
+};
+export type McpToolsetManualState = {
+    kind: 'missing';
+} | {
+    kind: 'invalid';
+    errorText: string;
+} | {
+    kind: 'present';
+    manual: McpToolsetManual;
+};
+export type McpToolsetManualByServer = {
+    manualByServerId: ReadonlyMap<string, McpToolsetManual>;
+    invalidByServerId: ReadonlyMap<string, string>;
+    warningTextByServerId: ReadonlyMap<string, string>;
+};
+export declare function emptyMcpToolsetManualByServer(): McpToolsetManualByServer;
+export declare function mcpToolsetManualProblemPrefix(serverId: string): string;
+export declare function mcpWorkspaceManualProblemPrefix(): string;
+export declare function parseMcpManualByServer(rawText: string): McpToolsetManualByServer;
+export declare function reconcileMcpToolsetManualProblems(params: {
+    serverIds: ReadonlyArray<string>;
+    manualInfo: McpToolsetManualByServer;
+    measureRenderedWorkspaceMcpTopicRawChars: () => Promise<number>;
+    workspaceManualPath: string;
+}): Promise<void>;

package/dist/mcp/manual-problems.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyMcpToolsetManualByServer = emptyMcpToolsetManualByServer;
+exports.mcpToolsetManualProblemPrefix = mcpToolsetManualProblemPrefix;
+exports.mcpWorkspaceManualProblemPrefix = mcpWorkspaceManualProblemPrefix;
+exports.parseMcpManualByServer = parseMcpManualByServer;
+exports.reconcileMcpToolsetManualProblems = reconcileMcpToolsetManualProblems;
+const time_1 = require("@longrun-ai/kernel/utils/time");
+const yaml_1 = __importDefault(require("yaml"));
+const problems_1 = require("../problems");
+const output_limit_1 = require("../tools/manual/output-limit");
+const render_1 = require("../tools/manual/render");
+const registry_1 = require("../tools/registry");
+const MCP_SERVER_PROBLEM_PREFIX = 'mcp/server/';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function emptyMcpToolsetManualByServer() {
+    return {
+        manualByServerId: new Map(),
+        invalidByServerId: new Map(),
+        warningTextByServerId: new Map(),
+    };
+}
+function mcpToolsetManualProblemPrefix(serverId) {
+    return `${MCP_SERVER_PROBLEM_PREFIX}${serverId}/toolset_manual_`;
+}
+function mcpWorkspaceManualProblemPrefix() {
+    return 'mcp/workspace_manual_';
+}
+function parseMcpManualByServer(rawText) {
+    const manualByServerId = new Map();
+    const invalidByServerId = new Map();
+    const warningTextByServerId = new Map();
+    let parsedRoot;
+    try {
+        parsedRoot = yaml_1.default.parse(rawText);
+    }
+    catch {
+        return { manualByServerId, invalidByServerId, warningTextByServerId };
+    }
+    if (!isObjectRecord(parsedRoot)) {
+        return { manualByServerId, invalidByServerId, warningTextByServerId };
+    }
+    const serversVal = parsedRoot['servers'];
+    if (!isObjectRecord(serversVal)) {
+        return { manualByServerId, invalidByServerId, warningTextByServerId };
+    }
+    for (const [serverId, serverVal] of Object.entries(serversVal)) {
+        if (!isObjectRecord(serverVal))
+            continue;
+        const manualVal = serverVal['manual'];
+        if (manualVal === undefined || manualVal === null)
+            continue;
+        const parsed = parseMcpManualField(serverId, manualVal);
+        if (parsed.warningText !== undefined) {
+            warningTextByServerId.set(serverId, parsed.warningText);
+        }
+        if (parsed.kind === 'present') {
+            manualByServerId.set(serverId, parsed.manual);
+            continue;
+        }
+        invalidByServerId.set(serverId, parsed.errorText);
+    }
+    return { manualByServerId, invalidByServerId, warningTextByServerId };
+}
+function parseMcpManualField(serverId, value) {
+    const fieldPath = `servers.${serverId}.manual`;
+    if (typeof value === 'string') {
+        const text = value.trim();
+        if (text === '') {
+            return { kind: 'invalid', errorText: `${fieldPath} must not be empty` };
+        }
+        return { kind: 'present', manual: { content: text, sections: [] } };
+    }
+    if (!isObjectRecord(value)) {
+        return {
+            kind: 'invalid',
+            errorText: `${fieldPath} must be either a string, or an object with optional content, contentFile, sections`,
+        };
+    }
+    const supportedKeys = new Set(['content', 'contentFile', 'sections']);
+    const unknownKeys = Object.keys(value).filter((key) => !supportedKeys.has(key));
+    const warningText = unknownKeys.length > 0
+        ? `${fieldPath} contains unsupported extra field(s): ${unknownKeys
+            .map((key) => `${fieldPath}.${key}`)
+            .join(', ')} (only content, contentFile, sections are used)`
+        : undefined;
+    const contentVal = value['content'];
+    let content;
+    if (contentVal !== undefined) {
+        if (!isNonEmptyString(contentVal)) {
+            return {
+                kind: 'invalid',
+                errorText: `${fieldPath}.content must be a non-empty string when provided`,
+                ...(warningText !== undefined ? { warningText } : {}),
+            };
+        }
+        content = contentVal.trim();
+    }
+    const contentFileVal = value['contentFile'];
+    let contentFile;
+    if (contentFileVal !== undefined) {
+        if (!isNonEmptyString(contentFileVal)) {
+            return {
+                kind: 'invalid',
+                errorText: `${fieldPath}.contentFile must be a non-empty string when provided`,
+                ...(warningText !== undefined ? { warningText } : {}),
+            };
+        }
+        contentFile = contentFileVal.trim();
+    }
+    const sectionsVal = value['sections'];
+    const sections = [];
+    if (sectionsVal !== undefined) {
+        if (Array.isArray(sectionsVal)) {
+            for (let i = 0; i < sectionsVal.length; i++) {
+                const sectionVal = sectionsVal[i];
+                if (!isObjectRecord(sectionVal)) {
+                    return {
+                        kind: 'invalid',
+                        errorText: `${fieldPath}.sections[${i}] must be an object with title/content non-empty strings`,
+                        ...(warningText !== undefined ? { warningText } : {}),
+                    };
+                }
+                const title = sectionVal['title'];
+                const sectionContent = sectionVal['content'];
+                if (!isNonEmptyString(title) || !isNonEmptyString(sectionContent)) {
+                    return {
+                        kind: 'invalid',
+                        errorText: `${fieldPath}.sections[${i}] must provide non-empty title/content strings`,
+                        ...(warningText !== undefined ? { warningText } : {}),
+                    };
+                }
+                sections.push({ title: title.trim(), content: sectionContent.trim() });
+            }
+        }
+        else if (isObjectRecord(sectionsVal)) {
+            for (const [sectionTitle, sectionContent] of Object.entries(sectionsVal)) {
+                if (!isNonEmptyString(sectionTitle) || !isNonEmptyString(sectionContent)) {
+                    return {
+                        kind: 'invalid',
+                        errorText: `${fieldPath}.sections object entries must be non-empty string -> string`,
+                        ...(warningText !== undefined ? { warningText } : {}),
+                    };
+                }
+                sections.push({ title: sectionTitle.trim(), content: sectionContent.trim() });
+            }
+        }
+        else {
+            return {
+                kind: 'invalid',
+                errorText: `${fieldPath}.sections must be either [{ title, content }] or { "<title>": "<content>" }`,
+                ...(warningText !== undefined ? { warningText } : {}),
+            };
+        }
+    }
+    if (content === undefined && contentFile === undefined && sections.length === 0) {
+        return {
+            kind: 'invalid',
+            errorText: `${fieldPath} must provide at least one of content, contentFile, or sections`,
+            ...(warningText !== undefined ? { warningText } : {}),
+        };
+    }
+    return {
+        kind: 'present',
+        manual: { content, contentFile, sections },
+        ...(warningText !== undefined ? { warningText } : {}),
+    };
+}
+function buildMcpToolsetManualInvalidProblem(serverId, errorText) {
+    return {
+        kind: 'mcp_server_error',
+        source: 'mcp',
+        id: `${mcpToolsetManualProblemPrefix(serverId)}error`,
+        severity: 'error',
+        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        message: `MCP server '${serverId}' manual declaration is invalid`,
+        messageI18n: {
+            en: `MCP server '${serverId}' manual declaration is invalid`,
+            zh: `MCP server '${serverId}' 的手册声明无效`,
+        },
+        detailTextI18n: {
+            en: errorText,
+            zh: errorText,
+        },
+        detail: { serverId, errorText },
+    };
+}
+function buildMcpToolsetManualUnknownFieldsProblem(serverId, warningText) {
+    return {
+        kind: 'mcp_server_error',
+        source: 'mcp',
+        id: `${mcpToolsetManualProblemPrefix(serverId)}unknown_fields`,
+        severity: 'warning',
+        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        message: `MCP server '${serverId}' manual declaration has unsupported extra fields`,
+        messageI18n: {
+            en: `MCP server '${serverId}' manual declaration has unsupported extra fields`,
+            zh: `MCP server '${serverId}' 的手册声明含有不支持的附加字段`,
+        },
+        detailTextI18n: {
+            en: `${warningText}\nThese extra fields are ignored by the manual loader. Keep only content, contentFile, and sections under \`servers.${serverId}.manual\`.`,
+            zh: `${warningText}\n这些附加字段会被手册加载器忽略。请仅在 \`servers.${serverId}.manual\` 下保留 content、contentFile、sections。`,
+        },
+        detail: { serverId, errorText: warningText },
+    };
+}
+function buildMcpToolsetManualTooLargeProblem(args) {
+    const errorText = `man({ "toolsetId": "${args.serverId}" }) rendered manual exceeds limit (${args.renderedChars} chars > ${args.limitChars} chars)`;
+    return {
+        kind: 'mcp_server_error',
+        source: 'mcp',
+        id: `${mcpToolsetManualProblemPrefix(args.serverId)}too_large`,
+        severity: 'error',
+        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        message: `MCP server '${args.serverId}' manual result is too large`,
+        messageI18n: {
+            en: `MCP server '${args.serverId}' manual result is too large`,
+            zh: `MCP server '${args.serverId}' 的手册结果过长`,
+        },
+        detailTextI18n: {
+            en: `${errorText}\nThe actual MCP toolset manual shown to the LLM is too large. Split the handbook by business topic so the default \`man({ "toolsetId": "${args.serverId}" })\` result stays within ${args.limitChars} chars.`,
+            zh: `\`man({ "toolsetId": "${args.serverId}" })\` 的实际手册结果过长（${args.renderedChars} chars > ${args.limitChars} chars）\n请按业务主题拆小手册，保证默认 \`man({ "toolsetId": "${args.serverId}" })\` 结果不超过 ${args.limitChars} chars。`,
+        },
+        detail: { serverId: args.serverId, errorText },
+    };
+}
+function buildMcpWorkspaceManualTooLargeProblem(args) {
+    const errorText = `man({ "toolsetId": "team_mgmt", "topics": ["mcp"] }) rendered manual exceeds limit (${args.renderedChars} chars > ${args.limitChars} chars)`;
+    return {
+        kind: 'mcp_workspace_config_error',
+        source: 'mcp',
+        id: `${mcpWorkspaceManualProblemPrefix()}team_mgmt_mcp_too_large`,
+        severity: 'error',
+        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        message: 'Rendered MCP handbook topic is too large',
+        messageI18n: {
+            en: 'Rendered MCP handbook topic is too large',
+            zh: 'MCP 手册主题的渲染结果过长',
+        },
+        detailTextI18n: {
+            en: `${errorText}\nThis check measures the final handbook content shown to the LLM. Split MCP handbook content so \`man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })\` stays within ${args.limitChars} chars.`,
+            zh: `\`man({ "toolsetId": "team_mgmt", "topics": ["mcp"] })\` 的实际手册结果过长（${args.renderedChars} chars > ${args.limitChars} chars）\n该检查衡量的是最终给 LLM 看的手册内容。请拆小 MCP 手册内容，保证该结果不超过 ${args.limitChars} chars。`,
+        },
+        detail: { filePath: args.workspaceManualPath, errorText },
+    };
+}
+function measureRenderedToolsetManualRawChars(serverId) {
+    const tools = (0, registry_1.getToolset)(serverId);
+    const meta = (0, registry_1.getToolsetMeta)(serverId);
+    if (!tools || meta?.source !== 'mcp')
+        return null;
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
+    const zh = (0, render_1.renderToolsetManual)({
+        toolsetId: serverId,
+        language: 'zh',
+        request: {},
+        availableToolNames,
+    });
+    const en = (0, render_1.renderToolsetManual)({
+        toolsetId: serverId,
+        language: 'en',
+        request: {},
+        availableToolNames,
+    });
+    if (!zh.foundToolset || !en.foundToolset)
+        return null;
+    return Math.max(zh.content.length, en.content.length);
+}
+async function reconcileMcpToolsetManualProblems(params) {
+    const desiredServerIds = new Set(params.serverIds);
+    const stalePrefixes = new Set();
+    for (const problem of (0, problems_1.listProblems)({ source: 'mcp' })) {
+        const match = problem.id.match(/^(mcp\/server\/[^/]+\/toolset_manual_)/);
+        if (!match || typeof match[1] !== 'string')
+            continue;
+        const serverId = problem.kind === 'mcp_server_error' ? problem.detail.serverId : null;
+        if (serverId !== null && desiredServerIds.has(serverId))
+            continue;
+        stalePrefixes.add(match[1]);
+    }
+    for (const prefix of stalePrefixes) {
+        (0, problems_1.reconcileProblemsByPrefix)(prefix, []);
+    }
+    const workspaceDesired = [];
+    const teamMgmtMcpTopicChars = await params.measureRenderedWorkspaceMcpTopicRawChars();
+    if (teamMgmtMcpTopicChars > output_limit_1.MANUAL_SINGLE_REQUEST_CHAR_LIMIT) {
+        workspaceDesired.push(buildMcpWorkspaceManualTooLargeProblem({
+            renderedChars: teamMgmtMcpTopicChars,
+            limitChars: output_limit_1.MANUAL_SINGLE_REQUEST_CHAR_LIMIT,
+            workspaceManualPath: params.workspaceManualPath,
+        }));
+    }
+    (0, problems_1.reconcileProblemsByPrefix)(mcpWorkspaceManualProblemPrefix(), workspaceDesired);
+    for (const serverId of params.serverIds) {
+        const desired = [];
+        const invalid = params.manualInfo.invalidByServerId.get(serverId);
+        if (invalid !== undefined) {
+            desired.push(buildMcpToolsetManualInvalidProblem(serverId, invalid));
+        }
+        const warningText = params.manualInfo.warningTextByServerId.get(serverId);
+        if (warningText !== undefined) {
+            desired.push(buildMcpToolsetManualUnknownFieldsProblem(serverId, warningText));
+        }
+        const renderedToolsetManualChars = measureRenderedToolsetManualRawChars(serverId);
+        if (renderedToolsetManualChars !== null &&
+            renderedToolsetManualChars > output_limit_1.MANUAL_SINGLE_REQUEST_CHAR_LIMIT) {
+            desired.push(buildMcpToolsetManualTooLargeProblem({
+                serverId,
+                renderedChars: renderedToolsetManualChars,
+                limitChars: output_limit_1.MANUAL_SINGLE_REQUEST_CHAR_LIMIT,
+            }));
+        }
+        (0, problems_1.reconcileProblemsByPrefix)(mcpToolsetManualProblemPrefix(serverId), desired);
+    }
+}

package/dist/mcp/supervisor.js

@@ -51,7 +51,9 @@ const work_language_1 = require("../runtime/work-language");
 const tool_1 = require("../tool");
 const spec_1 = require("../tools/manual/spec");
 const registry_1 = require("../tools/registry");
+const team_mgmt_mcp_manual_1 = require("../tools/team_mgmt-mcp-manual");
 const config_1 = require("./config");
+const manual_problems_1 = require("./manual-problems");
 const sdk_client_1 = require("./sdk-client");
 const server_runtime_1 = require("./server-runtime");
 const tool_names_1 = require("./tool-names");
@@ -533,20 +535,24 @@ async function reloadNow(reason) {
             // Deletion is treated as empty config.
             await applyWorkspaceConfig({ version: 1, servers: {} }, [], [], [], `missing file (${reason})`);
             clearWorkspaceConfigProblem();
+            await reconcileMcpManualProblemsForRuntime([], null);
             return;
         }
         clearDeclaredServerRuntimeCatalog();
+        await reconcileMcpManualProblemsForRuntime([], null);
         upsertWorkspaceConfigProblem(`Failed to read ${MCP_YAML_PATH}: ${String(err)}`);
         return;
     }
     const parsed = (0, config_1.parseMcpYaml)(rawText);
     if (!parsed.ok) {
         clearDeclaredServerRuntimeCatalog();
+        await reconcileMcpManualProblemsForRuntime([], null);
         upsertWorkspaceConfigProblem(parsed.errorText);
         return;
     }
     clearWorkspaceConfigProblem();
     await applyWorkspaceConfig(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder, parsed.validServerIdsInYamlOrder, reason);
+    await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
 }
 async function restartServerNow(serverId) {
     let rawText;
@@ -558,13 +564,16 @@ async function restartServerNow(serverId) {
         if (code === 'ENOENT') {
             // Deletion is treated as empty config, so restart cannot proceed.
             clearWorkspaceConfigProblem();
+            await reconcileMcpManualProblemsForRuntime([], null);
             return { ok: false, errorText: `Cannot restart '${serverId}': ${MCP_YAML_PATH} is missing` };
         }
+        await reconcileMcpManualProblemsForRuntime([], null);
         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);
     if (!parsed.ok) {
+        await reconcileMcpManualProblemsForRuntime([], null);
         upsertWorkspaceConfigProblem(parsed.errorText);
         return { ok: false, errorText: parsed.errorText };
     }
@@ -572,11 +581,13 @@ async function restartServerNow(serverId) {
     const invalid = parsed.invalidServers.find((s) => s.serverId === serverId);
     if (invalid) {
         replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder);
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
         upsertMcpServerConfigInvalidProblem(serverId, invalid.errorText);
         return { ok: false, errorText: invalid.errorText };
     }
     const serverCfg = parsed.config.servers[serverId];
     if (!serverCfg) {
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
         return {
             ok: false,
             errorText: `MCP server '${serverId}' is not configured in ${MCP_YAML_PATH}`,
@@ -588,6 +599,7 @@ async function restartServerNow(serverId) {
     replaceDeclaredServerRuntimeCatalog(parsed.config, parsed.invalidServers, parsed.serverIdsInYamlOrder);
     const res = await tryBuildServerState(serverCfg, desiredToolsetName, fingerprint);
     if (!res.ok) {
+        await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
         upsertDeclaredServerRuntimeError(serverId, res.errorText);
         upsertMcpServerRuntimeUnavailableProblem(serverId, res.errorText, res.detailTextI18n);
         return { ok: false, errorText: res.errorText };
@@ -602,8 +614,18 @@ async function restartServerNow(serverId) {
     serverStateById.set(serverId, res.state);
     (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), res.state.problems);
     reorderMcpToolsetsInRegistry(parsed.serverIdsInYamlOrder);
+    await reconcileMcpManualProblemsForRuntime(parsed.serverIdsInYamlOrder, rawText);
     return { ok: 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)({
+        serverIds: serverIdsInYamlOrder,
+        manualInfo,
+        measureRenderedWorkspaceMcpTopicRawChars: team_mgmt_mcp_manual_1.measureRenderedTeamMgmtMcpTopicRawChars,
+        workspaceManualPath: MCP_YAML_PATH,
+    });
+}
 function upsertWorkspaceConfigProblem(errorText) {
     (0, problems_1.upsertProblem)({
         kind: 'mcp_workspace_config_error',
@@ -707,7 +729,7 @@ async function applyWorkspaceConfig(config, invalidServers, serverIdsInYamlOrder
         unregisterServer(state);
         state.dispatch.requestStop();
         serverStateById.delete(serverId);
-        (0, problems_1.removeProblemsByPrefix)(problemPrefixForServer(serverId));
+        (0, problems_1.reconcileProblemsByPrefix)(problemPrefixForServer(serverId), []);
     }
     // Surface invalid server config errors (while keeping last-known-good runtimes registered).
     for (const s of invalidServers) {