@mrrisega/dsh-remote 0.7.11-beta.3 → 0.7.12-beta.2

package/clients/dsh-remote/test/upstream-discovery.test.mjs

@@ -17,13 +17,19 @@
  */
 import assert from "node:assert/strict";
 import http from "node:http";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import test from "node:test";
+import test, { beforeEach } from "node:test";
 
 import {
+  __resetUpstreamCachesForTest,
+  candidatePlan,
   candidatePorts,
+  discoverUpstreamFast,
+  discoverUpstreamFull,
+  isDshLikeProcessName,
+  isIgnoredListenProcess,
   discoverUpstream,
   listeningPortsOfPid,
   looksLikeDshWeb,
@@ -33,10 +39,16 @@ import {
   DESKTOP_DEFAULT_PORT,
   DESKTOP_PORT_SCAN,
   FALLBACK_UPSTREAM,
+  MAX_PROBE_CANDIDATES,
+  MAX_PROBE_CONCURRENCY,
+  PROBE_TIMEOUT_MS,
   UPSTREAM_FILE
 } from "../upstream-discovery.mjs";
 
 const DIR = mkdtempSync(path.join(os.tmpdir(), "dsh-upstream-"));
+// 发现模块有进程内缓存（负缓存/已验证/监听表）：用例之间必须清零，否则会互相污染
+// （真实验证：前一个用例缓存了已关闭的假 dsh 端口，后面的"回退 3080"用例读到了它）。
+beforeEach(() => { __resetUpstreamCachesForTest(); });
 process.on("exit", () => { try { rmSync(DIR, { recursive: true, force: true }); } catch { /* ignore */ } });
 
 /** 假的 dsh web：回一段带官方特征标记的 HTML（身份校验靠它）。 */
@@ -207,3 +219,192 @@ test("实测端口:能从本进程真实监听端口里读出来(macOS/Linux 用
     await close(srv);
   }
 });
