dsh-mobile-plugin 0.1.78 → 0.1.84

package/lib/relay/tunnel.js

@@ -381,6 +381,35 @@ class RelayTunnel {
     if (this.connected) this.sendJson(T.updatePairing, 0, { pairingCode: code });
   }
 
+  /** 注册帧的载荷。连接建立时发一次，之后元信息变了再由 updateRegistration 重发。 */
+  registrationPayload() {
+    return {
+      instanceId: this.instanceId,
+      pairingCode: this.pairingCode,
+      name: this.name,
+      // 可选：与中转端 TUNNEL_REGISTER_SECRET 对应，防止他人抢注 instanceId。
+      ...(this.registerSecret ? { secret: this.registerSecret } : {}),
+      ...(this.lanUrls.length ? { lanUrls: this.lanUrls } : {}),
+      ...(this.lanCandidates.length ? { lanCandidates: this.lanCandidates } : {}),
+    };
+  }
+
+  /**
+   * 在**现有连接上**重报一次注册信息（配对码 / 名字 / 局域网候选），不断连接。
+   *
+   * 中转那边同一个实例重复注册是幂等的（不会把自己顶掉），所以这条只是「更新名片」。
+   * 以前这类变化是把整条隧道拆了重建，代价是手机所有在途请求一起断——真机现场就是
+   * 「切个网络，接下来几秒点什么都失败」。真正决定「连到哪台」的字段（实例、中转
+   * 地址、注册密钥）不在这里更新，它们变了必须重建，由 worker 的 configure 判定。
+   */
+  updateRegistration(patch = {}) {
+    if (typeof patch.pairingCode === 'string' && patch.pairingCode) this.pairingCode = patch.pairingCode;
+    if (typeof patch.name === 'string') this.name = patch.name;
+    if (Array.isArray(patch.lanUrls)) this.lanUrls = patch.lanUrls.slice();
+    if (Array.isArray(patch.lanCandidates)) this.lanCandidates = patch.lanCandidates.slice();
+    if (this.connected) this.sendJson(T.register, 0, this.registrationPayload());
+  }
+
   /**
    * 回传桌面端弹窗授权结果：approved + 桌面签发的移动 token（拒绝时无 token）。
    * `hostPlatform` 是**宿主自己的** `process.platform`，经中转原样回给手机，
@@ -445,15 +474,7 @@ class RelayTunnel {
       });
 
       ws.on('open', () => {
-        this.sendJson(T.register, 0, {
-          instanceId: this.instanceId,
-          pairingCode: this.pairingCode,
-          name: this.name,
-          // 可选：与中转端 TUNNEL_REGISTER_SECRET 对应，防止他人抢注 instanceId。
-          ...(this.registerSecret ? { secret: this.registerSecret } : {}),
-          ...(this.lanUrls.length ? { lanUrls: this.lanUrls } : {}),
-          ...(this.lanCandidates.length ? { lanCandidates: this.lanCandidates } : {}),
-        });
+        this.sendJson(T.register, 0, this.registrationPayload());
       });
       ws.on('message', (data, isBinary) => push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
       ws.on('close', (code, reason) => {

package/lib/session-cleanup.cjs

@@ -9,11 +9,13 @@
  *    CANONICAL_LOG_FILENAME + compressionSuffix：0 代不带 vN，压缩时才带 .zstd）。
  *    曾经只认 `session.jsonl.zstd`，于是 0.2.0 真在用的 `session.v4.jsonl.zstd`
  *    一个都认不到 —— 表现是「清理已归档」恒回 `deleted: 0`，静默不删。
- *  - 删之前先从宿主归档集合里摘掉这些 id：宿主不会自己修剪，删完还留着就是「已归档」
- *    里一排点不开的死行，且每清一次只增不减。
  *  - 解压用 Node 自带的 zstd（DSH 自己就是这么读写日志的，宿主并不需要系统 zstd
  *    命令），不再 shell 出去：没装 zstd 命令的机器上它一缺就是 readHeader 静默返回
  *    undefined，整条删除路径空转。id 仍然取自日志第一行那条 header。
+ *  - **进程活着的时候不擦宿主的归档集合**，只删日志；擦集合放到宿主启动时
+ *    （pruneOrphanedArchivedSessionsOnce）。理由写在那个函数上：桌面端的会话列表是
+ *    连上宿主时拉的一份快照 + 之后的事件增量，进程里擦集合等于把已经删掉、却还留在
+ *    快照里的行放回正常列表。
  */
 'use strict'
 
