@@ -365,15 +365,9 @@ fn enqueueDirect(rt: *Runtime, agent_val: Value, action: Action) !void {
 /// its operand-stack roots (the in-flight action), like `future.worker`.
 fn drainer(a: *Agent) void {
     const agent_val = Value.encodeHeapPtr(.agent, a);
-    var ctx: root_set.ThreadGcContext = .{
-        .frame_slot = &env_mod.current_frame,
-        .analysis_frame_slot = &root_set.analysis_frame_head,
-        .eval_frame_slot = &root_set.eval_frame_head,
-        .self_guard_slot = &root_set.gc_self_guard,
-        // Publish this drainer's STM transaction (an action may run a `dosync`)
-        // so it is GC-rooted during a collect (#4a' in-txn-map rooting).
-        .tx_slot = @ptrCast(&lock_tx.current_tx),
-    };
+    // The tx_slot publishes this drainer's STM transaction (an action may run
+    // a `dosync`) so it is GC-rooted during a collect (#4a' in-txn-map rooting).
+    var ctx = root_set.workerContext(@ptrCast(&lock_tx.current_tx));
     // Must NOT drain while unregistered: an unregistered worker's operand stack
     // is invisible to the mark phase, so a concurrent collect (when auto-collect
     // turns ON) would sweep objects live only on this thread → use-after-free. On
 
@@ -58,7 +58,10 @@ var resume_cond: std.Io.Condition = .init;
 
 /// Worker safe point: register as parked, wake the collector, then block until
 /// the pending collection finishes. Called when `gc_requested` is observed set
-/// at the `alloc` boundary or the VM back-edge poll. Signalling `all_parked` on
+/// at the `alloc` boundary, the VM back-edge poll, or the registration
+/// safepoint at the tail of `root_set.registerThread` (ADR-0175 — a worker
+/// born while a collect is arming/running parks before its first mutator
+/// step). Signalling `all_parked` on
 /// every entry (not only the last) is robust against the collector checking the
 /// count before this thread parks. The resume guard tests the FLAG, not the
 /// count, so a spurious `Condition` wakeup re-parks correctly.
@@ -96,7 +99,11 @@ pub fn stopWorld(self_registered: bool) void {
         if (waited > max_stopworld_wait_ns.load(.monotonic))
             max_stopworld_wait_ns.store(waited, .monotonic);
     }
-    gc_requested.store(true, .release);
+    // Seq_cst, pairing with `registerThread`'s seq_cst count-add + flag-load
+    // (ADR-0175): a worker mid-registration is either visible in the count read
+    // below (we wait for its park) or sees this flag and parks at its
+    // registration safepoint — never both-miss (the spawn-to-register window).
+    gc_requested.store(true, .seq_cst);
     io_default.lockMutex(&sp_mutex);
     defer io_default.unlockMutex(&sp_mutex);
     // Recompute the target on every wake: a worker that finishes a tiny action
@@ -107,7 +114,7 @@ pub fn stopWorld(self_registered: bool) void {
     // no `registry_mutex`-under-`sp_mutex` inversion. A late-arriving worker
     // raises the count and parks at its first poll; an overshoot relaxes `<`.
     while (true) {
-        const registered = root_set.registeredCountRelaxed();
+        const registered = root_set.registeredCountLockFree();
         const target: u32 = if (self_registered and registered > 0) registered - 1 else registered;
         if (parked_count >= target) return;
         io_default.condWait(&all_parked, &sp_mutex);
@@ -359,6 +366,56 @@ test "collectStopTheWorld with no other registered worker is a fenced collect (D
     try testing.expect(!gc_requested.load(.acquire));
 }
 
+test "registerThread during an active STW collect parks the newborn until resumeWorld (spawn-to-register window)" {
+    var tio: ThreadedIo = .{};
+    tio.start();
+    defer tio.deinit();
+
+    const Shared = struct {
+        /// True between stopWorld-return and resumeWorld on the main thread —
+        /// the span where NO registered worker may run mutator code.
+        var in_stw: std.atomic.Value(bool) = .init(false);
+        var ran_during_collect: std.atomic.Value(bool) = .init(false);
+        var registered_ret: std.atomic.Value(bool) = .init(false);
+
+        fn worker() void {
+            var ctx: root_set.ThreadGcContext = .{
+                .frame_slot = &env_mod.current_frame,
+                .analysis_frame_slot = &root_set.analysis_frame_head,
+                .eval_frame_slot = &root_set.eval_frame_head,
+                .self_guard_slot = &root_set.gc_self_guard,
+            };
+            root_set.registerThread(&ctx) catch return;
+            // First mutator step after registration: if the collector is still
+            // between stopWorld and resumeWorld here, the newborn raced the
+            // collect (the spawn-to-register window).
+            if (in_stw.load(.seq_cst)) ran_during_collect.store(true, .seq_cst);
+            registered_ret.store(true, .release);
+            root_set.unregisterThread(&ctx);
+        }
+    };
+    Shared.in_stw.store(false, .monotonic);
+    Shared.ran_during_collect.store(false, .monotonic);
+    Shared.registered_ret.store(false, .monotonic);
+
+    // Arm + complete the rendezvous with ZERO registered workers (target 0 →
+    // returns at once) — the collector is now "collecting".
+    stopWorld(false);
+    Shared.in_stw.store(true, .seq_cst);
+
+    // A worker born mid-collect must park inside registerThread until
+    // resumeWorld, never run its first mutator step during the collect.
+    var t = try std.Thread.spawn(.{}, Shared.worker, .{});
+    while (parkedCountForTest() == 0 and !Shared.registered_ret.load(.acquire)) std.atomic.spinLoopHint();
+
+    Shared.in_stw.store(false, .seq_cst);
+    resumeWorld();
+    t.join();
+
+    try testing.expect(!Shared.ran_during_collect.load(.seq_cst));
+    try testing.expectEqual(@as(u32, 0), parkedCountForTest());
+}
+
 test "collectStopTheWorld parks real workers allocating through gc.alloc, then resumes them (D-244 #4)" {
     var tio: ThreadedIo = .{};
     tio.start();
 
@@ -31,7 +31,6 @@ const Value = value_mod.Value;
 const HeapHeader = value_mod.HeapHeader;
 const Runtime = @import("runtime.zig").Runtime;
 const Env = @import("env.zig").Env;
-const env_mod = @import("env.zig");
 const root_set = @import("gc/root_set.zig");
 const io_default = @import("concurrency/io_default.zig");
 const lock_tx = @import("concurrency/lock_tx.zig");
@@ -136,15 +135,9 @@ pub fn alloc(rt: *Runtime, env: *Env, thunk: Value, loc: SourceLocation) !Value
 /// slots (no conveyed dynamic bindings yet — binding conveyance is a follow-up).
 fn worker(f: *Future) void {
     const fut_val = Value.encodeHeapPtr(.future, f);
-    var ctx: root_set.ThreadGcContext = .{
-        .frame_slot = &env_mod.current_frame,
-        .analysis_frame_slot = &root_set.analysis_frame_head,
-        .eval_frame_slot = &root_set.eval_frame_head,
-        .self_guard_slot = &root_set.gc_self_guard,
-        // Publish this worker's STM transaction so a `dosync` in the thunk is
-        // GC-rooted during a collect (#4a' in-txn-map rooting).
-        .tx_slot = @ptrCast(&lock_tx.current_tx),
-    };
+    // The tx_slot publishes this worker's STM transaction so a `dosync` in the
+    // thunk is GC-rooted during a collect (#4a' in-txn-map rooting).
+    var ctx = root_set.workerContext(@ptrCast(&lock_tx.current_tx));
     const registered = if (root_set.registerThread(&ctx)) |_| true else |_| false;
     defer if (registered) root_set.unregisterThread(&ctx);
 
@@ -155,16 +148,24 @@ fn worker(f: *Future) void {
 
     var result_state: FutureState = .realised_error;
     var result_value: Value = .nil_val;
-    if (f.rt.vtable) |vt| {
-        if (vt.callFn(f.rt, f.env, f.thunk, &.{}, .{})) |result| {
-            result_state = .realised_value;
-            result_value = result;
-        } else |_| {
-            // ADR-0120: marshal the worker's error into a GC-heap exception
-            // Value (survives this thread) so `deref` re-raises the REAL error
-            // (kind/message/location), not a generic `future_thunk_failed`.
-            result_state = .realised_error;
-            result_value = worker_error.capture(f.rt);
+    // ADR-0175: NEVER run the thunk unregistered (registry cap hit) — an
+    // unregistered mutator is invisible to the STW rendezvous + root walk,
+    // the exact corruption the registration safepoint closes. The future
+    // realises as an error WITHOUT allocating (this thread may not touch the
+    // GC heap): `cached` stays nil, so `deref` raises `future_thunk_failed`
+    // (errorValue's nil-guard routes it past the reraise).
+    if (registered) {
+        if (f.rt.vtable) |vt| {
+            if (vt.callFn(f.rt, f.env, f.thunk, &.{}, .{})) |result| {
+                result_state = .realised_value;
+                result_value = result;
+            } else |_| {
+                // ADR-0120: marshal the worker's error into a GC-heap exception
+                // Value (survives this thread) so `deref` re-raises the REAL error
+                // (kind/message/location), not a generic `future_thunk_failed`.
+                result_state = .realised_error;
+                result_value = worker_error.capture(f.rt);
+            }
         }
     }
 
@@ -241,7 +242,12 @@ pub fn errorValue(v: Value) ?Value {
     const f = v.decodePtr(*Future);
     io_default.lockMutex(&f.cell.mutex);
     defer io_default.unlockMutex(&f.cell.mutex);
-    return if (f.state == .realised_error) f.cached else null;
+    // Nil-guard: a future that failed WITHOUT a marshalled exception (worker
+    // registration refused at the registry cap — that path may not allocate
+    // one) has `cached == nil`; report "no exception value" so the deref
+    // consumer raises the generic `future_thunk_failed` instead of
+    // re-raising nil (ADR-0175).
+    return if (f.state == .realised_error and !f.cached.isNil()) f.cached else null;
 }
 
 /// Wait up to `timeout_ms` for the worker (the 3-arity `deref` support).
 
@@ -331,7 +331,7 @@ var registry_mutex: std.Io.Mutex = .init;
 
 /// Live registered-worker count, mirroring the non-null slots in
 /// `thread_registry`. Maintained under `registry_mutex` (register/unregister)
-/// but exposed lock-free via `registeredCountRelaxed` so `safepoint.stopWorld`
+/// but exposed lock-free via `registeredCountLockFree` so `safepoint.stopWorld`
 /// can re-read the rendezvous target while holding `sp_mutex` — taking
 /// `registry_mutex` under `sp_mutex` would invert the lock order against the
 /// unregister path (registry_mutex → sp_mutex wake). The array scan in
@@ -351,20 +351,69 @@ var registered_count: std.atomic.Value(u32) = .init(0);
 /// dormant D-244 #4 path, validated separately under user awareness.
 pub threadlocal var is_registered_worker: bool = false;
 
+/// Build the CALLING thread's standard worker context: all four TLS root
+/// slots plus the caller-supplied opaque `tx_slot` (opaque because root_set
+/// must not import lock_tx — see `ThreadGcContext.tx_slot`). Must run ON the
+/// worker thread (the addresses taken are its threadlocals). One shared
+/// builder so a future worker family cannot silently drop a slot (the
+/// slot-drift hazard the ADR-0175 review named).
+pub fn workerContext(tx_slot: *const ?*anyopaque) ThreadGcContext {
+    return .{
+        .frame_slot = &env_mod.current_frame,
+        .analysis_frame_slot = &analysis_frame_head,
+        .eval_frame_slot = &eval_frame_head,
+        .self_guard_slot = &gc_self_guard,
+        .tx_slot = tx_slot,
+    };
+}
+
 /// Register a worker thread's published roots. Locked (workers register
 /// at `Thread.spawn`). Returns `error.TooManyThreads` past the cap.
+///
+/// Registration is itself a GC SAFEPOINT (ADR-0175). A worker spawned while a
+/// stop-the-world collect was arming is invisible to that collect's rendezvous
+/// target (it was not yet in the registry), so `stopWorld` can return with
+/// target 0 and start walking roots while this thread comes to life. Without
+/// the post-publish park below, the newborn would run mutator code (push
+/// binding/eval frames, pop an agent action) CONCURRENTLY with the collector's
+/// `nextThreadRoots` walk — the spawn-to-register window (the
+/// phase16_gc_torture agent-drain GP fault on the 4-vCPU Linux runner).
+///
+/// The seq_cst pairing makes the handshake airtight (Dekker shape): the
+/// collector stores `gc_requested` then reads `registered_count`; this thread
+/// adds `registered_count` then loads `gc_requested`. Under seq_cst it is
+/// impossible that BOTH the collector misses this thread's count AND this
+/// thread misses the collector's flag — so either the collector waits for our
+/// park, or we park here before touching the heap. The park runs AFTER
+/// `registry_mutex` is released (a parked thread must never hold it — peers
+/// registering and the next walk would block behind a thread the collector
+/// will not wake). A freshly registered ctx publishes only empty TLS roots, so
+/// a collector already mid-walk reading our slot sees an empty contribution.
+///
+/// CONTRACT for callers: (a) no lock may be held at the call site (the park
+/// must not strand a lock the collector's world could need); (b) code run
+/// BEFORE this call must touch only spawner-pinned objects and pure bit-ops
+/// (an unregistered thread's roots are invisible to the collector); (c) on
+/// `TooManyThreads` the worker must NOT run its mutator body — it reports its
+/// domain failure without GC allocation and exits (an unregistered mutator is
+/// exactly the corruption this safepoint closes).
 pub fn registerThread(ctx: *ThreadGcContext) error{TooManyThreads}!void {
-    io_default.lockMutex(&registry_mutex);
-    defer io_default.unlockMutex(&registry_mutex);
-    for (&thread_registry) |*slot| {
-        if (slot.* == null) {
-            slot.* = ctx;
-            is_registered_worker = true;
-            _ = registered_count.fetchAdd(1, .release);
-            return;
-        }
+    {
+        io_default.lockMutex(&registry_mutex);
+        defer io_default.unlockMutex(&registry_mutex);
+        const idx: usize = blk: {
+            for (&thread_registry, 0..) |*slot, i| {
+                if (slot.* == null) break :blk i;
+            }
+            return error.TooManyThreads;
+        };
+        // Release-store so a lock-free walker (`threadContextAt`) that sees the
+        // slot also sees the fully-initialised ctx it points at.
+        @atomicStore(?*ThreadGcContext, &thread_registry[idx], ctx, .release);
+        is_registered_worker = true;
+        _ = registered_count.fetchAdd(1, .seq_cst);
     }
-    return error.TooManyThreads;
+    if (safepoint.gc_requested.load(.seq_cst)) safepoint.park();
 }
 
 /// Deregister a worker thread's context (at `Thread.join`). No-op if absent.
@@ -376,8 +425,8 @@ pub fn unregisterThread(ctx: *ThreadGcContext) void {
         defer io_default.unlockMutex(&registry_mutex);
         for (&thread_registry) |*slot| {
             if (slot.* == ctx) {
-                slot.* = null;
-                _ = registered_count.fetchSub(1, .release);
+                @atomicStore(?*ThreadGcContext, slot, null, .release);
+                _ = registered_count.fetchSub(1, .seq_cst);
                 removed = true;
                 break;
             }
@@ -394,9 +443,13 @@ pub fn unregisterThread(ctx: *ThreadGcContext) void {
 }
 
 /// Lock-free snapshot of the registered-worker count for `safepoint.stopWorld`'s
-/// rendezvous-target recompute (see `registered_count`).
-pub fn registeredCountRelaxed() u32 {
-    return registered_count.load(.acquire);
+/// rendezvous-target recompute (see `registered_count` — taking `registry_mutex`
+/// under `sp_mutex` would invert the unregister path's lock order). Seq_cst: the
+/// collector reads this AFTER its seq_cst `gc_requested` store, pairing with
+/// `registerThread`'s seq_cst count-add + flag-load so a registering newborn is
+/// either counted here or parks there (ADR-0175 spawn-window handshake).
+pub fn registeredCountLockFree() u32 {
+    return registered_count.load(.seq_cst);
 }
 
 /// Count of currently-registered worker contexts (test/introspection).
@@ -417,8 +470,11 @@ pub fn registeredThreadCount() usize {
 /// single-thread collect sees an empty registry → no-op. `markTxFn` receives the
 /// opaque `current_tx` value (the worker's `?*LockingTransaction`, reinterpreted).
 pub fn markRegisteredTxs(context: *anyopaque, markTxFn: *const fn (*anyopaque, ?*anyopaque) void) void {
-    for (thread_registry) |slot| {
-        if (slot) |ctx| markTxFn(context, ctx.tx_slot.*);
+    for (&thread_registry) |*slot| {
+        // Acquire-load: a newborn may register mid-collect (it then parks at
+        // its registration safepoint with all-empty roots — ADR-0175), so the
+        // slot read must be atomic against that concurrent release-store.
+        if (@atomicLoad(?*ThreadGcContext, slot, .acquire)) |ctx| markTxFn(context, ctx.tx_slot.*);
     }
 }
 
@@ -428,9 +484,12 @@ pub fn markRegisteredTxs(context: *anyopaque, markTxFn: *const fn (*anyopaque, ?
 // worker), read through its published TLS pointers. `.end` terminates the walk
 // past the registry cap. A sparse (null) registry slot yields an all-empty
 // contribution and the cursor advances. Reading the registry array during the
-// walk is safe because (a) it is empty until Phase-B real threads (#3a/#3b are
-// runtime-inert), and (b) the #3b-step2 safepoint guarantees no concurrent
-// register/unregister during collect.
+// walk is safe because (a) slot reads are atomic acquire-loads paired with the
+// register/unregister release-stores, (b) a newborn registering mid-collect
+// parks at its registration safepoint BEFORE running any mutator code, so a
+// mid-walk registration contributes only its empty TLS roots (ADR-0175), and
+// (c) unregistration cannot happen mid-collect — the rendezvous completed, so
+// every already-registered worker is parked (or blocked-counted).
 const ThreadRoots = struct {
     frame_head: ?*env_mod.BindingFrame,
     eval_head: ?*EvalFrame,
@@ -447,7 +506,7 @@ fn threadContextAt(idx: usize) ThreadSource {
     } };
     const ri = idx - 1;
     if (ri >= MAX_GC_THREADS) return .end;
-    if (thread_registry[ri]) |ctx| return .{ .roots = .{
+    if (@atomicLoad(?*ThreadGcContext, &thread_registry[ri], .acquire)) |ctx| return .{ .roots = .{
         .frame_head = ctx.frame_slot.*,
         .eval_head = ctx.eval_frame_slot.*,
         .self_guard = ctx.self_guard_slot.*,