Verify each finding against the current code and only fix it if needed.

Inline comments:
In @.cspell.dict/cpython.txt:
- Line 163: The dictionary entry "PYTHONUTF" is misspelled; update the token to
"PYTHONUTF8" so the CPython UTF-8 environment variable is correct; locate the
entry "PYTHONUTF" in .cspell.dict/cpython.txt and replace it with "PYTHONUTF8"
(preserve surrounding formatting).

In `@crates/vm/src/stdlib/posix.rs`:
- Around line 913-918: The stop-the-world call may time out and currently is
ignored before calling libc::fork(), which can fork while another thread holds
interpreter locks; change the call site that invokes
vm.state.stop_the_world.stop_the_world(vm) to check a success/failure return (or
propagate a Result) and if the stop-the-world timed out abort the fork path by
returning an error or raising an exception instead of proceeding to unsafe {
libc::fork() }; update the stop_the_world API (and any callers like the code
invoking fork) to return a boolean/Result so fork only runs when stop-the-world
succeeded.

In `@crates/vm/src/vm/thread.rs`:
- Around line 175-202: do_suspend currently does a direct
s.state.store(THREAD_ATTACHED, Ordering::Release) after the suspension loop,
which can overwrite a concurrently set THREAD_SUSPENDED; change this to the same
CAS-with-retry pattern used by attach_thread: perform a compare_exchange loop on
s.state that only sets THREAD_ATTACHED when the current value is
THREAD_SUSPENDED (use the same Ordering::Acquire/Release semantics as
surrounding loads/stores), retrying or re-reading the state until the
compare_exchange succeeds or the state is no longer THREAD_SUSPENDED so you
avoid clobbering a new suspend request; reference function do_suspend, type
StopTheWorldState, and field s.state and constants THREAD_SUSPENDED and
THREAD_ATTACHED.

---

Nitpick comments:
In `@crates/compiler-core/src/bytecode.rs`:
- Around line 658-704: The fence(Ordering::Release) call inside
begin_descriptor_write is redundant because the successful compare_exchange_weak
already uses Ordering::AcqRel and provides the required release semantics;
remove the core::sync::atomic::fence(Ordering::Release) statement from the
begin_descriptor_write implementation so the CAS alone handles ordering, leaving
the rest of the loop and compare_exchange_weak call intact.

