aitable-workflow-cli 0.1.23 → 0.1.24

package/templates/support-qa/lib/__tests__/thread-observe-step.test.ts

@@ -1,391 +0,0 @@
-/**
- * thread 抽取的 schema 与 observe step 的门槛行为。
- *
- * 门槛顺序是本文件的重点，它决定了「哪些 thread 会白烧一次 LLM」和「哪些服务空白会被
- * 悄悄抹掉」：
- * ① 无真人响应 → 写观测列 + SLA状态，**不调 LLM**（但**不丢弃**：这类 thread 往往正是
- *    没人管的问题，丢掉就在表里看不见了）；
- * ② 观察行不存在 → 有限重试，达上限后兜底建行（bot-only thread 例外，按设计跳过）；
- * ③ 抽取失败/校验失败 → backoff 顺延，连续失败达上限才丢弃。
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  THREAD_CONTRACT_VERSION,
-  _resetDigestQueues,
-  _resetThreadStoreRegistry,
-  getThreadStore,
-  type NormalizedMessage,
-  type ThreadSnapshot,
-} from "aitable-workflow-core";
-import step from "../../workflows/thread-observer/recipes/thread_observe.recipe.js";
-import { parseThreadDigest, renderConclusion, typeToColumn } from "../thread-digest.js";
-
-const CID = "cidTEST==";
-const T0 = Date.parse("2026-08-11T09:54:00+08:00");
-const MIN = 60_000;
-
-beforeEach(() => {
-  _resetThreadStoreRegistry();
-  _resetDigestQueues();
-});
-
-// ─── schema ─────────────────────────────────────────────
-
-describe("parseThreadDigest", () => {
-  const ok = {
-    type: "kb_gap",
-    module: "表单",
-    standardQuestion: "手机端表单是否支持字段联动",
-    conclusion: "手机端暂不支持字段联动，改用表单视图。",
-    confidence: "high",
-  };
-
-  it("合法输出被接受", () => {
-    expect(parseThreadDigest(ok)?.type).toBe("kb_gap");
-  });
-
-  it("kb_gap/requirement/bug 结论为空被拒（避免表里留一行没内容的记录）", () => {
-    expect(parseThreadDigest({ ...ok, conclusion: "  " })).toBeNull();
-    expect(parseThreadDigest({ ...ok, type: "requirement", conclusion: "" })).toBeNull();
-    expect(parseThreadDigest({ ...ok, type: "bug", conclusion: "" })).toBeNull();
-  });
-
-  it("answered/chitchat 允许空结论", () => {
-    expect(parseThreadDigest({ ...ok, type: "chitchat", conclusion: "" })?.type).toBe("chitchat");
-  });
-
-  it("confidence 非 high 却不给理由被拒（「我不确定」不带理由对复核没价值）", () => {
-    expect(parseThreadDigest({ ...ok, confidence: "low" })).toBeNull();
-    expect(parseThreadDigest({ ...ok, confidence: "low", confidenceReason: "无人给出结论" })?.confidence).toBe("low");
-  });
-
-  it("非法 type 被拒，不静默透传", () => {
-    expect(parseThreadDigest({ ...ok, type: "unknown_type" })).toBeNull();
-  });
-
-  it("空数组字段不写进结果", () => {
-    const r = parseThreadDigest({ ...ok, amendments: [], evidenceMessageIds: [] });
-    expect(r && "amendments" in r).toBe(false);
-    expect(r && "evidenceMessageIds" in r).toBe(false);
-  });
-});
-
-describe("renderConclusion：amendments 合写一列但不丢", () => {
-  it("有纠正时结论与更正分段，模型不会把被推翻的说法当最终结论", () => {
-    const out = renderConclusion({
-      type: "kb_gap",
-      standardQuestion: "q",
-      conclusion: "手机端暂不支持字段联动。",
-      amendments: ["机器人早期说「在字段设置里打开」不成立。"],
-      evidenceMessageIds: ["msgC"],
-      confidence: "high",
-    });
-    expect(out).toContain("手机端暂不支持字段联动。");
-    expect(out).toContain("【过程更正】");
-    expect(out).toContain("【证据】msgC");
-  });
-
-  it("无纠正无证据时只有结论正文，不留空段落", () => {
-    expect(renderConclusion({ type: "answered", standardQuestion: "q", conclusion: "已解决。", confidence: "high" })).toBe("已解决。");
-  });
-});
-
-describe("typeToColumn", () => {
-  it("英文枚举映射成表里的中文选项，kb_gap 保留原样与主链口径对齐", () => {
-    expect(typeToColumn("kb_gap")).toBe("kb_gap");
-    expect(typeToColumn("requirement")).toBe("需求");
-    expect(typeToColumn("answered")).toBe("已答");
-    expect(typeToColumn("chitchat")).toBe("闲聊");
-  });
-});
-
-// ─── step 门槛 ───────────────────────────────────────────
-
-const CONFIG_DIR = "/tmp/observer-step-test";
-
-function message(over: Partial<NormalizedMessage> & { openMessageId: string }): NormalizedMessage {
-  return {
-    conversationId: CID,
-    groupName: "产品交流群",
-    senderName: "用户甲",
-    senderOpenDingTalkId: "openA",
-    createTime: T0,
-    content: "这单怎么还没成功",
-    images: [],
-    role: "unknown",
-    ...over,
-  };
-}
-
-/** 造一个 store 里已收敛的 thread：喂消息 → 让 step 自己 drain。 */
-function seedThread(messages: NormalizedMessage[], roster: Record<string, unknown> = {}): void {
-  const store = getThreadStore(CONFIG_DIR);
-  for (const m of messages) store.onMessage(m, roster);
-}
-
-type Updated = { recordId: string; fields: Record<string, unknown> };
-
-function makeCtx(opts: {
-  rowIds?: string[];
-  agentResponse?: string;
-  agentThrows?: boolean;
-  config?: Record<string, unknown>;
-}) {
-  const updated: Updated[] = [];
-  const created: Array<Record<string, unknown>> = [];
-  const prompts: string[] = [];
-  const logs: string[] = [];
-  const ctx = {
-    configDir: CONFIG_DIR,
-    trackerRef: { baseId: "b", tableId: "t" },
-    log: (m: string) => logs.push(m),
-    getGlobalVar: () => undefined,
-    config: {
-      bots: [{ botNick: "答疑助理" }],
-      answerers: [{ nick: "答疑甲", openDingTalkId: "openB" }],
-      module_owners: [{ module: "表单" }],
-      ...opts.config,
-    },
-    toolkit: {
-      table: {
-        findRowIds: vi.fn().mockResolvedValue(opts.rowIds ?? ["rec1"]),
-        updateRecordIn: vi.fn().mockImplementation((_ref: unknown, recordId: string, fields: Record<string, unknown>) => {
-          updated.push({ recordId, fields });
-          return Promise.resolve();
-        }),
-        createRecordIn: vi.fn().mockImplementation((_ref: unknown, fields: Record<string, unknown>) => {
-          created.push(fields);
-          return Promise.resolve({ recordId: "recNew" });
-        }),
-      },
-      coding: {
-        run: vi.fn().mockImplementation((prompt: string) => {
-          prompts.push(prompt);
-          if (opts.agentThrows) throw new Error("agent 挂了");
-          return Promise.resolve({ response: opts.agentResponse ?? "" });
-        }),
-      },
-    },
-  } as unknown as Parameters<typeof step.execute>[0];
-  return { ctx, updated, created, prompts, logs };
-}
-
-const GOOD_RESPONSE = JSON.stringify({
-  type: "kb_gap",
-  module: "表单",
-  standardQuestion: "手机端表单是否支持字段联动",
-  conclusion: "手机端暂不支持字段联动，改用表单视图。",
-  evidenceMessageIds: ["a1"],
-  confidence: "high",
-});
-
-describe("空转零成本", () => {
-  it("队列空时直接 tracker:false —— 无 LLM、无表写", async () => {
-    const { ctx, updated } = makeCtx({});
-    const r = await step.execute(ctx);
-    expect(r.tracker).toBe(false);
-    expect(updated).toHaveLength(0);
-    expect(ctx.toolkit.coding.run).not.toHaveBeenCalled();
-  });
-});
-
-describe("门槛1：无真人响应 → 写观测列但不抽取", () => {
-  it("只有用户提问的 thread：写 SLA状态=无真人响应、观察状态=skipped，不调 LLM", async () => {
-    seedThread([message({ openMessageId: "m1" })]);
-    const { ctx, updated } = makeCtx({});
-    await step.execute(ctx);
-
-    expect(ctx.toolkit.coding.run).not.toHaveBeenCalled();
-    expect(updated).toHaveLength(1);
-    const f = updated[0]!.fields;
-    expect(f["SLA状态"]).toBe("无真人响应");
-    expect(f["观察状态"]).toBe("skipped");
-    expect(f["跳过原因"]).toBe("no_answerer");
-    // 关键：行还在，服务空白没有被抹掉
-    expect(f["线程消息数"]).toBe(1);
-    expect(String(f["thread render"])).toContain("这单怎么还没成功");
-  });
-
-  it("名单缺失时 SLA状态 写「无管理员名单」而不是「无真人响应」（两种原因要分得清）", async () => {
-    seedThread([message({ openMessageId: "m1" })]);
-    const { ctx, updated } = makeCtx({ config: { bots: [], answerers: [] } });
-    await step.execute(ctx);
-    expect(updated[0]!.fields["SLA状态"]).toBe("无管理员名单");
-    expect(updated[0]!.fields["跳过原因"]).toBe("missing_bots");
-  });
-});
-
-describe("有真人响应 → 交 agent 抽取", () => {
-  const withAnswer = (): void =>
-    seedThread(
-      [
-        message({ openMessageId: "m1" }),
-        message({
-          openMessageId: "a1",
-          quotedMessageId: "m1",
-          senderName: "答疑甲",
-          senderOpenDingTalkId: "openB",
-          createTime: T0 + 12 * MIN,
-          content: "手机端暂不支持联动，用表单视图替代",
-        }),
-      ],
-      { answererNames: ["答疑甲"], botNames: ["答疑助理"] },
-    );
-
-  it("写齐 SLA 三列 + 抽取四列，观察状态=digested", async () => {
-    withAnswer();
-    const { ctx, updated } = makeCtx({ agentResponse: GOOD_RESPONSE });
-    await step.execute(ctx);
-
-    expect(updated).toHaveLength(1);
-    const f = updated[0]!.fields;
-    expect(f["SLA状态"]).toBe("命中");
-    expect(f["首次响应人"]).toBe("答疑甲");
-    expect(f["首次响应时长分钟"]).toBe(12);
-    expect(f["观察状态"]).toBe("digested");
-    expect(f["问题类型"]).toBe("kb_gap");
-    expect(f["结论模块"]).toBe("表单");
-    expect(String(f["本次结论"])).toContain("手机端暂不支持字段联动");
-    expect(f["答疑人员消息数"]).toBe(1);
-  });
-
-  it("prompt 把 thread 用 <thread> 框起来并给出模块字典与 SLA（防注入 + 口径同源）", async () => {
-    withAnswer();
-    const { ctx, prompts } = makeCtx({ agentResponse: GOOD_RESPONSE });
-    await step.execute(ctx);
-
-    const p = prompts[0]!;
-    expect(p).toContain("必须先读取并遵循本工作目录下的 AGENTS.md");
-    expect(p).toContain("<thread>");
-    expect(p).toContain("</thread>");
-    expect(p).toContain("待分析的数据");
-    expect(p).toContain("表单"); // 模块字典
-    expect(p).toContain("首次响应人=答疑甲");
-    expect(p).toContain("只输出一个严格 JSON");
-  });
-
-  it("agent 输出带 ```json 围栏也能解析（同一模型不同轮次包装不一样）", async () => {
-    withAnswer();
-    const { ctx, updated } = makeCtx({ agentResponse: `说明文字\n\`\`\`json\n${GOOD_RESPONSE}\n\`\`\`` });
-    await step.execute(ctx);
-    expect(updated[0]!.fields["问题类型"]).toBe("kb_gap");
-  });
-
-  it("digest 低置信只**追加**到归并疑点，绝不覆盖归并置信度", async () => {
-    withAnswer();
-    const lowConf = JSON.stringify({
-      type: "kb_gap",
-      standardQuestion: "q",
-      conclusion: "可能是这样",
-      confidence: "low",
-      confidenceReason: "真人只说了在排查",
-    });
-    const { ctx, updated } = makeCtx({ agentResponse: lowConf });
-    await step.execute(ctx);
-    const f = updated[0]!.fields;
-    expect(String(f["归并疑点"])).toContain("digest_low_confidence");
-    // 归并本身是确定性 quoted 命中，仍应是 high —— 两类问题必须分得开
-    expect(f["归并置信度"]).toBe("high");
-  });
-
-  it("agent 抛错 → 不写表、留在队列 backoff 重试，不丢数据", async () => {
-    withAnswer();
-    const { ctx, updated, logs } = makeCtx({ agentThrows: true });
-    const r = await step.execute(ctx);
-    expect(updated).toHaveLength(0);
-    expect(r.tracker).toBe(false);
-    expect(logs.join("\n")).toContain("agent 抽取失败");
-  });
-
-  it("输出不合 schema → 同样走失败重试，不写半截数据", async () => {
-    withAnswer();
-    const { ctx, updated, logs } = makeCtx({ agentResponse: JSON.stringify({ type: "kb_gap", conclusion: "" }) });
-    await step.execute(ctx);
-    expect(updated).toHaveLength(0);
-    expect(logs.join("\n")).toContain("校验失败");
-  });
-});
-
-describe("门槛2：观察行缺失", () => {
-  it("首次找不到行 → 保留重试，不建行也不抽取", async () => {
-    seedThread([message({ openMessageId: "m1" })]);
-    const { ctx, updated, created, logs } = makeCtx({ rowIds: [] });
-    await step.execute(ctx);
-    expect(updated).toHaveLength(0);
-    expect(created).toHaveLength(0);
-    expect(logs.join("\n")).toContain("观察行尚未建立");
-  });
-
-  it("重试达上限后兜底建行 —— 绝不让 thread 凭空消失", async () => {
-    seedThread([message({ openMessageId: "m1" })]);
-    const { ctx, created } = makeCtx({ rowIds: [], config: { max_root_retry: 1 } });
-    await step.execute(ctx); // 第 1 轮：attempts 0 → 保留
-    await step.execute(ctx); // 第 2 轮：attempts 1 已达上限 → 兜底建行
-    expect(created).toHaveLength(1);
-    expect(created[0]!["线程ID"]).toBeDefined();
-    expect(String(created[0]!["跳过原因"])).toContain("no_root_row");
-  });
-
-  it("bot-only thread 无行属正常 → 直接丢弃，不兜底建行（否则机器人自言自语变成用户问题）", async () => {
-    seedThread([message({ openMessageId: "b1", senderName: "答疑助理", role: "bot" })]);
-    const { ctx, created, logs } = makeCtx({ rowIds: [], config: { max_root_retry: 1 } });
-    await step.execute(ctx);
-    await step.execute(ctx);
-    expect(created).toHaveLength(0);
-    expect(logs.join("\n")).toContain("bot-only thread");
-  });
-});
-
-describe("每轮上限", () => {
-  it("超过 max_per_round 的 thread 留到下一轮，不拖慢当前链路", async () => {
-    // 两条各自有真人响应的 thread（引用命中确保不误合）
-    for (const [q, a] of [["q1", "a1"], ["q2", "a2"]] as const) {
-      seedThread(
-        [
-          message({ openMessageId: q, senderName: q === "q1" ? "用户甲" : "用户乙", senderOpenDingTalkId: q === "q1" ? "openA" : "openZ" }),
-          message({
-            openMessageId: a,
-            quotedMessageId: q,
-            senderName: "答疑甲",
-            senderOpenDingTalkId: "openB",
-            createTime: T0 + 5 * MIN,
-            content: "回答",
-          }),
-        ],
-        { answererNames: ["答疑甲"], botNames: ["答疑助理"] },
-      );
-    }
-    const { ctx, updated, logs } = makeCtx({ agentResponse: GOOD_RESPONSE, config: { max_per_round: 1 } });
-    await step.execute(ctx);
-    expect(updated).toHaveLength(1);
-    expect(logs.join("\n") + JSON.stringify(updated)).toBeTruthy();
-    // 第二条仍在队列，下一轮处理
-    const second = await step.execute(ctx);
-    expect(second.tracker).toBe(false);
-  });
-});
-
-describe("ThreadSnapshot 直接消费（不经 store）", () => {
-  it("snapshot 的 review 段能原样落表，供复核池筛选", () => {
-    const snap: ThreadSnapshot = {
-      contractVersion: THREAD_CONTRACT_VERSION,
-      threadId: "t-x",
-      conversationId: CID,
-      groupName: "产品交流群",
-      rootMsgId: "m1",
-      messages: [message({ openMessageId: "m1" })],
-      edges: [],
-      participants: [],
-      openedAt: T0,
-      review: {
-        reason: "same_sender_window",
-        confidence: "low",
-        warnings: ["heuristic_merge", "same_sender_window"],
-        candidateThreadIds: ["t-other"],
-        needsReview: true,
-      },
-    };
-    expect(snap.review.needsReview).toBe(true);
-    expect(snap.review.warnings.join(", ")).toBe("heuristic_merge, same_sender_window");
-  });
-});

