@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/serverFns/testcase/__tests__/testcase-crud.test.ts

@@ -28,7 +28,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 const H = vi.hoisted(() => {
   const fns = {
     requireAuth: vi.fn(),
-    resolveStoryScopeProjectId: vi.fn(),
+    resolveStoryScopeProjectIds: vi.fn(),
     isUserInTeam: vi.fn(),
   };
   const db = {
@@ -44,6 +44,9 @@ const H = vi.hoisted(() => {
     storyFindUnique: vi.fn(),
     memberFindUnique: vi.fn(),
     runCaseCount: vi.fn(),
+    collabDocumentFindUnique: vi.fn(),
+    collabDocumentUpdateMany: vi.fn(),
+    collabDocumentDeleteMany: vi.fn(),
     projectActivityCreate: vi.fn(),
     transaction: vi.fn(),
   };
@@ -63,6 +66,13 @@ const H = vi.hoisted(() => {
     projectMember: { findUnique: db.memberFindUnique },
     testRunCase: { count: db.runCaseCount },
     projectActivity: { create: db.projectActivityCreate },
+    // 任务 22 写入门卫快照检查：恒 null = 无快照 pass-through（非协同态零行为变化）
+    // R11 touch（updateMany）/ §5.2 删除清理（deleteMany）共形
+    collabDocument: {
+      findUnique: db.collabDocumentFindUnique,
+      updateMany: db.collabDocumentUpdateMany,
+      deleteMany: db.collabDocumentDeleteMany,
+    },
     $transaction: db.transaction,
   };
   return { fns, db, prisma };
@@ -102,7 +112,7 @@ vi.mock("@allbluecn/database/get-prisma", () => ({
 
 vi.mock("@/server/auth-helpers", () => ({ requireAuth: H.fns.requireAuth }));
 vi.mock("@/server/builtin-project", () => ({
-  resolveStoryScopeProjectId: H.fns.resolveStoryScopeProjectId,
+  resolveStoryScopeProjectIds: H.fns.resolveStoryScopeProjectIds,
 }));
 vi.mock("@/server/team-access", () => ({ isUserInTeam: H.fns.isUserInTeam }));
 
@@ -161,12 +171,14 @@ beforeEach(() => {
   vi.clearAllMocks();
   M.requireAuth.mockResolvedValue({ user: { id: U } });
   M.isUserInTeam.mockResolvedValue(true);
+  DB.collabDocumentUpdateMany.mockResolvedValue({ count: 0 });
+  DB.collabDocumentDeleteMany.mockResolvedValue({ count: 0 });
   mockTx();
 });
 
 describe("listTestCasesFn", () => {
   it("基础查询：走 scope 解析、where 默认排除归档、sequenceId 升序、无 cursor 无 skip", async () => {
-    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+    M.resolveStoryScopeProjectIds.mockResolvedValue([P]);
     const rows = [caseRow(), caseRow({ id: "c-2", sequenceId: 2, identifier: "ABC-TC2" })];
     DB.caseFindMany.mockResolvedValue(rows);
 
@@ -175,11 +187,11 @@ describe("listTestCasesFn", () => {
       nextCursor: string | null;
     };
 
-    expect(M.resolveStoryScopeProjectId).toHaveBeenCalledWith(P, U);
+    expect(M.resolveStoryScopeProjectIds).toHaveBeenCalledWith(P, U);
     expect(DB.caseFindMany).toHaveBeenCalledWith(
       expect.objectContaining({
-        where: { projectId: P, archived: false },
-        orderBy: [{ sequenceId: "asc" }],
+        where: { projectId: { in: [P] }, archived: false },
+        orderBy: [{ sequenceId: "asc" }, { id: "asc" }],
         take: 50,
       }),
     );
@@ -191,7 +203,7 @@ describe("listTestCasesFn", () => {
   });
 
   it("archived=true 仅查归档用例（where.archived=true）", async () => {
-    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+    M.resolveStoryScopeProjectIds.mockResolvedValue([P]);
     DB.caseFindMany.mockResolvedValue([]);
 
     await listTestCasesFn({ data: { projectId: P, archived: true } });
@@ -202,7 +214,7 @@ describe("listTestCasesFn", () => {
   });
 
   it("cursor 分页：传 cursor 时 skip:1 + cursor:{id}，满页时 nextCursor=最后一条 id", async () => {
-    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+    M.resolveStoryScopeProjectIds.mockResolvedValue([P]);
     const rows = [caseRow({ id: "c-2", sequenceId: 2 }), caseRow({ id: "c-3", sequenceId: 3 })];
     DB.caseFindMany.mockResolvedValue(rows);
 
@@ -217,7 +229,7 @@ describe("listTestCasesFn", () => {
   });
 
   it("多筛选叠加（folderId/state/type/priority/automation/assigneeId/storyId/searchText）收敛 where", async () => {
-    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+    M.resolveStoryScopeProjectIds.mockResolvedValue([P]);
     DB.caseFindMany.mockResolvedValue([]);
 
     await listTestCasesFn({
@@ -236,7 +248,7 @@ describe("listTestCasesFn", () => {
 
     expect(DB.caseFindMany).toHaveBeenCalledWith({
       where: {
-        projectId: P,
+        projectId: { in: [P] },
         archived: false,
         folderId: "f-1",
         state: "approved",
@@ -250,20 +262,22 @@ describe("listTestCasesFn", () => {
           { identifier: { contains: "登录", mode: "insensitive" } },
         ],
       },
-      orderBy: [{ sequenceId: "asc" }],
+      orderBy: [{ sequenceId: "asc" }, { id: "asc" }],
       take: 50,
       select: expect.objectContaining({ id: true, version: true, identifier: true }),
     });
   });
 
   it("非成员/无效项目：where 用回退后的独立项目 id（防越权）", async () => {
-    M.resolveStoryScopeProjectId.mockResolvedValue("pr-independent");
+    M.resolveStoryScopeProjectIds.mockResolvedValue(["pr-independent"]);
     DB.caseFindMany.mockResolvedValue([]);
 
     await listTestCasesFn({ data: { projectId: "pr-other" } });
 
     expect(DB.caseFindMany).toHaveBeenCalledWith(
-      expect.objectContaining({ where: { projectId: "pr-independent", archived: false } }),
+      expect.objectContaining({
+        where: { projectId: { in: ["pr-independent"] }, archived: false },
+      }),
     );
   });
 });
@@ -435,6 +449,36 @@ describe("updateTestCaseFn", () => {
     });
   });
 
+  // R11 touch 不变式（审查 Important 1）：生效直写不含 Y 属主面时同事务
+  // touch 快照；含 Y 属主面的直写保持旁路语义不 touch
+
+  it("纯非 Y patch（automation）→ 同事务 touch 快照（updatedAt = 回读行值）", async () => {
+    memberOk();
+    DB.caseFindUnique.mockResolvedValue(caseRow({ automation: "none" }));
+    const TOUCH_AT = new Date("2026-04-04T00:00:00Z");
+    DB.caseUpdate.mockResolvedValue(caseRow({ automation: "e2e", updatedAt: TOUCH_AT }));
+    DB.collabDocumentUpdateMany.mockResolvedValue({ count: 1 });
+
+    await updateTestCaseFn({ data: { id: "c-1", automation: "e2e" } });
+
+    expect(DB.caseUpdate).toHaveBeenCalled();
+    expect(DB.collabDocumentUpdateMany).toHaveBeenCalledWith({
+      where: { roomName: "entity:case:c-1" },
+      data: { updatedAt: TOUCH_AT },
+    });
+  });
+
+  it("含 Y 属主面的直写（state）→ 不 touch（旁路反超语义）", async () => {
+    memberOk();
+    DB.caseFindUnique.mockResolvedValue(caseRow());
+    DB.caseUpdate.mockResolvedValue(caseRow({ state: "deprecated" }));
+
+    await updateTestCaseFn({ data: { id: "c-1", state: "deprecated" } });
+
+    expect(DB.caseUpdate).toHaveBeenCalled();
+    expect(DB.collabDocumentUpdateMany).not.toHaveBeenCalled();
+  });
+
   it("字段值与现值相同时零 update（无变化不空转，也不留活动）", async () => {
     memberOk();
     DB.caseFindUnique.mockResolvedValue(caseRow({ title: "同标题" }));
@@ -555,7 +599,7 @@ describe("deleteTestCaseFn", () => {
     expect(DB.caseDelete).not.toHaveBeenCalled();
   });
 
-  it("无引用时删除成功并落 deleted 活动（targetType=testcase）", async () => {
+  it("无引用时删除成功并落 deleted 活动，且同事务清理协同快照行（§5.2 幽灵 room 防务）", async () => {
     memberOk();
     DB.caseFindUnique.mockResolvedValue(caseRow());
     DB.runCaseCount.mockResolvedValue(0);
@@ -564,6 +608,10 @@ describe("deleteTestCaseFn", () => {
     const out = (await deleteTestCaseFn({ data: { id: "c-1" } })) as { success: boolean };
 
     expect(DB.caseDelete).toHaveBeenCalledWith({ where: { id: "c-1" } });
+    // Important 3：实体删后快照行必删（room 命名与 collab-core 注册表一致）
+    expect(DB.collabDocumentDeleteMany).toHaveBeenCalledWith({
+      where: { roomName: "entity:case:c-1" },
+    });
     expect(DB.projectActivityCreate).toHaveBeenCalledWith({
       data: {
         projectId: P,

package/src/server/serverFns/testcase/__tests__/testcase-groups.test.ts

@@ -27,7 +27,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 const H = vi.hoisted(() => {
   const fns = {
     requireAuth: vi.fn(),
-    resolveStoryScopeProjectId: vi.fn(),
+    resolveStoryScopeProjectIds: vi.fn(),
   };
   const db = {
     caseGroupBy: vi.fn(),
@@ -82,7 +82,7 @@ vi.mock("@allbluecn/database/get-prisma", () => ({
 
 vi.mock("@/server/auth-helpers", () => ({ requireAuth: H.fns.requireAuth }));
 vi.mock("@/server/builtin-project", () => ({
-  resolveStoryScopeProjectId: H.fns.resolveStoryScopeProjectId,
+  resolveStoryScopeProjectIds: H.fns.resolveStoryScopeProjectIds,
 }));
 
 import {
@@ -94,6 +94,7 @@ import {
   updateFilterViewFn,
   deleteFilterViewFn,
 } from "../testcase-filter-views";
+import { TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } from "@/components/testcase/display/field-configs";
 
 const U = "u-1";
 const P = "pr-1";
@@ -103,7 +104,7 @@ const DATE = new Date("2026-01-01T00:00:00Z");
 beforeEach(() => {
   vi.clearAllMocks();
   M.requireAuth.mockResolvedValue({ user: { id: U } });
-  M.resolveStoryScopeProjectId.mockResolvedValue(P);
+  M.resolveStoryScopeProjectIds.mockResolvedValue([P]);
 });
 
 // ── listGroupsFn：分组统计计数 ──
@@ -119,10 +120,10 @@ describe("listGroupsFn", () => {
       groups: { key: string; label: string; count: number }[];
     };
 
-    expect(M.resolveStoryScopeProjectId).toHaveBeenCalledWith(P, U);
+    expect(M.resolveStoryScopeProjectIds).toHaveBeenCalledWith(P, U);
     expect(DB.caseGroupBy).toHaveBeenCalledWith({
       by: ["state"],
-      where: { projectId: P, archived: false },
+      where: { projectId: { in: [P] }, archived: false },
       _count: { _all: true },
     });
     // 仅返回库内实际存在的分组（空组不返回），顺序按枚举序
@@ -197,7 +198,7 @@ describe("listGroupsFn", () => {
     expect(DB.caseGroupBy).toHaveBeenCalledWith({
       by: ["priority"],
       where: {
-        projectId: P,
+        projectId: { in: [P] },
         archived: false,
         folderId: "f-1",
         state: "draft",
@@ -252,7 +253,7 @@ describe("listFilterViewsFn", () => {
     }[];
 
     expect(DB.viewFindMany).toHaveBeenCalledWith({
-      where: { userId: U },
+      where: { userId: U, name: { not: TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } },
       orderBy: { sortOrder: "asc" },
       select: {
         id: true,
@@ -272,6 +273,18 @@ describe("listFilterViewsFn", () => {
     expect(out[0].createdAt).toBe("2026-01-01T00:00:00.000Z");
     expect(out[0].filters).toEqual({ state: "draft" });
   });
+
+  it("存量 displayOptions.view=\"table\" 读取回落 \"list\"（任务 27 移除表格视图，DTO 反序列化面收口）", async () => {
+    DB.viewFindMany.mockResolvedValue([
+      viewRow({ displayOptions: { groupBy: "state", view: "table" } }),
+    ]);
+
+    const out = (await listFilterViewsFn({})) as {
+      displayOptions: { view?: string };
+    }[];
+
+    expect(out[0].displayOptions.view).toBe("list");
+  });
 });
 
 describe("createFilterViewFn", () => {
@@ -329,6 +342,13 @@ describe("createFilterViewFn", () => {
     ).rejects.toThrow();
     expect(DB.viewCreate).not.toHaveBeenCalled();
   });
+
+  it("保留名（显示选项保留行）拒绝且零 create（任务 20）", async () => {
+    await expect(
+      createFilterViewFn({ data: { name: TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } }),
+    ).rejects.toThrow("保留");
+    expect(DB.viewCreate).not.toHaveBeenCalled();
+  });
 });
 
 describe("updateFilterViewFn", () => {
@@ -340,7 +360,7 @@ describe("updateFilterViewFn", () => {
     };
 
     expect(DB.viewUpdate).toHaveBeenCalledWith({
-      where: { id: "v-1", userId: U },
+      where: { id: "v-1", userId: U, name: { not: TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } },
       data: { name: "改名" },
       select: expect.anything(),
     });
@@ -361,7 +381,7 @@ describe("updateFilterViewFn", () => {
     });
 
     expect(DB.viewUpdate).toHaveBeenCalledWith({
-      where: { id: "v-1", userId: U },
+      where: { id: "v-1", userId: U, name: { not: TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } },
       data: {
         filters: { priority: "p1" },
         displayOptions: { groupBy: "none", view: "table" },
@@ -391,7 +411,9 @@ describe("deleteFilterViewFn", () => {
       success: boolean;
     };
 
-    expect(DB.viewDelete).toHaveBeenCalledWith({ where: { id: "v-1", userId: U } });
+    expect(DB.viewDelete).toHaveBeenCalledWith({
+      where: { id: "v-1", userId: U, name: { not: TESTCASE_DISPLAY_OPTIONS_VIEW_NAME } },
+    });
     expect(out).toEqual({ success: true });
   });
 });

package/src/server/serverFns/testcase/bulk.ts

@@ -0,0 +1,195 @@
+// 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/>.
+
+// 用例批量操作（需求详情「测试用例」面板多选批量条）。本文件只准导出 createServerFn 产物。
+// 权限口径与 story-crud/bulk.ts 一致：一次取用户可访问（有效成员，suspended 视同无权限）
+// 的项目 id 集合进 where 做可见性过滤——跨项目 caseId 静默跳过而非报错（SEC-03/DB-03）。
+// version 口径：state/assignee/folder 是元数据面，批量更新不 bump version（规格 §3，
+// caseSnapshot 只锁内容五字段）。归档无状态前置限制（story 归档要求 done/cancelled，
+// 用例回收站无此门槛，与用例页单条归档口径一致）。
+import { getPrisma } from "@allbluecn/database/get-prisma";
+import { createServerFn } from "@tanstack/react-start";
+import { getRequest } from "@tanstack/react-start/server";
+import { z } from "zod";
+import { requireAuth } from "@/server/auth-helpers";
+import {
+  TEST_CASE_PRIORITY_VALUES,
+  TEST_CASE_STATE_VALUES,
+  type TestCasePriority,
+  type TestCaseState,
+} from "./constants";
+
+const idListSchema = z.object({ caseIds: z.array(z.string()).min(1).max(500) });
+
+/** 一次取用户可访问（有效成员，suspended 视同无权限）的项目 id 集合，供批量操作做可见性过滤 */
+async function accessibleProjectIds(userId: string): Promise<string[]> {
+  const prisma = await getPrisma();
+  const rows = await prisma.projectMember.findMany({
+    where: { userId, status: { not: "suspended" } },
+    select: { projectId: true },
+  });
+  return rows.map((r) => r.projectId);
+}
+
+export const bulkArchiveTestCasesFn = createServerFn({ method: "POST" })
+  .validator(idListSchema)
+  .handler(async ({ data }) => {
+    const prisma = await getPrisma();
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const visibleProjectIds = await accessibleProjectIds(session.user!.id!);
+    const result = await prisma.testCase.updateMany({
+      where: {
+        id: { in: data.caseIds },
+        projectId: { in: visibleProjectIds },
+        archived: false,
+      },
+      data: { archived: true, archivedAt: new Date() },
+    });
+    return { archived: result.count };
+  });
+
+export const bulkDeleteTestCasesFn = createServerFn({ method: "POST" })
+  .validator(idListSchema)
+  .handler(async ({ data }) => {
+    const prisma = await getPrisma();
+    const request = getRequest();
+    const session = await requireAuth(request);
+    // 可见性过滤进 where：跨项目 id 静默跳过而非报错（SEC-03/DB-03：单语句消除跨项目删除）
+    const visibleProjectIds = await accessibleProjectIds(session.user!.id!);
+    const result = await prisma.testCase.deleteMany({
+      where: { id: { in: data.caseIds }, projectId: { in: visibleProjectIds } },
+    });
+    return { deleted: result.count };
+  });
+
+const bulkUpdateSchema = z.object({
+  caseIds: z.array(z.string()).min(1).max(500),
+  patch: z
+    .object({
+      state: z.enum(TEST_CASE_STATE_VALUES).optional(),
+      priority: z.enum(TEST_CASE_PRIORITY_VALUES).optional(),
+      assigneeId: z.string().nullable().optional(),
+      folderId: z.string().nullable().optional(),
+      // 关联/取消关联需求（详情「关联测试用例」弹窗）：非空时校验 story 与用例同项目
+      storyId: z.string().nullable().optional(),
+    })
+    .refine((p) => Object.keys(p).length > 0, { message: "至少选择一个属性字段" })
+    .refine((p) => Object.keys(p).length === 1, { message: "批量更新一次仅支持一个字段" }),
+});
+
+export const bulkUpdateTestCasesFn = createServerFn({ method: "POST" })
+  .validator(bulkUpdateSchema)
+  .handler(async ({ data }) => {
+    const prisma = await getPrisma();
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    const visibleProjectIds = await accessibleProjectIds(userId);
+
+    const data_: Record<string, unknown> = {};
+    if (data.patch.state !== undefined) data_.state = data.patch.state as TestCaseState;
+    if (data.patch.priority !== undefined) data_.priority = data.patch.priority as TestCasePriority;
+    if (data.patch.assigneeId !== undefined) {
+      data_.assigneeId = data.patch.assigneeId;
+    }
+    if (data.patch.folderId !== undefined) {
+      data_.folderId = data.patch.folderId;
+    }
+    // folderId 归属校验（拒绝路径零写，PR-8 审查 A；口径同文件 storyId 校验与
+    // testcase-crud 的 assertFolderInProject——批量路径此前唯一缺席）：模块不
+    // 存在或不属用户可见项目 → 拒绝；且模块所在项目必须与全部目标用例一致，
+    // scope=all 聚合圈选可混入其他成员项目用例，无此校验会零报错把跨项目用例
+    // 挂到另一项目模块（folderId=null 语义是移出分组，无需归属校验）
+    const nextFolderId = data.patch.folderId;
+    if (nextFolderId !== undefined && nextFolderId !== null) {
+      const folder = await prisma.testCaseFolder.findUnique({
+        where: { id: nextFolderId },
+        select: { projectId: true },
+      });
+      if (!folder || !visibleProjectIds.includes(folder.projectId)) {
+        throw new Error("模块不存在或无权访问");
+      }
+      const foreignCount = await prisma.testCase.count({
+        where: { id: { in: data.caseIds }, projectId: { not: folder.projectId } },
+      });
+      if (foreignCount > 0) {
+        throw new Error("存在不属于该模块所在项目的用例，已拒绝本次批量移动");
+      }
+    }
+    if (data.patch.storyId !== undefined && data.patch.storyId !== null) {
+      // story 归属校验（防跨项目挂载）：story 不存在或不属于用例可见项目 → 拒绝（零写）
+      const story = await prisma.story.findUnique({
+        where: { id: data.patch.storyId },
+        select: { projectId: true },
+      });
+      if (!story || !visibleProjectIds.includes(story.projectId)) {
+        throw new Error("目标需求不存在或无权访问");
+      }
+      data_.storyId = data.patch.storyId;
+    } else if (data.patch.storyId === null) {
+      data_.storyId = null;
+    }
+
+    // 关联/取消关联需求：事务内 diff 出实际变更的用例，写 storyActivity
+    // （需求详情活动 tab 的数据源；action 为 testcase_added/testcase_removed）
+    if (data.patch.storyId !== undefined) {
+      const nextStoryId = (data_.storyId as string | null) ?? null;
+      const result = await prisma.$transaction(async (tx) => {
+        const affected = await tx.testCase.findMany({
+          where: {
+            id: { in: data.caseIds },
+            projectId: { in: visibleProjectIds },
+            archived: false,
+          },
+          select: { id: true, identifier: true, storyId: true },
+        });
+        const updated = await tx.testCase.updateMany({
+          where: {
+            id: { in: data.caseIds },
+            projectId: { in: visibleProjectIds },
+            archived: false,
+          },
+          data: data_,
+        });
+        const changed = affected.filter((c) => c.storyId !== nextStoryId);
+        if (changed.length > 0) {
+          await tx.storyActivity.createMany({
+            data: changed.map((c) => ({
+              // 取消关联挂到原需求（c.storyId），关联挂到目标需求
+              storyId: nextStoryId ?? c.storyId!,
+              userId,
+              action: nextStoryId ? "testcase_added" : "testcase_removed",
+              newValue: c.identifier,
+            })),
+          });
+        }
+        return updated;
+      });
+      return { updated: result.count };
+    }
+
+    const result = await prisma.testCase.updateMany({
+      where: {
+        id: { in: data.caseIds },
+        projectId: { in: visibleProjectIds },
+        archived: false,
+      },
+      data: data_,
+    });
+    return { updated: result.count };
+  });

package/src/server/serverFns/testcase/generation.ts

@@ -360,6 +360,16 @@ export const startGenerationFn = createServerFn({ method: "POST" })
               createdById: userId,
             },
           });
+          // 需求详情活动 tab（storyActivity）：AI 生成落库即带 storyId，同步记一条
+          await tx.storyActivity.create({
+            data: {
+              storyId: story.id,
+              userId,
+              action: "testcase_created",
+              newValue: created.identifier,
+              isAI: true,
+            },
+          });
           createdDrafts.push(created as unknown as DraftRow);
         }
 

package/src/server/serverFns/testcase/stats.ts

@@ -80,16 +80,30 @@ export const getStoryStalenessFn = createServerFn({ method: "GET" })
     if (!story) throw new Error("需求不存在");
     await assertProjectMembership(story.projectId, session.user!.id!);
 
-    // 最新一条未归档关联用例的 createdAt（max 聚合等价于 desc 取首条）
-    const latestCase = await prisma.testCase.findFirst({
-      where: { storyId: data.storyId, archived: false },
-      orderBy: { createdAt: "desc" },
-      select: { createdAt: true },
-    });
+    // 窄口径：需求「内容」（描述/标题）最后编辑时间 vs 最新关联用例创建时间。
+    // 从 storyActivity 的 content_edited 时间锚推导（web 直写与 collab exporter
+    // 双写路径统一落此锚）；无锚（从未改过内容）= 生成即基线，stale=false。
+    // 不再用整表 updatedAt——加标签/改状态/设负责人等非内容编辑不再误触提示。
+    const [latestCase, latestContentEdit] = await Promise.all([
+      prisma.testCase.findFirst({
+        where: { storyId: data.storyId, archived: false },
+        orderBy: { createdAt: "desc" },
+        select: { createdAt: true },
+      }),
+      prisma.storyActivity.findFirst({
+        where: { storyId: data.storyId, action: "content_edited" },
+        orderBy: { createdAt: "desc" },
+        select: { createdAt: true },
+      }),
+    ]);
 
+    const lastContentEditAt = latestContentEdit?.createdAt ?? null;
     return {
-      stale: latestCase ? story.updatedAt.getTime() > latestCase.createdAt.getTime() : false,
-      storyUpdatedAt: story.updatedAt.toISOString(),
+      stale:
+        latestCase != null &&
+        lastContentEditAt != null &&
+        lastContentEditAt.getTime() > latestCase.createdAt.getTime(),
+      storyUpdatedAt: (lastContentEditAt ?? story.updatedAt).toISOString(),
       latestCaseCreatedAt: latestCase ? latestCase.createdAt.toISOString() : null,
     };
   });