fix(execution): tune the event offload threshold to the observed distribution

Set the buffered-event offload threshold from production data rather than the
budget arithmetic alone. Across 111k executions, bytes-per-trace-span runs
~4.8 KB at p50, ~59 KB at p90 and ~960 KB at p99, and no execution came within
3 MB of the 64 MiB budget. 256 KiB sits between p90 and p99, so ordinary runs
stay fully inline and only the outlier tail is offloaded — ~4% of executions,
against ~9% at 64 KiB and ~15% at 32 KiB.

Offloading costs fidelity: a ref renders as a 256-character preview, and for
arrays and objects as a shape summary rather than contents. Tuning to the
distribution keeps that off the 95% of runs that never threatened the budget.

Author: waleedlatif1

apps/sim/lib/execution/event-buffer.test.ts

@@ -376,7 +376,7 @@ describe('execution event buffer', () => {
   it('offloads values far below the shared large-value threshold', async () => {
     mockRedis.incrby.mockResolvedValue(100)
     // Comfortably under LARGE_VALUE_THRESHOLD_BYTES (8 MiB), over the event one.
-    const payload = 'x'.repeat(64 * 1024)
+    const payload = 'x'.repeat(512 * 1024)
 
     const writer = createExecutionEventWriter('exec-1', {
       workspaceId: 'ws-1',
@@ -387,7 +387,7 @@ describe('execution event buffer', () => {
 
     expect(persistedEntries).toHaveLength(1)
     const persistedBytes = Buffer.byteLength(JSON.stringify(persistedEntries[0]), 'utf8')
-    expect(persistedBytes).toBeLessThan(64 * 1024)
+    expect(persistedBytes).toBeLessThan(256 * 1024)
   })
 
   it('preserves requested UserFile base64 when buffering terminal events', async () => {

apps/sim/lib/execution/payloads/large-value-ref.ts

@@ -6,17 +6,28 @@ export const LARGE_VALUE_THRESHOLD_BYTES = 8 * 1024 * 1024
  * Offload threshold for values inlined into buffered execution events.
  *
  * The replay buffer keeps `EVENT_LIMIT` (1000) events per execution inside a
- * `MAX_EXECUTION_REDIS_BYTES` (64 MiB) budget, so a full ring buffer only fits
- * if events average under 64 KiB. Anything above that exhausts the budget
- * before the ring even fills and pins the run at its ceiling for the rest of
- * its life. This sits at half that ceiling because the budget counts a whole
- * event while the threshold caps one value, and an event can carry several.
+ * `MAX_EXECUTION_REDIS_BYTES` (64 MiB) budget. Values were offloaded at 8 MiB,
+ * so a run emitting large block outputs exhausted that budget within a few
+ * dozen events and stayed pinned at its ceiling for the rest of its life.
  *
- * Deliberately far below {@link LARGE_VALUE_THRESHOLD_BYTES}, which stays at
- * 8 MiB for executor snapshots and inline UserFile base64 — those are bounded
- * per payload rather than accumulated across a thousand of them.
+ * Chosen from the observed distribution of bytes-per-trace-span across 111k
+ * production executions: p50 ~4.8 KB, p90 ~59 KB, p99 ~960 KB. This sits 4x
+ * above p90 and 4x below p99, so ordinary runs stay fully inline and only the
+ * outlier tail — the shape that exhausts the budget — is offloaded. It applies
+ * to ~4% of executions, against ~9% at 64 KiB and ~15% at 32 KiB.
+ *
+ * Offloading is not free: a ref renders in the terminal as a 256-character
+ * string preview, or for arrays and objects as a shape summary rather than
+ * their contents. That cost is why this tracks the real distribution instead of
+ * the 64 KiB the budget arithmetic alone would suggest — no execution in that
+ * sample came within 3 MB of the budget.
+ *
+ * Deliberately separate from {@link LARGE_VALUE_THRESHOLD_BYTES}, which stays
+ * at 8 MiB for executor snapshots and inline UserFile base64. Those are bounded
+ * per payload rather than accumulated across a thousand of them, and the base64
+ * limit is derived from it arithmetically.
  */
-export const EXECUTION_EVENT_VALUE_THRESHOLD_BYTES = 32 * 1024
+export const EXECUTION_EVENT_VALUE_THRESHOLD_BYTES = 256 * 1024
 export const LARGE_VALUE_REF_VERSION = 1
 
 export const LARGE_VALUE_KINDS = ['array', 'object', 'string', 'json'] as const