test(e2e): make overflow-recovery version-agnostic (opencode 1.16 compaction change)

opencode 1.16 commit 7e09660c3 (#30749, 'respect disabled auto compaction on
overflow') changed the post-overflow path: when compaction.auto=false (the Magic
Context default), an overflow now errors the turn and goes idle instead of
setting needsCompaction. Pre-1.16, needsCompaction triggered an in-turn
compaction → a second transform pass → our emergency recovery (95% bump →
historian → clear flag) completed SAME turn. On 1.16 there is no second in-turn
pass, so recovery fires on the user's NEXT prompt.

The plugin is correct on both versions — overflow detection persists
needs_emergency_recovery + detected_context_limit on the overflow turn, and the
transform.ts:519 consumer bumps to 95% and runs the recovery historian on the
next transform pass. Verified live on 1.16.0: after the overflow turn
needs_emergency_recovery=1/historian=0, and after a follow-up turn
needs_emergency_recovery=0/historian=1/compartment written (recovered=YES).

The TEST, however, asserted same-turn recovery (an opencode <=1.15 assumption),
so it failed on 1.16 — which is why CI/release host-e2e was pinned to 1.15.4 and
I had to downgrade locally to release. That pin was masking a stale test, not a
plugin defect. Fixed: assert detection on the overflow turn, then drive a
follow-up turn and assert recovery via persisted state. Verified 2/2 on BOTH
1.15.4 and 1.16.0; full OpenCode host suite 44/44 on 1.16.0.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: 2 people

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

@@ -25,6 +25,15 @@
  * 3. **Recovery** — The emergency recovery flag forces the percentage to 95%
  *    even if the model's self-reported usage still looks low, which fires
  *    the existing 95% emergency path (abort + historian + aggressive drops).
+ *    NOTE: recovery runs on a transform pass AFTER detection. On opencode
+ *    <=1.15 an overflow triggered in-turn compaction (a second pass same
+ *    turn), so recovery completed same-turn. On opencode >=1.16 (commit
+ *    7e09660c3, "respect disabled auto compaction on overflow") a session
+ *    with `compaction.auto:false` — the Magic Context default — errors the
+ *    turn and goes idle with NO in-turn second pass, so recovery fires on
+ *    the user's NEXT prompt. The plugin is correct in both cases; this test
+ *    drives a follow-up turn and asserts on persisted state so it is
+ *    version-agnostic.
  *
  * 4. **Completion** — When historian successfully publishes a compartment,
  *    the recovery flag is cleared so future turns aren't stuck at 95%.
@@ -174,13 +183,20 @@ describe("context overflow recovery", () => {
             // error from the provider.
             mainShouldOverflow = true;
 
-            // Fire the turn that will overflow. The full recovery cycle —
-            // detection → bump percentage to 95% → historian → clear flag —
-            // completes inside this single prompt's lifecycle because the
-            // emergency path is intentionally synchronous (historian runs
-            // inline at 95%). The SDK will still throw because the provider
-            // returned 400, but the plugin has already recorded and recovered
-            // from the overflow by the time the error propagates back.
+            // Fire the turn that will overflow. The provider returns 400, so the
+            // SDK throws. What opencode does next depends on its version:
+            //   - opencode <=1.15: an overflow set `needsCompaction`, which ran
+            //     opencode's compaction flow IN-TURN — producing a second
+            //     transform pass on which our recovery fired same-turn.
+            //   - opencode >=1.16 (commit 7e09660c3, "respect disabled auto
+            //     compaction on overflow"): with `compaction.auto:false` (what
+            //     every Magic Context user sets), opencode now errors the turn
+            //     and goes idle — NO in-turn compaction, no second transform
+            //     pass. Recovery therefore fires on the user's NEXT prompt.
+            // Either way, DETECTION happens on this turn via the session.error
+            // event; RECOVERY may be deferred to the next turn. The test asserts
+            // detection here, then drives a follow-up turn and asserts recovery —
+            // version-agnostic across both behaviors.
             try {
                 await h.sendPrompt(sessionId, "user turn that will overflow", {
                     timeoutMs: 30_000,
@@ -189,6 +205,38 @@ describe("context overflow recovery", () => {
                 // expected — provider returned 400
             }
 
+            // Detection must persist on the overflow turn itself (the session.error
+            // handler records the real limit + arms recovery), independent of when
+            // the recovery historian actually runs.
+            const afterOverflow = await h.waitFor(
+                () => {
+                    const s = readState();
+                    if (s.detected_context_limit !== 120000) return false;
+                    return s;
+                },
+                {
+                    timeoutMs: 15_000,
+                    intervalMs: 100,
+                    label: "overflow detected (real limit persisted)",
+                },
+            );
+            expect(afterOverflow.detected_context_limit).toBe(120000);
+
+            // Drive the recovery turn. On opencode >=1.16 this is the pass that
+            // bumps to 95% and fires the emergency historian; on <=1.15 recovery
+            // already completed in-turn and this is just a normal follow-up (the
+            // waitFor below still passes because the flag is already cleared and
+            // the historian already ran). The follow-up prompt itself may succeed
+            // or throw depending on timing — either is fine; we assert on state.
+            try {
+                await h.sendPrompt(sessionId, "follow-up turn that drives recovery", {
+                    timeoutMs: 30_000,
+                });
+            } catch {
+                // tolerated — recovery is asserted via persisted state, not the
+                // prompt's own resolution.
+            }
+
             // Wait for the recovery cycle to complete. End state evidence:
             //   - detected_context_limit persisted (proves detection worked)
             //   - needs_emergency_recovery cleared to 0 (proves historian ran
@@ -210,7 +258,7 @@ describe("context overflow recovery", () => {
                         return s;
                     },
                     {
-                        timeoutMs: 15_000,
+                        timeoutMs: 20_000,
                         intervalMs: 100,
                         label: "overflow detected, recovery completed, flag cleared",
                     },
@@ -234,7 +282,7 @@ describe("context overflow recovery", () => {
             // At least one historian call during recovery.
             expect(historianCalls).toBeGreaterThan(historianBeforeOverflow);
         },
-        120_000,
+        180_000,
     );
 
     it(