@allbluecn/web-app 0.5.0 → 0.6.0

package/src/server/serverFns/project.ts

@@ -328,8 +328,8 @@ export const deleteProjectFn = createServerFn({ method: "POST" })
             await prisma.$transaction(async (tx) => {
               for (const id of storyIds) {
                 const counter = await tx.sequenceCounter.upsert({
-                  where: { scope: "global" },
-                  create: { scope: "global", seq: 1 },
+                  where: { scope: independentId },
+                  create: { scope: independentId, seq: 1 },
                   update: { seq: { increment: 1 } },
                 });
                 await tx.story.update({
@@ -573,3 +573,46 @@ export const ensureBuiltinProjectFn = createServerFn({ method: "GET" }).handler(
   const projectId = await ensureBuiltinIndependentProject(userId);
   return { id: projectId, name: BUILTIN_INDEPENDENT_NAME, displayId: BUILTIN_INDEPENDENT_DISPLAY_ID, icon: BUILTIN_INDEPENDENT_ICON };
 });
+
+export const listProjectKbsFn = createServerFn({ method: "GET" })
+  .validator(z.object({ projectId: z.string() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+    const rows = await prisma.projectKnowledgeBase.findMany({
+      where: { projectId: data.projectId },
+      select: {
+        kb: { select: { id: true, name: true, icon: true, visibility: true } },
+      },
+      orderBy: { createdAt: "asc" },
+    });
+    return rows.map((r) => r.kb);
+  });
+
+export const setProjectKbsFn = createServerFn({ method: "POST" })
+  .validator(z.object({ projectId: z.string(), kbIds: z.array(z.string()) }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+    if (data.kbIds.length > 0) {
+      const valid = await prisma.knowledgeBase.findMany({
+        where: { id: { in: data.kbIds }, visibility: "team", isDeleted: false },
+        select: { id: true },
+      });
+      if (valid.length !== data.kbIds.length) {
+        throw new Error("仅允许团队可见的知识库关联项目");
+      }
+    }
+    await prisma.$transaction(async (tx) => {
+      await tx.projectKnowledgeBase.deleteMany({
+        where: { projectId: data.projectId, kbId: { notIn: data.kbIds } },
+      });
+      if (data.kbIds.length > 0) {
+        await tx.projectKnowledgeBase.createMany({
+          data: data.kbIds.map((kbId) => ({ projectId: data.projectId, kbId })),
+          skipDuplicates: true,
+        });
+      }
+    });
+    return { ok: true };
+  });

package/src/server/serverFns/story/__tests__/kb-scope.test.ts

@@ -0,0 +1,56 @@
+// 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/>.
+
+import { describe, it, expect } from "vitest";
+import { isIndependentProject, buildKbScopeWhere } from "../kb-scope";
+
+describe("kb-scope 可用范围判定", () => {
+  it("独立需求项目（displayId=STORY）识别", () => {
+    expect(isIndependentProject("STORY")).toBe(true);
+    expect(isIndependentProject("story")).toBe(false);
+    expect(isIndependentProject(null)).toBe(false);
+    expect(isIndependentProject("PROJ")).toBe(false);
+  });
+
+  it("普通项目：general ∪ 项目关联（不含他人 private/team）", () => {
+    const where = buildKbScopeWhere({
+      projectId: "p1",
+      projectDisplayId: "PROJ",
+      userId: "u1",
+    });
+    expect(where).toEqual({
+      OR: [
+        { visibility: "general" },
+        { projectLinks: { some: { projectId: "p1" } } },
+      ],
+    });
+  });
+
+  it("独立需求项目：自己的全部 ∪ 他人 team/general", () => {
+    const where = buildKbScopeWhere({
+      projectId: "p2",
+      projectDisplayId: "STORY",
+      userId: "u1",
+    });
+    expect(where).toEqual({
+      OR: [
+        { userId: "u1" },
+        { visibility: { in: ["team", "general"] } },
+      ],
+    });
+  });
+});

package/src/server/serverFns/story/__tests__/label-suggest-fn.test.ts

@@ -0,0 +1,100 @@
+// 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/>.
+
+import { describe, it, expect, vi, beforeEach } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  labelFindMany: vi.fn(),
+  storyLabelGroupBy: vi.fn(),
+  runChat: vi.fn(),
+  hasAiKey: vi.fn(),
+}))
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    label: { findMany: mocks.labelFindMany },
+    storyLabel: { groupBy: mocks.storyLabelGroupBy },
+  },
+}))
+
+vi.mock("@allbluecn/ai-gateway", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@allbluecn/ai-gateway")>()
+  return {
+    ...actual,
+    runChat: mocks.runChat,
+    hasAiKey: mocks.hasAiKey,
+  }
+})
+
+import { suggestLabelsCore } from "../story-crud/label-suggest-core"
+
+const ALL_LABELS = [
+  { id: "l1", name: "性能", color: "#ef4444" },
+  { id: "l2", name: "安全", color: "#3b82f6" },
+]
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.hasAiKey.mockResolvedValue(true)
+  mocks.labelFindMany.mockResolvedValue(ALL_LABELS)
+})
+
+describe("suggestLabelsCore", () => {
+  it("正常链路：查标签→runChat→解析→返回 existing 实体与 newNames", async () => {
+    mocks.runChat.mockResolvedValue('{"existing":["性能"],"new":["支付"]}')
+    const r = await suggestLabelsCore({ name: "优化登录" }, "u1")
+    expect(mocks.runChat).toHaveBeenCalledTimes(1)
+    const call = mocks.runChat.mock.calls[0] as any[]
+    expect(call[0][0].role).toBe("user")
+    expect(call[1].systemPrompts[0]).toContain("性能、安全")
+    expect(call[1].modelOptions).toEqual({ temperature: 0.2 })
+    expect(r.existingLabels).toEqual([{ id: "l1", name: "性能", color: "#ef4444" }])
+    expect(r.newNames).toEqual(["支付"])
+  })
+
+  it("AI 未配置抛错", async () => {
+    mocks.hasAiKey.mockResolvedValue(false)
+    await expect(suggestLabelsCore({ name: "x" }, "u1")).rejects.toMatchObject({
+      message: expect.stringContaining("AI"),
+    })
+  })
+
+  it("标签超 100 个时按使用频次截断", async () => {
+    const many = Array.from({ length: 120 }, (_, i) => ({
+      id: `l${i}`,
+      name: `标签${i}`,
+      color: "#6b7280",
+    }))
+    mocks.labelFindMany.mockResolvedValue(many)
+    mocks.storyLabelGroupBy.mockResolvedValue(
+      Array.from({ length: 100 }, (_, i) => ({ labelId: `l${i}`, _count: { _all: 100 - i } })),
+    )
+    mocks.runChat.mockResolvedValue('{"existing":[],"new":[]}')
+    await suggestLabelsCore({ name: "x" }, "u1")
+    expect(mocks.storyLabelGroupBy).toHaveBeenCalledTimes(1)
+    const prompt = (mocks.runChat.mock.calls[0] as any[])[1].systemPrompts[0] as string
+    const listed = prompt.split("已有标签：")[1]
+    expect(listed.split("、")).toHaveLength(100)
+  })
+
+  it("AI 输出解析失败抛错", async () => {
+    mocks.runChat.mockResolvedValue("垃圾输出")
+    await expect(suggestLabelsCore({ name: "x" }, "u1")).rejects.toMatchObject({
+      message: expect.stringContaining("解析失败"),
+    })
+  })
+})

