@@ -648,6 +648,26 @@ async function streamDirectR2Deploy(
   cliLog?: CliLogger,
 ): Promise<StreamDeployResult> {
   if (needed.length > 0) {
+    // Memory: drop buffers for assets the server already has so peak
+    // memory tracks `needed`, not the full bundle. Skipped entries become
+    // GC-eligible immediately rather than after `finalizeDeploy` returns.
+    // The pre-prune size is captured for the JSONL log only. We materialize
+    // the key list before deleting so the iterator isn't disturbed mid-walk.
+    const neededPaths = new Set(needed);
+    const preBufferCount = assetFiles.size;
+    const allPaths = Array.from(assetFiles.keys());
+    for (const path of allPaths) {
+      if (!neededPaths.has(path)) {
+        assetFiles.delete(path);
+      }
+    }
+    if (assetFiles.size !== preBufferCount) {
+      cliLog?.info('asset_cache_pruned', {
+        before: preBufferCount,
+        after: assetFiles.size,
+      });
+    }
+
     s.message(`Requesting upload URLs for ${needed.length} asset(s)...`);
 
     const assetsToUpload = needed.map((path) => {
@@ -704,7 +724,12 @@ async function streamDirectR2Deploy(
     });
 
     s.message(`Uploading ${items.length} asset(s) to R2...`);
-    await uploadAssetsToR2(items, cliLog);
+    // Per-PUT cleanup: once R2 acks the upload, drop the buffer from the
+    // CLI-side cache so peak memory under the bounded upload pool stays
+    // close to `R2_PUT_CONCURRENCY` × asset size, not the full bundle.
+    await uploadAssetsToR2(items, cliLog, undefined, (item) => {
+      assetFiles.delete(item.path);
+    });
   } else {
     cliLog?.info('presign_skipped', { reason: 'no_needed_assets' });
   }
 
@@ -47,8 +47,13 @@ export interface DirectR2PutItem {
   path: string;
   /** BLAKE3 storage hash — used for log correlation and R2 key. */
   hash: string;
-  /** Asset bytes. */
-  body: Buffer;
+  /**
+   * Asset bytes. Cleared (set to `undefined`) by `uploadAssetsToR2` after a
+   * successful PUT so the buffer becomes eligible for GC as soon as the
+   * upload is acknowledged. Callers should not read `body` after the upload
+   * completes.
+   */
+  body: Buffer | undefined;
   /** Presigned URL from `requestUploadUrls`. */
   url: string;
   /** Headers the platform required us to send (incl. Content-Md5, Content-Type). */
@@ -63,11 +68,17 @@ export interface DirectR2PutItem {
  *
  * Logs `r2_put_start` / `r2_put_end` per asset, plus `r2_put_retry` on
  * each retry attempt. Per-asset durations help identify slow uploads.
+ *
+ * Memory: each successful PUT clears `item.body` and invokes `onAfterPut`
+ * so the caller can drop its own ref (e.g. delete from the in-memory
+ * `assetFiles` cache). For huge deploys this keeps peak memory bounded by
+ * the upload concurrency rather than the total bundle size.
  */
 export async function uploadAssetsToR2(
   items: Array<DirectR2PutItem>,
   cliLog: CliLogger | undefined,
   fetchImpl: typeof fetch = fetch,
+  onAfterPut?: (item: DirectR2PutItem) => void,
 ): Promise<void> {
   if (items.length === 0) {
     return;
@@ -97,6 +108,12 @@ export async function uploadAssetsToR2(
             }
             return;
           }
+          // Drop refs to the asset bytes now that R2 has them. Both the
+          // local `body` ref on the item and any caller-side ref (via
+          // `onAfterPut`) are released so the buffer becomes eligible
+          // for GC under bounded concurrency.
+          items[i].body = undefined;
+          onAfterPut?.(items[i]);
         }
       })(),
     );
@@ -112,11 +129,18 @@ async function uploadOne(
   cliLog: CliLogger | undefined,
   fetchImpl: typeof fetch,
 ): Promise<void> {
+  // Capture the body up-front. The pool only clears `item.body` AFTER
+  // `uploadOne` returns successfully, so it is guaranteed defined here for
+  // all attempts of this single PUT.
+  if (!item.body) {
+    throw new Error(`internal: uploadOne invoked for ${item.path} with no body`);
+  }
+  const body = item.body;
   const startedAt = Date.now();
   cliLog?.info('r2_put_start', {
     hash: item.hash,
     path: item.path,
-    sizeBytes: item.body.length,
+    sizeBytes: body.length,
   });
 
   let attempt = 0;
@@ -128,7 +152,7 @@ async function uploadOne(
         // Clone the buffer into a fresh Uint8Array view so each retry sees
         // an independent body. Reusing the same Buffer across retries is
         // safe with `fetch` (it consumes once), but explicit here.
-        body: new Uint8Array(item.body) as unknown as BodyInit,
+        body: new Uint8Array(body) as unknown as BodyInit,
         headers: item.headers,
       });
     } catch (err) {
 
@@ -324,6 +324,83 @@ describe('direct-to-R2 deploy flow', () => {
     expect(uniquePaths.size).toBe(4);
   });
 
+  it('prunes the in-memory assetFiles cache to needed-only after preflight', async () => {
+    // 4 fixture assets, only 1 needed: pruning should drop 3 buffers
+    // immediately after preflight, and the per-PUT cleanup should drop
+    // the last one once R2 acks the upload. We assert via the JSONL log,
+    // which captures both the pre/post-prune sizes (`asset_cache_pruned`)
+    // and the upload events (`r2_put_end`).
+    installPlatformMocks({
+      preflightNeeded: ['/index.html'],
+      preflightSkipped: 3,
+    });
+    const cliLog = openDeployLog();
+    const logPath = cliLog.path;
+    expect(logPath).toBeTruthy();
+    const client = new PlatformClient('test-token', { apiUrl: 'https://api.test', cliLog });
+
+    await runStaticDeploy(
+      workdir,
+      { projectId: 'proj_t', slug: 'test' },
+      client,
+      { buildCommand: null, outputDir: assetsDir, appType: 'spa' },
+      true,
+      null,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      cliLog,
+      false,
+    );
+
+    await cliLog.close();
+    const lines = readFileSync(logPath as string, 'utf-8')
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l) as { msg: string; before?: number; after?: number });
+    const prune = lines.find((l) => l.msg === 'asset_cache_pruned');
+    expect(prune).toBeDefined();
+    // Before prune: 4 fixture buffers in the cache. After: 1 (the only
+    // needed asset). Per-PUT cleanup runs after this event so the log
+    // value here is the post-prune-but-pre-PUT size.
+    expect(prune?.before).toBe(4);
+    expect(prune?.after).toBe(1);
+  });
+
+  it('does not log asset_cache_pruned when nothing was skipped', async () => {
+    // All 4 needed → prune is a no-op and we suppress the noisy log.
+    installPlatformMocks();
+    const cliLog = openDeployLog();
+    const logPath = cliLog.path;
+    expect(logPath).toBeTruthy();
+    const client = new PlatformClient('test-token', { apiUrl: 'https://api.test', cliLog });
+
+    await runStaticDeploy(
+      workdir,
+      { projectId: 'proj_t', slug: 'test' },
+      client,
+      { buildCommand: null, outputDir: assetsDir, appType: 'spa' },
+      true,
+      null,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      cliLog,
+      false,
+    );
+
+    await cliLog.close();
+    const lines = readFileSync(logPath as string, 'utf-8')
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l) as { msg: string });
+    expect(lines.find((l) => l.msg === 'asset_cache_pruned')).toBeUndefined();
+  });
+
   it('skips upload-urls + R2 PUT phase when no assets are needed', async () => {
     const state = installPlatformMocks({ preflightNeeded: [], preflightSkipped: 4 });
     const client = makeClient();
 
@@ -160,4 +160,37 @@ describe('uploadAssetsToR2', () => {
     });
     expect(fetchMock).toHaveBeenCalledTimes(4);
   });
