dsh-m 0.9.18 → 0.9.20

package/CHANGELOG.md

@@ -8,6 +8,21 @@ The full release history of dsh-m, maintained bilingually: **Chinese first, Engl
 
 ## 中文
 
+### 0.9.20 变更：latest 探测缓存退回纯内存（重启即失效）+ mutation 定向失效（ADR-0006）
+
+- **事故复盘落地（2026-10-03 凌晨）**：0.9.14 起 latest 探测缓存 write-through 落盘、跨重启存活，失效通道只有 TTL 一条——00:22:58 缓存写入后，00:27–01:05 连发四版、01:07 重启 DSH、01:13 重开面板全部吃到陈旧值，卡片与 `dshm_outdated` 双双误报「已是最新」。本次推翻该设计，决策与取舍全文见 `docs/adr/0006-latest-cache-memory-only.md`。
+- **缓存退回纯内存**：latest 探测结果只存内存 Map + TTL（`cacheTtlMin`，默认 60 分钟），**重启即失效**——「发完版重启一下就能看到」重新成立。代价是重启后首轮受限重探（当前页条目、8 并发 + deadline 兜底，TTL 内只付一次）；registry/社区**目录正文**的落盘缓存与 SWR 不受影响，页面骨架照旧秒开。0.9.14 遗留的 `<cacheRoot>/latest/<ns>.json` 惰性文件由探测段一次性 best-effort 清扫。
+- **mutation 定向失效**：install/upgrade/uninstall 事务**成功点**按 itemId 作废该条目全部 registryKey 缓存变体（浏览页键 / 已装页 matched 键 / npm-only 键）——升级后卡片不再出现「已装新版 / 最新旧版」自相矛盾；`dshm_outdated` 对刚升级包诚实。只失效不回写（故意装旧版时回写会伪造 latest=已装）；事务回滚路径零失效；卸载对 github 源条目的 `gh:` 键尽力而为（pkg 名不可逆推 repo，交由 TTL 自然过期）。
+- **不做项留痕**：force 穿透探测缓存与浏览页 GitHub 预算对齐经主人拍板暂缓——前者残余盲区仅「不重启 + TTL 内」窗口，后者对现行全 npm 源精选清单收益为零（ADR-0006 §Considered Options）。
+
+### 0.9.19 变更：供应链等待期「锁文件校验」实证修复——委派前预检 + 全量违规解析 + 账实分裂明示
+
+- **根因（本机 2026-10-03 00:15 实证）**：pnpm 11.7 对 desktop profile 做**锁文件级**供应链校验（`Verifying lockfile against supply-chain policies (180 entries)`），而它给每次成功安装自动追加的 `minimumReleaseAgeExclude` **非 scoped 独立精确条目不被这次校验认可**（`dsh-m@0.9.18` 即被拒；scoped 的 `'@iasiv5/dsh-quota-watch@0.1.13'` 则认可）——装过一个「太新」版本后，**等待期内任何官方包操作都会被这个旁包条目拦死**，与本次目标无关；且校验失败前目标包已被写入 node_modules、官方管理器只回滚 manifest/lockfile → 界面显示新版 active、操作记录却是失败（**「账实分裂」**），下次包操作还会把插件静默回退。
+- **委派前预检（`releaseAgePrecheck`，只读、零文件级红线不破、fail-open）**：npm 源安装/升级在委派官方管理器前，对目标版本与锁内「不被校验认可的独立精确排除条目」逐个核对 registry 发布时刻，任一未满等待期 → 结构化 `release-age-wait` 拒绝（含各自可重试时刻），不再产生半写状态；发布时刻不可得 / 策略不可读 / 命中有效排除条目（包名级、`||` 复合、scoped 独立精确）→ 放行，pnpm 仍是最终执行者。
+- **失败翻译换新（替代 0.9.10 单条解析）**：解析全部违规条目，按「本次目标 vs 锁内旁包」分述发布时刻与可重试时刻——旁包连坐不再被冒充成目标被拦；移除「改用 DSH Web 安装」的失配指引。`DesktopOpsError` 新增结构化 `details`（violations/targetViolating/splitState/blockers）。
+- **账实分裂复读**：等待期失败后复读实装状态，node_modules 已是目标版本而 manifest 仍旧版时，在错误信息中明示「下次包操作会回退到旧版，等待期满重新升级即可对齐」。
+- **接线**：desktop install / self-upgrade 调用点补穿 `profileDir`（升级路径此前已有）。
+
 ### 0.9.18 变更：精选收录 DSH Market + README 重构与变更日志外迁
 
 - **新收录 DSH Market**（npm `dshmarket`，精选 18→19）：三方可视化插件市场——浏览、搜索社区插件并一键安装，主题一键热切换；主桶装机必备、次桶崔添翼精选（`alsoCategories` 次级归属）。文案按收录规范三句式，三方条目不设 `verified`。
@@ -215,6 +230,21 @@ The full release history of dsh-m, maintained bilingually: **Chinese first, Engl
 
 ## English
 
+### Changed in 0.9.20 — latest probe cache back to memory-only (restart invalidates) + mutation-scoped invalidation (ADR-0006)
+
+- **Post-mortem landed (night of 2026-10-03)**: since 0.9.14 the latest-version probe cache was written through to disk and survived restarts, with TTL as the only invalidation channel — after a cache write at 00:22:58, four releases (00:27–01:05), a DSH restart (01:07) and a panel reopen (01:13) all served the stale value; cards and `dshm_outdated` both wrongly reported "up to date". That design is overturned; the full decision record lives in `docs/adr/0006-latest-cache-memory-only.md`.
+- **Memory-only cache**: probe results now live in an in-memory Map + TTL (`cacheTtlMin`, default 60) — **a DSH restart drops them**, so "publish, restart, see the new version" works again. The cost is one bounded re-probe wave on the first open after a restart (current page, 8 workers + deadline cap, paid once per TTL window); the registry/community **catalog body** disk cache and SWR are untouched, so the page skeleton still opens instantly. Leftover inert `latest/<ns>.json` envelopes from 0.9.14 are swept once, best-effort, before the probe segment.
+- **Mutation-scoped invalidation**: on **success** of install/upgrade/uninstall, the entry's cached latest value is invalidated across all registryKey variants (browse key / installed matched key / npm-only key) by itemId — no more "installed new / latest old" self-contradicting cards; `dshm_outdated` is honest about freshly upgraded packages. Invalidate-only, no writeback (a deliberate old-version install would otherwise fabricate latest = installed); rollback paths never invalidate; uninstall invalidates npm keys on a best-effort basis (a `gh:` key cannot be reconstructed from a pkg name and expires via TTL).
+- **Not done, on record**: force passthrough of the probe cache and browse-page GitHub budget alignment were deferred by the owner — the former's residual blind spot is only the "no restart, within TTL" window; the latter has zero benefit for today's all-npm curated list (ADR-0006 §Considered Options).
+
+### Changed in 0.9.19 — supply-chain release-age: pre-delegation gate, full violation parsing, split-state disclosure
+
+- **Root cause (observed 2026-10-03 00:15 on this machine)**: pnpm 11.7 runs a **lockfile-wide** supply-chain verification on desktop installs (`Verifying lockfile against supply-chain policies (180 entries)`), and the standalone exact `minimumReleaseAgeExclude` entries it auto-appends after each successful install are **not honored by that verification when unscoped** (`dsh-m@0.9.18` flagged; scoped `'@iasiv5/dsh-quota-watch@0.1.13'` honored) — so one freshly installed version bricks every package operation for 24h, regardless of the current target. The target package gets written into node_modules before the verification fails while the official manager rolls back only manifest/lockfile → **"split state"**: the UI shows the new version active, the operation record says failed, and the next operation silently downgrades the plugin.
+- **Pre-delegation gate (`releaseAgePrecheck`; read-only, fail-open)**: npm installs/upgrades now check the target version and untrusted lockfile exclude entries against registry publish times **before** delegating; anything inside its waiting window is refused up front as structured `release-age-wait` with per-entry ready times — no more half-written states. Missing publish data / unreadable policy / entries covered by effective selectors (package-level, `||` compound, scoped standalone exact) → proceed; pnpm remains the final enforcer.
+- **Failure translation rewritten** (replacing the 0.9.10 single-match parser): all violations are parsed and reported as "target vs lockfile bystanders" with their own publish times and retry deadlines; the misleading "install via DSH Web instead" hint is gone. `DesktopOpsError` gained structured `details` (violations/targetViolating/splitState/blockers).
+- **Split-state re-read**: after a release-age failure the installed state is re-read; when node_modules already holds the target version while the manifest still records the old one, the error explains the upcoming silent downgrade and how to converge.
+- **Wiring**: desktop install / self-upgrade call sites now pass `profileDir` (upgrade already did).
+
 ### Changed in 0.9.18 — DSH Market added to Curated + README restructure, changelog extracted
 
 - **DSH Market added** (npm `dshmarket`, Curated 18→19): a third-party visual plugin market — browse, search community plugins, and one-click install; one-click live theme switching. Primary bucket Essentials, secondary Cui's Picks (via `alsoCategories`). Copy follows the registry guide; third-party entries carry no `verified` claims.

