aitable-workflow-cli 0.1.23 → 0.1.24

package/templates/support-qa/lib/__tests__/sandbox-agent.test.ts

@@ -1,382 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest";
-import { unzipSync } from "fflate";
-import { SandboxManager } from "@ali/aone-sandbox";
-import { CodeInterpreter, QoderRemoteAgent, Sandbox, type SandboxClient } from "@ali/aone-remote-agent";
-import { SupportQaSandboxAgentPool, runSandboxAgent, stopSandboxAgentPool } from "../sandbox-agent.js";
-
-vi.mock("@ali/aone-sandbox", () => ({
-  SandboxManager: { create: vi.fn() },
-}));
-
-vi.mock("@ali/aone-remote-agent", () => ({
-  CodeInterpreter: { fromSandbox: vi.fn() },
-  QoderRemoteAgent: vi.fn(),
-  Sandbox: { create: vi.fn() },
-}));
-
-const createMockAcpClient = () => {
-  const listeners = new Set<(update: { sessionId: string; update: Record<string, unknown>; raw: Record<string, unknown> }) => void>();
-  const emitText = (sessionId: string, text: string) => {
-    listeners.forEach((listener) =>
-      listener({
-        sessionId,
-        update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } },
-        raw: {},
-      }),
-    );
-  };
-  return {
-    newAcpSession: vi.fn().mockResolvedValue("session-1"),
-    query: vi.fn().mockImplementation(async (_prompt: string, sessionId: string) => {
-      emitText(sessionId, '{"action":"reply","reply":"hi"}');
-      return { stopReason: "end_turn", raw: {} };
-    }),
-    addUpdateListener: vi.fn().mockImplementation((listener) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }),
-    closeAcpSession: vi.fn().mockResolvedValue(undefined),
-    _emitText: emitText,
-  };
-};
-
-const createMockAgent = (sandbox: SandboxClient) => {
-  const client = createMockAcpClient();
-  return {
-    start: vi.fn().mockResolvedValue(undefined),
-    stop: vi.fn().mockResolvedValue(undefined),
-    sandbox: vi.fn().mockReturnValue(sandbox),
-    client: vi.fn().mockReturnValue(client),
-    _client: client,
-  };
-};
-
-function createLocalWorkspace(): { root: string; workDir: string; indexPath: string; mediaDir: string } {
-  const root = mkdtempSync(path.join(tmpdir(), "support-qa-sandbox-"));
-  const workDir = path.join(root, "workspaces", "support");
-  const compiledWiki = path.join(root, "wiki", "faq-support", ".kb", "wiki");
-  const mediaDir = path.join(root, ".aitable", "media", "dingtalk");
-  mkdirSync(path.join(workDir, "wiki"), { recursive: true });
-  mkdirSync(compiledWiki, { recursive: true });
-  mkdirSync(mediaDir, { recursive: true });
-  writeFileSync(path.join(workDir, "AGENTS.md"), "agent instructions");
-  writeFileSync(path.join(workDir, "owner-map.json"), "{}");
-  writeFileSync(path.join(root, "coding-agents.config.json"), JSON.stringify({
-    version: 1,
-    agents: { qoder: { enabled: true, model: "ConfiguredModel" } },
-  }));
-  writeFileSync(path.join(compiledWiki, "_index.md"), "# first index");
-  symlinkSync(compiledWiki, path.join(workDir, "wiki", "faq-support"), process.platform === "win32" ? "junction" : "dir");
-  return { root, workDir, indexPath: path.join(compiledWiki, "_index.md"), mediaDir };
-}
-
-function createRawSandbox(id: string) {
-  return {
-    id,
-    connectionConfig: { getBaseUrl: vi.fn().mockReturnValue("https://sandbox.test"), apiKey: "test-api-key" },
-    getEndpoint: vi.fn().mockResolvedValue({ endpoint: "https://endpoint.test", headers: {} }),
-    kill: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-describe("runSandboxAgent", () => {
-  const originalEnv = process.env;
-  let local: ReturnType<typeof createLocalWorkspace>;
-  let manager: { listSandboxInfos: Mock; killSandbox: Mock; close: Mock };
-  let mockInterpreter: {
-    commands: { run: Mock };
-    files: { readFile: Mock; writeFiles: Mock };
-  };
-  let rawSandboxes: ReturnType<typeof createRawSandbox>[];
-  let agents: ReturnType<typeof createMockAgent>[];
-  let configureAgent: (agent: ReturnType<typeof createMockAgent>) => void;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv, SANDBOX_API_KEY: "test-api-key", QODER_PERSONAL_ACCESS_TOKEN: "test-pat" };
-    local = createLocalWorkspace();
-    manager = {
-      listSandboxInfos: vi.fn().mockResolvedValue({ items: [] }),
-      killSandbox: vi.fn().mockResolvedValue(undefined),
-      close: vi.fn().mockResolvedValue(undefined),
-    };
-    mockInterpreter = {
-      commands: { run: vi.fn().mockResolvedValue({ exitCode: 0, logs: { stdout: [], stderr: [] } }) },
-      files: {
-        readFile: vi.fn(),
-        writeFiles: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-    rawSandboxes = [];
-    agents = [];
-    configureAgent = () => {};
-
-    vi.mocked(SandboxManager.create).mockReturnValue(manager as unknown as SandboxManager);
-    vi.mocked(Sandbox.create).mockImplementation(async () => {
-      const sandbox = createRawSandbox(`sandbox-${rawSandboxes.length + 1}`);
-      rawSandboxes.push(sandbox);
-      return sandbox as unknown as Sandbox;
-    });
-    vi.mocked(CodeInterpreter.fromSandbox).mockResolvedValue(
-      mockInterpreter as unknown as Awaited<ReturnType<typeof CodeInterpreter.fromSandbox>>,
-    );
-    vi.mocked(QoderRemoteAgent).mockImplementation((sandbox) => {
-      const agent = createMockAgent(sandbox as SandboxClient);
-      configureAgent(agent);
-      agents.push(agent);
-      return agent as unknown as QoderRemoteAgent;
-    });
-  });
-
-  afterEach(async () => {
-    await stopSandboxAgentPool(() => {});
-    rmSync(local.root, { recursive: true, force: true });
-    process.env = originalEnv;
-    vi.clearAllMocks();
-  });
-
-  it("缺少 SANDBOX_API_KEY 时抛出可读错误", async () => {
-    delete process.env.SANDBOX_API_KEY;
-    await expect(runSandboxAgent("prompt", local.workDir, () => {})).rejects.toThrow("SANDBOX_API_KEY");
-  });
-
-  it("缺少 QODER_PERSONAL_ACCESS_TOKEN 时抛出可读错误", async () => {
-    delete process.env.QODER_PERSONAL_ACCESS_TOKEN;
-    await expect(runSandboxAgent("prompt", local.workDir, () => {})).rejects.toThrow("QODER_PERSONAL_ACCESS_TOKEN");
-  });
-
-  it("创建三个独立 Sandbox、预装 qodercli 并返回 ACP 文本与会话标识", async () => {
-    const logs: string[] = [];
-    const result = await runSandboxAgent("prompt", local.workDir, (message) => logs.push(message));
-
-    expect(Sandbox.create).toHaveBeenCalledTimes(3);
-    for (let index = 0; index < 3; index++) {
-      expect(Sandbox.create).toHaveBeenNthCalledWith(index + 1, expect.objectContaining({
-        template: "code-interpreter",
-        metadata: expect.objectContaining({ slot: String(index + 1) }),
-      }));
-    }
-    expect(QoderRemoteAgent).toHaveBeenCalledTimes(3);
-    expect(QoderRemoteAgent).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ model: "ConfiguredModel" }),
-      "/workspace",
-      false,
-    );
-    expect(agents.every((agent) => agent.start.mock.calls.length === 1)).toBe(true);
-
-    const commands = mockInterpreter.commands.run.mock.calls.map(([command]) => String(command));
-    expect(commands.filter((command) => command.includes("@qoder-ai/qodercli"))).toHaveLength(3);
-    expect(commands.some((command) => command.includes("python3 -c"))).toBe(true);
-    expect(commands.some((command) => command.includes("ln -s /workspace/.kb/faq-support/"))).toBe(true);
-
-    const uploaded = mockInterpreter.files.writeFiles.mock.calls[0][0] as Array<{ path: string; data: Uint8Array }>;
-    expect(uploaded).toEqual(expect.arrayContaining([
-      expect.objectContaining({ path: "/workspace/.request/AGENTS.md" }),
-      expect.objectContaining({ path: "/workspace/.request/owner-map.json" }),
-    ]));
-    const archive = uploaded.find((entry) => entry.path.endsWith(".zip"));
-    expect(archive).toBeDefined();
-    const archiveFiles = unzipSync(archive!.data);
-    expect(new TextDecoder().decode(archiveFiles["wiki/_index.md"])).toBe("# first index");
-
-    expect(agents[0]._client.newAcpSession).toHaveBeenCalledWith("/workspace");
-    expect(agents[0]._client.query).toHaveBeenCalledWith("prompt", "session-1");
-    expect(result).toMatchObject({ sandboxId: "sandbox-1", sessionId: "session-1" });
-    expect(result.response).toContain('"action":"reply"');
-    expect(logs).toContain("沙箱：ACP Session 已创建 sandboxId=sandbox-1 sessionId=session-1");
-  });
-
-  it("启动时清理同 workspace 的全部遗留 Sandbox", async () => {
-    manager.listSandboxInfos.mockResolvedValue({
-      items: [{ id: "old-1" }, { id: "old-2" }],
-    });
-    const pool = new SupportQaSandboxAgentPool(2);
-    try {
-      await pool.run("prompt", local.workDir, () => {});
-      expect(manager.listSandboxInfos).toHaveBeenCalledWith(expect.objectContaining({
-        states: ["Running"],
-        metadata: expect.objectContaining({ application: "aitable-agent", workload: "support-qa" }),
-      }));
-      expect(manager.killSandbox).toHaveBeenCalledTimes(2);
-      expect(manager.killSandbox).toHaveBeenCalledWith("old-1");
-      expect(manager.killSandbox).toHaveBeenCalledWith("old-2");
-      expect(Sandbox.create).toHaveBeenCalledTimes(2);
-    } finally {
-      await pool.stop(() => {});
-    }
-  });
-
-  it("同一进程的后续请求复用已启动的 Sandbox 池", async () => {
-    const pool = new SupportQaSandboxAgentPool(2);
-    try {
-      await pool.run("first", local.workDir, () => {});
-      await pool.run("second", local.workDir, () => {});
-      expect(manager.listSandboxInfos).toHaveBeenCalledTimes(1);
-      expect(Sandbox.create).toHaveBeenCalledTimes(2);
-      expect(QoderRemoteAgent).toHaveBeenCalledTimes(2);
-      expect(agents[0]._client.query).toHaveBeenCalledTimes(2);
-      expect(pool.status()).toMatchObject({
-        capacity: 2,
-        busy: 0,
-        idle: 2,
-        sandboxIds: ["sandbox-1", "sandbox-2"],
-      });
-    } finally {
-      await pool.stop(() => {});
-    }
-  });
-
-  it("生命周期重建先释放旧 Sandbox，再创建替代实例", async () => {
-    const pool = new SupportQaSandboxAgentPool(1);
-    try {
-      await pool.run("first", local.workDir, () => {});
-      const firstSandbox = rawSandboxes[0];
-
-      await (pool as unknown as { rebuild(log: (message: string) => void): Promise<void> }).rebuild(() => {});
-
-      expect(Sandbox.create).toHaveBeenCalledTimes(2);
-      expect(firstSandbox.kill).toHaveBeenCalledTimes(1);
-      expect(firstSandbox.kill.mock.invocationCallOrder[0]).toBeLessThan(
-        vi.mocked(Sandbox.create).mock.invocationCallOrder[1],
-      );
-      expect(pool.status().sandboxIds).toEqual(["sandbox-2"]);
-    } finally {
-      await pool.stop(() => {});
-    }
-  });
-
-  it("上传消息图片并重写 prompt，忽略远程 URL 与目录外路径", async () => {
-    const imageData = Buffer.from("local image");
-    const localImage = path.join(local.mediaDir, "question.PNG");
-    const outsideImage = path.join(local.root, "outside.png");
-    writeFileSync(localImage, imageData);
-    writeFileSync(outsideImage, "outside");
-    const digest = createHash("sha256").update(imageData).digest("hex").slice(0, 20);
-    const sandboxImage = `/workspace/.media/${digest}.png`;
-    const remoteImage = "https://example.test/image.png";
-    const prompt = [
-      `第一张 ![图片](${localImage})`,
-      `重复引用 ![图片](<${localImage}>)`,
-      `远程图片 ![图片](${remoteImage})`,
-      `目录外图片 ![图片](${outsideImage})`,
-    ].join("\n");
-    const logs: string[] = [];
-
-    await runSandboxAgent(prompt, local.workDir, (message) => logs.push(message));
-
-    const imageUploads = mockInterpreter.files.writeFiles.mock.calls
-      .flatMap(([entries]) => entries as Array<{ path: string; data: Uint8Array }>)
-      .filter((entry) => entry.path.startsWith("/workspace/.media/"));
-    expect(imageUploads).toHaveLength(1);
-    expect(imageUploads[0]).toEqual({ path: sandboxImage, data: imageData });
-
-    const rewrittenPrompt = agents[0]._client.query.mock.calls[0][0] as string;
-    expect(rewrittenPrompt.match(new RegExp(sandboxImage, "g"))).toHaveLength(2);
-    expect(rewrittenPrompt).not.toContain(localImage);
-    expect(rewrittenPrompt).toContain(remoteImage);
-    expect(rewrittenPrompt).toContain(outsideImage);
-    expect(logs).toContain("沙箱：已同步消息图片 1 张");
-  });
-
-  it("知识库未变化时不重复上传归档，内容变化后上传新版本", async () => {
-    await runSandboxAgent("p1", local.workDir, () => {});
-    await runSandboxAgent("p2", local.workDir, () => {});
-    writeFileSync(local.indexPath, "# second index");
-    await runSandboxAgent("p3", local.workDir, () => {});
-
-    const archives = mockInterpreter.files.writeFiles.mock.calls.flatMap(([entries]) =>
-      (entries as Array<{ path: string }>).filter((entry) => entry.path.endsWith(".zip")),
-    );
-    expect(archives).toHaveLength(2);
-    expect(archives[0].path).not.toBe(archives[1].path);
-  });
-
-  it("status 反映当前并发占用", async () => {
-    let resolveQuery: ((value: { stopReason: string; raw: { text: string } }) => void) | undefined;
-    configureAgent = (agent) => {
-      agent._client.addUpdateListener.mockImplementation(() => () => {});
-      agent._client.query.mockImplementation(() => new Promise((resolve) => {
-        resolveQuery = resolve;
-      }));
-    };
-    const pool = new SupportQaSandboxAgentPool(1);
-    const running = pool.run("prompt", local.workDir, () => {});
-    await vi.waitFor(() => expect(agents[0]._client.query).toHaveBeenCalledTimes(1));
-    expect(pool.status()).toMatchObject({ capacity: 1, busy: 1, idle: 0, sandboxIds: ["sandbox-1"] });
-
-    resolveQuery?.({ stopReason: "end_turn", raw: { text: "done" } });
-    await running;
-    expect(pool.status()).toMatchObject({ capacity: 1, busy: 0, idle: 1 });
-    await pool.stop(() => {});
-  });
-
-  it("ACP 查询失败时在错误中保留模型已输出的内容", async () => {
-    configureAgent = (agent) => {
-      agent._client.query.mockImplementation(async (_prompt: string, sessionId: string) => {
-        agent._client._emitText(sessionId, "partial model output");
-        throw new Error("connection reset");
-      });
-    };
-    const pool = new SupportQaSandboxAgentPool(1);
-    await expect(pool.run("prompt", local.workDir, () => {})).rejects.toThrow(
-      'responseLength=20, response="partial model output", error=connection reset',
-    );
-    await pool.stop(() => {});
-  });
-
-  it("Agent 返回空响应时抛出错误", async () => {
-    configureAgent = (agent) => {
-      agent._client.query.mockResolvedValue({ stopReason: "end_turn", raw: {} });
-      agent._client.addUpdateListener.mockImplementation(() => () => {});
-    };
-    const pool = new SupportQaSandboxAgentPool(1);
-    await expect(pool.run("prompt", local.workDir, () => {})).rejects.toThrow("空响应");
-    await pool.stop(() => {});
-  });
-});
-
-describe("stopSandboxAgentPool", () => {
-  it("停止时释放每个 Agent 与 Sandbox", async () => {
-    process.env = { ...process.env, SANDBOX_API_KEY: "k", QODER_PERSONAL_ACCESS_TOKEN: "p" };
-    const local = createLocalWorkspace();
-    const interpreter = {
-      commands: { run: vi.fn().mockResolvedValue({ exitCode: 0, logs: { stdout: [], stderr: [] } }) },
-      files: { readFile: vi.fn(), writeFiles: vi.fn().mockResolvedValue(undefined) },
-    };
-    const sandboxes = [createRawSandbox("sandbox-a"), createRawSandbox("sandbox-b")];
-    const agents: ReturnType<typeof createMockAgent>[] = [];
-    vi.mocked(SandboxManager.create).mockReturnValue({
-      listSandboxInfos: vi.fn().mockResolvedValue({ items: [] }),
-      killSandbox: vi.fn(),
-      close: vi.fn().mockResolvedValue(undefined),
-    } as unknown as SandboxManager);
-    vi.mocked(Sandbox.create).mockImplementation(async () => sandboxes.shift() as unknown as Sandbox);
-    vi.mocked(CodeInterpreter.fromSandbox).mockResolvedValue(
-      interpreter as unknown as Awaited<ReturnType<typeof CodeInterpreter.fromSandbox>>,
-    );
-    vi.mocked(QoderRemoteAgent).mockImplementation((sandbox) => {
-      const agent = createMockAgent(sandbox as SandboxClient);
-      agents.push(agent);
-      return agent as unknown as QoderRemoteAgent;
-    });
-
-    const pool = new SupportQaSandboxAgentPool(2);
-    const ownedSandboxes = [...sandboxes];
-    try {
-      await pool.run("p", local.workDir, () => {});
-      await pool.stop(() => {});
-      expect(agents.every((agent) => agent.stop.mock.calls.length === 1)).toBe(true);
-      expect(ownedSandboxes.every((sandbox) => sandbox.kill.mock.calls.length === 1)).toBe(true);
-      expect(ownedSandboxes.every((sandbox) => sandbox.close.mock.calls.length === 1)).toBe(true);
-    } finally {
-      rmSync(local.root, { recursive: true, force: true });
-      await pool.stop(() => {});
-      await stopSandboxAgentPool(() => {});
-    }
-  });
-});

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

