@oh-agent/dsh-mcp-manager 0.1.2 → 0.1.4

package/README.en.md

@@ -4,8 +4,9 @@ English · [中文](README.md)
 
 Management page for the MCP servers scattered across every local AI development
 tool — one card per configuration file showing what it declares, one switch per
-server that mounts it in DeepSeek Harness, and one probe of what actually
-answers.
+server that mounts it in DeepSeek Harness, one probe of what actually answers,
+and, more importantly, a straight answer to whether it **really loaded** in the
+harness, with a retry button when it did not.
 
 DeepSeek Harness → **Settings → MCP Manager** (between Skills Manager and
 Market).
@@ -16,12 +17,12 @@ Install the bundle from the **Plugin Manager** page in Settings, or point
 `plugin_manager` at the npm package:
 
 ```
-plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.2"
+plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.4"
 ```
 
 An absolute directory works as `target` too, which is how you install a local
 checkout or the `dsh-mcp-manager.tgz` attached to the
-[v0.1.2 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases).
+[v0.1.4 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases).
 
 Do not `pnpm add` the package into the profile by hand, and do not edit the
 profile's `package.json` or `cordis.patch.yml`: installing a package is not the
@@ -234,19 +235,60 @@ Because the override is a separate item and not a rewrite, and because a row we
 wrote is removed rather than disabled, a full mount → unmount cycle returns
 `cordis.patch.yml` to its exact previous bytes.
 
+### Mounted is not loaded
+
+This is the field most likely to lie. A row existing in `cordis.patch.yml` proves
+only that it was **mounted**; it says nothing about whether `npx` started or the
+handshake succeeded.
+
+`@deepseek-ai/dsh-mcp-client` ships `failOnStartupError: false` by default, which
+buries the failure: `apply()` awaits `connection.ready` and, on error, simply
+returns instead of throwing. So the row's `fiberPhase` in the Plugin Manager
+stays `active` — every indicator is green and there are still no tools. Switch
+Node to 14 and start the harness and this is exactly what you get: the old Node
+runtime cannot run a modern MCP server, the process exits immediately, and
+nothing in the UI reports anything wrong.
+
+So this plugin ignores `fiberPhase` and reads the **tool registry** instead. A
+server that connected successfully necessarily registered tools named
+`mcp__<serverName>__<tool>`. Some are present → `loaded`; none are → `failed`.
+That is the part that tells the truth.
+
+| What the page shows | What it means |
+| --- | --- |
+| `loaded · N tools` | Connection succeeded, tools registered, the agent can call them now |
+| `mounted but failed to load` + Retry | The row is mounted but no tool registered — the process never started, or the handshake failed |
+| `activating` | The patch row was just written; the Loader has not recomposed yet |
+| `load state unknown` | The tool registry cannot be read (older host) — **no conclusion is drawn**, and it is never reported as a failure |
+
+Reporting "unknown" rather than "failed" when the registry is unavailable is
+deliberate: marking a healthy server as broken is worse than marking nothing.
+
+Retry goes through `hmr.reconcileProfile([entryId])`, serialized inside
+`hmr.runExclusive`. That makes the Loader re-import the rows that failed and
+judge activation. Backoff retries after a failed connection are the mcp-client's
+own business, but once it gives up it registers nothing and waits for a reload
+that a settings page cannot deliver — so the reload has to come from us.
+Reconnecting is not instant (process spawn plus handshake), so the page re-reads
+state 2.5 seconds after the button is pressed.
+
+`scripts/test-load.mjs` pins this down, mostly the boundary between `unknown`,
+`failed` and `loaded`, plus the name matching that decides which tools belong to
+which server.
+
 ### A mount name is not always the display name
 
 `@deepseek-ai/dsh-mcp-client` requires `serverName` to match
-`/^[A-Za-z0-9_-]{1,32}$/`. Many real servers do not — this machine has a dozen
-named `表单管理系统 - API 文档` and friends, and `Figma AI Bridge` has a space.
+`/^[A-Za-z0-9_-]{1,32}$/`. Many real servers do not — Chinese names commonly look
+like `示例服务器 - API 文档`, and an English name like `My Bridge` carries a space.
 Squeezing those through `sanitizeName` alone gives `API` for every Chinese name,
 so a second mount would collide with the first and the switch would flip the wrong
 server.
 
 `canonical.js` therefore exports `dshMountName(name)`: sanitize, and if the result
 lost information (CJK characters, spaces, over-length) append a short hash of the
-original — `表单管理系统 - API 文档` → `API-c2f500c4`, `Figma AI Bridge` →
-`Figma-AI-Bridge`. It is pure and total, so the write path, the scan, the toggle
+original — `示例服务器 - API 文档` → `API-0aac0ee2`, `My Bridge` →
+`My-Bridge`. It is pure and total, so the write path, the scan, the toggle
 and the removal all compute the same string from the same input without storing a
 mapping anywhere.
 
@@ -265,18 +307,18 @@ the round trip through scan.
 ## Using it
 
 The page is laid out like the skills page it sits next to: a title row with the
-actions, a four-cell summary strip (servers · files · mounted in DSH · literal
-credentials), a filter row, then one bordered card per config file.
+actions, a five-cell summary strip (servers · files · mounted in DSH · loaded ·
+literal credentials), a filter row, then one bordered card per config file.
 
 Each card lists the servers that file declares — headed by the tool name, the
 server count and the path (shortened to `%APPDATA%\…` style, full path in the
 tooltip). A card collapses; while a filter is active every card opens, because a
 match hidden inside a collapsed card reads as "no results". Every row shows the
-transport, the command or URL, how many tools share the definition, its probe
-result, and the mount switch.
+transport, the command or URL, its **load state**, how many tools share the
+definition, its probe result, and the mount switch.
 
 The filters are a free-text search (name, command, path) plus two selects: by
-tool, and by mount state (mounted / not mounted).
+tool, and by state (mounted / not mounted / **mounted but failed to load**).
 
 Clicking a row opens a dialog rather than expanding it in place — inline
 expansion reflows every row below and made the card look like two stacked cards.
@@ -288,7 +330,7 @@ The same operations are exposed to the agent as the `mcp_manage` tool, so the
 page and the agent share one implementation and cannot diverge:
 
 ```
-action: scan | probe | toggle | apply | remove | sync | snippet | reveal | history
+action: scan | probe | retry | toggle | apply | remove | sync | snippet | reveal | history
 ```
 
 ## Configuration
