@@ -16,10 +16,13 @@ import {
  * (scope `active`), so the browser paints populated on first render.
  *
  * The FILE LIST itself is deliberately not here: the sidebar reads it on every workspace route, so
- * it is prefetched by `prefetchWorkspaceSidebar` in the layout — the only boundary that renders
+ * it is seeded by `prefetchWorkspaceSidebar` in the layout — the only boundary that renders
  * before the sidebar registers the query. Prefetching it again here would re-read it per request
  * and still not reach the server render (`HydrationBoundary` defers an already-seen query to an
- * effect, which SSR never runs). See the note on that entry.
+ * effect, which SSR never runs). See the note on that entry. The layout declines to seed a
+ * workspace whose file list exceeds its payload budget; recovering those here would mean
+ * mirroring that budget check inversely, since an unconditional prefetch would re-read and
+ * duplicate the entry for every workspace under the budget.
  *
  * Folders and the chrome reads all go through the data layer, shaped to their route contracts so a
  * hydrated entry matches a client fetch.
 
@@ -97,7 +97,10 @@ vi.mock('@sim/emcn', () => ({
 
 import { prefetchFilesBrowser } from '@/app/workspace/[workspaceId]/files/prefetch'
 import { prefetchKnowledgeBases } from '@/app/workspace/[workspaceId]/knowledge/prefetch'
-import { prefetchWorkspaceSidebar } from '@/app/workspace/[workspaceId]/prefetch'
+import {
+  prefetchWorkspaceSidebar,
+  WORKSPACE_FILE_SEED_MAX,
+} from '@/app/workspace/[workspaceId]/prefetch'
 import { prefetchTables } from '@/app/workspace/[workspaceId]/tables/prefetch'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { knowledgeKeys } from '@/hooks/queries/utils/knowledge-keys'
@@ -510,6 +513,55 @@ describe('workspace list prefetches', () => {
       expect(client.getQueryData(workspaceKeys.list('active'))).toBeUndefined()
     })
 
+    /**
+     * The file list is seeded on every workspace route, so it is the one entry whose size
+     * scales with a workspace's content on routes that never read it. It is read one row
+     * past the budget so the overflow is detectable.
+     */
+    it('seeds the file list, bounded by the document payload budget', async () => {
+      const files = [{ id: 'file-1', name: 'a.txt' }]
+      mockListWorkspaceFilesWithShares.mockResolvedValue(files)
+      const client = makeClient()
+
+      await prefetchWorkspaceSidebar(client, WORKSPACE_ID, USER_ID, HOST_CONTEXT, null)
+
+      expect(mockListWorkspaceFilesWithShares).toHaveBeenCalledWith(WORKSPACE_ID, 'active', {
+        limit: WORKSPACE_FILE_SEED_MAX + 1,
+      })
+      expect(client.getQueryData(workspaceFilesKeys.list(WORKSPACE_ID, 'active'))).toEqual(files)
+    })
+
+    /**
+     * The load-bearing half of the budget: a workspace over it seeds NOTHING rather than the
+     * prefix it read. The sidebar search filters this list client-side and the Files browser
+     * renders it as the workspace's files, so a truncated seed would silently hide files —
+     * the client fetch must reach the route for the complete list instead.
+     */
+    it('seeds nothing when the workspace exceeds the budget', async () => {
+      mockListWorkspaceFilesWithShares.mockResolvedValue(
+        Array.from({ length: WORKSPACE_FILE_SEED_MAX + 1 }, (_, index) => ({
+          id: `file-${index}`,
+          name: `${index}.txt`,
+        }))
+      )
+      const client = makeClient()
+
+      await prefetchWorkspaceSidebar(client, WORKSPACE_ID, USER_ID, HOST_CONTEXT, null)
+
+      expect(client.getQueryData(workspaceFilesKeys.list(WORKSPACE_ID, 'active'))).toBeUndefined()
+    })
+
+    /** A failed file read is an optimization loss, not a render failure. */
+    it('does not throw when the file read rejects, and seeds no files', async () => {
+      mockListWorkspaceFilesWithShares.mockRejectedValue(new Error('500'))
+      const client = makeClient()
+
+      await expect(
+        prefetchWorkspaceSidebar(client, WORKSPACE_ID, USER_ID, HOST_CONTEXT, null)
+      ).resolves.toBeUndefined()
+      expect(client.getQueryData(workspaceFilesKeys.list(WORKSPACE_ID, 'active'))).toBeUndefined()
+    })
+
     /** Guards the mismatch check that keeps one workspace's data out of another's cache. */
     it('seeds nothing when the host context is for a different workspace', async () => {
       mockListWorkspacesForViewer.mockResolvedValue(LIST_PAYLOAD)
 
@@ -25,10 +25,7 @@ import { workflowKeys } from '@/hooks/queries/utils/workflow-keys'
 import { mapWorkflow, WORKFLOW_LIST_STALE_TIME } from '@/hooks/queries/utils/workflow-list-query'
 import { normalizeWorkspacesResponse } from '@/hooks/queries/utils/workspace-list-query'
 import { WORKSPACE_PERMISSIONS_STALE_TIME, workspaceKeys } from '@/hooks/queries/workspace'
-import {
-  WORKSPACE_FILES_LIST_STALE_TIME,
-  workspaceFilesKeys,
-} from '@/hooks/queries/workspace-files'
+import { workspaceFilesKeys } from '@/hooks/queries/workspace-files'
 import {
   WORKSPACE_HOST_CONTEXT_STALE_TIME,
   workspaceHostKeys,
@@ -95,6 +92,56 @@ async function seedWorkspaceList(
   }
 }
 
+/**
+ * How many files the layout is willing to inline into the document.
+ *
+ * The file list is seeded on EVERY workspace route (see the call site), so its cost is
+ * paid per navigation into the app, not per visit to Files. At roughly 500 bytes of
+ * serialized JSON per file, this budgets the entry at ~150 KB; a workspace with
+ * thousands of files would otherwise push more than a megabyte of HTML ahead of first
+ * paint on the logs, settings, and editor routes that never read it.
+ *
+ * The read is capped at one row past the budget purely to detect the overflow. A
+ * workspace above it seeds NOTHING rather than a prefix: the sidebar search filters this
+ * list client-side and the Files browser renders it as the workspace's files, so a
+ * truncated seed would silently hide files. Those workspaces fetch the complete list
+ * from the route instead — which for a list that large is also the cheaper first paint.
+ */
+export const WORKSPACE_FILE_SEED_MAX = 300
+
+/**
+ * Seeds the workspace's file list, which the sidebar's search modal reads on EVERY
+ * workspace route — so this query is registered by sidebar chrome before any page
+ * renders. That ordering is why it has to be seeded HERE and not only by the Files
+ * pages: `HydrationBoundary` hydrates a query the cache has already seen from a
+ * `useEffect`, which never runs during SSR, so a page-level boundary can only ever hand
+ * this entry to the client. Seeding it with the layout's own boundary — the first one to
+ * render — is what lets the server paint the Files browser and the open file's header
+ * populated instead of shipping a spinner and resolving it a beat later on the client.
+ *
+ * Seeded rather than prefetched so it can decline to create an entry at all when the
+ * workspace exceeds {@link WORKSPACE_FILE_SEED_MAX}: `prefetchQuery` always creates one,
+ * and a partial one would be read as the whole list.
+ *
+ * The shape comes from the same contract-parsed reader `GET /api/workspaces/[id]/files`
+ * responds with, so a seeded entry is identical to what the client hook would cache.
+ */
+async function seedWorkspaceFiles(queryClient: QueryClient, workspaceId: string): Promise<void> {
+  try {
+    const files = await listWorkspaceFilesWithShares(workspaceId, 'active', {
+      limit: WORKSPACE_FILE_SEED_MAX + 1,
+    })
+    if (files.length > WORKSPACE_FILE_SEED_MAX) return
+    queryClient.setQueryData(workspaceFilesKeys.list(workspaceId, 'active'), files)
+  } catch (error) {
+    /** Optimization only: the client fetch reaches the route instead. Logged so drift between
+     * this read and the contract's response schema doesn't degrade silently into a waterfall. */
+    logger.warn('Workspace file list seed failed; client will fetch', {
+      error: getErrorMessage(error),
+    })
+  }
+}
+
 /**
  * Prefetches the sidebar's workflow, chat, folder, workspace-permissions,
  * workspace, and viewer-profile reads for a workspace and stores them under the
@@ -153,22 +200,7 @@ export async function prefetchWorkspaceSidebar(
         ]
       : []),
     prefetchResourceFolders(queryClient, workspaceId, 'workflow', userId),
-    /**
-     * The sidebar reads the workspace's files for its search modal, on EVERY workspace route — so this
-     * query is registered by sidebar chrome before any page renders. That ordering is why it has to be
-     * prefetched HERE and not only by the Files pages: `HydrationBoundary` hydrates a query the cache
-     * has already seen from a `useEffect`, which never runs during SSR, so a page-level boundary can
-     * only ever hand this entry to the client. Seeding it with the layout's own boundary — the first
-     * one to render — is what lets the server paint the Files browser and the open file's header
-     * populated instead of shipping a spinner and resolving it a beat later on the client.
-     *
-     * Same key + shape as {@link prefetchFilesBrowser}, so whichever runs is a no-op for the other.
-     */
-    queryClient.prefetchQuery({
-      queryKey: workspaceFilesKeys.list(workspaceId, 'active'),
-      queryFn: () => listWorkspaceFilesWithShares(workspaceId, 'active'),
-      staleTime: WORKSPACE_FILES_LIST_STALE_TIME,
-    }),
+    seedWorkspaceFiles(queryClient, workspaceId),
     queryClient.prefetchQuery({
       queryKey: workspaceKeys.permissions(workspaceId),
       queryFn: () =>
 
@@ -161,6 +161,12 @@ interface ListWorkspaceFilesOptions {
   hydrateFolderPaths?: boolean
   /** Propagate storage errors when an incomplete list would be unsafe. */
   throwOnError?: boolean
+  /**
+   * Row cap for callers that only need to know whether the workspace fits a budget.
+   * The result is a prefix of the full list, so a caller that reads it as "the
+   * workspace's files" must not set this.
+   */
+  limit?: number
 }
 
 /**
@@ -223,7 +229,9 @@ interface WorkspaceFileMetadataInsert {
   size: number
 }
 
-function workspaceFileSize(file: typeof workspaceFiles.$inferSelect): number {
+function workspaceFileSize(
+  file: Pick<typeof workspaceFiles.$inferSelect, 'size' | 'sizeBytes'>
+): number {
   return file.sizeBytes ?? file.size
 }
 
@@ -1007,7 +1015,7 @@ export async function fileExistsInWorkspace(
 }
 
 function mapWorkspaceFileRecord(
-  file: typeof workspaceFiles.$inferSelect,
+  file: WorkspaceFileListRow,
   workspaceId: string,
   folderPaths: Map<string, string>
 ): WorkspaceFileRecord {
@@ -1144,9 +1152,40 @@ function workspaceFileScopeCondition(workspaceId: string, scope: WorkspaceFileSc
     : and(...base, isNull(workspaceFiles.deletedAt))
 }
 
+/**
+ * The columns {@link mapWorkspaceFileRecord} actually reads. The list reads below are
+ * workspace-wide, so `select()` would pull five columns no reader projects — `context`,
+ * `chatId`, `messageId`, `displayName`, `secretProvenanceVersion` — for every row of the
+ * scan. Narrowing here is invisible on the wire (the route contract already strips them)
+ * and cuts what the database ships per row.
+ */
+const workspaceFileListColumns = {
+  id: workspaceFiles.id,
+  key: workspaceFiles.key,
+  userId: workspaceFiles.userId,
+  workspaceId: workspaceFiles.workspaceId,
+  folderId: workspaceFiles.folderId,
+  originalName: workspaceFiles.originalName,
+  contentType: workspaceFiles.contentType,
+  size: workspaceFiles.size,
+  sizeBytes: workspaceFiles.sizeBytes,
+  width: workspaceFiles.width,
+  height: workspaceFiles.height,
+  deletedAt: workspaceFiles.deletedAt,
+  uploadedAt: workspaceFiles.uploadedAt,
+  updatedAt: workspaceFiles.updatedAt,
+  contentUpdatedAt: workspaceFiles.contentUpdatedAt,
+} as const
+
+/** A row carrying exactly the columns {@link mapWorkspaceFileRecord} needs; a full row satisfies it. */
+type WorkspaceFileListRow = Pick<
+  typeof workspaceFiles.$inferSelect,
+  keyof typeof workspaceFileListColumns
+>
+
 /** Resolves `folderPath` for a page of rows, reading the folder tree only if any row needs it. */
 async function hydrateWorkspaceFilePaths(
-  files: (typeof workspaceFiles.$inferSelect)[],
+  files: WorkspaceFileListRow[],
   workspaceId: string,
   options?: { folders?: WorkspaceFileFolderRecord[]; hydrateFolderPaths?: boolean }
 ): Promise<WorkspaceFileRecord[]> {
@@ -1167,12 +1206,13 @@ export async function listWorkspaceFiles(
   options?: ListWorkspaceFilesOptions
 ): Promise<WorkspaceFileRecord[]> {
   try {
-    const { scope = 'active' } = options ?? {}
-    const files = await db
-      .select()
+    const { scope = 'active', limit } = options ?? {}
+    const query = db
+      .select(workspaceFileListColumns)
       .from(workspaceFiles)
       .where(workspaceFileScopeCondition(workspaceId, scope))
       .orderBy(workspaceFiles.uploadedAt)
+    const files = await (limit === undefined ? query : query.limit(limit))
 
     return hydrateWorkspaceFilePaths(files, workspaceId, options)
   } catch (error) {
@@ -1265,7 +1305,7 @@ export async function queryWorkspaceFiles(
   ]
 
   const rows = await db
-    .select()
+    .select(workspaceFileListColumns)
     .from(workspaceFiles)
     .where(and(...conditions))
     .orderBy(...listOrderBy(keysetColumns(keys), sortOrder))
 
@@ -46,7 +46,10 @@ vi.mock('@/lib/uploads/contexts/workspace/workspace-file-folder-manager', () =>
   resolveWorkspaceFileFolderTarget: vi.fn(async () => null),
 }))
 
-import { queryWorkspaceFiles } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import {
+  listWorkspaceFiles,
+  queryWorkspaceFiles,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 
 const WS = 'workspace-1'
 
@@ -205,3 +208,52 @@ describe('queryWorkspaceFiles', () => {
     ).rejects.toMatchObject({ code: 'validation' })
   })
 })
+
+/**
+ * `listWorkspaceFiles` materializes a whole scope, so what it reads per row is
+ * multiplied by the size of the workspace. These assertions pin the two ways that
+ * stays bounded: the projection, and the optional row cap its one budgeted caller
+ * (the workspace layout's server seed) uses to detect an oversized workspace.
+ */
+describe('listWorkspaceFiles', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+  })
+
+  const lastProjection = () =>
+    Object.keys((dbChainMockFns.select.mock.calls.at(-1)?.[0] ?? {}) as Record<string, unknown>)
+
+  it('projects only the columns the record mapper reads', async () => {
+    queueTableRows(schemaMock.workspaceFiles, [buildRow()])
+
+    await listWorkspaceFiles(WS)
+
+    const projected = lastProjection()
+    expect(projected).toEqual(
+      expect.arrayContaining(['id', 'key', 'originalName', 'sizeBytes', 'contentUpdatedAt'])
+    )
+    /** Columns no reader projects; `select()` would ship them for every row of the scan. */
+    expect(projected).not.toContain('context')
+    expect(projected).not.toContain('chatId')
+    expect(projected).not.toContain('messageId')
+    expect(projected).not.toContain('displayName')
+    expect(projected).not.toContain('secretProvenanceVersion')
+  })
+
+  it('reads the whole scope when no cap is given', async () => {
+    queueTableRows(schemaMock.workspaceFiles, [buildRow()])
+
+    await listWorkspaceFiles(WS)
+
+    expect(dbChainMockFns.limit).not.toHaveBeenCalled()
+  })
+
+  it('caps the rows read when the caller only needs to fit a budget', async () => {
+    queueTableRows(schemaMock.workspaceFiles, [buildRow()])
+
+    await listWorkspaceFiles(WS, { limit: 2 })
+
+    expect(dbChainMockFns.limit).toHaveBeenCalledWith(2)
+  })
+})
@@ -15,10 +15,18 @@ import {
  * to a client fetch rather than carrying a field that vanishes on the next refetch.
  *
  * Callers authorize the viewer against `workspaceId` first.
+ *
+ * `limit` caps the rows read for callers that only need to know whether the workspace fits
+ * a payload budget; the result is then a prefix of the list, not the list, so no caller may
+ * present a limited read as the workspace's files.
  */
-export async function listWorkspaceFilesWithShares(workspaceId: string, scope: WorkspaceFileScope) {
+export async function listWorkspaceFilesWithShares(
+  workspaceId: string,
+  scope: WorkspaceFileScope,
+  options?: { limit?: number }
+) {
   const [files, shares] = await Promise.all([
-    listWorkspaceFiles(workspaceId, { scope }),
+    listWorkspaceFiles(workspaceId, { scope, limit: options?.limit }),
     getWorkspaceShares('file', workspaceId),
   ])
   const withShares = files.map((file) => ({ ...file, share: shares.get(file.id) ?? null }))