@@ -1,242 +0,0 @@
-/**
- * thread-adapter 的行为断言 —— support-qa payload → core thread 契约。
- *
- * 两条最容易回退的点，用例刻意钉死：
- * ① **逐条拆 `payload.messages`**，不能用 `payload.content`（那是同一人多条消息拼出来的
- *    多行文本，用它当一条会把每条自己的 openMessageId 与 quotedMessageId 全丢掉）；
- * ② **名单为空时降级不抛** —— `${globalVar.X}` 在首轮 config-sync 发布前解为 undefined。
- */
-import { describe, expect, it } from "vitest";
-import {
-  loadObserverRosters,
-  normalizeEventMessages,
-  parseGroupNames,
-  parseIdentities,
-  parseModuleTaxonomy,
-  parseThreadOptions,
-  resolveIdentity,
-  rosterStatus,
-} from "../thread-adapter.js";
-
-const CID = "cidTEST==";
-
-function payload(messages: Array<Record<string, unknown>>, extra: Record<string, unknown> = {}): Record<string, unknown> {
-  return {
-    conversationId: CID,
-    content: messages.map((m) => String(m.content ?? "")).join("\n"),
-    messages,
-    ...extra,
-  };
-}
-
-const ROSTERS = loadObserverRosters({
-  bots: [{ groupId: CID, botNick: "答疑助理" }],
-  answerers: [{ nick: "答疑甲", openDingTalkId: "openB" }],
-  groupConfigs: [{ groupId: CID, groupName: "产品交流群" }],
-});
-
-describe("parseIdentities", () => {
-  it("兼容字符串数组 / {nick,openDingTalkId} / {botNick} 三种形状", () => {
-    expect(parseIdentities(["甲", " 乙 "]).nicks).toEqual(new Set(["甲", "乙"]));
-    const s = parseIdentities([{ nick: "丙", openDingTalkId: "openC" }, { botNick: "机器人" }]);
-    expect(s.nicks).toEqual(new Set(["丙", "机器人"]));
-    expect(s.ids).toEqual(new Set(["openC"]));
-  });
-
-  it("非数组（含 undefined）降级为空集合，不抛 —— globalVar 首轮为空", () => {
-    expect(parseIdentities(undefined).nicks.size).toBe(0);
-    expect(parseIdentities(null).ids.size).toBe(0);
-    expect(parseIdentities("不是数组").nicks.size).toBe(0);
-  });
-});
-
-describe("resolveIdentity / rosterStatus", () => {
-  const bots = parseIdentities(["答疑助理"]);
-  const answerers = parseIdentities([{ nick: "答疑甲", openDingTalkId: "openB" }]);
-
-  it("bot 优先于 answerer（否则机器人秒回会被当成真人响应）", () => {
-    const both = parseIdentities(["答疑助理"]);
-    expect(resolveIdentity(bots, both, "答疑助理", "")).toBe("bot");
-  });
-
-  it("openId 命中即算 answerer，昵称改了也不影响", () => {
-    expect(resolveIdentity(bots, answerers, "换了个花名", "openB")).toBe("answerer");
-  });
-
-  it("都不命中 → user", () => {
-    expect(resolveIdentity(bots, answerers, "某用户", "openX")).toBe("user");
-  });
-
-  it("bots 缺失优先报（污染面比 answerers 缺失更大）", () => {
-    expect(rosterStatus(parseIdentities([]), answerers)).toBe("missing_bots");
-    expect(rosterStatus(bots, parseIdentities([]))).toBe("missing_answerers");
-    expect(rosterStatus(bots, answerers)).toBe("ok");
-  });
-});
-
-describe("normalizeEventMessages", () => {
-  it("一个 event 含同一人多条消息 → 逐条拆开，各自保留 openMessageId 与引用关系", () => {
-    const items = normalizeEventMessages(
-      payload([
-        { messageId: "m1", content: "这单怎么还没成功", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" },
-        { messageId: "m2", content: "有备注的", createTime: "2026-08-11T09:55:00+08:00", senderName: "用户甲", quotedMessageId: "m0" },
-      ]),
-      ROSTERS,
-    );
-    expect(items.map((i) => i.message.openMessageId)).toEqual(["m1", "m2"]);
-    expect(items[0]!.message.quotedMessageId).toBeUndefined();
-    expect(items[1]!.message.quotedMessageId).toBe("m0");
-  });
-
-  it("无 openMessageId 的消息被丢弃（既无法归并也无法溯源）", () => {
-    const items = normalizeEventMessages(
-      payload([{ content: "没有 id", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }]),
-      ROSTERS,
-    );
-    expect(items).toEqual([]);
-  });
-
-  it("既无正文又无图片的消息被丢弃（文件/系统消息）", () => {
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "   ", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }]),
-      ROSTERS,
-    );
-    expect(items).toEqual([]);
-  });
-
-  it("纯图片消息保留（正文空但有 images）", () => {
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "", images: ["/abs/p.png"], createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }]),
-      ROSTERS,
-    );
-    expect(items).toHaveLength(1);
-    expect(items[0]!.message.images).toEqual(["/abs/p.png"]);
-  });
-
-  it("bot 消息标 role=bot —— core 靠它避免把机器人当成提问人锚点", () => {
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "已收到", createTime: "2026-08-11T09:54:00+08:00", senderName: "答疑助理" }]),
-      ROSTERS,
-    );
-    expect(items[0]!.identity).toBe("bot");
-    expect(items[0]!.message.role).toBe("bot");
-  });
-
-  it("answerer 消息 role 仍是 unknown（谁是 asker 要等 thread 成型才知道）", () => {
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "我看看", createTime: "2026-08-11T09:54:00+08:00", senderName: "答疑甲", senderOpenDingTalkId: "openB" }]),
-      ROSTERS,
-    );
-    expect(items[0]!.identity).toBe("answerer");
-    expect(items[0]!.message.role).toBe("unknown");
-  });
-
-  it("群名从群配置按 groupId 反查 —— dingtalk_message 源不返回群名", () => {
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "问题", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }]),
-      ROSTERS,
-    );
-    expect(items[0]!.message.groupName).toBe("产品交流群");
-  });
-
-  it("事件源给了 conversationTitle 时优先用它（list-all 源有）", () => {
-    const items = normalizeEventMessages(
-      payload(
-        [{ messageId: "m1", content: "问题", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }],
-        { conversationTitle: "源给的群名" },
-      ),
-      ROSTERS,
-    );
-    expect(items[0]!.message.groupName).toBe("源给的群名");
-  });
-
-  it("群名都取不到时给空串而非 undefined，避免写表时整列被跳过", () => {
-    const items = normalizeEventMessages(
-      { conversationId: "cidUnknown==", messages: [{ messageId: "m1", content: "问题", createTime: "2026-08-11T09:54:00+08:00", senderName: "用户甲" }] },
-      ROSTERS,
-    );
-    expect(items[0]!.message.groupName).toBe("");
-  });
-
-  it("按时间升序产出：乱序会把追问判成新 thread", () => {
-    const items = normalizeEventMessages(
-      payload([
-        { messageId: "late", content: "后发", createTime: "2026-08-11T10:00:00+08:00", senderName: "用户甲" },
-        { messageId: "early", content: "先发", createTime: "2026-08-11T09:00:00+08:00", senderName: "用户甲" },
-      ]),
-      ROSTERS,
-    );
-    expect(items.map((i) => i.message.openMessageId)).toEqual(["early", "late"]);
-  });
-
-  it("缺 conversationId 的 payload 直接返回空（无法归群）", () => {
-    expect(normalizeEventMessages({ messages: [{ messageId: "m1", content: "x" }] }, ROSTERS)).toEqual([]);
-  });
-
-  it("时间解析不出来时回落当下，不给 0（0 会在时间排序里跑到所有 thread 之前）", () => {
-    const before = Date.now();
-    const items = normalizeEventMessages(
-      payload([{ messageId: "m1", content: "问题", createTime: "不是时间", senderName: "用户甲" }]),
-      ROSTERS,
-    );
-    expect(items[0]!.message.createTime).toBeGreaterThanOrEqual(before);
-  });
-});
-
-describe("parseGroupNames", () => {
-  it("没填群名的群不进 map（下游降级为空串）", () => {
-    const m = parseGroupNames([{ groupId: "a", groupName: "甲群" }, { groupId: "b" }]);
-    expect(m.get("a")).toBe("甲群");
-    expect(m.has("b")).toBe(false);
-  });
-});
-
-describe("parseModuleTaxonomy", () => {
-  it("从 [{module, owners}] 取模块名", () => {
-    expect(parseModuleTaxonomy([{ module: "表单", owners: ["甲"] }, { module: "自动化" }])).toBe("表单 / 自动化");
-  });
-
-  it("兼容 {模块名: [...]} 形状", () => {
-    expect(parseModuleTaxonomy({ 表单: ["甲"], 视图: ["乙"] })).toBe("表单 / 视图");
-  });
-
-  it("去重", () => {
-    expect(parseModuleTaxonomy([{ module: "表单" }, { module: "表单" }])).toBe("表单");
-  });
-
-  it("取不到时给空串（agent 侧据此省略 module，而不是乱造一个）", () => {
-    expect(parseModuleTaxonomy(undefined)).toBe("");
-    expect(parseModuleTaxonomy([])).toBe("");
-  });
-});
-
-describe("parseThreadOptions", () => {
-  it("分钟/小时换算成 ms", () => {
-    expect(parseThreadOptions({ thread_idle_close_min: 15, thread_max_open_hour: 3 })).toMatchObject({
-      idleCloseMs: 15 * 60_000,
-      maxOpenMs: 3 * 3_600_000,
-    });
-  });
-
-  it("归并开关默认不开：必须在 profile 显式打开（误合比漏合严重）", () => {
-    const opts = parseThreadOptions({});
-    expect(opts.enableMentionMerge).toBeUndefined();
-    expect(opts.enableHeuristicMerge).toBeUndefined();
-  });
-
-  it("显式 true 才打开；非布尔值不当真", () => {
-    expect(parseThreadOptions({ thread_enable_mention_merge: true }).enableMentionMerge).toBe(true);
-    expect(parseThreadOptions({ thread_enable_mention_merge: "true" }).enableMentionMerge).toBeUndefined();
-  });
-
-  it("不含 {name} 的 addressPattern 被丢弃（它无法定位被称呼者）", () => {
-    expect(parseThreadOptions({ thread_address_patterns: ["Hi {name}", "没有占位符"] })).toMatchObject({
-      addressPatterns: ["Hi {name}"],
-    });
-  });
-
-  it("非正数不当真，避免 0 或负数让 thread 立刻收敛", () => {
-    expect(parseThreadOptions({ thread_idle_close_min: 0 }).idleCloseMs).toBeUndefined();
-    expect(parseThreadOptions({ thread_max_open_hour: -1 }).maxOpenMs).toBeUndefined();
-  });
-});