@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/ai-task/executor.ts

@@ -0,0 +1,296 @@
+// AI 任务执行体（规格 §5.3）：无人值守执行单次 AiTaskRun。
+// 普通服务端模块（非 serverFn 文件），由任务触发的 serverFn 调度。
+//
+// 安全边界：工具白名单 AI_TASK_ALLOWED_TOOLS 恰为三个只读工具。
+// 绝对禁止加入 plan_submit 或任何写型工具——plan_submit 会激活审批中断
+// （planApprovalInterrupt 硬编码在 chat-stream-builder），无人值守执行会永久卡死。
+
+import { prisma } from '@allbluecn/database'
+import { runChat } from '@/server/ai-gateway/adapter'
+import { createNotification } from '@/server/notifications/notification-service'
+import { buildSourceContextBlock } from './context-builder'
+import type { TaskSource } from './types'
+
+/** 无人值守执行的工具白名单（规格 §5.3）：恰三个只读工具 */
+export const AI_TASK_ALLOWED_TOOLS = [
+  'knowledge_search',
+  'user_data_query',
+  'web_search',
+] as const
+
+/** 默认超时 55s：Vercel serverless 函数上限内留出落库/通知余量 */
+const DEFAULT_TIMEOUT_MS = 55_000
+/** 通知 body：结果/错误首行截断长度 */
+const NOTICE_BODY_LIMIT = 100
+/** run.error 截断长度：防异常超大堆栈撑爆写入 */
+const ERROR_LIMIT = 500
+
+/** run 的终态集合（schema 注释口径：running|completed|failed|timeout|canceled） */
+const TERMINAL_RUN_STATUSES = new Set(['completed', 'failed', 'timeout', 'canceled'])
+
+/**
+ * 超时专用哨兵：看门狗 reject 此实例，catch 处以 instanceof 判定 timeout 终态。
+ * 不用 message 子串判定（如 includes('超时')）——上游/网关自身的超时文案会被误判
+ * 成 run timeout；message 保留中文描述供落库展示。
+ */
+class TaskTimeoutError extends Error {
+  constructor(timeoutMs: number) {
+    super(`AI 任务执行超时（${timeoutMs}ms 内未返回）`)
+    this.name = 'TaskTimeoutError'
+  }
+}
+
+type TaskInput = {
+  id: string
+  title: string
+  instruction: string
+  sourceType: string | null
+  sourceId: string | null
+  projectId: string | null
+}
+
+export interface ExecuteAiTaskRunOptions {
+  task: TaskInput
+  runId: string
+  userId: string
+}
+
+type RunOutcome = {
+  status: 'completed' | 'failed' | 'timeout'
+  resultSummary: string | null
+  error: string | null
+}
+
+function truncateText(text: string, limit: number): string {
+  return text.length <= limit ? text : text.slice(0, limit) + '…[截断]'
+}
+
+/** 通知 body：硬截断（不带省略标记），精确 ≤ limit 字符 */
+function sliceText(text: string, limit: number): string {
+  return text.slice(0, limit)
+}
+
+/** 通知 body：取第一个非空行，截 100 字符 */
+function firstLineText(text: string): string {
+  const firstLine = text.split('\n').find((line) => line.trim().length > 0) ?? ''
+  return sliceText(firstLine.trim(), NOTICE_BODY_LIMIT)
+}
+
+/**
+ * 按 sourceType 查源表，select 按 context-builder 消费的字段收窄。
+ * 返回 null = 源条目已删除或 sourceType 非法（调用方降级为提示文本，不抛错）。
+ */
+async function lookupSource(
+  sourceType: string,
+  sourceId: string,
+): Promise<Record<string, unknown> | null> {
+  if (sourceType === 'story') {
+    return prisma.story.findUnique({
+      where: { id: sourceId },
+      select: {
+        identifier: true,
+        name: true,
+        description: true,
+        state: true,
+        priority: true,
+        targetDate: true,
+        project: { select: { name: true } },
+      },
+    })
+  }
+  if (sourceType === 'bug') {
+    return prisma.bug.findUnique({
+      where: { id: sourceId },
+      select: {
+        identifier: true,
+        title: true,
+        severity: true,
+        reproduceSteps: true,
+        stackSummary: true,
+        url: true,
+        env: true,
+        story: { select: { name: true } },
+      },
+    })
+  }
+  if (sourceType === 'testcase') {
+    return prisma.testCase.findUnique({
+      where: { id: sourceId },
+      select: {
+        identifier: true,
+        title: true,
+        precondition: true,
+        steps: true,
+        type: true,
+      },
+    })
+  }
+  return null
+}
+
+/** 系统提示词组装：基础指令 + 项目名（有 projectId 时）+ 源上下文（源型时） */
+async function buildSystemPrompts(task: TaskInput): Promise<string[]> {
+  const prompts = [
+    '你是 AllBlue 的 AI 任务执行助手，正在无人值守地执行任务，过程中无法与用户交互。',
+    '请独立完成任务指令：可使用提供的只读工具检索必要信息，完成后输出 markdown 格式的结果摘要。',
+    `任务标题：${task.title}`,
+  ]
+
+  if (task.projectId) {
+    const project = await prisma.project.findUnique({
+      where: { id: task.projectId },
+      select: { name: true },
+    })
+    if (project?.name) prompts.push(`所属项目：${project.name}`)
+  }
+
+  if (task.sourceType && task.sourceId) {
+    const row = await lookupSource(task.sourceType, task.sourceId)
+    if (row) {
+      // lookupSource 仅对三种合法 sourceType 返回非 null，此处断言安全
+      prompts.push(buildSourceContextBlock(task.sourceType as TaskSource, row))
+    } else {
+      prompts.push(
+        `## 源条目已删除\n\n发起本任务时关联的源条目（${task.sourceType}）已被删除，请仅依据任务指令执行。`,
+      )
+    }
+  }
+
+  return prompts
+}
+
+/** 执行指令：runChat + 超时竞速；任何异常归一化为 failed/timeout 终态结果，不抛出 */
+async function runInstruction(opts: ExecuteAiTaskRunOptions): Promise<RunOutcome> {
+  const { task, runId, userId } = opts
+  try {
+    const systemPrompts = await buildSystemPrompts(task)
+
+    // ⚠️ 每次执行时读取（不得模块顶层求值）：测试经 env 注入短超时才生效
+    const timeoutMs = Number(process.env.AI_TASK_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS
+
+    const result = await Promise.race([
+      runChat(
+        [{ role: 'user', content: task.instruction }],
+        {
+          systemPrompts,
+          userId,
+          parentRunId: runId,
+          allowedTools: [...AI_TASK_ALLOWED_TOOLS],
+        },
+      ),
+      new Promise<never>((_, reject) => {
+        const timer = setTimeout(() => reject(new TaskTimeoutError(timeoutMs)), timeoutMs)
+        timer.unref?.()
+      }),
+    ])
+    return { status: 'completed', resultSummary: result, error: null }
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e)
+    const isTimeout = e instanceof TaskTimeoutError
+    return {
+      status: isTimeout ? 'timeout' : 'failed',
+      resultSummary: null,
+      error: truncateText(message, ERROR_LIMIT),
+    }
+  }
+}
+
+/** 终态落库：run 落 completed/failed/timeout；task 投影落 completed/failed（timeout 投影为 failed） */
+async function persistOutcome(
+  opts: ExecuteAiTaskRunOptions,
+  outcome: RunOutcome,
+  startedAt: number,
+): Promise<void> {
+  await prisma.aiTaskRun.update({
+    where: { id: opts.runId },
+    data: {
+      status: outcome.status,
+      resultSummary: outcome.resultSummary,
+      error: outcome.error,
+      finishedAt: new Date(),
+      durationMs: Date.now() - startedAt,
+    },
+  })
+  await prisma.aiTask.update({
+    where: { id: opts.task.id },
+    data: {
+      status: outcome.status === 'timeout' ? 'failed' : outcome.status,
+      lastRunId: opts.runId,
+    },
+  })
+}
+
+/** 终态通知：body = 结果/错误首行截 100 字符；createNotification 自身吞错，此处再兜一层 */
+async function notifyFinished(opts: ExecuteAiTaskRunOptions, outcome: RunOutcome): Promise<void> {
+  await createNotification({
+    userId: opts.userId,
+    category: 'system',
+    type: 'ai_task_finished',
+    title: opts.task.title,
+    body: firstLineText(outcome.resultSummary ?? outcome.error ?? ''),
+    link: `/tasks/${opts.task.id}`,
+  })
+}
+
+/**
+ * finally 兜底：复查 run 与 task 状态，非终态则强制落 failed（防未知路径僵尸 running）。
+ * run 之外必须复查 task：persistOutcome 先 run 后 task 两次落库，run 成功而 task
+ * update 瞬时失败时 task 会永久 running（无法重跑/删除，详情页轮询不停）——此处
+ * 二次 update 自愈。task 侧非终态仅 running（backlog 是未占位的初始态，不得误伤）；
+ * task 表无 error 字段，落 status + lastRunId（与 persistOutcome 同款投影）。
+ */
+async function ensureTerminalRunState(
+  opts: ExecuteAiTaskRunOptions,
+  startedAt: number,
+): Promise<void> {
+  const run = await prisma.aiTaskRun.findUnique({
+    where: { id: opts.runId },
+    select: { status: true },
+  })
+  if (run && !TERMINAL_RUN_STATUSES.has(run.status)) {
+    console.warn(`[ai-task] run ${opts.runId} 兜底落 failed（原状态 ${run.status}）`)
+    await prisma.aiTaskRun.update({
+      where: { id: opts.runId },
+      data: {
+        status: 'failed',
+        error: '执行收尾异常，由兜底逻辑标记失败',
+        finishedAt: new Date(),
+        durationMs: Date.now() - startedAt,
+      },
+    })
+  }
+
+  const task = await prisma.aiTask.findUnique({
+    where: { id: opts.task.id },
+    select: { status: true },
+  })
+  if (task && task.status === 'running') {
+    console.warn(`[ai-task] task ${opts.task.id} 兜底落 failed（原状态 running）`)
+    await prisma.aiTask.update({
+      where: { id: opts.task.id },
+      data: { status: 'failed', lastRunId: opts.runId },
+    })
+  }
+}
+
+/**
+ * 执行一次 AI 任务 run：系统提示词组装 → 源上下文（源型时）→
+ * Promise.race(runChat, 超时) → 终态落库 + 通知。
+ *
+ * 全路径 try/catch/finally 落终态；本函数不抛出（终态/通知失败只记日志）。
+ */
+export async function executeAiTaskRun(opts: ExecuteAiTaskRunOptions): Promise<void> {
+  const startedAt = Date.now()
+  const outcome = await runInstruction(opts)
+
+  try {
+    try {
+      await persistOutcome(opts, outcome, startedAt)
+      await notifyFinished(opts, outcome)
+    } finally {
+      await ensureTerminalRunState(opts, startedAt)
+    }
+  } catch (e) {
+    console.error('[ai-task] 终态落库/收尾失败:', e instanceof Error ? e.message : e)
+  }
+}