package/templates/support-qa/lib/__tests__/thread-observer-handler.test.ts

@@ -1,274 +0,0 @@
-/**
- * Thread 观察器 handler 的行为断言。
- *
- * 四条硬口径，逐条钉死（它们是「旁路观察」这个定位的全部内容）：
- * ① **采集 ≠ 落表**：bot / answerer / 闲聊消息全都进 ThreadStore 与日志，但观察表是
- *    「一条 thread 一行」，不是一条消息一行；
- * ② **bot 开的 thread 不建行**：它不是用户问题，建行只会污染观察表；
- * ③ **不配日志目录就完全不碰文件系统**（配置即授权）；
- * ④ **归并 trace 落进复核字段**，且只在首次判定可疑时置「待复核」。
- */
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { _resetThreadStoreRegistry, threadLogFileName } from "aitable-workflow-core";
-import handler from "../../workflows/thread-observer/recipes/thread_observer_handler.recipe.js";
-
-const CID = "cidBSbNVEqwrLzTw6Pp3YqpeA==";
-const roots: string[] = [];
-
-beforeEach(() => {
-  // handler 用 per-configDir 共享单例，测试间必须重置，否则 thread 状态跨用例泄露
-  _resetThreadStoreRegistry();
-});
-
-afterEach(() => {
-  for (const r of roots.splice(0)) rmSync(r, { recursive: true, force: true });
-});
-
-function tmpRoot(): string {
-  const root = mkdtempSync(path.join(os.tmpdir(), "observer-"));
-  roots.push(root);
-  return root;
-}
-
-type Pushed = { action: string; fields: Record<string, unknown> };
-
-function makeCtx(config: Record<string, unknown>, configDir = `dir-${Math.random()}`) {
-  const pushed: Pushed[] = [];
-  const logs: string[] = [];
-  const ctx = {
-    config,
-    configDir,
-    log: (m: string) => logs.push(m),
-    pushEvent: (e: Pushed) => pushed.push(e),
-    getGlobalVar: () => undefined,
-    toolkit: { memory: { append: vi.fn() }, table: {} },
-  } as unknown as Parameters<typeof handler.create>[0];
-  return { ctx, pushed, logs };
-}
-
-/** 造一个 dingtalk_message 源形态的 event（messages 数组是关键，content 只是拼接产物）。 */
-function groupEvent(messages: Array<Record<string, unknown>>): never {
-  return {
-    type: "message_received",
-    payload: {
-      conversationId: CID,
-      messages,
-      content: messages.map((m) => String(m.content ?? "")).join("\n"),
-    },
-    timestamp: new Date().toISOString(),
-  } as never;
-}
-
-const msg = (over: Record<string, unknown>): Record<string, unknown> => ({
-  senderName: "用户甲",
-  senderOpenDingTalkId: "openA",
-  createTime: "2026-08-11T09:54:00+08:00",
-  content: "这单怎么还没成功",
-  ...over,
-});
-
-/** 读出日志行（扫全部日期目录：跨零点跑测试时写入日与消息日可能不同天）。 */
-function readLines(root: string): Array<Record<string, unknown>> {
-  const out: Array<Record<string, unknown>> = [];
-  if (!existsSync(root)) return out;
-  for (const day of readdirSync(root)) {
-    const file = path.join(root, day, threadLogFileName(CID));
-    if (!existsSync(file)) continue;
-    for (const raw of readFileSync(file, "utf8").split("\n")) {
-      if (raw.trim()) out.push(JSON.parse(raw) as Record<string, unknown>);
-    }
-  }
-  return out;
-}
-
-const ROSTER_CONFIG = {
-  bots: [{ groupId: CID, botNick: "答疑助理" }],
-  answerers: [{ nick: "答疑甲", openDingTalkId: "openB" }],
-  group_configs: [{ groupId: CID, groupName: "产品交流群" }],
-};
-
-describe("建行口径：一条 thread 一行", () => {
-  it("用户消息开 thread → 建一行，带齐溯源列", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m1" })]));
-
-    expect(pushed).toHaveLength(1);
-    const f = pushed[0]!.fields;
-    expect(pushed[0]!.action).toBe("create_record");
-    expect(String(f["线程ID"])).toMatch(/^t-/);
-    expect(f["根消息ID"]).toBe("m1");
-    expect(f["群ID"]).toBe(CID);
-    expect(f["群名"]).toBe("产品交流群");
-    expect(f["提问人"]).toBe("用户甲");
-    expect(f["用户原文"]).toBe("这单怎么还没成功");
-    expect(f["观察状态"]).toBe("open");
-    expect(f["角色判定状态"]).toBe("ok");
-    expect(f["标题"]).toBe("用户甲: 这单怎么还没成功");
-  });
-
-  it("同 thread 的后续消息不重复建行（一条 thread 一行，不是一条消息一行）", () => {
-    const { ctx, pushed } = makeCtx({ ...ROSTER_CONFIG, thread_enable_mention_merge: true });
-    const h = handler.create(ctx);
-    h.onEvent(groupEvent([msg({ messageId: "m1" })]));
-    // 引用回复：确定性归并信号，必然并入同一 thread
-    h.onEvent(
-      groupEvent([
-        msg({ messageId: "m2", quotedMessageId: "m1", senderName: "答疑甲", senderOpenDingTalkId: "openB", content: "我看看", createTime: "2026-08-11T09:57:00+08:00" }),
-      ]),
-    );
-    expect(pushed).toHaveLength(1);
-  });
-
-  it("不同用户的两个问题各建一行", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    const h = handler.create(ctx);
-    h.onEvent(groupEvent([msg({ messageId: "m1" })]));
-    h.onEvent(
-      groupEvent([msg({ messageId: "n1", senderName: "用户乙", senderOpenDingTalkId: "openZ", content: "另一个问题", createTime: "2026-08-11T10:30:00+08:00" })]),
-    );
-    expect(pushed).toHaveLength(2);
-    expect(pushed[0]!.fields["线程ID"]).not.toBe(pushed[1]!.fields["线程ID"]);
-  });
-
-  it("bot 开的 thread 只采集不建行（机器人自言自语不是用户问题）", () => {
-    const { ctx, pushed, logs } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "b1", senderName: "答疑助理", senderOpenDingTalkId: "openBot", content: "有人需要帮助吗" })]));
-    expect(pushed).toHaveLength(0);
-    expect(logs.join("\n")).toContain("只采集不建行");
-  });
-
-  it("答疑人员开的 thread 也建行（可能是他在代问或自己提问，观察表要能看到）", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(
-      groupEvent([msg({ messageId: "a1", senderName: "答疑甲", senderOpenDingTalkId: "openB", content: "我先记一下这个问题" })]),
-    );
-    expect(pushed).toHaveLength(1);
-  });
-
-  it("无 openMessageId / 空内容的消息既不进 thread 也不建行", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    const h = handler.create(ctx);
-    h.onEvent(groupEvent([msg({ content: "没有 id" })]));
-    h.onEvent(groupEvent([msg({ messageId: "m9", content: "   " })]));
-    expect(pushed).toHaveLength(0);
-  });
-});
-
-describe("归并 trace → 复核字段", () => {
-  it("高置信新建：写 reason/置信度，不置待复核", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m1" })]));
-    const f = pushed[0]!.fields;
-    expect(f["归并策略"]).toBe("new_thread");
-    expect(f["归并置信度"]).toBe("high");
-    expect(f["归并疑点"]).toBe("");
-    expect("复核状态" in f).toBe(false);
-  });
-
-  it("名单缺失 → 角色判定状态与疑点齐出，且进复核池", () => {
-    const { ctx, pushed } = makeCtx({}); // 完全不配名单，模拟首轮 config-sync 前
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m1" })]));
-    const f = pushed[0]!.fields;
-    expect(f["角色判定状态"]).toBe("missing_bots");
-    expect(String(f["归并疑点"])).toContain("missing_answerers");
-    expect(String(f["归并疑点"])).toContain("missing_bots");
-    expect(f["复核状态"]).toBe("待复核");
-    // 名单问题不该拉低归并置信度：threadId 本身没归错
-    expect(f["归并置信度"]).toBe("high");
-  });
-
-  it("引用锚点缺失 → low + 待复核（知道是回复但接不上，属漏合风险）", () => {
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m2", quotedMessageId: "从未见过的消息" })]));
-    const f = pushed[0]!.fields;
-    expect(f["归并置信度"]).toBe("low");
-    expect(String(f["归并疑点"])).toContain("quoted_parent_missing");
-    expect(f["复核状态"]).toBe("待复核");
-  });
-
-  it("启发式归并打开时，被并入的消息不会再建行，但疑点已记在 thread 上", () => {
-    // 启发式合并的消息不是新 thread，故不建行；它的 low 置信在收敛时由 step 刷进表
-    const { ctx, pushed } = makeCtx({ ...ROSTER_CONFIG, thread_enable_heuristic_merge: true });
-    const h = handler.create(ctx);
-    h.onEvent(groupEvent([msg({ messageId: "m1" })]));
-    h.onEvent(groupEvent([msg({ messageId: "m2", content: "补充一下", createTime: "2026-08-11T09:55:00+08:00" })]));
-    expect(pushed).toHaveLength(1);
-  });
-});
-
-describe("append-only 日志", () => {
-  it("bot / answerer 消息都落日志（否则 thread 永远拼不出问答对）", () => {
-    const root = tmpRoot();
-    const { ctx, pushed } = makeCtx({ ...ROSTER_CONFIG, thread_log_dir: root });
-    const h = handler.create(ctx);
-    h.onEvent(groupEvent([msg({ messageId: "m1" })]));
-    h.onEvent(groupEvent([msg({ messageId: "b1", senderName: "答疑助理", content: "已收到", createTime: "2026-08-11T09:55:00+08:00" })]));
-    h.onEvent(
-      groupEvent([msg({ messageId: "a1", senderName: "答疑甲", senderOpenDingTalkId: "openB", content: "我看看", createTime: "2026-08-11T09:56:00+08:00" })]),
-    );
-
-    const lines = readLines(root);
-    expect(lines.map((l) => l.identity)).toEqual(["user", "bot", "answerer"]);
-    // 但只有 user 与 answerer 开的 thread 建了行，bot 那条没有
-    expect(pushed).toHaveLength(2);
-  });
-
-  it("日志逐条落盘并带 threadId 与引用关系，便于离线比对归并结果", () => {
-    const root = tmpRoot();
-    const { ctx } = makeCtx({ ...ROSTER_CONFIG, thread_log_dir: root });
-    handler.create(ctx).onEvent(
-      groupEvent([
-        msg({ messageId: "m1" }),
-        msg({ messageId: "m2", quotedMessageId: "m1", content: "有备注的", createTime: "2026-08-11T09:55:00+08:00" }),
-      ]),
-    );
-    const lines = readLines(root);
-    expect(lines).toHaveLength(2);
-    expect(String(lines[0]!.threadId)).toMatch(/^t-/);
-    expect(lines[1]!.quotedMessageId).toBe("m1");
-    // 同一 thread（引用命中）→ 两行 threadId 相同
-    expect(lines[1]!.threadId).toBe(lines[0]!.threadId);
-  });
-
-  it("不配 thread_log_dir → 完全不创建任何目录（配置即授权），但归并照旧", () => {
-    const root = tmpRoot();
-    const before = readdirSync(root);
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m1" })]));
-    expect(readdirSync(root)).toEqual(before);
-    // 归并是纯内存无副作用的，绑在日志开关上会让线程ID 无缘无故为空
-    expect(String(pushed[0]!.fields["线程ID"])).toMatch(/^t-/);
-  });
-});
-
-describe("旁路定位：绝不动主链", () => {
-  it("handler 只 pushEvent 建行，不调用任何 messaging / 不写别的表", () => {
-    const sent: unknown[] = [];
-    const { ctx, pushed } = makeCtx(ROSTER_CONFIG);
-    // 往 toolkit 上放探针：一旦 handler 试图发消息或写表，用例立刻红
-    (ctx as unknown as { toolkit: Record<string, unknown> }).toolkit = {
-      messaging: {
-        replyToConversation: () => {
-          sent.push("reply");
-          return Promise.resolve();
-        },
-      },
-      table: {
-        createRecordIn: () => {
-          sent.push("createRecordIn");
-          return Promise.resolve({ recordId: "x" });
-        },
-        updateRecordIn: () => {
-          sent.push("updateRecordIn");
-          return Promise.resolve();
-        },
-      },
-    };
-    handler.create(ctx).onEvent(groupEvent([msg({ messageId: "m1" })]));
-    expect(sent).toEqual([]);
-    expect(pushed).toHaveLength(1);
-  });
-});