dsh-plugin-manager-companion 0.1.1 → 0.1.2

package/dist/client/locales.d.ts

@@ -185,6 +185,7 @@ export declare const zh: {
     readonly 'config.diagnostics.runtime': "L3 运行时";
     readonly 'config.diagnostics.consistency': "L4 一致性";
     readonly 'config.diagnostics.ecosystem': "L5 生态（需要联网）";
+    readonly 'config.diagnostics.reportStaleModuleFallbackLinks': "提示过期的依赖兜底链接";
     readonly 'config.marketplace': "市场";
     readonly 'config.marketplace.enabled': "启用远程索引";
     readonly 'config.marketplace.cacheTtlMinutes': "索引缓存有效期（分钟）";

package/dist/client.js

@@ -185,6 +185,7 @@ window.__ModuleLoader__.load({
 			"config.diagnostics.runtime": "L3 运行时",
 			"config.diagnostics.consistency": "L4 一致性",
 			"config.diagnostics.ecosystem": "L5 生态（需要联网）",
+			"config.diagnostics.reportStaleModuleFallbackLinks": "提示过期的依赖兜底链接",
 			"config.marketplace": "市场",
 			"config.marketplace.enabled": "启用远程索引",
 			"config.marketplace.cacheTtlMinutes": "索引缓存有效期（分钟）",
@@ -637,6 +638,7 @@ window.__ModuleLoader__.load({
 			"config.diagnostics.runtime": "L3 runtime",
 			"config.diagnostics.consistency": "L4 consistency",
 			"config.diagnostics.ecosystem": "L5 ecosystem (network)",
+			"config.diagnostics.reportStaleModuleFallbackLinks": "Report stale module-fallback links",
 			"config.marketplace": "Marketplace",
 			"config.marketplace.enabled": "Enable the remote index",
 			"config.marketplace.cacheTtlMinutes": "Index cache TTL (minutes)",
@@ -2385,7 +2387,8 @@ window.__ModuleLoader__.load({
 				composition: true,
 				runtime: true,
 				consistency: true,
-				ecosystem: false
+				ecosystem: false,
+				reportStaleModuleFallbackLinks: true
 			},
 			qualityGate: {
 				enabled: true,
@@ -2446,7 +2449,8 @@ window.__ModuleLoader__.load({
 						composition: read(diagnostics, "diagnostics.composition", flag(diagnostics["composition"], defaults.diagnostics.composition)),
 						runtime: read(diagnostics, "diagnostics.runtime", flag(diagnostics["runtime"], defaults.diagnostics.runtime)),
 						consistency: read(diagnostics, "diagnostics.consistency", flag(diagnostics["consistency"], defaults.diagnostics.consistency)),
-						ecosystem: read(diagnostics, "diagnostics.ecosystem", flag(diagnostics["ecosystem"], defaults.diagnostics.ecosystem))
+						ecosystem: read(diagnostics, "diagnostics.ecosystem", flag(diagnostics["ecosystem"], defaults.diagnostics.ecosystem)),
+						reportStaleModuleFallbackLinks: read(diagnostics, "diagnostics.reportStaleModuleFallbackLinks", flag(diagnostics["reportStaleModuleFallbackLinks"], defaults.diagnostics.reportStaleModuleFallbackLinks))
 					},
 					qualityGate: {
 						enabled: read(qualityGate, "qualityGate.enabled", flag(qualityGate["enabled"], defaults.qualityGate.enabled)),
@@ -4561,7 +4565,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region \0companion-css:/home/sixiao/aicode/test/test8/dsh-plugin-manager-companion/src/client/OfficialSlots.module.css.mjs
-		const css$4 = ".Kig3dq_summary{color:var(--dsw-alias-label-tertiary);margin:0;font-size:13px;line-height:20px}.Kig3dq_page{color:var(--dsw-alias-label-primary);flex-direction:column;gap:10px;display:flex}.Kig3dq_upgrade{border:.5px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-2);border-radius:10px;flex-direction:column;gap:6px;padding:10px 12px;display:flex}.Kig3dq_upgradeHead{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeTitle{font-size:13px;font-weight:600}.Kig3dq_upgradeVersions{font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);font-size:12px}.Kig3dq_upgradeField{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeNote{color:var(--dsw-alias-label-tertiary);margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeWarn{color:var(--dsw-alias-state-warning-primary,var(--dsw-alias-label-secondary));margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeActions{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeReason{flex-direction:column;gap:2px;display:flex}.Kig3dq_upgradeReasonLine{color:var(--dsw-alias-label-secondary);white-space:pre-wrap;margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeFacts{color:var(--dsw-alias-label-tertiary);margin:0;padding-left:18px;font-size:12px;line-height:18px}.Kig3dq_upgradeOutput{background:var(--dsw-alias-bg-layer-1);max-height:220px;font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);white-space:pre-wrap;word-break:break-word;border-radius:8px;margin:0;padding:8px 10px;font-size:12px;line-height:18px;overflow:auto}.Kig3dq_upgradeCommand{font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);word-break:break-all;font-size:12px;line-height:18px;display:block}";
+		const css$4 = ".Kig3dq_summary{color:var(--dsw-alias-label-tertiary);margin:0;font-size:13px;line-height:20px}.Kig3dq_page{color:var(--dsw-alias-label-primary);flex-direction:column;gap:10px;display:flex}.Kig3dq_upgrade{flex-direction:column;gap:6px;display:flex}.Kig3dq_upgradeHead{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeTitle{font-size:13px;font-weight:600}.Kig3dq_upgradeVersions{font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);font-size:12px}.Kig3dq_upgradeField{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeNote{color:var(--dsw-alias-label-tertiary);margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeWarn{color:var(--dsw-alias-state-warning-primary,var(--dsw-alias-label-secondary));margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeActions{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.Kig3dq_upgradeReason{flex-direction:column;gap:2px;display:flex}.Kig3dq_upgradeReasonLine{color:var(--dsw-alias-label-secondary);white-space:pre-wrap;margin:0;font-size:12px;line-height:18px}.Kig3dq_upgradeFacts{color:var(--dsw-alias-label-tertiary);margin:0;padding-left:18px;font-size:12px;line-height:18px}.Kig3dq_upgradeOutput{background:var(--dsw-alias-bg-layer-1);max-height:220px;font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);white-space:pre-wrap;word-break:break-word;border-radius:8px;margin:0;padding:8px 10px;font-size:12px;line-height:18px;overflow:auto}.Kig3dq_upgradeCommand{font-family:var(--dsw-font-markdown-code-font-family);color:var(--dsw-alias-label-secondary);word-break:break-all;font-size:12px;line-height:18px;display:block}";
 		const tagId$4 = "dsh-plugin-manager-companion/OfficialSlots.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$4) + "]") === null) {
 			const tag = document.createElement("style");
@@ -7232,7 +7236,20 @@ select(draft, id) {
 										actions.editConfigField(["diagnostics", layer], next);
 									}
 								})]
-							}, layer))
+							}, layer)),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: ConsolePage_module_css_default.fieldRow,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: ConsolePage_module_css_default.metaLabel,
+									children: t("config.diagnostics.reportStaleModuleFallbackLinks")
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Switch, {
+									checked: draft.diagnostics.reportStaleModuleFallbackLinks,
+									label: t("config.diagnostics.reportStaleModuleFallbackLinks"),
+									onChange: (next) => {
+										actions.editConfigField(["diagnostics", "reportStaleModuleFallbackLinks"], next);
+									}
+								})]
+							})
 						]
 					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {

package/dist/diagnostics.js

@@ -38,7 +38,8 @@ import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'n
 import { createRequire, isBuiltin } from 'node:module';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { profilesRoot, readEnvironmentManifest } from "./paths.js";
+import { dshHome, profilesRoot, readEnvironmentManifest } from "./paths.js";
+import { cleanupDanglingLinks, moduleFallbackDir, readModuleFallbackClosure, scanModuleFallback, scanProfileModuleFallback, } from "./moduleFallback.js";
 import { readRuntimeInventory } from "./official.js";
 /** 传给官方装载函数（loadProfileDirectory / loadOptionalPatches）的诊断前缀。 */
 const DIAG_BIN = 'dsh-plugin-manager-companion';
@@ -148,8 +149,14 @@ export async function analyzeEnvironment(ctx, env, config) {
             reason: '运行时事实不可用：' + (runtime.reason ?? '原因未知'),
         });
     }
