dsh-plugin-rea 2.0.7 → 2.0.8

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 本插件遵循语义化版本。版本号变化说明「配置组合」这层的变化，与 REA 自身的版本无关。
 
+## 2.0.8 — 2026-10-18
+
+**2.0.7 的启动检测在两种边界上会失控：一个包着本 shim 的 `rea` 会让探针递归成进程链；超时探针会漏掉一个孙进程。两条都已修，并补了复现测试。**
+
+### 修复
+
+- **重复注册检测在自定义 `DSH_HOME` 下失效**：harness 会从 MCP 子进程里抹掉所有 `DSH_*`，镜像副本因此读
+  `~/.dsh` —— 那是错的文件，上游写进真实 home 的第二条 `serverName: rea` 永远报不出来。`setup.mjs` 现在把运行时
+  的 home 记进 `mirror.json` 的 `dshHome`，shim 优先读环境、其次读这条记录。`check-updates.ps1` 的 profile 段也
+  改用同一条 home 规则（此前硬编码 `$env:USERPROFILE`，自定义 home 时报「找不到 profile」）。
+- **镜像启动器不会自己更新**：行执行的是 `<DSH_HOME>/plugins/rea-bundle/bin/rea-shim.mjs` 这份**副本**，而市场升级
+  只换包、不跑 setup —— 副本会一直跑它被复制时的代码，于是新版本里的修复对老用户静默失效（旧副本照常工作，最难发现）。
+  现在镜像启动时会与 `mirror.json` 记录的插件目录比对哈希，不同就转发执行插件里的那一份（一跳，带
+  `REA_BUNDLE_SHIM_REEXEC` 守卫，且只从镜像指向插件，不会反向）。`--shim-status` 新增 `mirror.stale`，
+  `check-updates.ps1` 也会报「镜像落后，重跑 setup」；`mirror.json` 增加 `shimSha256` 与 `pluginVersion` 便于追溯。
+  **2.0.8 之前的版本自身无法完成这一步**（副本里没有这段代码），从那些版本升级仍需手动跑一次 setup。
+- **探针递归**：`probeRea` 派生候选时没带 `REA_BUNDLE_DELEGATED=1`，而防自委派的守卫只在**委派**前生效。若 PATH 上是「调用本 shim 的 wrapper」，
+  探针 → wrapper → 新 shim → 再探针……实测并发 node 峰值 83+、杀掉后仍自我再生。现在探针环境同时带 `REA_BUNDLE_DELEGATED=1` 与
+  `REA_BUNDLE_AUTO_PROVISION=0`：嵌套运行直接走 bundle 并返回，实测 0.2 秒、零额外进程。
+- **超时探针泄漏孙进程**：`spawnSync` 的超时只杀它自己启动的 cmd.exe，而 `taskkill /T` 在 `spawnSync` 回收之后调用已找不到父进程 ——
+  每次超时留一个 REA/ping 在跑。探针改为异步 `spawn` + 自己的计时器：超时发生在父进程仍存活时，`taskkill /T /F` 能真正清掉整棵树。
+  实测 8.3 秒放弃、`rejected=["timeout"]`、无残留进程。
+- **Windows 信号处理器是死代码**：`child.kill("SIGTERM")` 在 Windows 上是 TerminateProcess，不可捕获；控制台的 Ctrl+C 又直达子进程。
+  该分支已删除，并如实写明限制：**在 Windows 上强制结束 shim 不会带走被委派的 REA**（Node 没有 job object 可用）。
+- **`comspec()` 不校验**：`ComSpec` 指向不存在的文件时，正常的 `.cmd` REA 被判 `spawn-failed`（`auto` 静默退回 bundle，`system` 直接 78）。
+  现在校验为常规文件，否则回落到 `%SystemRoot%\System32\cmd.exe`；实测 `ComSpec` 指向不存在路径仍能识别 6.9.0。
+- **文案**：显式路径是目录时报「does not exist」，改为「is not a file」。
+
+### 验证
+
+- 单测 **67 条**（2.0.7 是 60 条，本轮 +7：wrapper 递归必须被判为 `exit 78` 且 20 秒内收敛；`ComSpec` 失效仍识别 `.cmd` REA；
+  镜像自愈的转发/守卫/`stale` 上报/同内容不转发；`DSH_HOME` 被抹时从 `mirror.json` 找到真实 home 并报出重复注册）：
+  Windows 64 过 + 3 平台跳过。
+- `verify-branch.ps1` 全绿（39 项），含「两份 README 必须写出 package.json 里的 `engines.dsh` 原文」；`audit-manifest` clean；
+  `host-compat` 10 covered / 5 correctly outside。
+- 手工复现三例：wrapper 递归 0.2 秒收敛、0 残留进程；挂起候选 8.3 秒放弃且无 `PING` 残留；`ComSpec` 指向空路径仍识别系统 REA。
+
+
 ## 2.0.7 — 2026-10-18
 
 **机器上已有可用的 REA 时，2.x 直接按 1.x 的方式跑它（环境检测 + 委派），不再供给；同时把 2.0.6 的宿主声明收紧到真的能证明的范围。**

package/README.md

@@ -127,7 +127,7 @@ by the shim itself, which provisions in the background.
 
 ### Which DSH versions
 
-`package.json` declares `engines.dsh: ">=0.1.7-rc.2 <0.3.0"`, and that declaration is the answer the plugin market
+`package.json` declares `engines.dsh: ">=0.1.7-rc.2 <0.3.0-0"`, and that declaration is the answer the plugin market
 reads: with it the card says **compatible**; without it the market can only say *unknown*. The range is not a guess —
 it is the dsh release list this plugin is checked against, and `node scripts/host-compat.mjs` fails the build when the
 two disagree:
@@ -230,9 +230,9 @@ Which one? Upstream's is the configuration-only route: it expects Node on REA's
 zero-dependency route: it fetches Node, REA, JDK and Ghidra on first run. The patch shape and the
 `mcp__rea__*` surface are the same either way.
 
