@allbluecn/web-app 0.19.2 → 0.19.4

package/src/server/ai-gateway/__tests__/knowledge-search-fence.test.ts

@@ -57,8 +57,8 @@ const ctx: AppContext = {
 const count = (s: string, sub: string) => s.split(sub).length - 1
 
 /**
- * 模拟一条检索命中。id 格式为 `<documentId>-<chunkIndex>`：工具按首个 "-"
- * 前缀取 documentId（分片索引被丢弃），故 documentId 本身不能再含 "-"。
+ * 模拟一条检索命中。id 格式为 `<documentId>-<chunkIndex>`：工具按最后一个 "-"
+ * 拆出 documentId（分片索引被丢弃；documentId 含 "-" 时按最后一段分离依然正确）。
  * 真实标题由 knowledgeDocument 表反查；mock 缺省空数组 → 回落到 documentId。
  */
 const ragHit = (documentId: string, content: string, score: number) => ({

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

@@ -30,7 +30,9 @@ vi.mock("@allbluecn/database", () => ({
       update: vi.fn(),
       upsert: vi.fn(),
       updateMany: vi.fn(),
+      findUnique: vi.fn(),
     },
+    $transaction: vi.fn(),
   },
 }));
 
@@ -52,7 +54,9 @@ describe("messageStore", () => {
       update: ReturnType<typeof vi.fn>;
       upsert: ReturnType<typeof vi.fn>;
       updateMany: ReturnType<typeof vi.fn>;
+      findUnique: ReturnType<typeof vi.fn>;
     };
+    $transaction: ReturnType<typeof vi.fn>;
   };
 
   beforeEach(() => {
@@ -63,6 +67,12 @@ describe("messageStore", () => {
     mockPrisma.chatThread.update.mockResolvedValue({} as any);
     mockPrisma.chatThread.upsert.mockResolvedValue({} as any);
     mockPrisma.chatThread.updateMany.mockResolvedValue({ count: 1 } as any);
+    // saveThread 归属校验：缺省 thread 不存在（findUnique → null）走创建分支
+    mockPrisma.chatThread.findUnique.mockResolvedValue(null);
+    // 数组形式事务：原样等待全部操作（审计 A3x-2：delete+create 事务化）
+    mockPrisma.$transaction.mockImplementation(
+      async (ops: Array<Promise<unknown>>) => Promise.all(ops),
+    );
   });
 
   it("loadThread returns empty array when no messages", async () => {
@@ -158,6 +168,49 @@ describe("messageStore", () => {
     });
   });
 
+  it("saveThread 他人 thread → 抛错且不写入任何消息（审计 persistence 归属）", async () => {
+    mockPrisma.chatThread.findUnique.mockResolvedValue({ userId: "user2" });
+
+    const store = (await import("../persistence/message-store")).messageStore("user1");
+    await expect(store.saveThread("thread-of-user2", [
+      { id: "m1", role: "user", content: "pollution" },
+    ])).rejects.toThrow("does not belong to user");
+
+    expect(mockPrisma.chatThread.upsert).not.toHaveBeenCalled();
+    expect(mockPrisma.chatMessage.createMany).not.toHaveBeenCalled();
+  });
+
+  it("saveThread 本人 thread → 通过归属校验正常写入", async () => {
+    mockPrisma.chatThread.findUnique.mockResolvedValue({ userId: "user1" });
+
+    const store = (await import("../persistence/message-store")).messageStore("user1");
+    await store.saveThread("thread1", [{ id: "m1", role: "user", content: "mine" }]);
+
+    expect(mockPrisma.chatMessage.createMany).toHaveBeenCalledTimes(1);
+  });
+
+  it("saveThread 的 delete+create 在同一事务内（审计 A3x-2：两步写间崩溃不再丢整段历史）", async () => {
+    const store = (await import("../persistence/message-store")).messageStore("user1");
+    await store.saveThread("thread1", [{ id: "m1", role: "user", content: "hi" }]);
+
+    expect(mockPrisma.$transaction).toHaveBeenCalledTimes(1);
+    const ops = mockPrisma.$transaction.mock.calls[0][0] as unknown[];
+    expect(ops).toHaveLength(2);
+    expect(mockPrisma.chatMessage.deleteMany).toHaveBeenCalledWith({
+      where: { threadId: "thread1", thread: { userId: "user1" } },
+    });
+    expect(mockPrisma.chatMessage.createMany).toHaveBeenCalledTimes(1);
+  });
+
+  it("空消息数组事务只含 delete（createMany 空数组会被 Prisma 拒绝）", async () => {
+    const store = (await import("../persistence/message-store")).messageStore("user1");
+    await store.saveThread("thread1", []);
+
+    const ops = mockPrisma.$transaction.mock.calls[0][0] as unknown[];
+    expect(ops).toHaveLength(1);
+    expect(mockPrisma.chatMessage.createMany).not.toHaveBeenCalled();
+  });
+
   it("saveThread with empty array only deletes", async () => {
     const store = (await import("../persistence/message-store")).messageStore("user1");
     await store.saveThread("thread1", []);

package/src/server/ai-gateway/__tests__/pgvector-memory-adapter.test.ts

@@ -19,18 +19,19 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
 
 const mocks = vi.hoisted(() => {
-  const queryRawUnsafe = vi.fn()
-  const executeRawUnsafe = vi.fn()
+  // $queryRaw / $executeRaw 是标签模板：mock 收到 (templateStrings, ...values)
+  const queryRaw = vi.fn()
+  const executeRaw = vi.fn()
   const chatThreadFindUnique = vi.fn()
   const generateEmbedding = vi.fn()
   return {
-    queryRawUnsafe,
-    executeRawUnsafe,
+    queryRaw,
+    executeRaw,
     chatThreadFindUnique,
     generateEmbedding,
     prisma: {
-      $queryRawUnsafe: queryRawUnsafe,
-      $executeRawUnsafe: executeRawUnsafe,
+      $queryRaw: queryRaw,
+      $executeRaw: executeRaw,
       chatThread: { findUnique: chatThreadFindUnique },
     },
   }
@@ -58,7 +59,7 @@ const scope = { threadId: "thread-a", userId: "user-1" } as const
 // 否则 recall 在调用 embedding 之前就短路返回了——断言仍然全绿，
 // 但该用例其实什么都没测到（「检索异常降级」曾因此静默失真）。
 function seedExistingFacts(count = 1): void {
-  mocks.queryRawUnsafe.mockResolvedValueOnce([{ c: count, lastWrite: null }])
+  mocks.queryRaw.mockResolvedValueOnce([{ c: count, lastWrite: null }])
 }
 
 const VECTOR_4 = [0.1, 0.2, 0.3, 0.4]
@@ -91,8 +92,8 @@ function factRow(id: string, similarity: number, content = `内容${id}`) {
 
 beforeEach(() => {
   vi.clearAllMocks()
-  mocks.executeRawUnsafe.mockResolvedValue(1)
-  mocks.queryRawUnsafe.mockResolvedValue([])
+  mocks.executeRaw.mockResolvedValue(1)
+  mocks.queryRaw.mockResolvedValue([])
   mocks.generateEmbedding.mockResolvedValue(VECTOR_4)
 })
 
@@ -114,10 +115,10 @@ describe("pgvector MemoryAdapter.save", () => {
     expect(receipts[0]).toMatchObject({ ok: true })
     expect(receipts[0].latencyMs).toBe(25)
 
-    const [sql, id, userId, threadId, content, embeddingStr] =
-      mocks.executeRawUnsafe.mock.calls[0]
-    expect(String(sql)).toContain('INSERT INTO "memory_facts"')
-    expect(String(sql)).toContain("$5::vector")
+    const [strings, id, userId, threadId, content, embeddingStr] =
+      mocks.executeRaw.mock.calls[0]
+    expect(String(strings.join(""))).toContain('INSERT INTO "memory_facts"')
+    expect(String(strings.join(""))).toContain("::vector")
     expect(String(userId)).toBe("user-1")
     expect(String(threadId)).toBe("thread-a")
     expect(String(content)).toContain("我偏好使用深色主题")
@@ -127,7 +128,7 @@ describe("pgvector MemoryAdapter.save", () => {
 
   it("写入失败返回 ok:false + error，不抛错阻断对话", async () => {
     advanceNowBy(25)
-    mocks.executeRawUnsafe.mockRejectedValueOnce(
+    mocks.executeRaw.mockRejectedValueOnce(
       new Error('relation "memory_facts" does not exist'),
     )
     const adapter = makeAdapter()
@@ -145,7 +146,7 @@ describe("pgvector MemoryAdapter.save", () => {
 
   it("recall 有数据时返回非空 systemPrompt + 带 source 的 fragments", async () => {
     seedExistingFacts(2)
-    mocks.queryRawUnsafe.mockResolvedValue([
+    mocks.queryRaw.mockResolvedValue([
       factRow("fact-a", 0.9, "用户偏好深色主题"),
       factRow("fact-b", 0.8, "用户在杭州"),
     ])
@@ -165,7 +166,7 @@ describe("pgvector MemoryAdapter.save", () => {
 
   it("检索返回空数组时返回空 systemPrompt（middleware 会跳过注入）", async () => {
     seedExistingFacts(1)
-    mocks.queryRawUnsafe.mockResolvedValue([])
+    mocks.queryRaw.mockResolvedValue([])
     const adapter = makeAdapter()
 
     const result = await adapter.recall(scope, "随便问问")
@@ -177,21 +178,21 @@ describe("pgvector MemoryAdapter.save", () => {
 
   it("recall 用 userId 过滤，跨用户零泄露", async () => {
     seedExistingFacts(1)
-    mocks.queryRawUnsafe.mockResolvedValue([])
+    mocks.queryRaw.mockResolvedValue([])
     const adapter = makeAdapter()
 
     const result = await adapter.recall(scope, "我在哪里")
 
     expect(mocks.generateEmbedding).toHaveBeenCalledTimes(1)
-    const [sql, ...values] = mocks.queryRawUnsafe.mock.calls[1]!
-    expect(String(sql)).toContain('WHERE "userId" = $2')
+    const [strings, ...values] = mocks.queryRaw.mock.calls[1]!
+    expect(String(strings.join(""))).toContain('WHERE "userId" =')
     expect(String(values[1])).toBe("user-1")
     expect(result).toEqual({ systemPrompt: "" })
   })
 
   it("低于相似度阈值的结果被丢弃", async () => {
     seedExistingFacts(1)
-    mocks.queryRawUnsafe.mockResolvedValue([
+    mocks.queryRaw.mockResolvedValue([
       factRow("fact-low", DEFAULT_SIMILARITY_THRESHOLD - 0.05, "无关内容"),
     ])
     const adapter = makeAdapter()
@@ -202,7 +203,7 @@ describe("pgvector MemoryAdapter.save", () => {
 
   it("recall 结果按 topK 截断", async () => {
     seedExistingFacts(10)
-    mocks.queryRawUnsafe.mockResolvedValue(
+    mocks.queryRaw.mockResolvedValue(
       Array.from({ length: 10 }, (_, i) => factRow(`fact-${i}`, 0.9, `内容${i}`)),
     )
     const adapter = makeAdapter()
@@ -222,12 +223,12 @@ describe("pgvector MemoryAdapter.save", () => {
         { user: "有效内容", assistant: "回复" },
       ),
     ).toEqual([{ ok: false, error: "memory scope missing userId" }])
-    expect(mocks.executeRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.executeRaw).not.toHaveBeenCalled()
 
     expect(await adapter.recall({ threadId: "thread-a" }, "查询")).toEqual({
       systemPrompt: "",
     })
-    expect(mocks.queryRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.queryRaw).not.toHaveBeenCalled()
   })
 
   it("检索异常降级为空注入，不抛错", async () => {
@@ -245,7 +246,7 @@ describe("pgvector MemoryAdapter.save", () => {
     const receipts = await adapter.save(scope, { user: "嗯", assistant: "好的" })
 
     expect(receipts).toEqual([])
-    expect(mocks.executeRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.executeRaw).not.toHaveBeenCalled()
     expect(mocks.generateEmbedding).not.toHaveBeenCalled()
   })
 
@@ -259,7 +260,7 @@ describe("pgvector MemoryAdapter.save", () => {
       }),
     ).toEqual([])
     expect(DEFAULT_MIN_USER_CHARS).toBeLessThan(40)
-    expect(mocks.executeRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.executeRaw).not.toHaveBeenCalled()
   })
 
   it("assistant 为空时不写入", async () => {
@@ -271,7 +272,7 @@ describe("pgvector MemoryAdapter.save", () => {
         assistant: "   ",
       }),
     ).toEqual([])
-    expect(mocks.executeRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.executeRaw).not.toHaveBeenCalled()
   })
 
   it("embedding 为空向量时返回失败 receipt", async () => {
@@ -286,47 +287,47 @@ describe("pgvector MemoryAdapter.save", () => {
     expect(receipts).toHaveLength(1)
     expect(receipts[0].ok).toBe(false)
     expect(receipts[0].error).toContain("empty vector")
-    expect(mocks.executeRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.executeRaw).not.toHaveBeenCalled()
   })
 })
 
 describe("pgvector MemoryAdapter.recall 零记忆快路径", () => {
   it("该用户尚无沉淀时零 embedding 调用", async () => {
-    mocks.queryRawUnsafe.mockResolvedValue([{ c: 0, lastWrite: null }])
+    mocks.queryRaw.mockResolvedValue([{ c: 0, lastWrite: null }])
     const adapter = makeAdapter()
 
     expect(await adapter.recall(scope, "我偏好什么")).toEqual({ systemPrompt: "" })
     expect(mocks.generateEmbedding).not.toHaveBeenCalled()
-    expect(mocks.queryRawUnsafe).toHaveBeenCalledTimes(1)
+    expect(mocks.queryRaw).toHaveBeenCalledTimes(1)
   })
 
   it("有沉淀时才做 embedding + 向量检索", async () => {
-    mocks.queryRawUnsafe.mockResolvedValueOnce([{ c: 2, lastWrite: null }])
-    mocks.queryRawUnsafe.mockResolvedValue([factRow("fact-a", 0.9, "用户偏好深色主题")])
+    mocks.queryRaw.mockResolvedValueOnce([{ c: 2, lastWrite: null }])
+    mocks.queryRaw.mockResolvedValue([factRow("fact-a", 0.9, "用户偏好深色主题")])
     const adapter = makeAdapter()
 
     const result = await adapter.recall(scope, "我一般用深色模式吗")
 
     expect(mocks.generateEmbedding).toHaveBeenCalledWith("我一般用深色模式吗")
     expect(result.systemPrompt).toContain("用户偏好深色主题")
-    expect(mocks.queryRawUnsafe).toHaveBeenCalledTimes(2)
+    expect(mocks.queryRaw).toHaveBeenCalledTimes(2)
   })
 
   it("计数查询先于向量检索（顺序是零成本前提，不可调换）", async () => {
     seedExistingFacts(3)
-    mocks.queryRawUnsafe.mockResolvedValue([])
+    mocks.queryRaw.mockResolvedValue([])
     const adapter = makeAdapter()
 
     await adapter.recall(scope, "查询")
 
-    expect(String(mocks.queryRawUnsafe.mock.calls[0]![0])).toContain("COUNT(*)")
-    expect(String(mocks.queryRawUnsafe.mock.calls[1]![0])).toContain("<=>")
+    expect(String(mocks.queryRaw.mock.calls[0]![0].join(""))).toContain("COUNT(*)")
+    expect(String(mocks.queryRaw.mock.calls[1]![0].join(""))).toContain("<=>")
   })
 })
 
 describe("pgvector MemoryAdapter.inspect / listFacts", () => {
   it("inspect 返回快照结构与计数", async () => {
-    mocks.queryRawUnsafe.mockResolvedValue([
+    mocks.queryRaw.mockResolvedValue([
       { c: 7, lastWrite: new Date("2026-09-10T08:00:00Z") },
     ])
     const adapter = makeAdapter()
@@ -343,7 +344,7 @@ describe("pgvector MemoryAdapter.inspect / listFacts", () => {
   })
 
   it("inspect 无写入记录时 lastWrite 为 null", async () => {
-    mocks.queryRawUnsafe.mockResolvedValue([{ c: 0, lastWrite: null }])
+    mocks.queryRaw.mockResolvedValue([{ c: 0, lastWrite: null }])
     const adapter = makeAdapter()
 
     expect(await adapter.inspect!(scope)).toMatchObject({
@@ -352,7 +353,7 @@ describe("pgvector MemoryAdapter.inspect / listFacts", () => {
   })
 
   it("listFacts 返回 id/text/source/createdAt 结构", async () => {
-    mocks.queryRawUnsafe.mockResolvedValue([
+    mocks.queryRaw.mockResolvedValue([
       {
         id: "f1",
         content: "事实一",
@@ -376,7 +377,7 @@ describe("pgvector MemoryAdapter.inspect / listFacts", () => {
     const adapter = makeAdapter()
 
     expect(await adapter.listFacts!({ threadId: "thread-a" })).toEqual([])
-    expect(mocks.queryRawUnsafe).not.toHaveBeenCalled()
+    expect(mocks.queryRaw).not.toHaveBeenCalled()
   })
 })
 

package/src/server/ai-gateway/__tests__/prompt-vars-contract.test.ts

@@ -28,7 +28,7 @@ vi.mock("../provider-router", () => ({
 }))
 vi.mock("../runtime", () => ({ getPorts: vi.fn(() => ({})) }))
 vi.mock("../provider-tools", () => ({ hasNativeWebSearch: vi.fn(() => false) }))
-vi.mock("@/server/serverFns/web-search", () => ({
+vi.mock("@/server/web-search", () => ({
   isSearxngEnabled: vi.fn(() => false),
 }))
 

package/src/server/ai-gateway/__tests__/provider-adapter.test.ts

@@ -162,3 +162,59 @@ describe("createProviderAdapter 兜底分支", () => {
     ).rejects.toThrow("未知的 AI 服务商：ghost")
   })
 })
+
+describe("createProviderAdapter SEC-08 baseUrl 出口校验", () => {
+  it("云端（非 desktop）用户 baseUrl 指向云元数据/私网时抛 FetchGuardError", async () => {
+    mockFindUnique.mockResolvedValue(providerRow("openai") as never)
+
+    await expect(
+      createProviderAdapter("openai", {
+        model: "gpt-4o-mini",
+        apiKey: "sk-1",
+        baseUrl: "http://169.254.169.254/latest/meta-data",
+      }),
+    ).rejects.toThrow(/SSRF/)
+    await expect(
+      createProviderAdapter("openai", {
+        model: "gpt-4o-mini",
+        apiKey: "sk-1",
+        baseUrl: "http://10.0.0.5/v1",
+      }),
+    ).rejects.toThrow(/SSRF/)
+  })
+
+  it("desktop 运行时（DATABASE_PROVIDER=sqlite）放行本地 baseUrl（本地 Ollama）", async () => {
+    const saved = process.env.DATABASE_PROVIDER
+    process.env.DATABASE_PROVIDER = "sqlite"
+    try {
+      // 用 mock 的 bedrock 分支断言（openaiText 真 factory 会读 env key）
+      mockFindUnique.mockResolvedValue(providerRow("bedrock") as never)
+      await expect(
+        createProviderAdapter("bedrock", {
+          model: "llama3.3",
+          apiKey: "local",
+          baseUrl: "http://localhost:11434/v1",
+        }),
+      ).resolves.toBeDefined()
+      const [, , config] = bedrockCalls()[0]!
+      expect(config.baseURL).toBe("http://localhost:11434/v1")
+    } finally {
+      if (saved === undefined) delete process.env.DATABASE_PROVIDER
+      else process.env.DATABASE_PROVIDER = saved
+    }
+  })
+
+  it("公网 baseUrl 正常放行（不改变既有行为）", async () => {
+    mockFindUnique.mockResolvedValue({
+      ...providerRow("mistral"),
+      defaultBaseUrl: null,
+    } as never)
+    await expect(
+      createProviderAdapter("mistral", {
+        model: "mistral-large-latest",
+        apiKey: "msl-key",
+        baseUrl: "https://my-gateway.example.com/v1",
+      }),
+    ).resolves.toBeDefined()
+  })
+})

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

@@ -148,15 +148,17 @@ describe("runStore", () => {
       usage: null,
       error: null,
     };
-    mockPrisma.chatRun.findUnique.mockResolvedValue(existingRow);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(existingRow);
     mockPrisma.chatRun.update.mockResolvedValue({} as any);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
     await store.update("run1", { status: "completed", finishedAt: 2000 });
 
-    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
-      where: { id: "run1" },
+    // owning 变体按 userId 过滤（审计 A3x-2：他人 runId 不可改）
+    expect(mockPrisma.chatRun.findFirst).toHaveBeenCalledWith({
+      where: { id: "run1", userId: "user1" },
     });
+    expect(mockPrisma.chatRun.findUnique).not.toHaveBeenCalled();
     expect(mockPrisma.chatRun.update).toHaveBeenCalledWith({
       where: { id: "run1" },
       data: {
@@ -166,21 +168,31 @@ describe("runStore", () => {
     });
   });
 
+  it("update 他人 run（owning 变体查无 → 静默 no-op，零写入）", async () => {
+    mockPrisma.chatRun.findFirst.mockResolvedValue(null);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    await expect(store.update("run-of-other", { status: "completed" })).resolves.toBe(
+      undefined,
+    );
+    expect(mockPrisma.chatRun.update).not.toHaveBeenCalled();
+  });
+
   it("update no-ops for unknown runId without throwing", async () => {
-    mockPrisma.chatRun.findUnique.mockResolvedValue(null);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(null);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
     await expect(store.update("unknown", { status: "completed" })).resolves.toBe(
       undefined,
     );
 
-    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
-      where: { id: "unknown" },
+    expect(mockPrisma.chatRun.findFirst).toHaveBeenCalledWith({
+      where: { id: "unknown", userId: "user1" },
     });
     expect(mockPrisma.chatRun.update).not.toHaveBeenCalled();
   });
 
-  it("get returns known run", async () => {
+  it("get returns known run（owning 变体 findFirst 带 userId）", async () => {
     const row = {
       id: "run1",
       threadId: "thread1",
@@ -192,14 +204,15 @@ describe("runStore", () => {
       usage: { input: 100, output: 200 },
       error: null,
     };
-    mockPrisma.chatRun.findUnique.mockResolvedValue(row);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(row);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
     const record = await store.get("run1");
 
-    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
-      where: { id: "run1" },
+    expect(mockPrisma.chatRun.findFirst).toHaveBeenCalledWith({
+      where: { id: "run1", userId: "user1" },
     });
+    expect(mockPrisma.chatRun.findUnique).not.toHaveBeenCalled();
     expect(record).toMatchObject({
       runId: "run1",
       threadId: "thread1",
@@ -211,13 +224,13 @@ describe("runStore", () => {
   });
 
   it("get returns null for unknown runId", async () => {
-    mockPrisma.chatRun.findUnique.mockResolvedValue(null);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(null);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
     const record = await store.get("nonexistent");
 
-    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
-      where: { id: "nonexistent" },
+    expect(mockPrisma.chatRun.findFirst).toHaveBeenCalledWith({
+      where: { id: "nonexistent", userId: "user1" },
     });
     expect(record).toBeNull();
   });
@@ -314,7 +327,7 @@ describe("runStore", () => {
       usage: null,
       error: null,
     };
-    mockPrisma.chatRun.findUnique.mockResolvedValue(existingRow);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(existingRow);
     mockPrisma.chatRun.update.mockResolvedValue({} as any);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
@@ -342,7 +355,7 @@ describe("runStore", () => {
       usage: null,
       error: JSON.stringify({ message: "fail", code: "EFAIL" }),
     };
-    mockPrisma.chatRun.findUnique.mockResolvedValue(row);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(row);
 
     const store = (await import("../persistence/run-store")).runStore("user1");
     const record = await store.get("run1");
@@ -355,6 +368,29 @@ describe("runStore", () => {
     });
   });
 
+  it("rowToRecord 对非 JSON 的 error 历史值降级 { message } 而非抛错（审计 A3x-2）", async () => {
+    const row = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "failed",
+      startedAt: new Date(1000),
+      finishedAt: new Date(2000),
+      detachedSince: null,
+      usage: null,
+      error: "plain-text failure not from JSON.stringify",
+    };
+    mockPrisma.chatRun.findFirst.mockResolvedValue(row);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.get("run1");
+
+    expect(record).toMatchObject({
+      runId: "run1",
+      error: { message: "plain-text failure not from JSON.stringify" },
+    });
+  });
+
   it("listReclaimable returns detached running runs past TTL", async () => {
     const row = {
       id: "run1",

package/src/server/ai-gateway/__tests__/skills-resource-tool.test.ts

@@ -0,0 +1,56 @@
+// @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/>.
+
+// 资源工具条件注册回归（审计 🟢：注释称「只在确有资源时注册」实为无条件注册）。
+// mock builtin-source 使内置技能为空/零资源，断言 read_skill_resource 不注册。
+import { describe, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  hasResources: vi.fn(() => false),
+}))
+
+vi.mock("../skills/builtin-source", () => ({
+  getBuiltinSkillSources: vi.fn(() => []),
+  getBuiltinSkillCatalog: vi.fn(() => []),
+  getBuiltinResourceSource: vi.fn(() => {
+    throw new Error("zero-resource scenario must not construct a source")
+  }),
+  hasBuiltinResources: mocks.hasResources,
+}))
+
+import { resolveSkillSources } from "../skills"
+
+describe("resolveSkillSources 资源工具条件注册", () => {
+  it("零资源（hasBuiltinResources=false）→ 不注册资源工具、不构造聚合源", async () => {
+    const resolved = await resolveSkillSources({})
+    expect(resolved.tools).toEqual([])
+    expect(mocks.hasResources).toHaveBeenCalled()
+  })
+
+  it("有资源（hasBuiltinResources=true）→ 注册 read_skill_resource", async () => {
+    // 动态改 mock 返回值并重取模块（resolveSkillSources 每次调用都重读）
+    const mod = await import("../skills/builtin-source")
+    vi.mocked(mod.hasBuiltinResources).mockReturnValue(true)
+    vi.mocked(mod.getBuiltinResourceSource).mockImplementation(
+      () => ({}) as ReturnType<typeof mod.getBuiltinResourceSource>,
+    )
+
+    const resolved = await resolveSkillSources({})
+    expect(resolved.tools.map((t) => t.name)).toEqual(["read_skill_resource"])
+  })
+})

package/src/server/ai-gateway/__tests__/todo-plan-tools.test.ts

@@ -305,7 +305,7 @@ describe("plan-approval middleware：generic interrupt 触发路径", () => {
     expect(second).toBeUndefined();
   });
 
-  it("边界：arguments 非合法 JSON → 跳过该调用不 raise", async () => {
+  it("边界：arguments 非合法 JSON → 仍 raise 占位审批（审计 A3x-2：审批门不可被非法参数绕过）", async () => {
     const { middleware } = await makeMiddleware();
     const ctx = makeBoundaryCtx(
       [
@@ -320,10 +320,17 @@ describe("plan-approval middleware：generic interrupt 触发路径", () => {
       "beforeTools",
     );
     const result = await middleware.onInterruptBoundary?.(ctx);
-    expect(result).toBeUndefined();
+    expect(result).toBeDefined();
+    const interrupts = (result as unknown as { interrupts: ReadonlyArray<Record<string, unknown>> }).interrupts;
+    expect(interrupts).toHaveLength(1);
+    const req = interrupts[0] as { key: string; payload: { title: string; steps: unknown[] } };
+    expect(req.key).toBe("tc-bad");
+    // 降级占位 payload：满足 schema 形状，语义为「请人工确认」
+    expect(req.payload.title).toContain("无法解析");
+    expect(req.payload.steps).toEqual([]);
   });
 
-  it("边界：arguments JSON 合法但 safeParse 失败（缺 title）→ 跳过不 raise", async () => {
+  it("边界：arguments JSON 合法但 safeParse 失败（缺 title）→ 仍 raise 占位审批", async () => {
     const { middleware } = await makeMiddleware();
     const ctx = makeBoundaryCtx(
       [
@@ -342,7 +349,13 @@ describe("plan-approval middleware：generic interrupt 触发路径", () => {
       "beforeTools",
     );
     const result = await middleware.onInterruptBoundary?.(ctx);
-    expect(result).toBeUndefined();
+    expect(result).toBeDefined();
+    const interrupts = (result as unknown as { interrupts: ReadonlyArray<Record<string, unknown>> }).interrupts;
+    expect(interrupts).toHaveLength(1);
+    const req = interrupts[0] as { key: string; payload: { title: string; steps: unknown[] } };
+    expect(req.key).toBe("tc-schema");
+    expect(req.payload.title).toContain("无法解析");
+    expect(req.payload.steps).toEqual([]);
   });
 
   it("边界：toolCalls 空数组 → 不 raise", async () => {