package/src/server/ai-task/priority-map.ts

@@ -0,0 +1,37 @@
+import type { TaskSource, UnifiedPriority } from './types'
+
+const STORY_PRIORITY: Record<string, UnifiedPriority> = {
+  urgent: 'P0',
+  critical: 'P0',
+  high: 'P1',
+  medium: 'P2',
+  low: 'P3',
+}
+
+const BUG_SEVERITY_PRIORITY: Record<string, UnifiedPriority> = {
+  critical: 'P0',
+  high: 'P1',
+  medium: 'P2',
+  low: 'P3',
+}
+
+const TESTCASE_PRIORITY: Record<string, UnifiedPriority> = {
+  p0: 'P0',
+  p1: 'P1',
+  p2: 'P2',
+  p3: 'P3',
+}
+
+const PRIORITY_TABLES: Record<TaskSource, Record<string, UnifiedPriority>> = {
+  story: STORY_PRIORITY,
+  bug: BUG_SEVERITY_PRIORITY,
+  testcase: TESTCASE_PRIORITY,
+}
+
+export function mapToUnifiedPriority(
+  source: TaskSource,
+  raw: string | null | undefined,
+): UnifiedPriority {
+  if (!raw) return null
+  return PRIORITY_TABLES[source][raw] ?? null
+}

