@allbluecn/web-app 0.19.2 → 0.19.4

package/src/server/ai-gateway/__tests__/create-pr.test.ts

@@ -0,0 +1,169 @@
+// @vitest-environment node
+// 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/>.
+
+// create_pull_request 修复回归（审计 A3x-ai-gateway-3）：
+// 🟠 githubBase 必须含 /repos/{owner}/{repo} 路径（.origin 丢路径曾致全部 404）
+// 🟠 blob encoding=base64 与 inputSchema 声明一致
+// 🟡 分支名插入 URL 前 encodeURIComponent
+// 🟡 全部 fetch 携带 AbortSignal.timeout
+// 🟢 SECRET_PATTERNS 冗余删减后仍覆盖 .env.local 等敏感路径
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  fetchMock: vi.fn(),
+  decrypt: vi.fn(() => "gh-token"),
+}))
+
+vi.stubGlobal("fetch", mocks.fetchMock)
+
+vi.mock("@/server/lib/api-key-cipher", () => ({
+  decryptApiKey: mocks.decrypt,
+}))
+
+vi.mock("@/server/fetch-guard", () => ({
+  assertFetchableUrl: (input: string) => new URL(input),
+}))
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    aiProviderConfig: { findFirst: vi.fn(async () => ({ apiKey: "enc" })) },
+    account: { findFirst: vi.fn(async () => null) },
+  },
+}))
+
+import { prisma } from "@allbluecn/database"
+import { createPullRequestTool } from "../tools/create-pr"
+import type { AppContext } from "../types"
+
+const ctx = (): AppContext =>
+  ({
+    userId: "u1",
+    // 工具经 appCtx.db 读 GitHub token，须传 mock 后的 prisma
+    db: prisma as unknown as AppContext["db"],
+    workspaceContext: {
+      type: "github",
+      owner: "acme",
+      repo: "widgets",
+      defaultBranch: "main",
+    },
+  }) as unknown as AppContext
+
+const execute = createPullRequestTool.execute as unknown as (
+  input: Record<string, unknown>,
+  opts: { context: AppContext },
+) => Promise<{ success: boolean; prUrl?: string; message?: string }>
+
+/** 按 URL/method 路由的 GitHub API 假响应 */
+function githubRoute() {
+  const sha = (n: string) => ({ sha: n })
+  mocks.fetchMock.mockImplementation(async (url: string, init?: RequestInit) => {
+    const method = init?.method ?? "GET"
+    const json = (body: unknown, status = 200) =>
+      new Response(JSON.stringify(body), { status })
+    if (url.includes("/git/refs/heads/") && method === "GET") {
+      return json({ object: sha("basesha") })
+    }
+    if (url.endsWith("/git/blobs") && method === "POST") {
+      return json(sha("blobsha"))
+    }
+    if (url.endsWith("/git/trees") && method === "POST") {
+      return json(sha("treesha"))
+    }
+    if (url.endsWith("/git/commits") && method === "POST") {
+      return json(sha("commitsha"))
+    }
+    if (url.includes("/git/refs/heads/") && method === "PATCH") {
+      return json(sha("refsha"))
+    }
+    if (url.endsWith("/pulls") && method === "POST") {
+      return json({ html_url: "https://github.com/acme/widgets/pull/1" })
+    }
+    return json({ message: `unexpected ${method} ${url}` }, 500)
+  })
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  githubRoute()
+})
+
+describe("create_pull_request", () => {
+  it("API 调用打到 /repos/{owner}/{repo} 之下（.origin 丢路径回归哨兵）", async () => {
+    const out = await execute(
+      { title: "t", files: [{ path: "a.txt", content: "aGVsbG8=" }] },
+      { context: ctx() },
+    )
+    expect(out.success).toBe(true)
+    const firstUrl = mocks.fetchMock.mock.calls[0]![0] as string
+    expect(firstUrl).toBe("https://api.github.com/repos/acme/widgets/git/refs/heads/main")
+  })
+
+  it("blob 以 encoding=base64 提交，分支名经 encodeURIComponent", async () => {
+    await execute(
+      {
+        title: "t",
+        branch: "feat/a b",
+        files: [{ path: "a.txt", content: "aGVsbG8=" }],
+      },
+      { context: ctx() },
+    )
+    const blobCall = mocks.fetchMock.mock.calls.find(
+      (c) => (c[0] as string).endsWith("/git/blobs"),
+    )!
+    const blobBody = JSON.parse(blobCall[1]!.body as string) as { encoding: string }
+    expect(blobBody.encoding).toBe("base64")
+
+    const patchUrl = mocks.fetchMock.mock.calls.find(
+      (c) => (c[1]?.method as string) === "PATCH",
+    )![0] as string
+    expect(patchUrl).toBe(
+      "https://api.github.com/repos/acme/widgets/git/refs/heads/feat%2Fa%20b",
+    )
+  })
+
+  it("每次 fetch 都携带 AbortSignal.timeout", async () => {
+    await execute(
+      { title: "t", files: [{ path: "a.txt", content: "aGVsbG8=" }] },
+      { context: ctx() },
+    )
+    expect(mocks.fetchMock.mock.calls.length).toBeGreaterThan(0)
+    for (const call of mocks.fetchMock.mock.calls) {
+      const signal = (call[1] as RequestInit).signal as AbortSignal
+      expect(signal).toBeInstanceOf(AbortSignal)
+      expect(signal.aborted).toBe(false)
+    }
+  })
+
+  it("secrets 路径阻断：.env.local 命中（冗余删减后仍由 .env. 前缀模式覆盖）", async () => {
+    const out = await execute(
+      {
+        title: "t",
+        files: [
+          { path: ".env.local", content: "aGVsbG8=" },
+          { path: "src/a.txt", content: "aGVsbG8=" },
+        ],
+      },
+      { context: ctx() },
+    )
+    expect(out.success).toBe(false)
+    expect(out.message).toContain("敏感文件")
+    expect(out.message).toContain(".env.local")
+    // 只发生默认分支 ref 一次查询，未创建任何 blob
+    expect(mocks.fetchMock).toHaveBeenCalledTimes(1)
+  })
+})

