@@ -140,6 +140,7 @@ function forkParams(selection?: {
 describe('createFork storage headroom gate', () => {
   beforeEach(() => {
     resetDbChainMock()
+    dbChainMockFns.as.mockReturnValue(workspace)
     queueTableRows(workspace, [{ projectId: 'project-source' }])
     queueTableRows(workspace, [
       { project: { id: 'project-source', organizationId: null, archivedAt: null } },
@@ -215,6 +216,7 @@ describe('createFork storage headroom gate', () => {
 
   it('refuses when the parent changed organizations after the policy was captured', async () => {
     resetDbChainMock()
+    dbChainMockFns.as.mockReturnValue(workspace)
     queueTableRows(workspace, [{ projectId: 'project-source' }])
     queueTableRows(workspace, [
       { project: { id: 'project-source', organizationId: null, archivedAt: null } },
@@ -243,6 +245,7 @@ describe('createFork storage headroom gate', () => {
    */
   it('gives the child the source workspace personal API-key and fork-sync policies', async () => {
     resetDbChainMock()
+    dbChainMockFns.as.mockReturnValue(workspace)
     queueTableRows(workspace, [{ projectId: 'project-source' }])
     queueTableRows(workspace, [
       { project: { id: 'project-source', organizationId: null, archivedAt: null } },
 
@@ -218,6 +218,9 @@ describe('workspace payer-change transaction lock ordering', () => {
         orderBy() {
           return chain
         },
+        as() {
+          return table
+        },
         for() {
           ops.push({ op: 'lock', table })
           return chain
 
@@ -3,19 +3,28 @@ import { member, permissions, project, workspace } from '@sim/db/schema'
 import { ORG_ADMIN_ROLES } from '@sim/platform-authz/workspace'
 import { and, asc, eq, inArray, ne, or, sql } from 'drizzle-orm'
 import type { DbOrTx, DbTransaction } from '@/lib/db/types'
+import {
+  deleteObsoleteProjectMemberships,
+  getProjectEnvironmentSource,
+} from '@/lib/projects/environment-source'
 import {
   lockProjectBackfillWrites,
   lockProjects,
   ProjectConflictError,
 } from '@/lib/projects/membership'
 
 /** Two indexed lookups; an `OR` around a membership subquery would scan every Project. */
-async function loadRelatedProjects(executor: DbOrTx, userId: string, doomedWorkspaceIds: string[]) {
+async function loadRelatedProjects(
+  executor: DbTransaction,
+  userId: string,
+  doomedWorkspaceIds: string[]
+) {
+  const environments = await getProjectEnvironmentSource(executor)
   const doomedMemberships = doomedWorkspaceIds.length
     ? await executor
-        .select({ projectId: workspace.projectId })
-        .from(workspace)
-        .where(inArray(workspace.id, doomedWorkspaceIds))
+        .select({ projectId: environments.projectId })
+        .from(environments)
+        .where(inArray(environments.id, doomedWorkspaceIds))
     : []
   const projectIds = doomedMemberships.flatMap((row) => (row.projectId ? [row.projectId] : []))
   return executor
@@ -100,16 +109,17 @@ interface ProjectEnvironment {
 }
 
 /** Every environment of `projectIds`, in one query, keyed by Project. */
-async function loadProjectEnvironments(executor: DbOrTx, projectIds: string[]) {
+async function loadProjectEnvironments(executor: DbTransaction, projectIds: string[]) {
+  const environments = await getProjectEnvironmentSource(executor)
   const rows = projectIds.length
     ? await executor
         .select({
-          projectId: workspace.projectId,
-          id: workspace.id,
-          archivedAt: workspace.archivedAt,
+          projectId: environments.projectId,
+          id: environments.id,
+          archivedAt: environments.archivedAt,
         })
-        .from(workspace)
-        .where(inArray(workspace.projectId, projectIds))
+        .from(environments)
+        .where(inArray(environments.projectId, projectIds))
     : []
   const byProject = new Map<string, ProjectEnvironment[]>()
   for (const { projectId, ...environment } of rows) {
@@ -157,25 +167,27 @@ export async function getProjectAccountDeletionBlockers(
   userId: string,
   doomedWorkspaceIds: string[]
 ): Promise<string[]> {
-  const records = await loadRelatedProjects(db, userId, doomedWorkspaceIds)
-  const environments = await loadProjectEnvironments(
-    db,
-    records.map((record) => record.id)
-  )
-  const doomed = new Set(doomedWorkspaceIds)
-  const blockers: string[] = []
-  for (const record of records) {
-    const decision = await planProjectDeletion(
-      db,
-      record,
-      environments.get(record.id) ?? [],
-      userId,
-      doomed,
-      false
+  return db.transaction(async (tx) => {
+    const records = await loadRelatedProjects(tx, userId, doomedWorkspaceIds)
+    const environments = await loadProjectEnvironments(
+      tx,
+      records.map((record) => record.id)
     )
-    if ('blocker' in decision) blockers.push(decision.blocker)
-  }
-  return blockers
+    const doomed = new Set(doomedWorkspaceIds)
+    const blockers: string[] = []
+    for (const record of records) {
+      const decision = await planProjectDeletion(
+        tx,
+        record,
+        environments.get(record.id) ?? [],
+        userId,
+        doomed,
+        false
+      )
+      if ('blocker' in decision) blockers.push(decision.blocker)
+    }
+    return blockers
+  })
 }
 
 /** Transfers surviving Projects and returns private Projects to delete after their workspaces. */
@@ -235,5 +247,6 @@ export async function prepareProjectsForAccountDeletion(
       })
       .where(eq(project.id, record.id))
   }
+  await deleteObsoleteProjectMemberships(tx, projectsToDelete)
   return projectsToDelete
 }
@@ -1,5 +1,5 @@
 import type { Principal, SessionPrincipal } from '@sim/auth/principal'
-import { member, permissionGroup, permissions, project, workspace } from '@sim/db/schema'
+import { member, permissionGroup, permissions, project } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { isOrgAdminRole } from '@sim/platform-authz/workspace'
 import { and, asc, eq, inArray, sql } from 'drizzle-orm'
@@ -11,6 +11,7 @@ import { CAPABILITY_RULES, refuseCapability } from '@/lib/permission-groups/capa
 import { acquirePermissionGroupOrgLock } from '@/lib/permission-groups/locks'
 import { resolveVerifiedUserAccessControlContext } from '@/lib/permission-groups/resolve.server'
 import { type ProjectOperation, projectOperations } from '@/lib/projects/application/operations'
+import { getProjectEnvironmentSource } from '@/lib/projects/environment-source'
 import { lockProject } from '@/lib/projects/membership'
 
 const logger = createLogger('ProjectAuthorization')
@@ -67,23 +68,24 @@ async function loadProjectAccess(
   const [membership] = records.some((record) => record.organizationId)
     ? await (lock ? memberQuery.for('share') : memberQuery)
     : []
+  const source = await getProjectEnvironmentSource(tx)
   const environments = await tx
     .select({
-      projectId: workspace.projectId,
-      id: workspace.id,
-      name: workspace.name,
-      organizationId: workspace.organizationId,
-      archivedAt: workspace.archivedAt,
-      parentId: workspace.forkedFromWorkspaceId,
+      projectId: source.projectId,
+      id: source.id,
+      name: source.name,
+      organizationId: source.organizationId,
+      archivedAt: source.archivedAt,
+      parentId: source.parentId,
     })
-    .from(workspace)
+    .from(source)
     .where(
       inArray(
-        workspace.projectId,
+        source.projectId,
         records.map((record) => record.id)
       )
     )
-    .orderBy(asc(workspace.id))
+    .orderBy(asc(source.id))
   const grantQuery = tx
     .select({ id: permissions.entityId, permission: permissions.permissionType })
     .from(permissions)
 
@@ -14,6 +14,7 @@ import {
   requireProjectPrincipal,
 } from '@/lib/projects/application/authorization'
 import { projectOperations } from '@/lib/projects/application/operations'
+import { getProjectEnvironmentSource } from '@/lib/projects/environment-source'
 import { archiveProjectInTransaction, finishProjectArchive } from '@/lib/projects/lifecycle'
 import { requireProjectApiEnabled } from '@/lib/projects/rollout.server'
 
@@ -85,6 +86,7 @@ export const listProjects: OperationUseCase<
     requireProjectPrincipal(principal, projectOperations.list)
     await requireProjectApiEnabled()
     return db.transaction(async (tx) => {
+      const environments = await getProjectEnvironmentSource(tx)
       /** Driven from the caller's grants and admin organization, so cost tracks their reach. */
       const candidates = await tx.execute<{ id: string }>(sql`
         WITH accessible AS (
@@ -96,15 +98,15 @@ export const listProjects: OperationUseCase<
           JOIN ${workspace} ON ${workspace.organizationId} = ${member.organizationId}
           WHERE ${member.userId} = ${principal.userId} AND ${inArray(member.role, ORG_ADMIN_ROLES)}
         )
-        SELECT DISTINCT ${workspace.projectId} AS id
+        SELECT DISTINCT ${environments.projectId} AS id
         FROM accessible
-        JOIN ${workspace}
-          ON ${workspace.id} = accessible.workspace_id AND ${workspace.archivedAt} IS NULL
+        JOIN ${environments}
+          ON ${environments.id} = accessible.workspace_id AND ${environments.archivedAt} IS NULL
         JOIN ${project}
-          ON ${project.id} = ${workspace.projectId} AND ${project.archivedAt} IS NULL
+          ON ${project.id} = ${environments.projectId} AND ${project.archivedAt} IS NULL
         WHERE TRUE
           ${input.organizationId ? sql`AND ${project.organizationId} = ${input.organizationId}` : sql``}
-          ${input.cursor ? sql`AND ${workspace.projectId} > ${input.cursor}` : sql``}
+          ${input.cursor ? sql`AND ${environments.projectId} > ${input.cursor}` : sql``}
         ORDER BY 1
         LIMIT ${input.limit + 1}
       `)
@@ -210,10 +212,11 @@ export const getWorkspaceProject: OperationUseCase<
     requireProjectPrincipal(principal, projectOperations.get)
     await requireProjectApiEnabled()
     return db.transaction(async (tx) => {
+      const environments = await getProjectEnvironmentSource(tx)
       const [membership] = await tx
-        .select({ projectId: workspace.projectId })
-        .from(workspace)
-        .where(eq(workspace.id, input.workspaceId))
+        .select({ projectId: environments.projectId })
+        .from(environments)
+        .where(eq(environments.id, input.workspaceId))
         .limit(1)
       if (!membership?.projectId) throw new OrchestrationError('not_found', 'Project not found')
       return {
 
@@ -0,0 +1,77 @@
+import { projectWorkspace, workspace } from '@sim/db/schema'
+import { and, eq, exists, inArray, isNotNull, isNull, ne, sql } from 'drizzle-orm'
+import type { SubqueryWithSelection } from 'drizzle-orm/pg-core'
+import type { DbTransaction } from '@/lib/db/types'
+
+const fields = {
+  id: workspace.id,
+  projectId: workspace.projectId,
+  name: workspace.name,
+  ownerId: workspace.ownerId,
+  organizationId: workspace.organizationId,
+  archivedAt: workspace.archivedAt,
+  parentId: workspace.forkedFromWorkspaceId,
+}
+
+/**
+ * Columns win over legacy assignments. The workspace table lock protects the catalog
+ * check and fallback read from connector retirement until the caller commits. It is
+ * compatible with ordinary writes; retirement locks workspace and both FK-related
+ * tables up front with NOWAIT before dropping the connector.
+ */
+async function hasLegacyMemberships(tx: DbTransaction): Promise<boolean> {
+  await tx.execute(sql`LOCK TABLE ${workspace} IN ACCESS SHARE MODE`)
+  const [legacy] = await tx.execute<{ present: boolean }>(
+    sql`SELECT to_regclass('public.project_workspace') IS NOT NULL AS present`
+  )
+  return legacy?.present ?? false
+}
+
+/** Every workspace appears once; a populated column supersedes its legacy assignment. */
+export async function getProjectEnvironmentSource(
+  tx: DbTransaction
+): Promise<SubqueryWithSelection<typeof fields, 'project_environments'>> {
+  if (!(await hasLegacyMemberships(tx)))
+    return tx.select(fields).from(workspace).as('project_environments')
+  return tx
+    .select(fields)
+    .from(workspace)
+    .where(isNotNull(workspace.projectId))
+    .unionAll(
+      tx
+        .select({ ...fields, projectId: projectWorkspace.projectId })
+        .from(workspace)
+        .leftJoin(projectWorkspace, eq(projectWorkspace.workspaceId, workspace.id))
+        .where(isNull(workspace.projectId))
+    )
+    .as('project_environments')
+}
+
+/**
+ * A detached environment can still have a legacy reference to a Project being deleted.
+ * Remove only references superseded by a different non-null column, under the caller's
+ * Project locks and deletion transaction. Current memberships remain protected by the FK.
+ */
+export async function deleteObsoleteProjectMemberships(
+  tx: DbTransaction,
+  projectIds: string[]
+): Promise<void> {
+  if (!projectIds.length || !(await hasLegacyMemberships(tx))) return
+  await tx.delete(projectWorkspace).where(
+    and(
+      inArray(projectWorkspace.projectId, projectIds),
+      exists(
+        tx
+          .select({ id: workspace.id })
+          .from(workspace)
+          .where(
+            and(
+              eq(workspace.id, projectWorkspace.workspaceId),
+              isNotNull(workspace.projectId),
+              ne(workspace.projectId, projectWorkspace.projectId)
+            )
+          )
+      )
+    )
+  )
+}
@@ -1,7 +1,8 @@
 import { project, workspace } from '@sim/db/schema'
-import { asc, eq } from 'drizzle-orm'
+import { asc, eq, sql } from 'drizzle-orm'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import type { DbTransaction } from '@/lib/db/types'
+import { getProjectEnvironmentSource } from '@/lib/projects/environment-source'
 import { lockProject } from '@/lib/projects/membership'
 import {
   archiveEnvironmentInTransaction,
@@ -18,10 +19,13 @@ export async function archiveProjectInTransaction(
   const [record] = await tx.select().from(project).where(eq(project.id, projectId))
   if (!record) throw new OrchestrationError('not_found', 'Project not found')
   const now = record.archivedAt ?? new Date()
+  const source = await getProjectEnvironmentSource(tx)
   const environments = await tx
     .select({ id: workspace.id })
     .from(workspace)
-    .where(eq(workspace.projectId, projectId))
+    .where(
+      sql`${workspace.id} IN (SELECT ${source.id} FROM ${source} WHERE ${source.projectId} = ${projectId})`
+    )
     .orderBy(asc(workspace.id))
     .for('no key update')
   const effects: EnvironmentArchiveEffects[] = []