@oh-agent/dsh-mcp-manager 0.1.3 → 0.1.5

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.3"
+plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.5"
 ```
 
 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.3 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases).
+[v0.1.5 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
@@ -218,10 +219,23 @@ How the mount works, by case:
 
 | the server is | the switch does | takes effect |
 | --- | --- | --- |
-| an `- insert:` item we wrote | deletes the item on off, rewrites it on on | on reconcile; the file returns to its exact previous bytes |
 | already a live `dsh-mcp-client` row | `pluginManager.setPluginEnabled(rowId, …)` | instantly — the row unmounts and its tools leave the tool list |
+| an `- insert:` item we wrote | deletes the item on off, rewrites it on on | on reconcile; the file returns to its exact previous bytes |
 | an `- insert:` item the user wrote | appends/removes the same `- id: …` / `disabled: true` override the plugin manager itself writes | on reconcile |
 | declared in another tool only, and switched on | writes a new `- insert:` row | live as soon as the Loader reconciles it (usually 1–4 s); the operation waits up to 8 s and reports `live: true`, else `activating: true` |
+
+The order matters, and it cost a real bug: **the Loader path must come before any
+file edit**. The first row and the rows below it overlap — an `- insert:` item we
+wrote ourselves is, once the Loader has read it, a live entry. An earlier version
+checked "is this row ours?" first and deleted the YAML row, so switching one off
+edited a file that needs a reconcile instead of hot-disposing the running
+instance; worse, switching it back on appended the block to the end of
+`cordis.patch.yml`, so the user's careful ordering was destroyed. Measured once:
+a 15,640-byte file changed SHA and the `mcp-playwright` block moved from the
+middle to the end after a single toggle round. It now tries the Loader first and
+only falls back to the file when no such entry exists at all;
+`scripts/test-toggle.mjs` pins this with "the patch file's bytes are identical
+after a toggle round".
 | not mounted anywhere, and switched off | nothing — already true, no dangling override | — |
 
 Our own row is removed before the Loader path is tried: the plugin manager can
@@ -234,6 +248,73 @@ 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 |
+| a red banner at the top + Retry all | N mounted servers cannot connect; retry every failed one in a single action |
+| `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. The
+red banner follows the same rule and only appears when the registry is readable —
+otherwise every row reads `unknown`, and calling that a failure would be a guess.
+
+Retry is **not** `hmr.reconcileProfile`. That looks like the right lever and is a
+no-op: it only restarts entries that are **inactive**, while
+`@deepseek-ai/dsh-mcp-client` swallows the connect error under
+`failOnStartupError: false` and leaves the fiber **active**. Measured against a
+dead row: `reconcileProfile` returned success and rebuilt nothing — a retry button
+that lies.
+
+The lever that works is `pluginManager.setPluginEnabled(entryId, false)` followed
+by `(entryId, true)`: dispose the dead fiber, then mount it again from scratch.
+Hence three steps:
+
+1. `setPluginEnabled(entryId, false)` tears the old connection down. If that call
+   itself fails, report `could not dispose the stale connection: <code>` — never
+   pretend a retry happened;
+2. `setPluginEnabled(entryId, true)` rebuilds it. If it throws, best-effort
+   re-enable, because leaving a server switched off is worse than a retry that
+   did not help;
+3. poll the tool registry (`mcp__<mountName>__*`) until tools appear or the
+   budget runs out. **The verdict comes from the registry, not the composition**:
+   a rebuilt fiber shows up in the composition instantly, but only registered
+   tools prove the connection is real.
+
+Polling the registry rather than the fiber is the whole point: `active` only says
+"this plugin is loaded", and it stays active when the connection is dead — that is
+exactly why the page used to say "mounted" while nothing worked. Reconnecting is
+not instant (process spawn plus handshake), so the page re-reads state 2.5 seconds
+after the button is pressed, and a retry that still finds no tools reports the
+host's own reason instead of a generic "something went wrong".
+
+`scripts/test-load.mjs` pins the verdicts down (the boundary between `unknown`,
+`failed` and `loaded`, plus the name matching that decides which tools belong to
+which server), and `scripts/test-retry.mjs` pins the retry itself: exactly one
+disable followed by one enable, the host's reason surfaced verbatim, and a failed
+rebuild must not leave the row switched off.
+
 ### A mount name is not always the display name
 
 `@deepseek-ai/dsh-mcp-client` requires `serverName` to match
@@ -265,18 +346,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 +369,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 +399,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 +412,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 +435,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.3"
+plugin_manager  action: install_bundle  target: "@oh-agent/dsh-mcp-manager@0.1.5"
 ```
 
 `target` 也可以填一个绝对目录 —— 本地源码目录，或者
-[v0.1.3 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases) 里附的
+[v0.1.5 release](https://github.com/wangbobo-coder/dsh-mcp-manager/releases) 里附的
 `dsh-mcp-manager.tgz` 解出来的目录。
 
 **不要**手动 `pnpm add` 进 profile，也不要手改 profile 的 `package.json` 或
@@ -135,16 +135,48 @@ client.js  (设置页)                 index.js  (宿主入口)
 
 | 服务器是 | 开关做的事 | 生效时机 |
 | --- | --- | --- |
-| 我们自己写的 `- insert:` 项 | 关：删掉该项；开：重写它 | 重排后生效；文件回到精确的原始字节 |
 | 已经是运行中的 `dsh-mcp-client` 行 | `pluginManager.setPluginEnabled(rowId, …)` | 立即 —— 行卸载，其工具从工具列表消失 |
+| 我们自己写的 `- insert:` 项 | 关：删掉该项；开：重写它 | 重排后生效；文件回到精确的原始字节 |
 | 用户自己写的 `- insert:` 项 | 追加/移除插件管理器自己也会写的那种 `- id: …` / `disabled: true` 覆盖项 | 重排后生效 |
 | 只声明在别的工具里，且被打开 | 写一条新的 `- insert:` 行 | Loader 重排后即生效（通常 1–4 秒）；操作最多等 8 秒并上报 `live: true`，否则 `activating: true` |
 | 哪里都没挂载，且被关闭 | 什么都不做 —— 本就是事实，不留悬空覆盖项 | — |
 
+顺序很重要，这是踩过的坑：**Loader 路径必须排在改文件之前**。上面第一行和下面几行会同时命中 —— 我们自己写过的 `- insert:` 项，一旦被 Loader 读进来就是一条活的 entry。早先的版本先判「这行是我们的就删文件」，结果关一次开关，删掉的是 YAML 行（要重排才生效），而不是热卸载那个正在跑的实例；更糟的是重新打开时该块会被追加到文件末尾，用户精心排过序的 `cordis.patch.yml` 被搬了家。实测过一次：15640 字节的文件在开关一轮之后 SHA 变了、`mcp-playwright` 整块从前面挪到了文件尾。现在先走 Loader，只有在根本不存在这个 entry 时才回落到改文件，`scripts/test-toggle.mjs` 用「开关一轮之后补丁文件字节零变化」钉住了这件事。
+
 我们自己写的行会在尝试 Loader 路径之前被移除：插件管理器确实能热卸载一行，但它的做法是在定义旁边追加一条 `disabled: true` 覆盖项，那会让我们的行和这条覆盖项一起永久留在用户的组合文件里。删除 insert 项既是卸载也是清理。
 
 因为覆盖项是独立的一项而不是重写，且我们自己写的行是删除而不是禁用，一次完整的挂载 → 卸载循环会把 `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 现在就能调 |
