@noob-stupid/dsh-plugin-console 0.5.106 → 0.5.108

package/lib/server/domain/install-channels.js

@@ -17,6 +17,8 @@ import { targetVersionOf, versionMissOf, versionMissText } from './install-versi
 import { tryPresetSourceChannel } from './preset-source.js'
 // 自更新兜底（2026-11-03 加法，见 domain/self-update-guard.js 顶部事故记录）：只在"装的包名 === 本插件自己"时接管
 import { beginSelfUpdateGuard, selfUpdateFailureText, settleSelfUpdateGuard } from './self-update-guard.js'
+// 覆盖式安装（2026-11-04 加法，见 domain/install-self-overlay.js 顶部现场）：`/install` 上"目标是自己"时**不跑通道序列**
+import { runSelfOverlayInstall } from './install-self-overlay.js'
 // 通用"超时/中断把目录弄坏 ⇒ 复核 + 恢复"（2026-11-04 加法，见 domain/install-recovery.js 顶部）：对**所有**包生效
 import { withInstallRecovery } from './install-recovery.js'
 
@@ -74,10 +76,33 @@ async function tryCandidateChannels(args) {
 async function runSelfUpdateGuarded(args) {
   const inner = () => tryCandidateChannelsInner(args)
   const guardDeps = args?.selfUpdateDeps ?? {}
+  const job = args?.job !== null && args?.job !== undefined && typeof args.job === 'object' ? args.job : null
+  const namedVersion = targetVersionOf(args?.job, args?.name)
   const session = beginSelfUpdateGuard({
     packageName: args?.name, profileDir: args?.profileDir,
-    targetVersion: targetVersionOf(args?.job, args?.name), deps: guardDeps,
+    targetVersion: namedVersion, deps: guardDeps,
   })
+  // ★ 2026-11-04 加法（真机：详情页那颗「更新」走的是 `POST /install`，0.5.105 的"自更新不走 pnpm"根本没被触发）：
+  //   目标 === 本插件自己 ⇒ 先走**覆盖式安装**（domain/install-self-overlay.js：下载 tarball → 只覆盖不清空 → 读回版本）。
+  //   铺成了就**到此为止**：竞速 / pnpm / curl / release / preset / git / 定向重试一条都不启动（零 pnpm、不动 lock）。
+  //   铺不成（离线 / 拿不到 tarball / 覆盖失败）⇒ 不改变任何既有语义，落回下面那段原路；别的包 `overlay === null`，
+  //   同样一个字节都不多走（负控：tests/test-install-self-overlay.mjs ④）。
+  const overlay = await runSelfOverlayInstall({
+    job: args?.job ?? null, packageName: args?.name, profileDir: args?.profileDir,
+    registries: args?.registries ?? [], deps: args?.selfOverlayDeps ?? {},
+  })
+  if (overlay !== null && overlay.ok === true) {
+    // 收尾判据与既有自更新同源（settleSelfUpdateGuard）；`landed:true` 才允许它删本次备份（见那里的注释）
+    const selfUpdate = settleSelfUpdateGuard(session, { targetVersion: overlay.targetVersion ?? namedVersion, deps: guardDeps, landed: true })
+    if (job !== null) { job.selfUpdate = selfUpdate; job.selfOverlay = overlay }
+    if (selfUpdate === null || selfUpdate.verified === true) return { installedName: args?.name, lastError: null, source: null }
+    // 文件铺上了，但守卫的同一判据复核不过 ⇒ 如实失败（不在一份已经不对劲的新目录上继续施工）
+    return { installedName: null, lastError: new Error(selfUpdateFailureText(selfUpdate) ?? '自更新校验未通过（原因未知）') }
+  }
+  if (overlay !== null && job !== null) {
+    // 覆盖没成 ⇒ 如实说明"落回既有通道"，否则用户看到 pnpm 起来会以为改动没生效
+    noteChannel(job, `覆盖式安装没成功（${overlay.reason ?? '原因未知'}），已回落既有通道序列`)
+  }
   // ★ 2026-11-04 加法（见 domain/install-recovery.js 顶部现场）：不是自更新 ⇒ 走**通用**恢复那一层 ——
   //   对所有包生效（真机清空的不止控制台：用户的 dsh-workbuddy-connect 也被清空过）。
   //   为什么二选一、不叠加：两层用的都是同一个备份后缀（`.pre-update-<ts>`），叠在一起会互相把对方
@@ -87,7 +112,7 @@ async function runSelfUpdateGuarded(args) {
     const runWith = (channels) => tryCandidateChannelsInner(channels === null || channels === undefined ? args : { ...args, ch: channels })
     return await withInstallRecovery({
       job: args?.job ?? null, name: args?.name, profileDir: args?.profileDir,
-      targetVersion: targetVersionOf(args?.job, args?.name), ch: args?.ch ?? null, deps: args?.recoveryDeps ?? {},
+      targetVersion: namedVersion, ch: args?.ch ?? null, deps: args?.recoveryDeps ?? {},
     }, runWith)
   }
   let outcome = null
@@ -97,8 +122,12 @@ async function runSelfUpdateGuarded(args) {
   } catch (error) {
     thrown = error
   }
-  const selfUpdate = settleSelfUpdateGuard(session, { targetVersion: targetVersionOf(args?.job, args?.name), deps: guardDeps })
-  if (args?.job !== null && args?.job !== undefined && typeof args.job === 'object') args.job.selfUpdate = selfUpdate
+  // ★ 2026-11-04 改错（用户红线：备份不许在失败路径上被清理）：`landed` 必须由这里**明说** ——
+  //   "通道真的报了装上"才算这次落地；通道全失败 / 抛异常时目录可能原地没动，那时 verified 仍是 true，
+  //   旧判据就会把备份删掉（真机 `bak=1` → 8 秒后 `bak=0`，随后 pnpm 把目录清空 ⇒ "自动恢复失败：备份目录不存在"）。
+  const landed = thrown === null && outcome !== null && outcome !== undefined && typeof outcome.installedName === 'string' && outcome.installedName !== ''
+  const selfUpdate = settleSelfUpdateGuard(session, { targetVersion: namedVersion, deps: guardDeps, landed })
+  if (job !== null) job.selfUpdate = selfUpdate
   if (thrown !== null) throw thrown
   if (selfUpdate !== null && selfUpdate.verified === true) return outcome
   return { installedName: null, lastError: new Error(selfUpdateFailureText(selfUpdate) ?? '自更新校验未通过（原因未知）') }

package/lib/server/domain/install-job.js

@@ -21,6 +21,8 @@ import { verifyInstalledEntry } from './install-verify.js'
 import { selfUpdateFailureText } from './self-update-guard.js'
 // 通用超时/中断恢复（2026-11-04 加法，见 domain/install-recovery.js 顶部）：「安装把目录弄坏了」的那句话由它产出
 import { installRecoveryFailureText } from './install-recovery.js'
+// 覆盖式安装（2026-11-04 加法，见 domain/install-self-overlay.js 顶部现场）：成功时那一句如实文案由它产出
+import { selfOverlayNote } from './install-self-overlay.js'
 import { applyNpmNameHint, composeProbeFailureText, expandSubpackageCandidates, fetchRepoPackage, fetchRepoPackageEx, fetchSubdirPlugins, fetchSubpackageNames, npmNameHintForRepo, packageProbeErrorText, subpackageCandidates } from './market.js'
 import { decideNoRootManifest } from './subdir-detect.js'
 import { runSubdirInstallJob } from './subdir-install.js'
@@ -282,12 +284,37 @@ async function runInstallJob(job, ports, deps = {}) {
         // 包互斥闸的排队上限（domain/install-lock.js#INSTALL_LOCK_WAIT_MS 是生产默认值；
         // 这里只是**单测注入缝**，生产调用方不传 deps.installLockWaitMs ⇒ undefined ⇒ 默认值）
         lockWaitMs: Number.isFinite(deps.installLockWaitMs) ? deps.installLockWaitMs : undefined,
+        // 覆盖式安装（"目标就是本插件自己"那条路）的**单测注入缝**：元数据/下载/解包替身由此喂进去，
+        // 生产调用方不传 ⇒ undefined ⇒ 用既有实现，行为一个字都不变（见 domain/install-self-overlay.js）
+        selfOverlayDeps: deps.selfOverlayDeps ?? undefined,
         expand: (expanded || job.npmNameHint !== undefined) ? null : expandSubpackages,
       })
       installedName = attempt.installedName
       lastError = attempt.lastError
       if (installedName !== null) { installedSource = attempt.source ?? null; break }
     }