+    // 依赖兜底目录（$DSH_HOME/profiles/node_modules）的陈旧链接检查。
+    //
+    // 为什么在这里算（而不是放进 collectStaticFacts）：它要调**异步**的官方闭包算法。
+    // 层的 run() 是同步契约（其余四层都不需要 IO 之外的等待），为它把整条链改成异步
+    // 会把四层的调用点全部牵动——所以在进入层循环前算好，作为事实传进依赖层。
+    const moduleFallback = await readModuleFallbackFacts(env, diagnostics, skipped);
     const layers = [
-        { layer: 'dependency', run: () => dependencyLayer(env, facts, composition) },
+        { layer: 'dependency', run: () => dependencyLayer(env, facts, composition, moduleFallback) },
         { layer: 'composition', run: () => compositionLayer(env, facts, composition, skipped) },
         { layer: 'runtime', run: () => runtimeLayer(env, facts, composition, runtime) },
         { layer: 'consistency', run: () => consistencyLayer(env, facts, composition, runtime) },
@@ -408,9 +415,65 @@ function collectStaticFacts(env, config, skipped) {
         packageDirs, scans, manifests, edges, unscanned,
     };
 }
-// ── L1 依赖层 ───────────────────────────────────────────────────────────
-/** L1：import 图 × 声明 × loader 提供项。 */
-function dependencyLayer(env, facts, composition) {
+/**
+ * 扫一遍依赖兜底目录（`$DSH_HOME/profiles/node_modules`）。
+ *
+ * 目录不存在、闭包算不出来都**不是"没问题"**：如实记 skipped，让界面画成"没查"，
+ * 而不是画成 0（DESIGN：不允许用"没有标记"表达状态）。
+ *
+ * @param env - 被诊断环境（用它的 installAnchor 算闭包）。
+ * @param skipped - 跳过记录收集器。
+ * @returns 依赖层用的事实。
+ */
+async function readModuleFallbackFacts(env, config, skipped) {
+    const dir = moduleFallbackDir(dshHome());
+    if (!existsSync(dir)) {
+        // 共享层不存在 ≠ 没得查：**私有层是每个 profile 自己的**，仍然要扫。
+        // 这条 skipped 只说共享层没扫到，措辞不能写成"这台机器上没有可检查的陈旧链接"——
+        // 那会让下面私有层查出来的问题看起来自相矛盾（真机 web profile 就是这样：共享层不存在，
+        // 私有层却有 2 条断链）。
+        skipped.push({
+            check: 'module-fallback',
+            layers: ['dependency'],
+            reason: '共享依赖兜底目录不存在（' + dir + '）：这一类没有可检查的内容。',
+        });
+        return {
+            scan: scanModuleFallback(dir, { ok: false, reason: '目录不存在' }),
+            profileScan: scanProfileModuleFallback(env.dir),
+            staleMuted: staleMutedIn(config),
+        };
+    }
+    const closure = await readModuleFallbackClosure(env.installAnchor, dshHome());
+    if (!closure.ok) {
+        // 注意：这**不是**"这一层整层没查"——断链的判据与闭包无关，照常产出（scanModuleFallback 已处理）。
+        // 所以只说清"过时这一类没查"，并且**不带 layers**：带 layers 会被界面画成整层"没查"，
+        // 那会把已经查出来的断链一起抹掉。
+        skipped.push({
+            check: 'module-fallback-stale',
+            reason: '依赖兜底目录的当前闭包算不出来（' + closure.reason + '）：'
+                + '本次没有判定"完好但过时"这一类（断链仍照常检查）。',
+        });
+    }
+    return {
+        scan: scanModuleFallback(dir, closure),
+        profileScan: scanProfileModuleFallback(env.dir),
+        staleMuted: staleMutedIn(config),
+    };
+}
+/**
+ * 「完好但过时」是否被配置静音。
+ *
+ * 判据是 `=== false` 而不是 `!value`：这份配置可能来自只写了几个字段的旧配置文件
+ * （诊断测试与调用方都可能传部分对象），缺字段必须按**默认上报**处理——
+ * 用 `!value` 会把"没写"读成"关掉"，正好把默认值反过来。
+ *
+ * @param config - 诊断配置（可能缺字段）。
+ * @returns 是否静音。
+ */
+function staleMutedIn(config) {
+    return config.reportStaleModuleFallbackLinks === false;
+}
+function dependencyLayer(env, facts, composition, moduleFallback) {
     const issues = [];
     const envDir = facts.envDir;
     const manifestPath = join(envDir, 'package.json');
@@ -553,6 +616,102 @@ function dependencyLayer(env, facts, composition) {
         }
         issues.push(...peerIssues(name, manifest, facts));
     }
+    issues.push(...moduleFallbackIssues(moduleFallback));
+    return issues;
+}
+/**
+ * 依赖兜底目录的陈旧链接 → 两条发现（断链 / 完好但过时）。
+ *
+ * ## 为什么它归依赖层
+ *
+ * 它说的是"模块从哪来"这件事：这个目录是官方为所有 profile 铺的共享解析层。
+ *
+ * ## 文案必须说清的两件事
+ *
+ * 1. **它已不参与解析**——官方 0.1.6-alpha.2 默认 `resolutionMode = "runtime"`，
+ *    runtime 走 `materialize: false`，根本不写这个目录，解析也不读它。
+ *    不说这句，用户会以为删了会坏。
+ * 2. **断链与过时的处置不同**：断链默认自动删（旧代际残骸），完好但过时只报不删
+ *    （目标还在，用户可能有意保留）。
+ *
+ * @param facts - 扫描事实。
+ * @returns 发现清单（没有问题时为空数组）。
+ */
+function moduleFallbackIssues(facts) {
+    const { scan } = facts;
+    const issues = [];
+    const PREVIEW = 20;
+    // 共享层与私有层**各自独立**：共享层没扫到（目录不存在）不该连累私有层。
+    // 真机就是这样：共享层不存在，而 web profile 的私有层有 2 条断链。
+    if (scan.scanned && scan.dangling.length > 0) {
+        const preview = scan.dangling.slice(0, PREVIEW);
+        issues.push(makeIssue({
+            layer: 'dependency',
+            severity: 'safe-fix',
+            code: 'module-fallback-dangling-link',
+            title: '依赖兜底目录里有 ' + String(scan.dangling.length) + ' 条断开的链接',
+            detail: '这些链接指向的包已经不在磁盘上了（旧版本留下的残骸）。'
+                + '当前版本默认不写这个目录、也不从它解析（官方 0.1.6-alpha.2 的 runtime 解析模式），'
+                + '所以删掉它们不会影响任何东西的运行。'
+                + '修复只删符号链接本身，不递归删目录、不碰其它条目。'
+                + (scan.dangling.length > PREVIEW ? '（下面只列前 ' + String(PREVIEW) + ' 条，共 ' + String(scan.dangling.length) + ' 条。）' : ''),
+            subjects: preview.map(link => link.name),
+            scope: 'profiles/node_modules',
+            evidence: preview.map(link => ({
+                kind: 'file',
+                at: link.name,
+                note: '断链，指向 ' + (link.target ?? '（读不到目标）'),
+            })),
+            fix: {
+                action: 'remove-dangling-module-fallback-links',
+                summary: '删除这 ' + String(scan.dangling.length) + ' 条断链（只删符号链接）',
+            },
+            id: 'module-fallback-dangling-link',
+        }));
+    }
+    if (facts.profileScan.dangling.length > 0) {
+        const preview = facts.profileScan.dangling.slice(0, PREVIEW);
+        issues.push(makeIssue({
+            layer: 'dependency',
+            severity: 'report-only',
+            code: 'profile-module-fallback-dangling-link',
+            title: '这个环境的私有兜底层里有 ' + String(facts.profileScan.dangling.length) + ' 条断开的链接',
+            detail: '它们指向的包已经不存在了（多半是卸载插件后留下的）。'
+                + '私有兜底层由官方维护，官方**有**清理机制，所以出现断链是官方没清掉——'
+                + '这不影响当前运行（解析不读断掉的链接），但它是磁盘上的残留，值得知道。'
+                + '本项目**不自动删**它：这个目录归官方管，我们只如实报出来。',
+            subjects: preview.map(link => link.name),
+            scope: 'profile/.dsh-module-fallback',
+            evidence: preview.map(link => ({
+                kind: 'file',
+                at: '.dsh-module-fallback/node_modules/' + link.name,
+                note: '断链，指向 ' + (link.target ?? '（读不到目标）'),
+            })),
+            id: 'profile-module-fallback-dangling-link',
+        }));
+    }
+    if (scan.scanned && scan.stale.length > 0 && !facts.staleMuted) {
+        const preview = scan.stale.slice(0, PREVIEW);
+        issues.push(makeIssue({
+            layer: 'dependency',
+            severity: 'report-only',
+            code: 'module-fallback-stale-link',
+            title: '依赖兜底目录里有 ' + String(scan.stale.length) + ' 条链接不在当前安装的依赖闭包里',
+            detail: '这些链接的目标还在磁盘上，但它们不在当前 dsh 安装的依赖闭包里——'
+                + '多半是别的版本留下的。当前版本不从这个目录解析，所以它们不影响运行；'
+                + '我们**不自动删**（目标还在，可能是有意保留的），只报出来供你判断。'
+                + '不想要这类提示可以在设置里关掉。'
+                + (scan.stale.length > PREVIEW ? '（下面只列前 ' + String(PREVIEW) + ' 条，共 ' + String(scan.stale.length) + ' 条。）' : ''),
+            subjects: preview.map(link => link.name),
+            scope: 'profiles/node_modules',
+            evidence: preview.map(link => ({
+                kind: 'file',
+                at: link.name,
+                note: '不在当前闭包里，指向 ' + (link.target ?? '（读不到目标）'),
+            })),
+            id: 'module-fallback-stale-link',
+        }));
+    }
     return issues;
 }
 /** 一个包的 peerDependencies 与本环境实际安装版本的对照。 */

