@noob-stupid/dsh-plugin-console 0.5.77 → 0.5.87

package/lib/server/domain/persist.js

@@ -42,6 +42,59 @@ import { dshHome, packageNameOf } from '../infra/paths.js'
 /** 三处缺口的**稳定名字**（面板文案与测试都按它们断言，不许改写）。 */
 const PERSIST_PARTS = ['dependency', 'lock', 'mount']
 
+// ── 0.5.84 判据降噪：把「不一致」分成两类（**只分类，不改判据强度**）─────────────────
+// 用户反馈：面板上到处是红字「未持久化」，但绝大多数并不影响使用 —— 看一眼就想关掉，
+// 真正要紧的那条也跟着被无视了。所以这里给每个缺口定一个**机器可读的原因码**
+// （`parts.*.code`），再按「这个不一致会不会让插件在重启后消失」分成两档：
+//
+//   critical（会丢插件，必须红）—— 只有这两种：
+//     ① 清单里**没有**这个条目（或清单写的版本在磁盘上根本不存在）：
+//        pnpm 下一次任何操作都会把这个"多余包"清掉 → 插件真的没了。
+//     ② 挂载行**不满足**：包在盘上，但重启后没有任何行会加载它 → 用户视角"插件消失了"。
+//        注意这一条判的是"重启后会不会被挂上"，与"包是不是已经下载"无关。
+//
+//   warn（只是口径不一致，重启后照常加载，降级成可折叠提示）—— 其余全部：
+//     · lock 条目缺失 / 形态不符 / 指向的目标不同：**清单才是事实来源**，pnpm 会按清单重算 lock，
+//       插件本身不会被清掉（最坏情况是 lock 被重写成同样的结论）。
+//     · 清单声明 link: 而磁盘是真实目录、或精确版本与磁盘版本不一致：包就在那里，
+//       pnpm 会把它改写成清单说的形态/版本 —— 换的是那一份副本，不是"没有"。
+//
+// 为什么要在**服务端**分（而不是让面板各自判）：判据分两处必然分叉（本仓已多次踩过），
+// 而"会不会丢"这件事需要同时看清单、lock 与挂载行的真实值 —— 只有这里同时握着这三份事实。
+/** 会丢插件（必须红）的原因码。表里没有的码一律按 warn 处理（保守方向：宁可少报红）。 */
+const PERSIST_CRITICAL_CODES = new Set([
+  'dep-missing-entry',   // 清单 dependencies 里没有它 → pnpm 会当多余包清掉
+  'dep-link-broken',     // 清单钉的 link 目标不存在 → 这份链接是断的，pnpm 只会把它当坏的
+  'dep-version-missing', // 清单写了精确版本，但盘上根本没有这个包
+  'dep-range-missing',   // 清单写了范围/dist-tag，但盘上没有这个包
+])
+/** 只是为了让人看得懂原因码说的是什么（面板不读它，测试与日志用它）。 */
+const PERSIST_CODE_TEXT = {
+  'dep-missing-entry': '清单 dependencies 里没有条目',
+  'dep-link-broken': '清单钉的 link 目标不成立',
+  'dep-version-missing': '盘上没有这个版本',
+  'dep-range-missing': '盘上没有这个包',
+  'dep-link-not-a-link': '清单是 link: 但盘上是真实目录',
+  'dep-version-drift': '清单版本与磁盘版本不一致',
+  'lock-missing-entry': 'lock 里没有条目',
+  'lock-link-target-drift': 'lock 的 link 目标与清单不同',
+  'lock-form-drift': 'lock 的形态与清单不同',
+  'lock-version-drift': 'lock 的版本与清单不同',
+  'lock-unverified': 'lock 写入后未被只读校验确认',
+  'mount-bundle-no-patch': '在 bundles 里但没声明 bundle 补丁',
+  'mount-bundle-patch-missing': '声明的 bundle 补丁文件不存在',
+  'mount-bundle-patch-empty': 'bundle 补丁里没有任何 insert 行',
+  'mount-no-row': '补丁/bundles/运行时都没有它的行',
+}
+/** `mount-*` 一律 critical（挂不上就是"重启后看不见"）；这里显式列出，避免靠前缀猜。 */
+const PERSIST_CRITICAL_MOUNT = new Set(['mount-bundle-no-patch', 'mount-bundle-patch-missing', 'mount-bundle-patch-empty', 'mount-no-row'])
+
+/** 某个原因码算不算"会丢插件"。 */
+function isPersistCriticalCode(code) {
+  return PERSIST_CRITICAL_CODES.has(code) || PERSIST_CRITICAL_MOUNT.has(code)
+}
+
+
 /** 精确版本号形态（`1.2.3` / `0.0.1-rc1`）：只有它才要求与磁盘版本逐字相等。 */
 const EXACT_VERSION_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u
 /** 来源型 spec 前缀（协议）——这些形态**绝不**改写成版本号（改写等于丢来源）。 */