+    // ★ 2026-11-04 加法（真机：详情页那颗「更新」走 /install ⇒ 0.5.105 的"自更新不走 pnpm"根本没被触发）：
+    //   目标就是本插件自己、且**覆盖式安装已经铺上了** ⇒ 到此为止。下面那些收口步骤一个都不跑，因为
+    //   `syncAggregateSubpackageVersions` / `ensureBundlePatchIntegrity` / `reconcileLockfile` / `ensurePersisted`
+    //   都会去动包管理器或写 lock/清单（本轮的硬要求正是"零 pnpm + lock 一个字节都不变"）。
+    //   `job.selfOverlay` 只由 domain/install-self-overlay.js 在**真的铺上**时写入（install-channels.js 也只在这条
+    //   路上挂它）⇒ 装别的包、以及自更新的"覆盖没成 ⇒ 落回既有通道"两条路都永远进不到这里。
+    if (installedName !== null && job.selfOverlay !== null && job.selfOverlay !== undefined) {
+      job.candidateDone = true
+      job.candidateName = installedName
+      job.packageName = installedName
+      // 只读装后校验（入口 / 补丁行 / bundle 引用）：只提示，不改任何判定 —— 与既有通道同一份判据
+      job.entryCheck = verifyInstalledEntry(profileDir, installedName)
+      job.installedVersion = job.selfOverlay.version ?? job.entryCheck?.version ?? null
+      // 面板「已安装」那一行显示 curlNote；⚠️ 那句 lock 说明显示 lockNote（两点都如实，不静默）
+      const overlayNote = selfOverlayNote(job.selfOverlay)
+      if (overlayNote !== null) job.curlNote = overlayNote
+      // lock 这一栏只报**事实**：本次没写 lock（`lockVersion` 留空 = 没读/未知，绝不把目标版本冒充成 lock 里的版本）
+      job.lockUpdated = false
+      job.lockNote = job.selfOverlay.lockNote ?? null
+      job.status = 'done'
+      return
+    }
     // 预设收口（D-③ 源码装配成功 / D-⑥ 落地物里带预设）：能按预设收口就直接 return —— 见 preset-in-package.js
     // （这两条路都**没有 node_modules 插件**，写补丁行/声明依赖会让补丁行指向无入口模块 → 启动崩溃）。
     if (await settlePresetOutcome({ job, installedName, profileDir, repo: job.repo, deps: sourceDeps }) === true) return