@@ -24,6 +26,9 @@ const zlib = require('node:zlib')
 const DEFAULT_OLDER_THAN_MINUTES = 30
 const MINUTES = 60 * 1000
 
+/** 认为「宿主刚起来」的上限：装载插件只在这段时间里算启动，之后出现的调用只能是热替换。 */
+const BOOT_PRUNE_WINDOW_SECONDS = 60
+
 // 宿主认可的会话日志名。非规范名（迁移中途的临时文件、大写、前导零、带 v0）宿主自己
 // 也不认，这里同样不认 —— 认多了会把没提交的代次当会话删掉。
 const CANONICAL_LOG_FILENAME = /^session(?:\.v[1-9][0-9]*)?\.jsonl(?:\.zstd)?$/
@@ -128,18 +133,12 @@ async function deleteSessionData(sessionIds) {
 }
 
 /**
- * 把已经从磁盘删掉的 id 从宿主归档集合里擦掉（删除路径的最后一步，best-effort）。
- *
- * 宿主不会自己修剪这份集合：日志删了它照样留着那些 id，于是「已归档」里是一排点不开的
- * 死行，而且每清一次就多几条、只增不减。它排在 `deleteSessionData` **之后**：日志没删成
- * 前先擦集合，中途失败就会留下「已取消归档、日志还在」的会话——用户看到的是清理只把会话
- * 移出了归档，还要重启宿主才恢复。先删后擦则日志一没就是真的删掉了，立刻生效；擦失败最多
- * 留一行死行，重试即可。宿主对本来就未归档的 id 是 no-op。
+ * 把一批 id 从宿主归档集合里擦掉（宿主对本来就未归档的 id 是 no-op）。
  *
- * 只传**真删掉**的 id：没匹配到日志的还留着日志，擦掉它的名字只会让那一行消失而没有东西被删。
+ * 唯一的调用方是宿主启动时的孤儿修剪：进程活着的时候擦集合会把桌面端快照里那些已经
+ * 删掉的行放回正常列表，理由见 pruneOrphanedArchivedSessionsOnce。
  *
- * 返回擦失败的 id（`failed`），**不抛异常**：日志已经删成功，擦集合坏了不该让整条清理
- * 报错——那等于告诉用户「没删掉」，而事实上已经删掉了。
+ * 返回擦失败的 id（`failed`），**不抛异常**：修剪是收尾，一条擦不动不该让整轮修剪停摆。
  */
 async function forgetArchivedSessions(ctx, sessionIds, rpcId) {
   const failed = []
@@ -154,6 +153,69 @@ async function forgetArchivedSessions(ctx, sessionIds, rpcId) {
   return failed
 }
 
+/**
+ * 归档集合里那些日志确实已经不在磁盘上的 id。
+ *
+ * 判据是磁盘而不是宿主的会话列表：`sessions.list` 会不会漏一条（比如没有 cwd 的会话、
+ * 宿主服务还没装好）不是这里能判断的，而「归档集合里挂着、磁盘上已经没有日志」正是
+ * 清理真正删掉的那个状态。宿主把会话 id 原样当目录名（`encodeSegment` 对正常 id 恒等），
+ * 所以先用目录名筛掉绝大多数，只对候选读一遍 header 复核 —— 别为了修剪把整库日志解一遍。
+ */
+async function archivedIdsWithoutLogs(archivedSessionIds) {
+  const orphans = new Set(archivedSessionIds)
+  if (orphans.size === 0) return []
+  for (const file of sessionFiles(path.join(dshHome(), 'sessions'))) {
+    const name = path.basename(path.dirname(file))
+    if (!orphans.has(name)) continue
+    const header = await readHeader(file)
+    // 日志读不出来也算「还在」：宁可这一轮不修剪，也不能把一条还有日志的会话移出归档。
+    orphans.delete(name)
+    if (header && typeof header.id === 'string') orphans.delete(header.id)
+    if (orphans.size === 0) break
+  }
+  return [...orphans]
+}
+
+async function pruneOrphanedArchivedSessions(ctx) {
+  const workspaceList = ctx && ctx.apiProxy && ctx.apiProxy.workspace ? ctx.apiProxy.workspace.list : undefined
+  if (typeof workspaceList !== 'function') return 0
+  const rpcId = 'dsh-mobile-plugin-archive-prune'
+  const { value, error } = unwrap(await workspaceList({ rpcId, method: 'workspace.list', payload: {} }))
+  if (error) throw new Error(`workspace.list 失败：${error.message || error.code || '未知错误'}`)
+  const archived = value && Array.isArray(value.archivedSessionIds)
+    ? value.archivedSessionIds.filter((id) => typeof id === 'string' && id)
+    : []
+  const orphans = await archivedIdsWithoutLogs(archived)
+  if (orphans.length === 0) return 0
+  const failed = await forgetArchivedSessions(ctx, orphans, rpcId)
+  return orphans.length - failed.length
+}
+
+/**
+ * 宿主进程启动时修剪一次归档集合，然后整个进程不再碰。
+ *
+ * 这件事只能在启动这一刻做：桌面端的会话列表是「连上宿主时拉的一份快照 + 之后的事件
+ * 增量」，宿主本身没有「删除会话」的接口，插件在磁盘上删日志它也看不见。进程活着的时候
+ * 擦归档集合，宿主会把「归档集合变了」广播给桌面端，桌面端就把它快照里那些其实已经
+ * 没有日志、本来被归档藏着的行放回正常列表 —— 用户报的正是「清理后它们又回来了，重启
+ * DSH 才真的消失」。启动时桌面端还没连上（或正要重连，快照本来就从磁盘重新拉），擦掉
+ * 不会放出任何行。留在集合里的死 id 不显示在任何地方：「已归档」取的是会话列表与归档
+ * 集合的交集，没有日志就没有那一行。
+ *
+ * 用进程级标记而不是模块变量：代际热替换会重跑 apply，而桌面端那条快照挂在同一个进程上。
+ */
+const PRUNE_ONCE = Symbol.for('dsh-mobile-plugin.archived-prune')
+async function pruneOrphanedArchivedSessionsOnce(ctx, log) {
+  if (globalThis[PRUNE_ONCE]) return
+  globalThis[PRUNE_ONCE] = true
+  try {
+    const pruned = await pruneOrphanedArchivedSessions(ctx)
+    if (pruned > 0) log?.(`archived session prune: dropped ${pruned} deleted session ids`)
+  } catch (error) {
+    log?.(`archived session prune failed: ${error && error.message ? error.message : String(error)}`)
+  }
+}
+
 async function cleanupSessions(ctx, args) {
   const list = ctx.apiProxy?.sessions?.list
   const workspaceList = ctx.apiProxy?.workspace?.list
@@ -188,11 +250,9 @@ async function cleanupSessions(ctx, args) {
   }
   if (args.confirm !== true) throw new Error('永久删除需要 confirm: true')
   const ids = selected.map(item => item.sessionId)
-  // 与移动端那条路由同一口径：**先删日志、再擦归档集合**。反过来会在链路中途失败时
-  // 留下「名字已从归档集合消失、日志还在」的会话（看着像只是被移出了归档，得重启宿主
-  // 才恢复）；先删则日志一没就是真的删掉了，立刻生效。擦集合是收尾，失败不改变结果。
+  // 与移动端那条路由同一口径：**只删日志**，归档集合留到宿主下次启动时修剪。进程里擦
+  // 集合会把桌面端快照里那些已经删掉的行放回正常列表（见 pruneOrphanedArchivedSessionsOnce）。
   const deletedIds = await deleteSessionData(ids)
-  await forgetArchivedSessions(ctx, deletedIds, 'dsh-mobile-plugin-session-cleanup')
   return { action: args.action, cwd, selected: ids.length, archived: 0, deleted: deletedIds.length, failed: ids.length - deletedIds.length, sessionIds: deletedIds }
 }
 
@@ -219,4 +279,23 @@ function registerSessionCleanupTool(ctx) {
   }))
 }
 
