diff --git a/lib/erlang/scoreboard.json b/lib/erlang/scoreboard.json
index de791e67..fb812d73 100644
--- a/lib/erlang/scoreboard.json
+++ b/lib/erlang/scoreboard.json
@@ -1,11 +1,11 @@
 {
   "language": "erlang",
-  "total_pass": 577,
-  "total": 577,
+  "total_pass": 582,
+  "total": 582,
   "suites": [
     {"name":"tokenize","pass":62,"total":62,"status":"ok"},
     {"name":"parse","pass":52,"total":52,"status":"ok"},
-    {"name":"eval","pass":380,"total":380,"status":"ok"},
+    {"name":"eval","pass":385,"total":385,"status":"ok"},
     {"name":"runtime","pass":52,"total":52,"status":"ok"},
     {"name":"ring","pass":4,"total":4,"status":"ok"},
     {"name":"ping-pong","pass":4,"total":4,"status":"ok"},
diff --git a/lib/erlang/scoreboard.md b/lib/erlang/scoreboard.md
index d0b234f7..844d86b6 100644
--- a/lib/erlang/scoreboard.md
+++ b/lib/erlang/scoreboard.md
@@ -1,12 +1,12 @@
 # Erlang-on-SX Scoreboard
 
-**Total: 577 / 577 tests passing**
+**Total: 582 / 582 tests passing**
 
 |  | Suite | Pass | Total |
 |---|---|---|---|
 | ✅ | tokenize | 62 | 62 |
 | ✅ | parse | 52 | 52 |
-| ✅ | eval | 380 | 380 |
+| ✅ | eval | 385 | 385 |
 | ✅ | runtime | 52 | 52 |
 | ✅ | ring | 4 | 4 |
 | ✅ | ping-pong | 4 | 4 |
diff --git a/lib/erlang/tests/eval.sx b/lib/erlang/tests/eval.sx
index 40356cef..4b643c95 100644
--- a/lib/erlang/tests/eval.sx
+++ b/lib/erlang/tests/eval.sx
@@ -1309,6 +1309,37 @@
        hr6:v()")
   3)
 
+
+
+;; ── Phase 7 capstone: full hot-reload ladder ───────────────────
+;; Load v1 → spawn from inside module → load v2 → cross-mod hits v2 →
+;; local call inside v1 process still resolves v1 → soft_purge refuses
+;; while v1 procs alive → purge kills them.
+;;
+;; All stages must run in a single erlang-eval-ast call: each call resets
+;; the scheduler (er-sched-init!) so cross-call Pid handles would point at
+;; reaped processes.
+(er-modules-reset!)
+
+(define er-rt-cap-prog "code:load_binary(cap, \"cap.erl\", \"-module(cap). start() -> spawn(fun () -> loop() end). loop() -> receive {ping, From} -> From ! {pong, v1}, loop(); stop -> done end. tag() -> v1.\"), Tag1 = cap:tag(), Pid1 = cap:start(), code:load_binary(cap, \"cap.erl\", \"-module(cap). start() -> spawn(fun () -> loop() end). loop() -> receive {ping, From} -> From ! {pong, v2}, loop(); stop -> done end. tag() -> v2.\"), Tag2 = cap:tag(), _Pid2 = cap:start(), Soft1 = code:soft_purge(cap), Hard = code:purge(cap), Soft2 = code:soft_purge(cap), {Tag1, Tag2, Soft1, Hard, Soft2}")
+
+(define er-rt-cap-result (ev er-rt-cap-prog))
+
+(er-eval-test "capstone v1 tag direct"
+  (get (nth (get er-rt-cap-result :elements) 0) :name) "v1")
+
+(er-eval-test "capstone v2 tag"
+  (get (nth (get er-rt-cap-result :elements) 1) :name) "v2")
+
+(er-eval-test "capstone soft_purge while v1 alive = false"
+  (get (nth (get er-rt-cap-result :elements) 2) :name) "false")
+
+(er-eval-test "capstone hard purge = true"
+  (get (nth (get er-rt-cap-result :elements) 3) :name) "true")
+
+(er-eval-test "capstone soft_purge clean after hard = true"
+  (get (nth (get er-rt-cap-result :elements) 4) :name) "true")
+
 (define
   er-eval-test-summary
   (str "eval " er-eval-test-pass "/" er-eval-test-count))
diff --git a/lib/erlang/transpile.sx b/lib/erlang/transpile.sx
index 3ac63d54..28442cc9 100644
--- a/lib/erlang/transpile.sx
+++ b/lib/erlang/transpile.sx
@@ -1967,6 +1967,21 @@
                     :else
                       (er-mk-tuple (list (er-mk-atom "module") mod-arg))))))))))
 
