dsh-mini-remote 0.2.0 → 0.2.1

package/lib/index.js

@@ -28,6 +28,8 @@ import { randomBytes, randomUUID } from 'node:crypto'
 import z from '@deepseek-ai/schemastery'
 
 import { createStore } from './store.js'
+import { createDevices, credentialLooksLikeOurs } from './devices.js'
+import { createRemotes, normalizeBaseUrl } from './remotes.js'
 import { createTurnTracker, visibleText, stepSelfTalk } from './events.js'
 import { replayHistory, lastReply } from './history.js'
 import { createTrajectoryTracker, replayTrajectory, capTrajectory } from './trajectory.js'
@@ -48,7 +50,7 @@ import {
   parseSlashLine, describeCommands, commandRow, commandPatch,
   invalidCommandMessage, unknownCommandMessage,
 } from './commands.js'
-import { createMiniServer, miniControl, sendJson, readBody } from './server.js'
+import { createMiniServer, miniControl, sendJson, readBody, tokenEquals, LOCAL_WINDOW_DEVICE } from './server.js'
 import { createMirror } from './mirror.js'
 import { sendExternalNotification } from './notify.js'
 import { createFeishuChannel, feishuQuestionText, approvalText, FEISHU_TEXT_LIMIT } from './lark.js'
@@ -63,7 +65,7 @@ import { createSessionMetaCache } from './session-meta-cache.js'
 import { createSubagentCache } from './subagent-cache.js'
 import { listRoots, listDirectory, makeDirectory } from './browse.js'
 import { listPresets, setPreset, available as presetsAvailable } from './permissions.js'
-import { buildId } from './build.js'
+import { buildId, newestSource } from './build.js'
 
 export const name = 'dsh-mini-remote'
 // `sessionController` 是 DSH 的宿主会话业务接口（`@deepseek-ai/dsh-api-session-controller`
@@ -77,6 +79,15 @@ export const inject = ['agents', 'sessionController']
 /** 公网隧道起不来时重试几次——向 Cloudflare 注册会偶发超时，实测大约一半概率。 */
 const TUNNEL_ATTEMPTS = 3
 
+/**
+ * B 侧去另一台电脑打一次接口，最多等多久。
+ *
+ * 给一个上限不是可选项：对面不通（地址写错、没开机、不在同一个网络里）时，
+ * 界面会一直转圈，而用户看不出是"在等"还是"坏了"。8 秒够内网和 Tailscale 上
+ * 一个来回，又不至于让人干等。
+ */
+const REMOTE_CALL_TIMEOUT_MS = 8000
+
 /**
  * 手机上最多同时挂着几个「传了但还没发出去」的文件。
  *
@@ -154,6 +165,29 @@ const DEFAULTS = {
     /** 允许的 chat_id，同上。两个都空 = 任何来源都不处理。 */
     chatIds: '',
   },