In `@crates/vm/src/vm/mod.rs`:
- Around line 186-191: The branch returning true is redundant: where you
currently have `if all_suspended { /* Verify once more after dropping the lock
*/ return true; } all_suspended`, replace that whole conditional with a single
`return all_suspended;` and remove or update the misleading comment about
verifying after dropping the lock so it accurately reflects where verification
occurs; target the block that references the `all_suspended` boolean in this
function.
- Around line 199-218: stop_the_world currently proceeds silently on timeout;
after the waiting loop returns, call park_detached_threads(vm) once more (or
check the loop exit cause) and if it still fails to suspend all threads, emit a
debug log and/or increment an observability metric indicating a stop_the_world
timeout, including the requester_ident (from crate::stdlib::thread::get_ident())
for context; use existing symbols stop_the_world, park_detached_threads,
requester/requester_ident, and notify_mutex/notify_cv to locate the correct spot
to add the log/metric.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/vm/src/stdlib/time.rs`:
- Around line 120-122: The EINTR check is unreliable because errno is read after
vm.allow_threads returns; change the closure passed to vm.allow_threads so it
calls libc::nanosleep and immediately captures errno inside the closure (e.g.
call nix::Error::last_raw() or read libc::errno) and return or otherwise expose
both the nanosleep result and the captured errno to the outer scope; then
compute interrupted with the captured errno (e.g. interrupted = res == -1 &&
captured_errno == libc::EINTR) and call vm.check_signals() when interrupted.
Ensure you update the use of libc::nanosleep, vm.allow_threads,
nix::Error::last_raw(), and the interrupted logic to use the captured errno from
inside the closure.

In `@crates/vm/src/vm/mod.rs`:
- Around line 314-320: The stop-request flag self.requested must be cleared
before waking suspended threads to avoid a race where a thread rechecks
attach_thread() and re-suspends; move the self.requested.store(false,
Ordering::Release) above the loop that iterates registry and before calling
slot.state.store(... THREAD_DETACHED ...) and slot.thread.unpark() in
start_the_world(), so that threads returning from allow_threads() see
requested==false; update any comments around start_the_world(), attach_thread(),
THREAD_SUSPENDED, and THREAD_DETACHED to reflect the new ordering and keep
drop(registry) after the wake loop as needed.

In `@scripts/fork_stw_matrix.sh`:
- Around line 21-22: The script currently calls a hardcoded prebuilt RustPython
binary (target/release/rustpython) which breaks if CARGO_TARGET_DIR or Cargo
config moves build outputs; replace those direct binary invocations with cargo
run --release -- (invoked from the same directory where you run cargo build,
e.g. (cd "$ROOT_DIR" && cargo run --release -- -- <args>)) or alternatively
resolve the actual target dir via CARGO_TARGET_DIR (or cargo metadata) and use
that path; update every occurrence of target/release/rustpython (including the
block around the build step and the invocations in the 35-41 range) to use cargo
run --release -- or the dynamically-resolved path so RustPython is executed
reliably.

In `@scripts/fork_stw_stress.py`:
- Around line 92-105: The benchmark resets STW stats too early and labels
latency incorrectly: move the maybe_reset_stw_stats() call out of the top of the
loop and instead invoke it once immediately after the warmup iterations complete
so rustpython_stw_stats excludes warmup and aligns with lat_ns; also adjust how
fork_latency_us is measured—if you intend to measure pure fork latency (not
child exit+wait), capture t0 = time.perf_counter_ns() before os.fork() and
compute dt immediately after the fork returns (before os.waitpid()), otherwise
update the metric name to indicate it includes the waitpid round-trip; update
references in this block (maybe_reset_stw_stats(), warmup, lat_ns,
fork_latency_us) accordingly.

---

Outside diff comments:
In `@crates/vm/src/stdlib/thread.rs`:
- Around line 79-96: The rollout missed converting some blocking waits to detach
from the GC: wrap the raw mutex/wait calls in RLock::_acquire_restore and in
_ThreadHandle.join so they use vm.allow_threads (same pattern as Lock.acquire
used for mu.try_lock_for and mu.lock()); specifically replace direct
self.mu.lock() in RLock::_acquire_restore and the waits on done_event /
JoinHandle::join inside _ThreadHandle.join with vm.allow_threads(|| ... ) so
those waits occur while the thread is THREAD_DETACHED and cannot block
stop_the_world.

---

Duplicate comments:
In `@crates/vm/src/frame.rs`:
- Around line 7027-7058: The helper try_read_cached_descriptor can return a
false-positive by not checking the metaclass guard slot (cache_base + 3) in the
same snapshot as the descr_ptr; add the metaclass check into the atomic
double-check or provide a new variant (e.g.,
try_read_cached_descriptor_with_metaclass) that accepts an
expected_metaclass_version and verifies cache_base+3 equals that value in the
same re-read that validates the type version and descr_ptr. Update the
LoadAttrClassWithMetaclassCheck call site to call the new variant (or fold its
metaclass_version consumption into try_read_cached_descriptor) so the
metaclass_version, type_version, and descr_ptr are validated together before
returning the cloned object.

---

Nitpick comments:
In `@scripts/fork_stw_compare.sh`:
- Around line 17-18: The script uses the hardcoded interpreter "python3" when
invoking the CPython side; update the invocation in the fork_stw_compare.sh
script (the line calling python3 "$SCRIPT_PATH") to call "python" instead so the
harness uses the repo's configured CPython executable; keep the echo "[CPython]"
and rest of the invocation unchanged.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/vm/src/stdlib/imp.rs`:
- Around line 17-20: acquire_lock currently calls acquire_lock_for_fork and may
block on IMP_LOCK while the Python thread remains ATTACHED, preventing
stop_the_world from observing signals; wrap the blocking lock acquisition in the
Python-facing path with vm.allow_threads(...) so the thread detaches while
waiting — modify the acquire_lock function to call vm.allow_threads(||
acquire_lock_for_fork()) (or the equivalent closure/callback pattern used by
VirtualMachine) so the IMP_LOCK.lock() happens while threads are allowed,
ensuring check_signals() can run on the requester.

In `@crates/vm/src/stdlib/os.rs`:
- Around line 325-330: The write implementation in fn write (using
ArgBytesLike::with_ref and vm.allow_threads(|| crt_fd::write(fd, b))) should
loop and retry when the syscall returns an EINTR (io::ErrorKind::Interrupted)
similar to read/readinto: call crt_fd::write inside vm.allow_threads, if it
returns Err(e) with kind Interrupted then continue the loop and retry, otherwise
return the Ok or Err result; ensure you preserve the Borrowed fd and the bytes
slice across retries and break only on non-Interrupted errors or a successful
write.

In `@crates/vm/src/vm/thread.rs`:
- Around line 146-158: After the successful DETACHED->SUSPENDED CAS
(s.state.compare_exchange) you must re-check vm.state.stop_the_world.requested
to avoid parking on a cleared request: after Ok(_), reload requested with
Ordering::Acquire and if it's false, undo the suspend by CAS-ing s.state from
THREAD_SUSPENDED back to THREAD_DETACHED (or retry that revert loop) and skip
notify_suspended()/wait_while_suspended()/add_attach_wait_yields so the thread
self-recovers; apply the same pattern to the other identical suspend path (the
block around lines 205-220) so you never park when the STW request was cleared
between the initial load and the CAS.

---