package/src/server/ai-gateway/__tests__/delegate-task.test.ts

@@ -0,0 +1,121 @@
+// @vitest-environment node
+// 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/>.
+
+// delegate_task 工具修复回归（审计 A3x-ai-gateway-3）：
+// 🟠 context 入参透传进子 agent 消息（此前被静默丢弃）
+// 🟡 并发槽按 userId 计数（此前全局共享，A 用户可饿死 B 用户）+ 槽位 finally 释放
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  runChatAsAgent: vi.fn(),
+}))
+
+vi.mock("../runs/agent-runtime", () => ({
+  runChatAsAgent: mocks.runChatAsAgent,
+}))
+
+import { delegateTaskTool } from "../tools/delegate-task"
+import type { AppContext } from "../types"
+
+const ctx = (userId: string): AppContext =>
+  ({
+    userId,
+    db: undefined as unknown as AppContext["db"],
+    allowedTools: ["delegate_task", "knowledge_search"],
+  }) as AppContext
+
+const execute = delegateTaskTool.execute as unknown as (
+  input: Record<string, unknown>,
+  opts: { context: AppContext },
+) => Promise<{ summary: string; result: string }>
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe("delegate_task", () => {
+  it("context 入参拼入首条 user 消息（不再被静默丢弃）", async () => {
+    mocks.runChatAsAgent.mockResolvedValue("子 agent 结果")
+    await execute(
+      { bizKey: "story.pm", task: "补充 PRD 细节", context: "面向 iOS 端" },
+      { context: ctx("u1") },
+    )
+    expect(mocks.runChatAsAgent).toHaveBeenCalledTimes(1)
+    const messages = mocks.runChatAsAgent.mock.calls[0]![1] as Array<{ role: string; content: string }>
+    expect(messages[0]!.role).toBe("user")
+    expect(messages[0]!.content).toContain("补充 PRD 细节")
+    expect(messages[0]!.content).toContain("面向 iOS 端")
+  })
+
+  it("无 context 时不追加附加段", async () => {
+    mocks.runChatAsAgent.mockResolvedValue("ok")
+    await execute({ bizKey: "story.pm", task: "任务" }, { context: ctx("u1") })
+    const messages = mocks.runChatAsAgent.mock.calls[0]![1] as Array<{ content: string }>
+    expect(messages[0]!.content).toBe("任务")
+  })
+
+  it("并发槽按 userId 计数：第 4 个委派被拒，另一用户不受影响", async () => {
+    // 挂起中的委派：每个调用独立 resolve 柄，避免相互覆盖
+    const releases: Array<() => void> = []
+    mocks.runChatAsAgent.mockImplementation(
+      () =>
+        new Promise<string>((resolve) => {
+          releases.push(() => resolve("done"))
+        }),
+    )
+    const pending = [
+      execute({ bizKey: "story.pm", task: "t1" }, { context: ctx("u-conc") }),
+      execute({ bizKey: "story.pm", task: "t2" }, { context: ctx("u-conc") }),
+      execute({ bizKey: "story.pm", task: "t3" }, { context: ctx("u-conc") }),
+    ]
+    // 等微任务排空，让 3 个委派进入在途状态
+    await new Promise((r) => setTimeout(r, 0))
+
+    const rejected = await execute({ bizKey: "story.pm", task: "t4" }, { context: ctx("u-conc") })
+    expect(rejected.summary).toContain("上限")
+    expect(mocks.runChatAsAgent).toHaveBeenCalledTimes(3)
+
+    // 其他用户不受 u-conc 占槽影响
+    const other = execute({ bizKey: "story.pm", task: "t-other" }, { context: ctx("u-other") })
+    await new Promise((r) => setTimeout(r, 0))
+    expect(mocks.runChatAsAgent).toHaveBeenCalledTimes(4)
+    expect(mocks.runChatAsAgent.mock.calls[3]![2]).toMatchObject({ userId: "u-other" })
+    // 全部放行，收尾不悬挂
+    for (const release of releases) release()
+    expect((await other).summary).toBe("done")
+    await Promise.all(pending)
+  })
+
+  it("子 agent 失败后槽位释放（finally），可再次委派", async () => {
+    mocks.runChatAsAgent.mockRejectedValueOnce(new Error("boom"))
+    const failed = await execute({ bizKey: "story.pm", task: "t" }, { context: ctx("u-fail") })
+    expect(failed.summary).toBe("委派执行失败")
+
+    mocks.runChatAsAgent.mockResolvedValue("recovered")
+    const retry = await execute({ bizKey: "story.pm", task: "t" }, { context: ctx("u-fail") })
+    expect(retry.summary).toBe("recovered")
+  })
+
+  it("delegate_task 不进入子链工具面（防自递归）", async () => {
+    mocks.runChatAsAgent.mockResolvedValue("ok")
+    await execute({ bizKey: "story.pm", task: "t" }, { context: ctx("u-tools") })
+    const opts = mocks.runChatAsAgent.mock.calls[0]![2] as { allowedTools: string[] }
+    expect(opts.allowedTools).not.toContain("delegate_task")
+    expect(opts.allowedTools).toContain("knowledge_search")
+  })
+})

