dsh-mobile-plugin 0.1.93 → 0.1.95

package/lib/reconnect-scheduler.cjs

@@ -9,20 +9,47 @@
  *
  * 这里把「同一个待触发窗口内只保留一个定时器」这一不变量收敛成一个模块，
  * 以便用毫秒级延迟做真实的行为测试。端到端数连接次数是分不出来的：
- * 生产里延迟固定 5s，且 startTunnel 开头的 stopTunnel 会吸收重复定时器
- * 造成的大部分可见差异。
+ * startTunnel 开头的 stopTunnel 会吸收重复定时器造成的大部分可见差异。
+ *
+ * 延迟本身带**抖动**与**退避**：
+ *  - 抖动：中转重启（或宿主机休眠醒来）之后，所有宿主都会在同一刻掉线，固定 5s 会让
+ *    它们踩着同一个点回来；上下抖两千毫秒就把这一波摊开。
+ *  - 退避：连续失败（中转没起来、注册密钥不对）时不该每 5 秒敲一次，逐次翻倍到上限；
+ *    一次成功的注册由调用方 `reset()` 清账。
  */
-function createReconnectScheduler({ delayMs, onFire, setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+
+/** 连续失败最多翻到 delayMs 的 2^BACKOFF_EXP_CAP 倍（再被 maxDelayMs 压住）。 */
+const BACKOFF_EXP_CAP = 5
+
+function createReconnectScheduler({
+  delayMs,
+  jitterMs = 0,
+  maxDelayMs = Number.POSITIVE_INFINITY,
+  random = Math.random,
+  onFire,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+} = {}) {
   if (typeof delayMs !== 'number' || !(delayMs >= 0)) throw new Error('invalid delayMs')
+  if (typeof jitterMs !== 'number' || !(jitterMs >= 0)) throw new Error('invalid jitterMs')
+  if (typeof maxDelayMs !== 'number' || !(maxDelayMs > 0)) throw new Error('invalid maxDelayMs')
+  if (typeof random !== 'function') throw new Error('invalid random')
   if (typeof onFire !== 'function') throw new Error('invalid onFire')
   let timer = null
+  let misses = 0
   return {
     /** 排程一次重连；已有待触发的定时器时返回 false，表示被幂等吸收。 */
     schedule() {
       if (timer !== null) return false
-      timer = setTimer(() => { timer = null; onFire() }, delayMs)
+      const backoff = misses === 0 ? 1 : 2 ** Math.min(misses, BACKOFF_EXP_CAP)
+      const base = Math.min(delayMs * backoff, maxDelayMs)
+      const wait = base + (jitterMs > 0 ? Math.floor(random() * jitterMs) : 0)
+      misses += 1
+      timer = setTimer(() => { timer = null; onFire() }, wait)
       return true
     },
+    /** 连上之后清掉连续失败计数（下一次掉线重新从 delayMs 起算）。 */
+    reset() { misses = 0 },
     /** 取消待触发的重连（显式停止隧道时调用）。 */
     cancel() {
       if (timer === null) return

package/lib/relay/lan-proxy.js

@@ -17,6 +17,7 @@ const core = require('./core.js');
 const { isGlobalUnicastV6 } = require('./lan-network.cjs');
 const { safeEqual } = require('../shared/dshtoken');
 const { isFreshRequest } = require('../shared/fresh-request');
+const { encodeJsonBody } = require('../shared/http-util');
 const credentials = require('../shared/credentials-entry.js').credentialsEntry();
 
 const HOP_BY_HOP = new Set([
@@ -200,8 +201,15 @@ function createLanProxy(opts) {
     const body = isFreshRequest(req.url) ? null : readSnapshot({ method: req.method, path: req.url });
     if (body && body.ok) {
       try {
-        res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
-        res.end(JSON.stringify(body));
+        // 与中转那条同一条捷径：列表 / 工作区 / 消息 / 统计都在这里回，压缩才省得下来。
+        const encoded = encodeJsonBody(JSON.stringify(body), req.headers['accept-encoding']);
+        res.writeHead(200, {
+          'content-type': 'application/json; charset=utf-8',
+          'cache-control': 'no-store',
+          vary: 'accept-encoding',
+          ...(encoded.gzip ? { 'content-encoding': 'gzip' } : {}),
+        });
+        res.end(encoded.body);
       } catch { /* 已关闭 */ }
       return;
     }

package/lib/relay/protocol.js

@@ -11,11 +11,11 @@
  * - 控制消息（register / httpHead 等）payload 为 UTF-8 JSON；
  * - ping/pong 为应用层心跳（经代理/负载均衡时比 WS 原生 ping 更可靠）。
  *
- * 协议语义见 ../../../server/dsh-mobile-server/PROTOCOL.md（v2 章节）。
+ * 协议语义见 ../../../server/dsh-mobile-server/server/relay-core/PROTOCOL.md。
  *
  * 本文件是自包含副本（插件包不能跨目录引用中转仓库的文件），完整内联了共用类型表
- * 与编解码实现。类型表的事实源是 server/relay-core/protocol-types.js，
- * 由 dsh-mobile-plugin/test/protocol-parity.test.cjs 逐项对账；
+ * 与编解码实现。类型表的事实源在独立中转仓库的 server/relay-core/protocol-types.js；
+ * 本仓的 protocol-parity 测试钉住线格式，中转仓库另做 Rust 与 JS 字节对撞；
  * 改动帧编号后必须同步修改本文件。
  */
 

package/lib/relay/tunnel.js

@@ -14,6 +14,7 @@ const http = require('node:http');
 const { WebSocket } = require('ws');
 const { T, jsonFrame, encodeFrame, createFrameDecoder, parseJson, encodeClosePayload, decodeClosePayload } = require('./protocol.js');
 const { isFreshRequest } = require('../shared/fresh-request');
+const { encodeJsonBody } = require('../shared/http-util');
 
 const HEARTBEAT_INTERVAL_MS = 15_000;
 // Relay currently expires an idle tunnel after 60s. Keep a wider client-side
@@ -464,7 +465,10 @@ class RelayTunnel {
           fn(arg);
         }
       };
-      const ws = new WebSocket(this.relayUrl, { perMessageDeflate: true });
+      // 中转侧是 tokio-tungstenite 手写的 101，从不回 `sec-websocket-extensions`，
+      // 所以 permessage-deflate 一次都没协商成功过；开着只会让人以为隧道压过。
+      // 真省字节靠的是响应体的 gzip（见 lib/shared/http-util.js）。
+      const ws = new WebSocket(this.relayUrl);
       this.ws = ws;
       const timer = setTimeout(() => {
         done(reject, new Error('注册超时'));
@@ -572,9 +576,18 @@ class RelayTunnel {
         if (this.readSnapshot && !isFreshRequest(msg.path) && (msg.method === 'GET' || msg.method === undefined)) {
           const body = this.readSnapshot({ method: msg.method, path: msg.path });
           if (body && body.ok) {
-            const data = Buffer.from(JSON.stringify(body));
-            this.queueHttpResponseFrame(id, entry, T.httpHead, { status: 200, headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' } }, true);
-            this.queueHttpResponseFrame(id, entry, T.httpChunk, data);
+            // 这条捷径回的是列表 / 工作区 / 消息 / 统计这几条最重的读取，压缩的收益全在这儿。
+            const encoded = encodeJsonBody(JSON.stringify(body), msg.headers?.['accept-encoding']);
+            this.queueHttpResponseFrame(id, entry, T.httpHead, {
+              status: 200,
+              headers: {
+                'content-type': 'application/json; charset=utf-8',
+                'cache-control': 'no-store',
+                vary: 'accept-encoding',
+                ...(encoded.gzip ? { 'content-encoding': 'gzip' } : {}),
+              },
+            }, true);
+            this.queueHttpResponseFrame(id, entry, T.httpChunk, encoded.body);
             this.queueHttpResponseFrame(id, entry, T.httpEnd, Buffer.alloc(0));
             return;
           }

package/lib/routes/control-plane.js

@@ -48,6 +48,7 @@ const { createSelfCheck } = require('../mobile/self-check.cjs');
 const { checkForUpdate } = require('../update-registry.cjs');
 const { declaredSource } = require('../update-install.cjs');
 const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobile/session-cache.js');
+const { recordSessionRead } = require('../mobile/session-last-turn.js');
 
 /** 一次 desktop-read 上报最多带多少个会话 id（防灌爆；客户端半边一次最多也就几个）。 */
 const MAX_DESKTOP_READ_IDS = 200;
@@ -423,11 +424,21 @@ function registerControlPlaneRoutes(deps) {
     if (!ids.length) return sendJson(res, 200, { ok: true, cleared: 0 })
     if (!ctx) return sendJson(res, 200, { ok: true, cleared: 0 })
     let cleared = 0
-    for (const id of ids) cleared += clearCompletionForAllDevices(ctx, id)
+    let advanced = 0
+    const at = Date.now()
+    for (const id of ids) {
+      cleared += clearCompletionForAllDevices(ctx, id, at)
+      // 「这一轮被读过了」还要记一笔**设备无关**的水位：手机侧的点现在由它自己按这份
+      // 水位算（见 mobile/session-last-turn.js）。只清按设备的提醒的话，桌面点开之后
+      // 手机上那个点永远不会灭 —— 那条提醒本来就不在手机读取的路径上。
+      if (recordSessionRead(ctx, id, at)) advanced += 1
+    }
     desktopHalf.noteDesktopRead({ ids: ids.length, cleared })
-    // 有东西真被清掉才作废列表缓存：invalidateSessionList 会抬 generation，
-    // 让镜像推送器重建清单并广播 device/list-changed（见 A3-14）。
-    if (cleared > 0) invalidateSessionList(ctx)
+    // 作废列表缓存要抬 generation，让镜像推送器重建清单并广播 device/list-changed
+    // （见 A3-14）—— 只在**真有东西变了**时才调：已读水位进了下行清单，水位前进同样算
+    // 内容变了；但重复上报（客户端半边每 2s 报一批，多数都是旧的）绝不能每次都抬，
+    // 否则 App 的会话列表缓存会被永久压住。
+    if (cleared > 0 || advanced > 0) invalidateSessionList(ctx)
     return sendJson(res, 200, { ok: true, cleared })
   }) })
   // The process-level error ledger (see lib/host-guard.cjs). "Stop an unknown

package/lib/routes/mobile-api.js

@@ -36,8 +36,10 @@ const deepSeekAccount = require('../mobile/deepseek-account.js');
 const skills = require('../mobile/skills.js');
 const mobileCredentials = require('../mobile/credentials.js');
 const subagents = require('../mobile/subagents.js');
+const monitor = require('../mobile/monitor.js');
 const references = require('../mobile/references.js');
 const plugins = require('../mobile/plugins.js');
+const pluginUpdate = require('../mobile/plugin-update.js');
 const uploads = require('../mobile/uploads.js');
 const pairing = require('../mobile/pairing.js');
 const { credentialsEntry } = require('../shared/credentials-entry.js');
@@ -58,6 +60,9 @@ const API_VERSION = '1';
  *   let 变量，闭包捕获对象会让 handler 永远读到启动那一刻的旧快照（lan.updatedAt 停在
  *   进程启动时间，手机端看连接信息像失联了一样）。
  * @param {(port: number) => Array<object>} deps.safeLanCandidates 局域网候选地址
+ * @param {(port: number) => Array<object>} deps.safeIpv6Candidates 公网 IPv6 直连候选。
+ *   与上面那份并列、不并进它：手机拿这份和中转实测比快慢，掺进局域网那份就等于让它
+ *   跟「同一个 Wi-Fi」共用一套失败退避（手机刚离开家里 Wi-Fi 时正是最该试它的时候）。
  * @param {() => number} deps.lanPortInUse 手机该拨的局域网端口。**必须用取值器**：
  *   sidecar 自己 bind 到的端口可能与本进程解析出的不同（两条端口自适应），只认
  *   `state.lanPort` 会把这个接口变成「报一个没人监听的端口」——真机实测过 50933
@@ -71,7 +76,7 @@ const API_VERSION = '1';
  *   一次拒绝或一次握手。
  */
 function registerMobileRoutes(deps) {
-  const { registerRoute, registerUpgradeRoute, guarded, state, hostMetadata, getSidecarSnapshot, safeLanCandidates, lanPortInUse, preview, core, pairingApproval } = deps;
+  const { registerRoute, registerUpgradeRoute, guarded, state, hostMetadata, getSidecarSnapshot, safeLanCandidates, safeIpv6Candidates, lanPortInUse, preview, core, pairingApproval } = deps;
   const route = (path, handler) => registerRoute({ kind: 'exact', path, handler: guarded(handler) })
 
   registerRoute({ kind: 'exact', path: '/api/mobile/v1/status', handler: guarded(async (_ctx, _req, res) => {
@@ -135,6 +140,14 @@ function registerMobileRoutes(deps) {
     const candidates = state.lanEnabled
       ? orderCandidates(safeLanCandidates(port), state.preferredLanAddress)
       : []
+    // IPv6 直连候选：单独一份、**不参与**上面的排序 —— 它和中转谁更快只有手机实测得出，
+    // 宿主无从判断对端走哪条路由。与局域网那份同一个开关管（那条监听挂在同一个代理上），
+    // 关掉局域网直连就没有这条通道。
+    //
+    // 这份是手机配对之后**唯一**能拿到新 IPv6 地址的地方：二维码里带的候选只在配对那一刻
+    // 是真值，而隐私地址按小时轮换、运营商换前缀之后旧的那条就拨不通了。少回这一格，
+    // 手机上那条通道就只能靠配对当时的旧地址活着。
+    const ipv6 = state.lanEnabled ? safeIpv6Candidates(port) : []
     const lanUpdatedAt = getSidecarSnapshot()?.lan?.updatedAt || Date.now()
     sendJson(res, 200, {
       ok: true,
@@ -143,12 +156,17 @@ function registerMobileRoutes(deps) {
       relayUrl: state.enabled ? (state.relayUrl || null) : null,
       lanUrls: candidates,
       lanCandidates: candidates,
+      ipv6Candidates: ipv6,
       updatedAt: lanUpdatedAt,
       lastSeen: lanUpdatedAt,
     })
   })
 
   route('/api/mobile/v1/sessions', sessions.handleSessions)
+  // 后台提醒服务专用：只回「在跑 / 刚完成 / 待回话 / 上一轮失败」这几格，
+  // 带 `?rev=` 条件刷新。它要替掉原生那边每 8 秒一发的完整清单（那份还得为 20 个
+  // 会话各读一次 history 补预览），见 mobile/monitor.js。
+  route('/api/mobile/v1/monitor', monitor.handleMonitor)
   route('/api/mobile/v1/session', sessions.handleSession)
   route('/api/mobile/v1/session/messages', sessions.handleMessages)
   route('/api/mobile/v1/session/attachment', sessions.handleSessionAttachment)
@@ -254,6 +272,14 @@ function registerMobileRoutes(deps) {
   // 经 typertGateway 命名空间 pluginInventory 取，见 mobile/plugins.js。
   route('/api/mobile/v1/plugins', plugins.handlePlugins)
 
+  // 插件自更新：APP 的「应用更新」页给这台宿主升级插件版本（见 mobile/plugin-update.js）。
+  // 与桌面控制面 `/api/relay/update/*` 同一套实现，差别只在入口：那三条 localOnly，手机
+  // 永远打不到，而手机上聊天时「有对话在跑」那道闸几乎总关着 —— 自动更新等于不跑。
+  // 能力面有意放开给已配对设备，来源判据（只放行 npm 装的）不放开，理由写在那个文件头。
+  route('/api/mobile/v1/plugin/update/status', pluginUpdate.handlePluginUpdateStatus)
+  route('/api/mobile/v1/plugin/update/check', pluginUpdate.handlePluginUpdateCheck)
+  route('/api/mobile/v1/plugin/update/apply', pluginUpdate.handlePluginUpdateApply)
+
   // 分享文件的落地通道（App 把手机分享进来的文件分片传上来，见 mobile/uploads.js）。
   // 手机端没有「把文件交给宿主」的路：图片能进 session.send 的 base64 内容块，其它格式
   // 一律进不去。四条端点只做「收字节 → 落盘到 ~/.dsh/mobile-inbox/<日期>/<文件名>」，

package/lib/session-cleanup.cjs

@@ -1,9 +1,15 @@
 /**
  * 会话数据清理：按 sessionId 删除 dshHome 下的 sessions/** 目录与 project cache。
  *
- * 两个入口共用 deleteSessionData：DSH agent 工具 registerSessionCleanupTool（action=delete
+ * 两个入口共用同一套落地代码：DSH agent 工具 registerSessionCleanupTool（action=delete
  * 必须 confirm:true 且只针对已归档）与移动 API /workspace/clear-archived（archive-clean.js）。
  *
+ * **两个入口都不在进程里删磁盘**：只把 id 排进待删队列（dshHome 下的
+ * mobile-archived-clear.json），真正的删除放在宿主下次启动时做，见
+ * deleteQueuedArchivedSessions。宿主没有「删除会话」接口，进程活着的时候它手上那些会话
+ * 随时可能被读或写，文件不在就是一次未捕获的 ENOENT —— 宿主对未捕获异常是零容忍的，
+ * 整个进程退出，桌面端跟着消失（2026-10-20 就是这么闪退的）。
+ *
  * 认哪份文件、怎么读 id 都以宿主自己的规则为准，不按目录名猜：
  *  - 文件名 = `session[.vN].jsonl[.zstd]`（宿主 `dsh-session-format` 的
  *    CANONICAL_LOG_FILENAME + compressionSuffix：0 代不带 vN，压缩时才带 .zstd）。
@@ -12,10 +18,10 @@
  *  - 解压用 Node 自带的 zstd（DSH 自己就是这么读写日志的，宿主并不需要系统 zstd
  *    命令），不再 shell 出去：没装 zstd 命令的机器上它一缺就是 readHeader 静默返回
  *    undefined，整条删除路径空转。id 仍然取自日志第一行那条 header。
- *  - **进程活着的时候不擦宿主的归档集合**，只删日志；擦集合放到宿主启动时
- *    （pruneOrphanedArchivedSessionsOnce）。理由写在那个函数上：桌面端的会话列表是
- *    连上宿主时拉的一份快照 + 之后的事件增量，进程里擦集合等于把已经删掉、却还留在
- *    快照里的行放回正常列表。
+ *  - **进程活着的时候不删日志、也不擦宿主的归档集合**；两件事都放到宿主启动时
+ *    （pruneOrphanedArchivedSessionsOnce）。擦集合的理由写在那个函数上：桌面端的会话
+ *    列表是连上宿主时拉的一份快照 + 之后的事件增量，进程里擦集合等于把已经删掉、却还
+ *    留在快照里的行放回正常列表。删日志的理由见上面那段：进程里删 = 宿主随时可能踩空。
  *  - **Windows 上目录删不掉 ≠ 会话没删掉**：宿主对它打开过的会话一直握着 `session.lock`
  *    的写句柄，日志 unlink 成功后那个名字要等句柄关闭才消失（delete-pending），rmdir
  *    于是报 ENOTEMPTY。判据改成「目录里还有没有规范名日志」：没有就是删成了。
@@ -39,6 +45,7 @@ const CANONICAL_LOG_FILENAME = /^session(?:\.v[1-9][0-9]*)?\.jsonl(?:\.zstd)?$/
 const HEADER_MAX_BYTES = 64 * 1024
 
 const { envelopeValue, unwrap } = require('./mobile/envelope.js')
+const { rememberDeletedSessionIds } = require('./mobile/session-cache.js')
 
 function asItems(response) {
   const value = envelopeValue(response)
@@ -218,6 +225,104 @@ function sessionIdsWithoutAnyData(sessionIds) {
   return [...candidates, ...withoutData]
 }
 
+/**
+ * 「清理所有已归档」的待删队列：dshHome 下的一份小 JSON（`mobile-archived-clear.json`）。
+ *
+ * 用户点清理的那一刻**不动磁盘**，只把 id 记进这里；真正的删除在宿主下次启动时做，见
+ * deleteQueuedArchivedSessions。原因是宿主没有「删除会话」这个接口：进程活着的时候，
+ * 它内存里那些会话随时可能被读或写（列一遍会话、续写一条事件、开一条还没落盘的空白会话），
+ * 文件不在就是一次没人接的 ENOENT —— 宿主对未捕获异常零容忍，进程直接退出，桌面端窗口
+ * 跟着消失（2026-10-20 真机就是这么闪退的：清理删到一条 0 轮次的空白归档会话）。
+ *
+ * 队列是**并集**语义：同一批 id 点两次、两次清理之间换了批次，都只是往同一张表里加。
+ */
+const PENDING_ARCHIVED_CLEAR_FILE = 'mobile-archived-clear.json'
+
+function pendingArchivedClearFile() {
+  return path.join(dshHome(), PENDING_ARCHIVED_CLEAR_FILE)
+}
+
+/** 队列里的 id。文件不在 / 读坏了都当空：下一次点清理会把该排的重新排一遍。 */
+function readPendingArchivedClearIds() {
+  let text
+  try { text = fs.readFileSync(pendingArchivedClearFile(), 'utf8') } catch { return [] }
+  try {
+    const parsed = JSON.parse(text)
+    const list = parsed && Array.isArray(parsed.sessionIds) ? parsed.sessionIds : []
+    return [...new Set(list.filter((id) => typeof id === 'string' && id))]
+  } catch {
+    return []
+  }
+}
+
+/**
+ * 整份覆写队列；空队列就删文件。
+ *
+ * 写失败**向上抛**：排不上队就不能回「已清理」——那等于告诉用户删掉了，重启之后它们
+ * 原样回来。调用方（清理路由 / agent 工具）自带失败通道，不需要在这里兜。
+ */
+function writePendingArchivedClearIds(sessionIds) {
+  const file = pendingArchivedClearFile()
+  const unique = [...new Set((Array.isArray(sessionIds) ? sessionIds : []).filter((id) => typeof id === 'string' && id))]
+  if (unique.length === 0) {
+    fs.rmSync(file, { force: true })
+    return []
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  // 先写临时文件再改名：宿主随时可能被杀，半截 JSON 会让下一次启动整队读不出来。
+  const temp = `${file}.${process.pid}.tmp`
+  fs.writeFileSync(temp, `${JSON.stringify({ sessionIds: unique }, null, 2)}\n`)
+  fs.renameSync(temp, file)
+  return unique
+}
+
+/** 把一批 id 排进队列（并集、幂等），返回排完之后的整队。 */
+function queueArchivedClearIds(sessionIds) {
+  const incoming = Array.isArray(sessionIds) ? sessionIds : []
+  return writePendingArchivedClearIds([...readPendingArchivedClearIds(), ...incoming])
+}
+
+/**
+ * 宿主刚启动时把队里排着的日志真正删掉，删成的从队列里摘掉。
+ *
+ * 只在这个时刻删：桌面端还没连上（或正要重连，快照本来就从磁盘重新拉），宿主手上也没有
+ * 任何热会话，不存在「正读着 / 正写着被删掉的那条」。某一条删不掉（日志还在盘上）不算整轮
+ * 失败 —— 它的 id 留在队里等下次启动，其余照删。deleteSessionData 中途抛错时已经删掉的
+ * 那批靠 sessionIdsWithoutAnyData 补账（返回值随异常丢了）。
+ *
+ * @returns {Promise<{deleted: string[], kept: string[]}>}
+ */
+async function deleteQueuedArchivedSessions(log, ctx) {
+  const queued = readPendingArchivedClearIds()
+  if (queued.length === 0) return { deleted: [], kept: [] }
+  let removed = []
+  try {
+    removed = await deleteSessionData(queued)
+  } catch (error) {
+    log?.(`archived clear queue: ${error && error.message ? error.message : String(error)}`)
+  }
+  const done = new Set([...removed, ...sessionIdsWithoutAnyData(queued)])
+  const deleted = queued.filter((id) => done.has(id))
+  const kept = queued.filter((id) => !done.has(id))
+  writePendingArchivedClearIds(kept)
+  // 出队之后还得在本进程继续压住：宿主那份会话清单可能是清理之前建好的，行还在里面。
+  // 没有这一步，手机上会冒出一条点进去什么都没有的归档行（修剪成功时它甚至会被当成
+  // 未归档的普通行露出来）。
+  if (ctx && deleted.length > 0) rememberDeletedSessionIds(ctx, deleted)
+  return { deleted, kept }
+}
+
+/**
+ * 队列里的 id 在手机上必须继续看不到：插件的删除集是**进程内**的，宿主重启、代际热替换
+ * 都会丢，而队列里的会话在宿主那边还活着（归档列表照样列得出它们）。每次装载都从队列
+ * 里补一遍，两次启动之间也不会复活。
+ */
+function restoreQueuedArchivedClearIds(ctx) {
+  const queued = readPendingArchivedClearIds()
+  if (queued.length > 0) rememberDeletedSessionIds(ctx, queued)
+  return queued
+}
+
 async function pruneOrphanedArchivedSessions(ctx) {
   const workspaceList = ctx && ctx.apiProxy && ctx.apiProxy.workspace ? ctx.apiProxy.workspace.list : undefined
   if (typeof workspaceList !== 'function') return 0
@@ -234,27 +339,47 @@ async function pruneOrphanedArchivedSessions(ctx) {
 }
 
 /**
- * 宿主进程启动时修剪一次归档集合，然后整个进程不再碰。
+ * 宿主进程启动时做一次收尾，然后整个进程不再碰：先删队里排着的日志，再修剪归档集合。
  *
- * 这件事只能在启动这一刻做：桌面端的会话列表是「连上宿主时拉的一份快照 + 之后的事件
- * 增量」，宿主本身没有「删除会话」的接口，插件在磁盘上删日志它也看不见。进程活着的时候
- * 擦归档集合，宿主会把「归档集合变了」广播给桌面端，桌面端就把它快照里那些其实已经
- * 没有日志、本来被归档藏着的行放回正常列表 —— 用户报的正是「清理后它们又回来了，重启
- * DSH 才真的消失」。启动时桌面端还没连上（或正要重连，快照本来就从磁盘重新拉），擦掉
- * 不会放出任何行。留在集合里的死 id 不显示在任何地方：「已归档」取的是会话列表与归档
- * 集合的交集，没有日志就没有那一行。
+ * 这两件事都只能在启动这一刻做：
+ *  - **删日志**：宿主没有「删除会话」接口，进程活着时它随时可能去开那些文件；文件不在
+ *    就是一次未捕获的 ENOENT，宿主直接退出（2026-10-20 桌面端闪退就是这条）。
+ *  - **擦归档集合**：桌面端的会话列表是「连上宿主时拉的一份快照 + 之后的事件增量」，
+ *    进程活着的时候擦集合，宿主会把「归档集合变了」广播给桌面端，桌面端就把它快照里
+ *    那些其实已经没有日志、本来被归档藏着的行放回正常列表 —— 用户报的正是「清理后
+ *    它们又回来了，重启 DSH 才真的消失」。启动时快照本来就从磁盘重新拉，擦掉不会放出
+ *    任何行。留在集合里的死 id 不显示在任何地方：「已归档」取的是会话列表与归档集合
+ *    的交集，没有日志就没有那一行。
  *
  * 用进程级标记而不是模块变量：代际热替换会重跑 apply，而桌面端那条快照挂在同一个进程上。
  */
 const PRUNE_ONCE = Symbol.for('dsh-mobile-plugin.archived-prune')
+const PRUNE_ATTEMPTS = 3
+const PRUNE_RETRY_MS = 500
 async function pruneOrphanedArchivedSessionsOnce(ctx, log) {
   if (globalThis[PRUNE_ONCE]) return
   globalThis[PRUNE_ONCE] = true
+  // 删日志不碰宿主，先做：越早越好，别等宿主把 workspace 服务挂齐（那时桌面端可能已经连上）。
   try {
-    const pruned = await pruneOrphanedArchivedSessions(ctx)
-    if (pruned > 0) log?.(`archived session prune: dropped ${pruned} deleted session ids`)
+    const { deleted, kept } = await deleteQueuedArchivedSessions(log, ctx)
+    if (deleted.length > 0) log?.(`archived clear queue: deleted ${deleted.length} session logs`)
+    if (kept.length > 0) log?.(`archived clear queue: ${kept.length} session logs kept for the next start`)
   } catch (error) {
-    log?.(`archived session prune failed: ${error && error.message ? error.message : String(error)}`)
+    log?.(`archived clear queue failed: ${error && error.message ? error.message : String(error)}`)
+  }
+  // 修剪要等宿主的 workspace 服务就绪：0.2.x 的 workspace.list 就是 workspace.follow 的
+  // 首帧，刚启动那一下常常还没开出来。以前一次失败就把整轮收尾丢掉，结果是归档集合里
+  // 的死 id 一直没人清（实测宿主重启过一次，315 个没有日志的 id 原样挂着）。
+  for (let attempt = 1; attempt <= PRUNE_ATTEMPTS; attempt += 1) {
+    try {
+      const pruned = await pruneOrphanedArchivedSessions(ctx)
+      if (pruned > 0) log?.(`archived session prune: dropped ${pruned} deleted session ids`)
+      return
+    } catch (error) {
+      const message = error && error.message ? error.message : String(error)
+      if (attempt === PRUNE_ATTEMPTS) log?.(`archived session prune failed: ${message}`)
+      else await new Promise((resolve) => setTimeout(resolve, PRUNE_RETRY_MS * attempt))
+    }
   }
 }
 
@@ -292,19 +417,20 @@ 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)
-  return { action: args.action, cwd, selected: ids.length, archived: 0, deleted: deletedIds.length, failed: ids.length - deletedIds.length, sessionIds: deletedIds }
+  // 与移动端那条路由同一口径：进程里只排队，**日志留到宿主下次启动时删**。进程活着时
+  // 删日志，宿主随时可能去开一条已经不存在的文件，那是未捕获异常（会带走整个宿主）。
+  queueArchivedClearIds(ids)
+  rememberDeletedSessionIds(ctx, ids)
+  return { action: args.action, cwd, selected: ids.length, archived: 0, deleted: ids.length, failed: 0, sessionIds: ids }
 }
 
 function registerSessionCleanupTool(ctx) {
   const { defineTool } = require('@deepseek-ai/dsh-tools')
   ctx.tools.register(defineTool({
     name: 'session_cleanup',
-    description: 'Archive or permanently delete old DSH sessions. Delete only targets already archived sessions and requires confirm=true.',
+    description: 'Archive or permanently delete old DSH sessions. Delete only targets already archived sessions, requires confirm=true, and drops their logs when the host next starts.',
     parameters: {
-      action: { type: 'string', required: true, enum: ['archive', 'delete'], description: 'archive hides sessions; delete permanently removes their logs and local projection cache.' },
+      action: { type: 'string', required: true, enum: ['archive', 'delete'], description: 'archive hides sessions; delete schedules permanent removal of their logs and local projection cache at the next host start.' },
       cwd: { type: 'string', description: 'Project directory to target. Required when selecting by age across multiple projects.' },
       olderThanMinutes: { type: 'number', description: 'Only target sessions not updated within this many minutes. Defaults to 30.' },
       minProjectSessions: { type: 'integer', description: 'Skip the operation when the selected project has fewer sessions than this number.' },
@@ -315,24 +441,31 @@ function registerSessionCleanupTool(ctx) {
       schema: { type: 'object', additionalProperties: false, properties: {
         action: { type: 'string' }, cwd: { type: 'string' }, selected: { type: 'integer' }, archived: { type: 'integer' }, deleted: { type: 'integer' }, failed: { type: 'integer' }, sessionIds: { type: 'array', items: { type: 'string' } }, failures: { type: 'array', items: { type: 'object' } },
       } },
-      render: (_args, value) => [{ type: 'text', text: `${value.action === 'archive' ? 'Archived' : 'Deleted'} ${value.action === 'archive' ? value.archived : value.deleted} sessions.` }],
+      render: (_args, value) => [{ type: 'text', text: value.action === 'archive' ? `Archived ${value.archived} sessions.` : `Scheduled ${value.deleted} sessions for removal; their logs are deleted the next time the host starts.` }],
     },
     execute: (args) => cleanupSessions(ctx, args),
   }))
 }
 
 /**
- * 装配层的入口：注册 agent 的清理工具，同时在「宿主刚起来」时修剪一遍归档集合。
+ * 装配层的入口：注册 agent 的清理工具，同时在「宿主刚起来」时删掉待删队列里的日志、
+ * 修剪一遍归档集合。
  *
- * 两件事都是会话清理的一部分，所以共用装配层那一处 effect；impl.js 有行数兜底守卫，
+ * 三件事都是会话清理的一部分，所以共用装配层那一处 effect；impl.js 有行数兜底守卫，
  * 别把实现搬回去。
  */
 function installSessionCleanup(ctx) {
+  // 队列里的 id 每次装载都要补回删除集：宿主重启、代际热替换都会丢掉进程内那份，
+  // 而它们在宿主那边还活着（归档列表照样列得出），漏一次手机上就「又回来了」。
+  try {
+    restoreQueuedArchivedClearIds(ctx)
+  } catch { /* 读不出来就当没有：用户再点一次清理会重新排队 */ }
   // 「宿主启动时」不能只看进程级标记：升级到这份实现那次是**热替换**进来的（进程早就在跑），
   // 标记还没被谁设过。那一刻桌面端的会话列表快照里可能正挂着之前删掉的行，擦集合就会把它们
   // 放回列表。所以只在进程刚起的这点窗口里修剪；晚于它就留给下次启动。
   if (process.uptime() <= BOOT_PRUNE_WINDOW_SECONDS) {
-    // 修剪先挂：没有 tools 注入的 profile 注册不了工具（外层会吞掉这条错），但归档集合照样要收尾。
+    // 收尾先挂：没有 tools 注入的 profile 注册不了工具（外层会吞掉这条错），但队列里的日志
+    // 与归档集合照样要收尾。
     void pruneOrphanedArchivedSessionsOnce(ctx, (message) => {
       try { ctx.logger?.info?.(message) } catch { /* 日志失败不影响修剪 */ }
     })
@@ -340,4 +473,4 @@ function installSessionCleanup(ctx) {
   registerSessionCleanupTool(ctx)
 }
 
-module.exports = { cleanupSessions, registerSessionCleanupTool, installSessionCleanup, deleteSessionData, sessionIdsWithoutAnyData, forgetArchivedSessions, pruneOrphanedArchivedSessions, pruneOrphanedArchivedSessionsOnce }
+module.exports = { cleanupSessions, registerSessionCleanupTool, installSessionCleanup, deleteSessionData, sessionIdsWithoutAnyData, forgetArchivedSessions, pruneOrphanedArchivedSessions, pruneOrphanedArchivedSessionsOnce, deleteQueuedArchivedSessions, queueArchivedClearIds, readPendingArchivedClearIds, restoreQueuedArchivedClearIds }

package/lib/shared/desktop-view-signal.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * 「桌面侧栏折叠态变了」的信号总线。
+ *
+ * 桌面端那份 groupExpansion 只活在浏览器 localStorage 里，插件靠客户端半边轮询上报
+ * （lib/client.js 每 2 秒读一次，变了才 POST /api/relay/desktop-view），落到
+ * lib/desktop-view.cjs。手机要看这份镜像只有一条路：GET /api/mobile/v1/desktop-view。
+ *
+ * 过去 App 按一个 5 分钟最短间隔去问它 —— 因为没有任何「它变了」的信号可用：列表
+ * revision 只哈希会话与工作区，桌面改折叠不动它。那套是「猜一个足够长的周期」，
+ * 稳态下一天白问几百次。本模块给出真正的出口：上报落盘且**内容真变了**时广播一次，
+ * 设备级流立刻推给手机，App 收到才拉。
+ *
+ * 与 list-signal 同款模块级单例：生产端（desktop-view.cjs）与消费端
+ * （mobile/events.js）不需要互相认识；测试用 createDesktopViewSignal() 造独立实例。
+ *
+ * 内容没变不广播：客户端半边会重复 POST 同一份（页面重载、切窗口都会重来一次），
+ * 每次都给每台手机推一帧，等于把「5 分钟一问」换成「一上报一帧」。
+ */
+
+const NOOP_RELEASE = () => {};
+
+function createDesktopViewSignal() {
+  const listeners = new Set();
+  let updatedAt = 0;
+  let at = 0;
+
+  return {
+    /**
+     * 广播一次折叠态变更。同一个 updatedAt 连着广播两次只算一次（幂等）。
+     *
+     * @param {number} nextUpdatedAt 快照的 receivedAt（desktop-view.cjs 落盘时的时间）
+     * @returns {boolean} 是否真的广播了
+     */
+    bump(nextUpdatedAt) {
+      const value = Number(nextUpdatedAt) || 0;
+      if (value && value === updatedAt) return false;
+      updatedAt = value;
+      at = Date.now();
+      for (const listener of [...listeners]) {
+        try { listener({ updatedAt, at }); } catch { /* 订阅者自己的异常不该影响上报链路 */ }
+      }
+      return true;
+    },
+
+    /** 订阅变更；返回退订函数（可重复调用）。 */
+    onBump(listener) {
+      if (typeof listener !== 'function') return NOOP_RELEASE;
+      listeners.add(listener);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        listeners.delete(listener);
+      };
+    },
+
+    /** 最近一次变更（供断流重连后的补发与诊断）。 */
+    snapshot() { return { updatedAt, at }; },
+  };
+}
+
+const desktopViewSignal = createDesktopViewSignal();
+
+module.exports = { createDesktopViewSignal, desktopViewSignal };