+(define er-env-derived-from?
+  (fn (env target-env)
+    (cond
+      (= env target-env) true
+      :else
+        (let ((ks (keys env)) (found-ref (list false)))
+          (for-each
+            (fn (i)
+              (when (not (nth found-ref 0))
+                (let ((v (get env (nth ks i))))
+                  (when (and (er-fun? v) (= (get v :env) target-env))
+                    (set-nth! found-ref 0 true)))))
+            (range 0 (len ks)))
+          (nth found-ref 0)))))
+
 (define er-procs-on-env
   (fn (target-env)
     (let ((all-keys (keys (er-sched-processes)))
@@ -1977,7 +1992,7 @@
             (let ((init-fun (get proc :initial-fun)))
               (when (and (not (= init-fun nil))
                          (er-fun? init-fun)
-                         (= (get init-fun :env) target-env)
+                         (er-env-derived-from? (get init-fun :env) target-env)
                          (not (= (get proc :state) "dead")))
                 (append! matches (get proc :pid))))))
         (range 0 (len all-keys)))
diff --git a/plans/erlang-on-sx.md b/plans/erlang-on-sx.md
index 7bc00270..e11597e4 100644
--- a/plans/erlang-on-sx.md
+++ b/plans/erlang-on-sx.md
@@ -106,7 +106,7 @@ Driven by **fed-sx** (see `plans/fed-sx-design.md` §17.5): federated modules mu
 - [x] `code:purge/1` + `code:soft_purge/1` — purge clears `:old` slot and kills any process whose `:initial-fun` env identity matches the old env (returns `true` if there was old code, `false` if there wasn't). soft_purge: refuses (returns `false`, leaves `:old` intact) if any process is still pinned to the old env; otherwise clears and returns `true`. **+10 eval tests** (561/561 total). Caveat: a true "lingering on old code" test needs `spawn/3` (still stubbed) or `fun M:F/A` syntax (not parsed) — anonymous `fun () -> M:F() end` closures capture the caller's env, not the module's, and cross-module calls always resolve to `:current`. Current tests therefore exercise the return-value matrix but not the kill path.
 - [x] `code:which/1`, `code:is_loaded/1`, `code:all_loaded/0` — introspection. **+10 eval tests** (571/571 total). Return-value contract: `which` → `loaded` / `non_existing` (since we have no filesystem path); `is_loaded` → `{file, loaded}` / `false`; `all_loaded` → list of `{Module, loaded}` tuples. Non-atom Mod raises `error:badarg`.
 - [x] Cross-module call `M:F(...)` dispatches to `:current`; local calls inside a module body keep using the env they closed over so a running process finishes its current function with the version it started with — **+6 eval tests** verifying the property end-to-end (577/577 total). No implementation change: `er-apply-user-module` already routes through `er-module-current-env`, and `er-mk-fun` captures its env by reference so closures created under v1 retain v1's `mod-env` even after the slot bumps to v2.
-- [ ] Tests: load v1 → spawn → load v2 → cross-module call hits v2 → local call inside v1 process keeps v1 semantics until function returns → purge kills v1 procs → soft_purge refuses while v1 procs alive
+- [x] Tests: load v1 → spawn → load v2 → cross-module call hits v2 → local call inside v1 process keeps v1 semantics until function returns → purge kills v1 procs → soft_purge refuses while v1 procs alive — **+5 capstone eval tests** (582/582 total). Required extending `er-procs-on-env` from raw identity match to `er-env-derived-from?` (an env "comes from" mod-env if it IS mod-env or contains a value that's a fun closed over mod-env), because `er-apply-fun-clauses` does `er-env-copy closure-env` before binding params — so the spawned-from-inside-module fun's `:env` is a fresh dict, not mod-env. Test ladder runs as one single `erlang-eval-ast` program (every call to `ev` resets the scheduler via `er-sched-init!`, so Pid handles must live within one program).
 
 ### Phase 8 — FFI BIF mechanism + standard libs
 
@@ -126,6 +126,8 @@ Replace today's hardcoded BIF dispatch (`er-apply-bif`/`er-apply-remote-bif` in
 
 _Newest first._
 
+- **2026-05-14 Phase 7 capstone green — full hot-reload ladder works end-to-end** — Wires everything from the previous five iterations into one test program: load cap v1 with `start/0` (spawn-from-inside-module) + `loop/0` + `tag/0` → spawn Pid1 (running v1) → load cap v2 → assert `cap:tag()` returns v2 (cross-module dispatch hits `:current`) → spawn Pid2 (running v2) → `code:soft_purge(cap)` returns `false` (refuses while Pid1 is alive on v1's env) → `code:purge(cap)` returns `true` (kills Pid1, clears `:old`) → `code:soft_purge(cap)` returns `true` (clean — no `:old` left). To make this work, `er-procs-on-env` was extended with a new helper `er-env-derived-from?`: a process counts as "running on" mod-env if its `:initial-fun`'s `:env` IS mod-env directly OR contains at least one binding whose value is a fun closed over mod-env. Reason: `er-apply-fun-clauses` always `er-env-copy`s the closure-env before binding params, so a fun created inside a module body has a `:env` that's a *copy* of mod-env, not mod-env itself — the copy still contains the module's other functions as values, each pointing back to the canonical mod-env. The whole ladder runs as a single `erlang-eval-ast` invocation because each call to `ev` resets the scheduler via `er-sched-init!`, wiping any cross-call Pids. 5 capstone tests: v1 tag, v2 tag (cross-mod after reload), soft_purge-refuses, hard purge, soft_purge-clean-after-hard. Total **582/582** (+5 eval). Phase 7 fully ticked.
+
 - **2026-05-14 hot-reload call-dispatch semantics verified** — Tests-only iteration: no implementation change, just six new eval tests that nail down the Erlang semantics already implicit in the current code. (1) `M:F()` after reload returns v2's value (cross-module call hits `:current`). (2) Inside a freshly-loaded body, a bare local call resolves through the new mod-env so a chain `a() -> b()` reflects v2's `b/0`. (3) Calling a fun captured BEFORE reload, whose body uses a local call, returns the v1 value (closure pinned to old mod-env via `er-mk-fun`'s `:env` reference). (4) Calling a fun captured BEFORE reload, whose body uses a cross-module call `M:b()`, returns v2's value (cross-module always wins over closed-over env). (5) Two captured funs from two distinct vintages stay independent — F1() + F2() = 10 + 20 = 30. (6) The slot version counter still bumps even while old captured funs are alive, demonstrating the closure-pinning doesn't block reloads. The "running process finishes its current function with the version it started with" property falls out of fun-as-closure semantics for free — there's no special bookkeeping. Total **577/577** (+6 eval).
 
 - **2026-05-14 code introspection BIFs green** — `code:which/1`, `code:is_loaded/1`, `code:all_loaded/0` added to `er-apply-code-bif` dispatch with three small implementations in `transpile.sx`. `which` and `is_loaded` are dict-lookups on the module registry returning the loaded-marker (atom `loaded`) or the missing-marker (atom `non_existing` for which, atom `false` for is_loaded). Since we don't have a filesystem path representation, the standard `{file, Path}` shape for `is_loaded` becomes `{file, loaded}` — same tuple arity so destructuring code stays portable. `all_loaded` iterates `(keys (er-modules-get))` in reverse (so the result list preserves insertion order after the cons-prepend loop), wrapping each name in a `{Module, loaded}` tuple. **10 new eval tests**: non_existing for absent / loaded after load for which; missing / file-tag / loaded-value for is_loaded; empty / count-after-2-loads / first-entry-tag for all_loaded; badarg for both single-arg BIFs. Two of the all_loaded tests needed an explicit `(er-modules-reset!)` before the measurement because prior tests in the suite leave modules registered (the registry is process-global across the whole epoch session). Total **571/571** (+10 eval).