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

package/lib/server/domain/ai.js

@@ -1,5 +1,5 @@
 // L1 · domain —— ai.js（AI 赋能的纯逻辑部分：任务表与视图、DeepSeek 密钥与配置、占位符/Python/VLM 解析、写入白名单与运行白名单、内置计划模板、计划 JSON 解析；分层 Step 7 从 lib/index.js 搬出，只搬移未改逻辑。注：aiEmpowerPlan/Execute、runAiStep、aiRepair 吃运行上下文，留到 Step 8）
-// 分组见 D:\dsh\dsh-plugin-hub-plan\architecture.zh.md 三
+// 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
 import { dirname, join, basename, resolve } from 'node:path'
@@ -126,15 +126,41 @@ function resolvePlaceholders(value, jobOrEnv) {
     .replaceAll('${python}', python)
     .replaceAll('${scripts}', join(dirname(python), 'Scripts'))
     .replaceAll('${node}', process.execPath)
+    .replaceAll('${asciiData}', openVikingDataRoot())
     .replaceAll('${deepseekKey}', readDeepSeekKey())
 }
 
+/** 解析 Python 解释器：候选按平台分开，**不含任何开发机专有路径**。
+ *  win32：用户级安装目录（AppData\Local\Programs\Python）+ PATH 上的 python.exe；
+ *  POSIX：/usr/bin/python3、/usr/local/bin/python3、PATH 上的 python3/python。
+ *  原实现第一条写死开发机的绝对路径（`<盘符>:\python314\python.exe`），且三个候选全是 Windows 形态 ——
+ *  非 Windows 上永远解析不到，`${python}` 会退化成 Windows 专有名字。
+ *  解析不到时返回**本平台的命令名**（由执行阶段如实报错），不在这里抛。 */
 function resolvePythonPath() {
-  const candidates = [join('E:', 'python314', 'python.exe'), join(homedir(), 'AppData', 'Local', 'Programs', 'Python', 'Python314', 'python.exe'), 'python.exe']
+  const win = process.platform === 'win32'
+  const candidates = win
+    ? [
+      join(homedir(), 'AppData', 'Local', 'Programs', 'Python', 'Python314', 'python.exe'),
+      'python.exe',
+    ]
+    : ['/usr/bin/python3', '/usr/local/bin/python3', 'python3', 'python']
   for (const c of candidates) {
     if (existsSync(c)) return c
   }
-  return 'python.exe'
+  return win ? 'python.exe' : 'python3'
+}
+
+/** OpenViking 数据根：**必须纯 ASCII**（home 含非 ASCII 字符时，各语言的 Rust/原生向量库
+ *  写盘会报 UnicodeDecodeError）。三种来源，**不含任何写死的盘符**：
+ *    ① 环境变量 DSH_OPENVIKING_DATA_ROOT（用户显式指定，最高优先）
+ *    ② win32 历史默认：D:/OpenVikingData（保持既有实例的数据位置不变）
+ *    ③ 其他平台：${home}/.openviking/ascii-data
+ *  原实现无条件返回 'D:/OpenVikingData'：非 Windows 上它是个**相对路径**，会被写进 CWD
+ *  （服务进程的工作目录），在别人的机器上根本不是"ASCII 数据根"。 */
+function openVikingDataRoot() {
+  const override = process.env.DSH_OPENVIKING_DATA_ROOT
+  if (typeof override === 'string' && override.trim() !== '') return override.trim()
+  return process.platform === 'win32' ? 'D:/OpenVikingData' : join(homedir(), '.openviking', 'ascii-data')
 }
 
 /** 写入路径白名单：只允许 DSH profile、~/.dsh、~/.openviking、~/.cache/openviking、ASCII 数据根。 */
@@ -148,13 +174,13 @@ function isAllowedWritePath(p, profileDir) {
     norm(homedir()) + '/.local/share/openviking',
     norm(homedir()) + '/.dsh/repos',
     norm(profileDir),
-    'D:/OpenVikingData',
+    norm(openVikingDataRoot()),
   ]
   return roots.some((root) => target === root || target.startsWith(root + '/'))
 }
 
-/** run-cmd 可执行文件白名单（按 basename）。 */
-const ALLOWED_RUN_FILES = new Set(['curl.exe', 'curl', 'git.exe', 'git', 'node.exe', 'node', 'python.exe', 'python', 'py.exe', 'py', 'gh.exe', 'gh', 'npm.cmd', 'npm', 'ov.cmd', 'ov'])
+/** run-cmd 可执行文件白名单（按 basename；含 POSIX 名 python3，否则 ${python}=python3 会被自己拒掉）。 */
+const ALLOWED_RUN_FILES = new Set(['curl.exe', 'curl', 'git.exe', 'git', 'node.exe', 'node', 'python.exe', 'python3', 'python', 'py.exe', 'py', 'gh.exe', 'gh', 'npm.cmd', 'npm', 'ov.cmd', 'ov'])
 
 const DESTRUCTIVE_RE = /(^|\s)(rm\s+(-[a-zA-Z]*r)|rmdir\s+\/s|del\s+\/s|format\s+[a-zA-Z]:|Remove-Item\b|taskkill\s+\/im|reg\s+delete|schtasks\s+\/delete|shutdown|cipher\s+\/w)/iu
 
