fix(antigravity): throttle the lazy expiry scan (CI ubuntu timeout fix)

Every observe/apply ran an O(sessions) expiry scan; at the 10,240 cap
that is O(n^2), and the worst-case fixed-key test exceeded the ubuntu
CI test timeout. The 60s state-store sweeper is already the periodic
expiry authority, so lazy scans are throttled to one per 30s. The
worst-case test now runs in ~50ms and carries a 30s budget guard.

Author: lidge-jun

src/adapters/google-antigravity-replay.ts

@@ -294,6 +294,22 @@ function deleteExpiredReplaySessions(now: number): void {
   for (const [key, entry] of replayCache) if (entry.expiresAtMs <= now) deleteReplaySession(key);
 }
 
+/**
+ * The lazy per-call expiry scan is O(sessions); at the 10,240-session cap
+ * every observe/apply would rescan the whole map — O(n²) under load. The 60s
+ * state-store sweeper is already the periodic expiry authority, so lazy scans
+ * are throttled to at most one per interval (expired entries may linger a few
+ * extra seconds; TTL is fuzzy at that scale by design).
+ */
+const LAZY_SWEEP_INTERVAL_MS = 30_000;
+let lastLazySweepAt = Number.NEGATIVE_INFINITY;
+
+function deleteExpiredReplaySessionsThrottled(now: number): void {
+  if (now - lastLazySweepAt < LAZY_SWEEP_INTERVAL_MS) return;
+  lastLazySweepAt = now;
+  deleteExpiredReplaySessions(now);
+}
+
 export function sweepExpiredAntigravityReplay(now = Date.now()): number {
   const before = replayCache.size;
   deleteExpiredReplaySessions(now);
@@ -349,7 +365,7 @@ export function antigravityUsesReplayCache(model: string): boolean {
 export function observeAntigravityReplay(model: string, sessionId: string, parts: unknown[]): void {
   if (!antigravityUsesReplayCache(model) || !Array.isArray(parts) || parts.length === 0) return;
   const now = Date.now();
-  deleteExpiredReplaySessions(now);
+  deleteExpiredReplaySessionsThrottled(now);
   const key = replayKey(model, sessionId);
   const existing = replayCache.get(key);
   const entry = existing ?? {
@@ -403,7 +419,7 @@ export function observeAntigravityReplay(model: string, sessionId: string, parts
 export function applyAntigravityReplay(model: string, sessionId: string, contents: unknown[]): unknown[] {
   if (!antigravityUsesReplayCache(model) || !Array.isArray(contents)) return contents;
   const now = Date.now();
-  deleteExpiredReplaySessions(now);
+  deleteExpiredReplaySessionsThrottled(now);
   const entry = replayCache.get(replayKey(model, sessionId));
   if (!entry) {
     return contents;
@@ -478,6 +494,7 @@ export function setAntigravityReplayLimitsForTests(limits?: Partial<ReplayLimits
 
 /** Test seam. */
 export function __resetAntigravityReplayCache(): void {
+  lastLazySweepAt = Number.NEGATIVE_INFINITY;
   replayCache.clear();
   replayBytes = 0;
   replayOldestSessionKey = undefined;

tests/google-antigravity-replay.test.ts

@@ -14,6 +14,7 @@ import {
   evictOldestAntigravityReplayForBudget,
   observeAntigravityReplay,
   setAntigravityReplayLimitsForTests,
+  sweepExpiredAntigravityReplay,
 } from "../src/adapters/google-antigravity-replay";
 import { sanitizeAntigravityClaudeSignatures } from "../src/adapters/google-antigravity-wire";
 
@@ -340,6 +341,24 @@ describe("antigravity replay fixed-size key identities", () => {
     // keys never scale with input length, all within the 64 MiB global cap.
     expect(metrics.totalBytes).toBeLessThan(64 * 1024 * 1024);
     expect(metrics.totalBytes).toBe(10_240 * (64 + 64 + SIG.length));
+  }, 30_000);
+
+  test("lazy expiry scan is throttled; the sweeper remains authoritative", () => {
+    observeAntigravityReplay(MODEL, "s-1", [fcPart("f", {}, "sig-1234567890abcdef")]);
+    const originalNow = Date.now;
+    try {
+      // An expired session is NOT re-scanned within the 30s lazy interval.
+      Date.now = () => originalNow() + 1000;
+      observeAntigravityReplay(MODEL, "s-2", [fcPart("f", {}, "sig-1234567890abcdef")]);
+      expect(antigravityReplayMetrics().sessions).toBe(2);
+      // The periodic sweeper still removes expired sessions on its own pass.
+      Date.now = () => originalNow() + 60 * 60 * 1000 + 1000;
+      const removed = sweepExpiredAntigravityReplay(Date.now());
+      expect(removed).toBe(2);
+      expect(antigravityReplayMetrics().sessions).toBe(0);
+    } finally {
+      Date.now = originalNow;
+    }
   });
 
   test("length-prefixed components are unambiguous across separator content", () => {