Outside diff comments:
In `@crates/vm/src/stdlib/posix.rs`:
- Around line 1879-1885: The code currently calls vm.allow_threads(|| unsafe {
libc::waitpid(pid, &mut status, opt) }) and then checks nix::Error::last_raw(),
but errno can be overwritten when allow_threads reattaches the VM thread; fix by
capturing the raw errno inside the closure that calls libc::waitpid and return
it alongside the syscall result (e.g., return (res, err_no) from the
vm.allow_threads closure), then use that captured errno instead of calling
nix::Error::last_raw() after vm.allow_threads returns so EINTR is detected and
vm.check_signals() is called correctly; update the branch that compares to
libc::EINTR and the error return to use the captured errno and map it via
nix::Error::from_errno or into_pyexception as before.

---

Duplicate comments:
In `@crates/vm/src/stdlib/posix.rs`:
- Around line 948-950: py_os_before_fork(vm) may hide a failure/timeout from
StopTheWorldState::stop_the_world(), so do not call libc::fork()
unconditionally; change the call site in the posix fork path to inspect and
propagate the outcome of py_os_before_fork(vm) (or directly check
StopTheWorldState::stop_the_world()) and abort/return an error instead of
proceeding to unsafe { libc::fork() } when stop-the-world failed or timed out;
update py_os_before_fork(vm) to return a Result or bool indicating success if
needed, log the failure and return a Python error from the surrounding function
rather than performing fork when the stop-the-world step did not succeed.

In `@crates/vm/src/stdlib/time.rs`:
- Around line 120-122: The EINTR check reads errno after vm.allow_threads
reattaches the VM thread, allowing a different syscall to clobber errno; fix by
capturing the errno inside the closure that calls libc::nanosleep: call
vm.allow_threads(|| { let res = unsafe { libc::nanosleep(...)}; let err =
nix::Error::last_raw() (or read errno) inside the closure; return both res and
err (or set interrupted) so the outer code uses the captured err to compute
interrupted and then call vm.check_signals() accordingly, updating the handling
around res and interrupted variables in time.rs.

In `@crates/vm/src/vm/mod.rs`:
- Around line 305-321: The global stop flag self.requested is cleared too late
in start_the_world, allowing threads returning via attach_thread to see
requested == true and re-suspend; move the self.requested.store(false,
Ordering::Release) (and keep self.requester.store(0, Ordering::Relaxed) after)
to occur before iterating the registry so the wake loop sees requested==false;
ensure the loop still checks slot.state for THREAD_SUSPENDED and sets
THREAD_DETACHED and unpark() as before (symbols: start_the_world,
self.requested, self.requester, THREAD_SUSPENDED, THREAD_DETACHED,
attach_thread).

In `@crates/vm/src/vm/thread.rs`:
- Around line 299-304: The blind s.state.store(some) in the suspend-abort path
must be replaced with a guarded compare-and-swap loop: use
s.state.compare_exchange to change THREAD_DETACHED → THREAD_ATTACHED (with the
same Ordering semantics used elsewhere) and retry the CAS; if the CAS observes
THREAD_SUSPENDED (or any non-DETACHED that indicates a new STW request) then
abort/return without forcing ATTACHED. Apply the same CAS-and-retry reattach
flow to both the early-recovery branch around s.state.store(THREAD_ATTACHED) and
the later branch (lines ~315-320) so you don't overwrite a freshly suspended
slot; reference s.state, THREAD_DETACHED, THREAD_ATTACHED, THREAD_SUSPENDED, and
stw.requested and keep ordering Acquire/Release consistent.

---

Nitpick comments:
In `@crates/compiler-core/src/bytecode.rs`:
- Around line 658-688: Replace the manual begin/end pair with an RAII guard:
modify begin_descriptor_write to return a small DescriptorWriteGuard (holding
&self and the index) instead of unit, implement Drop for DescriptorWriteGuard to
perform the increment on self.descriptor_sequences[index] (using fetch_add with
Ordering::Release) so the sequence is always closed even on panic/early return,
and remove or make end_descriptor_write private/unused; keep the current locking
loop logic inside the new begin_descriptor_write before creating/returning the
guard so callers simply hold the guard for the write scope.

In `@crates/vm/src/frame.rs`:
- Around line 7053-7098: Extract the common publish protocol used by
write_cached_descriptor and write_cached_descriptor_with_metaclass into a single
helper (e.g., publish_descriptor_cache) that encapsulates
begin_descriptor_write(cache_base), the invalidate write_cache_u32(cache_base +
1, 0), the payload writes (write_cache_u32 for metaclass when present,
write_cache_ptr for descr_ptr), the final write_cache_u32(cache_base + 1,
type_version), and end_descriptor_write(cache_base); modify
write_cached_descriptor and write_cached_descriptor_with_metaclass to compute
their metaclass_version (Option<u32>) and descr_ptr values and then call this
helper so the begin/invalidate/payload/publish/end sequence is implemented once
and both functions delegate to it.