@@ -4,10 +4,7 @@ import { describeError, toError } from '@sim/utils/errors'
 import { inArray } from 'drizzle-orm'
 import { chatBackendCleanupPayloadSchema } from '@/lib/cleanup/chat-backend-cleanup'
 import { CHAT_BACKEND_CLEANUP_EVENT } from '@/lib/cleanup/chat-backend-cleanup-event'
-import {
-  cleanupCopilotBackend,
-  organizationAttachmentsStillReferenced,
-} from '@/lib/cleanup/chat-cleanup'
+import { cleanupCopilotBackend, deletableChatFiles } from '@/lib/cleanup/chat-cleanup'
 import { env } from '@/lib/core/config/env'
 import {
   continueOutboxHandler,
@@ -65,7 +62,8 @@ export const chatBackendCleanupOutboxHandlers = {
    * continues in a later run once its deadline nears. Any failure throws so the outbox retries it:
    * a failed backend call, a failed object delete, or chat ids queued for the backend reaching a
    * processor without `COPILOT_API_KEY`. An object already gone counts as deleted, so a retry
-   * repeats only what is left.
+   * repeats only what is left. A stored file another chat of its scope still references, as a
+   * fork's uncopied attachment does, is kept ({@link deletableChatFiles}).
    */
   [CHAT_BACKEND_CLEANUP_EVENT]: async (rawPayload, context) => {
     const { chatIds, files, copilotBackend, imagesSwept } =
@@ -100,9 +98,8 @@ export const chatBackendCleanupOutboxHandlers = {
     }
 
     if (deletedFiles.length === 0) return
-    const stillReferenced = await organizationAttachmentsStillReferenced(deletedFiles)
     const failures = await mapWithConcurrency(
-      deletedFiles.filter((file) => !stillReferenced.has(file.key)),
+      await deletableChatFiles(deletedFiles),
       FILE_DELETE_CONCURRENCY,
       async ({ key, context: storageContext }) => {
         context.signal.throwIfAborted()
 
@@ -313,6 +313,96 @@ describe('cleanup of a permanently deleted chat', () => {
     expect(backend.rejected).toBe(0)
   })
 
+  /**
+   * A fork whose copy of an upload failed keeps naming the source's key in its messages, while
+   * the upload's `workspace_files` row cascades away with the source chat.
+   */
+  it('keeps a deleted chat’s upload that a fork in its workspace still references', async () => {
+    const ownerId = await seedUser()
+    const workspaceId = await seedWorkspace(ownerId)
+    const uploadIn = async (chatId: string) => {
+      const key = `workspace/${workspaceId}/1700000000000-${generateId().slice(0, 8)}-shot.png`
+      await db.insert(workspaceFiles).values({
+        id: generateId(),
+        key,
+        userId: ownerId,
+        workspaceId,
+        context: 'mothership',
+        chatId,
+        originalName: 'shot.png',
+        contentType: 'image/png',
+        sizeBytes: 1,
+      })
+      await putObject(key)
+      return key
+    }
+    const forkedSource = await seedChat(ownerId, workspaceId)
+    const sharedKey = await uploadIn(forkedSource)
+    const fork = await seedChat(ownerId, workspaceId)
+    await db.insert(copilotMessages).values({
+      chatId: fork,
+      messageId: generateId(),
+      role: 'user',
+      content: {
+        role: 'user',
+        content: 'see attached',
+        fileAttachments: [{ key: sharedKey, filename: 'shot.png' }],
+      },
+    })
+    const unforkedSource = await seedChat(ownerId, workspaceId)
+    const ownKey = await uploadIn(unforkedSource)
+
+    await deleteCopilotChat({ chatId: forkedSource, userId: ownerId })
+    await deleteCopilotChat({ chatId: unforkedSource, userId: ownerId })
+
+    expect(new Set((await deliverCleanups()).outcomes)).toEqual(new Set(['completed']))
+    expect(await objectExists(sharedKey)).toBe(true)
+    expect(await objectExists(ownKey)).toBe(false)
+  })
+
+  it('keeps what an event queued before refs carried their scope cannot place', async () => {
+    const ownerId = await seedUser()
+    const workspaceId = await seedWorkspace(ownerId)
+    const deletedChat = await seedChat(ownerId, workspaceId)
+    const remainingChat = await seedChat(ownerId, workspaceId)
+    const referenced = `workspace/${workspaceId}/1700000000000-abcd1234-kept.png`
+    const unreferenced = `workspace/${workspaceId}/1700000000000-abcd1234-gone.png`
+    const unplaceable = `copilot/${generateId()}/legacy.png`
+    for (const key of [referenced, unreferenced, unplaceable]) await putObject(key)
+    await db.insert(copilotMessages).values({
+      chatId: remainingChat,
+      messageId: generateId(),
+      role: 'user',
+      content: { role: 'user', content: 'x', fileAttachments: [{ key: referenced }] },
+    })
+    await db.delete(copilotChats).where(eq(copilotChats.id, deletedChat))
+    await db.insert(outboxEvent).values({
+      id: generateId(),
+      eventType: CHAT_BACKEND_CLEANUP_EVENT,
+      payload: {
+        chatIds: [],
+        files: [referenced, unreferenced].map((key) => ({
+          key,
+          context: 'mothership',
+          chatId: deletedChat,
+        })),
+      },
+    })
+    await db.insert(outboxEvent).values({
+      id: generateId(),
+      eventType: CHAT_BACKEND_CLEANUP_EVENT,
+      payload: {
+        chatIds: [],
+        files: [{ key: unplaceable, context: 'copilot', chatId: deletedChat }],
+      },
+    })
+
+    expect((await deliverCleanups()).outcomes).toEqual(['completed', 'completed'])
+    expect(await objectExists(referenced)).toBe(true)
+    expect(await objectExists(unreferenced)).toBe(false)
+    expect(await objectExists(unplaceable)).toBe(true)
+  })
+
   it('records no cleanup when the delete rolls back', async () => {
     const ownerId = await seedUser()
     const workspaceId = await seedWorkspace(ownerId)
 
@@ -27,6 +27,7 @@ const chatFileSchema = z
     ]),
     chatId: chatIdSchema,
     organizationId: chatIdSchema.optional(),
+    workspaceId: chatIdSchema.nullable().optional(),
   })
   .strict()
 
@@ -83,11 +84,12 @@ export async function enqueueChatBackendCleanup(
     })),
     ...chunkArray([...filesByKey.values()], CHAT_BACKEND_CLEANUP_BATCH_SIZE).map((batch) => ({
       chatIds: [],
-      files: batch.map(({ key, context, chatId, organizationId }) => ({
+      files: batch.map(({ key, context, chatId, organizationId, workspaceId }) => ({
         key,
         context,
         chatId,
         ...(organizationId ? { organizationId } : {}),
+        ...(workspaceId !== undefined ? { workspaceId } : {}),
       })),
     })),
   ]
 
@@ -109,9 +109,9 @@ describe('chat cleanup file collection in PostgreSQL', () => {
           chatId,
           organizationId: 'org-1',
         },
-        { key: 'copilot/1234/legacy.png', context: 'copilot', chatId },
-        { key: 'copilot/5/other.png', context: 'copilot', chatId: otherChatId },
-        { key: 'copilot/9/removed.png', context: 'copilot', chatId },
+        { key: 'copilot/1234/legacy.png', context: 'copilot', chatId, workspaceId: null },
+        { key: 'copilot/5/other.png', context: 'copilot', chatId: otherChatId, workspaceId: null },
+        { key: 'copilot/9/removed.png', context: 'copilot', chatId, workspaceId: null },
       ].sort((a, b) => compareStrings(a.key, b.key))
     )
   })
 