package/lib/server/domain/install-self-overlay.js

@@ -0,0 +1,158 @@
+// L1 · domain —— install-self-overlay.js（`POST /install` 上「目标就是本插件自己」的覆盖式安装；2026-11-04 加法）
+//
+// ── 现场（真机 2026-11-04 20:21，8 秒粒度采样；用户提供的原始时间线）──────────────────────────
+//   用户点的是「**详情页的更新按钮**」—— 那颗按钮走 `POST /install`（lib/client.js#startJob），
+//   **不是** `POST /self-update`。所以 0.5.105「自更新彻底不走 pnpm」那套改动**一次都没被触发**：
+//     20:21:14  目录 = 空壳（1 文件）   pnpm = 有 1 个在跑   备份 = 0
+//     20:22:14  目录 = 空壳（1 文件）   pnpm = 仍在跑         备份 = 0
+//   即：`/install` 这条路上通道序列照旧先启动 pnpm，而 pnpm 一启动就**先把目标目录清空**，
+//   本机它要 3~9 分钟且必被超时杀 ⇒ 目录一直空着；排在它后面的 curl 兜底永远轮不到。
+//
+// ── 本模块做什么（判据只有一个：目标包名 === 本插件包名）──────────────────────────────────
+//   命中 ⇒ **整条通道序列（竞速 / pnpm / curl / release / preset / git / 定向重试）一个都不跑**，
+//   改走与 `/self-update` 同一条"下载 tarball → **只覆盖、不清空** → 读回核对版本"的路：
+//     ① 目标版本：作业点名的版本（`job.version`）优先；没点名就按 registry 的 `dist-tags.latest` 探一次；
+//     ② 预下载 tarball + 覆盖解包 —— **复用** domain/selfupdate-copy.js（唯一实现，含 breakHardLinksUnder）；
+//     ③ 备份 / 自愈 / 绝对路径 manualCommand —— **复用** domain/self-update-guard.js（唯一实现）；
+//     ④ **pnpm-lock.yaml 一个字节都不动**（用户 2026-11-04 拍板：「不按 lock 不就行了，我们不是取消 lock 了吗」）。
+//        理由：改 lock 是**风险来源**（写坏会波及整个 profile），而"被还原"的代价很低 —— 再点一次更新即可
+//        （覆盖式只要几秒钟）。所以本次**不写 lock、不做 lock 外科手术**，只在结果里如实记一条 `lockNote`
+//        （「本次没有改 lock，下次包管理器操作可能把版本还原」），绝不谎报"已同步"。
+//
+// ── 边界（别越线）────────────────────────────────────────────────────────────────────
+//   ① 只对**本插件自己**生效：`isSelfUpdate()` 不成立时 `runSelfOverlayInstall()` 直接返回 null，
+//      调用方走原路径 —— 装别的包的通道序列、超时、版本闸、AI 兜底、清单与 lock 写入**一个字节都不变**
+//      （负控见 tests/test-install-self-overlay.mjs ④）；
+//   ② 覆盖**没成**（离线 / 拿不到 tarball / 解包失败）⇒ 返回 `ok:false` 并**交还控制权**：调用方落回
+//      **既有**通道序列（语义与改动前逐字相同）。本模块绝不半路改判既有通道的行为。
+//   ③ 本模块**不判断"更新成功与否"**：落地与否由「读回的版本 === 目标版本」（覆盖那一步自己核对）
+//      + 守卫的同一判据说了算；任何一项不成立都如实报，绝不报成功。
+//   ④ 清单一族（`<profile>/package.json` 的 dependencies）本次也不改：清单与 lock 保持**互相一致**的旧状态，
+//      比"清单写新版、lock 还写旧版"这种两处对不上的状态干净（后者正是 reconcileLockfile 报的 `misrecorded`）。
+import { lstatSync } from 'node:fs'
+import { join } from 'node:path'
+import { probeRegistryPackage } from './dep-source.js'
+import { targetVersionOf } from './install-version.js'
+import { isSelfUpdate } from './self-update-guard.js'
+import { disposeSelfUpdateTarball, overlaySelfUpdateTarball, prepareSelfUpdateTarball } from './selfupdate-copy.js'
+
+/** 通道名（与 `/self-update` 那条路同一个说法：覆盖式 = manual-overlay）。 */
+const OVERLAY_CHANNEL = 'manual-overlay'
+
+/** 「lock 一个字节都没动」的如实说明（结果里/面板上都用这一句；**不许**改写成"已同步"）。 */
+const SELF_OVERLAY_LOCK_NOTE = '本次没有改 pnpm-lock.yaml（覆盖式安装只动 node_modules/<本插件>，清单与 lock 都保持原样）：'
+  + '之后任何一次包管理器操作（开关插件、dsh plugin add/remove）都可能把版本还原成 lock 里那一版 —— 届时在面板上再点一次更新即可（覆盖式只要几秒钟）'
+
+/** 目录是不是链接（junction 在 lstat 上也表现为符号链接）—— 只看形状；读不到按"不是链接"处理。 */
+function isLinkedDir(dir) {
+  try { return lstatSync(dir).isSymbolicLink() === true } catch { return false }
+}
+
+const labelOf = (error) => (error instanceof Error ? error.message : String(error))
+
+
+/**
+ * 目标版本：点名的优先，其次 registry 的 `dist-tags.latest`（**只读探测**，不装任何东西）。
+ * 返回 `{ version, source, reason }`：`version:null` 时 `reason` 里有如实原因（调用方据此落回既有通道。
+ */
+async function resolveSelfOverlayVersion({ job = null, packageName = '', registries = [], deps = {} } = {}) {
+  const named = targetVersionOf(job, packageName)
+  if (named !== null) return { version: named, source: 'job', reason: null }
+  const list = (Array.isArray(registries) ? registries : []).filter((r) => typeof r === 'string' && r.trim() !== '')
+  if (list.length === 0) return { version: null, source: null, reason: '没有可用的软件源，无法确定目标版本' }
+  const probe = typeof deps.probeRegistry === 'function' ? deps.probeRegistry : probeRegistryPackage
+  try {
+    const found = await probe(packageName, list, { fetchJson: deps.fetchJson, timeoutMs: deps.metaTimeoutMs })
+    const latest = typeof found?.latest === 'string' && found.latest !== '' ? found.latest : null
+    if (found?.resolvable !== true || latest === null) {
+      const tried = Array.isArray(found?.tried) && found.tried.length > 0 ? `（${found.tried.join('；')}）` : ''
+      return { version: null, source: null, reason: `探测不到 ${packageName} 的最新版本${tried}` }
+    }
+    return { version: latest, source: 'registry', reason: null }
+  } catch (error) {
+    return { version: null, source: null, reason: `探测最新版本失败：${labelOf(error)}` }
+  }
+}
+
+/**
+ * 覆盖式安装的**唯一入口**。
+ * 不是本插件自己 ⇒ 返回 null（调用方走原路径，一个字节都不多走）；是本插件自己 ⇒ 一定返回一个报告对象：
+ *   `ok:true`  已经铺上并且**读回的版本 === 目标版本**（可以就此收口，不用再碰任何通道）；
+ *   `ok:false` 没铺成（`reason` 里是如实原因）—— 调用方落回**既有**通道序列，语义不变。
+ * 返回结构（也直接进 `job.selfOverlay`，面板/接口都看得到；只增字段）：
+ * `{ ok, channel, packageName, targetVersion, versionSource, version, files, preserved, links, boxNote,
+ *    tarballNote, cleanupNote, lockTouched, lockNote, reason, ms }`。
+ */
+async function runSelfOverlayInstall({ job = null, packageName = '', profileDir = '', registries = [], deps = {} } = {}) {
+  if (isSelfUpdate(packageName, deps) !== true) return null
+  const startedAt = Date.now()
+  const out = {
+    ok: false, channel: OVERLAY_CHANNEL, packageName,
+    targetVersion: null, versionSource: null, version: null,
+    files: 0, preserved: 0, links: null, boxNote: null,
+    tarballNote: null, cleanupNote: null,
+    // lock 与清单**全程不动**（用户 2026-11-04 拍板）：这两个字段是给用户看的、也是自检用的
+    lockTouched: false, manifestTouched: false, lockNote: SELF_OVERLAY_LOCK_NOTE,
+    reason: null, ms: 0,
+  }
+  try {
+    if (typeof profileDir !== 'string' || profileDir.trim() === '') {
+      out.reason = '没有 profile 目录，无法做覆盖式安装'
+      return out
+    }
+    // ① 目标版本（点名优先，其次 registry 的 latest —— 只读探测）
+    const resolved = await resolveSelfOverlayVersion({ job, packageName, registries, deps })
+    out.targetVersion = resolved.version
+    out.versionSource = resolved.source
+    if (resolved.version === null) {
+      out.reason = resolved.reason ?? '拿不到目标版本，未做覆盖式安装'
+      return out
+    }
+    // ①′ 目标目录是**链接**（link:/junction 安装，用户自己的源码树）⇒ 不覆盖：
+    //    覆盖会顺着链接写进用户的工作区（把开发者正在改的那份源码换掉），这与 install-recovery 的
+    //    边界③同一条理由（"宁可不动手，也要说清为什么不动手"）。落回既有通道，一个字节都不多走。
+    if (isLinkedDir(join(String(profileDir), 'node_modules', ...String(packageName).split('/'))) === true) {
+      out.reason = `node_modules/${packageName} 是链接（link:/junction 安装，指向用户自己的目录）⇒ 不做覆盖式安装，已回落既有通道`
+      return out
+    }
+    // ② 预下载 tarball（复用的既有实现：registry 元数据 → dist.tarball → curl 下载）
+    const prepared = await prepareSelfUpdateTarball({ packageName, version: resolved.version, registries, deps })
+    out.tarballNote = prepared.ok === true ? null : (prepared.reason ?? null)
+    // ③ **只覆盖、不清空**地铺进 node_modules/<本插件>，随后读回核对版本（同一个既有实现）
+    const overlay = await overlaySelfUpdateTarball({ prepared, profileDir, packageName, expectedVersion: resolved.version, deps })
+    const cleanup = disposeSelfUpdateTarball(prepared) // 下载物与解包目录收尾即删（删不掉要如实记）
+    out.cleanupNote = cleanup.removed === true ? null : (cleanup.note ?? null)
+    out.version = overlay.version ?? null
+    out.files = overlay.files ?? 0
+    out.preserved = overlay.preserved ?? 0
+    out.links = overlay.links ?? null
+    out.boxNote = overlay.boxNote ?? null
+    out.ok = overlay.ok === true
+    if (out.ok !== true) {
+      out.reason = overlay.reason ?? prepared.reason ?? '覆盖式安装没有成功'
+    }
+    return out
+  } catch (error) {
+    out.reason = `覆盖式安装抛错：${labelOf(error)}`
+    return out
+  } finally {
+    out.ms = Date.now() - startedAt
+  }
+}
+
+/** 覆盖式安装成功时给用户看的那一句（**绝不静默**：铺了几个文件、原地保留几个、lock 没动）。
+ *  调用方把它塞进 `job.curlNote`（面板「已安装」那一行就显示这个字段）。 */
+function selfOverlayNote(overlay) {
+  if (overlay === null || overlay === undefined || overlay.ok !== true) return null
+  const version = overlay.version === null || overlay.version === undefined ? '?' : String(overlay.version)
+  const parts = [`用覆盖式安装升到 v${version}（只覆盖了 ${overlay.files ?? 0} 个文件、**没有清空目录**，原地保留 ${overlay.preserved ?? 0} 个不在 tarball 里的文件；全程没有调用包管理器 pnpm）`]
+  if (typeof overlay.boxNote === 'string' && overlay.boxNote !== '') parts.push(overlay.boxNote)
+  if (overlay.links !== null && overlay.links !== undefined && (overlay.links.broken > 0 || overlay.links.failed > 0)) {
+    parts.push(`断开硬链接 ${overlay.links.broken ?? 0} 个${overlay.links.failed > 0 ? `（${overlay.links.failed} 个没断开，已原地覆盖）` : ''}`)
+  }
+  if (typeof overlay.cleanupNote === 'string' && overlay.cleanupNote !== '') parts.push(overlay.cleanupNote)
+  parts.push('重启服务后生效')
+  return parts.join('；')
+}
+
+export { OVERLAY_CHANNEL, SELF_OVERLAY_LOCK_NOTE, resolveSelfOverlayVersion, runSelfOverlayInstall, selfOverlayNote }