package/src/server/ai-task/types.ts

@@ -0,0 +1,15 @@
+export type TaskSource = "story" | "bug" | "testcase"
+export type UnifiedPriority = "P0" | "P1" | "P2" | "P3" | null
+export type AssignedItem = {
+  source: TaskSource
+  id: string
+  identifier: string   // Story.identifier / Bug.identifier / TestCase.identifier
+  title: string        // Story.name / Bug.title / TestCase.title
+  projectId: string
+  projectName: string
+  priority: UnifiedPriority
+  dueAt: string | null     // ISO string；仅 Story.targetDate
+  href: string             // `/stories/${id}` | `/bugs/${id}` | `/test-cases/${id}`
+  updatedAt: string        // ISO string
+}
+export type AssignedResult = { items: AssignedItem[]; degraded: TaskSource[] }

package/src/server/bug-report/__tests__/report-handler.test.ts

@@ -43,6 +43,8 @@ const mocks = vi.hoisted(() => ({
   prismaBlobCreate: vi.fn(),
   prismaBlobDelete: vi.fn(),
   prismaProjectFindUnique: vi.fn(),
+  collabDocumentFindUnique: vi.fn(),
+  collabDocumentUpdateMany: vi.fn(),
   fireBugWebhook: vi.fn(),
 }));
 
