fix(bench): close the eight gaps the benchmark self-audit surfaced

Scoring OpenCodex against its own sixteen benchmark categories exposed
holes the phase reviews had each individually accepted: bodies were
admitted after allocation, management routes parsed unbounded JSON,
preflight heartbeats accumulated without cap, spill publication never
fsynced the directory entry, the provider and crash rings lacked
boundary tests, the periodic sweeper missed the continuation and replay
stores, a stale Grok flight could block applies until it settled, the
pinned headroom above the eviction target had no proven ceiling, and a
timed-out ACL hardening still published the secret. All eight now have
finite contracts with boundary tests, including a 512 MiB worst-case
pinned ceiling computed from the per-store caps themselves.

Author: lidge-jun

src/adapters/anthropic-image-normalize.ts

@@ -99,7 +99,7 @@ type ProcessResult =
  * not entry count. Entries are immutable snapshots — demotions write NEW tier-suffixed
  * keys, never mutate stored values.
  */
-const CACHE_BYTE_CAP = 64 * MiB;
+export const IMAGE_NORMALIZE_CACHE_MAX_BYTES = 64 * MiB;
 const CACHE_MAX_ENTRIES = 4_096;
 const CACHE_MAX_ENTRY_BYTES = 20 * MiB;
 // "pass" = validated pass-through; "miss" = this position's ladder cannot meet its hard
@@ -117,7 +117,7 @@ interface NormalizeCacheLimits {
   maxEntryBytes: number;
 }
 const DEFAULT_CACHE_LIMITS: NormalizeCacheLimits = {
-  maxBytes: CACHE_BYTE_CAP,
+  maxBytes: IMAGE_NORMALIZE_CACHE_MAX_BYTES,
   maxEntries: CACHE_MAX_ENTRIES,
   maxEntryBytes: CACHE_MAX_ENTRY_BYTES,
 };

src/adapters/cursor/framing.ts

@@ -31,6 +31,13 @@ interface CopyReservation {
   release(): void;
 }
 