@@ -86,8 +139,9 @@ function diskFormOf(profileDir, packageName) {
 function dependencyPart({ profileDir, packageName }) {
   const spec = profileSpec(profileDir, packageName)
   const disk = diskFormOf(profileDir, packageName)
-  const out = { ok: false, spec, form: null, disk: { form: disk.form, version: disk.version }, reason: null }
+  const out = { ok: false, spec, form: null, disk: { form: disk.form, version: disk.version }, reason: null, code: null }
   if (spec === null) {
+    out.code = 'dep-missing-entry'
     out.reason = 'package.json 的 dependencies 里没有这个条目（pnpm 会把它当多余包清掉）'
     return out
   }
@@ -95,10 +149,12 @@ function dependencyPart({ profileDir, packageName }) {
   if (trimmed.startsWith('link:')) {
     out.form = 'link'
     if (disk.form !== 'link') {
+      out.code = 'dep-link-not-a-link'
       out.reason = `清单是 ${trimmed}，但 node_modules/${packageName} 不是指向它的链接（磁盘上实际是 ${disk.form === 'missing' ? '不存在' : '真实目录'}）`
       return out
     }
     if (!linkSpecIsIntact(profileDir, packageName, trimmed)) {
+      out.code = 'dep-link-broken'
       out.reason = `清单是 ${trimmed}，但链接当前不成立（目标不存在或指向别处）`
       return out
     }
@@ -114,10 +170,12 @@ function dependencyPart({ profileDir, packageName }) {
   if (EXACT_VERSION_RE.test(trimmed)) {
     out.form = 'version'
     if (disk.version === null) {
+      out.code = 'dep-version-missing'
       out.reason = '清单写的是版本号，但 node_modules 里读不到该包的版本（没装或被还原）'
       return out
     }
     if (disk.version !== trimmed) {
+      out.code = 'dep-version-drift'
       out.reason = `清单写 ${trimmed}，磁盘上是 ${disk.version} —— 两处对不上`
       return out
     }
@@ -127,6 +185,7 @@ function dependencyPart({ profileDir, packageName }) {
   // 版本范围（^1.2.3）或 dist-tag（latest/next）：registry 来源但非精确值 —— 有条目且装上了即算就位
   out.form = 'range'
   if (disk.version === null) {
+    out.code = 'dep-range-missing'
     out.reason = `清单写 ${trimmed}，但 node_modules 里读不到该包（没装或被还原）`
     return out
   }
@@ -137,8 +196,9 @@ function dependencyPart({ profileDir, packageName }) {
 /** ② lock 条目：与 ① 的 spec 同一形态（link: ↔ link:；精确版本 ↔ 逐字相等）。 */
 function lockPart({ profileDir, packageName, spec }) {
   const entry = lockVersion(profileDir, packageName)
-  const out = { ok: false, entry: entry ?? null, reason: null }
+  const out = { ok: false, entry: entry ?? null, reason: null, code: null }
   if (entry === null || entry === undefined) {
+    out.code = 'lock-missing-entry'
     out.reason = 'pnpm-lock.yaml 里没有这个包的条目（任何一次 pnpm 操作都可能把它还原/清掉）'
     return out
   }
@@ -151,6 +211,7 @@ function lockPart({ profileDir, packageName, spec }) {
       out.ok = true
       return out
     }
+    out.code = value.startsWith('link:') ? 'lock-link-target-drift' : 'lock-form-drift'
     out.reason = value.startsWith('link:')
       ? `清单把该包钉在 ${s}，而 lock 里是 ${value}（**指向的目标不同**，对账后会被 pnpm 还原）`
       : `清单把该包钉在 ${s}，而 lock 里是 ${value}（对账后会被 pnpm 还原）`
@@ -165,6 +226,7 @@ function lockPart({ profileDir, packageName, spec }) {
       out.ok = true
       return out
     }
+    out.code = 'lock-version-drift'
     out.reason = `清单写 ${s}，lock 里是 ${value} —— 两处对不上`
     return out
   }
@@ -175,7 +237,7 @@ function lockPart({ profileDir, packageName, spec }) {
 
 /** ③ 挂载行：用户补丁 insert 行 / bundle 层 / 运行时已有行，三者任一成立即算会挂载。 */
 function mountPart({ profileDir, patchPath, packageName, patchText = null, bundles = null, entries = null }) {
-  const out = { ok: false, via: 'none', rowId: null, bundlePatch: null, reason: null }
+  const out = { ok: false, via: 'none', rowId: null, bundlePatch: null, reason: null, code: null }
   // 运行时已有行提供它（例如聚合包里的行）：最直接的证据，先看
   if (Array.isArray(entries)) {
     for (const entry of entries) {
@@ -208,12 +270,14 @@ function mountPart({ profileDir, patchPath, packageName, patchText = null, bundl
       rel = null
     }
     if (typeof rel !== 'string' || rel === '') {
+      out.code = 'mount-bundle-no-patch'
       out.reason = `已在 dsh.profile.bundles 里，但该包没有声明 dsh.bundle.patch —— bundle 层不会装入任何行，需要一条 insert 行`
       return out
     }
     const file = join(String(profileDir), 'node_modules', ...String(packageName).split('/'), rel)
     if (!existsSync(file)) {
       out.bundlePatch = file
+      out.code = 'mount-bundle-patch-missing'
       out.reason = `dsh.profile.bundles 里有它，但它声明的 bundle 补丁文件不存在（${file}）`
       return out
     }
@@ -225,15 +289,64 @@ function mountPart({ profileDir, patchPath, packageName, patchText = null, bundl
     }
     if (rows.size === 0) {
       out.bundlePatch = file
+      out.code = 'mount-bundle-patch-empty'
       out.reason = `bundle 补丁里读不到任何 insert 行（${rel}）—— 没有任何东西会被挂载`
       return out
     }
     return { ...out, ok: true, via: 'bundle', rowId: [...rows.keys()][0], bundlePatch: file }
   }
+  out.code = 'mount-no-row'
   out.reason = '用户补丁里没有它的 insert 行，dsh.profile.bundles 里也没有它 —— 重启后不会被挂载'
   return out
 }
 
+/**
+ * 0.5.84 判据降噪的**唯一判据**：这次不一致会不会让插件在重启后消失？
+ * 输入可以是一份 `persistReport()` 的结果（只看 `parts` / `missing`），也可以是裸的 `parts`。
+ * 返回 `{ level, losesAfterRestart, critical, downgraded, codes, note }`：
+ *   · `level: 'ok'`        三处齐备（不会多报红）
+ *   · `level: 'critical'`  至少一处会丢插件（清单里没有 / 挂不上）→ 面板必须报红
+ *   · `level: 'warn'`      只有口径不一致（lock 形态/目标、清单形态与磁盘不同）→ 降级成提示
+ * `note` 是**降级后**那句人话（critical 时与旧 persistNote 同一句，warn 时换软一点的措辞）；
+ * 旧的 `report.note` / `persisted` / `suggestedPersistAction` **一个字都没动**（安装闸门语义不变）。
+ */
+function persistSeverity(input) {
+  const parts = input !== null && typeof input === 'object' && input.parts !== undefined && input.parts !== null
+    ? input.parts
+    : (input !== null && typeof input === 'object' ? input : {})
+  const partsOf = {}
+  for (const key of PERSIST_PARTS) {
+    const part = parts[key]
+    partsOf[key] = part === undefined || part === null ? null : part
+  }
+  const openParts = PERSIST_PARTS.filter((key) => partsOf[key] !== null && partsOf[key].ok !== true)
+  const codes = {}
+  const critical = []
+  const downgraded = []
+  for (const key of openParts) {
+    const code = typeof partsOf[key].code === 'string' && partsOf[key].code !== '' ? partsOf[key].code : `${key}-unknown`
+    codes[key] = code
+    // 表里没有的码一律按 warn（保守方向：宁可少报红，也不拿红字打扰人）
+    if (isPersistCriticalCode(code)) critical.push(key)
+    else downgraded.push(key)
+  }
+  const losesAfterRestart = critical.length > 0
+  const level = openParts.length === 0 ? 'ok' : (losesAfterRestart ? 'critical' : 'warn')
+  const labels = { dependency: '① 清单 dependencies', lock: '② pnpm-lock.yaml', mount: '③ 挂载行（cordis.patch.yml / bundles）' }
+  let note = null
+  if (level === 'critical') {
+    const rows = critical.map((key) => `${labels[key]}：${(partsOf[key] && partsOf[key].reason) ?? PERSIST_CODE_TEXT[codes[key]] ?? '未就位'}`)
+    note = `未持久化（重启或任何一次 pnpm 操作后可能消失）—— ${rows.join('；')}`
+    if (downgraded.length > 0) {
+      note += `。另有 ${downgraded.length} 处口径不一致（不影响重启后加载）：${downgraded.map((key) => labels[key] + '：' + ((partsOf[key] && partsOf[key].reason) ?? '不一致')).join('；')}`
+    }
+  } else if (level === 'warn') {
+    const rows = downgraded.map((key) => `${labels[key]}：${(partsOf[key] && partsOf[key].reason) ?? '不一致'}`)
+    note = `口径不一致（**不影响重启后加载**，只是清单 / lock 没对齐，下次 pnpm 操作会自行收敛）—— ${rows.join('；')}`
+  }
+  return { level, losesAfterRestart, critical, downgraded, codes, note }
+}
+
 /**
  * 持久化判据（**只读**，永不抛）：返回
  * `{ persisted, packageName, missing, parts:{dependency,lock,mount}, note }`。
@@ -259,6 +372,9 @@ function persistReport({ profileDir, patchPath, packageName, entries = null, pat
     },
   }
   report.note = report.persisted ? null : persistNote(report)
+  // 0.5.84 加法：同一份事实多一档"要不要报红"的结论（判据见 persistSeverity 顶部）。
+  // 旧的 persisted / note 保持原样 —— 这里只多一个字段，老调用点（与安装闸门）一个字都不用改。
+  report.severity = persistSeverity(report)
   return report
 }
 
@@ -338,6 +454,11 @@ async function ensurePersisted({ profileDir, patchPath, packageName, mode = 'ins
           ...(typeof sourceSpec === 'string' && sourceSpec !== '' ? { sourceSpec, sourceOrigin, sourceKind } : {}),
           ...(typeof deps.installSource === 'function' ? { installSource: deps.installSource } : {}),
           ...(deps.syncLock === false ? { syncLock: false } : {}),
+          // ★ 0.5.87 加法（用户红线：正常下载安装/更新绝不能产出 link:/file:）：`registry-tarball` 是
+          // curl 通道从 registry 元数据里拿到 dist.tarball 并**校验摘要后**铺进去的 —— 这份物**证明**
+          // 该版本在 registry 上存在。于是探测说"查无此包/此版本"只能算探测失败，不能据此物化成 link:
+          // （详见 manifest.js#planDependencySpec 的 registryProven 分支）。其它来源一律不置位。
+          ...(sourceKind === 'registry-tarball' ? { registryProven: true } : {}),
         })
         if (declared.changed !== true) notes.push(`清单里已有这个包（实际是 ${declared.spec ?? disk.version}）`)
         if (declared.depNote !== null && declared.depNote !== undefined) notes.push(declared.depNote)
@@ -399,6 +520,8 @@ async function ensurePersisted({ profileDir, patchPath, packageName, mode = 'ins
     after.missing = PERSIST_PARTS.filter((key) => after.parts[key].ok !== true)
     after.persisted = after.missing.length === 0
     after.note = after.persisted ? null : persistNote(after)
+    // 0.5.84：这一档判据也改了 parts（lock → ok:false），降噪结论必须跟着重算，否则会拿旧的
+    after.severity = persistSeverity(after)
     lockVerdict = { verified: lock.lockVerified, reason }
   }
   // 0.5.41 接线：真装失败时写入层会下发「一键真装」动作 —— 它优先于"钉住"（此时用户要的是真装那一步）；
@@ -431,4 +554,6 @@ async function ensurePersisted({ profileDir, patchPath, packageName, mode = 'ins
 export {
   PERSIST_PARTS, EXACT_VERSION_RE, SOURCE_SPEC_RE, readManifestSync, readBundlesSync, diskFormOf,
   dependencyPart, lockPart, mountPart, persistReport, persistNote, suggestedPersistAction, ensurePersisted,
+  // 0.5.84 判据降噪：原因码表 + 唯一判据 + 判定函数（面板与测试都只认这一份）
+  PERSIST_CRITICAL_CODES, PERSIST_CRITICAL_MOUNT, PERSIST_CODE_TEXT, isPersistCriticalCode, persistSeverity,
 }

package/lib/server/domain/restart-launcher.js

@@ -0,0 +1,110 @@
+// L1 · domain —— restart-launcher.js（独立实例的**detached 重拉**：只起新进程，绝不动老进程；0.5.84 加法）
+// 分层分组：L1 · domain（不认识 cordis ctx；进程原语经 infra/egress.js 的 spawnDetached 出口）
+//
+// ── 为什么需要它（用户 2026-10 的第 5 项）────────────────────────────────────────
+//   「重启服务」过去在全仓是**一律拒绝**的：`restartPathDecision` 硬编码 spawns:false / kill:false。
+//   那条红线来自 2026-10-10 的真机事故 —— 但事故的成因是**桌面端托管**时自杀 + 与宿主争端口
+//   （详见 domain/restart.js 顶部取证）。**独立 `dsh web` 实例**没有那个问题：它自己就是那个进程，
+//   端口也归它；重启它只需要"起一个新进程 + 自己退出"。
+//   ⇒ 所以本模块只服务非 shell 托管的那一半，且只做两件事：
+//        ① 起一个 **detached** 的新实例（`node <bin.js> web [--port N]`）；
+//        ② 老进程**自己优雅退出**（不 kill 自己、不建计划任务、不自删）—— 端口随之释放。
+//
+// ── 端口竞态（必须处理，否则新实例必然 EADDRINUSE）────────────────────────────────
+//   父进程收到请求时端口还占着，而它要等响应发完才退出。所以新进程不能直接起 ——
+//   由本模块起一个**极小的中间启动器**（`node -e <script>`，无临时文件）：
+//        轮询 127.0.0.1:port，直到连接被拒绝（= 端口空了）再 spawn 真实例；
+//        最多等 30s，等不到就自己退出（绝不无限挂着一个轮询进程）。
+//   计划通过 `DSH_RELAUNCH_PLAN` 环境变量传给启动器（不走 argv —— `node -e` 下的 argv 位置不直观）。
+//
+// ── 红线（一条不减）────────────────────────────────────────────────────────────────
+//   · 不 kill 任何进程（包括自己）：`kill:false`、`scheduledTask:false`、`selfDelete:false`；
+//   · 只在 `host.hosted !== true` 时才会走到这里（判据在 domain/restart.js，唯一承担者）；
+//   · 进程原语只经 infra/egress.js 的 `spawnDetached` 出口 ⇒ 单测注入替身后"一次真进程都没起"
+//     是**可计数证明**的（tests/test-standalone-relaunch.mjs 就此断言）。
+import { spawnDetached } from '../infra/egress.js'
+
+/** 启动器最多等端口多久（毫秒）。 **有上限**：等不到就自己退出，不留悬挂轮询进程。 */
+const PORT_WAIT_DEADLINE_MS = 30000
+/** 轮询间隔（毫秒）。 */
+const PORT_POLL_MS = 250
+
+/**
+ * 启动器脚本（**纯文本**，单测可断言它只做"等端口 → 起新进程"）。
+ * 读 `DSH_RELAUNCH_PLAN`（JSON: { bin, args, cwd, port }）。
+ */
+function launcherScript() {
+  return [
+    "const net = require('node:net')",
+    "const { spawn } = require('node:child_process')",
+    "const plan = JSON.parse(process.env.DSH_RELAUNCH_PLAN || '{}')",
+    'const port = Number(plan.port) || 0',
+    'const deadline = Date.now() + Number(plan.deadlineMs) || 0',
+    'const poll = Number(plan.pollMs) || 250',
+    'const freeProbe = () => new Promise((resolve) => {',
+    "  const socket = net.connect({ host: '127.0.0.1', port: port })",
+    '  const settle = (free) => { try { socket.destroy() } catch { } ; resolve(free) }',
+    '  socket.setTimeout(1000, () => settle(false))',
+    '  socket.once(' + "'error'" + ', () => settle(true))',
+    '  socket.once(' + "'connect'" + ', () => settle(false))',
+    '})',
+    'const start = () => {',
+    '  const child = spawn(process.execPath, [plan.bin].concat(plan.args || []), { detached: true, stdio: ' + "'ignore'" + ', windowsHide: true, cwd: plan.cwd || undefined })',
+    '  child.unref()',
+    '  process.exit(0)',
+    '}',
+    'const tick = () => {',
+    '  if (Number.isFinite(deadline) && deadline > 0 && Date.now() > deadline) process.exit(1)',
+    '  freeProbe().then((free) => { if (free) start(); else setTimeout(tick, poll) })',
+    '}',
+    'tick()',
+  ].join('\n')
+}
+
+/**
+ * 规划一次 detached 重拉（**纯函数**）：argv 由调用方给（bin 路径由 routes 层按既有 `resolveDshBin` 解析）。
+ * @returns {{ ok: boolean, reason: string|null, plan: object|null }}
+ */
+function planRelaunch({ binPath, args = [], port = null, cwd = null } = {}) {
+  const bin = typeof binPath === 'string' ? binPath.trim() : ''
+  if (bin === '') return { ok: false, reason: '找不到 DSH 的入口（bin.js），无法自动重启 —— 请手动重启这个 dsh web 进程', plan: null }
+  const argv = (Array.isArray(args) ? args : []).filter((a) => typeof a === 'string')
+  const numericPort = Number.isFinite(port) && port > 0 ? Math.floor(port) : null
+  return {
+    ok: true,
+    reason: null,
+    plan: {
+      bin,
+      args: argv,
+      cwd: typeof cwd === 'string' && cwd !== '' ? cwd : null,
+      port: numericPort,
+      deadlineMs: PORT_WAIT_DEADLINE_MS,
+      pollMs: PORT_POLL_MS,
+    },
+  }
+}
+
+/**
+ * 真的起那个启动器（**detached + unref**，父进程退出后继续活）。
+ * `deps.spawn` 只为单测注入（生产走 infra/egress.js 的 spawnDetached 出口）。
+ * @returns {Promise<{ started: boolean, pid: number|null, error: string|null }>}
+ */
+async function relaunchDetached(plan, { spawn = spawnDetached, env = process.env } = {}) {
+  if (plan === null || typeof plan !== 'object' || typeof plan.bin !== 'string' || plan.bin === '') {
+    return { started: false, pid: null, error: '重拉计划无效（缺少 bin 路径），未起任何进程' }
+  }
+  if (typeof spawn !== 'function') return { started: false, pid: null, error: '进程出口不可用（spawnDetached 未接线）' }
+  const payload = JSON.stringify({ bin: plan.bin, args: plan.args ?? [], cwd: plan.cwd ?? null, port: plan.port ?? null, deadlineMs: plan.deadlineMs ?? PORT_WAIT_DEADLINE_MS, pollMs: plan.pollMs ?? PORT_POLL_MS })
+  try {
+    const out = await spawn(process.execPath, ['-e', launcherScript()], {
+      env: { ...env, DSH_RELAUNCH_PLAN: payload },
+      cwd: plan.cwd ?? undefined,
+      detached: true,
+    })
+    return { started: true, pid: out !== null && typeof out?.pid === 'number' ? out.pid : null, error: null }
+  } catch (error) {
+    return { started: false, pid: null, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export { PORT_POLL_MS, PORT_WAIT_DEADLINE_MS, launcherScript, planRelaunch, relaunchDetached }

package/lib/server/domain/restart.js

@@ -61,8 +61,14 @@ const STANDALONE_RESTART_NOTICE = 'DSH 没有可由插件调用的官方重启
 /** `/framework-relaunch`（原「手动拉起服务」悬浮按钮）：同一判据，另加"这条路已下线"的说明。 */
 const MANUAL_LAUNCH_REMOVED_NOTE = '「手动拉起服务」已按官方路径下线（控制台不再 spawn 新的 dsh 实例）：'
 
-/** 两条官方判定通道（稳定字符串，前端与测试按它判因）。 */
-const RESTART_CHANNEL = { desktopClient: 'desktop-client', unavailable: 'unavailable' }
+/** 两条官方判定通道（稳定字符串，前端与测试按它判因）。
+ *  0.5.84 加法：新增 `standaloneRelaunch` —— **只有独立实例**（非 shell 托管）才走这条真重启；
+ *  桌面端托管仍然走 desktop-client（拒绝 + 说明），那条一个字没动。 */
+const RESTART_CHANNEL = { desktopClient: 'desktop-client', standaloneRelaunch: 'standalone-relaunch', unavailable: 'unavailable' }
+
+/** 独立实例真的重启成功后的文案（**先起新进程、老进程自己优雅退出**）。 */
+const STANDALONE_RELAUNCH_NOTICE = '正在重启：已 detached 拉起一个新的 dsh web 进程，本进程即将优雅退出（不 kill 任何进程、不建计划任务）；'
+  + '新实例会等端口释放后启动，稍等几秒刷新页面即可。'
 
 /** 面向用户的出路（结构化下发，前端可原样展示；桌面端与独立实例各自一条真出路）。 */
 const GUIDES = {
@@ -71,6 +77,11 @@ const GUIDES = {
     '已弹出「应用无法启动或已意外停止」时：直接点弹窗里的「重启」（官方恢复对话框）。',
     '只是想让插件改动生效：按 DSH 官方语义"下次启动生效"（restart-required），刷新页面即可看到已生效的部分。',
   ],
+  'standalone-relaunch': [
+    '新实例会在老进程退出、端口释放后自动启动（启动器最多等 30 秒）。',
+    '若几秒后页面仍然连不上：回到启动它的终端看输出，必要时手动运行 dsh web。',
+    '控制台绝不会 kill 进程、绝不建计划任务：失败时如实告知，不制造幽灵实例。',
+  ],
   unavailable: [
     '独立 dsh web：在启动它的终端里 Ctrl+C，然后重新运行 dsh web。',
     '只改了客户端插件：DSH 官方语义是"下次启动生效"（restart-required），直接刷新页面。',
@@ -85,17 +96,80 @@ const GUIDES = {
  * @param {boolean} p.hosted  是否由桌面端外壳托管（调用方用 domain/framework.js#detectHostShape 判定后传入；
  *                            本函数不重复判定，保证与 shellHostedRefusal 同一份事实）
  * @param {'restart'|'relaunch'} [p.intent]  控制台里的哪颗按钮（只影响文案前缀，判定完全相同）
- * @returns {{ ok: false, official: boolean, channel: string, spawns: false, kill: false,
+ * @param {object|null} [p.relaunch]  **独立实例**的重拉计划（domain/restart-launcher.js#planRelaunch 的产物）。
+ *                            给了且 ok ⇒ 走 standalone-relaunch（真起一个 detached 新进程）；
+ *                            没给 / 不 ok ⇒ 回落 unavailable（如实告知手动重启）。
+ *                            ⚠️ 桌面端托管时本参数**被忽略**：那条路永远不 spawn（用户红线）。
+ * @returns {{ ok: boolean, official: boolean, channel: string, spawns: boolean, kill: false,
  *             status: number, code: string, message: string, details: object }}
  */
-function restartPathDecision({ hosted, intent = 'restart' } = {}) {
+function restartPathDecision({ hosted, intent = 'restart', relaunch = null } = {}) {
   const shellHosted = hosted === true
-  const channel = shellHosted ? RESTART_CHANNEL.desktopClient : RESTART_CHANNEL.unavailable
-  const base = shellHosted ? DESKTOP_CLIENT_RESTART_NOTICE : STANDALONE_RESTART_NOTICE
+  // ★ 桌面端托管：判据与文案与 2026-10-10 那次改错**逐字一致**（不接受任何 relaunch 计划）
+  if (shellHosted) {
+    const channel = RESTART_CHANNEL.desktopClient
+    const message = intent === 'relaunch' ? MANUAL_LAUNCH_REMOVED_NOTE + DESKTOP_CLIENT_RESTART_NOTICE : DESKTOP_CLIENT_RESTART_NOTICE
+    return {
+      ok: false,
+      official: true,
+      channel,
+      spawns: false,
+      kill: false,
+      status: 409,
+      code: `official-restart-${channel}`,
+      message,
+      details: {
+        code: `official-restart-${channel}`,
+        official: true,
+        channel,
+        // 机器可读的红线判据：桌面端托管时这三项永远是 false（测试的负控就钉在这里）
+        spawns: false,
+        kill: false,
+        scheduledTask: false,
+        selfDelete: false,
+        manualLaunch: intent === 'relaunch' ? 'removed' : 'never',
+        guide: GUIDES[channel],
+      },
+    }
+  }
+  // ★ 独立实例 + 有可用重拉计划 ⇒ **真重启**：起一个新进程，老进程自己优雅退出。
+  //   仍然不 kill / 不建计划任务 / 不自删 —— 用户那次事故的根因是"自杀 + 争端口"，
+  //   而独立实例既不需要自杀（它自己退出就行），也不存在争端口（启动器等端口空了才起新实例）。
+  const plan = relaunch !== null && typeof relaunch === 'object' && relaunch.ok === true ? relaunch.plan ?? null : null
+  if (plan !== null && typeof plan === 'object' && typeof plan.bin === 'string' && plan.bin !== '') {
+    const channel = RESTART_CHANNEL.standaloneRelaunch
+    return {
+      ok: true,
+      official: false,
+      channel,
+      spawns: true,
+      kill: false,
+      status: 200,
+      code: channel,
+      message: STANDALONE_RELAUNCH_NOTICE,
+      details: {
+        code: channel,
+        official: false,
+        channel,
+        spawns: true,
+        kill: false,
+        scheduledTask: false,
+        selfDelete: false,
+        detached: true,
+        gracefulExit: true,
+        manualLaunch: intent === 'relaunch' ? 'removed' : 'never',
+        plan: { bin: plan.bin, args: Array.isArray(plan.args) ? plan.args : [], port: plan.port ?? null, cwd: plan.cwd ?? null },
+        guide: GUIDES[channel],
+      },
+    }
+  }
+  // ★ 独立实例但拿不到重拉计划（例如找不到 bin.js）⇒ 与旧行为一致：如实告知手动重启
+  const channel = RESTART_CHANNEL.unavailable
+  const base = typeof relaunch?.reason === 'string' && relaunch.reason !== '' ? `${relaunch.reason}。${STANDALONE_RESTART_NOTICE}` : STANDALONE_RESTART_NOTICE
   const message = intent === 'relaunch' ? MANUAL_LAUNCH_REMOVED_NOTE + base : base
   return {
     ok: false,
-    official: shellHosted,
+    official: false,
     channel,
     spawns: false,
     kill: false,
@@ -104,9 +178,9 @@ function restartPathDecision({ hosted, intent = 'restart' } = {}) {
     message,
     details: {
       code: `official-restart-${channel}`,
-      official: shellHosted,
+      official: false,
       channel,
-      // 机器可读的红线判据：这两项永远是 false（测试的负控就钉在这里）
+      // 机器可读的红线判据：这三项永远是 false
       spawns: false,
       kill: false,
       scheduledTask: false,
@@ -117,4 +191,4 @@ function restartPathDecision({ hosted, intent = 'restart' } = {}) {
   }
 }
 
-export { DESKTOP_CLIENT_RESTART_NOTICE, MANUAL_LAUNCH_REMOVED_NOTE, RESTART_CHANNEL, STANDALONE_RESTART_NOTICE, restartPathDecision }
+export { DESKTOP_CLIENT_RESTART_NOTICE, MANUAL_LAUNCH_REMOVED_NOTE, RESTART_CHANNEL, STANDALONE_RELAUNCH_NOTICE, STANDALONE_RESTART_NOTICE, restartPathDecision }

package/lib/server/domain/selfupdate.js

@@ -511,7 +511,12 @@ async function reconcileLockfile({ profileDir, packageName = null, packages = nu
       suggestedActions.push(suggestedPinAction({ packageName: item.name, version: item.installed, profileDir, reason: why }))
       continue
     }
-    if (actual === item.spec) {
+    // ★ 0.5.87 改错（真机 E2E 2026-10-18 复现）：这条路的计划是 **`name@版本`**（给 pnpm add 用的
+    //   完整规格），而清单 `dependencies` 里存的是**版本号那一段**。旧代码拿整串去比 ⇒ 明明已经写对
+    //   （清单 = lock = 最新版）也一律报「写回**未生效**，请执行「钉住」动作」，还顺手挂上一个 pin 动作。
+    //   表现：更新成功、`persisted: true`，面板却同时说"没写进去"。这里只比**要写进清单的那一段**。
+    const wantedInManifest = item.spec.startsWith(`${item.name}@`) ? item.spec.slice(item.name.length + 1) : item.spec
+    if (actual === wantedInManifest) {
       if (item.spec.startsWith('link:') && item.reason !== null) {
         depNotes.push(`${item.name}：${item.reason}，已按源码安装（本地物化）记录依赖（${actual}）—— 不经 npm registry 解析、不经 tarball 完整性校验，pnpm 重建 lock 也能装上`)
       }

package/lib/server/domain/skills.js

@@ -13,17 +13,21 @@ import { dshHome } from '../infra/paths.js'
 /** 探测仓库是否为技能仓库：根目录或第一层子目录存在 SKILL.md。
  * 返回 { hasSkill, skillDir }（skillDir 为相对仓库根的目录，'' 表示根）。
  * raw 双通道竞速，3 秒封顶，失败静默。 */
-async function detectSkillRepo(repo, branch = 'main') {
+async function detectSkillRepo(repo, branch = 'main', deps = {}) {
+  // deps 只为**富化路径**（domain/market.js）注入限流出口而加；生产的老调用点都不传，
+  // 于是回落值与改动前逐字相同（curlText / curlJson）。
+  const fetchText = typeof deps.curlText === 'function' ? deps.curlText : curlText
+  const fetchJson = typeof deps.curlJson === 'function' ? deps.curlJson : curlJson
   const branchEnc = encodeURIComponent(branch)
   try {
     const root = await Promise.any([
-      curlText(`${GITHUB_RAW}/${repo}/${branchEnc}/SKILL.md`, 3000),
-      curlText(`https://ghproxy.net/${GITHUB_RAW}/${repo}/${branchEnc}/SKILL.md`, 3000),
-      curlText(`https://cdn.jsdelivr.net/gh/${repo}@${branchEnc}/SKILL.md`, 3000),
+      fetchText(`${GITHUB_RAW}/${repo}/${branchEnc}/SKILL.md`, 3000),
+      fetchText(`https://ghproxy.net/${GITHUB_RAW}/${repo}/${branchEnc}/SKILL.md`, 3000),
+      fetchText(`https://cdn.jsdelivr.net/gh/${repo}@${branchEnc}/SKILL.md`, 3000),
     ]).catch(() => null)
     if (root !== null) return { hasSkill: true, skillDir: '' }
     // 根没有时再查一层子目录（常用布局：skills/<name>/SKILL.md、<name>/SKILL.md）
-    const tree = await curlJson(`https://api.github.com/repos/${repo}/git/trees/${branchEnc}?recursive=1`, 5000).catch(() => null)
+    const tree = await fetchJson(`https://api.github.com/repos/${repo}/git/trees/${branchEnc}?recursive=1`, 5000).catch(() => null)
     const skillPaths = (tree?.tree ?? [])
       .filter((n) => n.type === 'blob' && /(?:^|\/)SKILL\.md$/u.test(n.path))
       .map((n) => n.path)