package/src/server/serverFns/story/__tests__/labels.test.ts

@@ -0,0 +1,67 @@
+// 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/>.
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  labelUpsert: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: { label: { upsert: mocks.labelUpsert } },
+}));
+
+import { upsertLabel } from "../story-crud/label-upsert";
+import { pickLabelColor, LABEL_PALETTE } from "../story-crud/label-palette";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("pickLabelColor", () => {
+  it("同名稳定同色且落在色板内", () => {
+    const a = pickLabelColor("性能");
+    expect(pickLabelColor("性能")).toBe(a);
+    expect(LABEL_PALETTE).toContain(a);
+  });
+
+  it("不同标签名颜色分布均匀（6 个标签至少 4 色）", () => {
+    const colors = new Set(["性能", "安全", "登录", "支付", "导入", "导出"].map(pickLabelColor));
+    expect(colors.size).toBeGreaterThanOrEqual(4);
+  });
+});
+
+describe("upsertLabel", () => {
+  it("走 upsert 且 create 分支使用色板颜色", async () => {
+    mocks.labelUpsert.mockResolvedValue({ id: "l1", name: "性能", color: "#ef4444" });
+    const r = await upsertLabel("性能", "u1");
+    expect(mocks.labelUpsert).toHaveBeenCalledTimes(1);
+    const arg = mocks.labelUpsert.mock.calls[0][0] as any;
+    expect(arg.where).toEqual({ name: "性能" });
+    expect(arg.update).toEqual({});
+    expect(LABEL_PALETTE).toContain(arg.create.color);
+    expect(arg.create.createdById).toBe("u1");
+    expect(r).toEqual({ id: "l1", name: "性能", color: "#ef4444" });
+  });
+
+  it("传自定义颜色时优先使用自定义颜色", async () => {
+    mocks.labelUpsert.mockResolvedValue({ id: "l1", name: "性能", color: "#ff0000" });
+    await upsertLabel("性能", "u1", "#ff0000");
+    const arg = mocks.labelUpsert.mock.calls[0][0] as any;
+    expect(arg.create.color).toBe("#ff0000");
+  });
+});