-module.exports = { cleanupSessions, registerSessionCleanupTool, deleteSessionData, forgetArchivedSessions }
+/**
+ * 装配层的入口：注册 agent 的清理工具，同时在「宿主刚起来」时修剪一遍归档集合。
+ *
+ * 两件事都是会话清理的一部分，所以共用装配层那一处 effect；impl.js 有行数兜底守卫，
+ * 别把实现搬回去。
+ */
+function installSessionCleanup(ctx) {
+  // 「宿主启动时」不能只看进程级标记：升级到这份实现那次是**热替换**进来的（进程早就在跑），
+  // 标记还没被谁设过。那一刻桌面端的会话列表快照里可能正挂着之前删掉的行，擦集合就会把它们
+  // 放回列表。所以只在进程刚起的这点窗口里修剪；晚于它就留给下次启动。
+  if (process.uptime() <= BOOT_PRUNE_WINDOW_SECONDS) {
+    // 修剪先挂：没有 tools 注入的 profile 注册不了工具（外层会吞掉这条错），但归档集合照样要收尾。
+    void pruneOrphanedArchivedSessionsOnce(ctx, (message) => {
+      try { ctx.logger?.info?.(message) } catch { /* 日志失败不影响修剪 */ }
+    })
+  }
+  registerSessionCleanupTool(ctx)
+}
+
+module.exports = { cleanupSessions, registerSessionCleanupTool, installSessionCleanup, deleteSessionData, forgetArchivedSessions, pruneOrphanedArchivedSessions, pruneOrphanedArchivedSessionsOnce }