package/README.en.md

@@ -119,7 +119,7 @@ When the registry is unavailable, `registry` / `search` / `outdated` print the c
   <p><sub>Community catalog · the default landing zone: zone tabs, persistent search, and counted open category chips</sub></p>
 </div>
 
-- **Fetch chain**: dist-tags probe → jsDelivr pinned fetch → npmmirror → unpkg fallback; unchanged versions are not re-fetched, probes are skipped within TTL. On failure it falls back to the runtime cache under `<cache dir>/awesome/` and **explicitly labels it "cached snapshot"** — stale data never masquerades as fresh.
+- **Fetch chain**: dist-tags probe → jsDelivr pinned fetch → npmmirror → unpkg fallback; unchanged versions are not re-fetched, probes are skipped within TTL. Latest-version probes use a memory-only cache: it is dropped on every DSH restart (publish a new version, restart, and the new version shows up), and a plugin's cached entry is invalidated immediately after a successful install/upgrade/uninstall via dsh-m. On failure it falls back to the runtime cache under `<cache dir>/awesome/` and **explicitly labels it "cached snapshot"** — stale data never masquerades as fresh.
 - **Switch & pin**: `communityCatalog` toggle in Settings (default on, live), `communityCatalogPin` to lock the catalog version (exact semver); CLI opt-out with `DSHM_COMMUNITY_CATALOG=0`, pin with `DSHM_COMMUNITY_CATALOG_PIN`.
 - **Categories & search**: community categories are an open set (23 known categories with bilingual labels — Chinese maintained in-repo as the single source of truth, English from the upstream catalog, served per UI language); search runs a relevance-weighted pipeline (Chinese + English); the community zone offers a sort switch (downloads/stars/added × asc/desc, default downloads-desc; missing downloads ≠ zero downloads).
 - **Install semantics**: community entries go through the same install path as curated entries (npm exact version / GitHub pinned commit SHA); the browse page probes npm entries only — GitHub entries are not probed at page level (anonymous 60 req/h quota is uncontrollable).

package/README.md

@@ -119,7 +119,7 @@ dshm restart --yes
   <p><sub>社区清单 · 默认落地分区：分区 tabs、常驻搜索与带计数的开放分类 chips</sub></p>
 </div>
 
-- **数据获取**：dist-tags 探测最新版本 → jsDelivr 按精确版本直取 → npmmirror → unpkg 三线路兜底；版本未变不重拉正文，TTL 内跳过探测。失败回落 `<缓存目录>/awesome/` 运行时缓存先展示（先回缓存、后台自愈）——过期数据绝不冒充最新；缓存状态（缓存快照/目录版本/获取线路/更新时间）在**设置页**可见，浏览页不打扰。
+- **数据获取**：dist-tags 探测最新版本 → jsDelivr 按精确版本直取 → npmmirror → unpkg 三线路兜底；版本未变不重拉正文，TTL 内跳过探测。「最新版本」探测结果为纯内存缓存：**重启 DSH 即失效**（发版后重启即可看到新版本），经 dsh-m 安装/升级/卸载成功后该条目缓存立即作废。失败回落 `<缓存目录>/awesome/` 运行时缓存先展示（先回缓存、后台自愈）——过期数据绝不冒充最新；缓存状态（缓存快照/目录版本/获取线路/更新时间）在**设置页**可见，浏览页不打扰。
 - **开关与锁定**：设置页 `communityCatalog` 开关（默认开，live 生效）、`communityCatalogPin` 可锁定目录版本（精确 semver）；CLI 用 `DSHM_COMMUNITY_CATALOG=0` 退出、`DSHM_COMMUNITY_CATALOG_PIN` 锁版本。
 - **分类与搜索**：社区分类是开放集（已知 23 个分类带中英双语标签：中文由包内单一事实源维护、英文取上游目录，按界面语言下发）；搜索走相关性加权管线（中英文双匹配）；社区区排序可切（下载量/Star/收录日期 × 升降，默认下载量降序，无下载量 ≠ 0 下载）。
 - **安装语义**：社区条目与精选条目走同一安装链路（npm 锁精确版本 / GitHub 锁 commit SHA）；市场浏览页只对 npm 条目做更新探测，GitHub 条目不做页面级探测（匿名配额 60 次/小时不可控）。

package/docs/DESIGN.md

@@ -21,7 +21,7 @@
 - **严格 v1 schema**：顶层只允许 `version/plugins`，条目只允许 `id/name/description/category/tags/source/npm/github/homepage/icon`；未知字段、非法 ID/npm/GitHub/URL、重复 ID/tag、字段超限、`plugins` 超过 1,000 条均拒绝整份清单（不截断、不部分加载）；超过 200 条提示性能边界。
 - **缓存模型**：cache 按 namespace 分目录（Host 与 Agent tools 用 `host/`，独立 CLI 用 `cli/`，互不删除），按带算法版本的 cacheKey 分文件（`CacheFile v2`：原子临时文件 + fsync + rename，0700/0600，symlink 拒写，同 key 进程内写锁）。**候选验证只写候选 cache，绝不 prune 旧源**；settings 写入成功后才 `commitActiveSource`：先原子写 accepted-source metadata（`host/active-source.json`，仅 Host），再清理非当前 custom cache；metadata 失败不 prune、prune 失败保留旧 cache，均只降级为 warning，不撤销已生效的配置。切换后只保留默认缓存与当前 custom 缓存。
 - **统一安全 HTTP**：所有 JSON/text/HEAD 请求共享同一 primitive——手动重定向（每跳校验协议、最多 3 跳、循环检测、signal 传播、返回最终 URL）+ 响应大小上限 + 超时。
-- **秒开缓存语义（0.9.14 SWR）**：`loadRegistry` 与社区获取链的 TTL 过期不再同步等网络——磁盘缓存存在即**先回 stale**（registry `source='default-cache'`、社区 `status='stale'` 既有契约；stale 状态由设置页社区卡承接，市场页不提示临时缓存状态——0.9.15 修订），后台**单飞**刷新写回 cache（同 key 进行中复用；不接调用者 signal，后台自愈不被请求 abort 腰斩；`force`/candidate/显式下载三路径不经 SWR）。默认双线路**粘性**：`loadDefaultChain` 读 cache 记录的上次成功 `source` 排序线路（稳定排序，cache 缺失 = 原序，force 同样生效）。社区 bg 自愈是 force flight——**不走同版本短路**（`if (!opts.force)` 守卫），每 TTL 至多全量重拉一次正文（同步路径的短路优化保留）。页条目 latest 探测缓存整体迁入 `latest-cache.ts`：内存 Map + `<cacheRoot>/latest/<ns>.json` 信封 write-through（`latest/` 在 nsDir 之外，规避 `pruneCaches` 顶层 `*.json` 清扫；懒 seed、损坏/版本不符整弃、24h 硬上限淘汰），跨服务重启存活。客户端默认首页响应存 localStorage（10min TTL、双 zone 分键、读侧再过 normalize 收敛）——面板打开先渲染快照后 background 换新。
+- **秒开缓存语义（0.9.14 SWR）**：`loadRegistry` 与社区获取链的 TTL 过期不再同步等网络——磁盘缓存存在即**先回 stale**（registry `source='default-cache'`、社区 `status='stale'` 既有契约；stale 状态由设置页社区卡承接，市场页不提示临时缓存状态——0.9.15 修订），后台**单飞**刷新写回 cache（同 key 进行中复用；不接调用者 signal，后台自愈不被请求 abort 腰斩；`force`/candidate/显式下载三路径不经 SWR）。默认双线路**粘性**：`loadDefaultChain` 读 cache 记录的上次成功 `source` 排序线路（稳定排序，cache 缺失 = 原序，force 同样生效）。社区 bg 自愈是 force flight——**不走同版本短路**（`if (!opts.force)` 守卫），每 TTL 至多全量重拉一次正文（同步路径的短路优化保留）。页条目 latest 探测缓存为 `latest-cache.ts` 的**纯内存 Map + TTL**（0.9.20 ADR-0006，推翻 0.9.14 的「磁盘信封 write-through + 懒 seed、跨服务重启存活」——2026-10-03 事故实证发版窗口内重启/重开面板全吃陈旧值，重启即失效回归为特性；install/upgrade/uninstall 成功点由 market.ts 按 itemId 定向作废该条目全部 registryKey 变体，只失效不回写；0.9.14 遗留 `<cacheRoot>/latest/<ns>.json` 惰性文件由探测段一次性 best-effort 清扫，`latest/` 在 nsDir 之外、不受 `pruneCaches` 清扫的不变量不变）。客户端默认首页响应存 localStorage（10min TTL、双 zone 分键、读侧再过 normalize 收敛）——面板打开先渲染快照后 background 换新。
 - **live 语义**：registry 地址是 live 设置，应用成功即时生效（无需重启）；只有**首次部署新 Host 代码**需要一次用户确认后的 DSH Web 重启。`timeoutMs`/`cacheTtlMin` 亦为 live 读取；agent 框架注册时的静态工具 deadline 不承诺热更新。
 
 ### 2.2 Schema（v1 定稿，严格校验）

