Bound the held fold's finished wait so a stall fails the test, not the job

[leaf-agent]

Problem

The test job on run 33165671503 spent the step's whole 45 minutes and left no failure to read. Under the -v #81 added, the log names what stopped: gw1 printed tests/test_render_conversations.py::test_a_thread_reopened_mid_fold_folds_again_when_it_settles at 11:11:32 and never reported it, while gw0 drained the rest and stopped at 81%, twenty-six minutes before the bound cut the job off.

Every wait that test makes is Playwright's and runs out in thirty seconds naming its nodeid, except one: it awaits the held fold's finished inside page.evaluate, which takes no timeout in any binding. An animation that never settles is therefore a wait nothing bounds, and what should have been one test failing became the job's whole cap plus the share of the suite xdist had already handed that worker.

Solution

Race that await against a setTimeout that rejects naming the motion, so the wait states its end as well as its fact. Thirty seconds, because that is where every other browser wait in the suite runs out. The rejection comes back through evaluate as the failure of the test that asked for it, which is the naming a wedge has never had.

This is the same class #84 bounds for rendering-frame promises, and the instance its sweep did not reach — finished is not a frame promise, and this is the suite's only await on one. The two are independent: #84 owns pyproject.toml's note about the class, so this branch leaves it alone.

tests/CLAUDE.md gains the rule under A wait consumes a fact the system states, since the shape recurs wherever a test awaits a page promise rather than a fact the page states.

Testing

The edited test, 5 runs at -n 0: 1 passed each, ~4.2s. Whole file at the suite's own -n 2 --dist loadgroup with --run-nightly: 41 passed in 46.8s. ruff check clean over tests/; ruff format leaves this diff untouched.

Bug-back — the deadline fires, and it names what stopped:

# seek removed, so `finished` never settles
FAILED tests/test_render_conversations.py::test_a_thread_reopened_mid_fold_folds_again_when_it_settles
  - playwright._impl._errors.Error: Page.evaluate: Error: held fold 0 never ran out
1 failed in 34.33s

Against main's expression the same page runs until whatever cap is above it — which is the run this fixes.

Why the wedge has to be this wait, when it did not reproduce

62 runs of the test locally — 30 sequential at -n 0, then 32 across four concurrent loops on a four-core runner — all passed. So the classification is by elimination rather than by repro, and the elimination is complete: every other call the test makes carries a deadline. click and wait_for_function take Playwright's 30s default (nothing here calls set_default_timeout; the one place that does is test_render_gate.py, and it lowers it), expect takes 5s, round_trip and undo go through _until's explicit 30s, told carries its own 30s, and events_model reads and appends are Python-side file work. Had any of them blown, the run would show a failure with the nodeid within thirty seconds. It showed nothing for thirty-seven minutes, so the wait was one that cannot run out — and page.evaluate is the only unbounded call in the test, with await m.finished the only thing in it that can block.

The one-in-ten rate fits: test was green on the nine other ci runs on main this morning, each of which ran this test once.

The other half of this run: `lint`

lint was also red, on the ruff format rewrite of the two asserts dbfaeaa added to this same file. That is #94, which is open and green, and it is the failure on all ten of main's red runs this morning. It is deliberately not duplicated here — so lint on this PR is red for that pre-existing reason until #94 or an equivalent lands, and test is the check this PR is answerable for.

---

Automated fix for failed run

[leaf-agent]

This branch's first ci run wedged too — run 33169923393, same 45-minute bound, but on a different test and a wait this diff does not touch: gw1 printed tests/test_smoke.py::test_a_shipped_page_passes_the_real_browser_gate at 12:36:23 and never reported it, at 99% with gw0 already idle since 78%. I've rerun the failed jobs to get a reading on the fold fix itself.

That test is one line — render_gate_model.render_version(...) — so the wait is on the gate's own path, in shipped code rather than in tests/. Two awaits there have no deadline, both reached through evaluate_probe, which is page.evaluate and so takes none either:

• nextFrame is new Promise(requestAnimationFrame), awaited at readings.py:188. Give the suite's rendered-frame waits a deadline of their own #84 named this one and scoped it out as product rather than suite behaviour.
• retiredSlots awaits Promise.allSettled over every animation under each holder — a.finished, the same promise this PR just had to bound, filtered only for infinite iteration counts. Nothing named it before.

So the rule this PR writes into tests/CLAUDE.md has one place left that breaks it, and it is the shipped gate: leaf version check can hang there for as long as the caller allows, saying nothing. I've left both alone here — a product change is not this PR's concern, and I have no reproduction of either, only the elimination that every other call on that path carries a Playwright deadline.

The rerun's reading: test passed in 25m10s on attempt 2 — the fold fix stands, and the gate wedge above is the intermittent one it did not catch. lint is still red on the two assert ( hunks #94 rewrites, in this same file but nowhere near this diff.

[max-sixty]

Landed on main as bb8b7e0 (leaf squash-merges directly to main rather than merging the PR). Full nightly suite green on the rebased tree.

This was written by Claude Code on behalf of max-sixty