@allbluecn/web-app 0.23.3 → 0.23.5

package/src/server/serverFns/sync/transfer.ts

@@ -7,10 +7,11 @@
 // cookie 天然过鉴权（backend 进程无 cookie，不得由 bind-flow 直调——复审⑥ P1-8）。
 // 校验链：① readRemoteAuth().userId 必须等于 data.cloudUserId（转移目标必须等于
 // 已交换登录的云账号，防参数伪造；非 desktop / 无 remoteAuth 时 readRemoteAuth
-// 恒 null → 拒绝）；② 复核目标为空账号（isAccountEmpty，与
-// /api/sync/account-status 端点同源）；③ 调 transferOwnership 执行
-// GUEST_USER_ID → cloudUserId 的单事务转移。outbox 语义由触发器自然产出
-// （op='upsert' + base_version=0），本 serverFn 不触碰同步两表。
+// 恒 null → 拒绝）；② 复核目标为空账号（**云端权威**：SaaS /api/sync/account-status，
+// I2 裁定——本地 PGlite 看不到云端数据，且转移后本地计数恒 >0 会破坏幂等重试）；
+// ③ 调 transferOwnership 执行 GUEST_USER_ID → cloudUserId 的单事务转移。
+// outbox 语义由触发器自然产出（op='upsert' + base_version=0），本 serverFn
+// 不触碰同步两表。
 // 身份字段（A8b 裁定）：name/avatarConfig 等可省略——云昵称/头像仅 SaaS 权威
 // （remote-auth.json session 块不存 profile，renderer 拿不到），省略时 handler
 // 以 remoteAuth.sessionToken 自取 SaaS profile 补齐；字段全传则用传入值（向后
@@ -27,9 +28,9 @@ import { authContextMiddleware } from "@/server/middlewares/auth-context"
 import { checkAuthRateLimit } from "@/server/middlewares/rate-limit"
 import { readRemoteAuth, clearRemoteAuth } from "@/server/remote-auth"
 import { GUEST_USER_ID, isDesktopServer } from "@/server/desktop-guest"
-import { isAccountEmpty } from "@/server/sync/account-status"
+import { probeCloudAccountStatus } from "@/server/sync/account-status-cloud"
 import { reverseTransferOwnership, transferOwnership } from "@/server/sync/ownership-transfer"
-import { fetchSaasProfile, DESKTOP_SAAS_URL } from "@/server/sync/saas-profile"
+import { fetchSaasProfile } from "@/server/sync/saas-profile"
 
 const transferInputSchema = z.object({
   cloudUserId: z.string().min(1),
@@ -52,10 +53,17 @@ export const transferOwnershipFn = createServerFn({ method: "POST" })
       )
     }
 
-    // ② 复核目标为空账号（仅空账号才允许归属转移，一期唯一路径）
-    const prisma = await getPrisma()
-    if (!(await isAccountEmpty(prisma, data.cloudUserId))) {
-      throw new Error("[sync/transfer] 目标云账号非空账号，拒绝归属转移")
+    // ② 复核目标为空账号（仅空账号才允许归属转移，一期唯一路径）。
+    //    I2 裁定：改用**云端权威**探测（SaaS /api/sync/account-status）——原先
+    //    用本地 PGlite 按 cloudUserId 计数，转移前恒 0（真）、转移后恒 >0（假），
+    //    幂等重试被自己的本地数据误判成「目标账号非空」；本地库也看不到云端数据。
+    //    不可达一律拒绝（宁可不转不可错转）。
+    const account = await probeCloudAccountStatus(remoteAuth.sessionToken)
+    if (account.unreachable) {
+      throw new Error("[sync/transfer] 无法确认目标账号状态（云端不可达），拒绝归属转移")
+    }
+    if (!account.empty) {
+      throw new Error("[sync/transfer] 目标账号非空，一期仅支持空账号转移")
     }
 
     // ②b 身份字段补齐（A8b 裁定）：name 省略 = renderer 未传身份字段（一期主
@@ -76,6 +84,7 @@ export const transferOwnershipFn = createServerFn({ method: "POST" })
     }
 
     // ③ 单事务转移 GUEST → cloudUserId（失败整体回滚，调用方走 bind:fail 恢复）
+    const prisma = await getPrisma()
     return transferOwnership(prisma, GUEST_USER_ID, {
       id: data.cloudUserId,
       name,
@@ -92,7 +101,8 @@ export const transferOwnershipFn = createServerFn({ method: "POST" })
 // （登出者必须是当前云身份本人；无 remoteAuth = 已登出/非云态 → 拒绝）；③ 会话
 // 身份 === data.cloudUserId（防「本地凭据会话与云身份并存」时误触发反向转移——
 // authjs 会话有效时 session.user.id 是本地用户而非云 id）；④ 单事务
-// cloud → GUEST 反向转移（outbox/row_state 同事务清空防反向 op 上云）。
+// cloud → GUEST 反向转移（outbox 同事务清空防反向 op 上云；row_state 保留以维持
+// base_version 连续性——裁定 R2）。
 // 事务提交成功后立即清 remote-auth（幂等）：反向转移一旦提交数据已 guest 属主，
 // 云身份残留会让 fallback 会话显示「云态零数据」假丢数据窗口（A8b 发现 2 的镜像
 // ——正向是转移成功 + 云身份未写，反向是转移成功 + 云身份未清）。renderer 侧的
@@ -132,9 +142,10 @@ export const reverseTransferOwnershipFn = createServerFn({ method: "POST" })
   })
 
 // claim 探测（A8b 编排时序第 3 步）：exchange 激活后、bind:begin 前，renderer
