@noob-stupid/dsh-plugin-console 0.5.32 → 0.5.34

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

@@ -0,0 +1,241 @@
+// L1 · domain —— compat-verdict.js（适配门结论的**判据版本戳** + 过期结论的读取代发重算；0.5.34 加法）
+// 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
+//
+// ── 真机背景（2026-10-01，用户实测）────────────────────────────────────────────────
+// `~/.dsh/plugin-console/compat-pending.json` 里 `dshmarket` 的记录仍是
+//   `check:"fail"` + `checkNote:"源码仍引用 0.1.2 起已删除的 dsh-settings API（…）——实际不兼容…"`
+// —— 那是 **0.5.33 收紧判据之前**的误报结论（真机复核：现在 0 命中）。面板照旧把它当事实展示
+// （「实际不兼容，启用会让整个服务启动崩溃」+「待适配」永久钉住），**持续误导用户**。
+//
+// ── 本模块只做两件事（**不放宽任何判据**）──────────────────────────────────────────
+//   ① 给结论打**判据版本戳**：记录里的 `scanVerdict.version` 标明"这条结论是哪一版判据算的"
+//      （戳来自 settings-api-scan.js 的 `SCAN_CRITERIA_VERSION`，判据改一次就要改它）。
+//   ② **读取代发**：读清单时若记录的戳落后于当前判据 → 用**当前判据只读重算**
+//      · 结论变了 → 回写（`check` / `checkNote` / `scanVerdict`，含 previous + rescinded + 来源证据）
+//      · 结论没变 → **零写盘**（幂等；同一条记录不会每次读都写盘）
+//      · 包解析不到 → 不猜：如实标注"无法复核"（保留旧结论，绝不假装成当前判据的结论）
+//   `fail` 永远不会因为"戳旧"就被改成 `pass` —— 只有**真的用当前判据重算**出非 fail 才算撤回；
+//   真不兼容的（重算仍 fail）一个字都不动。
+//
+// 行数预算：独立模块，留在 600 行架构硬顶内。
+
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { dshHome } from '../infra/paths.js'
+import { SCAN_CRITERIA_VERSION } from './settings-api-scan.js'
+
+/**
+ * 进程内重算备忘（纯性能，不影响判据）："结论未变 ⇒ 不写盘"意味着记录上的判据戳**一直是旧的**，
+ * 于是每次 `GET /state`（面板每隔几秒轮询一次）都会对同一批包重跑源码扫描（单包上限 120 文件 / 400KB）。
+ * 键含包路径 + 版本 + package.json 的 mtime：包一变（升级/改源码）就重算，包没变就复用。
+ */
+const VERDICT_MEMO = new Map()
+const MEMO_LIMIT = 200
+
+/** 判据版本戳（当前判据的版本；判据变了就跟着 settings-api-scan.js 一起变）。 */
+const SCANNER_VERSION = SCAN_CRITERIA_VERSION
+
+/** 适配门清单文件（原在 compat.js；0.5.34 搬到本模块，供"读取代发"一处收口）。 */
+const compatPendingFile = () => join(dshHome(), 'plugin-console', 'compat-pending.json')
+
+/**
+ * 「这条禁用记录是我们自己写进去的」判据（纯函数）。
+ * 只有这类记录才允许在**误报被撤回**时给用户一键解锁入口 —— 用户手写的禁用块不在此列。
+ */
+const SELF_INFLICTED_SOURCES = new Set([
+  'preflight-disabled-before-upgrade', // 框架升级前的预扫（dshmarket 就是这条）
+  'boot-quarantine',                   // 启动失败隔离
+  'auto-preflight',                    // 指纹变化自动预检
+])
+function isSelfInflictedSource(source) {
+  return typeof source === 'string' && SELF_INFLICTED_SOURCES.has(source)
+}
+
+/** 记录上的判据戳（缺失 = 旧时代结论：必须重算）。 */
+function stampOf(record) {
+  const s = record?.scanVerdict
+  if (s === null || typeof s !== 'object') return { version: null, decision: null, reason: null, at: null, rescinded: false, evidence: null }
+  return {
+    version: typeof s.version === 'string' ? s.version : null,
+    decision: typeof s.decision === 'string' ? s.decision : null,
+    reason: typeof s.reason === 'string' ? s.reason : null,
+    at: Number.isFinite(s.at) ? s.at : null,
+    rescinded: s.rescinded === true,
+    evidence: typeof s.evidence === 'string' ? s.evidence : null,
+  }
+}
+
+/** 这条记录的结论是不是"旧判据算的"（纯函数）。 */
+function isStaleVerdict(record, version = SCANNER_VERSION) {
+  return stampOf(record).version !== version
+}
+
+/**
+ * 纯判据：给一组记录算出「哪些结论过期、用当前判据重算后是什么」（IO 全由 `recompute` 注入）。
+ * `recompute(record)` → `{ decision, reason }`；解析不到包时返回 `{ unresolved: '原因' }`。
+ * 返回每条的 `{ rowId, status, decision, reason, storedDecision, storedNote, rescinded, evidence }`，
+ * status ∈ fresh（戳已是最新，无需重算）/ updated（结论变了 → 调用方回写）/ unchanged（结论没变 → **零写盘**）
+ *          / unresolved（复核不了 → 如实标注，保留旧结论）。
+ */
+function planVerdictRefresh(records, { version = SCANNER_VERSION, recompute } = {}) {
+  const out = []
+  for (const rec of (Array.isArray(records) ? records : [])) {
+    if (rec === null || typeof rec !== 'object' || typeof rec.rowId !== 'string' || rec.rowId === '') continue
+    const storedDecision = typeof rec.check === 'string' && rec.check !== '' ? rec.check : null
+    const storedNote = typeof rec.checkNote === 'string' ? rec.checkNote : null
+    const stamp = stampOf(rec)
+    if (stamp.version === version) {
+      out.push({ rowId: rec.rowId, status: 'fresh', decision: storedDecision, reason: stamp.reason ?? storedNote, storedDecision, storedNote, rescinded: stamp.rescinded, evidence: stamp.evidence, version })
+      continue
+    }
+    // 没给重算器（或明确要求只读）→ 不猜：标成"过期、未复核"
+    if (typeof recompute !== 'function') {
+      out.push({ rowId: rec.rowId, status: 'stale', decision: storedDecision, reason: storedNote, storedDecision, storedNote, rescinded: false, evidence: null, version: null })
+      continue
+    }
+    let next = null
+    try {
+      next = recompute(rec)
+    } catch (error) {
+      next = { unresolved: String(error?.message ?? error) }
+    }
+    if (next === null || next === undefined) next = { unresolved: '重算没有返回结论' }
+    if (typeof next.unresolved === 'string' && next.unresolved !== '') {
+      out.push({ rowId: rec.rowId, status: 'unresolved', decision: storedDecision, reason: storedNote, storedDecision, storedNote, rescinded: false, evidence: null, version: null, unresolved: next.unresolved })
+      continue
+    }
+    const decision = typeof next.decision === 'string' && next.decision !== '' ? next.decision : 'unknown'
+    const reason = typeof next.reason === 'string' ? next.reason : null
+    out.push({
+      rowId: rec.rowId,
+      status: decision === storedDecision ? 'unchanged' : 'updated',
+      decision,
+      reason,
+      storedDecision,
+      storedNote,
+      // 「旧判据判 fail，当前判据不再 fail」= 误报被撤回（这是唯一允许解除"待适配"的情形）
+      rescinded: storedDecision === 'fail' && decision !== 'fail',
+      evidence: isSelfInflictedSource(rec.source) ? String(rec.source) : null,
+      version,
+    })
+  }
+  return out
+}
+
+/**
+ * 读取代发（IO 版）：把 `planVerdictRefresh` 的结论落到记录上，**结论变了才写盘**（写后读回核实）。
+ * `deps`：`{ resolvePkg, readPkg, check, writeText, readText, now }` —— 全部可注入（离线测试）。
+ * 返回 `{ version, entries, updated, unchanged, unresolved, fresh, wrote, writeError, file }`。
+ */
+function refreshCompatPendingVerdicts({ pending, baseDir, file = null, deps = {} } = {}) {
+  const {
+    resolvePkg, readPkg, check, now = () => Date.now(), stat = statSync,
+    readText = (p) => readFileSync(p, 'utf8'), writeText = (p, data) => writeFileSync(p, data, 'utf8'),
+    memo = VERDICT_MEMO,
+  } = deps
+  const target = file ?? compatPendingFile()
+  const records = Array.isArray(pending?.pending) ? pending.pending : []
+  const fwVer = typeof pending?.frameworkVersion === 'string' ? pending.frameworkVersion : null
+  const recompute = (rec) => {
+    if (typeof rec.moduleName !== 'string' || rec.moduleName === '') return { unresolved: '记录里没有 moduleName（无法定位已装包）' }
+    if (typeof resolvePkg !== 'function' || typeof readPkg !== 'function' || typeof check !== 'function') return { unresolved: '读取代发缺少解析器（内部接线问题）' }
+    let pkgPath = null
+    try { pkgPath = resolvePkg(rec.moduleName, baseDir) } catch (error) { return { unresolved: '解析包失败：' + String(error?.message ?? error) } }
+    if (pkgPath === null || pkgPath === undefined) return { unresolved: `本机解析不到 ${rec.moduleName}` }
+    let pkg = null
+    try { pkg = readPkg(pkgPath) } catch (error) { return { unresolved: '读取包信息失败：' + String(error?.message ?? error) } }
+    if (pkg === null || pkg === undefined) return { unresolved: '读取包信息失败' }
+    const mtimeMs = (() => { try { return stat(pkgPath).mtimeMs } catch { return 0 } })()
+    const key = `${rec.rowId}|${pkgPath}|${pkg.version ?? ''}|${mtimeMs}|${SCANNER_VERSION}`
+    if (memo instanceof Map && memo.has(key)) return memo.get(key)
+    const verdict = check(pkg, fwVer ?? '?', dirname(pkgPath))
+    const out = { decision: verdict?.decision ?? 'unknown', reason: verdict?.reason ?? null }
+    if (memo instanceof Map) {
+      if (memo.size >= MEMO_LIMIT) memo.clear()
+      memo.set(key, out)
+    }
+    return out
+  }
+  const entries = planVerdictRefresh(records, { recompute })
+  const byRow = new Map(entries.map((e) => [e.rowId, e]))
+  const updated = []
+  const at = now()
+  for (const rec of records) {
+    const e = byRow.get(rec?.rowId)
+    if (e === undefined || e.status !== 'updated') continue
+    const previous = { decision: e.storedDecision, note: e.storedNote }
+    rec.check = e.decision
+    rec.checkNote = e.reason
+    rec.scanVerdict = { version: SCANNER_VERSION, decision: e.decision, reason: e.reason, at, previous, rescinded: e.rescinded, evidence: e.evidence }
+    rec.verdictUpdatedAt = at
+    updated.push({ rowId: e.rowId, from: e.storedDecision, to: e.decision, rescinded: e.rescinded, evidence: e.evidence })
+  }
+  const result = {
+    version: SCANNER_VERSION,
+    file: target,
+    entries,
+    updated,
+    unchanged: entries.filter((e) => e.status === 'unchanged').map((e) => e.rowId),
+    unresolved: entries.filter((e) => e.status === 'unresolved').map((e) => ({ rowId: e.rowId, reason: e.unresolved })),
+    fresh: entries.filter((e) => e.status === 'fresh').map((e) => e.rowId),
+    wrote: false,
+    writeError: null,
+  }
+  if (updated.length === 0) return result // ② 结论未变（或无可重算）→ **零写盘**
+  const payload = { ...pending, pending: records, updatedAt: new Date(at).toISOString() }
+  try {
+    mkdirSync(dirname(target), { recursive: true })
+    writeText(target, JSON.stringify(payload, null, 2), 'utf8')
+  } catch (error) {
+    result.writeError = '回写适配门清单失败：' + String(error?.message ?? error)
+    return result
+  }
+  // 读回核实：只有真的落盘且内容一致才算写成功（绝不谎报"已更正"）
+  try {
+    const back = JSON.parse(readText(target))
+    const rec = (back?.pending ?? []).find((p) => p.rowId === updated[0].rowId)
+    const ok = rec !== undefined && rec.check === updated[0].to && stampOf(rec).version === SCANNER_VERSION
+    if (!ok) result.writeError = '回写后读回内容与期望不一致（结论没真正落盘）'
+  } catch (error) {
+    result.writeError = '回写后读回失败：' + String(error?.message ?? error)
+  }
+  result.wrote = result.writeError === null
+  return result
+}
+
+/**
+ * 一条记录对外的"结论视图"（面板/门控摘要用）：当前判据下的结论 + 是否过期 + 是否已撤回。
+ * `entry` = `refreshCompatPendingVerdicts()` 的 `entries` 里对应那条（可省 → 只看记录上的判据戳）。
+ */
+function verdictView(record, entry = null) {
+  const stamp = stampOf(record)
+  const status = entry?.status ?? (stamp.version === SCANNER_VERSION ? 'fresh' : 'stale')
+  const evidence = entry?.evidence ?? stamp.evidence ?? (isSelfInflictedSource(record?.source) ? String(record.source) : null)
+  if (status === 'updated') {
+    return { decision: entry.decision, reason: entry.reason, version: entry.version, stale: false, rescinded: entry.rescinded === true, evidence, unresolved: null, status, previous: { decision: entry.storedDecision, note: entry.storedNote } }
+  }
+  if (status === 'fresh') {
+    return { decision: stamp.decision ?? (typeof record?.check === 'string' ? record.check : null), reason: stamp.reason ?? (typeof record?.checkNote === 'string' ? record.checkNote : null), version: stamp.version, stale: false, rescinded: stamp.rescinded, evidence, unresolved: null, status }
+  }
+  if (status === 'unchanged') {
+    // 结论与旧判据一致（已用当前判据复核过，但**不写盘**）：结论可信，判据戳仍是旧的
+    return { decision: entry.decision, reason: entry.reason, version: entry.version, stale: true, rescinded: false, evidence, unresolved: null, status }
+  }
+  if (status === 'unresolved') {
+    return { decision: entry.decision, reason: entry.reason, version: null, stale: true, rescinded: false, evidence: null, unresolved: entry.unresolved, status }
+  }
+  // 'stale'：本轮没有重算（没给基准/只读）→ 如实标"旧判据、未复核"
+  return { decision: stamp.decision ?? (typeof record?.check === 'string' ? record.check : null), reason: stamp.reason ?? (typeof record?.checkNote === 'string' ? record.checkNote : null), version: stamp.version, stale: true, rescinded: stamp.rescinded, evidence, unresolved: null, status: 'stale' }
+}
+
+export {
+  SCANNER_VERSION,
+  SELF_INFLICTED_SOURCES,
+  compatPendingFile,
+  isSelfInflictedSource,
+  isStaleVerdict,
+  planVerdictRefresh,
+  refreshCompatPendingVerdicts,
+  stampOf,
+  verdictView,
+}

