@@ -642,6 +642,50 @@ describe('setupWorkspaceFileDocHandlers', () => {
     }
   })
 
+  it('publishes write access to a socket only when it changes, not on every frame', async () => {
+    // A distinct user/file: role decisions recorded under fake timers outlive this test.
+    vi.useFakeTimers()
+    try {
+      const { io } = createIo()
+      const { socket, handlers } = setup('socket-capability', io, { userId: 'user-capability' })
+      await handlers[FILE_DOC_EVENTS.JOIN]({ fileId: 'file-capability', clientId: 7 })
+      await vi.advanceTimersByTimeAsync(0)
+      const presence = awarenessFrame(7, 'Capability').frame
+      const sendFrames = async () => {
+        for (let sent = 0; sent < 3; sent++) {
+          void handlers[FILE_DOC_EVENTS.MESSAGE](presence)
+          await vi.advanceTimersByTimeAsync(0)
+        }
+      }
+      const published = () =>
+        socket.emit.mock.calls
+          .filter(([event]) => event === FILE_DOC_EVENTS.PERMISSION)
+          .map(([, payload]) => (payload as { canWrite: boolean }).canWrite)
+      const changeRole = async (workspacePermission: 'read' | 'write') => {
+        mockAuthorizeRoom.mockResolvedValue({
+          allowed: true,
+          status: 200,
+          workspaceId: 'ws-1',
+          workspacePermission,
+        })
+        await vi.advanceTimersByTimeAsync(ROLE_REVALIDATION_TTL_MS + 1_000)
+      }
+
+      await sendFrames()
+      expect(published()).toEqual([true])
+
+      await changeRole('read')
+      await sendFrames()
+      expect(published()).toEqual([true, false])
+
+      await changeRole('write')
+      await sendFrames()
+      expect(published()).toEqual([true, false, true])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('applies + fans out an agent-streamed frame (SYNC_NO_PERSIST) but never persists it', async () => {
     mockFetchFileDocSeed.mockResolvedValue(seedResult('# From server'))
     const { io, sent } = createIo()
 
@@ -150,6 +150,8 @@ interface FileDocRoom {
   /** socketId → (clientId → its presence ownership). A socket owns one entry per collaborative provider
    * it mounted for this file (see {@link FileDocPresenceOwner}); an empty inner map is never kept. */
   owners: Map<string, Map<number, FileDocPresenceOwner>>
+  /** socketId → the write capability last sent to it, so per-frame checks publish only a change. */
+  publishedCanWrite: Map<string, boolean>
   /**
    * The in-flight server seed for this room, or `null`. Concurrent joins await THIS promise rather
    * than each starting a fetch — and, unlike a "started" boolean, awaiting it is what lets a second
@@ -1043,6 +1045,7 @@ function getOrCreateRoom(io: Server, target: FileDocTarget): FileDocRoom {
     doc,
     awareness,
     owners: new Map(),
+    publishedCanWrite: new Map(),
     seeding: null,
     lastEditorUserId: null,
     edited: false,
@@ -1161,11 +1164,15 @@ function resolveFileDocPermission(
   const room = fileDocRoom(document)
   const accept = (permission: string | null) => {
     if (socketToRoomName.get(socket.id) !== name || fileDocRooms.get(name) !== document) return null
-    socket.emit(FILE_DOC_EVENTS.PERMISSION, {
-      fileId: document.fileId,
-      ...fileDocOwnerWireFields(document.owner),
-      canWrite: permission === 'write' || permission === 'admin',
-    } satisfies FileDocPermission)
+    const canWrite = permission === 'write' || permission === 'admin'
+    if (document.publishedCanWrite.get(socket.id) !== canWrite) {
+      document.publishedCanWrite.set(socket.id, canWrite)
+      socket.emit(FILE_DOC_EVENTS.PERMISSION, {
+        fileId: document.fileId,
+        ...fileDocOwnerWireFields(document.owner),
+        canWrite,
+      } satisfies FileDocPermission)
+    }
     if (permission === null)
       evictSocketFromRoom(socket, room, 'Your access to this document has been revoked', io)
     return permission
@@ -1216,7 +1223,16 @@ async function handleMessage(socket: AuthenticatedSocket, io: Server, data: unkn
     }
     const decoder = decoding.createDecoder(bytes)
     const messageType = decoding.readVarUint(decoder)
-    const permission = await resolveFileDocPermission(socket, io, name)
+    let permission: string | null
+    try {
+      permission = await resolveFileDocPermission(socket, io, name)
+    } catch (error) {
+      logger.warn('Dropping file-doc frame while its authorization is unavailable', {
+        socketId: socket.id,
+        error,
+      })
+      return
+    }
     if (permission === null) return
     const canWrite = permission === 'write' || permission === 'admin'
     if (messageType === FILE_DOC_MESSAGE_TYPE.SYNC) {
@@ -1460,6 +1476,7 @@ export function cleanupFileDocForSocket(socketId: string, io: Server, endOfLife
   // caret via its awareness removal.
   const clientMap = room.owners.get(socketId)
   room.owners.delete(socketId)
+  room.publishedCanWrite.delete(socketId)
   clearFileDocPresence(io, socketId, name)
   if (clientMap !== undefined && clientMap.size > 0) {
     // Fires the awareness `update` handler with a non-socket origin → the removals
@@ -1788,6 +1805,7 @@ export function setupWorkspaceFileDocHandlers(
           awarenessProtocol.removeAwarenessStates(entry.awareness, [clientId], null)
           if (clientMap.size === 0) {
             entry.owners.delete(otherSid)
+            entry.publishedCanWrite.delete(otherSid)
             socketToRoomName.delete(otherSid)
             clearFileDocPresence(io, otherSid, name)
             io.in(otherSid).socketsLeave(name)
@@ -1832,6 +1850,8 @@ export function setupWorkspaceFileDocHandlers(
           roomName: name,
           user: { socketId: socket.id, userId, userName, avatarUrl },
         }
+        /** Co-mounted providers learn from the next frame whether this admission changed access. */
+        entry.publishedCanWrite.delete(socket.id)
 
         // Name the document this room holds, so a client that still carries a DIFFERENT one (its room
         // outlived by a document rebuilt in its place) can refuse to merge instead of unioning two
 
@@ -1,12 +1,18 @@
 import { projectFileDocPersistContract } from '@/lib/api/contracts/project-file-doc'
+import { isOffAppHost } from '@/lib/api/mcp/host-routing'
 import {
   defineInternalJsonRoute,
   internalOrchestrationErrorPolicy,
   internalRateLimits,
 } from '@/lib/api/server/routes'
 import { realtimeProjectFileAuth } from '@/lib/auth/realtime-file-delegation'
+import { MAX_COLLAB_DOC_STATE_BYTES } from '@/lib/collab-doc/state'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { persistProjectFileDoc } from '@/lib/projects/files/application/documents'
 
+/** A base64-encoded maximum snapshot plus 1 MiB for its JSON envelope (17 MiB). */
+const PERSIST_MAX_BODY_BYTES = Math.ceil(MAX_COLLAB_DOC_STATE_BYTES / 3) * 4 + 1024 * 1024
+
 export const POST = defineInternalJsonRoute({
   contract: projectFileDocPersistContract,
   operation: persistProjectFileDoc.operation,
@@ -15,11 +21,15 @@ export const POST = defineInternalJsonRoute({
     reason: 'Authenticated realtime relay; socket frame admission bounds collaborative traffic',
   }),
   errorPolicy: internalOrchestrationErrorPolicy,
+  /** Excluded from the proxy matcher, so the route refuses the dedicated MCP host itself. */
+  beforeParse: ({ request }) => {
+    if (isOffAppHost(request)) throw new OrchestrationError('not_found', 'Not found')
+  },
   mapInput: ({ params, body }) => ({
     ...params,
     docState: new Uint8Array(Buffer.from(body.docState, 'base64')),
     expectedVersion: body.expectedVersion,
   }),
   useCase: persistProjectFileDoc,
-  parseOptions: { maxBodyBytes: 17 * 1024 * 1024 },
+  parseOptions: { maxBodyBytes: PERSIST_MAX_BODY_BYTES, bypassesProxy: true },
 })
@@ -168,6 +168,25 @@ describe('v2 single-file routes', () => {
     )
   })
 
+  it('downloads an attachment with its stored type and name, without sniffing', async () => {
+    mocks.download.mockResolvedValueOnce({
+      file: fileRecord({ name: 'notes' }),
+      stream: new Blob(['<p>notes</p>']).stream(),
+      contentType: 'text/html',
+      contentLength: 12,
+    })
+
+    const response = await GET(
+      new NextRequest(`http://localhost:3000/api/v2/files/${FILE_ID}?workspaceId=${WORKSPACE_ID}`),
+      context
+    )
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('Content-Type')).toBe('text/html')
+    expect(response.headers.get('Content-Disposition')).toBe('attachment; filename="notes"')
+    expect(response.headers.get('X-Content-Type-Options')).toBe('nosniff')
+  })
+
   it('conceals cross-workspace download authorization', async () => {
     mocks.download.mockRejectedValue(new NoWorkspaceAccessError())
 
 
@@ -9,7 +9,7 @@ import {
   v2ApiKeyAuth,
   v2RateLimits,
 } from '@/lib/api/server/routes'
-import { FILE_CACHE_CONTROL, presentFileDelivery } from '@/lib/uploads/server/delivery'
+import { presentFileAttachment } from '@/lib/uploads/server/delivery'
 import { v2FileErrorPolicies } from '@/lib/workspace-files/api'
 import { deleteWorkspaceFileOperation } from '@/lib/workspace-files/application/delete-workspace-file'
 import { downloadWorkspaceFileStream } from '@/lib/workspace-files/application/download-workspace-file'
@@ -45,14 +45,7 @@ export const GET = defineV2BinaryRoute({
   }),
   useCase: downloadWorkspaceFileStream,
   present: ({ file, stream, contentType, contentLength }) =>
-    presentFileDelivery({
-      body: stream,
-      filename: file.name,
-      contentType,
-      contentLength,
-      attachment: true,
-      cacheControl: FILE_CACHE_CONTROL.noStore,
-    }),
+    presentFileAttachment({ body: stream, filename: file.name, contentType, contentLength }),
 })
 
 /**
 
@@ -1,6 +1,6 @@
 import { v2DownloadFileVersionContract } from '@/lib/api/contracts/v2/file-versions'
 import { defineV2BinaryRoute, v2ApiKeyAuth, v2RateLimits } from '@/lib/api/server/routes'
-import { FILE_CACHE_CONTROL, presentFileDelivery } from '@/lib/uploads/server/delivery'
+import { presentFileAttachment } from '@/lib/uploads/server/delivery'
 import { v2FileErrorPolicies } from '@/lib/workspace-files/api'
 import { downloadWorkspaceFileVersion } from '@/lib/workspace-files/application/file-versions'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
@@ -30,12 +30,5 @@ export const GET = defineV2BinaryRoute({
   }),
   useCase: downloadWorkspaceFileVersion,
   present: ({ file, stream, contentType, contentLength }) =>
-    presentFileDelivery({
-      body: stream,
-      filename: file.name,
-      contentType,
-      contentLength,
-      attachment: true,
-      cacheControl: FILE_CACHE_CONTROL.noStore,
-    }),
+    presentFileAttachment({ body: stream, filename: file.name, contentType, contentLength }),
 })
@@ -1,10 +1,9 @@
 import { v2ListFileVersionsContract } from '@/lib/api/contracts/v2/file-versions'
 import { cursorRoute, cursorScopeKey } from '@/lib/api/cursor-binding'
 import { defineV2JsonRoute, v2ApiKeyAuth, v2RateLimits } from '@/lib/api/server/routes'
-import { v2FileErrorPolicies } from '@/lib/workspace-files/api'
+import { toFileVersion, v2FileErrorPolicies } from '@/lib/workspace-files/api'
 import { listWorkspaceFileVersions } from '@/lib/workspace-files/application/file-versions'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
-import { toV2FileVersions } from '@/app/api/v2/files/utils'
 import { readSortedCursor, writeSortedCursor } from '@/app/api/v2/lib/response'
 
 export const dynamic = 'force-dynamic'
@@ -38,8 +37,8 @@ export const GET = defineV2JsonRoute({
     ),
   }),
   useCase: listWorkspaceFileVersions,
-  present: async ({ versions, nextKeys }, { params, query }) => ({
-    data: await toV2FileVersions(versions),
+  present: ({ versions, nextKeys }, { params, query }) => ({
+    data: versions.map(toFileVersion),
     nextCursor: writeSortedCursor(
       nextKeys,
       query.sortBy,
 
@@ -4,7 +4,7 @@ import { describe, expect, it, vi } from 'vitest'
 vi.mock('@/lib/users/queries', () => usersQueriesMock)
 
 import type { WorkspaceFileVersionRecord } from '@/lib/uploads/contexts/workspace/file-version-store'
-import { toV2FileVersions } from '@/app/api/v2/files/utils'
+import { toV2FileVersion } from '@/app/api/v2/files/utils'
 
 const { mockFindUserEmailsByIds } = usersQueriesMockFns
 
@@ -23,11 +23,11 @@ const version: WorkspaceFileVersionRecord = {
   supersededAt: null,
 }
 
-describe('toV2FileVersions', () => {
+describe('toV2FileVersion', () => {
   it('keeps authors whose accounts no longer exist, with a null email', async () => {
     mockFindUserEmailsByIds.mockResolvedValueOnce(new Map([['user-1', 'ada@example.com']]))
 
-    const [serialized] = await toV2FileVersions([version])
+    const serialized = await toV2FileVersion(version)
 
     expect(serialized.authors).toEqual([
       { id: 'user-1', email: 'ada@example.com' },
 
@@ -6,12 +6,10 @@ import { workspaceResourceWebUrl } from '@/lib/resources'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
 import { workspaceFileVfsPath } from '@/lib/uploads/contexts/workspace/file-manager'
 import type { WorkspaceFileVersionRecord } from '@/lib/uploads/contexts/workspace/file-version-store'
-import {
-  findUserEmailsByIds,
-  getUserEmailsByIds,
-  requireResolvedUserEmail,
-} from '@/lib/users/queries'
+import { getUserEmailsByIds, requireResolvedUserEmail } from '@/lib/users/queries'
+import { toFileVersion } from '@/lib/workspace-files/api'
 import type { ReadWorkspaceFileTextResult } from '@/lib/workspace-files/application/read-workspace-file-text'
+import { projectFileVersionAuthors } from '@/lib/workspace-files/application/version-authors'
 import { parseWorkspaceFileFolderDisplayPath } from '@/lib/workspace-files/folder-display-path'
 
 /** Shared serialization for the v2 files surface. */
@@ -93,34 +91,8 @@ export function toV2FileText({
   }
 }
 
-function serializeV2FileVersion(
-  record: WorkspaceFileVersionRecord,
-  emailByUserId: Map<string, string>
-): V2FileVersion {
-  return {
-    fileId: record.fileId,
-    version: record.version,
-    isCurrent: record.isCurrent,
-    size: record.size,
-    contentType: record.contentType,
-    source: record.source,
-    authors: record.authorUserIds.map((id) => ({ id, email: emailByUserId.get(id) ?? null })),
-    restoredFromVersion: record.restoredFromVersion,
-    createdAt: record.createdAt.toISOString(),
-    updatedAt: record.updatedAt.toISOString(),
-    supersededAt: record.supersededAt?.toISOString() ?? null,
-  }
-}
-
-/** Serializes file versions, resolving every author's email in one query. */
-export async function toV2FileVersions(
-  records: WorkspaceFileVersionRecord[]
-): Promise<V2FileVersion[]> {
-  const emailByUserId = await findUserEmailsByIds(records.flatMap((record) => record.authorUserIds))
-  return records.map((record) => serializeV2FileVersion(record, emailByUserId))
-}
-
+/** Serializes one version, resolving its authors' emails. */
 export async function toV2FileVersion(record: WorkspaceFileVersionRecord): Promise<V2FileVersion> {
-  const [version] = await toV2FileVersions([record])
-  return version
+  const [version] = await projectFileVersionAuthors([record])
+  return toFileVersion(version)
 }
@@ -103,8 +103,13 @@ describe('PUT /api/workspaces/[id]/files/[fileId]/content', () => {
     expect(mocks.updateContent).not.toHaveBeenCalled()
   })
 
+  /**
+   * The route declares a 70 MB inline cap, but Next's proxy truncates a client
+   * body past 10 MiB, so the parser clamps to that ceiling and answers 413
+   * rather than letting a truncated prefix surface as malformed JSON.
+   */
   it('rejects a JSON body above the proxy ceiling after admission', async () => {
-    const response = await PUT(createRequest({ content: '' }, 17 * 1024 * 1024 + 1), routeContext)
+    const response = await PUT(createRequest({ content: '' }, 10 * 1024 * 1024 + 1), routeContext)
 
     expect(response.status).toBe(413)
     expect(mocks.admit).toHaveBeenCalled()