-// 经本端点代持云会话 token 探测目标云账号是否空账号（isAccountEmpty 口径在 SaaS
-// 侧执行——账号状态只有 SaaS 权威，本地库看不到云端数据）。探测失败（SaaS 不可
-// 达/非 200/形状漂移）一律按非空处理（宁可不转不可错转），unreachable 标记供
+// 经本端点代持云会话 token 探测目标云账号是否空账号（账号状态只有 SaaS 权威，
+// 本地库看不到云端数据；探测逻辑与 transferOwnershipFn 的复核共用
+// @/server/sync/account-status-cloud，I2 抽共享）。探测失败（SaaS 不可达/非
+// 200/形状漂移）一律按非空处理（宁可不转不可错转），unreachable 标记供
 // renderer 区分提示；非空账号一期不支持转移。
 export const probeCloudAccountStatusFn = createServerFn({ method: "POST" })
   .middleware([authContextMiddleware])
@@ -152,17 +163,7 @@ export const probeCloudAccountStatusFn = createServerFn({ method: "POST" })
       throw new Error("[sync/transfer] 无云会话（未交换登录），无法探测账号状态")
     }
 
-    try {
-      const res = await fetch(`${DESKTOP_SAAS_URL}/api/sync/account-status`, {
-        headers: { Cookie: `auth.session-token=${remoteAuth.sessionToken}` },
-        credentials: "omit",
-        signal: AbortSignal.timeout(10_000),
-      })
-      if (!res.ok) return { empty: false, unreachable: true }
-      const json = (await res.json().catch(() => null)) as { empty?: unknown } | null
-      if (typeof json?.empty !== "boolean") return { empty: false, unreachable: true }
-      return json.empty ? { empty: true } : { empty: false }
-    } catch {
-      return { empty: false, unreachable: true }
-    }
+    const status = await probeCloudAccountStatus(remoteAuth.sessionToken)
+    if (status.empty) return { empty: true }
+    return status.unreachable ? { empty: false, unreachable: true } : { empty: false }
   })

package/src/server/serverFns/workspace-kb.ts

@@ -191,6 +191,16 @@ export const listWorkspaceAvailableKbsFn = createServerFn({ method: "GET" })
     return kbs.map((k) => ({ ...k, linked: linkedIds.has(k.id) }));
   });
 
+// 工作空间 ↔ 知识库关联设置（R1 一期限制，明示避免误判为「同步丢了数据」）：
+// 本端点只写 `workspace_knowledge_bases` join 表，**不维护** KnowledgeBase.workspaceId
+// 与 KnowledgeDocument.syncWorkspaceId ——而同步面的 scope 列正是后者（见
+// sync-core 的 SYNC_TABLE_OVERRIDES：knowledge_bases.scope=workspaceId、
+// knowledge_documents.scope=syncWorkspaceId）。因此：
+//   - 经本设置页关联的 KB **不进入同步面**（本机可见，不会上云、也不会被其他设备拉到）；
+//   - 只有「创建工作空间时自动建立的 KB」走 workspaceId 绑定，才参与同步。
+// 一期按设计限制收口（不在本端点做 scope 维护，避免隐式改归属语义）；join 表
+// 关联的 scope 维护留二期（届时需连带注册 workspace_knowledge_bases 或补冗余
+// scope 列）。详见 sync-core/scripts/generate-registrations.mjs 的同一注记。
 export const setWorkspaceKbsFn = createServerFn({ method: "POST" })
   .middleware([authContextMiddleware])
   .validator(z.object({ workspaceId: z.string(), kbIds: z.array(z.string()) }))

package/src/server/sync/__tests__/ownership-transfer.test.ts

@@ -5,8 +5,10 @@
 // 归属转移核心（正向，桌面本地优先 P2-A8a）回归哨兵。mock prisma 下钉死六条
 // 安全不变式（真库断言归 A13 集成实测）：
 // ① 属主 UPDATE 覆盖固定清单的每一张表且 where 恒为 fromUserId；
-// ② AiProviderConfig.userId（配置类）不在任何 UPDATE 中（TRANSFER_EXCLUDED）；
-// ③ 云身份行 upsert（载荷含传入昵称/头像）+ guest 行 deleteMany 被调；
+// ② AiProviderConfig.userId 随身份翻转（C3 裁定：移出排除清单——不翻转的话
+//    末尾 user.deleteMany 会经 ON DELETE CASCADE 把 AI 配置一起删掉），且该表
+//    不在同步面（SYNC_TABLES 无 ai_provider_configs → 翻转不产出 outbox）；
+// ③ 云身份行建行（载荷含传入昵称/头像 + 用户级配置复制）+ guest 行 deleteMany 被调；
 // ④ syncOutbox/syncRowState 零触达（转移开着触发器自然产出 op='upsert' +
 //    base_version=0，推送拓扑 A7 已修为 upsert 正向——实现若手碰同步两表即红）；
 // ⑤ 幂等：第二次调用 UPDATE 计数 0、guest 行 deleteMany 计 0（delete 会抛
