@@ -52,6 +52,7 @@ import {
 } from '@/app/workspace/[workspaceId]/tables/[tableId]/view-state'
 import { ImportCsvDialog } from '@/app/workspace/[workspaceId]/tables/components/import-csv-dialog'
 import { ImportProgressMenu } from '@/app/workspace/[workspaceId]/tables/components/import-progress-menu'
+import { useWorkspaceTablesRoom } from '@/app/workspace/[workspaceId]/tables/hooks/use-workspace-tables-room'
 import { useLogByExecutionId } from '@/hooks/queries/logs'
 import {
   downloadExportResult,
@@ -204,6 +205,7 @@ export function Table({
   const tableId = propTableId || (params.tableId as string)
   const hostContext = useOptionalWorkspaceHostContext()
   const referenceColumnsEnabled = hostContext?.features?.referenceColumns ?? false
+  useWorkspaceTablesRoom(workspaceId)
 
   const posthog = usePostHog()
   const tableRowTtlEnabled = useFeatureFlag('table-row-ttl')
 
@@ -251,6 +251,8 @@ export async function bulkDeleteFolders(params: {
   userId: string
   folders: readonly BulkFolderAffected[]
   countKey: 'tables' | 'knowledgeBases'
+  /** Reuse a reference scan completed for this batch while retaining each folder's lock guard. */
+  referenceCheckCompleted?: boolean
 }): Promise<BulkFolderDeleteOutcome> {
   const succeeded: BulkFolderAffected[] = []
   const failed: BulkFolderFailure[] = []
@@ -267,7 +269,11 @@ export async function bulkDeleteFolders(params: {
           userId: params.userId,
           folderName: folder.name,
         },
-        { projectAudit: false, notify: false }
+        {
+          projectAudit: false,
+          notify: false,
+          referenceCheckCompleted: params.referenceCheckCompleted,
+        }
       )
       if (result.success) {
         succeeded.push(folder)
 
@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import {
+  dbChainMockFns,
   flattenMockConditions,
   hasMockCondition,
   queueTableRows,
@@ -586,6 +587,31 @@ describe('knowledge_base and table folder resources', () => {
       }
     )
   })
+
+  it('preserves a concurrent table lock as a locked folder failure', async () => {
+    resetDbChainMock()
+    queueTableRows(schemaMock.userTableDefinitions, [{ id: 'tbl_accounts' }])
+    tableServiceMocks.deleteTables.mockResolvedValueOnce({
+      archived: [],
+      failed: [
+        {
+          id: 'tbl_accounts',
+          name: 'Accounts',
+          reason: 'Table deletion is locked',
+          code: 'locked',
+        },
+      ],
+      notFound: [],
+    })
+
+    await expect(
+      tableConfig.archiveChildren?.({
+        workspaceId: 'ws-1',
+        folderIds: ['folder-1'],
+        timestamp: TIMESTAMP,
+      })
+    ).rejects.toMatchObject({ code: 'locked', message: 'Table deletion is locked' })
+  })
 })
 
 describe('table folder deletion guard', () => {
@@ -631,4 +657,18 @@ describe('table folder deletion guard', () => {
       errorCode: 'conflict',
     })
   })
+
+  it('reuses a completed bulk reference check while still checking table locks', async () => {
+    queueTableRows(schemaMock.userTableDefinitions, [])
+
+    await expect(
+      FOLDER_RESOURCES.table.guardDelete?.({
+        workspaceId: 'ws-1',
+        folderIds: ['folder-root'],
+        referenceCheckCompleted: true,
+      })
+    ).resolves.toBeNull()
+
+    expect(dbChainMockFns.select).toHaveBeenCalledOnce()
+  })
 })
@@ -147,6 +147,8 @@ export interface FolderResourceConfig {
   guardDelete?: (context: {
     workspaceId: string
     folderIds: string[]
+    /** The caller already checked active references for this exact folder selection. */
+    referenceCheckCompleted?: boolean
   }) => Promise<FolderDeleteRejection | null>
 }
 
@@ -354,7 +356,10 @@ async function archiveTableChildren(context: CascadeChildrenContext): Promise<nu
   })
   if (result.terminalError) throw result.terminalError
   if (result.failed[0]) {
-    throw new OrchestrationError('conflict', result.failed[0].reason)
+    throw new OrchestrationError(
+      result.failed[0].code === 'locked' ? 'locked' : 'conflict',
+      result.failed[0].reason
+    )
   }
 
   return result.archived.length