@@ -178,7 +204,7 @@ function builtinPlanFor(source) {
     .replace(/\/$/u, '')
   if (norm !== 'openviking' && norm !== 'volcengine/openviking') return null
   const home = homedir()
-  const storage = /^[\x00-\x7F]+$/u.test(home) ? `${home}/.openviking/data` : 'D:/OpenVikingData'
+  const storage = /^[\x00-\x7F]+$/u.test(home) ? `${home}/.openviking/data` : openVikingDataRoot()
   const vlm = resolveVlmForOpenViking()
   // 注意：路径必须在此处（JSON.stringify 之前）使用真实值，由 stringify 统一转义；
   // 不能在 content 中保留 ${home} 占位符——写文件时替换会把反斜杠路径变成非法 JSON 转义。
@@ -209,10 +235,12 @@ function aiEmpowerPresetFor(source) {
   const common = [
     '## 本机环境事实（务必遵守）',
     '- 网络：pypi.org 不通、清华镜像 403；pip 必须用 `--index-url https://mirrors.aliyun.com/pypi/simple/`。npm registry.npmjs.org 可能黑洞，pnpm 用 `--registry https://registry.npmmirror.com`。huggingface.co 被墙，模型文件一律用 `https://hf-mirror.com/<同一路径>`（执行器会自动把 huggingface.co 换成 hf-mirror.com，计划里也可直接写 hf-mirror）。',
-    // 0.5.28 改错：这条原本把它写成"本机用户名含中文（花火）"的**个案**，读起来像只在
+    // 0.5.28 改错：这条原本把它写成"本机用户名含非 ASCII 字符"的**个案**，读起来像只在
     // 那台机器上成立。真正的规则是通用的：只要**写盘路径**里出现非 ASCII 字符，各语言的
     // Rust/原生向量库就可能报 UnicodeDecodeError —— 与用户名具体是不是中文无关。
-    '- 用户名/路径含非 ASCII 字符时：任何写盘路径若含非 ASCII 字符，各语言的 Rust/原生向量库会报 UnicodeDecodeError——服务数据目录必须纯 ASCII（如 `D:/OpenVikingData`）。',
+    // 2026-09-29 改错：ASCII 数据根不再写死某个盘符，改用 `${asciiData}` 占位符
+    // （由 resolvePlaceholders 解析成"本平台/本用户"的 ASCII 数据根，见 openVikingDataRoot）。
+    '- 用户名/路径含非 ASCII 字符时：任何写盘路径若含非 ASCII 字符，各语言的 Rust/原生向量库会报 UnicodeDecodeError——服务数据目录必须纯 ASCII，用 `${asciiData}` 引用控制台给出的 ASCII 数据根（可用环境变量 DSH_OPENVIKING_DATA_ROOT 覆盖）。',
     '- 凭据复用：DSH 的 DeepSeek 密钥在 `${home}/.dsh/.credentials.yaml`（YAML 行 `DEEPSEEK_API_KEY: sk-...`）；模型选择在 `${home}/.dsh/settings.yaml` 的 `agent-default-model`（provider deepseek-official）。对外 OpenAI 兼容接口：api_base `https://api.deepseek.com`，模型名 `deepseek-v4-flash-vision-exp`。',
     '- 步骤解释用中文；每个动作一个步骤；步骤数尽量少；不得包含任何破坏性命令；服务类组件必须配 start-service + wait-health。',
   ]
@@ -222,8 +250,8 @@ function aiEmpowerPresetFor(source) {
       '## OpenViking 已验证的部署事实（v0.4.17，Python 3.14）',
       '- 安装：`pip install openviking[local-embed]`（含 llama-cpp-python 0.3.35，cp310-abi3 轮子可用；无需加 --force-reinstall）。',
       '- 嵌入模型：`bge-small-zh-v1.5-f16.gguf`（47MB，512 维中文）下载到 `${home}/.cache/openviking/models/`（写 download 步骤；URL 写 huggingface.co 会被执行器自动换 hf-mirror.com）。',
-      '- ov.conf 路径 `${home}/.openviking/ov.conf`，内容：vlm = { provider: openai, api_base: https://api.deepseek.com, model: deepseek-v4-flash-vision-exp, api_key: 从 `${home}/.dsh/.credentials.yaml` 读取并内联 }；embedding.dense = { provider: local, model: bge-small-zh-v1.5-f16, model_path: <上面的 gguf 路径> }；server = { host: 127.0.0.1, port: 1933 }（不要写 root_api_key，dev 免鉴权模式自动启用）；storage.workspace = `${home}` 含非 ASCII 时写 `D:/OpenVikingData`，否则 `${home}/.openviking/data`。',
-      '- 启动：start-service，file=`${python}`，args=`["-m","openviking_cli.server_bootstrap"]`，cwd=`${home}/.openviking`，healthUrl=`http://127.0.0.1:1933/health`，port=1933。服务器启动首次会建 `D:/OpenVikingData` 数据目录。',
+      '- ov.conf 路径 `${home}/.openviking/ov.conf`，内容：vlm = { provider: openai, api_base: https://api.deepseek.com, model: deepseek-v4-flash-vision-exp, api_key: 从 `${home}/.dsh/.credentials.yaml` 读取并内联 }；embedding.dense = { provider: local, model: bge-small-zh-v1.5-f16, model_path: <上面的 gguf 路径> }；server = { host: 127.0.0.1, port: 1933 }（不要写 root_api_key，dev 免鉴权模式自动启用）；storage.workspace = `${home}` 含非 ASCII 时写 `${asciiData}`，否则 `${home}/.openviking/data`。',
+      '- 启动：start-service，file=`${python}`，args=`["-m","openviking_cli.server_bootstrap"]`，cwd=`${home}/.openviking`，healthUrl=`http://127.0.0.1:1933/health`，port=1933。服务器启动首次会建 `${asciiData}` 数据目录。',
       '- 部署完成后惯例：重启 DSH 会话后 mcp__openviking__* 工具出现，`${home}/.openviking/pending` 的积压消息会在新会话启动时自动回放——把这写进总结。',
     ].join('\n')
   }

package/lib/server/domain/auto-disable.js

@@ -0,0 +1,226 @@
+// L1 · domain —— auto-disable.js（把「自动禁用」的**触发源**从"我们升级"扩到"指纹变化 / 启动失败记录"；
+// 0.5.32 加法 D5，用户 2026-09-29 明确要求「我们本来就有自动禁用，要的是扩展」）
+//
+// 现状（0.5.31）自动禁用只有两个触发点，**都绑在我们自己的动作上**：
+//   ① `healPatchSafety`（判"模块确证缺失"，随 GET /state 每 ≤2min 跑一次）
+//   ② 我们升级流程里的 `preflightDisableIncompatible`
+// 于是**别人**改框架（官方桌面端更新器 / 手动 pnpm / npx 缓存变化）时，两者都不触发 ——
+// 用户看到的是一堆报错，而不是"肇事行已被关掉、服务能起来"。
+//
+// 本模块把触发源接到 D1 的预检清单与启动失败记录上，**但必须带上 0.5.30 已立的安全栏**：
+//   ① **只禁有证据的行**：`package-unresolvable`（解析器在所有基准上都解析不到）/ `file-target-missing`
+//      （`file://` 目标确实不存在）/ 启动失败日志**点名**的行。**解析不确定**（没有基准、解析器抛错、
+//      子路径解析不到）一律**只报告不写盘**。
+//   ② **`@deepseek-ai/*`（框架自带）永不自动禁用**、**受保护/核心行永不自动禁用**
+//      （`framework.js:483/493` 那两类判据：`CORE_PATCH_ROW_IDS` + `isProtected`）。
+//   ③ **禁前先写 last-known-good 快照**：任何一次自动禁用都能一键 / 一条命令回滚。
+//   ④ **幂等零写盘** + **每次留一条可读记录**（时间 / 行 id / 证据 / 恢复命令）。
+//   ⑤ **开关**：`compat-gate.json#autoDisableOnEvidence`（默认启用；关闭 = 退回"只报告 + 等你点"）。
+//
+// 分层：L1 domain —— 无 ctx；落盘复用 `domain/safe-boot.js` 的同一套原语（备份 + 原子写 + 读回核实）。
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { CORE_PATCH_ROW_IDS } from './patch.js'
+import { parsePatchRows } from './patch-composition-audit.js'
+import { disableSuspects, ensureSnapshotForCurrentState } from './safe-boot.js'
+import { dshHome } from '../infra/paths.js'
+
+/** 自动禁用的可读记录（追加式 JSONL：每次自动禁用一条，永不覆盖历史）。 */
+const autoDisableLog = (home = undefined) => join(home ?? dshHome(), 'plugin-console', 'auto-disable.log')
+
+/** 有证据的行必须落在这些 `code` 上（其余一律只报告）。 */
+const EVIDENCE_CODES = {
+  'package-unresolvable': '包在所有解析基准上都解析不到（确证缺失）',
+  'file-target-missing': 'file:// 目标文件确实不存在（确证缺失）',
+  'boot-log': '启动失败日志点名了这一行',
+  'boot-quarantine': '升级脚本留下的启动失败隔离记录点名了这一行',
+}
+
+/** 明确**不算**证据的形态（写在这里是为了让"为什么没禁"可查，而不是静默放过）。 */
+const NON_EVIDENCE_CODES = {
+  'subpath-unresolvable': '子路径解析不到（父包还在，可能只是导出变了）',
+  'row-without-name': '行既没有 name 也没有 config（形态可疑但无证据）',
+  'legacy-source-kind': '源码里的旧形状（可以自动改，不需要禁用）',
+  'legacy-source-kind-unresolved': '旧形状无法安全改写（需要人工过一眼）',
+  'schemastery-volatile': '依赖副本陈旧（对齐依赖即可，不需要禁用）',
+}
+
+/** 框架自带包（`@deepseek-ai/*`）—— 永不由本模块自动禁用。 */
+const isFrameworkOwnedName = (name) => {
+  const text = String(name ?? '')
+  if (text.startsWith('@deepseek-ai/')) return true
+  // 裸包名形态（补丁行写 `dsh-xxx` 而不是全名）也要认：框架内置包在补丁里两种写法都出现过
+  return /^dsh-[a-z0-9-]+$/iu.test(text)
+}
+
+/**
+ * 从「D1 预检清单 + 启动失败记录」里挑出**有确证证据、且过得了安全栏**的行（纯函数，不写盘）。
+ * @returns {{ disable: Array<{rowId,moduleName,evidence,detail}>, skipped: Array<{rowId,reason,evidence?}>, hasEvidence: boolean }}
+ */
+function planEvidenceDisable({
+  affected = [], bootRows = [], patchText = '', coreRowIds = CORE_PATCH_ROW_IDS,
+  isProtected = null, uncertainty = null, maxRows = 20,
+} = {}) {
+  const rows = parsePatchRows(patchText)
+  const byId = new Map(rows.map((r) => [r.id, r]))
+  const disable = []
+  const skipped = []
+  const pushSkip = (rowId, reason, evidence = null) => {
+    if (typeof rowId !== 'string' || rowId === '') return
+    if (disable.some((d) => d.rowId === rowId)) return
+    if (skipped.some((s) => s.rowId === rowId)) return
+    skipped.push({ rowId, reason, evidence })
+  }
+
+  // 解析面**不确定**（一个基准都没有 / 解析器建不起来）→ 整批只报告，绝不写盘
+  if (typeof uncertainty === 'string' && uncertainty !== '') {
+    for (const item of affected) if (item?.rowId) pushSkip(item.rowId, `resolution-uncertain: ${uncertainty}`, item.code ?? null)
+    return { disable, skipped, hasEvidence: false }
+  }
+
+  // ① D1 预检清单里的**确证**证据
+  for (const item of (Array.isArray(affected) ? affected : [])) {
+    const rowId = typeof item?.rowId === 'string' ? item.rowId : null
+    if (rowId === null) continue
+    const code = item.code ?? null
+    if (EVIDENCE_CODES[code] === undefined) { pushSkip(rowId, `not-evidence: ${NON_EVIDENCE_CODES[code] ?? code ?? 'unknown'}`, code); continue }
+    if (coreRowIds.has(rowId)) { pushSkip(rowId, 'core-row', code); continue }
+    if (rowId === 'plugin-console') { pushSkip(rowId, 'self', code); continue }
+    const row = byId.get(rowId) ?? null
+    if (row === null) { pushSkip(rowId, 'not-in-patch', code); continue }
+    if (row.disabled === true) { pushSkip(rowId, 'already-disabled', code); continue }
+    const moduleName = typeof item.moduleName === 'string' && item.moduleName !== '' ? item.moduleName : (row.name ?? null)
+    if (moduleName === null) { pushSkip(rowId, 'module-unknown', code); continue }
+    if (isFrameworkOwnedName(moduleName)) { pushSkip(rowId, 'framework-owned', code); continue }
+    if (typeof isProtected === 'function' && isProtected(moduleName) === true) { pushSkip(rowId, 'protected-module', code); continue }
+    if (disable.length >= maxRows) { pushSkip(rowId, 'row-limit', code); continue }
+    disable.push({ rowId, moduleName, evidence: code, detail: EVIDENCE_CODES[code] })
+  }
+
+  // ② 启动失败记录点名的行（计划里的 `rows`：分析器已剔除核心行/不可开关行）
+  for (const rowId of (Array.isArray(bootRows) ? bootRows : [])) {
+    if (typeof rowId !== 'string' || rowId === '') continue
+    if (coreRowIds.has(rowId) || rowId === 'plugin-console') { pushSkip(rowId, 'core-row', 'boot-log'); continue }
+    const row = byId.get(rowId) ?? null
+    if (row === null) { pushSkip(rowId, 'not-in-patch', 'boot-log'); continue }
+    if (row.disabled === true) { pushSkip(rowId, 'already-disabled', 'boot-log'); continue }
+    const moduleName = row.name ?? null
+    if (moduleName !== null && isFrameworkOwnedName(moduleName)) { pushSkip(rowId, 'framework-owned', 'boot-log'); continue }
+    if (moduleName !== null && typeof isProtected === 'function' && isProtected(moduleName) === true) { pushSkip(rowId, 'protected-module', 'boot-log'); continue }
+    if (disable.length >= maxRows) { pushSkip(rowId, 'row-limit', 'boot-log'); continue }
+    disable.push({ rowId, moduleName, evidence: 'boot-log', detail: EVIDENCE_CODES['boot-log'] })
+  }
+  return { disable, skipped, hasEvidence: disable.length > 0 }
+}
+
+/** 追加一条可读记录（JSONL；失败不抛 —— 它不能把自动禁用本身带崩）。 */
+function appendDisableLog(entry, { home = undefined, appendFile = (p, d) => appendFileSync(p, d, 'utf8'), mkdir = (d) => mkdirSync(d, { recursive: true }) } = {}) {
+  try {
+    const file = autoDisableLog(home)
+    mkdir(dirname(file))
+    appendFile(file, `${JSON.stringify(entry)}\n`)
+    return { ok: true, file }
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+/** 读记录（新→旧；损坏行跳过）。 */
+function readDisableLog({ home = undefined, limit = 50, readFile = (p) => readFileSync(p, 'utf8') } = {}) {
+  try {
+    return readFile(autoDisableLog(home))
+      .split(/\r?\n/u)
+      .filter((l) => l.trim() !== '')
+      .map((l) => { try { return JSON.parse(l) } catch { return null } })
+      .filter((x) => x !== null)
+      .slice(-limit)
+      .reverse()
+  } catch { return [] }
+}
+
+/**
+ * 有证据就自动禁用（D5 的落盘入口）。**顺序是关键**：
+ *   计划（纯判定）→ **禁前快照**（当前状态有可回滚材料）→ 复用 `disableSuspects`
+ *   （改前备份 + 严格 YAML 闸门 + 原子写 + 读回核实）→ 追加可读记录。
+ * 任一步失败都如实返回，**绝不部分静默**；`enabled !== true` 时只报告不写盘（退回"等你点"）。
+ */
+function applyEvidenceDisable({
+  patchPath, patchText = null, affected = [], bootRows = [], enabled = true,
+  fingerprint = null, frameworkVersion = null, reasons = [], home = undefined,
+  isProtected = null, uncertainty = null, coreRowIds = CORE_PATCH_ROW_IDS,
+  readFile = (p) => readFileSync(p, 'utf8'), exists = existsSync, ...rest
+} = {}) {
+  try {
+    if (typeof patchPath !== 'string' || patchPath === '') return { ok: false, code: 'no-patch-path', disabled: [], skipped: [] }
+    // 补丁不存在 → 如实拒绝（**绝不创建**：凭一份"没读到的补丁"去写 disabled 块等于凭空造文件）
+    if (typeof patchText !== 'string' && exists(patchPath) !== true) {
+      return { ok: false, code: 'patch-missing', disabled: [], skipped: [], error: `补丁文件不存在：${patchPath}` }
+    }
+    const text = typeof patchText === 'string' ? patchText : readFile(patchPath)
+    const plan = planEvidenceDisable({ affected, bootRows, patchText: text, coreRowIds, isProtected, uncertainty })
+    if (plan.disable.length === 0) {
+      return { ok: true, code: 'no-evidence', disabled: [], skipped: plan.skipped, snapshot: null, note: '没有确证证据可禁用（只报告不写盘）' }
+    }
+    if (enabled !== true) {
+      return {
+        ok: true, code: 'switch-off', disabled: [], skipped: plan.skipped, snapshot: null,
+        candidates: plan.disable.map((d) => d.rowId),
+        note: '自动禁用开关已关闭：只报告，等你手动点「只禁可疑行」（或离线脚本 --disable-suspects）',
+      }
+    }
+    // ③ 禁前先写 last-known-good 快照：没有可回滚材料就不动手
+    const snap = ensureSnapshotForCurrentState({
+      patchPath, patchText: text, fingerprint, frameworkVersion, reasons, home,
+      note: `自动禁用前的安全快照（点名 ${plan.disable.length} 行：${plan.disable.map((d) => d.rowId).join('、')}）`,
+      readFile,
+    })
+    if (snap.ok !== true) {
+      return { ok: false, code: 'snapshot-failed', disabled: [], skipped: plan.skipped, snapshot: snap, error: `禁前快照失败，已放弃自动禁用：${snap.error ?? '未知原因'}` }
+    }
+    const result = disableSuspects({
+      patchPath, rowIds: plan.disable.map((d) => d.rowId), home, coreRowIds,
+      moduleNameOf: (rowId) => plan.disable.find((d) => d.rowId === rowId)?.moduleName ?? null,
+      isProtected, isFrameworkOwned: null, readFile,
+    })
+    const entry = {
+      at: Date.now(),
+      kind: 'auto-disable',
+      source: 'evidence',
+      added: result.ok === true ? (result.added ?? []) : [],
+      skipped: result.skipped ?? plan.skipped,
+      evidence: plan.disable.map((d) => ({ rowId: d.rowId, moduleName: d.moduleName, code: d.evidence, detail: d.detail })),
+      snapshotId: snap.id ?? null,
+      backupPath: result.backupPath ?? null,
+      patchPath,
+      frameworkVersion: frameworkVersion ?? fingerprint?.frameworkVersion ?? null,
+      fingerprint: fingerprint ?? null,
+      restoreCommand: 'node scripts/safe-boot.mjs --restore-last-good',
+      result: { ok: result.ok === true, code: result.code ?? null, error: result.error ?? null },
+    }
+    const logged = appendDisableLog(entry, { home })
+    if (result.ok !== true) {
+      return { ok: false, code: result.code ?? 'disable-failed', disabled: [], skipped: result.skipped ?? plan.skipped, snapshot: snap, error: result.error ?? '自动禁用失败', log: logged }
+    }
+    return {
+      ok: true, code: result.changed === true ? 'auto-disabled' : 'noop', disabled: result.added ?? [], skipped: result.skipped ?? plan.skipped,
+      snapshot: snap, backupPath: result.backupPath ?? null, log: logged, prefixSame: result.prefixSame === true,
+      note: result.changed === true
+        ? `已自动禁用 ${result.added.length} 行（有确证证据；禁前快照 ${snap.id}，可一条命令回滚）`
+        : '点名行都已处于禁用状态（幂等零写盘）',
+    }
+  } catch (error) {
+    return { ok: false, code: 'auto-disable-failed', disabled: [], skipped: [], error: `自动禁用失败：${error instanceof Error ? error.message : String(error)}` }
+  }
+}
+
+export {
+  EVIDENCE_CODES,
+  NON_EVIDENCE_CODES,
+  appendDisableLog,
+  applyEvidenceDisable,
+  autoDisableLog,
+  isFrameworkOwnedName,
+  planEvidenceDisable,
+  readDisableLog,
+}

package/lib/server/domain/auto-preflight-run.js

@@ -0,0 +1,184 @@
+// L1 · domain —— auto-preflight-run.js（**只读**预检运行器：指纹变化后现场跑一次扫描；0.5.32 加法 D1）
+//
+// 与 `routes/framework-preflight.js` 的分工：
+//   · 那条路由是**用户手动点**的完整预检（目标版本可指定、会打 registry 抓契约、可能写补丁）；
+//   · 本模块是**指纹变化自动触发**的**只读**预检 —— 不下载、不安装、不改补丁、不碰 loader，
+//     只用「内置规则库 + 本地文件 + 补丁体检 + 启动失败日志分析」产出三样东西：
+//       ① 兼容清单（受影响行）  ② 隔离计划（建议禁用哪些行、为什么）  ③ 变更摘要（版本 from→to / 包增减 / 指纹 reasons）
+// 网络：自动模式下**一律跳过外部 registry**（自动触发不该偷偷联网）—— 结论完全由本地判据得出，
+//      这也是「离线脚本能在服务没跑时用同一套判据」的前提。
+//
+// 分层：L1 domain —— 不出现 ctx（loader 条目 / 扫描根由调用方注入）；IO 与纯判据分离，离线可断言。
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { affectedRows, planSuspectRows, summarizeDelta } from './auto-preflight.js'
+import { loadContractRules, summarizeContractRules } from './contract-rules.js'
+import { collectProducerTargets, scanProducerFiles } from './format-scan.js'
+import { CORE_PATCH_ROW_IDS } from './patch.js'
+import { classifyPatchRows, parsePatchRows } from './patch-composition-audit.js'
+import { collectPresetAudit } from './preset-audit.js'
+import { planQuarantine, readQuarantineRecord } from './quarantine.js'
+import { makePackageResolver } from '../infra/package-resolve.js'
+
+/** 扫不到规则库时的兜底规则（与 routes/framework-preflight.js 的兜底一字不差）。 */
+const DEFAULT_RULES = { producerKindRequired: false, forbiddenKinds: ['plugin'], pluginPrefix: 'plugin:', renames: {} }
+
+/** 自动模式下的固定说明（如实告诉用户"这份结论没打网络"）。 */
+const OFFLINE_NOTE = {
+  zh: '自动预检是只读且不联网的：结论来自内置规则库与本地文件；目标版本的 registry 契约未核对（可手动跑完整预检）',
+  en: 'Auto-preflight is read-only and offline: conclusions come from the built-in rule pack and local files; the target-version registry contract was not checked (run the full preflight manually)',
+}
+
+/**
+ * `<pnpmRoot>/.pnpm` 下的 `@deepseek-ai+*` 实体名（去版本后缀）—— 用于变更摘要的「新增/消失的包」。
+ * ★ 只用于**摘要展示**，绝不用于「包在不在」的判定：pnpm 会截断超长目录名（见 infra/package-resolve.js 头注释），
+ *   所以解析性判定一律走 Node 解析器（本文件里的 `resolve`）。
+ */
+function packageNamesOf(pnpmRoot, readDir = (dir) => readdirSync(dir)) {
+  if (typeof pnpmRoot !== 'string' || pnpmRoot === '') return []
+  let names = []
+  try { names = readDir(join(pnpmRoot, '.pnpm')) } catch { return [] }
+  const out = new Set()
+  for (const name of names) {
+    if (typeof name !== 'string' || !name.startsWith('@deepseek-ai+')) continue
+    const at = name.indexOf('@', 1)
+    out.add(at === -1 ? name : name.slice(0, at))
+  }
+  return [...out].sort()
+}
+
+/** `file://` URL → 路径（离线安全；解析失败抛给调用方，由调用方转成 false）。 */
+function fileUrlToPath(url) {
+  return fileURLToPath(String(url ?? ''))
+}
+
+/**
+ * 跑一次只读预检（**同步**：全部是本地文件扫描，调用方用 withTimeout 包裹即可）。
+ * @param {object} input
+ * @param {string|null} input.profileDir   profile 目录（补丁所在目录）
+ * @param {string|null} input.patchPath    cordis.patch.yml 绝对路径
+ * @param {object|null} input.current      当前指纹（frameworkVersion / pnpmEntities / pnpmRoot）
+ * @param {object|null} input.previous     基线指纹（可能为 null）
+ * @param {string[]} input.presetRoots     预设扫描根（通常 `<dshHome>/.agent-presets`）
+ * @param {Array<{root:string,kind:string,moduleName?:string|null}>} input.roots 生产方扫描根
+ * @param {string[]} input.reasons         指纹变更原因（直接来自 compareFingerprint）
+ * @param {string[]} input.previousPackages 上一次记录的框架包名（没有则空数组 → 摘要如实标 rationaleAvailable=false）
+ * @param {boolean} input.networkAllowed   是否允许打网络（自动预检一律 false）
+ * @param {Array} [input.targets]          直接给扫描目标（测试注入；缺省由 roots 推导）
+ * @param {boolean} [input.includeBootLog] 是否把 profile 下的 `.dsh-boot.log` 纳入启动失败分析（缺省 true）
+ */
+function runAutoPreflightScan(input = {}) {
+  const {
+    profileDir = null, patchPath = null, current = null, previous = null,
+    presetRoots = [], roots = [], reasons = [], previousPackages = [],
+    networkAllowed = false, targets = null, includeBootLog = true,
+    readFile = (p) => readFileSync(p, 'utf8'), existsFile = existsSync, readDir = (dir) => readdirSync(dir),
+  } = input
+
+  // ① 补丁体检（只读）：行 → 包可解析性（blocker / warning / 改名建议）
+  const patchText = typeof patchPath === 'string' && existsFile(patchPath) ? readFile(patchPath) : ''
+  const rows = parsePatchRows(patchText)
+  const bases = [profileDir, current?.pnpmRoot]
+    .map((b) => (typeof b === 'string' && b !== '' ? b : null))
+    .filter(Boolean)
+  const resolve = bases.length > 0 ? makePackageResolver(bases) : null
+  const patchReport = resolve === null
+    ? { blockers: [], warnings: [], resolvable: [], patchOnly: [], skipped: '没有可用的解析基准（profile 目录与框架运行时根都拿不到）' }
+    : classifyPatchRows(rows, {
+      resolve: (name) => resolve(name),
+      existsFile: (url) => { try { return existsFile(fileUrlToPath(url)) } catch { return false } },
+      candidates: [],
+    })
+
+  // ② 生产方源码扫描（会话格式契约）：规则来自**数据化规则库**（对我们没发过升级包的框架版本同样有效）
+  const rulePack = (() => { try { return loadContractRules() } catch { return null } })()
+  const hasRules = Array.isArray(rulePack?.rules) && rulePack.rules.length > 0
+  const scanTargets = Array.isArray(targets) ? targets : collectProducerTargets(roots)
+  const scan = scanProducerFiles({ targets: scanTargets, rules: hasRules ? rulePack.rules : DEFAULT_RULES, targetVersion: current?.frameworkVersion ?? null })
+  const scanSafe = { ...scan, files: (scan.files ?? []).slice(0, 40), findings: (scan.findings ?? []).slice(0, 40) }
+
+  // ③ 预设声明行体检（只读；失败如实记 error，不假装"零发现"）
+  let presetAudit = null
+  try {
+    presetAudit = collectPresetAudit({ presetsRoot: presetRoots[0] ?? null, patchPath })
+  } catch (error) {
+    presetAudit = { ok: false, error: error instanceof Error ? error.message : String(error), blockers: 0, stale: [], missing: [], orphan: [], targetMissing: [] }
+  }
+
+  // ④ 受影响行 + 隔离计划（只**建议**，绝不写盘）
+  const affected = affectedRows({ patchReport, scan, rows })
+  const plan = planSuspectRows(affected, { coreRowIds: CORE_PATCH_ROW_IDS, toggleableById: new Map() })
+
+  // ⑤ 我们的升级脚本若曾留下隔离记录，把它并进计划（旧记录仍有效）。
+  //    别人升级时没有这份记录 —— 这正是 0.5.32 补的缺口：兜底输入换成「指纹变化自动预检」的结论。
+  let bootQuarantine = null
+  try { bootQuarantine = readQuarantineRecord() } catch { bootQuarantine = null }
+  if (bootQuarantine !== null && Array.isArray(bootQuarantine.rows)) {
+    for (const rowId of bootQuarantine.rows) {
+      if (typeof rowId !== 'string' || rowId === '') continue
+      if (plan.suspects.some((s) => s.rowId === rowId)) continue
+      plan.suspects.push({ rowId, moduleName: null, reason: 'boot-quarantine', detail: '升级脚本留下的启动失败隔离记录', line: null })
+    }
+  }
+
+  // ⑥ 启动失败日志（若存在）：把「谁把服务搞挂了」也变成点名行
+  let bootPlan = null
+  if (includeBootLog === true) {
+    try {
+      const logPath = join(dirname(String(patchPath ?? join(profileDir ?? '.', 'x'))), '.dsh-boot.log')
+      if (existsFile(logPath)) {
+        bootPlan = planQuarantine({ logText: readFile(logPath), candidates: rows.map((r) => ({ rowId: r.id, moduleName: r.name, toggleable: true })) })
+        for (const rowId of bootPlan.rows ?? []) {
+          if (!plan.suspects.some((s) => s.rowId === rowId)) plan.suspects.push({ rowId, moduleName: null, reason: 'boot-log', detail: '启动失败日志点名', line: null })
+        }
+      }
+    } catch { bootPlan = null }
+  }
+
+  const delta = summarizeDelta({
+    current,
+    previous,
+    currentPackages: packageNamesOf(current?.pnpmRoot ?? null, readDir),
+    previousPackages,
+  })
+  const blockers = affected.filter((a) => a.severity === 'blocker').length
+  return {
+    ok: true,
+    at: Date.now(),
+    targetVersion: current?.frameworkVersion ?? null,
+    previousVersion: previous?.frameworkVersion ?? null,
+    reasons: Array.isArray(reasons) ? reasons : [],
+    summary: {
+      frameworkVersionFrom: previous?.frameworkVersion ?? null,
+      frameworkVersionTo: current?.frameworkVersion ?? null,
+      versionChanged: (previous?.frameworkVersion ?? null) !== (current?.frameworkVersion ?? null),
+      blockers,
+      affectedCount: affected.length,
+      suspectCount: plan.suspects.length,
+      packagesAdded: delta.packagesAdded,
+      packagesRemoved: delta.packagesRemoved,
+      note: blockers > 0 ? `预检发现 ${blockers} 行受影响` : '预检未发现受影响行',
+    },
+    affected,
+    suspects: plan.suspects,
+    skipped: plan.skipped,
+    delta,
+    // D5（自动禁用的扩展触发源）要用的两样东西：确证证据（affected 的行/码）与启动失败点名行。
+    // 这里是**只读**产出，是否落盘由 routes 层按开关决定（domain 不做"要不要动用户文件"的判断）。
+    evidence: {
+      uncertainty: resolve === null ? '没有可用的解析基准（profile 目录与框架运行时根都拿不到）' : (typeof patchReport.skipped === 'string' ? patchReport.skipped : null),
+      rows: affected.filter((a) => a.rowId !== null).map((a) => ({ rowId: a.rowId, moduleName: a.moduleName ?? null, code: a.code ?? null, severity: a.severity })),
+      bootRows: (bootPlan?.rows ?? []),
+    },
+    patch: { patchPath, rows: rows.length, blockers: (patchReport.blockers ?? []).length, warnings: (patchReport.warnings ?? []).length, skipped: patchReport.skipped ?? null },
+    scan: scanSafe,
+    rules: hasRules ? summarizeContractRules(rulePack) : { source: 'unavailable', version: null, updatedAt: null, total: 0, blockers: 0, autoDetected: 0, ids: [], error: '规则库不可用：本次扫描只用内置兜底规则（结论偏保守）' },
+    presetAudit,
+    bootPlan,
+    network: { allowed: networkAllowed === true, note: networkAllowed === true ? null : OFFLINE_NOTE },
+  }
+}
+
+export { DEFAULT_RULES, OFFLINE_NOTE, fileUrlToPath, packageNamesOf, runAutoPreflightScan }