test(e2e): overflow recovery — gate the no-more-main-calls assertion on the fold actually failing

The fail-closed gate deliberately proceeds when the recovery pass's forced
historian publishes and the fold materializes in that same pass (aborting
would interrupt a now-healthy compacted request). The test asserted zero new
main-model calls unconditionally, which only passed when machine load made
the in-test historian time out; on a quiet box the historian publishes
instantly, the fold lands, and proceeding is the designed behavior. Assert
the abort holds the line only while needs_emergency_recovery is still set;
the success path is proven by the existing end-state assertions.

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

Author: ualtinok

packages/e2e-tests/tests/overflow-recovery.test.ts

@@ -243,10 +243,22 @@ describe("context overflow recovery", () => {
                 // prompt's own resolution.
             }
             if (recoveryWasPendingBeforeFollowup) {
-                // The fail-closed transform must interrupt the run before OpenCode
-                // emits another doomed main-model request. Historian traffic is
-                // counted separately by the matcher above.
-                expect(mainCalls).toBe(mainCallsBeforeFollowup);
+                const recoveryStillPending = (readState().needs_emergency_recovery ?? 0) === 1;
+                if (recoveryStillPending) {
+                    // The historian did not publish, so the prompt is still the
+                    // doomed shape: the fail-closed transform must interrupt the
+                    // run before OpenCode emits another main-model request.
+                    // Historian traffic is counted separately by the matcher above.
+                    expect(mainCalls).toBe(mainCallsBeforeFollowup);
+                }
+                // Otherwise the recovery pass force-fired the historian, blocked
+                // until it published, and the fold materialized in that same pass
+                // — the prompt is compacted and no longer doomed, so the
+                // fail-closed gate deliberately lets the request proceed
+                // (aborting after a successful in-pass fold would interrupt a
+                // healthy request). Main-model calls advancing is the success
+                // path here; the end-state assertions below prove the recovery
+                // actually completed rather than leaked.
             }
 
             // Wait for the recovery cycle to complete. End state evidence: