@dsh-remote/relay 3.1.3 → 3.1.4

package/README.md

@@ -1,7 +1,7 @@
 # @dsh-remote/relay
 
 DSH Remote Control 的**零知识 WebSocket 中继**：在宿主插件与已配对的手机之间转发**密封记录**，
-只认帧名 / 会话 id / 能力协商，**从不解析载荷**——密文对它就是一个 base64 字符串。
+只认帧名 / 会话 id / 协议版本闸，**从不解析载荷**——密文对它就是一个 base64 字符串。
 
 生产形态是**单文件产物** `dist/bundle/main.js`（`ws` / `zod` / 协议层全部内联，运行时零依赖）；
 部署只有两种：拷这个单文件 + 起进程（systemd / docker / nginx 配方见下），或从源码构建。

package/deploy/README.md

@@ -20,7 +20,7 @@
 于是生产只有"拷一个文件 + 一个 env 文件"，没有 `npm install`，也就没有
 "服务器上的依赖树和 CI 不一样"这一类故障。
 
-> 完整的环境变量表、日志契约、重启语义、升级回滚见 [`../docs/SELF-HOSTING.md`](../docs/SELF-HOSTING.md)。
+> 完整的环境变量表、日志契约、重启语义、升级见 [`../docs/SELF-HOSTING.md`](../docs/SELF-HOSTING.md)。
 
 ## 从零复现
 

package/deploy/docker/README.md

@@ -57,20 +57,17 @@ docker compose … logs relay | jq 'select(.msg=="counters")'
 json-file 轮转（`max-size: 10m` / `max-file: 5`）。要长期留存就装一个日志驱动转发出去，
 别依赖 `docker logs`。
 
-## 升级与回滚
+## 升级
 
 ```sh
 # 升级：构建 → 重启 → 看版本号变了没有
 docker compose -f deploy/docker/compose.yaml up -d --build
 curl -s http://127.0.0.1:8787/healthz | grep -o '"version":"[^"]*"'
-
-# 回滚：把标签切回去再 up（镜像还在本地）
-docker tag dsh-remote-relay:2.0.14 dsh-remote-relay:2.0.15
-docker compose -f deploy/docker/compose.yaml up -d
 ```
 
-**回滚必须成对**（中继产物 + 主机插件产物）：两代握手帧名不兼容，只回滚一边会
-"永远配不上对"或"静默不上线"。见 `../SELF-HOSTING.md` §10.2 的对照表。
+三端（中继 / 宿主插件 / 小程序）必须升到**同一协议版本**：落后的一端会在 `hello` 那一刻
+被明确拒掉（`unsupported_protocol`）。⚠️ 2026-10-11 晚：原来这里还写着一套"成对回滚 +
+两代兼容矩阵"，随能力位与版本协商机制一起删掉了 —— 没有老用户，不需要回滚路径。
 
 ## 拉不到 Docker Hub 怎么办
 

package/dist/bundle/main.js

@@ -23394,7 +23394,7 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/limits.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/limits.js
 var MAX_RELAY_MESSAGE_BYTES = 1024 * 1024;
 var MAX_CIPHERTEXT_BYTES = MAX_RELAY_MESSAGE_BYTES - 8 * 1024;
 var MAX_IMAGE_ATTACHMENTS = 4;
@@ -23403,13 +23403,11 @@ var MAX_ATTACHMENT_BYTES = 512 * 1024;
 var MAX_ATTACHMENT_TOTAL_BYTES = 512 * 1024;
 var IDEMPOTENCY_WINDOW_MS = 5 * 60 * 1e3;
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/frames.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/frames.js
 var PROTOCOL_VERSION = 1;
-var MIN_SUPPORTED_PROTOCOL = 1;
 var PAIRING_TOKEN_RE = /^\d{6}$/;
 var nonEmpty = external_exports.string().min(1);
 var pairingToken = external_exports.string().regex(PAIRING_TOKEN_RE);
