fix(mothership): keep omitting bulk until an event fits one replay write

A result with more than one large object of short fields left the second
one over the write limit after the first was omitted, so the event was
refused and the turn ended. Omission now repeats until the event fits or
nothing large enough is left; each pass removes at least 64 KiB, so it
always terminates.

Author: waleedlatif1

apps/sim/lib/mothership/request/session/replay-compaction.test.ts

@@ -296,6 +296,36 @@ describe('compactStreamEvent', () => {
     })
   })
 
+  it('keeps omitting bulk until the event fits when more than one large object remains', () => {
+    const manyKeys = (prefix: string, count: number) =>
+      Object.fromEntries(
+        Array.from({ length: count }, (_, index) => [`${prefix}-${index}`, 'v'.repeat(300)])
+      )
+    const event: StreamEvent = {
+      type: 'tool',
+      payload: {
+        toolCallId: 'c',
+        toolName: 'cli_workflows_state_get',
+        executor: 'sim',
+        mode: 'async',
+        phase: 'result',
+        success: true,
+        status: 'success',
+        output: { workflowId: 'wf-1', a: manyKeys('a', 4_300), b: manyKeys('b', 3_600) },
+      },
+    }
+
+    const compacted = payloadOf(compactStreamEvent(event))
+    const output = toRecord(compacted.output)
+
+    expect(Buffer.byteLength(JSON.stringify(compacted))).toBeLessThanOrEqual(
+      STREAM_EVENT_MAX_PAYLOAD_BYTES
+    )
+    expect(output.workflowId).toBe('wf-1')
+    expect(output.a).toMatch(/^…\[omitted, [\d.]+ MB total\]$/)
+    expect(output.b).toMatch(/^…\[omitted, [\d.]+ MB total\]$/)
+  })
+
   it('never omits identity to make room for client-executed arguments it must keep whole', () => {
     const args = { workflowId: 'wf-1', input: 'w'.repeat(1.5 * MB) }
     const event: StreamEvent = {

apps/sim/lib/mothership/request/session/replay-compaction.ts

@@ -168,7 +168,8 @@ function omitDominantBulk(payload: Record<string, unknown>, skipKeys: ReadonlySe
  * only to the copy the writer delivers and persists; the caller keeps the full
  * event for dispatch. Long strings are cut to their head in place, so every
  * object keeps its shape; if that is not enough, long arrays keep their head,
- * and past one replay write the dominating bulk is replaced by a size note.
+ * and past one replay write each dominating bulk is replaced by a size note
+ * until the event fits.
  * Assistant text, file previews, and the arguments of calls the browser
  * executes are never cut; an event
  * still too large is refused by the buffer, which ends the turn with an error.
@@ -190,8 +191,12 @@ export function compactStreamEvent(event: StreamEvent): StreamEvent {
   if (Buffer.byteLength(JSON.stringify(compacted)) > STREAM_EVENT_COMPACTION_THRESHOLD_BYTES) {
     compacted = trimArrays(compacted, skipKeys)
   }
-  if (Buffer.byteLength(JSON.stringify(compacted)) > STREAM_EVENT_MAX_PAYLOAD_BYTES) {
-    compacted = omitDominantBulk(toRecordOrNull(compacted) ?? {}, skipKeys)
+  // Each pass replaces at least OMITTABLE_FIELD_MIN_BYTES, and stops when nothing is left to omit.
+  while (Buffer.byteLength(JSON.stringify(compacted)) > STREAM_EVENT_MAX_PAYLOAD_BYTES) {
+    const record = toRecordOrNull(compacted) ?? {}
+    const omitted = omitDominantBulk(record, skipKeys)
+    if (omitted === record) break
+    compacted = omitted
   }
   return compacted === payload ? event : ({ ...event, payload: compacted } as StreamEvent)
 }