@whyshu/argent-engine 0.0.0-stage → 0.6.1

package/engine/scripts/lib/bootcheck-wiring.mjs

@@ -0,0 +1,510 @@
+/**
+ * plugin-bootcheck 的**隔离装配计划**与**启动日志判据**（唯一真源，纯 L1）。
+ *
+ * 由来（2026-10-12 P1-0，依据 `docs/dsh-0.2.x-适配审计.md` §B2/§D1 + 契约 §3.1/§3.3）：
+ * 原 bootcheck 把**真实 profile** 原样软链进隔离 home ⇒ 插件仍解析到**真实 profile 指的那个
+ * scope**。在 0.2 宿主上，那个 scope 是 0.1.7 ⇒ 0.2 的 peer 门禁把**每一行** disable
+ * （`dsh: disabling profile plugin row "…"` ×110 + `startup failed: 1 required plugin did not
+ * activate`）⇒ **假红**，与"Argent 坏了"在输出上无法区分。
+ *
+ * 本模块把两件事从命令式脚本里抽成**可断言的纯数据**：
+ *   ① `planProfileWiring()` —— 把真实 profile **浅镜像**进临时 home，并把 `@deepseek-ai`
+ *      农场**重建**为指向目标 scope 的链接（⛔ 绝不写真实 profile；⛔ 不 `cp -R` node_modules）；
+ *   ② `evaluateBootLog()` —— 三条判据（零禁用行 / 提供行 / preset 探针）+ **三态**判定；
+ *   ③ `compareBinScopeVersions()` —— **硬前置**「被测 dsh 二进制必须与目标 scope 同源」（P1-0 实测的坑：
+ *      宿主 0.1.7 + 插件 0.2 ⇒ 110 条 `disabling profile plugin row`，与"Argent 坏了"无法区分）。
+ *
+ * ## 为什么"浅镜像"而不是"原样软链"
+ * 原样软链会把 dsh 的**组合产物** `cordis.yml` 写回**真实** profile（实测：内容 sha 不变、
+ * mtime 变）⇒ 违反"真实 `~/.dsh` 零增量"。镜像后所有写操作落在临时 home。
+ *
+ * ## 为什么不 `cp -R` node_modules
+ * 284 个包整树复制既慢又会**副本漂移**（改仓库插件后副本还是旧字节 ⇒ "重启即生效"是假的）。
+ * 镜像里 node_modules 的每个条目仍是**软链**（只读共享真实文件），只有 `@deepseek-ai` 这一项
+ * 被换成指向目标 scope 的链接。
+ *
+ * ## 两套 profile 农场形态都要支持
+ * | 形态 | 真实 profile 里 `node_modules/@deepseek-ai` | 重建方式 |
+ * |---|---|---|
+ * | **整树链接**（本机 0.1.7 web profile 现状） | 一个软链 | 一个软链 → 目标 scope 农场 |
+ * | **行式**（0.1.7 的 `profiles/node_modules` 农场） | 真目录，逐包软链 | 真目录 + 逐包软链 → 目标 scope |
+ * | **目录式**（0.1.5 的真目录/整树复制） | 真目录，包是真目录 | 真目录 + 逐包软链 → 目标 scope（⛔ 不复制） |
+ * 目标 scope 自身是**平铺**（`<scope>/<pkg>`）还是**嵌套**（`<scope>/dsh/node_modules/@deepseek-ai/<pkg>`）
+ * 由 `locateScopeFarm()` 探测。
+ *
+ * ⛔ 本文件是 L1：**零宿主 import**（只有 node 内建）。
+ */
+
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, statSync, symlinkSync, copyFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+
+/** 判定"这个目录是不是 `@deepseek-ai` 农场"的探针包（按顺序试）。 */
+export const SCOPE_PROBE_PKGS = ['dsh-base', 'dsh', 'dsh-agent-preset']
+
+/** 目标 scope 的布局标签（`locateScopeFarm().layout`）。 */
+export const SCOPE_LAYOUT = {
+  /** scopeDir 自己就是 `@deepseek-ai`（本机 / 靶子树：`…/node_modules/@deepseek-ai`）。 */
+  FLAT: 'flat',
+  /** scopeDir 下还有一层 `@deepseek-ai`（`<prefix>/@deepseek-ai`）。 */
+  PREFIXED: 'prefixed',
+  /** 主包内嵌：`<scope>/dsh/node_modules/@deepseek-ai`（rc.6 式 nested）。 */
+  NESTED: 'nested',
+}
+
+/** 真实 fs 适配器（测试可注入假实现）。 */
+export const defaultIo = {
+  exists: (p) => existsSync(p),
+  isDir: (p) => { try { return statSync(p).isDirectory() } catch { return false } },
+  isSymlink: (p) => { try { return lstatSync(p).isSymbolicLink() } catch { return false } },
+  readdir: (p) => { try { return readdirSync(p) } catch { return [] } },
+  realpath: (p) => { try { return realpathSync(p) } catch { return null } },
+  readlink: (p) => { try { return readlinkSync(p) } catch { return null } },
+  readText: (p) => { try { return readFileSync(p, 'utf8') } catch { return null } },
+  join,
+  dirname,
+  resolve,
+}
+
+/** 读某包的 version（读不到回 null，绝不抛）。 */
+export function readPackageVersion(pkgDir, io = defaultIo) {
+  const t = io.readText(io.join(pkgDir, 'package.json'))
+  if (!t) return null
+  try { return JSON.parse(t).version ?? null } catch { return null }
+}
+
+/**
+ * 定位目标 scope 的 `@deepseek-ai` 农场目录（平铺 / 前缀式 / 嵌套三种都探）。
+ * @returns {{farm: string, layout: string, probe: string} | null}
+ */
+export function locateScopeFarm(scopeDir, io = defaultIo) {
+  if (!scopeDir) return null
+  const cands = [
+    { farm: scopeDir, layout: SCOPE_LAYOUT.FLAT },
+    { farm: io.join(scopeDir, '@deepseek-ai'), layout: SCOPE_LAYOUT.PREFIXED },
+    { farm: io.join(scopeDir, 'node_modules', '@deepseek-ai'), layout: SCOPE_LAYOUT.PREFIXED },
+    { farm: io.join(scopeDir, 'dsh', 'node_modules', '@deepseek-ai'), layout: SCOPE_LAYOUT.NESTED },
+  ]
+  for (const c of cands) {
+    for (const probe of SCOPE_PROBE_PKGS) {
+      if (io.exists(io.join(c.farm, probe, 'package.json'))) return { ...c, probe }
+    }
+  }
+  return null
+}
+
+/** 农场里的包名清单（跳过点开头；排序保证计划可比对）。 */
+export function listFarmPackages(farm, io = defaultIo) {
+  return io.readdir(farm).filter((n) => !n.startsWith('.')).sort()
+}
+
+/**
+ * 探测真实 profile 里 `node_modules/@deepseek-ai` 的形态。
+ * @returns {{entry:string, exists:boolean, kind:'symlink'|'dir'|'missing', real:string|null, linkTo:string|null, packages:string[]}}
+ */
+export function inspectProfileScope(profileDir, io = defaultIo) {
+  const entry = io.join(profileDir, 'node_modules', '@deepseek-ai')
+  if (!io.exists(entry)) return { entry, exists: false, kind: 'missing', real: null, linkTo: null, packages: [] }
+  const linkTo = io.isSymlink(entry) ? io.readlink(entry) : null
+  const kind = io.isSymlink(entry) ? 'symlink' : (io.isDir(entry) ? 'dir' : 'missing')
+  return {
+    entry,
+    exists: true,
+    kind,
+    real: io.realpath(entry),
+    linkTo: linkTo ? io.resolve(io.dirname(entry), linkTo) : null,
+    packages: kind === 'missing' ? [] : listFarmPackages(entry, io),
+  }
+}
+
+/**
+ * 生成**隔离 home 的装配计划**（纯数据，不落盘 —— 落盘在 {@link applyProfileWiring}）。
+ *
+ * @param {object} o
+ * @param {string} o.profileDir     真实 profile 目录（**只读**）
+ * @param {string} o.tmpProfileDir  临时 home 里的目标 profile 目录（计划里所有写操作都在它下面）
+ * @param {string} o.targetFarm     目标 scope 的 `@deepseek-ai` 农场
+ * @returns {{mode:string, scopeMode:string, actions:Array, notes:string[], missing:string[], packages:string[],
+ *            sameFarm:boolean, profileFarm:string|null, targetFarm:string}}
+ */
+export function planProfileWiring({ profileDir, tmpProfileDir, targetFarm }, io = defaultIo) {
+  const actions = []
+  const notes = []
+  const scope = inspectProfileScope(profileDir, io)
+  const targetReal = io.realpath(targetFarm) || targetFarm
+  const profileFarmReal = scope.real
+  const sameFarm = !!(profileFarmReal && io.realpath(profileFarmReal) === targetReal)
+
+  // ── 顶层：文件**复制**（小、且可能是 dsh 的写目标，如 cordis.yml）；目录/软链**软链** ──
+  actions.push({ op: 'mkdir', path: tmpProfileDir })
+  for (const e of io.readdir(profileDir).sort()) {
+    if (e === 'node_modules') continue
+    const from = io.join(profileDir, e)
+    const at = io.join(tmpProfileDir, e)
+    if (io.isSymlink(from) || io.isDir(from)) {
+      if (io.isDir(from) && !io.isSymlink(from)) {
+        // 真目录：镜像一层（条目软链），这样目录内新增文件也落在 tmp
+        actions.push({ op: 'mkdir', path: at })
+        for (const sub of io.readdir(from).sort()) {
+          actions.push({ op: 'symlink', at: io.join(at, sub), to: io.join(from, sub) })
+        }
+      } else {
+        actions.push({ op: 'symlink', at, to: from })
+      }
+    } else {
+      actions.push({ op: 'copyFile', from, to: at })
+    }
+  }
+
+  // ── node_modules：除 @deepseek-ai 外全部软链（只读共享，零副本）──────────────
+  const realNm = io.join(profileDir, 'node_modules')
+  const tmpNm = io.join(tmpProfileDir, 'node_modules')
+  actions.push({ op: 'mkdir', path: tmpNm })
+  if (io.isDir(realNm)) {
+    for (const e of io.readdir(realNm).sort()) {
+      if (e === '@deepseek-ai') continue
+      actions.push({ op: 'symlink', at: io.join(tmpNm, e), to: io.join(realNm, e) })
+    }
+  } else {
+    notes.push(`真实 profile 没有 node_modules 目录（${realNm}）—— 只重建 @deepseek-ai`)
+  }
+
+  // ── @deepseek-ai：按目标 scope 重建 ──────────────────────────────────────
+  // 链接目标：同 scope（passthrough）时保持**现役**农场（= 逐字不回归）；否则指向目标 scope。
+  const linkFarm = sameFarm ? (profileFarmReal || targetFarm) : targetFarm
+  const scopeMode = scope.kind === 'symlink' || scope.kind === 'missing' ? 'dir-link' : 'per-pkg'
+  const missing = []
+  const at = io.join(tmpNm, '@deepseek-ai')
+  if (scopeMode === 'dir-link') {
+    // 整树链接：一个软链顶替整个 scope（本机 0.1.7 web profile 与审计的手搭 home 都是这一形态）。
+    // passthrough 时**原样保留** profile 现役那条软链的字面目标（逐字不回归）。
+    const linkTarget = sameFarm && scope.kind === 'symlink' && scope.linkTo ? scope.linkTo : linkFarm
+    actions.push({ op: 'symlink', at, to: linkTarget, scopeEntry: true })
+  } else {
+    actions.push({ op: 'mkdir', path: at, scopeEntry: true })
+    for (const pkg of scope.packages) {
+      const tgt = io.join(linkFarm, pkg)
+      if (!io.exists(tgt)) { missing.push(pkg); continue }
+      actions.push({ op: 'symlink', at: io.join(at, pkg), to: tgt, scopeEntry: true })
+    }
+    if (missing.length) notes.push(`目标 scope 缺 ${missing.length} 个 profile 农场里的包：${missing.slice(0, 8).join(', ')}${missing.length > 8 ? ' …' : ''}`)
+  }
+
+  return {
+    mode: sameFarm ? 'passthrough' : 'wired',
+    scopeMode,
+    sameFarm,
+    profileFarm: profileFarmReal,
+    targetFarm,
+    linkFarm,
+    packages: scope.packages,
+    missing,
+    notes,
+    actions,
+  }
+}
+
+/**
+ * 「计划绝不写真实 profile」的机器判据（防止后来者加一条 `copyFile` 到真实树里）。
+ * @returns {{ok:boolean, violations:string[]}}
+ */
+export function planStaysInsideTmp(plan, { profileDir, tmpProfileDir }, io = defaultIo) {
+  const tmp = io.realpath(tmpProfileDir) || tmpProfileDir
+  const inside = (p) => { const s = String(p); return s === tmp || s.startsWith(tmp + '/') }
+  const violations = []
+  for (const a of plan.actions) {
+    if (a.op === 'symlink') {
+      if (!inside(a.at)) violations.push(`symlink.at 不在临时 home: ${a.at}`)
+      continue
+    }
+    const target = a.op === 'mkdir' ? a.path : a.to
+    if (!inside(target)) violations.push(`${a.op} 的目标不在临时 home: ${target}`)
+  }
+  const realProfile = io.realpath(profileDir) || profileDir
+  const insideReal = (p) => { const s = String(p); return s === realProfile || s.startsWith(realProfile + '/') }
+  for (const a of plan.actions) {
+    if (a.op === 'copyFile' && insideReal(a.to)) violations.push(`copyFile 写回真实 profile: ${a.to}`)
+  }
+  return { ok: violations.length === 0, violations }
+}
+
+/** 落盘（真实 fs）。调用前应先跑 {@link planStaysInsideTmp}。 */
+export function applyProfileWiring(plan, io = defaultIo) {
+  const done = []
+  for (const a of plan.actions) {
+    if (a.op === 'mkdir') {
+      if (!io.exists(a.path)) { mkdirSync(a.path, { recursive: true }); done.push(a) }
+    } else if (a.op === 'copyFile') {
+      if (io.exists(a.from)) { copyFileSync(a.from, a.to); done.push(a) }
+    } else if (a.op === 'symlink') {
+      try { symlinkSync(a.to, a.at) } catch (e) { if (e.code !== 'EEXIST') throw e }
+      done.push(a)
+    }
+  }
+  return done
+}
+
+/**
+ * 自证：从**临时 profile** 解析探针包，必须落到**目标 scope** 里。
+ * @param {object} o
+ * @param {string} o.tmpProfileDir
+ * @param {string} o.targetFarm
+ * @param {(spec:string)=>string|null} o.resolveFrom  注入的解析器（避免本 L1 文件 import 宿主）
+ * @returns {{ok:boolean, spec:string|null, resolved:string|null, expected:string, why:string}}
+ */
+export function verifyScopeResolution({ tmpProfileDir, targetFarm, resolveFrom }, io = defaultIo) {
+  const expected = io.realpath(targetFarm) || targetFarm
+  for (const pkg of SCOPE_PROBE_PKGS) {
+    const spec = `@deepseek-ai/${pkg}`
+    let resolved = null
+    try { resolved = resolveFrom(spec) } catch { resolved = null }
+    if (!resolved) continue
+    const real = io.realpath(resolved) || resolved
+    const ok = real === expected || real.startsWith(expected + '/')
+    return {
+      ok, spec, resolved: real, expected,
+      why: ok
+        ? `${spec} ⇒ ${real}（在目标 scope 内）`
+        : `${spec} 解析到 ${real}，**不在**目标 scope ${expected} 内 ⇒ 目标 scope 未接好`,
+    }
+  }
+  return {
+    ok: false, spec: null, resolved: null, expected,
+    why: `临时 profile 里 ${SCOPE_PROBE_PKGS.map((p) => `@deepseek-ai/${p}`).join(' / ')} 一个都解析不到 ⇒ 目标 scope 不可用`,
+  }
+}
+
+// ── 硬前置：被测 dsh 二进制必须与**目标 scope 同源** ────────────────────────
+//
+// 由来（2026-10-12 P1-0 实测）：隔离 profile 的 `@deepseek-ai` 已按**目标 scope** 重接线，
+// 而被测的 `dsh` 可执行文件却是**本机全局**那一个（`resolveDshBin()` 先 PATH、后硬编码
+// `/opt/homebrew/bin/dsh`）⇒ 出现「插件 0.2.0-rc.2 + 宿主 0.1.7-rc.2」的混搭：
+//
+//   dsh: disabling profile plugin row "plugin-manager": Plugin @deepseek-ai/dsh-plugin-manager@0.2.0-rc.2
+//        is incompatible with dsh 0.1.7-rc.2: peerDependencies {…}. …
+//   dsh: startup failed: 1 required plugin did not activate
+//
+// 老输出只能把 110 条禁用行归因成「目标 scope 自身与本次 dsh 不兼容」——**方向对但没点名根因**，
+// 排障时会让人去怀疑目标 scope（其实它才是我们想要的那个）。⇒ 固化成**判据**：两者版本不一致
+// 就**响亮判红**（附双方版本 + 出路），⛔ 不许静默跑出一个"看起来像 Argent 坏了"的红。
+
+/** 同源判据的三态。 */
+export const BIN_SOURCE_LEVEL = { OK: 'ok', WARN: 'warn', FAIL: 'fail' }
+
+/**
+ * ⚠️ 候选序列的唯一实现（含**平铺档** `<dir>/node_modules/.bin/dsh`）在真源
+ * `scripts/lib/dsh-scope.mjs#scopeBinCandidates()`，而"取第一个存在的"那个取用口
+ * （`resolveBootcheckBin()`）也在同一文件（P1-3 2026-10-12 上移 + 搬家）。
+ *
+ * **本文件刻意不 import 它**：本文件被 `scripts/tests/kernel-purity.test.mjs` 认领为 **L1**
+ * （理由原文："纯 node 内建、零宿主 import"），而该门禁的既有约定是 `scripts/lib/dsh-*.mjs`
+ * 属 **L2**（宿主运维档）⇒ **L1 不得引用 `dsh-*` 模块**。要"这个 scope 自带的 dsh"的调用方
+ * （`plugin-bootcheck.mjs`，L2）直接从真源取 —— 两条纪律（"候选序列只许一份实现" +
+ * "L1 零宿主 import"）都成立，且**不必为绕过门禁抬任何基线**。
+ */
+
+/**
+ * 「被测 dsh 与目标 scope 是否同源」的**纯判据**（比对双方自报的 dsh 版本）。
+ *
+ * · 两边版本都拿到且**一致** ⇒ `ok`
+ * · 两边版本都拿到且**不一致** ⇒ `fail`（硬前置不满足）；`allowMismatch` 时降级成 `warn`
+ * · 任一边拿不到 ⇒ `warn`（⛔ 不静默：明说"无法证明同源"，而不是假装通过）
+ *
+ * @param {object} o
+ * @param {string|null} o.binVersion    被测 dsh 自报版本（`dsh --version`）
+ * @param {string|null} o.scopeVersion  目标 scope 里 `@deepseek-ai/dsh` 的版本
+ * @param {string|null} [o.binPath]     被测 dsh 路径（证据原文用）
+ * @param {string|null} [o.scopeDir]    目标 scope 目录（证据原文用）
+ * @param {boolean} [o.allowMismatch]   显式接受风险（`BOOTCHECK_ALLOW_VERSION_MISMATCH=1`）⇒ warn
+ * @returns {{level:'ok'|'warn'|'fail', why:string}}
+ */
+export function compareBinScopeVersions({ binVersion = null, scopeVersion = null, binPath = null, scopeDir = null, allowMismatch = false } = {}) {
+  const detail = `被测 dsh=${binPath ?? '?'}（自报 ${binVersion ?? '拿不到'}）｜目标 scope=${scopeDir ?? '?'}（dsh=${scopeVersion ?? '拿不到'}）`
+  if (binVersion && scopeVersion) {
+    if (binVersion === scopeVersion) return { level: BIN_SOURCE_LEVEL.OK, why: `同源（双方 dsh 版本一致 = ${binVersion}）：${detail}` }
+    const why = `${detail}\n  两侧**不同源**：隔离 profile 会解析到目标 scope（${scopeVersion}），而宿主可执行文件是 ${binVersion}` +
+      ` ⇒ 0.2 的 peer 门禁会把 profile 插件行**逐条** disable（\`disabling profile plugin row\` + \`startup failed\`），` +
+      `输出与"Argent 坏了"无法区分。\n  出路：① 设 \`DSH_BIN=<目标 scope 自带的 dsh>\`` +
+      `（平铺树 \`<dir>/node_modules/.bin/dsh\`；标准布局 \`<prefix>/bin/dsh\`；客户机 \`~/.local/node/bin/dsh\`）；` +
+      `② 或把 \`DSH_SCOPE\` 指向被测 dsh 所属的那个 scope。` +
+      `\n  （已实测：把 bin 换成目标 scope 自带的那个 ⇒ 全绿；这不是目标 scope 的问题。）`
+    return { level: allowMismatch ? BIN_SOURCE_LEVEL.WARN : BIN_SOURCE_LEVEL.FAIL, why }
+  }
+  if (!binVersion) return { level: BIN_SOURCE_LEVEL.WARN, why: `拿不到被测 dsh 的自报版本 ⇒ **无法证明**它与目标 scope 同源（⛔ 不静默，按"未证明"记）：${detail}` }
+  return { level: BIN_SOURCE_LEVEL.WARN, why: `拿不到目标 scope 的 dsh 版本 ⇒ 无法与宿主对照（⛔ 不静默）：${detail}` }
+}
+
+// ── 启动日志判据 ──────────────────────────────────────────────────────────
+
+/** 禁用行（0.2 peer 门禁）原文匹配。 */
+export const DISABLE_ROW_RE = /disabling profile plugin row "([^"]+)"/
+/** 装配失败行。 */
+export const STARTUP_FAILED_RE = /^\s*dsh: startup failed:/
+
+/**
+ * **提供行判据表**（不是硬编码一个字符串）。
+ * 每条 = 某插件 `apply()` 走到底时自己打的那行；`required` 为 true 的必须命中。
+ * 来源列写明**仓库内的出处**，改动插件日志时同步改这张表（门禁 `bootcheck-wiring.test.mjs` 会核出处文件里真有该串）。
+ */
+export const PROVIDER_LINES = [
+  {
+    id: 'argent-core',
+    required: true,
+    re: /\[argent-core\]\s*已启动/,
+    sample: '[argent-core] 已启动，数据目录: …',
+    sourceFile: 'plugins/argent-core/src/index.js',
+    literals: ["[argent-core] 已启动"],
+  },
+  {
+    id: 'argent-flow',
+    required: false,
+    re: /\[argent-flow\][^\n]*失败回路(?:已装载|已启用)/,
+    sample: '[argent-flow] ⏸ 失败回路已装载但**未运行**：… ／ [argent-flow] 失败回路已启用：…',
+    sourceFile: 'plugins/argent-flow/src/index.js',
+    literals: ['失败回路已装载但', '失败回路已启用：'],
+  },
+  {
+    id: 'argent-gateway',
+    required: false,
+    re: /\[argent-gateway\][^\n]*(?:已启动，|跳过启动)/,
+    sample: '[argent-gateway] 无可用 Bot 配置（…）——跳过启动 ／ [argent-gateway] 已启动，N 个 Bot 路由（…）',
+    sourceFile: 'plugins/argent-gateway/src/index.js',
+    literals: ['——跳过启动', '[argent-gateway] 已启动，'],
+  },
+  {
+    id: 'argent-ml',
+    required: false,
+    re: /\[argent-ml\]\s*已启动/,
+    sample: '[argent-ml] 已启动，scriptsDir: …',
+    sourceFile: 'plugins/argent-ml/src/index.js',
+    literals: ['[argent-ml] 已启动'],
+  },
+  {
+    id: 'argent-drive',
+    required: false,
+    re: /\[argent-drive\]\s*v0\.8-B\s*执行内核已启动/,
+    sample: '[argent-drive] v0.8-B 执行内核已启动',
+    sourceFile: null, // 插件已退场（仓库内无实现文件）⇒ 只留历史判据，明示无出处
+    literals: [],
+  },
+]
+
+/** 装配级错误特征（与既有脚本同义）。 */
+export const FATAL_RE = /fatal load failure|is not defined|has been registered at|Duplicate service|Cannot find (module|name)|is not a function/
+
+/** 逐行抽取 `disabling profile plugin row` 的原文与结构化字段。 */
+export function extractDisableRows(log) {
+  const out = []
+  for (const line of String(log).split('\n')) {
+    const m = DISABLE_ROW_RE.exec(line)
+    if (!m) continue
+    const p = /Plugin ((?:@[^@\s/]+\/)?[^@\s]+)@([^\s]+) is incompatible with dsh ([^\s:]+)/.exec(line)
+    out.push({ row: m[1], pkg: p ? p[1] : null, version: p ? p[2] : null, dshVersion: p ? p[3] : null, line: line.trim() })
+  }
+  return out
+}
+
+/**
+ * 把禁用行归因成"**目标 scope 未接好**"还是"目标 scope 本身不兼容"。
+ * 判据 = 该行自称的版本 vs **从临时 profile 真解析出来的版本**：
+ *   · 两者**不一致** ⇒ 这行读的不是我们接的那个 scope（scope 未接好）
+ *   · 两者**一致** ⇒ 我们有意识地接上的 scope 就是供这个版本（目标 scope 自身不兼容，属真结论）
+ */
+export function classifyDisableRows(rows, { resolveVersion } = {}) {
+  if (!rows.length) return { kind: 'none', total: 0, mismatched: [], consistent: [], unresolved: [], summary: '零条禁用行' }
+  const mismatched = []
+  const consistent = []
+  const unresolved = []
+  for (const r of rows) {
+    const v = r.pkg && resolveVersion ? resolveVersion(r.pkg) : null
+    if (!v) unresolved.push(r)
+    else if (v !== r.version) mismatched.push({ ...r, resolvedVersion: v })
+    else consistent.push({ ...r, resolvedVersion: v })
+  }
+  let kind
+  if (mismatched.length) kind = 'scope-not-wired'
+  else if (consistent.length) kind = 'target-scope-incompatible'
+  else kind = 'unattributed'
+  const summary = kind === 'scope-not-wired'
+    ? `有 ${mismatched.length} 条禁用行读到的版本**不是**临时 profile 接的那个 scope 的版本 ⇒ 目标 scope 未接好`
+    : kind === 'target-scope-incompatible'
+      ? `有 ${consistent.length} 条禁用行的版本**正是**目标 scope 供的版本 ⇒ 目标 scope 自身与本次 dsh 不兼容`
+      : `有 ${rows.length} 条禁用行，但无法解析其包版本 ⇒ 原因未归因`
+  return { kind, total: rows.length, mismatched, consistent, unresolved, summary }
+}
+
+/** 检查提供行判据表；返回逐条命中情况。 */
+export function matchProviderLines(log) {
+  const text = String(log)
+  return PROVIDER_LINES.map((c) => ({ id: c.id, required: c.required, hit: c.re.test(text), sample: c.sample, sourceFile: c.sourceFile, literals: c.literals }))
+}
+
+/** preset 探针结果。 */
+export function readPresetProbe(log) {
+  const text = String(log)
+  const done = /\[preset-probe\] DONE fail=(\d+) total=(\d+)/.exec(text)
+  const fails = text.split('\n').filter((l) => l.includes('[preset-probe] FAIL')).map((l) => l.trim())
+  const oks = text.split('\n').filter((l) => l.includes('[preset-probe] OK')).length
+  return { done: !!done, fail: done ? Number(done[1]) : null, total: done ? Number(done[2]) : null, fails, oks }
+}
+
+/**
+ * **三态判定**。
+ * @param {string} log 子进程完整 stdout+stderr
+ * @param {object} ctx
+ * @param {number} ctx.expectedPresets  期望挂载的 preset 数（0 ⇒ 该判据 n/a）
+ * @param {boolean} [ctx.httpReady]     HTTP 是否就绪
+ * @param {number|null} [ctx.exitCode]  子进程退出码
+ * @param {(pkg:string)=>string|null} [ctx.resolveVersion] 从临时 profile 解析包版本
+ * @returns {{verdict:'PASS'|'FAIL'|'EVIDENCE-INSUFFICIENT', criteria:Array, reasons:string[], disable:object, providers:Array, probe:object}}
+ */
+export function evaluateBootLog(log, ctx = {}) {
+  const text = String(log ?? '')
+  const expectedPresets = ctx.expectedPresets ?? 0
+  const reasons = []
+  const rows = extractDisableRows(text)
+  const disable = classifyDisableRows(rows, { resolveVersion: ctx.resolveVersion })
+  const providers = matchProviderLines(text)
+  const probe = readPresetProbe(text)
+  const fatal = FATAL_RE.test(text)
+  const startupFailed = text.split('\n').some((l) => STARTUP_FAILED_RE.test(l))
+
+  // ── 判据 ① 零条 `disabling profile plugin row` / 零条 `startup failed` ──
+  const c1 = rows.length === 0 && !startupFailed
+  if (!c1) {
+    if (rows.length) reasons.push(`判据①失败：${rows.length} 条 \`disabling profile plugin row\`（归因：${disable.summary}）`)
+    if (startupFailed) reasons.push('判据①失败：出现 `dsh: startup failed:` 行')
+  }
+
+  // ── 判据 ② 提供行（判据表，required 全中 + 至少 1 条）──
+  const hit = providers.filter((p) => p.hit)
+  const missRequired = providers.filter((p) => p.required && !p.hit)
+  const c2 = hit.length > 0 && missRequired.length === 0
+  if (!c2) {
+    reasons.push(missRequired.length
+      ? `判据②失败：必需提供行缺失 [${missRequired.map((p) => p.id).join(', ')}]（表见 PROVIDER_LINES）`
+      : '判据②失败：日志里一条提供行都没有（判据表零命中）')
+  }
+
+  // ── 判据 ③ preset 探针（既有判据，⛔ 不放宽成"任一哨兵命中"）──
+  let c3 = true
+  if (expectedPresets > 0) {
+    c3 = probe.done && probe.fail === 0 && probe.total === expectedPresets
+    if (!c3) {
+      reasons.push(probe.done
+        ? `判据③失败：[preset-probe] DONE fail=${probe.fail} total=${probe.total}（期望 fail=0 total=${expectedPresets}）`
+        : `判据③失败：preset 挂载探针未完成（期望 ${expectedPresets} 个，实收 OK ${probe.oks} 个）`)
+    }
+  }
+
+  if (fatal) reasons.push('日志命中装配级错误特征（FATAL_RE）')
+
+  // ── 三态 ──
+  // 「证据不足」= 拿不到可用日志：零提供行 + 零探针结果 + 零禁用行（子进程没能给出任何判据面）。
+  const noEvidence = hit.length === 0 && !probe.done && rows.length === 0 && !fatal && !startupFailed
+  let verdict
+  if (noEvidence) verdict = 'EVIDENCE-INSUFFICIENT'
+  else if (c1 && c2 && c3 && !fatal) verdict = 'PASS'
+  else verdict = 'FAIL'
+
+  return { verdict, criteria: { zeroDisable: c1, providerLine: c2, presetProbe: c3, noFatal: !fatal }, reasons, disable, providers, probe, startupFailed, fatal }
+}