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

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
 }
 
@@ -399,6 +515,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 +549,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/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)

package/lib/server/infra/egress.js

@@ -23,7 +23,7 @@
 //
 // 分层：L0 · infra（不得 import domain/routes/index —— tests/test-architecture-guard.mjs 断言②）。
 
-import { execFile as nodeExecFile } from 'node:child_process'
+import { execFile as nodeExecFile, spawn as nodeSpawn } from 'node:child_process'
 import { request as nodeHttpsRequest } from 'node:https'
 import { promisify } from 'node:util'
 
@@ -202,7 +202,40 @@ function egressHttpsRequestOnce(url, options) {
   return nodeHttpsRequest(url, options)
 }
 
+// ── 0.5.84 加法：detached 拉起（独立实例的"真重启"）──────────────────────────────
+// 为什么放在这里而不是 domain/restart-launcher.js 里直接 spawn：
+//   全仓的规矩是「进程原语只有 egress.js 认识」（tests/test-repo-manifest-channels.mjs ★⑨ 静态断言）。
+//   于是新增的 detached spawn 也必须是这一层的**可注入出口**：单测 `__setEgressStub({ spawnDetached })`
+//   之后，"一次真进程都没起"能被计数证明，而不是靠读代码相信。
+// 语义：**只起一个新进程，绝不动老进程**（不 kill、不自杀、不建计划任务）——
+//   调用方（routes/framework.js）负责"先回响应、再自己优雅退出"，把端口让给新实例。
+function egressSpawnDetachedReal(command, args = [], options = {}) {
+  const child = nodeSpawn(command, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    cwd: typeof options.cwd === 'string' && options.cwd !== '' ? options.cwd : undefined,
+    env: options.env !== undefined && options.env !== null ? options.env : process.env,
+  })
+  // 脱离父进程：父进程退出后子进程继续跑（这是"重启"能成立的前提）
+  child.unref()
+  return { pid: typeof child.pid === 'number' ? child.pid : null, detached: true }
+}
+/** 出口包装：stub 优先 → 记一笔 spawn → **真实现登记表**（不直接给 fallback！）。
+ *  为什么不给 fallback：给了就绕过了下面的 `unwired()` —— tripwire 与 gaps 全部失效，
+ *  测试进程里会**真的**起一个 detached 进程（写这条时实测踩到：给 fallback 的那版在单测里真 spawn 了）。
+ *  所以按本仓既有形态：真实现登记进 realImpl，出口只查表。 */
+const spawnDetached = makeEgress('spawnDetached', 'spawn')
+__setEgressRealImpl({ spawnDetached: egressSpawnDetachedReal })
+
+// 0.5.84 加法：把「本进程是测试进程」这一条判据**导出**（原本只在本文件内用）。
+//   用途：domain/lock-autofix.js 的**后台自动对账**在测试进程里一律不启动 ——
+//   它会真的跑 pnpm 并重写 fixture 的 pnpm-lock.yaml，而多套测试对"lock 是否被写过"有断言。
+//   判据只有这一份（看 process.argv[1] 是不是 tests/**），测试无法自己解开它。
+//   （注：本段说明放在 export 块**外面** —— 架构守卫 ⑥ 的导出名解析不跳过块内注释。）
 export {
   __setEgressStub, __setEgressTripwire, __setEgressRealImpl, __resetEgressStats, egressStatsNow,
   makeEgress, egressHttpsRequestOnce, egressSelfCheckSpawn, egressSelfCheckNetwork,
+  spawnDetached,
+  isTestProcess,
 }

package/lib/server/routes/disk.js

@@ -0,0 +1,59 @@
+// L2 · routes —— `<DSH_HOME>/plugin-console` 的**磁盘体检 / 清理**（0.5.84 加法，用户第 7 项）
+//   GET  /plugin-console/disk-audit    只读体检：谁占了多少、哪些可以清、哪些绝不能动
+//   POST /plugin-console/disk-cleanup  **必须显式确认**（confirm:true）才删；未确认只回计划
+//
+// 用户原话（大意）：这个目录已经 2.1 GB（framework-backups 含全平台 libreoffice），
+// 要一个"只读体检 + 显式确认后清理"的能力，**绝不自动删除**。
+//
+// 安全语义（写死，判据全在 domain/disk-audit.js）：
+//   · audit 只统计，不删不写；
+//   · cleanup 只认体检结果里出现过的条目名（拒绝路径穿越），且 protected（当前回滚点 /
+//     控制台状态文件 / 未知条目）一律拒绝并说明原因；
+//   · 删完**读回核实**，没删干净如实回报（Windows 上 rmSync 会静默落空，本仓 fsx.js 记过）。
+//
+// 真机实测（2026-10）：最大的那 2.1 GB 是 `framework-backups/0.2.0-rc.1`，而它**正是**
+// `framework-rollback.json` 的 checkpointDir ⇒ 判据从回滚记录里读，绝不按体积猜"大的就可以删"。
+
+import { auditConsoleDir, runCleanup } from '../domain/disk-audit.js'
+import { sendError, sendJson } from '../infra/httpd.js'
+import { dshHome } from '../infra/paths.js'
+import { join } from 'node:path'
+
+/** 体检/清理的唯一根目录（绝不接受调用方传路径 —— 那等于开了一个任意路径删除的口子）。 */
+function consoleDir() {
+  return join(dshHome(), 'plugin-console')
+}
+
+async function routeDiskAudit(req, res, rc) {
+  const audit = auditConsoleDir({ root: consoleDir(), deps: rc.deps?.diskAuditDeps ?? {} })
+  if (audit.ok !== true) {
+    sendError(res, 500, `磁盘体检失败：${audit.error ?? '未知原因'}`, { ok: false, entries: [] })
+    return
+  }
+  sendJson(res, 200, audit)
+}
+
+async function routeDiskCleanup(req, res, rc) {
+  const body = rc.body ?? {}
+  const ids = Array.isArray(body.ids) ? body.ids : (typeof body.ids === 'string' ? [body.ids] : [])
+  const root = consoleDir()
+  // 每次都**重新体检**（不信任客户端回传的体积/分级 —— 那等于让调用方决定删什么）
+  const audit = auditConsoleDir({ root, deps: rc.deps?.diskAuditDeps ?? {} })
+  if (audit.ok !== true) {
+    sendError(res, 500, `磁盘体检失败：${audit.error ?? '未知原因'}`, { ok: false })
+    return
+  }
+  const result = runCleanup({ root, audit, ids, confirm: body.confirm === true, deps: rc.deps?.diskCleanupDeps ?? {} })
+  if (result.needsConfirm === true) {
+    // 未确认：200 + 计划（不是错误 —— 面板要用这份计划渲染「确认清理」按钮与体积）
+    sendJson(res, 200, { ok: true, needsConfirm: true, applied: false, plan: result.plan, note: result.note })
+    return
+  }
+  if (result.plan?.refused?.length > 0 && result.removed?.length === 0) {
+    sendError(res, 400, `没有可以清理的条目：${result.plan.refused.map((r) => `${r.id}（${r.reason}）`).join('；')}`, { ok: false, applied: false, refused: result.plan.refused })
+    return
+  }
+  sendJson(res, 200, result)
+}
+
+export { routeDiskAudit, routeDiskCleanup }