@@ -17,18 +19,22 @@
 // ⑧ probeCloudAccountStatusFn 三态——空账号 { empty: true } / 非空 { empty: false }
 // / 探测失败（非 200、网络异常、形状漂移）一律 { empty: false, unreachable: true }
 // （宁可不转不可错转）。
+// C3 追加：⑨ AI 配置行翻转先于 guest 行删除（CASCADE 无从命中）；反向转移把
+// 云行的用户级配置列带回重建的 guest 行。
 // 另有清单对齐断言：实现导出的属主清单与测试内固定清单逐项相等——schema 增删
 // User-relation FK 时此测试红（防实现清单与 schema 漂移的哨兵）。
 // @vitest-environment node
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { ZodType } from 'zod'
+import { SYNC_TABLE_MAP } from '@allbluecn/sync-core/registrations'
 
-// ── 固定哨兵清单（schema.prisma @ a3adcc0a3 全量 User-relation FK 标量列 79 处，
-//    减 TRANSFER_EXCLUDED 的 AiProviderConfig.userId = 78；扫描口径见
-//    ownership-transfer.ts 头注释）──────────────────────────────────────────
+// ── 固定哨兵清单（schema.prisma @ a3adcc0a3 全量 User-relation FK 标量列 79 处；
+//    扫描口径见 ownership-transfer.ts 头注释。C3 起 AiProviderConfig.userId 在内，
+//    TRANSFER_EXCLUDED 清零——79 处 = 翻转清单全长）────────────────────────────
 const TEST_OWNERSHIP_COLUMNS: readonly string[] = [
   'Account.userId',
   'AgentConversation.userId',
+  'AiProviderConfig.userId',
   'AiTask.createdById',
   'AiUsageLog.userId',
   'AnyHubApp.userId',
@@ -132,11 +138,34 @@ const touchable = () => ({
 
 type TouchableMock = ReturnType<typeof touchable>
 type DelegateMap = Record<string, { updateMany: UpdateManyFn }>
+type UserRow = Record<string, unknown> & { id: string }
+
+/** 用户级配置列样本（C3）：aiSourceMode 故意为 null（不复制分支的哨兵） */
+const GUEST_PREFERENCES = {
+  id: GUEST,
+  aiApiKey: 'sk-guest',
+  aiProvider: 'openrouter',
+  aiModel: 'openai/gpt-4o-mini',
+  aiSourceMode: null,
+  locale: 'zh',
+  timezone: 'Asia/Shanghai',
+} as const
+const CLOUD_PREFERENCES = {
+  id: CLOUD,
+  aiApiKey: 'sk-cloud',
+  aiProvider: 'openai',
+  locale: 'en',
+} as const
+
 type PrismaMock = DelegateMap & {
   aiProviderConfig: { updateMany: UpdateManyFn }
   syncOutbox: TouchableMock
   syncRowState: TouchableMock
-  user: { upsert: UpdateManyFn; deleteMany: UpdateManyFn }
+  user: {
+    findUnique: UpdateManyFn
+    upsert: UpdateManyFn
+    deleteMany: UpdateManyFn
+  }
   $transaction: (fn: (tx: unknown) => Promise<unknown>) => Promise<unknown>
   /** A9：$executeRaw 只存在于事务闭包的 tx 上；外层 prisma 恒 undefined
    *  （实现若绕过事务直连外层 raw 清表，此处 undefined 直接 TypeError 红） */
@@ -155,13 +184,24 @@ function makePrismaMock(): PrismaMock {
   // 表写在事务闭包外（污染窗口）即 TypeError 红（同闭包哨兵，A9）
   const tx = {
     ...delegates,
-    // 排除类与同步两表：实现绝不以 delegate 触达，桩在此「能接住误触」
-    aiProviderConfig: { updateMany: vi.fn() },
     syncOutbox: touchable(),
     syncRowState: touchable(),
     // deleteMany 首跑模拟真删（count=1）；delete（单行）对已删行抛 P2025，
     // 实现必须走 deleteMany——此处无 delete 桩，误用即 TypeError 红
-    user: { upsert: vi.fn(async () => ({})), deleteMany: vi.fn(async () => ({ count: 1 })) },
+    // findUnique：C2 起云身份行统一走 ensureCloudIdentity（id 存在性 + email/
+    // username 冲突探测），默认 null = 空库首建；guest 行的用户级配置列样本
+    // 经 readUserPreferences 读出（C3）。云身份行默认「不存在」——反向转移用例
+    // 需要读到云行配置时用 mockCloudPreferences 显式注入。
+    user: {
+      findUnique: vi.fn(async (args?: { where?: Record<string, string> }) => {
+        const [field, value] = Object.entries(args?.where ?? {})[0] ?? []
+        if (field !== 'id') return null // email / username 冲突探测：恒空闲
+        if (value === GUEST) return GUEST_PREFERENCES
+        return null
+      }),
+      upsert: vi.fn(async () => ({})),
+      deleteMany: vi.fn(async () => ({ count: 1 })),
+    },
     $executeRaw: vi.fn(async () => 1),
   }
   const prisma = { ...tx } as Record<string, unknown>
@@ -182,6 +222,18 @@ const setUpdateCounts = (prisma: PrismaMock, count: number) => {
   }
 }
 
+/** 反向转移用例：让 readUserPreferences(CLOUD) 读到云身份行的用户级配置样本
+ *  （正向路径的 ensureCloudIdentity 存在性探测仍返回 null = 空库首建） */
+const mockCloudPreferences = (prisma: PrismaMock) => {
+  prisma.user.findUnique.mockImplementation(async (args?: { where?: Record<string, string> }) => {
+    const [field, value] = Object.entries(args?.where ?? {})[0] ?? []
+    if (field !== 'id') return null
+    if (value === GUEST) return GUEST_PREFERENCES
+    if (value === CLOUD) return CLOUD_PREFERENCES
+    return null
+  })
+}
+
 import {
   OWNERSHIP_COLUMNS,
   TRANSFER_EXCLUDED,
@@ -238,18 +290,37 @@ describe('transferOwnership（核心）', () => {
     }
   })
 
-  it('②AiProviderConfig.userId 不在任何 UPDATE 中（配置类排除）', async () => {
+  it('②AiProviderConfig 随身份翻转（不再排除）+ 不在同步面（翻转不上云）', async () => {
     await transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME })
 
-    expect(prisma.aiProviderConfig.updateMany).not.toHaveBeenCalled()
-    // 排除常量钉死 + 实现清单零残留（双保险：改常量名/漏排除均在此报）
-    expect(TRANSFER_EXCLUDED).toContain('AiProviderConfig.userId')
-    expect(
-      OWNERSHIP_COLUMNS.some((c) => c.table === 'AiProviderConfig'),
-    ).toBe(false)
+    // C3：AI 配置行必须翻转（不翻转 → 末尾删 guest 行经 CASCADE 静默删掉配置）
+    expect(prisma.aiProviderConfig.updateMany).toHaveBeenCalledTimes(1)
+    expect(prisma.aiProviderConfig.updateMany).toHaveBeenCalledWith({
+      where: { userId: GUEST },
+      data: { userId: CLOUD },
+    })
+    // 排除清单已清零（口径位保留）；实现清单里在内
+    expect(TRANSFER_EXCLUDED).toEqual([])
+    expect(OWNERSHIP_COLUMNS.some((c) => c.table === 'AiProviderConfig')).toBe(true)
+    // 复核同步面：ai_provider_configs 未注册 → 翻转不产出 change log / outbox
+    expect(SYNC_TABLE_MAP.has('ai_provider_configs')).toBe(false)
+    for (const regTable of SYNC_TABLE_MAP.keys()) {
+      expect(regTable).not.toBe('ai_provider_configs')
+    }
+    // 同步两表零触达（与既有 ④ 同口径，此处对 AI 配置翻转再钉一次）
+    expect(prisma.syncOutbox.updateMany).not.toHaveBeenCalled()
+    expect(prisma.syncRowState.updateMany).not.toHaveBeenCalled()
+  })
+
+  it('②b AI 配置翻转子序先于 guest 行删除（CASCADE 无从命中）', async () => {
+    await transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME })
+
+    const flipOrder = prisma.aiProviderConfig.updateMany.mock.invocationCallOrder[0]
+    const deleteOrder = (prisma.user.deleteMany as UpdateManyFn).mock.invocationCallOrder[0]
+    expect(flipOrder).toBeLessThan(deleteOrder)
   })
 
-  it('③云身份行 upsert（载荷含传入昵称/头像）+ guest 行 delete 被调', async () => {
+  it('③云身份行建行（载荷含传入昵称/头像 + 用户级配置复制）+ guest 行 delete 被调', async () => {
     await transferOwnership(prisma as never, GUEST, {
       id: CLOUD,
       name: CLOUD_NAME,
@@ -271,6 +342,15 @@ describe('transferOwnership（核心）', () => {
       avatarConfig: CLOUD_AVATAR,
       status: 'ACTIVE',
     })
+    // C3：用户级配置列随身份复制（AI key 不丢；aiSourceMode=null 不复制）
+    expect(arg.create).toMatchObject({
+      aiApiKey: 'sk-guest',
+      aiProvider: 'openrouter',
+      aiModel: 'openai/gpt-4o-mini',
+      locale: 'zh',
+      timezone: 'Asia/Shanghai',
+    })
+    expect('aiSourceMode' in arg.create).toBe(false)
     // password 随机占位（同 desktop-bootstrap 惯例：凭据登录必失败）
     expect(typeof arg.create.password).toBe('string')
     expect((arg.create.password as string).length).toBeGreaterThan(0)
@@ -295,6 +375,44 @@ describe('transferOwnership（核心）', () => {
     ).toEqual([])
   })
 
+  it('④b R2 重置 row_state 版本基线：base_version=0 + dirty=true，同事务、翻转之后、删 guest 行之前', async () => {
+    await transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME })
+
+    // raw 只经事务闭包的 tx（外层 prisma 无 $executeRaw——绕过事务即 TypeError 红）
+    const raw = prisma.__tx!.$executeRaw
+    expect(raw).toHaveBeenCalledTimes(1)
+    const sql = String((raw.mock.calls[0] as [TemplateStringsArray])[0])
+    expect(sql).toContain('UPDATE sync_row_state')
+    expect(sql).toContain('base_version = 0')
+    expect(sql).toContain('dirty = true')
+    // 不删行：删掉后 pull 把「有行但无 row_state」视为非 dirty → 直接覆盖本地行
+    expect(sql).not.toContain('DELETE')
+    expect(prisma.$executeRaw).toBeUndefined()
+
+    // 执行序：全部属主翻转 → 基线重置 → 删 guest 行
+    const lastFlipOrder = Math.max(
+      ...TEST_MODELS.flatMap((m) =>
+        ((prisma[delegateOf(m)] as { updateMany: UpdateManyFn }).updateMany.mock
+          .invocationCallOrder as number[]),
+      ),
+    )
+    const resetOrder = raw.mock.invocationCallOrder[0]
+    const deleteOrder = (prisma.user.deleteMany as UpdateManyFn).mock.invocationCallOrder[0]
+    expect(resetOrder).toBeGreaterThan(lastFlipOrder)
+    expect(resetOrder).toBeLessThan(deleteOrder)
+  })
+
+  it('④c R2 幂等二跑同样执行重置（UPDATE 全表天然幂等，不抛错）', async () => {
+    await transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME })
+    setUpdateCounts(prisma, 0)
+    prisma.user.deleteMany.mockResolvedValue({ count: 0 })
+
+    await expect(
+      transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME }),
+    ).resolves.toEqual({ tables: TEST_OWNERSHIP_COLUMNS.length, rows: 0 })
+    expect(prisma.__tx!.$executeRaw).toHaveBeenCalledTimes(2)
+  })
+
   it('⑤幂等：重复调用 UPDATE 计数 0，返回 { tables, rows: 0 } 不抛错', async () => {
     await transferOwnership(prisma as never, GUEST, { id: CLOUD, name: CLOUD_NAME })
 
@@ -394,24 +512,26 @@ describe('reverseTransferOwnership（A9 反向核心）', () => {
     expect(upsertOrder).toBeLessThan(firstUpdateOrder)
   })
 
-  it('③outbox/row_state 同事务清空：$executeRaw 含两条 DELETE，且在闭包内于翻转后执行', async () => {
+  it('③outbox 清空 / row_state 不动（裁定 R2）：单条 DELETE，且在闭包内于翻转后执行', async () => {
     await reverseTransferOwnership(prisma as never, CLOUD, GUEST)
 
     // raw 清表只经事务闭包的 tx（外层 prisma 无 $executeRaw——绕过事务即 TypeError 红）
     const raw = prisma.__tx!.$executeRaw
-    expect(raw).toHaveBeenCalledTimes(2)
+    expect(raw).toHaveBeenCalledTimes(1)
     const sqls = (raw.mock.calls as Array<[TemplateStringsArray]>).map((c) =>
       String(c[0]),
     )
     expect(sqls.some((s) => s.includes('DELETE FROM sync_outbox'))).toBe(true)
-    expect(sqls.some((s) => s.includes('DELETE FROM sync_row_state'))).toBe(true)
+    // 裁定 R2：row_state 保留（清掉会让重登后首推 base_version 全 0 → 全量
+    // versionDiverged；outbox 是「待推 op」的唯一载体，清它就够）
+    expect(sqls.some((s) => s.includes('DELETE FROM sync_row_state'))).toBe(false)
     expect(prisma.$executeRaw).toBeUndefined()
 
     // 同一事务：$transaction 恰一次（无第二事务 / 无事务外窗口）
     expect(prisma.$transaction).toHaveBeenCalledTimes(1)
 
-    // 闭包内执行序：guest 行重建 → 属主翻转 → 云行删除 → raw 清表（最后清同步两表，
-    // 清空后引擎无从产出反向 op——审查重点「防反向 op 推上云污染」）
+    // 闭包内执行序：guest 行重建 → 属主翻转 → 云行删除 → 清 outbox（清空后引擎
+    // 无从产出反向 op——审查重点「防反向 op 推上云污染」）
     const rawOrder = raw.mock.invocationCallOrder
     const lastUpdateOrder = Math.max(
       ...(prisma.story.updateMany as UpdateManyFn).mock.invocationCallOrder,
@@ -421,22 +541,42 @@ describe('reverseTransferOwnership（A9 反向核心）', () => {
     expect(Math.min(...rawOrder)).toBeGreaterThan(deleteOrder)
   })
 
-  it('④AiProviderConfig.userId 不翻转（配置类排除同正向）', async () => {
+  it('④AiProviderConfig 反向翻转 + 云行用户级配置复制到重建的 guest 行（C3）', async () => {
+    mockCloudPreferences(prisma)
     await reverseTransferOwnership(prisma as never, CLOUD, GUEST)
-    expect(prisma.aiProviderConfig.updateMany).not.toHaveBeenCalled()
+
+    // AI 配置行随身份回 guest（同正向；不翻转会被云行删除级联带走）
+    expect(prisma.aiProviderConfig.updateMany).toHaveBeenCalledWith({
+      where: { userId: CLOUD },
+      data: { userId: GUEST },
+    })
+
+    // guest 行重建时带走云态填的配置（AI key / 语言等；只在 create 分支生效）
+    const arg = (prisma.user.upsert as UpdateManyFn).mock.calls[0][0] as {
+      create: Record<string, unknown>
+      update: Record<string, unknown>
+    }
+    expect(arg.create).toMatchObject({
+      id: GUEST,
+      aiApiKey: 'sk-cloud',
+      aiProvider: 'openai',
+      locale: 'en',
+    })
+    // 幂等语义不变：update 仍留空（已存在的影子行保留本机值）
+    expect(arg.update).toEqual({})
   })
 
-  it('⑤幂等二跑：UPDATE 计 0、deleteMany 计 0、raw 清表照常，返回 rows=0 不抛错', async () => {
+  it('⑤幂等二跑：UPDATE 计 0、deleteMany 计 0、raw 清 outbox 照常，返回 rows=0 不抛错', async () => {
     await reverseTransferOwnership(prisma as never, CLOUD, GUEST)
 
     // 二跑：属主列 where cloudUserId 匹配 0 行（已回 guest）；云身份行已删（deleteMany
-    // 计 0 no-op）；guest 行 upsert 幂等（update 留空）；raw 清表照常执行
+    // 计 0 no-op）；guest 行 upsert 幂等（update 留空）；raw 清 outbox 照常执行
     setUpdateCounts(prisma, 0)
     prisma.user.deleteMany.mockResolvedValue({ count: 0 })
     await expect(
       reverseTransferOwnership(prisma as never, CLOUD, GUEST),
     ).resolves.toEqual({ tables: TEST_OWNERSHIP_COLUMNS.length, rows: 0 })
-    expect(prisma.__tx!.$executeRaw).toHaveBeenCalledTimes(4) // 2（首跑）+ 2（二跑）
+    expect(prisma.__tx!.$executeRaw).toHaveBeenCalledTimes(2) // 1（首跑）+ 1（二跑）
   })
 
   it('⑥审查重点（mock 翻译）：反向转移后 guest 对核心表读写可用——核心五表清单对齐 + 幂等二跑', async () => {
@@ -495,7 +635,6 @@ vi.mock('@allbluecn/database', () => ({
 const sfMocks = vi.hoisted(() => ({
   session: null as null | { user: { id: string } },
   remoteAuth: null as null | { userId: string; sessionToken?: string },
-  accountEmpty: true,
   prisma: null as unknown,
   checkAuthRateLimit: vi.fn(),
   clearRemoteAuth: vi.fn(),
@@ -578,9 +717,8 @@ vi.mock('@/server/remote-auth', () => ({
   readRemoteAuth: async () => sfMocks.remoteAuth,
   clearRemoteAuth: sfMocks.clearRemoteAuth,
 }))
-vi.mock('@/server/sync/account-status', () => ({
-  isAccountEmpty: async () => sfMocks.accountEmpty,
-}))
+// I2：空账号复核改云端权威（SaaS /api/sync/account-status），本地 isAccountEmpty
+// 不再参与转移判定——下面 transferFn 用例全部经 fetchMock 注入云端三态。
 vi.mock('@/server/middlewares/rate-limit', () => ({
   checkAuthRateLimit: sfMocks.checkAuthRateLimit,
 }))
@@ -602,25 +740,60 @@ const probeFn = probeCloudAccountStatusFn as unknown as () => Promise<{
   unreachable?: boolean
 }>
 
-// SaaS fetch stub（saas-profile.ts / probeCloudAccountStatusFn 消费；vi.stubGlobal
+// SaaS fetch stub（saas-profile.ts / account-status-cloud.ts 消费；vi.stubGlobal
 // 拦截，不真出网——惯例照 exchange-remote-token.test.ts）
 const fetchMock = vi.hoisted(() => vi.fn())
 
+interface FetchRoute {
+  ok?: boolean
+  status?: number
+  body?: unknown
+  /** true = 模拟网络异常（fetch reject） */
+  reject?: boolean
+}
+
+/**
+ * 按 URL 分流 stub：account-status（云端空账号探测，I2）与 desktop-callback
+ * （profile 自取）两个端点。缺省不传即「该端点不应被调」（调用即抛错）。
+ */
+function stubSaasFetch(routes: { accountStatus?: FetchRoute; profile?: FetchRoute }) {
+  fetchMock.mockImplementation(async (url: unknown) => {
+    const target = String(url)
+    const route = target.includes('/api/sync/account-status')
+      ? routes.accountStatus
+      : target.includes('/api/auth/desktop-callback')
+        ? routes.profile
+        : undefined
+    if (!route) throw new Error(`unexpected fetch: ${target}`)
+    if (route.reject) throw new Error('ECONNREFUSED')
+    return {
+      ok: route.ok,
+      status: route.status ?? (route.ok ? 200 : 503),
+      json: async () => route.body,
+    }
+  })
+}
+
 describe('transferOwnershipFn（serverFn 校验）', () => {
   beforeEach(() => {
     sfMocks.session = { user: { id: GUEST } }
     sfMocks.remoteAuth = { userId: CLOUD, sessionToken: 'tok-123' }
-    sfMocks.accountEmpty = true
     sfMocks.prisma = makePrismaMock()
     setUpdateCounts(sfMocks.prisma as PrismaMock, 1)
     fetchMock.mockReset()
+    // 默认：云端权威探测 = 空账号（转移放行）
+    stubSaasFetch({
+      accountStatus: { ok: true, body: { empty: true } },
+      profile: { ok: true, body: SAAS_PROFILE },
+    })
+    vi.stubGlobal('fetch', fetchMock)
   })
 
   afterEach(() => {
     vi.unstubAllGlobals()
   })
 
-  it('⑥remoteAuth.userId ≠ data.cloudUserId → 抛错，零触库', async () => {
+  it('⑥remoteAuth.userId ≠ data.cloudUserId → 抛错，零触库零出网', async () => {
     sfMocks.remoteAuth = { userId: 'attacker-other' }
 
     await expect(
@@ -630,6 +803,7 @@ describe('transferOwnershipFn（serverFn 校验）', () => {
     const p = sfMocks.prisma as PrismaMock
     expect(p.story.updateMany).not.toHaveBeenCalled()
     expect(p.user.upsert).not.toHaveBeenCalled()
+    expect(fetchMock).not.toHaveBeenCalled()
   })
 
   it('无 remoteAuth（非 desktop / 未交换登录）→ 抛错', async () => {
@@ -641,13 +815,44 @@ describe('transferOwnershipFn（serverFn 校验）', () => {
     expect((sfMocks.prisma as PrismaMock).story.updateMany).not.toHaveBeenCalled()
   })
 
-  it('账号非空（account-status.empty=false）→ 抛错拒绝转移', async () => {
-    sfMocks.accountEmpty = false
+  it('I2 云端权威：账号非空（account-status.empty=false）→ 抛错拒绝转移', async () => {
+    stubSaasFetch({ accountStatus: { ok: true, body: { empty: false } } })
 
     await expect(
       transferFn({ data: { cloudUserId: CLOUD, name: CLOUD_NAME } }),
     ).rejects.toThrow(/空账号|非空/)
     expect((sfMocks.prisma as PrismaMock).story.updateMany).not.toHaveBeenCalled()
+    // 判定来自云端端点（带云会话 token cookie），不是本地库计数
+    const [url, init] = fetchMock.mock.calls[0] as [string, { headers: { Cookie: string } }]
+    expect(url).toContain('/api/sync/account-status')
+    expect(init.headers.Cookie).toBe('auth.session-token=tok-123')
+  })
+
+  it('I2 云端权威：探测不可达（网络异常 / 非 200 / 形状漂移）→ 拒绝转移', async () => {
+    stubSaasFetch({ accountStatus: { reject: true } })
+    await expect(
+      transferFn({ data: { cloudUserId: CLOUD, name: CLOUD_NAME } }),
+    ).rejects.toThrow(/不可达|状态/)
+    expect((sfMocks.prisma as PrismaMock).story.updateMany).not.toHaveBeenCalled()
+
+    stubSaasFetch({ accountStatus: { ok: false, status: 503 } })
+    await expect(
+      transferFn({ data: { cloudUserId: CLOUD, name: CLOUD_NAME } }),
+    ).rejects.toThrow(/不可达|状态/)
+
+    stubSaasFetch({ accountStatus: { ok: true, body: { empty: 'yes' } } })
+    await expect(
+      transferFn({ data: { cloudUserId: CLOUD, name: CLOUD_NAME } }),
+    ).rejects.toThrow(/不可达|状态/)
+  })
+
+  it('I2 幂等语义：转移后再次进入（本地已有数据）仍按云端判定放行', async () => {
+    // 本地 mock 的 updateMany 一律返回 count=1（等价「本地已有转移后数据」），
+    // 云端仍报告空账号 → 允许重复执行（转移本身幂等，UPDATE 匹配 0 行）
+    const result = (await transferFn({
+      data: { cloudUserId: CLOUD, name: CLOUD_NAME },
+    })) as { tables: number }
+    expect(result.tables).toBe(TEST_OWNERSHIP_COLUMNS.length)
   })
 
   it('正向：guest 会话 + remoteAuth 匹配 + 空账号 → 以 GUEST→cloudUserId 转移并回传结果', async () => {
@@ -682,7 +887,6 @@ describe('reverseTransferOwnershipFn（A9 serverFn 校验）', () => {
   beforeEach(() => {
     sfMocks.session = { user: { id: CLOUD } }
     sfMocks.remoteAuth = { userId: CLOUD, sessionToken: 'tok-123' }
-    sfMocks.accountEmpty = true
     sfMocks.prisma = makePrismaMock()
     setUpdateCounts(sfMocks.prisma as PrismaMock, 1)
     sfMocks.clearRemoteAuth.mockClear()
@@ -770,10 +974,13 @@ describe('transferOwnershipFn 身份字段省略（A8b 自取 SaaS profile）',
   beforeEach(() => {
     sfMocks.session = { user: { id: GUEST } }
     sfMocks.remoteAuth = { userId: CLOUD, sessionToken: 'tok-123' }
-    sfMocks.accountEmpty = true
     sfMocks.prisma = makePrismaMock()
     setUpdateCounts(sfMocks.prisma as PrismaMock, 1)
     fetchMock.mockReset()
+    stubSaasFetch({
+      accountStatus: { ok: true, body: { empty: true } },
+      profile: { ok: true, body: SAAS_PROFILE },
+    })
     vi.stubGlobal('fetch', fetchMock)
   })
 
@@ -782,16 +989,17 @@ describe('transferOwnershipFn 身份字段省略（A8b 自取 SaaS profile）',
   })
 
   it('name 省略 → 以 remoteAuth.sessionToken 自取 profile，upsert 载荷携带自取资料', async () => {
-    fetchMock.mockResolvedValue({ ok: true, json: async () => SAAS_PROFILE })
-
     const result = (await transferFn({ data: { cloudUserId: CLOUD } })) as { rows: number }
     expect(result.rows).toBe(TEST_OWNERSHIP_COLUMNS.length)
 
     // 自取请求：SaaS exchange 端点 + 云会话 token cookie（照 exchange 先例）
-    expect(fetchMock).toHaveBeenCalledTimes(1)
-    const [url, init] = fetchMock.mock.calls[0] as [string, { headers: { Cookie: string } }]
-    expect(url).toContain('/api/auth/desktop-callback?exchange=true')
-    expect(init.headers.Cookie).toBe('auth.session-token=tok-123')
+    // I2 起首次请求是 account-status 探测（云端权威），profile 为第二次
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    const profileCall = (fetchMock.mock.calls as Array<[string, { headers: { Cookie: string } }]>).find(
+      ([url]) => url.includes('/api/auth/desktop-callback?exchange=true'),
+    )
+    expect(profileCall).toBeDefined()
+    expect(profileCall![1].headers.Cookie).toBe('auth.session-token=tok-123')
 
     // 云身份行 upsert：昵称/邮箱/头像来自 SaaS（缺 name 兜底 = cloudUserId）
     const arg = (sfMocks.prisma as PrismaMock).user.upsert.mock.calls[0][0] as {
@@ -807,11 +1015,13 @@ describe('transferOwnershipFn 身份字段省略（A8b 自取 SaaS profile）',
     })
   })
 
-  it('字段全传 → 用传入值，零 SaaS 出网（A8a 调用形态向后兼容）', async () => {
+  it('字段全传 → 用传入值，不请求 profile（A8a 调用形态向后兼容）', async () => {
     await transferFn({
       data: { cloudUserId: CLOUD, name: CLOUD_NAME, email: CLOUD_EMAIL, avatarConfig: CLOUD_AVATAR },
     })
-    expect(fetchMock).not.toHaveBeenCalled()
+    // I2 起必有 account-status 探测；但身份字段全传时不得再打 profile 端点
+    const urls = (fetchMock.mock.calls as Array<[string]>).map(([url]) => url)
+    expect(urls.some((u) => u.includes('/api/auth/desktop-callback'))).toBe(false)
     const arg = (sfMocks.prisma as PrismaMock).user.upsert.mock.calls[0][0] as {
       create: Record<string, unknown>
     }
@@ -823,7 +1033,10 @@ describe('transferOwnershipFn 身份字段省略（A8b 自取 SaaS profile）',
   })
 
   it('name 省略且 SaaS 资料获取失败 → 抛错走 bind:fail，零触库', async () => {
-    fetchMock.mockResolvedValue({ ok: false, status: 503 })
+    stubSaasFetch({
+      accountStatus: { ok: true, body: { empty: true } },
+      profile: { ok: false, status: 503 },
+    })
 
     await expect(transferFn({ data: { cloudUserId: CLOUD } })).rejects.toThrow(/SaaS/)
     const p = sfMocks.prisma as PrismaMock
@@ -833,7 +1046,7 @@ describe('transferOwnershipFn 身份字段省略（A8b 自取 SaaS profile）',
 
   it('name 省略且无 sessionToken → 抛错，零出网零触库', async () => {
     sfMocks.remoteAuth = { userId: CLOUD }
-    await expect(transferFn({ data: { cloudUserId: CLOUD } })).rejects.toThrow(/token/)
+    await expect(transferFn({ data: { cloudUserId: CLOUD } })).rejects.toThrow(/token|状态|不可达/)
     expect(fetchMock).not.toHaveBeenCalled()
     expect((sfMocks.prisma as PrismaMock).story.updateMany).not.toHaveBeenCalled()
   })