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

package/lib/server/domain/unpin-dev-dir.js

@@ -0,0 +1,149 @@
+// L1 · domain —— 取消钉住：把 profile 清单里那条 `link:` / `file:` 依赖摘掉（0.5.87 加法）
+//
+// 为什么需要（用户 2026-10-18 的原话）：link 面板过去**只能看不能改** —— 看到"这一条钉着本地目录"
+//   却没有任何办法退回去。钉住有入口（/pin-dev-dir），退出没有。
+//
+// 语义词边界（与 `routes/revoke-force.js` 同一套"窄动作"纪律，**照抄它的安全语义**）：
+//   · 只对**清单里真写着 `link:`/`file:` 的那一条**生效 —— 不是这种来源就一律拒（不猜、不代劳）；
+//   · 两段式：`planUnpinDevDir` 纯只读先给"将要发生什么"，`applyUnpinDevDir` 才会动手；
+//   · 动手时**先备份清单**，pnpm 报成功但**读回**发现清单里还有它 ⇒ 回滚并如实报错（绝不谎报）；
+//   · **只摘依赖**：不删开发目录、不删我们造过的 peer 垫片、不碰 dsh.profile.bundles 之外的东西。
+//     它若还在 `dsh.profile.bundles` 里，撤销后框架会跳过那个 bundle —— 这是**必说的后果**，
+//     由 plan.warnings 与 apply.note 明说，而不是替用户顺手改 bundles（那属于「卸载」的语义）。
+//
+// 为什么**不自己写清单**：`pnpm remove` 一个动作同时负责清单 / pnpm-lock.yaml / node_modules 三处；
+//   我们若先删清单再调 pnpm，失败时就是"清单没了、锁没动、链接还在"的半截状态。
+//   所以：备份 → 交给 pnpm → **读回三处**如实汇报。pnpm 是墙钟动作，执行器可注入（离线测试用）。
+//
+// 分层：L1 domain —— 收已解开的 profileDir；不认 ctx。
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { NPM_NAME_RE, canonicalSourceSpec, sourceSpecTarget } from './dep-source.js'
+import { pnpmRemove } from './install-cleanup.js'
+import { readBundlesSync } from './persist.js'
+import { lockVersion } from './selfupdate.js'
+
+/** 路径型来源（`link:` / `file:`）—— 只有这一族谈得上"钉住 / 取消钉住"。 */
+const PATH_SPEC_RE = /^(?:link:|file:)/u
+
+const readJsonSafe = (file) => {
+  try { return JSON.parse(readFileSync(file, 'utf8')) } catch { return null }
+}
+
+/** `node_modules/<包名>` 的路径（不判断存在性）。 */
+function nodeModulesPathOf(profileDir, packageName) {
+  return join(profileDir, 'node_modules', ...String(packageName).split('/'))
+}
+
+/** 清单里该依赖当前的 spec（没有就 null）。 */
+function manifestDepSpec(profileDir, packageName) {
+  const deps = readJsonSafe(join(profileDir, 'package.json'))?.dependencies
+  if (deps === null || typeof deps !== 'object') return null
+  const spec = deps[packageName]
+  return typeof spec === 'string' && spec !== '' ? spec : null
+}
+
+/**
+ * 规划一次取消钉住（**纯只读**，不写盘、不 spawn）。
+ *
+ * @param {object} p
+ * @param {string} p.profileDir profile 根目录
+ * @param {string} p.packageName 要取消钉住的包名
+ * @returns {{ ok: boolean, status: number, error: string|null, packageName: string, spec: string|null,
+ *             target: string|null, targetExists: boolean, inBundles: boolean, bundles: string[],
+ *             warnings: string[], steps: string[] }}
+ */
+function planUnpinDevDir({ profileDir, packageName } = {}) {
+  const base = {
+    ok: false, status: 400, error: null, packageName: typeof packageName === 'string' ? packageName : '',
+    spec: null, target: null, targetExists: false, inBundles: false, bundles: [], warnings: [], steps: [],
+  }
+  if (typeof profileDir !== 'string' || profileDir === '') return { ...base, error: '拿不到 profile 目录，拒绝改动' }
+  if (typeof packageName !== 'string' || !NPM_NAME_RE.test(packageName)) return { ...base, error: '包名无效' }
+  const spec = manifestDepSpec(profileDir, packageName)
+  if (spec === null) return { ...base, error: `${packageName} 不在 profile 清单的 dependencies 里 —— 没有可取消的钉住` }
+  const canonical = canonicalSourceSpec(spec)
+  if (typeof canonical !== 'string' || !PATH_SPEC_RE.test(canonical)) {
+    return { ...base, spec, error: `${packageName} 的来源是 ${spec}，不是 link:/file: —— 它本来就没被钉到本地目录，无需取消钉住` }
+  }
+  const target = sourceSpecTarget(profileDir, canonical)
+  const targetExists = target !== null && existsSync(target)
+  let bundles = []
+  try { bundles = readBundlesSync(profileDir) } catch { bundles = [] }
+  const inBundles = bundles.includes(packageName)
+  const warnings = inBundles
+    ? [`它仍在 dsh.profile.bundles 里：取消钉住后这个 bundle 会解析不到（重启后被框架跳过、插件不可用）。要连 bundle 一起去掉请用「卸载」；只想换回发行版请重新安装它。`]
+    : []
+  if (target !== null && !targetExists) {
+    warnings.push(`目标目录已经不在了（${target}）—— 这一条是"指向不存在目录的陈旧链接"，取消它只是清理，不会有任何功能损失。`)
+  }
+  const steps = [
+    `备份 profile 清单（package.json.bak-unpin-<时间戳>）`,
+    `执行 pnpm remove ${packageName}（同时清掉 pnpm-lock.yaml 条目与 node_modules 里的链接）`,
+    target === null ? '读回核对：清单 / lock / node_modules 三处都不再有它' : `读回核对：清单 / lock / node_modules 三处都不再有它（目标目录 ${target} 不会被删）`,
+  ]
+  return { ...base, ok: true, status: 200, spec, target, targetExists, inBundles, bundles, warnings, steps }
+}
+
+/** 把清单写回改动前（回滚用；失败只返回 false，绝不抛）。 */
+function restoreManifest(manifestPath, text) {
+  try { writeFileSync(manifestPath, text, 'utf8'); return true } catch { return false }
+}
+
+/**
+ * 执行取消钉住。**失败即回滚清单**，并如实汇报三处（清单 / lock / node_modules）的真实状态。
+ *
+ * @param {object} p
+ * @param {string} p.profileDir profile 根目录
+ * @param {string} p.packageName 要取消钉住的包名
+ * @param {(args: { profileDir: string, packageName: string }) => Promise<void>} [p.runRemove]
+ *        注入的移除执行器（离线测试用）；缺省走真实 pnpm remove。
+ */
+async function applyUnpinDevDir({ profileDir, packageName, runRemove = null } = {}) {
+  const plan = planUnpinDevDir({ profileDir, packageName })
+  if (plan.ok !== true) return { ...plan, changed: false, backup: null, removed: null }
+  const manifestPath = join(profileDir, 'package.json')
+  const before = readFileSync(manifestPath, 'utf8')
+  const backup = `${manifestPath}.bak-unpin-${Date.now()}`
+  try { writeFileSync(backup, before, 'utf8') } catch {}
+  const failed = (reason, restored) => ({
+    ...plan, ok: false, status: 500, changed: false, backup, removed: null,
+    error: `${reason}\n（清单${restored ? '已回滚到改动前' : '**回滚失败**，请手动检查'}，backup: ${backup}）`,
+  })
+  // ① 备份 → ② 交给 pnpm（清单 / lock / node_modules 由同一个动作负责）
+  try {
+    if (typeof runRemove === 'function') await runRemove({ profileDir, packageName })
+    else await pnpmRemove(profileDir, packageName)
+  } catch (error) {
+    const restored = restoreManifest(manifestPath, before)
+    return failed(`pnpm remove 失败：${error instanceof Error ? error.message : String(error)}`, restored)
+  }
+  // ③ 读回三处（不读回就报成功 = 谎报）
+  const afterSpec = manifestDepSpec(profileDir, plan.packageName)
+  const manifestCleared = afterSpec === null
+  const nodeModulesCleared = !existsSync(nodeModulesPathOf(profileDir, plan.packageName))
+  let lockCleared = false
+  try { lockCleared = lockVersion(profileDir, plan.packageName) === null } catch { lockCleared = false }
+  if (!manifestCleared) {
+    const restored = restoreManifest(manifestPath, before)
+    return failed(`pnpm 报告成功，但读回发现清单里仍有 ${plan.packageName}（实际 ${JSON.stringify(afterSpec)}）`, restored)
+  }
+  const note = [
+    `已从 profile 清单移除 ${plan.packageName}（原来源 ${plan.spec}）`,
+    `pnpm-lock.yaml 条目${lockCleared ? '已清除' : '仍在（lock 没跟上这一步，下一次 pnpm 操作会重算）'}`,
+    `node_modules 里的链接${nodeModulesCleared ? '已清除' : '仍在（pnpm 没清掉它，重启后它可能仍被解析到）'}`,
+    '开发目录与代码未被删除',
+    ...plan.warnings,
+  ].join('；')
+  return {
+    ...plan,
+    ok: true,
+    status: 200,
+    changed: true,
+    backup,
+    removed: { manifest: manifestCleared, lock: lockCleared, nodeModules: nodeModulesCleared },
+    note,
+  }
+}
+
+export { PATH_SPEC_RE, manifestDepSpec, nodeModulesPathOf, planUnpinDevDir, applyUnpinDevDir }

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 }