package/src/server/ai-gateway/__tests__/embedding-request.test.ts

@@ -1,5 +1,5 @@
 // @vitest-environment node
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import http from "node:http";
 import type { AddressInfo } from "node:net";
 
@@ -41,11 +41,19 @@ afterAll(async () => {
 describe("generateEmbedding 真实请求路径（本地 mock OpenAI 兼容端点）", () => {
   beforeEach(async () => {
     vi.resetModules();
+    // 本测试的 mock 端点跑在本机回环地址：SEC-08 出口守卫按云端语义会拒绝
+    // 127.0.0.1。stub 为桌面运行时（DESKTOP 语义 = 单机形态允许本地服务），
+    // 与「桌面端本地 embedding 服务」这条放行路径一致。
+    vi.stubEnv("DATABASE_PROVIDER", "sqlite");
     const mod = await import("../embedding");
     generateEmbedding = mod.generateEmbedding;
     EMBEDDING_MODEL = mod.EMBEDDING_MODEL;
   });
 
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
   it("显式 baseUrl 时走 openai/ 前缀模型名并命中 embeddings 端点", async () => {
     requests.length = 0;
     const vector = await generateEmbedding("测试文本", { apiKey: "sk-mock", baseUrl: base });
@@ -55,6 +63,14 @@ describe("generateEmbedding 真实请求路径（本地 mock OpenAI 兼容端点
     expect(vector).toEqual(FIXED_VECTOR);
   });
 
+  it("云端语义（非 desktop）下回环 baseUrl 被 SSRF 守卫拒绝（SEC-08 回归哨兵）", async () => {
+    vi.stubEnv("DATABASE_PROVIDER", "postgresql");
+    const mod = await import("../embedding");
+    await expect(
+      mod.generateEmbedding("测试文本", { apiKey: "sk-mock", baseUrl: base }),
+    ).rejects.toThrow(/SSRF|拒绝 fetch 目标/);
+  });
+
   it("无 baseUrl 且仅配 OPENROUTER_API_KEY 时兜底到 openrouter 端点", async () => {
     const saved = process.env.OPENAI_API_KEY;
     delete process.env.OPENAI_API_KEY;

package/src/server/ai-gateway/__tests__/embedding.test.ts

@@ -39,4 +39,27 @@ describe("embedding", () => {
     const chunks = chunkText(source, 500);
     expect(chunks.join(" ")).toBe(source.replace(/\s+/g, " ").trim());
   });
+
+  it("结尾无终止符的尾段不被丢弃（审计 2026-10-25 🟠 回归哨兵）", () => {
+    const chunks = chunkText("Intro. body without final period", 500);
+    expect(chunks.join("")).toBe("Intro. body without final period");
+    expect(chunks.join("")).toContain("body without final period");
+  });
+
+  it("中文句读（。！？）作为终止符切分，纯中文长文不再整篇成单 chunk", () => {
+    const sentence = "这是一句足够长的话需要被切分";
+    const source = `${sentence}。${sentence}！${sentence}？${sentence}。`;
+    const chunks = chunkText(source, 20);
+    expect(chunks.length).toBeGreaterThan(1);
+    expect(chunks.every((c) => c.length <= 20)).toBe(true);
+  });
+
+  it("任意输入（含换行/列表/空串）零内容丢失", () => {
+    const source = "第一行。\n- 列表项一\n- 列表项二\n结尾没有句号";
+    const chunks = chunkText(source, 12);
+    expect(chunks.join("").replace(/\s+/g, "")).toBe(
+      source.replace(/\s+/g, ""),
+    );
+    expect(chunkText("", 100)).toEqual([]);
+  });
 });

package/src/server/ai-gateway/__tests__/interrupt-store.test.ts

@@ -26,15 +26,19 @@ vi.mock("@allbluecn/database", () => ({
     chatInterrupt: {
       create: vi.fn(),
       update: vi.fn(),
+      updateMany: vi.fn(),
       findUnique: vi.fn(),
+      findFirst: vi.fn(),
       findMany: vi.fn(),
     },
     chatThread: {
       upsert: vi.fn(),
+      findUnique: vi.fn(),
     },
     chatRun: {
       upsert: vi.fn(),
     },
+    $transaction: vi.fn(),
   },
 }));
 
@@ -48,15 +52,19 @@ const mockPrisma = prisma as unknown as {
   chatInterrupt: {
     create: ReturnType<typeof vi.fn>;
     update: ReturnType<typeof vi.fn>;
+    updateMany: ReturnType<typeof vi.fn>;
     findUnique: ReturnType<typeof vi.fn>;
+    findFirst: ReturnType<typeof vi.fn>;
     findMany: ReturnType<typeof vi.fn>;
   };
   chatThread: {
     upsert: ReturnType<typeof vi.fn>;
+    findUnique: ReturnType<typeof vi.fn>;
   };
   chatRun: {
     upsert: ReturnType<typeof vi.fn>;
   };
+  $transaction: ReturnType<typeof vi.fn>;
 };
 
 const USER_ID = "user1";
@@ -65,11 +73,20 @@ describe("interruptStore", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+    mockPrisma.chatInterrupt.findFirst.mockResolvedValue(null);
     mockPrisma.chatInterrupt.findMany.mockResolvedValue([]);
     mockPrisma.chatInterrupt.create.mockResolvedValue({} as any);
     mockPrisma.chatInterrupt.update.mockResolvedValue({} as any);
+    mockPrisma.chatInterrupt.updateMany.mockResolvedValue({ count: 1 } as any);
     mockPrisma.chatThread.upsert.mockResolvedValue({} as any);
     mockPrisma.chatRun.upsert.mockResolvedValue({} as any);
+    // create 归属校验：缺省 thread 不存在（findUnique → null）走创建分支
+    mockPrisma.chatThread.findUnique.mockResolvedValue(null);
+    // commitBatch：数组形式事务原样回传每条 updateMany 的结果
+    mockPrisma.$transaction.mockImplementation(
+      async (ops: Array<Promise<{ count: number }>>) =>
+        Promise.all(ops.map(() => ({ count: 1 }))),
+    );
   });
 
   async function createStore() {
@@ -159,6 +176,25 @@ describe("interruptStore", () => {
     );
   });
 
+  it("create 他人 thread → 抛错且不建 run/interrupt 行（审计 persistence 归属）", async () => {
+    mockPrisma.chatThread.findUnique.mockResolvedValue({ userId: "user2" });
+
+    const store = await createStore();
+    await expect(
+      store.create({
+        interruptId: "int-foreign",
+        runId: "run-foreign",
+        threadId: "thread-of-user2",
+        requestedAt: 1000,
+        payload: {},
+      }),
+    ).rejects.toThrow("does not belong to user");
+
+    expect(mockPrisma.chatThread.upsert).not.toHaveBeenCalled();
+    expect(mockPrisma.chatRun.upsert).not.toHaveBeenCalled();
+    expect(mockPrisma.chatInterrupt.create).not.toHaveBeenCalled();
+  });
+
   it("create is idempotent — duplicate does not throw or overwrite", async () => {
     const existingRow = {
       id: "int1",
@@ -192,59 +228,29 @@ describe("interruptStore", () => {
     ).resolves.toBe(undefined);
   });
 
-  it("resolve marks resolved with resolvedAt and response", async () => {
-    const existingRow = {
-      id: "int1",
-      runId: "run1",
-      threadId: "thread1",
-      userId: USER_ID,
-      kind: "generic",
-      toolName: null,
-      state: "pending",
-      payload: {},
-      resolution: null,
-      createdAt: new Date(1000),
-      resolvedAt: null,
-    };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
-
+  it("resolve marks resolved via updateMany scoped to owner (审计 A3x-2：userId 行级过滤)", async () => {
     const store = await createStore();
     await store.resolve("int1", { result: "approved" });
 
-    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
-      where: { id: "int1" },
-    });
-    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
-      where: { id: "int1" },
+    expect(mockPrisma.chatInterrupt.updateMany).toHaveBeenCalledWith({
+      where: { id: "int1", userId: USER_ID },
       data: expect.objectContaining({
         state: "resolved",
         resolution: { response: { result: "approved" } },
         resolvedAt: expect.any(Date),
       }),
     });
+    // find-then-update 的存在性预检已删（TOCTOU 消除）
+    expect(mockPrisma.chatInterrupt.findUnique).not.toHaveBeenCalled();
+    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
   });
 
-  it("resolve with no response still marks resolved", async () => {
-    const existingRow = {
-      id: "int1",
-      runId: "run1",
-      threadId: "thread1",
-      userId: USER_ID,
-      kind: "generic",
-      toolName: null,
-      state: "pending",
-      payload: {},
-      resolution: null,
-      createdAt: new Date(1000),
-      resolvedAt: null,
-    };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
-
+  it("resolve with no response still marks resolved (DbNull)", async () => {
     const store = await createStore();
     await store.resolve("int1");
 
-    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
-      where: { id: "int1" },
+    expect(mockPrisma.chatInterrupt.updateMany).toHaveBeenCalledWith({
+      where: { id: "int1", userId: USER_ID },
       data: expect.objectContaining({
         state: "resolved",
         resolution: { __type: "DbNull" },
@@ -253,59 +259,30 @@ describe("interruptStore", () => {
     });
   });
 
-  it("resolve no-ops for unknown interruptId", async () => {
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
-
-    const store = await createStore();
-    await expect(store.resolve("unknown", {})).resolves.toBe(undefined);
-
-    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
-      where: { id: "unknown" },
-    });
-    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
-  });
-
-  it("cancel marks cancelled with resolvedAt", async () => {
-    const existingRow = {
-      id: "int1",
-      runId: "run1",
-      threadId: "thread1",
-      userId: USER_ID,
-      kind: "generic",
-      toolName: null,
-      state: "pending",
-      payload: {},
-      resolution: null,
-      createdAt: new Date(1000),
-      resolvedAt: null,
-    };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
-
+  it("cancel marks cancelled via updateMany scoped to owner", async () => {
     const store = await createStore();
     await store.cancel("int1");
 
-    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
-      where: { id: "int1" },
-    });
-    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
-      where: { id: "int1" },
+    expect(mockPrisma.chatInterrupt.updateMany).toHaveBeenCalledWith({
+      where: { id: "int1", userId: USER_ID },
       data: expect.objectContaining({
         state: "cancelled",
         resolvedAt: expect.any(Date),
       }),
     });
+    expect(mockPrisma.chatInterrupt.findUnique).not.toHaveBeenCalled();
+    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
   });
 
-  it("cancel no-ops for unknown interruptId", async () => {
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+  it("resolve/cancel 对不存在或他人 interrupt 天然 no-op（updateMany count=0 不抛错）", async () => {
+    mockPrisma.chatInterrupt.updateMany.mockResolvedValue({ count: 0 } as any);
 
     const store = await createStore();
+    await expect(store.resolve("unknown", {})).resolves.toBe(undefined);
     await expect(store.cancel("unknown")).resolves.toBe(undefined);
-
-    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
   });
 
-  it("get returns known interrupt", async () => {
+  it("get returns known interrupt（findFirst 带 userId 过滤）", async () => {
     const row = {
       id: "int1",
       runId: "run1",
@@ -319,13 +296,13 @@ describe("interruptStore", () => {
       createdAt: new Date(1000),
       resolvedAt: null,
     };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+    mockPrisma.chatInterrupt.findFirst.mockResolvedValue(row);
 
     const store = await createStore();
     const record = await store.get("int1");
 
-    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
-      where: { id: "int1" },
+    expect(mockPrisma.chatInterrupt.findFirst).toHaveBeenCalledWith({
+      where: { id: "int1", userId: USER_ID },
     });
     expect(record).toMatchObject({
       interruptId: "int1",
@@ -352,7 +329,7 @@ describe("interruptStore", () => {
       createdAt: new Date(1000),
       resolvedAt: new Date(2000),
     };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+    mockPrisma.chatInterrupt.findFirst.mockResolvedValue(row);
 
     const store = await createStore();
     const record = await store.get("int1");
@@ -367,13 +344,13 @@ describe("interruptStore", () => {
   });
 
   it("get returns null for unknown interruptId", async () => {
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+    mockPrisma.chatInterrupt.findFirst.mockResolvedValue(null);
 
     const store = await createStore();
     const record = await store.get("nonexistent");
 
-    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
-      where: { id: "nonexistent" },
+    expect(mockPrisma.chatInterrupt.findFirst).toHaveBeenCalledWith({
+      where: { id: "nonexistent", userId: USER_ID },
     });
     expect(record).toBeNull();
   });
@@ -541,7 +518,7 @@ describe("interruptStore", () => {
       createdAt: new Date(1000),
       resolvedAt: new Date(2000),
     };
-    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+    mockPrisma.chatInterrupt.findFirst.mockResolvedValue(row);
 
     const store = await createStore();
     const record = await store.get("int1");
@@ -551,4 +528,40 @@ describe("interruptStore", () => {
       response: "plain-string-response",
     });
   });
+
+  it("commitBatch 经 $transaction 逐条 updateMany 且按 userId 过滤（审计 A3x-2）", async () => {
+    const store = await createStore();
+    if (!store.commitBatch) throw new Error("commitBatch not implemented");
+    await store.commitBatch([
+      { interruptId: "int1", status: "resolved" as const, response: { approved: true } },
+      { interruptId: "int2", status: "cancelled" as const },
+    ]);
+
+    expect(mockPrisma.$transaction).toHaveBeenCalledTimes(1);
+    const ops = mockPrisma.$transaction.mock.calls[0][0] as Array<unknown>;
+    expect(ops).toHaveLength(2);
+    expect(mockPrisma.chatInterrupt.updateMany).toHaveBeenCalledWith({
+      where: { id: "int1", userId: USER_ID },
+      data: expect.objectContaining({
+        state: "resolved",
+        resolution: { response: { approved: true } },
+      }),
+    });
+    expect(mockPrisma.chatInterrupt.updateMany).toHaveBeenCalledWith({
+      where: { id: "int2", userId: USER_ID },
+      data: expect.objectContaining({ state: "cancelled" }),
+    });
+  });
+
+  it("commitBatch 有条目未命中（不存在/他人）→ 整批显式抛错，不静默部分通过", async () => {
+    mockPrisma.$transaction.mockImplementation(
+      async () => [{ count: 1 }, { count: 0 }] as unknown as Array<{ count: number }>,
+    );
+
+    const store = await createStore();
+    if (!store.commitBatch) throw new Error("commitBatch not implemented");
+    await expect(
+      store.commitBatch([{ interruptId: "ghost", status: "resolved" as const }]),
+    ).rejects.toThrow("missing or not owned");
+  });
 });