-The shim reports the conflict on startup when it can see that file — a custom `DSH_HOME` is hidden
-from an MCP child, so it falls back to `~/.dsh` there — and `node bin/rea-shim.mjs --shim-status`
-lists it under `duplicateRegistration`.
+The shim reports the conflict on startup — `setup.mjs` records the DSH home it ran under in
+`mirror.json`, and the mirrored copy reads that when the harness has stripped `DSH_*` from its
+environment; `node bin/rea-shim.mjs --shim-status` lists it under `duplicateRegistration`.
 
 ## Verify
 
@@ -337,6 +337,12 @@ back on the next start.
 
 - **This plugin** never updates itself. Installed from a market? Update it there. Installed from a `file:`
   checkout? Overwrite the directory and reinstall.
+- **The row runs a COPY of this plugin's launcher.** `<DSH_HOME>/plugins/rea-bundle/bin/rea-shim.mjs` is a mirror
+  made by setup, so a market upgrade replaces the package but not the file the row executes — until setup runs
+  again. From **2.0.8** the mirror notices that the installed plugin ships a different launcher and re-execs it
+  (one hop, guarded by `REA_BUNDLE_SHIM_REEXEC`), so upgrades carry. On an older version the mirror stays behind
+  silently; `--shim-status` now reports `mirror.stale`, and `check-updates.ps1` says to re-run setup. If you are
+  upgrading from 2.0.0–2.0.7, run `node scripts/setup.mjs` once after the upgrade.
 - **Upgrading from `2.0.0-bundle.1`**: that release mirrored the shim and `setup.mjs` but not the manifest,
   and recorded nothing about the plugin checkout, so a bundle it provisioned cannot repair itself — its
   background provisioning dies on the missing manifest, invisibly, and its own lock suppresses retries for

package/README.zh-CN.md

@@ -118,7 +118,7 @@ node scripts/setup.mjs --reuse      # 或先 --dry-run 看计划
 
 ### 支持哪些 DSH 版本
 
-`package.json` 里声明了 `engines.dsh: ">=0.1.7-rc.2 <0.3.0"`，这就是插件市场读的那句话：有它，卡片显示
+`package.json` 里声明了 `engines.dsh: ">=0.1.7-rc.2 <0.3.0-0"`，这就是插件市场读的那句话：有它，卡片显示
 **兼容**；没有它，市场只能说*未声明*。这个范围不是猜的——它对应本插件实际核对过的 dsh 发布列表，
 `node scripts/host-compat.mjs` 会在两者不一致时让构建失败：
 
@@ -216,8 +216,8 @@ duplicate server name 报错并加载失败，最终留下哪一行取决于加
 自己准备。本包是零依赖路线：首次运行自动取 Node、REA、JDK、Ghidra。两者的 patch 形态与
 `mcp__rea__*` 工具面相同。
 
-shim 在能看到该文件时会在启动时提示冲突 —— MCP 子进程里拿不到自定义 `DSH_HOME`，那种情况下它会
-退回 `~/.dsh`；`node bin/rea-shim.mjs --shim-status` 会把冲突列在 `duplicateRegistration` 下。
+shim 会在启动时提示冲突 —— `setup.mjs` 会把运行时的 DSH home 记进 `mirror.json`，镜像副本在 harness 抹掉
+`DSH_*` 之后就用这条记录去找那份文件；`node bin/rea-shim.mjs --shim-status` 会把冲突列在 `duplicateRegistration` 下。
 
 ## 验证
 
@@ -314,6 +314,11 @@ node scripts/setup.mjs          # 或：powershell -File scripts\rea-bundle-boot
 工具就回来了。
 
 - **本插件**从不自更新。从市场装的就在市场更新；从 `file:` 检出的就覆盖目录重装。
+- **行跑的是本插件启动器的「镜像副本」**：`<DSH_HOME>/plugins/rea-bundle/bin/rea-shim.mjs` 是 setup 复制过去的，
+  所以市场升级只换包、不换行执行的那个文件 —— 直到再跑一次 setup。从 **2.0.8** 起，镜像会发现自己落后于已安装的
+  插件，并转发执行插件里的那一份（一跳，带 `REA_BUNDLE_SHIM_REEXEC` 守卫），升级因此能生效。更早的版本里镜像会
+  静默地停在旧代码；`--shim-status` 现在会报 `mirror.stale`，`check-updates.ps1` 也会提示重跑 setup。**从
+  2.0.0–2.0.7 升级的话，升级后跑一次 `node scripts/setup.mjs`。**
 - **从 `2.0.0-bundle.1` 升级**：那一版镜像了 shim 与 `setup.mjs`，却漏了 manifest，也没有留下插件 checkout
   的记录，所以它供给出来的 bundle **无法自愈** —— 后台供给会因缺 manifest 而崩溃且完全不可见，而它自己写下的
   lock 又会让重试被抑制六小时。请**从插件目录**重跑一次 `node scripts/setup.mjs`：它会重新镜像三个文件，

package/bin/rea-shim.mjs

@@ -15,6 +15,7 @@
  *                            and the message is the operator's remediation.
  */
 import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -32,6 +33,36 @@ function dshHome() {
   return path.join(homedir(), ".dsh");
 }
 
+/**
+ * The DSH home recorded by setup, or null.
+ *
+ * Only the mirrored copy needs this: the harness strips `DSH_*` from an MCP
+ * child, so with a custom home the environment cannot answer. Read once per
+ * process — there is one bundle root per process and this is a startup query.
+ */
+let recordedDshHomeCache = null;
+function recordedDshHome(root) {
+  if (recordedDshHomeCache !== null) return recordedDshHomeCache;
+  let value = null;
+  try {
+    const record = JSON.parse(readFileSync(path.join(root, "mirror.json"), "utf8"));
+    if (typeof record?.dshHome === "string" && record.dshHome.trim() !== "" && path.isAbsolute(record.dshHome)) {
+      value = path.resolve(record.dshHome);
+    }
+  } catch {
+    value = null;
+  }
+  recordedDshHomeCache = value;
+  return value;
+}
+
+/** The home to look in when the environment has been scrubbed. */
+function dshHomeFor(root) {
+  const fromEnv = process.env.DSH_HOME;
+  if (fromEnv && fromEnv.trim() !== "") return path.resolve(fromEnv);
+  return recordedDshHome(root) ?? path.join(homedir(), ".dsh");
+}
+
 /**
  * Where setup writes the machine-local truth.
  *
@@ -104,13 +135,16 @@ function provisioningScript(root) {
  *
  * The parse is deliberately small: the two files it cares about are block
  * mappings with one id/serverName per row, and anything it cannot attribute is
- * ignored 鈥?a missed hint is acceptable, a false alarm is not. The mirrored shim
- * cannot see a custom DSH_HOME (the harness strips DSH_* from an MCP child), so
- * this falls back to `~/.dsh` like the rest of the bundle; the row has the same
- * limitation.
+ * ignored — a missed hint is acceptable, a false alarm is not.
+ *
+ * Finding the file is the part that needed care: the harness strips every DSH_*
+ * variable from an MCP child, so a mirrored copy with a custom DSH_HOME used to
+ * read `~/.dsh` — the wrong file, and therefore a conflict it could never report.
+ * `setup.mjs` writes the home it ran under into `mirror.json`, and that record is
+ * what this uses when the environment has nothing to say.
  */