@@ -50,7 +52,7 @@ vi.mock("@allbluecn/database", () => {
   const tx = {
     project: { findUnique: mocks.txProjectFindUnique },
     sequenceCounter: { upsert: mocks.txSequenceCounterUpsert },
-    bug: { create: mocks.txBugCreate },
+    bug: { create: mocks.txBugCreate, update: mocks.bugUpdate },
     bugEvent: { create: mocks.txBugEventCreate },
     bugActivity: { create: mocks.txBugActivityCreate },
     projectActivity: { create: mocks.txProjectActivityCreate },
@@ -58,6 +60,8 @@ vi.mock("@allbluecn/database", () => {
       count: mocks.txBugFixRunCount,
       create: mocks.txBugFixRunCreate,
     },
+    // R11 touch：dedupeExistingBug 指标写 + 快照 touch 同事务
+    collabDocument: { updateMany: mocks.collabDocumentUpdateMany },
   };
   const prisma = {
     projectAccessToken: {
@@ -75,6 +79,14 @@ vi.mock("@allbluecn/database", () => {
   return { prisma, Prisma: {} };
 });
 
+// 任务 23：重开路径接协同门卫（无 Y 属主外的快照查询走 getPrisma）——
+// 缺省无快照（pass-through 照旧直写，保持本文件既有断言零变化）
+vi.mock("@allbluecn/database/get-prisma", () => ({
+  getPrisma: async () => ({
+    collabDocument: { findUnique: mocks.collabDocumentFindUnique },
+  }),
+}));
+
 vi.mock("@/server/lib/rate-limit", () => ({
   checkRateLimit: mocks.checkRateLimit,
 }));
@@ -140,12 +152,15 @@ beforeEach(() => {
   mocks.tokenUpdate.mockResolvedValue(TOKEN_ROW);
   mocks.settingsUpsert.mockResolvedValue(SETTINGS_ROW);
   mocks.bugFindUnique.mockResolvedValue(null); // 新指纹默认查空
-  mocks.bugUpdate.mockResolvedValue(CREATED_BUG);
+  mocks.collabDocumentFindUnique.mockResolvedValue(null); // 任务 23：无快照（门卫 pass-through）
+  mocks.collabDocumentUpdateMany.mockResolvedValue({ count: 0 });
+  // R11 touch 读回读行 updatedAt
+  mocks.bugUpdate.mockResolvedValue({ ...CREATED_BUG, updatedAt: new Date("2026-01-01T00:00:00Z") });
   mocks.$transaction.mockImplementation(async (fn: (tx: unknown) => unknown) =>
     fn({
       project: { findUnique: mocks.txProjectFindUnique },
       sequenceCounter: { upsert: mocks.txSequenceCounterUpsert },
-      bug: { create: mocks.txBugCreate },
+      bug: { create: mocks.txBugCreate, update: mocks.bugUpdate },
       bugEvent: { create: mocks.txBugEventCreate },
       bugActivity: { create: mocks.txBugActivityCreate },
       projectActivity: { create: mocks.txProjectActivityCreate },
@@ -153,6 +168,7 @@ beforeEach(() => {
         count: mocks.txBugFixRunCount,
         create: mocks.txBugFixRunCreate,
       },
+      collabDocument: { updateMany: mocks.collabDocumentUpdateMany },
     }),
   );
   mocks.txProjectFindUnique.mockResolvedValue(PROJECT_ROW);
@@ -425,6 +441,41 @@ describe("已有指纹去重（§8.3 存在分支）", () => {
     expect(mocks.prismaBugActivityCreate).not.toHaveBeenCalled();
   });
 
+  // R11 touch 不变式（审查 Important 1）：totalCount/lastOccurAt 指标 bump
+  // 每事件必抬 updatedAt 且不含 Y 属主面 → 同事务 touch 快照，防有上报的
+  // BUG 几乎每次协同打开都误判旁路写 → 全量重种子化（Y 协作历史重置）
+
+  it("R11：纯指标 bump → 同事务 touch 快照（updatedAt = 回读行值）", async () => {
+    const TOUCH_AT = new Date("2026-06-06T00:00:00Z");
+    mocks.bugUpdate.mockResolvedValue({ updatedAt: TOUCH_AT });
+    mocks.bugFindUnique.mockResolvedValue(existingBug());
+
+    await postWithKey(validPayload());
+
+    expect(mocks.collabDocumentUpdateMany).toHaveBeenCalledWith({
+      where: { roomName: "entity:bug:bug2" },
+      data: { updatedAt: TOUCH_AT },
+    });
+  });
+
+  it("R11：降级重开直写 state（Y 属主面）→ 不 touch（业务列反超快照让重种子化兜底）", async () => {
+    vi.stubEnv("COLLAB_INTERNAL_URL", ""); // 门卫 degraded no-url → state 直写
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mocks.bugFindUnique.mockResolvedValue(existingBug({ state: "fixed" }));
+
+    try {
+      await postWithKey(validPayload());
+      expect(mocks.bugUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({ data: expect.objectContaining({ state: "open" }) }),
+      );
+      expect(mocks.collabDocumentUpdateMany).not.toHaveBeenCalled();
+    } finally {
+      vi.unstubAllEnvs();
+      warn.mockRestore();
+    }
+  });
+
   it("距上次上报超 5 分钟 → 采样新增 BugEvent", async () => {
     mocks.bugFindUnique.mockResolvedValue(
       existingBug({ lastOccurAt: new Date(Date.now() - 6 * 60_000) }),
@@ -451,7 +502,7 @@ describe("重开联动（§8.3 存在分支）", () => {
         data: expect.objectContaining({ state: "open" }),
       }),
     );
-    // 重开活动必须落库（actorType=sdk，更新分支不走事务）
+    // 重开活动必须落库（actorType=sdk；指标写+touch 同事务，活动留在事务外）
     expect(mocks.prismaBugActivityCreate).toHaveBeenCalledWith({
       data: {
         bugId: "bug2",

package/src/server/bug-report/report-handler.ts

@@ -22,6 +22,10 @@
 import { prisma } from "@allbluecn/database";
 import type { Prisma } from "@allbluecn/database";
 import { z } from "zod";
+import { buildMachineActor } from "@allbluecn/collab-core/actors";
+import { buildRoomName } from "@allbluecn/collab-core/rooms";
+import { withCollabGuard, COLLAB_GUARD_TTL_MS } from "@/server/collab/write-guard";
+import { touchCollabSnapshot } from "@/server/collab/touch-snapshot";
 import { computeFingerprint } from "./fingerprint";
 import { resolveSeverity } from "./severity-rules";
 import { hashToken, isValidTokenFormat } from "./tokens";
@@ -503,16 +507,58 @@ async function dedupeExistingBug(
     (bug.state === "fixed" || bug.state === "closed") &&
     ctx.settings.reopenOnDuplicate;
 
-  await prisma.bug.update({
-    where: { id: bug.id },
-    data: {
-      totalCount: { increment: 1 }, // 原子自增，并发安全
-      lastOccurAt: now,
-      ...(shouldReopen ? { state: "open" } : {}),
-    },
+  // ── Yjs 多人协作 §5.3 机器写入门卫（任务 23）：重开是 SDK 的 Y 属主面
+  // （state 字段协同 room 在管）。快照存在 → 一律转发 collab 内部通道
+  // （在线应用 Y 广播 / 离线 collab 直落业务列），**SDK 上报是不可丢链路**
+  // ——TTL 3s（规格 §5.3.2）内排队重试，超时降级直写（不 throw 吞上报）。
+  // 纯指标更新（无重开）无 Y 属主面，不查快照省一次查询。机器身份
+  // actor=`sdk:<source>`：经 collab 落活动时 actorType=sdk 保留（非 collab）。
+  // 无 assertWriteAllowed：token → 项目 → 指纹定位 BUG 即信任链（token 是
+  // 唯一信任锚，同建单路径）；降级/pass-through 直写也走同一定位。
+  let reopenForwarded = false;
+  if (shouldReopen) {
+    const guard = await withCollabGuard({
+      roomName: buildRoomName({ kind: "entity-bug", bugId: bug.id }),
+      docId: bug.id,
+      actor: buildMachineActor("sdk", "bug-report"),
+      patch: {
+        fields: { state: "open" },
+        // reopened_by_sdk 语义随行（forwarded 时 collab 侧活动行携带；web 不再补写）
+        activity: { action: "reopened_by_sdk", field: "state", oldValue: bug.state, newValue: "open" },
+      },
+      ttlMs: COLLAB_GUARD_TTL_MS,
+    });
+    reopenForwarded = guard.kind === "forwarded";
+  }
+
+  // R11 touch 不变式：totalCount/lastOccurAt 指标 bump 每事件必抬 @updatedAt
+  // ——不含 Y 属主面（指标列不入协同 room）时必须同事务 touch 快照，否则
+  // 有上报的 BUG 几乎每次协同打开都误判旁路写 → 全量重种子化（Y 协作历史
+  // 重置）。仅「降级直写 state（Y 属主面）」保持旁路语义不 touch——业务列
+  // 必须反超快照，重种子化兜底才有正确输入。
+  const writesYFace = shouldReopen && !reopenForwarded;
+  await prisma.$transaction(async (tx) => {
+    const updated = await tx.bug.update({
+      where: { id: bug.id },
+      data: {
+        totalCount: { increment: 1 }, // 原子自增，并发安全
+        lastOccurAt: now,
+        // forwarded 时 state 由 collab 接管（Y 是权威），直写即双写互吞
+        ...(writesYFace ? { state: "open" } : {}),
+      },
+    });
+    if (!writesYFace) {
+      await touchCollabSnapshot(
+        tx,
+        buildRoomName({ kind: "entity-bug", bugId: bug.id }),
+        updated.updatedAt,
+      );
+    }
   });
 
-  if (shouldReopen) {
+  if (shouldReopen && !reopenForwarded) {
+    // forwarded 时活动由 collab 侧 writeBugColumns 产出（actorType=sdk），
+    // web 再写即重复流水
     await prisma.bugActivity.create({
       data: {
         bugId: bug.id,

package/src/server/builtin-project.ts

@@ -76,6 +76,30 @@ export async function resolveStoryScopeProjectId(
   return ensureBuiltinIndependentProject(userId)
 }
 
+/**
+ * 解析列表/分组查询的项目范围（「全部项目」聚合语义）：
+ * - projectId 为空 → 当前用户全部可访问项目（有效成员，suspended 视同无权限）
+ * - projectId 非空 → 单元素数组（经 resolveStoryScopeProjectId 鉴权，无效静默回退独立项目）
+ * - 无任何可访问项目 → 回退独立项目
+ *
+ * 与 resolveStoryScopeProjectId 的区别：后者供详情/写入等需要「单一项目」的场景；
+ * 「全部项目」列表的越权防护由本函数承担（只返回成员关系内的项目 id）。
+ */
+export async function resolveStoryScopeProjectIds(
+  projectId: string | undefined,
+  userId: string,
+): Promise<string[]> {
+  if (projectId) {
+    return [await resolveStoryScopeProjectId(projectId, userId)]
+  }
+  const memberships = await prisma.projectMember.findMany({
+    where: { userId, status: { not: "suspended" } },
+    select: { projectId: true },
+  })
+  const ids = memberships.map((m) => m.projectId)
+  return ids.length > 0 ? ids : [await ensureBuiltinIndependentProject(userId)]
+}
+
 // 将一批需求迁移到用户的「独立需求」内置项目，重新分配 sequenceId/identifier；
 // identifier 唯一冲突（P2002）时整批重试（与 sequenceCounter 自增的并发竞争对应）
 export async function migrateStoriesToIndependentProject(

package/src/server/cloudflare/prisma-wasm-base64-stub.ts

@@ -0,0 +1,5 @@
+// prisma wasm-base64 双模块（postgresql/sqlite）的 CF 构建替身：
+// workerd 分支（Cloudflare-Workers 守卫）永不可达，但静态可达会把 ~9.4MB
+// base64 打进 worker 包（整分支审查发现 1，约 3.3MB gzip）。CF 目标经
+// vite alias 指向本 stub；Node/Vercel/desktop 构建不受影响（原模块照常）。
+export const wasm = "";