dsh-runtime-reconcile 0.0.0-stage → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## 0.2.1
+
+Discoverability and metadata only — no behavior changes, no new permissions, still zero I/O.
+
+- Package metadata: `displayName`, `icon`, expanded `keywords` (npm search), `homepage`.
+- README (EN/ZH): npm/version/download badges, a 30-second quick-start, and a one-command install up top.
+- GitHub repository: shorter searchable `description`, npm `homepage`, and expanded `topics` for ecosystem discovery.
+- Runtime-reported version in `core.js` synced to 0.2.1.
+
+## 0.2.0
+
+Diagnosis quality and engineering hardening. No new permissions, no new dependencies, still zero I/O.
+
+- **Root-cause correlation**: a missing web provider is now linked to the installed-but-disabled bundle that likely provides it. That bundle's finding is promoted from `info` to `warning` and marked `linkedToProviderError`.
+- **Actionable remedies**: error and warning findings carry a `remedy` string (e.g. `Enable bundle "@liustack/modsearch" (or set web.searchProvider to …)`), rendered in the text report.
+- **Three-state provider selection**: besides "not registered", the check now detects a configured provider that is registered but `available()` returns false (`WEB_PROVIDER_CONFIGURED_UNAVAILABLE`), and reports which registered providers are unavailable.
+- **Enabled-but-not-active rows**: `rows` now flags enabled Loader rows whose fiber never reached `active` — the class of silent failure static scanners cannot see — instead of only counting disabled rows.
+- **Removed a no-op check**: `tools.definitions()` returns the already-resolved visible set (a Map keyed by name), so duplicate visible names are impossible. The old duplicate-name detection could never fire. Replaced with real signals: visible count, tools declaring no `output` renderer, and listing cap.
+- **Honest `ok`**: a check group that could not run (missing service, throwing enumeration) now sets `complete: false` and forces `ok: false`. Previously an unreadable registry could still produce a clean bill of health.
+- **Input validation**: an invalid `focus` is rejected instead of silently producing an empty "OK" report; `maxTools` is clamped 0–200.
+- **Report metadata**: adds `complete`, `completeness.checked/unavailable`, `version`, and healthy-path findings (`*_PROVIDER_OK`, `BUNDLES_ALL_ENABLED`, `ROWS_ALL_ACTIVE`).
+- **Structure**: pure inspection logic moved to `core.js` (exported as `./core`, unit-testable). `index.js` now only wires the tool. Added `test/selftest.mjs` (14 checks) and `npm test`.
+- Corrected a latent syntax error in the 0.1.0 source path (`ROWS_ALL_ACTIVE` template literal) that the new module split surfaced; 0.1.0's shipped `index.js` was valid.
+
+## 0.1.0
+
+Initial release: read-only `reconcile_runtime` tool with five live check groups (providers / bundles / rows / tools / services).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shuai0503
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,214 @@
-# Temporary Holding Version
+# dsh-runtime-reconcile
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> A read-only agent tool that reconciles **what your DeepSeek Harness profile declares** against **what is actually registered in the live runtime**.
+
+[![npm version](https://img.shields.io/npm/v/dsh-runtime-reconcile.svg)](https://www.npmjs.com/package/dsh-runtime-reconcile)
+[![npm downloads](https://img.shields.io/npm/dm/dsh-runtime-reconcile.svg)](https://www.npmjs.com/package/dsh-runtime-reconcile)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![dsh-plugin](https://img.shields.io/badge/dsh-plugin-2ea44f.svg)](https://github.com/topics/dsh-plugin)
+
+English · [中文](README.zh.md)
+
+**30-second start:** `dsh plugin --profile web add dsh-runtime-reconcile` → start a new session → ask your agent `reconcile_runtime`. It will tell you *why* a tool is failing and what to enable.
+
+Static source scanners see a valid config. This tool sees the running process. It answers questions those scanners cannot:
+
+- Why does `web_search` say *`configured web provider "modsearch" is not registered`* when the config looks fine?
+- Which installed bundle is disabled but still referenced by an active config row?
+- Which tool names are shadowed in the live registry right now?
+- Which core services did this profile fail to mount?
+
+It is **read-only**: no file writes, no network calls, no config changes, no runtime imports.
+
+---
+
+## The problem, concretely
+
+DeepSeek Harness is "everything is a plugin". A profile composes dozens of bundles over ordered patch layers. A plugin row can be inserted, disabled, or overridden by a higher layer; a provider can be named in config while the bundle that registers it sits disabled. The composed config remains syntactically valid, so nothing complains at boot — the failure only appears when a tool call reaches provider selection:
+
+```
+configured web provider "modsearch" is not registered
+```
+
+`ctx.web` holds `config.searchProvider = 'modsearch'`, but its live `searchProviders` map contains only the providers whose bundles actually mounted. Source-level checks (`dsh-trust-check`, `dsh-plugin-preflight`, `dsh-conflict-doctor`, `dsh-doctor`, `dsh-plugin-ops`) inspect packages, manifests and patch files **before** or **outside** the running composition. They cannot see this drift, because the drift only exists after the Loader has applied every layer.
+
+`dsh-runtime-reconcile` runs *inside* that composed process and reads the live services through `ctx.get()`.
+
+### How it differs from adjacent tools
+
+| Tool | Inspects | Sees live provider maps / Loader rows? |
+|---|---|---|
+| `dsh-trust-check`, `dsh-plugin-preflight` | package source / manifest | no (pre-install, static) |
+| `dsh-conflict-doctor`, `dsh-plugin-conflict-guard` | declared capabilities | no (static / at install) |
+| `dsh-doctor`, `dsh-plugin-ops` | profile files, boot logs | no (pre-boot / post-mortem) |
+| `dsh-harbor` | declared vs detected ledger | partly (static reconciliation) |
+| `dsh-vitals`, `dsh-system-vitals` | CPU / RAM / GPU | no (hardware, not the plugin graph) |
+| **dsh-runtime-reconcile** | **live `ctx.web`, `ctx.tools`, `ctx.pluginManager`** | **yes** |
+
+Ecosystem scale of the underlying problem is documented in [deepseek-harness discussion #4253](https://github.com/deepseek-ai/deepseek-harness/discussions/4253): across 9,873 real plugins, 553 tool-name collisions, 452 entry-id collisions and 89 orphan patches fail silently. This tool does not fix those — the fixes that matter belong upstream — but it makes the *current* profile's state observable to both the user and the agent.
+
+---
+
+## What it checks
+
+| Group | Live source | Detects |
+|---|---|---|
+| `providers` | `ctx.web.config`, `searchProviders` / `fetchProviders` maps, `DSH_WEB_SEARCH_PROVIDER` / `DSH_WEB_FETCH_PROVIDER` | configured-but-unregistered, registered-but-unavailable, no provider, ambiguous providers |
+| `bundles` | `pluginManager.listBundles()` | installed-but-disabled bundles, **correlated as the likely root cause** of a provider error |
+| `rows` | `pluginManager.listPlugins()` | **enabled-but-not-active** Loader rows, disabled rows, active / total counts |
+| `tools` | `tools.definitions()` | visible tool count, tools without an `output` renderer, listing cap |
+| `services` | `ctx.get()` on core seams | missing optional services |
+
+Findings carry `severity`, `code`, `title`, `detail`, structured `evidence` and an actionable **`remedy`**. They are **observations, not a security verdict**.
+
+A check group that cannot run (missing service, throwing enumeration) is recorded in `completeness.unavailable` and forces `ok: false` / `complete: false` — an unreadable registry is never reported as a clean bill of health. An invalid `focus` is rejected rather than silently yielding an empty OK report.
+
+---
+
+## Install
+
+One command, no build step, zero dependencies, no network access at runtime:
+
+```bash
+dsh plugin --profile web add dsh-runtime-reconcile
+```
+
+GitHub source (pin a commit or tag):
+
+```bash
+dsh plugin --profile web add github:shuai0503/dsh-runtime-reconcile#v0.2.1
+```
+
+From npm (no build step, no dependencies):
+
+```bash
+dsh plugin --profile web add dsh-runtime-reconcile
+```
+
+Local development:
+
+```bash
+dsh plugin --profile web add file:/absolute/path/to/dsh-runtime-reconcile
+```
+
+Or via the Harness plugin manager / Web GUI: install the bundle directory. GitHub-sourced installs may require allowing a build — **this package has no build scripts and no dependencies**, so there is nothing to allow.
+
+Then **start a new session** so the newly registered tool enters the model's tool set.
+
+---
+
+## Usage
+
+Ask your agent, or call directly:
+
+```
+reconcile_runtime {}
+reconcile_runtime { "focus": "providers" }
+reconcile_runtime { "focus": "all", "maxTools": 200 }
+```
+
+`focus` narrows the output without skipping any safety-relevant inspection; `maxTools` caps the listed tool names (default 40, max 200), not the checks themselves.
+
+### Example output
+
+```
+Runtime reconcile — 1 error(s), 1 warning(s), 4 info
+focus=all  complete=true  generatedAt=2026-11-14T09:35:06.996Z
+
+web.search: configured=modsearch registered=[deepseek-official, web-search-free]
+web.fetch : configured=fs-quality-fetch registered=[fs-quality-fetch, http]
+bundles: 3/4 enabled; disabled=[@liustack/modsearch]
+loader rows: 200/202 active; 2 disabled; 0 enabled-but-not-active
+tools: 5 visible
+
+[ERROR] WEB_SEARCH_PROVIDER_MISSING — Configured search provider "modsearch" is not registered
+  ctx.web.searchProvider points at "modsearch", but the live searchProviders
+  registry contains [deepseek-official, web-search-free]. Every search call fails
+  at provider selection. The bundle "@liustack/modsearch" is installed but
+  disabled — that is the likely cause.
+  evidence: {"configuredFrom":"web.searchProvider","configured":"modsearch",
+             "registered":["deepseek-official","web-search-free"],
+             "disabledBundle":"@liustack/modsearch"}
+  remedy: Enable bundle "@liustack/modsearch" (or set web.searchProvider to one
+          of: deepseek-official, web-search-free).
+[WARNING] BUNDLE_DISABLED — Bundle "@liustack/modsearch" is installed but disabled
+  This disabled bundle is the likely cause of a provider error above.
+  evidence: {"bundle":"@liustack/modsearch","linkedToProviderError":true}
+[INFO] WEB_FETCH_PROVIDER_OK — fetch provider "fs-quality-fetch" is configured and live
+[INFO] ROWS_DISABLED — 2 of 202 Loader rows are disabled
+[INFO] TOOL_REGISTRY_OK — 5 tools are visible in the global scope
+[INFO] SERVICES_OK — 7 core services are live
+
+Read-only live inspection. No files, no network, no config changes.
+```
+
+The error/bundle pair is the whole diagnosis, and the `remedy` line is the next action. This tool deliberately does **not** edit your `cordis.patch.yml`.
+
+---
+
+## Design constraints (why it looks unusual)
+
+- **Zero runtime imports.** This package imports no `@deepseek-ai/*` module. Profiles use a hoisted pnpm layout: importing a runtime package from a third-party bundle can hoist a second copy to the profile root and shadow the host's copy. `Symbol` identity is per-module-instance, so the host then reads `undefined` and every tool call fails — see [discussion #1697](https://github.com/deepseek-ai/deepseek-harness/discussions/1697). Everything is reached through `ctx.get()` / `ctx.inject()` instead.
+- **No row-level `inject`.** A declared injection that is unavailable would keep the row from activating entirely — the plugin would be silent exactly when it is most useful. The plugin always mounts, and registers its single tool only when the `tools` seam is present.
+- **Namespaced row id.** `dsh-runtime-reconcile` avoids the generic ids (`storage`, `web`, …) that collide across hundreds of community bundles.
+- **Host-only, no Client half.** The report renders in the conversation, so there is no slot registration, no theme dependency and no Web rebuild.
+- **Plain `ToolDefinition` object.** No `defineTool()` import; the tool is registered with `ctx.tools.register()` using a plain JSON schema.
+
+---
+
+## Compatibility
+
+| | |
+|---|---|
+| DeepSeek Harness | `>=0.2.1-rc.2 <0.4.0-0` (declared via `engines.dsh`) |
+| Verified on | 0.2.2-rc.1 / 0.2.2-rc.2 (Web profile, Windows) |
+| Node | no direct Node API used in shipped code |
+| Profiles | web / desktop / any profile mounting the `tools` seam |
+| Dependencies | **none** |
+| Build scripts | **none** |
+| Network calls | **none** |
+| Writes | **none** |
+
+If the `tools` seam is absent the plugin still mounts and the `services` check reports it; the tool simply is not registered.
+
+---
+
+## Development
+
+```
+npm test          # 14 pure-core checks, no Harness runtime needed
+```
+
+`core.js` holds all inspection logic and depends on nothing — `collect()` takes a context-like object, so `test/selftest.mjs` drives it with a faithful mock of the live services. `index.js` only wires the tool. This split keeps the diagnosis testable without booting a profile.
+
+---
+
+## Privacy and trust
+
+The tool reads service objects already present in the Harness process. It does not read your files, inspect personal browser profiles, read credentials, contact any host, or transmit anything. Its entire output is a JSON report rendered into the current conversation. The one environment value it consults is `DSH_WEB_SEARCH_PROVIDER` / `DSH_WEB_FETCH_PROVIDER` (a provider id, not a secret) because the web seam itself honours those overrides.
+
+---
+
+## Limitations
+
+- It **diagnoses, does not repair**. Fixing a misconfigured provider means editing the profile patch or enabling the bundle, which is a user decision.
+- Checks are best-effort and defensive: a changed internal service shape degrades into a warning rather than a crash. If a future DSH renames `searchProviders`, the provider check reports the seam as unavailable instead of guessing.
+- Duplicate visible tool names are **not** detected, by design: `tools.definitions()` is the already-resolved visible set (a Map keyed by name), so duplicates cannot appear. Scoped shadowing is resolved by the registry itself. Declaring otherwise would be a check that can never fire.
+- The disabled-bundle correlation is heuristic string matching (package name ↔ provider id). It is a strong hint, not proof of ownership.
+- Findings describe state at call time. Re-run after enabling/disabling bundles or changing config.
+
+---
+
+## Repository
+
+Source: [github.com/shuai0503/dsh-runtime-reconcile](https://github.com/shuai0503/dsh-runtime-reconcile). Issues and pull requests are welcome.
+
+The `v0.2.1` tag makes the GitHub install command above resolve. The package is also published to npm, so `dsh plugin --profile web add dsh-runtime-reconcile` works without a build step. See [CHANGELOG.md](CHANGELOG.md) for the 0.1.0 → 0.2.1 changes.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+This is an independent community plugin, not affiliated with, endorsed by, or published by DeepSeek.

package/README.zh.md

@@ -0,0 +1,212 @@
+# dsh-runtime-reconcile
+
+> 一个**只读**的 Agent 工具：把「DeepSeek Harness profile 声明了什么」与「活体运行时里真正注册了什么」做对账。
+
+[![npm version](https://img.shields.io/npm/v/dsh-runtime-reconcile.svg)](https://www.npmjs.com/package/dsh-runtime-reconcile)
+[![npm downloads](https://img.shields.io/npm/dm/dsh-runtime-reconcile.svg)](https://www.npmjs.com/package/dsh-runtime-reconcile)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![dsh-plugin](https://img.shields.io/badge/dsh-plugin-2ea44f.svg)](https://github.com/topics/dsh-plugin)
+
+[English](README.md) · 中文
+
+**30 秒上手**：`dsh plugin --profile web add dsh-runtime-reconcile` → 新开一个会话 → 对 Agent 说 `reconcile_runtime`。它会告诉你某次工具调用**为什么**失败、该启用哪个 bundle。
+
+静态扫描器看到的是一份语法合法的配置。这个工具看到的是**正在运行的进程**。它能回答那些扫描器回答不了的问题：
+
+- 为什么 `web_search` 报 *`configured web provider "modsearch" is not registered`*，可配置明明看着没问题？
+- 哪个已安装的 bundle 被禁用了，却仍被某条生效的配置行引用？
+- 此刻活体工具注册表里有哪些工具名被遮蔽、哪些工具缺 output renderer？
+- 这个 profile 有哪些核心服务没挂载上？
+
+**只读**：不写文件、不联网、不改配置、不导入任何运行时包。
+
+---
+
+## 问题，具体地说
+
+DeepSeek Harness 是「一切皆插件」。一个 profile 由数十个 bundle 按顺序叠加的补丁层组合而成。某行可以被插入、禁用、或被更高层覆盖；某个 provider 可以在配置里被点名，而负责注册它的 bundle 却处于 disabled。组合出来的配置**语法依然完全合法**，启动时不会有任何抱怨——直到某次工具调用走到 provider 选择才炸：
+
+```
+configured web provider "modsearch" is not registered
+```
+
+`ctx.web` 里 `config.searchProvider = 'modsearch'`，但它的活体 `searchProviders` Map 里只有那些 bundle 真正挂载后才注册的 provider。源码级检查（`dsh-trust-check`、`dsh-plugin-preflight`、`dsh-conflict-doctor`、`dsh-doctor`、`dsh-plugin-ops`）看的是**安装前/进程外**的包、清单和补丁文件，看不到这种漂移——因为漂移只在 Loader 把所有层应用完之后才存在。
+
+`dsh-runtime-reconcile` 就跑在那个组合完成的进程内部，通过 `ctx.get()` 读活体服务。
+
+### 与同类工具的差别
+
+| 工具 | 检查对象 | 能看到活体 provider 表 / Loader 行吗 |
+|---|---|---|
+| `dsh-trust-check`、`dsh-plugin-preflight` | 包源码 / manifest | 否（装前静态） |
+| `dsh-conflict-doctor`、`dsh-plugin-conflict-guard` | 声明的能力 | 否（静态 / 安装时） |
+| `dsh-doctor`、`dsh-plugin-ops` | profile 文件、启动日志 | 否（启动前 / 事后） |
+| `dsh-harbor` | 声明 vs 检出的 ledger | 部分（静态对账） |
+| `dsh-vitals`、`dsh-system-vitals` | CPU / 内存 / GPU | 否（硬件，不是插件图） |
+| **dsh-runtime-reconcile** | **活体 `ctx.web` / `ctx.tools` / `ctx.pluginManager`** | **是** |
+
+问题规模有量化依据：[deepseek-harness 讨论 #4253](https://github.com/deepseek-ai/deepseek-harness/discussions/4253) 扫描 9,873 个真实插件，发现 553 起工具名冲突、452 起 entry id 撞车、89 个孤儿补丁静默失效。本工具**不修**这些（真正该修的在核心里），但它让**当前 profile 的状态**对用户和 Agent 都可见。
+
+---
+
+## 检查项
+
+| 组 | 活体数据源 | 检出 |
+|---|---|---|
+| `providers` | `ctx.web.config`、`searchProviders`/`fetchProviders` Map、`DSH_WEB_SEARCH_PROVIDER`/`DSH_WEB_FETCH_PROVIDER` | 配置指向但未注册、已注册但不可用、无 provider、多 provider 歧义 |
+| `bundles` | `pluginManager.listBundles()` | 已装但禁用的 bundle，**自动关联为 provider 错误的可能根因** |
+| `rows` | `pluginManager.listPlugins()` | **enabled 但未进入 active 阶段**的 Loader 行、禁用行、active/total |
+| `tools` | `tools.definitions()` | 可见工具数、缺 `output` renderer 的工具、列表上限 |
+| `services` | `ctx.get()` 核心 seam | 缺失的可选服务 |
+
+每条 finding 带 `severity`、`code`、`title`、`detail`、结构化 `evidence`，以及可执行的 **`remedy`**。它们是**观察结论，不是安全背书**。
+
+某个检查组跑不起来（服务缺失、枚举抛错）会记进 `completeness.unavailable`，并强制 `ok: false` / `complete: false`——读不到注册表绝不会被报成「一切正常」。非法的 `focus` 会被拒绝，而不是静默产出一份空的 OK 报告。
+
+---
+
+## 安装
+
+一条命令，无需构建、零依赖、运行时不联网：
+
+```bash
+dsh plugin --profile web add dsh-runtime-reconcile
+```
+
+GitHub 源（推荐，固定到 tag 或 commit）：
+
+```bash
+dsh plugin --profile web add github:shuai0503/dsh-runtime-reconcile#v0.2.1
+```
+
+npm（同上，免构建）：
+
+```bash
+dsh plugin --profile web add dsh-runtime-reconcile
+```
+
+本地开发：
+
+```bash
+dsh plugin --profile web add file:/绝对路径/dsh-runtime-reconcile
+```
+
+也可以在 Harness 插件管理器 / Web GUI 里安装 bundle 目录。GitHub 源安装有时会要求允许构建脚本——**本包无构建脚本、无依赖**，没什么需要允许的。
+
+然后**新开一个会话**，让新注册的工具进入模型的工具集。
+
+---
+
+## 用法
+
+直接让 Agent 调，或显式调用：
+
+```
+reconcile_runtime {}
+reconcile_runtime { "focus": "providers" }
+reconcile_runtime { "focus": "all", "maxTools": 200 }
+```
+
+`focus` 只收窄输出，不跳过任何与安全性相关的检查；`maxTools` 限制列出的工具名数量（默认 40，上限 200），不限制检查本身。
+
+### 输出示例
+
+```
+Runtime reconcile — 1 error(s), 1 warning(s), 4 info
+focus=all  complete=true  generatedAt=2026-11-14T09:35:06.996Z
+
+web.search: configured=modsearch registered=[deepseek-official, web-search-free]
+web.fetch : configured=fs-quality-fetch registered=[fs-quality-fetch, http]
+bundles: 3/4 enabled; disabled=[@liustack/modsearch]
+loader rows: 200/202 active; 2 disabled; 0 enabled-but-not-active
+tools: 5 visible
+
+[ERROR] WEB_SEARCH_PROVIDER_MISSING — Configured search provider "modsearch" is not registered
+  ctx.web.searchProvider 指向 "modsearch"，但活体 searchProviders 注册表里是
+  [deepseek-official, web-search-free]。每次搜索调用都会在 provider 选择处失败。
+  bundle "@liustack/modsearch" 已安装但被禁用——这很可能就是原因。
+  evidence: {"configuredFrom":"web.searchProvider","configured":"modsearch",
+             "registered":["deepseek-official","web-search-free"],
+             "disabledBundle":"@liustack/modsearch"}
+  remedy: 启用 bundle "@liustack/modsearch"（或把 web.searchProvider 改成
+          deepseek-official / web-search-free 之一）。
+[WARNING] BUNDLE_DISABLED — Bundle "@liustack/modsearch" 已安装但被禁用
+  这个被禁用的 bundle 很可能是上面 provider 错误的原因。
+  evidence: {"bundle":"@liustack/modsearch","linkedToProviderError":true}
+[INFO] WEB_FETCH_PROVIDER_OK — fetch provider "fs-quality-fetch" 已配置且存活
+[INFO] ROWS_DISABLED — 202 行里有 2 行禁用
+[INFO] TOOL_REGISTRY_OK — 全局作用域可见 5 个工具
+[INFO] SERVICES_OK — 7 个核心服务均存活
+```
+
+错误 + bundle 这两条就是完整诊断，`remedy` 那行就是下一步动作。工具**故意不**去改你的 `cordis.patch.yml`。
+
+---
+
+## 设计约束（为什么长这样）
+
+- **零运行时导入。** 不 import 任何 `@deepseek-ai/*` 模块。profile 用 hoisted pnpm 布局：第三方 bundle 引入运行时包可能把第二份副本提升到 profile 顶层、遮蔽宿主的副本。`Symbol` 身份是 per-module-instance 的，宿主随后读到 `undefined`，整个 profile 的每次工具调用都会失败——见[讨论 #1697](https://github.com/deepseek-ai/deepseek-harness/discussions/1697)。全部改用 `ctx.get()` / `ctx.inject()`。
+- **row 层不写 `inject`。** 声明式注入一旦不可用会让整行不激活——插件会在最该说话的时候失声。插件始终挂载，只在 `tools` seam 存在时注册工具。
+- **命名空间化的 row id / 工具名。** `dsh-runtime-reconcile` / `reconcile_runtime` 避开 #4253 测到的 452 起 entry id 撞车与 553 起工具名撞车。
+- **Host-only，无 Client 半。** 报告在会话里渲染，无需 slot 注册、主题 token，也无需重建 Web 产物。
+- **纯对象 `ToolDefinition`。** 不用 `defineTool()`，用 `ctx.tools.register()` 配普通 JSON Schema。
+- **`core.js` 是纯逻辑。** 所有检查逻辑不依赖运行时，`collect()` 接受一个 context-like 对象，因此可用 mock 做单元测试。
+
+---
+
+## 兼容性
+
+| | |
+|---|---|
+| DeepSeek Harness | `>=0.2.1-rc.2 <0.4.0-0`（通过 `engines.dsh` 声明） |
+| 实测环境 | 0.2.2-rc.1 / 0.2.2-rc.2（Web profile，Windows） |
+| Node | 发布代码不直接用 Node API |
+| Profile | web / desktop / 任何挂载了 `tools` seam 的 profile |
+| 依赖 | **无** |
+| 构建脚本 | **无** |
+| 网络请求 | **无** |
+| 写操作 | **无** |
+
+若 `tools` seam 缺失，插件仍会挂载，`services` 检查会把它报出来，只是工具不会注册。
+
+---
+
+## 开发
+
+```
+npm test          # 14 项纯 core 检查，不需要 Harness 运行时
+```
+
+（本机 node 不在 PATH 时，先把 node 所在目录加进 PATH——这是本机环境事实，不是项目要求。）
+
+`core.js` 承载全部检查逻辑、零依赖；`index.js` 只负责接线。这样诊断逻辑不用启动 profile 就能测试。
+
+---
+
+## 隐私与信任
+
+工具只读取 Harness 进程里本就存在的服务对象。不读你的文件、不翻个人浏览器 profile、不读凭据、不联系任何主机、不往外发任何东西。全部输出就是一份渲染进当前会话的 JSON 报告。唯一会查的环境变量是 `DSH_WEB_SEARCH_PROVIDER` / `DSH_WEB_FETCH_PROVIDER`（一个 provider id，不是密钥），因为 web seam 本身认这两个覆盖。
+
+---
+
+## 局限
+
+- **只诊断，不修复。** 改配置或启用 bundle 是用户决定。
+- 检查是尽力而为、防御式的：内部服务结构变了会降级成 warning 而不是崩溃。若未来 DSH 改名 `searchProviders`，provider 检查会报「seam 不可用」而不是瞎猜。
+- **故意不检测重复的可见工具名**：`tools.definitions()` 是已解析的可见集合（按名字索引的 Map），重复不可能出现；scope 遮蔽由注册表自己解决。硬说能检测，就是一个永远不会触发的检查。
+- 禁用 bundle 的关联是启发式字符串匹配（包名 ↔ provider id），是强提示，不是所有权证明。
+- finding 描述的是调用时刻的状态。启用/禁用 bundle 或改配置后请重跑。
+
+---
+
+## 仓库
+
+源码：[github.com/shuai0503/dsh-runtime-reconcile](https://github.com/shuai0503/dsh-runtime-reconcile)，欢迎 issue 与 PR。`v0.2.1` tag 让上面的 GitHub 安装命令可解析。本包同时也发布在 npm 上，所以 `dsh plugin --profile web add dsh-runtime-reconcile` 无需任何构建步骤即可使用。0.1.0 → 0.2.1 的变化见 [CHANGELOG.md](CHANGELOG.md)。
+
+---
+
+## 许可
+
+MIT — 见 [LICENSE](LICENSE)。
+
+独立社区插件，与 DeepSeek 无隶属、无背书、非官方发布。

package/cordis.patch.yml

@@ -0,0 +1,10 @@
+# One Host-only row. No row-level inject: the plugin must always mount so it can
+# *report* a missing service rather than silently not activating. index.js uses
+# ctx.inject(['tools'], ...) for the one capability its tool registration truly
+# needs, and ctx.get() defensively for everything else.
+#
+# The row id is namespaced to the package to avoid the entry-id collisions
+# measured in deepseek-harness discussion #4253 (452 colliding entry ids).
+- insert:
+    - id: dsh-runtime-reconcile
+      name: dsh-runtime-reconcile

package/core.js

@@ -0,0 +1,413 @@
+/**
+ * dsh-runtime-reconcile — pure inspection core.
+ *
+ * No runtime imports, no Node APIs beyond process.env, no I/O. `collect()` takes
+ * a context-like object and returns a plain JSON report, so it can be unit
+ * tested with a mock (see test/selftest.mjs) and reused outside a Host plugin.
+ *
+ * Design note: importing a @deepseek-ai/* runtime package from a third-party
+ * bundle can hoist a second copy and shadow the host's copy (Symbol identity is
+ * per-module-instance), breaking every tool call — see deepseek-harness
+ * discussion #1697. Everything here is reached through ctx.get().
+ */
+
+export const GROUPS = Object.freeze([
+  'providers', 'bundles', 'rows', 'tools', 'services',
+]);
+
+export const FOCI = Object.freeze(['all', ...GROUPS]);
+
+/** Core seams we expect in a healthy web profile. */
+const EXPECTED_SERVICES = Object.freeze([
+  'tools', 'web', 'pluginManager', 'configEditor', 'commands',
+  'systemPrompt', 'sessionProjections',
+]);
+
+/** Read a service defensively; a missing service is reported, never thrown. */
+function service(ctx, key) {
+  try {
+    return ctx?.get?.(key);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Pull a configured id out of a z.string().volatile() field or a plain value. */
+function configuredId(value) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') return value || undefined;
+  if (typeof value === 'object' && typeof value.get === 'function') {
+    try {
+      return configuredId(value.get());
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+/** Provider registry ids plus each provider's live availability/readiness. */
+function inspectProviderMap(map) {
+  const entries = [];
+  if (!map || typeof map.keys !== 'function') return { entries, available: false, ids: [] };
+  for (const [id, provider] of map.entries()) {
+    const name = String(id);
+    let present = true;
+    let unavailable = false;
+    try {
+      // The web seam calls provider.available() before selecting it.
+      if (provider && typeof provider.available === 'function' && !provider.available()) unavailable = true;
+    } catch {
+      // A throwing available() is itself a fault at selection time.
+      unavailable = true;
+    }
+    entries.push({ id: name, present, unavailable });
+  }
+  entries.sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    entries,
+    available: entries.length > 0,
+    ids: entries.map((e) => e.id),
+  };
+}
+
+function makeFinding(severity, code, title, detail, evidence, remedy) {
+  return {
+    severity, code, title, detail,
+    ...(evidence !== undefined ? { evidence } : {}),
+    ...(remedy !== undefined ? { remedy } : {}),
+  };
+}
+
+/** Does the named provider belong to a disabled bundle? Pure string matching. */
+function bundleForProvider(providerId, disabledBundles) {
+  if (!providerId) return undefined;
+  const needle = providerId.toLowerCase();
+  // Longest match first: "@liustack/modsearch" should beat a short "mod" hit.
+  const sorted = [...disabledBundles].sort((a, b) => b.length - a.length);
+  return sorted.find((name) => {
+    const n = name.toLowerCase();
+    return n === needle || n.endsWith('/' + needle) || needle === n.split('/').pop() || n.includes(needle);
+  });
+}
+
+/**
+ * Live report.
+ *
+ * `focus`: 'all' | one of GROUPS. Invalid values are rejected (see
+ * normalizeOptions) rather than silently producing an empty "OK" report.
+ * `maxTools`: cap on listed tool names, clamped 0..200.
+ */
+export async function collect(ctx, options = {}) {
+  const { focus = 'all', maxTools = 40 } = options;
+  const findings = [];
+  const summary = { errors: 0, warnings: 0, info: 0 };
+  const completeness = { checked: [], unavailable: [] };
+  let incomplete = false;
+
+  const add = (f) => {
+    if (!f) return;
+    findings.push(f);
+    if (f.severity === 'error') summary.errors += 1;
+    else if (f.severity === 'warning') summary.warnings += 1;
+    else summary.info += 1;
+  };
+  const group = (name, present) => {
+    const wanted = focus === 'all' || focus === name;
+    if (!wanted) return false;
+    completeness.checked.push(name);
+    if (!present) {
+      completeness.unavailable.push(name);
+      incomplete = true;
+    }
+    return present;
+  };
+
+  // Pre-fetch bundles once: the provider check correlates against them below.
+  // This keeps the diagnosis in one report without a second plugin-manager call.
+  const pm = service(ctx, 'pluginManager');
+  let bundlesRaw = null;
+  let bundlesError;
+  if (pm && typeof pm.listBundles === 'function') {
+    try {
+      const value = await pm.listBundles();
+      if (Array.isArray(value)) bundlesRaw = value;
+    } catch (error) {
+      bundlesError = String(error?.message ?? error);
+    }
+  }
+  const disabledBundles = [];
+  const bundleSnapshot = { total: 0, enabled: 0, disabled: [], unavailable: false };
+  if (bundlesRaw) {
+    bundleSnapshot.total = bundlesRaw.length;
+    for (const b of bundlesRaw) {
+      const name = String(b?.name ?? b?.id ?? '?');
+      if (b?.enabled === true) bundleSnapshot.enabled += 1;
+      else if (b?.enabled === false) {
+        bundleSnapshot.disabled.push(name);
+        disabledBundles.push(name);
+      }
+    }
+  } else {
+    bundleSnapshot.unavailable = true;
+  }
+
+  // --- 1. Web providers: three-state selection, correlated with bundles ---
+  const providerSnapshot = { search: null, fetch: null };
+  const web = service(ctx, 'web');
+  if (group('providers', !!web)) {
+    for (const [kind, configKey, mapKey, envKey] of [
+      ['search', 'searchProvider', 'searchProviders', 'DSH_WEB_SEARCH_PROVIDER'],
+      ['fetch', 'fetchProvider', 'fetchProviders', 'DSH_WEB_FETCH_PROVIDER'],
+    ]) {
+      const envValue = process.env?.[envKey];
+      const configured = configuredId(web.config?.[configKey]) ?? envValue;
+      const inspected = inspectProviderMap(web[mapKey]);
+      providerSnapshot[kind] = {
+        configured: configured ?? null,
+        configuredFrom: envValue ? envKey : (configured ? `web.${configKey}` : null),
+        registered: inspected.ids,
+        unavailable: inspected.entries.filter((e) => e.unavailable).map((e) => e.id),
+      };
+      if (!inspected.available) {
+        add(makeFinding('error', `WEB_${kind.toUpperCase()}_NO_PROVIDER`,
+          `No ${kind} provider is registered`,
+          `The live ${mapKey} map is empty, so ${kind}() cannot resolve any provider.`,
+          { map: mapKey },
+          'Enable the bundle that provides a web search/fetch provider, or set web.' + configKey + ' to one that is mounted.'));
+        continue;
+      }
+      if (configured && !inspected.ids.includes(configured)) {
+        const culprit = bundleForProvider(configured, disabledBundles);
+        const evidence = {
+          configuredFrom: providerSnapshot[kind].configuredFrom,
+          configured,
+          registered: inspected.ids,
+          ...(culprit ? { disabledBundle: culprit } : {}),
+        };
+        add(makeFinding('error', `WEB_${kind.toUpperCase()}_PROVIDER_MISSING`,
+          `Configured ${kind} provider "${configured}" is not registered`,
+          `ctx.web.${configKey} points at "${configured}", but the live ${mapKey} registry contains [${inspected.ids.join(', ')}]. Every ${kind} call fails at provider selection.`
+          + (culprit ? ` The bundle "${culprit}" is installed but disabled — that is the likely cause.` : ''),
+          evidence,
+          culprit
+            ? `Enable bundle "${culprit}" (or set web.${configKey} to one of: ${inspected.ids.join(', ')}).`
+            : `Set web.${configKey} to one of the registered providers: ${inspected.ids.join(', ')}, or install the bundle that provides "${configured}".`));
+        continue;
+      }
+      const chosen = configured
+        ? inspected.entries.find((e) => e.id === configured)
+        : undefined;
+      if (chosen?.unavailable) {
+        add(makeFinding('error', `WEB_${kind.toUpperCase()}_PROVIDER_UNAVAILABLE`,
+          `Configured ${kind} provider "${configured}" is registered but unavailable`,
+          'The web seam calls provider.available() before selecting it; this provider reports false (or threw), so resolveProvider() rejects with WEB_PROVIDER_CONFIGURED_UNAVAILABLE.',
+          { configured, registered: inspected.ids },
+          `Check the provider's credentials/readiness, or point web.${configKey} at another registered provider.`));
+        continue;
+      }
+      if (!configured && inspected.ids.length > 1) {
+        add(makeFinding('warning', `WEB_${kind.toUpperCase()}_AMBIGUOUS`,
+          `${inspected.ids.length} ${kind} providers registered with no selection`,
+          'Without an explicit config, resolveProvider() rejects with WEB_PROVIDER_AMBIGUOUS.',
+          { registered: inspected.ids },
+          `Set web.${configKey} to one of: ${inspected.ids.join(', ')}.`));
+        continue;
+      }
+      if (configured && inspected.ids.includes(configured)) {
+        add(makeFinding('info', `WEB_${kind.toUpperCase()}_PROVIDER_OK`,
+          `${kind} provider "${configured}" is configured and live`,
+          'The configured id resolves to a registered, available provider.',
+          { configured, registered: inspected.ids }));
+      }
+    }
+  }
+
+  // --- 2. Disabled installed bundles ---
+  if (group('bundles', bundlesRaw !== null)) {
+    if (bundlesError) {
+      add(makeFinding('warning', 'BUNDLE_LIST_FAILED', 'Could not enumerate installed bundles',
+        bundlesError, undefined, 'Retry after the profile settles; a failing plugin manager may indicate a broken composition.'));
+    } else {
+      for (const name of bundleSnapshot.disabled) {
+        const linked = findings.some((f) => f.code.startsWith('WEB_') && f.evidence?.disabledBundle === name);
+        add(makeFinding(linked ? 'warning' : 'info',
+          'BUNDLE_DISABLED', `Bundle "${name}" is installed but disabled`,
+          linked
+            ? 'This disabled bundle is the likely cause of a provider error above.'
+            : 'Its rows are inserted into the composition but never mounted. It matters only when a config points at a capability it provides.',
+          { bundle: name, linkedToProviderError: linked }));
+      }
+      if (bundleSnapshot.disabled.length === 0) {
+        add(makeFinding('info', 'BUNDLES_ALL_ENABLED', `${bundleSnapshot.total} installed bundles are enabled`,
+          'No installed bundle is disabled.'));
+      }
+    }
+  }
+
+  // --- 3. Loader rows: enabled-but-not-active is the real silent failure ---
+  const rowsSnapshot = { total: 0, active: 0, disabled: [], notActive: [] };
+  let rowsRaw = null;
+  let rowsError;
+  if (pm && typeof pm.listPlugins === 'function') {
+    try {
+      const value = await pm.listPlugins();
+      if (Array.isArray(value)) rowsRaw = value;
+    } catch (error) {
+      rowsError = String(error?.message ?? error);
+    }
+  }
+  if (group('rows', rowsRaw !== null)) {
+    if (rowsError) {
+      add(makeFinding('warning', 'PLUGIN_LIST_FAILED', 'Could not enumerate Loader rows', rowsError));
+    } else {
+      rowsSnapshot.total = rowsRaw.length;
+      for (const row of rowsRaw) {
+        const label = String(row?.moduleName ?? row?.entryId ?? '?');
+        if (row?.enabled === false) rowsSnapshot.disabled.push(label);
+        else if (row?.enabled === true && row?.fiberPhase !== 'active') rowsSnapshot.notActive.push(label);
+        else if (row?.enabled === true) rowsSnapshot.active += 1;
+      }
+      if (rowsSnapshot.notActive.length > 0) {
+        add(makeFinding('warning', 'ROWS_NOT_ACTIVE',
+          `${rowsSnapshot.notActive.length} enabled Loader row(s) are not in the active phase`,
+          'These rows are enabled but their fiber never reached "active" — the capability they were meant to provide is not live. This is the class of failure static scanners cannot see.',
+          { rows: rowsSnapshot.notActive.slice(0, 20) },
+          'Check the row\'s injection targets and load errors; a restart or fixing the missing dependency usually resolves it.'));
+      }
+      if (rowsSnapshot.disabled.length > 0) {
+        add(makeFinding('info', 'ROWS_DISABLED',
+          `${rowsSnapshot.disabled.length} of ${rowsSnapshot.total} Loader rows are disabled`,
+          'Disabled rows are expected for opt-in features. They matter only when a configured provider, command or service points at one of them.',
+          { count: rowsSnapshot.disabled.length, examples: rowsSnapshot.disabled.slice(0, 12) }));
+      }
+      if (rowsSnapshot.notActive.length === 0 && rowsSnapshot.disabled.length === 0) {
+        add(makeFinding('info', 'ROWS_ALL_ACTIVE', `${rowsSnapshot.active}/${rowsSnapshot.total} Loader rows are active`,
+          'Every enabled row reached the active fiber phase.'));
+      }
+    }
+  }
+
+  // --- 4. Tool registry health ---
+  // NOTE: tools.definitions() returns the *resolved* visible set (a Map keyed by
+  // name), so duplicate names cannot appear there — counting them was a no-op.
+  // Instead report real signals: visibility, reserved-name safety, schema caps.
+  const tools = service(ctx, 'tools');
+  const toolSnapshot = { count: 0, names: [], truncated: false };
+  let defs = null;
+  let toolsError;
+  if (tools && typeof tools.definitions === 'function') {
+    try {
+      const value = tools.definitions();
+      if (Array.isArray(value)) defs = value;
+    } catch (error) {
+      toolsError = String(error?.message ?? error);
+    }
+  }
+  if (group('tools', defs !== null)) {
+    if (toolsError) {
+      add(makeFinding('warning', 'TOOL_SCAN_FAILED', 'Could not enumerate live tools', toolsError));
+    } else {
+      const names = defs.map((d) => String(d?.name ?? '')).filter(Boolean).sort();
+      const cap = Math.max(0, Math.min(200, maxTools));
+      toolSnapshot.count = names.length;
+      toolSnapshot.names = names.slice(0, cap);
+      toolSnapshot.truncated = names.length > cap;
+      const withOutput = defs.filter((d) => d?.output && typeof d.output.render === 'function').length;
+      const withoutOutput = names.length - withOutput;
+      if (withoutOutput > 0) {
+        add(makeFinding('warning', 'TOOLS_WITHOUT_OUTPUT',
+          `${withoutOutput} registered tool(s) declare no output renderer`,
+          'ToolsService.register() requires output { schema, render }. Definitions without one may be scoped-only views or an incomplete registration.',
+          { count: withoutOutput }));
+      }
+      add(makeFinding('info', 'TOOL_REGISTRY_OK',
+        `${names.length} tools are visible in the global scope`,
+        `The live resolved registry was read successfully${toolSnapshot.truncated ? ` (listing capped at ${cap})` : ''}. Scoped shadowing is resolved by the registry itself, so duplicate visible names are not possible.`,
+        { count: names.length, withOutput, listed: toolSnapshot.names.length }));
+    }
+  }
+
+  // --- 5. Declared-vs-live services ---
+  if (group('services', true)) {
+    const missing = EXPECTED_SERVICES.filter((key) => service(ctx, key) === undefined);
+    if (missing.length > 0) {
+      add(makeFinding('warning', 'SERVICES_MISSING', `${missing.length} expected services are not mounted`,
+        'These are optional seams; their absence is only a fault if another enabled row injects them.',
+        { missing }));
+    } else {
+      add(makeFinding('info', 'SERVICES_OK', `${EXPECTED_SERVICES.length} core services are live`,
+        EXPECTED_SERVICES.join(' / ') + ' all resolve through ctx.get().'));
+    }
+  }
+
+  // `ok` must not be true when checks could not run: an unreadable registry is
+  // not a clean bill of health.
+  const ok = summary.errors === 0 && !incomplete;
+  return {
+    ok,
+    complete: !incomplete,
+    focus,
+    generatedAt: new Date().toISOString(),
+    version: '0.2.1',
+    summary,
+    completeness,
+    findings,
+    snapshot: {
+      providers: providerSnapshot,
+      bundles: bundleSnapshot,
+      rows: rowsSnapshot,
+      tools: toolSnapshot,
+    },
+    note: 'Read-only live inspection. No files, no network, no config changes. Findings are observations, not a security verdict.',
+  };
+}
+
+/** Validate and normalize tool arguments. Throws on an invalid focus. */
+export function normalizeOptions(args = {}) {
+  const focus = typeof args.focus === 'string' ? args.focus : 'all';
+  if (!FOCI.includes(focus)) {
+    throw new Error(`invalid focus "${focus}"; expected one of: ${FOCI.join(', ')}`);
+  }
+  const rawMax = Number(args.maxTools);
+  const maxTools = Number.isFinite(rawMax) && args.maxTools !== undefined
+    ? Math.max(0, Math.min(200, Math.floor(rawMax)))
+    : 40;
+  return { focus, maxTools };
+}
+
+export function renderText(report) {
+  const lines = [];
+  const status = report.ok ? 'OK' : `${report.summary.errors} error(s)`;
+  lines.push(`Runtime reconcile — ${status}, ${report.summary.warnings} warning(s), ${report.summary.info} info`);
+  lines.push(`focus=${report.focus}  complete=${report.complete}  generatedAt=${report.generatedAt}`);
+  lines.push('');
+  const s = report.snapshot;
+  for (const kind of ['search', 'fetch']) {
+    const p = s.providers[kind];
+    if (!p) continue;
+    const label = kind === 'search' ? 'web.search' : 'web.fetch ';
+    lines.push(`${label}: configured=${p.configured ?? '(none)'} registered=[${p.registered.join(', ') || 'none'}]`
+      + (p.unavailable?.length ? ` unavailable=[${p.unavailable.join(', ')}]` : ''));
+  }
+  lines.push(`bundles: ${s.bundles.enabled}/${s.bundles.total} enabled; disabled=[${s.bundles.disabled.join(', ') || 'none'}]`);
+  lines.push(`loader rows: ${s.rows.active}/${s.rows.total} active; ${s.rows.disabled.length} disabled; ${s.rows.notActive.length} enabled-but-not-active`);
+  lines.push(`tools: ${s.tools.count} visible${s.tools.truncated ? ' (listing capped)' : ''}`);
+  if (report.completeness.unavailable.length > 0) {
+    lines.push(`unavailable checks: ${report.completeness.unavailable.join(', ')} — report is incomplete, ok is false`);
+  }
+  lines.push('');
+  if (report.findings.length === 0) {
+    lines.push('No findings.');
+  } else {
+    for (const f of report.findings) {
+      lines.push(`[${f.severity.toUpperCase()}] ${f.code} — ${f.title}`);
+      lines.push(`  ${f.detail}`);
+      if (f.evidence !== undefined) lines.push(`  evidence: ${JSON.stringify(f.evidence)}`);
+      if (f.remedy) lines.push(`  remedy: ${f.remedy}`);
+    }
+  }
+  lines.push('');
+  lines.push(report.note);
+  return lines.join('\n');
+}

package/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect x="4" y="4" width="56" height="56" rx="14" fill="#12324a"/>
+  <path d="M10 33h11l5-11 7 22 6-15 4 4h11" fill="none" stroke="#57d6a8" stroke-width="3.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="49" cy="15" r="4" fill="#f2b857"/>
+</svg>

package/index.js

@@ -0,0 +1,106 @@
+/**
+ * dsh-runtime-reconcile — Host half. Read-only, zero-dependency.
+ *
+ * All inspection logic lives in core.js (pure, unit-tested). This module only
+ * wires one model-facing tool to it. No @deepseek-ai/* runtime imports: see
+ * deepseek-harness discussion #1697 for the hoisted-shadowing hazard.
+ */
+
+import { collect, normalizeOptions, renderText } from './core.js';
+
+export { collect, normalizeOptions, renderText } from './core.js';
+
+function reconcileTool(ctx) {
+  return {
+    // Namespaced on purpose: generic names collide across the ecosystem
+    // (553 tool-name collisions measured in discussion #4253).
+    name: 'reconcile_runtime',
+    description:
+      'Read-only live inspection of the running DeepSeek Harness profile. Reconciles what is configured against what is actually registered: configured-but-missing or unavailable web providers (the cause of "configured web provider is not registered"), disabled bundles correlated as the likely root cause, enabled-but-not-active Loader rows, tool registry health, and missing core services. Reports actionable remedies. Makes no network calls and changes nothing. Use this when a tool fails mysteriously, after installing/enabling plugins, or to check profile health.',
+    parameters: {
+      type: 'object',
+      properties: {
+        focus: {
+          type: 'string',
+          enum: ['all', 'providers', 'bundles', 'rows', 'tools', 'services'],
+          description: 'Which check group to run. Default "all". Use "providers" for the fast web-provider diagnosis.',
+        },
+        maxTools: {
+          type: 'number',
+          description: 'Cap on tool names listed in the snapshot (default 40, max 200). Does not limit the checks.',
+        },
+      },
+      additionalProperties: false,
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ok: { type: 'boolean' },
+          complete: { type: 'boolean' },
+          focus: { type: 'string' },
+          generatedAt: { type: 'string' },
+          version: { type: 'string' },
+          summary: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              errors: { type: 'number' },
+              warnings: { type: 'number' },
+              info: { type: 'number' },
+            },
+          },
+          completeness: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              checked: { type: 'array', items: { type: 'string' } },
+              unavailable: { type: 'array', items: { type: 'string' } },
+            },
+          },
+          findings: {
+            type: 'array',
+            items: {
+              type: 'object',
+              additionalProperties: true,
+              properties: {
+                severity: { type: 'string' },
+                code: { type: 'string' },
+                title: { type: 'string' },
+                detail: { type: 'string' },
+                remedy: { type: 'string' },
+              },
+            },
+          },
+          snapshot: { type: 'object', additionalProperties: true },
+          note: { type: 'string' },
+        },
+      },
+      render(_args, value) {
+        return [{ type: 'text', text: renderText(value) }];
+      },
+    },
+    async execute(args = {}) {
+      const options = normalizeOptions(args);
+      return collect(ctx, options);
+    },
+  };
+}
+
+export function apply(ctx) {
+  // No row-level inject: the plugin must always mount so it can *report* a
+  // missing service rather than silently not activating. Register the tool only
+  // when the tools seam is present.
+  ctx.inject(['tools'], (scoped) => {
+    let tools;
+    try {
+      tools = scoped.get('tools') ?? ctx.get('tools');
+    } catch {
+      return;
+    }
+    if (!tools || typeof tools.register !== 'function') return;
+    const dispose = tools.register(reconcileTool(ctx));
+    scoped.effect(() => dispose);
+  });
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Runtime reconcile",
+    "description": "A read-only agent tool that reconciles what the profile declares against what is actually registered in the live runtime, with root-cause correlation and actionable remedies. No files, no network, no config changes."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "运行时对账",
+    "description": "只读的 Agent 工具：把 profile 声明与活体运行时实际注册的内容对账，自动关联根因并给出可执行的修复建议。不读写文件、不联网、不改配置。"
+  }
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "dsh-runtime-reconcile",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "A read-only agent tool that reconciles what a DeepSeek Harness profile declares against what is actually registered in the live runtime.",
+  "displayName": "Runtime Reconcile",
+  "icon": "icon.svg",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "diagnostics",
+    "runtime",
+    "runtime-reconciliation",
+    "plugin-conflict",
+    "plugin-diagnostics",
+    "observability",
+    "profile-health",
+    "ssrf-prevention",
+    "tool-registry",
+    "agent-tools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shuai0503/dsh-runtime-reconcile.git"
+  },
+  "bugs": {
+    "url": "https://github.com/shuai0503/dsh-runtime-reconcile/issues"
+  },
+  "homepage": "https://github.com/shuai0503/dsh-runtime-reconcile#readme",
+  "author": "shuai0503",
+  "exports": {
+    ".": "./index.js",
+    "./core": "./core.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "core.js",
+    "test/selftest.mjs",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "locale/*.json",
+    "icon.svg"
+  ],
+  "scripts": {
+    "test": "node test/selftest.mjs"
+  },
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" }
+  },
+  "engines": {
+    "dsh": ">=0.2.1-rc.2 <0.4.0-0"
+  }
+}

package/test/selftest.mjs

@@ -0,0 +1,195 @@
+/**
+ * Repeatable self-test for the pure core. No Harness runtime needed.
+ *   node test/selftest.mjs
+ */
+import assert from 'node:assert/strict';
+import { collect, normalizeOptions, renderText, FOCI } from '../core.js';
+
+const str = (v) => ({ get: () => v });
+let passed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    passed += 1;
+    console.log('PASS ' + name);
+  } catch (error) {
+    console.log('FAIL ' + name + ' — ' + error.message);
+    process.exitCode = 1;
+  }
+}
+async function atest(name, fn) {
+  try {
+    await fn();
+    passed += 1;
+    console.log('PASS ' + name);
+  } catch (error) {
+    console.log('FAIL ' + name + ' — ' + error.message);
+    process.exitCode = 1;
+  }
+}
+
+/** Build a faithful mock of the live profile state observed on this machine. */
+function mockContext(overrides = {}) {
+  const defs = overrides.defs ?? [
+    { name: 'web_search', output: { render() {} } },
+    { name: 'web_fetch', output: { render() {} } },
+    { name: 'reconcile_runtime', output: { render() {} } },
+  ];
+  const bundles = overrides.bundles ?? [
+    { name: '@deepseek-ai/dsh-base', enabled: true },
+    { name: '@liustack/modsearch', enabled: false },
+    { name: 'dsh-runtime-reconcile', enabled: true },
+  ];
+  const rows = overrides.rows ?? [
+    { entryId: 'a', moduleName: 'x', enabled: true, fiberPhase: 'active' },
+    { entryId: 'include:modsearch', moduleName: '@liustack/modsearch', enabled: false, fiberPhase: null },
+  ];
+  const services = {
+    web: overrides.web ?? {
+      config: { searchProvider: str('modsearch'), fetchProvider: str('http') },
+      searchProviders: new Map([['deepseek-official', {}], ['web-search-free', {}]]),
+      fetchProviders: new Map([['http', {}]]),
+    },
+    pluginManager: {
+      async listBundles() { return bundles; },
+      async listPlugins() { return rows; },
+    },
+    tools: { definitions() { return defs; }, register() { return () => {}; } },
+    configEditor: {}, commands: {}, systemPrompt: {}, sessionProjections: {},
+  };
+  if (overrides.missingServices) for (const k of overrides.missingServices) delete services[k];
+  return { get: (k) => services[k] };
+}
+
+const codes = (r) => r.findings.map((f) => f.code);
+
+await atest('core: catches configured-but-unregistered search provider', async () => {
+  const r = await collect(mockContext(), { focus: 'all' });
+  assert.equal(r.ok, false);
+  assert.ok(codes(r).includes('WEB_SEARCH_PROVIDER_MISSING'));
+  assert.ok(!codes(r).includes('WEB_FETCH_PROVIDER_MISSING'));
+});
+
+await atest('core: correlates the error with the disabled bundle', async () => {
+  const r = await collect(mockContext(), { focus: 'all' });
+  const err = r.findings.find((f) => f.code === 'WEB_SEARCH_PROVIDER_MISSING');
+  assert.equal(err.evidence.disabledBundle, '@liustack/modsearch');
+  assert.match(err.remedy, /Enable bundle "@liustack\/modsearch"/);
+  const b = r.findings.find((f) => f.code === 'BUNDLE_DISABLED' && f.evidence.bundle === '@liustack/modsearch');
+  assert.equal(b.severity, 'warning');
+  assert.equal(b.evidence.linkedToProviderError, true);
+});
+
+await atest('core: healthy profile reports ok with provider OK findings', async () => {
+  const r = await collect(mockContext({
+    web: {
+      config: { searchProvider: str('deepseek-official'), fetchProvider: str('http') },
+      searchProviders: new Map([['deepseek-official', {}]]),
+      fetchProviders: new Map([['http', {}]]),
+    },
+    bundles: [{ name: 'dsh-runtime-reconcile', enabled: true }],
+    rows: [{ entryId: 'a', moduleName: 'x', enabled: true, fiberPhase: 'active' }],
+  }), { focus: 'all' });
+  assert.equal(r.ok, true);
+  assert.equal(r.complete, true);
+  assert.ok(codes(r).includes('WEB_SEARCH_PROVIDER_OK'));
+  assert.ok(codes(r).includes('BUNDLES_ALL_ENABLED'));
+  assert.ok(codes(r).includes('ROWS_ALL_ACTIVE'));
+  assert.ok(codes(r).includes('SERVICES_OK'));
+});
+
+await atest('core: registered-but-unavailable provider is an error', async () => {
+  const r = await collect(mockContext({
+    web: {
+      config: { searchProvider: str('slow'), fetchProvider: str('http') },
+      searchProviders: new Map([['slow', { available: () => false }]]),
+      fetchProviders: new Map([['http', {}]]),
+    },
+  }), { focus: 'providers' });
+  assert.ok(codes(r).includes('WEB_SEARCH_PROVIDER_UNAVAILABLE'));
+  assert.equal(r.snapshot.providers.search.unavailable[0], 'slow');
+});
+
+await atest('core: multiple providers with no config is ambiguous with remedy', async () => {
+  const r = await collect(mockContext({
+    web: {
+      config: { searchProvider: str(''), fetchProvider: str('') },
+      searchProviders: new Map([['a', {}], ['b', {}]]),
+      fetchProviders: new Map([['http', {}]]),
+    },
+  }), { focus: 'providers' });
+  assert.ok(codes(r).includes('WEB_SEARCH_AMBIGUOUS'));
+  const f = r.findings.find((x) => x.code === 'WEB_SEARCH_AMBIGUOUS');
+  assert.match(f.remedy, /Set web.searchProvider/);
+});
+
+await atest('core: enabled-but-not-active Loader row is a warning', async () => {
+  const r = await collect(mockContext({
+    rows: [
+      { entryId: 'a', moduleName: 'good', enabled: true, fiberPhase: 'active' },
+      { entryId: 'b', moduleName: 'stuck', enabled: true, fiberPhase: null },
+    ],
+  }), { focus: 'rows' });
+  assert.ok(codes(r).includes('ROWS_NOT_ACTIVE'));
+  assert.deepEqual(r.snapshot.rows.notActive, ['stuck']);
+});
+
+await atest('core: missing services reported, not silently OK', async () => {
+  const r = await collect(mockContext({ missingServices: ['commands', 'configEditor'] }), { focus: 'services' });
+  assert.ok(codes(r).includes('SERVICES_MISSING'));
+  assert.deepEqual(r.findings.find((f) => f.code === 'SERVICES_MISSING').evidence.missing, ['configEditor', 'commands']);
+});
+
+await atest('core: unavailable check sets complete=false and ok=false', async () => {
+  // Only `tools` resolves; web / pluginManager are absent so their groups
+  // cannot run and must be marked unavailable rather than silently OK.
+  const ctx = { get: (k) => (k === 'tools' ? { definitions: () => [] } : undefined) };
+  const r = await collect(ctx, { focus: 'all' });
+  assert.equal(r.ok, false);
+  assert.equal(r.complete, false);
+  assert.ok(r.completeness.unavailable.includes('providers'));
+  assert.ok(r.completeness.unavailable.includes('bundles'));
+  assert.match(renderText(r), /report is incomplete/);
+});
+
+await atest('core: focus narrows checked groups', async () => {
+  const r = await collect(mockContext(), { focus: 'providers' });
+  assert.deepEqual(r.completeness.checked, ['providers']);
+  assert.ok(!codes(r).includes('BUNDLE_DISABLED'));
+});
+
+await atest('core: tools without output renderer warned (real signal, not fake duplicates)', async () => {
+  const r = await collect(mockContext({ defs: [{ name: 'bare' }, { name: 'ok', output: { render() {} } }] }), { focus: 'tools' });
+  assert.ok(codes(r).includes('TOOLS_WITHOUT_OUTPUT'));
+  assert.ok(codes(r).includes('TOOL_REGISTRY_OK'));
+  assert.ok(!codes(r).includes('TOOL_NAME_SHADOWED'));
+});
+
+test('normalizeOptions: defaults', () => {
+  assert.deepEqual(normalizeOptions(), { focus: 'all', maxTools: 40 });
+});
+
+test('normalizeOptions: clamps maxTools to 0..200', () => {
+  assert.equal(normalizeOptions({ maxTools: 9999 }).maxTools, 200);
+  assert.equal(normalizeOptions({ maxTools: -5 }).maxTools, 0);
+  assert.equal(normalizeOptions({ maxTools: 12.9 }).maxTools, 12);
+});
+
+test('normalizeOptions: rejects invalid focus', () => {
+  assert.throws(() => normalizeOptions({ focus: 'nonsense' }), /invalid focus/);
+  assert.ok(FOCI.includes('all') && FOCI.includes('providers'));
+});
+
+test('renderText: includes remedy lines', () => {
+  const text = renderText({
+    ok: false, complete: true, focus: 'all', generatedAt: 'x',
+    summary: { errors: 1, warnings: 0, info: 0 },
+    completeness: { checked: [], unavailable: [] },
+    findings: [{ severity: 'error', code: 'X', title: 't', detail: 'd', remedy: 'do this' }],
+    snapshot: { providers: { search: null, fetch: null }, bundles: { enabled: 0, total: 0, disabled: [] }, rows: { active: 0, total: 0, disabled: [], notActive: [] }, tools: { count: 0 } },
+    note: 'n',
+  });
+  assert.match(text, /remedy: do this/);
+});
+
+console.log(`\n${passed} checks passed`);