package/lib/server/domain/install.js

@@ -510,6 +510,10 @@ function installJobView(job) {
     // 更新会出现，**非自更新作业恒 null**（既有契约一字不改）。`verified:false` ⇒ 作业必为 failed 且 job.error
     // 已写清原因/残缺目录/手动命令；`healed:true` ⇒ 已从备份恢复成更新前的版本（那不是"更新成功"）。
     selfUpdate: job.selfUpdate ?? null,
+    // 覆盖式安装的结果（2026-11-04 加法，见 domain/install-self-overlay.js 顶部现场）：**只有**
+    // "目标就是本插件自己、且真的用覆盖式铺上了"时才非 null（装别的包恒 null，既有契约一字不改）。
+    // 里面如实写明：铺了几个文件 / 原地保留几个 / lock 一个字节都没动（含那句 lockNote）。
+    selfOverlay: job.selfOverlay ?? null,
     // 同一个包互斥的结果（2026-11-04 加法，见 domain/install-lock.js 顶部现场）：`queued:true` ⇒ 本次在排队
     // 等前一个作业（有 `waitedMs` 就能看出等了多久）；`timeout:true` ⇒ 排队超时、本次**没装**（job.error 已写清）。
     // 非并发场景恒 null（既有契约一字不改）。

package/lib/server/domain/self-update-guard.js

@@ -250,9 +250,12 @@ function restoreSelfPackageDir(pkgDir, backupPath, deps = {}) {
       }
     }
   } else {
-    try { mkdirSync(dirname(dir), { recursive: true }) } catch {}
+    // ★ 2026-11-04 加法：目录**整个不见了**（安装把它删掉/搬走）也要能从备份放回来。旧代码在这里只建父目录、
+    //   mode 保持 null ⇒ 下面的复制分支被跳过 ⇒ "有备份却恢复不了"（真机 `cleanupStalePackageDir` 就是这样删的）。
+    try { mkdirSync(dir, { recursive: true }) } catch {}
+    out.mode = 'created'
   }
