@noob-stupid/dsh-plugin-console 0.5.98 → 0.5.99

package/lib/client.js

@@ -1,4 +1,4 @@
-window.__ModuleLoader__.load({
+window.__ModuleLoader__.load({
 	id: "@noob-stupid/dsh-plugin-console",
 	factory: (require) => {
 		var module = { exports: {} };
@@ -405,6 +405,29 @@
 			gateForgetDoneStale: "已清理 {n} 条失效记录（插件与补丁一个字都没动）",
 			gateForgetNone: "没有可删除的记录（文件未改动）",
 			gateForgetFailed: "删除失败：",
+			// ★ 0.5.100 加法（用户 2026-11-02）：「按需检查」—— 预检只在升级前跑，平时门控是空的，
+			//   0 条会被误读成"全部兼容"。这里给一个"现在查一次"的入口 + 空态说明 + 上次检查摘要。
+			gateScanBtn: "检查当前是否适配",
+			gateScanBusy: "正在检查…",
+			gateScanTitle: "对当前补丁里的行跑一次适配判定：只记录结论，不禁用任何行",
+			gateScanNoTargets: "当前没有可检查的行（补丁里没有可判定的插件行），所以不显示检查按钮",
+			gateScanDone: "检查 {n} 行：通过 {p} / 不适配 {f} / 无法判定 {u}",
+			gateScanFailed: "检查失败：",
+			gateNoRecordsHint: "本次没有裁决记录（预检只在升级前运行，可点上面按钮检查）",
+			gateLastScan: "上次检查（{at}）：{n} 行 · 通过 {p} / 不适配 {f} / 无法判定 {u}",
+			// ★ 0.5.101 加法（用户 2026-11-02）：**加载失败的行**（运行期挂载失败）分区 + 两段式停用。
+			//   与"适配裁决"分开：这类失败不经过预扫/隔离链，**不写 compat-pending.json**。
+			gateLoadFailedTitle: "加载失败的行（{n} 行 · 运行期挂载失败）",
+			gateLoadFailedHint: "这些行是**运行期加载失败**（例：某个依赖包解析不到），不是适配裁决，也不会写进适配记录；可在此停用它们。",
+			gateLoadDisable: "停用",
+			gateLoadDisableTitle: "停用这一行（会往补丁里写一条 disabled 块；点一下先确认）",
+			gateLoadArmRow: "将停用 {id}（{name}）。",
+			gateLoadSafety: "这会往 profile 补丁里写一条 disabled 块（可随时在列表里重新启用）；不会卸载包、不会动其它行。",
+			gateLoadConfirm: "确认停用",
+			gateLoadCancel: "取消",
+			gateLoadFailedDone: "已请求停用 {id}（补丁已更新，HMR 应用后列表会随之变化）",
+			gateLoadFailedGone: "该行已不在运行时列表里（可能已被删除），本动作没有发请求",
+			gateLoadFailedFailed: "停用失败：",
 			// ★ 0.5.x 加法（用户 2026-10-18）：「安全启动」在界面上的入口 —— 门控面板里的一个分区。
 			//   用户原话「现在这能力藏得太深，只有命令行能用」；这里只做展示 + 两段式上膛，
 			//   判据与动作白名单全在服务端 POST /plugin-console/safe-boot。
@@ -1198,6 +1221,27 @@
 			gateForgetDoneStale: "Removed {n} invalid record(s) (plugins and patch file untouched)",
 			gateForgetNone: "Nothing to delete (file unchanged)",
 			gateForgetFailed: "Delete failed: ",
+			// ★ 0.5.100 additive (user 2026-11-02): on-demand adaptation check in the gating panel.
+			gateScanBtn: "Check current compatibility",
+			gateScanBusy: "Checking…",
+			gateScanTitle: "Runs the adaptation verdict over the rows in the current patch: records conclusions only, disables nothing",
+			gateScanNoTargets: "No rows to check (the patch has no judgeable plugin rows), so the check button is not shown",
+			gateScanDone: "Checked {n} row(s): pass {p} / incompatible {f} / undecidable {u}",
+			gateScanFailed: "Check failed: ",
+			gateNoRecordsHint: "No verdict records yet (the pre-scan only runs before an upgrade — use the button above to check now)",
+			gateLastScan: "Last check ({at}): {n} row(s) · pass {p} / incompatible {f} / undecidable {u}",
+			// ★ 0.5.101 additive (user 2026-11-02): rows that FAILED TO LOAD at runtime.
+			gateLoadFailedTitle: "Rows that failed to load ({n} · runtime mount failure)",
+			gateLoadFailedHint: "These rows failed to load at runtime (e.g. a dependency cannot be resolved). This is not an adaptation verdict and is never written to the adaptation records; you can disable them here.",
+			gateLoadDisable: "Disable",
+			gateLoadDisableTitle: "Disable this row (writes a disabled block into the patch; click once to confirm)",
+			gateLoadArmRow: "Row {id} ({name}) will be disabled.",
+			gateLoadSafety: "This writes one disabled block into the profile patch (you can re-enable it from the list at any time); it does not uninstall the package and does not touch other rows.",
+			gateLoadConfirm: "Confirm disable",
+			gateLoadCancel: "Cancel",
+			gateLoadFailedDone: "Disable requested for {id} (the patch is updated; the list follows once HMR applies)",
+			gateLoadFailedGone: "This row is no longer in the runtime list (it may have been removed), so no request was sent",
+			gateLoadFailedFailed: "Disable failed: ",
 			gateRowAt: " · {t}",
 			gateRowAdoptable: " · passed the source scan, can be unlocked",
 			safeBootSectionTitle: "Safe boot",
@@ -5854,6 +5898,56 @@ const RESTART_FAILED_NOTE = "重启请求失败";
 			const [gateForgetArmed, setGateForgetArmed] = react.useState(null); // { kind: "row", rowId, moduleName } | { kind: "stale" }
 			const [gateForgetBusy, setGateForgetBusy] = react.useState(false);
 			const [gateForgetNote, setGateForgetNote] = react.useState(null); // { text, level }
+			// ★ 0.5.100 加法：「按需检查」的按钮状态与结果反馈（用户 2026-11-02「平时不预检」）。
+			//   `gateScanTargets` = 当前**可检查**的行数（有 rowId 且不是控制台自己）：为 0 时不摆按钮。
+			const gateScanTargets = gateReady && Array.isArray(state.data.entries)
+				? state.data.entries.filter((e) => typeof e?.rowId === "string" && e.rowId !== "" && e.rowId !== "plugin-console").length
+				: 0;
+			const gateLastScan = gateReady && state.data.compatPending !== null && state.data.compatPending !== undefined
+				? (state.data.compatPending.lastScan ?? null)
+				: null;
+			const [gateScanBusy, setGateScanBusy] = react.useState(false);
+			const [gateScanNote, setGateScanNote] = react.useState(null); // { text, level }
+			/** 一键「检查当前是否适配」：服务端只记录结论、绝不禁用任何行；成功/失败都要有明确反馈。 */
+			const gateScanSend = () => {
+				if (gateScanBusy) return;
+				setGateScanBusy(true);
+				setGateScanNote(null);
+				call("/plugin-console/compat-gate", { action: "scan-current" }).then(
+					(data) => {
+						const n = Number(data?.checked ?? 0);
+						const p = Number(data?.pass ?? 0);
+						const f = Number(data?.fail ?? 0);
+						const u = Number(data?.unknown ?? 0);
+						setGateScanNote({ text: t("gateScanDone").replace("{n}", String(n)).replace("{p}", String(p)).replace("{f}", String(f)).replace("{u}", String(u)), level: null });
+						refresh(); // 结论落盘了 ⇒ 重拉 /state（列表、计数、"上次检查"一起变）
+					},
+					(error) => setGateScanNote({ text: t("gateScanFailed") + friendlyGithubError(error).message, level: "error" }),
+				).finally(() => setGateScanBusy(false));
+			};
+			// ★ 0.5.101 加法（用户 2026-11-02）：**运行期加载失败**的行（`fiberPhase === 'failed'`）。
+			//   真机：`experimental-inspector` 因 `@deepseek-ai/cordis` 解析失败挂载失败，门控完全看不到
+			//   —— 那条失败不经过预扫/隔离链。这里只做**视图**（服务端 gating.loadFailed；**从不**写
+			//   compat-pending.json，那是适配裁决记录）；停用仍是用户的动作（两段式，落到既有 /toggle）。
+			const gateLoadFailed = gateReady && gateRows !== null && Array.isArray(gateRows.loadFailed) ? gateRows.loadFailed : [];
+			const [gateLoadArmed, setGateLoadArmed] = react.useState(null); // { rowId, name }
+			const [gateLoadNote, setGateLoadNote] = react.useState(null); // { text, level }
+			const gateLoadEntry = (rowId) => (gateReady && Array.isArray(state.data.entries)
+				? (state.data.entries.find((e) => e.rowId === rowId) ?? null)
+				: null);
+			/** 两段式第一段：只上膛（零请求）。 */
+			const gateLoadArm = (next) => { setGateLoadNote(null); setGateLoadArmed(next); };
+			/** 确认后才真发：走**既有** /toggle（enabled:false），成功后刷新。 */
+			const gateLoadDisable = (armed) => {
+				const entry = armed === null ? null : gateLoadEntry(armed.rowId);
+				setGateLoadArmed(null);
+				setGateLoadNote(null);
+				if (entry === null) { setGateLoadNote({ text: t("gateLoadFailedFailed") + t("gateLoadFailedGone"), level: "error" }); return; }
+				call("/plugin-console/toggle", { entryId: entry.entryId, enabled: false }).then(
+					() => { setGateLoadNote({ text: t("gateLoadFailedDone").replace("{id}", String(armed.rowId)), level: null }); refresh(); },
+					(error) => setGateLoadNote({ text: t("gateLoadFailedFailed") + friendlyGithubError(error).message, level: "error" }),
+				);
+			};
 			/** 两段式的第一段：只上膛，一个请求都不发（换目标 = 换载荷，旧载荷不会跟着发出去）。 */
 			const gateForgetArm = (next) => { setGateForgetNote(null); setGateForgetArmed(next); };
 			/** 唯一出口：真发删除请求（成功后刷新 /state，列表与计数一起变）。 */
@@ -6808,6 +6902,43 @@ const RESTART_FAILED_NOTE = "重启请求失败";
 								el("p", { className: styles.message }, t("compatGateHint")),
 								el("p", { className: styles.status, "data-pending": gatePendingCount > 0 ? "true" : undefined, "data-gate-pending": String(gatePendingCount), "data-gate-stale": String(gateStaleCount) },
 									gatePendingCount > 0 ? t("gatePendingInfo").replace("{n}", String(gatePendingCount)) : t("gatePendingNone")),
+								// ★ 0.5.100 加法（用户 2026-11-02「我们一般情况下都不预检吧」）：
+								//   预检只在**升级前**跑，所以平时门控是空的 —— 而 0 条会被误读成"全部兼容"。
+								//   这里给两件事：① 一个「现在查一次」的按钮（判据复用服务端框架升级预扫那条链，
+								//   **只记录结论、不禁用任何行**）；② 没有裁决记录时的说明 + 上次检查的摘要。
+								//   零行可查时**不摆按钮**，并说明为什么（不许出现点了必然没反应的按钮）。
+								gateScanTargets === 0
+									? el("p", { className: styles.status, "data-gate-scan-none": "true" }, t("gateScanNoTargets"))
+									: el("div", { style: { flexDirection: "row", gap: 8, display: "flex", alignItems: "center" } },
+										el("button", {
+											type: "button",
+											className: styles.toggle,
+											"aria-label": "gateScanCurrent",
+											disabled: gateScanBusy,
+											title: t("gateScanTitle"),
+											onClick: () => { gateScanSend(); },
+										}, gateScanBusy ? t("gateScanBusy") : t("gateScanBtn"))),
+								gateScanNote === null
+									? null
+									: el("p", {
+										className: styles.message,
+										"data-gate-scan-note": "true",
+										"data-error": gateScanNote.level === "error" ? "true" : undefined,
+										style: gateScanNote.level === "error" ? undefined : { color: "var(--dsw-alias-state-success-primary)" },
+									}, String(gateScanNote.text ?? "—")),
+								gateLastScan === null
+									? null
+									: el("p", { className: styles.status, "data-gate-lastscan": "true" },
+										t("gateLastScan")
+											.replace("{at}", gateTime(gateLastScan.at))
+											.replace("{n}", String(gateLastScan.checked ?? 0))
+											.replace("{p}", String(gateLastScan.pass ?? 0))
+											.replace("{f}", String(gateLastScan.fail ?? 0))
+											.replace("{u}", String(gateLastScan.unknown ?? 0))),
+								// 门控为空时的明确文案：不让 0 条看起来像"全绿"（用户 2026-11-02 点名）
+								gateRows === null || gateRows.pendingCount + gateRows.adoptedCount === 0
+									? el("p", { className: styles.status, "data-gate-empty-hint": "true" }, t("gateNoRecordsHint"))
+									: null,
 																			// 明细清单（2026-09-24 用户要求：面板要能看到是哪些插件，有列表数据）
 							gateRows !== null && gateRows.pendingCount + gateRows.adoptedCount > 0
 								? el("div", { style: { flexDirection: "column", gap: 6, display: "flex" } },
@@ -6890,6 +7021,64 @@ const RESTART_FAILED_NOTE = "重启请求失败";
 												: null)
 										: null)
 								: null,
+							// ★ 0.5.101 加法（用户 2026-11-02）：**加载失败的行**分区。
+							//   与"适配裁决"是两件事：这些行是**运行期挂载失败**（例：某个依赖包解析不到），
+							//   不经过预扫/隔离链，所以也**不会写进 compat-pending.json**；这里给的是视图 +
+							//   「停用」（两段式，落到既有 /toggle，真的写补丁 disabled 块）。
+							//   零失败行时整个分区不出现（不摆空壳）。
+							gateLoadFailed.length === 0
+								? null
+								: el("div", {
+									"data-gate-loadfailed": "true",
+									style: { flexDirection: "column", gap: 6, display: "flex", marginTop: 4, paddingTop: 8, borderTop: "1px solid var(--dsw-alias-border-l2)" },
+								},
+									el("strong", { className: styles.name }, t("gateLoadFailedTitle").replace("{n}", String(gateLoadFailed.length))),
+									el("p", { className: styles.status }, t("gateLoadFailedHint")),
+									gateLoadFailed.map((r) => el("div", {
+										key: "lf-" + String(r.rowId),
+										"data-gate-loadfailed-row": String(r.rowId),
+										style: { flexDirection: "column", gap: 2, display: "flex", padding: "4px 0" },
+									},
+										el("span", { className: styles.name }, "⛔ " + String(r.moduleName ?? r.rowId) + (r.version ? "  v" + r.version : "")),
+										el("span", { className: styles.status, "data-gate-loadfailed-module": "true" },
+											t("gateRowModule") + " " + (typeof r.moduleName === "string" && r.moduleName !== "" ? r.moduleName : "—")
+											+ " · " + String(r.fiberPhase ?? "failed"),
+											el("button", {
+												type: "button",
+												className: styles.toggle,
+												style: { marginLeft: 8, fontSize: 11, padding: "1px 6px" },
+												"aria-label": "gateLoadDisable",
+												"data-gate-load-disable": String(r.rowId),
+												title: t("gateLoadDisableTitle"),
+												onClick: () => gateLoadArm({ rowId: String(r.rowId), name: typeof r.moduleName === "string" ? r.moduleName : null }),
+											}, t("gateLoadDisable"))))),
+									gateLoadArmed === null
+										? null
+										: el("div", { "data-gate-load-armed": "true", style: { flexDirection: "column", gap: 6, display: "flex", borderLeft: "2px solid var(--dsw-alias-state-warning-primary)", paddingLeft: 8 } },
+											el("p", { className: styles.message, "data-warn": "true", "data-gate-load-text": "true" },
+												t("gateLoadArmRow").replace("{id}", String(gateLoadArmed.rowId)).replace("{name}", String(gateLoadArmed.name ?? "—"))),
+											el("p", { className: styles.status }, t("gateLoadSafety")),
+											el("div", { style: { flexDirection: "row", gap: 8, display: "flex" } },
+												el("button", {
+													type: "button",
+													className: styles.toggle,
+													"aria-label": "gateLoadConfirm",
+													onClick: () => { gateLoadDisable(gateLoadArmed); },
+												}, t("gateLoadConfirm")),
+												el("button", {
+													type: "button",
+													className: styles.toggle,
+													"aria-label": "gateLoadCancel",
+													onClick: () => { setGateLoadArmed(null); setGateLoadNote(null); },
+												}, t("gateLoadCancel")))),
+									gateLoadNote === null
+										? null
+										: el("p", {
+											className: styles.message,
+											"data-gate-load-note": "true",
+											"data-error": gateLoadNote.level === "error" ? "true" : undefined,
+											style: gateLoadNote.level === "error" ? undefined : { color: "var(--dsw-alias-state-success-primary)" },
+										}, String(gateLoadNote.text ?? "—"))),
 							// ★ 0.5.98 加法：删除的**两段式**确认区 + 结果反馈（都留在面板上，不弹系统对话框）。
 							//   上膛时把"要删什么、不会动什么"写清楚：只删记录，不动插件、不动补丁文件。
 							gateForgetArmed === null

package/lib/server/domain/compat-pending-records.js

@@ -241,6 +241,104 @@ function applyPendingForget(plan, deps = {}) {
   return { ...plan, backup, verified: true, rolledBack: false }
 }
 
+/**
+ * 规划一次「把扫描结论并进记录」（**纯函数，不写盘**；0.5.100 加法）。
+ *
+ * 语义（只加不删）：
+ *   · 传入的记录按 `rowId` **合并**进 `pending` 数组：已有则覆盖结论字段（并保持**同一条记录**的位置），
+ *     没有则追加；其余记录（含历史 adopted、别人的记录）**一个字都不动**；
+ *   · 只接受 `status`/`check`/`checkNote`/`version`/`moduleName`/`source`/`scanVerdict` 这些结论字段的更新；
+ *   · 额外写一条 `lastScan` 摘要（`{ at, frameworkVersion, checked, pass, fail, unknown, skipped, source }`）——
+ *     它让面板能说"上次检查了几个、结果如何"，而不是让 0 条记录看起来像"全绿"；
+ *   · 没有变化时 `changed:false` ⇒ 调用方**零写盘**（幂等）。
+ */
+function planScanMerge({ read, records, lastScan, frameworkVersion = null } = {}) {
+  const base = { ok: false, status: 400, error: null, file: read?.file ?? null, next: null, changed: false, added: [], updated: [], lastScan: lastScan ?? null }
+  if (read === null || typeof read !== 'object') return { ...base, error: '内部错误：没有读到记录文件' }
+  if (read.exists === true && read.corrupt === true) {
+    return { ...base, status: 409, error: `${read.file} 读不出来（${read.error ?? '格式非法'}）；为保住你的数据，本次扫描结果**没有写盘**（请先手工修好或删掉它）` }
+  }
+  const incoming = (Array.isArray(records) ? records : []).filter((r) => r !== null && typeof r === 'object' && typeof r.rowId === 'string' && r.rowId !== '')
+  const raw = read.raw === null || typeof read.raw !== 'object' ? { pending: [] } : read.raw
+  const current = (Array.isArray(raw.pending) ? raw.pending : []).filter((r) => r !== null && typeof r === 'object')
+  const next = { ...raw, pending: [...current] }
+  const added = []
+  const updated = []
+  // 「结论」= 只有这些字段变了才算真的变了；`scannedAt` 之类的时间戳**不算**变化 ——
+  // 否则每点一次「检查」都会重写一遍文件（也就每次留一份备份），幂等就名存实亡了。
+  const conclusionKey = (r) => JSON.stringify([
+    r?.status ?? null, r?.check ?? null, r?.checkNote ?? null, r?.version ?? null,
+    r?.moduleName ?? null, r?.source ?? null, r?.frameworkVersion ?? null,
+    r?.scanVerdict?.version ?? null, r?.scanVerdict?.decision ?? null,
+  ])
+  for (const rec of incoming) {
+    const at = next.pending.findIndex((p) => p?.rowId === rec.rowId)
+    if (at < 0) {
+      next.pending.push({ ...rec })
+      added.push(rec.rowId)
+      continue
+    }
+    const before = next.pending[at]
+    if (conclusionKey(before) === conclusionKey(rec)) continue // 结论没变 ⇒ 这条记录一个字都不动
+    next.pending[at] = { ...before, ...rec }
+    updated.push(rec.rowId)
+  }
+  if (typeof frameworkVersion === 'string' && frameworkVersion !== '') next.frameworkVersion = frameworkVersion
+  // lastScan 摘要：只在**摘要本身**变了（或还没有摘要）时才更新 —— 时间戳不算变化
+  if (lastScan !== null && lastScan !== undefined) {
+    const summaryKey = (s) => (s === null || s === undefined ? '' : JSON.stringify([s.checked, s.pass, s.fail, s.unknown, s.skipped, s.frameworkVersion, s.source]))
+    if (summaryKey(raw.lastScan) !== summaryKey(lastScan)) next.lastScan = lastScan
+  }
+  // 文件还不存在、也没有任何结论要写 ⇒ **连文件都不建**（零行可查时不留空壳文件）
+  if (read.exists !== true && added.length === 0 && updated.length === 0) {
+    return { ...base, ok: true, status: 200, next: raw, changed: false, added, updated }
+  }
+  const changed = JSON.stringify(next) !== JSON.stringify(raw)
+  return { ...base, ok: true, status: 200, next: changed ? next : raw, changed, added, updated }
+}
+
+/**
+ * 执行一次「整份记录的安全写入」：备份 → 原子写（临时文件 + rename）→ **读回核实** → 失败回滚。
+ * `verify(back)` 返回 `null` 表示核实通过，返回字符串表示为什么不通过（写进错误信息）。
+ * 与 `applyPendingForget` 同一套纪律，只是判据由调用方给（扫描合并与删除要核实的东西不一样）。
+ */
+function applyPendingWrite({ file, next, verify = null, tag = 'scan', deps = {} } = {}) {
+  const plan = { ok: true, status: 200, error: null, file: typeof file === 'string' ? file : null, changed: true, backup: null, verified: false, rolledBack: false }
+  if (plan.file === null || next === null || typeof next !== 'object') {
+    return { ...plan, ok: false, status: 400, error: '内部错误：缺少目标文件或内容' }
+  }
+  const io = {
+    copy: deps.copyFileSync ?? copyFileSync,
+    write: deps.writeFileSync ?? writeFileSync,
+    rename: deps.renameSync ?? renameSync,
+    remove: deps.unlinkSync ?? unlinkSync,
+    exists: deps.existsSync ?? existsSync,
+    read: deps.readFileSync ?? readFileSync,
+  }
+  const stamp = Date.now()
+  const backup = `${plan.file}.bak-${tag}-${stamp}`
+  const tmp = `${plan.file}.tmp-${tag}-${stamp}`
+  const rollback = (extra) => {
+    try { if (io.exists(backup)) io.copy(backup, plan.file) } catch {}
+    try { if (io.exists(tmp)) io.remove(tmp) } catch {}
+    return { ...plan, ...extra, backup, verified: false, rolledBack: io.exists(backup) }
+  }
+  try {
+    if (io.exists(plan.file)) io.copy(plan.file, backup)
+    io.write(tmp, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+    io.rename(tmp, plan.file)
+  } catch (error) {
+    return rollback({ ok: false, status: 500, error: `写入 ${plan.file} 失败：${String(error?.message ?? error)}（已回滚，文件保持原样）` })
+  }
+  let back = null
+  try { back = JSON.parse(io.read(plan.file, 'utf8')) } catch (error) {
+    return rollback({ ok: false, status: 500, error: `写入后读回失败：${String(error?.message ?? error)}（已回滚）` })
+  }
+  const why = typeof verify === 'function' ? verify(back) : null
+  if (why !== null && why !== undefined) return rollback({ ok: false, status: 500, error: `写入后读回内容与期望不一致（${String(why)}），已回滚` })
+  return { ...plan, backup, verified: true, rolledBack: false }
+}
+
 export {
   PENDING_STATUS,
   liveRowIdsFromPatch,
@@ -252,4 +350,6 @@ export {
   planForgetRecord,
   planForgetStale,
   applyPendingForget,
+  planScanMerge,
+  applyPendingWrite,
 }

package/lib/server/domain/compat-scan.js

@@ -0,0 +1,106 @@
+// L1 · domain —— compat-scan.js（门控的「按需检查」：对当前补丁里的行跑一次适配判定；0.5.100 加法）
+//
+// ── 为什么需要（用户 2026-11-02 原话：「我们一般情况下都不预检吧」）──────────────────────────
+// compat-pending 只在**框架升级前预扫**与**启动失败隔离**时写入。平时门控里一条记录都没有，
+// 而"0 条"会被误读成"全部兼容" —— 这不是事实，只是**没人裁决过**。
+// 这个模块给门控一个「现在查一下」的入口：对当前补丁里的行逐行跑判定，把结论如实记下来。
+//
+// ── 三条硬约束（一条都不许放宽）──────────────────────────────────────────────────────
+//   ① **判据只有一份**：复用 `checkPluginFrameworkCompat`（框架升级预扫那条唯一链路里的判定函数，
+//      含"源码里是否还引用已删除的 dsh-settings API"这条硬判据）。这里不新增任何兼容判据。
+//   ② **只记录结论，绝不禁用任何行**：禁用是用户的动作（`/toggle`）。本模块不 import
+//      `disableEntry`、不碰补丁文件 —— 扫描前后补丁必须逐字节不变。
+//   ③ **只把判为不适配（fail）的行写进记录**：pass / unknown 只进统计。
+//      为什么不能全写：`status:'pending'` 的记录会让 `/toggle` 对该行走"软禁"确认流程（409 +
+//      风险确认），把通过的行也写进去等于凭空给用户加一道墙 —— 那是行为变更，不是记录。
+//
+// 读/写 compat-pending.json 的纪律在 domain/compat-pending-records.js（备份 → 原子写 → 读回核实 → 回滚）。
+import { readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { resolvePackageJson } from '../infra/paths.js'
+import { SCANNER_VERSION } from './compat-verdict.js'
+import { checkPluginFrameworkCompat, isFrameworkOwnedPackage } from './compat.js'
+
+/** 记录里标注的来源（面板/日志靠它区分"这次是谁裁决的"）。 */
+const SCAN_SOURCE = 'manual-scan'
+/** 控制台自己永不参与扫描（它要是被判 fail，用户连面板都打不开）。 */
+const SELF_ROW_ID = 'plugin-console'
+
+/**
+ * 对**当前 loader 行**逐行跑一次适配判定（纯读：不写盘、不禁用、不改补丁）。
+ *
+ * @param {object} p
+ * @param {Array<object>} p.entries  loader 条目（`listEntries()` 的结果）
+ * @param {string} p.profileDir      profile 目录（解析已装包用）
+ * @param {string|null} p.frameworkVersion 当前框架版本（拿不到 => 全部 unknown，如实标注）
+ * @param {object} [p.deps]          注入缝：`resolvePkg` / `readPkg`
+ * @returns {{ ok: boolean, results: Array<object>, checked: number, pass: number, fail: number, unknown: number,
+ *             skipped: Array<{rowId: string|null, reason: string}>, frameworkVersion: string|null, error: string|null }}
+ */
+function planCurrentScan({ entries, profileDir, frameworkVersion = null, deps = {} } = {}) {
+  const resolvePkg = deps.resolvePkg ?? resolvePackageJson
+  const readPkg = deps.readPkg ?? ((p) => JSON.parse(readFileSync(p, 'utf8')))
+  const results = []
+  const skipped = []
+  const fwVer = typeof frameworkVersion === 'string' && frameworkVersion !== '' ? frameworkVersion : null
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const rowId = typeof entry?.rowId === 'string' ? entry.rowId : ''
+    if (rowId === '') { skipped.push({ rowId: null, reason: 'no-row-id' }); continue }
+    if (rowId === SELF_ROW_ID) { skipped.push({ rowId, reason: 'console-self' }); continue }
+    const moduleName = typeof entry?.moduleName === 'string' ? entry.moduleName : ''
+    let pkgPath = null
+    try { pkgPath = moduleName === '' ? null : resolvePkg(moduleName, profileDir) } catch { pkgPath = null }
+    if (pkgPath === null) { skipped.push({ rowId, reason: 'package-unreadable', moduleName }); continue }
+    let pkg = null
+    try { pkg = readPkg(pkgPath) } catch { pkg = null }
+    if (pkg === null || typeof pkg !== 'object') { skipped.push({ rowId, reason: 'package-unreadable', moduleName }); continue }
+    const pkgDir = dirname(pkgPath)
+    let check = null
+    if (fwVer === null) check = { decision: 'unknown', reason: '拿不到当前框架版本（无法判定，不是"兼容"）' }
+    else {
+      try { check = checkPluginFrameworkCompat(pkg, fwVer, pkgDir) } catch (error) { check = { decision: 'unknown', reason: '判定出错：' + String(error?.message ?? error) } }
+    }
+    const decision = check?.decision === 'pass' || check?.decision === 'fail' ? check.decision : 'unknown'
+    results.push({
+      rowId,
+      moduleName: moduleName === '' ? null : moduleName,
+      version: typeof pkg.version === 'string' ? pkg.version : null,
+      decision,
+      reason: check?.reason ?? null,
+      frameworkOwned: isFrameworkOwnedPackage(pkgDir, profileDir),
+      enabled: entry?.enabled === true,
+    })
+  }
+  const count = (d) => results.filter((r) => r.decision === d).length
+  return {
+    ok: true,
+    results,
+    checked: results.length,
+    pass: count('pass'),
+    fail: count('fail'),
+    unknown: count('unknown'),
+    skipped,
+    frameworkVersion: fwVer,
+    error: fwVer === null ? '拿不到当前框架版本：本次所有行都只能判成"无法判定"' : null,
+  }
+}
+
+/** 要写进 compat-pending 的记录（**只有 fail**；pass/unknown 只进统计，见模块头注释 ③）。 */
+function recordsFromScan(scan, { at = Date.now() } = {}) {
+  const list = Array.isArray(scan?.results) ? scan.results : []
+  return list.filter((r) => r.decision === 'fail').map((r) => ({
+    rowId: r.rowId,
+    moduleName: r.moduleName,
+    version: r.version,
+    status: 'pending',
+    check: 'fail',
+    checkNote: r.reason,
+    source: SCAN_SOURCE,
+    scannedAt: at,
+    frameworkVersion: scan?.frameworkVersion ?? null,
+    // 判据戳：这次用的就是**当前**判据（SCANNER_VERSION），所以"读取代发"不会把它当过期结论重算
+    scanVerdict: { version: SCANNER_VERSION, decision: 'fail', reason: r.reason, at, previous: null, rescinded: false, evidence: null },
+  }))
+}
+
+export { SCAN_SOURCE, SELF_ROW_ID, planCurrentScan, recordsFromScan }

package/lib/server/domain/framework-cleanup.js

@@ -35,6 +35,8 @@ import { basename, dirname, join, resolve, sep } from 'node:path'
 import { removeDirVerifiedAsync } from '../infra/fsx.js'
 import { dshHome, resolvePackageJson } from '../infra/paths.js'
 import { FRAMEWORK_BOOT_PACKAGES, classifyTopLevel, planBackupRetention, relinkTargetCandidates } from './framework-residuals.js'
+// 0.5.99 改错：改名残留能不能恢复的**判据**（可用 = 目录里有 package.json；候选包名必须与真名一致）
+import { emptyShellName, isUsablePackageDir, planStaleRestore } from './framework-stale-restore.js'
 
 /** 目录体积（失败返回 0；只用于报告「能释放多少」）。 */
 function dirSizeBytes(dir) {
@@ -424,54 +426,87 @@ function readRollbackReferenced({ home = undefined, deps = {} } = {}) {
   } catch { return [] }
 }
 /**
- * 升级失败后的补偿：把 `<name>.stale-<ver>-<ts>` **改回真名** —— 但只在真名缺失时。
+ * 升级失败后的补偿：把 `<name>.stale-<ver>-<ts>` **改回真名**。
  *
  * 背景（2026-10-28 真机）：升级在「拉起」阶段失败，向上层报「自动回滚未生效」，而清扫步
  * 已经把 10 个框架包改名成 `.stale-*`、真名处什么都没有。结果框架起不来：
  *   `Cannot find package '@deepseek-ai/cordis' imported from @deepseek-ai/dsh-app-boot`
  * 那一刻用户只能手改目录名 —— 这个函数就是那条手改的自动化版本。
  *
- * 纪律：
+ * ★ 0.5.99 改错（真机 2026-11-02，用户实测）：旧判据是「真名**缺失**才恢复；真名存在就跳过」，
+ *   而现场恰恰是「真名存在但是**空壳**（没有 package.json），内容在 `.stale-*` 里」⇒ 被跳过 ⇒
+ *   框架一直解析不到包（`ERR_MODULE_NOT_FOUND`），用户只能手工把 178 个空壳恢复回来。
+ *   现在判据收敛到 domain/framework-stale-restore.js：**可用 = 目录里有 package.json**，
+ *   空壳在判据里与"缺失"同等对待；候选还必须 `package.json.name === <scope>/<real>`（防张冠李戴）。
+ *   空壳**挪成 `<real>.empty-<ts>`**（挪开不删，可回溯），恢复后**读回核实**，不成就回滚并如实报。
+ *
+ * 纪律（一条都没放宽）：
  *   · **绝不删除**任何东西（只 rename）；
- *   · **真名已存在就跳过**（宁可不动，也不覆盖可能更新的目录）；
- *   · 幂等：重复调用第二次什么都不做；
- *   · 只看 `@deepseek-ai` 这一层（顶层 scope），不递归、不碰 `.pnpm` 内部。
+ *   · 真名**可用**就跳过（宁可不动，也不覆盖可能更新的目录）—— 健康树上零动作（幂等）；
+ *   · 只看 `@deepseek-ai` 这一层（顶层 scope），不递归、不碰 `.pnpm` 内部；
+ *   · 三类结果分开回报：`restored` / `noCandidate`（真缺内容，无可用候选）/ `failed`（名字不符、改名失败、读回不符）。
  */
-function restoreStaleBackups({ scopeDir, deps = {} } = {}) {
+function restoreStaleBackups({ scopeDir, stamp = null, deps = {} } = {}) {
   const exists = deps.exists ?? existsSync
-  const readdir = deps.readdir ?? ((dir) => readdirSync(dir, { withFileTypes: true }))
   const rename = deps.rename ?? renameSync
   const restored = []
   const skipped = []
+  const noCandidate = []
+  const emptied = []
   const failed = []
-  if (typeof scopeDir !== 'string' || scopeDir === '') return { ok: false, restored, skipped, failed, problem: '没有给 scopeDir' }
-  let entries = []
-  try { entries = readdir(scopeDir) } catch (error) {
-    const missing = error?.code === 'ENOENT'
-    return { ok: missing, restored, skipped, failed, problem: missing ? null : '列不出目录：' + errText(error) }
+  const io = { lstat: deps.lstat, readText: deps.readText, readdir: deps.readdir }
+  const plan = planStaleRestore({ scopeDir, deps: io })
+  if (plan.problem !== null) {
+    const missing = typeof scopeDir === 'string' && scopeDir !== '' && !exists(scopeDir)
+    return { ok: missing, restored, skipped, noCandidate, emptied, failed, problem: missing ? null : plan.problem }
   }
-  for (const entry of entries) {
-    const name = typeof entry === 'string' ? entry : entry?.name
-    const isDir = typeof entry === 'string' ? true : entry?.isDirectory?.() === true
-    if (typeof name !== 'string' || !isDir || !name.includes('.stale-')) continue
-    const real = name.replace(/\.stale-.*$/u, '')
-    if (real === '' || real === name) continue
-    const target = join(scopeDir, real)
-    const source = join(scopeDir, name)
-    let targetExists = false
-    try { targetExists = exists(target) } catch { targetExists = false }
-    if (targetExists) {
-      skipped.push({ name, real, reason: 'real-name-exists' })
-      continue
+  const ts = stamp === null ? String(Date.now()) : String(stamp)
+  for (const item of plan.items) {
+    const target = join(scopeDir, item.real)
+    if (item.action === 'skip') { skipped.push({ name: item.candidates[0], real: item.real, reason: 'real-name-exists' }); continue }
+    if (item.action === 'noCandidate') { noCandidate.push({ real: item.real, candidates: item.candidates, reason: item.reason, detail: item.detail, unusable: item.unusable ?? [] }); continue }
+    if (item.action === 'failed') { failed.push({ name: item.candidates[0] ?? item.real, real: item.real, reason: item.reason, error: item.detail }); continue }
+    // ① 空壳（存在但不可用）先挪开 —— **改个名，不删**；挪不动（或改名没生效）就整条不动
+    const source = join(scopeDir, item.staleName)
+    let emptyFull = null
+    if (item.realOccupied && item.realUsable !== true) {
+      const aside = join(scopeDir, emptyShellName(item.real, ts))
+      try {
+        rename(target, aside)
+      } catch (error) {
+        failed.push({ name: item.staleName, real: item.real, reason: 'empty-shell-move-failed', error: `真名是空壳但挪不开（${errText(error)}）—— 本次不动它` })
+        continue
+      }
+      // 挪开这个动作也要核实：注入桩/文件系统异常下"调用成功但没生效"不能当成功（否则报告会编造 emptied）
+      if (exists(target) || !exists(aside)) {
+        failed.push({ name: item.staleName, real: item.real, reason: 'empty-shell-move-failed', error: '把空壳挪成 .empty-* 没有生效（真名处仍有东西）—— 本次不动它' })
+        continue
+      }
+      emptyFull = aside
     }
+    // ② 候选 → 真名
     try {
       rename(source, target)
-      restored.push({ from: name, to: real })
     } catch (error) {
-      failed.push({ name, real, error: errText(error) })
+      // 挪开的空壳放回去（尽力而为；失败也要写在 failed 里，绝不静默）
+      let back = true
+      if (emptyFull !== null) { try { rename(emptyFull, target) } catch { back = false } }
+      failed.push({ name: item.staleName, real: item.real, reason: 'rename-failed', error: `改回真名失败：${errText(error)}${emptyFull === null ? '' : (back ? '（空壳已放回原处）' : '（**空壳没能放回原处**，现场可能不一致）')}` })
+      continue
+    }
+    // ③ 读回核实：真名目录里必须真的有 package.json（"改了名"不等于"能解析"）
+    if (isUsablePackageDir(target, io)) {
+      if (emptyFull !== null) emptied.push({ from: item.real, to: basename(emptyFull) })
+      restored.push({ from: item.staleName, to: item.real, emptied: emptyFull === null ? null : basename(emptyFull) })
+      continue
     }
+    // ④ 核实不过：把候选改回去、空壳放回原处，如实报失败（绝不谎报已恢复）
+    let rolledBack = true
+    try { if (!exists(source)) rename(target, source) } catch { rolledBack = false }
+    if (emptyFull !== null) { try { rename(emptyFull, target) } catch { rolledBack = false } }
+    failed.push({ name: item.staleName, real: item.real, reason: 'verify-failed', error: `改名后读回核实不通过（${item.real} 里仍读不到 package.json）${rolledBack ? '；已回滚到操作前' : '；**回滚未完成**，现场可能不一致'}` })
   }
-  return { ok: failed.length === 0, restored, skipped, failed, problem: null }
+  return { ok: failed.length === 0, restored, skipped, noCandidate, emptied, failed, problem: null }
 }
 
 export { cleanFrameworkBackups, cleanFrameworkTopLevel, dirSizeBytes, isLinkEntry, readRollbackReferenced, removeLinkSafe, reportFrameworkEntities, resolveFrameworkLayout, restoreStaleBackups, verifyFrameworkTreeResolvable }

package/lib/server/domain/framework-stale-repair.js

@@ -4,27 +4,42 @@
 // 真名处什么都没有 ⇒ 框架起不来：`Cannot find package '@deepseek-ai/cordis'`。
 // 当时只能手工改目录名；这里把那件事自动化，并**只返回人类可读的步骤**，
 // 让调用方（routes/framework-upgrade.js）保持精简（那个文件有 700 行硬顶）。
+//
+// ★ 0.5.99 改错（真机 2026-11-02）：「真名存在但只是空壳（没有 package.json）」以前被当成
+//   "已存在 ⇒ 跳过"，于是坏状态一直留着。判据已收敛到 domain/framework-stale-restore.js
+//   （可用 = 目录里有 package.json；候选包名必须与真名一致）。本文件把三类结果**都**翻成
+//   升级日志里的可读步骤：restored / noCandidate（真缺内容，无可用候选）/ failed。
 import { join } from 'node:path'
 import { restoreStaleBackups } from './framework-cleanup.js'
 
+/** 一列名字最多列几个（升级日志是单行步骤，别把几百个包名全塞进去）。 */
+const LIST_LIMIT = 8
+const brief = (names) => (names.length <= LIST_LIMIT ? names.join('、') : `${names.slice(0, LIST_LIMIT).join('、')} 等 ${names.length} 个`)
+
 /**
- * @returns {{ steps: string[], restored: Array<{from: string, to: string}>, failed: Array<object> }}
+ * @returns {{ steps: string[], restored: Array<object>, emptied: Array<object>, noCandidate: Array<object>, failed: Array<object> }}
  */
-function repairStaleRenameResidue({ fwRoot } = {}) {
+function repairStaleRenameResidue({ fwRoot, deps = {} } = {}) {
   const steps = []
-  if (typeof fwRoot !== 'string' || fwRoot === '') return { steps, restored: [], failed: [] }
+  const empty = { steps, restored: [], emptied: [], noCandidate: [], failed: [] }
+  if (typeof fwRoot !== 'string' || fwRoot === '') return empty
   try {
-    const repair = restoreStaleBackups({ scopeDir: join(fwRoot, '@deepseek-ai') })
+    const repair = restoreStaleBackups({ scopeDir: join(fwRoot, '@deepseek-ai'), deps })
     if (repair.restored.length > 0) {
-      steps.push(`修复上次失败留下的改名残留：${repair.restored.length} 个包已改回真名（${repair.restored.map((r) => r.to).join('、')}）`)
+      steps.push(`修复上次失败留下的改名残留：${repair.restored.length} 个包已改回真名（${brief(repair.restored.map((r) => r.to))}）`
+        + (Array.isArray(repair.emptied) && repair.emptied.length > 0 ? `；${repair.emptied.length} 个空壳已挪成 .empty-*（未删除）` : ''))
+    }
+    // ★ 0.5.99：真缺内容（真名不可用且没有可用候选）必须**说出来** —— 否则"框架解析不到包"在日志里无声无息
+    if (Array.isArray(repair.noCandidate) && repair.noCandidate.length > 0) {
+      steps.push(`有 ${repair.noCandidate.length} 个框架包真名不可用、且没有可用的 .stale-* 候选（真缺内容，需要重装/重新安装该版本）：${brief(repair.noCandidate.map((n) => n.real))}`)
     }
     if (repair.failed.length > 0) {
-      steps.push(`改名残留修复未全部成功：${repair.failed.map((f) => f.real).join('、')}（不阻塞升级）`)
+      steps.push(`改名残留修复未全部成功：${brief(repair.failed.map((f) => `${f.real}${f.reason ? `(${f.reason})` : ''}`))}（不阻塞升级）`)
     }
-    return { steps, restored: repair.restored, failed: repair.failed }
+    return { steps, restored: repair.restored, emptied: repair.emptied ?? [], noCandidate: repair.noCandidate ?? [], failed: repair.failed }
   } catch (error) {
     steps.push(`改名残留修复失败（不阻塞升级）：${error instanceof Error ? error.message : String(error)}`)
-    return { steps, restored: [], failed: [{ error: String(error) }] }
+    return { ...empty, steps, failed: [{ error: String(error) }] }
   }
 }
 

package/lib/server/domain/framework-stale-restore.js

@@ -0,0 +1,215 @@
+// L1 · domain —— framework-stale-restore.js（「改名残留」能不能恢复的**判据**；0.5.99 改错）
+//
+// ── 真机现场（2026-11-02，用户实测）────────────────────────────────────────────────
+// 框架包里出现大量「**真名目录存在，但是空壳**（没有 package.json），真正内容被改名成了
+// `<name>.stale-<ver>-<ts>`」：
+//     真名 cordis\                        → 空（无 package.json）
+//     cordis.stale-4.0.4-1793185607671\   → 有内容（package.json + lib）
+//   该目录下总计 564 项，其中 276 个是 .stale-*。后果：`@deepseek-ai/cordis` 解析失败
+//   （`ERR_MODULE_NOT_FOUND`），插件的 `import` 直接起不来；把 178 个空壳从 .stale-* 恢复后成功。
+//
+// ── 旧判据的缺陷（本次修的正是它）──────────────────────────────────────────────────
+// 旧实现是「真名**缺失**（exists=false）才恢复；真名已存在就跳过」。真机现场恰恰是
+// 「真名存在但是空壳」⇒ 被跳过 ⇒ 坏状态一直留着，框架一直起不来。
+//
+// ── 新判据（三条，全部可离线断言）──────────────────────────────────────────────────
+//   ① **可用**的定义是「这个目录里有 package.json」；目录存在但没有 package.json = **空壳 = 不可用**，
+//      在判据里与"缺失"同等对待（都算"真名此刻不可用"）。
+//   ② 恢复前必须校验候选的 `package.json.name` 与真名一致（`<scope>/<real>`）——
+//      不一致一律不动，记 `failed`（防张冠李戴：把别的包改成这个名字）。
+//   ③ 三类结果分开报告：`restore`（可恢复）/ `noCandidate`（真缺内容且没有可用的 .stale-*）/
+//      `failed`（候选名字不符、候选本身不可用等）—— 调用方要能原样写进升级日志。
+//
+// 本模块只做**判据与计划**（读目录 + 读 package.json，纯读、零写盘）；改名/读回核实/回滚在
+// domain/framework-cleanup.js#restoreStaleBackups（动作层），两处调用方共用同一条路。
+import { readdirSync, readFileSync, lstatSync } from 'node:fs'
+import { basename, join } from 'node:path'
+
+/** 空壳挪开后用的后缀（**挪开不删**，保留可回溯）。 */
+const EMPTY_SUFFIX = '.empty-'
+/** 改名残留的后缀（`<real>.stale-<ver>-<ts>`）。 */
+const STALE_MARK = '.stale-'
+
+function errText(error) {
+  return String(error?.message ?? error)
+}
+
+/** 从目录名拆出真名（`cordis.stale-4.0.4-123` → `cordis`）；不是残留就返回 null。 */
+function staleRealNameOf(name) {
+  if (typeof name !== 'string') return null
+  const at = name.indexOf(STALE_MARK)
+  if (at <= 0) return null
+  return name.slice(0, at)
+}
+
+/** 真名对应的**包名**（scope 目录下是 `@scope/real`；不是 scope 目录就用真名本身）。 */
+function expectedPackageName(scopeDir, real) {
+  const scope = basename(String(scopeDir ?? ''))
+  return scope.startsWith('@') ? `${scope}/${real}` : real
+}
+
+/** 空壳挪开后的名字：`<real>.empty-<stamp>`。 */
+function emptyShellName(real, stamp) {
+  return `${real}${EMPTY_SUFFIX}${stamp}`
+}
+
+/** 读 `<dir>/package.json`：`{ ok, name, version, error }`（读不到/解析不了都如实带原因）。 */
+function packageJsonOf(dir, { readText = (p) => readFileSync(p, 'utf8') } = {}) {
+  try {
+    const raw = JSON.parse(readText(join(dir, 'package.json')))
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, name: null, version: null, error: 'package.json 不是对象' }
+    return { ok: true, name: typeof raw.name === 'string' ? raw.name : null, version: typeof raw.version === 'string' ? raw.version : null, error: null }
+  } catch (error) {
+    return { ok: false, name: null, version: null, error: errText(error) }
+  }
+}
+
+/** 名字里那个"被占用"的东西（空壳 / 链接 / 文件 / 真实目录）：lstat 能立住就算被占着。 */
+function isOccupied(dir, { lstat = lstatSync } = {}) {
+  try { lstat(dir); return true } catch { return false }
+}
+
+/**
+ * **可用**的判据（用户 2026-11-02 定案）：目录里有**能读出来的 package.json**。
+ * 注意它不看包名 —— 「是不是这个包」由 `packageJsonOf().name` 与真名比对，两件事分开判。
+ */
+function isUsablePackageDir(dir, deps = {}) {
+  const lstat = deps.lstat ?? lstatSync
+  let stat = null
+  try { stat = lstat(dir) } catch { return false }
+  try { if (stat?.isDirectory?.() === false && stat?.isSymbolicLink?.() !== true) return false } catch {}
+  return packageJsonOf(dir, deps).ok === true
+}
+
+/** 候选排序用的时间戳（`<real>.stale-<ver>-<ts>` 里尾巴那串数字；没有就是 0）。 */
+function candidateStamp(name) {
+  const m = String(name ?? '').match(/-(\d{6,})$/u)
+  return m === null ? 0 : Number(m[1])
+}
+
+/**
+ * 挑要恢复的那份候选：包名必须与真名一致（防张冠李戴），多份时取**时间戳最新**的那份。
+ * 返回 `{ picked, mismatch, unusable }` —— `mismatch` 是"有 package.json 但名字不对"的候选，
+ * 它们不是可以恢复的对象，但**必须**在报告里点名（否则用户不知道为什么没恢复）。
+ */
+function pickRestoreCandidate({ scopeDir, real, candidates, deps = {} } = {}) {
+  const expected = expectedPackageName(scopeDir, real)
+  const usable = []
+  const mismatch = []
+  const unusable = []
+  for (const name of Array.isArray(candidates) ? candidates : []) {
+    const info = packageJsonOf(join(scopeDir, name), deps)
+    if (info.ok !== true) { unusable.push({ name, error: info.error }); continue }
+    if (info.name !== expected) { mismatch.push({ name, nameInPkg: info.name, expected }); continue }
+    usable.push({ name, version: info.version, stamp: candidateStamp(name) })
+  }
+  usable.sort((a, b) => (b.stamp - a.stamp) || (a.name < b.name ? 1 : a.name > b.name ? -1 : 0))
+  return { picked: usable.length > 0 ? usable[0] : null, usableCount: usable.length, mismatch, unusable }
+}
+
+/**
+ * 计划一次「改名残留修复」（**纯读，零写盘**）。返回每个真名一项：
+ *   `{ real, action: 'restore'|'skip'|'noCandidate'|'failed', staleName, reason, detail,
+ *      realOccupied, realUsable, candidates, mismatch, unusable }`
+ *
+ * 分类规则（顺序即优先级）：
+ *   ① 真名**可用** ⇒ `skip`（reason `real-name-exists`）—— 健康树上一个字节都不动（幂等）；
+ *   ② 真名不可用（缺失 **或空壳**）+ 有可用候选 ⇒ `restore`；
+ *   ③ 真名不可用 + 候选里**有名字不符的** ⇒ `failed`（reason `name-mismatch`，一个都不动）；
+ *   ④ 真名不可用 + 候选都不可用（没 package.json）或压根没有候选 ⇒ `noCandidate`。
+ */
+function planStaleRestore({ scopeDir, deps = {} } = {}) {
+  const empty = { ok: false, items: [], problem: null }
+  if (typeof scopeDir !== 'string' || scopeDir === '') return { ...empty, problem: '没有给 scopeDir' }
+  let entries = []
+  try { entries = deps.readdir ? deps.readdir(scopeDir) : readdirSync(scopeDir, { withFileTypes: true }) } catch (error) {
+    const missing = error?.code === 'ENOENT'
+    return { ...empty, ok: missing, problem: missing ? null : '列不出目录：' + errText(error) }
+  }
+  const byReal = new Map()
+  for (const entry of entries) {
+    const name = typeof entry === 'string' ? entry : entry?.name
+    const isDir = typeof entry === 'string' ? true : entry?.isDirectory?.() === true
+    if (typeof name !== 'string' || !isDir) continue
+    const real = staleRealNameOf(name)
+    if (real === null || real === '') continue
+    if (!byReal.has(real)) byReal.set(real, [])
+    byReal.get(real).push(name)
+  }
+  // 真名一侧也要扫：**空壳本身没有 .stale-* 兄弟**时（真缺内容）同样要报 `noCandidate`，
+  // 否则升级日志里那批"真名在、内容没了"的行一个字都不会出现（真机就是这样被漏掉的）。
+  const realNames = new Set()
+  for (const entry of entries) {
+    const name = typeof entry === 'string' ? entry : entry?.name
+    const isDir = typeof entry === 'string' ? true : entry?.isDirectory?.() === true
+    if (typeof name !== 'string' || !isDir) continue
+    if (name.includes(STALE_MARK) || name.includes(EMPTY_SUFFIX)) continue // 残留/挪开的空壳不是真名
+    realNames.add(name)
+  }
+  for (const real of realNames) if (!byReal.has(real)) byReal.set(real, [])
+  const items = []
+  for (const real of [...byReal.keys()].sort()) {
+    const candidates = byReal.get(real).slice().sort()
+    const target = join(scopeDir, real)
+    const realOccupied = isOccupied(target, deps)
+    const realUsable = realOccupied && isUsablePackageDir(target, deps)
+    const base = { real, staleName: null, realOccupied, realUsable, candidates }
+    if (realUsable) {
+      // 健康行：有候选也只是"旁边留着一份旧残留"，不动（幂等：健康树上零动作、零报告项）
+      if (candidates.length === 0) continue
+      items.push({ ...base, action: 'skip', reason: 'real-name-exists', detail: `真名目录里已有 package.json —— 不动旁边那份 ${candidates[0]}` })
+      continue
+    }
+    const pick = pickRestoreCandidate({ scopeDir, real, candidates, deps })
+    if (pick.picked !== null) {
+      items.push({
+        ...base,
+        action: 'restore',
+        staleName: pick.picked.name,
+        reason: realOccupied ? 'real-name-unusable' : 'real-name-missing',
+        detail: realOccupied
+          ? `真名目录存在但没有可读的 package.json（空壳）—— 用 ${pick.picked.name} 恢复，空壳挪成 ${EMPTY_SUFFIX}<ts>`
+          : `真名缺失 —— 用 ${pick.picked.name} 恢复`,
+        mismatch: pick.mismatch,
+        unusable: pick.unusable,
+      })
+      continue
+    }
+    if (pick.mismatch.length > 0) {
+      items.push({
+        ...base,
+        action: 'failed',
+        reason: 'name-mismatch',
+        detail: `候选的 package.json.name 与真名不符（应为 ${expectedPackageName(scopeDir, real)}）：${pick.mismatch.map((m) => `${m.name}=${String(m.nameInPkg)}`).join('、')} —— 一个都不动`,
+        mismatch: pick.mismatch,
+        unusable: pick.unusable,
+      })
+      continue
+    }
+    items.push({
+      ...base,
+      action: 'noCandidate',
+      reason: 'no-usable-stale',
+      detail: pick.unusable.length > 0
+        ? `真名不可用，且 ${pick.unusable.length} 份 .stale-* 都没有可读的 package.json（不可作为候选）`
+        : '真名不可用，且没有任何 .stale-* 候选（框架真缺内容，需要重装）',
+      mismatch: pick.mismatch,
+      unusable: pick.unusable,
+    })
+  }
+  return { ok: true, items, problem: null }
+}
+
+export {
+  EMPTY_SUFFIX,
+  STALE_MARK,
+  candidateStamp,
+  emptyShellName,
+  expectedPackageName,
+  isOccupied,
+  isUsablePackageDir,
+  packageJsonOf,
+  pickRestoreCandidate,
+  planStaleRestore,
+  staleRealNameOf,
+}

package/lib/server/infra/paths.js

@@ -1,7 +1,7 @@
 // L0 · infra（paths.js）—— 分层 Step 从 lib/index.js 搬出，只搬移未改逻辑
 // 分层分组：L0 · infra（边界由 tests/test-architecture-guard.mjs 断言）
 
-import { readFileSync, existsSync, statSync } from 'node:fs'
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { homedir } from 'node:os'
 import { fileURLToPath } from 'node:url'
@@ -12,10 +12,39 @@ function dshHome() {
   return process.env.DSH_HOME?.trim() || join(homedir(), '.dsh')
 }
 
-/** 默认 profile 用户补丁层路径（无 include 条目可推导时的兜底）。 */
+/**
+ * 默认 profile 用户补丁层路径（无 include 条目可推导时的兜底）。
+ *
+ * 硬编码 `profiles/web` 是真实事故（issue #27）：桌面端机器上 `cordis.yml` 里没有
+ * `cordis:include` 条目时兜底必然生效，于是所有补丁写入都落到早已废弃的 `web` profile，
+ * 正在用的 `desktop` 静默收不到——开关插件、改禁用都没反应，而且不报错。
+ *
+ * 现在按可信度排候选，绝不写死 profile 名：
+ *   ① DSH_PROFILE_DIR（桌面端/CLI 会显式设置，最可信）
+ *   ② DSH_PROFILE（只给名字时拼路径）
+ *   ③ `profiles/` 下真实存在补丁文件的目录（desktop 优先，其余按名字排序保证确定性）
+ */
 function defaultPatchPath() {
   const home = dshHome()
-  return join(home, 'profiles', 'web', 'cordis.patch.yml')
+  const explicitDir = process.env.DSH_PROFILE_DIR?.trim()
+  if (explicitDir !== undefined && explicitDir !== '') return join(explicitDir, 'cordis.patch.yml')
+  const candidates = []
+  const profileName = process.env.DSH_PROFILE?.trim()
+  if (profileName !== undefined && profileName !== '') candidates.push(join(home, 'profiles', profileName, 'cordis.patch.yml'))
+  candidates.push(join(home, 'profiles', 'desktop', 'cordis.patch.yml'))
+  try {
+    const base = join(home, 'profiles')
+    for (const name of readdirSync(base).sort()) {
+      if (name === 'node_modules' || name === 'desktop') continue
+      candidates.push(join(base, name, 'cordis.patch.yml'))
+    }
+  } catch {
+    // profiles 读不到就只用已知候选
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+  return candidates[0]
 }
 
 /** 从 loader 树推导 profile 的 cordis.patch.yml 绝对路径。 */

package/lib/server/routes/compat-scan.js

@@ -0,0 +1,123 @@
+// L2 · routes —— 门控的「按需检查」（0.5.100 加法）：`POST /plugin-console/compat-gate {action:'scan-current'}`
+//
+// 用户 2026-11-02 原话：「我们一般情况下都不预检吧」——compat-pending 只在升级前预扫与启动失败
+// 隔离时写入，平时门控一条记录都没有，而"0 条"会被误读成"全部兼容"。这个动作让用户随时查一次：
+// 对当前补丁里的行逐行跑适配判定，把**判为不适配**的结论记进 compat-pending（`source: 'manual-scan'`），
+// 并回一份统计（检查了几行 / 通过 / 不适配 / 无法判定）。
+//
+// 三条硬边界（判据在 domain/compat-scan.js，写盘纪律在 domain/compat-pending-records.js）：
+//   · 判据复用 `checkPluginFrameworkCompat`（与框架升级预扫同一条链），本文件不新写任何判据；
+//   · **绝不禁用任何行、绝不碰补丁文件** —— 禁用是用户的动作（/toggle）；
+//   · 写盘：备份 → 原子写 → 读回核实 → 失败回滚；坏文件 ⇒ 409 拒绝覆盖（保住用户数据）。
+import { dirname } from 'node:path'
+import { planCurrentScan, recordsFromScan } from '../domain/compat-scan.js'
+import { applyPendingWrite, countPendingRecords, liveRowIdsFromPatch, planScanMerge, readPendingRecords } from '../domain/compat-pending-records.js'
+import { currentFrameworkVersion } from '../domain/framework.js'
+import { readPatchState } from '../domain/patch.js'
+import { listEntries } from '../domain/runtime.js'
+import { sendError, sendJson } from '../infra/httpd.js'
+import { findPatchPath } from '../infra/paths.js'
+
+/** 读回核实的判据：本次写进去的每条 fail 记录都必须真的在盘上，且 check === 'fail'。 */
+function verifyScanWrite(expected) {
+  return (back) => {
+    const rows = (Array.isArray(back?.pending) ? back.pending : []).filter((r) => r !== null && typeof r === 'object')
+    const missing = expected.filter((id) => !rows.some((r) => r.rowId === id && r.check === 'fail'))
+    if (missing.length > 0) return `这些记录没真正落盘：${missing.slice(0, 5).join('、')}`
+    return null
+  }
+}
+
+async function routeCompatScanCurrent(req, res, rc) {
+  const at = Date.now()
+  let profileDir = null
+  let patchRowIds = new Set()
+  try {
+    const patchPath = findPatchPath(rc.ctx)
+    profileDir = dirname(patchPath)
+    patchRowIds = liveRowIdsFromPatch(await readPatchState(patchPath))
+  } catch {
+    sendError(res, 503, '读不到 profile 目录/补丁文件，无法确定要检查的行；本次扫描没有写任何东西', { ok: false, code: 'patch-unreadable' })
+    return
+  }
+  let entries = []
+  try { entries = listEntries(rc.ctx) } catch { entries = [] }
+  let frameworkVersion = null
+  try { frameworkVersion = currentFrameworkVersion(rc.ctx) } catch { frameworkVersion = null }
+  const scan = planCurrentScan({ entries, profileDir, frameworkVersion })
+  const records = recordsFromScan(scan, { at })
+  const read = readPendingRecords()
+  const merge = planScanMerge({
+    read,
+    records,
+    frameworkVersion,
+    lastScan: {
+      at,
+      frameworkVersion: scan.frameworkVersion,
+      checked: scan.checked,
+      pass: scan.pass,
+      fail: scan.fail,
+      unknown: scan.unknown,
+      skipped: scan.skipped.length,
+      source: 'manual-scan',
+    },
+  })
+  const counts = (() => {
+    try { return countPendingRecords(read.records, patchRowIds) } catch { return null }
+  })()
+  const base = {
+    ok: true,
+    action: 'scan-current',
+    frameworkVersion: scan.frameworkVersion,
+    // 扫描统计（面板只放一句短句；明细在 skipped/results 里）
+    checked: scan.checked,
+    pass: scan.pass,
+    fail: scan.fail,
+    unknown: scan.unknown,
+    skipped: scan.skipped,
+    results: scan.results,
+    // 落盘情况
+    recorded: records.length,
+    added: merge.added ?? [],
+    updated: merge.updated ?? [],
+    changed: false,
+    file: read.file,
+    backup: null,
+    verified: false,
+    counts,
+    error: scan.error,
+    note: null,
+  }
+  if (merge.ok !== true) {
+    // 坏文件：结论不写盘，但扫描统计照样如实回（用户至少知道"现在查出来是什么"）
+    sendError(res, merge.status ?? 500, merge.error ?? '扫描结果写入失败', { ...base, error: merge.error ?? scan.error })
+    return
+  }
+  if (merge.changed !== true) {
+    sendJson(res, 200, {
+      ...base,
+      changed: false,
+      note: scan.checked === 0
+        ? '没有可检查的行（补丁里没有可判定的插件行），未写任何记录'
+        : `检查 ${scan.checked} 行：通过 ${scan.pass} / 不适配 ${scan.fail} / 无法判定 ${scan.unknown}；记录没有变化（无需写盘）`,
+    })
+    return
+  }
+  const write = applyPendingWrite({ file: read.file, next: merge.next, verify: verifyScanWrite(records.map((r) => r.rowId)), tag: 'scan' })
+  const payload = {
+    ...base,
+    ok: write.ok === true,
+    changed: write.ok === true,
+    backup: write.backup ?? null,
+    verified: write.verified === true,
+    error: write.error ?? scan.error,
+    note: write.ok === true
+      ? `检查 ${scan.checked} 行：通过 ${scan.pass} / 不适配 ${scan.fail} / 无法判定 ${scan.unknown}`
+        + (records.length > 0 ? `；已记下 ${records.length} 条待适配结论（只记录，未禁用任何行）` : '；没有不适配的行，未新增记录')
+      : null,
+  }
+  if (write.ok === true) sendJson(res, 200, payload)
+  else sendError(res, write.status ?? 500, write.error ?? '扫描结果写入失败', payload)
+}
+
+export { routeCompatScanCurrent }

package/lib/server/routes/compat.js

@@ -29,6 +29,8 @@ import { compareFingerprint, computeFingerprint, planDesktopHostSwitch, readComp
 // 0.5.98 加法：适配门**记录**的删除（真待适配判据 + 写盘纪律都在该模块；本路由只映射状态码）
 import { applyPendingForget, countPendingRecords, liveRowIdsFromPatch, planForgetRecord, planForgetStale, readPendingRecords } from '../domain/compat-pending-records.js'
 import { readPatchState } from '../domain/patch.js'
+// 0.5.100 加法：门控的「按需检查」（只记录结论，绝不禁用任何行）
+import { routeCompatScanCurrent } from './compat-scan.js'
 import { currentFrameworkVersion, detectHostShape } from '../domain/framework.js'
 import { applyDependencyBackfill, planDependencyBackfill } from '../domain/manifest.js'
 import { isProtectedModule } from '../domain/runtime.js'
@@ -458,14 +460,28 @@ async function routeCompatAck(req, res, rc) {
   const ack = writeCompatAck(version)
   sendJson(res, 200, { ok: true, ack, noticeMode: readCompatGate().noticeMode })
 }
+/**
+ * POST /plugin-console/compat-gate 的**动作分派**（0.5.98 起；0.5.100 多一个 `scan-current`）。
+ *
+ *   `{ action: 'forget', rowId }`    删一条记录          → 见下（routeCompatPendingForget 的本体）
+ *   `{ action: 'forget-stale' }`     清掉失效记录        → 同上
+ *   `{ action: 'scan-current' }`     **按需检查**（0.5.100 加法，用户「平时不预检」的痛点）
+ *                                    → routes/compat-scan.js（只记录结论，绝不禁用任何行）
+ *   没有 `action`（或不是已知动作）⇒ **逐字**走原来的总开关逻辑（既有契约零变化）
+ *
+ * 为什么都挤在**既有的 /compat-gate** 上而不新开路由：门控面板的所有写入口必须同源
+ * （否则又要登记一份路由清单，两处判据迟早分叉）。装配层的分流见 routes/index.js#routeCompatGateAny。
+ */
+async function routeCompatGateAction(req, res, rc) {
+  const action = typeof rc.body?.action === 'string' ? rc.body.action.trim() : ''
+  if (action === 'scan-current') return routeCompatScanCurrent(req, res, rc)
+  return routeCompatPendingForget(req, res, rc)
+}
+
 /**
  * POST /plugin-console/compat-gate `{ action: 'forget' | 'forget-stale' }`
  *   —— 适配门**记录**的删除（0.5.98 加法，用户 2026-10-28 明确要求）。
  *
- * 为什么挂在**既有的 /compat-gate** 上而不是新开一条路由：门控面板的所有写入口必须同源
- * （否则又要登记一份路由清单，两处判据迟早分叉）。body 里没有 `action` 时**逐字**走原来的
- * 总开关逻辑（既有契约零变化，装配层的分流见 routes/index.js#routeCompatGateAny）。
- *
  * 语义（三条硬边界，用户定案）：
  *   · 只删 **记录**：不动插件、不动补丁文件、不动 bundles 清单；
  *   · `forget` 删指定 rowId；`forget-stale` 只清「status=pending 且该行已不在补丁里」的失效记录，
@@ -528,4 +544,4 @@ async function routeCompatPendingForget(req, res, rc) {
   else sendError(res, result.status ?? 400, result.error ?? '删除记录失败', payload)
 }
 
-export { hostShapeOf, maybeSwitchToObserver, maybeWriteSnapshot, preflightTimeoutMs, resetHostSwitchChecked, routeCompatAck, routeCompatMode, routeCompatPendingForget, routeCompatStamp, routeCompatStatusGet, routeDeclareInstalled, scheduleAutoPreflight }
+export { hostShapeOf, maybeSwitchToObserver, maybeWriteSnapshot, preflightTimeoutMs, resetHostSwitchChecked, routeCompatAck, routeCompatGateAction, routeCompatMode, routeCompatPendingForget, routeCompatStamp, routeCompatStatusGet, routeDeclareInstalled, scheduleAutoPreflight }

package/lib/server/routes/index.js

@@ -16,7 +16,7 @@ import { readBody, sendError } from '../infra/httpd.js'
 import { routeAiConsent, routeAiEmpowerCancel, routeAiEmpowerList, routeAiEmpowerPlan, routeAiEmpowerRun, routeAiEmpowerStatus } from './ai.js'
 import { routeRunSuggested } from './actions.js'
 import { routeComponentAutostart, routeComponentStart, routeComponentStatus, routeComponentStop, routeComponents, routeRepoClone, routeRepoLandConfig, routeRepoList, routeRepoOpen, routeRepoRemove } from './components.js'
-import { routeCompatAck, routeCompatMode, routeCompatPendingForget, routeCompatStamp, routeCompatStatusGet, routeDeclareInstalled } from './compat.js'
+import { routeCompatAck, routeCompatGateAction, routeCompatMode, routeCompatPendingForget, routeCompatStamp, routeCompatStatusGet, routeDeclareInstalled } from './compat.js'
 import { routeSafeBoot } from './safe-boot.js'
 // issue #22 ②③ 加法：用户备注 / 用户徽章 / 用户自建分组（独立文件，与插件列表完全解耦）
 import { routeAnnotationsGet, routeAnnotationsPost } from './annotations.js'
@@ -90,11 +90,11 @@ function routeDeps() {
  * 于是"分流"留在装配层，"动作实现"落在 routes/compat.js（适配门记录那一族）。
  *
  * 契约：body 里没有 `action`（或不是非空字符串）⇒ **逐字**走原来的总开关逻辑，
- * 既有请求/响应一字不变；带 `action` 才进删除记录那一族（forget / forget-stale）。
+ * 既有请求/响应一字不变；带 `action` 才进动作分派那一族（0.5.98 删记录 / 0.5.100 按需检查）。
  */
 async function routeCompatGateAny(req, res, rc) {
   const action = typeof rc.body?.action === 'string' ? rc.body.action : ''
-  if (action !== '') return routeCompatPendingForget(req, res, rc)
+  if (action !== '') return routeCompatGateAction(req, res, rc)
   return routeCompatGate(req, res, rc)
 }
 

package/lib/server/routes/state.js

@@ -276,11 +276,25 @@ async function routeStateGet(req, res, rc) {
     // ★ 0.5.98 加法：门控明细行补两个**只增不改**的字段 —— `rowMissing`（这一行的 rowId 已不在
     //   当前补丁里）与 `actionable`（与计数同一个判据）。面板据此如实标注「该行已不存在」并给删除入口；
     //   既有字段（pendingCount / rows 的全部旧字段）一个不少、语义不变。
+    // ★ 0.5.101 加法（用户 2026-11-02）：**运行期加载失败**的行（`fiberPhase === 'failed'`）。
+    //   真机现场：`experimental-inspector` 因 `@deepseek-ai/cordis` 解析失败而挂载失败，而门控**完全
+    //   看不到它** —— 因为这条失败不经过预扫/隔离链。这里只补一个**视图**字段：
+    //   **绝不写 compat-pending.json**（那是适配裁决记录，不能被运行期故障污染）、不改任何既有字段。
+    const loadFailed = entries
+      .filter((e) => e.fiberPhase === 'failed' && typeof e.rowId === 'string' && e.rowId !== '')
+      .map((e) => ({ rowId: e.rowId, moduleName: e.moduleName ?? null, version: e.version ?? null, fiberPhase: 'failed', enabled: e.enabled === true }))
     const gatingOut = (() => {
       const g = gatingSummary(ctx, compatPending, entries, compatVerdicts)
-      return { ...g, pending: annotateGateRows(g.pending, patchRowIds), adopted: annotateGateRows(g.adopted, patchRowIds) }
+      return {
+        ...g,
+        pending: annotateGateRows(g.pending, patchRowIds),
+        adopted: annotateGateRows(g.adopted, patchRowIds),
+        // 只增字段：加载失败的行 + 计数（面板据此决定分区显不显示）
+        loadFailed,
+        loadFailedCount: loadFailed.length,
+      }
     })()
-    sendJson(res, 200, { ok: true, entries: allEntries, skippedBundles, host, health, patchPath, compat, installJobs: jobs, recentFailures, pendingRestart, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, lockAutofix, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0, written: patchHeal.written === true, writeError: patchHeal.writeError ?? null, skippedFrameworkOwned: (patchHeal.skipped ?? []).map((s) => s.id ?? null), uncertain: (patchHeal.uncertain ?? []).map((u) => u.id ?? null) }, gating: gatingOut, compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null, verdict: compatVerdicts.get(p.rowId) ?? null })), verdictRefresh: pendingState.refresh === null ? null : { version: pendingState.refresh.version ?? null, updated: pendingState.refresh.updated ?? [], unchanged: pendingState.refresh.unchanged ?? [], unresolved: pendingState.refresh.unresolved ?? [], wrote: pendingState.refresh.wrote === true, writeError: pendingState.refresh.writeError ?? null }, actionableCount: pendingCounts.actionableCount, staleCount: pendingCounts.staleCount }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
+    sendJson(res, 200, { ok: true, entries: allEntries, skippedBundles, host, health, patchPath, compat, installJobs: jobs, recentFailures, pendingRestart, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, lockAutofix, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0, written: patchHeal.written === true, writeError: patchHeal.writeError ?? null, skippedFrameworkOwned: (patchHeal.skipped ?? []).map((s) => s.id ?? null), uncertain: (patchHeal.uncertain ?? []).map((u) => u.id ?? null) }, gating: gatingOut, compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null, verdict: compatVerdicts.get(p.rowId) ?? null })), verdictRefresh: pendingState.refresh === null ? null : { version: pendingState.refresh.version ?? null, updated: pendingState.refresh.updated ?? [], unchanged: pendingState.refresh.unchanged ?? [], unresolved: pendingState.refresh.unresolved ?? [], wrote: pendingState.refresh.wrote === true, writeError: pendingState.refresh.writeError ?? null }, actionableCount: pendingCounts.actionableCount, staleCount: pendingCounts.staleCount, lastScan: compatPending.lastScan ?? null }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
     return
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.98",
+  "version": "0.5.99",
   "description": "DSH 框架升级安全与插件升级门控：一键升级、失败自动回滚、升级后回滚上版、旧插件不适配自动禁用；内置多源插件市场为发现层，插件源全部可自定义，可指向公司内网私有源 / 私有索引 / 本地 Git 仓库，纯内网离线可用 | Framework upgrade safety & plugin version gating for DSH, with a customizable multi-source plugin market: point every source at internal mirrors or a local file:// repo for intranet-only, offline installs.",
   "repository": {
     "type": "git",