+
+  it('clears item.body and invokes onAfterPut after each successful PUT', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
+    const items = [makeItem('/a.html', 'h1'), makeItem('/b.css', 'h2'), makeItem('/c.js', 'h3')];
+    const seen: Array<string> = [];
+
+    await uploadAssetsToR2(items, cliLog, fetchMock, (item) => {
+      // body must already be cleared by the time the callback runs so the
+      // caller does not have to inspect it.
+      expect(item.body).toBeUndefined();
+      seen.push(item.path);
+    });
+
+    // Every item invoked the callback exactly once, with body cleared.
+    expect(seen.sort()).toEqual(['/a.html', '/b.css', '/c.js']);
+    for (const item of items) {
+      expect(item.body).toBeUndefined();
+    }
+  });
+
+  it('does not invoke onAfterPut when the PUT fails', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response('SignatureMismatch', { status: 403 }));
+    const item = makeItem('/oops.html', 'h-oops');
+    const onAfterPut = vi.fn();
+
+    await expect(uploadAssetsToR2([item], cliLog, fetchMock, onAfterPut)).rejects.toBeDefined();
+
+    // Failed upload must not signal "done" via the cleanup hook — callers
+    // depend on this to avoid prematurely dropping refs they may need to
+    // re-presign / retry against in a future iteration.
+    expect(onAfterPut).not.toHaveBeenCalled();
+    expect(item.body).toBeDefined();
+  });
 });