package/dist/envManager.d.ts

@@ -1045,3 +1045,67 @@ export interface RestoreEnvironmentOptions extends CrossEnvironmentOptions {
  * @returns 操作结果。
  */
 export declare function backupRestore(backup: EnvironmentBackup, target: string, options?: RestoreEnvironmentOptions): Promise<EnvironmentResult>;
+/**
+ * 目录类文件操作的重试。
+ *
+ * @param operation - 要执行的文件操作。
+ * @param attempts - 尝试次数上限。
+ */
+/**
+ * 删除一棵树的兜底：第一次失败后（Windows 上）清掉只读属性，再重试一次。
+ *
+ * ## 这条兜底真正守的是什么
+ *
+ * **不是只读属性**——见下「修正说明」。它守的是两件与平台无关的事：
+ *
+ * 1. **失败后重试一次**：对**瞬时**失败有效（文件被别的进程短暂占用、索引/杀毒尚未释放、
+ *    `EBUSY`/`EPERM` 那一类会自己消失的原因）。这是真实世界里最常见的删除失败形态。
+ * 2. **三层如实报错**：原始错误 + 我们做了什么 + 仍然失败。**这一条才是真正的交付**——
+ *    删除失败时用户能看到「为什么」，而不是一个裸 EPERM。
+ *    （变异 M7/M8 钉的正是这两行：删掉它们测试当场红。）
+ *
+ * ## 修正说明（2026-09-20，理由改过，实现保留）
+ *
+ * 本函数原先的理由是「Windows 上 `rmSync` 的 force 不覆盖只读属性 → 删除会永远失败」。
+ * **那个论断是错的**：
+ *   · 那句话**不在 Node 文档里**（v16/v18/v20/v22/v24 的 doc/api/fs.md 逐版 grep 零命中）；
+ *   · 底层 libuv 的 `fs__unlink_rmdir`（`src/win/fs.c`）**主动带**
+ *     `FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE`（Win10 1607+），老系统 fallback 也自己先清只读。
+ * ⇒ 只读属性在 libuv 那一层就已经被处理掉了，挡不住删除。
+ *
+ * 所以**清只读那一步降级为冗余保险**：不指望它救场，保留只因为成本极低、
+ * 且与 Node 自己的 `rimraf` 做法一致（`lib/internal/fs/rimraf.js` 的 `fixWinEPERM`：
+ * unlink 报 EPERM 时 Windows 上先 `chmod(path, 0o666)` 再重试，且把 chmod 失败当作可接受）。
+ *
+ * **没有真机证据**：POSIX 上造不出这个形态，Windows 上 libuv 已处理——两边都取不到。
+ * 判据因此落在行为上（测试用注入的假 fs）。
+ *
+ * ## 纪律（三条）
+ *
+ * 1. **只在删除这个明确意图下清只读，且只在第一次失败后做**——不是无差别预清。
+ *    先按现状删；删不掉才动属性，避免给正常路径增加副作用。
+ * 2. **只对 win32 做这一步**——POSIX 上 force 本来就够，多一步是无谓的副作用。
+ * 3. **仍失败就如实报错**——带上原始错误（EPERM/EBUSY 原文）、我们做了什么、以及它仍然失败。
+ *    不许静默降级，不许假装删成功。
+ *
+ * ## 清只读的做法（冗余保险）
+ *
+ * `chmodSync(path, 0o666)`：与 Node 的 `fixWinEPERM` 同一个值（POSIX 语义下 0o666 只是去掉写保护位）。
+ * 必须**递归**——只读的可能是 `node_modules` 里某个深层文件，只清顶层目录没用。
+ * 清属性本身失败（比如某个路径已经不存在了）不单独报错：继续清其余的，
+ * 真正的判据是**重试删除**的结果（与 Node 自己的取舍一致）。
+ *
+ * @param dir - 要删的目录。
+ * @param options - 注入点（测试用；生产路径用真实 fs 与 process.platform）。
+ * @returns 删除完成（成功时 resolve；仍失败时抛原始错误）。
+ */
+export declare function removeTreeWithReadonlyFallback(dir: string, options?: {
+    /** 删除操作（默认 rmSync recursive+force）。 */
+    readonly remove?: (path: string) => void;
+    /** 清只读（默认 chmodSync 0o666）。 */
+    readonly clearReadonly?: (path: string) => void;
+    /** 列出子项（默认 readdirSync；用于递归清只读）。 */
+    readonly list?: (path: string) => readonly string[];
+    /** 平台（默认 process.platform）；只有 win32 才走清只读那一步。 */
+    readonly platform?: string;
+}): Promise<void>;

package/dist/envManager.js

@@ -24,7 +24,7 @@
  * 官方 operations —— 差别只是传给 runPluginCommand 的 profile 参数，不是两套实现。
  */
 import { execFileSync, spawn, spawnSync } from 'node:child_process';
-import { accessSync, appendFileSync, closeSync, constants, copyFileSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from 'node:fs';
+import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { request as httpRequest } from 'node:http';
@@ -823,7 +823,8 @@ export async function removeEnvironment(name, options = {}) {
     }
     return enqueueMutation(async () => {
         try {
-            await retryFs(() => rmSync(dir, { recursive: true, force: true }));
+            // 走 Windows 只读兜底：环境目录里 node_modules 可能有只读文件，force 在 Windows 上删不掉。
+            await retryFs(async () => { await removeTreeWithReadonlyFallback(dir); });
         }
         catch (error) {
             return failure('io-failed', '删除失败 ' + name + '：' + messageOf(error));
@@ -2141,7 +2142,7 @@ export async function materializeSnapshot(sourceName, targetName, options = {})
         if (!existsSync(path))
             continue;
         try {
-            rmSync(path, { recursive: true, force: true });
+            await removeTreeWithReadonlyFallback(path);
         }
         catch (error) {
             throw new EnvironmentError('snapshot-not-shallow', '试装环境里还留着上一次试装的依赖文件，这次删不掉（' + messageOf(error)
@@ -2257,7 +2258,8 @@ export async function removeTrialEnvironment(name, options = {}) {
     }
     return enqueueMutation(async () => {
         try {
-            await retryFs(() => rmSync(dir, { recursive: true, force: true }));
+            // 走 Windows 只读兜底：环境目录里 node_modules 可能有只读文件，force 在 Windows 上删不掉。
+            await retryFs(async () => { await removeTreeWithReadonlyFallback(dir); });
         }
         catch (error) {
             return failure('io-failed', '删除测试环境失败 ' + name + '：' + messageOf(error));
@@ -3195,6 +3197,124 @@ async function officialBundlePredicate(installAnchor) {
  * @param operation - 要执行的文件操作。
  * @param attempts - 尝试次数上限。
  */
+/**
+ * 删除一棵树的兜底：第一次失败后（Windows 上）清掉只读属性，再重试一次。
+ *
+ * ## 这条兜底真正守的是什么
+ *
+ * **不是只读属性**——见下「修正说明」。它守的是两件与平台无关的事：
+ *
+ * 1. **失败后重试一次**：对**瞬时**失败有效（文件被别的进程短暂占用、索引/杀毒尚未释放、
+ *    `EBUSY`/`EPERM` 那一类会自己消失的原因）。这是真实世界里最常见的删除失败形态。
+ * 2. **三层如实报错**：原始错误 + 我们做了什么 + 仍然失败。**这一条才是真正的交付**——
+ *    删除失败时用户能看到「为什么」，而不是一个裸 EPERM。
+ *    （变异 M7/M8 钉的正是这两行：删掉它们测试当场红。）
+ *
+ * ## 修正说明（2026-09-20，理由改过，实现保留）
+ *
+ * 本函数原先的理由是「Windows 上 `rmSync` 的 force 不覆盖只读属性 → 删除会永远失败」。
+ * **那个论断是错的**：
+ *   · 那句话**不在 Node 文档里**（v16/v18/v20/v22/v24 的 doc/api/fs.md 逐版 grep 零命中）；
+ *   · 底层 libuv 的 `fs__unlink_rmdir`（`src/win/fs.c`）**主动带**
+ *     `FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE`（Win10 1607+），老系统 fallback 也自己先清只读。
+ * ⇒ 只读属性在 libuv 那一层就已经被处理掉了，挡不住删除。
+ *
+ * 所以**清只读那一步降级为冗余保险**：不指望它救场，保留只因为成本极低、
+ * 且与 Node 自己的 `rimraf` 做法一致（`lib/internal/fs/rimraf.js` 的 `fixWinEPERM`：
+ * unlink 报 EPERM 时 Windows 上先 `chmod(path, 0o666)` 再重试，且把 chmod 失败当作可接受）。
+ *
+ * **没有真机证据**：POSIX 上造不出这个形态，Windows 上 libuv 已处理——两边都取不到。
+ * 判据因此落在行为上（测试用注入的假 fs）。
+ *
+ * ## 纪律（三条）
+ *
+ * 1. **只在删除这个明确意图下清只读，且只在第一次失败后做**——不是无差别预清。
+ *    先按现状删；删不掉才动属性，避免给正常路径增加副作用。
+ * 2. **只对 win32 做这一步**——POSIX 上 force 本来就够，多一步是无谓的副作用。
+ * 3. **仍失败就如实报错**——带上原始错误（EPERM/EBUSY 原文）、我们做了什么、以及它仍然失败。
+ *    不许静默降级，不许假装删成功。
+ *
+ * ## 清只读的做法（冗余保险）
+ *
+ * `chmodSync(path, 0o666)`：与 Node 的 `fixWinEPERM` 同一个值（POSIX 语义下 0o666 只是去掉写保护位）。
+ * 必须**递归**——只读的可能是 `node_modules` 里某个深层文件，只清顶层目录没用。
+ * 清属性本身失败（比如某个路径已经不存在了）不单独报错：继续清其余的，
+ * 真正的判据是**重试删除**的结果（与 Node 自己的取舍一致）。
+ *
+ * @param dir - 要删的目录。
+ * @param options - 注入点（测试用；生产路径用真实 fs 与 process.platform）。
+ * @returns 删除完成（成功时 resolve；仍失败时抛原始错误）。
+ */
+export async function removeTreeWithReadonlyFallback(dir, options = {}) {
+    const remove = options.remove ?? ((path) => { rmSync(path, { recursive: true, force: true }); });
+    const clearReadonly = options.clearReadonly ?? ((path) => { chmodSync(path, 0o666); });
+    const list = options.list ?? ((path) => readdirSync(path));
+    const platform = options.platform ?? process.platform;
+    try {
+        remove(dir);
+        return;
+    }
+    catch (error) {
+        // 纪律 2：非 Windows 不折腾属性——POSIX 上 force 本来就够。
+        if (platform !== 'win32')
+            throw error;
+        const first = error;
+        // 纪律 1：到这里说明第一次真的失败了，才清只读。
+        clearReadonlyRecursive(dir, { clearReadonly, list });
+        try {
+            // 重试**一次**。
+            remove(dir);
+            return;
+        }
+        catch (retryError) {
+            // 纪律 3：如实报错——原始错误 + 我们做了什么 + 仍然失败。
+            // 文案按 §12.9 的 R2 规则写成**树状**（一层一个因果，每行最多一个冒号）：
+            // 结论 → 原始错误 → 我们做了什么 → 仍然失败的原因。
+            throw new Error([
+                '删除失败，Windows 只读属性兜底也没能删掉',
+                '  原始错误 ' + describeError(first),
+                '    → 已递归清除只读属性，并重试了一次',
+                '      → 仍然失败 ' + describeError(retryError),
+            ].join(String.fromCharCode(10)));
+        }
+    }
+}
+/**
+ * 递归清掉一棵树的只读属性（best-effort）。
+ *
+ * 为什么递归：只读的可能是 `node_modules` 里某个深层文件；只清顶层目录没有用。
+ * 单个路径失败不中断——继续清其余的，让**重试删除**去给出最终判据。
+ *
+ * @param root - 根路径。
+ * @param deps - 注入的 fs 操作。
+ */
+function clearReadonlyRecursive(root, deps) {
+    const walk = (path) => {
+        try {
+            deps.clearReadonly(path);
+        }
+        catch {
+            // 清不掉就往下走：最终判据是重试删除的结果，不是这里。
+        }
+        let children;
+        try {
+            children = deps.list(path);
+        }
+        catch {
+            // 读不到子项（可能是文件，或已不存在）：到此为止。
+            return;
+        }
+        for (const child of children)
+            walk(join(path, child));
+    };
+    walk(root);
+}
+/** 错误文本（带 code，便于用户排查）。 */
+function describeError(error) {
+    const code = error.code;
+    const text = error instanceof Error ? error.message : String(error);
+    return code === undefined ? text : code + '（' + text + '）';
+}
 async function retryFs(operation, attempts = 5) {
     const sleep = (ms) => new Promise((done) => { setTimeout(done, ms); });
     for (let attempt = 0;; attempt += 1) {

package/dist/fix.js

@@ -8,11 +8,13 @@
  *   前提已变：官方现在拥有组合的写权，而它**没有**删行能力。我们不再自己写那个文件，
  *   改为如实回 needs-manual —— 见 applyFix 的 JSDoc。
  */
-import { existsSync } from "node:fs";
+import { existsSync, unlinkSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
-import { environmentDir } from "./paths.js";
+import { dshHome, environmentDir } from "./paths.js";
 import { requireManager } from "./official.js";
+import { cleanupDanglingLinks, moduleFallbackDir, readModuleFallbackClosure, scanModuleFallback } from "./moduleFallback.js";
+import { readInstallAnchor } from "./diagnostics.js";
 /**
  * 需要用户手工处理的两条：它们都要求改 cordis.patch.yml 的**结构**（删行）。
  *
@@ -85,6 +87,8 @@ export async function applyFix(action, target, deps) {
                 if (target === undefined)
                     return failed(action, "缺少 target（包名）");
                 return await removeOfficialCopy(target, deps);
+            case "remove-dangling-module-fallback-links":
+                return await removeDanglingModuleFallbackLinks(deps);
             default:
                 return { ok: false, action, status: "failed", output: "未知修复动作：" + action };
         }
@@ -122,6 +126,73 @@ function manualOutcome(action, target) {
 function failed(action, output, target) {
     return { ok: false, action, ...(target === undefined ? {} : { target }), status: "failed", output };
 }
+/**
+ * 删掉依赖兜底目录（`$DSH_HOME/profiles/node_modules`）里的**断链**。
+ *
+ * 为什么这条修复自己动手删、而不找官方通道：官方**没有**清理这个目录的通道——
+ * `healProfilesModuleFallback` 只增不删（判据 `entries.every(...)` 只问"该有的到位没"，
+ * 写入路径只遍历 entries、无 readdir/unlink）。旧代际留下的断链因此永远不会自己消失。
+ *
+ * 安全边界（三条，代码里逐条落实）：
+ * 1. **只删符号链接**：每条都 `lstatSync().isSymbolicLink()` 确认；绝不递归删目录。
+ * 2. **只删断链**：删除前重新确认目标仍不存在（扫描到删除之间可能被别的进程动过）。
+ * 3. **结果如实**：删了几条 / 跳过几条 / 为什么 / 哪几条失败，逐条写进 output。
+ *
+ * 这不是 profile 的组合写入，所以不需要官方文件锁：它不碰 package.json、不碰 cordis.patch.yml，
+ * 删的只是共享兜底层里指向已消失目标的链接。
+ *
+ * @param deps - 修复依赖（需要 ctx 拿 DSH home 与安装锚点）。
+ * @returns 执行结果。
+ */
+async function removeDanglingModuleFallbackLinks(deps) {
+    const action = "remove-dangling-module-fallback-links";
+    try {
+        const home = dshHome();
+        const dir = moduleFallbackDir(home);
+        const envDir = environmentDir(deps.environmentName() ?? "");
+        const anchor = readInstallAnchor(deps.ctx);
+        const closure = await readModuleFallbackClosure(anchor, home);
+        const scan = scanModuleFallback(dir, closure);
+        if (!scan.scanned) {
+            return {
+                ok: false, action, status: "failed",
+                output: "没有扫到可清理的依赖兜底目录（" + dir + "）："
+                    + (scan.exists ? "当前安装的依赖闭包算不出来（" + String(scan.closureReason ?? "原因未知") + "）" : "目录不存在"),
+            };
+        }
+        // 注意：**没有断链也要往下走**——上一轮可能已经删完链接，但留下了空的 scope 目录。
+        // 真机就是这个状态（Lead 执行过一次清理：516 条链接归零，剩 29 个空 @scope 目录）。
+        // 早退会让那些空目录永远清不掉。
+        const result = cleanupDanglingLinks(dir, scan, path => { unlinkSync(path); });
+        const lines = [
+            "依赖兜底目录：" + dir,
+            "断链 " + String(scan.dangling.length) + " 条 → 已删 " + String(result.removed)
+                + " 条，跳过 " + String(result.skipped) + " 条，失败 " + String(result.failed) + " 条",
+        ];
+        if (result.removedScopes.length > 0) {
+            lines.push("变空的 scope 目录 → 已删 " + String(result.removedScopes.length) + " 个："
+                + result.removedScopes.join("、"));
+        }
+        else if (result.scopeSkipReasons.length === 0) {
+            lines.push("没有变空的 scope 目录");
+        }
+        if (result.scopeSkipReasons.length > 0) {
+            lines.push("", "scope 目录未删：", ...result.scopeSkipReasons.map(r => "  - " + r));
+        }
+        if (result.skipReasons.length > 0)
+            lines.push("", "跳过原因：", ...result.skipReasons.map(r => "  - " + r));
+        if (result.failures.length > 0)
+            lines.push("", "失败：", ...result.failures.map(r => "  - " + r));
+        if (scan.stale.length > 0) {
+            lines.push("", "完好但过时的 " + String(scan.stale.length) + " 条**没有动**（目标还在，按约定只报不删）");
+        }
+        void envDir;
+        return { ok: result.failed === 0, action, status: result.failed === 0 ? "executed" : "failed", output: lines.join(String.fromCharCode(10)) };
+    }
+    catch (error) {
+        return failed(action, error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * 删掉 profile 里重复的官方包拷贝，并把声明从 dependencies 挪到 peerDependencies。
  *