+  /**
+   * 跨机「远程窗口」：**允许别的电脑连到这台电脑来**（2026-10-16 跨机第二步）。
+   * 默认**关**。
+   *
+   * ## 为什么默认关（方案文档第五节那份判断，照办）
+   *
+   * 本机版那张票的前提是「只有本机回环上的宿主发得出来」，而本机的软件本来就有这台
+   * 电脑的全部权限，所以它没挂开关。**跨机之后这个前提消失了**——来换票的人在另一台
+   * 电脑上，而它换到的是**整个电脑端界面**（会话记录、模型配置、插件装卸全在里面），
+   * 比手机那条路能碰到的更多。这个边界该由用户自己划，不能替他默认打开。
+   *
+   * ## 「关」是一个整体状态（用户拍板）
+   *
+   * 关着的时候，**两条跨机路由一条都不接**：配对（`/mini-remote/pair`）和跨机取票
+   * （`/mini-remote/remote/window`）。只关一条的话，"关"就变成了"少录一项配置"，
+   * 用户读不懂；两条一起关才等于他要的那句话：**这台电脑不接受别的电脑连过来**。
+   *
+   * ## 为什么是一个平铺的布尔
+   *
+   * `tunnel` / `feishu` 那两层是因为各自还有别的字段（路径、凭据、名单）。这里就一个
+   * 开关，套一层只会让读的人多跳一次。
+   */
+  allowRemoteComputers: false,
 }
 
 /**
@@ -225,6 +259,17 @@ export const Config = z.object({
     openIds: z.string(),
     chatIds: z.string(),
   }).description('飞书（长连接）：机器人的两个凭据与两个允许名单。改了要重载插件（凭据变了得重建连接）。'),
+  /**
+   * 跨机「远程窗口」那个总开关（2026-10-16 跨机第二步）。默认关。
+   *
+   * **不标 volatile**（和飞书同一条口径，理由不同）：插件自己的设置页存完**就地生效**
+   * ——那两条跨机路由读的是同一个 `settings`（见下面 `pairingPayload` 与那两条路由），
+   * 所以不必重载插件；只有手改 settings.json 的人需要重载一次（DSH 只在加载时读那份
+   * 文件）。标了 volatile 等于向 DSH 承诺"改它不用重载"，而这里兑现得了，但会让这个
+   * 开关在 DSH 自己的配置表单里也出现一份——同一个开关两处可点，用户迟早对不上。
+   */
+  allowRemoteComputers: z.boolean()
+    .description('允许别的电脑连过来（配对 + 跨机取票）。默认关；手改 settings.json 之后要重载插件。'),
 })
 
 function deepMerge(base, ...overrides) {
@@ -246,6 +291,94 @@ function dataDir() {
   return join(home, 'dsh-mini-remote')
 }
 
+/**
+ * 这份插件在磁盘上的版本号（`package.json` 的 `version`）。自检那一栏要它。
+ *
+ * **每次现读**、不在加载时抄一份：抄一份的话，用户装上新版之后自检里那个号码还是旧的，
+ * 而那正是最需要看准的一格。读不到（文件缺了、内容不是 JSON）回 `null`——
+ * 自检宁可说「未知」，也不抛错。
+ *
+ * 「进程加载的是不是这一版」不靠它判断，靠下面 `staleCodeVerdict` 那条时刻比较。
+ */
+function pluginVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+    return typeof pkg?.version === 'string' && pkg.version ? pkg.version : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 「现在应答我的，是不是最新那份代码」——自检里最要紧的一句话（2026-10-17）。
+ *
+ * 判据只有一条：**进程的启动时刻早于插件文件最后被改动的时刻**。早于，说明那份文件
+ * 是进程起来之后才写下的，而 Node 只在启动时读一次代码——那些改动现在还没生效。
+ * 这正是那天真机上那件怪事的样子：桌面端连开一天，装是装了新版，跑的却是旧的。
+ *
+ * 两个时刻任何一个拿不到，`stale` 一律回 **`null`（未知）**，不猜：猜错的代价是
+ * 用户去重启一次白折腾，或者更糟——真旧了却告诉他"是最新的"。
+ *
+ * @param {number} startedAtMs 进程启动时刻（`Date.now() - process.uptime()*1000`）
+ * @param {{file:string, at:number}|null} newest `newestSource()` 的结果
+ * @returns {{stale:boolean|null, file:string|null, message:string|null}}
+ *//** 最近错误缓冲的容量与单条长度上限（见 `apply` 里 `recentErrors` 那段）。 */
+const RECENT_ERRORS_MAX = 20
+const RECENT_ERROR_TEXT_MAX = 300
+
+/**
+ * 把消息里属于我们自己的凭据换成 `***`。
+ *
+ * ## 为什么它必须存在
+ *
+ * 自检会把错误消息**摆到界面上**，而错误消息很容易夹着带凭据的东西：跨机那条路
+ * 失败时回的话就带着 `baseUrl`（今天不带凭据，但那是设计约束、不是形状保证），
+ * 飞书 SDK 的报错还常把请求详情拼进去。原样进缓冲，等于自己给自己开一条泄漏路。
+ *
+ * ## 判据和 `lib/server.js` 的 `stripOurSecrets` 是同一条：**看值，不看参数名**
+ *
+ * 参数名可以换（`token=` 写成 `device=` 照样转发），所以按名字摘是摘不干净的。
+ * 设备凭据那个形状复用 `credentialLooksLikeOurs`——那份正则只许有一处
+ * （见 lib/devices.js 上面那段注释）。
+ *
+ * ## 为什么是导出给测试的纯函数
+ *
+ * 和 `staleCodeVerdict` 同一个理由：脱敏这件事**必须能被单独钉住**。埋在闭包里只能
+ * 靠"造一个泄漏事故"来验，而那正是我们不想在测试里排练的事。
+ *
+ * @param {unknown} text 原始消息（不是字符串就按字符串处理）
+ * @param {string[]} secrets 这台电脑上已知的凭据值（口令、飞书密钥……），按**值**换
+ * @returns {string} 已脱敏、且截到 `RECENT_ERROR_TEXT_MAX` 字的消息
+ */
+export function redactSecrets(text, secrets = []) {
+  let s = String(text ?? '')
+  // ① 已知凭据按值换。短于 4 位不换：那多半是 "ab" 这种碎片，换了会伤到正常文字。
+  for (const value of Array.isArray(secrets) ? secrets : []) {
+    if (typeof value === 'string' && value.length >= 4) s = s.split(value).join('***')
+  }
+  // ② 查询串里的凭据参数：名字对得上就换（值可能是编码过的，也可能带标点）。
+  s = s.replace(/([?&](?:token|device|credential|app_secret)=)[^&\s"'<>]+/gi, '$1***')
+  // ③ 兜底：任何一段整体长得像我们的设备凭据，无论出现在哪儿都换。
+  s = s.replace(/[^\s"'<>()[\]]+/g, (piece) => (credentialLooksLikeOurs(piece) ? '***' : piece))
+  return s.slice(0, RECENT_ERROR_TEXT_MAX)
+}
+
+export function staleCodeVerdict(startedAtMs, newest) {
+  const file = newest?.file ?? null
+  const at = newest?.at
+  if (!Number.isFinite(startedAtMs) || !Number.isFinite(at)) {
+    return { stale: null, file, message: null }
+  }
+  const stale = startedAtMs < at
+  return {
+    stale,
+    file,
+    message: stale
+      ? '这台电脑的插件可能不是最新的，重启 DSH 才会加载新版本。'
+      : null,
+  }
+}
+
 function readJson(file) {
   try {
     return JSON.parse(readFileSync(file, 'utf8'))
@@ -341,6 +474,29 @@ export function apply(ctx, config = {}) {
   }
   const token = loadOrCreateToken(dir, settings.token)
   const store = createStore({ file: join(dir, 'state.json'), maxHistory: settings.maxHistory })
+  /**
+   * 「设备身份」名册（见 lib/devices.js）：一台手机一条，落盘在同一个数据目录里。
+   *
+   * **为什么和 settings.json 分开放**：那是给用户手改的文件，字段会进设置页那张表单
+   * ——把密钥哈希混进去，等于让「改个设置」有机会碰坏登录凭据。这份名册由插件自己管，
+   * 用户要看也是下一步的设置页按它渲染一份名单。
+   *
+   * 这份东西**和「远程窗口」那套是两个人**（lib/mirror.js）：那张票是一次通行证、
+   * 寿命跟着宿主进程、只够进镜像；这里是长期名单、要落盘、认的是手机。两者不合并，
+   * 手机也不会因为被登记就多得到镜像权限（那条权限挂在「进阶设置」那个开关上，没动）。
+   */
+  const devices = createDevices({ file: join(dir, 'devices.json') })
+  /**
+   * 「我能连的电脑」名册（**B 侧**，见 lib/remotes.js）：B 记着"我连得上哪几台电脑"。
+   *
+   * 和 `devices.json` **并排、不合并**：那份记的是"谁连得上我"（A 侧，密钥只存哈希），
+   * 这一份记的是"我连得上谁"，里面那枚凭据是**别人发给我的长期门卡**，必须原样留着。
+   * 两个方向、两种东西，混在一份文件里只会让"撤销"和"断开"分不清。
+   *
+   * 同样**不进 settings.json**（那是给用户手改、会进设置页表单的文件）——理由和
+   * devices.json 当初定的一模一样，见 lib/remotes.js 开头那一段。
+   */
+  const remotes = createRemotes({ file: join(dir, 'remotes.json') })
   /**
    * 会话标题的落盘缓存（见 lib/title-cache.js）。
    *
@@ -384,6 +540,45 @@ export function apply(ctx, config = {}) {
     warn: (m) => console.warn(`[dsh-mini-remote] ${m}`),
   }
 
+  /**
+   * 最近发生的错误，先进先出，最多 20 条。
+   *
+   * ## 为什么要有它（2026-10-17，两次真机故障的产物）
+   *
+   * 三块错误本来各有各的字段（`serverError` / `tunnelError` / `feishuError`），而且都会
+   * `log.warn` 一句。问题不在"没有记录"，在**记录只到 stdout**：用户看着图形界面，
+   * 终端里写了什么他一个字都看不到。而跨机那条路连状态字段都没有 —— `callRemote` 失败时
+   * 只把一句话回给界面，**不留痕**。
+   *
+   * 于是那天两次故障都只能靠猜：一次是桌面端连开 24 小时（跑的还是旧代码），一次是
+   * 另一台装的是旧版本。自检能回答"版本对不对"，这个缓冲回答"刚才出了什么事"。
+   *
+   * ## 只留 20 条、每条 300 字，不落盘
+   *
+   * 它**不是日志**：重启即清空、按条数淘汰、只回答"刚才发生了什么"，不回答"上周三下午
+   * 发生了什么"。要长历史就去 stdout。
+   */
+  const recentErrors = []
+
+  /**
+   * 记一条错误：进缓冲，同时照旧打一行 stdout。
+   *
+   * `kind` 是给人看的分类：`service`（手机服务起不来）、`tunnel`（公网隧道）、
+   * `feishu`（飞书长连接）、`notify`（外部推送）、`remote`（跨机那一头不通）、
+   * `internal`（别的地方兜到的）。分类不是为了统计，是为了让用户一眼看出"是哪一块在坏"。
+   *
+   * **文本一律先过 `redactSecrets`**：这里是错误消息唯一进入界面的通道，也是唯一可能
+   * 把凭据带出去的地方（见那个函数上面那段）。
+   */
+  function report(kind, message) {
+    // 口令和飞书密钥按**值**换：这两个是这台电脑上最要命的两样。
+    const line = redactSecrets(message, [token, settings?.feishu?.appSecret])
+    recentErrors.push({ at: Date.now(), kind, message: line })
+    if (recentErrors.length > RECENT_ERRORS_MAX) recentErrors.shift()
+    // 行为与从前完全一致：以前这儿是裸 `log.warn`，现在只是多存了一份。stdout 那条路没变。
+    log.warn(`[${kind}] ${line}`)
+  }
+
   /** @type {Awaited<ReturnType<typeof createMiniServer>> | null} */
   let server = null
 
@@ -592,7 +787,7 @@ export function apply(ctx, config = {}) {
     try {
       writeFileSync(settingsFile, `${JSON.stringify(settings, null, 2)}\n`)
     } catch (err) {
-      log.warn(`配置写不进去：${err?.message ?? err}`)
+      report('service', `配置写不进去：${err?.message ?? err}`)
     }
   }
 
@@ -609,7 +804,7 @@ export function apply(ctx, config = {}) {
       })
       if (!found.path) {
         tunnelError = found.error
-        log.warn(`公网访问没起来：${found.error}`)
+        report('tunnel', `公网访问没起来：${found.error}`)
         return
       }
       if (found.source === 'downloaded') log.info('cloudflared 准备好了。')
@@ -634,7 +829,7 @@ export function apply(ctx, config = {}) {
             // 我们自己关的不算故障
             if (!tunnelWanted) return
             tunnelError = `隧道断了（cloudflared 退出码 ${code}），公网那边暂时连不上。\n\n${TUNNEL_HINT}`
-            log.warn(tunnelError)
+            report('tunnel', tunnelError)
           })
           return
         } catch (err) {
@@ -646,10 +841,10 @@ export function apply(ctx, config = {}) {
         }
       }
       tunnelError = `${TUNNEL_ATTEMPTS} 次都没起来。${lastError?.message ?? lastError}\n\n${TUNNEL_HINT}`
-      log.warn(`公网访问没起来：${tunnelError}`)
+      report('tunnel', `公网访问没起来：${tunnelError}`)
     } catch (err) {
       tunnelError = err?.message ?? String(err)
-      log.warn(`公网访问没起来：${tunnelError}`)
+      report('tunnel', `公网访问没起来：${tunnelError}`)
     } finally {
       tunnelStarting = false
     }
@@ -699,7 +894,7 @@ export function apply(ctx, config = {}) {
           tunnelError = '隧道本身是通的，但这台电脑解析不了这个域名。\n\n'
             + '多半是代理或路由器的问题。先试试关掉代理；还不行就在手机上换成流量，'
             + '或者把电脑的 DNS 改成 1.1.1.1。'
-          log.warn(tunnelError)
+          report('tunnel', tunnelError)
           return
         }
         tunnelProbeFails += 1
@@ -707,7 +902,7 @@ export function apply(ctx, config = {}) {
         tunnelHealthy = false
         tunnelError = '公网隧道还开着，但已经连不上了：'
           + `${code || err?.message || err}。手机打开会看到 Cloudflare 的 Error 1033。\n\n${TUNNEL_HINT}`
-        log.warn(tunnelError)
+        report('tunnel', tunnelError)
         // 判死之后就别再打了：结果不会变，白跑网络。
         stopTunnelProbe()
       }
@@ -725,7 +920,7 @@ export function apply(ctx, config = {}) {
     if (notify.onlyWhenBackground !== false && store.isForeground()) return
     sendExternalNotification(notify, text).then((result) => {
       if (!result.ok && result.error !== 'disabled') {
-        log.warn(`外部推送失败：${result.error}`)
+        report('notify', `外部推送失败：${result.error}`)
       }
     })
   }
@@ -767,7 +962,7 @@ export function apply(ctx, config = {}) {
     } catch (err) {
       feishu = null
       feishuError = err?.message ?? String(err)
-      log.warn(`飞书没起来：${feishuError}`)
+      report('feishu', `飞书没起来：${feishuError}`)
     } finally {
       feishuStarting = false
     }
@@ -2246,6 +2441,87 @@ export function apply(ctx, config = {}) {
   //    不是倒计时，是「手机还在不在」。
   // ------------------------------------------------------------------
 
+  /**
+   * 「哪个会话此刻在等人」——手机导航栏那三枚待处理徽标的**唯一**来源。
+   *
+   * 为什么是这里、而不是去问 DSH 要一个状态字段：PC 侧栏那三个分类（等待审批 / 计划待审 /
+   * 等待回答）**在 Host 侧并不存在**。DSH 自己的做法是让每个功能插件在客户端注册一个
+   * `registerPendingInteraction`，也就是"谁在等，谁自己说"。我们这边真正在等的那两扇门
+   * 就是下面这两条 waterfall（审批与提问），所以正确的做法只有：**在这两扇门上各挂一个
+   * 旁观者**，进门记一笔、落定销一笔。
+   *
+   * 为什么不另写一套轮询去猜：猜出来的徽标会在"其实已经答完了"之后还挂着，那比没有徽标更坏。
+   *
+   * 计数而不是布尔：同一个会话理论上可以同时挂着一条审批和一道题（一次工具调用触发的审批
+   * 还没落定，模型又问了问题），谁先落定都不该把另一枚一起抹掉。
+   */
+  const pendingBySession = new Map()
+  /** 三类同时挂着时的显示优先级：审批最"堵"，计划审阅次之，普通提问最后。 */
+  const PENDING_ORDER = ['approval', 'plan', 'question']
+  const PENDING_LABEL = { approval: 'approval', plan: 'plan', question: 'question' }
+
+  function markPending(sessionId, kind) {
+    if (typeof sessionId !== 'string' || !sessionId) return () => {}
+    let kinds = pendingBySession.get(sessionId)
+    if (!kinds) {
+      kinds = new Map()
+      pendingBySession.set(sessionId, kinds)
+    }
+    kinds.set(kind, (kinds.get(kind) ?? 0) + 1)
+    broadcastPending()
+    return function release() {
+      const left = (kinds.get(kind) ?? 1) - 1
+      if (left > 0) kinds.set(kind, left)
+      else kinds.delete(kind)
+      if (!kinds.size) pendingBySession.delete(sessionId)
+      broadcastPending()
+    }
+  }
+
+  function pendingSnapshot() {
+    const out = {}
+    for (const [id, kinds] of pendingBySession) {
+      for (const kind of PENDING_ORDER) {
+        if (kinds.has(kind)) { out[id] = PENDING_LABEL[kind]; break }
+      }
+    }
+    return out
+  }
+
+  /**
+   * 徽标一变就吱一声。手机那边不改整棵树，只就地换那几行的尾部标记——
+   * 重绘会把用户正在划的滚动位置弹回顶部（和 paintNavCurrent 同一条理由）。
+   */
+  function broadcastPending() {
+    try {
+      server?.broadcast('navigation-pending', pendingSnapshot())
+    } catch {
+      // 服务还没起来、或者正在关：徽标晚一步知道不影响遥控本身。
+    }
+  }
+
+  /**
+   * **只做旁观**：把"这条链什么时候落定"记下来，返回值**原样**交回去。
+   *
+   * 为什么不能写成 `return next().finally(release)`：那会把一个同步的返回值包成 Promise，
+   * 而这条链的契约是"接不接、给什么，都在同步那一瞬间定下来"（见下面那段说明）。形状一变
+   * 就可能让整条派发认不出谁接了这一手。
+   *
+   * 所以只在它**确实是 thenable** 时才挂回调；给回来一个普通值时，说明下游已经当场答完了，
+   * 徽标立刻销掉是对的——**不挂一枚永远不会落定的假徽标**。
+   */
+  function watchSettle(value, release) {
+    if (value && typeof value.then === 'function') value.then(release, release)
+    else release()
+    return value
+  }
+
+  /** 这一批题目是不是"计划审阅"。DSH 把计划审批和普通提问放在同一扇门里，靠 intent 分。 */
+  function isPlanReview(questions) {
+    return (Array.isArray(questions) ? questions : [])
+      .some((q) => q && q.intent && q.intent.kind === 'plan-review')
+  }
+
   // **注意这个监听器不是 async，这是刻意的，不是漏写。**
   //
   // 顾问指出的关键一条（对照 DSH 自己那个转发给远端的监听器，写法完全一致）：
@@ -2261,6 +2537,10 @@ export function apply(ctx, config = {}) {
     const agentId = request?.agent?.id ?? null
     const bound = store.snapshot().boundSessionId
     const questions = Array.isArray(request?.questions) ? request.questions : []
+    // 进门先记一笔：这个会话此刻在等人。落定（答了、或者本来就没接）时销掉。
+    // 计划审阅走的是同一扇门，只是 intent 不同——不分开记的话，手机上那三个
+    // 分类就只剩两种（PC 侧栏是分三种的）。
+    const release = markPending(agentId, isPlanReview(questions) ? 'plan' : 'question')
     // ——— 同步阶段：只做"接不接"的判断，绝不 await ———
     // 能力从 `miniControl` 这个固定取用点拿（服务启动时主动放进去的），
     // **不再经过 createMiniServer 的回执**——实测那个回执兑现出来是 undefined。
@@ -2293,15 +2573,15 @@ export function apply(ctx, config = {}) {
      */
     if (!agentId || agentId !== bound || questions.length === 0) {
       console.log(`[dsh-mini-remote] 提问让路：问的=${agentId ?? '无'}，手机绑的=${bound ?? '无'}，题目数=${questions.length}`)
-      return next()
+      return watchSettle(next(), release)
     }
     if (!phoneReady && !feishuReady) {
       console.log('[dsh-mini-remote] 提问让路：手机和飞书此刻都接不上（页面没开、锁屏或断网，飞书那头没有在等的轮次），交给电脑')
-      return next()
+      return watchSettle(next(), release)
     }
     if (typeof miniControl.askPhone !== 'function') {
       console.log('[dsh-mini-remote] 提问让路：拿不到 askPhone（手机服务还没起来），交给电脑')
-      return next()
+      return watchSettle(next(), release)
     }
     // ——— 同步交出"将来会有答案"的东西；下面的等待都在这里，不再有同步判断 ———
     console.log(`[dsh-mini-remote] 提问推给手机：${questions.length} 题，等它答`
@@ -2312,7 +2592,7 @@ export function apply(ctx, config = {}) {
      * 题目的胜负、谁先答谁生效，全在 lib/server.js 那份清单里，这里不另判。
      */
     let askId = null
-    return miniControl.askPhone(questions, agentId, {
+    return watchSettle(miniControl.askPhone(questions, agentId, {
       onPending: (id) => {
         askId = id
         // 飞书那边写成一段普通文字问出来。它没接（写不成、或发不出去就当场撤回）时，
@@ -2337,7 +2617,7 @@ export function apply(ctx, config = {}) {
       if (askId) feishu?.expireAsk?.(askId)
       console.log('[dsh-mini-remote] 接管提问出错，让回电脑：' + String(err))
       return next()
-    })
+    }), release)
   }, { prepend: true })
   // ------------------------------------------------------------------
   // 命令确认（审批）也推到手机上
@@ -2352,6 +2632,8 @@ export function apply(ctx, config = {}) {
     const agentId = request?.agent?.id ?? null
     const bound = store.snapshot().boundSessionId
     const toolName = request?.toolName ?? '某个工具'
+    // 和上面那条提问链同一件事：进门记一笔「这个会话在等人」，落定时销掉。
+    const release = markPending(agentId, 'approval')
     // 这次到底要跑什么：审批请求只带调用编号，参数在会话事件里记着的那份。
     const command = request?.callId ? (toolCalls.get(String(request.callId)) ?? '') : ''
     const phoneReady = typeof miniControl.hasPhone === 'function' ? miniControl.hasPhone() : false
@@ -2368,20 +2650,20 @@ export function apply(ctx, config = {}) {
       && feishu.serving()
     if (!agentId || agentId !== bound) {
       console.log(`[dsh-mini-remote] 审批让路：批的=${agentId ?? '无'}，手机绑的=${bound ?? '无'}`)
-      return next()
+      return watchSettle(next(), release)
     }
     if (!phoneReady && !feishuReady) {
       console.log('[dsh-mini-remote] 审批让路：手机和飞书此刻都接不上（页面没开、锁屏或断网，飞书那头没有在等的轮次），交给电脑')
-      return next()
+      return watchSettle(next(), release)
     }
     if (typeof miniControl.askApproval !== 'function') {
       console.log('[dsh-mini-remote] 审批让路：拿不到 askApproval（手机服务还没起来），交给电脑')
-      return next()
+      return watchSettle(next(), release)
     }
     console.log(`[dsh-mini-remote] 审批推给手机：${toolName}，等它拍板`
       + (feishuReady ? '（飞书那边一起问）' : ''))
     let askId = null
-    return miniControl.askApproval(request, agentId, command, {
+    return watchSettle(miniControl.askApproval(request, agentId, command, {
       onPending: (id) => {
         askId = id
         feishu?.openAsk?.({ id, kind: 'approval', payload: view })
@@ -2399,7 +2681,7 @@ export function apply(ctx, config = {}) {
       if (askId) feishu?.expireAsk?.(askId)
       console.log('[dsh-mini-remote] 接管审批出错，让回电脑：' + String(err))
       return next()
-    })
+    }), release)
   }, { prepend: true })
 
   // ------------------------------------------------------------------
@@ -2716,6 +2998,325 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  // ------------------------------------------------------------------
+  // 会话条目的执行功能（2026-10-09）：置顶 / 重命名 / 分叉 / 归档
+  // ------------------------------------------------------------------
+  //
+  // 四件都**走 DSH 自己的服务**，不自己写盘：
+  //   · 重命名  `sessionController.rename({ sessionId, title })`
+  //   · 分叉    `sessionController.fork({ sessionId })`（＋照 PC 补一次 rename 递增标题）
+  //   · 置顶    `workspaceRegistry.pinSession / unpinSession`
+  //   · 归档    `workspaceRegistry.archiveSession / unarchiveSession`
+  //
+  // 读状态也走官方现成的两个 getter（`archivedSessionIds` / `pinnedSessionIds`），
+  // 它们正是 PC 侧栏读的那一份。**不去读 `~/.dsh/storages/workspace.json`**：
+  // 那是 DSH 的内部落盘格式，跟着版本变，而 getter 是它的公开面。
+  //
+  // 拿不到服务时一律**如实说没这个能力**（reason 带回手机），界面据此不摆一个按了没反应的按钮。
+
+  /** `sessionController` 现在拿不拿得到——和 createSession 同一条取用路径。 */
+  function sessionControllerNow() {
+    return canCreate.controller ?? ctx.get('sessionController')
+  }
+
+  /**
+   * 已归档 / 已置顶两个集合。
+   *
+   * 这两个 getter 在服务还没就绪时会抛（`requireState()`）——那时候导航栏少两枚徽标，
+   * 不该影响遥控本身，所以照 lib/tree.js 里 safeList 那条老规矩：读不到就当空。
+   * 但**要把 `ok:false` 带出去**，手机那边据此不显示「没有已归档」这种会被当成事实的说法。
+   */
+  function readSessionFlags() {
+    const reg = treeServices.registry
+    if (!reg) return { ok: false, reason: 'no-registry', archived: [], pinned: [] }
+    const strings = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x) : [])
+    try {
+      return {
+        ok: true,
+        archived: strings(reg.archivedSessionIds),
+        pinned: strings(reg.pinnedSessionIds),
+      }
+    } catch (err) {
+      return { ok: false, reason: 'not-ready', archived: [], pinned: [], error: String(err?.message ?? err) }
+    }
+  }
+
+  /**
+   * 每个会话的官方摘要（`SessionSummary`）：我们要的只有 `blank` 一个字段。
+   *
+   * **为什么非它不可**：「空白新会话」这条判据在我们这边没有第二个来源——
+   * `sessionQuery.listSessions()` 给的记录只有 `{header, live, persisted}`，
+   * 里面没有"用过没用过"。而 `blank` 正是 PC 侧栏用来决定"这一行要不要摆出来"的那个字段。
+   * 编一个（比如"标题为空就算空白"）会让一条只是标题没读出来的老会话当场消失，
+   * 那是拿猜测当事实——**拿不到就如实说拿不到**，手机侧退回原来的行为（一条都不隐藏）。
+   *
+   * 缓存 30 秒：和导航那两层同一个口径。展开一个工作区本来就要读日志折标题，
+   * 这一趟相对便宜，但没必要每次展开都重问一遍。
+   */
+  const SUMMARIES_TTL_MS = 30_000
+  const summariesCache = { at: 0, value: null, inflight: null }
+  async function readSessionSummaries(force = false) {
+    const controller = sessionControllerNow()
+    if (!controller || typeof controller.list !== 'function') {
+      return { ok: false, reason: 'unavailable', byId: new Map() }
+    }
+    const now = Date.now()
+    if (!force && summariesCache.value && now - summariesCache.at < SUMMARIES_TTL_MS) {
+      return summariesCache.value
+    }
+    if (summariesCache.inflight) return summariesCache.inflight
+    summariesCache.inflight = (async () => {
+      try {
+        const res = await controller.list({}, undefined)
+        const byId = new Map()
+        for (const item of res?.items ?? []) {
+          if (item && typeof item.sessionId === 'string') byId.set(item.sessionId, item)
+        }
+        const value = { ok: true, byId }
+        summariesCache.at = Date.now()
+        summariesCache.value = value
+        return value
+      } catch (err) {
+        // 失败不进缓存：下一次展开还会重试。返回的形状和上面一样，只是 ok:false。
+        return { ok: false, reason: 'failed', byId: new Map(), error: String(err?.message ?? err) }
+      } finally {
+        summariesCache.inflight = null
+      }
+    })()
+    return summariesCache.inflight
+  }
+
+  /**
+   * 改一个会话的标题。
+   *
+   * **官方语义（2026-10-09 从 0.2.0-rc.2 的 `dsh-session-title` 读到原文）**：
+   * `rename` 会追加一条 `session/title` 事件、`source.kind = 'user'`，这一条**钉住标题**——
+   * 在途的自动生成当场作废，之后的用户消息也不再生成新标题。也就是说：**传什么都会钉**，
+   * 哪怕跟当前自动标题一模一样。
+   *
+   * 所以"防误钉"这一步**不在这里**，在手机页：新标题与当前标题逐字相同就**根本不发这一趟**
+   * （见 lib/page.html 的 renameSubmit）。服务端这一层只负责把官方的拒绝如实翻译回去。
+   */
+  async function renameSession(sessionId, title) {
+    const controller = sessionControllerNow()
+    if (!controller || typeof controller.rename !== 'function') {
+      return { ok: false, reason: 'no-service' }
+    }
+    const text = typeof title === 'string' ? title : ''
+    // 空/全空白：官方会抛 SessionTitleInvalidError（"归一化之后是空的"）。我们在这里就先拦住，
+    // 措辞更直白，也省一趟往返。
+    if (!text.trim()) return { ok: false, reason: 'blank' }
+    try {
+      const res = await controller.rename({ sessionId, title: text })
+      // 官方会把归一化之后真正接受的那一份交回来（可能被截断、被去掉控制字符）。
+      // 界面上要显示的是**它接受的那份**，不是我们递过去的那份。
+      const accepted = typeof res?.title === 'string' ? res.title : text
+      // 就手记到我们自己这两层缓存上。**不记的话**，用户改完名字再展开一次工作区，
+      // 列表里还是旧标题（标题有 7 天的落盘缓存，已知标题优先于去读日志）——
+      // 那就是"我刚改的名字它没记住"，界面自己打自己的脸。
+      store.touchSession(sessionId, { title: accepted })
+      titles.set(sessionId, accepted)
+      return { ok: true, title: accepted }
+    } catch (err) {
+      if (err?.code === 'session/title-invalid' || err?.name === 'SessionTitleInvalidError') {
+        return { ok: false, reason: 'blank' }
+      }
+      if (err?.code === 'session/not-found') return { ok: false, reason: 'not-found' }
+      return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+    }
+  }
+
+  /**
+   * 标题里那个「(N)」，照官方**客户端的原函数**递增。
+   *
+   * 为什么这份逻辑在我们这边：官方 Host 的 `fork` 只管复制事件，**不动标题**——
+   * 子会话继承源会话的标题。PC 是客户端自己再补一次改名：
+   * `ClientSessions.fork({ increaseTitle: true })` 里那一行原文是
+   *   `const renamed = await this.manager.rename(childId, increasedForkTitle(sourceTitle));`
+   * 所以要跟电脑端一模一样，就得把 `increasedForkTitle` 这个函数也搬一份。
+   *
+   * 规则照抄（半角/全角括号都认，认不出就补 ` (1)`）：
+   *   `^(.*?)\((\d+)\)$`  → `前缀(数字+1)`
+   *   `^(.*?)（(\d+)）$`  → `前缀（数字+1）`
+   *   其它一律               → `${title} (1)`
+   */
+  function increasedForkTitle(title) {
+    const ascii = /^(.*?)\((\d+)\)$/u.exec(title)
+    if (ascii?.[1] !== undefined && ascii[2] !== undefined) return `${ascii[1]}(${BigInt(ascii[2]) + 1n})`
+    const fullWidth = /^(.*?)（(\d+)）$/u.exec(title)
+    if (fullWidth?.[1] !== undefined && fullWidth[2] !== undefined) return `${fullWidth[1]}（${BigInt(fullWidth[2]) + 1n}）`
+    return `${title} (1)`
+  }
+
+  /**
+   * 分叉时要拿来做递增的那个「源标题」。
+   *
+   * PC 用的是它自己列表快照里的 `title`（`this.list.getSnapshot().byId[id]?.title`）。
+   * 我们这边等价的来源是 Host 的列表投影：`SessionSummary.projections.values.title`，
+   * 也就是 `controller.list()` 给的那一份——和手机列表显示的是同一个字段。
+   *
+   * 拿不到就退到插件自己的标题缓存（就是下面那个 `titles`：读过一次就留着，改名也记一笔）。
+   * **两个都没有就返回空串**——空串表示"不知道源标题"，那就**不做这次改名**，
+   * 和 PC 的 `sourceTitle === undefined` 那条路一致（不硬编一个 `(1)` 出来骗人）。
+   */
+  async function forkSourceTitle(sessionId) {
+    const summaries = await readSessionSummaries()
+    const fromHost = summaries.byId?.get(sessionId)?.projections?.values?.title
+    if (typeof fromHost === 'string' && fromHost.trim()) return fromHost
+    const cached = titles.get(sessionId)
+    return typeof cached === 'string' && cached.trim() ? cached : ''
+  }
+
+  /**
+   * 分叉会话：在源会话**最后一个已完成轮次**处复制出一个新会话。
+   *
+   * 官方语义（2026-10-09 从 0.2.0-rc.2 的 `@deepseek-ai/dsh-api-session-controller` 读到原文）：
+   * `fork(request: { sessionId, atSeq? })`，省略 `atSeq` 就是"最近一个已完成的前缀"——
+   * 原文（lib/index.js 第 776-798 行）：
+   * ```
+   * async fork(request) {
+   *   atSeq = request.atSeq === void 0 ? void 0 : SessionSeq(request.atSeq)
+   *   const boundary = atSeq ?? latestCompletedPrefixBoundary(source.events)
+   *   if (boundary === void 0 || source.events[boundary]?.seq !== boundary)
+   *     throw new RemoteError("session/fork-unavailable", request.atSeq === void 0
+   *       ? `session "${request.sessionId}" has no completed turn to fork from`
+   *       : `event ${...} does not exist in session "${...}" (last seq: ${...})`,
+   *       { sessionId: request.sessionId })
+   *   ...
+   *   return { sessionId: childId }
+   * }
+   * ```
+   * 也就是说：**源会话里一个已完成轮次都没有时，Host 抛 `session/fork-unavailable`**，
+   * 那句话就是上面那串英文；`not-found` 是另一条（`session "${id}" not found`）。
+   *
+   * **它不会打开新会话、也不会改当前选中的会话**——PC 那条路上
+   * `navigation.forkSession()` 之后就结束了，没有任何 `replaceMain/open` 调用。
+   * 我们这边同样一个字节都不动 `store` 里的绑定会话。
+   *
+   * 失败时**把 Host 那句话原样交给手机**：这是用户点名要的（"不要自己编一句『无法分叉』"），
+   * 而且它正是 PC 用来区分「没有已结束轮次」和「真的失败了」的那个判据
+   * （PC 的 `error.rpcError.code === "session/fork-unavailable"`）。
+   * 唯一多写的一句是 `no-turn` 的中文引子——**照抄 PC 自己词条表里的原句**
+   * （`"shortcut.noCompletedTurn": "当前会话没有已结束的轮次"`），让非技术用户看得懂；
+   * Host 原话跟在它后面，一个字都没被改写。
+   */
+  async function forkSession(sessionId) {
+    const controller = sessionControllerNow()
+    if (!controller || typeof controller.fork !== 'function') {
+      return { ok: false, reason: 'no-service' }
+    }
+    let childId = ''
+    try {
+      const res = await controller.fork({ sessionId })
+      childId = typeof res?.sessionId === 'string' ? res.sessionId : ''
+    } catch (err) {
+      const message = String(err?.message ?? err)
+      if (err?.code === 'session/fork-unavailable') {
+        return { ok: false, reason: 'no-turn', error: `当前会话没有已结束的轮次。Host 原话：${message}` }
+      }
+      if (err?.code === 'session/not-found') {
+        return { ok: false, reason: 'not-found', error: message }
+      }
+      return { ok: false, reason: 'failed', error: message }
+    }
+    // Host 说成功却没交出 id：那是它违约，不能编一个"大概建好了"糊过去。
+    if (!childId) return { ok: false, reason: 'failed', error: 'Host 建好了会话却没有交出它的 id。' }
+    // 标题递增。**失败不算分叉失败**——会话是真建出来了，把它说成没建出来更坏；
+    // 只是标题留在继承来的那一个上（如实把 title 报成空串，手机就不拿标题说事）。
+    let title = ''
+    const source = await forkSourceTitle(sessionId)
+    if (source) {
+      const next = increasedForkTitle(source)
+      try {
+        await controller.rename({ sessionId: childId, title: next })
+        title = next
+      } catch (err) {
+        title = ''
+      }
+    }
+    if (title) {
+      // 和 renameSession 一样就手记上，不然用户刷新回来还是旧标题（标题有 7 天的落盘缓存，
+      // 而这一条是刚建出来的、哪一层都还没有）。
+      store.touchSession(childId, { title })
+      titles.set(childId, title)
+    }
+    return { ok: true, sessionId: childId, title }
+  }
+
+  /**
+   * 归档 / 取消归档。
+   *
+   * `stop` 这一个布尔是**官方那条两段式流程**的全部：
+   *   · 不带它（默认）：会话**还有工作在跑时服务会拒绝**，抛 `WorkspaceActiveSessionError`，
+   *     错的 `.activity` 上按族列着"会停掉什么"（turn / job / subagent / schedule，各自带 items）。
+   *     我们**原样交给手机**，手机照族列出来问过用户才继续——**不自己猜会停掉什么**。
+   *   · 带了它（`{ stopActivity: true }`）：跳过检查，写完归档再去请各个 provider 停。
+   *
+   * 官方的原话是「Host 拒绝普通归档并列出这些工作，侧栏随即打开『停止并归档』对话框」——
+   * 我们做的就是同一件事，只是"侧栏"换成了手机页。
+   */
+  async function archiveSession(sessionId, stop) {
+    const reg = treeServices.registry
+    if (!reg || typeof reg.archiveSession !== 'function') return { ok: false, reason: 'no-registry' }
+    try {
+      await reg.archiveSession(sessionId, stop ? { stopActivity: true } : {})
+      return { ok: true, ...readSessionFlags() }
+    } catch (err) {
+      if (err?.name === 'WorkspaceActiveSessionError' || Array.isArray(err?.activity)) {
+        return { ok: false, reason: 'active', activity: shapeActivity(err?.activity) }
+      }
+      if (err?.name === 'WorkspaceUnknownSessionError') return { ok: false, reason: 'not-found' }
+      return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+    }
+  }
+
+  /**
+   * 把官方那四族活动收成手机要的形状。**只搬运，不重写**：
+   * `kind` 原样（`turn`/`job`/`subagent`/`schedule`），中文说法在页面上拼——
+   * 界面文字归界面管，服务端不该替它起中文名。
+   *
+   * 每族最多带 20 项：官方的 items 原则上不长，但这是**用户自己机器上的数据**，
+   * 不该让一条超长的清单把手机页撑爆。截断了就把真实条数一起带出去，页面如实说。
+   */
+  function shapeActivity(activity) {
+    return (Array.isArray(activity) ? activity : [])
+      .filter((a) => a && typeof a.kind === 'string')
+      .map((a) => {
+        const items = (Array.isArray(a.items) ? a.items : [])
+          .map((it) => ({
+            id: typeof it?.id === 'string' ? it.id : '',
+            label: typeof it?.label === 'string' ? it.label : '',
+          }))
+        return { kind: a.kind, count: items.length, items: items.slice(0, 20) }
+      })
+  }
+
+  async function setPinned(sessionId, on) {
+    const reg = treeServices.registry
+    if (!reg || typeof reg.pinSession !== 'function') return { ok: false, reason: 'no-registry' }
+    try {
+      await (on ? reg.pinSession(sessionId) : reg.unpinSession(sessionId))
+      return { ok: true, ...readSessionFlags() }
+    } catch (err) {
+      // 已归档的不能置顶（官方规定两者互斥）。界面上归档行本来就不给置顶入口，
+      // 这条是兜底：真走到了也要说人话，不能回一个"失败"了事。
+      if (err?.name === 'WorkspaceArchivedSessionPinError') return { ok: false, reason: 'archived' }
+      if (err?.name === 'WorkspaceUnknownSessionError') return { ok: false, reason: 'not-found' }
+      return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+    }
+  }
+
+  async function unarchiveSession(sessionId) {
+    const reg = treeServices.registry
+    if (!reg || typeof reg.unarchiveSession !== 'function') return { ok: false, reason: 'no-registry' }
+    try {
+      await reg.unarchiveSession(sessionId)
+      return { ok: true, ...readSessionFlags() }
+    } catch (err) {
+      return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+    }
+  }
+
   const nav = {
     listWorkspaces: (runningIds, force, includeEmpty) =>
       listWorkspaces({ registry: treeServices.registry, query: treeServices.query, runningIds, force, includeEmpty, meta: sessionMeta }),
@@ -2732,6 +3333,18 @@ export function apply(ctx, config = {}) {
         onTitle,
         meta: sessionMeta,
       }),
+    // —— 会话条目的执行功能（2026-10-09）：都由 lib/server.js 那几条路由调用 ——
+    // 分组口径（隐藏空白、5 条空闲配额、已归档筛选）**不在这一层**：树那一层
+    // （lib/tree.js）只回答"这个工作区有哪些会话"，页面口径属于服务层。
+    sessionFlags: () => readSessionFlags(),
+    sessionSummaries: (force) => readSessionSummaries(force),
+    pendingInteractions: () => pendingSnapshot(),
+    renameSession: (sessionId, title) => renameSession(sessionId, title),
+    forkSession: (sessionId) => forkSession(sessionId),
+    pinSession: (sessionId) => setPinned(sessionId, true),
+    unpinSession: (sessionId) => setPinned(sessionId, false),
+    archiveSession: (sessionId, stop) => archiveSession(sessionId, stop),
+    unarchiveSession: (sessionId) => unarchiveSession(sessionId),
     // 建会话：先用 inject 拿到的那个，拿不到就现读一次——`ctx.get` 对没写进 inject
     // 的服务名是**返回 undefined**（不是抛错），所以这么写是安全的。
     createSession: (workspaceId, agentPreset) =>
@@ -3301,7 +3914,7 @@ export function apply(ctx, config = {}) {
       try {
         return connection.authenticatedUrl(`${base}/`)
       } catch (err) {
-        log.warn?.('取电脑端界面的访问凭据失败：' + (err?.message ?? err))
+        report('service', '取电脑端界面的访问凭据失败：' + (err?.message ?? err))
         return null
       }
     },
@@ -3313,12 +3926,38 @@ export function apply(ctx, config = {}) {
   // ------------------------------------------------------------------
   // 起服务
   // ------------------------------------------------------------------
+  /**
+   * 「跨机那两条」在**手机服务那个端口上**的第二份挂载点（2026-10-17 第七步）。
+   *
+   * ## 为什么要有它（"B 填哪条地址"那个毛病的答案）
+   *
+   * 这两台电脑之间，B 手上只会填**一条**地址。而 A 这边两条路本来长在两个端口上：
+   * 配对和跨机取票在宿主那一半（DSH 的 web 端口），取票回来的那条地址指向的
+   * `/mini/mirror/` 在手机服务那一半（3090）。取票回的那条地址用的是**请求到达时的
+   * Host**（见下面的 `requestOrigin`），于是 B 填哪一边都有一半对不上。
+   *
+   * 把这两条**原样**挂在手机服务上，B 就只填手机页那条地址——两端同源，`/mini/mirror/`
+   * 本来就在那儿。
+   *
+   * ## 形状是可变的，而且这里只有挂载点
+   *
+   * `createMiniServer` 在 `webServer` 之前就起来了（上面那个 effect），而这两条路由
+   * 要等 webServer 就绪才谈得上注册——所以这里先占位、注册那一刻填上，
+   * 手机服务每次请求现取（见 lib/server.js 的 `remoteRoutes`）。
+   * **逻辑一份都不在这儿**：下面两个处理函数原样交出去，两个端口共用同一份实现
+   * （总开关、限速、口令/凭据的比对、票怎么发，一处都没多）。
+   * 卸载时跟着摘掉（见那个 disposer）。
+   */
+  const hostHalfRoutes = { pair: null, remoteWindow: null }
+
   ctx.effect(() => {
     let closed = false
     createMiniServer({
       store,
       config: settings,
       token,
+      // 「设备身份」名册：认凭据（每一次请求现查，删掉记录即失效）和登记新设备。
+      devices,
       bindAddresses: resolveBindAddresses(settings.bindAddress),
       tunnelHost,
       log,
@@ -3327,6 +3966,8 @@ export function apply(ctx, config = {}) {
       // 「有这条路但它坏了」的 502：前者是实话，后者会让用户以为功能坏了。
       mirror,
       mirrorEnabled: () => store.state.mirrorEnabled === true && mirror.available(),
+      // 跨机那两条在手机服务上的第二份挂载点（见上面那段）。
+      remoteRoutes: hostHalfRoutes,
       onInstruction,
       onCommands,
       onCommand,
@@ -3356,7 +3997,7 @@ export function apply(ctx, config = {}) {
         server = instance
         serverError = null
         for (const f of instance.failed) {
-          log.warn(`地址 ${f.address} 没绑上，已跳过：${f.message}`)
+          report('service', `地址 ${f.address} 没绑上，已跳过：${f.message}`)
         }
         const usable = reachableAddresses().filter((a) => instance.addresses.includes(a.address))
         if (usable.length) {
@@ -3367,7 +4008,7 @@ export function apply(ctx, config = {}) {
           }
         } else {
           log.info(`已启动，但只绑上了本机：http://127.0.0.1:${instance.port}/mini?token=${token}`)
-          log.warn('没找到手机能连上的地址——检查 Wi-Fi／网线，或者 Tailscale 是否已登录。')
+          report('service', '没找到手机能连上的地址——检查 Wi-Fi／网线，或者 Tailscale 是否已登录。')
         }
         // 服务起来了才谈得上开隧道：cloudflared 要指向这个端口
         if (settings.tunnel?.enabled) bringTunnelUp()
@@ -3379,7 +4020,7 @@ export function apply(ctx, config = {}) {
         // 记下来。设置页那边要拿它把「还在启动」和「起不来了」分开说——
         // 只写日志的话，用户看到的永远是那句「过几秒刷新一下」。
         serverError = err?.message ?? String(err)
-        log.warn(`启动失败：${serverError}`)
+        report('service', `启动失败：${serverError}`)
       })
 
     return () => {
@@ -3428,7 +4069,7 @@ export function apply(ctx, config = {}) {
   ctx.inject(['webServer'], (webCtx) => {
     const webServer = webCtx.webServer
     if (typeof webServer?.register !== 'function') {
-      log.warn('拿不到 webServer 服务，设置页里的扫码面板用不了（手机端不受影响）。')
+      report('service', '拿不到 webServer 服务，设置页里的扫码面板用不了（手机端不受影响）。')
       return
     }
 
@@ -3448,6 +4089,40 @@ export function apply(ctx, config = {}) {
       return false
     }
 
+    /**
+     * 路由登记簿 + 挂载口（自检要看的「我们注册了哪些 / 哪些现在真的在」）。
+     *
+     * **登记和注册必须同一处发生**。另写一份常量清单看着更省事，但它迟早会和实际注册的
+     * 那几条对不上——而这份清单的用处**恰恰是回答"这台跑的是哪一版"**：对不上的清单会
+     * 把用户引到一个错结论上（"接口都在"其实少一条，或者反过来，让他白重启一趟）。
+     *
+     * `mounted` 在注销那一刻翻成 `false`：路由交出去之后，**只有我们自己知道它还在不在**
+     * （`webServer.register` 返回的那个 disposer 被调用过没有）。
+     */
+    const routeBook = new Map()
+    function mountRoute(route) {
+      routeBook.set(route.path, { kind: route.kind ?? 'exact', mounted: true })
+      const off = webServer.register(route)
+      return () => {
+        const entry = routeBook.get(route.path)
+        if (entry) entry.mounted = false
+        // 注销失败不该盖住真正要报的错（下面那个 disposer 一把全摘，一条出错不能拖着别的）。
+        try { off?.() } catch { /* 见上 */ }
+      }
+    }
+
+    /**
+     * 跨机那个开关的现状，交给设置页。
+     *
+     * **包在 `buildPairing` 外面**（不是当参数传进去）：那个函数有四条早退路径
+     * （成功 / 隧道报错 / 绑定配置问题 / 一条地址都没有），逐条补字段就是同一个坑
+     * ——`serve` 和 `feishu` 都在那上面栽过（见 test/tunnel.test.mjs 里那两条测试）。
+     * 包在外面，以后它再加一条早退路径也不会漏。
+     */
+    function remoteStatus() {
+      return { allowed: Boolean(settings.allowRemoteComputers) }
+    }
+
     async function pairingPayload() {
       if (!server) {
         // 分清「还在启动」和「起不来了」。原来两种情况都回同一句「过几秒刷新一下」，
@@ -3463,6 +4138,9 @@ export function apply(ctx, config = {}) {
             // 手机服务没起来，不影响飞书那一块——它和手机服务没有关系，谁用谁的。
             // 所以这一条早退路径上也带着 feishu，用户至少改得动它。
             feishu: feishuStatus(),
+            // 跨机那个开关同理：它的路由长在宿主这一半（不在手机服务里），所以服务没
+            // 起来的时候它照旧点得动、也照旧该显示出来。
+            remote: remoteStatus(),
           },
         }
       }
@@ -3493,10 +4171,10 @@ export function apply(ctx, config = {}) {
         // 飞书那一块的现状（**永远不含 appSecret**，只回答「有没有凭据」）。
         feishu: feishuStatus(),
       })
-      return { status: payload.ok ? 200 : 500, body: payload }
+      return { status: payload.ok ? 200 : 500, body: { ...payload, remote: remoteStatus() } }
     }
 
-    const offGet = webServer.register({
+    const offGet = mountRoute({
       kind: 'exact',
       path: '/mini-remote/pairing',
       handler: async (req, res) => {
@@ -3510,7 +4188,7 @@ export function apply(ctx, config = {}) {
       },
     })
 
-    const offTunnel = webServer.register({
+    const offTunnel = mountRoute({
       kind: 'exact',
       path: '/mini-remote/tunnel',
       handler: async (req, res) => {
@@ -3550,7 +4228,7 @@ export function apply(ctx, config = {}) {
      * 官方印出来的开启链接。整个功能里门槛最高的就是这一步，把链接原样递给用户，
      * 他点一下就完事；自己写一句「请到后台开启」等于把门槛加回去。
      */
-    const offServe = webServer.register({
+    const offServe = mountRoute({
       kind: 'exact',
       path: '/mini-remote/serve',
       handler: async (req, res) => {
@@ -3615,7 +4293,7 @@ export function apply(ctx, config = {}) {
      * 面板上那些二维码仍然是**当前在用的**旧密码编出来的——它们在重启前确实还能用，
      * 显示成新的就成了骗人。
      */
-    const offToken = webServer.register({
+    const offToken = mountRoute({
       kind: 'exact',
       path: '/mini-remote/token',
       handler: async (req, res) => {
@@ -3673,7 +4351,7 @@ export function apply(ctx, config = {}) {
      *   2. 存完**就地重建连接**。飞书的长连接是绑在凭据上的，不重建的话用户会看到
      *      「填好了、开关也开着，就是不回消息」，而屏幕上没有任何东西提示他原因。
      */
-    const offFeishu = webServer.register({
+    const offFeishu = mountRoute({
       kind: 'exact',
       path: '/mini-remote/feishu',
       handler: async (req, res) => {
@@ -3711,6 +4389,895 @@ export function apply(ctx, config = {}) {
       },
     })
 
+    /**
+     * 「远程窗口」：给桌面端那个面板换一张**一次性票**（2026-10-15）。
+     *
+     * ## 为什么要有它（而不是让界面自己去拿）
+     *
+     * 桌面端的界面半边跑在 DSH 自己的页面里（实测：那个页面在自定义协议
+     * `dsh-app://app/` 上，见 DSH 桌面端 main.js 的 `protocol.handle(SCHEME…)`），
+     * 我们的镜像在 `http://127.0.0.1:<端口>` 上——**既跨源又跨站**。它自己去要凭据，
+     * 要么被跨源拦住，要么就得把令牌发给浏览器，而令牌一旦进了 iframe 的地址就会留在
+     * 那台电脑的浏览历史里（设计稿那条硬规矩）。
+     *
+     * 所以由**宿主这一半**（就跑在这个进程里、本来就拿着令牌）去换票，再把票交给界面：
+     * 界面只拿得到「票 + 一条地址」，令牌一个字节都过不去。
+     *
+     * ## 票怎么用
+     *
+     * 地址是 `http://127.0.0.1:<我们的端口>/mini/mirror/?ticket=…`。浏览器拿着它进那扇门，
+     * 门里把票兑现成一枚**窗口会话 cookie**（iframe 后续那些请求全靠它认人），
+     * 票自己**只授权那一次**；地址里留着的那张票之后只用来回答「这一页是我嵌出来的吗」
+     * ——取景政策靠它（见 `lib/server.js` 的取景政策与 `lib/mirror.js` 的票）。
+     * **票 30 秒、一次性、用完即废。**
+     *
+     * 用 `127.0.0.1` 而不是本机在局域网里的地址：这个面板只可能在**这台电脑**上打开。
+     *
+     * 和别的 `/mini-remote/*` 一样**只允许本机调用**——能发这张票的只能是本机上的软件。
+     *
+     * **票上要写着这扇窗是谁的**（2026-10-16 第五步）：本机这一条给 `local`，兑票那一下
+     * 照着它签窗口会话（见 lib/server.js 的 ticketWindowOwner）。兑票的浏览器在**这台
+     * 电脑**上，所以那一关仍然要求"这一下是这台电脑自己发的"（回环、无转发头）。
+     */
+    const offWindow = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/window',
+      handler: (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        if (!server) {
+          sendJson(res, 503, { ok: false, error: '手机服务还在启动，过几秒再试。' })
+          return
+        }
+        if (!mirror.available()) {
+          // 这台机器上没拿到「电脑端界面」的地址（宿主刚起来那一段是这样）。
+          sendJson(res, 503, { ok: false, error: '这台电脑上现在找不到可嵌入的「电脑端界面」，过几秒重新打开这一次。' })
+          return
+        }
+        sendJson(res, 200, {
+          ok: true,
+          url: `http://127.0.0.1:${server.port}/mini/mirror/?ticket=${encodeURIComponent(mirror.issueTicket(LOCAL_WINDOW_DEVICE))}`,
+          expiresIn: Math.round(mirror.ticketTtlMs / 1000),
+        })
+      },
+    })
+
+    /**
+     * 回给外面那台电脑的地址里，那个「源」是什么（2026-10-16 跨机第二步）。
+     *
+     * ## 为什么必须是**请求到达时的 Host**，不能写死 `127.0.0.1`
+     *
+     * 本机版那条可以写死（那个面板只可能在这台电脑上打开），跨机这一条**不行**：
+     * 这条地址会原样交到**对面那台电脑**的浏览器里，而在那台电脑上 `127.0.0.1`
+     * 指的是**它自己**——框会去连它自己的本机端口，屏幕上是一片白/一个莫名其妙的
+     * 404，而 A 这边日志干干净净，最难查的就是这种。所以用请求里那个 Host：
+     * 它天然就是"对面用来够到我的那个地址"。
+     *
+     * 协议跟着 `X-Forwarded-Proto` 走：A 很可能藏在 Tailscale 的 https 后面
+     * （那边转发进来的是明文 http），这时对面要的是 `https://`。
+     *
+     * **Host 缺失就回 null**，由调用方当场报错。宁可明说"说不清该回哪条地址"，
+     * 也绝不退回一个写死的本机地址——那正是这一条要防的错。
+     */
+    function requestOrigin(req) {
+      const host = String(req.headers?.host ?? '').trim()
+      if (!host) return null
+      const proto = String(req.headers?.['x-forwarded-proto'] ?? '').split(',')[0].trim().toLowerCase()
+      return `${proto === 'https' ? 'https' : 'http'}://${host}`
+    }
+
+    /**
+     * 「跨机远程窗口」：**另一台电脑拿自己的设备凭据，来换一张带票的地址**
+     * （2026-10-16 跨机第二步）。
+     *
+     * ## 它和本机那条（`/mini-remote/window`）是同一件事的两个人
+     *
+     * 本机那条拿票的是**这台电脑自己的软件**，所以只允许回环（`localOnly`）；
+     * 这一条拿票的人在**另一台电脑上**，手上那枚东西是配对时换来的**设备凭据**
+     * ——不是这台电脑的口令，也不是本机回环。所以：
+     *
+     *   · **不调用 `localOnly`**（照 `pair` 那条的先例——它也是给外面调的）；
+     *   · 认的是**设备凭据**，三种带法（`X-Mini-Device` 头 / `?device=` / cookie）
+     *     走**同一份实现**（`server.verifyDevice` → `isAuthorized` 里认设备那一路），
+     *     而且每次都现查名册：那台电脑被撤销之后，这枚凭据当场失效；
+     *   · 票还是那一种票（30 秒、一次性、用完即废），换来的会话里签着它的设备身份
+     *     ——撤销对**已经开着的那扇窗**也生效（见 lib/server.js 的 windowSession）。
+     *
+     * ## 票上要写着这台设备的 id（2026-10-16 第五步）
+     *
+     * 兑票的那一下在**对面那台电脑的浏览器**里发生：那个浏览器**没有设备凭据**（凭据
+     * 只活在这条路由的调用方——对面那个宿主进程里），也**不是这台电脑的回环**。所以
+     * 身份必须在**发票这一刻**定下来、跟着票走：这里就是刚验过的 `deviceId`
+     * （`server.verifyDevice` 那一步，每次都现查名册）。兑票那一下照它签会话，
+     * 而且**兑现时还会再查一次名册**（见 lib/server.js 的 ticketWindowOwner）。
+     *
+     * ## 少掉 `localOnly` 之后补的是什么（照 `pair` 那套，顺序固定）
+     *
+     * 1. **开关**：`allowRemoteComputers` 关着时**这条路由一条都不接**；
+     * 2. **服务在不在**：不在就 503——限速那一套就长在那个服务实例里；
+     * 3. **限速**：和手机服务**共用同一张表**（`server.rateLimit`）。这条是外面能调的，
+     *    闸不是可选项。**不写 `?.`**：拿不到闸宁可当场报错（关着），也不静默放行；
+     * 4. **凭据**：比对本身走 `devices.verify`（`timingSafeEqual`，定长比较），
+     *    和口令那条同一个口径。
+     *
+     * ## 为什么限速只查不记（和 `pair` 不同的一处，有意）
+     *
+     * `pair` 那条输的是**口令**——用户自己定的、猜得动，所以错一次记一次。这条输的是
+     * **设备凭据**（256 位随机数），猜不动，记失败一个字节的安全都换不来；而它会造出
+     * 一个死结：那台电脑被撤销之后手上那枚凭据必然失败，它的界面会反复重试，5 次就把
+     * 来源封一分钟——用户在同一台电脑上重新配对时撞上的是"错误次数太多"。这正是
+     * `lib/server.js` 的 `noteTokenFailure` 那段写下过的坑，所以这里照它办：
+     * **只 `noteSuccess`，不 `noteFailure`**；闸门照旧查（共用同一张表）。
+     *
+     * ## 回给对面的字段
+     *
+     * `{ ok, url, expiresIn }`——和本机那条**逐字同形状**（对面那台电脑的宿主两件事
+     * 都要做：拿地址、按到期时间决定多久重取一次）。凭据、名册、id 一概不回。
+     *
+     * ## 这一条**两个端口上各挂一份**（2026-10-17 第七步）
+     *
+     * 上面这些规矩一条都不变；变的是"它能从哪儿进来"。同一个处理函数既挂在宿主这一半
+     * （下面 `webServer.register`），也挂在**手机服务那一半**（`hostHalfRoutes.remoteWindow`
+     * → lib/server.js 的 `remoteRoutes`）。理由见 `hostHalfRoutes` 那段：B 只填一条地址，
+     * 而那条地址上必须有配对、取票、`/mini/mirror/` 三样。
+     */
+    const remoteWindowRoute = {
+      kind: 'exact',
+      path: '/mini-remote/remote/window',
+      handler: (req, res) => {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        if (!settings.allowRemoteComputers) {
+          sendJson(res, 403, {
+            ok: false,
+            error: '这台电脑没有允许别的电脑连接。要连的话，先在这台电脑的设置里打开「允许别的电脑连接」。',
+          })
+          return
+        }
+        if (!server) {
+          sendJson(res, 503, { ok: false, error: '手机服务还在启动，过几秒再试。' })
+          return
+        }
+        if (server.rateLimit.isBlocked(req)) {
+          sendJson(res, 429, { ok: false, error: '口令错误次数太多，等一分钟再试。' })
+          return
+        }
+        // 认人（**三种带法都收**）：`?device=` 在地址里，cookie 是浏览器自己带的，
+        // 跨机那条主路是 `X-Mini-Device` 请求头（对面那台电脑的宿主进程带着它发过来）。
+        const deviceId = server.verifyDevice(req, new URL(req.url ?? '/', 'http://placeholder'))
+        if (!deviceId) {
+          sendJson(res, 401, { ok: false, error: '没带对凭据。这一枚是配对的时候换来的，撤销之后也没法再用。' })
+          return
+        }
+        // 认下来了：把这一小段试错历史清掉（和手机页进门那一下同一条口径）。
+        server.rateLimit.noteSuccess(req)
+        if (!mirror.available()) {
+          sendJson(res, 503, { ok: false, error: '这台电脑上现在找不到可嵌入的「电脑端界面」，过几秒再试。' })
+          return
+        }
+        const origin = requestOrigin(req)
+        if (!origin) {
+          sendJson(res, 400, { ok: false, error: '这个请求没有带 Host，说不清该回哪条地址。' })
+          return
+        }
+        // 只记设备 id：不记凭据、不记地址——和 issueDeviceCookie 那条日志同一条规矩。
+        console.log(`[dsh-mini-remote] 跨机取票：给名册里那台电脑（${deviceId}）发了一张票`)
+        sendJson(res, 200, {
+          ok: true,
+          // **这一张票记的就是这台设备**（见上面那段）：兑票的浏览器手上没有凭据。
+          url: `${origin}/mini/mirror/?ticket=${encodeURIComponent(mirror.issueTicket(deviceId))}`,
+          expiresIn: Math.round(mirror.ticketTtlMs / 1000),
+        })
+      },
+    }
+    // 手机服务那一半也挂这一份（见 hostHalfRoutes 那段）：B 填的那条地址上，
+    // 取票和票指向的 `/mini/mirror/` 必须在同一个源上。
+    hostHalfRoutes.remoteWindow = remoteWindowRoute.handler
+    const offRemoteWindow = mountRoute(remoteWindowRoute)
+
+    /**
+     * 「允许别的电脑连接」那个总开关（2026-10-16 跨机第二步）。
+     *
+     * 和公网开关、改密码、飞书那几条**同一个位置、同一条规矩**（`localOnly`）：
+     * 它决定**别的电脑能不能连过来**，是同一张 Wi-Fi 下别人不该替你做主的事。
+     *
+     * 存进 `settings.allowRemoteComputers`（落 settings.json），**存完就地生效**——
+     * 那两条跨机路由读的是同一个值，不必重载插件。返回的是整份配对信息
+     * （和公网开关那条一样），界面拿它一次刷新到位。
+     *
+     * **默认关**：新用户第一次进这一页看到的是关着的。**装好不会自动打开**——
+     * 这是刻意留白，那个动作只能由人来点。
+     */
+    const offRemoteAccess = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/remote-access',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        settings.allowRemoteComputers = Boolean(want?.enabled)
+        persistSettings()
+        console.log(`[dsh-mini-remote] 「允许别的电脑连接」现在是${settings.allowRemoteComputers ? '开' : '关'}`)
+        try {
+          const { status, body } = await pairingPayload()
+          sendJson(res, status, body)
+        } catch (err) {
+          sendJson(res, 500, { ok: false, error: `切换之后读不到状态：${err?.message ?? err}` })
+        }
+      },
+    })
+
+    /**
+     * 「设备名册」那三条：**列出 / 改名 / 撤销**（2026-10-16 第三步）。
+     *
+     * ## 为什么在这里、为什么只允许本机
+     *
+     * 和配对信息、改密码、开关公网同一个位置、同一条规矩（`localOnly`）：这几条决定
+     * **谁进得来**，是同一张 Wi-Fi 下别人不该替你做主的事。
+     *
+     * ## 为什么三条都只跟 `devices` 说话
+     *
+     * `devices`（见 lib/devices.js）是这份名册**唯一**的读写口。设置页那半边不做第二份
+     * 判断、更不自己去读写那个 JSON：内存一份、磁盘一份，两处各写各的迟早对不上，
+     * 而对不上的表现是「界面上删了，那台手机还能进」——最难查、也最要命的那种。
+     *
+     * 返回里**永远没有 keyHash、也没有凭据本身**：list / rename 回的都是
+     * `devices.js` 的 publicRecord（id、名字、类型、创建时间、最近使用）。
+     */
+    const offDevices = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/devices',
+      handler: (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 GET。' })
+          return
+        }
+        sendJson(res, 200, { ok: true, devices: devices.list() })
+      },
+    })
+
+    /**
+     * 改一台设备的名字。
+     *
+     * **名字只是标签**（见 lib/devices.js 开头）：改了它，那台设备照旧进得来、照旧
+     * 什么都做得了。所以这一条不掐连接、不碰凭据，只动那一个字符串。
+     *
+     * 名字的合法性由 devices.rename 判（空名字、超长），错误原样带回去——两处各写一份
+     * 校验，迟早一处改了一处没改，而表现是「界面放行、服务端拒绝」。
+     */
+    const offDeviceRename = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/devices/rename',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const done = devices.rename(want?.id, want?.name)
+        if (!done.ok) {
+          sendJson(res, 400, { ok: false, error: done.error })
+          return
+        }
+        sendJson(res, 200, { ok: true, device: done.device })
+      },
+    })
+
+    /**
+     * 撤销一台设备：**删掉记录 + 掐掉它手上的活连接**。
+     *
+     * ## 顺序不能反（先删记录，再掐线）
+     *
+     * 反过来的话，那条流断开时客户端会立刻重连一次——而记录还在，它重连就成功了。
+     * 用户看到的就是「撤销了，但那台手机照旧在动」。先删记录：重连撞上 401，
+     * 于是按设计回到门禁页。
+     *
+     * ## 为什么要掐（这一步的核心）
+     *
+     * 手机那边是**服务端单向推**的。只让"下一次请求被拒"，那条已经挂着的 SSE 照样
+     * 收得到新消息——用户会以为撤销没生效。掐断是这件事**看得见**的那一半，
+     * 具体在 lib/server.js 的 dropDeviceConnections 里（SSE + 镜像那个框的 WebSocket，
+     * **「远程窗口」那扇窗的常驻连接也算它的**——会话里签着设备身份，见 server.js 的升级处理器）。
+     *
+     * ⚠️ **那扇开着的窗不会"当场断开"**：窗口里的请求是浏览器自动带 cookie 发的短请求，
+     * 不是长连接。撤销之后它**下一次请求**才 401（静态资源、`/api/*`、下一次点击/轮询），
+     * 随后页面自己回门禁页。**给用户的话就照这个说**，别承诺"立刻变"。
+     *
+     * 撤销**不需要二次确认**吗？需要，但那一步在**界面那一侧**（用户拍板的：撤销要
+     * 二次确认，确认框里说清"这台设备要重新扫码才能再用"）。服务端这条只管执行——
+     * 它只对本机的软件开口，而本机的软件本来就有这台电脑的全部权限，谈不上绕过。
+     */
+    const offDeviceRevoke = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/devices/revoke',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const id = typeof want?.id === 'string' ? want.id : ''
+        if (!id) {
+          sendJson(res, 400, { ok: false, error: '要撤销哪一台？请求里没有 id。' })
+          return
+        }
+        const removed = devices.remove(id)
+        if (!removed) {
+          // 另一台电脑/另一个标签页刚撤过：如实说"它已经不在名册里了"，别假装成功。
+          sendJson(res, 404, { ok: false, error: '这台设备已经不在名册里了，刷新看看。' })
+          return
+        }
+        // 服务还没起来时它手上不可能有活连接（那条流是它自己起的），所以这里可以缺。
+        const dropped = server?.dropDeviceConnections?.(id) ?? 0
+        console.log(`[dsh-mini-remote] 撤销了一台设备（${id}），掐掉 ${dropped} 条活连接`)
+        sendJson(res, 200, { ok: true, id, dropped })
+      },
+    })
+
+    /**
+     * 「配对」：**另一台电脑拿这台电脑的口令，给自己换一枚设备凭据**（2026-10-16，跨机第一步）。
+     *
+     * ## 为什么它**不走 `localOnly`**（2026-10-16 第二步起，这样的有两条）
+     *
+     * 别的 `/mini-remote/*` 都只允许本机调用，因为它们是"本机的软件替你做主"。这一条
+     * 正相反：**要配对的那台电脑在"外面"**——它不在本机回环上，而且调用的这一刻它手里
+     * 还没有任何凭据（凭据正是它来这儿要的东西）。所以这里**不调用 `localOnly`**。
+     * 另一条是「跨机取票」（`/mini-remote/remote/window`），同一条理由：来换票的人在
+     * 另一台电脑上，手上那枚凭据是这一条刚换给它的。
+     *
+     * 少掉的那道门用三样补上，缺一不可：
+     *   · **开关**（`settings.allowRemoteComputers`，默认关）：关着时这一条一条都不接
+     *     ——"关"是"这台电脑不接受别的电脑连过来"这个整体状态；
+     *   · **口令**（`tokenEquals`，定长比较，和手机页同一枚、同一个判据）；
+     *   · **试错限速**（`server.rateLimit`，和手机服务**共用同一张表**，见 lib/server.js）。
+     *     这条是外面能调的，限速不是可选项。**不另写一套**：现成那一套就是为猜口令准备的，
+     *     两套各数各的，等于给猜的人两份额度。
+     *
+     * ## 口令**不是一次性的**
+     *
+     * 配对成功之后它照旧有效：口令是"这台电脑的入场邀请函"，本来就允许多次使用
+     * ——手机页那一路每次带 `?token=` 进来都会发一枚新凭据，用的还是同一枚口令。
+     * 所以一台 A 可以配多台电脑，配完照样能继续用手机。**一次性的东西是"票"**
+     * （`/mini-remote/window` 那张，30 秒、用完即废），不是口令。要收回哪一台，
+     * 走名册那一行撤销（`/mini-remote/devices/revoke`）。
+     *
+     * ## 回给调用方的**只有凭据**
+     *
+     * `{ ok: true, credential }`：名字、创建时间、名册、keyHash 一概不回——对面要的就是
+     * 这一枚，多一个字段就多一处泄漏面。`id` 本来就在凭据里（`<id>.<密钥>`），不用另给一份。
+     *
+     * ## 口令只从请求体里收（**不接受 `?token=`**）
+     *
+     * 口令进了地址，就会被写进对面、以及中间任何一台代理的日志和历史里。别的路由把
+     * 地址里带参数当成方便，这一条不行：它是跨机的，路上不止一台机器。
+     *
+     * ## 这一条也是**两个端口上各挂一份**（2026-10-17 第七步）
+     *
+     * 和「跨机取票」同一条理由（见 `hostHalfRoutes` 那段）：B 填的那一条地址必须同时
+     * 容得下配对和 `/mini/mirror/`，而那两样本来分在两个端口上。规矩一个字没改，
+     * 只是同一个处理函数多了一个挂载点。
+     */
+    const pairRoute = {
+      kind: 'exact',
+      path: '/mini-remote/pair',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        // 「允许别的电脑连接」关着：**配对也不接**（用户拍板的：关 = 这台电脑不接受
+        // 别的电脑连过来，是一个整体状态，不是"少录一项配置"）。这一闸放在最前面，
+        // 排在限速和口令之前——关着的时候连"猜口令"这件事都不该发生。
+        if (!settings.allowRemoteComputers) {
+          sendJson(res, 403, {
+            ok: false,
+            error: '这台电脑没有允许别的电脑连接。要连的话，先在这台电脑的设置里打开「允许别的电脑连接」。',
+          })
+          return
+        }
+        if (!server) {
+          // 限速那一套长在手机服务里（同一张表）。服务没起来时配对也没有意义——
+          // 换回去的凭据进不了门，所以如实说"还在启动"，别让对面以为配好了。
+          sendJson(res, 503, { ok: false, error: '手机服务还在启动，过几秒再试。' })
+          return
+        }
+        // **不写 `?.`**：限速这一套就在上面那个服务实例里（同一个模块给的），拿不到就等于
+        // 这道门没闸——那种情况下宁可当场报错（关着），也不要静悄悄放它过去（开着）。
+        if (server.rateLimit.isBlocked(req)) {
+          sendJson(res, 429, { ok: false, error: '口令错误次数太多，等一分钟再试。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const given = typeof want?.token === 'string' ? want.token : ''
+        if (!tokenEquals(given, token)) {
+          // 记一次试错。**只有外面能调的这条路**才需要在这里数：猜口令的次数就是在
+          // 这一行数出来的（同来源错 5 次封一分钟，下次请求进门就被上面那道 429 挡住）。
+          server.rateLimit.noteFailure(req)
+          sendJson(res, 401, { ok: false, error: '口令不对。' })
+          return
+        }
+        // 口令对了：把这一小段历史清掉（和手机页进门那一下同一条口径）。
+        server.rateLimit.noteSuccess(req)
+        // 名字留空 = register 的默认名，用户可以之后在设置页改名。**不从请求体里收名字**：
+        // 这一条的输入只有口令一样（见上面"只给凭据"那一段的同一条理由）。
+        const issued = devices.register({ kind: 'desktop' })
+        // 只记 id、不记口令、不记凭据：和 issueDeviceCookie 那条日志同一条规矩。
+        console.log(`[dsh-mini-remote] 配对成功，登记了一台电脑（${issued.id}）`)
+        sendJson(res, 200, { ok: true, credential: issued.credential })
+      },
+    }
+    // 手机服务那一半也挂这一份（见 hostHalfRoutes 那段）。
+    hostHalfRoutes.pair = pairRoute.handler
+    const offPair = mountRoute(pairRoute)
+
+    /**
+     * 「我能连的电脑」那四条（**B 侧**，2026-10-16 跨机第三步）。
+     *
+     * ## 它管的是哪一件事
+     *
+     * 前两步都在 A 侧（A 面对"别的电脑来连我"：配对、跨机取票、那个总开关）。
+     * 这一族在 **B 侧**：B 自己记着"我连得上哪几台电脑"（lib/remotes.js 的
+     * `remotes.json`），并且**替自己的界面**去那台电脑换票。
+     *
+     * ## 为什么四条都只允许本机（`localOnly`）
+     *
+     * 这一族是"**这台电脑的软件替你做主**"：添加（要输对面的口令）、列出、取票、断开，
+     * 全都发生在 B 自己的设置页上——同一个 Wi-Fi 下，别人不该替 B 决定"我要连谁"。
+     * 和 `/mini-remote/pair`、`/mini-remote/remote/window` 那两条恰好相反：那两条长在 A 上、
+     * 服务的是**外面**那台电脑，所以它们不调 localOnly。
+     *
+     * ## 凭据一步都不进浏览器
+     *
+     * 界面能拿到的只有 `lib/remotes.js` 的 `publicRecord`（id、名字、地址、两个时间）。
+     * 凭据只在**这一半**（宿主进程）手里：去 A 取票时放进 `X-Mini-Device` **请求头**，
+     * 既不进地址（那会留在浏览历史、中间代理和对面日志里），也不进任何一条回给界面的
+     * JSON。取票回来的 `{url}` 里只有一张 30 秒、一次性的票——**票不是凭据**。
+     *
+     * ## 「重连」没有第五条路由
+     *
+     * 用户拍板的：**重连 = 重新取一次票**。界面点「重连」就是再调一次
+     * `/mini-remote/remotes/window`——票本来就是一次性的、30 秒就过期，界面按回来的
+     * `expiresIn` 自己决定多久重取一次。再加一条"重连"路由，只会多一份做着同一件事的代码。
+     *
+     * ## 「断开」只动 B 本地（用户拍板的那一条）
+     *
+     * **B 不管理它连的那台 A**，所以这里不替用户去 A 撤销——断开 = 从 B 的名册里删掉那条
+     * 记录（`remotes.forget`）。用户看到的文案在 `REMOTE_FORGOTTEN_NOTE`：说清"A 那边
+     * 还留着这条记录，要彻底收回得去 A 的设置页撤销"。
+     */
+
+    /**
+     * 对面已经撤销了 B 这枚凭据时说的话。
+     *
+     * 为什么不照抄 A 那句（"没带对凭据。这一枚是配对的时候换来的，撤销之后也没法再用。"）：
+     * 那句是在**交代自己的规则**，没有告诉用户**接下来怎么办**。而在 B 这边，用户手上
+     * 真正能做的只有一件事：拿 A 的口令重新添加一台。
+     */
+    const REMOTE_REVOKED_HINT = '那台电脑已经不认这枚凭据了——多半是它那边把这条记录撤销了。\n'
+      + '要重新连，得拿那台电脑的口令在这儿重新添加一次。'
+
+    /**
+     * 断开之后给用户看的那句话。
+     *
+     * **必须说清"A 那边还留着"**：断开的语义是"B 不再管它了"，不是"收回那台电脑的权限"。
+     * 用户以为自己收回了、其实 A 名册里那一条还在，是这一步最容易留下的误会。
+     */
+    const REMOTE_FORGOTTEN_NOTE = '已经从这台电脑的列表里移除了，本地存的那枚凭据也一起删了。\n'
+      + '那台电脑上还留着「这台电脑」那条记录——要彻底收回，得去它的「手机遥控」设置页里撤销那一台。'
+
+    /**
+     * 对面回了错、又没说原因时，照状态码说一句人话。
+     *
+     * 正常情况下 A 会把原因写在 `error` 里（照抄即可）。这条兜底是给"路上不是 A"准备的：
+     * 地址指到了别的服务（一页 HTML 的 404）、中间挡了一层代理，都可能一个字段都不给。
+     */
+    function remoteStatusText(status) {
+      if (status === 404) return '那台电脑上没有这个接口（404）：多半是它的 DSH 还没更新到这一步，或者地址、端口写错了。'
+      if (status === 403) return '那台电脑现在不接受别的电脑连接。要连的话，先在它的「手机遥控」设置里打开「允许别的电脑连接」。'
+      return `那台电脑没通过这一下（HTTP ${status}），它也没说原因。`
+    }
+
+    /**
+     * 替 B 去 A 打一次接口。返回 `{ ok, status, body?, error? }`。
+     *
+     * **两件事分开说**：网络层失败（连不上、超时）和对面回了个错（401/403/503）是两种
+     * 人话——前者要用户去看地址和网络，后者对面已经写好了原因，照抄就行（加一句"那台电脑说："
+     * 让用户知道这话是谁说的）。
+     *
+     * 超时用 `AbortSignal.timeout`（和隧道那条探针同一个写法）。
+     *
+     * **这个方法只发两样东西**：请求体里的口令（`pair` 那一下）和请求头里的凭据
+     * （取票那一下）。凭据一个字节都不进地址——那是这一族最硬的一条规矩。
+     */
+    async function callRemote(baseUrl, path, { body, headers } = {}) {
+      let res
+      try {
+        res = await fetch(`${baseUrl}${path}`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', ...headers },
+          body: JSON.stringify(body ?? {}),
+          signal: AbortSignal.timeout(REMOTE_CALL_TIMEOUT_MS),
+        })
+      } catch (err) {
+        const code = err?.cause?.code ?? err?.code ?? ''
+        const text = `连不上那台电脑（${baseUrl}）：${code || err?.message || err}。`
+        // **这条路以前完全不留痕**（2026-10-17 补）：错误只回给界面，用户一退出面板就再也
+        // 查不到上一次报的是什么。跨机碰的是"另一边的东西"，出错时最需要的就是"上一次到底
+        // 报了什么"——地址写错、对面没开、还是网络不通，全靠这一句分。
+        //
+        // 只记网络层失败（连不上 / 超时）。对面回 401/403 那类**不记**：那是业务拒绝，
+        // 界面已经把人话和下一步说清楚了，记下来只会把真正的故障挤出这 20 条。
+        report('remote', text)
+        return {
+          ok: false,
+          status: 0,
+          error: text + '\n先确认它在开着、地址和端口没写错、而且和这台电脑在同一个网络里。',
+        }
+      }
+      let payload = null
+      try {
+        payload = await res.json()
+      } catch {
+        // 对面回的不是 JSON：下面按状态码说人话，别把一页 HTML 丢给用户。
+      }
+      if (res.ok && payload?.ok) return { ok: true, status: res.status, body: payload }
+      const said = typeof payload?.error === 'string' && payload.error ? payload.error : ''
+      return { ok: false, status: res.status, error: said ? `那台电脑说：${said}` : remoteStatusText(res.status) }
+    }
+
+    /**
+     * ① 列出「我能连的电脑」。
+     *
+     * **永远不含凭据**（`remotes.list()` 走的一定是 publicRecord）。这一条是界面那张
+     * 列表的唯一数据来源；名字改了、时间更新了，界面刷一下就知道。
+     */
+    const offRemotesList = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/remotes',
+      handler: (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 GET。' })
+          return
+        }
+        sendJson(res, 200, { ok: true, remotes: remotes.list() })
+      },
+    })
+
+    /**
+     * ② 添加一台电脑：**拿它的口令，换一枚自己的凭据存下来**。
+     *
+     * 收 `{ name?, baseUrl, token }`。口令走**请求体**去 A 的 `/mini-remote/pair`
+     * （A 那条路由只从请求体收口令，理由见它上面那一段：进了地址就会被写进对面和中间
+     * 任何一台代理的日志里）。名字只是 B 这边的标签，可以不给——不给就取地址里的 host。
+     *
+     * ## 失败一律不落盘
+     *
+     * 口令错、对面开关关着、地址不通、对面回的凭据不像话——**一条记录都不许留下**。
+     * 名册里出现一条"其实连不上"的记录，用户下次点它只会得到一个查不出原因的失败。
+     * 所以顺序是：**先换凭据、成功了才 `remotes.add`**（`add` 自己不落盘失败）。
+     *
+     * ## 回给界面的是 publicRecord（**没有凭据**）
+     */
+    const offRemotesAdd = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/remotes/add',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const baseUrl = normalizeBaseUrl(want?.baseUrl)
+        if (!baseUrl) {
+          sendJson(res, 400, {
+            ok: false,
+            // 不举 `IP:端口` 的例子：这一步只管逻辑，"那条地址到底长什么样"取决于
+            // 两台电脑怎么连上（内网 / Tailscale / 隧道）——那是后面的「网络形态」那一步。
+            // 举一个具体的端口只会把人带到错误的方向上。
+            error: '要填那台电脑的地址，写成 http:// 或 https:// 开头的一整条'
+              + '（就是那台电脑的「手机遥控」地址：http:// 地址:3090，或者 https:// 的 Tailscale 地址；'
+              + '不要带 /mini 和它后面的参数）。',
+          })
+          return
+        }
+        const given = typeof want?.token === 'string' ? want.token.trim() : ''
+        if (!given) {
+          sendJson(res, 400, { ok: false, error: '要填那台电脑的口令（在它的「手机遥控」设置里能复制到）。' })
+          return
+        }
+        const answer = await callRemote(baseUrl, '/mini-remote/pair', { body: { token: given } })
+        if (!answer.ok) {
+          // **一个字都不落盘**：这一次没换成凭据，就地结束。
+          // 状态用 502：出错的是"网关那一头"（对面），不是本机这次调用不合规矩。
+          sendJson(res, 502, { ok: false, error: answer.error })
+          return
+        }
+        const added = remotes.add({
+          name: want?.name,
+          baseUrl,
+          credential: typeof answer.body?.credential === 'string' ? answer.body.credential : '',
+        })
+        if (!added.ok) {
+          // 走到这儿只剩一种可能：对面回了个 `ok:true`，里面那枚凭据却不像话
+          //（地址和口令在上面都验过了）。
+          sendJson(res, 502, { ok: false, error: added.error })
+          return
+        }
+        // 只记 id 和地址：**不记口令、不记凭据**（和 devices 那几条日志同一条规矩）。
+        console.log(`[dsh-mini-remote] 添加了一台电脑（${added.remote.id}），地址 ${baseUrl}`)
+        sendJson(res, 200, { ok: true, remote: added.remote })
+      },
+    })
+
+    /**
+     * ③ 取票：**拿自己存的那枚凭据，去那台电脑换一张带票的地址**。
+     *
+     * 这是这一族唯一会用到凭据的地方，也是"凭据只活在宿主进程里"这句话的落点：
+     * 凭据从 `remotes.secret(id)` 出来、直接进 `X-Mini-Device` 请求头，**从头到尾
+     * 不经过界面**。界面拿到的是 A 回的那条 `{url}`（里面只有一张 30 秒、一次性的票）。
+     *
+     * 成功之后记一次 `lastOk`（列表上"最近成功连接"那句话就是它）。
+     *
+     * **重连没有单独一条路由**：再调一次这一条就是重连。
+     */
+    const offRemotesWindow = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/remotes/window',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const id = typeof want?.id === 'string' ? want.id : ''
+        if (!id) {
+          sendJson(res, 400, { ok: false, error: '要连哪一台？请求里没有 id。' })
+          return
+        }
+        const secret = remotes.secret(id)
+        if (!secret) {
+          // 另一个标签页刚断开过它——如实说，别假装还在。
+          sendJson(res, 404, { ok: false, error: '这台电脑已经不在列表里了，刷新看看。' })
+          return
+        }
+        // ⚠️ 凭据**只走请求头**：进了地址就会留在浏览历史、中间代理和对面日志里。
+        const answer = await callRemote(secret.baseUrl, '/mini-remote/remote/window', {
+          headers: { 'x-mini-device': secret.credential },
+        })
+        if (!answer.ok) {
+          // 401 单独说：那多半是"对面把这条记录撤销了"，而用户能做的只有重新配对一次。
+          sendJson(res, 502, { ok: false, error: answer.status === 401 ? REMOTE_REVOKED_HINT : answer.error })
+          return
+        }
+        const url = typeof answer.body?.url === 'string' ? answer.body.url : ''
+        if (!url) {
+          sendJson(res, 502, { ok: false, error: '那台电脑回了话，但里面没有地址。过几秒再试一次。' })
+          return
+        }
+        remotes.markOk(id)
+        // 只记 id：**不记凭据、不记那条地址**（里面那张票够开一扇窗）。
+        console.log(`[dsh-mini-remote] 从「我能连的电脑」里换了一张票（${id}）`)
+        sendJson(res, 200, { ok: true, url, expiresIn: Number(answer.body?.expiresIn) || 0 })
+      },
+    })
+
+    /**
+     * ④ 断开：**只从 B 本地删掉这条记录**（见上面「断开」那一段）。
+     *
+     * 不碰 A、不给 A 发任何请求——**B 不管理它连的那台 A**。回给界面的 `note` 是要
+     * 原样显示给用户的那句话：说清"A 那边还留着这条记录，要彻底收回得去 A 撤销"。
+     */
+    const offRemotesForget = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/remotes/forget',
+      handler: async (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 POST。' })
+          return
+        }
+        let want
+        try {
+          want = await readBody(req)
+        } catch (err) {
+          sendJson(res, 400, { ok: false, error: `请求体读不了：${err?.message ?? err}` })
+          return
+        }
+        const id = typeof want?.id === 'string' ? want.id : ''
+        if (!id) {
+          sendJson(res, 400, { ok: false, error: '要断开哪一台？请求里没有 id。' })
+          return
+        }
+        if (!remotes.forget(id)) {
+          // 另一个标签页刚断开过：如实说"它已经不在列表里了"，别假装成功。
+          sendJson(res, 404, { ok: false, error: '这台电脑已经不在列表里了，刷新看看。' })
+          return
+        }
+        // 只记 id、只说明"本地删了"：**不写"已撤销"**——我们没去 A 那边撤销。
+        console.log(`[dsh-mini-remote] 断开了一台电脑（${id}）：只删了本地这一条`)
+        sendJson(res, 200, { ok: true, id, note: REMOTE_FORGOTTEN_NOTE })
+      },
+    })
+
+    /**
+     * 「自检」：**这台电脑到底在跑什么**（2026-10-17）。
+     *
+     * ## 为什么要有它（两个真真的教训）
+     *
+     * 那天排一台真机上的故障花掉很久，根因有两条，而两条都是**"看不见那台机器在跑什么"
+     * 造成的**：A 那台的桌面端连开了二十四小时，加载的是"新功能写下来之前"的旧代码；
+     * B 那台装的插件是旧版本，新接口根本没出现。当时只能靠用户来回反馈、一个个地址去敲、
+     * 靠猜——而这两条各自用一句话就能定位（进程比代码旧 / 接口清单里少一条）。
+     *
+     * 所以它回答的就是那几个问题：这份插件是哪一版、宿主进程什么时候起的、我们注册了
+     * 哪些 `/mini-remote/*`、跨机那个总开关开没开、手机服务在听哪个端口绑了哪些地址、
+     * 数据目录在哪、两份名册各有多少条。
+     *
+     * ## 只给本机看（和别的 `/mini-remote/*` 同一条规矩）
+     *
+     * 它摆的是这台电脑的底细（路径、端口、名册条数、进程何时起的）。**不调 `localOnly`
+     * 的两条是例外**（`pair` / `remote/window`），理由写在它们那儿——这一条没有那个理由。
+     *
+     * ## 一个字节的凭据都不许进这个返回值
+     *
+     * 自检是**给人看**的，不是给机器用的：口令、设备密钥哈希、`remotes.json` 里那枚
+     * 长期凭据、飞书的 appSecret，一个都不出现。所以下面**只数条数、不摆记录**
+     * （`devices.list()` / `remotes.list()` 回来的记录里带着 id、名字、时间——那些也不必要）。
+     *
+     * ## 拿不到就说「未知」，它自己不能成为新的故障点
+     *
+     * 手机服务还没起来（`server` 为 null）、`package.json` 读不到、名册读不出来——
+     * 每一种都对应一个 `null`/空列表，**不抛错**。一条诊断路由要是在被诊断的东西坏掉时
+     * 跟着坏掉，那它就白写了。
+     */
+    function selfcheckPayload() {
+      const startedAtMs = Date.now() - Math.round(process.uptime() * 1000)
+      const newest = newestSource()
+      const verdict = staleCodeVerdict(startedAtMs, newest)
+      // 只数条数。这两份名册一个是"谁连得上我"、一个是"我连得上谁"，
+      // 内容一个字段都不往这儿搬（见上面那段）。
+      const countOf = (fn) => {
+        try {
+          const rows = fn()
+          return Array.isArray(rows) ? rows.length : null
+        } catch {
+          return null
+        }
+      }
+      return {
+        ok: true,
+        /** `package.json` 里的 version；读不到是 null。 */
+        version: pluginVersion(),
+        process: {
+          pid: process.pid,
+          startedAtMs,
+          /** ISO 时刻，给 curl 的人看；界面自己按本地时区格式化那个毫秒值。 */
+          startedAt: new Date(startedAtMs).toISOString(),
+          uptimeSec: Math.round(process.uptime()),
+        },
+        /**
+         * 「进程比代码旧」那一条（见 `staleCodeVerdict`）。
+         * `stale` 三态：`true` 旧了 / `false` 不是 / `null` 拿不到、不知道。
+         */
+        code: {
+          file: verdict.file,
+          modifiedAtMs: Number.isFinite(newest?.at) ? newest.at : null,
+          stale: verdict.stale,
+          message: verdict.message,
+        },
+        /** 我们注册过的 `/mini-remote/*`：`mounted` 说的是"现在仍挂着"。 */
+        routes: [...routeBook.entries()].map(([path, one]) => ({
+          path,
+          kind: one.kind,
+          mounted: one.mounted,
+        })),
+        /** 「允许别的电脑连接」那个总开关（默认关）。 */
+        allowRemoteComputers: Boolean(settings.allowRemoteComputers),
+        /** 手机服务那一半：只报"在不在听、听哪儿"，不报任何凭据。 */
+        phoneService: {
+          listening: Boolean(server),
+          port: server?.port ?? null,
+          addresses: server ? [...server.addresses] : [],
+          // 起不来时把原因（端口被占之类）原样说一句，这比一个光秃秃的 false 有用。
+          error: server ? null : (serverError ? String(serverError) : null),
+          /**
+           * 跨机那两条在**手机服务那一半**也有挂载点（见 `hostHalfRoutes`）。
+           * 它们决定"B 只填一条地址"能不能成——所以两半的状态都要看得见。
+           */
+          hostHalf: {
+            pair: Boolean(hostHalfRoutes.pair),
+            remoteWindow: Boolean(hostHalfRoutes.remoteWindow),
+          },
+        },
+        dataDir: dir,
+        rosters: {
+          devices: countOf(() => devices.list()),
+          remotes: countOf(() => remotes.list()),
+        },
+        /**
+         * 最近出的错，**最新在前**，最多 20 条（见上面 `recentErrors` 那段）。
+         *
+         * 为什么把 `message` 直接摆出来而不是给个错误码：这几块错误（端口被占、隧道连不上、
+         * 飞书断开、跨机不通）本来就是"一句话就能说清"的东西，码表只会多一层翻译。
+         * 消息已经过 `redact`，不会有凭据。
+         *
+         * 空数组是正常的：那是"这次开机以来没出过错"，不是"取不到"。
+         */
+        errors: recentErrors.slice().reverse(),
+      }
+    }
+
+    const offSelfcheck = mountRoute({
+      kind: 'exact',
+      path: '/mini-remote/selfcheck',
+      handler: (req, res) => {
+        if (!localOnly(req, res)) return
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { ok: false, error: '这个地址只接受 GET。' })
+          return
+        }
+        try {
+          sendJson(res, 200, selfcheckPayload())
+        } catch (err) {
+          // 兜底：这一段本该一步都不会抛（每一项各自拿不到就说"未知"）。
+          // 真抛了也不许把自检变成一个报错页面——如实说哪一步没读出来。
+          // `ok:false` 是有意的：界面那一头照别的失败一样把那句原因摆出来，
+          // 而不是拿到一份缺胳膊少腿的"正常"数据。
+          sendJson(res, 200, { ok: false, error: `自检读不出来：${err?.message ?? err}` })
+        }
+      },
+    })
+
     /**
      * 卸载时把注册过的路由全部注销。
      *
@@ -3719,6 +5286,16 @@ export function apply(ctx, config = {}) {
      *
      * 2026-09-24 补：`offToken` 一直是漏的（改密码那条路由注册了却没注销），
      * 加 HTTPS 这条时对照着数了一遍才发现。五条注册，五条注销，现在对得上。
+     * 2026-10-15 加「远程窗口」那条：六条注册，六条注销。
+     * 2026-10-16 加「设备名册」那三条（列出/改名/撤销）：**九条注册，九条注销**。
+     * 2026-10-16 加「配对」那一条：**十条注册，十条注销**。
+     * 2026-10-16 加「跨机取票」和「允许别的电脑连接」那两条：**十二条注册，十二条注销**。
+     * 2026-10-16 加「我能连的电脑」那四条（B 侧：列出/添加/取票/断开）：**十六条注册，
+     * 十六条注销**。
+     * 2026-10-17 加「跨机那两条在手机服务上再挂一份」：注册数没变（那两条不是新的
+     * `webServer.register`，是同一个处理函数的第二个挂载点），但**两处挂载点都得摘**。
+     * 2026-10-17 加「自检」那一条：**十七条注册，十七条注销**。
+     *   （那十六条现在都走 `mountRoute`——它就是我们这一处的登记口，注册和注销同一个门。）
      */
     return () => {
       offGet?.()
@@ -3726,6 +5303,22 @@ export function apply(ctx, config = {}) {
       offServe?.()
       offToken?.()
       offFeishu?.()
+      offWindow?.()
+      offDevices?.()
+      offDeviceRename?.()
+      offDeviceRevoke?.()
+      offPair?.()
+      offRemoteWindow?.()
+      offRemoteAccess?.()
+      offRemotesList?.()
+      offRemotesAdd?.()
+      offRemotesWindow?.()
+      offRemotesForget?.()
+      offSelfcheck?.()
+      // 手机服务那一半那两个挂载点（见 hostHalfRoutes）：那条服务活得比这份 disposer
+      // 久是可能的（先摘路由、后关服务），留着就是两个指向死闭包的口子。
+      hostHalfRoutes.pair = null
+      hostHalfRoutes.remoteWindow = null
     }
   })
 }