package/lib/server/routes/framework.js

@@ -10,6 +10,9 @@ import { createRequire } from 'node:module'
 import { readCompatGate, writeCompatGate } from '../domain/compat.js'
 import { cleanupStaleFwTasks, currentFrameworkVersion, detectHostShape, pickFrameworkTarget, platformUpgradeRefusal, relaunchPrelude, resolveDshBin, shellHostedRefusal } from '../domain/framework.js'
 import { restartPathDecision } from '../domain/restart.js'
+// 0.5.84 加法（用户第 5 项）：独立实例的 detached 重拉 —— 计划在 domain/restart-launcher.js，
+// 进程原语仍走 infra/egress.js 的可注入出口（单测能证明"一次真进程都没起"）。
+import { planRelaunch, relaunchDetached } from '../domain/restart-launcher.js'
 import { readGithubAuth } from '../domain/install.js'
 import { webPort } from '../domain/runtime.js'
 import { fetchJsonUrl } from '../infra/http.js'
@@ -45,6 +48,31 @@ function hostedHere(rc) {
   return rc.deps?.hosted ?? detectHostShape().hosted === true
 }
 
+/** 解析 DSH 的 bin.js（**失败不抛**）：拿不到就返回 null，判据据此回落"手动重启"。 */
+function resolveDshBinSafe() {
+  try {
+    return resolveDshBin()
+  } catch {
+    return null
+  }
+}
+
+/** 本实例真实监听的端口（自定义 --port / 系统分配也对；拿不到返回 null）。 */
+function webPortHard(rc) {
+  try {
+    return webPort(rc.ctx)
+  } catch {
+    return null
+  }
+}
+
+/** 优雅退出的默认实现：回完响应后结束本进程（**不 kill 任何进程**，端口随进程结束而释放）。 */
+function defaultGracefulExit(delayMs) {
+  const timer = setTimeout(() => { process.exit(0) }, Math.max(0, Number(delayMs) || 0))
+  // 不阻止进程退出：这个定时器只是"晚一点退"，不是"必须跑完"
+  if (typeof timer?.unref === 'function') timer.unref()
+}
+
 /**
  * 平台守卫（2026-09-29 改错，与宿主守卫同形）：一键升级/回滚脚本整体依赖 Windows 机制 ——
  * `schtasks.exe` 计划任务 + PowerShell + `Get-NetTCPConnection`；非 Windows 上 execFile 必然 ENOENT，
@@ -454,8 +482,41 @@ async function routeRestart(req, res, rc) {
     //
     // 注：清僵尸计划任务的既有能力**保留**（cleanupStaleFwTasks 见 lib/index.js 接线），
     // 只是控制台自己再也不新建这类任务了。
-    const decision = restartPathDecision({ hosted: hostedHere(rc), intent: 'restart' })
-    sendError(res, decision.status, decision.message, decision.details)
+    //
+    // ★ 0.5.84（用户第 5 项，**只在非 shell 托管时**）：独立 dsh web 实例现在支持**真重启** ——
+    //   detach 起一个新实例，老进程自己优雅退出。桌面端托管时判据照旧拒绝（那一半一个字没动）。
+    //   判据仍在 domain/restart.js（唯一承担者）；这里只做三件事，顺序是刻意的：
+    //     ① 先算重拉计划（拿不到 bin.js 就如实回落"手动重启"，不硬来）；
+    //     ② 起启动器（detached，它自己等端口空了再起新实例 —— 于是没有 EADDRINUSE 竞态）；
+    //     ③ **先回响应**，再让本进程退出（不 kill 自己、不建计划任务）。
+    const hosted = hostedHere(rc)
+    // `rc.deps.relaunch` 是单测的确定性注入口（与 rc.deps.hosted 同一风格）：
+    // 传 `null` = 模拟"拿不到 bin.js"；不传 = 按真实解析（resolveDshBin + webPort）算。
+    const relaunchPlan = hosted === true ? null : (rc.deps?.relaunch !== undefined ? rc.deps.relaunch : planRelaunch({
+      binPath: resolveDshBinSafe(),
+      // 与真机那条原始命令同形：`node <bin.js> web`；端口显式带上（自定义 --port 也能原样重启）
+      args: (() => { const p = webPortHard(rc); return p === null ? ['web'] : ['web', '--port', String(p)] })(),
+      port: webPortHard(rc),
+      cwd: null,
+    }))
+    const decision = restartPathDecision({ hosted, intent: 'restart', relaunch: relaunchPlan })
+    if (decision.spawns !== true) {
+      sendError(res, decision.status, decision.message, decision.details)
+      return
+    }
+    const kicked = await relaunchDetached(relaunchPlan.plan, { spawn: rc.deps?.spawnDetached })
+    if (kicked.started !== true) {
+      // 起不来就**如实说**，绝不让面板以为"重启了"（也不会退出本进程——那样用户就真的没有实例了）
+      sendError(res, 500, `重启失败：没能拉起新进程（${kicked.error ?? '原因未知'}）。本进程仍在运行，请手动重启。`, {
+        code: 'standalone-relaunch-failed', channel: decision.channel, spawns: false, kill: false, scheduledTask: false, selfDelete: false,
+      })
+      return
+    }
+    sendJson(res, 200, { ok: true, restarted: true, channel: decision.channel, pid: kicked.pid, message: decision.message, details: decision.details })
+    // ★ 先回响应、再退（"优雅退出"）：让端口随本进程结束而释放；启动器在那之后才起新实例。
+    //   延时是给响应刷出去的时间；delayedExit 可注入（单测绝不真的退出进程）。
+    const exit = typeof rc.deps?.delayedExit === 'function' ? rc.deps.delayedExit : defaultGracefulExit
+    exit(500)
     return
 }
 

package/lib/server/routes/index.js

@@ -20,6 +20,8 @@ import { routeCompatAck, routeCompatMode, routeCompatStamp, routeCompatStatusGet
 import { routeSafeBoot } from './safe-boot.js'
 import { routePatchAuditGet } from './patch-audit.js'
 import { routePresetAuditGet } from './preset-audit.js'
+// 0.5.84 加法（用户第 7 项）：<DSH_HOME>/plugin-console 的磁盘体检（只读）与**确认后**清理
+import { routeDiskAudit, routeDiskCleanup } from './disk.js'
 import { routeFrameworkUpgrade } from './framework-upgrade.js'
 import { routeFrameworkPreflight, routeFrameworkPreflightPatch } from './framework-preflight.js'
 import { routeCheckUpdate, routeCompatGate, routeFrameworkCheck, routeFrameworkRelaunch, routeFrameworkRollback, routeFrameworkStatusClear, routeFrameworkUpgradeStatusGet, routeRestart } from './framework.js'
@@ -32,6 +34,8 @@ import { routeAdaptUnlock, routeAdaptUnlockAll, routeCleanResiduals, routeSelfUp
 import { routeSkillRemove, routeSkillToggle, routeSkillsInstalledGet } from './skills.js'
 import { routeGiteeOauthCallbackGet, routeGiteeOauthUrlGet, routeRegistryScan, routeSources, routeSourcesGet } from './sources.js'
 import { routeCompatExempt, routeDetails, routeDevRoots, routeLinksGet, routePinDevDir, routeStateGet } from './state.js'
+// 0.5.87 加法：link 面板的写动作（补依赖/垫片 + 取消钉住）—— 判据在 domain 层，这里只做白名单与回包
+import { routeLinkRepair, routeUnpinDevDir } from './link-actions.js'
 
 const ROUTE_PREFIX = '/plugin-console'
 
@@ -41,9 +45,10 @@ const ROUTES_EARLY = [
   { methods: ['GET'], path: `${ROUTE_PREFIX}/links`, handler: routeLinksGet },
   // 兼容豁免（0.5.56 加法）：把"被跳过的 bundle"的三条出路之一做成真正可点的动作
   { methods: ['POST'], path: `${ROUTE_PREFIX}/compat-exempt`, handler: routeCompatExempt },
-  // 开发区根 + 钉住（0.5.57 加法）：允许注册自己的根；不允许任意目录；agent 发起需用户勾选（默认关）
-  { methods: ['POST'], path: `${ROUTE_PREFIX}/dev-roots`, handler: routeDevRoots },
-  { methods: ['POST'], path: `${ROUTE_PREFIX}/pin-dev-dir`, handler: routePinDevDir },
+  // ★ 2026-10-18 改错（0.5.87）：`dev-roots` / `pin-dev-dir` 原来登记在这张表里，而这张表的 handler
+  //   **收不到 body**（`handle()` 在 earlyHit 分支里只传 ctx/url/pathname/method/deps，readBody 在它之后）。
+  //   真机后果：面板点「钉住」永远得到 `{"ok":false,"error":"没有提供目录"}`，注册开发区根也永远走 list 分支
+  //   —— 典型的"接线了但死"。它们是 POST 写动作，本来就该在 readBody 之后 ⇒ 已移到下面的 ROUTES 表。
   { methods: ['GET'], path: `${ROUTE_PREFIX}/sources`, handler: routeSourcesGet },
   { methods: ['GET'], path: `${ROUTE_PREFIX}/gitee-oauth-url`, handler: routeGiteeOauthUrlGet },
   { methods: ['GET'], path: `${ROUTE_PREFIX}/gitee-oauth-callback`, handler: routeGiteeOauthCallbackGet },
@@ -58,6 +63,8 @@ const ROUTES_EARLY = [
   //   **任何声明 GET 的路由都必须登记在 ROUTES_EARLY**。该判据已固化进 tests/test-route-inventory.mjs。
   { methods: ['GET'], path: `${ROUTE_PREFIX}/patch-audit`, handler: routePatchAuditGet },
   { methods: ['GET'], path: `${ROUTE_PREFIX}/preset-audit`, handler: routePresetAuditGet },
+  // 0.5.84 加法（用户第 7 项）：磁盘体检**只读** ⇒ 必须住在 405 守卫之前的表里（声明 GET 就要走得到）。
+  { methods: ['GET'], path: `${ROUTE_PREFIX}/disk-audit`, handler: routeDiskAudit },
   { methods: ['POST'], path: `${ROUTE_PREFIX}/framework-relaunch`, handler: routeFrameworkRelaunch },
 
 ]
@@ -123,6 +130,13 @@ const ROUTES = [
   { methods: ['POST'], path: `${ROUTE_PREFIX}/compat-stamp`, handler: routeCompatStamp },
   { methods: ['POST'], path: `${ROUTE_PREFIX}/compat-ack`, handler: routeCompatAck },
   { methods: ['POST'], path: `${ROUTE_PREFIX}/declare-installed`, handler: routeDeclareInstalled },
+  // 开发区根 + 钉住（0.5.57 加法）：允许注册自己的根；不允许任意目录；agent 发起需用户勾选（默认关）
+  // ★ 0.5.87：从 ROUTES_EARLY 移到这里 —— 它们**吃 body**（见上方 ROUTES_EARLY 里的说明）。
+  { methods: ['POST'], path: `${ROUTE_PREFIX}/dev-roots`, handler: routeDevRoots },
+  { methods: ['POST'], path: `${ROUTE_PREFIX}/pin-dev-dir`, handler: routePinDevDir },
+  // link 面板的两个写动作（0.5.87 加法）：补依赖/垫片（kind 指定做哪件）、取消钉住（两段式）
+  { methods: ['POST'], path: `${ROUTE_PREFIX}/link-repair`, handler: routeLinkRepair },
+  { methods: ['POST'], path: `${ROUTE_PREFIX}/unpin-dev-dir`, handler: routeUnpinDevDir },
   // 安全启动材料恢复入口（2026-09-29 加法 D3-①，0.5.32）：白名单动作 list / restore-last-good /
   // disable-suspects / mark-good；只认动作名，绝不接受命令串；服务起不来时走 scripts/safe-boot.mjs
   { methods: ['POST'], path: `${ROUTE_PREFIX}/safe-boot`, handler: routeSafeBoot },
@@ -161,6 +175,8 @@ const ROUTES = [
   // 依赖锁体检与重建（2026-09-27 加法）：check 纯只读；repair 必须由用户显式调用
   { methods: ['POST'], path: `${ROUTE_PREFIX}/lockfile-check`, handler: routeLockfileCheck },
   { methods: ['POST'], path: `${ROUTE_PREFIX}/lockfile-repair`, handler: routeLockfileRepair },
+  // 0.5.84 加法（用户第 7 项）：磁盘清理**默认只回计划**，confirm:true 才删（判据见 domain/disk-audit.js）
+  { methods: ['POST'], path: `${ROUTE_PREFIX}/disk-cleanup`, handler: routeDiskCleanup },
   // 结构化建议动作（2026-09-27 加法）：只认白名单动作类型，argv 由服务端自拼（绝不接受命令字符串）
   { methods: ['POST'], path: `${ROUTE_PREFIX}/run-suggested`, handler: routeRunSuggested },
 

package/lib/server/routes/install.js

@@ -28,6 +28,11 @@ async function routeInstall(req, res, rc) {
       try { repo = githubRepoInfo(rawRepo) } catch {}
     }
     const givenName = typeof body.packageName === 'string' ? body.packageName.trim() : ''
+  // ★ 0.5.81（用户 2026-10-18）：目标版本（"更新并适配"必须装它，否则 pnpm 按 latest 原地重装旧版）。
+  //   严格限制形态：只接受 semver 样式的版本，别的一律忽略（不把任意字符串塞进 pnpm 规格）。
+  const requestedVersion = typeof body.version === 'string' && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.test(body.version.trim())
+    ? body.version.trim()
+    : null
     // 框架本体拦截：deepseek-harness 仓库与其根包 @deepseek-ai/dsh-root 是 DSH 框架自身，
     // 作为插件安装会试图构建整个框架源码——直接拒绝并提示
     if (repo === 'deepseek-ai/deepseek-harness'
@@ -94,6 +99,7 @@ async function routeInstall(req, res, rc) {
       subpackages: null,
       lastError: null,
         update: body.update === true,
+    version: requestedVersion, // ★ 目标版本（null = 照旧按 latest）
       kind,
       // 子目录插件安装（纯加法：不带 subdir 时这两项就是 null，作业形状与改动前逐字相同）
       subdir,

package/lib/server/routes/link-actions.js

@@ -0,0 +1,120 @@
+// L2 · routes —— link 面板的**两个写动作**（0.5.87 加法）
+//   POST /plugin-console/link-repair     缺什么补什么（kind: deps 补依赖 / shims 造垫片 / all 两件都做）
+//   POST /plugin-console/unpin-dev-dir   取消钉住（两段式：先只读计划，confirm:true 才移除）
+//
+// 为什么单独一个文件：`routes/state.js` 已经 439 行（上限 600），而这两条动作与「只读清单」
+//   是两种职责（写 vs 读）。判据一律在 domain 层（link-self-sufficiency.js / unpin-dev-dir.js），
+//   本文件只做三件事：**白名单校验 → 调 domain → 如实回包**。
+//
+// 安全语义（与 routes/revoke-force.js、routes/disk.js 同一套）：
+//   · 包名必须是合法 npm 包名（NPM_NAME_RE），且**必须真的是本 profile 里的 link:/file: 依赖** ——
+//     不接受任意包名，也不对 registry 依赖动手（那不是"开发式链接"）；
+//   · 路径**绝不从请求体来** —— profileDir 由服务端按当前 profile 决定；
+//   · 未确认（confirm!==true）时只回计划，一个字节都不写。
+import { dirname } from 'node:path'
+import { NPM_NAME_RE } from '../domain/dep-source.js'
+import { pathDepsOf } from '../domain/link-inventory.js'
+import { repairLinkTarget } from '../domain/link-self-sufficiency.js'
+import { applyUnpinDevDir, planUnpinDevDir } from '../domain/unpin-dev-dir.js'
+import { sendError, sendJson } from '../infra/httpd.js'
+import { dshHome, findPatchPath } from '../infra/paths.js'
+
+/** 当前 profile 根目录（拿不到就 null —— 调用方必须当成"拒绝改动"处理）。 */
+function profileDirOfCtx(ctx) {
+  try { return dirname(findPatchPath(ctx)) } catch { return null }
+}
+
+/** 请求体 → 合法包名（不合法就空串）。 */
+function packageNameOf(body) {
+  const raw = body !== null && typeof body === 'object' && typeof body.packageName === 'string' ? body.packageName.trim() : ''
+  return NPM_NAME_RE.test(raw) ? raw : ''
+}
+
+/**
+ * POST /link-repair —— 把"缺依赖 / 缺 peer"这两条出路做成可点动作。
+ * body: { packageName, kind?: 'deps' | 'shims' | 'all' }
+ */
+async function routeLinkRepair(req, res, rc) {
+  const body = rc.body ?? {}
+  const packageName = packageNameOf(body)
+  if (packageName === '') { sendError(res, 400, '包名无效（只接受合法 npm 包名）'); return }
+  const kind = body.kind === 'deps' ? 'deps' : body.kind === 'shims' ? 'shims' : 'all'
+  const profileDir = profileDirOfCtx(rc.ctx)
+  if (typeof profileDir !== 'string' || profileDir === '') { sendError(res, 400, '拿不到 profile 目录，拒绝改动'); return }
+  // 只对**确实是本 profile 里的路径型依赖**生效（不凭空对任意包名动手）
+  const dep = pathDepsOf(profileDir).find((x) => x.packageName === packageName) ?? null
+  if (dep === null) {
+    sendError(res, 400, `${packageName} 不是本 profile 里的 link:/file: 依赖 —— 这份清单只处理开发式链接，不改别的东西`)
+    return
+  }
+  const result = await repairLinkTarget({ profileDir, packageName, kind, spec: dep.spec, home: dshHome() })
+  const plan = result.plan ?? null
+  const payload = {
+    ok: result.ok === true,
+    kind: result.kind,
+    packageName,
+    ready: result.ready === true,
+    changed: result.changed === true,
+    installed: result.installed === null || result.installed === undefined
+      ? null
+      : { ok: result.installed.ok === true, error: result.installed.error ?? null },
+    created: Array.isArray(result.created) ? result.created : [],
+    skipped: Array.isArray(result.skipped) ? result.skipped : [],
+    target: plan?.target ?? null,
+    missingDeps: plan?.missingDeps ?? [],
+    missingPeers: plan?.missingPeers ?? [],
+    shimmablePeers: plan?.shimmablePeers ?? [],
+    note: result.note ?? null,
+    error: result.ok === true ? null : (result.note ?? '补齐失败'),
+  }
+  if (result.ok === true) sendJson(res, 200, payload)
+  else sendError(res, 500, payload.error, payload)
+}
+
+/**
+ * POST /unpin-dev-dir —— 取消钉住（摘掉清单里那条 link:/file: 依赖）。
+ * body: { packageName, confirm?: boolean }
+ *   confirm !== true → 只读计划（面板先给人看会怎样）
+ *   confirm === true → 备份清单 → pnpm remove → **读回三处** → 失败即回滚
+ */
+async function routeUnpinDevDir(req, res, rc) {
+  const body = rc.body ?? {}
+  const packageName = packageNameOf(body)
+  if (packageName === '') { sendError(res, 400, '包名无效（只接受合法 npm 包名）'); return }
+  const profileDir = profileDirOfCtx(rc.ctx)
+  if (typeof profileDir !== 'string' || profileDir === '') { sendError(res, 400, '拿不到 profile 目录，拒绝改动'); return }
+  if (body.confirm !== true) {
+    const plan = planUnpinDevDir({ profileDir, packageName })
+    if (plan.ok !== true) {
+      sendError(res, plan.status ?? 400, plan.error ?? '取消钉住规划失败', { ok: false, packageName, spec: plan.spec ?? null })
+      return
+    }
+    sendJson(res, 200, {
+      ok: true, applied: false, packageName, spec: plan.spec, target: plan.target,
+      targetExists: plan.targetExists, inBundles: plan.inBundles, bundles: plan.bundles,
+      warnings: plan.warnings, steps: plan.steps,
+    })
+    return
+  }
+  // 真删：用与 /uninstall 同一条 pnpm 通道（rc.deps.pnpmRemove），保持"一个动作负责三处"
+  const injected = rc.deps !== null && typeof rc.deps === 'object' && typeof rc.deps.pnpmRemove === 'function' ? rc.deps.pnpmRemove : null
+  const runRemove = injected === null ? null : (args) => injected(args.profileDir, args.packageName)
+  const result = await applyUnpinDevDir({ profileDir, packageName, runRemove })
+  const payload = {
+    ok: result.ok === true,
+    applied: result.changed === true,
+    packageName,
+    spec: result.spec ?? null,
+    target: result.target ?? null,
+    inBundles: result.inBundles === true,
+    removed: result.removed ?? null,
+    backup: result.backup ?? null,
+    warnings: result.warnings ?? [],
+    note: result.note ?? null,
+    error: result.ok === true ? null : (result.error ?? '取消钉住失败'),
+  }
+  if (result.ok === true) sendJson(res, 200, payload)
+  else sendError(res, result.status ?? 400, payload.error, payload)
+}
+
+export { routeLinkRepair, routeUnpinDevDir }

