@@ -469,6 +469,22 @@ describe('organization resource stream', () => {
     expect(workspace.removeResource).not.toHaveBeenCalled()
     expect(mocks.invalidateResourceQueries).not.toHaveBeenCalled()
   })
+
+  it('opens a Project file tab, which names no workspace, in an organization chat', () => {
+    const org = makeStreamLoopDeps({ workspaceId: undefined })
+    const projectFile = {
+      type: 'file' as const,
+      id: 'file-1',
+      title: 'context.md',
+      owner: { entityType: 'project' as const, entityId: 'project-1' },
+    }
+    handleResourceEvent({ deps: org } as StreamLoopContext, {
+      ...removeEvent('file', 'file-1'),
+      payload: { op: 'upsert', resource: projectFile },
+    })
+    expect(org.addResource).toHaveBeenCalledWith(projectFile)
+    expect(mocks.invalidateResourceQueries).not.toHaveBeenCalled()
+  })
 })
 
 describe('owner-addressed effects on a legacy tab', () => {
 
@@ -10,6 +10,7 @@ import { searchResourceMatchesOwner } from '@/lib/mothership/resources/search'
 import {
   chatResourceKeyFor,
   getChatResourceSelectionId,
+  isFileResourceType,
   mergeChatResource,
 } from '@/lib/mothership/resources/types'
 import { notifyWorkflowExternalUpdate } from '@/lib/workflows/external-update'
@@ -194,12 +195,19 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
   if (owner?.entityType === 'project' && payload.resource.type === 'file' && payload.resource.id)
     invalidateProjectFileQueries(queryClient, owner.entityId, payload.resource.id)
   const workspaceId = payload.resource.workspaceId ?? chatWorkspaceId
-  if (!workspaceId || (chatWorkspaceId && workspaceId !== chatWorkspaceId)) return
+  /** A Project file names no workspace, so an organization chat has none to check it against. */
+  if (
+    workspaceId
+      ? chatWorkspaceId && workspaceId !== chatWorkspaceId
+      : !(owner?.entityType === 'project' && isFileResourceType(payload.resource.type))
+  )
+    return
   // Browser and terminal tabs are projected from the desktop app's live
   // lists, never from the stream; older servers announced them as resources.
   if (payload.resource.type === 'browser' || payload.resource.type === 'terminal') return
   const resourceType = payload.resource.type
-  invalidateResourceQueries(queryClient, workspaceId, resourceType, payload.resource.id)
+  if (workspaceId)
+    invalidateResourceQueries(queryClient, workspaceId, resourceType, payload.resource.id)
   if (resourceType === 'workflow' && payload.op !== 'remove' && payload.resource.id) {
     notifyWorkflowExternalUpdate(payload.resource.id)
   }
@@ -246,7 +254,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
       : undefined
   const resource: MothershipResource = {
     ...payload.resource,
-    ...(chatWorkspaceId ? {} : { workspaceId }),
+    ...(!chatWorkspaceId && workspaceId ? { workspaceId } : {}),
     type: payload.resource.type as MothershipResourceType,
     title:
       typeof payload.resource.title === 'string' ? payload.resource.title : payload.resource.id,
@@ -264,7 +272,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
         current === getChatResourceSelectionId(resource) ? null : current
       )
     } else removeResource(resource)
-    if (resourceType === 'workflow') {
+    if (resourceType === 'workflow' && workspaceId) {
       removeWorkflowFromActiveCache(queryClient, workspaceId, resource.id)
     }
     return
@@ -352,7 +360,7 @@ export function handleResourceEvent(ctx: StreamLoopContext, parsed: ResourceEven
     } else onResourceEvent?.(getChatResourceSelectionId(resource))
   }
 
-  if (resource.type === 'workflow') {
+  if (resource.type === 'workflow' && workspaceId) {
     ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
   }
 }
@@ -0,0 +1,45 @@
+import { queueTableRows, resetDbChainMock } from '@sim/testing/mocks/database.mock'
+import { schemaMock } from '@sim/testing/mocks/schema.mock'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { changeStoredChatResources } from '@/lib/mothership/resources/store'
+import type { MothershipResource } from '@/lib/mothership/resources/types'
+
+const unscopedFile: MothershipResource = { type: 'file', id: 'file-1', title: 'notes.md' }
+const scopedFile: MothershipResource = { ...unscopedFile, workspaceId: 'ws' }
+const table: MothershipResource = { type: 'table', id: 'table-1', title: 'Accounts' }
+
+function storeWorkspaceChat(resources: MothershipResource[]) {
+  queueTableRows(schemaMock.copilotChats, [{ resources, workspaceId: 'ws' }])
+}
+
+describe('changeStoredChatResources reorder', () => {
+  beforeEach(() => {
+    resetDbChainMock()
+  })
+
+  it('keeps the reorder when a workspace chat holds a tab both unscoped and scoped', async () => {
+    storeWorkspaceChat([unscopedFile, scopedFile, table])
+
+    const reordered = await changeStoredChatResources('chat-1', {
+      kind: 'reorder',
+      resources: [table, unscopedFile, scopedFile],
+    })
+
+    expect(reordered.map((resource) => resource.type)).toEqual(['table', 'file'])
+  })
+
+  it('still rejects an order that drops or invents a resource', async () => {
+    storeWorkspaceChat([scopedFile, table])
+    await expect(
+      changeStoredChatResources('chat-1', { kind: 'reorder', resources: [table, table] })
+    ).rejects.toThrow('Reordered resources must match existing resources')
+
+    storeWorkspaceChat([scopedFile, table])
+    await expect(
+      changeStoredChatResources('chat-1', {
+        kind: 'reorder',
+        resources: [table, { ...unscopedFile, id: 'file-2' }],
+      })
+    ).rejects.toThrow('Reordered resources must match existing resources')
+  })
+})
@@ -8,6 +8,7 @@ import {
   type MothershipResource,
   type MothershipResourceUpdate,
   mergeChatResource,
+  reorderStoredChatResources,
   sanitizeChatResources,
 } from '@/lib/mothership/resources/types'
 
@@ -112,25 +113,20 @@ export async function changeStoredChatResources(
         const incoming = sanitizeChatResources(
           change.resources.filter((resource) => resource.id !== 'streaming-file')
         )
-        const byKey = new Map(existing.map((resource) => [keyOf(resource), resource]))
         if (change.kind === 'reorder') {
-          const keys = incoming.map(keyOf)
-          if (
-            keys.length !== byKey.size ||
-            new Set(keys).size !== keys.length ||
-            keys.some((key) => !byKey.has(key))
-          ) {
+          const reordered = reorderStoredChatResources(
+            existing,
+            incoming,
+            chat.workspaceId ?? undefined
+          )
+          if (!reordered)
             throw new OrchestrationError(
               'validation',
               'Reordered resources must match existing resources'
             )
-          }
-          resources = keys.map((key) => {
-            const resource = byKey.get(key)
-            if (!resource) throw new OrchestrationError('validation', 'Resource order changed')
-            return resource
-          })
+          resources = reordered
         } else {
+          const byKey = new Map(existing.map((resource) => [keyOf(resource), resource]))
           for (const resource of incoming) {
             const key = keyOf(resource)
             const previous = byKey.get(key)
 
@@ -6,6 +6,7 @@ import {
 import { urlsMockFns } from '@sim/testing/mocks/urls.mock'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { copilotRequestPrincipal, isCopilotRequest } from '@/lib/api/server/routes/copilot-request'
+import { DEFAULT_MAX_JSON_BODY_BYTES } from '@/lib/api/server/validation'
 import {
   type ContentSource,
   noteContentDeliveryOperation,
@@ -465,3 +466,33 @@ it('validates a copy body itself once the lease negotiated the file-owner protoc
   expect(response.status).toBe(400)
   expect(fetcher).not.toHaveBeenCalled()
 })
+
+it.each([undefined, 1 as const])(
+  'refuses an oversized streamed copy body at the cap without dispatch (protocol %s)',
+  async (fileOwnerProtocolVersion) => {
+    readScope.mockResolvedValue({ ...scope, fileOwnerProtocolVersion })
+    routeMatcher.mockReturnValue({ params: {}, load: async () => ({ POST: fetcher }) })
+    const projectCopy = new TextEncoder().encode(
+      JSON.stringify({
+        source: { owner: workspaceOwner, fileIds: ['file'] },
+        destination: { owner: { entityType: 'project', entityId: 'project' } },
+      })
+    )
+    const padding = new Uint8Array(1024 * 1024).fill(0x20)
+    const paddingChunks = Math.ceil((2 * DEFAULT_MAX_JSON_BODY_BYTES) / padding.byteLength)
+    let pulledChunks = 0
+    const body = new ReadableStream<Uint8Array>({
+      pull(controller) {
+        if (pulledChunks === 0) controller.enqueue(projectCopy)
+        else if (pulledChunks <= paddingChunks) controller.enqueue(padding)
+        else controller.close()
+        pulledChunks++
+      },
+    })
+    const init: RequestInit & { duplex: 'half' } = { method: 'POST', body, duplex: 'half' }
+    const response = await proxySandboxResourceRequest(request('/api/v2/files/copy', init), token)
+    expect(response.status).toBe(413)
+    expect(fetcher).not.toHaveBeenCalled()
+    expect(pulledChunks).toBeLessThan(paddingChunks)
+  }
+)
@@ -1,12 +1,18 @@
 import { createLogger } from '@sim/logger'
 import { generateId } from '@sim/utils/id'
 import { NextRequest } from 'next/server'
-import { fileCopyInputSchema } from '@/lib/api/contracts/file-copy-input'
 import { v2CopyFileItemsContract } from '@/lib/api/contracts/v2/file-copy'
 import { markCopilotRequest } from '@/lib/api/server/routes/copilot-request'
 import { matchV2Route } from '@/lib/api/server/routes/in-process-transport'
+import { V2_PARSE_DEFAULTS } from '@/lib/api/server/routes/v2-json-route'
+import { DEFAULT_MAX_JSON_BODY_BYTES, parseRequest } from '@/lib/api/server/validation'
 import { withWorkspaceInvocationScope } from '@/lib/core/application/workspace-invocation-scope'
 import { asOrchestrationError, statusForOrchestrationError } from '@/lib/core/orchestration/types'
+import {
+  assertContentLengthWithinLimit,
+  isPayloadSizeLimitError,
+  readStreamToBufferWithLimit,
+} from '@/lib/core/utils/stream-limits'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { createResourceEffectTransport } from '@/lib/mothership/agent-cli/resource-effects'
 import { resolveInvocationWorkspace } from '@/lib/mothership/application/workspace-target'
@@ -27,9 +33,10 @@ const logger = createLogger('MothershipSandboxResourceTransport')
 
 /** Private callback observes the real authenticated v2 request without changing its body or API contract. */
 export async function proxySandboxResourceRequest(
-  request: Request,
+  callback: Request,
   token: string
 ): Promise<Response> {
+  let request = callback
   const url = new URL(request.url)
   const prefix = `/api/mothership/sandbox/${token}`
   const path = url.pathname.slice(prefix.length)
@@ -51,11 +58,13 @@ export async function proxySandboxResourceRequest(
    * owner is refused there; workspace copies and invalid bodies keep the workspace route and its
    * v2 validation response.
    */
-  if (
-    path === v2CopyFileItemsContract.path &&
-    (scope.fileOwnerProtocolVersion === 1 || (await copiesBeyondWorkspaces(request)))
-  )
-    return proxySandboxFileCopyRequest(request, token, scope)
+  if (path === v2CopyFileItemsContract.path) {
+    const buffered = await bufferCopyRequest(request)
+    if (buffered instanceof Response) return buffered
+    request = buffered
+    if (scope.fileOwnerProtocolVersion === 1 || (await copiesBeyondWorkspaces(request)))
+      return proxySandboxFileCopyRequest(request, token, scope)
+  }
   const ownerHeader = request.headers.get('x-mothership-file-owner')
   let owner: FileOperationOwner | undefined
   if (ownerHeader !== null) {
@@ -203,18 +212,42 @@ async function proxyAuthorizedSandboxRequest(
   })
 }
 
-/** A valid copy naming a non-workspace source or destination needs the file-owner protocol. */
-async function copiesBeyondWorkspaces(request: Request): Promise<boolean> {
-  let body: unknown
+/**
+ * Reads a copy body once, under the v2 body cap, so the protocol check and whichever copy path
+ * handles it each read an in-memory copy. Parsing a clone of the live stream instead would hang on
+ * an oversized body: cancelling one branch of a teed stream waits for the unread other branch.
+ */
+async function bufferCopyRequest(request: Request): Promise<Request | Response> {
+  if (!request.body) return request
   try {
-    body = await request.clone().json()
-  } catch {
-    return false
+    assertContentLengthWithinLimit(request.headers, DEFAULT_MAX_JSON_BODY_BYTES, 'Request body')
+    const body = await readStreamToBufferWithLimit(request.body, {
+      maxBytes: DEFAULT_MAX_JSON_BODY_BYTES,
+      label: 'Request body',
+      signal: request.signal,
+    })
+    return new Request(request, { body: new Uint8Array(body) })
+  } catch (error) {
+    if (isPayloadSizeLimitError(error)) return V2_PARSE_DEFAULTS.payloadTooLargeResponse()
+    throw error
   }
-  const parsed = fileCopyInputSchema.safeParse(body)
+}
+
+/**
+ * A valid copy naming a non-workspace source or destination needs the file-owner protocol. Parsed
+ * as the copy route parses it: an invalid body stays on the workspace route, which returns its own
+ * 400.
+ */
+async function copiesBeyondWorkspaces(request: Request): Promise<boolean> {
+  const parsed = await parseRequest(
+    v2CopyFileItemsContract,
+    new NextRequest(request.clone()),
+    {},
+    V2_PARSE_DEFAULTS
+  )
   return (
     parsed.success &&
-    (parsed.data.source.owner.entityType !== 'workspace' ||
-      parsed.data.destination.owner.entityType !== 'workspace')
+    (parsed.data.body.source.owner.entityType !== 'workspace' ||
+      parsed.data.body.destination.owner.entityType !== 'workspace')
   )
 }