@dsh-remote/relay 3.1.2 → 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 配方见下），或从源码构建。
@@ -34,12 +34,12 @@ curl -s http://127.0.0.1:8787/healthz
 
 ### 端点
 
-| 路径                   | 说明                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `GET /healthz`         | 运维契约（**二十三个字段**）：`ok` / `version` / `uptimeSec` / `hosts` / `clients` / `conversations` / `pendingPairs` / `droppedFrames` / `slowConsumers` / `rejectedPairs` / `shutdownForced` / `persistence` / `stateRestored` / `stateSavedAtSec` / `stateWrites` / `stateWriteFailures` / `lastPingAgo` / `shuttingDown` / `protocolSelf` / `protocolMin` / `peerProtocolMin` / `peerProtocolMax` / `peersNoProtocol` |
-| `GET /api/info`        | `{"publicUrl","protocol"}`                                                                                                                                                                                                                                                                                                                                                                                                |
-| `GET /api/pair-status` | **默认 404**。无需认证地回答"配对码 N 是否有效"等于给 6 位码空间装了扫描 oracle；确需调试时 `DRC_PAIR_STATUS=1`，用完关掉                                                                                                                                                                                                                                                                                                 |
-| WebSocket              | 路径不设限，任意路径都能升级                                                                                                                                                                                                                                                                                                                                                                                              |
+| 路径                   | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GET /healthz`         | 运维契约（**二十四个字段**）：`ok` / `version` / `uptimeSec` / `hosts` / `clients` / `conversations` / `pendingPairs` / `hostTokens` / `droppedFrames` / `slowConsumers` / `rejectedPairs` / `shutdownForced` / `persistence` / `stateRestored` / `stateSavedAtSec` / `stateWrites` / `stateWriteFailures` / `lastPingAgo` / `shuttingDown` / `protocolSelf` / `protocolMin` / `peerProtocolMin` / `peerProtocolMax` / `peersNoProtocol` |
+| `GET /api/info`        | `{"publicUrl","protocol"}`                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `GET /api/pair-status` | **默认 404**。无需认证地回答"配对码 N 是否有效"等于给 6 位码空间装了扫描 oracle；确需调试时 `DRC_PAIR_STATUS=1`，用完关掉                                                                                                                                                                                                                                                                                                                |
+| WebSocket              | 路径不设限，任意路径都能升级                                                                                                                                                                                                                                                                                                                                                                                                             |
 
 落盘五字段（`persistence` / `stateRestored` / `stateSavedAtSec` / `stateWrites` /
 `stateWriteFailures`）是"还在落盘"的唯一读数——换机器先看 `stateWriteFailures`，不是 0 就是没在写。

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.6/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.6/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"
@@ -23725,7 +23718,19 @@ var BackpressureGate = class {
 var LOG_LEVELS = { debug: 10, info: 20, warn: 30, error: 40, silent: 99 };
 var levelWeight = (level) => LOG_LEVELS[level];
 var DECIMAL_INTEGER_RE = /^[0-9]+$/;
-function integer2(raw, fallback, name, problems) {
+function claimMinIntervalMs(env, problems) {
+  const value = integer2(env.DRC_CLAIM_MIN_INTERVAL_MS, 4e3, "DRC_CLAIM_MIN_INTERVAL_MS", problems, {
+    allowZero: true
+  });
+  if (value === 0) {
+    problems.push({
+      level: "warn",
+      message: "DRC_CLAIM_MIN_INTERVAL_MS=0\uFF1A\u8BA4\u9886\u63A5\u53E3\u7684\u9650\u9891**\u5DF2\u5173\u95ED**\uFF08\u540C IP \u53EF\u4EE5\u65E0\u9650\u8FDE\u6253\uFF09\u3002\u53EA\u5728\u6D4B\u8BD5\u6216\u5B8C\u5168\u5185\u7F51\u81EA\u7528\u65F6\u8FD9\u4E48\u8BBE\uFF1B\u516C\u7F51\u4E0A\u7684\u8FD9\u53F0\u4E2D\u7EE7\u8BF7\u7559 4000\u3002"
+    });
+  }
+  return value;
+}
+function integer2(raw, fallback, name, problems, options = {}) {
   if (raw === void 0) return fallback;
   if (raw === "") {
     problems.push({
@@ -23739,8 +23744,9 @@ function integer2(raw, fallback, name, problems) {
     return fallback;
   }
   const n = Number(raw.trim());
-  if (!Number.isSafeInteger(n) || n <= 0) {
-    problems.push({ level: "error", message: `${name} \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230 ${JSON.stringify(raw)}` });
+  if (!Number.isSafeInteger(n) || n < 0 || n === 0 && options.allowZero !== true) {
+    const shape = options.allowZero === true ? "\u975E\u8D1F\u6574\u6570" : "\u6B63\u6574\u6570";
+    problems.push({ level: "error", message: `${name} \u5FC5\u987B\u662F${shape}\uFF0C\u6536\u5230 ${JSON.stringify(raw)}` });
     return fallback;
   }
   return n;
@@ -23804,6 +23810,8 @@ function loadConfig(env, version2) {
     pairGlobalBudgetPerSec: integer2(env.DRC_PAIR_GLOBAL_PER_SEC, 20, "DRC_PAIR_GLOBAL_PER_SEC", problems),
     pairStatusBudgetPerSec: integer2(env.DRC_PAIR_STATUS_PER_SEC, 5, "DRC_PAIR_STATUS_PER_SEC", problems),
     maxPendingPairs: integer2(env.DRC_MAX_PENDING_PAIRS, 1e3, "DRC_MAX_PENDING_PAIRS", problems),
+    maxHostTokens: integer2(env.DRC_MAX_HOST_TOKENS, 500, "DRC_MAX_HOST_TOKENS", problems),
+    claimMinIntervalMs: claimMinIntervalMs(env, problems),
     conversationIdleTtlMs: integer2(env.DRC_CONV_IDLE_TTL_MS, 7 * 24 * 3600 * 1e3, "DRC_CONV_IDLE_TTL_MS", problems),
     // P2-⑤（2026-10-04 用户拍板 30 分钟）：远小于 7 天的空闲 TTL。
     // 删的代价是手机再扫一次码；不删的代价是 conversations 计数虚高、排障对不上。
@@ -23867,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.6/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() {
@@ -23877,10 +23885,52 @@ function newHostId() {
   return randomBytes(4).toString("hex");
 }
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.6/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.6/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",
@@ -23950,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,
@@ -23969,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"),
@@ -24039,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,
@@ -24051,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` 是如实上报，不是错误。 */
@@ -24076,7 +24140,8 @@ var evModel = external_exports.object({
    * 模型是**按会话**的，不带 sessionId 就无法过滤——任何一条别的会话的
    * 模型帧都会覆盖本会话的显示。
    *
-   * 必填：老主机不带这个字段时 mp 端宁可忽略这一帧，也不显示错的。
+   * **必填**（2026-10-11 晚）：不带会话归属的模型帧在 mp 端一律丢弃 ——
+   * 宁可这一帧不算数，也不能把别的会话的模型名显示到本会话顶栏。
    */
   sessionId: nonEmpty2,
   provider: nonEmpty2.optional(),
@@ -24111,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()
 });