@@ -393,9 +398,11 @@ async function restoreTableChildren(context: CascadeChildrenContext): Promise<nu
 async function guardTableDeletion({
   workspaceId,
   folderIds,
+  referenceCheckCompleted,
 }: {
   workspaceId: string
   folderIds: string[]
+  referenceCheckCompleted?: boolean
 }): Promise<FolderDeleteRejection | null> {
   const [
     { db },
@@ -427,6 +434,8 @@ async function guardTableDeletion({
     }
   }
 
+  if (referenceCheckCompleted) return null
+
   const [blocker] = await findActiveTableReferenceBlockers(db, workspaceId, {
     folderIds: new Set(folderIds),
   })
 
@@ -11,6 +11,7 @@ import {
   schemaMock,
 } from '@sim/testing'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { FolderCollectionFullError, FolderCollectionLimitExceededError } from '@/lib/folders/errors'
 import { folderMutationStatus } from '@/lib/folders/status'
 
@@ -770,6 +771,21 @@ describe('deleteFolder', () => {
     expect(mockArchiveFolderCascade).not.toHaveBeenCalled()
   })
 
+  it('returns a classified failure when a table lock appears after the guard', async () => {
+    queueTableRows(schemaMock.folder, [{ deletedAt: null }])
+    mockArchiveFolderCascade.mockRejectedValueOnce(
+      new OrchestrationError('locked', 'Table deletion is locked')
+    )
+
+    const result = await deleteFolder(baseDelete)
+
+    expect(result).toEqual({
+      success: false,
+      error: 'Table deletion is locked',
+      errorCode: 'locked',
+    })
+  })
+
   it('hands the guard the whole resolved subtree, not just the root', async () => {
     setConfig({ guardDelete: mockGuardDelete })
     mockGuardDelete.mockResolvedValueOnce(null)
@@ -784,6 +800,20 @@ describe('deleteFolder', () => {
     })
   })
 
+  it('passes a completed reference preflight through to the table guard', async () => {
+    setConfig({ guardDelete: mockGuardDelete })
+    mockGuardDelete.mockResolvedValueOnce(null)
+    queueTableRows(schemaMock.folder, [{ deletedAt: null }])
+
+    await deleteFolder(baseDelete, { referenceCheckCompleted: true })
+
+    expect(mockGuardDelete).toHaveBeenCalledWith({
+      workspaceId: 'ws-1',
+      folderIds: ['folder-1'],
+      referenceCheckCompleted: true,
+    })
+  })
+
   it('reuses an already-archived folder’s timestamp so a retry rejoins the same snapshot', async () => {
     // A fresh stamp would be unrecoverable: the folder row keeps its original deletedAt, so
     // anything archived under the new stamp would never match on restore.
 
@@ -792,8 +792,11 @@ export async function deleteFolder(
    *
    * `notify: false` for a caller deleting several folders in one gesture that
    * sends a single batch notification of its own — see {@link bulkDeleteFolders}.
+   * `referenceCheckCompleted: true` reuses that batch's reference scan; the
+   * table guard still checks deletion locks, and the table service rechecks
+   * references under its own transaction locks before archiving the cohort.
    */
-  options?: { projectAudit?: boolean; notify?: boolean }
+  options?: { projectAudit?: boolean; notify?: boolean; referenceCheckCompleted?: boolean }
 ): Promise<DeleteFolderResult> {
   const existing = await withFolderTreeLock(params.workspaceId, params.resourceType, async (tx) => {
     const [row] = await tx
@@ -817,13 +820,14 @@ export async function deleteFolder(
   return deleteFolderWithoutTreeLock(params, existing.deletedAt, {
     projectAudit: options?.projectAudit ?? true,
     notify: options?.notify ?? true,
+    referenceCheckCompleted: options?.referenceCheckCompleted,
   })
 }
 
 async function deleteFolderWithoutTreeLock(
   params: DeleteFolderParams,
   deletedAt: Date | null,
-  options: { projectAudit: boolean; notify: boolean }
+  options: { projectAudit: boolean; notify: boolean; referenceCheckCompleted?: boolean }
 ): Promise<DeleteFolderResult> {
   const { resourceType, folderId, workspaceId, userId, folderName, folderPath } = params
   const config = folderResourceConfig(resourceType)
@@ -844,12 +848,25 @@ async function deleteFolderWithoutTreeLock(
           params.maxFolderRows
         )
 
-  const rejection = await config.guardDelete?.({ workspaceId, folderIds })
+  const rejection = await config.guardDelete?.({
+    workspaceId,
+    folderIds,
+    ...(options.referenceCheckCompleted ? { referenceCheckCompleted: true } : {}),
+  })
   if (rejection) {
     return { success: false, error: rejection.error, errorCode: rejection.errorCode }
   }
 
-  const counts = await archiveFolderCascade(db, config, workspaceId, folderIds, timestamp)
+  let counts: Awaited<ReturnType<typeof archiveFolderCascade>>
+  try {
+    counts = await archiveFolderCascade(db, config, workspaceId, folderIds, timestamp)
+  } catch (error) {
+    const classified = asOrchestrationError(error)
+    if (classified?.code === 'locked' || classified?.code === 'conflict') {
+      return { success: false, error: classified.message, errorCode: classified.code }
+    }
+    throw error
+  }
 
   logger.info('Deleted folder and all contents', { folderId, resourceType, counts })
 
 
@@ -221,6 +221,63 @@ describe('table bulk application use cases', () => {
     )
   })
 
+  it('retries an explicit target after its selected-folder referrer is archived', async () => {
+    mocks.planFolderSelection.mockResolvedValue({
+      selected: [{ id: 'folder-1', name: 'Reports' }],
+      notFound: [],
+      contained: [],
+      covered: new Set(['folder-1']),
+      coveredBySelected: new Map([['folder-1', new Set(['folder-1'])]]),
+    })
+    mocks.deleteTables
+      .mockResolvedValueOnce({
+        archived: [],
+        failed: [
+          {
+            id: 'table-target',
+            name: 'Target',
+            reason: 'Target is referenced by Referrer',
+            code: 'reference',
+          },
+        ],
+        notFound: [],
+      })
+      .mockResolvedValueOnce(successfulTableDeleteBatch(['table-target']))
+    mocks.bulkDeleteFolders.mockResolvedValue({
+      succeeded: [{ id: 'folder-1', name: 'Reports' }],
+      failed: [],
+      folderCount: 1,
+      resourceCount: 1,
+    })
+
+    const result = await bulkDeleteTables.execute({
+      principal,
+      input: {
+        assertedWorkspaceId: 'workspace-1',
+        tableIds: ['table-target'],
+        folderKeying: 'ids' as const,
+        folders: ['folder-1'],
+      },
+    })
+
+    expect(result.deleted).toEqual([
+      { kind: 'folder', id: 'folder-1', name: 'Reports' },
+      { kind: 'table', id: 'table-target', name: 'Archived' },
+    ])
+    expect(result.failed).toEqual([])
+    expect(result.deletedItems).toEqual({ tables: 2, folders: 1 })
+    expect(mocks.deleteTables).toHaveBeenCalledTimes(2)
+    expect(mocks.deleteTables).toHaveBeenLastCalledWith(
+      ['table-target'],
+      'request-1',
+      expect.anything()
+    )
+    expect(mocks.findReferenceBlockers).toHaveBeenCalledOnce()
+    expect(mocks.bulkDeleteFolders).toHaveBeenCalledWith(
+      expect.objectContaining({ referenceCheckCompleted: true })
+    )
+  })
+
   /**
    * The whole point of taking both id lists in one request: a table that is
    * also inside a selected folder must be archived exactly once, under the
 
@@ -529,7 +529,9 @@ export const bulkDeleteTables = defineAuthorizedTableUseCase({
       for (const table of tableResult.archived) {
         deleted.push({ kind: 'table', id: table.id, name: table.name })
       }
+      const referenceFailures = tableResult.failed.filter((table) => table.code === 'reference')
       for (const table of tableResult.failed) {
+        if (table.code === 'reference') continue
         outcome.failed.push({ kind: 'table', id: table.id, name: table.name, reason: table.reason })
       }
       for (const tableId of tableResult.notFound) {
@@ -567,6 +569,7 @@ export const bulkDeleteTables = defineAuthorizedTableUseCase({
               })
             )
       const deletedItems = { tables: deleted.length, folders: 0 }
+      let deletedFolder = false
       if (terminalError === undefined && plan.selected.length > 0) {
         const deletableFolders = plan.selected.filter((folder) => {
           const blocker = blockedFolderIds.get(folder.id)
@@ -589,11 +592,49 @@ export const bulkDeleteTables = defineAuthorizedTableUseCase({
             }).attributedUserId,
             folders: deletableFolders,
             countKey: 'tables',
+            referenceCheckCompleted: true,
           })
           for (const folder of folders.succeeded) deleted.push({ kind: 'folder', ...folder })
           for (const folder of folders.failed) outcome.failed.push({ kind: 'folder', ...folder })
           deletedItems.folders = folders.folderCount
           deletedItems.tables += folders.resourceCount
+          deletedFolder = folders.succeeded.length > 0
+        }
+      }
+
+      if (terminalError === undefined && deletedFolder && referenceFailures.length > 0) {
+        const retryResult = await deleteTables(
+          referenceFailures.map((table) => table.id),
+          generateRequestId(),
+          {
+            expectedWorkspaceId: context.workspaceId,
+            skipNotify: true,
+          }
+        )
+        for (const table of retryResult.archived) {
+          deleted.push({ kind: 'table', id: table.id, name: table.name })
+          deletedItems.tables += 1
+        }
+        for (const table of retryResult.failed) {
+          outcome.failed.push({
+            kind: 'table',
+            id: table.id,
+            name: table.name,
+            reason: table.reason,
+          })
+        }
+        for (const tableId of retryResult.notFound) {
+          outcome.notFound.push({ kind: 'table', id: tableId })
+        }
+        terminalError = retryResult.terminalError
+      } else {
+        for (const table of referenceFailures) {
+          outcome.failed.push({
+            kind: 'table',
+            id: table.id,
+            name: table.name,
+            reason: table.reason,
+          })
         }
       }