package/lib/shell/device-ota.js

@@ -1,62 +1,77 @@
-/** 设备端临时插件 OTA：npm 保持正式来源，OTA 仅保存于 DSH home。 */
+/** 设备端临时插件 OTA：npm 保持正式来源，OTA 只落在 profile 里（见 storageRoot）。 */
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
-import { createRequire } from 'node:module'
 import { dshHome } from '../shared/paths.js'
-import { compareVersion } from './manager.js'
-
-const require_ = createRequire(import.meta.url)
-const zlib = require_('node:zlib')
-const ROOT = () => path.join(dshHome(), 'plugin-ota')
+import { compareVersion, generationModulesError } from './manager.js'
+import { movePath, readManifest, sha256Hex, unpackTarGz, verifyManifest } from './ota-package.js'
+/**
+ * OTA 包落在哪。
+ *
+ * 默认 `<DSH_HOME>/plugin-ota`，但外壳知道 profile 在哪之后会把它挪到**profile 里面**
+ * （`<profile>/.dsh-mobile-ota`）。原因不是洁癖：DSH 宿主的 profile-resolution 拦截层
+ * 只认 `profiles/` 树内的模块，树外的裸包名走的是原生解析 —— 而宿主提供的那批 peer
+ * （`@deepseek-ai/dsh-tools` 之类）压根不在 profile 的 node_modules 里，于是 OTA 代
+ * 第一句 `require('@deepseek-ai/dsh-tools')` 就 MODULE_NOT_FOUND（2026-10-17 真机：
+ * 0.1.80 装载失败）。落在 profile 里之后，OTA 代与装进来的那一代走**同一条**解析链。
+ */
+let storageRoot = ''
+export function configureOtaRoot(dir) {
+  if (typeof dir === 'string' && dir.length > 0) storageRoot = dir
+}
+const ROOT = () => storageRoot || path.join(dshHome(), 'plugin-ota')
 const PACKAGE = 'dsh-mobile-plugin'
 const RELAY = 'https://dsh-hub.wnluo.com/api/desktop-plugins/ota'
 const CHANNEL = 'stable'
 const PLATFORM = process.platform
+/**
+ * 平台回落的兜底标记。
+ *
+ * 这个插件是纯 JS，同一份包在 Linux/macOS/Windows 上都能跑；但中转是按平台分发的，以前
+ * 只发过 darwin 就意味着 Windows 机器永远查不到更新（`ok:false` 被当成「没有新版」）。
+ * 约定：自己平台没包时再问一次 `any`，发布方也可以直接只发一份 `any`。
+ */
+const ANY_PLATFORM = 'any'
 function validVersion(value) { return typeof value === 'string' && /^\d+\.\d+\.\d+$/.test(value) }
 function validPackageUrl(value) {
   try { return new URL(value).protocol === 'https:' } catch { return false }
 }
