@nimoxie/dsh-ui-tweaks 0.1.4 → 0.1.5

package/DEVELOPMENT.md

@@ -4,7 +4,7 @@
 
 ## 骨架（与 dsh-model-organizer 同构）
 
-- `lib/index.js`：host 半区，空 `apply()`，只为让插件出现在 cordis loader / bundle 列表。
+- `lib/index.js`：host 半区，挂两条回环路由（`GET /api/ui-tweaks/local-plugins` 本地包识别、`POST /api/ui-tweaks/normalize-excludes` 豁免表归并），并在加载时静默归并一次；细节见「更新检查」。
 - `lib/client.js`：浏览器半区，`module.exports = { name, apply, inject }`；`apply(ctx)` 由客户端 cordis 上下文调用。
 - `cordis.patch.yml`：`- insert: [{id: ui-tweaks, name: '@nimoxie/dsh-ui-tweaks'}]`。**profile 必须声明 `dsh.bundle.patch`，否则 dsh 启动即报 declares no dsh.bundle**；**insert.name 必须写全 scope**（loader 按它在 node_modules 解析包）。
 - `package.json`：`exports["./client"]` 指向 client bundle；`dsh.client.platform: "web"`；inject 只需 `@deepseek-ai/dsh-api-remotes`（`remote.*` 服务由它提供）。`react` / `react-dom` 等是 shell 内置（PLATFORM_MODULES），不用声明。
@@ -31,31 +31,35 @@
 
 ## 更新检查（模块 3）
 
-### 关键经验：注解必须回读，而且 pnpm 的 minimumReleaseAge 是主要的静止源
+### 关键经验：pnpm 的 minimumReleaseAge 是主要的静止源（0.1.5 起分成两条路径看）
 
-- **更新用 `name@latest` 的教训**：pnpm 11 的 `minimumReleaseAge`（profile 的 `pnpm-workspace.yaml`，本机 1440min=24h）会**静默**跳过发布不足 24h 的新版本——区级安装请求会成功、但它解析到「最新合法版本」而**不是**时候刚发布的版本，装上后版本没变，面板才改判「暂缓」。这不是失败，是 pnpm 的窗口保护，不报错。
-- **绕法（已实测）**：把 spec 写成 **`name@精确版本号`**（`dsh-context@0.61.0` 而不是 `dsh-context@latest`），pnpm 会把该版本自动写入 workspace 的 `minimumReleaseAgeExclude`（实测输出 `Added 1 entry to minimumReleaseAgeExclude in pnpm-workspace.yaml`）并照常安装。所以本插件的 `startOne` 现在用面板解析出的 `latest` 拼 spec（`name + "@" + row.latest`），而不是 `name + "@latest"`。
-- `finishOne` 的「版本没变 → 暂缓更新」判据仍然保留作为兜底（防 registry 解析与 pnpm 最终解析不一致），只是正常情况下它不会再被触发。
-- 参考实现：社区分叉版 `@linxin666/dsh-client-ui-plugin-manager` 的 update handler 也是先 `fetchManifest` 拿 registry 的 `version`，再 `installBundle(name@version)`——即它「能更新」不是因为绕过了 pnpm，而是因为用的是精确版本。
+- **`minimumReleaseAge` 有两条独立的作用路径，别混为一谈**（0.1.5 修订；0.1.4 这段只写对了一半）：
+  1. **门禁（在解析之前）**：`pnpm install/add` 一上来就校验**磁盘上现有的** lockfile，任一 entry 的发布时间落在窗口内 → **整体中止整个 profile 的安装**并报 `ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`（exit 1）。这一步与"你要装什么"无关，**写精确版本号也救不了**。
+  2. **解析（在门禁之后）**：候选不合法时 pnpm 会挑「最新合法版本」（于是装上后版本没变 → 面板判「暂缓」）；但**显式写 `name@版本`** 时它会打印 `Added 1 entry to minimumReleaseAgeExclude in pnpm-workspace.yaml` 并照常安装——这条仍然成立，只是它管不了第 1 条。
+- **豁免表的坑（0.1.5 实测）**：`minimumReleaseAgeExclude` 里同一个包名出现**多条**时**只有文件中靠前的那条生效**（不是并集）。同一份 lockfile/yaml 只改顺序：`[pkg@0.69.0, pkg@0.61.0]` 通过、`[pkg@0.61.0, pkg@0.69.0]` 失败。于是陈旧条目**静默遮蔽**新条目，此后每次安装都被门禁拦下；而一次成功的未成熟安装又会把新条目**追加在末尾**，让旧条重新变成靠前那条 → 下一次安装立刻失败。**这就是 0.1.5 之前用户侧「更新某插件 → 报一长串 pnpm 错误 → 之后所有插件都装不上」的真因。**
+- **对策（0.1.5）**：host 半区新增归并器 `normalizeReleaseAgeExcludes()`（`lib/index.js`），把该表收敛成「每包一条」——同包多条只留"与 lockfile 锁定版本一致"的那条（否则留靠前那条）；受管包名（profile `dependencies` 里的）唯一条且版本 ≠ 锁定版本 → 删除；非受管且不重复的条目不动。结果恒为原条目的**子集**（绝不比现状更宽松）。触发：插件加载时静默一次 + `POST /api/ui-tweaks/normalize-excludes`（client 在安装落地成功后与「重新检查」时 fire-and-forget 调用）。安全约束：只改 `minimumReleaseAgeExclude` 这一段、其余字节逐字节保留；写前留 `pnpm-workspace.yaml.bak-<时间戳>`；同目录临时文件 + `renameSync` 原子替换；写后重读校验；无变化不写盘；幂等；异常一律不外抛。
+- **客户端「冷静期中」(cooling)**：两条判定路——① 预判：拉该包**全量 packument** 读 `time[版本]`（`/<pkg>/latest` 与 abbreviated packument 都**没有** `time`，实测），`发布时间 + 窗口 > 现在` 即标 cooling；② 反应式：门禁报错里同时有 `published at <ISO>` 与 `cutoff <ISO>`，于是 `窗口 = now − cutoff`、`成熟时刻 = 发布 + 窗口`（前提是刚失败就解析，秒级误差）。反推窗口只接受 (0, 30 天]，越界退回会话默认值（真实值会从首次报错学到）。cooling 标签**不可点击安装**（点它必然撞门禁、还可能连累整个 profile），只切换详情；`enqueue` 里还有第二道闸。
+- **本机实测环境**：dsh 用的是**自带的 pnpm 11.7.0**（`<DSH_HOME>/dsh-runtimes/dsh-primary-runtime/dependencies/pnpm`），**不是** PATH 上那个（本机 PATH 是 11.21.0）。排查这类问题必须用前者复现，否则结论会反过来。
+- 参考实现：社区分叉版 `@linxin666/dsh-client-ui-plugin-manager` 的 update handler 也是先 `fetchManifest` 拿 registry 的 `version`，再 `installBundle(name@version)`——它「能更新」不是因为绕过了门禁，而是因为它用的是精确版本（只绕开第 2 条路径）。
 
 ### 本地包识别 = host 路由为主，404 签名兜底
 
-- `listBundles()` 不透传安装来源（`installed` 不是 spec 字符串），而发布到 npm 的本地包（如 `@nimoxie/dsh-model-organizer`）连 registry 404 签名都不命中 —— 所以 host 半区挂了 `GET /api/ui-tweaks/local-plugins`（读 profile `package.json` 的 dependencies，按 source 分两类回给面板：**local** = `link:`/`file:` 本地路径，标「本地链接」；**remote** = `git:`/`github:`/`http` 直装，标「Git 直装」；仅回环放行）。两者都**不参与 registry 比对**——即使 npm 上有同名包（如 `dsh-ego-browser` 有 `github:` 声明、registry 也存在 0.8.6），装的也是仓库源码、与 npm 版不是一回事。client 每轮检查先取这份名单，取不到（host 半区未重启）再退回 404 签名（404 时也按 `installed` 来源区分 local/remote）。**改 host 半区必须重启 dsh/客户端才生效**（client bundle 刷新即可）。
+- `listBundles()` 不透传安装来源（`installed` 不是 spec 字符串），而发布到 npm 的本地包（如 `@nimoxie/dsh-model-organizer`）连 registry 404 签名都不命中 —— 所以 host 半区挂了 `GET /api/ui-tweaks/local-plugins`（读 profile `package.json` 的 dependencies，按 source 分两类回给面板：**local** = `link:`/`file:` 本地路径，标「本地链接」；**remote** = `git:`/`github:`/`http` 直装，标「Git 直装」；仅回环放行）；0.1.5 起还有第二条回环路由 `POST /api/ui-tweaks/normalize-excludes`（见上面的归并器）。两者都**不参与 registry 比对**——即使 npm 上有同名包（如 `dsh-ego-browser` 有 `github:` 声明、registry 也存在 0.8.6），装的也是仓库源码、与 npm 版不是一回事。client 每轮检查先取这份名单，取不到（host 半区未重启）再退回 404 签名（404 时也按 `installed` 来源区分 local/remote）。**改 host 半区必须重启 dsh/客户端才生效**（client bundle 刷新即可）。
   profile 目录定位：先从 `import.meta.url` 向上找带 `dsh.profile.bundles` 且包含自身的 package.json（npm 直装必命中）；软链安装时模块被解析到 profile 外的真实目录，退回 `DSH_HOME/profiles/*` 扫描，多 profile 命中时按 `ELECTRON_RUN_AS_NODE` 区分 desktop/web。
 
 ### 其它要点
 
