fix(test): the paused-walk cancel test holds the walk before it can finish, instead of racing it

live::cancel_returns_within_200ms_on_five_thousand_entries (tm-walk
tests/walk.rs, Phase 3) started a real walk of 5,050 entries, then paused
it and cancelled 30 ms later. A pause only takes hold at a worker's next
check, so a test thread descheduled between start() and pause() let the
whole walk finish first: "the walk completed (5050 entries) before the
cancel landed", seen once by T6b's agent under load (26 Sep 2026). The
test raced the clock.

Now the governor is paused before the walk starts, so each worker
completes at most the one folder it holds and parks in throttle() — the 51
folders cannot finish. The walk is then paused, the governor released, and
the test waits (counted, not timed) until a worker is parked in the walk's
pause before cancelling; take() runs behind a hang guard, so a cancel that
never reaches the paused walk fails instead of hanging.

Proved on a scratch copy: the old test with 300 ms between start() and
pause() goes red with the very message seen; the new test with the same
delay stays green; the new test goes red ("take() did not return within
10s") when a cancel no longer wakes the walk's pause.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Prithvi-Web

native/treemap-core/crates/tm-walk/tests/walk.rs

@@ -1628,7 +1628,9 @@ mod live {
         WalkOptions, probe, start,
     };
 
-    use super::{REACT_WITHIN, TestResult, index_by_path, node, rel_paths, wait_done};
+    use super::{
+        REACT_WITHIN, SETTLE, TestResult, index_by_path, node, rel_paths, wait_done, wait_until,
+    };
 
     const A_BYTES: usize = 1_234;
     const B_BYTES: usize = 4_096;
@@ -2039,22 +2041,44 @@ mod live {
     #[test]
     fn cancel_returns_within_200ms_on_five_thousand_entries() -> TestResult {
         let fx = five_thousand("cancel")?;
-        let handle = start(WalkOptions::new(&fx.root), governor()).map_err(|e| e.to_string())?;
-        // Hold the workers so the cancel has something to interrupt.
+        // Hold the workers so the cancel has something to interrupt — and so the
+        // walk cannot finish first, however late this thread runs: with the
+        // governor paused a worker completes at most the one folder it holds,
+        // then parks in `throttle()`, and 51 folders need more than the workers.
+        // (Pausing the walk after `start` raced it: a descheduled test thread let
+        // all 5,050 entries finish before the pause landed.)
+        let gov = governor();
+        gov.pause();
+        let handle =
+            start(WalkOptions::new(&fx.root), Arc::clone(&gov)).map_err(|e| e.to_string())?;
         handle.pause();
-        thread::sleep(Duration::from_millis(30));
+        gov.resume();
+        // A worker let out of `throttle()` takes its next folder and parks in the
+        // walk's pause: counted, not timed.
+        if !wait_until(SETTLE, || handle.counts().paused_workers > 0) {
+            return Err("no worker parked in the walk's pause".to_owned());
+        }
         let asked = Instant::now();
         handle.cancel();
-        let result = handle.take();
+        let (tx, rx) = std::sync::mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(handle.take());
+        });
+        let outcome = rx.recv_timeout(SETTLE);
         let took = asked.elapsed();
-        assert!(took <= REACT_WITHIN, "cancel took {took:?}");
-        match result {
-            Err(WalkError::Cancelled) => Ok(()),
-            Ok(out) => Err(format!(
+        match outcome {
+            Ok(Err(WalkError::Cancelled)) => {
+                assert!(took <= REACT_WITHIN, "cancel took {took:?}");
+                Ok(())
+            }
+            Ok(Ok(out)) => Err(format!(
                 "the walk completed ({} entries) before the cancel landed",
                 out.stats.entries
             )),
-            Err(other) => Err(format!("expected Cancelled, got {other:?}")),
+            Ok(Err(other)) => Err(format!("expected Cancelled, got {other:?}")),
+            Err(_) => Err(format!(
+                "take() did not return within {SETTLE:?}: the cancel never reached the paused walk"
+            )),
         }
     }