+| `已挂载但加载失败` + 「重试」 | 行挂上了，但一个工具都没注册 —— 进程没起来或握手失败 |
+| 页面顶部红色横幅 + 「全部重试」 | 有 N 个服务器挂上了却连不上，一次把失败的全部重试 |
+| `正在激活` | 刚写完补丁行，Loader 还没重排完 |
+| `加载状态未知` | 读不到工具注册表（老版本宿主），此时**不下结论**，绝不误判成失败 |
+
+拿不到注册表时宁可显示「未知」也不显示「失败」：把一台健康的服务器标成坏的，比不标更糟。同理，红色横幅只在注册表可读时才出现 —— 否则每一行都是「未知」，那时候报「失败」纯属猜测。
+
+失败行的「重试」**不是** `hmr.reconcileProfile`。那个看着像正解，实际是个假动作：它只重启处于 **inactive** 的行，而 `@deepseek-ai/dsh-mcp-client` 在 `failOnStartupError: false` 下会把连接错误吞掉，fiber 一直是 **active**。拿一条死行实测过：`reconcileProfile` 返回成功，一个连接都没重建 —— 一个会说谎的重试按钮。
+
+真正的杠杆是 `pluginManager.setPluginEnabled(entryId, false)` 再 `(entryId, true)`：先 dispose 掉那条死 fiber，再重新走一遍完整的挂载。据此分三步：
+
+1. `setPluginEnabled(entryId, false)` 拆掉旧连接 —— 这一步失败就直接报「could not dispose the stale connection: <code>」，不要假装重试过；
+2. `setPluginEnabled(entryId, true)` 重建 —— 抛异常时尽力恢复成「开着」，宁可保留一个连不上的行，也不能把用户的服务悄悄关掉；
+3. 轮询工具注册表（`mcp__<挂载名>__*`）直到出现工具或超时。**判定依据是注册表，不是组合文件**：重建后的 fiber 会立刻出现在组合里，可只有它真注册上工具才算连上了。
+
+为什么轮询注册表而不是直接看 fiber：fiber `active` 只说明「这个插件被加载了」，连不上也照样 active，这正是当初「显示已挂载、其实加载失败」的根源。重连不是瞬时的（起进程 + 握手），所以按钮点完 2.5 秒后页面会自己再读一次状态；等不到工具时提示里带的是宿主返回的真实原因，而不是一句「出错了」。
+
+`scripts/test-load.mjs` 钉住了判定边界（`unknown` / `failed` / `loaded` 三者不能互相冒充，按名字归属工具也不能张冠李戴），`scripts/test-retry.mjs` 钉住了重试本身：必须是「先关后开」两次调用、失败原因要原样透出、重建失败时不能把行留在关闭状态。
+
 ### 挂载名不总是显示名
 
 `@deepseek-ai/dsh-mcp-client` 要求 `serverName` 匹配 `/^[A-Za-z0-9_-]{1,32}$/`。现实中很多服务器不满足 —— 大量中文名形如 `示例服务器 - API 文档`，也有带空格的英文名形如 `My Bridge`。只用 `sanitizeName` 压一遍，所有中文名都会变成 `API`，第二个挂载就会和第一个撞名，开关就会翻错服务器。
@@ -161,18 +193,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 +226,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 +235,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 +251,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/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,8 +81,20 @@ 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.',
+        'toast.retryReason': 'Could not reconnect “{name}”: {reason}',
+        'toast.retryWarn': '{count} warning(s) from DeepSeek Harness — the connection was rebuilt anyway.',
+        '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.',
+        'banner.loadFailed': '{count} server(s) are mounted in DeepSeek Harness but failed to connect — no tool is registered from them.',
+        'btn.retryAll': 'Retry all',
         'confirm.sync': 'Copy “{name}” into {count} other tool(s)?',
         'confirm.reveal': 'Show credential values in clear text?',
         'error.title': 'Something went wrong',
@@ -115,12 +133,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 +149,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,8 +164,20 @@ 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}” 仍未加载。点“测试”可以看清进程为什么起不来。',
+        'toast.retryReason': '无法重连 “{name}”：{reason}',
+        'toast.retryWarn': 'DeepSeek Harness 返回了 {count} 条警告，但连接已重建。',
+        'error.retry': 'DeepSeek Harness 无法重新发起这次连接。',
         'banner.secrets': '有 {count} 个服务器把凭据以明文保存在可能被提交的配置文件里。',
         'banner.parse': '有 {count} 个文件无法解析。',
+        'banner.loadFailed': '有 {count} 个服务器已挂载到 DeepSeek Harness，但连接失败 —— 没有任何工具注册成功。',
+        'btn.retryAll': '全部重试',
         'confirm.sync': '把 “{name}” 复制到 {count} 个其他工具？',
         'confirm.reveal': '以明文显示凭据？',
         'error.title': '出错了',
