test: prove page yielding by loop turns and stall ratio instead of a wall-clock budget

The compartment-drop pagination test asserted a 100 ms maximum event-loop gap
while scanning 100k parts; on a shared CI runner under parallel test load the
yielding traversal measured 136 ms and failed release run r3 (8 ms on a quiet
box). The mechanism under test is that the traversal yields between pages, so
the test now counts event-loop turns during the scan (>= pages - 1; a
non-yielding scan yields 0 and fails) and bounds the longest stall relative to
the scan's own duration, which scales with load instead of racing it.

Co-authored-by: Alfonso <alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/plugin/src/hooks/magic-context/compartment-drop-pagination.test.ts

@@ -233,7 +233,7 @@ describe("compartment drop tag-key pagination", () => {
         expect(helperSource).not.toContain("readRawSessionMessages(sessionId)");
     });
 
-    it("keeps event-loop timer gaps within 100 ms while scanning 100k SQLite parts", async () => {
+    it("yields to the event loop between pages while scanning 100k SQLite parts", async () => {
         const dir = mkdtempSync(join(tmpdir(), "compartment-drop-responsive-"));
         tempDirs.push(dir);
         const dbPath = join(dir, "opencode.db");
@@ -305,28 +305,51 @@ describe("compartment drop tag-key pagination", () => {
         closeReadOnlySessionDb();
         resetOpenCodeDbPathStateForTesting();
 
+        // Two load-invariant measurements replace an absolute wall-clock budget, which a
+        // shared CI runner under parallel test load cannot honor (136 ms observed against
+        // a 100 ms budget with the yielding traversal in place). (1) A self-rescheduling
+        // immediate counts event-loop turns during the scan: a traversal that yields
+        // between its 32 pages hands the loop at least 31 turns; a non-yielding scan hands
+        // it none. (2) The longest stall is compared with the scan's own duration, so
+        // both scale together under load: a non-yielding scan stalls for the whole scan.
         const tickTimes: number[] = [];
         const timer = setInterval(() => tickTimes.push(performance.now()), 5);
+        let loopTurns = 0;
+        let counting = true;
+        const countTurns = () => {
+            if (!counting) return;
+            loopTurns += 1;
+            setImmediate(countTurns);
+        };
         try {
             await delay(20);
+            loopTurns = 0;
+            setImmediate(countTurns);
             const scanStartedAt = performance.now();
             await getRawSessionTagKeysThrough(sessionId, messageCount, { pageSize: 32 });
             const scanFinishedAt = performance.now();
+            counting = false;
             await delay(20);
 
-            const observedTimes = [scanStartedAt, ...tickTimes, scanFinishedAt].sort(
-                (left, right) => left - right,
-            );
+            const pages = Math.ceil(messageCount / 32);
+            expect(loopTurns).toBeGreaterThanOrEqual(pages - 1);
+
+            const observedTimes = [
+                scanStartedAt,
+                ...tickTimes.filter((t) => t >= scanStartedAt && t <= scanFinishedAt),
+                scanFinishedAt,
+            ].sort((left, right) => left - right);
             let maxGapMs = 0;
             for (let index = 1; index < observedTimes.length; index += 1) {
                 maxGapMs = Math.max(
                     maxGapMs,
                     (observedTimes[index] ?? 0) - (observedTimes[index - 1] ?? 0),
                 );
             }
-            expect(tickTimes.length).toBeGreaterThan(2);
-            expect(maxGapMs).toBeLessThanOrEqual(100);
+            const scanDurationMs = scanFinishedAt - scanStartedAt;
+            expect(maxGapMs).toBeLessThanOrEqual(Math.max(scanDurationMs / 4, 20));
         } finally {
+            counting = false;
             clearInterval(timer);
         }
     }, 30_000);