+
+// ===========================================================================
+// 2026-11-07：不再乱敲本机所有端口（微信 CPU 高 + 登录慢）
+// ===========================================================================
+
+test("★ 进程名过滤:只保留像 dsh 宿主的端口,IM 客户端/无关进程全部跳过并计数", () => {
+  // 黑名单优先：名字里带 wechat 的即使像 node 也拒绝
+  assert.equal(isIgnoredListenProcess("WeChat"), true);
+  assert.equal(isIgnoredListenProcess("企业微信"), true);
+  assert.equal(isIgnoredListenProcess("wecom-node"), true);
+  assert.equal(isDshLikeProcessName("wechat-node"), false, "黑名单优先于白名单");
+  assert.equal(isDshLikeProcessName("QQ"), false);
+  assert.equal(isDshLikeProcessName("node"), true);
+  assert.equal(isDshLikeProcessName("nodejs"), true);
+  assert.equal(isDshLikeProcessName("dsh-web"), true);
+  assert.equal(isDshLikeProcessName("deepseek-harness"), true);
+  assert.equal(isDshLikeProcessName("Electron"), true);
+  assert.equal(isDshLikeProcessName("python3"), false);
+  assert.equal(isDshLikeProcessName(""), false);
+
+  const plan = candidatePlan({
+    relayDir: "", // 不读端口文件：本用例只关心进程名过滤
+    env: {},
+    platform: "win32",
+    includeStatic: false,
+    listeners: [
+      { port: 40001, name: "WeChat", pid: 1 },
+      { port: 40002, name: "企业微信", pid: 2 },
+      { port: 40003, name: "node", pid: 3 },
+      { port: 40004, name: "Electron", pid: 4 },
+      { port: 40005, name: "deepseek-harness", pid: 5 },
+      { port: 40006, name: "python3", pid: 6 },
+    ],
+  });
+  const ports = plan.entries.map((e) => e.port).sort((a, b) => a - b);
+  assert.deepEqual(ports, [40003, 40004, 40005], "★ 只保留 node/electron/deepseek 的端口；微信/企微/python 全部排除");
+  assert.equal(plan.skipped, 3, "★ skipped 必须统计被跳过的非 node 进程端口（微信、企微、python）");
+  assert.ok(plan.entries.every((e) => e.source === "listen"));
+});
+
+test("★ 拿不到进程名时**绝不退化成全量探测**（SKIP 整层，不瞎敲）", () => {
+  // listeners:false = 模拟 lsof/ss 不可用（如 NAS/精简系统）
+  const plan = candidatePlan({ relayDir: "", env: {}, platform: "win32", includeStatic: false, listeners: false });
+  assert.equal(plan.entries.length, 0, "拿不到进程名 → 本层一个候选都不收");
+  assert.equal(plan.skipped, 0, "这不是'跳过'，是'整层不可用'");
+  // 旧实现会把所有监听端口都收进来（listenPorts 注入路径保持兼容，供测试/特殊部署显式使用）
+  const injected = candidatePlan({ relayDir: "", env: {}, platform: "win32", includeStatic: false, listenPorts: [40003, 40004] });
+  assert.deepEqual(injected.entries.map((e) => e.port).sort(), [40003, 40004], "显式注入路径保持既有语义");
+});
+
+test("★ 负缓存:判定'不是 dsh'的端口 10 分钟内不再探测", async () => {
+  const stranger = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/plain" }); res.end(STRANGER); });
+  writeHint("not-a-url");
+  try {
+    const first = await discoverUpstreamFull({ relayDir: DIR, env: {}, extraPorts: [stranger.port], listeners: false, platform: "win32", fetchImpl: blockedFetch, timeoutMs: 300 });
+    assert.ok(first.probed.includes(stranger.port), "第一次必须探测该端口");
+    const second = await discoverUpstreamFull({ relayDir: DIR, env: {}, extraPorts: [stranger.port], listeners: false, platform: "win32", fetchImpl: blockedFetch, timeoutMs: 300 });
+    assert.ok(!second.probed.includes(stranger.port), "★ 负缓存内不得重复探测（微信 CPU 的根因之一就是反复敲）");
+  } finally {
+    await close(stranger);
+  }
+});
+
+test("★ fast 路径：没有 hint/缓存/进程端口时**一个请求都不发**（<50ms 语义）", async () => {
+  writeHint("not-a-url");
+  let calls = 0;
+  const fetchImpl = () => { calls += 1; return Promise.reject(new Error("fast 不该探测")); };
+  const t0 = Date.now();
+  const fast = await discoverUpstreamFast({
+    relayDir: DIR, env: {}, platform: "win32", listeners: false, fetchImpl
+  });
+  const cost = Date.now() - t0;
+  assert.equal(fast.url, "", "没有可用来源时返回空（由调用方决定回退）");
+  assert.equal(calls, 0, "★ fast 不得探测未知端口");
+  assert.ok(cost < 50, `fast 必须很快（实际 ${cost}ms）`);
+});
+
+test("★ 探测成本：超时 300ms；150ms 才回的 dsh 仍能命中，>300ms 的不再等", async () => {
+  assert.equal(PROBE_TIMEOUT_MS, 300, "默认探测超时必须是 300ms");
+  let pending = [];
+  const slowOk = await listen((_req, res) => {
+    pending.push(setTimeout(() => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); }, 150));
+  });
+  const tooSlow = await listen((_req, res) => {
+    pending.push(setTimeout(() => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); }, 450));
+  });
+  try {
+    assert.equal(await probeDshWeb(slowOk.url), true, "150ms 内响应 → 必须命中（缩短超时不能把慢机器误杀）");
+    assert.equal(await probeDshWeb(tooSlow.url), false, "超过 300ms 的静默端口不再等");
+  } finally {
+    for (const t of pending) clearTimeout(t);
+    pending = [];
+    await close(slowOk); await close(tooSlow);
+  }
+});
+
+test("★ 并发上限：候选再多也最多 16 个并发探测", async () => {
+  const servers = [];
+  try {
+    for (let i = 0; i < 20; i++) {
+      servers.push(await listen((_req, res) => {
+        setTimeout(() => { res.writeHead(200, { "content-type": "text/plain" }); res.end(STRANGER); }, 40);
+      }));
+    }
+    const inflight = { now: 0, max: 0 };
+    const countingFetch = (input, init) => {
+      inflight.now += 1;
+      inflight.max = Math.max(inflight.max, inflight.now);
+      return Promise.resolve(blockedFetch(input, init)).finally(() => { inflight.now -= 1; });
+    };
+    writeHint("not-a-url");
+    await discoverUpstreamFull({
+      relayDir: DIR, env: {}, platform: "win32", listeners: false,
+      extraPorts: servers.map((s) => s.port), fetchImpl: countingFetch, timeoutMs: 300
+    });
+    assert.ok(inflight.max <= MAX_PROBE_CONCURRENCY, `★ 并发不得超过 ${MAX_PROBE_CONCURRENCY}（实际 ${inflight.max}）`);
+    assert.ok(inflight.max >= 2, "应当确实并行（否则发现会串行变慢）");
+  } finally {
+    for (const s of servers) await close(s);
+  }
+});
+
+test("★ 行为不回归：过滤后仍能发现非默认端口上的 dsh web（能力保留）", async () => {
+  const dsh = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/html" }); res.end(DSH_HTML); });
+  writeHint("not-a-url");
+  try {
+    const found = await discoverUpstreamFull({
+      relayDir: DIR, env: {}, platform: "win32", listeners: false, fetchImpl: blockedFetch,
+      extraPorts: [dsh.port], timeoutMs: 300
+    });
+    assert.equal(found.url, dsh.url, "非默认端口仍必须能发现（过滤只排除非 dsh 进程，不排除位置）");
+    assert.equal(found.source, "extra");
+  } finally {
+    await close(dsh);
+  }
+});
+
+test("★ 每个候选最多 1 次请求：连 HTTP 都不通的端口不再打第二条探测", async () => {
+  // ① 死端口：旧实现 / + /dsh-remote/self = 2 个请求；现在 1 个
+  let calls = 0;
+  const deadFetch = () => { calls += 1; return Promise.reject(Object.assign(new Error("ECONNREFUSED"), { code: "ECONNREFUSED" })); };
+  assert.equal(await probeDshWeb("http://127.0.0.1:1", { fetchImpl: deadFetch }), false);
+  assert.equal(calls, 1, "★ 首探连 HTTP 响应都没拿到 → 不再打 /dsh-remote/self（省一半连接）");
+
+  // ② 正常 HTTP 的陌生服务：首页特征不中时仍要问一次 /dsh-remote/self（保持识别能力）
+  const stranger = await listen((_req, res) => { res.writeHead(200, { "content-type": "text/plain" }); res.end(STRANGER); });
+  let n = 0;
+  const real = (input, init) => { n += 1; return realFetch(input, init); };
+  try {
+    assert.equal(await probeDshWeb(stranger.url, { fetchImpl: real }), false);
+    assert.equal(n, 2, "拿到了 HTTP 响应（只是特征不中）→ 允许第二次探测 /dsh-remote/self");
+  } finally {
+    await close(stranger);
+  }
+});
+
+test("★ 候选上限：超过 20 个时整层放弃 listen 扫描（只探 hint/进程/静态）", async () => {
+  // 注入 24 个"像 node"的监听端口（超过 LISTEN_PROBE_LIMIT 与 MAX_PROBE_CANDIDATES）
+  const listeners = Array.from({ length: 24 }, (_, i) => ({ port: 45000 + i, name: "node", pid: 1000 + i }));
+  let calls = 0;
+  const fetchImpl = () => { calls += 1; return Promise.reject(new Error("blocked")); };
+  writeHint("not-a-url");
+  const found = await discoverUpstreamFull({
+    relayDir: DIR, env: {}, platform: "win32", listeners, fetchImpl, timeoutMs: 60
+  });
+  assert.ok(MAX_PROBE_CANDIDATES === 20);
+  assert.ok(!found.probed.some((p) => p >= 45000 && p < 45024), "★ 超限时不得探测 listen 层的端口");
+  // 静态候选仍会探（3080 + Desktop 区间），所以请求数应为 13 而不是 13+24
+  assert.ok(calls <= DESKTOP_PORT_SCAN + 1, `请求数应被压到静态候选量级（实际 ${calls}）`);
+});
+
+test("微信通道与上游发现互不相干：不枚举/不探测本机端口（源级断言，Lead 补充报告第 3 条）", () => {
+  for (const f of ["wechat-channel.mjs", "wechat-runtime.mjs"]) {
+    const src = readFileSync(new URL(`../${f}`, import.meta.url), "utf8");
+    assert.ok(!/upstream-discovery/.test(src), `${f} 不得 import 上游发现（微信通道只跟 ilinkai.weixin.qq.com 通信）`);
+    assert.ok(!/allLoopbackListeningPorts|candidatePorts|listeningPortsWithProcess/.test(src), `${f} 不得枚举本机监听端口`);
+    assert.ok(!/lsof|netstat/.test(src), `${f} 不得调用 lsof/netstat 扫本机端口`);
+  }
+});
+
+test("dsh-setup watcher：失败指数退避 + 端口文件事件驱动（源级契约）", () => {
+  const setup = readFileSync(new URL("../../../dsh-setup.mjs", import.meta.url), "utf8");
+  assert.match(setup, /UPSTREAM_DISCOVERY_BACKOFF_MS\s*=\s*\[15_000,\s*30_000,\s*60_000,\s*300_000\]/,
+    "连续失败退避必须是 15s→30s→60s→300s");
+  assert.match(setup, /if \(now < upstreamDiscoveryNextAt\) return upstreamUrl\(\);/, "退避检查必须在 force 分支之外（force 不得打穿退避）");
+  assert.match(setup, /watchUpstreamFile\(ensureBridge\)/, "watcher 必须监听 .dsh-upstream 的变化（事件驱动替代全量扫描）");
+  assert.match(setup, /fs\.watchFile\(file, \{ interval: 1000, persistent: false \}/, "监听用 1s stat（不扫端口）");
+  assert.ok(/upstreamDiscoveryFails = 0;\s*\n\s*upstreamDiscoveryNextAt = 0;/.test(setup), "端口文件变化时必须清零退避，立即采用新端口");
+});

package/clients/dsh-remote/test/wecom-bot.test.mjs

@@ -1165,7 +1165,8 @@ test("★ 会话绑定优先级：配置固定 → 最近活跃 → sessions[0]
     const server = await startFakeServer({ onFrame: (f, ws) => { autoAckAuth(f, ws); autoAckPing(f, ws); } });
     const bot = createWecomBot({
       botId: BOT_ID, secret: SECRET, url: server.url, relayDir: relayDir1, logger: () => {},
-      subscriber: sub, configuredSessionId: "s-fixed", configuredSessionTitle: "固定会话"
+      subscriber: sub, configuredSessionId: "s-fixed", configuredSessionTitle: "固定会话",
+      tier: "pro" // 固定会话是会员能力（sessions）；免费档会被忽略（另有用例覆盖）
     });
     try {
       bot.start();
@@ -1277,6 +1278,285 @@ test("控制器：只改 sessionId 也会重建 bot（配置热更新后转发
   }
 });
 
+// ─────────────────────── ⑩f IM 通道会员判定（2026-11-07）───────────────────────
+
+// 复用微信通道那套能力表（单一真相源）：免费 = 通知/审批/状态/急停 + assign.continue(20 条/月)
+const FREE_CAPS = ["notify", "approve", "status", "stop", "assign.continue"];
+const PAID_CAPS = ["notify", "approve", "status", "stop", "assign", "sessions", "summary", "steer", "attach", "multi"];
+const tierFreeObj = () => ({ plan: "free", caps: FREE_CAPS, limits: { messages_per_month: 20 }, rev: "rev-free" });
+const tierProObj = () => ({ plan: "pro", caps: PAID_CAPS, limits: { messages_per_month: 0 }, rev: "rev-pro" });
+
+/** 会员用例的 bot：接入一个可控 capsProvider，返回常用断言面。 */
+async function setupMemberBot(over = {}) {
+  const server = await startFakeServer({ onFrame: (f, ws) => { autoAckAuth(f, ws); autoAckPing(f, ws); autoAckSend(f, ws); } });
+  const sub = fakeSubscriber(over.sub || {
+    sessionIds: ["s-live", "s-other"],
+    sessions: [
+      { sessionId: "s-live", title: "活跃会话", running: true, updatedAt: 200 },
+      { sessionId: "s-other", title: "另一个", updatedAt: 100 }
+    ]
+  });
+  const lines = [];
+  const decisions = [];
+  const bot = createWecomBot({
+    botId: BOT_ID, secret: SECRET, url: server.url,
+    logger: (level, line) => lines.push(line),
+    subscriber: sub,
+    capsProvider: over.capsProvider,
+    appUrl: "https://app.test/",
+    onApprovalDecision: async (requestId, decision) => { decisions.push({ requestId, decision }); return { ok: true }; },
+    tierDenyThrottleMs: 0,
+    ...(over.bot || {})
+  });
+  const replies = () => server.state.frames.filter((f) => f.cmd === "aibot_respond_msg");
+  const markdowns = () => server.state.frames.filter((f) => f.cmd === "aibot_send_msg" && f.body && f.body.markdown);
+  const cards = () => server.state.frames.filter((f) => f.cmd === "aibot_send_msg" && f.body && f.body.msgtype === "template_card");
+  let seq = 0;
+  return {
+    server, sub, bot, lines, decisions, replies, markdowns, cards,
+    async start() { bot.start(); await waitFor(() => bot.status().authenticated, { label: "认证(member)" }); },
+    /** 发一条入站文本；返回是否真的被转发（promptSession）。 */
+    async inbound(text = "hi", userid = "user-a") {
+      seq += 1;
+      const beforeP = sub.promptCalls.length;
+      const beforeR = replies().length;
+      server.push({
+        cmd: "aibot_msg_callback", headers: { req_id: `min-${seq}` },
+        body: { msgid: `mm-${seq}`, msgtype: "text", text: { content: text }, from: { userid } }
+      });
+      await waitFor(() => sub.promptCalls.length > beforeP || replies().length > beforeR, { label: `入站 ${seq} 处理完` });
+      await sleep(10);
+      return sub.promptCalls.length > beforeP;
+    },
+    lastReplyText() {
+      const r = replies()[replies().length - 1];
+      return r && r.body && r.body.stream ? String(r.body.stream.content || "") : "";
+    },
+    async close() { await bot.stop(); await server.close(); }
+  };
+}
+
+test("★ 会员·免费档：通知照常、审批卡可点且**不计数**、额度不变", async () => {
+  const relayDir = tmpRelayDir();
+  const rt = await setupMemberBot({ capsProvider: async () => tierFreeObj(), bot: { relayDir } });
+  try {
+    await rt.start();
+    await waitFor(() => rt.bot.status().tier === "free", { label: "档位 free" });
+    // 入站绑定（同时消耗 1 条免费额度）
+    assert.equal(await rt.inbound("你好"), true);
+    await waitFor(() => rt.bot.status().usage.messages === 1, { label: "用量 1" });
+    // 通知照常（免费）
+    rt.sub.emit("event", { kind: NODE_KINDS.TURN_END, sessionId: "session-x", reason: "completed", turn: 1, seq: 1, at: Date.now() });
+    await waitFor(() => rt.markdowns().find((f) => /任务完成/.test(f.body.markdown.content)), { label: "免费通知" });
+    // 审批卡：可点、不计数
+    const card = rt.bot.sendApprovalCard("user-a", { requestId: "ev-free-1", toolName: "Bash" });
+    await waitFor(() => rt.cards().length === 1, { label: "免费审批卡" });
+    pushCardClick(rt.server, { reqId: "free-click-1", taskId: card.taskId, eventKey: "allow:ev-free-1" });
+    await waitFor(() => rt.decisions.length === 1, { label: "免费审批回执" });
+    assert.equal(rt.bot.status().usage.messages, 1, "★ 审批回执不得计数（安全阀优先）");
+    const st = readStatus(relayDir);
+    assert.deepEqual(st.wecom.usage, { month: st.wecom.usage.month, messages: 1 }, "状态文件 usage 只记 1（入站那条）");
+    assert.equal(st.wecom.tier, "free");
+    assert.ok(Array.isArray(st.wecom.caps) && st.wecom.caps.includes("assign.continue"));
+    assert.equal(st.wecom.messagesPerMonth, 20);
+    assert.equal(st.wecom.remainingMessages, 19);
+  } finally {
+    await rt.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 会员·免费档额度：前 20 条正常派活，第 21 条回「本月免费指令已用完」+ 升级链接且不调 promptSession", async () => {
+  const relayDir = tmpRelayDir();
+  const rt = await setupMemberBot({ capsProvider: async () => tierFreeObj(), bot: { relayDir } });
+  try {
+    await rt.start();
+    for (let i = 1; i <= 20; i++) {
+      assert.equal(await rt.inbound(`第 ${i} 条`), true, `第 ${i} 条应允许`);
+    }
+    await waitFor(() => rt.bot.status().usage.messages === 20, { label: "用满 20" });
+    const promptsBefore = rt.sub.promptCalls.length;
+    assert.equal(await rt.inbound("第 21 条"), false, "★ 第 21 条不得派活");
+    assert.equal(rt.sub.promptCalls.length, promptsBefore, "第 21 条不得调用 promptSession");
+    const reply = rt.lastReplyText();
+    assert.match(reply, /本月免费指令已用完/);
+    assert.match(reply, /20/);
+    assert.match(reply, /升级 Pro/);
+    assert.match(reply, /https:\/\/app\.test\/promo/, "要带升级链接 /app/promo");
+    assert.equal(rt.bot.status().usage.messages, 20, "被拦的消息不计数");
+    // 超额后通知仍然正常（不能把已有通道静默停掉）
+    rt.sub.emit("event", { kind: NODE_KINDS.TURN_END, sessionId: "session-x", reason: "completed", turn: 9, seq: 9, at: Date.now() });
+    await waitFor(() => rt.markdowns().find((f) => /任务完成/.test(f.body.markdown.content)), { label: "超额后通知仍在" });
+  } finally {
+    await rt.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 会员·跨月清零：上月用满 20 条 → 本月第一条仍可派活", async () => {
+  const relayDir = tmpRelayDir();
+  // 预置"上个月已经用满"的状态
+  fs.writeFileSync(path.join(relayDir, IM_BOT_STATUS_FILE), JSON.stringify({
+    version: 1, wecom: { usage: { month: "2000-01", messages: 25 } }
+  }), { mode: 0o600 });
+  const rt = await setupMemberBot({ capsProvider: async () => tierFreeObj(), bot: { relayDir } });
+  try {
+    await rt.start();
+    await waitFor(() => rt.bot.status().tier === "free", { label: "档位" });
+    assert.equal(await rt.inbound("新月份第一条"), true, "★ 跨月必须清零");
+    const st = readStatus(relayDir);
+    const d = new Date();
+    const month = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+    assert.equal(st.wecom.usage.month, month);
+    assert.equal(st.wecom.usage.messages, 1);
+  } finally {
+    await rt.close();
+    fs.rmSync(relayDir, { recursive: true, force: true });
+  }
+});
+
+test("★ 会员·fail-closed：没有 capsProvider 按 free 处理（额度用满即拦）；档位刷新后放行", async () => {
+  const relayDir = tmpRelayDir();
+  const d = new Date();
+  const month = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+  fs.writeFileSync(path.join(relayDir, IM_BOT_STATUS_FILE), JSON.stringify({
+    version: 1, wecom: { usage: { month, messages: 20 } }
+  }), { mode: 0o600 });
+  // ① 完全没有 provider
+  {
+    const rt = await setupMemberBot({ bot: { relayDir } });
+    try {
+      await rt.start();
+      await sleep(30);
+      assert.equal(rt.bot.status().tier, "free", "★ 没有 capsProvider → free（fail-closed）");
+      assert.equal(await rt.inbound("没有 provider"), false);
+      assert.match(rt.lastReplyText(), /本月免费指令已用完/);
+    } finally {
+      await rt.close();
+    }
+  }
+  // ② provider 先取不到（空），随后返回 pro → 下一次放行
+  {
+    let plan = "";
+    const rt = await setupMemberBot({ capsProvider: async () => (plan ? tierProObj() : ""), bot: { relayDir } });
+    try {
+      await rt.start();
+      await sleep(30);
+      assert.equal(await rt.inbound("空档位时"), false, "取不到档位 → 按 free 拦");
+      plan = "pro";
+      assert.equal(await rt.inbound("刚升级后"), true, "★ 档位刷新后必须放行（不用重启）");
+      assert.equal(rt.bot.status().tier, "pro");
+    } finally {
+      await rt.close();
+    }
+  }
+  fs.rmSync(relayDir, { recursive: true, force: true });
+});
+
+test("★ 会员·免费档忽略配置固定会话（bindingGated）；paid 档全放开（不限量/固定会话生效）", async () => {
+  // ① 免费：配置了 sessionId 也不生效，回退活跃会话；状态标注 bindingGated
+  {
+    const relayDir = tmpRelayDir();
+    const rt = await setupMemberBot({
+      capsProvider: async () => tierFreeObj(),
+      bot: { relayDir, configuredSessionId: "s-fixed", configuredSessionTitle: "固定会话" }
+    });
+    try {
+      await rt.start();
+      await waitFor(() => rt.bot.status().tier === "free", { label: "free" });
+      const st0 = rt.bot.status();
+      assert.equal(st0.bindingGated, true, "★ 免费档固定会话被门槛忽略");
+      assert.equal(await rt.inbound("免费档"), true);
+      assert.equal(rt.sub.promptCalls[0].sessionId, "s-live", "免费档回退到活跃会话，而不是 s-fixed");
+      await waitFor(() => { const st = readStatus(relayDir); return st && st.wecom && st.wecom.bindingGated === true; }, { label: "状态文件 bindingGated" });
+      const st = readStatus(relayDir);
+      assert.equal(st.wecom.boundSessionId, "s-live");
+      assert.equal(st.wecom.bindingGated, true);
+    } finally {
+      await rt.close();
+      fs.rmSync(relayDir, { recursive: true, force: true });
+    }
+  }
+  // ② paid：不限量 + 固定会话生效 + bindingGated=false
+  {
+    const relayDir = tmpRelayDir();
+    const rt = await setupMemberBot({
+      capsProvider: async () => tierProObj(),
+      bot: { relayDir, configuredSessionId: "s-fixed", configuredSessionTitle: "固定会话" }
+    });
+    try {
+      await rt.start();
+      await waitFor(() => rt.bot.status().tier === "pro", { label: "pro" });
+      assert.equal(rt.bot.status().bindingGated, false);
+      for (let i = 1; i <= 25; i++) assert.equal(await rt.inbound(`付费 ${i}`), true, `付费第 ${i} 条`);
+      assert.equal(rt.bot.status().usage.messages, 25, "付费也统计用量（但不限量）");
+      assert.equal(rt.bot.status().messagesPerMonth, 0, "0 = 不限");
+      assert.equal(rt.sub.promptCalls.every((c) => c.sessionId === "s-fixed"), true, "★ 付费档固定会话生效");
+      const st = readStatus(relayDir);
+      assert.equal(st.wecom.tier, "pro");
+      assert.equal(st.wecom.remainingMessages, null, "不限量时 remaining=null");
+    } finally {
+      await rt.close();
+      fs.rmSync(relayDir, { recursive: true, force: true });
+    }
+  }
+});
+
+test("★ 会员·服务端 caps 清空（空数组=权威）→ 互动全关但通知照常；审批卡仍可点", async () => {
+  const rt = await setupMemberBot({
+    capsProvider: async () => ({ plan: "free", caps: [], limits: { messages_per_month: 20 }, rev: "rev-empty" })
+  });
+  try {
+    await rt.start();
+    await waitFor(() => rt.bot.status().caps.length === 0, { label: "caps 清空" });
+    assert.equal(rt.bot.status().caps.length, 0, "空数组 = 服务端明确清空，不得回退内置表");
+    assert.equal(await rt.inbound("被清空的档位"), false, "没有 assign.continue → 不得派活");
+    assert.match(rt.lastReplyText(), /会员功能|升级 Pro/);
+    // 通知不受能力表影响（通知是免费能力，不能静默停掉）
+    rt.sub.emit("event", { kind: NODE_KINDS.TURN_END, sessionId: "session-x", reason: "completed", turn: 3, seq: 3, at: Date.now() });
+    await waitFor(() => rt.markdowns().find((f) => /任务完成/.test(f.body.markdown.content)), { label: "通知仍在" });
+    // 审批卡也不受互动闸影响（点得动、不计数）
+    const card = rt.bot.sendApprovalCard("user-a", { requestId: "ev-empty-1", toolName: "Bash" });
+    await waitFor(() => rt.cards().length === 1, { label: "卡" });
+    pushCardClick(rt.server, { reqId: "empty-click", taskId: card.taskId, eventKey: "allow:ev-empty-1" });
+    await waitFor(() => rt.decisions.length === 1, { label: "审批回执" });
+    assert.equal(rt.bot.status().usage.messages, 0);
+  } finally {
+    await rt.close();
+  }
+});
+
+// ─────────────────────── ⑩g 通道格式化接入（2026-11-08）───────────────────────
+
+test("★ 通道格式化接入：回答回传含 Markdown 表格时，发出的报文里没有裸表格（转成「• 列：值」）", async () => {
+  const answerWithTable = [
+    "修复完成，改动如下：",
+    "",
+    "| 文件 | 改动 | 行数 |",
+    "|---|---|---|",
+    "| clients/dsh-remote/a.mjs | 修端口探测 | 10 |",
+    "| clients/dsh-remote/b.mjs | 加负缓存 | 20 |",
+    "",
+    "以上。"
+  ].join("\n");
+  const rt = await setupRelayBot({ assistantText: { ok: true, text: answerWithTable } });
+  try {
+    rt.bot.start();
+    await waitFor(() => rt.bot.status().authenticated, { label: "认证完成" });
+    await rt.inbound("relay-table-1", "给我看下改动");
+    rt.turnEnd({ turn: 1, seq: 41 });
+    const send = await waitFor(() => rt.sends()[0], { label: "回答回传" });
+    const content = send.body.markdown.content;
+    assert.ok(!/\|\s*-{2,}/.test(content), "★ 报文里不得出现 |--- 分隔行");
+    assert.ok(!/^\s*\|.*\|\s*$/m.test(content), "★ 报文里不得出现裸表格行");
+    assert.match(content, /^• 文件：clients\/dsh-remote\/a\.mjs · 改动：修端口探测 · 行数：10$/m);
+    assert.match(content, /修复完成/);
+    assert.match(content, /以上。/);
+  } finally {
+    await rt.close();
+  }
+});
+
 // ─────────────────────────── ⑪ 配置契约 ───────────────────────────
 
 test("配置契约：normalizeImBotsConfig 缺字段补默认、非法值当未配置；readImBotsConfig 文件不存在返回 null", () => {