-- **更新主路径全部走官方 remote API**（host 半区只挂一条本地包识别路由）：`pluginManager.listBundles()`（清单+版本）、`installBundle("<名>@版本", { enabled, requestId })`（更新）、`waitForInstall(requestId)`（**仅**响应丢失后的恢复）、`cancelInstall(requestId)`（取消，回 `{status}`）。
+- **更新主路径全部走官方 remote API**（host 半区两条回环路由：本地包识别 + 豁免表归并）：`pluginManager.listBundles()`（清单+版本）、`installBundle("<名>@版本", { enabled, requestId })`（更新）、`waitForInstall(requestId)`（**仅**响应丢失后的恢复）、`cancelInstall(requestId)`（取消，回 `{status}`）。
 - **`installBundle` 是「等到装完才返回」的调用，它的返回值就是终态**（0.1.4 的关键纠正）：remote 信封是 `{ok, value}`，`value` 即 `{changed, application, stage, target, enabled?, error?, warnings?, packageResult?, bundle?, pendingBuilds?, approvedBuilds?, registries?, failedAt?}`。官方桌面端插件页也是 `await installBundle(...)` 之后直接 `settleInstall(result.value)`。
 - **`waitForInstall` 不是进度轮询器**（**0.1.3 的理解是错的，那正是「更新永远超时」的真因**）：它只用于**响应丢失后**恢复同一请求的结果，请求不在活动中时返回 `null`，而且**已完成的结果不保留**。`installBundle` 已经 await 到装完，此时再轮询 `waitForInstall` 必然一路读到 `null` → 空转到 240s 看门狗 → 面板报「更新超时」，真实结果（成功或 pnpm 报错）全被丢掉。0.1.4 起：正常路径只读 `res.value`；**仅当信封本身失败（`res.ok === false`，结果未知）**才调一次 `waitForInstall` 恢复，仍为 `null` 就如实报「已发起·未确认」。
-- **终态判定读 `application`**：`applied` / `restart-required`（都算成功，后者提示重启）→ 回读版本核对；`cancelled` → 该行退回「有新版本」（取消不是失败，仍可重试）；`failed` → 行标「更新失败」，并把 `error.code`（译成中文）+ `error.diagnostic` + `packageResult.kind/exitCode/output/logPath` + `pendingBuilds` + `failedAt` 一起写进行内 `why`；`overridden` → 提示被覆盖、可重试；未知值一律按「结果未知」处理，不硬判成功。
+- **终态判定读 `application`**：`applied` / `restart-required`（都算成功，后者提示重启）→ 回读版本核对；`cancelled` → 该行退回「有新版本」（取消不是失败，仍可重试）；`failed` → 行标「更新失败」，并把 `error.code`（译成中文）+ `error.diagnostic` + `packageResult.kind/exitCode/output/logPath` + `pendingBuilds` + `failedAt` 一起写进行内 `why`（**成熟期违规例外**：报错里带 `ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION` 时不落 `failed`，判成 `cooling`，并把反推出来的窗口记进会话供预判复用）；`overridden` → 提示被覆盖、可重试；未知值一律按「结果未知」处理，不硬判成功。
 - **回读版本是唯一成功判据**：只有在 `listBundles()` 里读到该行版本、且**与安装前不同**时才判「已是最新」。回读**只用 `pluginManager.listBundles()`**——`pluginInventory` 只有 `list()` 没有 `listBundles`（踩过，会造成「回读版本失败」假阳性）；装完瞬间清单可能短暂不可用，重试 3 次（1.5s 间隔）。比对基准 `busyBefore` 在 `startOne` 抓取，**不受中途「重新检查」重建行的影响**。
 - **registry 比对在浏览器直连**：`registry.npmjs.org` 带 CORS *（实测），逐包**串行** fetch `/latest`，不打并发。代价要知道：比对源是 npmjs，而安装走 pnpm 自己的 registry（本机 `.npmrc` 指向 npmmirror）——镜像尚未同步到的新版本会「面板说有、装时报 no-matching-version」（见「待办」）。
 - **取消要分清对象**（0.1.4 修）：排队项点取消只把它自己摘出队列（`cancelQueued`）；在装项点取消才 `cancelInstall(requestId)`，且**保留队列**，等这次落定后 `done() → pump()` 接着装下一项。旧实现 `requestCancel` 里一句 `queue = []` 把整个队列清空，于是「等待更新」的项全部退回「有新版本」不再开始——这就是「取消一项后，等待的项不更新、反而变回有新版本」的真因。`cancelInstall` 的回值 `{status: cancelled|not-running|too-late}` 也要读：`too-late` 说明已进入应用阶段、取消不掉，得如实告诉用户。
 - **重新检查必须回填在飞状态**（0.1.4 修）：`checkNow` 重建 `rows` 会把「更新中/等待更新」抹成「有新版本」，而 `busyName`/`queue` 仍在——此时点那一行会撞上 `enqueue` 的 `name === busyName` 保护而**静默无反应**（这就是「重新检查后无法更新」的真因），真正在装的那一项也失去取消入口。修法是重建行后立刻 `reconcileInstallStates()` 把 busy/queuing 盖回去，且这两种行不参与 registry 比对。
 - **总看门狗（0.1.4 起只是兜底）**：正常路径一次 `installBundle` 就定案，不必再等 240s；看门狗只覆盖 fetchLatest（现场查 registry，fetch 无超时）这类异常分支，触发时报「结果未知」并 `cancelInstall`。
 - **`enabled` 用清单里的真实状态**：`installBundle` 的 `enabled` 传 `!(row.enabled === false)`，保留用户手动禁用的选择（旧实现一律 `enabled: true`，会把禁用的插件重新启用）。
-- **失败原因要可见**：`fail` / `unchanged` / `unconfirmed` / `error` 行在行下多渲染一行 `.why`——只放在 `title` 悬停提示里，等于 pnpm 的报错没显示。
+- **失败原因要可见**：`fail` / `unchanged` / `unconfirmed` / `error` / `cooling` 行在行下多渲染一行 `.why`——只放在 `title` 悬停提示里，等于 pnpm 的报错没显示。0.1.5 起渲染前先 `stripAnsi`（CSI/OSC/控制字符/CRLF，否则用户第一屏是一串 `鈺?` 残渣），并把 `diagnostic` 与 `packageResult.output` 互相包含时只留更完整的一份（dsh 常把同一份 pnpm 输出摘成两段）；`cooling` 的完整诊断默认折叠，点标签才展开（`.dtl`）。
 
 
 ## 动画修复（模块 4）
@@ -81,15 +85,20 @@
 - [ ] 会话内重启 dsh 的入口（需要 host 配合或官方重启 API，未调研）。
 - [x] 0.1.3：`waitForInstall` 终态按 zod schema 收紧了字段名（`application`/`stage`/`failedAt`）+ 全程总看门狗。**注意：这一版的结论是错的**——字段名猜对了，但把 `waitForInstall` 当进度轮询器用，而它只做「响应丢失恢复」；见 0.1.4 条目。
 - [x] 0.1.4：终态改读 `installBundle().value`（`waitForInstall` 只在信封失败时兜一次）；取消不再清空队列、排队项可单独取消；`checkNow` 回填 busy/queuing；失败原因（`error`/`packageResult`/`pendingBuilds`）落到面板；`enabled` 沿用清单里的真实状态。
+- [x] 0.1.5：新增「冷静期中」(cooling)——预判（全量 packument 的 `time`）+ 报错反推成熟时刻，标签不可点击安装、`enqueue` 二次拦截；host 半区新增 `minimumReleaseAgeExclude` 归并器与 `POST /api/ui-tweaks/normalize-excludes`（安装成功/重新检查时 fire-and-forget）；失败文案剥 ANSI、同一份 pnpm 输出去重、cooling 详情折叠；纠正 0.1.4 关于 `minimumReleaseAge` 的半个结论。
 - [ ] 比对 registry 与安装 registry 对齐：面板查 `registry.npmjs.org`，pnpm 走 `.npmrc`（npmmirror）。镜像未同步的新版本会造成「面板说有新版、装时报 no-matching-version」。可用 `pluginManager.registries()` 取实际 registry 再比对（需先确认镜像的 CORS）。
 - [ ] `pendingBuilds` 的「允许这些脚本并重试」入口（`installBundle(spec, { approvedBuilds })`）。现在只在失败行里列出待授权名单。
 - [ ] `removable === false` / `optional` / 带 `readOnlyReason` 的 bundle 在面板隐藏或标注——否则点了会以 `management-required` 失败。
 - [ ] `installBundle` 的 `registry` 参数补齐（官方传了，本插件省略）。
 - [ ] 插件被禁用/卸载时的运行时清理（目前 DOM 残留到页面刷新为止）。
+- [ ] 归并器收尾：`.bak-<时间戳>` 会随每次改写累积（改成只留最近 N 个或固定单名）；`minimumReleaseAgeExclude` 里出现空行/纯注释行时扫描会提前结束（只漏收敛、不误删），可顺手修成跳过空行继续扫。
+- [ ] cooling 的反推窗口依赖"报错新鲜度"：解析被延迟时反推窗口会偏大（现有 30 天上限兜底），偏大表现为**多标**冷静期；可考虑优先用 host 侧策略真值而不是反推。
+- [ ] `鈺?`/`鉁?` 这类残渣的根因在 host 侧读 pnpm stdout 时的解码（UTF-8 被按 CP936 解），client 只能剥 ANSI；根治要动解码或让 host 回报已解码文本。
 
 ## 发布
 
 - npm 不允许覆盖已发布的版本号：**先升版本，再提交，最后发布**。
