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

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

@@ -3107,7 +3107,13 @@ function startImBots() {
       // 订阅器要连的本机 dsh web：传取值器，宿主换端口时下一次重连能跟上
       botOptions: {
         upstream: () => currentUpstreamForChannel(),
-        cookie: harnessCookieOf
+        cookie: harnessCookieOf,
+        // 会员判定（2026-11-07 业主拍板：通知免费 / 审批免费 / 互动半阉割）：
+        // 直接复用微信通道那份档位解析（/api/me → 服务端权益包，含 caps/limits/rev），
+        // 拿不到就由 wecom-bot 按 free fail-closed 处理。
+        capsProvider: resolveWechatTier,
+        // 免费用户越界时的转化入口（与微信通道同一个 App 地址；wecom-bot 拼 /app/promo）
+        appUrl: wechatAppUrl()
       },
       // 企微审批卡片点按钮 → 与手机拍板同一条路（协调器 → DSH 回执）；失败返回 {ok:false} 让卡片显示"没送达"
       onApprovalDecision: (requestId, decision) => applyApprovalDecision(requestId, decision),

package/clients/dsh-remote/im-format.mjs

@@ -0,0 +1,372 @@
+/**
+ * im-format — **通道感知的消息格式化**（2026-11-08 业主反馈「企微/飞书推回来的表格都是乱的」）。
+ *
+ * 背景
+ * -----------------------------------------------------------------
+ * agent 的最终回答常带 Markdown 表格（`| a | b |`）、标题、引用、任务列表…… 而企业微信 / 钉钉的
+ * markdown **不支持表格**：原样发出去就是一堆竖线，用户看到的就是「乱」。不同 IM 通道的能力也不同
+ * （企微/钉钉支持 markdown 子集；飞书 markdown 能力弱、卡片强；个人微信机器人有自己的一套特殊格式），
+ * 所以"发之前按通道能力适配一次"应该是一个**独立的、可单测的纯函数模块**，而不是散在 wecom-bot 里。
+ *
+ * 用法
+ * -----------------------------------------------------------------
+ * ```js
+ * import { formatForChannel, CHANNEL_CAPS } from "./im-format.mjs";
+ * const text = formatForChannel("wecom", { title: "", text: agentAnswer });
+ * ```
+ * 规则（确定性、可测，见 formatForChannel 注释）：
+ *   · 表格 → 「• 列1：值1 · 列2：值2」多行（列多/超宽时按「• 记录 N」+ 每列一行拆开）
+ *   · `#` 标题 → 加粗（markdown 通道）/ 纯文本
+ *   · `---` 分隔线 → 空行；`>` 引用 → `› `；`- [ ]` / `- [x]` → `☐` / `☑`；嵌套列表压平一层
+ *   · 代码块**原样保留**；inline code / bold / 链接不动（企微 markdown 支持）
+ *   · wecom 默认按 **4096 字节（UTF-8）** 截断，优先在段落/行边界，附「…(已截断，完整内容看电脑)」
+ *   · `wechat` 走现有特殊格式（本模块只做 **plain 兜底**，不重复实现微信那套富文本）
+ *   · 未知通道 → `plain`（fail-safe：宁可少用格式，也不发坏的 markdown）
+ */
+
+/** 各通道能力（钉钉/飞书实现时直接复用；wechat = 现有特殊格式，不经本模块排版）。 */
+export const CHANNEL_CAPS = Object.freeze({
+  wecom: Object.freeze({ markdown: true, tables: false, card: true }),
+  dingtalk: Object.freeze({ markdown: true, tables: false, card: true }),
+  feishu: Object.freeze({ markdown: false, tables: false, card: true }),
+  wechat: Object.freeze({ markdown: false, special: true }),
+  plain: Object.freeze({ markdown: false })
+});
+
+/** 截断提示（与 wecom-bot 的 ANSWER_TRUNCATED_NOTE 同文，便于去重）。 */
+export const TRUNCATED_NOTE = "…(已截断，完整内容看电脑)";
+
+/** 各通道默认字节上限（wecom 官方 4096；其它先给宽松值，留 maxBytes 覆盖）。 */
+const DEFAULT_MAX_BYTES = Object.freeze({
+  wecom: 4096,
+  dingtalk: 4096,
+  feishu: 8192,
+  wechat: Infinity,
+  plain: Infinity
+});
+
+/** UTF-8 字节数（中文 3 字节；emoji 4 字节）。 */
+export function utf8Bytes(value) {
+  try {
+    return Buffer.byteLength(String(value == null ? "" : value), "utf8");
+  } catch {
+    return String(value == null ? "" : value).length * 3;
+  }
+}
+
+/** 终端/聊天窗口的显示宽度（CJK 与 emoji 记 2 列；只用于"这行会不会太宽"的确定性判断）。 */
+export function displayWidth(value) {
+  let width = 0;
+  for (const ch of String(value == null ? "" : value)) {
+    const cp = ch.codePointAt(0) || 0;
+    const wide = cp === 0x2329 || cp === 0x232a
+      || (cp >= 0x1100 && cp <= 0x115f)
+      || (cp >= 0x2e80 && cp <= 0xa4cf)
+      || (cp >= 0xac00 && cp <= 0xd7a3)
+      || (cp >= 0xf900 && cp <= 0xfaff)
+      || (cp >= 0xfe30 && cp <= 0xfe4f)
+      || (cp >= 0xff00 && cp <= 0xff60)
+      || (cp >= 0xffe0 && cp <= 0xffe6)
+      || (cp >= 0x1f300 && cp <= 0x1f64f)
+      || (cp >= 0x1f900 && cp <= 0x1f9ff)
+      || (cp >= 0x20000 && cp <= 0x3fffd);
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+
+/** 通道名规范化：未知/空 → `plain`（fail-safe）。 */
+export function normalizeChannelName(channel) {
+  const name = String(channel || "").trim().toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(CHANNEL_CAPS, name)) return name;
+  // 常见别名（调用方拼错/叫法不同时不至于掉进 markdown 分支）
+  if (name === "weixin" || name === "wx" || name === "wechat-bot" || name === "personal") return "wechat";
+  if (name === "workbench" || name === "wxwork" || name === "qywx" || name === "wecom-bot") return "wecom";
+  if (name === "ding" || name === "dingding") return "dingtalk";
+  if (name === "lark") return "feishu";
+  return "plain";
+}
+
+// ---------- Markdown 表格解析（确定性：只按未转义的 `|` 切） ----------
+
+/** 是否是表格行（以 `|` 开头且至少 2 个竖线）。 */
+function isTableLine(line) {
+  const t = String(line || "").trim();
+  if (!t.startsWith("|")) return false;
+  const count = (t.match(/\|/g) || []).length;
+  return count >= 2;
+}
+
+/** 把一行表格拆成单元格（支持 `\|` 转义；不会把转义竖线当分隔符）。 */
+export function splitTableRow(line) {
+  let s = String(line || "").trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  // 结尾的竖线是边框（`\|` 结尾不算）
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let cur = "";
+  for (let i = 0; i < s.length; i += 1) {
+    const ch = s[i];
+    if (ch === "\\" && s[i + 1] === "|") { cur += "|"; i += 1; continue; }
+    if (ch === "|") { cells.push(cur.trim()); cur = ""; continue; }
+    cur += ch;
+  }
+  cells.push(cur.trim());
+  return cells;
+}
+
+/** 分隔行（`|---|---|` / `|:--|--:|`）。 */
+function isSeparatorRow(cells) {
+  return Array.isArray(cells) && cells.length > 0 && cells.every((c) => /^:?-{1,}:?$/.test(String(c || "").trim()));
+}
+
+/**
+ * 表格 → 可读文本。
+ *
+ * 规则（写死，便于单测）：
+ *   · 每条数据行 = 「• 列1：值1 · 列2：值2 …」；
+ *   · 列数 ≤3 且整行显示宽度 ≤60 → 单行；否则拆成「• 记录 N」+ 每列一行（避免超宽/被客户端折行成乱码）；
+ *   · 表头作为**列名**逐行带上（不是另起一行表格头——用户要的是"看得懂哪列是什么"）。
+ * @param {string[]} lines 连续的表格行
+ * @returns {string[]} 转换后的行（不含 `|---`）
+ */
+export function convertMarkdownTable(lines) {
+  const rows = (Array.isArray(lines) ? lines : []).map(splitTableRow);
+  if (!rows.length) return [];
+  let header = null;
+  let dataRows = rows;
+  if (rows.length >= 2 && isSeparatorRow(rows[1])) { header = rows[0]; dataRows = rows.slice(2); }
+  else if (rows.length >= 1 && isSeparatorRow(rows[0])) { dataRows = rows.slice(1); }
+  else { header = rows[0]; dataRows = rows.slice(1); }
+  const colCount = Math.max(
+    header ? header.length : 0,
+    ...dataRows.map((r) => r.length),
+    0
+  );
+  const out = [];
+  let index = 0;
+  for (const row of dataRows) {
+    if (!row || isSeparatorRow(row)) continue;
+    index += 1;
+    const cells = [];
+    for (let c = 0; c < colCount; c += 1) {
+      const rawName = header && header[c] ? String(header[c]).trim() : "";
+      const name = rawName || `列${c + 1}`;
+      const val = row[c] == null ? "" : String(row[c]).trim();
+      if (!val) continue;
+      cells.push({ name, val });
+    }
+    if (!cells.length) continue;
+    const oneLine = cells.map((c) => `${c.name}：${c.val}`).join(" · ");
+    if (cells.length <= 3 && displayWidth(oneLine) <= 60) {
+      out.push(`• ${oneLine}`);
+      continue;
+    }
+    out.push(`• 记录 ${index}`);
+    for (const c of cells) out.push(`  ${c.name}：${c.val}`);
+  }
+  return out;
+}
+
+// ---------- 行级转换 ----------
+
+const RE_FENCE = /^\s{0,3}(```|~~~)/;
+const RE_HEADING = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const RE_HR = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const RE_QUOTE = /^\s{0,3}>\s?(.*)$/;
+const RE_TASK = /^(\s*)([-*+]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/;
+const RE_NESTED_LIST = /^(\s{2,})([-*+]|\d+\.)\s+(.*)$/;
+const RE_BULLET = /^(\s*)([-*+])\s+(.*)$/;
+
+/** 把一段"非代码块"文本按行转换（markdown 通道保留 inline 语法；非 markdown 通道降级）。 */
+function convertLines(lines, markdown) {
+  const out = [];
+  let table = [];
+  const flushTable = () => {
+    if (!table.length) return;
+    const converted = convertMarkdownTable(table);
+    if (converted.length) {
+      out.push("", ...converted, "");
+    }
+    table = [];
+  };
+  for (const rawLine of lines) {
+    const line = String(rawLine == null ? "" : rawLine);
+    if (isTableLine(line)) { table.push(line); continue; }
+    flushTable();
+    // 标题
+    const heading = RE_HEADING.exec(line);
+    if (heading) {
+      const text = heading[2].trim();
+      out.push(markdown ? `**${text}**` : text);
+      continue;
+    }
+    // 分隔线 → 空行
+    if (RE_HR.test(line)) { out.push(""); continue; }
+    // 引用
+    const quote = RE_QUOTE.exec(line);
+    if (quote) { out.push(`› ${quote[1].trim()}`); continue; }
+    // 任务列表（☐/☑，不再保留 `- [ ]`）
+    const task = RE_TASK.exec(line);
+    if (task) {
+      const done = String(task[3]).toLowerCase() === "x";
+      const box = done ? "☑" : "☐";
+      out.push(markdown ? `- ${box} ${task[4].trim()}` : `${box} ${task[4].trim()}`);
+      continue;
+    }
+    // 嵌套列表：压平一层（更深缩进统一成 2 空格 + `·`，不再出现多层缩进）
+    const nested = RE_NESTED_LIST.exec(line);
+    if (nested) { out.push(`  · ${nested[3].trim()}`); continue; }
+    // 普通列表：非 markdown 通道把 `-` 换成 `•`（markdown 通道保持）
+    const bullet = RE_BULLET.exec(line);
+    if (bullet && !markdown) { out.push(`${bullet[1]}• ${bullet[3].trim()}`); continue; }
+    out.push(markdown ? line : line.replace(/\*\*(.+?)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1"));
+  }
+  flushTable();
+  return out;
+}
+
+/** 整段 Markdown → 目标通道文本（代码块原样保留）。 */
+function convertMarkdownLike(input, markdown) {
+  const text = String(input == null ? "" : input);
+  if (!text.trim()) return "";
+  const lines = text.split("\n");
+  const out = [];
+  let code = [];
+  let inCode = false;
+  const flushCode = () => {
+    if (!code.length) return;
+    if (markdown) out.push(...code);
+    else {
+      // 非 markdown 通道：去掉围栏，内容缩进两格（保持"是代码"的观感，不出现 ```）
+      for (const line of code) {
+        if (RE_FENCE.test(line)) continue;
+        out.push(line ? `  ${line}` : "");
+      }
+    }
+    code = [];
+  };
+  let plainBuffer = [];
+  const flushPlain = () => {
+    if (!plainBuffer.length) return;
+    out.push(...convertLines(plainBuffer, markdown));
+    plainBuffer = [];
+  };
+  for (const line of lines) {
+    if (RE_FENCE.test(line)) {
+      if (!inCode) { flushPlain(); inCode = true; code = [line]; continue; }
+      code.push(line); flushCode(); inCode = false; continue;
+    }
+    if (inCode) { code.push(line); continue; }
+    plainBuffer.push(line);
+  }
+  if (inCode) flushCode(); // 未闭合的代码块也原样保留（不吞内容）
+  flushPlain();
+  // 收尾清理：行尾空格 / 连续空行压成一个 / 首尾空行去掉
+  const cleaned = [];
+  for (const line of out) {
+    const trimmedRight = String(line).replace(/[ \t]+$/, "");
+    if (trimmedRight === "" && (cleaned.length === 0 || cleaned[cleaned.length - 1] === "")) continue;
+    cleaned.push(trimmedRight);
+  }
+  while (cleaned.length && cleaned[cleaned.length - 1] === "") cleaned.pop();
+  return cleaned.join("\n");
+}
+
+// ---------- 截断（按 UTF-8 字节 / 字符，优先段落边界） ----------
+
+function fitsBoth(value, maxBytes, maxChars) {
+  if (utf8Bytes(value) > maxBytes) return false;
+  if (maxChars !== Infinity && [...String(value)].length > maxChars) return false;
+  return true;
+}
+
+/**
+ * 安全截断：优先整段 → 整行 → 逐码点；绝不切在 UTF-8 中间（用 `for...of` 按码点累加）。
+ * 结果末尾附 `suffix`（调用方保证 suffix 也计入上限）。
+ * @returns {string}
+ */
+export function truncateUtf8Safe(text, { maxBytes = Infinity, maxChars = Infinity, suffix = TRUNCATED_NOTE } = {}) {
+  const body = String(text == null ? "" : text);
+  if (fitsBoth(body, maxBytes, maxChars)) return body;
+  const tail = `\n${suffix}`;
+  const budgetBytes = maxBytes - utf8Bytes(tail);
+  const budgetChars = maxChars === Infinity ? Infinity : maxChars - [...tail].length;
+  if (budgetBytes <= 0 || (budgetChars !== Infinity && budgetChars <= 0)) return suffix;
+  // ① 段落
+  let out = "";
+  for (const para of body.split(/\n{2,}/)) {
+    const cand = out ? `${out}\n\n${para}` : para;
+    if (!fitsBoth(cand, budgetBytes, budgetChars)) break;
+    out = cand;
+  }
+  // ② 行
+  if (!out) {
+    for (const line of body.split("\n")) {
+      const cand = out ? `${out}\n${line}` : line;
+      if (!fitsBoth(cand, budgetBytes, budgetChars)) break;
+      out = cand;
+    }
+  }
+  // ③ 逐码点（不会切坏代理对/中文）
+  if (!out) {
+    for (const ch of body) {
+      const cand = out + ch;
+      if (!fitsBoth(cand, budgetBytes, budgetChars)) break;
+      out = cand;
+    }
+  }
+  return `${out.replace(/[ \t]+$/, "")}${tail}`;
+}
+
+// ---------- 对外主函数 ----------
+
+/**
+ * 按通道能力格式化消息。
+ *
+ * 支持的选项：
+ *   · `text`      正文（Markdown 源码）
+ *   · `title`     可选标题（会作为加粗/纯文本首行；正文里的 `#` 标题也会各自转换）
+ *   · `kind`      预留：目前不影响输出（钉钉/飞书将来可按 kind 分样式）
+ *   · `maxChars`  字符上限（可选）
+ *   · `maxBytes`  字节上限（默认按通道：wecom/dingtalk 4096；feishu 8192；plain/wechat 不限）
+ *
+ * @param {"wecom"|"dingtalk"|"feishu"|"wechat"|"plain"|string} channel
+ * @param {{title?:string, text?:string, kind?:string, maxChars?:number, maxBytes?:number}} [options]
+ * @returns {string}
+ */
+export function formatForChannel(channel, options = {}) {
+  const name = normalizeChannelName(channel);
+  const caps = CHANNEL_CAPS[name] || CHANNEL_CAPS.plain;
+  const markdown = caps.markdown === true;
+  const rawText = String(options.text == null ? "" : options.text);
+  const maxBytes = Number.isFinite(Number(options.maxBytes)) && Number(options.maxBytes) > 0
+    ? Number(options.maxBytes) : DEFAULT_MAX_BYTES[name];
+  const maxChars = Number.isFinite(Number(options.maxChars)) && Number(options.maxChars) > 0
+    ? Number(options.maxChars) : Infinity;
+
+  // 调用方可能已经自己截断过并附了 suffix（wecom-bot 的回答回传会先按字符截 1500）：
+  // 先摘掉，统一由本模块决定是否需要再按字节截，避免出现两个「已截断」。
+  let preTruncated = false;
+  let bodyText = rawText;
+  if (bodyText.endsWith(TRUNCATED_NOTE)) {
+    preTruncated = true;
+    bodyText = bodyText.slice(0, -TRUNCATED_NOTE.length);
+  }
+
+  let body = convertMarkdownLike(bodyText, markdown);
+  const title = String(options.title == null ? "" : options.title).trim();
+  if (title) {
+    const titleLine = markdown ? `**${title}**` : title;
+    body = body ? `${titleLine}\n\n${body}` : titleLine;
+  }
+  // 微信通道有其自己的特殊格式（wechat-runtime 负责）：这里只做 plain 兜底，且不截断（由微信侧管）。
+  if (name === "wechat") return body;
+
+  const fitted = truncateUtf8Safe(body, { maxBytes, maxChars, suffix: TRUNCATED_NOTE });
+  if (fitted === body) {
+    // 原本就在上限内：如果调用方已标过截断，保留它的提示（不要悄悄丢掉；保持原样拼接）
+    return preTruncated ? `${body}${TRUNCATED_NOTE}` : body;
+  }
+  return fitted;
+}

