@allbluecn/web-app 0.17.1 → 0.18.0

package/src/server/mcp/__tests__/tools.test.ts

@@ -0,0 +1,1185 @@
+// 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/>.
+
+// MCP 工具集测试（任务 21 六 bug 工具 + 任务 24 test 域四工具）——测试即规格：
+// tools/list 六/四工具且 inputSchema 为合法 JSON Schema（z.toJSONSchema 产物）/
+// list_bugs 项目隔离 + 无 status 优先「有待修复任务」/ get_bug 全量（复现步骤/
+// 堆栈/最近 5 事件）/ claim_fix 原子性（updateMany count=0 即冲突，含先占者）/
+// report_progress 首次 claimed→in_progress / report_result 三态状态联动 +
+// webhook spy / list_events 分页上限 50。全工具 ctx.projectId 数据边界。
+// test 域（§8.2 钉死）：list_pending_execs 只返 untested+run running+未认领 /
+// claim_exec 建 ExecRun(claimed)+回填 execRunId，已被认领 JSON-RPC -32001 /
+// report_step 追加 perStep + RunCase.stepResults 同步（claimed→running 首步转移）/
+// report_exec_result 恒置终态（pass→passed/fail→failed/uncertain→retest）+
+// 复用 finalizeRunIfComplete 落 run completed+summary+webhook（R16：失败态从
+// 结果读不依赖 run.status）；对非 claimed（timeout_reclaimed 等）report 被拒 -32002。
+// prisma 与 fireBugWebhook/fireTestRunWebhook 全 mock（照 json-rpc.test.ts 样板）。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  bugFindMany: vi.fn(),
+  bugFindFirst: vi.fn(),
+  bugUpdate: vi.fn(),
+  bugCreate: vi.fn(),
+  fixRunFindFirst: vi.fn(),
+  fixRunFindUnique: vi.fn(),
+  fixRunUpdateMany: vi.fn(),
+  bugEventFindMany: vi.fn(),
+  bugActivityCreate: vi.fn(),
+  storyFindUnique: vi.fn(),
+  fireBugWebhook: vi.fn(),
+  fireTestRunWebhook: vi.fn(),
+  testRunFindFirst: vi.fn(),
+  testRunFindUnique: vi.fn(),
+  testRunUpdate: vi.fn(),
+  testRunCaseFindMany: vi.fn(),
+  testRunCaseFindUnique: vi.fn(),
+  testRunCaseUpdate: vi.fn(),
+  testRunCaseUpdateMany: vi.fn(),
+  execRunCreate: vi.fn(),
+  execRunFindMany: vi.fn(),
+  execRunFindUnique: vi.fn(),
+  execRunUpdateMany: vi.fn(),
+  projectActivityCreate: vi.fn(),
+  transaction: vi.fn(),
+  scheduleFlakyRetry: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    bug: {
+      findMany: mocks.bugFindMany,
+      findFirst: mocks.bugFindFirst,
+      update: mocks.bugUpdate,
+      create: mocks.bugCreate,
+    },
+    bugFixRun: {
+      findFirst: mocks.fixRunFindFirst,
+      findUnique: mocks.fixRunFindUnique,
+      updateMany: mocks.fixRunUpdateMany,
+    },
+    bugEvent: { findMany: mocks.bugEventFindMany },
+    bugActivity: { create: mocks.bugActivityCreate },
+    story: { findUnique: mocks.storyFindUnique },
+    testRun: {
+      findFirst: mocks.testRunFindFirst,
+      findUnique: mocks.testRunFindUnique,
+      update: mocks.testRunUpdate,
+    },
+    testRunCase: {
+      findMany: mocks.testRunCaseFindMany,
+      findUnique: mocks.testRunCaseFindUnique,
+      update: mocks.testRunCaseUpdate,
+      updateMany: mocks.testRunCaseUpdateMany,
+    },
+    testExecRun: {
+      create: mocks.execRunCreate,
+      findMany: mocks.execRunFindMany,
+      findUnique: mocks.execRunFindUnique,
+      updateMany: mocks.execRunUpdateMany,
+    },
+    projectActivity: { create: mocks.projectActivityCreate },
+    $transaction: mocks.transaction,
+  },
+  Prisma: {},
+}));
+
+vi.mock("@/server/bug-report/webhook-out", () => ({
+  fireBugWebhook: mocks.fireBugWebhook,
+}));
+
+vi.mock("@/server/testcase/run-webhook", () => ({
+  fireTestRunWebhook: mocks.fireTestRunWebhook,
+}));
+
+// 任务 32：flaky-retry 判定逻辑（decideFlakyAction/extractFinalVerdicts）用真实现，
+// 仅 stub 回池调度（fire-and-forget，断言「是否调度」而非异步落库细节——回池行为
+// 本体在 flaky-retry.test.ts 全覆盖）
+vi.mock("@/server/testcase/flaky-retry", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  scheduleFailedExecRetry: mocks.scheduleFlakyRetry,
+}));
+
+import { handleMcpRequest, TOOLS_BY_SCOPE, type McpRequestContext } from "../protocol";
+import { BUG_MCP_TOOLS, TEST_MCP_TOOLS, TOOL_NAMES } from "../tools";
+
+const ctx: McpRequestContext = {
+  auth: { projectId: "p1", tokenId: "tok1" },
+  tools: BUG_MCP_TOOLS,
+};
+
+const testCtx: McpRequestContext = {
+  auth: { projectId: "p1", tokenId: "tok1" },
+  tools: TEST_MCP_TOOLS,
+};
+
+const now = new Date("2026-10-03T08:00:00Z");
+
+const BUG_P1 = {
+  id: "b1",
+  projectId: "p1",
+  identifier: "BCT-B1",
+  sequenceId: 1,
+  title: "TypeError: cannot read properties of null",
+  description: null,
+  reproduceSteps: {
+    steps: [{ order: 1, action: "打开登录页" }, { order: 2, action: "点击提交" }],
+    expectedResult: "登录成功",
+    actualResult: "白屏",
+  },
+  state: "open",
+  severity: "high",
+  source: "sdk_auto",
+  env: "prod",
+  url: "https://app.example.com/login",
+  userAgent: "Mozilla/5.0",
+  stackSummary: "TypeError: cannot read 'submit' at login.ts:42",
+  totalCount: 3,
+  firstOccurAt: now,
+  lastOccurAt: now,
+  repoHints: null,
+  storyId: "s1",
+  archived: false,
+};
+
+const RUN_PENDING = {
+  id: "run1",
+  bugId: "b1",
+  status: "pending",
+  triggerType: "manual",
+  agentName: null,
+  claimedAt: null,
+  completedAt: null,
+  summary: null,
+  createdAt: now,
+};
+
+const callTool = async (name: string, args: unknown, c: McpRequestContext = ctx) => {
+  const res = await handleMcpRequest(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name, arguments: args },
+    }),
+    c,
+  );
+  expect(res.status).toBe(200);
+  const body = await res.json();
+  expect(body.error).toBeUndefined();
+  const result = body.result as {
+    content: { type: string; text: string }[];
+    isError?: boolean;
+  };
+  expect(result.content).toHaveLength(1);
+  expect(result.content[0].type).toBe("text");
+  return { raw: result, payload: JSON.parse(result.content[0].text) };
+};
+
+/** 协议层错误通道（JSON-RPC error 响应，非 isError 工具结果）：claim_exec -32001 / report -32002 专用 */
+const callToolRaw = async (name: string, args: unknown, c: McpRequestContext = ctx) => {
+  const res = await handleMcpRequest(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name, arguments: args },
+    }),
+    c,
+  );
+  expect(res.status).toBe(200);
+  return (await res.json()) as {
+    result?: { content: { type: string; text: string }[]; isError?: boolean };
+    error?: { code: number; message: string };
+  };
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.bugActivityCreate.mockResolvedValue({});
+  mocks.bugUpdate.mockResolvedValue({});
+  mocks.fixRunUpdateMany.mockResolvedValue({ count: 1 });
+  mocks.storyFindUnique.mockResolvedValue(null);
+  // test 域默认桩：条件更新全部命中、finalize 阶段空集（不触发 run completed）
+  mocks.testRunCaseFindMany.mockResolvedValue([]);
+  mocks.testRunCaseFindUnique.mockResolvedValue(null);
+  mocks.testRunCaseUpdateMany.mockResolvedValue({ count: 1 });
+  mocks.testRunFindUnique.mockResolvedValue(null);
+  mocks.testRunUpdate.mockResolvedValue({});
+  mocks.execRunCreate.mockResolvedValue({ id: "er1" });
+  mocks.execRunFindMany.mockResolvedValue([]); // 惰性回收扫描（list_pending_execs 接缝）无过期
+  mocks.execRunFindUnique.mockResolvedValue(null);
+  mocks.execRunUpdateMany.mockResolvedValue({ count: 1 });
+  mocks.projectActivityCreate.mockResolvedValue({});
+  mocks.testRunUpdate.mockResolvedValue({});
+  // $transaction 交互式事务：fn(tx) 直调，tx 即 prisma mock 本体（照 run-cases.test.ts）
+  mocks.transaction.mockImplementation(async (input: unknown) => {
+    if (typeof input === "function") {
+      return (input as (tx: unknown) => Promise<unknown>)(
+        (await import("@allbluecn/database")).prisma,
+      );
+    }
+    return Promise.all(input as Promise<unknown>[]);
+  });
+});
+
+// ── tools/list：六工具 + 合法 JSON Schema ──
+describe("tools/list", () => {
+  it("返回六工具且 inputSchema 为合法 JSON Schema（z.toJSONSchema 产物）", async () => {
+    const res = await handleMcpRequest(
+      JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+      ctx,
+    );
+    const body = await res.json();
+    expect(body.result.tools.map((t: { name: string }) => t.name)).toEqual([
+      TOOL_NAMES.listBugs,
+      TOOL_NAMES.getBug,
+      TOOL_NAMES.claimFix,
+      TOOL_NAMES.reportProgress,
+      TOOL_NAMES.reportResult,
+      TOOL_NAMES.listEvents,
+    ]);
+    for (const tool of body.result.tools) {
+      expect(typeof tool.description).toBe("string");
+      expect(tool.description.length).toBeGreaterThan(0);
+      const schema = tool.inputSchema;
+      expect(schema.type).toBe("object");
+      expect(schema.properties).toBeTypeOf("object");
+      expect(Array.isArray(schema.required) || schema.required === undefined).toBe(true);
+      // JSON.stringify round-trip 即结构合法性底线（无循环引用/函数残留）
+      expect(() => JSON.parse(JSON.stringify(schema))).not.toThrow();
+    }
+  });
+
+  it("claim_fix schema：bugId/agentName 必填且枚举收敛（agentName 无枚举，phase 有）", async () => {
+    const res = await handleMcpRequest(
+      JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+      ctx,
+    );
+    const body = await res.json();
+    const byName = Object.fromEntries(
+      body.result.tools.map((t: { name: string; inputSchema: unknown }) => [t.name, t]),
+    );
+    const claim = byName[TOOL_NAMES.claimFix].inputSchema;
+    expect(claim.required).toEqual(["bugId", "agentName"]);
+    const progress = byName[TOOL_NAMES.reportProgress].inputSchema;
+    expect(progress.properties.phase.enum).toEqual(["analyzing", "fixing", "verifying"]);
+    const result = byName[TOOL_NAMES.reportResult].inputSchema;
+    expect(result.properties.result.enum).toEqual(["fixed", "failed", "cannot_reproduce"]);
+    // limit 上限收敛为 50（list_bugs / list_events 同规）
+    expect(byName[TOOL_NAMES.listBugs].inputSchema.properties.limit.maximum).toBe(50);
+    expect(byName[TOOL_NAMES.listEvents].inputSchema.properties.limit.maximum).toBe(50);
+  });
+});
+
+// ── list_bugs：项目隔离 + 优先排序 ──
+describe("list_bugs", () => {
+  it("status 过滤：以 ctx.projectId 为边界（项目隔离），单查询含活跃 fixRun", async () => {
+    mocks.bugFindMany.mockResolvedValueOnce([
+      { ...BUG_P1, fixRuns: [{ id: "run1", status: "pending", agentName: null, triggerType: "manual", claimedAt: null }] },
+    ]);
+    const { payload } = await callTool(TOOL_NAMES.listBugs, { status: "open" });
+    expect(mocks.bugFindMany).toHaveBeenCalledTimes(1);
+    const where = mocks.bugFindMany.mock.calls[0][0].where;
+    expect(where.projectId).toBe("p1");
+    expect(where.status).toBe("open");
+    expect(mocks.bugFindMany.mock.calls[0][0].take).toBe(20); // 默认 limit
+    expect(payload.bugs).toHaveLength(1);
+    expect(payload.bugs[0].fixRun.status).toBe("pending");
+  });
+
+  it("无 status：两阶段查询——先「有待修复任务」的，再补其余，合并保持优先序", async () => {
+    const withRun = { ...BUG_P1, id: "b-run", fixRuns: [RUN_PENDING] };
+    const withoutRun = { ...BUG_P1, id: "b-plain", fixRuns: [] };
+    mocks.bugFindMany
+      .mockResolvedValueOnce([withRun]) // fixRuns: { some: ... }
+      .mockResolvedValueOnce([withoutRun]); // fixRuns: { none: ... }
+    const { payload } = await callTool(TOOL_NAMES.listBugs, {});
+    expect(mocks.bugFindMany).toHaveBeenCalledTimes(2);
+    const firstWhere = mocks.bugFindMany.mock.calls[0][0].where;
+    const secondWhere = mocks.bugFindMany.mock.calls[1][0].where;
+    expect(firstWhere.projectId).toBe("p1");
+    expect(firstWhere.fixRuns).toEqual({ some: { status: { in: ["pending", "claimed", "in_progress"] } } });
+    expect(secondWhere.fixRuns).toEqual({ none: { status: { in: ["pending", "claimed", "in_progress"] } } });
+    expect(mocks.bugFindMany.mock.calls[1][0].take).toBe(19); // limit - 第一阶段命中数
+    expect(payload.bugs.map((b: { id: string }) => b.id)).toEqual(["b-run", "b-plain"]);
+  });
+
+  it("limit 收敛：limit=3 传给查询（schema max 50 拦截更大值）", async () => {
+    mocks.bugFindMany.mockResolvedValueOnce([]).mockResolvedValueOnce([]); // 两阶段查询均空
+    const { payload } = await callTool(TOOL_NAMES.listBugs, { limit: 3 });
+    expect(mocks.bugFindMany.mock.calls[0][0].take).toBe(3);
+    expect(payload.bugs).toEqual([]);
+  });
+
+  it("limit > 50 → 工具级 isError（非协议错误）", async () => {
+    const { raw } = await callTool(TOOL_NAMES.listBugs, { limit: 999 });
+    expect(raw.isError).toBe(true);
+    expect(mocks.bugFindMany).not.toHaveBeenCalled();
+  });
+});
+
+// ── get_bug：全量 + 越权边界 ──
+describe("get_bug", () => {
+  it("返回复现步骤/堆栈/环境/最近 5 条事件/关联 story/活跃 fixRun", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.bugEventFindMany.mockResolvedValueOnce(
+      Array.from({ length: 5 }, (_, i) => ({
+        id: `ev${i}`,
+        occurTime: now,
+        userAgent: "Mozilla/5.0",
+        rawPayload: { errorName: "TypeError", stack: `frame-${i}` },
+      })),
+    );
+    mocks.fixRunFindFirst.mockResolvedValueOnce({ ...RUN_PENDING, status: "claimed", agentName: "opencode" });
+    mocks.storyFindUnique.mockResolvedValueOnce({ id: "s1", identifier: "STORY-9", title: "登录重构" });
+    const { payload } = await callTool(TOOL_NAMES.getBug, { bugId: "b1" });
+    // 越权防线：查询 where 必含 projectId 边界
+    expect(mocks.bugFindFirst).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: "b1", projectId: "p1" } }),
+    );
+    expect(mocks.bugEventFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { bugId: "b1" }, take: 5, orderBy: { occurTime: "desc" } }),
+    );
+    expect(payload.bug.stackSummary).toContain("login.ts:42");
+    expect(payload.bug.reproduceSteps.steps).toHaveLength(2);
+    expect(payload.bug.env).toBe("prod");
+    expect(payload.recentEvents).toHaveLength(5);
+    expect(payload.story.identifier).toBe("STORY-9");
+    expect(payload.activeFixRun.status).toBe("claimed");
+    expect(payload.activeFixRun.agentName).toBe("opencode");
+  });
+
+  it("越权 bugId（他项目/不存在）→ isError:true 可读 message，不泄漏存在性", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(null);
+    const { raw, payload } = await callTool(TOOL_NAMES.getBug, { bugId: "b-other-project" });
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("不存在或无权访问");
+    expect(mocks.bugEventFindMany).not.toHaveBeenCalled();
+  });
+});
+
+// ── claim_fix：原子认领（审查重点 4）──
+describe("claim_fix", () => {
+  it("pending run → updateMany 原子认领 + BugActivity(fix_claimed, actorType=agent, isAI)", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce(RUN_PENDING);
+    mocks.fixRunUpdateMany.mockResolvedValueOnce({ count: 1 });
+    const { payload } = await callTool(TOOL_NAMES.claimFix, { bugId: "b1", agentName: "opencode" });
+    // 原子语义：条件更新（status 仍为 pending 才生效），非 findFirst+update 竞态窗口
+    expect(mocks.fixRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "run1", status: "pending" },
+      data: expect.objectContaining({
+        status: "claimed",
+        agentName: "opencode",
+        claimedAt: expect.any(Date),
+      }),
+    });
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        bugId: "b1",
+        action: "fix_claimed",
+        actorType: "agent",
+        agentName: "opencode",
+        isAI: true,
+        userId: null,
+      }),
+    });
+    expect(payload.ok).toBe(true);
+    expect(payload.status).toBe("claimed");
+  });
+
+  it("原子性：updateMany count=0（已被并发认领）→ isError:true 含先占 agentName", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce(RUN_PENDING);
+    mocks.fixRunUpdateMany.mockResolvedValueOnce({ count: 0 }); // 条件更新未命中 = 已被抢
+    mocks.fixRunFindUnique.mockResolvedValueOnce({ ...RUN_PENDING, status: "claimed", agentName: "claude" });
+    const { raw, payload } = await callTool(TOOL_NAMES.claimFix, { bugId: "b1", agentName: "opencode" });
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("claude");
+    expect(payload.agentName).toBe("claude");
+    expect(mocks.bugActivityCreate).not.toHaveBeenCalled();
+  });
+
+  it("无活跃修复任务 → isError 引导先入队", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce(null);
+    const { raw, payload } = await callTool(TOOL_NAMES.claimFix, { bugId: "b1", agentName: "opencode" });
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("无活跃修复任务");
+    expect(mocks.fixRunUpdateMany).not.toHaveBeenCalled();
+  });
+
+  it("缺 agentName → 工具级参数校验 isError（非 -32602 协议错误）", async () => {
+    const { raw } = await callTool(TOOL_NAMES.claimFix, { bugId: "b1" });
+    expect(raw.isError).toBe(true);
+    expect(mocks.bugFindFirst).not.toHaveBeenCalled();
+  });
+});
+
+// ── report_progress：claimed→in_progress 首次转移 ──
+describe("report_progress", () => {
+  it("首次：run claimed → in_progress + BugActivity(fix_progress, actorType=agent, isAI, metadata.phase)", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce({ ...RUN_PENDING, status: "claimed", agentName: "opencode" });
+    const { payload } = await callTool(TOOL_NAMES.reportProgress, {
+      bugId: "b1",
+      message: "定位到 login.ts 空指针",
+      phase: "analyzing",
+    });
+    expect(mocks.fixRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "run1", status: "claimed" },
+      data: { status: "in_progress" },
+    });
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        bugId: "b1",
+        action: "fix_progress",
+        actorType: "agent",
+        agentName: "opencode",
+        isAI: true,
+        userId: null,
+        metadata: expect.objectContaining({ phase: "analyzing" }),
+      }),
+    });
+    expect(payload.ok).toBe(true);
+    expect(payload.status).toBe("in_progress");
+  });
+
+  it("后续进度：run 已 in_progress 不再重复转移，仍记 fix_progress 活动", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce({ ...RUN_PENDING, status: "in_progress", agentName: "opencode" });
+    await callTool(TOOL_NAMES.reportProgress, { bugId: "b1", message: "修复中" });
+    expect(mocks.fixRunUpdateMany).not.toHaveBeenCalled();
+    expect(mocks.bugActivityCreate).toHaveBeenCalled();
+  });
+
+  it("run 仍 pending（未认领）→ isError 引导先 claim_fix", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce(RUN_PENDING);
+    const { raw, payload } = await callTool(TOOL_NAMES.reportProgress, { bugId: "b1", message: "x" });
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("claim_fix");
+    expect(mocks.bugActivityCreate).not.toHaveBeenCalled();
+  });
+});
+
+// ── report_result：三态状态联动 + webhook ──
+describe("report_result", () => {
+  const setupRun = (status = "in_progress") => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.fixRunFindFirst.mockResolvedValueOnce({ ...RUN_PENDING, status, agentName: "opencode" });
+  };
+
+  it("fixed：run → completed + summary 落库 + Bug.state=fixed + BugActivity(fix_completed, isAI) + webhook", async () => {
+    setupRun();
+    const { payload } = await callTool(TOOL_NAMES.reportResult, {
+      bugId: "b1",
+      result: "fixed",
+      summary: "修复了 login.ts 空指针",
+      commitUrl: "https://github.com/org/repo/commit/abc",
+      changedFiles: ["src/views/login.ts"],
+    });
+    expect(mocks.fixRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "run1", status: { in: ["claimed", "in_progress"] } },
+      data: expect.objectContaining({
+        status: "completed",
+        completedAt: expect.any(Date),
+        summary: expect.objectContaining({
+          result: "fixed",
+          summaryText: "修复了 login.ts 空指针",
+          changedFiles: ["src/views/login.ts"],
+        }),
+      }),
+    });
+    expect(mocks.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "b1" },
+      data: { state: "fixed" },
+    });
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        bugId: "b1",
+        action: "fix_completed",
+        actorType: "agent",
+        isAI: true,
+        newValue: "fixed",
+      }),
+    });
+    expect(mocks.fireBugWebhook).toHaveBeenCalledWith(
+      "fix.completed",
+      expect.objectContaining({
+        projectId: "p1",
+        fixRunId: "run1",
+        bug: expect.objectContaining({ id: "b1", identifier: "BCT-B1", state: "fixed" }),
+      }),
+    );
+    expect(payload.ok).toBe(true);
+    expect(payload.bugState).toBe("fixed");
+  });
+
+  it("failed：不改 Bug.state（留人工裁决），webhook 照发", async () => {
+    setupRun();
+    const { payload } = await callTool(TOOL_NAMES.reportResult, {
+      bugId: "b1",
+      result: "failed",
+      summary: "修复引入回归，已回滚",
+    });
+    expect(mocks.bugUpdate).not.toHaveBeenCalled();
+    expect(mocks.fixRunUpdateMany).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: "completed" }) }),
+    );
+    expect(mocks.fireBugWebhook).toHaveBeenCalledWith(
+      "fix.completed",
+      expect.objectContaining({
+        bug: expect.objectContaining({ id: "b1", state: "open" }), // failed 不改 state
+      }),
+    );
+    expect(payload.bugState).toBe("open"); // 保持原状态
+  });
+
+  it("cannot_reproduce：不改 Bug.state，提示可发起 AI 复现交叉验证", async () => {
+    setupRun("claimed");
+    const { payload } = await callTool(TOOL_NAMES.reportResult, {
+      bugId: "b1",
+      result: "cannot_reproduce",
+      summary: "本地无法复现",
+    });
+    expect(mocks.bugUpdate).not.toHaveBeenCalled();
+    expect(payload.hint).toContain("AI 复现");
+  });
+
+  it("重复上报：run 已 completed（updateMany count=0）→ isError 防重复落账", async () => {
+    setupRun();
+    mocks.fixRunUpdateMany.mockResolvedValueOnce({ count: 0 });
+    const { raw } = await callTool(TOOL_NAMES.reportResult, {
+      bugId: "b1",
+      result: "fixed",
+      summary: "x",
+    });
+    expect(raw.isError).toBe(true);
+    expect(mocks.bugUpdate).not.toHaveBeenCalled();
+    expect(mocks.fireBugWebhook).not.toHaveBeenCalled();
+  });
+
+  it("run 仍 pending（未认领）→ isError 引导先 claim_fix", async () => {
+    setupRun("pending");
+    const { raw } = await callTool(TOOL_NAMES.reportResult, {
+      bugId: "b1",
+      result: "fixed",
+      summary: "x",
+    });
+    expect(raw.isError).toBe(true);
+    expect(mocks.fixRunUpdateMany).not.toHaveBeenCalled();
+  });
+});
+
+// ── list_events：样本列表 + 分页上限 ──
+describe("list_events", () => {
+  it("返回事件样本（occurTime desc），limit 显式传 50", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(BUG_P1);
+    mocks.bugEventFindMany.mockResolvedValueOnce(
+      Array.from({ length: 2 }, (_, i) => ({ id: `ev${i}`, occurTime: now, rawPayload: {} })),
+    );
+    const { payload } = await callTool(TOOL_NAMES.listEvents, { bugId: "b1", limit: 50 });
+    expect(mocks.bugEventFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { bugId: "b1" }, take: 50, orderBy: { occurTime: "desc" } }),
+    );
+    expect(payload.events).toHaveLength(2);
+  });
+
+  it("limit > 50 → isError（分页上限 50）", async () => {
+    const { raw } = await callTool(TOOL_NAMES.listEvents, { bugId: "b1", limit: 51 });
+    expect(raw.isError).toBe(true);
+    expect(mocks.bugEventFindMany).not.toHaveBeenCalled();
+  });
+
+  it("越权 bugId → isError", async () => {
+    mocks.bugFindFirst.mockResolvedValueOnce(null);
+    const { raw } = await callTool(TOOL_NAMES.listEvents, { bugId: "b-other" });
+    expect(raw.isError).toBe(true);
+  });
+});
+
+// ══ 任务 24：MCP test 域四工具（规格 §8.2 钉死契约）══
+
+const SNAPSHOT = {
+  title: "登录成功跳转工作台",
+  precondition: null,
+  steps: { steps: [{ order: 1, action: "打开登录页" }, { order: 2, action: "输入账密提交" }] },
+  priority: "p1",
+  type: "functional",
+};
+
+const TEST_RUN = {
+  id: "tr1",
+  projectId: "p1",
+  planId: null,
+  name: "冒烟批次",
+  trigger: "ai",
+  executorType: "ai_agent",
+  targetEnv: "https://staging.example.com",
+  status: "running",
+  summary: null,
+  startedAt: now,
+  completedAt: null,
+  createdById: "u1", // AI 回报的 run 完成活动归属批次创建人
+  createdAt: now,
+};
+
+const RUN_CASE = {
+  id: "rc1",
+  runId: "tr1",
+  caseId: "tc1",
+  caseVersion: 1,
+  caseSnapshot: SNAPSHOT,
+  status: "untested",
+  stepResults: null,
+  actualResult: null,
+  bugId: null,
+  execRunId: null,
+  flaky: false,
+  fingerprint: null,
+  startedAt: null,
+  finishedAt: null,
+  durationMs: null,
+  executedById: null,
+};
+
+const execRunRow = (overrides: Record<string, unknown> = {}) => ({
+  id: "er1",
+  runCaseId: "rc1",
+  mode: "browser",
+  status: "claimed",
+  agentName: "opencode",
+  report: { perStep: [] },
+  error: null,
+  claimedAt: now,
+  completedAt: null,
+  createdAt: now,
+  ...overrides,
+});
+
+/** setupReport：报步/报结果共用的前置加载桩（runCase + run + execRun 全部就绪） */
+const setupReport = (
+  execRun: Record<string, unknown> = {},
+  runCase: Record<string, unknown> = {},
+) => {
+  mocks.testRunCaseFindUnique.mockResolvedValue({ ...RUN_CASE, execRunId: "er1", ...runCase });
+  mocks.testRunFindUnique.mockResolvedValue(TEST_RUN);
+  mocks.execRunFindUnique.mockResolvedValue(execRunRow(execRun));
+};
+
+// ── scope 分流（§8.1）：一个 token 只见自己 scope 的 tools ──
+describe("test 域 scope 分流", () => {
+  it("TOOLS_BY_SCOPE：bug.mcp → 六 bug 工具 | test.exec → 四 test 工具", () => {
+    expect(TOOLS_BY_SCOPE["bug.mcp"]).toBe(BUG_MCP_TOOLS);
+    expect(TOOLS_BY_SCOPE["test.exec"]).toBe(TEST_MCP_TOOLS);
+    expect(TOOLS_BY_SCOPE["test.exec"].map((t) => t.name)).toEqual([
+      TOOL_NAMES.listPendingExecs,
+      TOOL_NAMES.claimExec,
+      TOOL_NAMES.reportStep,
+      TOOL_NAMES.reportExecResult,
+    ]);
+  });
+
+  it("tools/list（test.exec ctx）：四工具且 inputSchema 为合法 JSON Schema", async () => {
+    const res = await handleMcpRequest(
+      JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+      testCtx,
+    );
+    const body = await res.json();
+    expect(body.result.tools.map((t: { name: string }) => t.name)).toEqual([
+      TOOL_NAMES.listPendingExecs,
+      TOOL_NAMES.claimExec,
+      TOOL_NAMES.reportStep,
+      TOOL_NAMES.reportExecResult,
+    ]);
+    const byName = Object.fromEntries(
+      body.result.tools.map((t: { name: string; inputSchema: Record<string, unknown> }) => [
+        t.name,
+        t,
+      ]),
+    );
+    // 契约形状钉死（§8.2 入参面）：verdict 三值枚举、claim 必填对、limit 上限 50
+    const step = byName[TOOL_NAMES.reportStep].inputSchema;
+    expect(step.properties.status.enum).toEqual(["pass", "fail", "uncertain"]);
+    expect(step.required).toEqual(["runCaseId", "order", "status", "observed"]);
+    const result = byName[TOOL_NAMES.reportExecResult].inputSchema;
+    expect(result.properties.finalVerdict.enum).toEqual(["pass", "fail", "uncertain"]);
+    expect(result.required).toEqual(["runCaseId", "finalVerdict", "summaryText"]);
+    expect(byName[TOOL_NAMES.claimExec].inputSchema.required).toEqual(["runCaseId", "agentName"]);
+    expect(byName[TOOL_NAMES.listPendingExecs].inputSchema.properties.limit.maximum).toBe(50);
+    for (const tool of body.result.tools) {
+      expect(() => JSON.parse(JSON.stringify(tool.inputSchema))).not.toThrow();
+    }
+  });
+});
+
+// ── list_pending_execs：只返 untested + run running + 未认领 ──
+describe("list_pending_execs", () => {
+  it("无 runId：项目内全部 running 批次的 untested 且未认领用例，claimed 恒 false", async () => {
+    mocks.testRunCaseFindMany.mockResolvedValueOnce([
+      { id: "rc1", runId: "tr1", caseSnapshot: SNAPSHOT, run: { targetEnv: TEST_RUN.targetEnv } },
+    ]);
+    const { payload } = await callTool(TOOL_NAMES.listPendingExecs, {}, testCtx);
+    expect(mocks.testRunCaseFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: {
+          status: "untested",
+          execRunId: null,
+          run: { projectId: "p1", status: "running" },
+        },
+        orderBy: { id: "asc" }, // cuid 单调 = 快照创建序（TestRunCase 无 createdAt 列）
+        take: 20, // 默认 limit
+      }),
+    );
+    expect(payload.items).toEqual([
+      {
+        runCaseId: "rc1",
+        runId: "tr1",
+        caseSnapshot: SNAPSHOT,
+        targetEnv: TEST_RUN.targetEnv,
+        claimed: false,
+      },
+    ]);
+  });
+
+  it("runId 限定：run 归属项目边界（越权/不存在 → isError）", async () => {
+    mocks.testRunFindFirst.mockResolvedValueOnce(TEST_RUN);
+    await callTool(TOOL_NAMES.listPendingExecs, { runId: "tr1" }, testCtx);
+    expect(mocks.testRunFindFirst).toHaveBeenCalledWith({
+      where: { id: "tr1", projectId: "p1" },
+      select: { id: true },
+    });
+    expect(mocks.testRunCaseFindMany.mock.calls[0][0].where.run).toEqual({
+      projectId: "p1",
+      status: "running",
+      id: "tr1",
+    });
+  });
+
+  it("runId 不存在或属他项目 → isError 不泄漏存在性", async () => {
+    mocks.testRunFindFirst.mockResolvedValueOnce(null);
+    const { raw, payload } = await callTool(
+      TOOL_NAMES.listPendingExecs,
+      { runId: "tr-other" },
+      testCtx,
+    );
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("不存在或无权访问");
+    expect(mocks.testRunCaseFindMany).not.toHaveBeenCalled();
+  });
+
+  it("limit=3 显式传递；limit>50 → isError（schema 拦截）", async () => {
+    mocks.testRunCaseFindMany.mockResolvedValue([]);
+    await callTool(TOOL_NAMES.listPendingExecs, { limit: 3 }, testCtx);
+    expect(mocks.testRunCaseFindMany.mock.calls[0][0].take).toBe(3);
+    const { raw } = await callTool(TOOL_NAMES.listPendingExecs, { limit: 99 }, testCtx);
+    expect(raw.isError).toBe(true);
+  });
+});
+
+// ── claim_exec：建 ExecRun + 原子回填（审查重点 2）──
+describe("claim_exec", () => {
+  it("untested 用例 → 建 TestExecRun(claimed) + 条件回填 execRunId（updateMany where execRunId null）", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(RUN_CASE);
+    mocks.testRunFindUnique.mockResolvedValueOnce(TEST_RUN);
+    const { payload } = await callTool(
+      TOOL_NAMES.claimExec,
+      { runCaseId: "rc1", agentName: "opencode" },
+      testCtx,
+    );
+    expect(mocks.execRunCreate).toHaveBeenCalledWith({
+      data: { runCaseId: "rc1", agentName: "opencode", status: "claimed" },
+    });
+    // 原子语义：execRunId 仍为 null 才回填——count=0 即已被并发认领
+    expect(mocks.testRunCaseUpdateMany).toHaveBeenCalledWith({
+      where: { id: "rc1", execRunId: null, status: "untested" },
+      data: { execRunId: "er1" },
+    });
+    expect(payload.ok).toBe(true);
+    expect(payload).toEqual(
+      expect.objectContaining({
+        runCaseId: "rc1",
+        execRunId: "er1",
+        runId: "tr1",
+        status: "claimed",
+        agentName: "opencode",
+      }),
+    );
+  });
+
+  it("审查重点 2：已被并发认领（updateMany count=0）→ JSON-RPC error -32001", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(RUN_CASE);
+    mocks.testRunFindUnique.mockResolvedValueOnce(TEST_RUN);
+    mocks.testRunCaseUpdateMany.mockResolvedValueOnce({ count: 0 }); // 条件更新未命中 = 已被抢
+    const body = await callToolRaw(
+      TOOL_NAMES.claimExec,
+      { runCaseId: "rc1", agentName: "claude" },
+      testCtx,
+    );
+    expect(body.result).toBeUndefined();
+    expect(body.error?.code).toBe(-32001);
+    expect(body.error?.message).toContain("已被认领");
+  });
+
+  it("runCaseId 越权/不存在 → 工具级 isError", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(null);
+    const { raw } = await callTool(
+      TOOL_NAMES.claimExec,
+      { runCaseId: "rc-other", agentName: "opencode" },
+      testCtx,
+    );
+    expect(raw.isError).toBe(true);
+    expect(mocks.execRunCreate).not.toHaveBeenCalled();
+  });
+
+  it("run 非运行态（completed/aborted）→ isError 拒绝认领", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(RUN_CASE);
+    mocks.testRunFindUnique.mockResolvedValueOnce({ ...TEST_RUN, status: "completed" });
+    const { raw, payload } = await callTool(
+      TOOL_NAMES.claimExec,
+      { runCaseId: "rc1", agentName: "opencode" },
+      testCtx,
+    );
+    expect(raw.isError).toBe(true);
+    expect(payload.message).toContain("批次");
+    expect(mocks.execRunCreate).not.toHaveBeenCalled();
+  });
+
+  it("用例已有终态（非 untested）→ isError 拒绝认领", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce({ ...RUN_CASE, status: "passed" });
+    mocks.testRunFindUnique.mockResolvedValueOnce(TEST_RUN);
+    const { raw } = await callTool(
+      TOOL_NAMES.claimExec,
+      { runCaseId: "rc1", agentName: "opencode" },
+      testCtx,
+    );
+    expect(raw.isError).toBe(true);
+    expect(mocks.execRunCreate).not.toHaveBeenCalled();
+  });
+});
+
+// ── report_step：追加 perStep + stepResults 同步 ──
+describe("report_step", () => {
+  it("追加 report.perStep（action 取自快照）+ RunCase.stepResults 同步；已 running 保持不重置 startedAt", async () => {
+    setupReport(
+      {
+        status: "running",
+        report: { perStep: [{ order: 1, action: "打开登录页", observed: "页面已打开", verdict: "pass" }] },
+      },
+      { stepResults: [{ order: 1, status: "pass" }], startedAt: now },
+    );
+    const { payload } = await callTool(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 2, status: "fail", observed: "提交后无跳转", screenshotBlobId: "blob002" },
+      testCtx,
+    );
+    // ExecRun：条件更新（claimed|running 才生效）+ 状态保持 running
+    expect(mocks.execRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "er1", status: { in: ["claimed", "running"] } },
+      data: {
+        status: "running",
+        report: {
+          perStep: [
+            { order: 1, action: "打开登录页", observed: "页面已打开", verdict: "pass" },
+            { order: 2, action: "输入账密提交", observed: "提交后无跳转", verdict: "fail", screenshotBlobId: "blob002" },
+          ],
+        },
+      },
+    });
+    // RunCase.stepResults 增量合并（observed 映射 actual，与人工 DTO 同形）；startedAt 不重置
+    const data = (mocks.testRunCaseUpdate.mock.calls[0] as [{ data: Record<string, unknown> }])[0].data;
+    expect(data.stepResults).toEqual([
+      { order: 1, status: "pass" },
+      { order: 2, status: "fail", actual: "提交后无跳转" },
+    ]);
+    expect(data.startedAt).toBeUndefined();
+    expect(payload.ok).toBe(true);
+    expect(payload.perStepCount).toBe(2);
+  });
+
+  it("首步：claimed→running 转移 + RunCase 首次置 startedAt", async () => {
+    setupReport();
+    await callTool(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 1, status: "pass", observed: "ok" },
+      testCtx,
+    );
+    expect(mocks.execRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "er1", status: { in: ["claimed", "running"] } },
+      data: expect.objectContaining({ status: "running" }),
+    });
+    expect(mocks.testRunCaseUpdate).toHaveBeenCalledWith({
+      where: { id: "rc1" },
+      data: expect.objectContaining({
+        stepResults: [{ order: 1, status: "pass", actual: "ok" }],
+        startedAt: expect.any(Date),
+      }),
+    });
+  });
+
+  it("uncertain 步骤：stepResults 以 verdict 原值落盘（AI 值域扩展，不映射人工四值）", async () => {
+    setupReport();
+    await callTool(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 1, status: "uncertain", observed: "弹窗文案不明确" },
+      testCtx,
+    );
+    expect(mocks.testRunCaseUpdate).toHaveBeenCalledWith({
+      where: { id: "rc1" },
+      data: expect.objectContaining({
+        stepResults: [{ order: 1, status: "uncertain", actual: "弹窗文案不明确" }],
+      }),
+    });
+  });
+
+  it("审查重点 5：对非 claimed（timeout_reclaimed 等终态）ExecRun 报步 → JSON-RPC -32002", async () => {
+    setupReport({ status: "timeout_reclaimed" });
+    const body = await callToolRaw(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 1, status: "pass", observed: "迟到上报" },
+      testCtx,
+    );
+    expect(body.result).toBeUndefined();
+    expect(body.error?.code).toBe(-32002);
+    expect(mocks.testRunCaseUpdate).not.toHaveBeenCalled();
+  });
+
+  it("ExecRun 未建（execRunId null，从未认领）→ JSON-RPC -32002", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(RUN_CASE); // execRunId: null
+    mocks.testRunFindUnique.mockResolvedValueOnce(TEST_RUN);
+    const body = await callToolRaw(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 1, status: "pass", observed: "x" },
+      testCtx,
+    );
+    expect(body.error?.code).toBe(-32002);
+    expect(mocks.execRunUpdateMany).not.toHaveBeenCalled();
+  });
+
+  it("order 不在快照步骤白名单 → isError（快照锁定）", async () => {
+    setupReport();
+    const { raw } = await callTool(
+      TOOL_NAMES.reportStep,
+      { runCaseId: "rc1", order: 9, status: "pass", observed: "x" },
+      testCtx,
+    );
+    expect(raw.isError).toBe(true);
+    expect(mocks.execRunUpdateMany).not.toHaveBeenCalled();
+  });
+});
+
+// ── report_exec_result：恒置终态（R16）+ 复用 finalize 管道 ──
+describe("report_exec_result", () => {
+  it.each([
+    ["pass", "passed"],
+    ["fail", "failed"],
+    ["uncertain", "retest"],
+  ])("R16 恒置终态：finalVerdict=%s → RunCase.status=%s（不读 run.status）", async (verdict, expected) => {
+    setupReport({ report: { perStep: [{ order: 1, action: "打开登录页", observed: "ok", verdict: "pass" }] } });
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: verdict, summaryText: "执行完成" },
+      testCtx,
+    );
+    expect(mocks.testRunCaseUpdate).toHaveBeenCalledWith({
+      where: { id: "rc1" },
+      data: expect.objectContaining({
+        status: expected,
+        finishedAt: expect.any(Date),
+        actualResult: "执行完成",
+      }),
+    });
+    expect(payload.ok).toBe(true);
+    expect(payload.runCaseStatus).toBe(expected);
+  });
+
+  it("任务 32 flaky：首次失败（无历史终局）→ failed + 事务后调度回池重试（flakyDecision=retry）", async () => {
+    setupReport();
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "fail", summaryText: "首跑失败" },
+      testCtx,
+    );
+    expect(mocks.testRunCaseUpdate).toHaveBeenCalledWith({
+      where: { id: "rc1" },
+      data: expect.objectContaining({ status: "failed" }),
+    });
+    expect(mocks.scheduleFlakyRetry).toHaveBeenCalledWith({
+      runId: "tr1",
+      runCaseId: "rc1",
+      execRunId: "er1",
+    });
+    expect(payload.flakyDecision).toBe("retry");
+  });
+
+  it("任务 32 flaky：两次一致 failed（历史含 fail）→ 不再重试进归因队列（flakyDecision=triage）", async () => {
+    setupReport();
+    // 执行历史：首跑已 fail（TestExecRun.report.finalVerdict，任务 24 起落账）
+    mocks.execRunFindMany.mockResolvedValue([{ report: { perStep: [], finalVerdict: "fail" } }]);
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "fail", summaryText: "复跑仍失败" },
+      testCtx,
+    );
+    const update = mocks.testRunCaseUpdate.mock.calls[0][0] as {
+      data: Record<string, unknown>;
+    };
+    expect(update.data).toEqual(
+      expect.objectContaining({ status: "failed" }),
+    );
+    expect(update.data).not.toHaveProperty("flaky"); // triage 队列口径：failed 非 flaky
+    expect(mocks.scheduleFlakyRetry).not.toHaveBeenCalled();
+    expect(payload.flakyDecision).toBe("triage");
+  });
+
+  it("任务 32 flaky：重跑后 pass（历史含 fail）→ 两态不一致 mark_flaky：retest + flaky=true（不转 bug 不计指纹）", async () => {
+    setupReport();
+    mocks.execRunFindMany.mockResolvedValue([{ report: { perStep: [], finalVerdict: "fail" } }]);
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "复跑通过" },
+      testCtx,
+    );
+    const update = mocks.testRunCaseUpdate.mock.calls[0][0] as {
+      data: Record<string, unknown>;
+    };
+    expect(update.data).toEqual(expect.objectContaining({ status: "retest", flaky: true }));
+    expect(update.data).not.toHaveProperty("fingerprint"); // 不计指纹
+    expect(mocks.bugCreate).not.toHaveBeenCalled(); // 不转 bug（任务 33 转 bug 路径的回归防线）
+    expect(mocks.scheduleFlakyRetry).not.toHaveBeenCalled();
+    expect(payload.flakyDecision).toBe("mark_flaky");
+    expect(payload.runCaseStatus).toBe("retest"); // payload 反映实际落库终态
+  });
+
+  it("ExecRun → completed + report 合并 finalVerdict/consoleLog/networkLog（perStep 保留）", async () => {
+    setupReport({
+      report: { perStep: [{ order: 1, action: "打开登录页", observed: "ok", verdict: "pass" }] },
+    });
+    await callTool(
+      TOOL_NAMES.reportExecResult,
+      {
+        runCaseId: "rc1",
+        finalVerdict: "fail",
+        consoleLog: ["TypeError: x is not a function"],
+        networkLog: ["POST /api/login 500"],
+        summaryText: "提交后接口 500",
+      },
+      testCtx,
+    );
+    expect(mocks.execRunUpdateMany).toHaveBeenCalledWith({
+      where: { id: "er1", status: { in: ["claimed", "running"] } },
+      data: {
+        status: "completed",
+        completedAt: expect.any(Date),
+        report: {
+          perStep: [{ order: 1, action: "打开登录页", observed: "ok", verdict: "pass" }],
+          consoleLog: ["TypeError: x is not a function"],
+          networkLog: ["POST /api/login 500"],
+          finalVerdict: "fail",
+        },
+      },
+    });
+  });
+
+  it("run 全部终态 → finalizeRunIfComplete 落 run completed + summary + 活动 + webhook（任务 14/15 管道复用）", async () => {
+    setupReport({ status: "running" });
+    // finalize 阶段：全量 RunCase 已终态（含本例即将写入的 passed）
+    mocks.testRunCaseFindMany.mockResolvedValue([{ status: "passed" }, { status: "passed" }]);
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "全过" },
+      testCtx,
+    );
+    expect(mocks.testRunUpdate).toHaveBeenCalledWith({
+      where: { id: "tr1" },
+      data: expect.objectContaining({
+        status: "completed",
+        completedAt: expect.any(Date),
+        summary: expect.objectContaining({ total: 2, passed: 2 }),
+      }),
+    });
+    expect(mocks.projectActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        projectId: "p1",
+        userId: "u1", // agent 无登录用户，活动归属批次创建人（ProjectActivity.userId 非空）
+        action: "completed",
+        targetType: "testrun",
+        targetId: "tr1",
+      }),
+    });
+    expect(mocks.fireTestRunWebhook).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "p1",
+        run: expect.objectContaining({ id: "tr1", name: "冒烟批次" }),
+        summary: expect.objectContaining({ total: 2, passed: 2 }),
+      }),
+    );
+    expect(payload.runCompleted).toBe(true);
+    expect(payload.summary).toEqual(expect.objectContaining({ total: 2 }));
+  });
+
+  it("存在未终态 RunCase → 不落 run completed、不产活动、不发 webhook", async () => {
+    setupReport();
+    mocks.testRunCaseFindMany.mockResolvedValue([{ status: "passed" }, { status: "untested" }]);
+    const { payload } = await callTool(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "x" },
+      testCtx,
+    );
+    expect(mocks.testRunUpdate).not.toHaveBeenCalled();
+    expect(mocks.projectActivityCreate).not.toHaveBeenCalled();
+    expect(mocks.fireTestRunWebhook).not.toHaveBeenCalled();
+    expect(payload.runCompleted).toBe(false);
+  });
+
+  it("审查重点 5：对非 claimed ExecRun 报终局（守卫读态已 completed / 条件更新 count=0 双路）→ JSON-RPC -32002", async () => {
+    // 路径一：守卫读态非活跃（timeout_reclaimed/completed 等）→ 读态即拒
+    setupReport({ status: "timeout_reclaimed" });
+    const guarded = await callToolRaw(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "迟到上报" },
+      testCtx,
+    );
+    expect(guarded.error?.code).toBe(-32002);
+    expect(mocks.testRunCaseUpdate).not.toHaveBeenCalled();
+    // 路径二：读态 claimed 但条件更新 count=0（并发完结/回收赢得竞态）→ 条件更新即拒
+    setupReport();
+    mocks.execRunUpdateMany.mockResolvedValueOnce({ count: 0 });
+    const raced = await callToolRaw(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "重复上报" },
+      testCtx,
+    );
+    expect(raced.error?.code).toBe(-32002);
+    expect(mocks.testRunCaseUpdate).not.toHaveBeenCalled();
+    expect(mocks.fireTestRunWebhook).not.toHaveBeenCalled();
+  });
+
+  it("ExecRun 未建（execRunId null）→ JSON-RPC -32002", async () => {
+    mocks.testRunCaseFindUnique.mockResolvedValueOnce(RUN_CASE);
+    mocks.testRunFindUnique.mockResolvedValueOnce(TEST_RUN);
+    const body = await callToolRaw(
+      TOOL_NAMES.reportExecResult,
+      { runCaseId: "rc1", finalVerdict: "pass", summaryText: "x" },
+      testCtx,
+    );
+    expect(body.error?.code).toBe(-32002);
+    expect(mocks.execRunUpdateMany).not.toHaveBeenCalled();
+  });
+});