@mrrisega/dsh-remote 0.6.10-beta.2 → 0.6.10-beta.6

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

@@ -1224,6 +1224,66 @@ function tagWeChat(m) {
   return s.startsWith("[") ? s : `[wechat] ${s}`;
 }
 
+/**
+ * 微信通道的档位来源(免费/付费分层)。
+ *
+ * 取值 = 账号的**生效套餐**,服务端只有三种:free / pro / pro_max
+ * (见企业端 auth.js 的 PLAN_PRIORITY;试用期服务端已折算成 pro,这里不必自己判断)。
+ *
+ * ⚠️ 取不到时返回**空串**,而不是 "free":空串让 runtime 沿用上次成功取到的档位。
+ *    一次网络抖动就把付过钱的用户降级成免费、还提示他去升级,比多给几分钟权限糟糕得多。
+ * ⚠️ 自建部署直接给最高档:用户跑的是自己的服务器,不存在"会员"这回事,
+ *    不能拿 SaaS 的分层去卡自建用户。
+ */
+/**
+ * 档位查询专用的 token 缓存(理由见 resolveWechatTier 里的注释)。
+ * TTL 取 5 分钟:远小于 JWT 有效期,又足以把「每 10 分钟一次定时校准 + 被拒即重查」
+ * 全部挡在网络之外 —— 不缓存的话,免费用户连着发几条消息就会触发一串 device-login。
+ */
+const WECHAT_TIER_TOKEN_TTL_MS = 5 * 60_000;
+let WECHAT_TIER_TOKEN = { value: "", at: 0 };
+
+async function resolveWechatTier() {
+  if (process.env.DSH_BRIDGE_LOCAL_KEY) return "pro_max";
+  try {
+    // ⚠️ `resolveToken()` **不带缓存**:账号模式下每调一次就重新 device-login 一次
+    //    (见它的第一行,只有 DSH_BRIDGE_TOKEN / 自建模式才短路)。
+    //    而档位会被反复查询:每 10 分钟一次定时校准 + 免费用户**每次被拒**都重查(最快 5 秒一次)。
+    //    拿它直接查 = 用户连着发几条消息就把自己打到登录限流里 —— 而 /api/device-login
+    //    是**按出口 IP 限流**的(15 分钟 5 次),连累的不只是他自己。
+    //    所以这里自己缓存 token。
+    const now = Date.now();
+    if (!WECHAT_TIER_TOKEN.value || now - WECHAT_TIER_TOKEN.at > WECHAT_TIER_TOKEN_TTL_MS) {
+      const t = await resolveToken();
+      if (!t) return "";
+      WECHAT_TIER_TOKEN = { value: t, at: now };
+    }
+    const r = await fetch(`${API_BASE}/api/me`, {
+      headers: { authorization: `Bearer ${WECHAT_TIER_TOKEN.value}` },
+      signal: AbortSignal.timeout(6000)
+    });
+    // token 过期/被吊销 → 丢掉缓存,下一次查询重新登录(而不是一直拿坏 token 打)
+    if (r.status === 401 || r.status === 403) {
+      WECHAT_TIER_TOKEN = { value: "", at: 0 };
+      return "";
+    }
+    if (!r.ok) return "";
+    const j = await r.json().catch(() => null);
+    return String((j && j.user && j.user.plan) || "");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * App 入口(免费用户越界时给的转化链接)。
+ * 由账号 API 地址推导:去掉 `/relay-api` 再加 `/app/` —— 与插件半的 DEFAULT_APP_URL 同一口径
+ * (https://host:port/relay-api → https://host:port/app/)。
+ */
+function wechatAppUrl() {
+  return `${API_BASE.replace(/\/relay-api\/?$/, "")}/app/`;
+}
+
 let wechatRuntime = null;
 function startWeChat() {
   if (WECHAT_DISABLED) {
@@ -1238,6 +1298,9 @@ function startWeChat() {
       upstream: UPSTREAM,
       cookieOf: harnessCookieOf,
       secret: process.env.DSH_BRIDGE_SECRET || (typeof cfg.bridge_secret === "string" ? cfg.bridge_secret : ""),
+      // 免费/付费分层:档位来自账号的生效套餐,App 链接是免费用户越界时的转化入口。
+      tierProvider: resolveWechatTier,
+      appUrl: wechatAppUrl(),
       // 模块自己的消息已带 `[wechat]` / `[wechat/events]` 前缀,这里**不能再加一次**
       // (真机日志里出现过 `[wechat] [wechat] 控制面已就绪`)。没前缀的兜底补一个。
       logger: {
@@ -1280,6 +1343,10 @@ async function runTunnel() {
     console.error("[bridge] 隧道模式需要账号认证:请设 DSH_BRIDGE_TOKEN,或 DSH_BRIDGE_PHONE+DSH_BRIDGE_PASSWORD");
     process.exit(1);
   }
+  // 把刚拿到的 JWT 喂给档位查询的缓存:否则 startWeChat 里的档位校准会**再登录一次**
+  // (真机日志实测:同一个桥接启动里出现两条并发的 device-login)。
+  // 而 /api/device-login 是按出口 IP 限流的 —— 每次启动都多花一份登录额度没有道理。
+  WECHAT_TIER_TOKEN = { value: token, at: Date.now() };
   // 新进程开始:重置状态文件(上一轮的成功记录不能代表这一轮,面板据此判定 online)
   persistBridgeState({ device_id: DEVICE_ID, started_at: Date.now(), phase: "connecting", last_error: null }, { reset: true });
   await initE2ee(token);

package/clients/dsh-remote/test/wechat-runtime.test.mjs

@@ -97,6 +97,12 @@ async function boundRuntime(ilink, opts = {}) {
     upstream: "http://127.0.0.1:1",
     secret: SECRET,
     cooldownMs: opts.cooldownMs,
+    // 默认按**付费档**跑:本文件绝大多数用例测的是遥控能力(交代任务/选会话)。
+    // 免费档的门槛由「分层」那组用例专门守 —— 它们显式传 tier:"free"。
+    tier: opts.tier === undefined ? "pro" : opts.tier,
+    tierProvider: opts.tierProvider,
+    tierDenyThrottleMs: opts.tierDenyThrottleMs,
+    appUrl: opts.appUrl,
     logger: quietLogger()
   });
   // 替换订阅器:本文件测编排,不测 DSH 协议(那是 dsh-events.test.mjs 的职责)
@@ -300,17 +306,24 @@ test("★ handleCommand 的字段是 replyText:回 /help 必须真的发出帮
   }
 });
 
-test("★ 运营钩子:能力表是活代码 —— 每档能力可查,未知档位按最低档", () => {
+test("★ 分层:免费档 = 通知+审批,付费档才给遥控;未知档位按最低档", () => {
   const { capabilitiesFor, WECHAT_CAPABILITY_TABLE } = rtmod;
-  // 免费档今天必须**包含全部**能力(业主:当前免费开放给所有人)
   const free = capabilitiesFor("free");
-  for (const cap of ["notify", "approve", "assign", "sessions", "summary"]) {
-    assert.ok(free.includes(cap), `免费档今天必须有 ${cap}(当前全免费)`);
+  // 免费档(业主口径):收得到通知、点得了审批、看得到状态、停得下任务 —— 但**遥控不了**。
+  for (const cap of ["notify", "approve", "status", "stop"]) {
+    assert.ok(free.includes(cap), `免费档必须有 ${cap}`);
   }
-  // 付费档是预留的:必须存在且是免费档的超集(加付费档 = 只改表,不动业务逻辑)
+  for (const cap of ["assign", "sessions", "summary"]) {
+    assert.ok(!free.includes(cap), `免费档**不得**有 ${cap}(业主:那是付费能力)`);
+  }
+  // 付费档 = 免费档超集 + 遥控
   const pro = capabilitiesFor("pro");
   for (const cap of free) assert.ok(pro.includes(cap), `付费档必须是免费档超集,缺 ${cap}`);
+  for (const cap of ["assign", "sessions", "summary"]) assert.ok(pro.includes(cap), `付费档必须有 ${cap}`);
   assert.ok(pro.length > free.length, "付费档应比免费档多能力(否则钩子没意义)");
+  // ⚠️ 服务端的最高档取值是 **pro_max** —— 漏了它 capabilitiesFor 会回退 free,
+  //    把花了最多钱的用户当成免费用户挡在门外。
+  assert.deepEqual(capabilitiesFor("pro_max"), pro, "pro_max 必须与 pro 同权(服务端 plan 取值就是 pro_max)");
   // 未知/空档位按最低档处理 —— 宁可少给,不可误放
   assert.deepEqual(capabilitiesFor("nonexistent"), free);
   assert.deepEqual(capabilitiesFor(""), free);
@@ -319,30 +332,126 @@ test("★ 运营钩子:能力表是活代码 —— 每档能力可查,未知档
   assert.ok(Object.isFrozen(WECHAT_CAPABILITY_TABLE));
 });
 
-test("★ 运营钩子:能力表在派发路径上真的生效 —— 拿掉 assign 后交代任务被拒", async () => {
-  // 这条守的是"钩子是活代码,不是文档":今天免费档含 assign 所以行为不变,
-  // 但把 assign 从表里拿掉后,**派发必须真的拒绝**。
+test("★ 分层:免费档被挡且回复里带 App 链接;付费档放行;未知档位按免费", async () => {
+  // 这条守的是两件事:(1) 门槛是**活代码**,不是文档;(2) 免费用户越界时拿到的是
+  // 「解释 + 可点击的 App 链接」,而不是一句干巴巴的拒绝 —— 那是把用户引回主功能的入口。
+  const APP_URL = "https://app.example/x/";
+  const ilink = await fakeIlink();
+  try {
+    const send = (rt) => rt.handleInbound({
+      from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/new 做点事" } }]
+    });
+
+    // ① 免费档:必须拒绝,且回复里要有 App 链接
+    const free = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "free", appUrl: APP_URL });
+    await send(free.rt);
+    assert.equal(free.rt.subscriber.calls.filter((c) => c.m === "createSession").length, 0,
+      "免费档不得真的建会话");
+    const freeText = lastText(ilink.state);
+    assert.match(freeText, /会员功能/, `要说清为什么被拒,实际:${freeText}`);
+    assert.ok(freeText.includes(APP_URL),
+      `★回复必须带上可点击的 App 链接(业主:免费用户要去做别的,就给他访问 App 的链接),实际:${freeText}`);
+    assert.match(freeText, /\/help/, "还要告诉他现在能做什么,而不是死路一条");
+
+    // ② 付费档:同一句话必须放行
+    const pro = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "pro", appUrl: APP_URL });
+    await send(pro.rt);
+    assert.equal(pro.rt.subscriber.calls.filter((c) => c.m === "createSession").length, 1,
+      "付费档必须能交代任务");
+
+    // ③ 未知档位按最低档 —— 宁可少给,不可误放
+    const weird = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "谁", appUrl: APP_URL });
+    await send(weird.rt);
+    assert.equal(weird.rt.subscriber.calls.filter((c) => c.m === "createSession").length, 0,
+      "未知档位必须按免费档处理");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 分层:免费档仍能收通知、点审批、看状态、急停(不能把免费版做成废的)", async () => {
   const ilink = await fakeIlink();
   try {
     const sub = makeFakeSubscriber();
-    const relayDir = tmp();
-    saveAccount(relayDir, { token: "tok", accountId: "b", baseUrl: ilink.baseUrl, userId: "u", boundAt: 1 });
-    const rt = createWeChatRuntime({
-      relayDir, upstream: "http://127.0.0.1:1", secret: SECRET, logger: quietLogger(),
-      // 注入一张"免费档不含 assign"的表,模拟将来把该能力收进付费档
-      capabilityTable: { free: ["notify"], pro: ["notify", "approve", "assign", "sessions", "summary"] }
+    const { rt } = await boundRuntime(ilink, { subscriber: sub, tier: "free" });
+
+    // ① 通知 + 审批一步回执 —— 免费档的核心价值,绝不能因为分层被误伤
+    await rt.notify({
+      kind: NODE_KINDS.APPROVAL_REQUEST, eventId: "evt-free", toolName: "Read",
+      reason: "读取文件", answerShape: "approval", at: 1
+    });
+    assert.ok(rt.pendingReplies.length > 0, "免费档必须收到可回执的审批通知");
+    assert.match(lastText(ilink.state), /回复 1/, "非破坏性审批必须给编号选项");
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "1" } }] });
+    assert.equal(sub.calls.filter((c) => String(c.m).startsWith("answer")).length, 1,
+      "免费档必须能一步回执审批");
+
+    // ② /status 是信息类:人人可用(也是免费用户的转化入口)
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/status" } }] });
+    assert.ok(lastText(ilink.state).length > 0, "/status 必须对免费档可用");
+
+    // ③ /stop 是急停阀:免费档也必须能停。
+    //    免费用户不能主动 /use 切会话,但指针会在他收到事件时自动落上(见 #rememberSession),
+    //    这里直接把它置上,模拟"本来就在跑某个任务"。
+    rt.currentSessionId = "session-running";
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/stop" } }] });
+    assert.equal(sub.calls.filter((c) => c.m === "cancelSession").length, 1,
+      "免费档必须能急停(一个只会通知、连停都停不了的通道会让人觉得被挟持)");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 分层:档位取不到时沿用上次已知档位(绝不因一次网络抖动把付费用户降级)", async () => {
+  const ilink = await fakeIlink();
+  try {
+    let answer = "pro";
+    const sub1 = makeFakeSubscriber();
+    const { rt } = await boundRuntime(ilink, {
+      subscriber: sub1, tier: "", tierProvider: async () => answer, tierDenyThrottleMs: 0
+    });
+
+    // 首次判档位时缓存为空(按免费)→ 被拒路径触发刷新 → 取到 pro → **同一条指令立即放行**
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/ls" } }] });
+    assert.equal(sub1.calls.filter((c) => c.m === "listSessions").length, 1,
+      "首次取到 pro 后就该放行(不能因为'一开始不知道'就把付费用户挡掉)");
+
+    // 此后账号 API 一直取不到(返回空串)→ 必须**沿用 pro**。
+    // ⚠️ 必须**主动**触发一次校准:光靠派发测不到 —— 缓存已是 pro 时 `#can` 直接放行,
+    //    根本不会再走刷新那条路径(变异测试实测:不加这一步,"取不到就降级"的变异抓不到)。
+    answer = "";
+    assert.equal(await rt.refreshTierNow(), "pro",
+      "★取不到档位时必须沿用上次的 pro —— 付过钱的用户不该因一次网络失败被判成免费");
+
+    // 而且能力也真的还在(不只是内部字段好看)
+    const sub2 = makeFakeSubscriber();
+    rt.subscriber = sub2;
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/ls" } }] });
+    assert.equal(sub2.calls.filter((c) => c.m === "listSessions").length, 1,
+      "沿用 pro 期间,遥控能力必须仍然可用");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 分层:刚升级完立刻重试必须能进(不必重启 bridge)", async () => {
+  const ilink = await fakeIlink();
+  try {
+    // 一开始服务端说 free → 交代任务被拒;用户买完后服务端改口 pro → 同一条指令必须能进。
+    // tierDenyThrottleMs:0 把节流关掉,让这条路径确定性地可测(生产默认 5 秒,注释已写明)。
+    let plan = "free";
+    const sub = makeFakeSubscriber();
+    const { rt } = await boundRuntime(ilink, {
+      subscriber: sub, tier: "", tierProvider: async () => plan, tierDenyThrottleMs: 0
     });
-    rt.subscriber = sub;
 
     await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/new 做点事" } }] });
-    assert.equal(sub.calls.filter((c) => c.m === "createSession").length, 0, "不含 assign 时不得真的建会话");
-    assert.match(lastText(ilink.state), /当前档位/, `必须给出可照做的拒绝理由,实际:${lastText(ilink.state)}`);
+    assert.equal(sub.calls.filter((c) => c.m === "createSession").length, 0, "免费时先拒");
 
-    // 默认档位(不注入)必须仍然可用 —— 业主:当前免费开放给所有人
-    const rt2 = createWeChatRuntime({ relayDir, upstream: "http://127.0.0.1:1", secret: SECRET, logger: quietLogger() });
-    rt2.subscriber = makeFakeSubscriber();
-    await rt2.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/new 做点事" } }] });
-    assert.equal(rt2.subscriber.calls.filter((c) => c.m === "createSession").length, 1, "默认(免费档)今天必须能交代任务");
+    plan = "pro"; // 用户升级
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/new 做点事" } }] });
+    assert.equal(sub.calls.filter((c) => c.m === "createSession").length, 1,
+      "★升级后必须能进:否则用户付了钱还要重启 bridge 才能用");
   } finally {
     await ilink.close();
   }
@@ -454,6 +563,7 @@ test("★ v2:当前会话指针在重启后恢复(否则用户下一条消息会
     const sub2 = makeFakeSubscriber();
     const rt2 = createWeChatRuntime({
       relayDir, upstream: "http://127.0.0.1:1", secret: SECRET,
+      tier: "pro", // 本用例测的是"指针持久化",不是分层;按付费档跑才有"发消息"这条能力
       logger: quietLogger()
     });
     rt2.subscriber = sub2;
@@ -484,6 +594,97 @@ test("★ v2:完成推送带会话名称 + 结论,而不只是「任务已停止
   }
 });
 
+test("★ 分层:免费档的完成推送不能承诺「回复就能接着做」,要改成会员说明 + App 链接", async () => {
+  // 默认那句「回复这条消息就能接着这个会话往下做」对免费用户是**空头承诺**:
+  // 他回复纯文本只会拿到付费引导。文案必须跟着档位走,否则用户会以为产品坏了。
+  const APP_URL = "https://app.example/x/";
+  const ilink = await fakeIlink();
+  try {
+    const sub = makeFakeSubscriber();
+    sub.sessionsFixture = [{ sessionId: "session-s1", title: "跑个长任务", running: false, cwd: "/p" }];
+    sub.summaryFixture = "已完成。";
+    const { rt } = await boundRuntime(ilink, { subscriber: sub, tier: "free", appUrl: APP_URL });
+    rt.currentSessionId = "session-s1";
+    await rt.notify({ kind: NODE_KINDS.TURN_END, sessionId: "session-s1", reason: "completed", at: 1 });
+    const text = lastText(ilink.state);
+
+    // 免费档照样要看得到"完成了 + 结论"(这是他的核心价值)
+    assert.match(text, /完成/, "免费档必须照样收到完成通知");
+    assert.match(text, /已完成/, "结论也要给");
+    assert.ok(!/就能接着这个会话/.test(text),
+      `★不得对免费用户承诺"回复就能接着做"(他做不到),实际:${text}`);
+    assert.ok(text.includes(APP_URL), `★收尾要给出 App 链接,实际:${text}`);
+
+    // 付费档:保留原话术(产品核心,别被这条改动误伤)
+    const ilink2 = await fakeIlink();
+    try {
+      const sub2 = makeFakeSubscriber();
+      sub2.sessionsFixture = [{ sessionId: "session-s1", title: "跑个长任务", running: false, cwd: "/p" }];
+      sub2.summaryFixture = "已完成。";
+      const { rt: rt2 } = await boundRuntime(ilink2, { subscriber: sub2, tier: "pro", appUrl: APP_URL });
+      rt2.currentSessionId = "session-s1";
+      await rt2.notify({ kind: NODE_KINDS.TURN_END, sessionId: "session-s1", reason: "completed", at: 1 });
+      assert.match(lastText(ilink2.state), /就能接着这个会话/, "付费档必须保留「回复即续接」这句");
+    } finally {
+      await ilink2.close();
+    }
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 分层:/help 必须按档位如实分层(免费用户看到的清单里不能有他做不到的指令)", async () => {
+  const APP_URL = "https://app.example/x/";
+  const ilink = await fakeIlink();
+  try {
+    const free = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "free", appUrl: APP_URL });
+    await free.rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/help" } }] });
+    const t = lastText(ilink.state);
+    assert.match(t, /通知版/, "免费档的帮助要说明自己是通知版");
+    assert.ok(t.includes(APP_URL), "免费档的帮助里必须带开通入口(App 链接)");
+    assert.match(t, /会员功能/, "会员能力必须单独分组，不能混进「现在能用的」");
+    // /new 只能出现在「会员功能」那一段之后 —— 混在前面就是骗人
+    const memberAt = t.indexOf("会员功能");
+    assert.ok(memberAt > -1 && t.indexOf("/new") > memberAt, "/new 不得出现在免费能力段里");
+
+    const pro = await boundRuntime(ilink, { subscriber: makeFakeSubscriber(), tier: "pro", appUrl: APP_URL });
+    await pro.rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/help" } }] });
+    const pt = lastText(ilink.state);
+    assert.match(pt, /DSH 微信通道/, "付费档仍用完整帮助");
+    assert.ok(!/通知版/.test(pt), "付费档不该被标成通知版");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 分层:免费用户打字「允许」(而不是回数字)时,要先把「回数字就能拍板」说在前面", async () => {
+  // 回执只认纯数字(classifyInbound),而免费档的核心价值就是审批 ——
+  // 用户很可能打字「允许」。这时只回一句付费提示,他会以为免费版什么都干不了。
+  const ilink = await fakeIlink();
+  try {
+    const sub = makeFakeSubscriber();
+    const { rt } = await boundRuntime(ilink, { subscriber: sub, tier: "free", appUrl: "https://app.example/x/" });
+    await rt.notify({
+      kind: NODE_KINDS.APPROVAL_REQUEST, eventId: "evt-1", toolName: "Read",
+      reason: "读取文件", answerShape: "approval", at: 1
+    });
+    assert.ok(rt.pendingReplies.length > 0, "先得有一条待回执的消息");
+
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "允许" } }] });
+    const text = lastText(ilink.state);
+    assert.match(text, /回一个数字/, `必须先告诉他怎么拍板,实际:${text}`);
+    assert.match(text, /待你拍板/, "要说明确实有东西在等他决定");
+    assert.ok(text.includes("https://app.example/x/"), "仍然要带上 App 链接");
+
+    // 而回数字本身必须真的能拍板(免费档的核心价值不能被这条改动带坏)
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "1" } }] });
+    assert.equal(sub.calls.filter((c) => String(c.m).startsWith("answer")).length, 1,
+      "回数字必须照常完成审批");
+  } finally {
+    await ilink.close();
+  }
+});
+
 test("★ v2 安全:破坏性审批不给回执选项,回数字也不产生任何回执", async () => {
   const ilink = await fakeIlink();
   try {

package/clients/dsh-remote/test/wechat-tier-source.test.mjs

@@ -0,0 +1,125 @@
+/**
+ * 微信通道「档位来源」回归（分层功能的接线段）。
+ *
+ * 分层本身在 wechat-runtime 里可测；这里守的是**桥接侧喂给它的那个值对不对**：
+ *   · 自建部署必须是最高档 —— 用户跑的是自己的服务器，不该被 SaaS 的会员分层卡住；
+ *   · SaaS 走账号的**生效套餐**（free / pro / pro_max，试用期服务端已折算成 pro）；
+ *   · 取不到时必须返回**空串**（让 runtime 沿用上次的档位），绝不能返回 "free" ——
+ *     一次网络抖动就把付过钱的用户降级、还提示他去升级，比多给几分钟权限糟糕得多；
+ *   · App 链接要从账号 API 地址推导出来（免费用户越界时的转化入口）。
+ *
+ * 这些分支在测试机上跑不到（要真账号 + 真网络），所以把函数从源码抠出来，
+ * 注入假 process / resolveToken / fetch，把每条路真的执行一遍。
+ */
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const BRIDGE_SRC = readFileSync(path.join(HERE, "..", "dsh-bridge.mjs"), "utf8");
+const API_BASE = "https://api.example/relay-api";
+
+function loadTierResolver({ localKey = "", token = "tok-1", status = 200, body = { user: { plan: "pro" } }, throws = false } = {}) {
+  // 切片必须**带上 token 缓存那两个声明**（它们在函数之外，漏了就 ReferenceError →
+  // 被函数内的 try/catch 吞成空串，测试会假绿）。
+  const from = BRIDGE_SRC.indexOf("const WECHAT_TIER_TOKEN_TTL_MS");
+  const to = BRIDGE_SRC.indexOf("function wechatAppUrl()");
+  assert.ok(from > -1 && to > from, "未能从 dsh-bridge.mjs 切出 resolveWechatTier（锚点已漂移）");
+  assert.ok(/async function resolveWechatTier\(\)/.test(BRIDGE_SRC.slice(from, to)),
+    "切片必须同时包含 token 缓存声明与 resolveWechatTier");
+  const calls = [];
+  let tokenCalls = 0;
+  const fakeFetch = async (url, init) => {
+    calls.push({ url, init });
+    if (throws) throw new Error("network down");
+    return { ok: status >= 200 && status < 300, status, json: async () => body };
+  };
+  const make = new Function("process", "resolveToken", "API_BASE", "fetch", "AbortSignal",
+    `${BRIDGE_SRC.slice(from, to)}\nreturn resolveWechatTier;`);
+  const env = localKey ? { DSH_BRIDGE_LOCAL_KEY: localKey } : {};
+  const fn = make({ env }, async () => { tokenCalls += 1; return token; }, API_BASE, fakeFetch, AbortSignal);
+  return { fn, calls, tokenCalls: () => tokenCalls };
+}
+
+function loadAppUrl(apiBase) {
+  const from = BRIDGE_SRC.indexOf("function wechatAppUrl()");
+  const to = BRIDGE_SRC.indexOf("let wechatRuntime = null;");
+  assert.ok(from > -1 && to > from, "未能从 dsh-bridge.mjs 切出 wechatAppUrl（锚点已漂移）");
+  const make = new Function("API_BASE", `${BRIDGE_SRC.slice(from, to)}\nreturn wechatAppUrl;`);
+  return make(apiBase);
+}
+
+test("档位来源：SaaS 用账号的生效套餐，并带上 Bearer token 打 /api/me", async () => {
+  for (const plan of ["free", "pro", "pro_max"]) {
+    const { fn, calls } = loadTierResolver({ body: { user: { plan } } });
+    assert.equal(await fn(), plan, `必须如实透传服务端的生效套餐 ${plan}`);
+    assert.equal(calls.length, 1, "只应请求一次");
+    assert.equal(calls[0].url, `${API_BASE}/api/me`, "应打账号 API 的 /api/me");
+    assert.equal(calls[0].init.headers.authorization, "Bearer tok-1", "必须带 token");
+    assert.ok(calls[0].init.signal, "必须有超时信号（不能把档位查询挂死）");
+  }
+});
+
+test("★档位来源：自建部署直接给最高档，且**不去打账号 API**", async () => {
+  // 自建用户跑的是自己的服务器，不存在"会员"这回事。
+  // 而且必须**一次网络请求都不发** —— 自建环境常常连不上（也不该连）账号 API。
+  const { fn, calls } = loadTierResolver({ localKey: "local-key-abc" });
+  assert.equal(await fn(), "pro_max", "自建部署必须是最高档");
+  assert.equal(calls.length, 0, "★自建模式不得请求账号 API");
+});
+
+test("★档位来源：取不到时返回空串（让上层沿用旧值），绝不返回 free 把付费用户降级", async () => {
+  // 空串 = "这次没取到"，runtime 据此保留上次的档位；返回 "free" 则会把人降级。
+  const http = loadTierResolver({ status: 503, body: {} });
+  assert.equal(await http.fn(), "", "HTTP 失败 → 空串");
+  const boom = loadTierResolver({ throws: true });
+  assert.equal(await boom.fn(), "", "网络异常必须被吞掉并返回空串（档位不是关键路径，不能拖垮 bridge）");
+  const noToken = loadTierResolver({ token: "" });
+  assert.equal(await noToken.fn(), "", "拿不到 token → 空串");
+  assert.equal(noToken.calls.length, 0, "没 token 就不该白跑一次请求");
+  const weird = loadTierResolver({ body: { user: {} } });
+  assert.equal(await weird.fn(), "", "服务端没给 plan → 空串（不是猜一个 free）");
+});
+
+test("★档位来源：token 必须自己缓存（否则免费用户连点几下就把自己打到登录限流）", async () => {
+  // `resolveToken()` 在账号模式下**每调一次就重新 device-login 一次**，而 /api/device-login
+  // 是按**出口 IP** 限流的（15 分钟 5 次）。档位会被反复查询（定时校准 + 免费用户每次被拒都重查），
+  // 不缓存就是拿用户的登录额度去换一个只读字段。
+  const { fn, calls, tokenCalls } = loadTierResolver({ body: { user: { plan: "free" } } });
+  await fn();
+  await fn();
+  await fn();
+  assert.equal(tokenCalls(), 1, "★多次查档位只应登录一次");
+  assert.equal(calls.length, 3, "但 /api/me 每次都要查（档位本身要新鲜）");
+});
+
+test("★档位来源：token 失效(401/403)时丢掉缓存，下次重新登录而不是一直用坏 token", async () => {
+  const bad = loadTierResolver({ status: 401, body: {} });
+  assert.equal(await bad.fn(), "", "401 → 空串（沿用上层旧档位，不降级）");
+  assert.equal(await bad.fn(), "", "仍然空串");
+  assert.equal(bad.tokenCalls(), 2, "★401 之后必须重新登录一次（缓存已失效，不能一直拿坏 token 打）");
+});
+
+test("★档位来源：启动时必须复用桥接刚拿到的 JWT（否则每次启动多花一份登录额度）", () => {
+  // 真机日志实测：同一个桥接启动里出现两条并发的 device-login —— 一条是隧道登录，
+  // 另一条是档位校准。而 device-login 按出口 IP 限流，每次启动多花一份额度没有道理。
+  const i = BRIDGE_SRC.indexOf("async function runTunnel()");
+  assert.ok(i > -1, "应能找到 runTunnel");
+  const body = BRIDGE_SRC.slice(i, BRIDGE_SRC.indexOf("async function main()"));
+  assert.ok(body.length > 0, "切片边界应正确");
+  const seedAt = body.indexOf("WECHAT_TIER_TOKEN = { value: token");
+  const startAt = body.indexOf("startWeChat()");
+  assert.ok(seedAt > -1, "runTunnel 必须把刚拿到的 token 喂给档位缓存");
+  assert.ok(startAt > -1, "runTunnel 应调用 startWeChat()");
+  assert.ok(seedAt < startAt, "★必须在 startWeChat() **之前**喂，否则档位校准仍会再登录一次");
+});
+
+test("App 链接：由账号 API 地址推导，与插件半的 DEFAULT_APP_URL 同口径", () => {
+  assert.equal(loadAppUrl(API_BASE)(), "https://api.example/app/");
+  assert.equal(loadAppUrl("https://n.risegao.cn:13443/relay-api")(), "https://n.risegao.cn:13443/app/",
+    "生产地址必须推导出真实可点的 App 入口");
+  assert.equal(loadAppUrl("https://api.example/relay-api/")(), "https://api.example/app/",
+    "结尾斜杠也要正确吃掉");
+});

package/clients/dsh-remote/wechat-channel.mjs

@@ -1947,7 +1947,9 @@ const COMPLETION_REASON_NOTES = Object.freeze({
  *
  * @param {object} args { title(会话名), reason(completed|aborted|blocked|error|max-tokens|interrupted),
  *                        summary(结论), sessionId, hanging(结论取不到时 true) }
- * @param {object} [opts] { summaryMaxLength=400, maxLength=900, ttlMinutes }
+ * @param {object} [opts] { summaryMaxLength=400, maxLength=900, ttlMinutes, continuationHint }
+ *   `continuationHint` 非空 = 用**调用方给的**收尾话术替换默认的「回复就能接着做」,
+ *   且不再在结论缺失时邀请用户回复(免费档做不到,不能对他下这种指令)。
  * @returns {{kind:'completed', title:string, text:string, replyable:false, ttlMinutes:number}}
  *   title 是**展示标题**(和 formatNotification 的 title 同义,【】里那一行);会话名在 text 里。
  */
@@ -1977,16 +1979,24 @@ export function formatCompletion({ title, reason, summary, sessionId, hanging }
   }
 
   // ③ 结论
+  //   只有「能回话」的档位才邀请用户回复 —— 否则那是对一个做不到的人下指令
+  //   (免费用户回复纯文本只会拿到付费引导,见 wechat-runtime 的 #upsellText)。
+  const canContinue = opts.continuationHint === undefined;
   if (body) {
     lines.push(`结论:${shorten(body, summaryMax)}`);
   } else if (hanging) {
-    lines.push("结论:暂时没取到(任务可能还在收尾)。回复 /summary 可以再要一次。");
+    lines.push(canContinue
+      ? "结论:暂时没取到(任务可能还在收尾)。回复 /summary 可以再要一次。"
+      : "结论:暂时没取到(任务可能还在收尾)。");
   } else {
-    lines.push("结论:这次没有产出结论。回复一句话就能追问。");
+    lines.push(canContinue
+      ? "结论:这次没有产出结论。回复一句话就能追问。"
+      : "结论:这次没有产出结论。");
   }
 
-  // ④ 收尾:回复即续接同一会话(产品核心,别删这句)
-  lines.push("回复这条消息(直接说下一步)就能接着这个会话往下做,不用重新交代背景。");
+  // ④ 收尾:回复即续接同一会话(付费档的产品核心,别删这句)。
+  //   免费档由调用方传 `continuationHint` 换成"会员可用 + App 链接"的说法。
+  lines.push(opts.continuationHint || "回复这条消息(直接说下一步)就能接着这个会话往下做,不用重新交代背景。");
 
   // 纯文本 + 长度上限:微信不是富客户端,超长整条截断并显式标注
   let text = lines.join("\n");

package/clients/dsh-remote/wechat-runtime.mjs

@@ -40,6 +40,7 @@ import {
   extractInboundText,
   extractFromUserId,
   handleCommand,
+  HELP_TEXT,
   classifyInbound,
   formatCompletion,
   isDestructiveTool,
@@ -62,21 +63,29 @@ import { createEventSubscriber, NODE_KINDS } from "./dsh-events.mjs";
  */
 
 /**
- * v2 能力表(运营钩子)。
+ * v2 能力表(运营钩子) —— 业主 2026-09-22 确认的分层:
  *
- * 业主的运营规划:**当前全部免费开放**,后续留钩子让付费用户用更高阶的功能。
- * 所以这里把「谁能用什么」做成**一张表 + 一处判断**,而不是散在代码里的 if:
- * 将来加付费档 = 改这张表,不动任何业务逻辑(也不改架构)。
+ *   · **免费档 = 只读 + 审批**:收得到任务通知(含完成小结、报错、额度、会员到期),
+ *     点得了审批回执(选择下一步执行)。但**遥控不了**。
+ *   · **付费档 = 免费档 + 遥控**:在微信里直接交代任务、切换会话(以及预留的中途纠偏/附件/多会话)。
  *
- * ⚠️ 这张表现在是 **permissive** 的(免费档已含全部能力),所以它**不改变今天的可用性**;
- *    但它在代码路径上是活的(每次派发都会查),不是死代码。
- * ⚠️ `tier` 暂时恒为 "free" —— bridge 目前拿不到账号套餐。付费档上线时,
- *    由 host 半边/账号 API 提供真实 tier 再塞进 `#tier()`,**只需改这一个函数**。
+ * 免费用户尝试付费能力时,回复里带上 App 链接 —— 这既是解释,也是转化入口
+ * (见 `#upsellText()`:业主口径是"如果免费用户要去做其他的东西,就在消息后面跟一个访问 App 的链接")。
+ *
+ * ⚠️ `pro_max` **必须存在**:服务端的生效套餐取值就是 free / pro / pro_max(见企业端 auth.js 的
+ *    PLAN_PRIORITY),而 `capabilitiesFor` 对**未知档位回退 free** —— 漏了 pro_max 就会把
+ *    最高的付费档用户当成免费用户挡在门外。
+ * ⚠️ 改这张表 = 改产品权限,别顺手加能力;`free` 那行是"用户没付钱时他能做什么"的唯一定义。
  */
+const PAID_CAPABILITIES = Object.freeze([
+  "notify", "approve", "status", "stop",
+  "assign", "sessions", "summary",
+  "steer", "attach", "multi" // 预留:中途纠偏 / 附件 / 多会话并行
+]);
 export const WECHAT_CAPABILITY_TABLE = Object.freeze({
-  free: Object.freeze(["notify", "approve", "assign", "sessions", "summary"]),
-  // 预留给付费档:中途纠偏(steer)、附件、多会话并行。今天不启用。
-  pro: Object.freeze(["notify", "approve", "assign", "sessions", "summary", "steer", "attach", "multi"])
+  free: Object.freeze(["notify", "approve", "status", "stop"]),
+  pro: PAID_CAPABILITIES,
+  pro_max: PAID_CAPABILITIES
 });
 
 /** 某档位具备哪些能力。未知档位按最低档(free)处理 —— 宁可少给,不可误放。 */
@@ -85,6 +94,22 @@ export function capabilitiesFor(tier, table = WECHAT_CAPABILITY_TABLE) {
   return table[key];
 }
 
+/**
+ * 指令 → 所需能力。**没列出的指令不设门槛**（`/help`、`/status`、`/unbind`、`/quiet` 人人可用）。
+ *
+ * 为什么 `/unbind` 绝不设门槛:免费用户也必须能解绑 —— 否则他被绑上了却退不掉,
+ * 这既是骚扰也是合规问题。
+ * 为什么 `/stop` 放进免费档:免费用户已经能通过审批「选择下一步执行」,再给一个急停阀是同一件事;
+ * 一个只会发通知、却连"停下"都做不到的通道,用户会觉得被挟持。
+ */
+const COMMAND_CAPABILITY = Object.freeze({
+  "/new": "assign",
+  "/ls": "sessions",
+  "/use": "sessions",
+  "/summary": "summary",
+  "/stop": "stop"
+});
+
 /**
  * ★ 两个上游模块的**节点词表不一致**,这里是唯一的翻译点。
  *
@@ -176,6 +201,11 @@ export const CONTROL_HEADER = "x-dsh-bridge-secret";
 export const DEFAULT_BIND_TTL_MS = 5 * 60_000;
 /** 默认每日简报时刻(本地时区小时,0-23)。 */
 export const DEFAULT_DIGEST_HOUR = 9;
+/**
+ * 档位校准间隔。10 分钟足够跟上升级/到期(派发被拒时还会立刻再确认一次),
+ * 又不至于把账号 API 当心跳打。
+ */
+export const WECHAT_TIER_REFRESH_MS = 10 * 60_000;
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -302,11 +332,31 @@ export class WeChatRuntime {
     /** `/ls` 的结果缓存(1-based 序号供 /use 使用)。 */
     this.sessionIndex = [];
     /**
-     * 运营钩子的两个可注入点(都只为可测与将来接真实套餐;生产不传即用默认)。
-     * `tierOverride` 空 = 按 free;`capabilityTable` 空 = 用内置表。
+     * 运营钩子的可注入点(生产由 bridge 注入真实档位;测试可覆盖)。
+     * `tierOverride` 空 = 用缓存/默认;`capabilityTable` 空 = 用内置表。
      */
     this.tierOverride = typeof opts.tier === "string" ? opts.tier : "";
     this.capabilityTable = opts.capabilityTable || WECHAT_CAPABILITY_TABLE;
+    /**
+     * 真实档位来源(async→ "free"|"pro"|"pro_max";空串 = 这次没取到)。
+     * bridge 用账号 API 的生效套餐实现它;不注入时档位恒为缓存/默认(测试与自建)。
+     */
+    this.tierProvider = typeof opts.tierProvider === "function" ? opts.tierProvider : null;
+    /** App 入口(免费用户越界时给的转化链接)。空则不附链接,不编一个假地址。 */
+    this.appUrl = String(opts.appUrl || "").trim();
+    /**
+     * ★ 档位**持久化缓存**:进程重启后不会因为一次网络失败就把付费用户降级成免费。
+     * 首次运行且从未取到过 = 空 → 按 free(宁可少给,不可误放)。
+     */
+    this.cachedTier = String(persisted.tier || "").trim();
+    this.tierCheckedAt = 0;
+    this.tierTimer = null;
+    /**
+     * 被拒时重查档位的节流窗口。用户刚升级完重试要能进,但免费用户反复发消息
+     * 也不能变成"每条消息打一次账号 API",所以取 5 秒(最坏情况等 5 秒就能进)。
+     * 可注入,便于测试把这条路径跑成确定性的。
+     */
+    this.tierDenyThrottleMs = Number.isFinite(opts.tierDenyThrottleMs) ? opts.tierDenyThrottleMs : 5_000;
   }
 
   // ── 状态 ────────────────────────────────────────────────────────────────
@@ -456,6 +506,13 @@ export class WeChatRuntime {
     if (this.channelTask || !this.channel.account) return false;
     this.stopping = false;
     this.channel.writeState({ connected_at: this.clock(), last_error: "" });
+    // 档位:启动时取一次(不等它,别拖慢上线),之后每 10 分钟校准一次。
+    // 用户升级后不必重启 bridge —— 下一次派发时的 #canNow 还会立刻再确认一遍。
+    void this.#refreshTier(0);
+    if (!this.tierTimer) {
+      this.tierTimer = setInterval(() => { void this.#refreshTier(0); }, WECHAT_TIER_REFRESH_MS);
+      if (typeof this.tierTimer.unref === "function") this.tierTimer.unref();
+    }
     this.#startSubscriber();
     this.channelTask = this.#channelLoop().catch((e) => {
       this.logger.warn(`[wechat] 长轮询退出:${redact(String(e && e.message ? e.message : e))}`);
@@ -466,6 +523,10 @@ export class WeChatRuntime {
 
   async stopChannel() {
     this.stopping = true;
+    if (this.tierTimer) {
+      clearInterval(this.tierTimer);
+      this.tierTimer = null;
+    }
     if (this.subscriber) {
       try { this.subscriber.close(); } catch { /* 忽略 */ }
       this.subscriber = null;
@@ -572,17 +633,29 @@ export class WeChatRuntime {
       return;
     }
     if (cls.kind === "message") {
+      // 纯文本 = 「在微信里交代任务」→ 付费能力。免费用户拿到解释 + App 链接(转化入口)。
+      if (!(await this.#canNow("assign"))) {
+        // ⚠️ 陷阱:回执只认**纯数字**(见 classifyInbound)。免费档的核心价值恰恰是审批,
+        //    用户很可能打字「允许」而不是回「1」—— 若只回一句付费提示,他会以为免费版什么都干不了。
+        //    所以手上有待回执的消息时,先把"回数字就能拍板"说在前面。
+        const head = this.pendingReplies.length > 0
+          ? `你还有 ${this.pendingReplies.length} 条待你拍板的消息 —— 直接回一个数字(如 1)就能完成决定,不用打字。\n\n`
+          : "";
+        await this.reply(from, head + this.#upsellText());
+        return;
+      }
       await this.#sendToSession(from, cls.text);
       return;
     }
   }
 
   /**
-   * 当前账号档位。今天恒为 free(bridge 拿不到套餐);付费档上线时**只改这里**。
-   * 可用 `opts.tier` 覆盖,供测试注入。
+   * 当前账号档位。可用 `opts.tier` 覆盖(测试注入);否则用**上次成功取到的档位**。
+   * 从没取到过 = 空 → 按 free(宁可少给,不可误放)。
    */
   #tier() {
-    return this.tierOverride || "free";
+    if (this.tierOverride) return this.tierOverride;
+    return this.cachedTier || "free";
   }
 
   /** 当前档位是否具备某能力(运营钩子的唯一判断入口)。 */
@@ -590,15 +663,120 @@ export class WeChatRuntime {
     return capabilitiesFor(this.#tier(), this.capabilityTable).includes(cap);
   }
 
+  /**
+   * 刷新档位(带节流)。**取不到时保留上次已知档位** —— 网络抖一下就把付费用户降级成免费,
+   * 他会看到"升级后即可使用"而自己明明付过钱,这比多给几分钟权限糟糕得多。
+   * @returns {Promise<string>} 刷新后的档位
+   */
+  async #refreshTier(minIntervalMs = 30_000) {
+    if (!this.tierProvider) return this.#tier();
+    const now = Date.now();
+    if (now - this.tierCheckedAt < minIntervalMs) return this.#tier();
+    this.tierCheckedAt = now;
+    let next = "";
+    try {
+      next = String((await this.tierProvider()) || "").trim();
+    } catch (e) {
+      this.logger.warn(`[wechat] 读取账号档位失败(沿用上次):${redact(String(e && e.message ? e.message : e))}`);
+      return this.#tier();
+    }
+    if (!next) return this.#tier(); // 空串 = 这次没取到 → 沿用缓存
+    if (next !== this.cachedTier) {
+      this.cachedTier = next;
+      this.channel.writeState({ tier: next });
+      this.logger.info(`[wechat] 账号档位:${next}`);
+    }
+    return this.#tier();
+  }
+
+  /**
+   * 判能力时先**确保档位是新鲜的**:用户刚买完重试必须能进(最坏等 `tierDenyThrottleMs`,
+   * 默认 5 秒),而不是等到下次重启 bridge 才发现"我付了钱还是不能用"。
+   */
+  async #canNow(cap) {
+    if (this.#can(cap)) return true;
+    await this.#refreshTier(this.tierDenyThrottleMs);
+    return this.#can(cap);
+  }
+
+  /**
+   * 立刻校准一次档位(不走节流)。
+   *
+   * 存在的理由:这是唯一能**主动**触发校准的入口 —— 其余触发点都被"当前档位够用就不查"
+   * 拦在前面(`#canNow` 只在被拒时才查),于是一条关键不变量没法被测到:
+   * 「provider 返回空串时必须沿用上次档位,而不是降级」。付费用户的钱包就挂在这条上。
+   * 将来面板做"我刚买完,立刻校准"也走这里。
+   */
+  async refreshTierNow() {
+    return this.#refreshTier(0);
+  }
+
+  /**
+   * 帮助文案。**必须按档位如实分层**。
+   *
+   * 为什么不能直接用上游那个静态 HELP_TEXT:它把 `/new`、`/ls`、`/use` 与"直接发一句话"
+   * 都列成"你能用的",而 `#upsellText()` 正是让免费用户"回复 /help 看现在能做什么" ——
+   * 那等于把人骗到一个他做不到的清单上,然后每次尝试都吃一次拒绝。
+   */
+  #helpText() {
+    if (this.#can("assign")) return HELP_TEXT; // 付费档:完整清单
+    const lines = [
+      "【DSH 微信通道 · 通知版】",
+      "现在能用的:",
+      "· 回数字(如 1)回执最近一条需要你拍板的消息",
+      "· /stop 中断当前会话正在跑的回合",
+      "· /status 查看绑定与推送状态",
+      "· /quiet 暂停推送(回复任意消息恢复)",
+      "· /unbind 解除微信绑定",
+      "",
+      "会员功能(开通后可用):",
+      "· 直接发一句话 = 给当前任务派活",
+      "· /new 开新任务、/ls 列出会话、/use <编号> 切换会话、/summary 重发最近结论"
+    ];
+    if (this.appUrl) lines.push("", `👉 开通并查看设备列表:${this.appUrl}`);
+    return lines.join("\n");
+  }
+
+  /**
+   * 免费用户越界时的回复:说清「通知版能做什么」+ 给出可点击的 App 链接。
+   *
+   * 业主口径:免费用户要去做别的事情时,就在消息后面跟一个访问 App 的链接,
+   * 点一下就能到我们的 App 界面 —— 这既是解释,也是把用户引回远程控制主功能的入口。
+   * ⚠️ 微信不渲染 Markdown,所以这里用「」和纯文本,不要写 `**`。
+   */
+  #upsellText() {
+    const lines = [
+      "微信机器人当前是「通知版」:",
+      "· 能收到任务通知、完成小结,以及需要你审批的请求",
+      "· 在微信里直接交代任务、切换会话属于会员功能"
+    ];
+    if (this.appUrl) {
+      lines.push("", `👉 打开 App 查看设备列表、远程控制你的电脑:${this.appUrl}`);
+    }
+    lines.push("", "回复 /help 可以看到现在能做什么。");
+    return lines.join("\n");
+  }
+
+  /**
+   * 免费档的任务收尾话术。
+   * 默认那句「回复就能接着做」对免费用户是**空头承诺**(他回复只会拿到付费引导),
+   * 所以换成"会员可用 + App 链接",把用户引到主功能上去。
+   */
+  #continuationHint() {
+    const tail = this.appUrl ? `打开 App 继续:${this.appUrl}` : "打开 App 即可继续。";
+    return `在微信里接着交代下一步属于会员功能。${tail}`;
+  }
+
   /** 指令分派。 */
   async #runCommand(from, cls) {
     const cmd = cls.command;
     const args = cls.args || "";
 
     // ★ 运营钩子:能力表在**每次派发**时真的被查 —— 它是活代码,不是文档。
-    //   今天免费档已含 assign,所以行为不变;将来把 assign 从 free 拿掉即生效。
-    if (["/new", "/use", "/stop"].includes(cmd) && !this.#can("assign")) {
-      await this.reply(from, "当前档位还不能在微信里交代任务。升级后即可使用。");
+    //   先 `#canNow` 刷新档位再判:用户刚升级完立刻重试必须能进。
+    const need = COMMAND_CAPABILITY[cmd];
+    if (need && !(await this.#canNow(need))) {
+      await this.reply(from, this.#upsellText());
       return;
     }
 
@@ -636,7 +814,11 @@ export class WeChatRuntime {
       await this.#cmdStatus(from);
       return;
     }
-    // 其余(含 /help)交给上游的通用处理 —— ⚠️ 字段是 `replyText`,不是 text。
+    if (cmd === "/help") {
+      await this.reply(from, this.#helpText());
+      return;
+    }
+    // 其余交给上游的通用处理 —— ⚠️ 字段是 `replyText`,不是 text。
     const r = handleCommand(cmd, args);
     await this.reply(from, (r && r.replyText) || "可用指令:/new /ls /use /stop /status /summary /help /quiet /unbind");
   }
@@ -983,7 +1165,7 @@ export class WeChatRuntime {
         summary,
         sessionId: sid,
         hanging: !summary
-      });
+      }, this.#can("assign") ? {} : { continuationHint: this.#continuationHint() });
       built = { text: c.text, replyable: false, eventId: "" };
     } else if (
       formatterKind === "approval" &&

package/dsh-setup.mjs

@@ -407,6 +407,36 @@ function readPidFile(name) {
   } catch { return null; }
 }
 
+/**
+ * 这个 pid 看起来**真的**是 watcher 吗？
+ *
+ * 为什么必须查:pid 文件可能过期，而 pid 会被系统**回收给无关进程**。
+ * 去重逻辑信任 `pidAlive()` 只会导致"我多退一次"（安全方向）；但监管者接管时要
+ * **主动结束**那个 pid —— 盲杀一个被回收的无关进程是事故。所以动它之前先认一下命令行。
+ */
+function looksLikeWatcher(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  const r = sh(`ps -p ${pid} -o command=`);
+  return Boolean(r.ok && /dsh-setup\.mjs/.test(r.stdout));
+}
+
+/**
+ * 去重决策（纯函数 —— 这条判断的代价很高，必须能被直接测）。
+ *
+ *   · "run"      → 没有别的守护（或就是自己），正常跑
+ *   · "takeover" → 有别的守护，但**本进程是监管者(launchd)拉起的**：请它让位，我们接管
+ *   · "yield"    → 有别的守护，本进程是手动/插件脱离进程拉起的：直接退出，避免两个 bridge
+ *                  抢同一个设备登记
+ *
+ * 为什么"被监管者拉起"必须走 takeover 而不是 yield：
+ *   KeepAlive 每次重拉都秒退 → 监管者判为崩溃并节流 → 插件的自愈认定"服务坏了"→
+ *   bootout 摘掉作业（入口判定成立时连 plist 一起删）→ **自启动彻底消失**（真机实测）。
+ */
+function dedupDecision({ existingPid = null, selfPid = 0, supervisor = "" } = {}) {
+  if (!existingPid || existingPid === selfPid) return "run";
+  return supervisor ? "takeover" : "yield";
+}
+
 function pidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; }
@@ -958,12 +988,37 @@ function loginRateLimitUntil() {
 // ---------- run：前台跑 bridge（带配置 + 自启动 watcher） ----------
 async function runBridge() {
   // 去重（所有平台）：自启动服务、登录任务、插件半的脱离进程兜底都可能拉起 watcher，
-  // 两个 bridge 会抢同一个设备登记 → 以 pid 文件为准，已有守护在跑就直接退出。
+  // 两个 bridge 会抢同一个设备登记 → 以 pid 文件为准。
+  //
+  // ⚠️ 但**被监管者（launchd）拉起的那个实例绝不能再"直接退出"**。
+  //    真机实测的后果链：KeepAlive 每次重拉 → 本进程秒退 → 监管者判为崩溃并节流
+  //    （`launchctl print` 显示 `state = spawn scheduled`）→ 插件的自愈据此认定"服务坏了"
+  //    → `bootout` 摘掉作业（入口判定成立时连 plist 一起删）→
+  //    **自启动彻底消失，连 `launchctl kickstart` 都报"域里找不到该服务"**，
+  //    只剩插件面板的「启动」能救回来。
+  //    被监管者拉起 = 我们才是那个该活下来的实例 → 请游离实例让位，然后接管。
   {
     const other = readPidFile(WATCHER_PID_FILE);
     if (other && other !== process.pid && pidAlive(other)) {
-      console.log(`[dsh-remote] 已有一个 bridge 守护在运行（pid=${other}），本进程直接退出，避免重复实例。`);
-      return;
+      const supervisor = String(process.env.XPC_SERVICE_NAME || "");
+      const decision = dedupDecision({ existingPid: other, selfPid: process.pid, supervisor });
+      if (decision === "takeover") {
+        console.log(`[dsh-remote] 检测到游离守护（pid=${other}）——本进程由 ${supervisor} 监管，请它让位后接管。`);
+        // ⚠️ pid 可能已被系统回收给无关进程：必须确认它**真的**是 watcher 才敢动它，
+        //    否则宁可当作过期 pid 直接接管（下面 writePidFile 会覆盖掉）。
+        if (looksLikeWatcher(other)) {
+          try { process.kill(other, "SIGTERM"); } catch { /* 已退出 */ }
+          // 等它自己退（它的退出钩子会清理 pid 文件并停掉它的 bridge）。最多 5 秒 ——
+          // 不能等太久，否则监管者又看到一次"迟迟没起来"。
+          const deadline = Date.now() + 5000;
+          while (Date.now() < deadline && pidAlive(other)) sleepSync(100);
+          if (pidAlive(other)) { try { process.kill(other, "SIGKILL"); } catch { /* 已退出 */ } }
+        }
+        writePidFile(WATCHER_PID_FILE, process.pid);
+      } else {
+        console.log(`[dsh-remote] 已有一个 bridge 守护在运行（pid=${other}），本进程直接退出，避免重复实例。`);
+        return;
+      }
     }
   }
   let cfg = loadConfig();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.10-beta.2",
+  "version": "0.6.10-beta.6",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",

package/packages/dsh-remote-web/lib/client.js

@@ -4442,15 +4442,18 @@ window.__ModuleLoader__.load({
 
       // ── 首屏「这功能是干什么用的」导览（业主口径：先讲清用途，它就是绑定的理由） ──────────
       // 位置：内嵌内容体的**最上面**，在「连接微信机器人」按钮之前（DOM 顺序也一样）——
-      // 第一次进来的人先看懂用途，再决定要不要绑。三行 + 一行小标题，紧凑小字，
+      // 第一次进来的人先看懂用途，再决定要不要绑。紧凑小字，
       // 不会把连接按钮挤出首屏（见 .dru-wx-intro 的样式注释）。
-      // 只讲**产品真的会做的事**（推送 / 回数字拍板 / 微信里交代任务），不写承诺以外的话。
+      // 只讲**产品真的会做的事**，且必须**按档位如实分层**：
+      // 免费档只能收通知 + 回数字拍板，「在微信里交代任务」是会员能力 ——
+      // 在面板里含糊其辞，用户绑完去微信发句话拿到付费提示，只会觉得产品骗人。
       // 已绑定态同样保留：它是常驻的用途说明（不是一次性引导气泡），不占用任何按钮。
       var intro = h("div", { className: "dru-wx-intro", role: "note", "aria-label": "微信机器人通道能做什么" },
         h("div", { className: "dru-wx-intro-title" }, "绑定后能做什么"),
         h("div", { className: "dru-wx-intro-row" }, "· 任务完成 / 出错 / 停下时**推送**到微信 —— 不用守着电脑。"),
         h("div", { className: "dru-wx-intro-row" }, "· 需要你拍板时，在微信里**回一个数字**就完成决定（放行 / 拒绝 / 选哪个）。"),
-        h("div", { className: "dru-wx-intro-row" }, "· 也可以**直接在微信里交代任务**，并对同一个任务继续追问。")
+        h("div", { className: "dru-wx-intro-row" }, "· 以上两项**免费用**。"),
+        h("div", { className: "dru-wx-intro-row" }, "· **会员**：还能直接在微信里交代任务、切换会话，并对同一个任务继续追问。")
       );
 
       if (loading && !wx && !fail) {

package/packages/dsh-remote-web/lib/index.js

@@ -90,6 +90,20 @@ const DEFAULT_API = String(process.env.DSH_RELAY_DEFAULT_API || "").trim()
   || "https://n.risegao.cn:13443/relay-api";
 const DEFAULT_APP_URL = "https://n.risegao.cn:13443/app/";
 
+/**
+ * 自启动服务（launchd plist / systemd unit）与子进程使用的 PATH。
+ *
+ * ⚠️ **必须含 `/usr/sbin` 与 `/sbin`**：它们是系统管理命令所在目录（`ioreg`、`sysctl`…），
+ *    而 bridge 会用这些命令探测本机信息。
+ *    真机实证（2026-09-22）：本文件此前**硬编码**了不含 `/usr/sbin` 的 PATH，而插件每次
+ *    自愈/启动都会重写 plist —— 于是它覆盖掉了 dsh-setup.mjs 里那份**正确**的 SERVICE_PATH，
+ *    结果 bridge 日志里刷 `/bin/sh: ioreg: command not found`，机器指纹静默退化成
+ *    hostname 哈希（用户改一次主机名就被当成新设备）。
+ * ⚠️ 与 `dsh-setup.mjs` 的 `SERVICE_PATH` **必须一致** —— 两处都会写同一个 plist，
+ *    谁写谁说了算；有测试锁死这条一致性（跨文件不变量）。
+ */
+const SERVICE_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+
 /**
  * 把文件权限收紧到「只有本人可读写」。
  *
@@ -226,7 +240,9 @@ function spawnEnv(extra) {
   // PATH 分隔符必须按平台取（Windows 是 ";"，POSIX 是 ":"）：写死 ":" 会把整条 PATH
   // 在 Windows 上拼成一个不存在的路径，node/npx 全部找不到。
   // 追加的 POSIX 目录只在类 Unix 上有意义，Windows 上不追加。
-  const posixDirs = isWindows() ? [] : ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin"];
+  // 含 /usr/sbin 与 /sbin：插件用 spawnEnv 拉起的是 watcher，它会再拉起 bridge，
+  // 而 bridge 要用 ioreg 之类系统命令（缺了它 → 机器指纹静默退化，见 SERVICE_PATH 注释）。
+  const posixDirs = isWindows() ? [] : ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
   const PATH = [nodeDir, base, ...posixDirs].filter(Boolean).join(delimiter);
   return { ...process.env, PATH, ...(extra || {}) };
 }
@@ -1007,7 +1023,18 @@ function ensureRuntime(relayDir) {
   }
 }
 
-/** 生成 plist（与 dsh-setup.mjs writeAutostartFile 同构），返回路径。 */
+/**
+ * 生成 plist（与 dsh-setup.mjs 的 writeAutostartFile **必须同构**），返回路径。
+ *
+ * ⚠️ 两份模板历史上漂移过、并因此各造成一个真机事故（插件每次自愈/启动都会重写 plist，
+ *    所以**插件这份谁写谁说了算**，漂移等于把安装器那份正确的覆盖掉）：
+ *   · 漏 `/usr/sbin`、`/sbin`（SERVICE_PATH）→ bridge 找不到 `ioreg` → 机器指纹静默退化成
+ *     hostname 哈希（改一次主机名就被当成新设备）；
+ *   · 漏 `LimitLoadToSessionType` → `bootstrap user/<uid>` 失败（rc=5）→ 域阶梯回退到
+ *     gui/<uid>，而 macOS 26 上 gui 域是 on-demand-only、`RunAtLoad`/`KeepAlive` 失效 →
+ *     **服务被系统（BTM）回收后再也回不来**，只能手动点面板「启动」。
+ *   两者都由 launchd-domain.test.mjs 的跨文件不变量锁死。
+ */
 function writeAutostartFile(relayDir) {
   const plistPath = launchAgentPath();
   if (!plistPath) return null;
@@ -1021,9 +1048,10 @@ function writeAutostartFile(relayDir) {
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
   <key>ThrottleInterval</key><integer>10</integer>
+  <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string><key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string><key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string></dict>
 </dict></plist>`;
   mkdirSync(dirname(plistPath), { recursive: true });
   writeFileSync(plistPath, plist, { mode: 0o644 });
@@ -2453,7 +2481,7 @@ const PLUGIN_ID = "dsh-remote-web";
 const PLUGIN_LEGACY_IDS = ["dsh-remote-ui"];
 const PLUGIN_ALL_IDS = [PLUGIN_ID, ...PLUGIN_LEGACY_IDS];
 /** 插件自身发布版本（与 dsh-remote 根包同步递增）。 */
-const PLUGIN_VERSION = "0.6.10-beta.2";
+const PLUGIN_VERSION = "0.6.10-beta.6";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.10-beta.2",
+  "version": "0.6.10-beta.6",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/packages/dsh-remote-web/test/launchd-domain.test.mjs

@@ -24,6 +24,8 @@ import { dirname, join } from "node:path";
 
 const SETUP = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "dsh-setup.mjs");
 const src = readFileSync(SETUP, "utf8");
+/** 插件半边也会写同一份 plist —— 两份模板必须一致（谁写谁说了算）。 */
+const INDEX_SRC = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "lib", "index.js"), "utf8");
 
 test("launchd 修复：plist 必须带 LimitLoadToSessionType（user domain 的必要条件）", () => {
   assert.match(
@@ -34,6 +36,16 @@ test("launchd 修复：plist 必须带 LimitLoadToSessionType（user domain 的
   // RunAtLoad / KeepAlive 仍需保留：user domain 下它们才真正生效
   assert.match(src, /<key>RunAtLoad<\/key><true\/>/, "RunAtLoad 不能删（user domain 下靠它开机自启）");
   assert.match(src, /<key>KeepAlive<\/key><true\/>/, "KeepAlive 不能删（user domain 下靠它崩溃自愈）");
+  // ★ 插件那份模板**也**必须有：它每次自愈/启动都会重写 plist（谁写谁说了算）。
+  //   真机实证 2026-09-22：插件模板漏了它 → bootstrap user/<uid> 失败 → 回退 gui/<uid> →
+  //   macOS 26 上该域 on-demand-only、KeepAlive 失效 → 服务被系统回收后再也回不来，
+  //   现场表现就是「自启动服务偶尔整个消失，连 kickstart 都报域里找不到该服务」。
+  assert.match(
+    INDEX_SRC,
+    /<key>LimitLoadToSessionType<\/key><array><string>Aqua<\/string><string>Background<\/string><\/array>/,
+    "★插件半边的 plist 模板也必须有 LimitLoadToSessionType（否则它会覆盖掉安装器那份正确的）"
+  );
+  assert.match(INDEX_SRC, /<key>KeepAlive<\/key><true\/>/, "插件模板也要保留 KeepAlive");
 });
 
 test("launchd 修复：启动走 user → gui 阶梯，且每次都 kickstart", () => {
@@ -76,3 +88,50 @@ test("launchd 修复：服务 PATH 必须含 /usr/sbin 与 /sbin（否则 ioreg
   assert.ok(/\$\{SERVICE_PATH\}/.test(src), "plist/systemd 应使用 SERVICE_PATH 常量");
   assert.ok(!/Environment=PATH=\/usr\/local\/bin:\/usr\/bin:\/bin/.test(src), "systemd unit 不应再写死旧 PATH");
 });
+
+test("★ 两份 plist 模板的 PATH 必须一致（插件那份曾漏掉 /usr/sbin，覆盖掉正确的那份）", () => {
+  // 真机实证（2026-09-22）：插件半边在 plist 模板里**硬编码**了不含 /usr/sbin 的 PATH，
+  // 而它每次自愈/启动都会重写 plist → 覆盖掉 dsh-setup.mjs 里正确的那份 →
+  // bridge 日志刷 `/bin/sh: ioreg: command not found` → 机器指纹静默退化成 hostname 哈希。
+  const setupPath = /const SERVICE_PATH = "([^"]+)"/.exec(src);
+  const pluginPath = /const SERVICE_PATH = "([^"]+)"/.exec(INDEX_SRC);
+  assert.ok(setupPath, "dsh-setup.mjs 应定义 SERVICE_PATH");
+  assert.ok(pluginPath, "插件半边也必须定义 SERVICE_PATH（它也会写 plist）");
+  assert.equal(pluginPath[1], setupPath[1], "★两处 PATH 必须逐字一致：同一个 plist 谁写谁说了算");
+
+  // 插件写 plist 时必须用它，不能再硬编码
+  assert.ok(/\$\{SERVICE_PATH\}/.test(INDEX_SRC), "插件的 plist 模板必须使用 SERVICE_PATH");
+  assert.ok(!/<key>PATH<\/key><string>\/usr\/local\/bin:\/opt\/homebrew\/bin:\/usr\/bin:\/bin<\/string>/.test(INDEX_SRC),
+    "插件不得再硬编码不含 /usr/sbin 的 PATH");
+  // spawnEnv 拉起的是 watcher → 它会再拉起 bridge → 也必须能用到系统管理命令
+  for (const dir of ["/usr/sbin", "/sbin"]) {
+    assert.ok(INDEX_SRC.includes(`"${dir}"`), `spawnEnv 的 posixDirs 也应含 ${dir}`);
+  }
+});
+
+test("★ 被监管者(launchd)拉起的实例不得因『已有游离守护』而秒退", () => {
+  // 真机事故链：KeepAlive 重拉 → 本进程发现 pid 文件里已有游离守护 → 秒退
+  //   → 监管者判为崩溃并节流（`launchctl print` = `state = spawn scheduled`）
+  //   → 插件自愈认定"服务坏了" → bootout 摘作业（入口判定成立时连 plist 一起删）
+  //   → **自启动彻底消失，`launchctl kickstart` 报"域里找不到该服务"**。
+  const from = src.indexOf("function dedupDecision(");
+  assert.ok(from > -1, "应能找到 dedupDecision");
+  const body = src.slice(from, src.indexOf("function writeWindowsTask("));
+  assert.ok(body.length > 0, "切片边界应正确");
+  const decide = new Function(`${body}\nreturn dedupDecision;`)();
+
+  assert.equal(decide({ existingPid: 123, selfPid: 456, supervisor: "com.dshremote.bridge" }), "takeover",
+    "★被监管者拉起时必须接管，绝不能退出（否则自启动会被监管者与自愈联手摘掉）");
+  assert.equal(decide({ existingPid: 123, selfPid: 456, supervisor: "" }), "yield",
+    "手动/插件脱离进程拉起时仍必须让位（两个 bridge 会抢同一设备登记）");
+  assert.equal(decide({ existingPid: 0, selfPid: 456, supervisor: "" }), "run", "没有别的守护 → 正常跑");
+  assert.equal(decide({ existingPid: 456, selfPid: 456, supervisor: "" }), "run", "pid 就是自己 → 正常跑");
+  assert.equal(decide({ existingPid: null, selfPid: 456, supervisor: "" }), "run");
+
+  // 接管路径的接线：判据用监管者注入的 XPC_SERVICE_NAME；动那个 pid 之前必须先认命令行
+  const rb = src.slice(src.indexOf("async function runBridge()"), src.indexOf("// ---------- setup"));
+  assert.ok(rb.length > 0, "应能切出 runBridge");
+  assert.match(rb, /XPC_SERVICE_NAME/, "必须用监管者注入的 XPC_SERVICE_NAME 作判据");
+  assert.match(rb, /looksLikeWatcher\(other\)/, "★接管前必须确认那个 pid 真的是 watcher（pid 会被回收给无关进程）");
+  assert.match(rb, /dedupDecision\(/, "决策必须走 dedupDecision（保证被判为活代码且可测）");
+});

package/packages/dsh-remote-web/test/wechat-bot-ui.test.mjs

@@ -498,6 +498,10 @@ test("首屏导览：未绑定时就在最上面（DOM 顺序在「连接微信
   assert.ok(textHas(intro, "拍板"), "② 要交代这是需要你拍板的时刻");
   assert.ok(textHas(intro, "交代任务"), "③ 要明说可以**直接在微信里交代任务**");
   assert.ok(textHas(intro, "追问"), "③ 要明说可以对同一个任务继续追问");
+  // ★ 分层必须如实写在面板上：「交代任务/追问」是会员能力，免费档只有推送与回数字。
+  //   面板里含糊其辞 → 用户绑完去微信发句话拿到付费提示 → 只会觉得产品骗人。
+  assert.ok(textHas(intro, "免费用"), "必须写明哪两项是免费的");
+  assert.ok(textHas(intro, "会员"), "必须写明「交代任务/切换会话」属于会员能力（不能含糊）");
 
   // DOM 顺序：导览在「连接微信机器人」按钮之前（用户先看懂用途，再看到按钮）
   const introAt = domIndex(tree, (n) => n.props?.className === "dru-wx-intro");