package/lib/server/domain/compat.js

@@ -1,7 +1,7 @@
 // L1 · domain —— compat.js（框架兼容判定与适配门：设置 API 扫描 / 兼容门读写 / 待适配记录 / 隔离记录合并的前置部分 / 启动失败分析；分层 Step 6 从 lib/index.js 搬出，只搬移未改逻辑。注：detectCompat 等吃运行上下文的留到 Step 8）
 // 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
 
-import { readFileSync, writeFileSync, readdirSync, mkdirSync, realpathSync } from 'node:fs'
+import { readFileSync, writeFileSync, mkdirSync, realpathSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { spawn } from 'node:child_process'
 import { dirname, join, sep, resolve } from 'node:path'
@@ -13,6 +13,11 @@ import { listEntries } from './runtime.js'
 import { fetchJsonUrl } from '../infra/http.js'
 import { dshHome, findPatchPath, pluginRoot, profileDirOf, resolvePackageJson } from '../infra/paths.js'
 import { semverRangeMatch, semverRangeMatchLoose } from '../infra/semver.js'
+// 0.5.34 加法：适配门结论的**判据版本戳** + 过期结论的读取代发重算（见该模块头注释）。
+import { SCANNER_VERSION, compatPendingFile, isSelfInflictedSource, planVerdictRefresh, refreshCompatPendingVerdicts, verdictView } from './compat-verdict.js'
+// 0.5.33 改错：已删除 API 的源码扫描搬进独立 domain 模块（判据收紧为"真的从 dsh-settings 绑定进来"）。
+// 这三个名字继续由本模块导出，对外契约不变。
+import { REMOVED_SETTINGS_SYMBOLS, referencesRemovedSymbol, scanSettingsApiUsage } from './settings-api-scan.js'
 
 /** Cordis Fiber 状态映射（与 dsh-host-plugin-inventory 一致）。 */
 const FIBER_STATE = { PENDING: 0, LOADING: 1, ACTIVE: 2, FAILED: 3, DISPOSED: 4, UNLOADING: 5 }
@@ -26,63 +31,6 @@ const FIBER_PHASE = {
   [FIBER_STATE.UNLOADING]: 'unloading',
 }
 
-/**
- * 扫描已安装包源码，检测对已删除的 dsh-settings API 的引用
- * （2026-09-04 教训：0.1.2-rc.1 起 settingsNamespace / installSettingsSection 已删除，
- * 静态声明检查判 pass 是假通过；真实兼容性只有模块 import 时见分晓，而 loader 单行失败
- * = 整个服务启动崩溃）。返回命中的符号列表，空数组 = 干净。
- */
-const REMOVED_SETTINGS_SYMBOLS = ['settingsNamespace', 'installSettingsSection']
-
-/** 源码是否**引用**了已删除符号——而不是「恰好包含同名前缀的其它标识符」或「自己定义的同名局部函数」。
- *  v0.3.35 修复（真机演练抓到的误伤）：原先用 `text.includes('settingsNamespace')` 子串匹配，
- *  而框架自带的 @deepseek-ai/dsh-api-settings-controller 里有个 `settingsNamespaceRequestSchema`，
- *  于是框架自己的 settings 控制器被判「引用已删除 API」→ 升级预扫会把它自动禁用（砍掉框架功能）。
- *  现在要求标识符边界，且排除「本地 const/let/var/function/class 定义且同行没有 dsh-settings 引用」。 */
-function referencesRemovedSymbol(text, sym) {
-  const re = new RegExp(`(?<![A-Za-z0-9_$])${sym}(?![A-Za-z0-9_$])`, 'u')
-  for (const line of text.split(/\r?\n/u)) {
-    const m = re.exec(line)
-    if (m === null) continue
-    const before = line.slice(0, m.index)
-    const localDefinition = /(?:^|[^\w$])(?:const|let|var|function|class|async\s+function)\s*$/u.test(before)
-    if (localDefinition && !/dsh-settings/u.test(line)) continue
-    return true
-  }
-  return false
-}
-
-function scanSettingsApiUsage(pkgDir) {
-  const found = []
-  const seen = new Set()
-  const walk = (dir, depth) => {
-    if (depth > 3) return
-    let entries = []
-    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
-    for (const entry of entries) {
-      const full = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue
-        walk(full, depth + 1)
-        continue
-      }
-      if (!entry.isFile() || !/\.(?:js|mjs|cjs)$/u.test(entry.name)) continue
-      if (seen.has(full)) continue
-      seen.add(full)
-      if (seen.size > 120) return
-      try {
-        const text = readFileSync(full, 'utf8').slice(0, 400000)
-        for (const sym of REMOVED_SETTINGS_SYMBOLS) {
-          if (found.includes(sym)) continue
-          if (referencesRemovedSymbol(text, sym)) found.push(sym)
-        }
-      } catch {}
-    }
-  }
-  walk(pkgDir, 0)
-  return found
-}
-
 /** 包是否由框架自带（解析到 profile 目录之外，如 npx/pnpm 缓存里的 @deepseek-ai/*）。
  *  v0.3.35：这类行随框架一起发布，禁用**不是**正确处置（正确处置是回滚框架），
  *  而且一旦判定有误就会把框架功能砍掉——所以升级预扫永不自动禁用它们。 */