-  if (out.mode === 'renamed') {
+  if (out.mode === 'renamed' || out.mode === 'created') {
     try {
       copy(backupPath, dir)
     } catch (error) {
@@ -389,7 +392,7 @@ function noteGuardStep(session, step) {
  * → 备份收口（最多留 KEEP_BACKUPS 份）→ 产出如实报告。session 为 null 时原样返回 null。
  * 返回的报告就是作业里那个 `selfUpdate` 字段（只增字段，见 installJobView）。
  */
-function settleSelfUpdateGuard(session, { targetVersion = undefined, deps = {} } = {}) {
+function settleSelfUpdateGuard(session, { targetVersion = undefined, deps = {}, landed = false } = {}) {
   if (session === null || session === undefined || typeof session !== 'object') return null
   const io = { ...(session.deps ?? {}), ...(deps ?? {}) }
   const expected = targetVersion === undefined
@@ -443,8 +446,12 @@ function settleSelfUpdateGuard(session, { targetVersion = undefined, deps = {} }
       }
     }
   }
-  // 备份收口（成败都收口到"最多 KEEP_BACKUPS 份"）：通过 ⇒ 本次这份也删掉；没通过 ⇒ 留着它（那是唯一的旧版）
-  const dropped = out.verified === true ? dropBackupOf(out.backupPath) : null
+  // ★ 2026-11-04 改错（用户红线「失败路径必须保留备份」；真机 `bak=1` → 8 秒后 `bak=0` 随后目录被清空）：
+  //   旧判据只看 `out.verified === true`，而它只证明"目录里有一份完整的自身副本" —— 通道**全部失败、目录原地
+  //   没动**时同样成立，于是备份被当成"更新成功"删掉，紧接着 pnpm 把目录清空 ⇒「自动恢复失败：备份目录不存在」。
+  //   现在必须由调用方**明说这次真的落地了**（`landed === true` 且同一判据复核通过）才允许删本次备份；
+  //   任何失败 / 中断 / 未指定 landed 的调用都**保留**备份（保守：宁可多留一份旧版）。
+  const dropped = landed === true && out.verified === true ? dropBackupOf(out.backupPath) : null
   const pruned = pruneSelfBackups(pkgDir, { keep: KEEP_BACKUPS, deps: io })
   out.backupCleanup = {
     removed: [...(dropped !== null && dropped.removed === true ? [out.backupPath] : []), ...pruned.removed],

package/lib/server/domain/selfupdate.js

@@ -162,7 +162,9 @@ async function selfUpdateToLatestLocked({ profileDir, latest, registries, curlMa
   const cleanup = disposeSelfUpdateTarball(prepared)
 
   // 收尾：全部动作走完才统一校验（仍不过才自愈），然后交给**原样搬出**的收尾段组装返回结构
-  const selfUpdate = settleSelfUpdateGuard(guard, { targetVersion: latest })
+  // ★ 2026-11-04 改错：`landed` 必须显式给 —— 只有"盘上真的是目标版本"才允许守卫删掉本次备份；
+  //   通道报成功而目录原地没动（或已被掏空）时，那份备份是唯一的旧版，绝不能删（见 settleSelfUpdateGuard）。
+  const selfUpdate = settleSelfUpdateGuard(guard, { targetVersion: latest, landed: installed === latest })
   const tarball = {
     ok: prepared.ok === true,
     version: prepared.version ?? latest,

package/package.json

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