test(ci): schedule a mid-test snapshot 150ms after every beforeEach

Run 26401801404 (PR #7841 after merging develop) captured the dying
test's beforeEach node-report — be-0258, written 75ms after
socketio.ts > "Pad-wide settings creator gate different browsers"
entered — but no further state. The kill landed 321ms into the test
body, between 1 Hz heartbeat ticks, and the 100ms boundary throttle
prevented further beforeEach writes inside the same test. The report
we have shows only the listening server socket; the connections that
the test body creates (and that presumably precede the kill) never
get snapshotted.

Schedule an unref'd setTimeout from beforeEach that fires 150ms after
the test entered. If it's still the running test at fire time (i.e.
slow enough that the death window applies), capture a node-report
from INSIDE the test body — the moment when the real TCP / socket.io
activity is in flight. Fast tests (<150ms) skip the write because
afterEach has already cleared currentTest by the time the timer
fires.

Result on the next reproduction of the death pattern:
  - be-NNNN report at +75ms (beforeEach, body not yet started)
  - mt-MMMM report at +150ms (mid-test, body in flight, before kill
    at +320ms)
  - kill, no further reports

Cost: only slow tests (>150ms) generate an mt report, so the
artifact size growth is bounded by the count of tests that take
longer than 150ms — typically a small minority. Locally verified
against a 3-test probe: 2 fast tests skipped, 1 300ms test produced
the expected mt-NNNN snapshot.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: JohnMcLear

src/tests/backend/diagnostics.ts

@@ -204,6 +204,24 @@ export const mochaHooks = {
       // boundary writes for any test whose neighbour fired ≥100 ms ago,
       // including the socketio tests in the dying-test pattern.
       tryWriteReport('be', 100);
+      // Mid-test snapshot. Run 26401801404 captured the dying test's
+      // beforeEach write but no further state — the kill landed 321 ms
+      // into the test body, between the 1 Hz heartbeat ticks, and the
+      // 100 ms boundary-throttle prevented additional beforeEach writes
+      // inside a single test. Schedule an unref'd setTimeout that fires
+      // 150 ms after the test entered: if it's still the running test
+      // at that point (i.e. slow enough that the death window applies),
+      // capture a snapshot from INSIDE the test body — where the TCP
+      // traffic and socket.io activity that precedes the kill happens.
+      // Fast tests (<150 ms) skip the write because currentTest will
+      // have already been cleared in afterEach.
+      const enteredTest = currentTest;
+      const midSnapshot = setTimeout(() => {
+        if (currentTest === enteredTest) {
+          tryWriteReport('mt', 0);
+        }
+      }, 150);
+      midSnapshot.unref();
     }
   },
   afterEach(this: any) {