package/lib/core/host-api.js

@@ -277,6 +277,7 @@ export function createApiDispatcher(ctx) {
                         const managed = await d.desktopInstall(ctx.pkg.name, cfg(), {
                             namespace: 'host',
                             profile: profile.name,
+                            profileDir: profile.dir,
                             signal,
                         }, { getService: d.getService, ensureService: d.ensureService });
                         if ('needsBuildApproval' in managed) {
@@ -417,6 +418,7 @@ export function createApiDispatcher(ctx) {
                                 forceIncompatible: boolArg(body.forceIncompatible),
                                 namespace: 'host',
                                 profile: profile.name,
+                                profileDir: profile.dir,
                                 signal,
                             }, { getService: d.getService, ensureService: d.ensureService })) };
                         break;

package/lib/core/latest-cache.js

@@ -1,23 +1,29 @@
 /**
- * 0.9.14 Task 4a：latest 探测缓存的唯一 owner——内存 Map + 磁盘信封层（write-through）。
- * 磁盘文件 `<cacheRoot(profile)>/latest/<namespace>.json`：置于 nsDir 之外——registry.ts
- * pruneCaches 只清扫 `<ns>/` 顶层 *.json（keep 集不含 latest），放 nsDir 内会被每次
- * registry 刷新成功后的 prune 删除。信封 { version, namespace, entries }；损坏/版本不符
- * 整文件弃；全部磁盘操作静默失败（缓存是优化不是功能）。Task 4b 由 market.ts 接线
- * （探测段前 ensureLatestCacheSeeded + writeLatestCache write-through 迁移）。
+ * 0.9.20：latest 探测缓存的唯一 owner——**纯内存 Map + TTL**（ADR-0006）。
+ * 设计立场：缓存是优化不是功能；「重启即失效」是特性而非缺陷。0.9.14 的磁盘信封层
+ * （write-through 落盘 + 懒 seed，跨重启存活）在 2026-10-03 事故中被证伪为负债：
+ * 发版窗口内重启/重开面板全部吃到陈旧 latest（唯一失效通道只剩 TTL），卡片与
+ * `dshm_outdated` 双双误报「已是最新」。故磁盘层整体退役——重启变回可靠逃生门，
+ * 代价是重启后首轮受限重探（8 并发 + deadline 兜底，TTL 内只付一次）。
+ * 0.9.14 遗留的 `<cacheRoot>/latest/<ns>.json` 惰性文件由 ensureLatestCacheSwept
+ * 在探测段一次性 best-effort 清扫（每 (namespace,profile) 记忆化，失败静默）。
+ * mutation 协作（0.9.20 ①）：install/upgrade/uninstall 成功后由 market.ts 调
+ * invalidateLatestCache 按 itemId 定向作废（只失效不回写：故意装旧版时回写会伪造
+ * latest=已装版本；registry 真值交给下一次探测）。
  */
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { WEB_PROFILE, cacheRoot } from './env.js';
-export const LATEST_CACHE_VERSION = 1;
 const latestCache = new Map();
 const LATEST_CACHE_MAX = 5000;
-/** seed 硬上限淘汰窗口：超过 24h 的条目不再灌内存（write/seed 双侧一致） */
-const SEED_MAX_AGE_MS = 24 * 60 * 60_000;
+/** 缓存键第三段（itemId）：浏览页键 / 已装页 matched 键 / npm-only 键共用同一尾段，定向失效按它匹配。 */
+export function latestItemId(item) {
+    return item.source === 'npm' && item.npm ? `npm:${item.npm}` : item.github ? `gh:${item.github}` : item.id;
+}
 export function latestCacheKey(namespace, registryKey, item) {
-    const id = item.source === 'npm' && item.npm ? `npm:${item.npm}` : item.github ? `gh:${item.github}` : item.id;
-    return `${namespace}|${registryKey}|${id}`;
+    return `${namespace}|${registryKey}|${latestItemId(item)}`;
 }
+/** TTL 过期即从内存删除条目并返回 null（过期值不复活、不外泄；不得以 ttlMin=0 当「force 穿透」用——会先删旧值）。 */
 export function readLatestCache(key, ttlMin) {
     const entry = latestCache.get(key);
     if (!entry)
@@ -28,112 +34,48 @@ export function readLatestCache(key, ttlMin) {
     }
     return entry.value;
 }