@@ -136,8 +84,6 @@ function checkPluginFrameworkCompat(pkg, frameworkVersion, pkgDir = null) {
 // 支持 0.1.x 系列（0.1.0 / 0.1.1 等）；0.2 / 1.0 等破坏性大版本才标记不支持
 const SUPPORTED_WEB_APP_PATTERN = /^0\.1\.\d+/u
 
-const COMPAT_PENDING_FILE = () => join(dshHome(), 'plugin-console', 'compat-pending.json')
-
 /**
  * 启用前冒烟检查（服务永不崩机制）：在独立子进程中动态 import 插件主模块，
  * 捕获 loader 会遇到的 import/resolution 错误（SyntaxError、缺失导出、模块缺失）。
@@ -180,7 +126,49 @@ function probePluginImport(moduleName, profileDir) {
   })
 }
 
-/** 读取框架升级适配门清单（compat-pending.json）；损坏/缺失返回 null。 */
+/** 适配门清单文件（0.5.34 起由 compat-verdict.js 定义，供"读取代发"一处收口）。 */
+const COMPAT_PENDING_FILE = compatPendingFile
+
+/**
+ * 读取框架升级适配门清单（compat-pending.json）；损坏/缺失返回 `{ pending: null, ... }`。
+ *
+ * 0.5.34 加法（**读取代发**）：给 `baseDir`（当前 profile 目录）时，对**判据戳落后**的记录
+ * 用当前判据只读重算：结论变了才回写（幂等：结论不变**零写盘**），解析不到包就如实标注"无法复核"。
+ * 真不兼容的（重算仍 fail）一个字都不动 —— 这条只解决"过期结论仍当事实展示"，不放宽任何判据。
+ * 返回 `{ pending, refresh, verdicts }`：`verdicts` = rowId → 结论视图（面板/门控摘要用）。
+ */
+function readCompatPendingWithVerdicts({ baseDir = null, deps = {} } = {}) {
+  let raw = null
+  try { raw = JSON.parse(readFileSync(COMPAT_PENDING_FILE(), 'utf8')) } catch { return { pending: null, refresh: null, verdicts: new Map() } }
+  if (raw === null || typeof raw !== 'object') return { pending: null, refresh: null, verdicts: new Map() }
+  let refresh = null
+  if (baseDir !== null && baseDir !== undefined && Array.isArray(raw.pending) && raw.pending.length > 0) {
+    try {
+      refresh = refreshCompatPendingVerdicts({
+        pending: raw,
+        baseDir,
+        deps: {
+          resolvePkg: (name, base) => resolvePackageJson(name, base),
+          readPkg: (p) => JSON.parse(readFileSync(p, 'utf8')),
+          check: checkPluginFrameworkCompat,
+          ...deps,
+        },
+      })
+    } catch (error) {
+      // 复核本身出问题也必须如实回报（不静默）：结论按记录原样展示，附上失败原因
+      refresh = { version: SCANNER_VERSION, entries: [], updated: [], unchanged: [], unresolved: [], fresh: [], wrote: false, writeError: '读取代发重算失败：' + String(error?.message ?? error), file: COMPAT_PENDING_FILE() }
+    }
+  }
+  const entries = Array.isArray(refresh?.entries) ? refresh.entries : planVerdictRefresh(raw.pending)
+  const verdicts = new Map()
+  for (const rec of raw.pending) {
+    if (rec === null || typeof rec !== 'object' || typeof rec.rowId !== 'string') continue
+    verdicts.set(rec.rowId, verdictView(rec, entries.find((e) => e.rowId === rec.rowId) ?? null))
+  }
+  return { pending: raw, refresh, verdicts }
+}
+
+/** 读取清单（原契约不变：只读、不做复核）。需要"读取代发"的路径用 readCompatPendingWithVerdicts。 */
 function readCompatPending() {
   try { return JSON.parse(readFileSync(COMPAT_PENDING_FILE(), 'utf8')) } catch { return null }
 }
@@ -337,15 +325,18 @@ async function detectCompat(baseUrl) {
 }
 
 /** 待适配行的「现在是否已适配」检测（只提示，不自动解锁——用户定案：我点才开）。
- * 返回 Map<rowId, {version, check, note}>：仅当版本已变化且源码扫描不再 fail 时才算可解锁。 */
+ * 返回 Map<rowId, {version, check, note, basis}>：可解锁有两种**互不放松**的来路 ——
+ *   ① `version-changed`：插件真的更新过（版本 ≠ 记录版本）且源码扫描不再 fail（原判据，不变）；
+ *   ② `verdict-rescinded`（0.5.34 加法）：记录里的 `fail` 是**旧判据的误报**，当前判据重算后不再 fail。
+ *      真不兼容（重算仍 fail）**一个都不放行**；②也不需要"版本变化"——否则用户会被永久钉在「待适配」。 */
 function detectAdoptablePending(ports) {
   const out = new Map()
-  const pending = readCompatPending()
+  let profileDir = null
+  try { profileDir = dirname(findPatchPath(ports)) } catch { return out }
+  const { pending, verdicts } = readCompatPendingWithVerdicts({ baseDir: profileDir })
   if (pending === null) return out
   const fwVer = typeof pending.frameworkVersion === 'string' ? pending.frameworkVersion : null
   if (fwVer === null) return out
-  let profileDir = null
-  try { profileDir = dirname(findPatchPath(ports)) } catch { return out }
   for (const p of (pending.pending ?? []).filter((x) => (x.status ?? 'pending') === 'pending')) {
     try {
       const pkgPath = resolvePackageJson(p.moduleName, profileDir)
@@ -354,9 +345,18 @@ function detectAdoptablePending(ports) {
       const version = typeof pkg.version === 'string' ? pkg.version : null
       const changed = version !== null && version !== p.version
       const check = checkPluginFrameworkCompat(pkg, fwVer, dirname(pkgPath))
-      if (changed && check.decision !== 'fail') {
-        out.set(p.rowId, { version, check: check.decision, note: check.reason ?? null })
-      }
+      if (check.decision === 'fail') continue
+      const view = verdicts.get(p.rowId) ?? null
+      const rescinded = view?.rescinded === true
+      if (!changed && !rescinded) continue
+      out.set(p.rowId, {
+        version,
+        check: check.decision,
+        note: check.reason ?? null,
+        basis: changed ? 'version-changed' : 'verdict-rescinded',
+        previousVerdict: view?.storedDecision ?? null,
+        evidence: view?.evidence ?? null,
+      })
     } catch {}
   }
   return out
@@ -371,8 +371,11 @@ function detectAdoptablePending(ports) {
  *
  * pending —— 当前被拦下/待解锁的行（含原因、来源、是否已通过源码扫描可解锁）
  * adopted —— 曾经被拦、现已适配解锁的行（让用户能核对"到底动过哪些行"）
+ *
+ * 0.5.34 加法：每行多带 `verdict`（当前判据下的结论视图：`stale` / `rescinded` / `unresolved`）——
+ * 旧判据的结论不许再被当成事实展示；**复核不了**（包解析不到）的行在 `note` 上如实标注。
  */
-function gatingSummary(ports, compatPending, ctxEntries = null) {
+function gatingSummary(ports, compatPending, ctxEntries = null, verdicts = null) {
   const rec = compatPending ?? { frameworkVersion: null, upgradeFrom: null, pending: [] }
   const all = Array.isArray(rec.pending) ? rec.pending : []
   let info = new Map()
@@ -383,11 +386,14 @@ function gatingSummary(ports, compatPending, ctxEntries = null) {
   for (const e of Array.isArray(ctxEntries) ? ctxEntries : []) {
     if (typeof e?.rowId === 'string' && e.rowId !== '') byRow.set(e.rowId, e)
   }
+  const byVerdict = verdicts instanceof Map ? verdicts : new Map()
   const row = (p) => {
     const meta = info.get(p.rowId) ?? null
     const entry = byRow.get(p.rowId) ?? null
     const moduleName = p.moduleName ?? meta?.moduleName ?? entry?.moduleName ?? null
     const name = moduleName ?? p.rowId ?? '（未知行）'
+    const verdict = byVerdict.get(p.rowId) ?? verdictView(p)
+    const note = p.checkNote ?? null
     return {
       rowId: p.rowId ?? null,
       name,
@@ -396,12 +402,16 @@ function gatingSummary(ports, compatPending, ctxEntries = null) {
       version: p.version ?? meta?.version ?? entry?.version ?? null,
       status: p.status ?? 'pending',
       check: p.check ?? null,
-      note: p.checkNote ?? null,
+      // 复核不了的行：**如实标注**"旧判据结论、未复核"（不许继续当事实；也不猜新结论）
+      note: verdict.unresolved === null || verdict.unresolved === undefined
+        ? note
+        : `${note ?? ''}（旧判据结论，未能复核：${verdict.unresolved}）`,
       source: p.source ?? null,
       adoptedAt: p.adoptedAt ?? null,
       forcedAt: p.forcedAt ?? null,
       adoptedBy: p.adoptedBy ?? null,
       enabled: entry === null ? null : entry.enabled === true,
+      verdict,
     }
   }
   const isPending = (p) => (p.status ?? 'pending') === 'pending'
@@ -445,9 +455,10 @@ function rowIdModuleMap(ports) {
 /**
  * 框架升级适配门：安装/更新完成后自动校验兼容性，
  * 通过（版本已变化 + 未在声明/依赖层面明确不兼容）则移除补丁禁用块并解锁启用。
+ * 0.5.34：走**读取代发**（`profileDir` 已知）—— 顺手把过期判据的结论复核/回写，避免旧误报继续挂在这里。
  */
 async function maybeAutoAdaptCompat({ profileDir, packageName, syncedNames, patchPath, ports }) {
-  const pending = readCompatPending()
+  const { pending } = readCompatPendingWithVerdicts({ baseDir: profileDir })
   if (!pending || !Array.isArray(pending.pending)) return { ran: false }
   const interested = new Set([packageName, ...(syncedNames ?? [])].filter((n) => n !== null))
   const targets = pending.pending.filter((p) => (p.status ?? 'pending') === 'pending' && interested.has(p.moduleName))
@@ -492,7 +503,7 @@ async function maybeAutoAdaptCompat({ profileDir, packageName, syncedNames, patc
 /** AI 赋能框架适配预检：查 registry 最新版声明 + 兼容门清单，给出权威说明。 */
 async function frameworkCompatReportFor(source, ports, profileDir) {
   const fwVer = currentFrameworkVersion(ports)
-  const pending = readCompatPending()
+  const { pending, verdicts } = readCompatPendingWithVerdicts({ baseDir: profileDir })
   const norm = String(source ?? '').trim()
   const isNpm = norm.startsWith('@') || !norm.includes('/')
   const installed = (() => {
@@ -502,7 +513,10 @@ async function frameworkCompatReportFor(source, ports, profileDir) {
       return JSON.parse(readFileSync(pkgPath, 'utf8')).version ?? null
     } catch { return null }
   })()
-  const pendHits = (pending?.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending' && p.moduleName === norm)
+  // 命中行带上当前判据的结论视图（`fail` 仍然是 fail；过期/复核不了会如实标注）
+  const pendHits = (pending?.pending ?? [])
+    .filter((p) => (p.status ?? 'pending') === 'pending' && p.moduleName === norm)
+    .map((p) => ({ ...p, verdict: verdicts.get(p.rowId) ?? verdictView(p) }))
   if (!isNpm) {
     return {
       kind: 'repo', frameworkVersion: fwVer, packageName: null, latest: null, check: null,
@@ -541,4 +555,4 @@ async function frameworkCompatReportFor(source, ports, profileDir) {
     summary: parts.length > 0 ? parts.join('；') : `框架 ${fwVer}，无待适配记录`,
   }
 }
-export { gatingSummary, COMPAT_PENDING_FILE, COMPAT_GATE_FILE, COMPAT_ACK_FILE, COMPAT_GATE_DEFAULTS, NOTICE_MODES, DEFAULT_NOTICE_MODE, REMOVED_SETTINGS_SYMBOLS, FIBER_STATE, FIBER_PHASE, SUPPORTED_WEB_APP_PATTERN, referencesRemovedSymbol, scanSettingsApiUsage, isFrameworkOwnedPackage, checkPluginFrameworkCompat, probePluginImport, readCompatPending, writeCompatPending, readCompatGate, writeCompatGate, readCompatAck, writeCompatAck, resolveNoticeState, frameworkCheckPromptText, CONSOLE_VERSION, detectCompat, detectAdoptablePending, rowIdModuleMap, frameworkCompatReportFor, maybeAutoAdaptCompat }
+export { gatingSummary, COMPAT_PENDING_FILE, COMPAT_GATE_FILE, COMPAT_ACK_FILE, COMPAT_GATE_DEFAULTS, NOTICE_MODES, DEFAULT_NOTICE_MODE, REMOVED_SETTINGS_SYMBOLS, FIBER_STATE, FIBER_PHASE, SUPPORTED_WEB_APP_PATTERN, referencesRemovedSymbol, scanSettingsApiUsage, isFrameworkOwnedPackage, checkPluginFrameworkCompat, probePluginImport, readCompatPending, readCompatPendingWithVerdicts, writeCompatPending, verdictView, SCANNER_VERSION, readCompatGate, writeCompatGate, readCompatAck, writeCompatAck, resolveNoticeState, frameworkCheckPromptText, CONSOLE_VERSION, detectCompat, detectAdoptablePending, rowIdModuleMap, frameworkCompatReportFor, maybeAutoAdaptCompat }