@noob-stupid/dsh-plugin-console 0.5.38 → 0.5.39

package/lib/server/domain/dep-source.js

@@ -20,7 +20,7 @@
 //      不经 tarball 完整性校验，lock 删掉重建、node_modules 清空重装都稳定通过。
 
 import { existsSync, rmSync, mkdirSync, realpathSync } from 'node:fs'
-import { basename, dirname, join } from 'node:path'
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
 import { copyTree } from '../infra/fsx.js'
 import { fetchJsonUrl } from '../infra/http.js'
 import { dshHome } from '../infra/paths.js'
@@ -113,6 +113,65 @@ function linkSpecFor(dir) {
   return `link:${String(dir).replace(/\\/gu, '/')}`
 }
 
+/**
+ * 依赖规格的**唯一规范形**（0.5.39 加法）：`link:` / `file:` 这类**路径型**来源统一成 pnpm 实际写出的
+ * 形态 —— **正斜杠**（是绝对还是相对保持调用方给的选择：pnpm 的 lock 里由它自己决定，见
+ * lock-importer.js#lockVersionText）。其它 spec（版本号/范围/dist-tag/URL/git）只做 trim。
+ *
+ * 为什么必须归一（真机证据，2026-10-04）：desktop profile 的 `@noob-stupid/dsh-connection-card-host`
+ * 清单里是 `link:D:\dsh-link\dsh-connection-card-host`（**反斜杠**），而所有写回路径都是逐字比较
+ * （`pinProfileDependency` / `setProfileDependency` / `declareProfileDependency` 的 `deps[name] === spec`）
+ * ⇒ 任何一次「钉住」都会把它改成正斜杠 —— 用户没要求的漂移，而且幂等性彻底失效（每次都"有变化"）。
+ */
+function canonicalSourceSpec(spec) {
+  if (typeof spec !== 'string') return null
+  const s = spec.trim()
+  const m = /^(link:|file:)([\s\S]*)$/u.exec(s)
+  if (m === null) return s
+  let target = m[2].replace(/\\/gu, '/').replace(/\/{2,}/gu, '/')
+  // 去掉尾部多余的斜杠（但别把盘根 `C:/` 或 POSIX 根 `/` 也削掉）
+  if (target.length > 1 && /\/$/u.test(target) && !/:\/$/u.test(target)) target = target.replace(/\/+$/u, '')
+  return `${m[1]}${target}`
+}
+
+/** 路径型 spec 的目标目录（相对写法按 profile 目录解析）；非路径型返回 null。 */
+function sourceSpecTarget(profileDir, spec) {
+  const canonical = canonicalSourceSpec(spec)
+  if (canonical === null) return null
+  const m = /^(link:|file:)([\s\S]*)$/u.exec(canonical)
+  if (m === null || m[2] === '') return null
+  const raw = m[2]
+  try {
+    return isAbsolute(raw) ? raw : resolve(String(profileDir ?? ''), raw)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 两种写法是否**指向同一个东西**（0.5.39 加法，Fix 2 的判据）：等价即视为**完好、零写盘**。
+ *   · 先比规范形（`link:C:/x` ↔ `link:C:\x` ↔ `link:C:/x/` 全部等价）；
+ *   · 路径型再比 realpath（相对↔绝对、Windows 大小写差异、符号链接指向同一目录都算等价）。
+ * 只用它做"要不要写"的判断；真正写盘时一律写**规范形**（canonicalSourceSpec）。
+ */
+function sameSourceSpec(profileDir, a, b) {
+  const na = canonicalSourceSpec(a)
+  const nb = canonicalSourceSpec(b)
+  if (na === null || nb === null) return false
+  if (na === nb) return true
+  if (!/^(?:link:|file:)/u.test(na) || !/^(?:link:|file:)/u.test(nb)) return false
+  const pa = sourceSpecTarget(profileDir, na)
+  const pb = sourceSpecTarget(profileDir, nb)
+  if (pa === null || pb === null) return false
+  try {
+    const ra = realpathSync(pa)
+    const rb = realpathSync(pb)
+    return process.platform === 'win32' ? ra.toLowerCase() === rb.toLowerCase() : ra === rb
+  } catch {
+    return false
+  }
+}
+
 /**
  * manifest 里的 `link:` 规格当前是否**真的**还生效（`node_modules/<包名>` 就是指向它的那个链接）。
  * 为什么必须查：release / curl 通道更新包时是「先 rmSync 再 copyTree」，会把 `node_modules/<包名>`
@@ -198,4 +257,4 @@ function suggestedReconcileAction({ profileDir = null, profile = null, reason =
   }
 }
 
-export { PLUGIN_SRC_DIR, NPM_NAME_RE, probeRegistryPackage, probeFailureKind, materializePackageForLink, linkSpecFor, linkSpecIsIntact, profileNameOf, suggestedAllowBuildsAction, suggestedPinAction, suggestedReconcileAction }
+export { PLUGIN_SRC_DIR, NPM_NAME_RE, probeRegistryPackage, probeFailureKind, materializePackageForLink, linkSpecFor, linkSpecIsIntact, profileNameOf, suggestedAllowBuildsAction, suggestedPinAction, suggestedReconcileAction, canonicalSourceSpec, sameSourceSpec, sourceSpecTarget }

package/lib/server/domain/lock-importer.js

@@ -0,0 +1,411 @@
+// L1 · domain —— lock-importer.js（pnpm-lock.yaml importer 条目的**定点写入** + **只读**校验；0.5.39 加法）
+//
+// 为什么存在（用户 2026-10-04 定案，两处真缺陷）：
+//   ① `reconcileLockfile` 过去对 `link:` 漂移一律跑一次**完整** `pnpm add`（拉包、动 node_modules、
+//      重写整份 lock）—— 而 lock 里 link 依赖的持久化**只需要 importer 里那两行**
+//      （pnpm 对 link 依赖不写 packages/snapshots —— 本机 pnpm 11.21.0 实测）。所以非 registry 来源的
+//      lock 持久化 = 本模块的定点写入（**唯一实现**；persist.js 走的 reconcile 通路就是这一条），
+//      `pnpm add` **不再**充当持久化手段。
+//   ② 写出后必须用 **只读** 的 pnpm 校验确认 lock 仍可解析：`install --lockfile-only --dry-run
+//      --frozen-lockfile`（实测：成功与失败两种结局下 lock 都逐字节不变）；失败或无法确认 ⇒ 调用方
+//      报「未持久化」+ 一键钉住，**绝不报成功**。
+//
+// ★ 现场事实（2026-10-04 实测，pnpm 11.21.0，本机 desktop profile 的副本）：
+//   `pnpm install --lockfile-only`（**不加** `--dry-run`）会把**无关条目**的 peer 后缀剥掉 ——
+//   实测把 `@deepseek-ai/dsh-experimental-schedule-bundle` / `dsh-schedule` 的
+//   `(@deepseek-ai/dsh-brand@0.1.7-rc.2)` 去掉。⇒ 它**不是**"定点补一条"的无损工具，因此：
+//     · 本模块的写入是**纯文本外科手术**（只动目标条目的那几行，其余字节逐字保留，见 planLockImporterEntry）；
+//     · 校验只用 `--dry-run`（并且每次校验后核对 lock 字节，一旦发现被动过就**立即还原**并报未确认）。
+//
+// 分层：L1 domain —— 不认识 cordis ctx；IO 与 pnpm 执行都可注入（便于离线单测跑正控/负控）。
+import { readFileSync, writeFileSync } from 'node:fs'
+import { isAbsolute, join, relative, resolve } from 'node:path'
+import { buildPnpmEnv, runPnpmWithFallback } from '../infra/exec.js'
+import { queuedWrite } from '../infra/fsx.js'
+
+/** importers 段里 pnpm 认的三个依赖分区（与 lockfile-health.js#DEP_SECTIONS 同一形状）。 */
+const IMPORTER_SECTIONS = ['dependencies', 'devDependencies', 'optionalDependencies']
+
+/**
+ * 能由 importer 条目**完整**表达的来源（唯一白名单）：`link:`。
+ * 为什么其余的不在这里（本机 pnpm 11.21.0 实测）：`file:` / `git+` / tarball URL 依赖除了 importer 那两行，
+ * pnpm 还要写 `packages:` / `snapshots:` 里的**解析记录**（file: 目录 = `resolution: {directory: …}`，
+ * file: tgz 与 URL = `integrity`），只留 importer 时 `pnpm install --lockfile-only` 会把 packages 段
+ * 重新补出来 ⇒ 本地无法凭空确定，**绝不伪造**（也不退回 `pnpm add`；由调用方如实报未持久化 + 一键钉住）。
+ */
+const IMPORTER_ONLY_RE = /^link:/u
+
+/** 该校验/写入用的 lock 文件名（唯一常量，别处不要再拼字面量）。 */
+const LOCKFILE_NAME = 'pnpm-lock.yaml'
+
+/** 只读校验的超时（`--dry-run --lockfile-only` 实测 0.5~1.5s；给足余量，失败即如实报）。 */
+const VERIFY_TIMEOUT_MS = 60000
+
+/** 该来源是否走「只写 lock importer 条目」的定点写入（唯一判据；调用方不许再各判一套）。 */
+function canWriteImporterEntry(spec) {
+  return typeof spec === 'string' && IMPORTER_ONLY_RE.test(spec.trim())
+}
+
+/**
+ * lock 里 importer 键行的判据（**唯一真源**）：`name:` / `'name':` / `"name":` 三种形态都认。
+ * 与 selfupdate.js#lockVersion 的键判据**逐字同一份**（真机证据：pnpm 对含 `/`、`@` 的包名加引号，
+ * 对未加 scope 的裸名不加 —— 0.5.38 修过一次"裸键读不出来"，两处各写一份必然再次分叉）。
+ */
+function lockEntryKeyMatches(line, name) {
+  const trimmed = String(line).trim()
+  const bare = trimmed.replace(/^'|':?$/gu, '').replace(/'$/u, '')
+  const bareKey = trimmed.replace(/'$/u, '').replace(/:$/u, '')
+  const unquoted = trimmed.replace(/^"|":?$/gu, '').replace(/"$/u, '')
+  return trimmed === `'${name}':` || trimmed === `"${name}":` || bare === name || bareKey === name || unquoted === name
+}
+
+/** YAML 明文标量安全吗（危险形态才加引号）。普通路径/URL/`link:…` 一律**明文** —— pnpm 自己就是
+ *  这么写的（真机 lock 证据：`specifier: link:C:/Users/花火/.dsh/plugin-src/…` 未加引号；
+ *  `@` 与 `:` 出现在**中间**是合法明文，只有出现在开头/结尾或后跟空格才是危险形态）。 */
+function yamlScalar(value) {
+  const text = String(value)
+  const needsQuote = text === ''
+    || /[\n\r\t]/u.test(text)
+    || /^\s|\s$/u.test(text)
+    || /:\s|:$/u.test(text)
+    || /#/u.test(text)
+    || /^[!&*?|>%@`"'[\]{},-]/u.test(text)
+  return needsQuote ? `'${text.replace(/'/gu, "''")}'` : text
+}
+
+/**
+ * `link:` 规格在 lock 里的 `version:` 形态（**pnpm 实际写出的形态**，真机 + 本机实测双重证据）：
+ *   · 同盘 → 相对 profile 目录的路径（`link:../../plugin-src/x`）；
+ *   · 跨盘（`path.relative` 只能给出绝对路径）→ 绝对路径（`link:D:/dsh-link/x`）；
+ *   · 一律**正斜杠**（清单里的反斜杠目标也归一成正斜杠 —— 真机 desktop profile 的
+ *     `link:D:\dsh-link\…` 在 lock 里就是 `link:D:/dsh-link/…`）。
+ * 非 link: 规格返回 null（不在本模块的白名单里）。
+ */
+function lockVersionText(profileDir, spec) {
+  if (!canWriteImporterEntry(spec)) return null
+  const raw = spec.trim().slice('link:'.length).replace(/\\/gu, '/')
+  if (raw === '') return null
+  const abs = isAbsolute(raw) ? raw : resolve(String(profileDir), raw)
+  let rel = ''
+  try {
+    rel = relative(String(profileDir), abs)
+  } catch {
+    rel = ''
+  }
+  const text = rel !== '' && !isAbsolute(rel) ? rel : abs
+  return `link:${String(text).replace(/\\/gu, '/')}`
+}
+
+/**
+ * 纯函数：把 lock 文本改成"该包在 importer 里有正确条目"的文本（**只动它自己那几行**）。
+ * 返回 `{ ok, changed, text, reason }`；`changed:false` 表示磁盘上的形态已经就是目标形态（零写盘）。
+ * 形态不认识的 lock（没有 importers 段 / 缩进不是 pnpm 的形状）→ `ok:false` + 原因，**绝不猜着改**。
+ */
+function planLockImporterEntry(lockText, { name, specifier, version, section = IMPORTER_SECTIONS[0] } = {}) {
+  const text = typeof lockText === 'string' ? lockText : String(lockText ?? '')
+  const eol = /\r\n/u.test(text) ? '\r\n' : '\n'
+  const trailing = /\r?\n$/u.test(text)
+  const lines = text.split(/\r?\n/u)
+  if (trailing && lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
+  const rebuild = (next) => next.join(eol) + (trailing ? eol : '')
+  const fail = (reason) => ({ ok: false, changed: false, text, reason })
+
+  const start = lines.findIndex((l) => /^importers:\s*$/u.test(l))
+  if (start === -1) return fail('lock 里没有 importers 段（形态不认识），已跳过定点写入')
+  // 根 importer（profile 是单项目工程 → 键是 `.`；找不到就退回第一个 importer）
+  let importerAt = -1
+  let importerEnd = lines.length
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^[A-Za-z]/u.test(lines[i])) {
+      if (importerAt !== -1) importerEnd = i
+      break
+    }
+    const key = /^\s{2}(\S.*?):\s*$/u.exec(lines[i])
+    if (key !== null) {
+      if (importerAt === -1) importerAt = i
+      if (key[1] === '.') {
+        importerAt = i
+        // 该 importer 的结束位置：下一个缩进 ≤2 的非空行
+        for (let k = i + 1; k < lines.length; k += 1) {
+          if (lines[k].trim() !== '' && !/^\s{3,}/u.test(lines[k])) {
+            importerEnd = k
+            break
+          }
+        }
+        break
+      }
+    }
+  }
+  if (importerAt === -1) return fail('lock 里读不到 importer 键（形态不认识），已跳过定点写入')
+
+  const wanted = [yamlScalar(`specifier: ${specifier}`), yamlScalar(`version: ${version}`)]
+  // 扫该 importer：既找该包现有条目（就地改），也记录目标分区的插入点
+  let foundAt = -1
+  let foundSection = null
+  let foundBlockEnd = -1
+  let target = IMPORTER_SECTIONS.includes(section) ? section : IMPORTER_SECTIONS[0]
+  let currentSection = null
+  let insertAt = -1
+  for (let i = importerAt + 1; i < importerEnd; i += 1) {
+    const line = lines[i]
+    if (line.trim() === '') continue
+    const sec = /^\s{4}([A-Za-z]+):\s*$/u.exec(line)
+    if (sec !== null) {
+      currentSection = sec[1]
+      if (currentSection === target) {
+        // 目标分区的插入点：本分区最后一个条目之后（遇到缩进 ≤4 的非空行即本分区结束）
+        let last = i
+        for (let k = i + 1; k < importerEnd; k += 1) {
+          if (lines[k].trim() !== '' && !/^\s{5,}/u.test(lines[k])) break
+          last = k
+        }
+        insertAt = last + 1
+      }
+      continue
+    }
+    if (foundAt === -1 && /^\s{6}\S/u.test(line) && lockEntryKeyMatches(line, name)) {
+      foundAt = i
+      foundSection = currentSection
+      // 该条目的块范围（键行 + 缩进更深的字段行）
+      foundBlockEnd = i + 1
+      for (let k = i + 1; k < importerEnd; k += 1) {
+        if (lines[k].trim() !== '' && !/^\s{7,}/u.test(lines[k])) break
+        foundBlockEnd = k + 1
+      }
+    }
+  }
+
+  if (foundAt !== -1) {
+    // 就地改：只替换/补齐 specifier 与 version 两行，其它字段与所有无关行逐字保留
+    const keyIndent = /^\s*/u.exec(lines[foundAt])[0]
+    const fieldIndent = `${keyIndent}  `
+    const block = lines.slice(foundAt + 1, foundBlockEnd)
+    const next = [...block]
+    let sawSpecifier = false
+    let sawVersion = false
+    for (let k = 0; k < next.length; k += 1) {
+      const field = /^\s*(specifier|version):/u.exec(next[k])
+      if (field === null) continue
+      if (field[1] === 'specifier') {
+        sawSpecifier = true
+        next[k] = `${fieldIndent}specifier: ${yamlScalar(specifier)}`
+      } else {
+        sawVersion = true
+        next[k] = `${fieldIndent}version: ${yamlScalar(version)}`
+      }
+    }
+    if (!sawSpecifier) next.unshift(`${fieldIndent}specifier: ${yamlScalar(specifier)}`)
+    if (!sawVersion) next.push(`${fieldIndent}version: ${yamlScalar(version)}`)
+    if (next.join(eol) === block.join(eol)) {
+      return { ok: true, changed: false, text, reason: null, section: foundSection ?? target, version, specifier }
+    }
+    return {
+      ok: true,
+      changed: true,
+      text: rebuild([...lines.slice(0, foundAt + 1), ...next, ...lines.slice(foundBlockEnd)]),
+      reason: null,
+      section: foundSection ?? target,
+      version,
+      specifier,
+    }
+  }
+
+  // 没有该条目 → 在目标分区末尾插入一条（分区不存在时先补分区头）
+  const keyText = /[/@]/u.test(name) ? `'${name}':` : `${name}:`
+  const block = [`      ${keyText}`, `        specifier: ${yamlScalar(specifier)}`, `        version: ${yamlScalar(version)}`]
+  if (insertAt === -1) {
+    // 分区不存在：插到该 importer 现有分区之后（没有分区就紧跟 importer 键行）
+    let at = importerAt + 1
+    for (let i = importerAt + 1; i < importerEnd; i += 1) {
+      if (lines[i].trim() === '') continue
+      at = i + 1
+    }
+    return {
+      ok: true,
+      changed: true,
+      text: rebuild([...lines.slice(0, at), `    ${target}:`, ...block, ...lines.slice(at)]),
+      reason: null,
+      section: target,
+      version,
+      specifier,
+    }
+  }
+  return {
+    ok: true,
+    changed: true,
+    text: rebuild([...lines.slice(0, insertAt), ...block, ...lines.slice(insertAt)]),
+    reason: null,
+    section: target,
+    version,
+    specifier,
+  }
+}
+
+/**
+ * 写入（**唯一写入口**）：读 → 纯函数改造 → 写 → **读回核实**（既有规矩：写完必须读回，绝不凭返回值
+ * 报成功）。走 fsx 的写队列（与清单/补丁写入同一把锁，避免并发读改写互相覆盖）。
+ * 返回 `{ changed, unchanged, specifier, version, section, reason }`；任何一步不成 ⇒ `changed:false` + 原因。
+ */
+async function writeLockImporterEntry(profileDir, { name, spec, section = IMPORTER_SECTIONS[0], deps = {} } = {}) {
+  const readText = typeof deps.readText === 'function' ? deps.readText : (p) => readFileSync(p, 'utf8')
+  const writeText = typeof deps.writeText === 'function' ? deps.writeText : (p, text) => writeFileSync(p, text, 'utf8')
+  const file = join(String(profileDir), LOCKFILE_NAME)
+  const specifier = typeof spec === 'string' ? spec.trim() : ''
+  const version = lockVersionText(profileDir, specifier)
+  if (version === null) {
+    return { changed: false, unchanged: false, specifier, version: null, section, reason: '该来源的 lock 记录不止 importer 一行，本地无法确定 ⇒ 未写入（不用 pnpm add 当持久化手段）' }
+  }
+  return queuedWrite(async () => {
+    let text = null
+    try {
+      text = readText(file)
+    } catch (error) {
+      return { changed: false, unchanged: false, specifier, version, section, reason: `读不到 ${LOCKFILE_NAME}（${error instanceof Error ? error.message : String(error)}），未写入` }
+    }
+    const plan = planLockImporterEntry(text, { name, specifier, version, section })
+    if (plan.ok !== true) return { changed: false, unchanged: false, specifier, version, section, reason: plan.reason }
+    if (plan.changed !== true) return { changed: false, unchanged: true, specifier: plan.specifier, version: plan.version, section: plan.section, reason: null }
+    try {
+      writeText(file, plan.text)
+    } catch (error) {
+      return { changed: false, unchanged: false, specifier, version, section, reason: `写盘失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+    let after = null
+    try {
+      after = readText(file)
+    } catch (error) {
+      return { changed: false, unchanged: false, specifier, version, section, reason: `写盘后读回失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+    if (after !== plan.text) return { changed: false, unchanged: false, specifier, version, section, reason: '写盘后读回与预期不一致（未能核实），按未写入处理' }
+    return { changed: true, unchanged: false, specifier: plan.specifier, version: plan.version, section: plan.section, reason: null }
+  })
+}
+
+/**
+ * 从 lock 自己的 `settings:` 段取出 pnpm 配置，供**只读**校验按 lock 的形态复算
+ * （不镜像它时 pnpm 直接 `ERR_PNPM_LOCKFILE_CONFIG_MISMATCH`：本机实测 `autoInstallPeers`）。
+ * 只认单行标量；对象/数组等复杂设置一律不传（不猜）。
+ */
+function lockfileSettingsFlags(lockText) {
+  const lines = String(lockText ?? '').split(/\r?\n/u)
+  const start = lines.findIndex((l) => /^settings:\s*$/u.test(l))
+  if (start === -1) return []
+  const flags = []
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^[A-Za-z]/u.test(lines[i])) break
+    const m = /^\s{2}([A-Za-z][A-Za-z0-9]*):\s*(.+?)\s*$/u.exec(lines[i])
+    if (m === null) continue
+    const value = m[2].replace(/^'|'$/gu, '')
+    if (!/^[A-Za-z0-9._-]+$/u.test(value)) continue
+    flags.push(`--config.${m[1]}=${value}`)
+  }
+  return flags
+}
+
+/** 只读校验的 argv（**唯一产出点**，纯函数，便于单测断言"没有任何写盘开关"）。 */
+function verifyArgsFor({ registry = null, settings = [], relaxReleaseAge = false } = {}) {
+  const args = ['install', '--lockfile-only', '--dry-run', '--frozen-lockfile']
+  if (typeof registry === 'string' && registry.trim() !== '') args.push('--registry', registry.trim())
+  args.push(...settings)
+  // ★ 供应链年龄闸（pnpm 的 minimumReleaseAge，默认 24h）会在**解析之前**卡住整份 lock：
+  //   本机实测（刚发布的 @noob-stupid/dsh-plugin-console@0.5.37 在 24h 窗口内）不加它时任何
+  //   `--lockfile-only` 调用都只报 ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION，看不出 lock 到底能不能解析。
+  //   它与"lock 可解析"是两件事，所以**只读重试**时才放宽；`--dry-run` + `--lockfile-only` 下不装任何东西
+  //   （实测 lock 逐字节不变）。**写盘路径永不出现这个开关**（修复 argv 由 lockfile-health#repairArgsFor
+  //   唯一产出，那一处一个字没动）。
+  if (relaxReleaseAge) args.push('--config.minimumReleaseAge=0')
+  return args
+}
+
+/** 错误文本尾部（面板要能看到 pnpm 的原始输出，不允许只报"失败了"）。 */
+function tailOf(error) {
+  const message = String(error?.message ?? error ?? '')
+  return message.split(/\r?\n/u).filter((l) => l.trim() !== '').slice(-3).join(' ⏎ ').slice(0, 400)
+}
+
+/**
+ * **只读**校验：这条 lock 现在还能被 pnpm 解析吗（`install --lockfile-only --dry-run --frozen-lockfile`）。
+ * 返回 `{ verified, via, reason, attempts, changed }`：
+ *   · `verified:true`  —— pnpm 退出码 0，且 lock 字节**逐字节未变**；
+ *   · `verified:false` —— pnpm 明确报错（lock 形态/配置有问题）；
+ *   · `verified:null`  —— pnpm 根本跑不起来（执行方式不可用）⇒ "无法确认"，调用方按未持久化处理。
+ * `changed:true` 表示校验过程**动过** lock（理论上不可能，`--dry-run` 的硬前提）——此时立即还原原字节
+ * 并把结论降为未确认：宁可报"没确认"，也绝不留下被校验命令改过的 lock。
+ */
+async function verifyLockReadOnly({ profileDir, registry = null, run = runPnpmWithFallback, deps = {}, execOpts = {} } = {}) {
+  const file = join(String(profileDir), LOCKFILE_NAME)
+  let before = null
+  try {
+    before = readFileSync(file, 'utf8')
+  } catch (error) {
+    return { verified: false, via: null, changed: false, attempts: [], reason: `读不到 ${LOCKFILE_NAME}（${error instanceof Error ? error.message : String(error)}），无法校验` }
+  }
+  const settings = lockfileSettingsFlags(before)
+  const attempts = []
+  const once = async (relax) => {
+    const args = verifyArgsFor({ registry, settings, relaxReleaseAge: relax })
+    try {
+      await run(args, { execOpts: { cwd: profileDir, timeout: VERIFY_TIMEOUT_MS, windowsHide: true, maxBuffer: 4 * 1024 * 1024, env: buildPnpmEnv(registry), ...execOpts } })
+      attempts.push({ args, ok: true, tail: null })
+      return { ok: true, tail: null }
+    } catch (error) {
+      const tail = tailOf(error)
+      attempts.push({ args, ok: false, tail })
+      return { ok: false, tail, error }
+    }
+  }
+  const guard = () => {
+    // 校验必须是无损的：核对字节，被动过就还原（并如实标注 changed）
+    let now = null
+    try {
+      now = readFileSync(file, 'utf8')
+    } catch {
+      return { changed: true, restored: false }
+    }
+    if (now === before) return { changed: false, restored: false }
+    try {
+      writeFileSync(file, before, 'utf8')
+      return { changed: true, restored: true }
+    } catch {
+      return { changed: true, restored: false }
+    }
+  }
+  let outcome = await once(false)
+  if (outcome.ok !== true && /MINIMUM_RELEASE_AGE|minimumReleaseAge/iu.test(String(outcome.tail))) outcome = await once(true)
+  const bytes = guard()
+  const via = attempts.filter((a) => a.ok).length > 0 ? 'pnpm install --lockfile-only --dry-run --frozen-lockfile' : null
+  if (bytes.changed) {
+    return {
+      verified: null,
+      via,
+      changed: true,
+      restored: bytes.restored,
+      attempts,
+      reason: `只读校验**改动了** ${LOCKFILE_NAME}（违反只读前提）——已${bytes.restored ? '还原' : '尝试还原失败'}，按未确认处理`,
+    }
+  }
+  if (outcome.ok === true) return { verified: true, via, changed: false, attempts, reason: null }
+  const unavailable = /ENOENT|Cannot find module|已尝试：/u.test(String(outcome.tail)) && !/ERR_PNPM_/u.test(String(outcome.tail))
+  return {
+    verified: unavailable ? null : false,
+    via,
+    changed: false,
+    attempts,
+    reason: `${unavailable ? 'pnpm 执行方式不可用（无法确认）' : 'pnpm 只读校验未通过'}：${outcome.tail ?? '（无输出）'}`,
+  }
+}
+
+export {
+  IMPORTER_SECTIONS,
+  IMPORTER_ONLY_RE,
+  LOCKFILE_NAME,
+  VERIFY_TIMEOUT_MS,
+  canWriteImporterEntry,
+  lockEntryKeyMatches,
+  lockVersionText,
+  lockfileSettingsFlags,
+  planLockImporterEntry,
+  verifyArgsFor,
+  verifyLockReadOnly,
+  writeLockImporterEntry,
+}

package/lib/server/domain/manifest.js

@@ -12,7 +12,7 @@
 
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { linkSpecFor, materializePackageForLink, probeFailureKind, probeRegistryPackage, suggestedPinAction } from './dep-source.js'
+import { linkSpecFor, materializePackageForLink, probeFailureKind, probeRegistryPackage, sameSourceSpec, suggestedPinAction } from './dep-source.js'
 import { queuedWrite } from '../infra/fsx.js'
 import { resolvePackageJson } from '../infra/paths.js'
 import { reconcileLockfile } from './selfupdate.js'
@@ -174,7 +174,9 @@ async function declareProfileDependency(profileDir, packageName, version = null,
   const result = await queuedWrite(async () => {
     const manifest = await readManifest(profileDir)
     const deps = { ...(manifest.dependencies ?? {}) }
-    if (deps[packageName] === plan.spec) return { changed: false }
+    // 0.5.39 改错（Fix 2）：逐字比较会把「同一目标的另一种写法」当成漂移 —— 真机 desktop profile 的
+    // `link:D:\dsh-link\…`（反斜杠）会被这条路径无谓改写成正斜杠（用户没要求的漂移）。等价 ⇒ 零写盘。
+    if (sameSourceSpec(profileDir, deps[packageName], plan.spec)) return { changed: false }
     deps[packageName] = plan.spec
     manifest.dependencies = deps
     await writeManifest(profileDir, manifest)
@@ -230,14 +232,16 @@ async function pinProfileDependency(profileDir, packageName, options = {}) {
   const changed = await queuedWrite(async () => {
     const manifest = await readManifest(profileDir)
     const deps = { ...(manifest.dependencies ?? {}) }
-    if (deps[packageName] === spec) return false
+    // 0.5.39 改错（Fix 2）：等价写法（正/反斜杠、相对↔绝对指向同一目录）**不再改写清单** ——
+    // 幂等零写盘；只有真漂移（目标不同/确实缺失）才写，且写的是 linkSpecFor 的**规范形**。
+    if (sameSourceSpec(profileDir, deps[packageName], spec)) return false
     deps[packageName] = spec
     manifest.dependencies = deps
     await writeManifest(profileDir, manifest)
     return true
   })
   const after = await specOf(profileDir, packageName)
-  return { ok: after === spec, spec, before, after, changed, dir }
+  return { ok: sameSourceSpec(profileDir, after, spec), spec, before, after, changed, dir }
 }
 
 /**
@@ -252,7 +256,8 @@ async function setProfileDependency(profileDir, packageName, spec) {
   const changed = await queuedWrite(async () => {
     const manifest = await readManifest(profileDir)
     const deps = { ...(manifest.dependencies ?? {}) }
-    if (deps[packageName] === spec) return false
+    // 0.5.39 改错（Fix 2）：判等用同一把尺子（canonicalSourceSpec + realpath）—— 等价即零写盘
+    if (sameSourceSpec(profileDir, deps[packageName], spec)) return false
     deps[packageName] = spec
     manifest.dependencies = deps
     await writeManifest(profileDir, manifest)

package/lib/server/domain/persist.js

@@ -31,7 +31,7 @@
 // 分层：L1 domain —— 不认识 cordis ctx；IO 与四个写入器都可注入（便于离线单测跑正控/负控）。
 import { existsSync, lstatSync, readFileSync, realpathSync } from 'node:fs'
 import { join } from 'node:path'
-import { PLUGIN_SRC_DIR, linkSpecFor, profileNameOf, linkSpecIsIntact } from './dep-source.js'
+import { PLUGIN_SRC_DIR, linkSpecFor, profileNameOf, linkSpecIsIntact, sameSourceSpec } from './dep-source.js'
 import { isUnder } from '../infra/framework-root.js'
 import { addBundleToManifest, declareProfileDependency, pinProfileDependency, setProfileDependency } from './manifest.js'
 import { appendInsert, parseInsertNames } from './patch.js'
@@ -145,11 +145,15 @@ function lockPart({ profileDir, packageName, spec }) {
   const value = String(entry).trim()
   const s = typeof spec === 'string' ? spec.trim() : ''
   if (s.startsWith('link:')) {
-    if (value.startsWith('link:')) {
+    // 0.5.39 改错（Fix 2）：link 条目还必须**指向清单里的同一个目标** —— 只判"以 link: 开头"会把
+    // 「清单指 A、lock 指 B」当成就位，而 pnpm 下一次操作会按 lock 把链接还原到 B（真实漂移）。
+    if (value.startsWith('link:') && sameSourceSpec(profileDir, value, s)) {
       out.ok = true
       return out
     }
-    out.reason = `清单把该包钉在 ${s}，而 lock 里是 ${value}（对账后会被 pnpm 还原）`
+    out.reason = value.startsWith('link:')
+      ? `清单把该包钉在 ${s}，而 lock 里是 ${value}（**指向的目标不同**，对账后会被 pnpm 还原）`
+      : `清单把该包钉在 ${s}，而 lock 里是 ${value}（对账后会被 pnpm 还原）`
     return out
   }
   if (EXACT_VERSION_RE.test(s)) {
@@ -361,6 +365,18 @@ async function ensurePersisted({ profileDir, patchPath, packageName, mode = 'ins
     }
   }
   const after = persistReport({ profileDir, patchPath, packageName, entries })
+  // 0.5.39 加法（修 1 的收尾）：reconcile 写出 lock importer 条目后会用 pnpm 的**只读**用法确认 lock
+  // 仍可解析；「没通过 / 无法确认」时**不能**因为磁盘上有那两行就报成功 —— 按未持久化处理。
+  // 判据与文案都来自同一条通路（reconcile 的 lockVerified/lockNote），本模块只把结论并进来，不新判一套。
+  let lockVerdict = null
+  if (lock !== null && typeof lock === 'object' && (lock.lockVerified === false || lock.lockVerified === null) && lock.lockUpdated !== true) {
+    const reason = lock.lockNote ?? 'lock 已写入，但 pnpm 的只读校验未能确认它可解析'
+    after.parts.lock = { ...after.parts.lock, ok: false, reason }
+    after.missing = PERSIST_PARTS.filter((key) => after.parts[key].ok !== true)
+    after.persisted = after.missing.length === 0
+    after.note = after.persisted ? null : persistNote(after)
+    lockVerdict = { verified: lock.lockVerified, reason }
+  }
   const suggested = after.persisted ? null : suggestedPersistAction({ packageName, profileDir, missing: after.missing, reason: after.note })
   return {
     persisted: after.persisted,
@@ -370,6 +386,7 @@ async function ensurePersisted({ profileDir, patchPath, packageName, mode = 'ins
     parts: after.parts,
     declared,
     lock,
+    lockVerdict,
     bundled,
     rowId: after.parts.mount.rowId ?? rowId ?? null,
     notes,

package/lib/server/domain/selfupdate.js

@@ -12,7 +12,9 @@
 //            ③ 回读核实 readInstalledVersion / lockVersion；都不匹配才回落手铺文件，且**必须**带 lockNote 警告。
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { linkSpecFor, linkSpecIsIntact, materializePackageForLink, probeRegistryPackage, suggestedPinAction } from './dep-source.js'
+import { linkSpecFor, linkSpecIsIntact, materializePackageForLink, probeRegistryPackage, sameSourceSpec, suggestedPinAction } from './dep-source.js'
+import { canWriteImporterEntry, lockEntryKeyMatches, verifyLockReadOnly, writeLockImporterEntry } from './lock-importer.js'
+import { readManifestDeps } from './lockfile-health.js'
 import { pnpmInstall } from './install.js'
 import { fetchJsonUrl } from '../infra/http.js'
 import { runPnpmWithFallback } from '../infra/exec.js'
@@ -72,16 +74,15 @@ function lockVersion(profileDir, name) {
     return null
   }
   for (let i = 0; i < lines.length; i += 1) {
-    const trimmed = lines[i].trim()
     // 键形态三种都认（0.5.38 改错）：`name`、`'name':`（pnpm 对**含 `/`/`@`** 的包名加引号）、
     // `name:`（pnpm 对**未加 scope** 的包名不加引号）。旧判据漏了第三种 ⇒ 未加 scope 的 `link:`
     // 依赖在 importers 里明明有条目却读不出来（真机 desktop profile 的 `dshmarket` 就是：
     // lock 的 35-37 行写着 `dshmarket: / specifier: link:… / version: link:../../plugin-src/dshmarket`，
     // 而 `lockVersion()` 返回 null）——后果是面板永远报"没写进 pnpm-lock.yaml"、pin 永远 partial、
     // 每次对账都白跑一次 `pnpm add`。真值一律从下面这一处读，别在调用方再补一套。
-    const bare = trimmed.replace(/^'|':?$/gu, '').replace(/'$/u, '')
-    const bareKey = trimmed.replace(/'$/u, '').replace(/:$/u, '')
-    if (bare === name || bareKey === name || trimmed === `'${name}':`) {
+    // 0.5.39：键判据搬进 lock-importer.js#lockEntryKeyMatches —— 定点**写**入也要认同一批键形态，
+    // 两处各写一份必然再次分叉（写进去的键、读的时候认不出，就是 0.5.38 那个现场）。
+    if (lockEntryKeyMatches(lines[i], name)) {
       for (let k = i + 1; k < Math.min(i + 8, lines.length); k += 1) {
         const m = /^\s*version:\s*(\S+)\s*$/u.exec(lines[k])
         if (m) return m[1]
@@ -210,14 +211,113 @@ const EXACT_VERSION_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u
  */
 const DIST_TAG_RE = /^[A-Za-z][A-Za-z0-9._-]*$/u
 
+/**
+ * manifest spec 的写入器（0.5.39 加法）：**复用 manifest.js 那一个既有写入器**
+ * `setProfileDependency`（只改 `dependencies[包名]` 一个键、走同一把写队列），本模块**不新造第二套**。
+ * 为什么用动态 import：manifest.js 顶部 import 了本模块的 `reconcileLockfile`（syncLockFor 用），
+ * 静态互相 import 会成环；这里只在**真的需要改清单**时才按需取一次（同进程内 import 有缓存，零成本）。
+ * 单测可用 `deps.setSpec` 直接替换（离线夹具不需要真写清单时）。
+ */
+async function defaultSetSpec(profileDir, packageName, spec) {
+  // 注意：这里**不能**用解构（`const { setProfileDependency } = await import(…)`）—— 架构守卫的自由变量
+  // 扫描认不出解构声明（`const {` 形态），会把导入名误判成"没声明/没 import"的自由变量。
+  const manifestModule = await import('./manifest.js')
+  return manifestModule.setProfileDependency(profileDir, packageName, spec)
+}
+
+/** 该包在清单里属于哪个依赖分区（复用 lockfile-health.js 的既有解析器，不新写一份）。 */
+function manifestSectionOf(profileDir, name) {
+  try {
+    const { deps } = readManifestDeps(readFileSync(join(String(profileDir), 'package.json'), 'utf8'))
+    return deps.find((d) => d.name === name)?.section ?? 'dependencies'
+  } catch {
+    return 'dependencies'
+  }
+}
+
+/**
+ * 非 registry 来源的 lock 持久化收口（0.5.39 加法，用户点名的修 1）：
+ *   · `items`（**能由 importer 条目完整表达**的来源，目前只有 `link:`）→ **只写 lock importer 条目**
+ *     （lock-importer.js 是唯一实现；persist.js 走的 reconcile 通路就是这一条），清单形态与目标不等价时
+ *     先用既有 `setProfileDependency` 写规范形；写完跑**一次** pnpm **只读**校验确认 lock 仍可解析；
+ *   · `skipped`（file:/workspace:/portal:/git+/URL…）→ lock 记录不止 importer 一行（pnpm 还要写
+ *     packages/snapshots 的解析记录），本地无法确定 ⇒ **既不伪造条目、也不用 `pnpm add` 当持久化手段**，
+ *     由调用方如实报「未持久化」+ 一键钉住。
+ * 返回 `{ writes, verified, verifyNote, errors, manifestWrites, changed }`；`verified` 为 `true|false|null`
+ * （null = pnpm 执行方式不可用 ⇒ 无法确认）。
+ */
+async function settleImporterEntries({ profileDir, items = [], deps = {}, registries = [] } = {}) {
+  const setSpec = typeof deps.setSpec === 'function' ? deps.setSpec : defaultSetSpec
+  const writeImporter = typeof deps.writeImporter === 'function' ? deps.writeImporter : writeLockImporterEntry
+  const verify = typeof deps.verifyLock === 'function' ? deps.verifyLock : verifyLockReadOnly
+  const writes = []
+  const errors = []
+  const manifestWrites = []
+  for (const item of items) {
+    // ① 清单里必须有这个来源的声明：lock 条目不能单独存在（清单没有 = pnpm 会把它当多余条目清掉）
+    const before = profileSpec(profileDir, item.name)
+    if (typeof before !== 'string' || before.trim() === '') {
+      writes.push({ name: item.name, changed: false, skipped: true, reason: '清单 dependencies 里没有这个依赖的声明（lock 条目不能单独存在）—— 未写 lock，请先走「声明」通路' })
+      continue
+    }
+    // ② 形态与目标**不等价**才算真漂移 → 写**规范形**；等价（正/反斜杠、相对↔绝对同一目标）⇒ 零写盘
+    if (!sameSourceSpec(profileDir, before, item.spec)) {
+      try {
+        const wrote = await setSpec(profileDir, item.name, item.spec)
+        manifestWrites.push({ name: item.name, changed: wrote?.changed === true, before, after: wrote?.after ?? null })
+      } catch (error) {
+        const reason = `清单写回失败：${error instanceof Error ? error.message : String(error)}`
+        errors.push(reason)
+        writes.push({ name: item.name, changed: false, skipped: true, reason })
+        continue
+      }
+      const actual = profileSpec(profileDir, item.name)
+      if (!sameSourceSpec(profileDir, actual, item.spec)) {
+        const reason = `清单写回未生效（现在仍是 ${actual ?? '（没有这个条目）'}）—— 未写 lock`
+        errors.push(`${item.name}：${reason}`)
+        writes.push({ name: item.name, changed: false, skipped: true, reason })
+        continue
+      }
+    }
+    // ③ 定点写 lock importer 条目（读改写 + 读回核实都在 lock-importer.js 里）
+    let written = null
+    try {
+      written = await writeImporter(profileDir, { name: item.name, spec: item.spec, section: manifestSectionOf(profileDir, item.name), deps })
+    } catch (error) {
+      written = { changed: false, reason: `lock 写入失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+    if (written?.changed !== true && written?.unchanged !== true) errors.push(`${item.name}：${written?.reason ?? 'lock 写入未成功'}`)
+    writes.push({ name: item.name, ...written, reason: written?.reason ?? null })
+  }
+  let verified
+  let verifyNote = null
+  if (writes.some((w) => w.changed === true)) {
+    // 写出后**必须**用 pnpm 的只读用法确认 lock 仍可解析；失败或无法确认 ⇒ 调用方报「未持久化」
+    let verdict = null
+    try {
+      verdict = await verify({ profileDir, registry: registries?.[0] ?? null })
+    } catch (error) {
+      verdict = { verified: null, reason: `只读校验执行失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+    verified = verdict?.verified ?? null
+    verifyNote = verdict?.reason ?? null
+    if (verified !== true) errors.push(`pnpm 只读校验${verified === null ? '无法确认' : '未通过'}：${verifyNote ?? '原因未知'}`)
+  }
+  return { writes, manifestWrites, verified, verifyNote, errors, changed: writes.some((w) => w.changed === true) }
+}
+
 /**
  * 通用 lock 对账（**任何**安装通道装完都该调用，支持一次对账多个包）：
  * 走非 pnpm 通道（并行 curl / curl tarball / GitHub Release / git clone 装配 / 套装装配）装的包，
  * node_modules 里的版本与 `pnpm-lock.yaml` 记的版本可能不一致——之后任何 pnpm 操作（开关插件改
  * `dsh.profile.bundles`、`dsh plugin add/remove`）都可能按 lock 把它**还原**甚至当外来物处理。这里：
  *   ① 全部一致 → 直接返回（不跑 pnpm，零成本）；
- *   ② 有漂移 → **一次** `pnpm add <spec1> <spec2> …` 把所有漂移包精确写进 lock；
- *   ③ 仍对不上 → 返回 lockNote（逐包列出）与可复制命令，由调用方如实展示，绝不假装成功。
+ *   ② 有漂移 → registry 形态（版本号/dist-tag）：**一次** `pnpm add <spec1> <spec2> …` 把它们精确写进
+ *      lock（**行为一个字未改**）；非 registry 来源里的 `link:`：**只写 lock importer 条目**
+ *      （domain/lock-importer.js，唯一实现），再用 pnpm 的**只读**用法确认 lock 可解析 ——
+ *      `pnpm add` **不再**充当非 registry 来源的持久化手段；
+ *   ③ 仍对不上（含只读校验没通过/无法确认）→ 返回 lockNote（逐包列出）与可复制命令，由调用方如实展示，
+ *      绝不假装成功。
  * `packages` 形如 [{ name, version }]；只给 `packageName` 时等价于单包对账（向后兼容）。
  *
  * ★ 缺陷②修复（0.4.0-beta.16 / 0.3.63）：写回 spec 前必须确认来源，**绝不能把 release 来源的包
@@ -231,7 +331,7 @@ const DIST_TAG_RE = /^[A-Za-z][A-Za-z0-9._-]*$/u
  *       查无此包（404）→ 物化到 `<DSH_HOME>/plugin-src/<包名>` 并写 `link:<绝对路径>`，同时回 depNote；
  *       连物化都做不到 → **跳过对齐且不碰 package.json**，只记 note。
  */
-async function reconcileLockfile({ profileDir, packageName = null, packages = null, registries = [], pnpmAdd = pnpmInstall, execOpts = {}, fetchJson = fetchJsonUrl, home = null } = {}) {
+async function reconcileLockfile({ profileDir, packageName = null, packages = null, registries = [], pnpmAdd = pnpmInstall, execOpts = {}, fetchJson = fetchJsonUrl, home = null, deps = {} } = {}) {
   const targets = Array.isArray(packages)
     ? packages.filter((p) => p && typeof p.name === 'string' && p.name !== '')
     : (packageName === null ? [] : [{ name: packageName, version: null }])
@@ -265,8 +365,13 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
   const aligned = (r) => {
     if (r.installed === null) return false
     if (typeof r.spec === 'string' && r.spec.startsWith('link:')) {
+      // 0.5.39 改错（Fix 2）：lock 里那条 link 条目还必须**指向同一个目标**才算对齐。
+      // 旧判据只要求它以 `link:` 开头 ⇒ 「清单指 A、lock 指 B」被当成对齐（真实漂移：两处目标不同），
+      // 而 pnpm 下一次操作会按 lock 把链接还原到 B。等价判据与清单写入共用同一把尺子
+      // （dep-source.js#sameSourceSpec：正/反斜杠、相对↔绝对都算同一目标）。
       return linkSpecIsIntact(profileDir, r.name, r.spec)
         && typeof r.lock === 'string' && r.lock.trim().startsWith('link:')
+        && sameSourceSpec(profileDir, r.lock, r.spec)
     }
     return r.installed === r.lock || sourcePinned(r.lock)
   }
@@ -296,8 +401,11 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
       if (/^https?:/u.test(spec.trim()) || misrecorded(row)) {
         return linkPlan(row, '该包原先以 tarball URL 记录（pnpm 10 重写 lock 会丢 integrity，实测 ERR_PNPM_MISSING_TARBALL_INTEGRITY）')
       }
-      // link: 规格：链接可能已被 release/curl 通道的"先删再铺"打断 → 先把新副本刷进 plugin-src 再重放
+      // link: 规格：链接**还在**（node_modules 里就是指向清单那个目标的链接）→ 一个字节都不用物化，
+      // 按清单形态重放即可（0.5.39：等价即零漂移，别为了写一条 lock 去复制整棵包）；
+      // 链接已被 release/curl 通道的"先删再铺"打断 → 先把新副本刷进 plugin-src 再重放（既有能力，不变）
       if (spec.trim().startsWith('link:')) {
+        if (linkSpecIsIntact(profileDir, name, spec)) return { spec: spec.trim(), reason: null, note: null }
         const dir = materializePackageForLink(profileDir, name, home === null ? {} : { home })
         return { spec: dir === null ? spec.trim() : linkSpecFor(dir), reason: null, note: null }
       }
@@ -327,14 +435,29 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
   const errors = []
   let method = null
   const planned = []
+  let importerSettled = null
   if (drifted.length > 0) {
     // 只对"能读到实际版本"的包做对齐；读不到的（目录都没有）无法对账，留给 lockNote
-    const specs = []
+    const specs = []         // registry 形态（版本号 / dist-tag）→ **照旧**走既有 pnpm add 通道
+    const importerItems = [] // 非 registry 来源且**能由 importer 条目完整表达**（link:）→ 定点写 lock
+    const notWritable = []   // 其余非 registry 来源（file:/git+/URL/…）→ 本地不伪造、也不用 pnpm add
     for (const row of drifted) {
       if (row.installed === null) continue
       const plan = await planWriteback(row)
-      planned.push({ name: row.name, installed: row.installed, spec: plan.spec, reason: plan.reason ?? null, note: plan.note ?? null })
-      if (plan.spec !== null) specs.push(plan.spec)
+      const item = { name: row.name, installed: row.installed, spec: plan.spec, reason: plan.reason ?? null, note: plan.note ?? null }
+      if (plan.spec !== null && canWriteImporterEntry(plan.spec)) {
+        item.channel = 'importer'
+        importerItems.push(item)
+      } else if (plan.spec !== null && SOURCE_PINNED_RE.test(plan.spec.trim())) {
+        // 修 1（0.5.39）：非 registry 来源**绝不**再用 `pnpm add` 当持久化手段；本地又无法确定它的
+        // lock 记录（上面 IMPORTER_ONLY_RE 的注释说了为什么）⇒ 一个字节都不写，交给下面的文案如实报。
+        item.channel = 'importer-skipped'
+        notWritable.push(item)
+      } else {
+        item.channel = 'pnpm'
+        if (plan.spec !== null) specs.push(plan.spec)
+      }
+      planned.push(item)
     }
     if (specs.length > 0) {
       try {
@@ -344,18 +467,43 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
         errors.push(`pnpm add 对齐失败：${error instanceof Error ? error.message : String(error)}`)
       }
     }
+    if (importerItems.length > 0) {
+      importerSettled = await settleImporterEntries({ profileDir, items: importerItems, deps, registries })
+      errors.push(...importerSettled.errors)
+      if (importerSettled.changed === true) method = method === null ? 'lock-importer' : `${method}+lock-importer`
+    }
     rows = snap()
     drifted = driftedOf(rows)
   }
   // ★ 文案一律按**实际写入形态**生成（读回清单再描述）——"计划写 link:"与"清单里真是 link:"
   //   是两件事：pnpm add 失败、或后续某一步又把 spec 覆盖成版本号时，绝不能报"已钉住"。
   const suggestedActions = []
+  const writeOf = new Map((importerSettled?.writes ?? []).map((w) => [w.name, w]))
   for (const item of planned) {
     const actual = profileSpec(profileDir, item.name)
     if (item.spec === null) {
       if (item.note !== null) depNotes.push(item.note)
       continue
     }
+    if (item.channel === 'importer') {
+      const wrote = writeOf.get(item.name) ?? null
+      if (wrote !== null && (wrote.changed === true || wrote.unchanged === true)) {
+        if (item.reason !== null) {
+          depNotes.push(`${item.name}：${item.reason}，已按 link: 形式记录依赖（${actual}）—— lock 的 importer 条目已**定点写入**（${wrote.version ?? ''}），不经 npm registry 解析、不经 tarball 完整性校验`)
+        }
+        continue
+      }
+      const why = `${item.name}：${item.reason !== null ? `${item.reason}；` : ''}${wrote?.reason ?? 'lock importer 条目未能写入'}（清单现在是 ${actual ?? '（没有这个条目）'}）—— lock 条目**未写入**`
+      depNotes.push(`${why}。请执行「钉住」动作或手动执行：${command(item.name, item.installed)}`)
+      suggestedActions.push(suggestedPinAction({ packageName: item.name, version: item.installed, profileDir, reason: why }))
+      continue
+    }
+    if (item.channel === 'importer-skipped') {
+      const why = `${item.name}：来源是 ${item.spec}（非 registry）—— lock 里的记录不止 importer 一行（pnpm 还要写 packages/snapshots 的解析记录），本地无法确定 ⇒ **未写入 lock**，也没用 pnpm add 顶替`
+      depNotes.push(`${why}。要钉住请执行「钉住」动作或手动执行：${command(item.name, item.installed)}`)
+      suggestedActions.push(suggestedPinAction({ packageName: item.name, version: item.installed, profileDir, reason: why }))
+      continue
+    }
     if (actual === item.spec) {
       if (item.spec.startsWith('link:') && item.reason !== null) {
         depNotes.push(`${item.name}：${item.reason}，已按 link: 形式记录依赖（${actual}）—— 不经 npm registry 解析、不经 tarball 完整性校验，pnpm 重建 lock 也能装上`)
@@ -366,7 +514,39 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
     depNotes.push(`${why}。请执行「钉住」动作或手动执行：${command(item.name, item.installed)}`)
     suggestedActions.push(suggestedPinAction({ packageName: item.name, version: item.installed, profileDir, reason: why }))
   }
-  const lockUpdated = drifted.length === 0
+  // 只读校验没通过/无法确认 ⇒ **不算已持久化**（修 1 的硬要求：不许报成功），把缺口与出路如实写进 lockNote
+  const lockVerified = importerSettled === null ? undefined : importerSettled.verified
+  const verifyBlocked = lockVerified === false || lockVerified === null
+  const verifyNames = (importerSettled?.writes ?? []).filter((w) => w.changed === true).map((w) => w.name)
+  const verifyNote = verifyBlocked
+    ? `${verifyNames.join('、')} 的 lock importer 条目已按来源写入，但 pnpm 的**只读**校验${lockVerified === null ? '无法确认' : '未通过'}（${importerSettled?.verifyNote ?? '原因未知'}）—— 按**未持久化**处理，绝不报成功`
+    : null
+  if (verifyBlocked && verifyNames.length > 0 && !suggestedActions.some((a) => a?.payload?.packageName === verifyNames[0])) {
+    const target = planned.find((p) => p.name === verifyNames[0]) ?? { name: verifyNames[0], installed: readInstalledVersion(profileDir, verifyNames[0]) }
+    suggestedActions.push(suggestedPinAction({ packageName: target.name, version: target.installed ?? null, profileDir, reason: verifyNote }))
+  }
+  // 只写 lock 成功、但 node_modules 里的链接还没就位（release/curl/URL 通道「先删再铺」把链接换成了真实目录）：
+  // 这条**不是**"没写进 lock"，文案必须分开说；同时要给「缺口明细 + 一键钉住」。
+  const writtenNames = new Set((importerSettled?.writes ?? []).filter((w) => w.changed === true || w.unchanged === true).map((w) => w.name))
+  const linkPending = drifted.filter((r) => writtenNames.has(r.name) && typeof r.lock === 'string' && r.lock.trim().startsWith('link:'))
+  for (const row of linkPending) {
+    if (suggestedActions.some((a) => a?.payload?.packageName === row.name)) continue
+    const reason = `${row.name}：lock 条目已按来源写入（${row.lock}），但 node_modules 里的链接尚未就位 —— 点「钉住」可立即用 pnpm 把链接建起来（否则要等下一次 pnpm 操作）`
+    depNotes.push(reason)
+    suggestedActions.push(suggestedPinAction({ packageName: row.name, version: row.installed, profileDir, reason }))
+  }
+  const lockUpdated = drifted.length === 0 && !verifyBlocked
+  const notWritten = drifted.filter((r) => !linkPending.includes(r))
+  const driftedText = drifted.length === 0
+    ? null
+    : [
+      linkPending.length > 0
+        ? `${linkPending.map((r) => `${r.name}：lock 条目已按来源写入（${r.lock}），但 node_modules 里的链接尚未就位 —— 下一次 pnpm 操作会按这条 lock 重建链接`).join('；')}`
+        : null,
+      notWritten.length > 0
+        ? `${notWritten.length} 个包没写进 pnpm-lock.yaml（${notWritten.map((r) => `${r.name}：装了 ${r.installed ?? '未知'}／lock 里是 ${r.lock ?? '未记录'}`).join('；')}）：之后任何 pnpm 操作（开关插件、dsh plugin add/remove）都可能把它们还原。要钉住请执行：${command(notWritten[0].name, notWritten[0].installed)}`
+        : null,
+    ].filter((x) => x !== null).join('；')
   return {
     method,
     packages: rows.map((r) => ({ name: r.name, installedVersion: r.installed, lockVersion: r.lock, spec: r.spec, aligned: r.installed !== null && (r.installed === r.lock || sourcePinned(r.lock)) })),
@@ -374,9 +554,19 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
     installedVersion: rows.length === 1 ? rows[0].installed : null,
     lockVersion: rows.length === 1 ? rows[0].lock : null,
     lockUpdated,
+    // 只读校验的结论如实下发（true=确认可解析 / false=未通过 / null=无法确认；没写过条目时是 undefined）
+    lockVerified,
+    lockVerifyNote: importerSettled?.verifyNote ?? null,
+    lockImporterWrites: (importerSettled?.writes ?? []).map((w) => ({ name: w.name, changed: w.changed === true, version: w.version ?? null, reason: w.reason ?? null })),
     lockNote: lockUpdated
       ? null
-      : `${drifted.length} 个包没写进 pnpm-lock.yaml（${drifted.map((r) => `${r.name}：装了 ${r.installed ?? '未知'}／lock 里是 ${r.lock ?? '未记录'}`).join('；')}）：之后任何 pnpm 操作（开关插件、dsh plugin add/remove）都可能把它们还原。要钉住请执行：${command(drifted[0].name, drifted[0].installed)}`,
+      : [
+        verifyNote,
+        // 定点写入失败的逐条原因也要进 lockNote（缺口明细：面板只看 lockNote 时也说得清）
+        (importerSettled?.writes ?? []).filter((w) => w.changed !== true && w.unchanged !== true && typeof w.reason === 'string' && w.reason !== '')
+          .map((w) => `${w.name}：${w.reason}`).join('；') || null,
+        drifted.length === 0 ? null : `${driftedText}`,
+      ].filter((x) => x !== null).join('；'),
     // 非常规来源（link:）写回时的**用户可见**说明：绝不静默（缺陷②的隐蔽性正是"装完看不出问题"）。
     // 文案由上面的"读回真实值"步骤产出，因此永远不会出现"面板说已钉住、磁盘上仍是版本号"。
     depNote: depNotes.length > 0 ? depNotes.join('；') : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.38",
+  "version": "0.5.39",
   "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",