@mrrisega/dsh-remote 0.7.9 → 0.7.10-beta.10

package/clients/dsh-remote/decision-poller.mjs

@@ -0,0 +1,235 @@
+/**
+ * decision-poller — 把"用户在手机上点的允许/拒绝"从 SaaS 拉回来，落到电脑端。
+ *
+ * 链路（配合服务端 `/api/notify/pending`）：
+ *   手机点按钮 → POST /api/notify/decision（服务端存）
+ *     → 本模块每 3s GET /api/notify/pending?device_id=…
+ *     → 对每条决策调用注入的 `apply(item)`（bridge 里 = dsh-events 的 answerApproval）
+ *     → POST /api/notify/ack 确认，服务端不再返回
+ *
+ * 设计边界（每一条都重要）
+ * ---------------------------------------------------------------
+ * 1. **默认不启动**：只有「事件上报已在跑」时才起（没有上报就没有通知，也就不可能有回执）。
+ * 2. **绝不阻塞主链路**：所有异常吞掉只记日志；一个 tick 失败不影响下一个 tick。
+ * 3. **幂等**：apply 成功才 ack；apply 失败（例如会话已结束）也 ack —— 否则会每 3s 重放同一条
+ *    并把用户"一直点不掉"的旧决策反复怼给 DSH。失败会记 warn，不影响其它决策。
+ * 4. **有界**：单次最多处理 20 条（服务端也限 20），串行 apply，避免并发打爆 dsh。
+ * 5. **过期不应用**：服务端已过滤；这里再按 expires_at 兜一次（时钟漂移时宁可丢也不误放行）。
+ *
+ * 安全语义：`allow` 只能映射成 **allowed-once**（"允许一次"），绝不映射成"永久放行"；
+ * `deny` 映射成 `rejected`。任何未知值 → 当 deny 处理（fail-closed）。
+ */
+
+export const DEFAULT_POLL_INTERVAL_MS = 3_000;
+export const MAX_ITEMS_PER_TICK = 20;
+export const REQUEST_TIMEOUT_MS = 8_000;
+
+/** 手机端的 decision → dsh-events 的 outcome（未知一律 deny，fail-closed）。 */
+export function toDshOutcome(decision) {
+  return String(decision) === "allow" ? "allowed-once" : "rejected";
+}
+
+/**
+ * @param {{
+ *   apiBase: string,
+ *   deviceId: string,
+ *   tokenProvider: () => (string|Promise<string>),
+ *   apply: (item: {event_id:string, request_id:string, decision:"allow"|"deny", id:string}) => Promise<any>,
+ *   fetchImpl?: typeof fetch,
+ *   now?: () => number,
+ *   intervalMs?: number,
+ *   log?: (level:string, message:string, meta?:object) => void,
+ * }} options
+ */
+export function createDecisionPoller(options = {}) {
+  const apiBase = String(options.apiBase || "").replace(/\/+$/, "");
+  const deviceId = String(options.deviceId || "");
+  const tokenProvider = typeof options.tokenProvider === "function" ? options.tokenProvider : () => "";
+  const apply = typeof options.apply === "function" ? options.apply : null;
+  const fetchImpl = typeof options.fetchImpl === "function" ? options.fetchImpl : globalThis.fetch;
+  const now = typeof options.now === "function" ? options.now : () => Date.now();
+  const intervalMs = Number.isFinite(options.intervalMs) ? options.intervalMs : DEFAULT_POLL_INTERVAL_MS;
+  const log = typeof options.log === "function" ? options.log : () => {};
+
+  const stats = { started: false, polls: 0, applied: 0, skipped: 0, failed: 0, acked: 0, lastError: "" };
+  /**
+   * 已应用过的决策 id（有界 LRU）。
+   *
+   * 为什么需要：服务端是"至少一次"语义 —— 我们 ack 丢了或超时未 ack，同一条回执会被重投。
+   * 若每次都重新 `apply()`，会把同一条审批反复回执给 DSH（服务端虽是幂等的 already_decided，
+   * 但会刷日志、也会让"允许一次"看起来像被允许多次）。所以按 id 去重：见过的只 ack 不再应用。
+   */
+  const appliedIds = new Map();
+  let timer = null;
+  let stopped = false;
+  let ticking = false;
+
+  function schedule(delayMs) {
+    if (stopped) return;
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void tick();
+    }, Math.max(0, delayMs));
+    if (timer && typeof timer.unref === "function") timer.unref();
+  }
+
+  async function tick() {
+    if (stopped || ticking) return;
+    ticking = true;
+    try {
+      stats.polls += 1;
+      const token = await Promise.resolve(tokenProvider()).catch(() => "");
+      if (!token) {
+        stats.lastError = "no_token";
+        return;
+      }
+      const url = `${apiBase}/api/notify/pending?device_id=${encodeURIComponent(deviceId)}`;
+      const res = await fetchWithTimeout(url, {
+        method: "GET",
+        headers: { authorization: `Bearer ${token}` }
+      }, fetchImpl, REQUEST_TIMEOUT_MS);
+      if (!res) { stats.lastError = "no_response"; return; }
+      if (res.status === 401) {
+        // token 过期：等下一次 device-login 刷新，继续轮询没有意义但也不该停（刷新后要能恢复）
+        stats.lastError = "auth_failed";
+        log("warn", "[decision] 设备 token 失效，跳过本轮（等下次登录刷新）");
+        return;
+      }
+      if (res.status === 403) {
+        // device_mismatch：这台机器的 device_id 已登记在别的账号下 —— 重试永远不会成功，停下。
+        stats.lastError = "device_mismatch";
+        log("warn", "[decision] 本机设备不属于当前账号（device_mismatch），已停止决策轮询");
+        stopped = true;
+        return;
+      }
+      if (res.status === 400) {
+        // invalid_device_id（缺/超长）：配置问题，重试无意义
+        stats.lastError = "invalid_device_id";
+        log("warn", "[decision] device_id 非法，已停止决策轮询");
+        stopped = true;
+        return;
+      }
+      if (res.status !== 200) { stats.lastError = `http_${res.status}`; return; }
+      const body = await safeJson(res);
+      const items = Array.isArray(body && body.items) ? body.items.slice(0, MAX_ITEMS_PER_TICK) : [];
+      if (items.length === 0) { stats.lastError = ""; return; }
+
+      const ackIds = [];
+      for (const item of items) {
+        const id = String(item && item.id ? item.id : "");
+        const eventId = String(item && item.event_id ? item.event_id : "");
+        const requestId = String(item && item.request_id ? item.request_id : "");
+        const decision = String(item && item.decision ? item.decision : "");
+        const expiresAt = Number(item && item.expires_at ? item.expires_at : 0);
+        // 服务端"至少一次"语义：redeliver_count>0 表示这条之前可能已经投递过（我们回过 ack 但响应丢了）。
+        // 不改行为（仍照常应用并 ack），只在日志留痕，便于排查"为什么同一条审批被应用两次"。
+        const redeliverCount = Number(item && item.redeliver_count ? item.redeliver_count : 0);
+        if (redeliverCount > 0) {
+          log("warn", `[decision] 收到重投回执（第 ${redeliverCount} 次） request_id=${requestId || "-"}`);
+        }
+        if (expiresAt > 0 && expiresAt < now()) {
+          // 服务端已过期却仍返回（时钟漂移）：不应用，但 ack 掉避免反复拉
+          stats.failed += 1;
+          if (id) ackIds.push(id);
+          continue;
+        }
+        if (id && appliedIds.has(id)) {
+          // 重投的同一条：之前已应用过 → 只 ack，不再 apply（幂等）
+          stats.skipped += 1;
+          ackIds.push(id);
+          continue;
+        }
+        if (!apply || !requestId) {
+          stats.failed += 1;
+          if (id) ackIds.push(id);
+          continue;
+        }
+        try {
+          await apply({
+            id,
+            event_id: eventId,
+            request_id: requestId,
+            decision: decision === "allow" ? "allow" : "deny",
+            outcome: toDshOutcome(decision)
+          });
+          stats.applied += 1;
+          if (id) {
+            appliedIds.set(id, now());
+            if (appliedIds.size > 500) {
+              const first = appliedIds.keys().next();
+              if (!first.done) appliedIds.delete(first.value);
+            }
+          }
+        } catch (e) {
+          // 应用失败（会话已结束/事件已作废）也必须 ack，否则每 3s 重放同一条
+          stats.failed += 1;
+          stats.lastError = String(e && e.message ? e.message : e);
+          log("warn", `[decision] 应用失败（已跳过并确认）: ${stats.lastError}`);
+        }
+        if (id) ackIds.push(id);
+      }
+      if (ackIds.length > 0) await ack(token, ackIds, apiBase, fetchImpl, stats, log);
+    } catch (e) {
+      stats.lastError = String(e && e.message ? e.message : e);
+      log("warn", `[decision] 轮询异常（已忽略）：${stats.lastError}`);
+    } finally {
+      ticking = false;
+      if (!stopped) schedule(intervalMs);
+    }
+  }
+
+  return {
+    start() {
+      if (stats.started || stopped) return stats;
+      if (!apiBase || !deviceId || !apply) {
+        stats.lastError = !apiBase ? "no_api_base" : !deviceId ? "no_device" : "no_apply";
+        return stats;
+      }
+      stats.started = true;
+      schedule(intervalMs);
+      return stats;
+    },
+    stop() {
+      stopped = true;
+      if (timer) { clearTimeout(timer); timer = null; }
+      stats.started = false;
+    },
+    status() { return { ...stats }; },
+    /** 仅供单测：跑一次 tick（不排下一轮）。 */
+    _tick: tick
+  };
+}
+
+async function ack(token, ids, apiBase, fetchImpl, stats, log) {
+  try {
+    const res = await fetchWithTimeout(`${apiBase}/api/notify/ack`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({ ids: ids.slice(0, 50) })
+    }, fetchImpl, REQUEST_TIMEOUT_MS);
+    if (res && res.status === 200) {
+      stats.acked += ids.length;
+      return;
+    }
+    log("warn", `[decision] ack 失败（HTTP ${res ? res.status : "无响应"}），下轮会重复拉取（幂等，无副作用）`);
+  } catch (e) {
+    log("warn", `[decision] ack 异常（已忽略）：${e && e.message ? e.message : e}`);
+  }
+}
+
+async function fetchWithTimeout(url, init, fetchImpl, timeoutMs) {
+  if (typeof fetchImpl !== "function") return null;
+  const ctl = typeof AbortController === "function" ? new AbortController() : null;
+  const timer = ctl ? setTimeout(() => { try { ctl.abort(); } catch { /* 忽略 */ } }, timeoutMs) : null;
+  if (timer && typeof timer.unref === "function") timer.unref();
+  try {
+    return await fetchImpl(url, ctl ? { ...init, signal: ctl.signal } : init);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+async function safeJson(r) {
+  try { return await r.json(); } catch { return null; }
+}

package/clients/dsh-remote/dsh-bridge.mjs

@@ -114,6 +114,10 @@ import {
 // ⚠️ 微信流量只走「腾讯 ilink ↔ 本机」,**不经我们的 relay**;DSH 事件走本机回环。
 // 总开关 DSH_WECHAT=0(默认开启);未绑定时只起控制面,不起长轮询。
 import { createWeChatRuntime } from "./wechat-runtime.mjs";
+import { createPushReporter } from "./push-reporter.mjs";
+import { createDecisionPoller } from "./decision-poller.mjs";
+import { createApprovalCoordinator } from "./approval-coordinator.mjs";
+import { createAgentRuntime } from "./agent/index.mjs";
 
 // ---------- 强制直连:清除代理环境变量 ----------
 // 家庭网络常配 Clash 等代理(127.0.0.1:7890),node 的 ws/fetch 会继承
@@ -288,7 +292,44 @@ function stampBridgeHeartbeat() {
   const now = Date.now();
   if (now - lastStateHeartbeatAt < STATE_HEARTBEAT_MIN_MS) return;
   lastStateHeartbeatAt = now;
-  persistBridgeState({ pid: process.pid, heartbeat_at: now });
+  persistBridgeState({
+    pid: process.pid,
+    heartbeat_at: now,
+    // 【0.7.10 / W1-T3】E2EE 死会话拒绝计数（见 noteE2eeWsReject 的说明）。
+    // 跟着心跳一起落盘：不额外写盘、不加定时器；旧面板/旧插件读到多余字段一律忽略。
+    e2ee_ws_reject_locked: e2eeWsRejectStats.locked,
+    e2ee_ws_reject_disabled: e2eeWsRejectStats.disabled,
+    e2ee_ws_reject_at: e2eeWsRejectStats.lastAt
+  });
+}
+
+/**
+ * 【0.7.10 / W1-T3】E2EE 会话拒绝计数 —— **只做可观测，不改任何协议行为**。
+ *
+ * 生产复盘（2026-10）：WS 升级被拒里 71.8% 是 `e2ee_session_locked`（死会话），涉 163 用户；
+ * 0.7.3+ 已闭环（手机侧清内存会话 + 连续 3 次失败作废交接单 + 每页一次受控 reload；
+ * bridge 侧回 `retryable:true, action:"rehandshake"` 让手机自动重握手）。但「死会话占比
+ * 降到多少」此前只在 nginx/router 侧可见，客户端自己答不出来。
+ *
+ * 这里把本进程的拒绝次数记下来、随心跳写进状态文件（面板「复制诊断信息」会带上一行），
+ * 于是支持包/诊断信息本身就能回答「这台机器还在被死会话打吗」。
+ * 落盘节流 ≥10s：死循环期一台设备一天能拒近万次，绝不能每拒一次就写盘。
+ */
+const e2eeWsRejectStats = { locked: 0, disabled: 0, lastAt: 0 };
+const E2EE_REJECT_FLUSH_MIN_MS = 10_000;
+let lastE2eeRejectFlushAt = 0;
+function noteE2eeWsReject(kind) {
+  if (kind === "disabled") e2eeWsRejectStats.disabled += 1;
+  else e2eeWsRejectStats.locked += 1;
+  const now = Date.now();
+  e2eeWsRejectStats.lastAt = now;
+  if (now - lastE2eeRejectFlushAt < E2EE_REJECT_FLUSH_MIN_MS) return;
+  lastE2eeRejectFlushAt = now;
+  persistBridgeState({
+    e2ee_ws_reject_locked: e2eeWsRejectStats.locked,
+    e2ee_ws_reject_disabled: e2eeWsRejectStats.disabled,
+    e2ee_ws_reject_at: e2eeWsRejectStats.lastAt
+  });
 }
 
 // ---------- 安装来源 / 版本(服务端设备行统计约定) ----------
@@ -1714,6 +1755,7 @@ export async function handleWsOpen(dchOrSend, frame) {
   const tagged = parseWsE2eeParams(path);
   if (tagged) {
     if (!e2ee.enabled) {
+      noteE2eeWsReject("disabled"); // 可观测计数（见 noteE2eeWsReject；不改行为）
       sendWsOpenReject(send, id, 1008, "e2ee_disabled:bridge 未启用端到端加密(请用明文连接)");
       return;
     }
@@ -1721,6 +1763,7 @@ export async function handleWsOpen(dchOrSend, frame) {
     if (!esess || !esess.verified) {
       // 会话可能刚被重启/被 LRU 挤掉：把「可自动重握手」写成机器可读信号，
       // 手机侧据此自动重建会话，而不是弹「请重新解锁」让用户输密码（生产 3964 次/设备）。
+      noteE2eeWsReject("locked");
       console.error(`[bridge] e2ee ws 拒绝(会话未解锁/未验证): ${path}`);
       sendWsOpenReject(send, id, 1008, "e2ee_session_locked:加密会话已失效，需要重新握手", {
         retryable: true,
@@ -2801,6 +2844,155 @@ function currentUpstreamForChannel() {
   return UPSTREAM;
 }
 
+/**
+ * 推送上报（2026-11-05）：把"任务完成/需要拍板/出错"上报给 SaaS，由服务端规则引擎决定是否推送。
+ *
+ * 为什么放在这里有独立开关：它是**可选增强**，任何失败都不得影响远程访问主链路。
+ * 真正的启动条件由 push-reporter 自己问服务端（`/api/push/public-key` 的 enabled+subscribed），
+ * 本地只有 `DSH_PUSH_REPORT=0` 能强制关闭。
+ */
+let pushReporter = null;
+let PUSH_TOKEN = "";
+
+function startPushReporter() {
+  if (String(process.env.DSH_PUSH_REPORT || "") === "0") {
+    console.log("[push] 上报已禁用(DSH_PUSH_REPORT=0)");
+    return;
+  }
+  try {
+    if (pushReporter) return;
+    pushReporter = createPushReporter({
+      apiBase: API_BASE,
+      deviceId: DEVICE_ID,
+      tokenProvider: () => PUSH_TOKEN,
+      upstream: () => currentUpstreamForChannel(),
+      cookie: harnessCookieOf,
+      detail: String(process.env.DSH_PUSH_DETAIL || "") === "1",
+      log: (level, message) => {
+        try {
+          if (level === "warn") console.warn(message);
+          else console.log(message);
+        } catch { /* 忽略 */ }
+      }
+    });
+    // 不 await：启动探测失败绝不影响隧道
+    void pushReporter.start().then((st) => {
+      try {
+        if (st && st.started) {
+          ensureApprovalCoordinator();
+          startDecisionPoller();
+          startAgentRuntime();
+        }
+      } catch { /* 忽略 */ }
+    }).catch(() => {});
+  } catch (e) {
+    // 可选增强失败不得冒泡
+    console.warn(`[push] 上报器初始化失败（已忽略）：${e && e.message ? e.message : e}`);
+  }
+}
+
+/**
+ * 多 Agent 接入（2026-11-06）：默认**关闭**，只有 `DSH_AGENT_ENABLED=1` 才起。
+ *
+ * 为什么默认关：这条链路要 spawn 用户的 Claude Code、开本机回环端口、写临时 settings，
+ * 且手机端审批还没接通 —— 没有消费方时开机就跑它，是在用户机器上白花钱、白担风险。
+ * 启用后若任何一步不满足（没装 CLI / 版本太低 / 已有审批钩子），runtime 会返回明确状态
+ * （disabled / cli-missing / version-unsupported / existing-hooks / bridge-error），
+ * **绝不静默降级**，也绝不抛错影响远程访问主链路。
+ */
+let agentRuntime = null;
+
+function startAgentRuntime() {
+  if (String(process.env.DSH_AGENT_ENABLED || "") !== "1") return;
+  try {
+    if (agentRuntime) return;
+    const coordinator = ensureApprovalCoordinator();
+    agentRuntime = createAgentRuntime({
+      // 手机审批：钩子 → 协调器（等手机回执）→ allow/deny；没有协调器时 runtime 内部 fail-closed
+      decide: coordinator ? (req) => coordinator.ask(req) : undefined,
+      log: (e) => {
+        try {
+          const level = e && e.level === "error" ? "error" : e && e.level === "warn" ? "warn" : "info";
+          console[level]("[agent] " + JSON.stringify(e));
+        } catch { /* 忽略 */ }
+      }
+    });
+    // 不 await：失败也只在日志里体现，主链路照常
+    void agentRuntime.start().then((r) => {
+      try {
+        const st = r && r.status ? r.status : "unknown";
+        console.log(`[agent] 运行时状态=${st} mode=${(r && r.mode) || "-"}${r && r.reason ? " reason=" + r.reason : ""}`);
+        persistBridgeState({ agent: { status: st, mode: (r && r.mode) || null, enabled: true, at: Date.now() } });
+      } catch { /* 忽略 */ }
+    }).catch((e) => {
+      console.warn(`[agent] 启动异常（已忽略）：${e && e.message ? e.message : e}`);
+    });
+  } catch (e) {
+    console.warn(`[agent] 初始化失败（已忽略）：${e && e.message ? e.message : e}`);
+  }
+}
+
+/**
+ * 决策轮询（2026-11-06）：把"手机上点的允许/拒绝"拉回电脑端并写回 DSH。
+ *
+ * 只有"事件上报已在跑"时才起 —— 没有上报就没有通知，也就不可能有回执；
+ * 所有异常吞掉只记日志，绝不阻塞隧道。
+ */
+/**
+ * 审批协调器（2026-11-06）：把 Claude Code 的审批请求接到手机回执上。
+ * 只有"推送上报已在跑"时才创建 —— 没有手机通道，等 90 秒再拒绝毫无意义。
+ */
+let approvalCoordinator = null;
+
+function ensureApprovalCoordinator() {
+  if (approvalCoordinator) return approvalCoordinator;
+  try {
+    approvalCoordinator = createApprovalCoordinator({
+      report: (info) => pushReporter && pushReporter.reportApproval ? pushReporter.reportApproval(info) : false,
+      log: (level, message) => {
+        try {
+          if (level === "warn") console.warn(message);
+          else console.log(message);
+        } catch { /* 忽略 */ }
+      }
+    });
+  } catch (e) {
+    console.warn(`[approval] 协调器初始化失败（已忽略）：${e && e.message ? e.message : e}`);
+    approvalCoordinator = null;
+  }
+  return approvalCoordinator;
+}
+
+let decisionPoller = null;
+
+function startDecisionPoller() {
+  try {
+    if (decisionPoller) return;
+    decisionPoller = createDecisionPoller({
+      apiBase: API_BASE,
+      deviceId: DEVICE_ID,
+      tokenProvider: () => PUSH_TOKEN,
+      apply: async (item) => {
+        // ① 先看是不是"本地 Agent（Claude Code）"的审批 —— 协调器认得就消费掉
+        try {
+          if (approvalCoordinator && approvalCoordinator.resolve(item.request_id, item.decision)) return;
+        } catch { /* 继续走 DSH 那条路 */ }
+        // ② 否则按 DSH 审批回执处理：手机上的"允许"只能映射成 allowed-once，绝不升级成永久放行
+        return pushReporter.answerApproval(item.request_id, item.outcome);
+      },
+      log: (level, message) => {
+        try {
+          if (level === "warn") console.warn(message);
+          else console.log(message);
+        } catch { /* 忽略 */ }
+      }
+    });
+    decisionPoller.start();
+  } catch (e) {
+    console.warn(`[decision] 轮询器初始化失败（已忽略）：${e && e.message ? e.message : e}`);
+  }
+}
+
 function startWeChat() {
   if (WECHAT_DISABLED) {
     console.log("[bridge] 微信通道已禁用(DSH_WECHAT=0)");
@@ -2983,6 +3175,7 @@ async function runTunnel() {
   // (真机日志实测:同一个桥接启动里出现两条并发的 device-login)。
   // 而 /api/device-login 是按出口 IP 限流的 —— 每次启动都多花一份登录额度没有道理。
   WECHAT_TIER_TOKEN = { value: token, at: Date.now() };
+  PUSH_TOKEN = token;
   // 新进程开始:重置状态文件(上一轮的成功记录不能代表这一轮,面板据此判定 online)。
   // `pid` 一并写入 = **bridge 自证身份**:插件可以用「state.pid 活着 + heartbeat_at 新鲜」
   // 判断桥是否真的在跑,不必依赖按镜像名(node.exe)扫描 —— 桌面端宿主拉起的进程名不是 node.exe。
@@ -2998,6 +3191,10 @@ async function runTunnel() {
   }
   // 隧道已发起（或已进入锁定等待）后再起微信:主链路优先,微信永不阻塞远程访问
   startWeChat();
+  // 同理：推送上报也是可选增强，最后起、失败静默
+  startPushReporter();
+  // 多 Agent 运行时：默认关，只有 DSH_AGENT_ENABLED=1 **且** 推送通道已就绪时才起
+  //（没有手机通道 = 审批无处可问，起了只会卡住用户）
   setTimeout(() => {
     console.log(`[bridge] 隧道模式运行中(上游 ${UPSTREAM},Ctrl-C 退出)`);
   }, 1000);
@@ -3043,6 +3240,13 @@ async function main() {
     console.log(`[bridge] 收到 ${sig},正在优雅退出...`);
     // 退出前把 E2EE 会话库刷一次（滑动 TTL 的 usedAt 要落盘；崩溃也能恢复到最多 60s 前）
     try { e2ee.flushStore(); } catch { /* 已内部兜底 */ }
+    // 退出前尽力把待上报的事件发出去（最多等 1s，绝不阻塞退出）
+    try { if (decisionPoller) decisionPoller.stop(); } catch { /* 已内部兜底 */ }
+    // 未决审批一律拒绝（绝不留悬挂的 Promise）
+    try { if (approvalCoordinator) approvalCoordinator.stop(); } catch { /* 已内部兜底 */ }
+    try { if (pushReporter) await pushReporter.stop(); } catch { /* 已内部兜底 */ }
+    // 多 Agent 运行时：关端口、删临时 settings、未决审批一律 deny（runtime 内部保证幂等）
+    try { if (agentRuntime) await agentRuntime.stop(); } catch { /* 已内部兜底 */ }
     await stopWeChat();
     process.exit(0);
   };
@@ -3188,6 +3392,9 @@ export function __wsSessionState(id) {
   return { opened: s.opened === true, pending: s.pending ? s.pending.length : 0, cancelled: s.cancelled === true, failed: s.failed === true };
 }
 
+// test hook：E2EE 拒绝计数快照（W1-T3 可观测字段；状态文件里同名 e2ee_ws_reject_* 字段的来源）
+export function __e2eeRejectStatsForTest() { return { ...e2eeWsRejectStats }; }
+
 // 直接运行(node dsh-bridge.mjs)时启动服务;被测试 import 时只导出协议函数。
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
 if (isMain) {