package/src/server/serverFns/story/__tests__/story-assoc.test.ts

@@ -0,0 +1,222 @@
+// 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/>.
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (config: any) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        const wrapped = async (args: any) => {
+          let data = args?.data;
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse ? this._validator.parse(data) : data;
+          }
+          return fn({ data });
+        };
+        return wrapped;
+      },
+    };
+    return api;
+  },
+}));
+
+vi.mock("@tanstack/react-start/server", () => ({
+  getRequest: () => ({}),
+}));
+
+const mocks = vi.hoisted(() => ({
+  storyFindUnique: vi.fn(),
+  kbFindMany: vi.fn(),
+  kbFindFirst: vi.fn(),
+  docFindMany: vi.fn(),
+  linkFindMany: vi.fn(),
+  linkCreateMany: vi.fn(),
+  extLinkFindMany: vi.fn(),
+  extLinkCreateMany: vi.fn(),
+  extLinkDeleteMany: vi.fn(),
+  activityCreate: vi.fn(),
+  currentSession: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => {
+  const prisma = {
+    story: { findUnique: mocks.storyFindUnique },
+    knowledgeBase: { findMany: mocks.kbFindMany, findFirst: mocks.kbFindFirst },
+    knowledgeDocument: { findMany: mocks.docFindMany },
+    storyDocLink: { findMany: mocks.linkFindMany, createMany: mocks.linkCreateMany },
+    storyExternalLink: {
+      findMany: mocks.extLinkFindMany,
+      createMany: mocks.extLinkCreateMany,
+      deleteMany: mocks.extLinkDeleteMany,
+    },
+    storyActivity: { create: mocks.activityCreate },
+  };
+  return { prisma, Prisma: {} };
+});
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+import {
+  listStoryAvailableKbsFn,
+  searchKbDocsFn,
+  linkDocsFn,
+  getLinkedDocsFn,
+} from "../story-assoc";
+
+const SESSION = { user: { id: "u1" } };
+const STORY_WITH_PROJECT = {
+  project: { id: "p1", displayId: "PROJ" },
+};
+const STORY_INDEPENDENT = {
+  project: { id: "p2", displayId: "STORY" },
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue(SESSION);
+  mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+  mocks.extLinkFindMany.mockResolvedValue([]);
+  mocks.extLinkCreateMany.mockResolvedValue({ count: 0 });
+  mocks.extLinkDeleteMany.mockResolvedValue({ count: 0 });
+  mocks.activityCreate.mockResolvedValue({
+    id: "act1",
+    action: "kb_linked",
+    field: null,
+    oldValue: null,
+    newValue: "1",
+    isAI: false,
+    createdAt: new Date("2026-08-31T00:00:00Z"),
+    user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+  });
+});
+
+describe("listStoryAvailableKbsFn", () => {
+  it("普通项目：按 scope 查询返回 KB 列表", async () => {
+    mocks.kbFindMany.mockResolvedValue([
+      { id: "kb1", name: "团队库", icon: "notebook", visibility: "team" },
+      { id: "kb2", name: "通用库", icon: "book", visibility: "general" },
+    ]);
+    const result = await listStoryAvailableKbsFn({ data: { storyId: "s1" } });
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ id: "kb1", name: "团队库" });
+    const where = mocks.kbFindMany.mock.calls[0][0].where;
+    expect(where.AND).toBeDefined(); // AND: [scope, { isDeleted: false }]
+  });
+
+  it("需求不存在抛错", async () => {
+    mocks.storyFindUnique.mockResolvedValue(null);
+    await expect(listStoryAvailableKbsFn({ data: { storyId: "nope" } })).rejects.toMatchObject({
+      message: expect.stringContaining("需求不存在"),
+    });
+  });
+});
+
+describe("searchKbDocsFn 两态", () => {
+  it("指定 kbId：全量树查询（take 500，含 parentId/type/kb 元数据）", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.kbFindFirst.mockResolvedValue({ id: "kb1" }); // 范围内
+    mocks.docFindMany.mockResolvedValue([
+      { id: "d1", title: "页1", parentId: null, kb: { id: "kb1", name: "团队库", icon: "notebook" }, icon: "doc" },
+    ]);
+    const result = await searchKbDocsFn({ data: { storyId: "s1", kbId: "kb1", query: "" } });
+    expect(result.items[0]).toMatchObject({ id: "d1", kbName: "团队库" });
+    expect(result.nextCursor).toBeNull();
+    const args = mocks.docFindMany.mock.calls[0][0];
+    expect(args.take).toBe(500);
+    expect(args.where.kbId).toBe("kb1");
+  });
+
+  it("指定范围外 kbId：抛越界错误", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.kbFindFirst.mockResolvedValue(null); // 不在 scope 内
+    await expect(
+      searchKbDocsFn({ data: { storyId: "s1", kbId: "kbX", query: "" } }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("不在可用范围") });
+  });
+
+  it("全部模式：平铺分页（take 21 判 hasMore）", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.docFindMany.mockResolvedValue([]);
+    await searchKbDocsFn({ data: { storyId: "s1", query: "关键词" } });
+    const args = mocks.docFindMany.mock.calls[0][0];
+    expect(args.take).toBe(21);
+    expect(args.where.kb).toBeDefined(); // scope 下推到 kb 关系
+  });
+});
+
+describe("linkDocsFn 批量关联", () => {
+  it("合法项批量建链、已存在跳过、越界归 failed", async () => {
+    mocks.storyFindUnique.mockResolvedValue(STORY_WITH_PROJECT);
+    mocks.docFindMany.mockResolvedValue([
+      { id: "d1", kbId: "kb1" }, // 合法
+      { id: "d2", kbId: "kb9" }, // 越界（kb9 不在 scope）
+    ]);
+    mocks.kbFindMany.mockResolvedValue([{ id: "kb1" }, { id: "kb2" }]); // scope 内 KB 集合
+    mocks.linkFindMany.mockResolvedValue([{ docId: "d1" }]); // d1 已关联
+    mocks.linkCreateMany.mockResolvedValue({ count: 0 });
+
+    const result = await linkDocsFn({ data: { storyId: "s1", docIds: ["d1", "d2"] } });
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(["d1"]);
+    expect(result.failed).toEqual([{ docId: "d2", reason: "outOfScope" }]);
+    expect(mocks.linkCreateMany).not.toHaveBeenCalled(); // 无新增
+  });
+
+  it("新增项走 createMany skipDuplicates", async () => {
+    mocks.docFindMany.mockResolvedValue([{ id: "d3", kbId: "kb1" }]);
+    mocks.kbFindMany.mockResolvedValue([{ id: "kb1" }]);
+    mocks.linkFindMany.mockResolvedValue([]);
+    mocks.linkCreateMany.mockResolvedValue({ count: 1 });
+    const result = await linkDocsFn({ data: { storyId: "s1", docIds: ["d3"] } });
+    expect(result.linked).toEqual(["d3"]);
+    expect(mocks.linkCreateMany.mock.calls[0][0].data).toEqual([{ storyId: "s1", docId: "d3" }]);
+  });
+});
+
+describe("getLinkedDocsFn 扩展返回 KB 元数据", () => {
+  it("返回对齐 DocBrief 的字段", async () => {
+    mocks.linkFindMany.mockResolvedValue([
+      {
+        doc: {
+          id: "d1",
+          title: "页1",
+          kb: { id: "kb1", name: "团队库", icon: "notebook" },
+          icon: "doc",
+          parentId: null,
+        },
+      },
+    ]);
+    const result = await getLinkedDocsFn({ data: { storyId: "s1" } });
+    expect(result[0]).toEqual({
+      id: "d1",
+      title: "页1",
+      kbId: "kb1",
+      kbName: "团队库",
+      kbIcon: "notebook",
+      docIcon: "doc",
+      parentId: null,
+    });
+  });
+});