package/clients/dsh-remote/test/im-format.test.mjs

@@ -0,0 +1,229 @@
+/**
+ * im-format — 通道感知消息格式化单测（2026-11-08 业主反馈「企微/飞书推回来的表格都是乱的」）。
+ *
+ * 只测**纯函数**（不连网、不起进程）：表格→可读列表、标题/引用/分隔线/任务列表/嵌套列表、
+ * 代码块原样保留、UTF-8 字节截断（4096，优先段落边界、绝不切坏中文）、各通道分支。
+ *
+ * 接入测（wecom-bot 发出的报文里没有裸表格）在 wecom-bot.test.mjs 里。
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  CHANNEL_CAPS,
+  TRUNCATED_NOTE,
+  convertMarkdownTable,
+  displayWidth,
+  formatForChannel,
+  normalizeChannelName,
+  splitTableRow,
+  truncateUtf8Safe,
+  utf8Bytes
+} from "../im-format.mjs";
+
+const fmt = (text, opts = {}) => formatForChannel("wecom", { text, ...opts });
+
+/** 展示用：断言"没有裸表格"（分隔行 / 行首竖线表格）。 */
+const hasRawTable = (s) => /\|\s*-{2,}/.test(s) || /^\s*\|.*\|\s*$/m.test(s);
+
+// ─────────────────────────── 通道能力表 ───────────────────────────
+
+test("CHANNEL_CAPS：企微/钉钉 markdown 无表格、飞书无 markdown、微信特殊格式、plain 兜底", () => {
+  assert.deepEqual(CHANNEL_CAPS.wecom, { markdown: true, tables: false, card: true });
+  assert.deepEqual(CHANNEL_CAPS.dingtalk, { markdown: true, tables: false, card: true });
+  assert.deepEqual(CHANNEL_CAPS.feishu, { markdown: false, tables: false, card: true });
+  assert.deepEqual(CHANNEL_CAPS.wechat, { markdown: false, special: true });
+  assert.deepEqual(CHANNEL_CAPS.plain, { markdown: false });
+  // 通道别名与未知通道
+  assert.equal(normalizeChannelName("wxwork"), "wecom");
+  assert.equal(normalizeChannelName("Lark"), "feishu");
+  assert.equal(normalizeChannelName("dingding"), "dingtalk");
+  assert.equal(normalizeChannelName("weixin"), "wechat");
+  assert.equal(normalizeChannelName("something-else"), "plain");
+  assert.equal(normalizeChannelName(""), "plain");
+});
+
+// ─────────────────────────── 表格 ───────────────────────────
+
+test("★ 表格 → 可读列表（2 列中文）：不含 |---，每条记录一行「• 列：值」", () => {
+  const md = [
+    "查询结果如下：",
+    "",
+    "| 姓名 | 年龄 |",
+    "|---|---|",
+    "| 张三 | 30 |",
+    "| 李四 | 25 |",
+    "",
+    "以上。"
+  ].join("\n");
+  const out = fmt(md);
+  assert.ok(!out.includes("|---"), "★ 不得残留表格分隔行");
+  assert.ok(!hasRawTable(out), "★ 不得残留裸表格");
+  assert.match(out, /^• 姓名：张三 · 年龄：30$/m);
+  assert.match(out, /^• 姓名：李四 · 年龄：25$/m);
+  assert.match(out, /查询结果如下/);
+  assert.match(out, /以上。/);
+  // 表头只作为列名出现，不额外留一行"| 姓名 | 年龄 |"
+  assert.ok(!out.includes("| 姓名 |"));
+});
+
+test("表格 1 列 / 3 列：1 列逐条「• 列：值」；3 列窄表仍单行", () => {
+  const one = fmt("| 项目 |\n|---|\n| A |\n| B |");
+  assert.deepEqual(one.split("\n"), ["• 项目：A", "• 项目：B"]);
+
+  const three = fmt("| 名称 | 数量 | 价格 |\n|---|---|---|\n| 苹果 | 2 | 5 |");
+  assert.match(three, /^• 名称：苹果 · 数量：2 · 价格：5$/m);
+});
+
+test("★ 表格 5 列（超宽）：拆成「• 记录 N」+ 每列一行，避免客户端折行成乱码", () => {
+  const md = [
+    "| 序号 | 模块 | 状态 | 负责人 | 备注 |",
+    "|---|---|---|---|---|",
+    "| 1 | 登录 | 完成 | 张三 | 已经上线验证过了 |",
+    "| 2 | 支付 | 进行中 | 李四 | 等第三方回调 |"
+  ].join("\n");
+  const out = fmt(md);
+  assert.ok(!hasRawTable(out));
+  assert.match(out, /^• 记录 1$/m);
+  assert.match(out, /^ {2}序号：1$/m);
+  assert.match(out, /^ {2}模块：登录$/m);
+  assert.match(out, /^ {2}负责人：张三$/m);
+  assert.match(out, /^• 记录 2$/m);
+  // 每行都不该太宽（拆开是为了可读；阈值 60 显示列 + 列名余量）
+  for (const line of out.split("\n")) {
+    assert.ok(displayWidth(line) <= 80, `行太宽（${displayWidth(line)}）：${line}`);
+  }
+});
+
+test("表格转义竖线：`\\|` 是单元格内容，不是分隔符", () => {
+  assert.deepEqual(splitTableRow("| a \\| b | c |"), ["a | b", "c"]);
+  const out = fmt("| 表达式 | 值 |\n|---|---|\n| a \\| b | 真 |");
+  assert.match(out, /• 表达式：a \| b · 值：真/);
+  assert.ok(!hasRawTable(out));
+});
+
+test("无分隔行 / 无表头 / 空单元格：不崩、不生造列", () => {
+  // 没有 |---| 分隔行的两行表：第一行当表头
+  const out = fmt("| k | v |\n| a | 1 |");
+  assert.match(out, /^• k：a · v：1$/m);
+  // 单元格为空 → 该列不输出
+  const sparse = convertMarkdownTable(["| a | b | c |", "|---|---|---|", "| 1 |  | 3 |"]);
+  assert.deepEqual(sparse, ["• a：1 · c：3"]);
+  // 全空行表 → 空数组（不要留空壳）
+  assert.deepEqual(convertMarkdownTable(["| a | b |", "|---|---|"]), []);
+  assert.deepEqual(convertMarkdownTable([]), []);
+});
+
+// ─────────────────────────── 标题 / 引用 / 分隔线 / 列表 ───────────────────────────
+
+test("★ 标题→加粗、引用→›、分隔线→空行、任务列表→☐/☑、嵌套列表压平一层、代码块原样保留", () => {
+  const md = [
+    "# 一级标题",
+    "## 二级标题",
+    "> 引用一句话",
+    "",
+    "---",
+    "",
+    "- [ ] 待办事项",
+    "- [x] 已完成",
+    "- 父项",
+    "  - 子项",
+    "    - 孙项",
+    "",
+    "```js",
+    "const a = 1; // 代码块里 # 和 | 都不该被转换",
+    "| not | a | table |",
+    "```"
+  ].join("\n");
+  const out = fmt(md);
+  assert.match(out, /^\*\*一级标题\*\*$/m, "标题 → 加粗");
+  assert.match(out, /^\*\*二级标题\*\*$/m);
+  assert.match(out, /^› 引用一句话$/m, "引用 → ›");
+  assert.ok(!/^-{3,}$/m.test(out), "★ 分隔线不得残留");
+  assert.match(out, /^- ☐ 待办事项$/m, "未完成 → ☐");
+  assert.match(out, /^- ☑ 已完成$/m, "已完成 → ☑");
+  assert.match(out, /^- 父项$/m);
+  assert.match(out, /^ {2}· 子项$/m, "嵌套压平成一层 ·");
+  assert.match(out, /^ {2}· 孙项$/m, "第三层也压到同一层");
+  assert.ok(out.includes("```js"), "★ 代码块围栏必须保留");
+  assert.ok(out.includes("const a = 1;"), "代码内容保留");
+  assert.ok(out.includes("| not | a | table |"), "★ 代码块里的表格语法不得被转换");
+});
+
+test("inline code / 加粗 / 链接保留（企微 markdown 支持）", () => {
+  const out = fmt("用 `npm test` 跑一下，**注意**看 [文档](https://example.com/x)。");
+  assert.equal(out, "用 `npm test` 跑一下，**注意**看 [文档](https://example.com/x)。");
+});
+
+test("非 markdown 通道（plain/feishu）降级：去掉 ** 与 `，列表换 •，代码围栏去掉", () => {
+  const md = "# 标题\n\n**重点** 和 `code`\n\n- 条目\n\n```\nplain code\n```";
+  const plain = formatForChannel("plain", { text: md });
+  assert.ok(!plain.includes("**"), "plain 不得保留加粗标记");
+  assert.ok(!plain.includes("`code`"), "plain 不得保留 inline code 标记");
+  assert.match(plain, /^• 条目$/m);
+  assert.ok(!plain.includes("```"), "plain 去掉代码围栏");
+  assert.ok(plain.includes("plain code"), "代码内容保留");
+  // feishu：markdown=false，走同一套降级
+  const feishu = formatForChannel("feishu", { text: md });
+  assert.ok(!feishu.includes("**"));
+});
+
+// ─────────────────────────── 截断 ───────────────────────────
+
+test("★ wecom 4096 字节截断：中文按字节算、优先段落边界、末尾带截断提示、不切坏 UTF-8", () => {
+  const para1 = "第一段：" + "甲".repeat(600) + "。"; // 1800+ 字节
+  const para2 = "第二段：" + "乙".repeat(600) + "。";
+  const para3 = "第三段：" + "丙".repeat(600) + "。";
+  const md = [para1, para2, para3].join("\n\n");
+  assert.ok(utf8Bytes(md) > 4096, "输入必须超过 4096 字节");
+  const out = fmt(md);
+  assert.ok(utf8Bytes(out) <= 4096, `输出必须 ≤4096 字节（实际 ${utf8Bytes(out)}）`);
+  assert.ok(out.endsWith(TRUNCATED_NOTE), "必须带「…(已截断，完整内容看电脑)」");
+  assert.ok(out.startsWith("第一段："), "保留开头");
+  assert.ok(!out.includes("第三段："), "后面的段落被截掉");
+  // 不切在 UTF-8 中间：字符串往返必须一致（出现 U+FFFD 说明切坏了）
+  assert.equal(Buffer.from(out, "utf8").toString("utf8"), out);
+  assert.ok(!out.includes("\uFFFD"));
+});
+
+test("截断：段落太大时退到行边界；单行超长时按码点切（不破坏代理对/中文）", () => {
+  // 每行都很短但整体超限 → 在行边界截断（不会出现半行）
+  const manyLines = Array.from({ length: 400 }, (_, i) => `第 ${i} 行：数据`).join("\n");
+  const out = fmt(manyLines, { maxBytes: 300 });
+  assert.ok(utf8Bytes(out) <= 300);
+  assert.ok(out.endsWith(TRUNCATED_NOTE));
+  assert.equal(Buffer.from(out, "utf8").toString("utf8"), out);
+  // 单行超长（含 emoji 4 字节）→ 逐码点截断，不产生 U+FFFD
+  const huge = "😀".repeat(2000);
+  const cut = truncateUtf8Safe(huge, { maxBytes: 100 });
+  assert.ok(utf8Bytes(cut) <= 100);
+  assert.equal(Buffer.from(cut, "utf8").toString("utf8"), cut);
+  assert.ok(!cut.includes("\uFFFD"));
+});
+
+test("maxChars 与「调用方已截断」去重：不会出现两个「已截断」", () => {
+  const out = fmt("甲".repeat(1000), { maxChars: 100 });
+  assert.ok([...out].length <= 100, "字符上限生效");
+  assert.equal((out.match(/已截断/g) || []).length, 1);
+  // 调用方自带 suffix（回答回传先按字符截 1500 + 本提示）：模块不得重复追加
+  const pre = `${"乙".repeat(1500)}${TRUNCATED_NOTE}`;
+  const out2 = fmt(pre);
+  assert.equal((out2.match(/已截断/g) || []).length, 1, "★ 不得出现两个截断提示");
+  assert.ok(out2.endsWith(TRUNCATED_NOTE));
+  // 自带 suffix 且其实没超限 → 保留原提示
+  const shortPre = `短内容${TRUNCATED_NOTE}`;
+  assert.equal(fmt(shortPre), shortPre);
+});
+
+// ─────────────────────────── wechat / 未知通道 ───────────────────────────
+
+test("wechat 分支：走现有特殊格式（本模块只做 plain 兜底、不截断）", () => {
+  const big = "| a | b |\n|---|---|\n| 1 | 2 |\n" + "内容".repeat(5000);
+  const out = formatForChannel("wechat", { text: big });
+  assert.ok(!hasRawTable(out), "兜底也不留裸表格");
+  assert.ok(!out.endsWith(TRUNCATED_NOTE), "wechat 不在这里截断（由微信通道自己管长度/格式）");
+  // 未知通道 → plain（fail-safe，不发坏 markdown）
+  const unknown = formatForChannel("mystery-channel", { text: "# 标题\n\n**粗**" });
+  assert.ok(!unknown.includes("**"));
+  assert.equal(unknown, "标题\n\n粗");
+});