@@ -318,10 +360,11 @@ one in a command-line flag (`--figma-api-key` in Qoder's `mcp.json`). None of
 their literals appears anywhere in the state payload; the page shows only key
 names, and the write path refuses a masked value.
 
-Thirteen test suites under `scripts/` cover the editors, the path layer, the write
-path, the DSH adapter, the patch layer, the mount switch, the mount-name mapping
-for non-ASCII server names, redaction and the masked-write guard, plus an
-end-to-end pass that asserts no credential literal reaches the client payload:
+Fourteen test suites under `scripts/` cover the editors, the path layer, the write
+path, the DSH adapter, the patch layer, the mount switch, runtime load-state
+detection, the mount-name mapping for non-ASCII server names, redaction and the
+masked-write guard, plus an end-to-end pass that asserts no credential literal
+reaches the client payload:
 
 ```
 node scripts/test-surgical.mjs      17 passing
@@ -330,6 +373,7 @@ node scripts/test-dsh.mjs           16 passing
 node scripts/test-dsh-patch.mjs     15 passing
 node scripts/test-dsh-e2e.mjs        8 passing
 node scripts/test-toggle.mjs        16 passing
+node scripts/test-load.mjs          15 passing
 node scripts/test-redact.mjs        14 passing
 node scripts/test-masked-write.mjs   5 passing
 node scripts/test-client-load.mjs   28 passing
@@ -352,6 +396,12 @@ node scripts/test-release.mjs        11 passing
   `disabled: true` override the plugin manager writes, and stays in the file.
 - **Only DSH is switchable.** The other tools' files are read and written
   explicitly, never toggled — see the section above.
+- **Load state only covers DSH's own connections.** Whether a server in another
+  tool actually starts is knowable only by pressing probe; those tools are not in
+  this harness's tool registry and there is nowhere else to read it from.
+- **A server with no tools is reported as a failed load.** The judgement is the
+  tool registry, so a connection that succeeds but exposes zero tools looks the
+  same as one that never connected. Such servers are rare, but they exist.
 - **Continue is read-only** (YAML array shape); editing it is planned.
 - **Secrets are not migrated to a vault.** The plugin masks and warns; moving
   credentials into `${env:...}` references stays the user's decision.

package/README.md

@@ -2,7 +2,7 @@
 
 **中文** · [English](README.en.md)
 
-一个设置页，管理散落在本机各个 AI 开发工具里的 MCP 服务器 —— 每个配置文件一张卡片，显示它声明了什么；每个服务器一个开关，把它挂载进 DeepSeek Harness；再加一次真连探活，看它到底能不能起来。
+一个设置页，管理散落在本机各个 AI 开发工具里的 MCP 服务器 —— 每个配置文件一张卡片，显示它声明了什么；每个服务器一个开关，把它挂载进 DeepSeek Harness；再加一次真连探活，看它到底能不能起来；更重要的是，页面直接告诉你它在 Harness 里**到底加载成功没有**，失败了可以就地重试。
 
 入口：DeepSeek Harness → **设置 → MCP**（位于「技能管理」和「插件市场」之间）。
 
@@ -17,11 +17,11 @@
 直接说「安装 @oh-agent/dsh-mcp-manager」，等价于：
 
 ```
-plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.2"
+plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.4"
 ```
 
 `target` 也可以填一个绝对目录 —— 本地源码目录，或者
-[v0.1.2 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases) 里附的
+[v0.1.4 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases) 里附的
 `dsh-mcp-manager.tgz` 解出来的目录。
 
 **不要**手动 `pnpm add` 进 profile，也不要手改 profile 的 `package.json` 或
@@ -145,11 +145,32 @@ client.js  (设置页)                 index.js  (宿主入口)
 
 因为覆盖项是独立的一项而不是重写，且我们自己写的行是删除而不是禁用，一次完整的挂载 → 卸载循环会把 `cordis.patch.yml` 还原到精确的原始字节。
 
+### 挂上了 ≠ 加载成功了
+
+这是最容易撒谎的一格。行存在于 `cordis.patch.yml` 里，只证明它**被挂载**了；它一点都不能证明 `npx` 起没起来、握手成没成功。
+
+`@deepseek-ai/dsh-mcp-client` 的默认 `failOnStartupError: false` 让这件事更隐蔽：`apply()` 会等 `connection.ready`，连接失败时**只是返回**，不抛错。于是插件管理页里那一行的 `fiberPhase` 照样是 `active` —— 你看到的每一项都是绿的，工具却一个都没有。把 Node 切到 14 再启动 DSH 就是这个现象：老 Node 跑不了新语法的 MCP 服务器，进程立刻退出，界面上却什么异常都没有。
+
+所以本插件不看 `fiberPhase`，改看**工具注册表**：一个连接成功的 MCP 服务器，必然在 `tools` 里注册了 `mcp__<serverName>__<工具名>` 形式的工具。有就是 `loaded`，一条都没有就是 `failed`，这才是真话。
+
+| 页面显示 | 含义 |
+| --- | --- |
+| `已加载 · N 个工具` | 连接成功，工具已注册，agent 现在就能调 |
+| `已挂载但加载失败` + 「重试」 | 行挂上了，但一个工具都没注册 —— 进程没起来或握手失败 |
+| `正在激活` | 刚写完补丁行，Loader 还没重排完 |
+| `加载状态未知` | 读不到工具注册表（老版本宿主），此时**不下结论**，绝不误判成失败 |
+
+拿不到注册表时宁可显示「未知」也不显示「失败」：把一台健康的服务器标成坏的，比不标更糟。
+
+「重试」走的是 `hmr.reconcileProfile([entryId])`（在 `hmr.runExclusive` 里串行执行），它会让 Loader 重新导入那些失败的行并判定激活结果 —— 连接失败之后的退避重试是 mcp-client 自己的事，可它一旦放弃就什么都不注册、只等一次重载，而设置页给不了这次重载，所以必须由我们来触发。重连不是瞬时的（起进程 + 握手），因此按钮点完 2.5 秒后页面会自己再读一次状态。
+
+`scripts/test-load.mjs` 钉住了这套判定，重点是 `unknown` / `failed` / `loaded` 三者的边界，以及按名字归属工具时不能张冠李戴。
+
 ### 挂载名不总是显示名
 
-`@deepseek-ai/dsh-mcp-client` 要求 `serverName` 匹配 `/^[A-Za-z0-9_-]{1,32}$/`。现实中很多服务器不满足 —— 这台机器上有十几个叫 `表单管理系统 - API 文档` 之类，`Figma AI Bridge` 带空格。只用 `sanitizeName` 压一遍，所有中文名都会变成 `API`，第二个挂载就会和第一个撞名，开关就会翻错服务器。
+`@deepseek-ai/dsh-mcp-client` 要求 `serverName` 匹配 `/^[A-Za-z0-9_-]{1,32}$/`。现实中很多服务器不满足 —— 大量中文名形如 `示例服务器 - API 文档`，也有带空格的英文名形如 `My Bridge`。只用 `sanitizeName` 压一遍，所有中文名都会变成 `API`，第二个挂载就会和第一个撞名，开关就会翻错服务器。
 
-因此 `canonical.js` 导出 `dshMountName(name)`：先 sanitize，如果结果丢了信息（中日韩字符、空格、超长），就追加原名的短哈希 —— `表单管理系统 - API 文档` → `API-c2f500c4`，`Figma AI Bridge` → `Figma-AI-Bridge`。它是纯函数且全域的，所以写入路径、扫描、开关、移除都从同一输入算出同一字符串，不需要在任何地方存映射表。
+因此 `canonical.js` 导出 `dshMountName(name)`：先 sanitize，如果结果丢了信息（中日韩字符、空格、超长），就追加原名的短哈希 —— `示例服务器 - API 文档` → `API-0aac0ee2`，`My Bridge` → `My-Bridge`。它是纯函数且全域的，所以写入路径、扫描、开关、移除都从同一输入算出同一字符串，不需要在任何地方存映射表。
 
 扫描和页面处理的后果：
 
@@ -161,18 +182,18 @@ client.js  (设置页)                 index.js  (宿主入口)
 
 ## 怎么用
 
-页面布局和它旁边的技能页一致：标题行加操作按钮，四格汇总条（服务器 · 文件 · 已挂载进 DSH · 字面凭据），筛选行，然后每个配置文件一张带边框的卡片。
+页面布局和它旁边的技能页一致：标题行加操作按钮，五格汇总条（服务器 · 文件 · 已挂载进 DSH · 已加载 · 字面凭据），筛选行，然后每个配置文件一张带边框的卡片。
 
-每张卡片列出该文件声明的服务器 —— 头部是工具名、服务器数量和路径（缩短成 `%APPDATA%\…` 风格，完整路径在 tooltip 里）。卡片可折叠；筛选生效时所有卡片都会展开，因为藏在折叠卡片里的命中会被读成「没有结果」。每行显示传输方式、命令或 URL、有多少工具共用这份定义、探活结果，以及挂载开关。
+每张卡片列出该文件声明的服务器 —— 头部是工具名、服务器数量和路径（缩短成 `%APPDATA%\…` 风格，完整路径在 tooltip 里）。卡片可折叠；筛选生效时所有卡片都会展开，因为藏在折叠卡片里的命中会被读成「没有结果」。每行显示传输方式、命令或 URL、**加载状态**、有多少工具共用这份定义、探活结果，以及挂载开关。
 
-筛选是一个自由文本搜索（名字、命令、路径）加两个下拉：按工具、按挂载状态（已挂载 / 未挂载）。
+筛选是一个自由文本搜索（名字、命令、路径）加两个下拉：按工具、按状态（已挂载 / 未挂载 / **已挂载但加载失败**）。
 
 点击一行打开对话框，而不是在原地展开 —— 原地展开会把它下面每一行都重排，让一张卡片看起来像两张叠在一起。对话框列出声明该服务器的每个文件、统一后的定义、一条可直接粘贴进 cordis 组合的 YAML 行，以及「复制到…」用于把定义推到别的工具。
 
 同一批操作也以 `mcp_manage` 工具暴露给 agent，所以页面和 agent 共用一份实现，不可能走岔：
 
 ```
-action: scan | probe | toggle | apply | remove | sync | snippet | reveal | history
+action: scan | probe | retry | toggle | apply | remove | sync | snippet | reveal | history
 ```
 
 ## 配置
@@ -194,7 +215,7 @@ action: scan | probe | toggle | apply | remove | sync | snippet | reveal | histo
 
 磁盘上发现 21 处明文凭据 —— 多数在 `env` 映射里，一处在命令行参数里（Qoder `mcp.json` 的 `--figma-api-key`）。它们的字面值没有出现在 state 载荷的任何位置；页面只显示键名，写入路径拒绝被掩码的值。
 
-`scripts/` 下十三个测试套件覆盖编辑器、路径层、写入路径、DSH 适配器、补丁层、挂载开关、非 ASCII 服务器名的挂载名映射、脱敏与掩码写入防护、发布元数据一致性，外加一次端到端断言：没有任何凭据字面值进入客户端载荷。
+`scripts/` 下十四个测试套件覆盖编辑器、路径层、写入路径、DSH 适配器、补丁层、挂载开关、运行时加载状态判定、非 ASCII 服务器名的挂载名映射、脱敏与掩码写入防护、发布元数据一致性，外加一次端到端断言：没有任何凭据字面值进入客户端载荷。
 
 ```
 node scripts/test-surgical.mjs      17 passing
@@ -203,6 +224,7 @@ node scripts/test-dsh.mjs           16 passing
 node scripts/test-dsh-patch.mjs     15 passing
 node scripts/test-dsh-e2e.mjs        8 passing
 node scripts/test-toggle.mjs        16 passing
+node scripts/test-load.mjs          15 passing
 node scripts/test-redact.mjs        14 passing
 node scripts/test-masked-write.mjs   5 passing
 node scripts/test-client-load.mjs   28 passing
@@ -218,6 +240,8 @@ node scripts/test-release.mjs        11 passing
 - **新挂载的 DSH 服务器依赖 Loader 重排。** 操作最多等 8 秒并上报 `live: true`；窗口过期则上报 `activating: true`，页面稍后重新读取状态。对 Loader 看得见的行，永不索要重启。
 - **不是我们写的行只被关闭，不会被删除。** 删掉用户粘进去的定义等于毁掉他的工作，所以这样的行会得到与插件管理器相同的那种 `disabled: true` 覆盖项，并留在文件里。
 - **只有 DSH 可切换。** 其他工具的文件只被显式读写，从不切换 —— 见上文。
+- **加载状态只能看见 DSH 自己的连接。** 别的工具的服务器有没有真正跑起来，只有点「探活」才知道；它们不在这个 Harness 的工具注册表里，没别的地方能读到。
+- **没有工具的服务会被报成「加载失败」。** 判定依据是工具注册表，所以一个连接完全成功、但本身不提供任何工具的服务器，看起来和连不上是一样的。这种服务器很少，但确实存在。
 - **Continue 只读**（YAML 数组形态）；编辑在计划中。
 - **凭据不会被迁移进保险库。** 插件只做掩码和告警；把凭据换成 `${env:...}` 引用仍是用户自己的决定。
 - **不查询 MCP 注册表。** `registry.modelcontextprotocol.io` 明确是预览态且不面向宿主直接消费，所以服务器发现只靠扫描本地文件。

package/lib/canonical.js

@@ -267,12 +267,12 @@ export function sanitizeName(raw, fallback = 'server') {
  *
  * The harness's own `@deepseek-ai/dsh-mcp-client` constrains `serverName` to
  * `/^[A-Za-z0-9_-]{1,32}$/` (lib/index.js of that package, the zod schema and
- * `SERVER_NAME_PATTERN`), so a name like `表单管理系统 - API 文档` CANNOT be used
+ * `SERVER_NAME_PATTERN`), so a name like `示例服务器 - API 文档` CANNOT be used
  * verbatim. It has to be mapped.
  *
  * `sanitizeName` alone is not a usable mapping here: every CJK name collapses
- * to whatever ASCII fragments it contains — `表单管理系统 - API 文档`,
- * `方案生成助手 - API 文档` and `心理健康关爱系统 - API 文档` ALL become `API`, and
+ * to whatever ASCII fragments it contains — `示例服务器 - API 文档`,
+ * `示例助手 - API 文档` and `另一个服务 - API 文档` ALL become `API`, and
  * for a fully-CJK name it falls back to the constant `server`. That collision is
  * not cosmetic. It produced two visible bugs: the mount row was created under
  * `API`, the page looked the mount up by the display name (found nothing), so
@@ -283,7 +283,7 @@ export function sanitizeName(raw, fallback = 'server') {
  *
  *   1. An all-ASCII name keeps `sanitizeName`'s result unchanged. Those names
  *      are already readable and already distinct from each other, so
- *      `Figma AI Bridge` stays `Figma-AI-Bridge` and `my server!` stays
+ *      `My Bridge` stays `My-Bridge` and `my server!` stays
  *      `my-server` — which also means rows mounted before this mapping existed
  *      keep their identity.
  *   2. A name with any non-ASCII character — CJK, full-width punctuation,

package/lib/client.js

@@ -50,12 +50,14 @@ window.__ModuleLoader__.load({
         'summary.servers': 'servers',
         'summary.files': 'files',
         'summary.mounted': 'mounted in DSH',
+        'summary.loaded': 'loaded',
         'summary.secrets': 'literal credentials',
         'filter.search': 'Filter by name, command or path',
         'filter.toolAll': 'All tools',
         'filter.statusAll': 'All servers',
         'filter.statusMounted': 'Mounted in DSH',
         'filter.statusUnmounted': 'Not mounted',
+        'filter.statusFailed': 'Mounted but failed to load',
         'label.project': 'project',
         'label.global': 'global',
         'label.profile': 'profile',
@@ -64,6 +66,10 @@ window.__ModuleLoader__.load({
         'label.mounted': 'mounted',
         'label.off': 'off',
         'label.shared': 'in {count} files',
+        'label.loaded': 'loaded',
+        'label.loadFailed': 'failed to load',
+        'label.loadUnknown': 'load unknown',
+        'btn.retry': 'Retry',
         'switch.title': 'Mount in DeepSeek Harness (this never edits {client})',
         'detail.targets': 'Declared in',
         'detail.definition': 'Definition',
@@ -75,6 +81,14 @@ window.__ModuleLoader__.load({
         'probe.ok': 'healthy · {tools} tools · {ms}ms',
         'probe.failed': 'failed',
         'probe.tools': '{count} tools',
+        'load.loaded': 'loaded · {count} tools',
+        'load.failed': 'failed to load',
+        'load.failedTitle': 'Mounted in DeepSeek Harness, but no tool was ever registered — the connection did not succeed. A server that declares no tools looks the same, so run a test to confirm.',
+        'load.unknown': 'load unknown',
+        'load.unknownTitle': 'The tool registry is not available, so whether this server connected cannot be checked from here.',
+        'toast.retried': 'Reconnected “{name}” — {count} tools are live now.',
+        'toast.retryFailed': '“{name}” is still not loaded. Run a test to see why the process will not start.',
+        'error.retry': 'DeepSeek Harness could not re-run this connection.',
         'banner.secrets': '{count} server(s) store credentials as literal text in a configuration file that may be committed.',
         'banner.parse': '{count} file(s) could not be parsed.',
         'confirm.sync': 'Copy “{name}” into {count} other tool(s)?',
@@ -115,12 +129,14 @@ window.__ModuleLoader__.load({
         'summary.servers': '个服务器',
         'summary.files': '个文件',
         'summary.mounted': '已挂载到 DSH',
+        'summary.loaded': '已加载',
         'summary.secrets': '处明文凭据',
         'filter.search': '按名称、命令或路径筛选',
         'filter.toolAll': '全部工具',
         'filter.statusAll': '全部服务器',
         'filter.statusMounted': '已挂载到 DSH',
         'filter.statusUnmounted': '未挂载',
+        'filter.statusFailed': '已挂载但加载失败',
         'label.project': '项目',
         'label.global': '全局',
         'label.profile': 'profile',
@@ -129,6 +145,10 @@ window.__ModuleLoader__.load({
         'label.mounted': '已挂载',
         'label.off': '未启用',
         'label.shared': '出现在 {count} 个文件',
+        'label.loaded': '已加载',
+        'label.loadFailed': '加载失败',
+        'label.loadUnknown': '加载状态未知',
+        'btn.retry': '重试',
         'switch.title': '挂载到 DeepSeek Harness（不会改动 {client} 本身）',
         'detail.targets': '声明位置',
         'detail.definition': '定义',
@@ -140,6 +160,14 @@ window.__ModuleLoader__.load({
         'probe.ok': '正常 · {tools} 个工具 · {ms}ms',
         'probe.failed': '失败',
         'probe.tools': '{count} 个工具',
+        'load.loaded': '已加载 · {count} 个工具',
+        'load.failed': '加载失败',
+        'load.failedTitle': '已挂载到 DeepSeek Harness，但一个工具都没注册上 —— 说明连接没有成功。声明了零个工具的服务器看起来一样，建议点“测试”确认。',
+        'load.unknown': '加载状态未知',
+        'load.unknownTitle': '当前取不到工具注册表，无法从这里判断该服务器是否连上。',
+        'toast.retried': '已重连 “{name}” —— 现有 {count} 个工具可用。',
+        'toast.retryFailed': '“{name}” 仍未加载。点“测试”可以看清进程为什么起不来。',
+        'error.retry': 'DeepSeek Harness 无法重新发起这次连接。',
         'banner.secrets': '有 {count} 个服务器把凭据以明文保存在可能被提交的配置文件里。',
         'banner.parse': '有 {count} 个文件无法解析。',
         'confirm.sync': '把 “{name}” 复制到 {count} 个其他工具？',
@@ -245,17 +273,16 @@ window.__ModuleLoader__.load({
 .mcpm-btn.primary { background: var(--dsw-alias-brand-primary); border-color: var(--dsw-alias-brand-primary); color: #fff; }
 .mcpm-btn.primary:hover:not(:disabled) { border-color: var(--dsw-alias-brand-primary); opacity: .88; }
 
-.mcpm-summary { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); overflow: hidden;
+/* auto-fit wraps the stats instead of needing one breakpoint per column count,
+   which matters now that there are five of them rather than four. */
+.mcpm-summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(118px, 1fr)); overflow: hidden;
   border: 0.5px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-lg, 16px); background: var(--dsw-alias-bg-layer-1); }
 .mcpm-stat { min-width: 0; overflow: hidden; padding: 4px 10px; border-right: 0.5px solid var(--dsw-alias-border-l1);
   font-size: 12px; line-height: 18px; color: var(--dsw-alias-label-secondary); text-overflow: ellipsis; white-space: nowrap; }
-.mcpm-stat:last-child { border-right: 0; }
 .mcpm-stat strong { margin-right: 4px; color: var(--dsw-alias-label-primary); font-size: 14px; font-weight: 650; }
-@container (max-width: 620px) {
-  .mcpm-summary { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-  .mcpm-stat:nth-child(2) { border-right: 0; }
-  .mcpm-stat:nth-child(-n+2) { border-bottom: 0.5px solid var(--dsw-alias-border-l1); }
-}
+/* A stat that reports a failure has to read as one at a glance. */
+.mcpm-stat-bad { color: var(--dsw-alias-state-error-primary); }
+.mcpm-stat-bad strong { color: var(--dsw-alias-state-error-primary); }
 @container (max-width: 380px) {
   .mcpm-summary { grid-template-columns: 1fr; }
   .mcpm-stat { border-right: 0; border-bottom: 0.5px solid var(--dsw-alias-border-l1); }
@@ -541,6 +568,8 @@ window.__ModuleLoader__.load({
       const [expanded, setExpanded] = useState({});
       const [probes, setProbes] = useState({});
       const [probing, setProbing] = useState({});
+      /* Keyed by server name so several failed rows can be retried independently. */
+      const [retrying, setRetrying] = useState({});
       const [busy, setBusy] = useState(false);
       const [toast, setToast] = useState(null);
       const [snippet, setSnippet] = useState(null);
@@ -592,6 +621,9 @@ window.__ModuleLoader__.load({
        * from: one name can be declared in five tools while being mounted in
        * DeepSeek Harness exactly once. Indexing it here keeps every row's
        * switch consistent with the DSH card.
+       *
+       * `load` is carried alongside because a mount is only half the answer:
+       * the row is mounted and still may never have connected.
        */
       const mountIndex = useMemo(() => {
         const index = new Map();
@@ -603,6 +635,7 @@ window.__ModuleLoader__.load({
             enabled: dsh ? dsh.enabled !== false : false,
             pending: dsh?.pending === true,
             entryId: dsh?.entryId ?? null,
+            load: server.load ?? dsh?.load ?? null,
             node: server,
           });
         }
@@ -637,6 +670,9 @@ window.__ModuleLoader__.load({
             const isMounted = Boolean(mount?.mounted && mount.enabled);
             if (statusFilter === 'mounted' && !isMounted) continue;
             if (statusFilter === 'unmounted' && isMounted) continue;
+            /* The whole point of the filter: a mounted row whose connection never
+               came up. Servers the registry cannot judge are not claimed as bad. */
+            if (statusFilter === 'failed' && mount?.load?.status !== 'failed') continue;
             if (needle) {
               const haystack = [
                 item.name,
@@ -667,6 +703,26 @@ window.__ModuleLoader__.load({
         [mountIndex],
       );
 
+      /*
+       * Counted from the server list rather than from the filtered view: the
+       * headline numbers describe the machine, not the current search.
+       */
+      const loadCounts = useMemo(() => {
+        const counts = { loaded: 0, failed: 0, off: 0, pending: 0, unknown: 0 };
+        for (const item of mountIndex.values()) {
+          const status = item.load?.status;
+          if (!status || status === 'absent') continue;
+          if (status in counts) counts[status] += 1;
+        }
+        return counts;
+      }, [mountIndex]);
+
+      /*
+       * Opt-in, not opt-out: an older host snapshot has no `loadSummary` at all,
+       * and that must read as "cannot tell" rather than as "registry is fine".
+       */
+      const registryAvailable = state?.loadSummary?.registry === true;
+
       const run = async (action, body, success, after) => {
         setBusy(true);
         setError(null);
@@ -736,6 +792,39 @@ window.__ModuleLoader__.load({
         if (!result) flash(t('error.mount'));
       };
 
+      /*
+       * Retry a server that is mounted but never connected.
+       *
+       * The failure is often environmental and temporary — the wrong Node was on
+       * PATH when the Host booted, a package was still downloading — so the fix
+       * is simply to run the connection again. That is a Host-side operation
+       * (a profile reconcile), not a config edit.
+       */
+      const retryLoad = async (name) => {
+        setRetrying((current) => ({ ...current, [name]: true }));
+        try {
+          const data = await run('retry', { name });
+          if (!data) {
+            flash(t('error.retry'));
+            return;
+          }
+          if (data.loaded) flash(t('toast.retried', { name, count: data.load?.toolCount ?? 0 }));
+          else flash(t('toast.retryFailed', { name }));
+          /*
+           * A reconnect is not instant: the process still has to spawn and do its
+           * initialize handshake, so the snapshot in the response can be one beat
+           * too early. Re-read once after it has had a moment.
+           */
+          setTimeout(() => { if (mounted.current) void load(reveal); }, 2500);
+        } finally {
+          setRetrying((current) => {
+            const next = { ...current };
+            delete next[name];
+            return next;
+          });
+        }
+      };
+
       const doSync = async (server) => {
         if (!window.confirm(t('confirm.sync', { name: server.name, count: syncPicks.length }))) return;
         const data = await run('sync', { name: server.name, server: server.canonical, targets: syncPicks });
@@ -791,10 +880,23 @@ window.__ModuleLoader__.load({
         h('p', { className: 'mcpm-desc', key: 'desc' }, t('desc')),
       ]);
 
+      /*
+       * "Mounted" alone is a lie the old page told: a row can be mounted and its
+       * process fail to start, which is exactly the case this stat exists to
+       * make visible. Loaded and failed are counted separately beside it.
+       */
       const summary = state ? h('div', { className: 'mcpm-summary', key: 'summary' }, [
         h('div', { className: 'mcpm-stat', key: 'servers' }, [h('strong', { key: 'v' }, String(state.servers.length)), t('summary.servers')]),
         h('div', { className: 'mcpm-stat', key: 'files' }, [h('strong', { key: 'v' }, String(sources.length)), t('summary.files')]),
         h('div', { className: 'mcpm-stat', key: 'mounted' }, [h('strong', { key: 'v' }, String(mountedCount)), t('summary.mounted')]),
+        h('div', {
+          className: `mcpm-stat${loadCounts.failed > 0 ? ' mcpm-stat-bad' : ''}`,
+          key: 'loaded',
+          title: loadCounts.failed > 0 ? t('load.failedTitle') : undefined,
+        }, [
+          h('strong', { key: 'v' }, registryAvailable ? `${loadCounts.loaded}/${mountedCount}` : '—'),
+          t('summary.loaded'),
+        ]),
         h('div', { className: 'mcpm-stat', key: 'secrets' }, [h('strong', { key: 'v' }, String(state.literalSecrets.length)), t('summary.secrets')]),
       ]) : null;
 
@@ -831,6 +933,7 @@ window.__ModuleLoader__.load({
           h('option', { key: 'all', value: 'all' }, t('filter.statusAll')),
           h('option', { key: 'mounted', value: 'mounted' }, t('filter.statusMounted')),
           h('option', { key: 'unmounted', value: 'unmounted' }, t('filter.statusUnmounted')),
+          h('option', { key: 'failed', value: 'failed' }, t('filter.statusFailed')),
         ]),
       ]) : null;
 
@@ -857,6 +960,40 @@ window.__ModuleLoader__.load({
         ]);
       };
 
+      /*
+       * The load badge, and the retry that belongs beside it.
+       *
+       * Only a mounted-and-enabled row can be loaded, so nothing is shown
+       * otherwise — an unmounted server is not "failed", it is simply absent.
+       * `unknown` is rendered as its own neutral state rather than as a failure,
+       * because a scan without the tool registry must not accuse a healthy server.
+       */
+      const loadTag = (mount, name) => {
+        const load = mount?.load;
+        if (!mount?.mounted || !mount.enabled || !load) return null;
+        const status = load.status;
+        if (status === 'off' || status === 'absent') return null;
+        const parts = [];
+        if (status === 'loaded') {
+          parts.push(h('span', { className: 'mcpm-tag ok', key: 'ld' }, t('load.loaded', { count: load.toolCount ?? 0 })));
+        } else if (status === 'failed') {
+          parts.push(h('span', { className: 'mcpm-tag err', key: 'ld', title: t('load.failedTitle') }, t('load.failed')));
+          parts.push(h('button', {
+            key: 'rt',
+            type: 'button',
+            className: 'mcpm-btn sm',
+            disabled: busy || (retrying[name] === true),
+            title: t('btn.retry'),
+            onClick: () => retryLoad(name),
+          }, retrying[name] ? h('span', { className: 'mcpm-spin', key: 's' }) : t('btn.retry')));
+        } else if (status === 'pending') {
+          parts.push(h('span', { className: 'mcpm-tag', key: 'ld' }, t('label.pending')));
+        } else {
+          parts.push(h('span', { className: 'mcpm-tag', key: 'ld', title: t('load.unknownTitle') }, t('load.unknown')));
+        }
+        return parts;
+      };
+
       const rowFor = (source, item) => {
         const mount = mountIndex.get(item.name);
         const node = mount?.node ?? null;
@@ -880,6 +1017,7 @@ window.__ModuleLoader__.load({
             shared > 1 ? h('span', { className: 'mcpm-tag', key: 'sh', title: node?.clients?.join(', ') ?? '' }, t('label.shared', { count: shared })) : null,
             mount?.pending ? h('span', { className: 'mcpm-tag warn', key: 'pd' }, t('label.pending')) : null,
             isDsh && !checked ? h('span', { className: 'mcpm-tag', key: 'off' }, t('label.off')) : null,
+            loadTag(mount, item.name),
             probeTag(item.name),
             h(MountSwitch, {
               key: 'sw',

package/lib/index.js

@@ -68,6 +68,11 @@ const STATUS_BY_CODE = new Map([
   ['error.backup.missing', 404],
   ['error.route.missing', 404],
   ['error.action.unknown', 400],
+  ['error.dsh.notMounted', 409],
+  ['error.dsh.pending', 409],
+  ['error.dsh.noEntry', 409],
+  ['error.dsh.noHmr', 501],
+  ['error.dsh.retry', 500],
 ]);
 
 function statusFor(result) {
@@ -144,9 +149,16 @@ export function apply(ctx, config = {}) {
 
   const configEditor = () => (typeof ctx.get === 'function' ? ctx.get('configEditor') : undefined);
 
+  /* The tool registry is the only truthful source of "did the connection
+     succeed": a connected server has registered `mcp__<mount>__<tool>` names,
+     while `@deepseek-ai/dsh-mcp-client` swallows a failed connect. Read lazily
+     so a profile without the service still scans (statuses become `unknown`). */
+  const toolRegistry = () => (typeof ctx.get === 'function' ? ctx.get('tools') : undefined);
+
   const projectRoots = () => (options.includeProjectScope ? registeredWorkspaceRoots(ctx) : []);
 
-  const snapshot = (reveal = false) => scanAll({ store, configEditor: configEditor(), projectRoots: projectRoots(), reveal, profileDir });
+  const snapshot = (reveal = false) =>
+    scanAll({ store, configEditor: configEditor(), projectRoots: projectRoots(), reveal, profileDir, tools: toolRegistry() });
 
   /* ---------------------------------------------------------- operations -- */
 
@@ -321,6 +333,63 @@ export function apply(ctx, config = {}) {
     return store.restore(body.backup, body.path);
   }
 
+  /**
+   * Retry a mounted server that never connected.
+   *
+   * Nothing in the config is wrong when a connection fails — the process was
+   * simply not there yet (wrong Node version, a package that had not finished
+   * downloading, a laptop that had just woken up). The mcp-client keeps its own
+   * backoff timer for that, but once it gives up it registers nothing and waits
+   * for a reload that a settings page has no way to deliver.
+   *
+   * The supported lever is `hmr.reconcileProfile(requiredIds)`: it recomposes the
+   * profile, re-imports the entry, and — because the id is listed as required —
+   * reports its inactivity instead of silently tolerating it. That re-runs the
+   * connection, which is exactly the retry the user asked for. Serialized through
+   * `runExclusive` so it cannot race an automatic reload.
+   */
+  async function opRetry(body) {
+    const name = typeof body.name === 'string' ? body.name.trim() : '';
+    if (!name) return { ok: false, code: 'error.input', error: 'name is required' };
+
+    const state = snapshot(false);
+    const node = state.servers.find((item) => item.name === name);
+    if (!node) return { ok: false, code: 'error.server.missing', error: `unknown server ${name}` };
+    const target = node.targets.find((item) => item.clientId === 'dsh');
+    if (!target) return { ok: false, code: 'error.dsh.notMounted', error: `${name} is not mounted in DeepSeek Harness` };
+    if (target.pending === true) return { ok: false, code: 'error.dsh.pending', error: `${name} is still being mounted; wait for it to appear first` };
+    if (!target.entryId) return { ok: false, code: 'error.dsh.noEntry', error: `${name} has no Loader entry id; reload the plugin instead` };
+
+    const hmr = typeof ctx.get === 'function' ? ctx.get('hmr') : undefined;
+    if (!hmr || typeof hmr.reconcileProfile !== 'function') {
+      return { ok: false, code: 'error.dsh.noHmr', error: 'the hot-reload service is not available, so the connection cannot be re-run' };
+    }
+
+    const before = node.load ?? null;
+    try {
+      const run = () => hmr.reconcileProfile([target.entryId]);
+      const reconciled = typeof hmr.runExclusive === 'function' ? await hmr.runExclusive(run) : await run();
+      const after = snapshot(false).servers.find((item) => item.name === name);
+      const load = after?.load ?? null;
+      /* A reconcile that succeeds only proves the profile recomposed. Whether the
+         connection came back is decided by the registry, read again after it. */
+      return {
+        ok: true,
+        name,
+        entryId: target.entryId,
+        before,
+        load,
+        loaded: load?.status === 'loaded',
+        warnings: Array.isArray(reconciled?.warnings) ? reconciled.warnings : [],
+        pending: Array.isArray(reconciled?.pending) ? reconciled.pending.map((item) => item.reason) : [],
+        restartReason: reconciled?.restartReason ?? null,
+        state: snapshot(false),
+      };
+    } catch (error) {
+      return { ok: false, code: 'error.dsh.retry', error: String(error && error.message ? error.message : error) };
+    }
+  }
+
   const dispatch = async (action, body = {}) => {
     switch (action) {
       case 'scan': return opScan(body);
@@ -332,6 +401,7 @@ export function apply(ctx, config = {}) {
       case 'reveal': return opReveal(body);
       case 'toggle': return opToggle(body);
       case 'restore': return opRestore(body);
+      case 'retry': return opRetry(body);
       case 'history': return { ok: true, writes: store.recentWrites(100), backups: store.listBackups(100) };
       default: return { ok: false, code: 'error.action.unknown', error: `unknown action ${action}` };
     }
@@ -402,14 +472,15 @@ export function apply(ctx, config = {}) {
       description: [
         'Inspect and manage Model Context Protocol servers across the local AI development tools installed on this machine',
         '(DeepSeek Harness, Claude Code, Cursor, VS Code, Roo Code, OpenCode, Trae, Trae CN, Qoder, Gemini CLI, Zed and others).',
-        'Use action "scan" to see every server and which tools it is configured in, "probe" to check whether a server actually starts and lists tools,',
+        'Use action "scan" to see every server, which tools it is configured in, and whether it actually LOADED in DeepSeek Harness (a mounted row can still be a dead connection),',
+        '"probe" to check whether a server actually starts and lists tools, "retry" to re-run the connection of a mounted server that failed to load,',
         '"toggle" to mount or unmount one server in DeepSeek Harness only (it never edits another tool\'s own config file),',
         '"sync" to copy one definition to other tools, "apply" to write one definition to one target, "remove" to delete one, and "snippet" to get a YAML row for adding a brand-new DeepSeek Harness server.',
       ].join(' '),
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['scan', 'probe', 'apply', 'remove', 'sync', 'snippet', 'toggle', 'reveal', 'history'], description: 'Operation to perform.' },
+          action: { type: 'string', enum: ['scan', 'probe', 'apply', 'remove', 'sync', 'snippet', 'toggle', 'reveal', 'retry', 'history'], description: 'Operation to perform.' },
           name: { type: 'string', description: 'Server name, as reported by scan.' },
           enabled: { type: 'boolean', description: 'For toggle: true mounts the server in DeepSeek Harness, false unmounts it.' },
           clientId: { type: 'string', description: 'Target client id (see scan output).' },
@@ -439,15 +510,44 @@ export function apply(ctx, config = {}) {
               : (data.activating ? ' — DeepSeek Harness is activating it; its tools appear in a moment' : '');
             return [{ type: 'text', text: `${data.name}: ${what}${when}` }];
           }
+          if (data.name && data.load && typeof data.loaded === 'boolean') {
+            const before = data.before?.status ?? 'unknown';
+            const after = data.load?.status ?? 'unknown';
+            const lines = [`${data.name}: reconnect requested (was ${before}, now ${after}${data.load?.toolCount ? `, ${data.load.toolCount} tools` : ''}).`];
+            if (data.loaded) lines.push('Its tools are registered and callable.');
+            else if (after === 'failed') lines.push('Still no tools registered — run "probe" to see why the process will not start.');
+            else lines.push('The connection is still settling; scan again in a moment.');
+            for (const warning of data.warnings ?? []) lines.push(`warning: ${warning}`);
+            return [{ type: 'text', text: lines.join('\n') }];
+          }
           if (data.clients && data.servers) {
             const lines = [`${data.servers.length} MCP server(s) across ${data.clients.filter((client) => client.installed).length} installed tool(s).`];
+            const summary = data.loadSummary;
+            if (summary && summary.mounted > 0) {
+              lines.push(summary.registry
+                ? `Mounted in DeepSeek Harness: ${summary.mounted} — ${summary.loaded} loaded, ${summary.failed} failed to load${summary.off ? `, ${summary.off} off` : ''}${summary.pending ? `, ${summary.pending} activating` : ''}.`
+                : `Mounted in DeepSeek Harness: ${summary.mounted}. The tool registry is unavailable, so load state cannot be checked.`);
+            }
             for (const server of data.servers.slice(0, 40)) {
               /*
                * Mount state is the one thing a reader acts on, so it belongs on
-               * the line rather than in a second pass over the payload.
+               * the line rather than in a second pass over the payload. A
+               * mounted-but-dead server is exactly what this feature exists to
+               * expose, so it says FAILED rather than just "mounted".
                */
               const dsh = (server.targets ?? []).find((target) => target.clientId === 'dsh');
-              const mount = dsh ? (dsh.enabled === false ? ' [dsh: off]' : ' [dsh: mounted]') : '';
+              const load = server.load?.status;
+              const mount = !dsh
+                ? ''
+                : dsh.enabled === false
+                  ? ' [dsh: off]'
+                  : load === 'loaded'
+                    ? ` [dsh: loaded, ${server.load.toolCount} tools]`
+                    : load === 'failed'
+                      ? ' [dsh: MOUNTED BUT FAILED TO LOAD]'
+                      : load === 'pending'
+                        ? ' [dsh: activating]'
+                        : ' [dsh: mounted, load unknown]';
               lines.push(`- ${server.name} [${server.transport}]${mount} in: ${server.clients.join(', ') || 'none'}`);
             }
             if (data.servers.length > 40) lines.push(`… ${data.servers.length - 40} more`);

package/lib/load.js

@@ -0,0 +1,102 @@
+/**
+ * Runtime load status: did a mounted MCP server actually CONNECT?
+ *
+ * A row in the profile composition only proves a server is MOUNTED. It says
+ * nothing about whether the connection succeeded, because `@deepseek-ai/dsh-mcp-client`
+ * treats a failed first connection as a non-event: `apply()` awaits
+ * `connection.ready` and, when `failOnStartupError` is false (the default), it
+ * merely returns on error. The fiber stays `active`, the plugin manager reports
+ * `fiberPhase: 'active'`, and the settings file still lists the server — so
+ * "mounted but broken" is invisible everywhere the UI used to look.
+ *
+ * The one place a successful connection MUST leave a trace is the tool
+ * registry: every tool of a connected server is registered as
+ * `mcp__<serverName>__<rawName>`. That makes the registry the ground truth, and
+ * this module only ever READS it — it spawns nothing and writes nothing.
+ *
+ * Limitation worth stating plainly: a server that connects successfully but
+ * declares zero tools also registers zero names, so it is indistinguishable
+ * from a failed connection here. The status message says so instead of
+ * pretending to know which one it is, and `probe` answers the question.
+ */
+
+const PREFIX = 'mcp__';
+
+/**
+ * Read the live tool names out of the registry.
+ *
+ * Returns `null` — never an empty array — when the registry is unavailable, so
+ * a profile without the `tools` service reports "unknown" rather than accusing
+ * every server of having failed.
+ */
+export function liveToolNames(tools) {
+  if (!tools || typeof tools.schemas !== 'function') return null;
+  try {
+    const schemas = tools.schemas();
+    if (!Array.isArray(schemas)) return null;
+    return schemas.map((schema) => schema?.name).filter((name) => typeof name === 'string');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Count registered tools per mounted server name.
+ *
+ * Matched by longest known mount name rather than by splitting on `__`, because
+ * `serverName` legitimately allows underscores: for a server named `a__b` the
+ * naive split of `mcp__a__b__tool` would credit server `a`. Only the mount
+ * names we actually asked about can match, so longest-first is unambiguous.
+ */
+export function indexLiveTools(toolNames, mountNames) {
+  const counts = new Map();
+  if (!Array.isArray(toolNames) || !toolNames.length) return counts;
+  const ordered = [...mountNames].filter((name) => typeof name === 'string' && name).sort((left, right) => right.length - left.length);
+  if (ordered.length === 0) return counts;
+  for (const name of toolNames) {
+    if (typeof name !== 'string' || !name.startsWith(PREFIX)) continue;
+    const hit = ordered.find((mount) => name.startsWith(`${PREFIX}${mount}__`));
+    if (!hit) continue;
+    counts.set(hit, (counts.get(hit) ?? 0) + 1);
+  }
+  return counts;
+}
+
+/** Count the registered tools of one mount name. */
+export function countLiveTools(toolNames, mountName) {
+  if (!Array.isArray(toolNames) || typeof mountName !== 'string' || !mountName) return 0;
+  const prefix = `${PREFIX}${mountName}__`;
+  let total = 0;
+  for (const name of toolNames) if (typeof name === 'string' && name.startsWith(prefix)) total += 1;
+  return total;
+}
+
+/**
+ * Turn the observations into one status.
+ *
+ *   absent  — not mounted in DeepSeek Harness at all
+ *   off     — mounted but disabled, so nothing is expected to run
+ *   pending — a patch row the Loader has not reconciled yet
+ *   loaded  — mounted, enabled, and at least one tool is registered
+ *   failed  — mounted and enabled, yet no tool is registered
+ *   unknown — the tool registry is unavailable, so nothing can be claimed
+ */
+export function loadStatus({ mounted, enabled, pending, toolCount }) {
+  if (!mounted) return 'absent';
+  if (enabled === false) return 'off';
+  if (pending === true) return 'pending';
+  if (toolCount === null || toolCount === undefined) return 'unknown';
+  return toolCount > 0 ? 'loaded' : 'failed';
+}
+
+/** Build one `load` record for a mount name. */
+export function loadRecord({ mountName, mounted, enabled, pending, counts, registry }) {
+  const toolCount = counts ? (mountName ? counts.get(mountName) ?? 0 : 0) : null;
+  const status = loadStatus({ mounted, enabled, pending, toolCount });
+  return { mountName: mountName ?? null, status, toolCount: toolCount ?? 0, registry: registry === true };
+}
+
+/** True when this status is something the user must act on. */
+export function needsAttention(status) {
+  return status === 'failed';
+}

package/lib/probe.js

@@ -25,7 +25,7 @@ const PROTOCOL_VERSION = '2025-06-18';
  * connection to this plugin and a version we still recognise. `test-release.mjs`
  * asserts it matches package.json — a stale value here is otherwise invisible.
  */
-const CLIENT_INFO = { name: 'dsh-mcp-manager', version: '0.1.2' };
+const CLIENT_INFO = { name: 'dsh-mcp-manager', version: '0.1.4' };
 
 function rpcRequest(id, method, params) {
   return JSON.stringify({ jsonrpc: '2.0', id, method, params });

package/lib/scan.js

@@ -13,6 +13,7 @@ import { decodeEntry, definitionHash, dshMountName, redactServer } from './canon
 import { readContainer, readTomlServers, readYamlServers } from './surgical.js';
 import { mcpEntries, decodeDshEntry } from './dsh.js';
 import { readDshPatchServers } from './dsh-patch.js';
+import { indexLiveTools, liveToolNames, loadRecord } from './load.js';
 
 const READ_KINDS = new Set(['json', 'toml', 'yaml']);
 
@@ -80,7 +81,7 @@ function readDsh(configEditor, profileDir) {
  * A server mounted in the harness lives under `dshMountName(displayName)`,
  * because `serverName` may only use `[A-Za-z0-9_-]` — a CJK name has to be
  * mapped. Without this pass the mounted row appears as a SEVENTH server named
- * `API-c2f500c4` next to `表单管理系统 - API 文档`, and the display-named node has
+ * `API-0aac0ee2` next to `示例服务器 - API 文档`, and the display-named node has
  * no `dsh` target at all, so its switch reads "off" while the server is in fact
  * mounted.
  *
@@ -158,6 +159,10 @@ function foldDshNames(matrix, sources, store) {
  *
  *   projectRoots — workspace directories whose project-scope files to include
  *   reveal       — return credential literals instead of masked values
+ *   tools        — the Harness tool registry, read to tell a CONNECTED server
+ *                  (its `mcp__<mount>__<tool>` names are registered) apart from a
+ *                  mounted-but-dead one. Omitting it yields `unknown`, never a
+ *                  false accusation.
  *
  * Two projections are produced from one read, because they answer different
  * questions and recomputing them separately would let them disagree:
@@ -166,7 +171,7 @@ function foldDshNames(matrix, sources, store) {
  *             servers that file holds. This is what the page groups by, since
  *             "which directory holds which MCP" is a per-file question.
  */
-export function scanAll({ store, configEditor, projectRoots = [], reveal = false, profileDir }) {
+export function scanAll({ store, configEditor, projectRoots = [], reveal = false, profileDir, tools }) {
   const warnings = [];
   const clients = [];
   const matrix = new Map();
@@ -303,6 +308,48 @@ export function scanAll({ store, configEditor, projectRoots = [], reveal = false
   // BEFORE the servers projection is built: the fold rewrites matrix keys.
   foldDshNames(matrix, sources, store);
 
+  /* Load status, computed AFTER the fold because it needs the real mount name.
+     The registry is read once for the whole scan; `null` means the service is
+     absent and every status degrades to `unknown` rather than to `failed`. */
+  const registryNames = liveToolNames(tools);
+  const registry = registryNames !== null;
+  const mountOf = (node) => {
+    const target = node.targets.find((item) => item.clientId === 'dsh');
+    if (!target) return null;
+    return target.mountedAs ?? target.server?.mountName ?? dshMountName(node.name);
+  };
+  const mountNames = [...matrix.values()].map(mountOf).filter((name) => typeof name === 'string' && name);
+  const counts = registry ? indexLiveTools(registryNames, [...new Set(mountNames)]) : null;
+
+  for (const node of matrix.values()) {
+    const mountName = mountOf(node);
+    const dshTarget = node.targets.find((item) => item.clientId === 'dsh');
+    node.load = loadRecord({
+      mountName,
+      mounted: Boolean(dshTarget),
+      enabled: dshTarget ? dshTarget.enabled !== false : false,
+      pending: dshTarget?.pending === true,
+      counts,
+      registry,
+    });
+    if (dshTarget) dshTarget.load = node.load;
+  }
+
+  for (const source of sources) {
+    if (source.clientId !== 'dsh') continue;
+    for (const item of source.servers) {
+      const mountName = item.mountName ?? item.name;
+      item.load = loadRecord({
+        mountName,
+        mounted: true,
+        enabled: item.enabled !== false,
+        pending: item.pending === true,
+        counts,
+        registry,
+      });
+    }
+  }
+
   const servers = [...matrix.values()].map((node) => {
     const clientIds = new Set(node.targets.map((target) => target.clientId));
     const canonical = node.canonical;
@@ -322,6 +369,7 @@ export function scanAll({ store, configEditor, projectRoots = [], reveal = false
       clients: [...clientIds],
       targets: node.targets,
       drift,
+      load: node.load,
       canonical: redactServer(canonical, reveal),
     };
   }).sort((a, b) => b.clientCount - a.clientCount || a.name.localeCompare(b.name));
@@ -341,6 +389,16 @@ export function scanAll({ store, configEditor, projectRoots = [], reveal = false
     }
   }
 
+  /* Counted here so the page and the agent share one number instead of each
+     recomputing it from `servers` with slightly different filters. */
+  const loadSummary = { mounted: 0, loaded: 0, failed: 0, off: 0, pending: 0, unknown: 0 };
+  for (const node of matrix.values()) {
+    const status = node.load?.status;
+    if (status === 'absent' || !status) continue;
+    loadSummary.mounted += 1;
+    if (status in loadSummary) loadSummary[status] += 1;
+  }
+
   return {
     clients,
     servers,
@@ -348,6 +406,7 @@ export function scanAll({ store, configEditor, projectRoots = [], reveal = false
     locations,
     warnings,
     literalSecrets,
+    loadSummary: { ...loadSummary, registry },
     scannedAt: new Date().toISOString(),
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oh-agent/dsh-mcp-manager",
-  "version": "0.1.2",
-  "description": "One settings page for every MCP server on your machine: scan each AI tool's own config file, see which directory holds which server, probe whether it really starts, and mount or unmount it in DeepSeek Harness without ever editing the other tools' files. / 一个设置页管理本机所有 AI 开发工具的 MCP：按配置文件分组展示、真连探活、只在 DeepSeek Harness 内挂载/卸载，绝不改动其他工具的配置。",
+  "version": "0.1.4",
+  "description": "One settings page for every MCP server on your machine: scan each AI tool's own config file, see which directory holds which server, probe whether it really starts, tell you whether it actually loaded in DeepSeek Harness with a retry button, and mount or unmount it without ever editing the other tools' files. / 一个设置页管理本机所有 AI 开发工具的 MCP：按配置文件分组展示、真连探活、明确显示在 DeepSeek Harness 里是否真正加载成功并可重试，只在 Harness 内挂载/卸载，绝不改动其他工具的配置。",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -66,4 +66,4 @@
     "node": "^22.19.0 || >=24.0.0"
   }
 }
-
+