-function foreignReaRegistration() {
-  const patch = path.join(dshHome(), "cordis.patch.yml");
+function foreignReaRegistration(root) {
+  const patch = path.join(dshHomeFor(root), "cordis.patch.yml");
   let text;
   try {
     text = readFileSync(patch, "utf8");
@@ -516,7 +550,11 @@ function cmdQuote(value) {
  */
 function comspec() {
   const fromEnv = process.env.ComSpec ?? process.env.COMSPEC;
-  if (typeof fromEnv === "string" && fromEnv.trim() !== "") return fromEnv;
+  // A ComSpec that names nothing is a real (if unusual) state, and trusting it
+  // would judge every `.cmd` REA "spawn-failed" — i.e. report the machine as
+  // having no REA because its shell pointer is broken. Fall back to the path
+  // Windows itself would use.
+  if (typeof fromEnv === "string" && fromEnv.trim() !== "" && isFileSync(fromEnv)) return fromEnv;
   const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT ?? "C:\\Windows";
   return path.join(systemRoot, "System32", "cmd.exe");
 }
@@ -527,50 +565,77 @@ function comspec() {
  * A file existing on PATH is not the same as a working install: npx leftovers,
  * half-removed globals and a shim whose Node is gone all sit on PATH and all
  * fail at once. One bounded `--version` separates them, and a slow or hanging
- * answer counts as "not usable" 鈥?the fallback (the bundle) still works, while
+ * answer counts as "not usable" — the fallback (the bundle) still works, while
  * delegating to a broken binary would take the tools down with it.
+ *
+ * Two things here are not incidental:
+ *
+ *  * The probe runs with `REA_BUNDLE_DELEGATED=1`. A candidate that is itself a
+ *    wrapper around this shim would otherwise be probed by a nested shim that
+ *    probes the wrapper — measured: a process chain that keeps respawning
+ *    itself. The flag makes the nested run take the bundle path and return.
+ *  * It is asynchronous, not `spawnSync` with a timeout. `spawnSync` reaps the
+ *    child it started, and its timeout kills only that child: for a `.cmd` shim
+ *    that means cmd.exe dies while the REA inside it keeps running and holds
+ *    the pipes. Killing the TREE is only possible while the parent is alive,
+ *    which means owning the wait ourselves.
  */
 function probeRea(file, { platform = process.platform, timeout = PROBE_TIMEOUT_MS } = {}) {
-  // `existsSync` says nothing about the shape: a DIRECTORY named `rea.cmd` exists,
-  // fails to spawn, and would be reported as a broken install instead of as a
-  // name collision. Only a regular file is a candidate.
-  try {
-    if (!statSync(file).isFile()) return { ok: false, reason: "not a file" };
-  } catch {
-    return { ok: false, reason: "missing" };
-  }
-  const command = [file, "--version"];
-  // `cmd /d /s /c "<line>"`: Windows only. Two details are load-bearing.
-  // `/s` strips the first and last quote, so the whole line is quoted; and the
-  // arguments are passed VERBATIM, because Node otherwise backslash-escapes the
-  // quotes it sees and cmd.exe does not understand `\"` — every candidate then
-  // answers "exit 1", which reads as "no REA on this machine".
-  const result = platform === "win32" && /\.(cmd|bat)$/i.test(file)
-    ? spawnSync(comspec(), ["/d", "/s", "/c", `"${[cmdQuote(file), "--version"].join(" ")}"`], {
-        encoding: "utf8",
-        timeout,
-        windowsHide: true,
-        windowsVerbatimArguments: true,
-      })
-    : spawnSync(command[0], command.slice(1), {
-        encoding: "utf8",
-        timeout,
-        windowsHide: true,
-      });
-  if (result.error) {
-    // A timed-out probe leaves its grandchild running: cmd.exe is killed, the
-    // REA inside it is not, and it keeps the inherited pipes open. Clean the tree
-    // before answering, or a hung candidate leaves a process behind per start.
-    if (result.error.code === "ETIMEDOUT") killTree(result.pid, platform);
-    return { ok: false, reason: result.error.code === "ETIMEDOUT" ? "timeout" : "spawn-failed" };
-  }
-  if (result.status !== 0) return { ok: false, reason: `exit ${String(result.status)}` };
-  const text = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-  const version = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/.exec(text)?.[1] ?? null;
-  // A REA install prints its version. Anything else (a shim that swallowed the
-  // flag, an unrelated program that shares the name) is not a usable CLI.
-  if (version === null) return { ok: false, reason: "no version in --version output" };
-  return { ok: true, version };
+  return new Promise((resolve) => {
+    // `existsSync` says nothing about the shape: a DIRECTORY named `rea.cmd`
+    // exists, fails to spawn, and would be reported as a broken install instead
+    // of as a name collision. Only a regular file is a candidate.
+    if (!isFileSync(file)) {
+      resolve({ ok: false, reason: "not a file" });
+      return;
+    }
+    const useShell = platform === "win32" && /\.(cmd|bat)$/i.test(file);
+    // `REA_BUNDLE_AUTO_PROVISION=0` is part of the same guard: if the candidate
+    // turns out to be a wrapper around THIS shim, the nested run must not start
+    // an 800 MB provisioning job just because a probe asked it for a version.
+    const env = { ...process.env, REA_BUNDLE_DELEGATED: "1", REA_BUNDLE_AUTO_PROVISION: "0" };
+    // `cmd /d /s /c "<line>"`: Windows only. Two details are load-bearing.
+    // `/s` strips the first and last quote, so the whole line is quoted; and the
+    // arguments are passed VERBATIM, because Node otherwise backslash-escapes the
+    // quotes it sees and cmd.exe does not understand `\"` — every candidate then
+    // answers "exit 1", which reads as "no REA on this machine".
+    const child = useShell
+      ? spawn(comspec(), ["/d", "/s", "/c", `"${[cmdQuote(file), "--version"].join(" ")}"`], {
+          env,
+          stdio: ["ignore", "pipe", "pipe"],
+          windowsHide: true,
+          windowsVerbatimArguments: true,
+        })
+      : spawn(file, ["--version"], { env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    let output = "";
+    let settled = false;
+    let timer = null;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer !== null) clearTimeout(timer);
+      resolve(result);
+    };
+    timer = setTimeout(() => {
+      killTree(child.pid, platform);
+      finish({ ok: false, reason: "timeout" });
+    }, timeout);
+    child.stdout.on("data", (chunk) => { output += String(chunk); });
+    child.stderr.on("data", (chunk) => { output += String(chunk); });
+    child.on("error", () => finish({ ok: false, reason: "spawn-failed" }));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        finish({ ok: false, reason: `exit ${String(code)}` });
+        return;
+      }
+      // A REA install prints its version. Anything else (a shim that swallowed
+      // the flag, an unrelated program that shares the name) is not a usable CLI.
+      const version = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/.exec(output.trim())?.[1] ?? null;
+      finish(version === null
+        ? { ok: false, reason: "no version in --version output" }
+        : { ok: true, version });
+    });
+  });
 }
 
 /**
@@ -580,7 +645,7 @@ function probeRea(file, { platform = process.platform, timeout = PROBE_TIMEOUT_M
  * provisioner installed is the `bundle` mode, and delegating to it would be a
  * loop through a path the bundle already covers.
  */
-function detectSystemRea({ env = process.env, platform = process.platform, root, pluginRoot = PLUGIN_ROOT } = {}) {
+async function detectSystemRea({ env = process.env, platform = process.platform, root, pluginRoot = PLUGIN_ROOT } = {}) {
   const rejected = [];
   let profiled = 0;
   const explicit = (env.REA_BUNDLE_SYSTEM_REA ?? "").trim();
@@ -609,7 +674,7 @@ function detectSystemRea({ env = process.env, platform = process.platform, root,
       continue;
     }
     profiled += 1;
-    const probe = probeRea(candidate, { platform });
+    const probe = await probeRea(candidate, { platform });
     if (probe.ok) return { found: true, file: candidate, version: probe.version };
     if (rejected.length < 8) rejected.push({ file: candidate, reason: probe.reason });
   }
@@ -624,7 +689,9 @@ function detectSystemRea({ env = process.env, platform = process.platform, root,
   if (explicitPath !== null && explicitRejection !== null) {
     reason = `REA_BUNDLE_SYSTEM_REA was rejected (${explicitRejection.reason}): ${explicitPath}`;
   } else if (explicitPath !== null && !isFileSync(explicitPath)) {
-    reason = `REA_BUNDLE_SYSTEM_REA does not exist: ${explicitPath}`;
+    reason = existsSync(explicitPath)
+      ? `REA_BUNDLE_SYSTEM_REA is not a file: ${explicitPath}`
+      : `REA_BUNDLE_SYSTEM_REA does not exist: ${explicitPath}`;
   } else {
     reason = profiled === 0 ? "no rea on PATH" : "no usable rea on PATH";
   }
@@ -660,7 +727,7 @@ function compareDotted(a, b) {
  * honoured literally 鈥?`system` fails loudly rather than provisioning 800 MB
  * behind an operator who asked for their own REA.
  */
-function resolveLaunch({ root, bundleVersion = null, bundleProvisioned = false, env = process.env, platform = process.platform } = {}) {
+async function resolveLaunch({ root, bundleVersion = null, bundleProvisioned = false, env = process.env, platform = process.platform } = {}) {
   const preference = launchPreference(env);
   if (preference.value === "bundle") {
     return { preference: preference.value, invalid: preference.invalid, mode: "bundle", reason: "pinned by REA_BUNDLE_LAUNCH=bundle" };
@@ -678,7 +745,7 @@ function resolveLaunch({ root, bundleVersion = null, bundleProvisioned = false,
       reason: "REA_BUNDLE_DELEGATED=1: already running under a delegated system REA, refusing to delegate again",
     };
   }
-  const system = detectSystemRea({ env, platform, root });
+  const system = await detectSystemRea({ env, platform, root });
   if (system.found) {
     const order = bundleVersion === null ? null : compareDotted(system.version, bundleVersion);
     const pinned = preference.value === "system";
@@ -747,25 +814,14 @@ function launchSystemRea(system, argv) {
         windowsVerbatimArguments: true,
       })
     : spawn(system.file, args, { env, stdio: "inherit", windowsHide: true });
-  // Signal handling, per platform, because the two are not the same problem.
-  //
-  // POSIX: stdio is inherited and the child is in this process's group, so a
-  // terminal's Ctrl+C already reaches it. Forwarding again would deliver the
-  // signal twice.
-  //
-  // Windows: there is no process group to deliver to, and `child.kill("SIGINT")`
-  // is TerminateProcess on the cmd.exe WRAPPER — the REA inside it survives and
-  // keeps the inherited pipes open, which looks exactly like "the tools still
-  // work after I stopped the harness". `taskkill /T` is what actually ends the
-  // tree, so that is what a signal asks for here.
-  if (process.platform === "win32") {
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-      process.on(signal, () => {
-        killTree(child.pid, "win32");
-        process.exit(signal === "SIGINT" ? 130 : 143);
-      });
-    }
-  }
+  // No signal forwarding on Windows, deliberately. `child.kill()` there is
+  // TerminateProcess on the cmd.exe WRAPPER — the REA inside it survives, still
+  // holding the inherited pipes — and a console Ctrl+C is delivered to the whole
+  // process group anyway, so the child already has it. A hard kill of this shim
+  // (what a supervisor or Task Manager does) runs no JavaScript at all, so the
+  // wrapper must not pretend otherwise: on Windows the delegated REA outlives a
+  // forcibly killed shim. On POSIX the child is in this process's group and gets
+  // the terminal's signal directly; `process.exit` below then ends the shim.
   child.on("error", (error) => {
     process.stderr.write(`rea-shim: could not start ${system.file}\n  ${String(error && error.message)}\n`);
     process.exit(EX_CONFIG);
@@ -780,6 +836,101 @@ function launchSystemRea(system, argv) {
   return null;
 }
 
+/**
+ * The mirror problem.
+ *
+ * The published row launches `<bundle>/bin/rea-shim.mjs` — a COPY made by
+ * `setup.mjs`. Upgrading the plugin from the market replaces the package but runs
+ * no setup, so the copy keeps executing the code it was made from: every fix in
+ * a new plugin version reaches a user only if they happen to re-run setup. That
+ * is invisible (the old copy keeps working) and it is exactly the wrong
+ * direction for a safety fix.
+ *
+ * The repair has to live in the copy, because the copy is what runs. So the
+ * copy compares itself with the plugin's own `bin/rea-shim.mjs`, recorded in
+ * `mirror.json` by setup, and re-execs that file when the two differ. One hop,
+ * guarded by an environment flag, and only from mirror to checkout — the
+ * checkout copy has no `mirror.json` and would find itself anyway.
+ *
+ * A plugin version older than 2.0.8 cannot do this for its own upgrades: there
+ * is nothing in it to run. `--shim-status` reports `mirror.stale` so the
+ * condition is at least visible, and `check-updates.ps1` says to re-run setup.
+ */
+function sha256(file) {
+  return createHash("sha256").update(readFileSync(file)).digest("hex");
+}
+
+/** Where the installed plugin lives according to setup's record, or null. */
+function pluginCheckout(root) {
+  try {
+    const record = JSON.parse(readFileSync(path.join(root, "mirror.json"), "utf8"));
+    const dir = record?.pluginRoot;
+    if (typeof dir !== "string" || dir.trim() === "") return null;
+    const shim = path.join(dir, "bin", "rea-shim.mjs");
+    return isFileSync(shim) ? shim : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether this copy is behind the plugin it was mirrored from.
+ *
+ * `self` is this file, `source` the checkout's. A checkout copy (it ships
+ * `cordis.patch.yml`) is never stale against itself; a mirror with no record, or
+ * whose recorded checkout is gone, is not re-pointed anywhere.
+ */
+function describeMirror(root, { self = fileURLToPath(import.meta.url) } = {}) {
+  let record = null;
+  try {
+    record = JSON.parse(readFileSync(path.join(root, "mirror.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  const source = pluginCheckout(root);
+  let stale = false;
+  let reason = "no usable plugin checkout in mirror.json";
+  if (source !== null) {
+    if (path.resolve(source) === path.resolve(self)) {
+      reason = "this copy is the plugin checkout";
+    } else {
+      try {
+        stale = sha256(source) !== sha256(self);
+        reason = stale ? "the plugin ships a different launcher than this mirrored copy" : "this copy matches the plugin";
+      } catch {
+        reason = "could not compare the two launchers";
+      }
+    }
+  }
+  return {
+    pluginRoot: typeof record?.pluginRoot === "string" ? record.pluginRoot : null,
+    mirroredAt: typeof record?.mirroredAt === "string" ? record.mirroredAt : null,
+    stale,
+    reason,
+  };
+}
+
+/** Run the checkout's launcher instead of this copy, once. */
+function reexecFromCheckout(source, argv) {
+  const child = spawn(process.execPath, [source, ...argv], {
+    stdio: "inherit",
+    env: { ...process.env, REA_BUNDLE_SHIM_REEXEC: "1" },
+    windowsHide: true,
+  });
+  child.on("error", () => {
+    // Falling back is better than failing: the copy still knows how to launch.
+    process.stderr.write(`rea-shim: could not run ${source}; continuing with the mirrored copy.\n`);
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      const signals = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 };
+      process.exit(128 + (signals[signal] ?? 0));
+    }
+    process.exit(code ?? 0);
+  });
+  return null;
+}
+
 /**
  * Usage text, also what a bare invocation prints.
  *
@@ -808,7 +959,7 @@ function usage() {
   ].join("\n");
 }
 
-function main() {
+async function main() {
   const argv = process.argv.slice(2);
 
   if (argv.includes("--shim-help") || argv.length === 0) {
@@ -817,12 +968,21 @@ function main() {
   }
 
   const root = bundleRoot();
+  // Self-healing before anything else: a mirrored copy that predates the plugin
+  // it was made from would otherwise keep running that older code forever, and a
+  // market upgrade never re-runs setup. One hop, guarded, and never for the
+  // status query — there the staleness is reported instead.
+  const mirror = describeMirror(root);
+  if (mirror !== null && mirror.stale && process.env.REA_BUNDLE_SHIM_REEXEC !== "1" && !argv.includes("--shim-status")) {
+    const source = pluginCheckout(root);
+    if (source !== null) return reexecFromCheckout(source, argv);
+  }
   const loaded = readBundleConfig(root);
   // Decide what to run before asking whether the bundle is provisioned: a
   // machine with its own working REA must not be sent into an ~800 MB
   // provisioning run just because this bundle has no state yet.
   const bundleVersion = loaded.ok ? (loaded.config.versions?.reaAgents ?? null) : null;
-  const launch = resolveLaunch({ root, bundleVersion, bundleProvisioned: loaded.ok });
+  const launch = await resolveLaunch({ root, bundleVersion, bundleProvisioned: loaded.ok });
   if (launch.invalid !== null) {
     process.stderr.write(
       `rea-shim: REA_BUNDLE_LAUNCH="${launch.invalid}" is not one of ${LAUNCH_MODES.join("/")}; using auto.\n`,
@@ -831,7 +991,7 @@ function main() {
   // Upstream can add a second row for the same serverName; the shim cannot stop
   // DSH from loading both rows, but saying so is better than doubled tools with
   // no stated cause. The status report carries the same fact for diagnostics.
-  const duplicate = foreignReaRegistration();
+  const duplicate = foreignReaRegistration(root);
   if (duplicate && !argv.includes("--shim-status")) {
     process.stderr.write(
       `\n  dsh-plugin-rea (bundle): duplicate REA registration.\n` +
@@ -860,6 +1020,10 @@ function main() {
       },
     };
     if (launch.system?.rejected?.length) report.launch.rejected = launch.system.rejected;
+    // A mirrored copy that lags the plugin keeps working, which is exactly why
+    // nobody notices it: the row runs old code until the mirror is refreshed.
+    // Reported here so `--shim-status` answers "am I running what I installed?".
+    if (mirror !== null) report.mirror = mirror;
     if (duplicate) report.duplicateRegistration = duplicate;
     if (loaded.ok) {
       report.paths = loaded.config.paths ?? {};
@@ -972,5 +1136,8 @@ function main() {
   return null;
 }
 
-const status = main();
+// The launch decision awaits a probe, so `main` is async; the status it returns
+// is this process's exit code, and a launch path resolves to null while the
+// child (already wired to `process.exit`) keeps the loop alive.
+const status = await main();
 if (typeof status === "number") process.exit(status);

package/check-updates.ps1

@@ -73,9 +73,13 @@ function Test-NodeEngines([string]$node, [string]$engines) {
 # bundle.json：把全局路径当默认是 1.x 的答案，在 2.x 机器上会让这一节指向错误的
 # 对象（"全局包丢了"），并给出错误的升级动作（npm i -g）。
 $bundleRootEarly = $env:REA_BUNDLE_ROOT
+# Resolve the home unconditionally: the profile section below needs it whether or
+# not REA_BUNDLE_ROOT was set, and computing it only inside the fallback branch
+# left it $null — `Join-Path $null 'profiles'` throws, so the section degraded to
+# "no profile" on exactly the machines that use the override.
+$homeEarly = $env:DSH_HOME
+if (-not $homeEarly) { $homeEarly = Join-Path $HOME '.dsh' }
 if (-not $bundleRootEarly) {
-  $homeEarly = $env:DSH_HOME
-  if (-not $homeEarly) { $homeEarly = Join-Path $HOME '.dsh' }
   $bundleRootEarly = Join-Path $homeEarly 'plugins\rea-bundle'
 }
 $bundleState = $null
@@ -106,8 +110,12 @@ $reaFromBundle = [bool]($bundleReaPackageDir -and $ReaPackageDir -eq $bundleReaP
 if (-not $ProfileDir) {
   if ($env:DSH_PROFILE_DIR) { $ProfileDir = $env:DSH_PROFILE_DIR }
   else {
-    $profiles = @(Get-ChildItem (Join-Path $env:USERPROFILE '.dsh\profiles') -Directory -ErrorAction SilentlyContinue)
-    $ProfileDir = if ($profiles.Count -gt 0) { $profiles[0].FullName } else { Join-Path $env:USERPROFILE '.dsh\profiles\desktop' }
+    # Same home rule the bundle uses everywhere else: DSH_HOME, then ~/.dsh.
+    # Hardcoding $env:USERPROFILE here was a second algorithm in the same script,
+    # so on a custom DSH_HOME the profile section reported "no profile found"
+    # while the rest of the run had already resolved that home correctly.
+    $profiles = @(Get-ChildItem (Join-Path $homeEarly 'profiles') -Directory -ErrorAction SilentlyContinue)
+    $ProfileDir = if ($profiles.Count -gt 0) { $profiles[0].FullName } else { Join-Path $homeEarly 'profiles\desktop' }
   }
 }
 
@@ -340,7 +348,27 @@ if (-not (Test-Path $manifestPath)) {
         Warn ("TOFU（无厂商校验和，取首次实测值）: " + (@($state.unverifiedChecksums) -join ', '))
       }
       $mirrored = Join-Path $bundleRoot 'bin\rea-shim.mjs'
-      if (Test-Path $mirrored) { Ok 'MCP 行指向的 shim 已就位' }
+      if (Test-Path $mirrored) {
+        Ok 'MCP 行指向的 shim 已就位'
+        # The row launches this COPY, so a plugin upgrade that does not re-run
+        # setup leaves the old launcher in place — visible only as "the new
+        # version behaves like the old one". Compare it with the checkout the
+        # mirror record names.
+        $mirrorRecord = Join-Path $bundleRoot 'mirror.json'
+        if (Test-Path $mirrorRecord) {
+          try {
+            $record = Get-Content $mirrorRecord -Raw -Encoding UTF8 | ConvertFrom-Json
+            $pluginShim = if ($record.pluginRoot) { Join-Path $record.pluginRoot 'bin\rea-shim.mjs' } else { $null }
+            if ($pluginShim -and (Test-Path $pluginShim)) {
+              $same = (Get-FileHash $mirrored -Algorithm SHA256).Hash -eq (Get-FileHash $pluginShim -Algorithm SHA256).Hash
+              if ($same) { Ok '镜像 shim 与插件一致（行跑的就是这个版本）' }
+              else { Warn "镜像 shim 落后于插件（$($record.pluginRoot)）—— 行仍在跑旧副本；重跑 node scripts/setup.mjs 让它换成新版本" }
+            } else {
+              Warn "mirror.json 指向的插件目录已不存在（$($record.pluginRoot)）—— 无法比对镜像 shim 是否最新"
+            }
+          } catch { Warn "mirror.json 解析失败: $($_.Exception.Message)" }
+        }
+      }
       else { Bad "缺少 MCP 行指向的 shim: $mirrored —— 重跑 setup --reuse" }
       # 镜像副本的 setup 用它自己所在的位置推 plugin root，所以 manifest 必须
       # 一起镜像。旧版镜像缺这个文件：auto-provision 会以 ENOENT 崩掉且不可见，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-rea",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "One-plugin bundle: provisions Node/REA/JDK/Ghidra for you, then registers the upstream REA MCP server as mcp__rea__* tools. · 一体包：自动准备 Node/REA/JDK/Ghidra，并把上游 REA 的 MCP 服务接入 DeepSeek Harness。",
   "type": "module",
   "main": "./index.mjs",

package/scripts/setup.mjs

@@ -1636,6 +1636,31 @@ function mirrorLauncher(context) {
  */
 function writeMirrorRecord(context, source) {
   const record = { schema: 1, pluginRoot: source, mirroredAt: new Date().toISOString() };
+  // Provenance for the self-healing check: the mirrored shim compares itself
+  // with `<pluginRoot>/bin/rea-shim.mjs` and re-execs that one when the plugin
+  // has moved on. These two fields are what `--shim-status` shows when the
+  // comparison cannot be made (missing checkout, unreadable file).
+  try {
+    record.shimSha256 = createHash("sha256")
+      .update(readFileSync(path.join(context.root, "bin", "rea-shim.mjs")))
+      .digest("hex");
+  } catch {
+    /* the copy is missing or unreadable; the shim reports the comparison itself */
+  }
+  try {
+    record.pluginVersion = JSON.parse(readFileSync(path.join(source, "package.json"), "utf8")).version ?? null;
+  } catch {
+    record.pluginVersion = null;
+  }
+  // The MCP child the harness starts has every DSH_* variable stripped, so the
+  // mirrored shim cannot re-derive a CUSTOM home from its environment — it would
+  // read `~/.dsh` and miss a duplicate `serverName: rea` living in the real one.
+  // Record the home setup ran under; the shim prefers the environment, then this.
+  try {
+    record.dshHome = dshHome();
+  } catch {
+    record.dshHome = null;
+  }
   try {
     mkdirSync(context.root, { recursive: true });
     writeFileSync(path.join(context.root, "mirror.json"), JSON.stringify(record, null, 2) + "\n");

package/scripts/setup.test.mjs

@@ -1564,3 +1564,184 @@ test("--shim-print-env reports the system launch instead of a child environment"
     f.clean();
   }
 });
+
+test("a candidate that wraps this shim is rejected instead of recursing", () => {
+  // The probe asks the candidate for `--version`; a wrapper answers by running
+  // this very shim, which would probe the wrapper again. The probe therefore runs
+  // with REA_BUNDLE_DELEGATED=1, so the nested run takes the bundle path and
+  // returns. Without that, one wrapper on PATH spawns a process chain that keeps
+  // respawning after the parent is killed.
+  const f = launchFixture();
+  mkdirSync(f.bin, { recursive: true });
+  const shim = path.join(REPO_ROOT, "bin", "rea-shim.mjs");
+  const wrapper = path.join(f.bin, process.platform === "win32" ? "rea.cmd" : "rea");
+  if (process.platform === "win32") {
+    writeFileSync(wrapper, `@echo off\r\n"${process.execPath}" "${shim}" %*\r\n`);
+  } else {
+    writeFileSync(wrapper, `#!/bin/sh\nexec "${process.execPath}" "${shim}" "$@"\n`);
+    chmodSync(wrapper, 0o755);
+  }
+  try {
+    const started = Date.now();
+    const run = runShimIsolated(
+      { PATH: f.emptyPath, REA_BUNDLE_SYSTEM_REA: wrapper, REA_BUNDLE_ROOT: f.bundleRoot, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "" },
+      ["--shim-status"],
+    );
+    const elapsed = Date.now() - started;
+    const report = JSON.parse(run.stdout);
+    assert.equal(report.launch.mode, "bundle");
+    assert.deepEqual(report.launch.rejected.map(r => r.reason), ["exit 78"]);
+    assert.ok(elapsed < 20000, `the probe must not recurse; it took ${elapsed} ms`);
+  } finally {
+    f.clean();
+  }
+});
+
+test("a ComSpec that points at nothing falls back to the real shell", () => {
+  // Trusting ComSpec blindly would judge every .cmd REA "spawn-failed" — i.e.
+  // report the machine as having no REA because its shell pointer is broken.
+  const f = launchFixture();
+  mkdirSync(f.bin, { recursive: true });
+  const rea = writeFakeRea(f.bin, { version: "6.9.0" });
+  try {
+    const run = runShimIsolated(
+      {
+        PATH: f.emptyPath,
+        ComSpec: path.join(f.root, "no-such-cmd.exe"),
+        REA_BUNDLE_SYSTEM_REA: rea,
+        REA_BUNDLE_ROOT: f.bundleRoot,
+        REA_BUNDLE_AUTO_PROVISION: "0",
+        REA_BUNDLE_LAUNCH: "",
+      },
+      ["--shim-status"],
+    );
+    const report = JSON.parse(run.stdout);
+    if (process.platform === "win32") {
+      assert.equal(report.launch.mode, "system", JSON.stringify(report.launch));
+      assert.equal(report.launch.systemRea.version, "6.9.0");
+    } else {
+      // POSIX never consults ComSpec; the assertion above would be incidental.
+      assert.equal(report.launch.mode, "system");
+    }
+  } finally {
+    f.clean();
+  }
+});
+
+/* --------------------------------------------------- the mirrored launcher */
+
+// The row launches `<bundle>/bin/rea-shim.mjs`, a COPY. A market upgrade replaces
+// the package and runs no setup, so without this the copy keeps running the code
+// it was made from — every fix silently stops at the old mirror. These tests pin
+// the repair: the copy re-execs the plugin's launcher when they differ, once.
+
+function mirrorFixture() {
+  const root = mkdtempSync(path.join(tmpdir(), "rea-mirror-"));
+  const bundle = path.join(root, "bundle");
+  const checkout = path.join(root, "checkout");
+  mkdirSync(path.join(bundle, "bin"), { recursive: true });
+  mkdirSync(path.join(checkout, "bin"), { recursive: true });
+  copyFileSync(path.join(REPO_ROOT, "bin", "rea-shim.mjs"), path.join(bundle, "bin", "rea-shim.mjs"));
+  writeFileSync(path.join(bundle, "mirror.json"), JSON.stringify({ schema: 1, pluginRoot: checkout, mirroredAt: "2026-10-18T00:00:00Z" }));
+  return { root, bundle, checkout, clean() { rmSync(root, { recursive: true, force: true }); } };
+}
+
+function checkoutStub(checkout, marker) {
+  const file = path.join(checkout, "bin", "rea-shim.mjs");
+  writeFileSync(
+    file,
+    'import { writeFileSync } from "node:fs";\n' +
+      `writeFileSync(${JSON.stringify(marker)}, "checkout");\n` +
+      "process.exit(7);\n",
+  );
+  return file;
+}
+
+test("a mirrored launcher re-execs the plugin's launcher when they differ", () => {
+  const f = mirrorFixture();
+  const marker = path.join(f.root, "checkout-ran");
+  checkoutStub(f.checkout, marker);
+  try {
+    const run = runShimIsolated({ REA_BUNDLE_ROOT: f.bundle, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "bundle" }, ["mcp"]);
+    assert.equal(run.status, 7, `expected the checkout's status, got ${run.status}: ${run.stderr}`);
+    assert.equal(existsSync(marker), true, "the checkout launcher must have run");
+  } finally {
+    f.clean();
+  }
+});
+
+test("the re-exec happens once, and a pinned guard stops it", () => {
+  const f = mirrorFixture();
+  const marker = path.join(f.root, "checkout-ran");
+  checkoutStub(f.checkout, marker);
+  try {
+    const run = runShimIsolated(
+      { REA_BUNDLE_ROOT: f.bundle, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "bundle", REA_BUNDLE_SHIM_REEXEC: "1" },
+      ["mcp"],
+    );
+    // The guard is set, so the mirrored copy runs its own logic: bundle pinned and
+    // nothing provisioned means EX_CONFIG, and the checkout never starts.
+    assert.equal(run.status, 78, run.stderr);
+    assert.equal(existsSync(marker), false, "the guard must prevent a second hop");
+  } finally {
+    f.clean();
+  }
+});
+
+test("--shim-status reports a stale mirror instead of re-execing it", () => {
+  const f = mirrorFixture();
+  const marker = path.join(f.root, "checkout-ran");
+  checkoutStub(f.checkout, marker);
+  try {
+    const run = runShimIsolated({ REA_BUNDLE_ROOT: f.bundle, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "bundle" }, ["--shim-status"]);
+    const report = JSON.parse(run.stdout);
+    assert.equal(report.mirror.stale, true, JSON.stringify(report.mirror));
+    assert.match(report.mirror.reason, /different launcher/);
+    assert.equal(existsSync(marker), false, "status is a query; it must not start anything");
+  } finally {
+    f.clean();
+  }
+});
+
+test("an identical mirror is not stale and is not re-exec'd", () => {
+  const f = mirrorFixture();
+  const same = path.join(f.checkout, "bin", "rea-shim.mjs");
+  copyFileSync(path.join(f.bundle, "bin", "rea-shim.mjs"), same);
+  try {
+    const run = runShimIsolated({ REA_BUNDLE_ROOT: f.bundle, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "bundle" }, ["--shim-status"]);
+    const report = JSON.parse(run.stdout);
+    assert.equal(report.mirror.stale, false, JSON.stringify(report.mirror));
+    assert.equal(report.mirror.reason, "this copy matches the plugin");
+  } finally {
+    f.clean();
+  }
+});
+
+test("a mirrored shim finds the real DSH home when the environment is scrubbed", () => {
+  // The harness strips DSH_* from an MCP child, so with a custom DSH_HOME the
+  // old code read ~/.dsh — the wrong file — and could never report upstream's
+  // duplicate `serverName: rea`. setup records the home; the shim must use it.
+  const f = mirrorFixture();
+  const home = path.join(f.root, "custom-home");
+  mkdirSync(home, { recursive: true });
+  writeFileSync(
+    path.join(home, "cordis.patch.yml"),
+    "- insert:\n    - id: rea-mcp\n      name: '@deepseek-ai/dsh-mcp-client'\n      config:\n        serverName: rea\n",
+  );
+  writeFileSync(
+    path.join(f.bundle, "mirror.json"),
+    JSON.stringify({ schema: 1, pluginRoot: f.checkout, mirroredAt: "2026-10-18T00:00:00Z", dshHome: home }),
+  );
+  try {
+    const run = runShimIsolated(
+      // DSH_HOME="" models the scrubbed environment: the variable exists, empty.
+      { REA_BUNDLE_ROOT: f.bundle, REA_BUNDLE_AUTO_PROVISION: "0", REA_BUNDLE_LAUNCH: "bundle", DSH_HOME: "" },
+      ["--shim-status"],
+    );
+    const report = JSON.parse(run.stdout);
+    assert.equal(report.duplicateRegistration?.id, "rea-mcp", run.stdout);
+    assert.equal(report.duplicateRegistration.patch, path.join(home, "cordis.patch.yml"));
+  } finally {
+    f.clean();
+  }
+});

package/scripts/verify-branch.ps1

@@ -90,6 +90,14 @@ Check 'main resolves to a shipped file' ($pkg.main -and (Test-Path (Join-Path $r
 Check 'package.json declares engines.dsh' (-not [string]::IsNullOrWhiteSpace($pkg.engines.dsh)) ''
 $compat = & node scripts\host-compat.mjs 2>&1
 Check 'engines.dsh covers every released DSH host' ($LASTEXITCODE -eq 0) (($compat | Select-Object -Last 2) -join ' ')
+# Both READMEs quote the range verbatim, and a stale quote is invisible: JSON,
+# host-compat and the audit all agree while the sentence a human reads names a
+# different ceiling. That is exactly how `<0.3.0` survived in the docs after the
+# declaration moved to `<0.3.0-0`, so the comparison lives here now.
+foreach ($doc in @('README.md', 'README.zh-CN.md')) {
+  $text = Get-Content (Join-Path $root $doc) -Raw -Encoding UTF8
+  Check "$doc quotes the declared engines.dsh" $text.Contains([string]$pkg.engines.dsh) "expected $($pkg.engines.dsh)"
+}
 foreach ($script in @('bundle:setup', 'bundle:status', 'bundle:audit', 'bundle:test', 'bundle:host-compat')) {
   Check "scripts.$script exists" ($pkg.scripts.PSObject.Properties.Name -contains $script) ''
 }