+- **发版前先 `npm pack --dry-run` 看一眼清单**：`files` 里曾把开发笔记写成 `DEVELOPING.md`（实际文件名是 `DEVELOPMENT.md`），于是它一直没进包；0.1.5 已修。
 - 版本号同时在 `package.json` 和 `lib/client.js` 的 `BUILD` 常量里（改两处）。发版命令：
   ```sh
   npm version patch        # 或手改 package.json 的 version；记得同步 BUILD

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 NimoXie
-
-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.
+MIT License
+
+Copyright (c) 2026 NimoXie
+
+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

@@ -22,6 +22,8 @@
 **插件更新检查**
 - 插件管理页顶部多一枚「检查更新」按钮（刷新按钮左侧，样式与「添加插件」按钮一致）：比对已装插件（官方 `@deepseek-ai` 插件除外）与 npm registry 的版本，有新版本可点上就地更新，支持全部更新与中途取消
 - 不检查 dsh 本体，也不检查 `@deepseek-ai` 官方插件——两者的更新都由 dsh 本体的更新流程负责（桌面端自带更新器；web 端本体升级走 `npm install -g @deepseek-ai/dsh@next`）
+- 新版本还没过 pnpm 的发布时长窗口（`minimumReleaseAge`，由 dsh 注入给自带 pnpm，默认 24 小时）时，该行标 **「冷静期中」** 并给出可更新时间（精确到分钟，发布时间与判定 cutoff 都能从报错里读到）；点它只展开详情，**不会**发动一次注定失败的安装
+- 安装成功后自动把 profile 的 `minimumReleaseAgeExclude` 归并成「每包一条」，修掉「同一个包名出现多条时只有靠前那条生效、陈旧条目静默遮蔽新条目，导致此后每次安装都失败」这个坑（由 host 半区静默完成，无界面）
 
 ## 安装
 
@@ -55,8 +57,9 @@ dsh plugin --profile <profile> add link:/absolute/path/to/dsh-ui-tweaks
 
 - 非 npm 来源的插件没有可比的 registry 版本，直接跳过比对：`link:` / `file:` 本地路径标「本地链接」；`git:` / `github:` / `http` 直装标「Git 直装」（例如 `github:Fisfzy/dsh-ego-browser` 会显示为 Git 直装，即使 npm 上有同名包，装的也是仓库源码、与 npm 版本不是一回事）
 - `@deepseek-ai` 官方插件直接从检查列表里剔除：它们的更新由 dsh 本体流程负责
-- 更新走 profile 内的插件安装接口，与官方插件管理页同源；安装按 registry 解析出的**精确版本号**发起（而非 `@latest`），不受 pnpm 发布时长策略（minimumReleaseAge）拦挡，刚发布的版本也能装
-- 更新失败时行内会直接给出原因（pnpm 的输出、退出码与日志路径），不再只说一句「失败」；失败行可点击重试。取消只作用于你点的那一项：取消排队的项不影响正在装的，取消正在装的也不会丢掉后面排队的（它会自动接着装）
+- 更新走 profile 内的插件安装接口，与官方插件管理页同源；安装按 registry 解析出的**精确版本号**发起（而非 `@latest`），装的就是面板显示的那一个版本
+- **精确版本号并不能绕过 pnpm 的发布时长策略**（`minimumReleaseAge`，由 dsh 注入，默认 24 小时，不在任何配置文件里）：门禁在解析之前先校验 profile 现有的 lockfile，窗口内的版本会让整个 profile 的安装被**整体中止**（`ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`，exit 1）。所以这类行被判成「冷静期中」而不是「更新失败」——发布满 24 小时后重试即可
+- 更新失败时行内会直接给出原因（pnpm 的输出、退出码与日志路径），不再只说一句「失败」；渲染前会剥掉终端转义序列（否则第一屏是一串乱码），同一份 pnpm 输出被 dsh 摘成两段时只留更完整的一份；失败行可点击重试。冷静期不是失败，不渲染那一长串，只在展开详情里给完整诊断。取消只作用于你点的那一项：取消排队的项不影响正在装的，取消正在装的也不会丢掉后面排队的（它会自动接着装）
 - 面板比对用的是 npm 官方 registry，而安装走你本机 pnpm 配置的源（如 npmmirror 镜像）。镜像尚未同步到的新版本会出现「面板说有新版、装时报找不到版本」，稍后镜像同步后重试即可
 - 个别插件（如社区插件管理页扩展）自带单独的「检查更新」入口，与本插件的检查互不关联，结果可能不同
 - 与启动器 dsh-web-shell 的分工：对话区滚动条、宽表格修复等界面增强已由本插件接管，dsh-web-shell 自身不再注入；其「检查更新」按钮仍负责 **dsh 本体**的比对与升级提示

package/cordis.patch.yml

@@ -1,7 +1,7 @@
-# dsh-ui-tweaks bundle patch: one host row over the web profile.
-# The row name resolves from the profile's own node_modules where
-# `dsh plugin --profile web add <path>` installed this package.
-# Scoped 包名的 name 必须写全（同 @linxin666 系插件），loader 按它解析 node_modules。
-- insert:
-    - id: ui-tweaks
-      name: '@nimoxie/dsh-ui-tweaks'
+# dsh-ui-tweaks bundle patch: one host row over the web profile.
+# The row name resolves from the profile's own node_modules where
+# `dsh plugin --profile web add <path>` installed this package.
+# Scoped 包名的 name 必须写全（同 @linxin666 系插件），loader 按它解析 node_modules。
+- insert:
+    - id: ui-tweaks
+      name: '@nimoxie/dsh-ui-tweaks'

package/lib/client.js

@@ -14,7 +14,7 @@ window.__ModuleLoader__.load({
     const module = { exports: {} };
     const exports = module.exports;
 
-    const BUILD = "0.1.4";
+    const BUILD = "0.1.5";
 
     /* 每个模块的注册各套一层 guard：失败只记 warn（座位/模块失败模式是「静默消失」，
        必须主动吭声；但不能让一个模块的异常打断同文件里其它模块的 apply）。 */
@@ -359,11 +359,25 @@ window.__ModuleLoader__.load({
      * registry 比对从浏览器直连（registry.npmjs.org 带 CORS *）。
      *
      * 更新严格串行（pnpm 对 profile 的 package.json 有文件锁，并发只会在锁上
-     * 排队）；安装 spec 用面板解析出的**精确版本**（`name@版本`，不是 @latest）：
-     * pnpm 11 的 minimumReleaseAge 门禁只拦「最新版本」解析，显式版本会自动
-     * 写入 profile 的 pnpm-workspace.yaml 的 minimumReleaseAgeExclude 并放行。
-     * 装完仍回读实际版本兜底（registry 与 pnpm 解析可能不一致），版本没变
-     * 才是「暂缓更新」。
+     * 排队）；安装 spec 用面板解析出的**精确版本**（`name@版本`，不是 @latest），
+     * 装完仍回读实际版本兜底（registry 与 pnpm 解析可能不一致），版本没变才是
+     * 「暂缓更新」。
+     *
+     * minimumReleaseAge（DSH 自带 pnpm 11 注入，本机策略 1440 分钟）：
+     *   门禁在**解析之前**校验磁盘上已有的 lockfile，任何一个 entry 的发布时间
+     *   落在窗口内就整体中止整个 profile 的安装，报
+     *   ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION（exit 1）—— 写显式版本号并不能
+     *   豁免（旧注释在这里写反过，已纠正）。
+     *   真正的豁免表是 profile 的 minimumReleaseAgeExclude，但**同一个包名出现多
+     *   条时只有文件中靠前的那条生效**：陈旧条会静默遮蔽新条（实测 [0.69.0,
+     *   0.61.0] 通过、[0.61.0, 0.69.0] 失败，只差顺序）。所以「再点一次 = 知情
+     *   并继续」在豁免表没被归并干净时会失败，而且紧接着连累整个 profile 的后续
+     *   安装。这张表由 host 半边自动归并成「每包一条」
+     *   （POST /api/ui-tweaks/normalize-excludes），client 只负责在安装成功后 /
+     *   面板重新检查时尽力而为地触发一次。
+     *   窗口内的版本在面板上标成「冷静期中」(cooling)：发布时间与门禁 cutoff 都
+     *   能从 pnpm 报错文本里读出来，成熟时刻 = 发布时间 + (门禁运行时刻 − cutoff)；
+     *   预判则拉全量 packument 的 time[版本] 自己算（见下面的 cooling 两段）。
      * ==================================================================== */
     function installPluginUpdates(ctx) {
       if (window.__DSHUIW_UPDATES__) { return; }
@@ -413,6 +427,258 @@ window.__ModuleLoader__.load({
         });
       }
 
+      /* ---- 报错文案 / 冷静期：纯函数区 ---------------------------------------
+       * 这一段不读任何闭包状态（策略窗口、当前时刻、错误码表都作为参数传入），
+       * 因此可以单独喂样例跑断言。
+       * -------------------------------------------------------------------- */
+      var MAX_POLICY_MS = 30 * 24 * 60 * 60 * 1000;       /* 反推窗口的合理上限（30 天） */
+
+      /* pnpm 输出带 ANSI 转义（CSI 色码 / OSC 超链接）与不可打印控制字符，直接渲染
+         就是用户第一屏看到的「鈺?」「鉁?」这类残渣；这里统一剥掉（保留 \n \t），
+         并把 CRLF 归一成 \n（pnpm 日志是 CRLF）。 */
+      function stripAnsi(s) {
+        return String(s == null ? "" : s)
+          .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g, "")     /* OSC */
+          .replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, "")                     /* CSI */
+          .replace(/\u001b[@-Z\\-_]/g, "")                                  /* 其它两字节转义 */
+          .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")   /* 控制字符 */
+          .replace(/\r\n?/g, "\n");
+      }
+
+      function isoToMs(s) {
+        var t = Date.parse(String(s == null ? "" : s));
+        return isFinite(t) ? t : NaN;
+      }
+
+      /* registry 全量 packument 的 time 字段 → {版本: 发布时间ms}（created / modified
+         是元数据不是版本）。/<pkg>/latest 与 abbreviated packument
+         （Accept: application/vnd.npm.install-v1+json）都没有 time 字段，别用它们。 */
+      function packumentTimes(doc) {
+        var out = {};
+        if (!doc || !doc.time || typeof doc.time !== "object") { return out; }
+        for (var k in doc.time) {
+          if (!Object.prototype.hasOwnProperty.call(doc.time, k)) { continue; }
+          if (k === "created" || k === "modified") { continue; }
+          var t = isoToMs(doc.time[k]);
+          if (isFinite(t)) { out[k] = t; }
+        }
+        return out;
+      }
+
+      /* 门禁报错的解析（真实样例）：
+           dsh-context@0.69.0 was published at 2026-10-11T18:46:04.000Z,
+           within the minimumReleaseAge cutoff (2026-10-11T07:56:04.065Z)
+         cutoff = 门禁运行时刻 − 窗口 ⇒ 窗口 = 现在 − cutoff，
+         成熟时刻 = 发布时间 + 窗口。
+         真实路径是「安装失败回调里立刻解析刚回来的报错」，现在 ≈ 门禁运行时刻，误差
+         只有秒级；对陈旧报错文本反推会偏大，故窗口只接受 (0, 30 天]，越界退回
+         defaultWindowMs（会话已从真实报错里学到的值，默认 1440 分钟）。 */
+      function parseCoolingFailure(text, nowMs, defaultWindowMs) {
+        var s = String(text == null ? "" : text);
+        if (!/ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION|minimumReleaseAge|supply-chain polic/i.test(s)) {
+          return null;
+        }
+        var out = {
+          violation: true, packageName: "", version: "",
+          publishedMs: NaN, cutoffMs: NaN, windowMs: NaN, matureAtMs: NaN
+        };
+        var mPub = /published at\s+([0-9T:.\-Z]+)/.exec(s);
+        var mCut = /\bcutoff\b[^0-9]{0,8}([0-9T:.\-Z]+)/.exec(s);
+        var mName = /(@?[^\s@\/]+(?:\/[^\s@\/]+)?)@([0-9][0-9A-Za-z.\-+]*)/.exec(s);
+        if (mName) { out.packageName = mName[1]; out.version = mName[2]; }
+        if (mPub) { out.publishedMs = isoToMs(mPub[1]); }
+        if (mCut) { out.cutoffMs = isoToMs(mCut[1]); }
+        var win = (isFinite(nowMs) && isFinite(out.cutoffMs)) ? (nowMs - out.cutoffMs) : NaN;
+        if (!isFinite(win) || win <= 0 || win > MAX_POLICY_MS) {
+          win = (isFinite(defaultWindowMs) && defaultWindowMs > 0) ? defaultWindowMs : NaN;
+        }
+        out.windowMs = win;
+        if (isFinite(out.publishedMs) && isFinite(win)) { out.matureAtMs = out.publishedMs + win; }
+        return out;
+      }
+
+      /* 从一次安装结果里认出「成熟期违规」：文本取自 error.message / diagnostic /
+         code / packageResult.output（同一份 pnpm 输出的不同片段，合起来看）。 */
+      function coolingFromResult(st, nowMs, defaultWindowMs, codeText) {
+        if (!st || typeof st !== "object") { return null; }
+        var pr = st.packageResult;
+        var text = stripAnsi([
+          st.error && st.error.message,
+          st.error && st.error.diagnostic,
+          st.error && st.error.code,
+          pr && pr.output
+        ].filter(function (x) { return !!x; }).join("\n"));
+        var info = parseCoolingFailure(text, nowMs, defaultWindowMs);
+        if (!info) { return null; }
+        return {
+          violation: true, version: info.version, packageName: info.packageName,
+          publishedAt: info.publishedMs, matureAt: info.matureAtMs,
+          windowMs: info.windowMs,
+          detail: failureText(st, codeText)
+        };
+      }
+
+      /* 失败原因必须落到面板上：旧实现只回一句「安装失败」，把 pnpm 的真实报错
+         （如 ERR_PNPM_UNEXPECTED_STORE）连同 logPath 一起丢掉，用户只看到「超时」。
+         diagnostic 与 packageResult.output 常是同一份 pnpm 输出的两段（dsh 摘的尾部
+         vs 原始输出），两段都贴会让同一段报错在气泡里出现两遍：一段被另一段包含时
+         只留更完整的那份；渲染前先剥掉转义与控制字符。 */
+      function failureText(st, codeText) {
+        var tbl = codeText || {};
+        var parts = [];
+        var code = st && st.error && st.error.code;
+        parts.push("安装失败" + (code ? "：" + (tbl[code] || code) : ""));
+        var diag = stripAnsi(st && st.error && st.error.diagnostic).replace(/^\s+|\s+$/g, "");
+        var pr = st && st.packageResult;
+        var out = stripAnsi(pr && pr.output).replace(/^\s+|\s+$/g, "");
+        if (diag && out && (diag.indexOf(out) >= 0 || out.indexOf(diag) >= 0)) {
+          if (out.length > diag.length) { diag = ""; } else { out = ""; }
+        }
+        if (diag) { parts.push(diag); }
+        if (pr) {
+          if (pr.kind) { parts.push("分类：" + pr.kind); }
+          if (pr.exitCode) { parts.push("pnpm 退出码 " + pr.exitCode); }
+          if (out) { parts.push("输出：" + out.slice(-800)); }
+          if (pr.logPath) { parts.push("日志：" + pr.logPath); }
+        }
+        var pend = st && st.pendingBuilds;
+        if (pend && pend.length) { parts.push("待授权的构建脚本：" + pend.join("、") + "（需在官方插件页授权后重试）"); }
+        if (st && st.failedAt) { parts.push("失败环节：" + st.failedAt); }
+        return parts.join(" ｜ ");
+      }
+
+      function pad2(n) { return (n < 10 ? "0" : "") + n; }
+      /* 绝对时间用本地时间（MM-DD HH:mm） */
+      function fmtLocal(ms) {
+        var d = new Date(ms);
+        return pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " + pad2(d.getHours()) + ":" + pad2(d.getMinutes());
+      }
+      /* 相对剩余时间：16h49m / 49m */
+      function fmtLeft(ms) {
+        var s = Math.max(0, Math.round(ms / 1000));
+        var h = Math.floor(s / 3600);
+        var m = Math.floor((s - h * 3600) / 60);
+        if (h > 0) { return h + "h" + (m > 0 ? pad2(m) + "m" : ""); }
+        return m + "m";
+      }
+      function fmtWindow(ms) {
+        if (!isFinite(ms) || ms <= 0) { return ""; }
+        var mins = Math.round(ms / 60000);
+        if (mins < 60) { return mins + " 分钟"; }
+        var hrs = mins / 60;
+        return (hrs === Math.floor(hrs) ? String(hrs) : hrs.toFixed(1)) + " 小时";
+      }
+      /* cooling 行副标题：绝对时间（本地）+ 相对剩余时间 + 「现在装会被门禁整体中止、
+         不是本插件的问题」。 */
+      function coolingWhyText(info) {
+        var i = info || {};
+        var out = (i.version ? String(i.version) : "该版本") + " 处于供应链冷静期";
+        var win = fmtWindow(i.windowMs);
+        if (win) { out += "（发布未满 " + win + "）"; }
+        var mature = i.matureAt;
+        if (isFinite(mature)) {
+          var left = mature - (isFinite(i.nowMs) ? i.nowMs : 0);
+          out += "，" + fmtLocal(mature) + " 后可更新" +
+            (left > 0 ? "（剩 " + fmtLeft(left) + "）" : "（已到期，点「重新检查」刷新）");
+        } else {
+          out += "，成熟时刻没能从报错里解析出来";
+        }
+        return out + "。现在点安装会被 pnpm 的 minimumReleaseAge 门禁整体中止（连累整个 profile 的后续安装），不是本插件的问题。";
+      }
+      /* ---- 纯函数区结束 ---- */
+
+      /* ---- 供应链冷静期（cooling）：预判数据源与护栏 --------------------------
+       * 预判 = 拉全量 packument 读该版本的发布时间（/<pkg>/latest 和 abbreviated
+       * packument 都没有 time），发布时间 + 策略窗口 > 现在 → 该行标 cooling。
+       * 会话级缓存：一个包只拉一次、缓存 10 分钟，失败（含超时）也缓存 —— 否则每次
+       * 重绘都会重拉，就是重试风暴。超过 8 秒用 AbortController 掐断、体积异常大直接
+       * 放弃：这两种情况都只是「不做预判」，该行保持「有新版本」，不报错、不重试。
+       * 请求串行（同 registry 比对一样，别对 registry 打并发）。
+       * 策略窗口优先用真实报错反推出来的值（见 coolingFromResult），默认 1440 分钟。
+       * -------------------------------------------------------------------- */
+      var DEFAULT_POLICY_MS = 1440 * 60000;       /* pnpm minimumReleaseAge 默认 1440 分钟 */
+      var policyWindowMs = DEFAULT_POLICY_MS;
+      var PACKUMENT_TTL_MS = 10 * 60000;
+      var PACKUMENT_TIMEOUT_MS = 8000;
+      var PACKUMENT_MAX_CHARS = 4 * 1024 * 1024;
+      var packumentCache = {};                    /* name → {at, ok, time:{版本:ms}, err} */
+      var packumentChain = Promise.resolve();     /* 串行闸门 */
+
+      function fetchPackumentTimes(name, cb) {
+        var hit = packumentCache[name];
+        if (hit && Date.now() - hit.at < PACKUMENT_TTL_MS) { cb(hit); return; }
+        var ctl = null, timer = null, done = false;
+        function settle(res) {
+          if (done) { return; }
+          done = true;
+          if (timer) { clearTimeout(timer); timer = null; }
+          packumentCache[name] = res;
+          try { cb(res); } catch (e) {}
+        }
+        function begin() {
+          try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e1) {}
+          if (ctl) { timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, PACKUMENT_TIMEOUT_MS); }
+          var path = String(name).split("/").map(encodeURIComponent).join("/");
+          var opts = { cache: "no-store", headers: { Accept: "application/json" } };
+          if (ctl) { opts.signal = ctl.signal; }
+          return fetch("https://registry.npmjs.org/" + path, opts)
+            .then(function (r) {
+              if (!r || !r.ok) { throw new Error("HTTP " + (r ? r.status : "?")); }
+              return r.text();
+            })
+            .then(function (txt) {
+              txt = String(txt == null ? "" : txt);
+              if (txt.length > PACKUMENT_MAX_CHARS) { throw new Error("packument 体积异常大（" + txt.length + " 字符）"); }
+              var doc = null;
+              try { doc = JSON.parse(txt); } catch (e3) { throw new Error("packument 不是合法 JSON"); }
+              settle({ at: Date.now(), ok: true, time: packumentTimes(doc) });
+            })
+            .catch(function (e) { settle({ at: Date.now(), ok: false, err: msgOf(e), time: {} }); });
+        }
+        packumentChain = packumentChain.then(begin, begin).catch(function () {});
+      }
+
+      /* 预判：只对「有新版本」的行做。窗口内 → cooling（标签不可点击安装）；
+         窗口外 / 数据源不可用 → 保持 update。 */
+      function applyCoolingGuess(name) {
+        var row = findRow(name);
+        if (!row || row.state !== "update" || !row.latest) { return; }
+        var ver = row.latest;
+        fetchPackumentTimes(name, function (res) {
+          var r = findRow(name);
+          /* 期间该行可能被安装 / 重查改过：只处理仍是「有新版本」且版本没变的行 */
+          if (!r || r.state !== "update" || r.latest !== ver) { return; }
+          if (!res || !res.ok || !res.time) { return; }
+          var pub = res.time[ver];
+          if (!isFinite(pub)) { return; }
+          var mature = pub + policyWindowMs;
+          if (!isFinite(mature) || Date.now() >= mature) { return; }
+          setRow(name, {
+            state: "cooling", publishedAt: pub, matureAt: mature, why: "",
+            detail: "registry 记录 " + ver + " 发布于 " + new Date(pub).toISOString() +
+              "；minimumReleaseAge 策略窗口 " + fmtWindow(policyWindowMs) + "。" +
+              "pnpm 在解析之前校验 lockfile，窗口内的版本会让整个 profile 的安装整体中止" +
+              "（ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION，exit 1）。"
+          });
+        });
+      }
+
+      /* 安装成功后 / 面板重新检查时，尽力而为地让 host 半边把 profile 的
+         minimumReleaseAgeExclude 归并成「每包一条」：同一个包名出现多条时只有靠前的
+         那条生效，陈旧条会静默遮蔽新条，让下一次安装继续撞门禁。
+         fire-and-forget：不 await（不阻塞 UI）、失败不弹错、异常全吞
+         （host 未重启时这个路由就是 404）。 */
+      function normalizeExcludes() {
+        try {
+          fetch("/api/ui-tweaks/normalize-excludes", {
+            method: "POST", cache: "no-store",
+            headers: { "Content-Type": "application/json" },
+            body: "{}"
+          }).catch(function () {});
+        } catch (e) {}
+      }
+      /* ---- 冷静期预判区结束 ---- */
+
       /* ---- remote 服务解析：ctx.inject 的 scope 优先（缓存复用），超时兜底直读 ctx ---- */
       var savedScope = null;
       var got = null;             // checkNow 的服务句柄缓存（{pm}）
@@ -469,8 +735,12 @@ window.__ModuleLoader__.load({
       function isRemoteSrc(src) { return /^(git[+:@]|github:|git:|http)/.test(String(src || "")); }
 
       /* ---- 面板状态 ---- */
-      var rows = [];              // {name, version, latest, state, why}
-      // state: pending | checking | current | update | local | remote | error | queuing | busy | done | unchanged
+      var rows = [];              // {name, version, latest, state, why, publishedAt, matureAt, detail}
+      /* state: pending | checking | current | update | local | remote | error | queuing | busy
+         | done | unchanged | unconfirmed | fail | cooling
+         cooling（冷静期中）：还有比已装更新的版本，但它的发布时间没满 minimumReleaseAge
+         窗口 —— matureAt = 成熟时刻，detail = 展开后的详情文本；该标签不可点击安装。 */
+      var revealedCooling = {};   // name → true：该行详情已展开（点 cooling 标签切换）
       var queue = [];             // 待更新名单（串行队列）
       var busyName = "";          // 正在更新的那个
       var busyReq = "";
@@ -498,6 +768,8 @@ window.__ModuleLoader__.load({
       function checkNow() {
         if (checking) { return; }
         checking = true;
+        /* 重新检查 / 打开面板：顺手让 host 半边归并一次豁免表（fire-and-forget） */
+        normalizeExcludes();
         rows = [];
         emit();
         var pm = null;
@@ -564,6 +836,8 @@ window.__ModuleLoader__.load({
                       row.latest = v || "";
                       row.state = v && cmpSemver(v, row.version) > 0 ? "update" : "current";
                       emit();
+                      /* 有新版本才做冷静期预判（异步，不阻塞比对链） */
+                      if (row.state === "update") { applyCoolingGuess(row.name); }
                     }).catch(function (e) {
                       row.state = e && e.notFound ? notFoundState(row) : "error";
                       row.why = String(e && e.message || e);
@@ -622,27 +896,8 @@ window.__ModuleLoader__.load({
         "incompatible-version": "版本与当前 dsh 不兼容",
         "operation-error": "安装命令执行失败（pnpm 非零退出）"
       };
-      /* 失败原因必须落到面板上：旧实现只回一句「安装失败」，把 pnpm 的真实报错
-         （如 ERR_PNPM_UNEXPECTED_STORE）连同 logPath 一起丢掉，用户只看到「超时」。 */
-      function failureText(st) {
-        var parts = [];
-        var code = st && st.error && st.error.code;
-        parts.push("安装失败" + (code ? "：" + (ERROR_CODE_TEXT[code] || code) : ""));
-        var diag = st && st.error && st.error.diagnostic;
-        if (diag) { parts.push(String(diag)); }
-        var pr = st && st.packageResult;
-        if (pr) {
-          if (pr.kind) { parts.push("分类：" + pr.kind); }
-          if (pr.exitCode) { parts.push("pnpm 退出码 " + pr.exitCode); }
-          var out = String(pr.output || "").trim();
-          if (out) { parts.push("输出：" + out.slice(-800)); }
-          if (pr.logPath) { parts.push("日志：" + pr.logPath); }
-        }
-        var pend = st && st.pendingBuilds;
-        if (pend && pend.length) { parts.push("待授权的构建脚本：" + pend.join("、") + "（需在官方插件页授权后重试）"); }
-        if (st && st.failedAt) { parts.push("失败环节：" + st.failedAt); }
-        return parts.join(" ｜ ");
-      }
+      /* failureText 与 coolingFromResult 都在文件上方的「纯函数区」里（错误码表作为
+         参数传入），这里只保留这张码表；旧的长文案实现已删除，避免两份逻辑漂移。 */
       function lostReplyText(res) {
         var m = res && res.error && res.error.message;
         return "安装请求未返回结果" + (m ? "：" + String(m) : "");
@@ -650,6 +905,10 @@ window.__ModuleLoader__.load({
 
       function enqueue(name) {
         if (name === busyName) { return; }        // 正在装它（行内已是「更新中」态）
+        /* 冷静期行不得入队：点它必然撞门禁，并在豁免表存在遮蔽条时连累整个 profile
+           的后续安装（实测）。标签本身也不可点击，这里是第二道闸。 */
+        var grow = findRow(name);
+        if (grow && grow.state === "cooling") { return; }
         if (busyName) {
           if (queue.indexOf(name) < 0) { queue.push(name); setRow(name, { state: "queuing" }); }
           return;
@@ -687,11 +946,11 @@ window.__ModuleLoader__.load({
           finish("unknown", "更新超时（240 秒未结束）；结果未知，请点「重新检查」确认");
           try { var pm2 = pickService(null, "remote.pluginManager"); if (pm2 && pm2.cancelInstall && busyReq) { pm2.cancelInstall(busyReq); } } catch (e) {}
         }, 240000);
-        function finish(kind, why) {
+        function finish(kind, why, meta) {
           if (settled) { return; }
           settled = true;
           clearTimeout(watchdog);
-          finishOne(name, kind, why || "");
+          finishOne(name, kind, why || "", meta);
         }
         function settle(st) {
           if (!st || typeof st !== "object") { finish("unknown", "安装未返回可判定的结果"); return; }
@@ -700,7 +959,18 @@ window.__ModuleLoader__.load({
           if (app === "restart-required") { finish("applied", "已应用，重启桌面端后生效"); return; }
           if (app === "cancelled") { finish("cancelled", "已取消"); return; }
           if (app === "overridden") { finish("failed", "已被另一次安装覆盖，请重试"); return; }
-          if (app === "failed") { finish("failed", failureText(st)); return; }
+          if (app === "failed") {
+            /* 成熟期违规不是「更新失败」：落 cooling，并把反推出来的窗口记进会话缓存
+               （预判复用）；那条长报错不渲染，改由 cooling 的可展开详情承担。 */
+            var cool = coolingFromResult(st, Date.now(), policyWindowMs, ERROR_CODE_TEXT);
+            if (cool) {
+              if (isFinite(cool.windowMs) && cool.windowMs > 0) { policyWindowMs = cool.windowMs; }
+              finish("cooling", "", cool);
+              return;
+            }
+            finish("failed", failureText(st, ERROR_CODE_TEXT));
+            return;
+          }
           finish("unknown", "安装返回了无法识别的结果（application=" + String(app) + "）");
         }
         function lostReply(res) {
@@ -715,9 +985,11 @@ window.__ModuleLoader__.load({
             finish("unknown", lostReplyText(res) + "；恢复结果失败，请点「重新检查」确认");
           });
         }
-        /* 安装 spec 用面板已解析的精确版本（`name@版本`），不用 @latest：pnpm 11 的
-           minimumReleaseAge 只拦「最新版本」解析，显式版本会触发
-           minimumReleaseAgeExclude 自动豁免并照常安装。行内没解析过则现场查 registry。 */
+        /* 安装 spec 用面板已解析的精确版本（`name@版本`），不用 @latest —— 装的就是
+           面板显示的那个版本。注意它**不会**因此豁免 minimumReleaseAge：门禁在解析
+           之前校验 lockfile，窗口内的版本照样整体中止整个 profile 的安装（豁免只能靠
+           profile 的 minimumReleaseAgeExclude，那张表由 host 半边归并成每包一条）。
+           行内没解析过则现场查 registry。 */
         var specPromise = busyLatest
           ? Promise.resolve(name + "@" + busyLatest)
           : fetchLatest(name)
@@ -734,10 +1006,11 @@ window.__ModuleLoader__.load({
       }
 
       /* 终态落定：回读清单核对真实版本（registry 解析与 pnpm 实际安装可能不一致，
-         如镜像源），再按 kind 决定文案。kind: applied | failed | cancelled | unknown。
+         如镜像源），再按 kind 决定文案。kind: applied | failed | cancelled | cooling
+         | unknown；cooling 只由 settle 的成熟期违规分支给出（meta 带成熟时刻与详情）。
          回读只用 pluginManager.listBundles（pluginInventory 只有 list()，没有
          listBundles）；装完瞬间清单可能短暂不可用，重试 3 次（1.5s 间隔）再下结论。 */
-      function finishOne(name, kind, why) {
+      function finishOne(name, kind, why, meta) {
         var before = busyBefore;
         var latest = busyLatest;
         var pm = pickService(null, "remote.pluginManager");
@@ -749,10 +1022,21 @@ window.__ModuleLoader__.load({
         }
         function judge(ver) {
           if (ver && ver !== before) {
-            setRow(name, { version: ver, state: "current", latest: ver, why: "" });
+            setRow(name, { version: ver, state: "current", latest: ver, why: "", publishedAt: NaN, matureAt: NaN, detail: "" });
+            /* 安装真的落地了：顺手让 host 半边归并豁免表，免得陈旧条遮蔽下一次安装 */
+            normalizeExcludes();
           } else if (kind === "cancelled") {
             /* 取消不是失败：该行仍有新版本，退回可再次更新的状态。 */
             setRow(name, { state: "update", latest: latest, why: "" });
+          } else if (kind === "cooling") {
+            /* 门禁在解析前整体中止了这次安装：落 cooling（不是 fail），也不贴那串长报错 */
+            var m = meta || {};
+            var patch = {
+              state: "cooling", why: "", detail: m.detail || "",
+              publishedAt: m.publishedAt, matureAt: m.matureAt
+            };
+            if (latest || m.version) { patch.latest = latest || m.version; }
+            setRow(name, patch);
           } else if (kind === "failed") {
             setRow(name, { state: "fail", why: why || "更新失败" });
           } else if (kind === "applied" && ver) {
@@ -833,6 +1117,7 @@ window.__ModuleLoader__.load({
           ".rowwrap:last-child{border-bottom:0}" +
           ".row{display:flex;align-items:center;gap:8px;padding:7px 12px}" +
           ".why{padding:0 12px 8px;font-size:12px;line-height:1.45;opacity:.7;word-break:break-word;white-space:pre-wrap}" +
+          ".dtl{margin-top:4px;padding-top:6px;border-top:1px dashed var(--dsw-alias-border-l2,rgba(128,128,128,.28));font-size:11px;opacity:.62}" +
           ".nm{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}" +
           ".ver{opacity:.6;font-size:12px;white-space:nowrap;font-variant-numeric:tabular-nums}" +
           ".tag{font-size:11px;padding:1px 7px;border-radius:999px;white-space:nowrap;" +
@@ -842,6 +1127,7 @@ window.__ModuleLoader__.load({
           ".tag.other{background:rgba(128,128,128,.14);opacity:.85}" +
           ".tag.busy{opacity:.6}" +
           ".tag.error{background:rgba(255,80,80,.14);color:#e07070;border-color:rgba(255,80,80,.28)}" +
+          ".tag.cooling{background:rgba(90,160,255,.16);color:#74b0ff;border-color:rgba(90,160,255,.34)}" +
           ".tag.clickable{cursor:pointer}" +
           ".tag.clickable:hover{filter:brightness(1.15)}" +
           ".allbtn{cursor:pointer;font-size:12px;padding:2px 9px;border-radius:6px;flex:0 0 auto;" +
@@ -915,6 +1201,12 @@ window.__ModuleLoader__.load({
             rows.forEach(function (r) { if (r.state === "update" && queue.indexOf(r.name) < 0 && r.name !== busyName) { enqueue(r.name); } });
             return;
           }
+          if (t.classList.contains("cooling")) {
+            /* 冷静期标签：只展开 / 收起详情，绝不触发安装 */
+            var nm0 = t.getAttribute("data-n");
+            if (nm0) { revealedCooling[nm0] = !revealedCooling[nm0]; paint(); }
+            return;
+          }
           if (t.classList.contains("act")) {
             var nm = t.getAttribute("data-n");
             if (nm) { enqueue(nm); }
@@ -949,6 +1241,7 @@ window.__ModuleLoader__.load({
               r.latest = v || "";
               r.state = v && cmpSemver(v, r.version) > 0 ? "update" : "current";
               emit();
+              if (r.state === "update") { applyCoolingGuess(name); }
             }).catch(function (e) {
               setRow(name, e && e.notFound ? { state: notFoundState(cur), why: String(e.message) } : { state: "error", why: String(e && e.message || e) });
             });
@@ -960,7 +1253,8 @@ window.__ModuleLoader__.load({
       var TAG_TEXT = {
         checking: "比对中 …", current: "已是最新", update: "有新版本",
         local: "本地链接", remote: "Git 直装", unknown: "无法比对", error: "检查失败", queuing: "等待更新",
-        busy: "更新中 …", unchanged: "暂缓更新", unconfirmed: "已发起·未确认", fail: "更新失败"
+        busy: "更新中 …", unchanged: "暂缓更新", unconfirmed: "已发起·未确认", fail: "更新失败",
+        cooling: "冷静期中"
       };
       function tagHtml(r) {
         var cls = "tag other", act = "", title = "";
@@ -972,6 +1266,8 @@ window.__ModuleLoader__.load({
         else if (r.state === "unknown") { title = " title=\"" + esc(r.why || "插件清单未提供已装版本") + "，因此无法与 registry 比对\""; }
         else if (r.state === "queuing") { cls = "tag other cancel clickable"; act = " data-n=\"" + esc(r.name) + "\""; title = " title=\"点击取消排队\""; }
         else if (r.state === "busy") { cls = "tag other cancel clickable"; act = " data-n=\"" + esc(r.name) + "\""; title = " title=\"" + esc(r.why ? r.why + "；" : "") + "点击取消本次更新\""; }
+        /* cooling：不可点击安装（点它必然撞门禁、还会连累整个 profile），只切换详情 */
+        else if (r.state === "cooling") { cls = "tag cooling clickable"; act = " data-n=\"" + esc(r.name) + "\""; title = " title=\"处于供应链冷静期（minimumReleaseAge）；点击展开/收起详情，不会触发安装\""; }
         else if (r.state === "fail") { cls = "tag error act clickable"; act = " data-n=\"" + esc(r.name) + "\""; title = " title=\"" + esc(r.why || "更新失败") + "（点击重试）\""; }
         else if (r.state === "unchanged") { cls = "tag update act clickable"; act = " data-n=\"" + esc(r.name) + "\""; title = " title=\"" + esc(r.why || "") + "（点击重试）\""; }
         else if (r.state === "unconfirmed") { cls = "tag other reverify clickable"; title = " title=\"" + esc(r.why || "") + "（点击重查）\""; }
@@ -987,14 +1283,21 @@ window.__ModuleLoader__.load({
           body = "<div class=\"msg\">" + (checking ? "正在读取插件清单…" : "点上方「重新检查」开始比对") + "</div>";
         } else {
           body = rows.map(function (r) {
-            var showLatest = r.state === "update" || r.state === "unchanged" || r.state === "fail";
+            var showLatest = r.state === "update" || r.state === "unchanged" || r.state === "fail" || r.state === "cooling";
             var ver = r.latest && showLatest ? r.version + " → " + r.latest : r.version;
-            var sub = r.why && (r.state === "fail" || r.state === "unchanged" || r.state === "unconfirmed" || r.state === "error")
-              ? "<div class=\"why\">" + esc(r.why) + "</div>" : "";
+            /* cooling 的副标题是现算的（绝对成熟时刻 + 相对剩余时间），不在 r.why 里 */
+            var why = r.state === "cooling"
+              ? coolingWhyText({ version: r.latest || r.version, windowMs: policyWindowMs, publishedAt: r.publishedAt, matureAt: r.matureAt, nowMs: Date.now() })
+              : r.why;
+            var sub = why && (r.state === "fail" || r.state === "unchanged" || r.state === "unconfirmed" || r.state === "error" || r.state === "cooling")
+              ? "<div class=\"why\">" + esc(why) + "</div>" : "";
+            /* 详情只在点开 cooling 标签后渲染：失败/冷静期的那条完整诊断默认不占第一屏 */
+            var dtl = r.state === "cooling" && revealedCooling[r.name] && r.detail
+              ? "<div class=\"why dtl\">" + esc(r.detail) + "</div>" : "";
             return "<div class=\"rowwrap\"><div class=\"row\">" +
               "<span class=\"nm\" title=\"" + esc(r.name) + "\">" + esc(r.name) + "</span>" +
               "<span class=\"ver\" title=\"" + esc(ver) + "\">" + esc(ver) + "</span>" +
-              tagHtml(r) + "</div>" + sub + "</div>";
+              tagHtml(r) + "</div>" + sub + dtl + "</div>";
           }).join("");
         }
         var html = "<div class=\"hd\"><b>插件更新 · " + (busyName ? "正在更新 " + esc(busyName) + " …" : (checking ? "检查中…" : (rows.length ? upd + " 个插件有新版本" : "插件更新检查"))) + "</b>" +

package/lib/index.js

@@ -1,99 +1,317 @@
-/**
- * dsh-ui-tweaks host half.
- *
- * 挂一条 GET /api/ui-tweaks/local-plugins：返回当前 profile package.json
- * dependencies 里非 registry 直装（link:/file:/git+/github:/http）的包名清单。
- * 浏览器半区的更新面板据此把这些插件标成「本地链接」或「Git 直装」、跳过
- * registry 比对 —— listBundles 不透传安装来源，而「npm 上恰好也发布过」的
- * 非 registry 源（如 @nimoxie/dsh-model-organizer）在客户端侧没有别的办法认。
- *
- * 纯读操作：只读 profile 的 package.json，不改任何东西；仅回环访问放行。
- */
-import { readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const name = "ui-tweaks";
-export const inject = ["webServer"];
-
-const SELF = "@nimoxie/dsh-ui-tweaks";
-const LOCAL_SPEC_RE = /^(link:|file:)/;                 // 本地路径（link:→按包名查 node_modules）
-const REMOTE_SPEC_RE = /^(git[+:@]|github:|git:|http)/; // Git 仓库 / URL 直装
-const LOOPBACK_RE = /^(127\.|::1$|::ffff:127\.)/;
-
-function readJson(p) {
-  try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; }
-}
-
-function hasUs(m) {
-  return !!(m && m.dsh && m.dsh.profile && Array.isArray(m.dsh.profile.bundles) && m.dsh.profile.bundles.includes(SELF));
-}
-
-function findProfileDir() {
-  // ① npm 直装：包物理位于 profile/node_modules 内，向上走必经 profile 根
-  //   （profile 根 package.json 的判据是 dsh.profile.bundles 且包含本插件）。
-  let dir = dirname(dirname(fileURLToPath(import.meta.url)));
-  for (let depth = 0; depth < 8; depth++) {
-    const m = readJson(join(dir, "package.json"));
-    if (hasUs(m)) { return dir; }
-    const parent = dirname(dir);
-    if (parent === dir) { break; }
-    dir = parent;
-  }
-  // ② link: 软链安装：Node 默认把 ESM 模块解析到真实路径，import.meta.url
-  //    指向 profile 外的仓库目录，①必然失败。退回扫描 profiles/*：
-  //    DSH_HOME 环境变量 → 用户主目录默认 .dsh（dsh 未设环境变量时的标准位置）。
-  //    多个 profile 都装了本插件时按 host 进程形态二选一
-  //    （桌面 host 跑在 ELECTRON_RUN_AS_NODE=1 的 Electron Node 下）。
-  const homes = [process.env.DSH_HOME, join(homedir(), ".dsh")].filter(Boolean);
-  let hits = [];
-  for (const home of homes) {
-    try {
-      for (const entry of readdirSync(join(home, "profiles"))) {
-        const dir2 = join(home, "profiles", entry);
-        if (hasUs(readJson(join(dir2, "package.json")))) { hits.push(dir2); }
-      }
-    } catch { /* 该 home 不存在或不可读，试下一个 */ }
-    if (hits.length) { break; }
-  }
-  if (hits.length === 0) { return null; }
-  if (hits.length === 1) { return hits[0]; }
-  const wanted = process.env.ELECTRON_RUN_AS_NODE === "1" ? "desktop" : "web";
-  return hits.find((d) => new RegExp(wanted + "$").test(d)) || hits[0];
-}
-
-export function apply(ctx) {
-  const route = {
-    kind: "exact",
-    path: "/api/ui-tweaks/local-plugins",
-    handler: (req, res) => {
-      const done = (code, body) => {
-        res.writeHead(code, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
-        res.end(body);
-      };
-      try {
-        const addr = String((req.socket && req.socket.remoteAddress) || "");
-        if (!LOOPBACK_RE.test(addr)) { done(403, JSON.stringify({ ok: false, code: "forbidden" })); return; }
-        if (req.method !== "GET") { done(405, JSON.stringify({ ok: false, code: "method not allowed" })); return; }
-        const dir = findProfileDir();
-        const manifest = dir ? readJson(join(dir, "package.json")) : null;
-        const deps = (manifest && manifest.dependencies) || {};
-        const local = [];   // link:/file: —— 本地路径
-        const remote = [];  // git/github/http —— 仓库或 URL 直装
-        for (const [n, spec] of Object.entries(deps)) {
-          const s = String(spec);
-          if (LOCAL_SPEC_RE.test(s)) { local.push(n); }
-          else if (REMOTE_SPEC_RE.test(s)) { remote.push(n); }
-        }
-        done(200, JSON.stringify({ ok: true, local, remote, profile: (manifest && manifest.name) || "" }));
-      } catch (e) {
-        done(500, JSON.stringify({ ok: false, code: String((e && e.message) || e) }));
-      }
-    }
-  };
-  ctx.effect(() => {
-    const dispose = ctx.webServer.register(route);
-    return () => { try { dispose(); } catch {} };
-  }, "ui-tweaks: local-plugins route");
-}
+/**
+ * dsh-ui-tweaks host half.
+ *
+ * 两条回环路由：
+ * - GET  /api/ui-tweaks/local-plugins：返回当前 profile package.json
+ *   dependencies 里非 registry 直装（link:/file:/git+/github:/http）的包名清单。
+ *   浏览器半区的更新面板据此把这些插件标成「本地链接」或「Git 直装」、跳过
+ *   registry 比对 —— listBundles 不透传安装来源，而「npm 上恰好也发布过」的
+ *   非 registry 源（如 @nimoxie/dsh-model-organizer）在客户端侧没有别的办法认。
+ * - POST /api/ui-tweaks/normalize-excludes：手动触发一次下面的归并，回
+ *   {ok, changed, kept, removed}；插件加载时也会静默跑一次。
+ *
+ * 写操作（全文件只此一处）：归并 profile 的 pnpm-workspace.yaml 里
+ * minimumReleaseAgeExclude 序列。为什么必须收敛：
+ * DSH 给自带 pnpm 11.7.0 注入供应链策略 minimumReleaseAge=1440（分钟，不在任何配置文件里），
+ * pnpm 在解析之前先校验磁盘上现有的 lockfile，任一 entry 未成熟即整体中止安装并报
+ * ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION（exit 1）；而该白名单按包名匹配，同一个包名出现
+ * 多条时「文件中靠前的那条生效」。于是同包重复/陈旧条目会静默抵消掉真正需要的豁免
+ * （例：dsh-context@0.61.0 陈旧条排在 dsh-context@0.69.0 前面，后者从未生效），
+ * 之后 profile 的每一次安装都失败；而一次成功的「未成熟版本」安装又会把新条目追加到
+ * 末尾，让旧条重新变成靠前那条 —— 紧接着的下一次安装立刻 FAIL。所以这必须常态化自动收敛。
+ * 安全约束：只改这一个序列，其余字节逐字节保持原样；写前备份
+ * pnpm-workspace.yaml.bak-<时间戳>；同目录临时文件 + renameSync 原子替换；写后重读校验；
+ * 无变化不写文件；幂等；结果永远是原条目的子集（绝不比现状更宽松）；陈旧剪除只针对
+ * profile dependencies 里的受管包名，重复折叠适用于任何包名；裸名（不带 @版本）豁免该包
+ * 全部版本，永不视为陈旧。整个过程不外抛异常。仅回环访问放行。
+ */
+import { readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const name = "ui-tweaks";
+export const inject = ["webServer"];
+
+const SELF = "@nimoxie/dsh-ui-tweaks";
+const LOCAL_SPEC_RE = /^(link:|file:)/;                 // 本地路径（link:→按包名查 node_modules）
+const REMOTE_SPEC_RE = /^(git[+:@]|github:|git:|http)/; // Git 仓库 / URL 直装
+const LOOPBACK_RE = /^(127\.|::1$|::ffff:127\.)/;
+const EXCLUDE_KEY = "minimumReleaseAgeExclude";
+const WORKSPACE_FILE = "pnpm-workspace.yaml";
+
+function readJson(p) {
+  try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function hasUs(m) {
+  return !!(m && m.dsh && m.dsh.profile && Array.isArray(m.dsh.profile.bundles) && m.dsh.profile.bundles.includes(SELF));
+}
+
+function findProfileDir() {
+  // ① npm 直装：包物理位于 profile/node_modules 内，向上走必经 profile 根
+  //   （profile 根 package.json 的判据是 dsh.profile.bundles 且包含本插件）。
+  let dir = dirname(dirname(fileURLToPath(import.meta.url)));
+  for (let depth = 0; depth < 8; depth++) {
+    const m = readJson(join(dir, "package.json"));
+    if (hasUs(m)) { return dir; }
+    const parent = dirname(dir);
+    if (parent === dir) { break; }
+    dir = parent;
+  }
+  // ② link: 软链安装：Node 默认把 ESM 模块解析到真实路径，import.meta.url
+  //    指向 profile 外的仓库目录，①必然失败。退回扫描 profiles/*：
+  //    DSH_HOME 环境变量 → 用户主目录默认 .dsh（dsh 未设环境变量时的标准位置）。
+  //    多个 profile 都装了本插件时按 host 进程形态二选一
+  //    （桌面 host 跑在 ELECTRON_RUN_AS_NODE=1 的 Electron Node 下）。
+  const homes = [process.env.DSH_HOME, join(homedir(), ".dsh")].filter(Boolean);
+  let hits = [];
+  for (const home of homes) {
+    try {
+      for (const entry of readdirSync(join(home, "profiles"))) {
+        const dir2 = join(home, "profiles", entry);
+        if (hasUs(readJson(join(dir2, "package.json")))) { hits.push(dir2); }
+      }
+    } catch { /* 该 home 不存在或不可读，试下一个 */ }
+    if (hits.length) { break; }
+  }
+  if (hits.length === 0) { return null; }
+  if (hits.length === 1) { return hits[0]; }
+  const wanted = process.env.ELECTRON_RUN_AS_NODE === "1" ? "desktop" : "web";
+  return hits.find((d) => new RegExp(wanted + "$").test(d)) || hits[0];
+}
+
+// ---------- minimumReleaseAgeExclude 归并 ----------
+
+/** yaml 标量去引号：'x' / "x" → x，其余原样 */
+function unquote(s) {
+  const m = /^(['"])([\s\S]*)\1$/.exec(s);
+  return m ? m[2] : s;
+}
+
+/** 条目原文 → 裸值：去空白、去行尾注释、去引号 */
+function entryValue(raw) {
+  const s = String(raw).trim();
+  const quoted = unquote(s);
+  if (quoted !== s) { return quoted; }      // 整段就是带引号的标量
+  const i = s.indexOf(" #");                // 裸标量后跟注释
+  return i < 0 ? s : unquote(s.slice(0, i).trim());
+}
+
+/** 版本键里的 'name@version' → {name, version}（scoped 与裸名都要能分） */
+function splitNameVersion(s) {
+  const at = s.startsWith("@") ? s.indexOf("@", 1) : s.indexOf("@");
+  if (at <= 0) { return { name: s, version: null }; }
+  return { name: s.slice(0, at), version: s.slice(at + 1) || null };
+}
+
+/** '1.2.3(peer@x)' → '1.2.3'；link:/file:/workspace: 协议没有版本概念 → undefined */
+function cleanVersion(v) {
+  const s = String(v || "").trim().replace(/\([\s\S]*$/, "").replace(/^['"]|['"]$/g, "");
+  if (!s || /^(link:|file:|workspace:)/.test(s)) { return undefined; }
+  return s;
+}
+
+/**
+ * 从 pnpm-lock.yaml 取「包名 → 锁定版本」。
+ * importers 段（profile 自己的 dependencies）优先，packages 段兜底；
+ * link:/file:/workspace: 这类没有发布版本的条目不进表（查询得到 undefined = 未锁定）。
+ */
+function parseLockVersions(text) {
+  const fromImporters = new Map();
+  const fromPackages = new Map();
+  let section = null;
+  let inImporterDeps = false;
+  let pendingName = null;
+  for (const line of String(text).split(/\r?\n/)) {
+    const top = /^([A-Za-z][\w-]*):\s*$/.exec(line);   // 缩进 0 的顶层段落
+    if (top) { section = top[1]; inImporterDeps = false; pendingName = null; continue; }
+    if (section === "importers") {
+      if (/^ {4}(?:dependencies|devDependencies|optionalDependencies):\s*$/.test(line)) { inImporterDeps = true; continue; }
+      if (/^ {2,4}\S/.test(line)) { inImporterDeps = false; continue; }   // 换 importer / 换字段
+      if (inImporterDeps) {
+        const k = /^ {6}(\S[\s\S]*?):\s*$/.exec(line);
+        if (k) { pendingName = unquote(k[1]); continue; }
+        const v = /^ {8}version:\s*(\S+)\s*$/.exec(line);
+        if (v && pendingName) {
+          const ver = cleanVersion(v[1]);
+          if (ver) { fromImporters.set(pendingName, ver); }
+          pendingName = null;
+          continue;
+        }
+      }
+    } else if (section === "packages") {
+      const k = /^ {2}(\S[\s\S]*?):\s*$/.exec(line);      // 'name@version':
+      if (k) {
+        const p = splitNameVersion(unquote(k[1]));
+        const ver = p.version && cleanVersion(p.version);
+        if (ver) { fromPackages.set(p.name, ver); }
+      }
+    }
+  }
+  const out = new Map(fromPackages);
+  for (const [k, v] of fromImporters) { out.set(k, v); }
+  return out;
+}
+
+/**
+ * 归并 profile pnpm-workspace.yaml 的 minimumReleaseAgeExclude 序列。
+ * 只重排这一段的条目行，其余字节逐字节保留；无变化不写盘。
+ * 任何异常都被吞掉，返回 {ok:false, code}。
+ */
+export function normalizeReleaseAgeExcludes() {
+  let backup = null;
+  try {
+    const dir = findProfileDir();
+    if (!dir) { return { ok: false, code: "profile-not-found" }; }
+    const wsPath = join(dir, WORKSPACE_FILE);
+    let raw;
+    try { raw = readFileSync(wsPath, "utf8"); }
+    catch (e) { return { ok: false, code: "workspace-unreadable: " + String((e && e.code) || e) }; }
+
+    // 受管包名：profile dependencies 的键
+    const manifest = readJson(join(dir, "package.json"));
+    const managed = new Set(Object.keys((manifest && manifest.dependencies) || {}));
+
+    // 锁定版本：lockfile 不可读/不存在时留空表，陈旧剪除据此退化为「无版本可依」
+    let locked = new Map();
+    let lockKnown = false;
+    try { locked = parseLockVersions(readFileSync(join(dir, "pnpm-lock.yaml"), "utf8")); lockKnown = true; } catch { /* 无 lockfile */ }
+
+    const lines = String(raw).split(/(?<=\n)/);   // 每行带着自己的换行符，join 即还原
+    const keyRe = new RegExp("^" + EXCLUDE_KEY + "\\s*:\\s*(?:#[\\s\\S]*)?$");
+    let keyLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (keyRe.test(lines[i].replace(/\r?\n$/, ""))) { keyLine = i; break; }
+    }
+    // 没有这个键不是错误：profile 本来就没有待归并的条目（或已被清理干净），按「无变化」回。
+    if (keyLine < 0) { return { ok: true, changed: false, kept: [], removed: [], path: wsPath }; }
+
+    const entries = [];   // {idx, raw(line), name, version}
+    for (let i = keyLine + 1; i < lines.length; i++) {
+      const body = lines[i].replace(/\r?\n$/, "");
+      const m = /^(\s*)-\s+(\S[\s\S]*)$/.exec(body);
+      if (!m || m[1].length === 0) { break; }   // 序列条目必须缩进，否则该块已结束
+      const value = entryValue(m[2]);
+      const nv = splitNameVersion(value);
+      entries.push({ idx: i, line: lines[i], value, name: nv.name, version: nv.version });
+    }
+    // 键在但一条条目都没有，同样按「无变化」回（客户端是 fire-and-forget，500 只会变成日志噪声）。
+    if (entries.length === 0) { return { ok: true, changed: false, kept: [], removed: [], path: wsPath }; }
+
+    const groups = new Map();   // name → [entry…]（保序）
+    for (const e of entries) {
+      if (!groups.has(e.name)) { groups.set(e.name, []); }
+      groups.get(e.name).push(e);
+    }
+
+    const keep = new Set();   // 保留的条目行号
+    const removed = [];
+    for (const [pkg, group] of groups) {
+      if (group.length >= 2) {
+        // 重复折叠：优先保留「版本 == lockfile 锁定版本」的那条，否则保留文件中第一条
+        // （与 pnpm「靠前者生效」的现行语义一致，且结果永远是原并集的子集）。
+        const want = locked.get(pkg);
+        const chosen = (want && group.find((e) => e.version === want)) || group[0];
+        keep.add(chosen.idx);
+        for (const e of group) { if (e !== chosen) { removed.push(e.value); } }
+        continue;
+      }
+      const e = group[0];
+      // 陈旧剪除：只碰受管包名；裸名豁免全部版本，永不视为陈旧。
+      // lockfile 整个缺失时不剪除（此时「锁定版本」无从谈起，剪掉受管条可能把
+      // 尚未安装的 profile 卡死 —— 宁可不动，提交集方向也依然安全）。
+      if (lockKnown && managed.has(pkg) && e.version !== null && e.version !== locked.get(pkg)) {
+        removed.push(e.value);
+        continue;
+      }
+      keep.add(e.idx);
+    }
+
+    const entryIdx = new Set(entries.map((e) => e.idx));
+    const keptInOrder = entries.filter((e) => keep.has(e.idx)).map((e) => e.value);
+    const newRaw = lines.filter((line, i) => !entryIdx.has(i) || keep.has(i)).join("");
+
+    if (newRaw === raw) { return { ok: true, changed: false, kept: keptInOrder, removed: [], path: wsPath }; }
+
+    // ① 写前备份（同目录，时间戳后缀）
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    backup = wsPath + ".bak-" + stamp;
+    writeFileSync(backup, raw, "utf8");
+    // ② 原子替换：同目录临时文件 + renameSync
+    const tmp = join(dir, "." + WORKSPACE_FILE + ".tmp-" + process.pid + "-" + Date.now());
+    try {
+      writeFileSync(tmp, newRaw, "utf8");
+      renameSync(tmp, wsPath);
+    } catch (e) {
+      try { unlinkSync(tmp); } catch { /* 临时文件可能未创建 */ }
+      throw e;
+    }
+    // ③ 写后重读校验
+    const after = readFileSync(wsPath, "utf8");
+    if (after !== newRaw) { return { ok: false, code: "verify-mismatch", path: wsPath, backup }; }
+
+    return { ok: true, changed: true, kept: keptInOrder, removed, path: wsPath, backup };
+  } catch (e) {
+    return { ok: false, code: String((e && e.message) || e) };
+  }
+}
+
+export function apply(ctx) {
+  const respond = (res) => (code, body) => {
+    res.writeHead(code, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(body);
+  };
+  const isLoopback = (req) => LOOPBACK_RE.test(String((req.socket && req.socket.remoteAddress) || ""));
+
+  const routes = [
+    {
+      kind: "exact",
+      path: "/api/ui-tweaks/local-plugins",
+      handler: (req, res) => {
+        const done = respond(res);
+        try {
+          if (!isLoopback(req)) { done(403, JSON.stringify({ ok: false, code: "forbidden" })); return; }
+          if (req.method !== "GET") { done(405, JSON.stringify({ ok: false, code: "method not allowed" })); return; }
+          const dir = findProfileDir();
+          const manifest = dir ? readJson(join(dir, "package.json")) : null;
+          const deps = (manifest && manifest.dependencies) || {};
+          const local = [];   // link:/file: —— 本地路径
+          const remote = [];  // git/github/http —— 仓库或 URL 直装
+          for (const [n, spec] of Object.entries(deps)) {
+            const s = String(spec);
+            if (LOCAL_SPEC_RE.test(s)) { local.push(n); }
+            else if (REMOTE_SPEC_RE.test(s)) { remote.push(n); }
+          }
+          done(200, JSON.stringify({ ok: true, local, remote, profile: (manifest && manifest.name) || "" }));
+        } catch (e) {
+          done(500, JSON.stringify({ ok: false, code: String((e && e.message) || e) }));
+        }
+      }
+    },
+    {
+      kind: "exact",
+      path: "/api/ui-tweaks/normalize-excludes",
+      handler: (req, res) => {
+        const done = respond(res);
+        try {
+          if (!isLoopback(req)) { done(403, JSON.stringify({ ok: false, code: "forbidden" })); return; }
+          if (req.method !== "POST") { done(405, JSON.stringify({ ok: false, code: "method not allowed" })); return; }
+          const r = normalizeReleaseAgeExcludes();
+          if (!r.ok) { done(500, JSON.stringify({ ok: false, code: r.code })); return; }
+          done(200, JSON.stringify({ ok: true, changed: r.changed, kept: r.kept, removed: r.removed }));
+        } catch (e) {
+          done(500, JSON.stringify({ ok: false, code: String((e && e.message) || e) }));
+        }
+      }
+    }
+  ];
+
+  ctx.effect(() => {
+    const disposes = routes.map((r) => ctx.webServer.register(r));
+    return () => { for (const d of disposes) { try { d(); } catch { /* 已释放 */ } } };
+  }, "ui-tweaks: loopback routes");
+
+  // 加载时静默收敛一次（fire-and-forget：异常绝不影响插件加载）
+  try { normalizeReleaseAgeExcludes(); } catch { /* 归并自身已吞异常，这里只兜底 */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimoxie/dsh-ui-tweaks",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "dsh Web UI 微调合集：宽表格越界修复、对话区左侧自绘滚动条、插件更新检查面板（不含 dsh 本体）",
   "type": "module",
   "main": "lib/index.js",