@@ -7,7 +7,9 @@ import { and, eq, inArray, or, sql } from 'drizzle-orm'
 import { enqueueChatBackendCleanup } from '@/lib/cleanup/chat-backend-cleanup'
 import {
   type ChatFileRef,
+  type ChatFileReferenceScope,
   type ChatScopedContext,
+  chatFileReferenceScope,
   collectChatFiles,
 } from '@/lib/cleanup/chat-files'
 import { env } from '@/lib/core/config/env'
@@ -24,22 +26,38 @@ const COPILOT_CLEANUP_BATCH_SIZE = 1000
 const CHAT_FILE_COLLECT_CHUNK_SIZE = 500
 
 /**
- * Organization attachment keys that a remaining chat still references, so they outlive the
- * chats being purged. Runs after the caller deleted those chats' rows, so any match is
- * another chat: a fork, or a chat that is only soft-deleted and may be restored.
+ * The files among `files` that may be deleted: those no remaining chat of their scope still
+ * references ({@link chatFileReferenceScope}). A fork keeps naming its source's key wherever it
+ * did not copy the file, so a key still in another chat's `fileAttachments` outlives the chats
+ * being purged, and a key whose scope is unknown is kept rather than risked. Runs after the caller
+ * deleted those chats' rows, so any match is another chat: a fork, or a chat that is only
+ * soft-deleted and may be restored.
  */