-function latestDir(profile) {
-    return join(cacheRoot(profile), 'latest');
-}
-function latestFile(namespace, profile) {
-    return join(latestDir(profile), `${namespace}.json`);
-}
-let persistChain = Promise.resolve();
-/** 入队时快照单条（key+entry）：flush 晚于内存 reset 也不丢数据；串行链防并发读改写互相覆盖。 */
-function queuePersist(key, namespace, profile, entry) {
-    persistChain = persistChain.then(() => persistEnvelope(key, namespace, profile, entry)).catch(() => undefined);
-}
-async function persistEnvelope(key, namespace, profile, entry) {
-    let entries = {};
-    try {
-        const parsed = JSON.parse(await readFile(latestFile(namespace, profile), 'utf8'));
-        if (parsed && typeof parsed === 'object' &&
-            parsed.version === LATEST_CACHE_VERSION && parsed.namespace === namespace &&
-            parsed.entries && typeof parsed.entries === 'object') {
-            entries = parsed.entries;
-        }
-    }
-    catch {
-        // 无/损坏信封 → 从本条重建（静默）
-    }
-    const floor = Date.now() - SEED_MAX_AGE_MS;
-    for (const k of Object.keys(entries)) {
-        const e = entries[k];
-        if (!e || typeof e !== 'object' || typeof e.at !== 'number' || !Number.isFinite(e.at) || e.at < floor)
-            delete entries[k];
-    }
-    entries[key] = entry;
-    const envelope = { version: LATEST_CACHE_VERSION, namespace, entries };
-    await mkdir(latestDir(profile), { recursive: true });
-    const file = latestFile(namespace, profile);
-    const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile(tmp, JSON.stringify(envelope));
-    await rename(tmp, file);
-}
-/** 内存 set + write-through：ns 自 key 首段 `|` 前缀解析定位 `<ns>.json` 信封；profile 缺省 web（0.9.0 双 profile 段约定，调用方可显式传）。 */
-export function writeLatestCache(key, value, profile = WEB_PROFILE) {
+/** 内存 set（超上限淘汰最旧）；纯内存，无任何落盘。 */
+export function writeLatestCache(key, value) {
     if (latestCache.size >= LATEST_CACHE_MAX) {
         const oldest = latestCache.keys().next().value;
         if (oldest !== undefined)
             latestCache.delete(oldest);
     }
     latestCache.set(key, { at: Date.now(), value });
-    const ns = key.split('|', 1)[0];
-    if (ns !== 'host' && ns !== 'cli')
-        return;
-    const entry = latestCache.get(key);
-    if (!entry)
-        return;
-    queuePersist(key, ns, profile, entry);
 }
-// ---------- 懒 seed（每 (namespace,profile) 记忆化一次） ----------
-const seeded = new Map();
-export async function ensureLatestCacheSeeded(opts = {}) {
+/**
+ * 0.9.20 ①：mutation 成功后的定向失效——按 itemId 尾段作废该条目在指定 namespace 下的
+ * 全部 registryKey 变体（浏览页键、已装页 matched 键、npm-only 键共用同一 itemId）。
+ * 返回删除条数（测试断言用）。
+ */
+export function invalidateLatestCache(namespace, itemId) {
+    const prefix = `${namespace}|`;
+    const suffix = `|${itemId}`;
+    let removed = 0;
+    for (const key of [...latestCache.keys()]) {
+        if (key.startsWith(prefix) && key.endsWith(suffix)) {
+            latestCache.delete(key);
+            removed += 1;
+        }
+    }
+    return removed;
+}
+// ---------- 0.9.14 遗留磁盘信封的一次性清扫（ADR-0006） ----------
+const swept = new Map();
+/** 探测段前调用：删除遗留 `<cacheRoot>/latest/<ns>.json`（退役后的惰性文件，删失败静默）；每 (namespace,profile) 记忆化一次。 */
+export async function ensureLatestCacheSwept(opts = {}) {
     const namespace = opts.namespace ?? 'host';
     const profile = opts.profile ?? WEB_PROFILE;
     const memoKey = `${namespace}§${profile}`;
-    let task = seeded.get(memoKey);
+    let task = swept.get(memoKey);
     if (!task) {
-        task = (async () => {
-            await persistChain.catch(() => undefined); // 先排空 write-through 队列（写→reset→seed 顺序亦确定成立）
-            await seedFromDisk(namespace, profile);
-        })().catch(() => undefined);
-        seeded.set(memoKey, task);
+        task = rm(join(cacheRoot(profile), 'latest', `${namespace}.json`), { force: true }).catch(() => undefined);
+        swept.set(memoKey, task);
     }
     await task;
 }
-async function seedFromDisk(namespace, profile) {
-    let raw;
-    try {
-        raw = await readFile(latestFile(namespace, profile), 'utf8');
-    }
-    catch {
-        return; // 无信封 = 首次运行；静默
-    }
-    let envelope;
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object')
-            return;
-        if (parsed.version !== LATEST_CACHE_VERSION || parsed.namespace !== namespace)
-            return;
-        if (!parsed.entries || typeof parsed.entries !== 'object')
-            return;
-        envelope = parsed;
-    }
-    catch {
-        return; // 损坏整文件弃（静默，行为退化为现状探测重放）
-    }
-    const floor = Date.now() - SEED_MAX_AGE_MS;
-    for (const [key, entry] of Object.entries(envelope.entries)) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        if (typeof entry.at !== 'number' || !Number.isFinite(entry.at) || entry.at < floor)
-            continue;
-        if (!entry.value || typeof entry.value !== 'object')
-            continue;
-        if (!latestCache.has(key))
-            latestCache.set(key, entry);
-    }
-}
-/** 测试钩子：清内存 Map + seed 记忆化（dsh-version.ts resetDshVersionCacheForTest 同款先例）。 */
+/** 测试钩子：清内存 Map + 清扫记忆化（dsh-version.ts resetDshVersionCacheForTest 同款先例）。 */
 export function resetLatestCacheForTest() {
     latestCache.clear();
-    seeded.clear();
+    swept.clear();
 }

package/lib/core/market.js

@@ -23,7 +23,7 @@ import { adaptCommunityCatalog } from './community-adapter.js';
 import { normalizeSearchText, relevanceScore, tokenizeSearchText } from './search-relevance.js';
 import { GithubBudgetExhaustedError, createGithubRequestBudget, isExactVersion } from './versions.js';
 import { HttpError } from './httpx.js';
-import { ensureLatestCacheSeeded, latestCacheKey, readLatestCache, writeLatestCache } from './latest-cache.js';
+import { ensureLatestCacheSwept, invalidateLatestCache, latestCacheKey, latestItemId, readLatestCache, writeLatestCache } from './latest-cache.js';
 import { verifyInstalledAdditions } from './install-guard.js';
 import { fetchTextLimited } from './httpx.js';
 import { githubLatestTag as defaultGithubLatestTag, isNewerVersion, npmLatest as defaultNpmLatest, npmVersion, } from './versions.js';
@@ -139,6 +139,13 @@ function deadlineRace(task, ms) {
         });
     });
 }