-var capabilityList = external_exports.array(external_exports.string().min(1).max(64)).max(64);
 var base64Text = external_exports.string().min(1).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
 var clientMeta = external_exports.object({
   /**
@@ -23424,12 +23422,8 @@ var clientMeta = external_exports.object({
 var helloFrame = external_exports.object({
   t: external_exports.literal("hello"),
   role: external_exports.enum(["host", "client"]),
-  protocol: external_exports.number().int().positive().optional(),
-  /**
-   * 本端支持的能力（规范 §5.3）。**可选**：老对端不带，老中继也照旧工作——
-   * 缺省按"只支持基线"处理，而不是按"什么都不支持"拒绝。
-   */
-  capabilities: capabilityList.optional(),
+  /** **必填**：两端必须同版本（单版本制，见 `negotiate.ts`）。 */
+  protocol: external_exports.number().int().positive(),
   /** host 的出站认证凭据，与中继的 `DRC_HOST_TOKEN` 定时安全比较。上限防超长串白占内存。 */
   token: external_exports.string().min(1).max(512).optional(),
   hostId: nonEmpty.optional(),
@@ -23494,9 +23488,7 @@ var helloOkFrame = external_exports.object({
   /** 权威 clientId：小程序会采纳它并覆盖本地安装 id（F2/§3.6）。 */
   clientId: external_exports.string().min(1).max(128).optional(),
   hostId: nonEmpty.optional(),
-  protocol: external_exports.number().int().positive().optional(),
-  /** 中继自己支持的能力（规范 §5.3）。端点据此知道自己能向它要什么。 */
-  capabilities: capabilityList.optional()
+  protocol: external_exports.number().int().positive()
 });
 var pairReadyFrame = external_exports.object({
   t: external_exports.literal("pair-ready"),
@@ -23541,11 +23533,11 @@ var pairFailFrame = external_exports.object({
    * 症状不是"多扫一次码"：B 的 PSK 被丢弃意味着那条配对通道作废，
    * 而这正是文件头引用的那起「取错 PSK 全线解不开」事故的前置条件。
    *
-   * ## 兼容
+   * ## 为什么可选
    *
-   * **可选**：更老的中继不发它，主机侧必须继续按"当前展示的那张"兜底
-   * （`onPairFail` 的注释里写着这条兜底的原因）。发它的是中继、读它的是主机，
-   * 同一时刻两端版本必然一致——所以"新主机 + 老中继"才是需要兜底的那一侧。
+   * **中继不总能知道是哪一张**：帧本身坏掉那条分支（`server.ts` 里 `bad_frame` 那条）
+   * 手上没有 token 可点名。缺省时主机按"当前展示的那张"兜底
+   * （`onPairFail` 的注释里写着这条兜底的原因）。
    */
   pairingToken: external_exports.string().min(1).max(16).optional()
 });
@@ -23568,11 +23560,12 @@ var peerLeftFrame = external_exports.object({
    *     **再也不会带这个 convId 回来**。主机留着这条会话就是一条永远清不掉的幽灵。
    *   - 手机 socket 断了（切后台、断网）：D3 要求会话留着，回前台还要用它。
    *
-   * 不带这个标记 = 断线（老中继行为，保持 D3）；带 true = 主动解配，主机应当把
-   * 会话一并作废，于是 pill 从「手机离线」回到「未配对」（2026-10-05 用户报：
-   * 「mp 端解除配对，dsh 端执行的是手机离线」）。
+   * 不带这个标记 = **断线**（D3：会话留着，回前台还要用）；带 true = 主动解配，
+   * 主机应当把会话一并作废，于是 pill 从「手机离线」回到「未配对」
+   * （2026-10-05 用户报：「mp 端解除配对，dsh 端执行的是手机离线」）。
    *
-   * 可选是刻意的：老中继不会带这个字段，主机必须仍按「断线」处理，不能假定。
+   * 可选是**语义**上的：它表达"这次离开是断线还是解配"，缺省必须是断线
+   * （主机不许假定是解配 —— 那会把用户的一条会话凭空作废）。
    */
   unpaired: external_exports.boolean().optional()
 });
@@ -23609,12 +23602,12 @@ var errorCodes = [
    */
   "history_window_exceeded",
   /**
-   * 对端的对端版本落在 `[MIN_SUPPORTED_PROTOCOL, 本端]` 之外（规范 §5.2 V3）。
+   * 对端报的协议版本与本端**不相等**（含没报，规范 §5.2 V3）。
    *
    * 为什么不复用 `bad_frame`：它是**版本问题**而不是形状问题，而它唯一该触发的
    * 动作是"把版本说清楚"——一句"帧形状非法"会让用户去查一个根本不存在的问题。
-   * 加它不破坏任何老实现：老 client 见到不认识的码会走兜底展示（`message || code`），
-   * 所以中继 MUST 同时带上一句中文 message（规范 §12.3 E1）。
+   * 不认识的码在客户端会走兜底展示（`message || code`），所以中继 MUST 同时带上一句
+   * 中文 message（规范 §12.3 E1）—— 反过来，"没带 message"就是把英文码弹给用户。
    */
   "unsupported_protocol",
   "internal"
@@ -23882,7 +23875,7 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/identity/ids.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/identity/ids.js
 import { randomBytes, randomUUID } from "node:crypto";
 var CONVERSATION_ID_PREFIX = "c_";
 function newConversationId() {
@@ -23892,10 +23885,52 @@ function newHostId() {
   return randomBytes(4).toString("hex");
 }
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/platform/sleep.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/negotiate.js
+function negotiateProtocol(peerProtocol, own2 = PROTOCOL_VERSION) {
+  if (peerProtocol === void 0 || peerProtocol === null) {
+    return {
+      ok: false,
+      reason: "missing",
+      peer: peerProtocol,
+      message: `\u5BF9\u65B9\u6CA1\u6709\u62A5\u534F\u8BAE\u7248\u672C\uFF08\u672C\u7AEF\u4E3A ${own2}\uFF09\uFF1A\u628A\u5BF9\u7AEF\u5347\u5230\u540C\u4E00\u7248\u672C\u518D\u8BD5`
+    };
+  }
+  if (typeof peerProtocol !== "number" || !Number.isInteger(peerProtocol) || peerProtocol <= 0) {
+    return {
+      ok: false,
+      reason: "invalid",
+      peer: peerProtocol,
+      message: `\u5BF9\u65B9\u62A5\u544A\u7684\u534F\u8BAE\u7248\u672C\u4E0D\u662F\u6B63\u6574\u6570\uFF08\u6536\u5230 ${JSON.stringify(peerProtocol) ?? "undefined"}\uFF09`
+    };
+  }
+  if (peerProtocol !== own2) {
+    return {
+      ok: false,
+      reason: "mismatch",
+      peer: peerProtocol,
+      /**
+       * ⚠️ 这句话**会被原样弹到用户手机上**（中继 `acceptProtocol` 显式带 message，
+       * 而客户端的处理是 `f.message || f.code`）。所以人称必须从**读它的人**出发：
+       * 收这条错的那端才是要被升级的那端。写"请把本端升级"时，手机用户读到的是
+       * "请升级我的手机"，而真正落后的是中继/主机那一侧 —— 两个方向都试过，
+       * 都会指错人。⇒ 只陈述事实（本端 X、对方 Y），由人来判断升哪一端。
+       */
+      message: `\u534F\u8BAE\u7248\u672C\u5BF9\u4E0D\u4E0A\uFF1A\u8FD9\u4E00\u7AEF\u662F ${own2}\uFF0C\u5BF9\u65B9\u662F ${peerProtocol}\u3002\u4E24\u7AEF\u5FC5\u987B\u662F\u540C\u4E00\u7248\u672C`
+    };
+  }
+  return { ok: true, version: peerProtocol };
+}
+
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/errors.js
+var WAIT_HINTABLE = /* @__PURE__ */ new Set(["rate_limited", "pair_table_full"]);
+function wantsRetryAfter(code) {
+  return typeof code === "string" && WAIT_HINTABLE.has(code);
+}
+
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/platform/sleep.js
 var SLEEP_BACKENDS = ["caffeinate", "systemd-inhibit", "unsupported"];
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/payloads.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/payloads.js
 var SESSION_STATES = [
   "idle",
   "running",
@@ -23965,9 +24000,18 @@ var evPermissionRequest = external_exports.object({
 var evPermissionResolved = external_exports.object({
   t: external_exports.literal("ev.permission_resolved"),
   requestId: nonEmpty2,
-  sessionId: nonEmpty2.optional(),
-  /** 谁收的场。手机只按"要不要收掉这张卡"读它，所以不做必填。 */
-  by: external_exports.enum(["desktop", "cancelled"]).optional()
+  /**
+   * ⚠️ **必填**（2026-10-11 晚）：句柄在生产端（`runtime.ts` 的 `voidStaleCard`）
+   * 从来都是给全的，而"可选"在这里只有一个后果 —— 一次串台的收场会把别的会话的卡收掉。
+   */
+  sessionId: nonEmpty2,
+  /**
+   * 谁收的场。
+   *
+   * ⚠️ **必填**（2026-10-11 晚）：原来写的是"手机只按'要不要收掉这张卡'读它，所以不做必填"，
+   * 而生产端一直都给 —— 形状只有一种，那就不留"缺了也算合法"的第二条路。
+   */
+  by: external_exports.enum(["desktop", "cancelled"])
 });
 var questionItem = external_exports.object({
   id: nonEmpty2,
@@ -23984,19 +24028,26 @@ var evQuestionRequest = external_exports.object({
   /**
    * 这张提问卡什么时候作废（ISO 字符串）。
    *
-   * 为什么审批有而提问没有过：主机侧的提问等待本来就带超时（`questionTimeoutMs`，默认 300s），
-   * 但手机上那张卡**没有任何倒计时**——用户看不见自己按的按钮什么时候失效，
-   * 而这违反伞仓 `docs/PRODUCT.md` §3 第 3 条「超时必须可见」。
-   * 与审批那条同一个形状：可选、ISO 字符串、由主机每次发问时现算。
+   * ⚠️ **2026-10-11 起：这个字段由宿主决定，我们不自己算。**
+   *
+   * 主机侧追问题时**带不带期限，由那一代内核说了算**（实测它给的是"不带"）。
+   * 带来就填、不带就**省掉这个键** —— 手机据此决定要不要起倒计时，
+   * 而它只在主机真的会到点结算时才有意义。
+   *
+   * 曾经这里写的是"主机侧的提问等待本来就带超时（默认 300s）"，而那个上限是
+   * **插件自己加的**（`approvalTimeoutSec` 那个旋钮同批删除）。
+   * 它造成过真实故障：页面退后台 → 事件退订 → 卡帧到了 client 没到界面 →
+   * 用户回到页面时主机早已判超时，于是"手机上点不动"。
    */
   expiresAt: external_exports.string().optional()
 });
 var evQuestionResolved = external_exports.object({
   t: external_exports.literal("ev.question_resolved"),
   requestId: nonEmpty2,
-  sessionId: nonEmpty2.optional(),
-  /** 谁收的场。手机只按"要不要收掉这张卡"读它，所以不做必填。 */
-  by: external_exports.enum(["desktop", "cancelled"]).optional()
+  /** 必填，理由同 `evPermissionResolved.sessionId`（收场必须精确到会话）。 */
+  sessionId: nonEmpty2,
+  /** 必填，理由同 `evPermissionResolved.by`。 */
+  by: external_exports.enum(["desktop", "cancelled"])
 });
 var evRunState = external_exports.object({
   t: external_exports.literal("ev.run_state"),
@@ -24054,8 +24105,8 @@ var evHostInfo = external_exports.object({
   t: external_exports.literal("ev.host_info"),
   /**
    * 主机自述。这里**没有** `sessionId`，将来也不许加（与 `ev.session_changed` /
-   * `ev.keep_awake_state` 同一条 F11）：能力面是主机级的，按会话分装会把
-   * "这台主机支持什么"变成"这条通道支持什么"，而手机只想知道前者。
+   * `ev.keep_awake_state` 同一条 F11）：限额是主机级的，按会话分装会把
+   * "这台主机能收多少"变成"这条通道能收多少"，而手机只想知道前者。
    */
   host: external_exports.object({
     platform: nonEmpty2,
@@ -24066,8 +24117,6 @@ var evHostInfo = external_exports.object({
     carrier: external_exports.string().optional(),
     dshVersion: external_exports.string().optional()
   }),
-  /** §17.4 的能力 id 列表。生产端取自 `CAPABILITY_IDS`（L1）。 */
-  caps: capabilityList,
   limits: hostLimits,
   state: external_exports.object({
     /** 防休眠走哪条系统后端；`unsupported` 是如实上报，不是错误。 */
@@ -24091,7 +24140,8 @@ var evModel = external_exports.object({
    * 模型是**按会话**的，不带 sessionId 就无法过滤——任何一条别的会话的
    * 模型帧都会覆盖本会话的显示。
    *
-   * 必填：老主机不带这个字段时 mp 端宁可忽略这一帧，也不显示错的。
+   * **必填**（2026-10-11 晚）：不带会话归属的模型帧在 mp 端一律丢弃 ——
+   * 宁可这一帧不算数，也不能把别的会话的模型名显示到本会话顶栏。
    */
   sessionId: nonEmpty2,
   provider: nonEmpty2.optional(),
@@ -24126,8 +24176,9 @@ var evSessionHistory = external_exports.object({
    * 而空页没有任何 seq 可取——于是手机要么记一个陈旧的值（下次重复收到已看过的条目），
    * 要么记 0（下次把整段历史重拉一遍）。这个字段让"你现在到哪了"始终有答案。
    *
-   * ⚠️ 它**不是**能力位那样的"可选支持"：老主机不发这个字段时，手机看到 `undefined`
-   * 就退回 v2 的重拉一页（能力位 `drc.payload.resume` 决定走哪条路）。
+   * ⚠️ 可选的含义是"**这一页报不出游标**"（内核这一代给不出来），不是"对端可能不支持"：
+   * 手机拿到 `undefined` 就按"已经到顶"收工（`client.js` 的 `next === null` 那一支），
+   * 不记一个错的游标。（原来这里还提能力位 `drc.payload.resume` —— 那套机制已删除。）
    */
   latestSeq: external_exports.number().int().nonnegative().optional()
 });
@@ -24174,8 +24225,7 @@ var cmdSendPrompt = external_exports.object({
   sessionId: nonEmpty2,
   text: external_exports.string(),
   /**
-   * 随消息的图片附件。**可选**：老版本手机不带这个字段，老主机看到也不认
-   * （zod 默认 strip 未知键，而 text 照旧）——所以这是向后兼容的增补，不升协议版本。
+   * 随消息的图片附件。**可选**：不带 = 这条消息没有图片（一个真实状态）。
    * 上限取 `limits.ts` 的 `MAX_IMAGE_ATTACHMENTS`（4）：再多对"看清楚这张图"没有帮助，
    * 只是把帧撑爆。**同一个数**还在小程序（`MAX_ATTACH`）与主机侧（`uploads.ts`）各写一遍，
    * 靠 `e2e/wire-surface.test.mjs` 逐处比对钉住——改动必须三处同时发生。
@@ -24306,145 +24356,7 @@ var PAYLOAD_TYPES = {
   evSessionHistory: "ev.session_history"
 };
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/registry.js
-var ENDPOINT_FRAME_NAMES = [
-  "hello",
-  "pair-begin",
-  "pair-begin-client",
-  "resync",
-  "enc",
-  "enc-batch",
-  "session-leave",
-  "ping"
-];
-var RELAY_FRAME_NAMES = [
-  "hello-ok",
-  "pair-ready",
-  "paired",
-  "pair-fail",
-  "peer-joined",
-  "peer-left",
-  "error",
-  "pong",
-  "enc",
-  "enc-batch"
-];
-var FRAME_TYPES = [
-  .../* @__PURE__ */ new Set([...ENDPOINT_FRAME_NAMES, ...RELAY_FRAME_NAMES])
-];
-var FRAME_TYPE_SET = new Set(FRAME_TYPES);
-function isKnownFrameType(name) {
-  return typeof name === "string" && FRAME_TYPE_SET.has(name);
-}
-var CMD_TYPES = [
-  PAYLOAD_TYPES.cmdSendPrompt,
-  PAYLOAD_TYPES.cmdAnswer,
-  PAYLOAD_TYPES.cmdResolvePermission,
-  PAYLOAD_TYPES.cmdInterrupt,
-  PAYLOAD_TYPES.cmdListSessions,
-  PAYLOAD_TYPES.cmdKeepAwake,
-  PAYLOAD_TYPES.cmdSessionHistory,
-  PAYLOAD_TYPES.cmdNewSession,
-  PAYLOAD_TYPES.cmdGetPending,
-  PAYLOAD_TYPES.cmdArchiveSession
-];
-var EV_TYPES = [
-  PAYLOAD_TYPES.evSessionChanged,
-  PAYLOAD_TYPES.evMessageDelta,
-  PAYLOAD_TYPES.evToolEvent,
-  PAYLOAD_TYPES.evPermissionRequest,
-  PAYLOAD_TYPES.evPermissionResolved,
-  PAYLOAD_TYPES.evQuestionRequest,
-  PAYLOAD_TYPES.evQuestionResolved,
-  PAYLOAD_TYPES.evRunState,
-  PAYLOAD_TYPES.evTodo,
-  PAYLOAD_TYPES.evRetry,
-  PAYLOAD_TYPES.evCompaction,
-  PAYLOAD_TYPES.evKeepAwakeState,
-  PAYLOAD_TYPES.evHostInfo,
-  PAYLOAD_TYPES.evModel,
-  PAYLOAD_TYPES.evResult,
-  PAYLOAD_TYPES.evSessionHistory
-];
-var PAYLOAD_TYPE_SET = /* @__PURE__ */ new Set([...CMD_TYPES, ...EV_TYPES]);
-var CAPABILITY_IDS = [
-  "drc.v1",
-  "drc.pairing.qr",
-  "drc.pairing.token",
-  "drc.payload.attachments",
-  "drc.payload.history",
-  /**
-   * 支持 `cmd.session_history.since` 向前补差量 + `ev.session_history.latestSeq`。
-   *
-   * **为什么是能力位而不是版本号**：协议 v1 的帧名与载荷名冻结（规范 §5.2 V1），
-   * 加这个字段属"加性变更"；而手机要知道**对端是否真的会回 `latestSeq`**，
-   * 才能决定走补差量还是退回重拉一页。版本号表达不了"这一项有没有"。
-   *
-   * 老主机缺这一位时，手机**必须**退回重拉一页而不是发 `since`——
-   * 那是可验证的降级路径（反向判据见 `tests/resume-capability.test.ts`）。
-   */
-  "drc.payload.resume",
-  "drc.payload.new-session.workspace",
-  "drc.payload.get-pending",
-  "drc.payload.keep-awake",
-  "drc.payload.archive-session",
-  "drc.payload.model",
-  "drc.payload.retry-compaction",
-  "drc.cmd.idempotency",
-  "drc.data.enc-batch",
-  "drc.host.resync",
-  "drc.host.info",
-  "drc.crypto.v2"
-];
-var CAPABILITY_SET = new Set(CAPABILITY_IDS);
-
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/negotiate.js
-function negotiateProtocol(peerProtocol, own2 = PROTOCOL_VERSION, min = MIN_SUPPORTED_PROTOCOL) {
-  if (peerProtocol === void 0 || peerProtocol === null) {
-    return verdictFor(1, own2, min, true);
-  }
-  if (typeof peerProtocol !== "number" || !Number.isInteger(peerProtocol) || peerProtocol <= 0) {
-    return {
-      ok: false,
-      reason: "invalid",
-      peer: peerProtocol,
-      message: `\u5BF9\u65B9\u62A5\u544A\u7684\u534F\u8BAE\u7248\u672C\u4E0D\u662F\u6B63\u6574\u6570\uFF08\u6536\u5230 ${JSON.stringify(peerProtocol) ?? "undefined"}\uFF09`
-    };
-  }
-  return verdictFor(peerProtocol, own2, min, false);
-}
-function verdictFor(peer, own2, min, missing) {
-  if (peer < min) {
-    return {
-      ok: false,
-      reason: "too_old",
-      peer,
-      message: `\u5BF9\u65B9\u534F\u8BAE\u7248\u672C ${peer} \u592A\u65E7\uFF0C\u672C\u7AEF\u6700\u4F4E\u652F\u6301 ${min}\uFF1B\u8BF7\u628A\u5BF9\u7AEF\u5347\u7EA7\u540E\u518D\u8BD5`
-    };
-  }
-  if (peer > own2) {
-    return {
-      ok: false,
-      reason: "too_new",
-      peer,
-      // ⚠️ 这句话**会被原样弹到用户手机上**（中继 `acceptProtocol` 显式带 message，
-      // 而客户端的处理是 `f.message || f.code`）。所以人称必须从**读它的人**出发：
-      // 收这条错的一端是"对方"，而被要求升级的是它自己 —— 写"请把本端升级"时，
-      // 手机用户读到的是"请升级我的手机"，而真正要升级的是中继/主机那一侧。
-      // 同理"对方"在中继的日志里指的是手机。两个方向都试过，读起来都指错了人。
-      message: `\u672C\u7AEF\u534F\u8BAE\u7248\u672C ${own2} \u6BD4\u5BF9\u65B9\u65E7\uFF08\u5BF9\u65B9\u4E3A ${peer}\uFF09\uFF1B\u8BF7\u628A\u672C\u7AEF\u5347\u7EA7\u5230 ${peer} \u6216\u66F4\u9AD8\u540E\u518D\u8BD5`
-    };
-  }
-  return { ok: true, version: peer, missing };
-}
-
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/errors.js
-var WAIT_HINTABLE = /* @__PURE__ */ new Set(["rate_limited", "pair_table_full"]);
-function wantsRetryAfter(code) {
-  return typeof code === "string" && WAIT_HINTABLE.has(code);
-}
-
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/outbound.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/outbound.js
 function helloOkForClient(clientId, protocol) {
   return { t: "hello-ok", role: "client", clientId, ...protocol === void 0 ? {} : { protocol } };
 }
@@ -24522,7 +24434,69 @@ function encBatchToRelay(sessionId, items) {
   return { t: "enc-batch", sessionId, items: items.map((item) => ({ ...item })) };
 }
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.7/node_modules/@dsh-remote/protocol/dist/src/wire/classify.js
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/registry.js
+var ENDPOINT_FRAME_NAMES = [
+  "hello",
+  "pair-begin",
+  "pair-begin-client",
+  "resync",
+  "enc",
+  "enc-batch",
+  "session-leave",
+  "ping"
+];
+var RELAY_FRAME_NAMES = [
+  "hello-ok",
+  "pair-ready",
+  "paired",
+  "pair-fail",
+  "peer-joined",
+  "peer-left",
+  "error",
+  "pong",
+  "enc",
+  "enc-batch"
+];
+var FRAME_TYPES = [
+  .../* @__PURE__ */ new Set([...ENDPOINT_FRAME_NAMES, ...RELAY_FRAME_NAMES])
+];
+var FRAME_TYPE_SET = new Set(FRAME_TYPES);
+function isKnownFrameType(name) {
+  return typeof name === "string" && FRAME_TYPE_SET.has(name);
+}
+var CMD_TYPES = [
+  PAYLOAD_TYPES.cmdSendPrompt,
+  PAYLOAD_TYPES.cmdAnswer,
+  PAYLOAD_TYPES.cmdResolvePermission,
+  PAYLOAD_TYPES.cmdInterrupt,
+  PAYLOAD_TYPES.cmdListSessions,
+  PAYLOAD_TYPES.cmdKeepAwake,
+  PAYLOAD_TYPES.cmdSessionHistory,
+  PAYLOAD_TYPES.cmdNewSession,
+  PAYLOAD_TYPES.cmdGetPending,
+  PAYLOAD_TYPES.cmdArchiveSession
+];
+var EV_TYPES = [
+  PAYLOAD_TYPES.evSessionChanged,
+  PAYLOAD_TYPES.evMessageDelta,
+  PAYLOAD_TYPES.evToolEvent,
+  PAYLOAD_TYPES.evPermissionRequest,
+  PAYLOAD_TYPES.evPermissionResolved,
+  PAYLOAD_TYPES.evQuestionRequest,
+  PAYLOAD_TYPES.evQuestionResolved,
+  PAYLOAD_TYPES.evRunState,
+  PAYLOAD_TYPES.evTodo,
+  PAYLOAD_TYPES.evRetry,
+  PAYLOAD_TYPES.evCompaction,
+  PAYLOAD_TYPES.evKeepAwakeState,
+  PAYLOAD_TYPES.evHostInfo,
+  PAYLOAD_TYPES.evModel,
+  PAYLOAD_TYPES.evResult,
+  PAYLOAD_TYPES.evSessionHistory
+];
+var PAYLOAD_TYPE_SET = /* @__PURE__ */ new Set([...CMD_TYPES, ...EV_TYPES]);
+
+// node_modules/.pnpm/@dsh-remote+protocol@3.1.4/node_modules/@dsh-remote/protocol/dist/src/wire/classify.js
 function frameTypeOf(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return void 0;
@@ -24615,12 +24589,11 @@ import {
   writeFileSync
 } from "node:fs";
 import { dirname } from "node:path";
-var STATE_FILE_VERSION = 1;
+var STATE_FILE_VERSION = 2;
 var CONVERSATION_ID_RE = new RegExp(`^${CONVERSATION_ID_PREFIX}[0-9a-f]{12}$`);
 var HOST_TOKEN_RE = /^[0-9a-f]{48}$/;
 var MAX_HOST_ID_LEN = 200;
 function sanitizeHostTokens(raw) {
-  if (!Array.isArray(raw)) return { hostTokens: [], dropped: 0 };
   const hostTokens = [];
   const seen = /* @__PURE__ */ new Set();
   for (const item of raw) {
@@ -24628,7 +24601,10 @@ function sanitizeHostTokens(raw) {
       continue;
     }
     const entry = item;
-    if (typeof entry.hostId !== "string" || entry.hostId.length > MAX_HOST_ID_LEN || entry.hostId !== "" && entry.hostId.trim() !== entry.hostId || !isNonEmptyString(entry.token) || !HOST_TOKEN_RE.test(entry.token) || !isTimestamp(entry.issuedAt) || !isTimestamp(entry.lastUsedAt) || seen.has(entry.hostId)) {
+    if (typeof entry.hostId !== "string" || // ⚠️ **空 hostId 一律丢**（2026-10-11 晚）：那曾是"未绑定槽位"的键，而它的令牌
+    // 对任意主机都算数。旧状态文件里可能真有一条这样的记录 —— 读进来就等于把
+    // 那把万能钥匙又装回内存，所以在这一层直接筛掉（不是靠 `hostTokenAccepted` 单独兜）。
+    entry.hostId === "" || entry.hostId.length > MAX_HOST_ID_LEN || entry.hostId.trim() !== entry.hostId || !isNonEmptyString(entry.token) || !HOST_TOKEN_RE.test(entry.token) || !isTimestamp(entry.issuedAt) || !isTimestamp(entry.lastUsedAt) || seen.has(entry.hostId)) {
       continue;
     }
     seen.add(entry.hostId);
@@ -24703,6 +24679,10 @@ function readStateFile(path, log) {
   }
   const { conversations, dropped } = sanitize(file2.conversations);
   if (dropped > 0) log.warn("state file entries dropped", { path, dropped, kept: conversations.length });
+  if (!Array.isArray(file2.hostTokens)) {
+    log.warn("state file has no hostTokens array, starting empty", { path });
+    return void 0;
+  }
   const hostTokenResult = sanitizeHostTokens(file2.hostTokens);
   if (hostTokenResult.dropped > 0) {
     log.warn("state file host tokens dropped", {
@@ -24717,13 +24697,12 @@ function readStateFile(path, log) {
     dropped,
     hostTokens: hostTokenResult.hostTokens.length
   });
-  const restored = {
+  return {
     version: STATE_FILE_VERSION,
     savedAt: isTimestamp(file2.savedAt) ? file2.savedAt : 0,
-    conversations
+    conversations,
+    hostTokens: hostTokenResult.hostTokens
   };
-  if (hostTokenResult.hostTokens.length > 0) restored.hostTokens = hostTokenResult.hostTokens;
-  return restored;
 }
 function snapshotState(state, now) {
   const conversations = [];
@@ -24742,9 +24721,7 @@ function snapshotState(state, now) {
   for (const [hostId, entry] of state.hostTokens) {
     hostTokens.push({ hostId, token: entry.token, issuedAt: entry.issuedAt, lastUsedAt: entry.lastUsedAt });
   }
-  const snapshot = { version: STATE_FILE_VERSION, savedAt: now, conversations };
-  if (hostTokens.length > 0) snapshot.hostTokens = hostTokens;
-  return snapshot;
+  return { version: STATE_FILE_VERSION, savedAt: now, conversations, hostTokens };
 }
 function restoreState(path, state, log, now) {
   const file2 = readStateFile(path, log);
@@ -24766,7 +24743,7 @@ function restoreState(path, state, log, now) {
   if (clamped > 0) {
     log.warn("state file timestamps in the future, clamped to now", { path, clamped });
   }
-  for (const entry of file2.hostTokens ?? []) {
+  for (const entry of file2.hostTokens) {
     state.hostTokens.set(entry.hostId, {
       token: entry.token,
       issuedAt: entry.issuedAt,
@@ -24826,13 +24803,12 @@ function writeStateFile(path, snapshot, log) {
 
 // src/state.ts
 var WS_OPEN = 1;
-var UNBOUND_HOST_TOKEN_KEY = "";
 var RelayState = class {
   hosts = /* @__PURE__ */ new Map();
   clients = /* @__PURE__ */ new Map();
   pendingPairs = /* @__PURE__ */ new Map();
   conversations = /* @__PURE__ */ new Map();
-  /** 按 hostId 一机一枚（外加 `UNBOUND_HOST_TOKEN_KEY` 那个未绑定槽位）。 */
+  /** 按 hostId 一机一枚（键一定是非空 hostId，见 `HostTokenEntry`）。 */
   hostTokens = /* @__PURE__ */ new Map();
   /** 测试可注入固定时钟；默认用真实时间。 */
   clock;
@@ -25301,15 +25277,9 @@ function createRelay(config2) {
   }
   function hostTokenAccepted(hostId, got) {
     if (!got) return false;
-    const now = Date.now();
     const perHost = state.hostTokens.get(hostId);
     if (perHost && tokenMatches(perHost.token, got)) {
-      state.markHostTokenUsed(hostId, now);
-      return true;
-    }
-    const unbound = state.hostTokens.get(UNBOUND_HOST_TOKEN_KEY);
-    if (unbound && tokenMatches(unbound.token, got)) {
-      state.markHostTokenUsed(UNBOUND_HOST_TOKEN_KEY, now);
+      state.markHostTokenUsed(hostId, Date.now());
       return true;
     }
     return config2.hostToken !== "" && tokenMatches(config2.hostToken, got);
@@ -25423,21 +25393,6 @@ function createRelay(config2) {
     peer.hostId = void 0;
   }
   function handleHello(peer, frame) {
-    if (peer.protocol === void 0 && !peer.countedProtocol) {
-      peer.countedProtocol = true;
-      if (frame.protocol === void 0) peersWithoutProtocol++;
-      else peerProtocols.set(frame.protocol, (peerProtocols.get(frame.protocol) ?? 0) + 1);
-    } else if (peer.protocol !== frame.protocol) {
-      if (peer.protocol === void 0) peersWithoutProtocol = Math.max(0, peersWithoutProtocol - 1);
-      else {
-        const left = (peerProtocols.get(peer.protocol) ?? 1) - 1;
-        if (left > 0) peerProtocols.set(peer.protocol, left);
-        else peerProtocols.delete(peer.protocol);
-      }
-      if (frame.protocol === void 0) peersWithoutProtocol++;
-      else peerProtocols.set(frame.protocol, (peerProtocols.get(frame.protocol) ?? 0) + 1);
-    }
-    peer.protocol = frame.protocol;
     if (frame.role === "host") {
       const hostId = frame.hostId?.trim() || newHostId();
       if (!config2.hostToken && state.hostTokens.size === 0) {
@@ -25607,8 +25562,6 @@ function createRelay(config2) {
     for (const sock of clients) sendTo(sock, encBatchToClient(frame.sessionId, items));
   }
   let lastResyncPersistAt = 0;
-  const peerProtocols = /* @__PURE__ */ new Map();
-  let peersWithoutProtocol = 0;
   function acceptProtocol(peer, peerProtocol) {
     const verdict = negotiateProtocol(peerProtocol);
     if (verdict.ok) return true;
@@ -25724,8 +25677,6 @@ function createRelay(config2) {
       pairBudgetWarnedAt: 0,
       backpressure: new BackpressureGate(),
       alive: true,
-      // 观测面计数的闩锁（见 Peer.countedProtocol）：连接为单位，不是 hello 为单位。
-      countedProtocol: false,
       // 轮转序号取模分配：**均匀是刻意的**。哪怕重启风暴里 10k 条连接在几十秒内
       // 全建起来，它们也会摊到所有桶上；若改成"分给下一个将要轮到的桶"，
       // 风暴会把它们全塞进同一两个桶，等于把刚拆掉的突发又造回来（C7 的场景）。
@@ -25800,12 +25751,6 @@ function createRelay(config2) {
     });
     ws.on("close", () => {
       peers.delete(ws);
-      if (peer.protocol === void 0) peersWithoutProtocol = Math.max(0, peersWithoutProtocol - 1);
-      else {
-        const left = (peerProtocols.get(peer.protocol) ?? 1) - 1;
-        if (left > 0) peerProtocols.set(peer.protocol, left);
-        else peerProtocols.delete(peer.protocol);
-      }
       bucketAt(peer.pingBucket).delete(peer);
       if (peer.role === "client" && peer.clientId) {
         for (const notice of state.clientGone(peer.clientId, ws)) {
@@ -25899,18 +25844,12 @@ function createRelay(config2) {
       stateWriteFailures: persistence.failures,
       lastPingAgo: lastPingAt === 0 ? -1 : Math.round((Date.now() - lastPingAt) / 1e3),
       shuttingDown,
-      // 协议版本协商的观测面（2026-10-07）。有了版本闸之后，"为什么这个对端连不上"
-      // 就成了新的排障问题，而没有这一项时它只能去翻日志。
-      //
-      // 报的是**对端报的最小/最大版本**与"没报过版本"的连接数，两个方向缺一不可：
-      // 只报最大值的话，一个全是老小程序的环境看起来与新版本一样正常。
-      protocolSelf: PROTOCOL_VERSION,
-      protocolMin: MIN_SUPPORTED_PROTOCOL,
-      peerProtocolMin: peerProtocols.size === 0 ? -1 : Math.min(...peerProtocols.keys()),
-      peerProtocolMax: peerProtocols.size === 0 ? -1 : Math.max(...peerProtocols.keys()),
-      peersNoProtocol: peersWithoutProtocol
+      // 本端说的协议版本（单版本制：它是一个常量，但排障时要能一眼看到"这一个中继
+      // 说的是哪一版"——版本对不上的现场表现是"连上了、什么都不发生"，没有任何一层会报错）。
+      protocolSelf: PROTOCOL_VERSION
     };
   }
+  const BODY_TOO_LARGE = "body_too_large";
   function readBody(req, limit) {
     return new Promise((resolve, reject) => {
       const chunks = [];
@@ -25918,8 +25857,8 @@ function createRelay(config2) {
       req.on("data", (chunk) => {
         size += chunk.length;
         if (size > limit) {
-          reject(new Error("body_too_large"));
-          req.destroy();
+          req.pause();
+          reject(Object.assign(new Error(BODY_TOO_LARGE), { code: BODY_TOO_LARGE }));
           return;
         }
         chunks.push(chunk);
@@ -25950,7 +25889,18 @@ function createRelay(config2) {
     }
     rememberClaim(ip, now);
     let body = {};
-    const raw = await readBody(req, CLAIM_BODY_MAX_BYTES);
+    let raw;
+    try {
+      raw = await readBody(req, CLAIM_BODY_MAX_BYTES);
+    } catch (error62) {
+      if (error62?.code === BODY_TOO_LARGE) {
+        res.statusCode = 413;
+        res.setHeader("connection", "close");
+        res.end(JSON.stringify({ error: "body_too_large", limitBytes: CLAIM_BODY_MAX_BYTES }));
+        return;
+      }
+      throw error62;
+    }
     if (raw.trim() !== "") {
       try {
         const parsed = JSON.parse(raw);
@@ -25961,24 +25911,29 @@ function createRelay(config2) {
       }
     }
     const rawHostId = typeof body.hostId === "string" ? body.hostId.trim() : "";
-    if (rawHostId !== "" && (rawHostId.length > MAX_HOST_ID_LEN2 || !HOST_ID_RE.test(rawHostId))) {
+    if (rawHostId === "") {
+      res.statusCode = 400;
+      res.end(
+        JSON.stringify({
+          error: "host_id_required",
+          hint: 'POST {"hostId":"<\u672C\u673A\u8EAB\u4EFD>"} \u2014\u2014 2026-10-11 \u8D77\u4EE4\u724C\u6309 hostId \u4E00\u673A\u4E00\u679A\uFF0C\u6CA1\u6709\u8EAB\u4EFD\u5C31\u4E0D\u7B7E'
+        })
+      );
+      return;
+    }
+    if (rawHostId.length > MAX_HOST_ID_LEN2 || !HOST_ID_RE.test(rawHostId)) {
       res.statusCode = 400;
       res.end(
         JSON.stringify({ error: "bad_host_id", hint: `hostId \u6700\u591A ${MAX_HOST_ID_LEN2} \u5B57\u7B26\uFF0C\u53EA\u5141\u8BB8\u5B57\u6BCD\u6570\u5B57\u4E0E ._:-` })
       );
       return;
     }
-    const slot = rawHostId === "" ? UNBOUND_HOST_TOKEN_KEY : rawHostId;
     const token = newHostToken();
-    state.issueHostToken(slot, token, now);
+    state.issueHostToken(rawHostId, token, now);
     const pruned = state.pruneHostTokens(config2.maxHostTokens);
     if (pruned > 0) log.warn("host tokens pruned", { dropped: pruned, kept: state.hostTokens.size });
     markStateChanged();
-    log.info(rawHostId === "" ? "host token claimed (unbound)" : "host token claimed", {
-      ip,
-      hostId: rawHostId,
-      hostTokens: state.hostTokens.size
-    });
+    log.info("host token claimed", { ip, hostId: rawHostId, hostTokens: state.hostTokens.size });
     res.end(JSON.stringify({ token, hostId: rawHostId, rotatedAt: new Date(now).toISOString() }));
   }
   function httpHandler(req, res) {
@@ -26186,7 +26141,7 @@ function registerSignalHandlers(shutdown) {
 
 // src/main.ts
 function readVersion() {
-  if ("3.1.3") return "3.1.3";
+  if ("3.1.4") return "3.1.4";
   try {
     const pkg = JSON.parse(readFileSync2(new URL("../../package.json", import.meta.url), "utf8"));
     if (typeof pkg.version === "string") return pkg.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-remote/relay",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "description": "DSH Remote Control 的零知识 WebSocket 中继：只做路由，不碰载荷明文。可自托管的单文件产物。",
   "type": "module",
   "license": "MIT",