@allbluecn/web-app 0.17.2 → 0.18.0

package/src/server/testcase/__tests__/auto-bug.test.ts

@@ -0,0 +1,715 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+// 指纹判重与 Bug 自动起草测试（任务 34，规格 §10 R6 / Q2）。
+// 钉死口径：
+// - 判重六值矩阵（审查重点 3）：同 case 同根因（category/错误摘要同）→命中关联
+//   （totalCount+1 + lastOccurAt + RunCase.bugId 回写，不新建）；category / 错误摘要 /
+//   firstFailedOrder 任一分量不同→新建；历史 Bug.state=resolved 不命中（查询层只
+//   匹配 state ∈ {open,in_progress}）；跨 Run 同 case 同指纹→命中（where 不限 runId）；
+// - 起草字段：title=`[TC{seq}] {快照.title} · {category 摘要}`（规格 §10 起草行）、
+//   reproduceSteps=快照 steps 同构直拷+失败步 actual、severity=priorityToSeverity、
+//   storyId 继承 case.storyId、source=test_run、state=open、fingerprint 落列；
+// - 闸门（审查重点 6）：pendingConfirm=!autoSubmitTestBugs；pendingConfirm=true 不出
+//   现在 BUG 常规默认列表（buildListWhere 默认过滤衔接核实）；确认按钮→false；
+//   autoSubmitTestBugs=true 直提（pendingConfirm=false）；webhook test.bug.drafted 派发；
+// - 触发链：triage 完成后接线（triageFailedRunCase 非 env_issue 分支尾部调用），
+//   env_issue 不进 bug 链；指纹 P2002（resolved 旧 Bug 占用指纹）回退关联既有 Bug；
+// - 错误摘要取值：stepResults 首个失败步（order 升序）的 actual——确定性执行产物，
+//   AI evidence 逐次生成措辞不稳定会破坏同根因判重。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const H = vi.hoisted(() => {
+  const fns = {
+    runChatAsAgent: vi.fn(),
+    createNotification: vi.fn(),
+    webhookDrafted: vi.fn(),
+    msgTitle: vi.fn(() => "NOTIFY_TITLE"),
+    msgBody: vi.fn(() => "NOTIFY_BODY"),
+    msgHintPending: vi.fn(() => "待人工确认"),
+    msgHintSubmitted: vi.fn(() => "已自动提交"),
+  };
+  const db = {
+    runCaseFindUnique: vi.fn(),
+    runCaseFindFirst: vi.fn(),
+    runCaseFindMany: vi.fn(),
+    runCaseUpdateMany: vi.fn(),
+    execRunFindUnique: vi.fn(),
+    execRunUpdate: vi.fn(),
+    runFindUnique: vi.fn(),
+    runUpdate: vi.fn(),
+    userFindUnique: vi.fn(),
+    settingsFindUnique: vi.fn(),
+    bugFindUnique: vi.fn(),
+    bugUpdate: vi.fn(),
+    bugUpdateMany: vi.fn(),
+    bugCreate: vi.fn(),
+    bugFindMany: vi.fn(),
+    projectFindUnique: vi.fn(),
+    projectMemberFindUnique: vi.fn(),
+    counterUpsert: vi.fn(),
+    bugActivityCreate: vi.fn(),
+    projectActivityCreate: vi.fn(),
+  };
+  const prisma = {
+    testRunCase: {
+      findUnique: db.runCaseFindUnique,
+      findFirst: db.runCaseFindFirst,
+      findMany: db.runCaseFindMany,
+      updateMany: db.runCaseUpdateMany,
+    },
+    testExecRun: { findUnique: db.execRunFindUnique, update: db.execRunUpdate },
+    testRun: { findUnique: db.runFindUnique, update: db.runUpdate },
+    user: { findUnique: db.userFindUnique },
+    bugProjectSettings: { findUnique: db.settingsFindUnique },
+    bug: {
+      findUnique: db.bugFindUnique,
+      findMany: db.bugFindMany,
+      update: db.bugUpdate,
+      updateMany: db.bugUpdateMany,
+      create: db.bugCreate,
+    },
+    project: { findUnique: db.projectFindUnique },
+    projectMember: { findUnique: db.projectMemberFindUnique },
+    sequenceCounter: { upsert: db.counterUpsert },
+    bugActivity: { create: db.bugActivityCreate },
+    projectActivity: { create: db.projectActivityCreate },
+    $transaction: vi.fn(),
+  };
+  return { fns, db, prisma };
+});
+const M = H.fns;
+const DB = H.db;
+const PRISMA = H.prisma;
+
+vi.mock("@allbluecn/database/get-prisma", () => ({
+  getPrisma: async () => H.prisma,
+}));
+vi.mock("@allbluecn/database", () => ({ prisma: {} }));
+vi.mock("@/server/ai-gateway/runs/agent-runtime", () => ({
+  runChatAsAgent: H.fns.runChatAsAgent,
+}));
+vi.mock("@/server/notifications/notification-service", () => ({
+  createNotification: H.fns.createNotification,
+}));
+vi.mock("@/paraglide/messages.js", () => ({
+  m: {
+    testcase_autoBug_draftedTitle: H.fns.msgTitle,
+    testcase_autoBug_draftedBody: H.fns.msgBody,
+    testcase_autoBug_pendingHint: H.fns.msgHintPending,
+    testcase_autoBug_submittedHint: H.fns.msgHintSubmitted,
+    // triage env_issue 通知（接线链路 env_issue 分支复用 task 33 文案）
+    testcase_triage_envIssueBlockedTitle: H.fns.msgTitle,
+    testcase_triage_envIssueBlockedBody: H.fns.msgBody,
+  },
+}));
+vi.mock("../run-webhook", () => ({
+  fireTestBugDraftedWebhook: H.fns.webhookDrafted,
+  fireTestRunWebhook: vi.fn(),
+  TEST_RUN_WEBHOOK_TIMEOUT_MS: 5000,
+}));
+// serverFn 测试桩（照 bug-crud.test.ts 惯例）：确认闸门 serverFn 走真实 zod 校验
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: () => {
+    const api: {
+      _validator?: { parse: (d: unknown) => unknown };
+      validator(schema: { parse: (d: unknown) => unknown }): unknown;
+      handler(fn: (args: { data: unknown }) => unknown): (args: { data: unknown }) => unknown;
+    } = {
+      _validator: undefined,
+      validator(schema) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn) {
+        return async (args: { data: unknown }) => {
+          const data =
+            api._validator && args?.data !== undefined ? api._validator.parse(args.data) : args?.data;
+          return fn({ data });
+        };
+      },
+    };
+    return api;
+  },
+}));
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: vi.fn(async () => ({ user: { id: "user-1" } })),
+}));
+
+import { execFingerprint } from "../fingerprint";
+import {
+  TEST_BUG_CATEGORY_LABEL,
+  autoBugForTrialedRunCase,
+  pickFirstFailedActual,
+} from "../auto-bug";
+import { triageFailedRunCase } from "../triage";
+import { buildListWhere } from "@/server/serverFns/bug/bug-list-query";
+import { confirmTestRunBugFn, listPendingTestRunBugsFn } from "@/server/serverFns/bug/test-bug-confirm";
+
+// ── 夹具 ──
+
+const FINGERPRINT_INPUT = {
+  projectId: "p1",
+  caseId: "case-1",
+  firstFailedOrder: 2,
+  category: "assertion_mismatch" as const,
+  errorSummary: "期望跳转首页 实际停留在登录页",
+};
+const F = execFingerprint(FINGERPRINT_INPUT);
+
+const TRIAGE_VERDICT = {
+  category: "assertion_mismatch",
+  evidence: ["步骤 2 观察: 期望跳转首页 实际停留在登录页", "consoleLog: TypeError x"],
+  confidence: 0.9,
+};
+
+function runCaseRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "rc-1",
+    runId: "run-1",
+    caseId: "case-1",
+    status: "failed",
+    flaky: false,
+    bugId: null,
+    execRunId: "er-1",
+    caseSnapshot: {
+      title: "登录成功跳转",
+      priority: "p1",
+      steps: {
+        steps: [
+          { order: 1, action: "打开登录页" },
+          { order: 2, action: "提交表单", expected: "跳转首页" },
+        ],
+      },
+    },
+    stepResults: [
+      { order: 1, status: "pass" },
+      { order: 2, status: "fail", actual: "期望跳转首页 实际停留在登录页", evidenceBlobIds: ["blob-1"] },
+    ],
+    run: { id: "run-1", projectId: "p1", createdById: "u1" },
+    case: { storyId: "story-1", identifier: "STORY-TC3" },
+    ...overrides,
+  };
+}
+
+function triagedReportRow() {
+  return { id: "er-1", report: { triage: TRIAGE_VERDICT } };
+}
+
+/** 起草路径全通夹具（history 未命中 + 项目/发号/建单成功） */
+function happyDraftFx(overrides: { settings?: { autoSubmitTestBugs: boolean } | null } = {}) {
+  DB.runCaseFindFirst.mockResolvedValue(null);
+  DB.settingsFindUnique.mockResolvedValue(
+    overrides.settings === undefined ? { autoSubmitTestBugs: false } : overrides.settings,
+  );
+  DB.projectFindUnique.mockResolvedValue({ id: "p1", name: "Alpha", displayId: "ABC" });
+  DB.counterUpsert.mockResolvedValue({ scope: "bug:p1", seq: 7 });
+  DB.bugCreate.mockResolvedValue({ id: "b-new" });
+  DB.bugUpdateMany.mockResolvedValue({ count: 0 });
+  DB.runCaseUpdateMany.mockResolvedValue({ count: 1 });
+  DB.bugActivityCreate.mockResolvedValue({});
+  DB.projectActivityCreate.mockResolvedValue({});
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  PRISMA.$transaction.mockImplementation(async (cb: (tx: typeof PRISMA) => Promise<unknown>) =>
+    cb(PRISMA),
+  );
+  DB.runCaseFindUnique.mockResolvedValue(runCaseRow());
+  DB.execRunFindUnique.mockResolvedValue(triagedReportRow());
+  DB.userFindUnique.mockResolvedValue({ locale: "zh" });
+  DB.bugUpdate.mockResolvedValue({});
+  DB.runCaseUpdateMany.mockResolvedValue({ count: 1 });
+  DB.execRunUpdate.mockResolvedValue({});
+  DB.runFindUnique.mockResolvedValue({ status: "completed", summary: { durationMs: 1000 } });
+  DB.runCaseFindMany.mockResolvedValue([{ status: "passed" }, { status: "blocked" }]);
+  M.createNotification.mockResolvedValue(undefined);
+});
+
+// ── 错误摘要取值（纯函数）──
+
+describe("pickFirstFailedActual（指纹错误摘要取数）", () => {
+  it("取 order 升序首个 fail 步的 actual（trim）", () => {
+    expect(
+      pickFirstFailedActual([
+        { order: 2, status: "fail", actual: "  B 错  " },
+        { order: 1, status: "pass" },
+        { order: 3, status: "fail", actual: "C 错" },
+      ]),
+    ).toBe("B 错");
+  });
+  it("无失败步 / 无 actual / 异常形状 → 空串", () => {
+    expect(pickFirstFailedActual([{ order: 1, status: "pass" }])).toBe("");
+    expect(pickFirstFailedActual([{ order: 1, status: "fail" }])).toBe("");
+    expect(pickFirstFailedActual("garbage")).toBe("");
+    expect(pickFirstFailedActual(null)).toBe("");
+  });
+});
+
+// ── 守卫：不进 bug 链的形态 ──
+
+describe("autoBugForTrialedRunCase 队列守卫", () => {
+  it("非 failed / flaky / 无 ExecRun / 已关联 BUG → null 零查询", async () => {
+    for (const over of [
+      { status: "passed" },
+      { flaky: true },
+      { execRunId: null },
+      { bugId: "b-taken" },
+    ]) {
+      DB.runCaseFindUnique.mockResolvedValueOnce(runCaseRow(over));
+      const out = await autoBugForTrialedRunCase("rc-1");
+      expect(out).toBeNull();
+    }
+    expect(DB.runCaseFindFirst).not.toHaveBeenCalled();
+  });
+
+  it("report 无 triage（未归因）→ null", async () => {
+    DB.execRunFindUnique.mockResolvedValue({ id: "er-1", report: {} });
+    expect(await autoBugForTrialedRunCase("rc-1")).toBeNull();
+    expect(DB.runCaseFindFirst).not.toHaveBeenCalled();
+  });
+
+  it("env_issue 不进 bug 链（task 33 隔离口径）", async () => {
+    DB.execRunFindUnique.mockResolvedValue({
+      id: "er-1",
+      report: { triage: { ...TRIAGE_VERDICT, category: "env_issue" } },
+    });
+    expect(await autoBugForTrialedRunCase("rc-1")).toBeNull();
+    expect(DB.runCaseFindFirst).not.toHaveBeenCalled();
+    expect(DB.bugCreate).not.toHaveBeenCalled();
+  });
+});
+
+// ── 判重六值矩阵（审查重点 3）──
+
+describe("指纹判重六值矩阵", () => {
+  it("① 同 case 同根因（category/错误摘要同）→ 命中：totalCount+1+lastOccurAt+RunCase 关联，不新建", async () => {
+    DB.runCaseFindFirst.mockResolvedValue({ bugId: "b-9" });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toEqual({ action: "linked", bugId: "b-9", pendingConfirm: false });
+    // 查询形状：同 caseId + 同指纹 + bugId 非空 + Bug.state ∈ {open,in_progress} + 取最新历史
+    const where = DB.runCaseFindFirst.mock.calls[0][0].where;
+    expect(where).toEqual({
+      caseId: "case-1",
+      fingerprint: F,
+      bugId: { not: null },
+      bug: { state: { in: ["open", "in_progress"] } },
+    });
+    expect(DB.runCaseFindFirst.mock.calls[0][0].orderBy).toEqual({ id: "desc" });
+    // 命中分支：条件回写（bugId 仍空才命中）→ 计数 + lastOccurAt；不建单
+    expect(DB.runCaseUpdateMany).toHaveBeenCalledWith({
+      where: { id: "rc-1", bugId: null },
+      data: { bugId: "b-9", fingerprint: F },
+    });
+    expect(DB.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "b-9" },
+      data: expect.objectContaining({
+        totalCount: { increment: 1 },
+        lastOccurAt: expect.any(Date),
+      }),
+    });
+    expect(DB.bugCreate).not.toHaveBeenCalled();
+    // 命中不通知不派 webhook（仅起草派发）
+    expect(M.createNotification).not.toHaveBeenCalled();
+    expect(M.webhookDrafted).not.toHaveBeenCalled();
+  });
+
+  it("② category 不同 → 新建（指纹分量变化，历史查不到）", async () => {
+    DB.execRunFindUnique.mockResolvedValue({
+      id: "er-1",
+      report: { triage: { ...TRIAGE_VERDICT, category: "api_error" } },
+    });
+    happyDraftFx();
+    await autoBugForTrialedRunCase("rc-1");
+    const lookupF = DB.runCaseFindFirst.mock.calls[0][0].where.fingerprint;
+    expect(lookupF).not.toBe(F);
+    expect(lookupF).toBe(
+      execFingerprint({
+        projectId: "p1",
+        caseId: "case-1",
+        firstFailedOrder: 2,
+        category: "api_error",
+        errorSummary: "期望跳转首页 实际停留在登录页",
+      }),
+    );
+    expect(DB.bugCreate).toHaveBeenCalled();
+  });
+
+  it("③ 错误摘要不同 → 新建", async () => {
+    DB.runCaseFindUnique.mockResolvedValue(
+      runCaseRow({
+        stepResults: [{ order: 2, status: "fail", actual: "完全不同的错误文本" }],
+      }),
+    );
+    happyDraftFx();
+    await autoBugForTrialedRunCase("rc-1");
+    const lookupF = DB.runCaseFindFirst.mock.calls[0][0].where.fingerprint;
+    expect(lookupF).not.toBe(F);
+    expect(DB.bugCreate).toHaveBeenCalled();
+  });
+
+  it("④ firstFailedOrder 不同 → 新建", async () => {
+    DB.runCaseFindUnique.mockResolvedValue(
+      runCaseRow({
+        stepResults: [
+          { order: 1, status: "fail", actual: "期望跳转首页 实际停留在登录页" },
+          { order: 2, status: "fail", actual: "期望跳转首页 实际停留在登录页" },
+        ],
+      }),
+    );
+    happyDraftFx();
+    await autoBugForTrialedRunCase("rc-1");
+    const lookupF = DB.runCaseFindFirst.mock.calls[0][0].where.fingerprint;
+    expect(lookupF).toBe(
+      execFingerprint({
+        projectId: "p1",
+        caseId: "case-1",
+        firstFailedOrder: 1,
+        category: "assertion_mismatch",
+        errorSummary: "期望跳转首页 实际停留在登录页",
+      }),
+    );
+    expect(lookupF).not.toBe(F);
+    expect(DB.bugCreate).toHaveBeenCalled();
+  });
+
+  it("⑤ 历史 Bug.state=resolved 不命中 → 新建（查询层只匹配 open/in_progress）", async () => {
+    // 查询层过滤 resolved（fixed/closed/wontfix 均不入 in 集合）——where 断言见用例 ①
+    DB.runCaseFindFirst.mockResolvedValue(null);
+    happyDraftFx();
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out?.action).toBe("drafted");
+    expect(DB.bugCreate).toHaveBeenCalled();
+  });
+
+  it("⑥ 跨 Run 同 case 同指纹 → 命中（where 不限 runId）", async () => {
+    DB.runCaseFindFirst.mockResolvedValue({ bugId: "b-other-run" });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toEqual({ action: "linked", bugId: "b-other-run", pendingConfirm: false });
+    expect(DB.runCaseFindFirst.mock.calls[0][0].where.runId).toBeUndefined();
+    expect(DB.bugCreate).not.toHaveBeenCalled();
+  });
+
+  it("命中关联两写事务化：bug.update 抛 P2025（Bug 已删）→ 事务拒绝整体失败，outcome null 不逃逸", async () => {
+    DB.runCaseFindFirst.mockResolvedValue({ bugId: "b-gone" });
+    DB.bugUpdate.mockRejectedValue(
+      Object.assign(new Error("Record to update not found"), { code: "P2025" }),
+    );
+    const out = await autoBugForTrialedRunCase("rc-1");
+    // RunCase 回写与计数同事务：计数失败整体回滚（真实 DB），此处零 outcome + 不逃逸
+    expect(out).toBeNull();
+    expect(PRISMA.$transaction).toHaveBeenCalled();
+    expect(DB.runCaseUpdateMany).toHaveBeenCalledWith({
+      where: { id: "rc-1", bugId: null },
+      data: { bugId: "b-gone", fingerprint: F },
+    });
+  });
+});
+
+// ── 起草字段（规格 §10 起草行 + 任务 17 组装复用）──
+
+describe("起草字段组装", () => {
+  it("title/identifier/severity/storyId/source/state/fingerprint 按规格落库", async () => {
+    happyDraftFx();
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out?.action).toBe("drafted");
+    const data = DB.bugCreate.mock.calls[0][0].data;
+    expect(data).toEqual(
+      expect.objectContaining({
+        // [TC{seq}]（case.identifier 的 -TC 后数字）+ 快照标题 + category 摘要
+        title: "[TC3] 登录成功跳转 · 断言不符",
+        identifier: "ABC-B7",
+        sequenceId: 7,
+        projectId: "p1",
+        state: "open",
+        severity: "high", // p1 → high
+        storyId: "story-1",
+        source: "test_run",
+        fingerprint: F,
+        createdById: "u1", // 批次创建人（AI 起草无登录用户）
+      }),
+    );
+    // reproduceSteps=快照 steps 同构直拷 + 失败步 actual
+    expect(data.reproduceSteps).toEqual({
+      steps: [
+        { order: 1, action: "打开登录页" },
+        { order: 2, action: "提交表单", expected: "跳转首页" },
+      ],
+      actualResult: "期望跳转首页 实际停留在登录页",
+    });
+    // description 含归因证据与截图 blob 引用
+    const desc = JSON.parse(data.description as string) as { html: string; markdown: string };
+    expect(desc.markdown).toContain("期望跳转首页 实际停留在登录页");
+    expect(desc.markdown).toContain("/api/blob/blob-1");
+  });
+
+  it("RunCase 回写 bugId+fingerprint 条件更新（并发双建回滚），活动 isAI=true", async () => {
+    happyDraftFx();
+    await autoBugForTrialedRunCase("rc-1");
+    expect(DB.runCaseUpdateMany).toHaveBeenCalledWith({
+      where: { id: "rc-1", bugId: null },
+      data: { bugId: "b-new", fingerprint: F },
+    });
+    expect(DB.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({ bugId: "b-new", action: "created", isAI: true }),
+    });
+    expect(DB.projectActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({ projectId: "p1", action: "created", targetType: "bug" }),
+    });
+    // 起草前腾挪指纹：仅 resolved 旧 Bug 占用同指纹时腾挪（活跃单持指纹禁止抹除，
+    // 并发双 worker 后提交者撞 P2002 走降级关联）
+    expect(DB.bugUpdateMany).toHaveBeenCalledWith({
+      where: {
+        projectId: "p1",
+        fingerprint: F,
+        state: { not: { in: ["open", "in_progress"] } },
+      },
+      data: { fingerprint: null },
+    });
+  });
+
+  it("RunCase 回写零行（并发已关联）→ 抛错回滚整体，outcome null", async () => {
+    happyDraftFx();
+    DB.runCaseUpdateMany.mockResolvedValue({ count: 0 });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toBeNull();
+  });
+});
+
+// ── 闸门（审查重点 6）──
+
+describe("pendingConfirm 闸门", () => {
+  it("autoSubmitTestBugs 缺省 false → pendingConfirm=true + 通知提示待确认", async () => {
+    happyDraftFx();
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toMatchObject({ pendingConfirm: true });
+    expect(DB.bugCreate.mock.calls[0][0].data.pendingConfirm).toBe(true);
+    expect(M.createNotification).toHaveBeenCalledWith(
+      expect.objectContaining({ userId: "u1", category: "collaboration", type: "test.bug.drafted" }),
+    );
+    expect(M.msgHintPending).toHaveBeenCalled();
+    expect(M.webhookDrafted).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "p1",
+        bug: expect.objectContaining({ id: "b-new", pendingConfirm: true }),
+      }),
+    );
+  });
+
+  it("autoSubmitTestBugs=true → 直提 pendingConfirm=false", async () => {
+    happyDraftFx({ settings: { autoSubmitTestBugs: true } });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toMatchObject({ pendingConfirm: false });
+    expect(DB.bugCreate.mock.calls[0][0].data.pendingConfirm).toBe(false);
+    expect(M.msgHintSubmitted).toHaveBeenCalled();
+  });
+
+  it("settings 行缺失 → 惰性默认 false（pendingConfirm=true）", async () => {
+    happyDraftFx({ settings: null });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toMatchObject({ pendingConfirm: true });
+  });
+
+  it("通知链失败（locale 查询抛错）不连坐 webhook 派发", async () => {
+    happyDraftFx();
+    DB.userFindUnique.mockRejectedValue(new Error("db down"));
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toMatchObject({ action: "drafted" });
+    expect(M.createNotification).not.toHaveBeenCalled();
+    expect(M.webhookDrafted).toHaveBeenCalledTimes(1);
+  });
+
+  it("BUG 常规默认列表排除 pendingConfirm=true（任务 17 buildListWhere 衔接核实）", () => {
+    // 默认视图（不传 includePendingConfirm）→ where.pendingConfirm = false
+    expect(buildListWhere({ userId: "u1", projectId: "p1" }).pendingConfirm).toBe(false);
+    // 显式保存视图传 true → 不过滤（防既有视图被静默改变）
+    expect(
+      buildListWhere({ userId: "u1", projectId: "p1", includePendingConfirm: true }),
+    ).not.toHaveProperty("pendingConfirm");
+  });
+
+  it("确认按钮：pendingConfirm true→false + 活动留痕", async () => {
+    DB.bugFindUnique.mockResolvedValue({
+      id: "b-new",
+      projectId: "p1",
+      source: "test_run",
+      pendingConfirm: true,
+    });
+    DB.projectMemberFindUnique.mockResolvedValue({ status: "active" });
+    DB.bugActivityCreate.mockResolvedValue({});
+    const res = await confirmTestRunBugFn({ data: { bugId: "b-new" } });
+    expect(res).toEqual({ success: true });
+    expect(DB.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "b-new" },
+      data: { pendingConfirm: false },
+    });
+    expect(DB.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        bugId: "b-new",
+        action: "confirmed",
+        field: "pendingConfirm",
+        oldValue: "true",
+        newValue: "false",
+      }),
+    });
+  });
+
+  it("确认守卫：非 test_run / 非待确认 / 非成员 → 拒绝", async () => {
+    DB.bugFindUnique.mockResolvedValue({
+      id: "b1",
+      projectId: "p1",
+      source: "manual",
+      pendingConfirm: false,
+    });
+    await expect(confirmTestRunBugFn({ data: { bugId: "b1" } })).rejects.toThrow();
+    expect(DB.bugUpdate).not.toHaveBeenCalled();
+
+    DB.bugFindUnique.mockResolvedValue({
+      id: "b2",
+      projectId: "p1",
+      source: "test_run",
+      pendingConfirm: false,
+    });
+    await expect(confirmTestRunBugFn({ data: { bugId: "b2" } })).rejects.toThrow();
+
+    DB.bugFindUnique.mockResolvedValue({
+      id: "b3",
+      projectId: "p1",
+      source: "test_run",
+      pendingConfirm: true,
+    });
+    DB.projectMemberFindUnique.mockResolvedValue({ status: "suspended" });
+    await expect(confirmTestRunBugFn({ data: { bugId: "b3" } })).rejects.toThrow();
+    expect(DB.bugUpdate).not.toHaveBeenCalled();
+  });
+
+  it("待确认清单：source=test_run + pendingConfirm + 按 run 圈定", async () => {
+    DB.runFindUnique.mockResolvedValue({ id: "run-1", projectId: "p1" });
+    DB.projectMemberFindUnique.mockResolvedValue({ status: "active" });
+    DB.bugFindMany.mockResolvedValue([
+      { id: "b-new", identifier: "ABC-B7", title: "t", severity: "high", state: "open", createdAt: new Date() },
+    ]);
+    const items = await listPendingTestRunBugsFn({ data: { runId: "run-1" } });
+    const args = DB.bugFindMany.mock.calls[0][0];
+    expect(args.where).toEqual({
+      archived: false,
+      source: "test_run",
+      pendingConfirm: true,
+      runCases: { some: { runId: "run-1" } },
+    });
+    expect(items).toHaveLength(1);
+  });
+});
+
+// ── 指纹唯一约束冲突回退（resolved 旧 Bug 占用指纹）──
+
+describe("指纹 P2002 回退", () => {
+  it("create 撞指纹唯一（resolved 旧单未及腾挪）→ 降级关联既有 Bug", async () => {
+    happyDraftFx();
+    DB.bugCreate.mockRejectedValue(
+      Object.assign(new Error("Unique constraint failed"), { code: "P2002", meta: { target: ["projectId", "fingerprint"] } }),
+    );
+    DB.bugFindUnique.mockResolvedValue({ id: "b-old", state: "fixed" });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out).toEqual({ action: "linked", bugId: "b-old", pendingConfirm: false });
+    expect(DB.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "b-old" },
+      data: expect.objectContaining({ totalCount: { increment: 1 } }),
+    });
+    expect(DB.runCaseUpdateMany).toHaveBeenCalledWith({
+      where: { id: "rc-1", bugId: null },
+      data: { bugId: "b-old", fingerprint: F },
+    });
+  });
+
+  it("identifier 撞号 → 重试取新 seq 后起草成功", async () => {
+    happyDraftFx();
+    DB.bugCreate
+      .mockRejectedValueOnce(
+        Object.assign(new Error("dup"), { code: "P2002", meta: { target: ["projectId", "identifier"] } }),
+      )
+      .mockResolvedValueOnce({ id: "b-new" });
+    const out = await autoBugForTrialedRunCase("rc-1");
+    expect(out?.action).toBe("drafted");
+    expect(DB.counterUpsert).toHaveBeenCalledTimes(2);
+  });
+});
+
+// ── 触发链接线：triage 非 env_issue 分支尾部调用 bug 链 ──
+
+describe("triage → auto-bug 接线", () => {
+  function chainFx() {
+    // 第一次 findUnique（triage 读）与第二次（auto-bug 读）同形；execRun 首次无
+    // triage（队列守卫）→ AI 归因 → persist 后 auto-bug 重读带 triage（mock 链）
+    DB.execRunFindUnique
+      .mockResolvedValueOnce({ id: "er-1", report: { perStep: [] } })
+      .mockResolvedValue(triagedReportRow());
+    M.runChatAsAgent.mockResolvedValue(JSON.stringify(TRIAGE_VERDICT));
+    DB.runCaseFindFirst.mockResolvedValue(null);
+    DB.settingsFindUnique.mockResolvedValue({ autoSubmitTestBugs: false });
+    DB.projectFindUnique.mockResolvedValue({ id: "p1", name: "Alpha", displayId: "ABC" });
+    DB.counterUpsert.mockResolvedValue({ scope: "bug:p1", seq: 1 });
+    DB.bugCreate.mockResolvedValue({ id: "b-chain" });
+    DB.bugUpdateMany.mockResolvedValue({ count: 0 });
+    DB.bugActivityCreate.mockResolvedValue({});
+    DB.projectActivityCreate.mockResolvedValue({});
+  }
+
+  it("非 env_issue 归因后自动起草（同进程真链路）", async () => {
+    chainFx();
+    const res = await triageFailedRunCase("rc-1");
+    expect(res).toMatchObject({ category: "assertion_mismatch", blocked: false });
+    expect(DB.bugCreate).toHaveBeenCalled();
+    expect(M.webhookDrafted).toHaveBeenCalled();
+  });
+
+  it("env_issue 归因不触发起草（不进 bug 链）", async () => {
+    DB.execRunFindUnique
+      .mockResolvedValueOnce({ id: "er-1", report: { perStep: [] } })
+      .mockResolvedValue({
+        id: "er-1",
+        report: { triage: { ...TRIAGE_VERDICT, category: "env_issue" } },
+      });
+    M.runChatAsAgent.mockResolvedValue(
+      JSON.stringify({ ...TRIAGE_VERDICT, category: "env_issue" }),
+    );
+    const res = await triageFailedRunCase("rc-1");
+    expect(res).toMatchObject({ category: "env_issue", blocked: true });
+    expect(DB.bugCreate).not.toHaveBeenCalled();
+  });
+});
+
+// ── category 摘要映射（title 组成部分）──
+
+describe("TEST_BUG_CATEGORY_LABEL", () => {
+  it("六值全覆盖且非空", () => {
+    for (const c of [
+      "frontend_error",
+      "api_error",
+      "assertion_mismatch",
+      "env_issue",
+      "data_issue",
+      "unknown",
+    ] as const) {
+      expect(TEST_BUG_CATEGORY_LABEL[c].length).toBeGreaterThan(0);
+    }
+    expect(TEST_BUG_CATEGORY_LABEL.assertion_mismatch).toBe("断言不符");
+  });
+});