+/**
+ * 列出盘上可用的 OTA 代。
+ *
+ * 两条容错都是必要的：**逐个条目自己 try**（一个残目录不能让整台机器的 OTA 全部不可见——
+ * 旧实现把整个 map 包在一个 try 里，任何一份半拷贝都会让 `availableOta()` 返回空，表现为
+ * 「更新装了但界面上永远没有新版」），以及**跳过点开头的目录**（`.staging-*` 是解包中途的
+ * 暂存，不能当成一代）。
+ */
 function availableOta() {
-  try {
-    return fs.readdirSync(ROOT(), { withFileTypes: true }).filter(item => item.isDirectory()).map(item => {
+  let items
+  try { items = fs.readdirSync(ROOT(), { withFileTypes: true }) } catch { return [] }
+  const found = []
+  for (const item of items) {
+    if (!item.isDirectory() || item.name.startsWith('.')) continue
+    try {
       const pkgDir = path.join(ROOT(), item.name, PACKAGE)
       const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'))
-      if (pkg.name !== PACKAGE || !validVersion(pkg.version) || !fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) return null
-      return { version: pkg.version, entry: path.join(pkgDir, 'lib', 'impl.js'), dir: pkgDir, pkgDir, source: 'ota' }
-    }).filter(Boolean).sort((a, b) => compareVersion(b.version, a.version))
-  } catch { return [] }
+      if (pkg.name !== PACKAGE || !validVersion(pkg.version)) continue
+      if (!fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) continue
+      found.push({ version: pkg.version, entry: path.join(pkgDir, 'lib', 'impl.js'), dir: pkgDir, pkgDir, source: 'ota' })
+    } catch { /* 半份包 / 残目录：只跳过它自己 */ }
+  }
+  return found.sort((a, b) => compareVersion(b.version, a.version))
+}
+/** 清掉上次解包中途退出留下的暂存目录（断电 / 进程被杀时的残骸）。 */
+function sweepStaging() {
+  let items
+  try { items = fs.readdirSync(ROOT(), { withFileTypes: true }) } catch { return }
+  for (const item of items) {
+    if (!item.isDirectory() || !item.name.startsWith('.staging-')) continue
+    try { fs.rmSync(path.join(ROOT(), item.name), { recursive: true, force: true }) } catch { /* 下次再清 */ }
+  }
 }
 function clearSuperseded(version) {
   if (!validVersion(version)) return
   for (const release of availableOta()) if (compareVersion(version, release.version) >= 0) fs.rmSync(path.dirname(release.pkgDir), { recursive: true, force: true })
 }