+interface InspectedConnectFrame {
+  flags: number;
+  length: number;
+  payloadStart: number;
+  readBytes: number;
+}
+
 export class ConnectFrameError extends Error {
   constructor(
     public readonly code: ConnectFrameErrorCode,
@@ -77,36 +84,26 @@ export function tryDecodeConnectFrame(
   reservePayloadCopy?: (bytes: number) => CopyReservation | undefined,
 ): DecodedConnectFrame | null {
   assertOffset(input, offset);
-  if (input.length - offset < CONNECT_FRAME_HEADER_BYTES) return null;
-
-  const view = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset);
-  const flags = view.getUint8(0);
-  const length = view.getUint32(1, false);
-  if (length > maxPayloadBytes) {
-    throw new ConnectFrameError("payload_too_large", `Connect frame payload too large: ${length}`);
-  }
-  const readBytes = CONNECT_FRAME_HEADER_BYTES + length;
-  if (input.length - offset < readBytes) return null;
-
-  const payloadStart = offset + CONNECT_FRAME_HEADER_BYTES;
-  const payloadEnd = payloadStart + length;
-  const reservation = reservePayloadCopy?.(length);
+  const inspected = inspectConnectFrame(input, offset, maxPayloadBytes);
+  if (!inspected) return null;
+  const payloadEnd = inspected.payloadStart + inspected.length;
+  const reservation = reservePayloadCopy?.(inspected.length);
   let payload: Uint8Array;
   try {
-    payload = input.slice(payloadStart, payloadEnd);
+    payload = input.slice(inspected.payloadStart, payloadEnd);
     reservation?.commitRetained();
   } catch (error) {
     reservation?.release();
     throw error;
   }
   return {
     frame: {
-      flags,
+      flags: inspected.flags,
       payload,
-      compressed: isConnectFrameCompressed(flags),
-      endStream: isConnectFrameEndStream(flags),
+      compressed: isConnectFrameCompressed(inspected.flags),
+      endStream: isConnectFrameEndStream(inspected.flags),
     },
-    readBytes,
+    readBytes: inspected.readBytes,
   };
 }
 
@@ -135,28 +132,57 @@ export function decodeAvailableConnectFrames(
   availableFrameSlots = Number.POSITIVE_INFINITY,
   reservePayloadCopy?: (bytes: number) => CopyReservation | undefined,
 ): DecodedConnectFrames {
-  const frames: ConnectFrame[] = [];
+  const planned: Array<InspectedConnectFrame & { reservation?: CopyReservation }> = [];
   let offset = 0;
-  while (offset < input.length && frames.length < availableFrameSlots) {
-    const decoded = tryDecodeConnectFrame(input, offset, maxPayloadBytes, reservePayloadCopy);
-    if (!decoded) break;
-    frames.push(decoded.frame);
-    offset += decoded.readBytes;
-  }
-  const remainderBytes = offset === input.length ? 0 : bufferedPayloadBytes(input, offset);
-  const remainderReservation = reservePayloadCopy?.(remainderBytes);
-  let remainder: Uint8Array;
+  let remainderReservation: CopyReservation | undefined;
   try {
-    remainder = offset === input.length ? new Uint8Array() : input.slice(offset);
+    while (offset < input.length && planned.length < availableFrameSlots) {
+      const inspected = inspectConnectFrame(input, offset, maxPayloadBytes);
+      if (!inspected) break;
+      const reservation = reservePayloadCopy?.(inspected.length);
+      planned.push({ ...inspected, reservation });
+      offset += inspected.readBytes;
+    }
+    const remainderBytes = offset === input.length ? 0 : bufferedPayloadBytes(input, offset);
+    remainderReservation = reservePayloadCopy?.(remainderBytes);
+
+    // Keep every reservation transient until every batch allocation succeeds. A later admission
+    // failure can then roll the entire batch back without needing ownership of unreturned frames.
+    const frames = planned.map(({ flags, length, payloadStart }) => {
+      const payload = input.slice(payloadStart, payloadStart + length);
+      return {
+        flags,
+        payload,
+        compressed: isConnectFrameCompressed(flags),
+        endStream: isConnectFrameEndStream(flags),
+      };
+    });
+    const remainder = offset === input.length ? new Uint8Array() : input.slice(offset);
+    for (const entry of planned) entry.reservation?.commitRetained();
     remainderReservation?.commitRetained();
+    return { frames, remainder };
   } catch (error) {
+    for (const entry of planned) entry.reservation?.release();
     remainderReservation?.release();
     throw error;
   }
-  return {
-    frames,
-    remainder,
-  };
+}
+
+function inspectConnectFrame(
+  input: Uint8Array,
+  offset: number,
+  maxPayloadBytes: number,
+): InspectedConnectFrame | null {
+  if (input.length - offset < CONNECT_FRAME_HEADER_BYTES) return null;
+  const view = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset);
+  const flags = view.getUint8(0);
+  const length = view.getUint32(1, false);
+  if (length > maxPayloadBytes) {
+    throw new ConnectFrameError("payload_too_large", `Connect frame payload too large: ${length}`);
+  }
+  const readBytes = CONNECT_FRAME_HEADER_BYTES + length;
+  if (input.length - offset < readBytes) return null;
+  return { flags, length, payloadStart: offset + CONNECT_FRAME_HEADER_BYTES, readBytes };
 }
 
 function bufferedPayloadBytes(input: Uint8Array, start: number): number {

src/adapters/cursor/native-exec.ts

@@ -87,7 +87,7 @@ export function cursorUnsafeNativeLocalExecEnabled(input: Pick<CursorNativeExecC
 const BLOB_TTL_MS = 15 * 60_000;
 const BLOB_MAX_ENTRIES = 4_096;
 const BLOB_MAX_ENTRY_BYTES = 16 * 1024 * 1024;
-const BLOB_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+export const CURSOR_BLOB_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
 
 type CursorBlobProvenance = "local-regenerated" | "remote-setBlobArgs";
 export type CursorBlobRequestScopeToken = symbol;
@@ -121,7 +121,7 @@ const DEFAULT_BLOB_LIMITS: CursorBlobLimits = {
   ttlMs: BLOB_TTL_MS,
   maxEntries: BLOB_MAX_ENTRIES,
   maxEntryBytes: BLOB_MAX_ENTRY_BYTES,
-  maxTotalBytes: BLOB_MAX_TOTAL_BYTES,
+  maxTotalBytes: CURSOR_BLOB_MAX_TOTAL_BYTES,
 };
 
 const blobs = new Map<string, CursorBlobEntry>();

src/adapters/google-antigravity-replay.ts

@@ -28,10 +28,11 @@ interface ReplayEntry {
 
 const MIN_SIGNATURE_LEN = 16;
 const REPLAY_TTL_MS = 60 * 60 * 1000; // 1h
-const REPLAY_MAX_ENTRIES = 10_240;
+export const ANTIGRAVITY_REPLAY_MAX_ENTRIES = 10_240;
 const REPLAY_EVICT_BATCH = 128;
 const REPLAY_MAX_CALLS_PER_SESSION = 256;
-const REPLAY_MAX_BYTES_PER_SESSION = 2 * 1024 * 1024;
+export const ANTIGRAVITY_REPLAY_MAX_BYTES_PER_SESSION = 2 * 1024 * 1024;
+export const ANTIGRAVITY_REPLAY_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
 const REPLAY_MAX_SIGNATURE_BYTES = 64 * 1024;
 
 interface ReplayLimits {
@@ -42,7 +43,7 @@ interface ReplayLimits {
 
 const DEFAULT_REPLAY_LIMITS: ReplayLimits = {
   maxCallsPerSession: REPLAY_MAX_CALLS_PER_SESSION,
-  maxBytesPerSession: REPLAY_MAX_BYTES_PER_SESSION,
+  maxBytesPerSession: ANTIGRAVITY_REPLAY_MAX_BYTES_PER_SESSION,
   maxSignatureBytes: REPLAY_MAX_SIGNATURE_BYTES,
 };
 
@@ -122,6 +123,12 @@ function deleteExpiredReplaySessions(now: number): void {
   for (const [key, entry] of replayCache) if (entry.expiresAtMs <= now) deleteReplaySession(key);
 }
 
+export function sweepExpiredAntigravityReplay(now = Date.now()): number {
+  const before = replayCache.size;
+  deleteExpiredReplaySessions(now);
+  return before - replayCache.size;
+}
+
 function deleteReplayCall(entry: ReplayEntry, callKey: string): number {
   const call = entry.byCall.get(callKey);
   if (!call) return 0;
@@ -143,11 +150,18 @@ function evictInnerCalls(entry: ReplayEntry): void {
 }
 
 function evictIfNeeded(): void {
-  if (replayCache.size <= REPLAY_MAX_ENTRIES) return;
-  const oldest = [...replayCache.entries()]
-    .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)
-    .slice(0, REPLAY_EVICT_BATCH);
-  for (const [key] of oldest) deleteReplaySession(key);
+  if (replayCache.size > ANTIGRAVITY_REPLAY_MAX_ENTRIES) {
+    const oldest = [...replayCache.entries()]
+      .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)
+      .slice(0, REPLAY_EVICT_BATCH);
+    for (const [key] of oldest) deleteReplaySession(key);
+  }
+  while (replayBytes > ANTIGRAVITY_REPLAY_MAX_TOTAL_BYTES) {
+    const oldestKey = [...replayCache.entries()]
+      .sort((a, b) => a[1].expiresAtMs - b[1].expiresAtMs)[0]?.[0];
+    if (oldestKey === undefined) return;
+    deleteReplaySession(oldestKey);
+  }
 }
 
 /** Gemini/Flash/Agent use the replay cache; Claude does not (inline sanitization instead). */