package/src/server/serverFns/story/__tests__/story-dependencies.test.ts

@@ -47,9 +47,13 @@ vi.mock("@tanstack/react-start/server", () => ({
 const mocks = vi.hoisted(() => ({
   depFindMany: vi.fn(),
   depFindFirst: vi.fn(),
+  depFindUnique: vi.fn(),
   depCreate: vi.fn(),
+  depUpdate: vi.fn(),
   depDelete: vi.fn(),
   storyFindMany: vi.fn(),
+  storyFindUnique: vi.fn(),
+  activityCreate: vi.fn(),
   currentSession: vi.fn(),
 }));
 
@@ -58,10 +62,13 @@ vi.mock("@allbluecn/database", () => {
     storyDependency: {
       findMany: mocks.depFindMany,
       findFirst: mocks.depFindFirst,
+      findUnique: mocks.depFindUnique,
       create: mocks.depCreate,
+      update: mocks.depUpdate,
       delete: mocks.depDelete,
     },
-    story: { findMany: mocks.storyFindMany },
+    story: { findMany: mocks.storyFindMany, findUnique: mocks.storyFindUnique },
+    storyActivity: { create: mocks.activityCreate },
   };
   return { prisma, Prisma: {} };
 });
@@ -72,6 +79,7 @@ vi.mock("@/server/auth-helpers", () => ({
 
 import {
   addDependenciesFn,
+  updateDependencyFn,
   removeDependencyFn,
   getDependenciesFn,
 } from "../story-dependencies";
@@ -104,6 +112,24 @@ beforeEach(() => {
   mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
   // 默认 DB 无既有依赖边（handler 开头一次性取全边建邻接表，必须返回数组）
   mocks.depFindMany.mockResolvedValue([]);
+  // 活动写入段：端点 label 查询 + create 返回（含 select 字段）
+  mocks.storyFindMany.mockResolvedValue([
+    { id: "a", identifier: "A-1", name: "story a" },
+    { id: "b", identifier: "B-1", name: "story b" },
+  ]);
+  mocks.activityCreate.mockImplementation(({ data }: any) =>
+    Promise.resolve({
+      id: `act-${data.storyId}`,
+      action: "dependency_added",
+      field: null,
+      oldValue: null,
+      newValue: data.newValue,
+      isAI: false,
+      createdAt: new Date("2026-08-31T00:00:00Z"),
+      storyId: data.storyId,
+      user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+    }),
+  );
 });
 
 describe("addDependenciesFn", () => {
@@ -187,6 +213,12 @@ describe("addDependenciesFn", () => {
     expect(mocks.depFindMany).toHaveBeenCalledWith({
       select: { sourceId: true, targetId: true },
     });
+    // 活动契约：依赖两端各记一条「添加依赖关系」，newValue 为对方描述
+    expect(res.activities).toHaveLength(2);
+    expect(res.activities.map((x) => [x.storyId, x.newValue]).sort()).toEqual([
+      ["a", "B-1 story b"],
+      ["b", "A-1 story a"],
+    ]);
   });
 
   it("validator 拒绝旧枚举值：BLOCKED_BY 不再合法", async () => {
@@ -199,12 +231,110 @@ describe("addDependenciesFn", () => {
   });
 });
 
+describe("updateDependencyFn", () => {
+  const EXISTING = { id: "d1", sourceId: "a", targetId: "b", type: "BLOCKS" };
+  const UPDATE_ACTIVITY = {
+    id: "act1",
+    action: "dependency_updated",
+    field: null,
+    oldValue: null,
+    newValue: "B-1 story b",
+    isAI: false,
+    createdAt: new Date("2026-08-31T00:00:00Z"),
+    storyId: "a",
+    user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null },
+  };
+
+  it("同向改类型：仅更新 type，两端各记一条活动", async () => {
+    mocks.depFindUnique.mockResolvedValue(EXISTING);
+    mocks.depFindMany.mockResolvedValue([]); // 排除自身后无其他边
+    mocks.depUpdate.mockResolvedValue({ ...EXISTING, type: "STARTS_BEFORE" });
+    mocks.activityCreate.mockResolvedValue(UPDATE_ACTIVITY);
+    const res = await updateDependencyFn({
+      data: { depId: "d1", sourceId: "a", targetId: "b", type: "STARTS_BEFORE" },
+    });
+    expect(res.ok).toBe(true);
+    expect(mocks.depUpdate).toHaveBeenCalledWith({
+      where: { id: "d1" },
+      data: { sourceId: "a", targetId: "b", type: "STARTS_BEFORE" },
+    });
+    expect(res.activities).toHaveLength(2);
+  });
+
+  it("方向反转合法时更新为新的 source/target", async () => {
+    mocks.depFindUnique.mockResolvedValue(EXISTING);
+    mocks.depFindMany.mockResolvedValue([]);
+    mocks.depUpdate.mockResolvedValue({ ...EXISTING, sourceId: "b", targetId: "a" });
+    mocks.activityCreate.mockResolvedValue(UPDATE_ACTIVITY);
+    const res = await updateDependencyFn({
+      data: { depId: "d1", sourceId: "b", targetId: "a", type: "BLOCKS" },
+    });
+    expect(res.ok).toBe(true);
+    expect(mocks.depUpdate).toHaveBeenCalledWith({
+      where: { id: "d1" },
+      data: { sourceId: "b", targetId: "a", type: "BLOCKS" },
+    });
+  });
+
+  it("方向反转成环时拒绝写入", async () => {
+    mocks.depFindUnique.mockResolvedValue(EXISTING);
+    // 现边 a -> b；另已存在路径 a -> c -> b。请求反转成 b -> a 后，
+    // 从新 target(a) 出发可直达新 source(b) ⇒ 成环，必须拒绝
+    mocks.depFindMany.mockResolvedValue([
+      { sourceId: "a", targetId: "c" },
+      { sourceId: "c", targetId: "b" },
+    ]);
+    const res = await updateDependencyFn({
+      data: { depId: "d1", sourceId: "b", targetId: "a", type: "BLOCKS" },
+    });
+    expect(res).toEqual({ ok: false, reason: "CYCLE" });
+    expect(mocks.depUpdate).not.toHaveBeenCalled();
+  });
+
+  it("三元组与现状一致时短路返回且不写库", async () => {
+    mocks.depFindUnique.mockResolvedValue(EXISTING);
+    const res = await updateDependencyFn({
+      data: { depId: "d1", sourceId: "a", targetId: "b", type: "BLOCKS" },
+    });
+    expect(res).toEqual({ ok: true, activities: [] });
+    expect(mocks.depUpdate).not.toHaveBeenCalled();
+    expect(mocks.depFindMany).not.toHaveBeenCalled();
+  });
+
+  it("两端不属于原边时抛错", async () => {
+    mocks.depFindUnique.mockResolvedValue(EXISTING);
+    await expect(
+      updateDependencyFn({
+        data: { depId: "d1", sourceId: "a", targetId: "c", type: "BLOCKS" },
+      }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("依赖关系两端不匹配") });
+    expect(mocks.depUpdate).not.toHaveBeenCalled();
+  });
+
+  it("depId 不存在时抛错", async () => {
+    mocks.depFindUnique.mockResolvedValue(null);
+    await expect(
+      updateDependencyFn({
+        data: { depId: "missing", sourceId: "a", targetId: "b", type: "BLOCKS" },
+      }),
+    ).rejects.toMatchObject({ message: expect.stringContaining("依赖关系不存在") });
+  });
+});
+
 describe("removeDependencyFn", () => {
   it("按 depId 删除", async () => {
+    mocks.depFindUnique.mockResolvedValue({ id: "d1", sourceId: "s1", targetId: "t1" });
+    mocks.storyFindUnique.mockImplementation(({ where }: any) => {
+      if (where.id === "s1") return Promise.resolve({ identifier: "A-1", name: "story a" });
+      if (where.id === "t1") return Promise.resolve({ identifier: "B-1", name: "story b" });
+      return Promise.resolve(null);
+    });
     mocks.depDelete.mockResolvedValue({ id: "d1" });
+    mocks.activityCreate.mockResolvedValue({ id: "act1", action: "dependency_removed", field: null, oldValue: null, newValue: "B-1", isAI: false, createdAt: new Date(), user: { id: "u1", username: "u1", email: "e", avatarConfig: null, bgShape: null, bgColor: null } });
     const res = await removeDependencyFn({ data: { depId: "d1" } });
-    expect(res.id).toBe("d1");
+    expect(res?.dep.id).toBe("d1");
     expect(mocks.depDelete).toHaveBeenCalledWith({ where: { id: "d1" } });
+    expect(mocks.activityCreate).toHaveBeenCalledTimes(2);
   });
 });