@noob-stupid/dsh-plugin-console 0.3.60 → 0.3.63

package/lib/index.js

@@ -2966,6 +2966,116 @@ async function backfillMissingDeps(profileDir, deps, registries) {
   return stillMissing
 }
 
+// ── 依赖来源写回（缺陷②修复：0.3.63）────────────────────────────────────────────
+// 缺陷背景（用户 issue 草案「缺陷②」，2026-09-22 实测）：release 通道装的包只存在于 GitHub
+// release，npm registry 里查无此包；而 0.3.57 起的 lock 对账一律 `pnpm add <name>@<installed>` ——
+// pnpm 看到「已装版本满足新 spec」就**静默**把 profile package.json 的 dependencies 改写为裸版本号
+// （输出 `Already up to date`、EXIT=0，面板显示成功），同时把 lock 的 specifier 也改成版本号、
+// 却保留旧的 tarball 解析。装完一切正常，直到有人重建 lock（删 lock / 清 node_modules / 换机 / CI）
+// → `ERR_PNPM_FETCH_404`，而报错指向 npm registry，用户根本联想不到是几周前面板安装改写造成的。
+//
+// 两条硬约束（本机真 pnpm 10.34.5 实测矩阵见 D:\dsh\dsh-plugin-hub-plan\refactor-bugs.zh.md 第 23 节）：
+//   ① 写回前必须确认「这个包的**这个版本**」在 registry 可解析，否则**绝不**写裸版本号；
+//   ② 不可解析时**也不能**写 tarball URL：pnpm 10 对 direct-URL 依赖只在冷缓存真下载时记 integrity，
+//      命中缓存重写 lock 时 resolution 里没有 integrity → `ERR_PNPM_MISSING_TARBALL_INTEGRITY`，
+//      而且 pnpm 会把 lock 文件直接删掉，形成「删 lock 修不好、不删 lock 装不动」的死循环。
+//      改用 `link:<DSH_HOME>/plugin-src/<包名>`：pnpm 的 link 协议只建符号链接，不经 registry 解析、
+//      不经 tarball 完整性校验，lock 删掉重建、node_modules 清空重装都稳定通过。
+
+/** 物化目录的根（与用户 issue 里手工规避用的 `/root/.dsh/plugin-src/...` 同一位置）。 */
+const PLUGIN_SRC_DIR = 'plugin-src'
+
+/**
+ * registry 能否解析该包的指定版本（按顺序多源尝试，任一源可解析即通过）。
+ * 404 / 网络失败都归为「不可解析」——调用方据此决定**绝不写裸版本号**。
+ * `version` 为 null 时只判包是否存在；`hasVersion` 表示指定版本是否在 versions 里
+ * （release 通道装的版本可能比 registry 上的 latest 还新，只判包名存在是不够的）。
+ */
+async function probeRegistryPackage(packageName, registries = [], options = {}) {
+  const fetchJson = typeof options.fetchJson === 'function' ? options.fetchJson : fetchJsonUrl
+  const version = typeof options.version === 'string' && options.version !== '' ? options.version : null
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 8000
+  const list = (Array.isArray(registries) ? registries : []).filter((r) => typeof r === 'string' && r.trim() !== '')
+  const tries = list.length > 0 ? list : ['https://registry.npmmirror.com']
+  const encoded = packageName.startsWith('@')
+    ? `@${encodeURIComponent(packageName.slice(1).split('/')[0])}%2f${encodeURIComponent(packageName.split('/').slice(1).join('/'))}`
+    : encodeURIComponent(packageName)
+  const tried = []
+  for (const reg of tries) {
+    const base = String(reg).replace(/\/+$/u, '')
+    try {
+      const meta = await fetchJson(`${base}/${encoded}`, timeoutMs)
+      const versions = meta && typeof meta === 'object' && meta.versions && typeof meta.versions === 'object' ? meta.versions : null
+      if (versions === null) {
+        tried.push(`${base}：返回体没有 versions 字段`)
+        continue
+      }
+      const latest = typeof meta['dist-tags']?.latest === 'string' ? meta['dist-tags'].latest : null
+      return {
+        resolvable: true,
+        hasVersion: version === null || Object.prototype.hasOwnProperty.call(versions, version),
+        latest,
+        registry: base,
+        tried,
+      }
+    } catch (error) {
+      tried.push(`${base}：${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+  return { resolvable: false, hasVersion: false, latest: null, registry: null, tried }
+}
+
+/**
+ * 把 profile 里**已装好的**包物化一份到 `<DSH_HOME>/plugin-src/<包名>`，返回该绝对路径。
+ * 为什么必须另存一份而不是直接 link node_modules 里的目录：pnpm 重建 node_modules 时会先删掉
+ * 整个目录，link 目标随即消失；plugin-src 是 pnpm 不管理的独立目录，跨 lock 重建、
+ * 跨 node_modules 清空都稳定存在（这也是用户手工规避时选的位置）。
+ * 返回 null 表示源目录不存在或复制失败 —— 调用方必须**跳过对齐**并如实记 note，绝不改 package.json。
+ */
+function materializePackageForLink(profileDir, packageName, options = {}) {
+  const home = typeof options.home === 'string' && options.home !== '' ? options.home : dshHome()
+  const src = join(profileDir, 'node_modules', ...packageName.split('/'))
+  if (!existsSync(join(src, 'package.json'))) return null
+  const dest = join(home, PLUGIN_SRC_DIR, ...packageName.split('/'))
+  // 已经是指向 plugin-src 的链接（重复对账）→ 不能先删再复制：那样源就成了悬空链接
+  try {
+    if (existsSync(dest) && realpathSync(src) === realpathSync(dest)) return dest
+  } catch {}
+  try {
+    mkdirSync(dirname(dest), { recursive: true })
+    if (existsSync(dest)) rmSync(dest, { recursive: true, force: true })
+    copyTree(src, dest)
+  } catch {
+    return null
+  }
+  return existsSync(join(dest, 'package.json')) ? dest : null
+}
+
+/** pnpm 的 `link:` 规格：写绝对路径（反斜杠转正斜杠，跨平台且 lock 可读）。 */
+function linkSpecFor(dir) {
+  return `link:${String(dir).replace(/\\/gu, '/')}`
+}
+
+/**
+ * manifest 里的 `link:` 规格当前是否**真的**还生效（`node_modules/<包名>` 就是指向它的那个链接）。
+ * 为什么必须查：release / curl 通道更新包时是「先 rmSync 再 copyTree」，会把 `node_modules/<包名>`
+ * 从"链接"换成"真实目录"，而 manifest 与 lock 里仍写着 `link:<plugin-src/…>` —— 光看版本号看不出来
+ * （lock 里本来就是 `link:`），但**之后任何一次 pnpm 操作都会按 lock 重建链接**，把刚更新上去的版本
+ * 还原成 `plugin-src` 里的旧副本（与 0.3.56 修过的「自更新被 lock 还原」同族）。
+ * 返回 false 时调用方会重新物化（把新副本刷进 plugin-src）并重放 `link:`，实测能把链接与版本一起恢复。
+ */
+function linkSpecIsIntact(profileDir, packageName, spec) {
+  if (typeof spec !== 'string' || !spec.startsWith('link:')) return false
+  const target = spec.slice('link:'.length)
+  const src = join(profileDir, 'node_modules', ...packageName.split('/'))
+  try {
+    if (!existsSync(src) || !existsSync(target)) return false
+    return realpathSync(src) === realpathSync(target)
+  } catch {
+    return false
+  }
+}
+
 // ── GitHub Release 源解析（issue #3：按包名反查发布仓库 → 遍历 release 的 assets → 按包名挑产物）──
 //
 // 背景（用户 issue，附逐条实测）：安装 yjh051108/dsh-routing-suite（根包 @dsh-external/dsh-super-injector，
@@ -3693,10 +3803,11 @@ function installJobView(job) {
     subpackages: job.subpackages ?? null,
     source: job.source ?? 'github',
     curlNote: job.curlNote ?? null,
-    bundleNote: job.bundleNote ?? null,
-    lockUpdated: job.lockUpdated ?? null,
-    lockVersion: job.lockVersion ?? null,
+    bundleNote: job.bundleNote ?? null,
+    lockUpdated: job.lockUpdated ?? null,
+    lockVersion: job.lockVersion ?? null,
     lockNote: job.lockNote ?? null,
+    depNote: job.depNote ?? null, // 依赖来源写回说明（缺陷②：release 专属包按 link: 记录时给出可见解释，绝不静默）
     compatNote: job.compatNote ?? null,
     kind: job.kind ?? 'plugin',
     skillName: job.skillName ?? null,
@@ -4121,9 +4232,9 @@ export async function runSuiteInstallJob(job, ctx) {
         copyTree(subDir, target)
         const taken = new Set(listEntries(ctx).map((e) => e.rowId))
         const entryId = deriveEntryId(pkg.name, taken)
-        await appendInsert(patchPath, entryId, pkg.name)
-        // 记下套装装配出的包名：它们是 copyTree 铺进去的、不在 pnpm-lock.yaml 里，交给调用方统一对账
-        if (!Array.isArray(job.suiteInstalled)) job.suiteInstalled = []
+        await appendInsert(patchPath, entryId, pkg.name)
+        // 记下套装装配出的包名：它们是 copyTree 铺进去的、不在 pnpm-lock.yaml 里，交给调用方统一对账
+        if (!Array.isArray(job.suiteInstalled)) job.suiteInstalled = []
         if (!job.suiteInstalled.includes(pkg.name)) job.suiteInstalled.push(pkg.name)
         report.push({ component: sub.name, type: 'plugin', ok: true, note: `已安装 ${pkg.name}（HMR 生效）` })
         handled = true
@@ -5673,16 +5784,25 @@ function frameworkCheckPromptText(fc) {
  * 只给前 N 个候选扫 release；排在后面的候选仍照走 curl/并行竞速（按包名施工，代价小）。 */
 const RELEASE_CHANNEL_BUDGET = 3
 
-/** 安装通道实现集合（默认真实实现；ctx.installChannels 可覆盖）。
+/** 安装通道实现集合（默认真实实现；`ctx.get('installChannels')` 可覆盖 —— 只走可选读取，不走属性访问）。
  * 为什么留这个缝：通道守卫（哪些通道在懒惰展开之后仍应被尝试）正是 issue #3 的核心语义，
  * 用真实通道无法离线断言"谁被调用了"——单测注入桩函数即可把语义钉死（见 test-suite-detect.mjs ⑪）。
- * 也给离线 e2e（test-suite-install.mjs）用：那条用例不该为了验证通道派发去真装一个包。 */
-function channelImpls(ports) {
+ * 也给离线 e2e（test-suite-install.mjs）用：那条用例不该为了验证通道派发去真装一个包。
+ * 注：注入桩在测试里必须以「provide 但未 inject」的方式喂进来（见 strict-ctx.mjs 的严格替身），
+ * 否则替身与 cordis 语义不一致，这类缺陷还会再溜过去一次。导出只为单测能直接断言这个缝。 */
+export function channelImpls(ports) {
   const real = { pnpmInstall, curlManualInstall, raceInstallChannels, githubReleaseInstall, backfillMissingDeps }
-  // 测试注入缝：ports 在生产路径上可能是 cordis 的 ctx 代理，直接访问未 inject 的属性会**同步抛错**
-// （cannot get property ... without inject），导致每一次安装都失败 → 必须兜住。
-let override = null
-try { override = ports?.installChannels ?? null } catch { override = null }
+  // 测试注入缝（2026-09-22 事故的修法，**别改回属性访问**）：
+  //   生产路径上 ports 就是 cordis 的 ctx 代理，属性式读取未 inject 的名字会**同步抛**
+  //   `cannot get property "installChannels" without inject` —— 0.3.59 因此每一次安装都在这里失败。
+  //   正规写法是 ctx.get('installChannels')（Cordis 的可选读取，未声明也不抛，与本文件其它
+  //   ctx.get('subagents') / ctx.get('agents') / ctx.get('skills') 一致）；普通对象（测试替身/窄接口）
+  //   才回退属性访问。try/catch 保留 0.3.60/0.3.61 的兜底语义：万一还有别的 ctx 形状，
+  //   宁可回落真实实现也不要炸掉安装。
+  let override = null
+  try {
+    override = typeof ports?.get === 'function' ? (ports.get('installChannels') ?? null) : (ports?.installChannels ?? null)
+  } catch { override = null }
   return override !== null && typeof override === 'object' ? { ...real, ...override } : real
 }
 
@@ -5833,17 +5953,18 @@ async function runInstallJob(job, ctx) {
       if (resolveInstallKind(job.kind, await probeGitmodules(job.repo)) === 'suite') {
         job.kind = 'suite'
         const suiteResult = await runSuiteInstallJob(job, ctx)
-    // 套装装配出的普通插件同样对账，避免之后被 pnpm 还原/清理
-    if (Array.isArray(job.suiteInstalled) && job.suiteInstalled.length > 0) {
-      try {
-        const lock = await reconcileLockfile({ profileDir, packages: job.suiteInstalled.map((name) => ({ name })), registries })
-        job.lockUpdated = lock.lockUpdated
-        job.lockVersion = lock.lockVersion
-        job.lockMethod = lock.method
-        job.lockPackages = lock.packages
-        if (lock.lockNote !== null) job.lockNote = lock.lockNote
-      } catch {}
-    }
+    // 套装装配出的普通插件同样对账，避免之后被 pnpm 还原/清理
+    if (Array.isArray(job.suiteInstalled) && job.suiteInstalled.length > 0) {
+      try {
+        const lock = await reconcileLockfile({ profileDir, packages: job.suiteInstalled.map((name) => ({ name })), registries })
+        job.lockUpdated = lock.lockUpdated
+        job.lockVersion = lock.lockVersion
+        job.lockMethod = lock.method
+        job.lockPackages = lock.packages
+        if (lock.lockNote !== null) job.lockNote = lock.lockNote
+        if (lock.depNote !== null) job.depNote = lock.depNote
+      } catch {}
+    }
         // clone 后才发现没有 .gitmodules（探测假阳性 / 仓库已重构）→ 回落普通安装，不给用户一个失败
         if (suiteResult?.notASuite !== true) return
         job.kind = 'plugin'
@@ -6037,20 +6158,22 @@ async function runInstallJob(job, ctx) {
       const adapt = await maybeAutoAdaptCompat({ profileDir, packageName: installedName, syncedNames, patchPath, ctx })
       if (adapt !== null && adapt.ran === true) job.compatNote = adapt.note
     } catch {}
-    // lock 对账（2026-09-21，用户报告的自更新缺陷同源）：主包 + 本次被补装/对齐的聚合子包一起核对，
-    // 一次 pnpm add 把漂移的包全写进 lock；对不上就留 lockNote，让面板如实告知（不假装成功）。
-    try {
-      const lock = await reconcileLockfile({
-        profileDir,
-        packages: [installedName, ...syncedNames].map((name) => ({ name })),
-        registries,
-      })
-      job.lockUpdated = lock.lockUpdated
-      job.lockVersion = lock.lockVersion
-      job.lockMethod = lock.method
-      job.lockPackages = lock.packages
-      if (lock.lockNote !== null) job.lockNote = lock.lockNote
-    } catch {}
+    // lock 对账（2026-09-21，用户报告的自更新缺陷同源）：主包 + 本次被补装/对齐的聚合子包一起核对，
+    // 一次 pnpm add 把漂移的包全写进 lock；对不上就留 lockNote，让面板如实告知（不假装成功）。
+    try {
+      const lock = await reconcileLockfile({
+        profileDir,
+        packages: [installedName, ...syncedNames].map((name) => ({ name })),
+        registries,
+      })
+      job.lockUpdated = lock.lockUpdated
+      job.lockVersion = lock.lockVersion
+      job.lockMethod = lock.method
+      job.lockPackages = lock.packages
+      if (lock.lockNote !== null) job.lockNote = lock.lockNote
+      // 非常规来源（link:）写回说明：必须让用户看见（缺陷②最阴的地方就是"装完完全看不出问题"）
+      if (lock.depNote !== null) job.depNote = lock.depNote
+    } catch {}
     job.stage = 'configuring'
     // 2026-09-06 事故（i18n 更新变重复行）：@linxin666/dsh-i18n 声明了 dsh.bundle.patch，
     // 更新流程按「bundle 安装规则」把它追加进 bundles → 与全家桶内的 web-ui-i18n 行（同包）重复。
@@ -6168,7 +6291,13 @@ export function readInstalledVersion(profileDir, name) {
 
 /** 从 pnpm-lock.yaml 读出该包被**钉住**的版本。解析只认两种确定性位置，避免子串误命中：
  * ① importers 段里恰为 `'<name>':` 的行，随后几行内的 `version: X`；② packages 段 `<name>@<版本>:` 的键名。
- * 读不到返回 null（调用方据此判定"没能核实"，绝不谎报成功）。 */
+ * 读不到返回 null（调用方据此判定"没能核实"，绝不谎报成功）。
+ *
+ * ★ 2026-09-22 修复（缺陷②连带）：旧版 ① 在遇到 `specifier: …` 行时**直接 break**，而 importers 段
+ *   恒为 `specifier:` 在前、`version:` 在后 → ① 从来没生效过，全靠 ② 兜底；而 ② 的正则用 `[^':\s]+`
+ *   取值，遇到 `name@https://…tgz` / `link:…` 会在第一个冒号处截断（读出 `http`）或读不到（link 依赖
+ *   在 lock 里没有 packages 条目 → 返回 null）。后果：来源钉住的包永远被判为「漂移」→ 每次安装都白跑
+ *   一次 pnpm add，并给用户一条假的「没写进 lock」警告。现在 ① 跳过 specifier 行、② 取到行尾。 */
 export function lockVersionOf(profileDir, name) {
   const file = join(profileDir, 'pnpm-lock.yaml')
   if (!existsSync(file)) return null
@@ -6180,14 +6309,16 @@ export function lockVersionOf(profileDir, name) {
   }
   for (let i = 0; i < lines.length; i += 1) {
     if (lines[i].trim() !== `'${name}':`) continue
-    for (let k = i + 1; k < Math.min(i + 5, lines.length); k += 1) {
+    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]
-      if (/^\s*\S+:/u.test(lines[k]) && !/^\s*version:/u.test(lines[k])) break
+      // 只在新包的键行（`'<name>':` 形态）处停止；`specifier: X` 有值，不是键行，必须继续往下看
+      if (/^\s*'?[^\s:]+'?:\s*$/u.test(lines[k])) break
     }
   }
   const escaped = name.replace(/[/\\^$*+?.()|[\]{}]/gu, '\\$&')
-  const keyRe = new RegExp(`^\\s*'?${escaped}@([^':\\s]+)'?:`, 'u')
+  // 取到行尾再剥尾部的引号/冒号：`'name@https://…tgz':` / `name@git+https://…#sha:` / `name@1.2.3:`
+  const keyRe = new RegExp(`^\\s*'?${escaped}@(.+?)'?:\\s*$`, 'u')
   for (const line of lines) {
     const m = keyRe.exec(line)
     if (m) return m[1]
@@ -6253,63 +6384,166 @@ export async function selfUpdateToLatest({ profileDir, latest, registries, curlM
   return { method, spec, installedVersion: installed, lockVersion: lock, lockUpdated, lockNote, command, note: noteParts.join('；'), errors }
 }
 
-
-/**
- * 通用 lock 对账（**任何**安装通道装完都该调用，支持一次对账多个包）。
- * 走非 pnpm 通道（并行 curl / curl tarball / GitHub Release / git 装配 / 套装 copyTree / 聚合子包补装）装的包，
- * node_modules 里的版本与 `pnpm-lock.yaml` 记的版本可能不一致——之后任何 pnpm 操作（开关插件改
- * `dsh.profile.bundles`、`dsh plugin add/remove`）都可能按 lock 把它还原或当外来物处理。这里：
- *   ① 全部一致 → 直接返回（不跑 pnpm，零成本）；
- *   ② 有漂移 → **一次** `pnpm add <pkg1>@<v1> <pkg2>@<v2> …` 把漂移包精确写进 lock；
- *   ③ 仍对不上 → 返回 lockNote（逐包列出）+ 可复制命令，由调用方如实展示，绝不假装成功。
- */
-export async function reconcileLockfile({ profileDir, packageName = null, packages = null, registries = [], pnpmAdd = pnpmInstall, execOpts = {} }) {
-  const targets = Array.isArray(packages)
-    ? packages.filter((p) => p && typeof p.name === 'string' && p.name !== '')
-    : (packageName === null ? [] : [{ name: packageName, version: null }])
-  const unique = []
-  for (const t of targets) if (!unique.some((u) => u.name === t.name)) unique.push(t)
-  const command = (name, version) => `dsh plugin --profile <你的profile> add ${name}@${version ?? '<版本>'}`
-  const snap = () => unique.map((t) => ({
-    name: t.name,
-    spec: profileSpecOf(profileDir, t.name),
-    installed: readInstalledVersion(profileDir, t.name),
-    lock: lockVersionOf(profileDir, t.name),
-  }))
-  const drift = (rows) => rows.filter((r) => r.installed === null || r.installed !== r.lock)
-  let rows = snap()
-  let drifted = drift(rows)
-  const errors = []
-  let method = null
-  if (drifted.length > 0) {
-    const specs = drifted.filter((r) => r.installed !== null).map((r) => `${r.name}@${r.installed}`)
-    if (specs.length > 0) {
-      try {
-        await pnpmAdd(profileDir, specs.length === 1 ? specs[0] : specs, registries?.[0])
-        method = 'pnpm-add'
-      } catch (error) {
-        errors.push(`pnpm add 对齐失败：${error instanceof Error ? error.message : String(error)}`)
-      }
-    }
-    rows = snap()
-    drifted = drift(rows)
-  }
-  const lockUpdated = drifted.length === 0
-  return {
-    method,
-    packages: rows.map((r) => ({ name: r.name, installedVersion: r.installed, lockVersion: r.lock, aligned: r.installed !== null && r.installed === r.lock })),
-    spec: rows.length === 1 ? rows[0].spec : null,
-    installedVersion: rows.length === 1 ? rows[0].installed : null,
-    lockVersion: rows.length === 1 ? rows[0].lock : null,
-    lockUpdated,
-    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)}`,
-    command: drifted.length > 0 ? command(drifted[0].name, drifted[0].installed) : command(rows[0]?.name ?? '', rows[0]?.installed ?? null),
-    errors,
-  }
-}
-
+
+/**
+ * 依赖**来源规格**的协议前缀：manifest 里出现这些，说明来源不是 npm registry（link:/file:/URL/git/别名）。
+ * 这类 spec 必须原样保留，**绝不能**换成版本号（换成 `<name>@<版本>` 就等于把来源丢掉 —— 缺陷②）。
+ */
+const SOURCE_SPEC_RE = /^(link:|file:|https?:|git\+|git:|github:|gitlab:|bitbucket:|workspace:|portal:|npm:|jsr:)/u
+
+/**
+ * lock 里被**来源**（而不是版本号）钉住的解析：`link:../x`、`https://…tgz`、`git+https://…#sha`。
+ * 这类解析的 `version` 字段不是语义化版本，不能拿它跟已装版本做相等比较（见下面 aligned）。
+ */
+const SOURCE_PINNED_RE = SOURCE_SPEC_RE
+
+/** 裸精确版本号（面板写回留下的形态）：`0.3.3`。`^0.3.3` / `~0.3.3` / `>=1` 是用户手写的范围。 */
+const EXACT_VERSION_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u
+
+/**
+ * dist-tag 形式的 spec（`latest` / `next` / `beta`）：也是 registry 来源，但要**保留标签**而不是钉成版本号。
+ * 判据：不含版本号或协议前缀的裸标识符。注意不能把它当成"非 registry 来源"原样丢给 pnpm ——
+ * `pnpm add latest` 会去装一个**名叫 latest 的包**，那是灾难性的误装。
+ */
+const DIST_TAG_RE = /^[A-Za-z][A-Za-z0-9._-]*$/u
+
+/**
+ * 通用 lock 对账（**任何**安装通道装完都该调用，支持一次对账多个包）。
+ * 走非 pnpm 通道（并行 curl / curl tarball / GitHub Release / git 装配 / 套装 copyTree / 聚合子包补装）装的包，
+ * node_modules 里的版本与 `pnpm-lock.yaml` 记的版本可能不一致——之后任何 pnpm 操作（开关插件改
+ * `dsh.profile.bundles`、`dsh plugin add/remove`）都可能按 lock 把它还原或当外来物处理。这里：
+ *   ① 全部一致 → 直接返回（不跑 pnpm，零成本）；
+ *   ② 有漂移 → **一次** `pnpm add <spec1> <spec2> …` 把所有漂移包精确写进 lock；
+ *   ③ 仍对不上 → 返回 lockNote（逐包列出）+ 可复制命令，由调用方如实展示，绝不假装成功。
+ *
+ * ★ 缺陷②修复（0.3.63）：写回 spec 前必须确认来源，**绝不能把 release 来源的包写成裸版本号**——
+ *   0.3.57 起的旧实现一律 `pnpm add <name>@<installed>`，对 npm 上不存在的包会被 pnpm 静默改写成
+ *   `<name>: "<版本>"`（EXIT=0，装完看不出问题），lock 一重建就 ERR_PNPM_FETCH_404。现在的规则：
+ *     · manifest 已是真实来源（link: / git+ / file:）→ 原样重放，不降级成版本号；
+ *     · 已是 tarball URL（或在 lock 里被 URL 钉住）→ 转成 link: 形式
+ *       （pnpm 10 对 direct-URL 依赖重写 lock 会丢 integrity，实测 ERR_PNPM_MISSING_TARBALL_INTEGRITY）；
+ *     · 版本号 / 没有条目 → **先探 registry**：这个包的**这个版本**可解析才写 `<name>@<版本>`；
+ *       查无此包（404）→ 物化到 `<DSH_HOME>/plugin-src/<包名>` 并写 `link:<绝对路径>`，同时回 depNote；
+ *       连物化都做不到 → **跳过对齐且不碰 package.json**，只记 note。
+ */
+export async function reconcileLockfile({ profileDir, packageName = null, packages = null, registries = [], pnpmAdd = pnpmInstall, execOpts = {}, fetchJson = fetchJsonUrl, home = null } = {}) {
+  const targets = Array.isArray(packages)
+    ? packages.filter((p) => p && typeof p.name === 'string' && p.name !== '')
+    : (packageName === null ? [] : [{ name: packageName, version: null }])
+  const unique = []
+  for (const t of targets) if (!unique.some((u) => u.name === t.name)) unique.push(t)
+  const command = (name, version) => `dsh plugin --profile <你的profile> add ${name}@${version ?? '<版本>'}`
+
+  const snap = () => unique.map((t) => ({
+    name: t.name,
+    spec: profileSpecOf(profileDir, t.name),
+    installed: readInstalledVersion(profileDir, t.name),
+    lock: lockVersionOf(profileDir, t.name),
+  }))
+  const sourcePinned = (v) => typeof v === 'string' && SOURCE_PINNED_RE.test(v.trim())
+  const urlPinned = (v) => typeof v === 'string' && /^https?:/u.test(v.trim())
+  /** 缺陷②指纹：manifest 声明裸版本号、lock 却把该包解析到一个 URL —— pnpm 静默改写留下的状态。 */
+  const misrecorded = (r) => typeof r.spec === 'string' && EXACT_VERSION_RE.test(r.spec.trim()) && urlPinned(r.lock)
+  /** manifest 里仍是 tarball URL：虽然 lock 能解析，但 pnpm 10 重写 lock 会丢 integrity（实测），
+   *  必须**主动**规整成 link: 形式 —— 否则「删 lock / 清 node_modules / 换机」就装不回来。 */
+  const urlSpec = (r) => typeof r.spec === 'string' && /^https?:/u.test(r.spec.trim())
+  /** 来源钉住的包没有「版本号相等」可比：link 依赖要看链接是否**真的**还在（release 通道更新会把
+   *  node_modules/<包名> 换成真实目录，此时必须重新物化 + 重放 link:，否则下次 pnpm 操作会还原版本）；
+   *  其余来源（git+/file:/URL）只要有解析且包装着即视为对齐。 */
+  const aligned = (r) => {
+    if (r.installed === null) return false
+    if (typeof r.spec === 'string' && r.spec.startsWith('link:')) return linkSpecIsIntact(profileDir, r.name, r.spec)
+    return r.installed === r.lock || sourcePinned(r.lock)
+  }
+  const driftedOf = (rows) => rows.filter((r) => r.installed === null || !aligned(r) || misrecorded(r) || urlSpec(r))
+
+  const depNotes = []
+  // 物化 + link: 计划（registry 查无此包时唯一安全的写回形式）
+  const linkPlan = (row, why) => {
+    const dir = materializePackageForLink(profileDir, row.name, home === null ? {} : { home })
+    if (dir === null) {
+      return {
+        spec: null,
+        note: `${row.name}：${why}，但 node_modules 里找不到可物化的已装副本 —— 已跳过 lock 对齐（**未改动 package.json**，避免留下指向不存在 npm 版本的裸版本号）`,
+      }
+    }
+    const link = linkSpecFor(dir)
+    return {
+      spec: link,
+      note: `${row.name}：${why}，已按 link: 形式记录依赖（${link}）—— 不经 npm registry 解析、不经 tarball 完整性校验，pnpm 重建 lock 也能装上`,
+    }
+  }
+  /** 决定单个漂移包该以什么 spec 写回。spec=null 表示跳过（不碰 manifest）。 */
+  const planWriteback = async (row) => {
+    const { name, spec, installed } = row
+    // ① manifest 里已是真实来源（协议前缀）→ 保持来源，绝不降级成裸版本号
+    if (typeof spec === 'string' && SOURCE_SPEC_RE.test(spec.trim())) {
+      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 再重放
+      if (spec.trim().startsWith('link:')) {
+        const dir = materializePackageForLink(profileDir, name, home === null ? {} : { home })
+        return { spec: dir === null ? spec.trim() : linkSpecFor(dir), note: null }
+      }
+      return { spec: spec.trim(), note: null } // git+ / file: / 别名 原样重放（幂等，来源不变）
+    }
+    // ② dist-tag（latest/next…）：registry 来源，但**保留标签**（钉成版本号会悄悄失去升级语义）
+    if (typeof spec === 'string' && DIST_TAG_RE.test(spec.trim())) {
+      const probeTag = await probeRegistryPackage(name, registries, { fetchJson })
+      if (probeTag.resolvable) return { spec: `${name}@${spec.trim()}`, note: null }
+      return linkPlan(row, 'npm registry 查无此包（该包只存在于 GitHub release）')
+    }
+    // ③ 版本号或没有条目 → 先探 registry：**这个版本**可解析才允许写版本号
+    const probe = await probeRegistryPackage(name, registries, { version: installed, fetchJson })
+    if (probe.resolvable && probe.hasVersion) return { spec: `${name}@${installed}`, note: null }
+    // ④ registry 查无此包（或查无此版本）→ 只存在于 GitHub release → 物化 + link:
+    return linkPlan(row, probe.resolvable ? `registry 上没有 ${installed} 这个版本` : 'npm registry 查无此包（该包只存在于 GitHub release）')
+  }
+
+  let rows = snap()
+  let drifted = driftedOf(rows)
+  const errors = []
+  let method = null
+  if (drifted.length > 0) {
+    // 只对"能读到实际版本"的包做精确对齐；读不到的（目录都没有）无法对账，留给 lockNote
+    const specs = []
+    for (const row of drifted) {
+      if (row.installed === null) continue
+      const plan = await planWriteback(row)
+      if (plan.note !== null) depNotes.push(plan.note)
+      if (plan.spec !== null) specs.push(plan.spec)
+    }
+    if (specs.length > 0) {
+      try {
+        await pnpmAdd(profileDir, specs.length === 1 ? specs[0] : specs, registries?.[0])
+        method = 'pnpm-add'
+      } catch (error) {
+        errors.push(`pnpm add 对齐失败：${error instanceof Error ? error.message : String(error)}`)
+      }
+    }
+    rows = snap()
+    drifted = driftedOf(rows)
+  }
+  const lockUpdated = drifted.length === 0
+  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)) })),
+    spec: rows.length === 1 ? rows[0].spec : null,
+    installedVersion: rows.length === 1 ? rows[0].installed : null,
+    lockVersion: rows.length === 1 ? rows[0].lock : null,
+    lockUpdated,
+    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)}`,
+    // 非常规来源（link:）写回时的**用户可见**说明：绝不静默（缺陷②的隐蔽性正是"装完看不出问题"）
+    depNote: depNotes.length > 0 ? depNotes.join('；') : null,
+    command: drifted.length > 0 ? command(drifted[0].name, drifted[0].installed) : command(rows[0]?.name ?? '', rows[0]?.installed ?? null),
+    errors,
+  }
+}
+
+
 export function apply(ctx) {
   // 恢复 AI 赋能任务（restart 后 running 置失败，plan-ready/结果保留）
   loadAiJobs()

package/package.json

@@ -1,44 +1,44 @@
-{
-  "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.3.60",
-  "description": "DSH plugin management panel & marketplace: one-click enable/disable, multi-source market (GitHub/Gitee/custom), static-index market (500+ plugins / 300 skills), skills, suites, and one-click framework upgrade.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Noob-stupid/dsh-plugin-hub"
-  },
-  "type": "module",
-  "main": "./lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./client": "./lib/client.js",
-    "./package.json": "./package.json"
-  },
-  "keywords": [
-    "dsh-plugin",
-    "deepseek-harness",
-    "plugin-manager"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "@deepseek-ai/dsh-client-runtime",
-        "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-ui-settings"
-      ]
-    }
-  },
-  "files": [
-    "lib",
-    "cordis.patch.yml",
-    "SECURITY.md"
-  ],
-  "license": "MIT",
-  "scripts": {
-    "checkBom": "node -e \"const fs=require('fs');const b=fs.readFileSync('package.json');if(b[0]===0xEF){console.error('BOM detected in package.json — strip it before publish');process.exit(1)};console.log('package.json BOM check OK')\"",
-    "prepublishOnly": "npm run checkBom"
-  }
-}
+{
+  "name": "@noob-stupid/dsh-plugin-console",
+  "version": "0.3.63",
+  "description": "DSH plugin management panel & marketplace: one-click enable/disable, multi-source market (GitHub/Gitee/custom), static-index market (500+ plugins / 300 skills), skills, suites, and one-click framework upgrade.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Noob-stupid/dsh-plugin-hub"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "plugin-manager"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "SECURITY.md"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "checkBom": "node -e \"const fs=require('fs');const b=fs.readFileSync('package.json');if(b[0]===0xEF){console.error('BOM detected in package.json — strip it before publish');process.exit(1)};console.log('package.json BOM check OK')\"",
+    "prepublishOnly": "npm run checkBom"
+  }
+}