@@ -24159,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` 逐处比对钉住——改动必须三处同时发生。
@@ -24291,145 +24356,7 @@ var PAYLOAD_TYPES = {
   evSessionHistory: "ev.session_history"
 };
 
-// node_modules/.pnpm/@dsh-remote+protocol@3.0.6/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.6/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.6/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.6/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 } };
 }
@@ -24507,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.6/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;
@@ -24600,8 +24589,34 @@ 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) {
+  const hostTokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const entry = item;
+    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);
+    hostTokens.push({
+      hostId: entry.hostId,
+      token: entry.token,
+      issuedAt: entry.issuedAt,
+      lastUsedAt: entry.lastUsedAt
+    });
+  }
+  return { hostTokens, dropped: raw.length - hostTokens.length };
+}
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
@@ -24664,8 +24679,30 @@ function readStateFile(path, log) {
   }
   const { conversations, dropped } = sanitize(file2.conversations);
   if (dropped > 0) log.warn("state file entries dropped", { path, dropped, kept: conversations.length });
-  log.info("state file loaded", { path, conversations: conversations.length, dropped });
-  return { version: STATE_FILE_VERSION, savedAt: isTimestamp(file2.savedAt) ? file2.savedAt : 0, conversations };
+  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", {
+      path,
+      dropped: hostTokenResult.dropped,
+      kept: hostTokenResult.hostTokens.length
+    });
+  }
+  log.info("state file loaded", {
+    path,
+    conversations: conversations.length,
+    dropped,
+    hostTokens: hostTokenResult.hostTokens.length
+  });
+  return {
+    version: STATE_FILE_VERSION,
+    savedAt: isTimestamp(file2.savedAt) ? file2.savedAt : 0,
+    conversations,
+    hostTokens: hostTokenResult.hostTokens
+  };
 }
 function snapshotState(state, now) {
   const conversations = [];
@@ -24680,7 +24717,11 @@ function snapshotState(state, now) {
     if (conv.emptySince !== void 0) conversation.emptySince = conv.emptySince;
     conversations.push(conversation);
   }
-  return { version: STATE_FILE_VERSION, savedAt: now, conversations };
+  const hostTokens = [];
+  for (const [hostId, entry] of state.hostTokens) {
+    hostTokens.push({ hostId, token: entry.token, issuedAt: entry.issuedAt, lastUsedAt: entry.lastUsedAt });
+  }
+  return { version: STATE_FILE_VERSION, savedAt: now, conversations, hostTokens };
 }
 function restoreState(path, state, log, now) {
   const file2 = readStateFile(path, log);
@@ -24702,7 +24743,18 @@ function restoreState(path, state, log, now) {
   if (clamped > 0) {
     log.warn("state file timestamps in the future, clamped to now", { path, clamped });
   }
-  log.info("state restored", { path, conversations: state.conversations.size });
+  for (const entry of file2.hostTokens) {
+    state.hostTokens.set(entry.hostId, {
+      token: entry.token,
+      issuedAt: entry.issuedAt,
+      lastUsedAt: entry.lastUsedAt
+    });
+  }
+  log.info("state restored", {
+    path,
+    conversations: state.conversations.size,
+    hostTokens: state.hostTokens.size
+  });
   return state.conversations.size;
 }
 function syncPath(target, log, strict = true) {
@@ -24756,6 +24808,8 @@ var RelayState = class {
   clients = /* @__PURE__ */ new Map();
   pendingPairs = /* @__PURE__ */ new Map();
   conversations = /* @__PURE__ */ new Map();
+  /** 按 hostId 一机一枚（键一定是非空 hostId，见 `HostTokenEntry`）。 */
+  hostTokens = /* @__PURE__ */ new Map();
   /** 测试可注入固定时钟；默认用真实时间。 */
   clock;
   maxPendingPairsValue;
@@ -25120,12 +25174,56 @@ var RelayState = class {
     return dropped;
   }
   /** 测试与诊断：把内部计数摊平成 `/healthz` 需要的形状。 */
+  // ── host token（按 hostId 一机一枚，2026-10-11 起）────────────────────
+  /**
+   * 签发/覆盖 `hostId` 的令牌。**只动这一条**，别人那枚不受影响。
+   *
+   * `lastUsedAt` 归零：这一枚刚签出来还没被用来鉴权过。它只影响诊断与裁剪顺序
+   * （见 `pruneHostTokens`），不参与鉴权判定——鉴权只看 `token` 本身。
+   */
+  issueHostToken(hostId, token, now) {
+    const entry = { token, issuedAt: now, lastUsedAt: 0 };
+    this.hostTokens.set(hostId, entry);
+    return entry;
+  }
+  /** 记下"这枚令牌刚被用来**成功**鉴权"。没这一条时裁剪顺序就退化成"签得早的先丢"。 */
+  markHostTokenUsed(hostId, now) {
+    const entry = this.hostTokens.get(hostId);
+    if (entry) entry.lastUsedAt = now;
+  }
+  /**
+   * 令牌表有界：超出 `max` 时，按 `lastUsedAt || issuedAt` **从旧到新**丢。
+   *
+   * 为什么不是"按签发时刻丢最老"：一台一直在用的机器（签得早、但一直在用）会被
+   * 优先丢掉，而它**不会自愈**——下次它连上来只会拿到 `bad_token`，而它盘上有令牌
+   * 就不会重新认领。所以分两档：**没用过的先丢**，同一档里再按最近活动从旧到新。
+   *
+   * 返回丢掉几条（调用方去记一条 warn）。
+   */
+  pruneHostTokens(max) {
+    if (!Number.isFinite(max) || max <= 0) return 0;
+    if (this.hostTokens.size <= max) return 0;
+    const order = [...this.hostTokens.entries()].sort((a, b) => {
+      const usedA = a[1].lastUsedAt > 0 ? 1 : 0;
+      const usedB = b[1].lastUsedAt > 0 ? 1 : 0;
+      if (usedA !== usedB) return usedA - usedB;
+      return (a[1].lastUsedAt || a[1].issuedAt) - (b[1].lastUsedAt || b[1].issuedAt);
+    });
+    let dropped = 0;
+    for (const [key] of order) {
+      if (this.hostTokens.size <= max) break;
+      this.hostTokens.delete(key);
+      dropped += 1;
+    }
+    return dropped;
+  }
   counts() {
     return {
       hosts: this.hosts.size,
       clients: this.clients.size,
       conversations: this.conversations.size,
-      pendingPairs: this.pendingPairs.size
+      pendingPairs: this.pendingPairs.size,
+      hostTokens: this.hostTokens.size
     };
   }
   /** 全量清空（优雅停机或测试重置）。 */
@@ -25134,6 +25232,7 @@ var RelayState = class {
     this.clients.clear();
     this.pendingPairs.clear();
     this.conversations.clear();
+    this.hostTokens.clear();
   }
 };
 
@@ -25147,8 +25246,9 @@ function tokenMatches(expected, got) {
   if (a.length !== b.length) return false;
   return timingSafeEqual(a, b);
 }
-var CLAIM_MIN_INTERVAL_MS = 4e3;
 var CLAIM_TRACK_MAX = 1e4;
+var MAX_HOST_ID_LEN2 = 200;
+var HOST_ID_RE = /^[A-Za-z0-9._:-]+$/;
 function createRelay(config2) {
   const log = new Log(config2.logLevel);
   const state = new RelayState({ maxPendingPairs: config2.maxPendingPairs });
@@ -25157,23 +25257,32 @@ function createRelay(config2) {
   const pairStatusBudget = new Budget(config2.pairStatusBudgetPerSec);
   const peers = /* @__PURE__ */ new WeakMap();
   let shuttingDown = false;
-  let currentHostToken = config2.hostToken;
   const lastClaimAt = /* @__PURE__ */ new Map();
   let sweepTimer;
   let pingTimer;
   let lastPingAt = 0;
   let lastCountersAt = 0;
-  function rotateHostToken() {
-    currentHostToken = randomBytes2(24).toString("hex");
-    if (lastClaimAt.size >= CLAIM_TRACK_MAX) {
-      const drop = lastClaimAt.size - CLAIM_TRACK_MAX + 1;
-      let i = 0;
-      for (const key of lastClaimAt.keys()) {
-        lastClaimAt.delete(key);
-        if (++i >= drop) break;
-      }
+  function newHostToken() {
+    return randomBytes2(24).toString("hex");
+  }
+  function rememberClaim(ip, now) {
+    lastClaimAt.set(ip, now);
+    if (lastClaimAt.size <= CLAIM_TRACK_MAX) return;
+    const drop = lastClaimAt.size - CLAIM_TRACK_MAX;
+    let i = 0;
+    for (const key of lastClaimAt.keys()) {
+      lastClaimAt.delete(key);
+      if (++i >= drop) break;
+    }
+  }
+  function hostTokenAccepted(hostId, got) {
+    if (!got) return false;
+    const perHost = state.hostTokens.get(hostId);
+    if (perHost && tokenMatches(perHost.token, got)) {
+      state.markHostTokenUsed(hostId, Date.now());
+      return true;
     }
-    return currentHostToken;
+    return config2.hostToken !== "" && tokenMatches(config2.hostToken, got);
   }
   const persistence = { enabled: config2.stateFile !== "", restored: 0, savedAt: 0, writes: 0, failures: 0 };
   if (persistence.enabled) {
@@ -25284,35 +25393,20 @@ 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") {
-      if (!currentHostToken) {
+      const hostId = frame.hostId?.trim() || newHostId();
+      if (!config2.hostToken && state.hostTokens.size === 0) {
         sendError(peer, "internal", "relay has no host token configured");
         peer.ws.close(1011);
         return;
       }
-      if (!frame.token || !tokenMatches(currentHostToken, frame.token)) {
+      if (!hostTokenAccepted(hostId, frame.token)) {
         peer.authAttempts += 1;
         log.warn("host auth failed", { attempts: peer.authAttempts });
         sendError(peer, "bad_token");
         if (peer.authAttempts >= config2.maxHostAuthAttempts) peer.ws.close(4001, "too_many_auth_attempts");
         return;
       }
-      const hostId = frame.hostId?.trim() || newHostId();
       releaseIdentityFor(peer, { role: "host", id: hostId });
       const { replaced } = state.attachHost(hostId, peer.ws, frame.label ?? "");
       peer.role = "host";
@@ -25468,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;
@@ -25585,8 +25677,6 @@ function createRelay(config2) {
       pairBudgetWarnedAt: 0,
       backpressure: new BackpressureGate(),
       alive: true,
-      // 观测面计数的闩锁（见 Peer.countedProtocol）：连接为单位，不是 hello 为单位。
-      countedProtocol: false,
       // 轮转序号取模分配：**均匀是刻意的**。哪怕重启风暴里 10k 条连接在几十秒内
       // 全建起来，它们也会摊到所有桶上；若改成"分给下一个将要轮到的桶"，
       // 风暴会把它们全塞进同一两个桶，等于把刚拆掉的突发又造回来（C7 的场景）。
@@ -25661,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)) {
@@ -25760,18 +25844,98 @@ 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 = [];
+      let size = 0;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > limit) {
+          req.pause();
+          reject(Object.assign(new Error(BODY_TOO_LARGE), { code: BODY_TOO_LARGE }));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+      req.on("error", reject);
+    });
+  }
+  const CLAIM_BODY_MAX_BYTES = 1024;
+  async function handleClaimToken(req, res) {
+    if (req.method !== "POST") {
+      res.statusCode = 405;
+      res.end(JSON.stringify({ error: "use POST" }));
+      return;
+    }
+    if (shuttingDown) {
+      res.statusCode = 503;
+      res.end(JSON.stringify({ error: "shutting_down" }));
+      return;
+    }
+    const now = Date.now();
+    const ip = req.socket.remoteAddress ?? "unknown";
+    const last = lastClaimAt.get(ip) ?? 0;
+    if (now - last < config2.claimMinIntervalMs) {
+      res.statusCode = 429;
+      res.end(JSON.stringify({ error: "too_soon", retryAfterMs: config2.claimMinIntervalMs - (now - last) }));
+      return;
+    }
+    rememberClaim(ip, now);
+    let body = {};
+    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);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          body = parsed;
+        }
+      } catch {
+      }
+    }
+    const rawHostId = typeof body.hostId === "string" ? body.hostId.trim() : "";
+    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 token = newHostToken();
+    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("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) {
     try {
       const url2 = new URL(req.url ?? "/", "http://relay.invalid");
@@ -25782,28 +25946,13 @@ function createRelay(config2) {
         return;
       }
       if (url2.pathname === "/api/claim-token") {
-        if (req.method !== "POST") {
-          res.statusCode = 405;
-          res.end(JSON.stringify({ error: "use POST" }));
-          return;
-        }
-        if (shuttingDown) {
-          res.statusCode = 503;
-          res.end(JSON.stringify({ error: "shutting_down" }));
-          return;
-        }
-        const now = Date.now();
-        const ip = req.socket.remoteAddress ?? "unknown";
-        const last = lastClaimAt.get(ip) ?? 0;
-        if (now - last < CLAIM_MIN_INTERVAL_MS) {
-          res.statusCode = 429;
-          res.end(JSON.stringify({ error: "too_soon", retryAfterMs: CLAIM_MIN_INTERVAL_MS - (now - last) }));
-          return;
-        }
-        lastClaimAt.set(ip, now);
-        const token = rotateHostToken();
-        log.info("host token claimed", { ip });
-        res.end(JSON.stringify({ token, rotatedAt: new Date(now).toISOString() }));
+        void handleClaimToken(req, res).catch((e) => {
+          log.warn("claim handler failed", { error: String(e) });
+          if (!res.headersSent) {
+            res.statusCode = 500;
+            res.end(JSON.stringify({ error: "internal" }));
+          }
+        });
         return;
       }
       if (url2.pathname === "/api/info") {
@@ -25992,7 +26141,7 @@ function registerSignalHandlers(shutdown) {
 
 // src/main.ts
 function readVersion() {
-  if ("3.1.2") return "3.1.2";
+  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.2",
+  "version": "3.1.4",
   "description": "DSH Remote Control 的零知识 WebSocket 中继：只做路由，不碰载荷明文。可自托管的单文件产物。",
   "type": "module",
   "license": "MIT",