+// ---------- latest TTL cache ----------
+// 0.9.20：纯内存 TTL 缓存（ADR-0006，推翻 0.9.14 的落盘跨重启存活——重启即失效是特性）；
+// mutation 成功后的定向失效走 invalidateLatestForEntry（只失效不回写）。
+/** 0.9.20 ①：install/upgrade/uninstall 成功点调用的定向失效——registry 真值交给下一次探测。 */
+function invalidateLatestForEntry(namespace, entry) {
+    invalidateLatestCache(namespace ?? 'host', latestItemId(entry));
+}
 function probeTask(item, deps, timeoutMs, signal) {
     if (item.source === 'npm' && item.npm) {
         return deps.npmLatest(item.npm, timeoutMs, signal).then((r) => ({ version: r.version }));
@@ -509,8 +516,8 @@ export async function listMarket(cfg = {}, opts = {}, deps = {}) {
     let latestComplete = true;
     let latestTimedOut = false;
     if (withLatest && items.length > 0) {
-        // 0.9.14：latest 探测缓存已落盘——探测段前装载/排空磁盘信封（重启后零重放）
-        await ensureLatestCacheSeeded({ namespace, profile: opts.profile });
+        // 0.9.20：latest 缓存纯内存（ADR-0006）——探测段前仅一次性清扫 0.9.14 遗留磁盘信封
+        await ensureLatestCacheSwept({ namespace, profile: opts.profile });
         // 先吃 cache 命中
         const ttlMin = Math.max(0, cfg.cacheTtlMin ?? 60);
         for (const item of items) {
@@ -540,7 +547,7 @@ export async function listMarket(cfg = {}, opts = {}, deps = {}) {
                     const outcome = await probeWithBudget(task, perBudget, signal);
                     if (outcome.ok && outcome.value) {
                         applyProbe(item, outcome.value);
-                        writeLatestCache(latestCacheKey(namespace, loaded.configuredAddress, item), outcome.value, opts.profile);
+                        writeLatestCache(latestCacheKey(namespace, loaded.configuredAddress, item), outcome.value);
                     }
                     else if (outcome.timeout) {
                         item.latestError = '更新检查未完成：超时';
@@ -629,9 +636,9 @@ export async function listInstalledWithMeta(cfg = {}, opts = {}, deps = {}) {
     }
     const registryState = stateOf(loaded);
     matchInstalled(items, community.merged);
-    // 0.9.14：latest 探测缓存已落盘——探测段前装载/排空磁盘信封
-    await ensureLatestCacheSeeded({ namespace, profile: opts.profile });
-    await probeLatest(items, { merged: community.merged, registryAddress: loaded.configuredAddress, ttlMin: Math.max(0, cfg.cacheTtlMin ?? 60) }, d, { namespace, signal, githubBudget, remaining, timeoutMs: cfg.timeoutMs ?? 20_000, profile: opts.profile });
+    // 0.9.20：latest 缓存纯内存（ADR-0006）——探测段前仅一次性清扫 0.9.14 遗留磁盘信封
+    await ensureLatestCacheSwept({ namespace, profile: opts.profile });
+    await probeLatest(items, { merged: community.merged, registryAddress: loaded.configuredAddress, ttlMin: Math.max(0, cfg.cacheTtlMin ?? 60) }, d, { namespace, signal, githubBudget, remaining, timeoutMs: cfg.timeoutMs ?? 20_000 });
     return { items, others: installed.others, profileDir: installed.profileDir, registryState, community: community.summary };
 }
 /** matching（主+社区合并条目）：命中主条目或社区条目都写 registryId；社区命中再标 community。 */
@@ -685,7 +692,7 @@ async function probeLatest(items, ctx, d, rt) {
                     }
                     if (value) {
                         applyProbe(item, value);
-                        writeLatestCache(cacheKey, value, rt.profile);
+                        writeLatestCache(cacheKey, value);
                     }
                 }
                 catch (err) {
@@ -1087,6 +1094,8 @@ async function installEntryLocked(entry, cfg = {}, opts = {}, deps) {
             ...(prior.kind === 'dependency' ? { priorPkgs: [pkg] } : {}),
         });
         if (guard.unavailable.length > 0) {
+            // 0.9.20 ①：事务已 committed（守卫不可定 fail-open 亦是成功态）→ 定向作废该条目 latest 缓存
+            invalidateLatestForEntry(opts.namespace, entry);
             return {
                 id: entry.id,
                 pkg: result.pkg ?? pkg,
@@ -1118,6 +1127,8 @@ async function installEntryLocked(entry, cfg = {}, opts = {}, deps) {
             });
         }
         const notes = result.healActions.map((h) => h.note).filter((n) => n !== '');
+        // 0.9.20 ①：安装成功 → 定向作废该条目 latest 缓存（只失效不回写，ADR-0006）
+        invalidateLatestForEntry(opts.namespace, entry);
         return {
             id: entry.id,
             pkg: result.pkg ?? pkg,
@@ -1192,6 +1203,8 @@ async function installEntryLocked(entry, cfg = {}, opts = {}, deps) {
             ...(prior.kind === 'dependency' ? { priorPkgs: [realKey] } : {}),
         });
         if (guard.unavailable.length > 0) {
+            // 0.9.20 ①：事务已 committed（守卫不可定 fail-open 亦是成功态）→ 定向作废该条目 latest 缓存
+            invalidateLatestForEntry(opts.namespace, entry);
             const notes = result.healActions.map((h) => h.note).filter((n) => n !== '');
             return {
                 id: entry.id,
@@ -1222,6 +1235,8 @@ async function installEntryLocked(entry, cfg = {}, opts = {}, deps) {
             });
         }
         const notes = result.healActions.map((h) => h.note).filter((n) => n !== '');
+        // 0.9.20 ①：安装成功 → 定向作废该条目 latest 缓存（只失效不回写，ADR-0006）
+        invalidateLatestForEntry(opts.namespace, entry);
         return {
             id: entry.id,
             pkg: realKey,
@@ -1251,6 +1266,9 @@ async function uninstallPluginLocked(pkg, _cfg = {}, opts = {}, deps = {}) {
     const result = await runProfileTransaction({ kind: 'uninstall', pkg, signal: opts.signal }, deps.transaction ?? {});
     if (!result.ok)
         throw new TransactionError(result);
+    // 0.9.20 ①：卸载成功 → 尽力作废 npm-only 键（github 条目的 gh: 键无法由 pkg 名重构，
+    // 交由 TTL 自然过期——卸载后已装列表无此条目，不存在「已装/最新」自相矛盾场景）
+    invalidateLatestCache(opts.namespace ?? 'host', `npm:${pkg}`);
     const orphaned = result.orphanedPatchFiles ?? [];
     const leftovers = [...new Set([...leftoverCandidates(pkg), ...orphaned])];
     return {

package/lib/core/profile-ops.js

@@ -14,6 +14,9 @@
  *   重试把 pending 名单原样传回 `approvedBuilds`（键格式由官方管理器自己写），
  *   dsh-m 绝不直接编辑 desktop profile 的 pnpm-workspace.yaml，绝不全量放行；
  * - 成功判定 = 官方结果无 error + `listBundles()` 复读目标 bundle 在装，二者同时满足。
+ * - 0.9.19：供应链等待期在委派前预检（release-age.ts，零写操作 fail-open）；失败翻译解析
+ *   全部违规条目并复读「账实分裂」（pnpm 11 锁文件校验失败前目标已写入 node_modules、
+ *   官方管理器只回滚 manifest/lockfile 的实证形态——0:15 quota-watch 事件）。
  *
  * 禁止事项：desktop 路径零 Web fallback——不做文件级装后守卫（app.asar 探测盲区）、
  * 不写 allowBuilds、不跑 dsh-m 自实现 pnpm 编排、服务缺席一律结构化拒绝。
@@ -26,39 +29,21 @@ import { listInstalledPlugins as defaultListInstalled } from './installed.js';
 import { precheckNpmCompat, IncompatibleError } from './compat-check.js';
 import { npmLatest as defaultNpmLatest, githubLatestTag as defaultGithubLatestTag } from './versions.js';
 import { togglePlugin, ToggleError } from './toggle.js';
-function humanDuration(ms) {
-    if (!Number.isFinite(ms) || ms <= 0)
-        return '不到 1 分钟';
-    const minutes = Math.round(ms / 60_000);
-    if (minutes < 60)
-        return `${minutes} 分钟`;
-    const hours = Math.floor(minutes / 60);
-    const rest = minutes % 60;
-    return rest ? `${hours} 小时 ${rest} 分钟` : `${hours} 小时`;
-}
-/**
- * 0.9.10：desktop profile 的 pnpm 供应链策略（minimumReleaseAge）拒绝「太新鲜」的版本——
- * 这是策略在正确工作（防供应链攻击的发布等待期），不是环境故障。解析出条目/发布时刻/
- * 策略截止，翻译成「何时可重试」的诚实指引，而不是甩一屏 pnpm 原文（dsh-market #732 同态度）。
- */
-function releaseAgeWaitMessage(diagnostic) {
-    const m = /(\S+@\S+) was published at ([^,]+), within the minimumReleaseAge cutoff \(([^)]+)\)/.exec(diagnostic);
-    if (!m) {
-        return '官方管理器的供应链策略（minimumReleaseAge）未满足：新发布的版本需满等待期才能装入 desktop profile。稍后再点升级即可；等待期内也可改用 DSH Web 安装';
-    }
-    const entry = m[1];
-    const publishedAt = Date.parse(m[2]);
-    const cutoff = Date.parse(m[3]);
-    const deadline = Number.isFinite(publishedAt) && Number.isFinite(cutoff) ? publishedAt + (Date.now() - cutoff) : NaN;
-    const when = Number.isFinite(deadline) ? `约 ${humanDuration(deadline - Date.now())}后（${new Date(deadline).toLocaleString('zh-CN', { hour12: false })}）` : '稍后';
-    return `官方管理器的供应链策略（minimumReleaseAge）要求新发布版本满等待期才能安装：${entry} 尚在等待期内，预计 ${when}可重试。等待期内也可改用 DSH Web 安装同版本`;
-}
+import { describeReleaseAgeFailure, releaseAgePrecheck } from './release-age.js';
+// 0.9.19：等待期失败翻译移入 release-age.ts（describeReleaseAgeFailure）——全量违规解析 +
+// 目标/旁包分述。0.9.10 版只取第一条违规并把旁包名字当成本次目标、给「改用 DSH Web」的
+// 失配指引（本机 quota-watch 0.1.15 事件实证：被拦的是旁包 dsh-m@0.9.18，文案却让用户等
+// 旁包满期、去装 web profile）。
 export class DesktopOpsError extends Error {
     code;
-    constructor(code, message) {
+    /** 0.9.19：结构化细节（release-age：violations/targetViolating/splitState；precheck：blockers）。 */
+    details;
+    constructor(code, message, details) {
         super(message);
         this.name = 'DesktopOpsError';
         this.code = code;
+        if (details !== undefined)
+            this.details = details;
     }
 }
 /** 结构化信号：build-blocked + pendingBuilds（desktopInstall/Upgrade 共享，调用方映射各自返回形态）。 */
@@ -135,10 +120,24 @@ async function desktopInstallLocked(id, cfg, opts, deps) {
     else {
         throw new DesktopOpsError('install-refused', `收录条目 ${entry.id} 缺少 npm/github 来源，无法在 desktop 安装`);
     }
+    // 0.9.19：供应链等待期预检——pnpm 11 锁文件校验会拦死整次安装，且失败前目标已写入
+    // node_modules（账实分裂）；目标太新或锁内「独立精确排除条目」未满期 → 委派前结构化拒绝。
+    if (entry.source === 'npm' && version !== undefined) {
+        const gate = await releaseAgePrecheck({
+            pkg,
+            version,
+            profileDir: opts.profileDir,
+            timeoutMs,
+            signal: opts.signal,
+            deps: { packumentTimes: deps.packumentTimes, workspacePolicy: deps.workspacePolicy },
+        });
+        if (gate.blocked)
+            throw new DesktopOpsError('release-age-wait', gate.message, { blockers: gate.blockers });
+    }
     let change;
     let bundleName;
     try {
-        ({ change, bundleName } = await runManagedInstall(service, pkg, spec, opts.approvedBuilds));
+        ({ change, bundleName } = await runManagedInstall(service, { pkg, spec, version, profileDir: opts.profileDir, approvedBuilds: opts.approvedBuilds, listInstalled: deps.listInstalled }));
     }
     catch (err) {
         if (err instanceof DesktopBuildApprovalNeeded) {
@@ -179,6 +178,9 @@ export async function desktopToggle(pkg, enabled, deps = {}) {
  * desktopInstall / desktopUpgrade 共用；build-blocked 以 DesktopBuildApprovalNeeded 抛出，
  * 由调用方映射各自的返回形态。判定纪律沿用文件头「报告 §5.2」（dsh-market #703/#772 实证）：
  * 以 application/stage 为准，绝不只看 packageResult.exitCode；overridden 非失败。
+ * 0.9.19：release-age 失败翻译换 release-age.ts（全量违规解析 + 目标/旁包分述），并复读
+ * 「账实分裂」（pnpm 11 锁文件校验失败前目标可能已写入 node_modules，官方管理器只回滚
+ * manifest/lockfile），把回退风险明示进错误信息。
  *
  * 本地增强（2026-10-02，未随计划发版）：enable 阶段失败自动重试一次 + 文案按 packageResult 精确化。
  * 背景：desktop 高频装卸/插件树重载窗口下，官方管理器 enable 阶段与应用侧操作竞速，返回
@@ -205,42 +207,63 @@ function enableStageFailureMessage(pkg, change) {
     }
     return `安装后启用阶段失败（${pkg}；application=failed、stage=enable${change.error?.code ? `、error=${change.error.code}` : ''}）：${writtenText}，请在官方 Desktop 插件页查看状态或重试`;
 }
-async function runManagedInstall(service, pkg, spec, approvedBuilds) {
-    const installOnce = async () => changeOf(await service.installBundle(spec, {
+async function runManagedInstall(service, ctx) {
+    const installOnce = async () => changeOf(await service.installBundle(ctx.spec, {
         enabled: true,
-        ...(approvedBuilds && approvedBuilds.length > 0 ? { approvedBuilds } : {}),
+        ...(ctx.approvedBuilds && ctx.approvedBuilds.length > 0 ? { approvedBuilds: ctx.approvedBuilds } : {}),
     }));
     /** 失败映射（既有语义不变：cancelled / build-blocked 审批 / release-age 等待 / enable / 通用）。 */
-    const mapFailure = (change) => {
+    const mapFailure = async (change) => {
         if (change.application === 'cancelled') {
-            throw new DesktopOpsError('install-refused', `安装已被取消（${pkg}）：desktop profile 文件已由官方管理器恢复，未安装`);
+            throw new DesktopOpsError('install-refused', `安装已被取消（${ctx.pkg}）：desktop profile 文件已由官方管理器恢复，未安装`);
         }
         const pending = Array.isArray(change.pendingBuilds) ? change.pendingBuilds.filter((n) => typeof n === 'string') : [];
         if (change.packageResult?.kind === 'build-blocked' && pending.length > 0) {
             throw new DesktopBuildApprovalNeeded(pending);
         }
-        // 0.9.10：供应链等待期（minimumReleaseAge）——策略正确工作，翻译成「何时可重试」
+        // 0.9.19：供应链等待期——解析全部违规条目（0.9.10 只取第一条，旁包被当成被拦目标）、
+        // 目标/旁包分述 + 账实分裂复读（pnpm 11 校验失败前已写入 node_modules 的实证形态）。
         const diagnosticText = `${change.error?.diagnostic ?? ''}\n${change.error?.code ?? ''}`;
         if (/ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION|minimumReleaseAge/i.test(diagnosticText)) {
-            throw new DesktopOpsError('release-age-wait', releaseAgeWaitMessage(diagnosticText));
+            const view = describeReleaseAgeFailure({ pkg: ctx.pkg, version: ctx.version, diagnostic: diagnosticText });
+            let message = view.message;
+            let splitState;
+            if (ctx.profileDir && ctx.version) {
+                try {
+                    const items = (await ctx.listInstalled?.(ctx.profileDir) ?? { items: [] }).items;
+                    const row = items.find((it) => it.pkg === ctx.pkg);
+                    if (row && row.version === ctx.version && typeof row.spec === 'string' && row.spec !== '') {
+                        splitState = { installedVersion: row.version, manifestSpec: row.spec };
+                        message += `\n注意：${row.version} 已写入 node_modules 且在运行，但 manifest/lockfile 仍记录 ${row.spec}（官方管理器失败回滚所致，「账实分裂」）——官方管理器下次任何包操作都会把它回退到 ${row.spec}；等待期满后重新升级即可对齐。`;
+                    }
+                }
+                catch {
+                    // 复读失败不遮蔽原错误
+                }
+            }
+            throw new DesktopOpsError('release-age-wait', message, {
+                violations: view.violations,
+                targetViolating: view.targetViolating,
+                ...(splitState !== undefined ? { splitState } : {}),
+            });
         }
         if (change.stage === 'enable') {
-            throw new DesktopOpsError('enable-failed', enableStageFailureMessage(pkg, change));
+            throw new DesktopOpsError('enable-failed', enableStageFailureMessage(ctx.pkg, change));
         }
-        throw new DesktopOpsError('install-refused', `官方管理器安装失败（${pkg}；application=${change.application ?? 'failed'}${change.error?.code ? `、error=${change.error.code}` : ''}${change.error?.diagnostic ? `：${change.error.diagnostic}` : ''}）`);
+        throw new DesktopOpsError('install-refused', `官方管理器安装失败（${ctx.pkg}；application=${change.application ?? 'failed'}${change.error?.code ? `、error=${change.error.code}` : ''}${change.error?.diagnostic ? `：${change.error.diagnostic}` : ''}）`);
     };
     /** 复读校验：listBundles 可用必须见目标在装；不可用（老管理器）至少要求官方宣称产出 bundle。 */
     const verifyAndBundle = async (change) => {
-        const bundleName = change.bundle ?? pkg;
+        const bundleName = change.bundle ?? ctx.pkg;
         if (typeof service.listBundles === 'function') {
             const bundles = await service.listBundles();
             const found = (bundles ?? []).find((b) => b && b.name === bundleName);
             if (!found || found.installed === false) {
-                throw new DesktopOpsError('verify-failed', `安装复读失败（${pkg}）：官方结果为 ${change.application ?? 'unknown'} 但 listBundles 未見目标 bundle 在装——不冒充安装成功`);
+                throw new DesktopOpsError('verify-failed', `安装复读失败（${ctx.pkg}）：官方结果为 ${change.application ?? 'unknown'} 但 listBundles 未見目标 bundle 在装——不冒充安装成功`);
             }
         }
         else if (!change.bundle) {
-            throw new DesktopOpsError('verify-failed', `安装复读不可用（${pkg}）：官方结果未携带 bundle 字段且 listBundles 缺席——不冒充安装成功`);
+            throw new DesktopOpsError('verify-failed', `安装复读不可用（${ctx.pkg}）：官方结果未携带 bundle 字段且 listBundles 缺席——不冒充安装成功`);
         }
         return { change, bundleName };
     };
@@ -253,7 +276,7 @@ async function runManagedInstall(service, pkg, spec, approvedBuilds) {
         change = await installOnce();
     }
     if (change.application === 'failed' || change.application === 'cancelled' || change.error)
-        mapFailure(change);
+        await mapFailure(change);
     return verifyAndBundle(change);
 }
 /**
@@ -359,10 +382,23 @@ async function desktopUpgradeLocked(pkg, cfg, opts, deps) {
     else {
         throw new DesktopOpsError('install-refused', `收录条目 ${entry.id} 缺少 npm/github 来源，无法在 desktop 升级`);
     }
+    // 0.9.19：供应链等待期预检（同 desktopInstallLocked；0:15 quota-watch 事件即此形态实证）
+    if (entry.source === 'npm' && version !== undefined) {
+        const gate = await releaseAgePrecheck({
+            pkg,
+            version,
+            profileDir: opts.profileDir,
+            timeoutMs,
+            signal: opts.signal,
+            deps: { packumentTimes: deps.packumentTimes, workspacePolicy: deps.workspacePolicy },
+        });
+        if (gate.blocked)
+            throw new DesktopOpsError('release-age-wait', gate.message, { blockers: gate.blockers });
+    }
     let change;
     let bundleName;
     try {
-        ({ change, bundleName } = await runManagedInstall(service, pkg, spec, opts.approvedBuilds));
+        ({ change, bundleName } = await runManagedInstall(service, { pkg, spec, version, profileDir: opts.profileDir, approvedBuilds: opts.approvedBuilds, listInstalled: deps.listInstalled }));
     }
     catch (err) {
         if (err instanceof DesktopBuildApprovalNeeded) {

package/lib/core/release-age.js

@@ -0,0 +1,267 @@
+/**
+ * Desktop 供应链等待期（minimumReleaseAge）预检与失败翻译（0.9.19）。
+ *
+ * pnpm 11.7 实机实证（2026-10-03，本机 desktop profile，官方管理器操作日志
+ * operation-hNjgaN / operation-l5fXEd）：
+ * 1. 显式安装「太新」目标：非严格模式放行，pnpm 自动向 pnpm-workspace.yaml 的
+ *    `minimumReleaseAgeExclude` 追加一条「独立精确条目」（`pkg@ver` 形态）；
+ * 2. 但后续任何包操作的锁文件级供应链校验（`Verifying lockfile against
+ *    supply-chain policies (N entries)`）不认可 pnpm 自己追加的这种条目——
+ *    任何一条未满期的 `pkg@ver` 都会拦死整个安装，且与本次目标无关（旁包能拦住
+ *    所有升级，0.9.18 拦住 quota-watch 0.1.15 升级即实证）；
+ * 3. 校验失败前目标包可能已写入 node_modules，官方管理器只回滚 manifest/lockfile
+ *    →「账实分裂」：界面实装新版 active，账本仍旧版，下次包操作静默回退。
+ *
+ * 对策（零文件级红线不破：只读 profile 文件，绝不写）：
+ * ① 委派前预检（releaseAgePrecheck）：目标版本或锁内「不被校验认可的独立精确
+ *    排除条目」任一未满等待期 → 结构化拒绝，不委派官方管理器；
+ * ② 失败翻译（describeReleaseAgeFailure）：解析全部违规条目，按「本次目标 vs
+ *    锁内旁包」分别给出发布时刻与可重试时刻——不再把旁包名字冒充成本次目标被拦。
+ *
+ * fail-open 纪律：发布时刻不可得 / 策略文件不可读 / profileDir 缺席 / 命中有效排除
+ * 条目（包名级、`||` 复合、scoped 独立精确）→ 一律放行；pnpm 仍是最终执行者。
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isMap, isScalar, isSeq, parseDocument } from 'yaml';
+import { fetchJsonLimited } from './httpx.js';
+import { isExactVersion } from './versions.js';
+/** pnpm 11.7 实机测得的策略窗口：24h（operation-l5fXEd 的 cutoff = 检查时刻 − 1440min）。 */
+export const DEFAULT_MINIMUM_RELEASE_AGE_MIN = 1440;
+/** 锁内「独立精确排除条目」旁包探测上限（防清单失控；超出部分放弃预判，交 pnpm 兜底）。 */
+export const MAX_EXCLUDE_PROBES = 8;
+function scalarNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
+        return Number(value);
+    return null;
+}
+/**
+ * 最小解析 pnpm-workspace.yaml 的两个策略键。
+ * 保守口径：坏 YAML / 根非映射 / 结构不符 → 空策略（minimumReleaseAgeMin=null、excludes=[]），
+ * 调用方按默认窗口 + 无排除处理，绝不抛。
+ */
+export function parseWorkspacePolicy(text) {
+    const empty = { minimumReleaseAgeMin: null, excludes: [] };
+    let document;
+    try {
+        document = parseDocument(text);
+    }
+    catch {
+        return empty;
+    }
+    if (document.errors.length > 0 || !isMap(document.contents))
+        return empty;
+    const excludes = [];
+    const rawExcludes = document.contents.get('minimumReleaseAgeExclude');
+    if (isSeq(rawExcludes)) {
+        for (const item of rawExcludes.items) {
+            if (isScalar(item) && typeof item.value === 'string' && item.value.trim() !== '') {
+                excludes.push(item.value.trim());
+            }
+        }
+    }
+    // yaml 库的 Map.get() 对标量返回已解包的原始值（number/string），对集合返回节点——两种形态都兜住
+    const rawAge = document.contents.get('minimumReleaseAge');
+    const age = isScalar(rawAge) ? scalarNumber(rawAge.value) : scalarNumber(rawAge);
+    return { minimumReleaseAgeMin: age !== null && age > 0 ? age : null, excludes };
+}
+export function excludeMatch(selector, pkg, version) {
+    const s = selector.trim();
+    if (s === '')
+        return 'no';
+    if (s.includes('||')) {
+        for (const part of s.split('||')) {
+            if (excludeMatch(part.trim(), pkg, version) !== 'no')
+                return 'effective';
+        }
+        return 'no';
+    }
+    const at = s.lastIndexOf('@');
+    if (at <= 0) {
+        // 包名级（dshmarket）或裸版本号段（只应出现在复合条目内，顶层出现视为包名比较）
+        return s === pkg || s === version ? 'effective' : 'no';
+    }
+    const namePart = s.slice(0, at);
+    const verPart = s.slice(at + 1);
+    if (namePart !== pkg)
+        return 'no';
+    if (verPart === version) {
+        return pkg.startsWith('@') ? 'effective' : 'unreliable-unscoped-exact';
+    }
+    return 'no';
+}
+/** 从独立精确条目提取 (pkg, version)；复合/包名级/版本段非精确 semver → null。 */
+export function splitExactSelector(selector) {
+    const s = selector.trim();
+    if (s === '' || s.includes('||'))
+        return null;
+    const at = s.lastIndexOf('@');
+    if (at <= 0)
+        return null;
+    const pkg = s.slice(0, at);
+    const version = s.slice(at + 1);
+    if (!isExactVersion(version))
+        return null;
+    if (!/^@?[A-Za-z0-9-._~]+(\/[A-Za-z0-9-._~]+)?$/.test(pkg))
+        return null;
+    return { pkg, version, reliable: pkg.startsWith('@') };
+}
+const VIOLATION_RE = /(\S+@\S+) was published at ([^,]+), within the minimumReleaseAge cutoff \(([^)]+)\)/g;
+/** 解析 pnpm 诊断里的全部等待期违规条目（0.9.10 只取第一条是「报错报错包」的根因之一）。 */
+export function parseViolations(diagnostic, nowMs = Date.now()) {
+    const out = [];
+    for (const m of diagnostic.matchAll(VIOLATION_RE)) {
+        const entry = m[1] ?? '';
+        const publishedAt = Date.parse(m[2] ?? '');
+        const cutoff = Date.parse(m[3] ?? '');
+        if (entry === '' || !Number.isFinite(publishedAt) || !Number.isFinite(cutoff))
+            continue;
+        const at = entry.lastIndexOf('@');
+        out.push({
+            entry,
+            pkg: at > 0 ? entry.slice(0, at) : entry,
+            version: at > 0 ? entry.slice(at + 1) : null,
+            publishedAt,
+            cutoff,
+            deadline: publishedAt + (nowMs - cutoff),
+        });
+    }
+    return out;
+}
+function fmtLocal(ms) {
+    return new Date(ms).toLocaleString('zh-CN', { hour12: false });
+}
+/**
+ * 0.9.19 失败翻译：替代 0.9.10 的 releaseAgeWaitMessage（只取第一条违规、把旁包
+ * 名字当成被拦对象、给「DSH Web 安装同版本」的失配指引）。多行文案进操作记录面板。
+ */
+export function describeReleaseAgeFailure(input) {
+    const now = input.nowMs ?? Date.now();
+    const violations = parseViolations(input.diagnostic, now);
+    if (violations.length === 0) {
+        return {
+            message: '官方管理器的供应链策略（minimumReleaseAge）未满足：新发布的版本需满等待期才能装入 desktop profile。稍后再点升级即可',
+            violations,
+            targetViolating: false,
+        };
+    }
+    const targetEntry = input.version ? `${input.pkg}@${input.version}` : input.pkg;
+    const targetViol = violations.find((v) => v.pkg === input.pkg);
+    const others = violations.filter((v) => v !== targetViol);
+    const lines = [`官方管理器的供应链策略（minimumReleaseAge）拦截了本次安装（${input.pkg}）：锁文件供应链校验未通过`];
+    if (targetViol) {
+        lines.push(`· 本次目标 ${targetViol.entry}：发布于 ${fmtLocal(targetViol.publishedAt)}，预计 ${fmtLocal(targetViol.deadline)} 后满等待期`);
+    }
+    else {
+        lines.push(`· 本次目标 ${targetEntry}：不在违规名单（被锁内其他未满期条目连坐）`);
+    }
+    for (const v of others) {
+        lines.push(`· 锁内未满期条目 ${v.entry}：发布于 ${fmtLocal(v.publishedAt)}，预计 ${fmtLocal(v.deadline)} 后满等待期（pnpm 安装它时自动追加的独立精确排除条目不被锁文件校验认可，等待期内任何官方包操作都会被拦）`);
+    }
+    const maxDeadline = Math.max(...violations.map((v) => v.deadline));
+    lines.push(`预计 ${fmtLocal(maxDeadline)} 后可重试；等待期内也可由操作员把 pnpm-workspace.yaml 中对应的独立精确排除条目改为包名级或复合条目以解除拦截`);
+    return { message: lines.join('\n'), violations, targetViolating: targetViol !== undefined };
+}
+/** registry packument 的 time 映射（与 npmPackument 同源；失败返回 null，不抛）。 */
+export async function npmPackumentTimes(pkg, timeoutMs = 20_000, signal) {
+    if (!/^@?[A-Za-z0-9-._~]+(\/[A-Za-z0-9-._~]+)?$/.test(pkg))
+        return null;
+    try {
+        const data = await fetchJsonLimited(`https://registry.npmjs.org/${encodeURIComponent(pkg)}`, { timeoutMs, signal, maxBytes: 8 * 1024 * 1024 });
+        if (!data || typeof data !== 'object' || data.time === null || typeof data.time !== 'object')
+            return null;
+        const out = {};
+        for (const [k, v] of Object.entries(data.time)) {
+            if (typeof v === 'string')
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+/** 读 profile 的 pnpm-workspace.yaml 策略；缺席/不可读 → null（调用方 fail-open）。 */
+export async function readWorkspacePolicy(profileDir) {
+    if (!profileDir)
+        return null;
+    try {
+        return parseWorkspacePolicy(await readFile(join(profileDir, 'pnpm-workspace.yaml'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+const packumentCache = new Map();
+const PACKUMENT_CACHE_TTL_MS = 5 * 60_000;
+/** 测试钩子：清空 packument 进程内缓存。 */
+export function _resetReleaseAgeCachesForTests() {
+    packumentCache.clear();
+}
+/**
+ * 委派前预检：目标版本与锁内「不被校验认可的独立精确排除条目」逐个对发布时刻，
+ * 任一未满等待期 → 结构化拒绝（blocked + 多行理由）。零写操作；不确定一律放行。
+ */
+export async function releaseAgePrecheck(input) {
+    // profileDir 缺席 = 读不到操作员排除条目 → 不预判（避免误拦操作员显式 pin 的安装）
+    if (!input.profileDir)
+        return { blocked: false };
+    const now = input.nowMs ?? Date.now();
+    const policy = input.deps?.workspacePolicy
+        ? await input.deps.workspacePolicy(input.profileDir)
+        : await readWorkspacePolicy(input.profileDir);
+    const policyMin = policy?.minimumReleaseAgeMin ?? DEFAULT_MINIMUM_RELEASE_AGE_MIN;
+    const probe = async (pkg) => {
+        const hit = packumentCache.get(pkg);
+        if (hit && Date.now() - hit.at < PACKUMENT_CACHE_TTL_MS)
+            return hit.times;
+        const times = await (input.deps?.packumentTimes ?? npmPackumentTimes)(pkg, Math.min(input.timeoutMs ?? 20_000, 12_000), input.signal);
+        packumentCache.set(pkg, { at: Date.now(), times });
+        return times;
+    };
+    const blockers = [];
+    // ① 本次目标版本的发布时刻（有效排除条目覆盖 → 放行）
+    const times = await probe(input.pkg);
+    const publishedAt = times ? Date.parse(times[input.version] ?? '') : NaN;
+    if (Number.isFinite(publishedAt)) {
+        const exempt = (policy?.excludes ?? []).some((sel) => excludeMatch(sel, input.pkg, input.version) === 'effective');
+        if (!exempt) {
+            const deadline = publishedAt + policyMin * 60_000;
+            if (now < deadline) {
+                blockers.push({ entry: `${input.pkg}@${input.version}`, role: 'target', publishedAt, deadline });
+            }
+        }
+    }
+    // ② 锁内「不被校验认可的独立精确排除条目」（非 scoped）——任何一条未满期都会拦死整次安装
+    const seen = new Set([`${input.pkg}@${input.version}`]);
+    const candidates = (policy?.excludes ?? [])
+        .map((sel) => splitExactSelector(sel))
+        .filter((x) => x !== null && !x.reliable);
+    for (const ex of candidates.slice(0, MAX_EXCLUDE_PROBES)) {
+        const entry = `${ex.pkg}@${ex.version}`;
+        if (seen.has(entry))
+            continue;
+        seen.add(entry);
+        const t2 = await probe(ex.pkg);
+        const pub = t2 ? Date.parse(t2[ex.version] ?? '') : NaN;
+        if (!Number.isFinite(pub))
+            continue;
+        const deadline = pub + policyMin * 60_000;
+        if (now < deadline) {
+            blockers.push({ entry, role: 'lockfile-exclude', publishedAt: pub, deadline });
+        }
+    }
+    if (blockers.length === 0)
+        return { blocked: false };
+    const lines = ['官方管理器的供应链策略（minimumReleaseAge）将拦截本次安装，已提前拒绝（未触碰 profile 文件）：'];
+    for (const b of blockers) {
+        lines.push(b.role === 'target'
+            ? `· 目标 ${b.entry}：发布于 ${fmtLocal(b.publishedAt)}，预计 ${fmtLocal(b.deadline)} 后满等待期`
+            : `· 锁内排除条目 ${b.entry}：发布于 ${fmtLocal(b.publishedAt)}，预计 ${fmtLocal(b.deadline)} 后满等待期（pnpm 自动追加的独立精确条目不被锁文件校验认可，等待期内任何官方包操作都会被拦）`);
+    }
+    const maxDeadline = Math.max(...blockers.map((b) => b.deadline));
+    lines.push(`预计 ${fmtLocal(maxDeadline)} 后可重试；等待期内也可由操作员修正 pnpm-workspace.yaml 的排除条目形态（包名级/复合）解除拦截`);
+    return { blocked: true, message: lines.join('\n'), blockers };
+}

package/lib/tools.js

@@ -255,7 +255,7 @@ export function registerTools(ctx, cfg, deps = {}, profile = resolveActiveProfil
             if (profile.kind !== 'web') {
                 assertWriteAllowed(profile, 'install');
                 // 0.9.8：补传服务解析 deps（此前漏传 → desktop 安装恒 no-manager，实机 2026-10-01）
-                return cloneJson(await m.desktopInstall(id, cfg, { version, forceIncompatible: force, namespace: 'host', profile: profile.name }, { getService: getService, ensureService: ensureService }));
+                return cloneJson(await m.desktopInstall(id, cfg, { version, forceIncompatible: force, namespace: 'host', profile: profile.name, profileDir: profile.dir }, { getService: getService, ensureService: ensureService }));
             }
             try {
                 return cloneJson(await m.installFromRegistry(id, cfg, { version, forceIncompatible: force, namespace: 'host' }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-m",
-  "version": "0.9.18",
+  "version": "0.9.20",
   "description": "可自定义收录清单的 DSH 插件市场：收录、安装、卸载、升级一站完成，附 agent 工具与 dshm CLI。",
   "license": "MIT",
   "type": "module",