-export async function organizationAttachmentsStillReferenced(
-  files: readonly ChatFileRef[]
-): Promise<Set<string>> {
-  const keysByOrganization = new Map<string, string[]>()
+export async function deletableChatFiles(files: readonly ChatFileRef[]): Promise<ChatFileRef[]> {
+  const keysByScope = new Map<string, { scope: ChatFileReferenceScope; keys: string[] }>()
+  const kept = new Set<string>()
   for (const file of files) {
-    if (!file.organizationId) continue
-    const keys = keysByOrganization.get(file.organizationId)
-    if (keys) keys.push(file.key)
-    else keysByOrganization.set(file.organizationId, [file.key])
+    const scope = chatFileReferenceScope(file)
+    if (scope === null) continue
+    if (scope === undefined) {
+      kept.add(file.key)
+      continue
+    }
+    const scopeKey = `${scope.kind}:${scope.id}`
+    const group = keysByScope.get(scopeKey)
+    if (group) group.keys.push(file.key)
+    else keysByScope.set(scopeKey, { scope, keys: [file.key] })
+  }
+  if (kept.size > 0) {
+    logger.warn(`Keeping ${kept.size} chat files whose reference scope is unknown`, {
+      keys: [...kept],
+    })
   }
-  const referenced = new Set<string>()
-  for (const [organizationId, keys] of keysByOrganization) {
+  for (const { scope, keys } of keysByScope.values()) {
+    const inScope =
+      scope.kind === 'organization'
+        ? eq(copilotChats.organizationId, scope.id)
+        : eq(copilotChats.workspaceId, scope.id)
     for (const chunk of chunkArray(keys, CHAT_FILE_COLLECT_CHUNK_SIZE)) {
       const wanted = new Set(chunk)
       const rows = await cleanupDb
@@ -48,7 +66,7 @@ export async function organizationAttachmentsStillReferenced(
         .innerJoin(copilotChats, eq(copilotChats.id, copilotMessages.chatId))
         .where(
           and(
-            eq(copilotChats.organizationId, organizationId),
+            inScope,
             or(
               ...chunk.map(
                 (key) =>
@@ -65,12 +83,12 @@ export async function organizationAttachmentsStillReferenced(
             typeof attachment.key === 'string' &&
             wanted.has(attachment.key)
           )
-            referenced.add(attachment.key)
+            kept.add(attachment.key)
         }
       }
     }
   }
-  return referenced
+  return files.filter((file) => !kept.has(file.key))
 }
 
 /** Groups files by storage context so each context can use one batch DELETE call. */
@@ -195,12 +213,9 @@ export async function prepareChatCleanup(
         )
       }
       const confirmedChatIds = chatIds.filter((id) => !survivors.has(id))
-      const sharedKeys = await organizationAttachmentsStillReferenced(
+      const confirmedFiles = await deletableChatFiles(
         files.filter((file) => !survivors.has(file.chatId))
       )
-      const confirmedFiles = files.filter(
-        (file) => !survivors.has(file.chatId) && !sharedKeys.has(file.key)
-      )
 
       // Call copilot backend
       if (confirmedChatIds.length > 0) {