fix(e2e): async wait_for_function predicates never waited — poll from Python

page.wait_for_function does not await a returned Promise: the Promise
object itself is truthy, so every 'async () => ...' predicate passed on
its first poll no matter what it would have resolved to. Verified
empirically — wait_for_function('async () => false') returns instantly.

That silent no-op is how phase 5 of the body-double journey went red on
main (run 33859082268): its 'wait until the server holds both notes' guard
never waited, and the active_total read raced the second POST on a loaded
runner. Six call sites carried the same defect — one had already failed,
five were latent.

Add _env.await_async_predicate, which drives the predicate through
page.evaluate (which DOES await) on a Python-side deadline, and convert
all six sites. Positive control per the campaign's trap #1: an
always-false predicate times out, an eventually-true one passes at the
flip. Sync predicates keep using wait_for_function, which is cheaper.

Verified: test_body_double_journey 13 passed; test_session_recovery_journey
+ test_ghostty_dev_terminal 40 passed, 2 skipped.

Author: NetDevAutomate

packages/studyloop/tests/e2e/_env.py

@@ -468,3 +468,35 @@ def goto_view(page: Page, view: str) -> None:
     page.wait_for_function("() => !!window.Alpine && !!window.Alpine.store('nav')", timeout=15000)
     page.evaluate("(v) => window.Alpine.store('nav').go(v)", view)
     page.wait_for_timeout(250)
+
+
+def await_async_predicate(
+    page: Page,
+    js: str,
+    *,
+    arg: object = None,
+    timeout: float = 15.0,
+    what: str = "async page predicate",
+    poll_ms: int = 200,
+) -> None:
+    """Poll an ``async`` JS predicate until truthy, from Python.
+
+    Exists because ``page.wait_for_function`` does NOT await a returned
+    Promise: the Promise object itself is truthy, so an ``async () => …``
+    predicate passes on its first poll no matter what it would resolve to —
+    the wait is silently a no-op. (Verified:
+    ``wait_for_function("async () => false")`` returns instantly.) That
+    no-op is exactly how phase 5 of the body-double journey went red on CI
+    twice on 2026-09-04: its "wait until the server holds both notes" guard
+    never waited, and the read raced the second POST.
+
+    ``page.evaluate`` DOES await, so this loop drives it from Python with a
+    deadline. Sync predicates should keep using ``wait_for_function``, which
+    polls in-page and is cheaper.
+    """
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if page.evaluate(js, arg):
+            return
+        page.wait_for_timeout(poll_ms)
+    raise AssertionError(f"timed out after {timeout:.0f}s waiting for {what}")

packages/studyloop/tests/e2e/test_body_double_journey.py

@@ -51,7 +51,12 @@
     sys.path.insert(0, _tests_dir)
 
 from _playwright_paths import PLAYWRIGHT_ARTIFACTS as RESULTS  # noqa: E402