-function unpackTarGz(buffer, target) {
-  const tar = zlib.gunzipSync(buffer)
-  let offset = 0
-  while (offset + 512 <= tar.length) {
-    const header = tar.subarray(offset, offset + 512)
-    if (header.every(byte => byte === 0)) break
-    const name = header.subarray(0, 100).toString().replace(/\0.*$/, '')
-    const prefix = header.subarray(345, 500).toString().replace(/\0.*$/, '')
-    const rel = path.posix.join(prefix, name)
-    const size = parseInt(header.subarray(124, 136).toString().replace(/\0.*$/, '').trim() || '0', 8)
-    const type = header[156]
-    const start = offset + 512
-    if (!rel.startsWith('package/') || rel.split('/').includes('..')) throw new Error('OTA 包含无效路径')
-    if (type === 0 || type === 48) {
-      const dest = path.join(target, PACKAGE, ...rel.split('/').slice(1))
-      fs.mkdirSync(path.dirname(dest), { recursive: true })
-      fs.writeFileSync(dest, tar.subarray(start, start + size))
-    } else if (type !== 53) throw new Error(`OTA 包包含不支持的 tar 项：${rel}`)
-    offset = start + Math.ceil(size / 512) * 512
-  }
-  const pkgDir = path.join(target, PACKAGE)
-  const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'))
-  if (pkg.name !== PACKAGE || !validVersion(pkg.version) || !fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) throw new Error('OTA 包结构不完整')
-  return pkg.version
-}
-
 export function createDeviceOta({ fetchImpl = fetch, installed = () => null, platform = PLATFORM, channel = CHANNEL, runtime = null } = {}) {
   async function reconcileOfficial() {
     const active = runtime?.status()
@@ -73,37 +88,66 @@ export function createDeviceOta({ fetchImpl = fetch, installed = () => null, pla
     if (status?.source === 'installed') clearSuperseded(officialVersion)
     return { switched: status?.source === 'installed', status }
   }
-  async function check() {
-    await reconcileOfficial()
-    const url = `${RELAY}/latest?platform=${encodeURIComponent(platform)}&channel=${encodeURIComponent(channel)}`
+  /** 问一次中转「我该装哪个版本」；没有就返回 null（不抛）。 */
+  async function latestFor(wanted) {
+    const url = `${RELAY}/latest?platform=${encodeURIComponent(wanted)}&channel=${encodeURIComponent(channel)}`
     const response = await fetchImpl(url, { headers: { accept: 'application/json' } })
     if (!response.ok) throw new Error(`OTA relay 返回 HTTP ${response.status}`)
     const body = await response.json()
-    const release = body?.data
-    if (body?.ok !== true || !validVersion(release?.version) || release.platform !== platform || release.channel !== channel || !validPackageUrl(release.packageUrl)) throw new Error('OTA relay 没有提供匹配平台、stable channel、有效版本或 HTTPS 下载地址')
+    if (body?.ok !== true) return null
+    const release = body.data
+    if (!release || !validVersion(release.version)) return null
+    // 回落来的包平台标记是 `any`；自己平台那份必须正好对上。
+    if (release.platform !== wanted || release.channel !== channel) return null
+    if (!validPackageUrl(release.packageUrl)) return null
+    return release
+  }
+  async function check() {
+    await reconcileOfficial()
+    const release = (await latestFor(platform)) ?? (platform === ANY_PLATFORM ? null : await latestFor(ANY_PLATFORM))
+    if (!release) throw new Error('OTA relay 没有提供匹配平台、stable channel、有效版本或 HTTPS 下载地址')
     const installedVersion = installed()
     const officialVersion = installedVersion
     const ota = availableOta()[0] || null
     const otaVersion = validVersion(release.version) ? release.version : null
     const newest = [ota?.version, otaVersion].filter(validVersion).sort((a, b) => compareVersion(b, a))[0] || null
     const absorbed = Boolean(validVersion(officialVersion) && newest && compareVersion(officialVersion, newest) >= 0 && runtime?.status()?.source !== 'ota')
-    return { available: Boolean(newest && !absorbed && compareVersion(newest, installedVersion || '0.0.0') > 0), version: newest, platform: release.platform || platform, channel: release.channel || channel, installedVersion, otaVersion: ota?.version ?? null, officialVersion, absorbed, packageUrl: release.packageUrl }
+    return { available: Boolean(newest && !absorbed && compareVersion(newest, installedVersion || '0.0.0') > 0), version: newest, platform: release.platform || platform, channel: release.channel || channel, installedVersion, otaVersion: ota?.version ?? null, officialVersion, absorbed, packageUrl: release.packageUrl, sha256: typeof release.sha256 === 'string' && /^[0-9a-f]{64}$/i.test(release.sha256) ? release.sha256.toLowerCase() : null }
   }
   async function apply() {
     const info = await check()
     if (info.otaVersion && compareVersion(info.otaVersion, info.version) === 0) return { installed: true, version: info.version, source: 'ota', alreadyDownloaded: true }
     if (validVersion(info.officialVersion) && compareVersion(info.officialVersion, info.version) >= 0) return { installed: false, reason: 'npm-current-or-newer', version: info.officialVersion }
-    const staging = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-plugin-ota-'))
+    // 暂存目录**建在目标根里面**，不是系统临时目录：最后一步要 rename 到 `<root>/<version>`，
+    // 跨盘的 rename 在 Windows 上直接 EXDEV（系统临时目录常在 C:，而 profile 可能在别的盘）。
+    fs.mkdirSync(ROOT(), { recursive: true })
+    sweepStaging()
+    const staging = fs.mkdtempSync(path.join(ROOT(), '.staging-'))
     try {
       const response = await fetchImpl(info.packageUrl)
       if (!response.ok) throw new Error(`OTA 下载失败：HTTP ${response.status}`)
-      const version = unpackTarGz(Buffer.from(await response.arrayBuffer()), staging)
+      const raw = Buffer.from(await response.arrayBuffer())
+      // 中转记了哈希就一定要对上：半个包、被中间层改过的包都在这里被挡住，而不是装上去再炸。
+      if (info.sha256 && sha256Hex(raw) !== info.sha256) {
+        throw new Error(`OTA 包校验失败：下载内容的 sha256 与中转记录不一致（预期 ${info.sha256}，实际 ${sha256Hex(raw)}）`)
+      }
+      unpackTarGz(raw, staging)
+      const pkgDir = path.join(staging, PACKAGE)
+      const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'))
+      const version = pkg && pkg.version
+      if (pkg.name !== PACKAGE || !validVersion(version)) throw new Error('OTA 包结构不完整：package.json 里的包名或版本不对')
       if (version !== info.version) throw new Error(`OTA 版本不匹配：预期 ${info.version}，实际 ${version}`)
+      if (!fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) throw new Error('OTA 包结构不完整：缺 lib/impl.js')
+      // 有清单就逐项核对（缺文件 / 大小不符在**激活之前**失败）；老包没有清单，退回上面那两条判据。
+      const manifest = readManifest(pkgDir)
+      if (manifest) {
+        if (manifest.version !== version) throw new Error(`OTA 包清单版本与 package.json 不一致（${manifest.version} ≠ ${version}）`)
+        verifyManifest(pkgDir, manifest)
+      }
       const releaseDir = path.join(ROOT(), version)
-      fs.mkdirSync(ROOT(), { recursive: true })
       fs.rmSync(releaseDir, { recursive: true, force: true })
-      fs.renameSync(staging, releaseDir)
-      return { installed: true, version, source: 'ota' }
+      movePath(staging, releaseDir)
+      return { installed: true, version, source: 'ota', verified: Boolean(manifest) }
     } catch (error) {
       fs.rmSync(staging, { recursive: true, force: true })
       throw error
@@ -113,7 +157,7 @@ export function createDeviceOta({ fetchImpl = fetch, installed = () => null, pla
     const installedVersion = installed()
     const active = runtime?.status() ?? null
     const ota = availableOta()[0] || null
-    return { available: Boolean(ota && compareVersion(ota.version, installedVersion || '0.0.0') > 0), activeVersion: active?.version ?? installedVersion, otaVersion: ota?.version ?? null, officialVersion: installedVersion, absorbed: Boolean(installedVersion && ota && compareVersion(installedVersion, ota.version) >= 0 && active?.source !== 'ota'), channel }
+    return { available: Boolean(ota && compareVersion(ota.version, installedVersion || '0.0.0') > 0), activeVersion: active?.version ?? installedVersion, otaVersion: ota?.version ?? null, officialVersion: installedVersion, absorbed: Boolean(installedVersion && ota && compareVersion(installedVersion, ota.version) >= 0 && active?.source !== 'ota'), channel, dependencyLinkError: generationModulesError() }
   }
   async function activate() {
     const outcome = await apply()

package/lib/shell/manager.js

@@ -32,7 +32,9 @@ import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { availableOta } from './device-ota.js'
+import { availableOta, configureOtaRoot } from './device-ota.js'
+import { movePath } from './ota-package.js'
+import { dshHome } from '../shared/paths.js'
 
 /** CJS 模块缓存。实现树里 `lib/relay`、`lib/routes`、`lib/mobile` 都是 CJS。 */
 const require_ = createRequire(import.meta.url)
@@ -227,6 +229,101 @@ function evictCommonJsTree(roots) {
   }
 }
 
+/**
+ * OTA 包落到 `<profile>/.dsh-mobile-ota`（不再放 `<DSH_HOME>/plugin-ota`）。
+ *
+ * 宿主对模块解析有一层拦截：**`profiles/` 树内**的模块，裸包名会先按 profile 的
+ * 本地包解析、再回落到宿主自己那份；树外的模块走原生解析。而宿主提供的那批 peer
+ * （`@deepseek-ai/dsh-tools` 等）并不在 profile 的 `node_modules` 里 —— 所以 OTA 包
+ * 一旦落在树外，那一代 `require('@deepseek-ai/dsh-tools')` 就是 MODULE_NOT_FOUND
+ * （2026-10-17 真机：0.1.80 装载失败）。位置挪进 profile 后，OTA 代与装进来的那一代
+ * 走同一条解析链，不必再靠调用点逐个打补丁。
+ *
+ * 老位置残留的包顺手搬过来：换代失败时它还是磁盘上的回退包，不能在升级路径上丢。
+ */
+function moveOtaRootIntoProfile() {
+  if (path.basename(PROFILE_NODE_MODULES) !== 'node_modules') return
+  const next = path.join(path.dirname(PROFILE_NODE_MODULES), '.dsh-mobile-ota')
+  const legacy = path.join(dshHome(), 'plugin-ota')
+  configureOtaRoot(next)
+  try {
+    if (!fs.existsSync(legacy) || fs.lstatSync(legacy).isSymbolicLink()) return
+    fs.mkdirSync(next, { recursive: true })
+    for (const entry of fs.readdirSync(legacy)) {
+      const target = path.join(next, entry)
+      if (fs.existsSync(target)) continue
+      // 跨盘也能搬：`<DSH_HOME>` 与 profile 在 Windows 上很可能不在同一个盘，
+      // 那时 rename 抛 EXDEV，整段迁移会静默失败、OTA 留在树外（依赖就解析不到了）。
+      movePath(path.join(legacy, entry), target)
+    }
+    fs.rmSync(legacy, { recursive: true, force: true })
+  } catch {
+    // 搬不动就用老位置：那是「OTA 仍可下载但可能装不起来」，比让外壳启动失败强
+  }
+}
+
+/**
+ * 给 OTA 代补齐「裸包名怎么解析」。
+ *
+ * Node 只沿**自己的祖先目录**找 `node_modules`，而 OTA 落在
+ * `<DSH_HOME>/plugin-ota/<version>/` —— 这条路径上没有任何一份 `node_modules`。于是
+ * `lib/impl.js` 第一句 `import { z } from '@deepseek-ai/schemastery'` 就报
+ * `Cannot find package`，一代整个装不起来（2026-10-17 真机：0.1.79 的 OTA 装载失败，
+ * 外壳按规矩回滚到旧代，机器上什么都没变）。
+ *
+ * 修法是补上基础代本来就有、而 OTA 路径上没有的那两层软链：
+ *   `<version>/node_modules`                    → profile 的 `node_modules`
+ *   `<version>/dsh-mobile-plugin/node_modules`  → profile 里那份插件的 `node_modules`（pnpm 严格布局才有）
+ * 从 `<version>/dsh-mobile-plugin/lib` 往上第一站就命中，解析到的是**同一份** peer 与依赖，
+ * 与基础代的 real path 一致 —— 不会出现两份 cordis/schemastery。
+ */
+/** 外壳一启动就把 OTA 落盘位置定下来（见 moveOtaRootIntoProfile 的注释）。 */
+moveOtaRootIntoProfile()
+
+/**
+ * 最近一次「给 OTA 代补依赖软链」的失败原因。
+ *
+ * 软链只是兜底（落在 profile 里的一代本来就能沿祖先目录解析到 profile 的依赖），可它
+ * **在 Windows 默认没有权限建**。旧实现把失败静默吞掉，于是现场只剩一句
+ * `Cannot find module`，看不出是缺依赖还是补链失败。记在这里，由状态接口如实报出来。
+ */
+let generationLinkError = null
+export function generationModulesError() {
+  return generationLinkError
+}
+
+function ensureGenerationModules(generation) {
+  if (!generation || generation.source !== 'ota' || !generation.dir) return
+  // 只认真正的 `node_modules`：`findProfileNodeModules()` 找不到时会回落到 profile 根，
+  // 把那个当依赖目录链过去等于凭空造一层错的解析路径。
+  if (path.basename(PROFILE_NODE_MODULES) !== 'node_modules' || !fs.existsSync(PROFILE_NODE_MODULES)) return
+  const versionDir = path.dirname(generation.dir)
+  const link = (target, at) => {
+    try {
+      if (fs.lstatSync(at).isSymbolicLink()) {
+        if (fs.readlinkSync(at) === target) return
+        fs.unlinkSync(at)
+      } else {
+        return // 已经是实体目录（有人手工铺过依赖）：不动它
+      }
+    } catch {
+      // 还不存在，往下建
+    }
+    try {
+      fs.symlinkSync(target, at, 'dir')
+      generationLinkError = null
+    } catch (error) {
+      // Windows 默认没有建软链的权限（要开发者模式或管理员），这类失败**必须留痕**：
+      // 否则现场只有一句 `Cannot find module`，看不出是缺依赖还是补链被拒。
+      generationLinkError = `补依赖软链失败（${at} → ${target}）：${error && typeof error === 'object' ? error.code || error.message : error}`
+      try { process.stderr.write(`[dsh-mobile-plugin] ${generationLinkError}\n`) } catch { /* ignore */ }
+    }
+  }
+  link(PROFILE_NODE_MODULES, path.join(versionDir, 'node_modules'))
+  const nested = path.join(PROFILE_NODE_MODULES, PLUGIN_PKG, 'node_modules')
+  if (fs.existsSync(nested)) link(nested, path.join(versionDir, PLUGIN_PKG, 'node_modules'))
+}
+
 /**
  * 动态 import 一个代。
  *
@@ -247,6 +344,7 @@ export async function importGeneration(generation) {
   const cacheKey = generationCacheKey(generation)
   const cached = imported.get(cacheKey)
   if (cached) return cached
+  ensureGenerationModules(generation)
   // 先把 CJS 缓存清干净再 import，否则「入口是新的、子模块还是旧的」，等于换了个半成品上去。
   evictCommonJsTree(evictionRoots(generation))
   importSeq += 1