package/lib/server/routes/state.js

@@ -17,12 +17,15 @@ import { applyPinDevDir, planPinDevDir } from '../domain/pin-dev-dir.js'
 import { reconcileLockfile } from '../domain/selfupdate.js'
 import { ensureLinkSelfSufficiency } from '../domain/link-self-sufficiency.js'
 import { readBundlesSync } from '../domain/persist.js'
+// 0.5.84 加法：清单 ↔ lock 口径不一致的**后台自动对账**（见 domain/lock-autofix.js 顶部三条硬约束）
+import { lockAutofixStatus, scheduleLockAutofix } from '../domain/lock-autofix.js'
 import { failedJobEvidence } from '../domain/install-verify.js'
 import { installJobView, readGithubAuth } from '../domain/install.js'
 import { readPluginDetails } from '../domain/market.js'
 import { healPatchSafety, readPatchState } from '../domain/patch.js'
 import { pendingRestartJobs } from '../domain/revoke.js'
 import { mergePendingRestart } from '../domain/pending-restart.js'
+import { recordInstallJob, readInstallJobs } from '../domain/install-jobs-store.js'
 import { listEntries } from '../domain/runtime.js'
 import { sendError, sendJson } from '../infra/httpd.js'
 import { dshHome, entryPkgMeta, findPatchPath, pluginRoot, profileDirOf, rowIdOf } from '../infra/paths.js'