-from e2e._env import RunningServer, build_test_world, start_server  # noqa: E402
+from e2e._env import (  # noqa: E402
+    RunningServer,
+    await_async_predicate,
+    build_test_world,
+    start_server,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -293,16 +298,19 @@ def _park(page: Page, question: str, notes: str = "") -> None:
 
     # The invariant the product actually guarantees: one more pending topic
     # exists server-side. Polled through the page so it shares the browser's
-    # origin and auth, exactly as _api does.
-    page.wait_for_function(
+    # origin and auth, exactly as _api does. await_async_predicate, not
+    # wait_for_function: the latter does not await async predicates (_env.py).
+    await_async_predicate(
+        page,
         """async (want) => {
             const r = await fetch('/api/backlog');
             if (!r.ok) return false;
             const b = await r.json();
             return (b.active_count + b.parking_lot_count) >= want;
         }""",
         arg=expected,
-        timeout=15_000,
+        timeout=15.0,
+        what=f"backlog to reach {expected} pending topics",
     )
     # Only now is the form guaranteed quiescent: submitPark() clears the
     # question field in its success path, so returning before that lands would
@@ -619,9 +627,16 @@ def test_phase5_notes_are_structured_markdown_and_preview_renders(
         # then races the second POST. The write itself is durable once it returns
         # -- add_note commits before responding -- so polling the count is the
         # honest signal. test_phase8 already polls a count for this reason.
-        page.wait_for_function(
+        #
+        # await_async_predicate, not wait_for_function: the previous de-flake
+        # used wait_for_function with an async predicate, which never awaits
+        # the Promise and so never waited at all — red on main twice,
+        # 2026-09-04. See _env.await_async_predicate.
+        await_async_predicate(
+            page,
             "async () => (await (await fetch('/api/notes')).json()).active_total === 2",
-            timeout=10_000,
+            timeout=10.0,
+            what="both notes to land server-side",
         )
 
         notes = _api(page, "/api/notes")
@@ -1092,16 +1107,19 @@ def test_phase10_park_form_survives_a_draft_typed_while_a_save_is_in_flight(
         page.locator("#bd-park-submit").click()
         page.locator("#bd-park-question").fill("Race second tangent")
 
-        # Let the first save complete server-side.
-        page.wait_for_function(
+        # Let the first save complete server-side. await_async_predicate, not
+        # wait_for_function, which never awaits an async predicate (_env.py).
+        await_async_predicate(
+            page,
             """async (want) => {
                 const r = await fetch('/api/backlog');
                 if (!r.ok) return false;
                 const b = await r.json();
                 return (b.active_count + b.parking_lot_count) >= want;
             }""",
             arg=total + 1,
-            timeout=15_000,
+            timeout=15.0,
+            what="the first park to land server-side",
         )
 
         # The draft must still be there. Before the fix this was '' and the next

packages/studyloop/tests/e2e/test_ghostty_dev_terminal.py

@@ -51,7 +51,12 @@
 if _tests_dir not in sys.path:
     sys.path.insert(0, _tests_dir)
 
-from e2e._env import RunningServer, build_test_world, start_server  # noqa: E402
+from e2e._env import (  # noqa: E402
+    RunningServer,
+    await_async_predicate,
+    build_test_world,
+    start_server,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -735,15 +740,19 @@ def _await_server_sees_session(page, session_id: str) -> None:
         is visible: without this the test asserts on a race and fails with an
         opaque KeyError when it loses.
         """
-        page.wait_for_function(
+        # await_async_predicate, not wait_for_function, which never awaits an
+        # async predicate (_env.py).
+        await_async_predicate(
+            page,
             """async (id) => {
               const res = await fetch('/api/session/state', { cache: 'no-store' });
               if (!res.ok) return false;
               const state = await res.json();
               return state.study_session_id === id;
             }""",
             arg=session_id,
-            timeout=15_000,
+            timeout=15.0,
+            what=f"the server to report session {session_id}",
         )
 
     def test_session_state_survives_reload(self, dev_page) -> None:

packages/studyloop/tests/e2e/test_session_recovery_journey.py

@@ -49,6 +49,7 @@
     sys.path.insert(0, _tests_dir)
 
 from _playwright_helpers import start_web_server  # noqa: E402
+from e2e._env import await_async_predicate  # noqa: E402
 
 _TEST_AGENT_SCRIPT = Path(_tests_dir) / "_fake_agent.py"
 
@@ -283,13 +284,17 @@ def test_end_from_the_picker_releases_the_slot(self, clean_session: str, page: P
         dialog.wait_for(state="visible", timeout=5_000)
         page.locator("[data-testid='study-end-confirm-yes']").click()
 
-        page.wait_for_function(
+        # await_async_predicate, not wait_for_function, which never awaits an
+        # async predicate (_env.py).
+        await_async_predicate(
+            page,
             """async () => {
               const res = await fetch('/api/session/state');
               const s = await res.json();
               return !s.study_session_id;
             }""",
-            timeout=10_000,
+            timeout=10.0,
+            what="the session to be released server-side",
         )
         page.wait_for_function(
             """() => {
@@ -385,13 +390,17 @@ def test_body_double_picker_can_end_a_foreign_session(
         page.locator("#bd-conflict-end").wait_for(state="visible", timeout=5_000)
         page.locator("#bd-conflict-end").click()
 
-        page.wait_for_function(
+        # await_async_predicate, not wait_for_function, which never awaits an
+        # async predicate (_env.py).
+        await_async_predicate(
+            page,
             """async () => {
               const res = await fetch('/api/session/state');
               const state = await res.json();
               return !state.study_session_id;
             }""",
-            timeout=10_000,
+            timeout=10.0,
+            what="the conflicting session to be ended server-side",
         )
 
     def test_body_double_picker_can_reattach_its_own_session(