@@ -245,17 +281,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); }
@@ -326,6 +361,9 @@ window.__ModuleLoader__.load({
 .mcpm-banner { border: 0.5px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-lg, 16px);
   padding: 9px 11px; color: var(--dsw-alias-label-secondary); font-size: 12px; line-height: 18px; }
 .mcpm-banner.warn { border-color: var(--dsw-alias-state-warn-primary); color: var(--dsw-alias-state-warn-primary); }
+.mcpm-banner.err { border-color: var(--dsw-alias-state-error-primary); color: var(--dsw-alias-state-error-primary); }
+.mcpm-banner-row { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; }
+.mcpm-banner-row > span { flex: 1 1 220px; min-width: 0; }
 .mcpm-error { border: 0.5px solid var(--dsw-alias-state-error-primary); border-radius: var(--dsw-radius-lg, 16px);
   padding: 9px 11px; color: var(--dsw-alias-state-error-primary); font-size: 12px; line-height: 18px; }
 .mcpm-error-lines { display: flex; flex-direction: column; gap: 6px; }
@@ -541,6 +579,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 +632,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 +646,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 +681,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 +714,38 @@ 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]);
+
+      /*
+       * The names that "Retry all" will visit, in list order. Only rows that are
+       * mounted, enabled and stuck in `failed` qualify — a row that is merely
+       * off must stay off, and a healthy row must not be bounced.
+       */
+      const failedList = useMemo(
+        () => [...mountIndex.values()]
+          .filter((item) => item.mounted && item.enabled && item.load?.status === 'failed')
+          .map((item) => item.node.name),
+        [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 +815,67 @@ 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
+       * (dispose the dead fiber, then re-enable it), not a config edit.
+       *
+       * This does NOT go through run(): a failed retry answers with a specific
+       * reason ("could not dispose the stale connection: operation-error — …"),
+       * and a generic "it did not work" toast would throw that away.
+       */
+      const retryLoad = async (name) => {
+        setRetrying((current) => ({ ...current, [name]: true }));
+        setError(null);
+        try {
+          const data = await api('retry', { name });
+          if (data?.state && mounted.current) setState(data.state);
+          if (data?.loaded) flash(t('toast.retried', { name, count: data.load?.toolCount ?? 0 }));
+          else flash(t('toast.retryFailed', { name }));
+          if (data?.warnings?.length) {
+            flash(t('toast.retryWarn', { count: data.warnings.length }));
+          }
+          /*
+           * 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);
+        } catch (cause) {
+          /*
+           * Keep the reason visible: the usual cause is a spawn failure that
+           * only the Host knows about, so surfacing cause.message here is the
+           * whole point of the button.
+           */
+          setError(cause);
+          flash(t('toast.retryReason', { name, reason: cause?.message ?? t('error.retry') }));
+        } finally {
+          setRetrying((current) => {
+            const next = { ...current };
+            delete next[name];
+            return next;
+          });
+        }
+      };
+
+      /*
+       * Retry every failed row in one go.
+       *
+       * Serial on purpose: each retry disposes and rebuilds one fiber, and doing
+       * them at once would spawn a burst of npm processes that fight for the same
+       * network and the same CPU, which makes a slow failure look like a hang.
+       * The list is recomputed from the LAST snapshot so a row that recovers
+       * halfway through is not retried twice.
+       */
+      const retryAll = async () => {
+        const names = failedList;
+        if (names.length === 0) return;
+        for (const name of names) await retryLoad(name);
+      };
+
       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 +931,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 +984,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;
 
@@ -841,6 +995,22 @@ window.__ModuleLoader__.load({
         state.warnings.length
           ? h('div', { className: 'mcpm-banner warn', key: 'parse' }, t('banner.parse', { count: state.warnings.length }))
           : null,
+        /*
+         * Only when the registry is readable: without it every mounted row reads
+         * as `unknown`, and claiming a failure there would be a guess.
+         */
+        registryAvailable && failedList.length
+          ? h('div', { className: 'mcpm-banner err mcpm-banner-row', key: 'loadFailed' }, [
+            h('span', { key: 't' }, t('banner.loadFailed', { count: failedList.length })),
+            h('button', {
+              key: 'r',
+              type: 'button',
+              className: 'mcpm-btn sm',
+              disabled: busy,
+              onClick: retryAll,
+            }, t('btn.retryAll')),
+          ])
+          : null,
       ].filter(Boolean) : [];
 
       const probeTag = (name) => {
@@ -857,6 +1027,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 +1084,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

@@ -21,6 +21,7 @@ import { applyServerToTarget, removeServer, syncServer, snippetFor } from './ops
 import { CLIENTS, CLIENT_BY_ID } from './adapters.js';
 import { redactServer, isSecretKey, isSecretValue, maskValue, dshMountName } from './canonical.js';
 import { toggleServer } from './toggle.js';
+import { countLiveTools, liveToolNames, loadRecord } from './load.js';
 import { mcpEntries } from './dsh.js';
 
 export const name = 'mcp-manager';
@@ -68,6 +69,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) {
@@ -130,6 +136,7 @@ export function apply(ctx, config = {}) {
     backupsToKeep: Number.isFinite(config.backupsToKeep) ? config.backupsToKeep : 20,
     includeProjectScope: config.includeProjectScope !== false,
     probeConcurrency: Number.isFinite(config.probeConcurrency) ? config.probeConcurrency : 4,
+    retryTimeoutMs: Number.isFinite(config.retryTimeoutMs) ? config.retryTimeoutMs : 25000,
   };
 
   const home = process.env.DSH_HOME || join(process.env.USERPROFILE || process.env.HOME || '.', '.dsh');
@@ -144,9 +151,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 -- */
 
@@ -253,6 +267,25 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  /**
+   * Wait until a reconnected server has registered at least one tool.
+   *
+   * Polls the tool registry rather than the composition: a rebuilt fiber shows up
+   * in the composition immediately, but the connection is only proven by the
+   * `mcp__<mount>__*` names it registers. Returns the tool count it last saw, so
+   * a 0 after the budget expires is a measured failure, not a guess.
+   */
+  async function waitForTools(mountName, budgetMs) {
+    const deadline = Date.now() + budgetMs;
+    for (;;) {
+      const names = liveToolNames(toolRegistry());
+      const count = names ? countLiveTools(names, mountName) : 0;
+      if (count > 0) return count;
+      if (Date.now() >= deadline) return count;
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+  }
+
   async function opProbe({ names, timeoutMs } = {}) {
     const state = snapshot(true);
     const wanted = Array.isArray(names) && names.length ? new Set(names) : null;
@@ -321,6 +354,107 @@ 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.
+   *
+   * `hmr.reconcileProfile` looks like the right lever and is NOT. It recomposes
+   * the profile and re-imports the entry, but a failed mcp-client keeps its fiber
+   * `active` (it swallows the connect error under `failOnStartupError: false`),
+   * and reconcile only restarts entries that are INACTIVE. Measured against a
+   * dead row it returned success and rebuilt nothing — a retry button that lies.
+   *
+   * The lever that does rebuild the connection is the one the plugin manager
+   * itself uses: `setPluginEnabled(id, false)` disposes the mcp-client fiber and
+   * `setPluginEnabled(id, true)` recreates it, running `apply()` again — a fresh
+   * connection attempt. This does exactly that, then polls the tool registry
+   * (the only truthful proof of a successful connect) until tools appear or the
+   * budget runs out, so the answer is measured rather than assumed.
+   *
+   * Failure safety: the row is enabled again even when the enable call throws,
+   * because leaving a server switched off would be a worse outcome than a retry
+   * that did not help.
+   */
+  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 manager = typeof ctx.get === 'function' ? ctx.get('pluginManager') : undefined;
+    if (!manager || typeof manager.setPluginEnabled !== 'function') {
+      return { ok: false, code: 'error.dsh.noManager', error: 'the plugin manager is not available, so the connection cannot be rebuilt' };
+    }
+
+    const entryId = target.entryId;
+    const mountName = target.mountedAs ?? target.server?.mountName ?? dshMountName(name);
+    const before = node.load ?? null;
+    const warnings = [];
+    let disabled = false;
+    let enabled = null;
+
+    try {
+      const off = await manager.setPluginEnabled(entryId, false);
+      for (const warning of off?.warnings ?? []) warnings.push(warning);
+      if (off?.application === 'failed') {
+        return {
+          ok: false,
+          code: 'error.dsh.retry',
+          error: `could not dispose the stale connection: ${off?.error?.code ?? 'unknown'}${off?.error?.diagnostic ? ` — ${off.error.diagnostic}` : ''}`,
+          before,
+          state: snapshot(false),
+        };
+      }
+      disabled = true;
+      enabled = await manager.setPluginEnabled(entryId, true);
+      for (const warning of enabled?.warnings ?? []) warnings.push(warning);
+    } catch (error) {
+      /* Put the row back the way the user left it before reporting the failure. */
+      if (disabled) {
+        try {
+          enabled = await manager.setPluginEnabled(entryId, true);
+        } catch { /* the retry error below is the one worth reporting */ }
+      }
+      return {
+        ok: false,
+        code: 'error.dsh.retry',
+        error: String(error && error.message ? error.message : error),
+        before,
+        state: snapshot(false),
+      };
+    }
+
+    const toolCount = await waitForTools(mountName, options.retryTimeoutMs);
+    const after = snapshot(false).servers.find((item) => item.name === name);
+    const load = after?.load ?? loadRecord({ mountName, mounted: true, enabled: true, pending: false, counts: null, registry: false });
+
+    return {
+      ok: true,
+      name,
+      entryId,
+      mountName,
+      before,
+      load,
+      loaded: load?.status === 'loaded',
+      toolCount,
+      warnings,
+      application: enabled?.application ?? null,
+      restartReason: enabled?.restartReason ?? null,
+      state: snapshot(false),
+    };
+  }
+
   const dispatch = async (action, body = {}) => {
     switch (action) {
       case 'scan': return opScan(body);
@@ -332,6 +466,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 +537,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 +575,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.3' };
+const CLIENT_INFO = { name: 'dsh-mcp-manager', version: '0.1.5' };
 
 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']);
 
@@ -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/lib/toggle.js

@@ -67,25 +67,6 @@ export async function toggleServer({ get, profileDir, store }, { name, enabled,
 
   const manager = pluginManagerOf(get);
 
-  /*
-   * Unmounting a row WE created takes our own row out again.
-   *
-   * This runs first, before the Loader path and before the manager check, for
-   * three reasons: the Loader disposes the instance hot but does so by appending
-   * a `disabled: true` override beside the `- insert:` item, which leaves our
-   * row (and the override) in the user's composition forever; removing the
-   * insert item returns the file to exactly the bytes it had before we mounted
-   * anything; and removing a row needs no service, so the switch still works if
-   * the plugin manager is unavailable. A row the user authored is never touched
-   * here — `ownedByUs` requires our own ledger entry for it.
-   */
-  if (!enabled && ownedByUs(store, rowName)) {
-    const removed = removeDshPatchServer({ serverName: rowName, store, profileDir });
-    if (removed.ok && removed.changed) {
-      return { ok: true, changed: true, enabled: false, via: 'patch', restartRequired: false, target: removed.path, unmounted: true };
-    }
-  }
-
   if (!manager) {
     /*
      * No plugin manager: a row we can reach in the patch layer can still be
@@ -149,8 +130,30 @@ export async function toggleServer({ get, profileDir, store }, { name, enabled,
   }
 
   /*
-   * No live row answered. Either the server is only an insert item we have not
-   * reconciled yet, or it is not mounted here at all.
+   * No live row answered. Unmounting a row WE created takes our own row back out
+   * rather than leaving a `disabled: true` override in the user's composition
+   * forever: removing the `- insert:` item returns the file to exactly the bytes
+   * it had before we mounted anything.
+   *
+   * This runs AFTER the Loader path, not before it. It used to run first, and
+   * that was a real bug: a mounted row we once created is also a live Loader
+   * entry, so the switch deleted the YAML row (a file edit that needs a reload)
+   * instead of disposing the running instance hot. Worse, because the removal
+   * appends the block back on re-enable, toggling a row MOVED it to the end of
+   * cordis.patch.yml — the user's file lost its authored ordering. The Loader is
+   * now always asked first; only a row the Loader cannot address is removed from
+   * the patch layer.
+   */
+  if (!enabled && ownedByUs(store, rowName)) {
+    const removed = removeDshPatchServer({ serverName: rowName, store, profileDir });
+    if (removed.ok && removed.changed) {
+      return { ok: true, changed: true, enabled: false, via: 'patch', restartRequired: false, target: removed.path, unmounted: true };
+    }
+  }
+
+  /*
+   * Either the server is only an insert item we have not reconciled yet, or it
+   * is not mounted here at all.
    */
   const pending = readDshPatchServers(profileDir).find((item) => item.name === rowName);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oh-agent/dsh-mcp-manager",
-  "version": "0.1.3",
-  "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.5",
+  "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"
   }
 }
-
+