@@ -146,6 +149,13 @@ async function routeStateGet(req, res, rc) {
       } catch {}
       return set
     })()
+    // ★ 0.5.83（用户 2026-10-18）：作业结束后**落盘一条记录**（只记 done/failed，幂等），
+    //   宿主重启后仍能查到"上次更新干了什么、为什么失败"。写盘失败一律吞掉，绝不影响本接口。
+    try {
+      for (const job of installJobs.values()) {
+        if (job?.status === 'done' || job?.status === 'failed') recordInstallJob(job)
+      }
+    } catch {}
     let pendingRestart = []
     try { pendingRestart = mergePendingRestart(pendingRestartJobs([...installJobs.values()], listEntries(ctx)), livePackageNames) } catch { pendingRestart = pendingRestartJobs([...installJobs.values()], listEntries(ctx)) }
     // 框架升级检测与适配（备份快照 + 重打框架补丁），try 包裹不阻塞 state 返回
@@ -242,7 +252,19 @@ async function routeStateGet(req, res, rc) {
         patchUncertain: patchHeal === null ? [] : (patchHeal.uncertain ?? []),
       })
     } catch {}
-    sendJson(res, 200, { ok: true, entries: allEntries, skippedBundles, host, health, patchPath, compat, installJobs: jobs, recentFailures, pendingRestart, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0, written: patchHeal.written === true, writeError: patchHeal.writeError ?? null, skippedFrameworkOwned: (patchHeal.skipped ?? []).map((s) => s.id ?? null), uncertain: (patchHeal.uncertain ?? []).map((u) => u.id ?? null) }, gating: gatingSummary(ctx, compatPending, entries, compatVerdicts), compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null, verdict: compatVerdicts.get(p.rowId) ?? null })), verdictRefresh: pendingState.refresh === null ? null : { version: pendingState.refresh.version ?? null, updated: pendingState.refresh.updated ?? [], unchanged: pendingState.refresh.unchanged ?? [], unresolved: pendingState.refresh.unresolved ?? [], wrote: pendingState.refresh.wrote === true, writeError: pendingState.refresh.writeError ?? null } }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
+    // ★ 0.5.84 加法（用户 2026-10）：**后台自动对账 lock**。
+    //   为什么放在 /state：这里是唯一"每次开面板都会被调"的地方 —— 于是"清单与 lock 对不上"能被
+    //   及时发现，而不必等用户自己去点「重建 lock」。
+    //   为什么**不 await**：pnpm 是墙钟动作（实测 1.5s 起步、最坏分钟级），等它就会把 /state 拖死。
+    //   冷却窗 / 失败停手 / 在跑去重都在 domain/lock-autofix.js 里，这里只负责"问一句、不挡路"。
+    let lockAutofix = null
+    try {
+      const kicked = scheduleLockAutofix({ profileDir, registries: [] })
+      lockAutofix = { ...lockAutofixStatus({ profileDir }), scheduled: kicked.started, skippedReason: kicked.started ? null : kicked.reason }
+    } catch (error) {
+      lockAutofix = { error: error instanceof Error ? error.message : String(error), scheduled: false }
+    }
+    sendJson(res, 200, { ok: true, entries: allEntries, skippedBundles, host, health, patchPath, compat, installJobs: jobs, recentFailures, pendingRestart, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, lockAutofix, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0, written: patchHeal.written === true, writeError: patchHeal.writeError ?? null, skippedFrameworkOwned: (patchHeal.skipped ?? []).map((s) => s.id ?? null), uncertain: (patchHeal.uncertain ?? []).map((u) => u.id ?? null) }, gating: gatingSummary(ctx, compatPending, entries, compatVerdicts), compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null, verdict: compatVerdicts.get(p.rowId) ?? null })), verdictRefresh: pendingState.refresh === null ? null : { version: pendingState.refresh.version ?? null, updated: pendingState.refresh.updated ?? [], unchanged: pendingState.refresh.unchanged ?? [], unresolved: pendingState.refresh.unresolved ?? [], wrote: pendingState.refresh.wrote === true, writeError: pendingState.refresh.writeError ?? null } }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
     return
 }
 

package/package.json

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