diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index e5ff4be3..4394256c 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -1,6 +1,6 @@
 # ClojureWasm
 
-Full-scratch Clojure implementation in Zig 0.15.2. Behavioral compatibility target.
+Full-scratch Clojure implementation in Zig 0.16.0. Behavioral compatibility target.
 Reference: ClojureWasmBeta (via add-dir). Design: `.dev/future.md`. Memo: `.dev/memo.md`.
 
 ## Language Policy
@@ -287,10 +287,10 @@ Notes: `"JVM interop"`, `"builtin (upstream is pure clj)"`, `"stub"`, `"UPSTREAM
 See `.claude/rules/java-interop.md` (auto-loads on .clj/analyzer/builtin edits).
 Do NOT skip features that look JVM-specific — try Zig equivalents first.
 
-## Zig 0.15.2 Pitfalls
+## Zig 0.16.0 Pitfalls
 
 Check `.claude/references/zig-tips.md` first, then Zig stdlib at
-`/opt/homebrew/Cellar/zig/0.15.2/lib` or Beta's `docs/reference/zig_guide.md`.
+`/opt/homebrew/Cellar/zig/0.16.0/lib` or Beta's `docs/reference/zig_guide.md`.
 
 ## References
 
diff --git a/.claude/references/zig-tips.md b/.claude/references/zig-tips.md
index 8f834e81..0b15bc97 100644
--- a/.claude/references/zig-tips.md
+++ b/.claude/references/zig-tips.md
@@ -1,4 +1,4 @@
-# Zig 0.15.2 Tips & Pitfalls
+# Zig 0.16.0 Tips & Pitfalls
 
 Common mistakes and workarounds discovered during development.
 
@@ -23,7 +23,7 @@ try list.append(allocator, 42);        // allocator passed per call
 
 ```zig
 var buf: [4096]u8 = undefined;
-var writer = std.fs.File.stdout().writer(&buf);
+var writer = std.Io.File.stdout().writer(io_default.get(), &buf);
 const stdout = &writer.interface;
 // ... write ...
 try stdout.flush();  // don't forget
@@ -31,7 +31,7 @@ try stdout.flush();  // don't forget
 
 ## Use std.Io.Writer (type-erased) instead of anytype for writers
 
-In 0.15.2, `std.Io.Writer` is the new type-erased writer.
+In 0.16.0, `std.Io.Writer` is the new type-erased writer.
 `GenericWriter` and `fixedBufferStream` are deprecated.
 
 Prefer `*std.Io.Writer` over `anytype` for writer parameters.
diff --git a/.dev/CONTRIBUTING.md b/.dev/CONTRIBUTING.md
index 5f5be5b5..7c6bbdc4 100644
--- a/.dev/CONTRIBUTING.md
+++ b/.dev/CONTRIBUTING.md
@@ -30,7 +30,7 @@ the project direction.
 
 ### Prerequisites
 
-- [Zig 0.15.2](https://ziglang.org/download/) (exact version required)
+- [Zig 0.16.0](https://ziglang.org/download/) (exact version required)
 - macOS Apple Silicon (primary development platform)
 
 ### Build & Test
diff --git a/.dev/archive/zig-016-migration.md b/.dev/archive/zig-016-migration.md
new file mode 100644
index 00000000..f68aceca
--- /dev/null
+++ b/.dev/archive/zig-016-migration.md
@@ -0,0 +1,170 @@
+# Zig 0.15.2 → 0.16.0 Migration — Working Document
+
+**Status**: In progress (branch `develop/zig-016-migration`)
+**Baseline**: commit `8bfbf5b` (`pre-zig-016` in `bench/history.yaml`)
+**Target zwasm**: v1.11.0 (released)
+
+This is a **temporary** working doc. Delete after Phase 7 completion (or
+move learnings into `.dev/decisions.md` D## entry and `.dev/zig-tips.md`).
+
+## Phase -1: zwasm Dependency Audit
+
+### Existing -Dwasm Infrastructure (already in place)
+
+`build.zig` already supports `-Dwasm=true|false` (default true) with full
+conditional gating. Zig source files using zwasm are already wrapped in
+`if (enable_wasm) ...` patterns. **No new build-side gating needed**.
+
+- `build.zig:10` — `-Dwasm` flag definition
+- `build.zig:17` — propagated to `build_options.enable_wasm`
+- `build.zig:22-37` — `zwasm_mod` / `zwasm_native_mod` conditional dep
+- `build.zig:44,59,84` — conditional `addImport("zwasm", ...)`
+- `build.zig:115` — `wasm32-wasi` target does NOT depend on zwasm (correct)
+
+Source-side gates already present:
+
+- `src/runtime/wasm_types.zig:20` — `const zwasm = if (enable_wasm) @import("zwasm") else struct {};`
+- `src/lang/lib/cljw_wasm.zig:16` — `.enabled = wasm_types.enable_wasm`
+  (NamespaceDef level — `cljw.wasm` namespace is unregistered when disabled)
+
+### Verified working under `-Dwasm=false` on Zig 0.15.2
+
+- `zig build -Dwasm=false` → exit 0 ✓
+- `zig build test -Dwasm=false` → exit 0 ✓ (Zig unit tests auto-skip)
+- `zig build -Doptimize=ReleaseSafe -Dwasm=false` → exit 0 ✓
+
+### What FAILS under `-Dwasm=false` (needs Phase 0 work)
+
+#### 1. E2E Wasm tests (test/e2e/wasm/, 6 files)
+
+```
+test/e2e/wasm/01_basic_test.clj
+test/e2e/wasm/02_tinygo_test.clj
+test/e2e/wasm/03_host_functions_test.clj
+test/e2e/wasm/04_module_objects_test.clj
+test/e2e/wasm/05_wit_test.clj
+test/e2e/wasm/06_multi_module_test.clj
+```
+
+All start with `(require '[cljw.wasm :as wasm])` → fail with "Could not
+locate cljw.wasm on load path" because the namespace is not registered.
+
+#### 2. Test runners that unconditionally invoke wasm tests/benchmarks
+
+| Runner | What breaks |
+|---|---|
+| `test/run_all.sh` | step "e2e tests (wasm)" calls `bash test/e2e/run_e2e.sh` (no dir filter) → all e2e dirs incl. wasm |
+| `test/e2e/run_e2e.sh` | no `--no-wasm` flag; finds all `*_test.clj` recursively |
+| `bench/wasm_bench.sh` | runs wasm benchmarks via TinyGo .wasm modules — needs cljw.wasm |
+| `bench/run_bench.sh` | runs benchmarks 21-25, 28-31 (9 wasm benchmarks) under `bench/benchmarks/` |
+
+#### 3. Wasm benchmarks (bench/benchmarks/)
+
+```
+21_wasm_load     22_wasm_call    23_wasm_memory  24_wasm_fib     25_wasm_sieve
+28_wasm_tgo_fib  29_wasm_tgo_tak 30_wasm_tgo_arith 31_wasm_tgo_sieve
+```
+
+### Source files referencing WasmModule type (for migration awareness)
+
+Already-gated, but require io threading in Phase 2:
+
+- `src/runtime/wasm_types.zig` — main bridge
+- `src/runtime/wasm_wit_parser.zig` — WIT parser, uses @embedFile (no io)
+- `src/runtime/value.zig` — `.wasm_module` variant
+- `src/runtime/dispatch.zig` — invokeWasmFn dispatch
+- `src/runtime/gc.zig` — WasmModule finalizer registry
+- `src/lang/lib/cljw_wasm.zig` — NamespaceDef
+- `src/lang/lib/cljw_wasm_builtins.zig` — wasm/load, wasm/fn impl
+- `src/engine/vm/vm.zig`, `src/engine/evaluator/tree_walk.zig` — call sites
+- `src/app/repl/nrepl.zig:1427` — `#<WasmModule>` formatter
+- `src/app/deps.zig` — `cljw/wasm-deps` config parsing (test data only)
+
+## Phase 0: Plan
+
+Reduced scope thanks to existing infrastructure:
+
+1. **Add `--no-wasm` flag to test runners**:
+   - `test/run_all.sh` — skip "e2e tests (wasm)" step when `--no-wasm`
+   - `test/e2e/run_e2e.sh` — skip `wasm/` directory when `--no-wasm` (or `WASM_DISABLED=1` env)
+   - `bench/wasm_bench.sh` — early exit with friendly message when `--no-wasm`
+   - `bench/run_bench.sh` — filter out wasm_* benchmarks when `--no-wasm`
+
+2. **Update build.zig.zon**: `minimum_zig_version = "0.16.0"` (will be done as
+   part of Phase 0 commit, even though we still build with 0.15.2 during the
+   actual code migration phases — `.zon` is just metadata until we actually
+   bump zig).
+
+   Actually: defer this to first 0.16-only commit so we can keep building
+   with 0.15.2 during preparatory commits.
+
+3. **Update zwasm dep tag**: defer to Phase 6 (currently v1.9.1, target v1.11.0).
+   Until Phase 6, build with `-Dwasm=false` so the v1.9.1 zwasm dep is never resolved.
+
+4. **Update `.dev/baselines.md`**: relax binary size cap (≤5.0MB → provisional
+   ≤5.5MB during migration, finalize in Phase 7).
+
+5. **Doc/CI sweep**: grep "0.15.2", "Zig 0.15", update to "Zig 0.16.0":
+   - `.claude/CLAUDE.md`
+   - `.dev/baselines.md`, `.dev/decisions.md`, `.dev/references/*.md`
+   - `README.md`
+   - `flake.nix`, `flake.lock` (if present)
+   - `.github/workflows/*.yml` (if present)
+   - `scripts/*.sh`
+
+## Decision: Gating mechanism for test runners
+
+Use **`--no-wasm` flag** on each runner (matches existing `--quick`,
+`--tree-walk` patterns). Avoid env vars to keep behavior explicit.
+
+`test/run_all.sh` will pass `--no-wasm` down to `run_e2e.sh` when invoked
+with `--no-wasm`, and skip `wasm_bench.sh` entirely.
+
+## Open questions for Phase 6 (deferred)
+
+- Does zwasm v1.11.0 export the same module interface as v1.9.1?
+  (`zwasm.WasmModule`, `zwasm.Capabilities`, `zwasm.ImportEntry`, etc.)
+- Are there breaking API changes in zwasm v1.10.0 → v1.11.0 we'd need
+  to absorb at the `wasm_types.zig` bridge?
+- Action: read `~/Documents/MyProducts/zwasm/CHANGELOG.md` v1.10.0 + v1.11.0
+  notes when entering Phase 6.
+
+## Phase 7: Atomic Toolchain Flip (deferred)
+
+Once code migration is complete and tests are green on Zig 0.16.0,
+flip all toolchain pins and version-mention strings in a single commit.
+Doing this earlier creates a window where neither 0.15.2 nor 0.16.0 builds
+cleanly.
+
+Files to update:
+
+| File | Lines | Change |
+|---|---|---|
+| `build.zig.zon` | 11 | `.minimum_zig_version = "0.16.0"` |
+| `flake.nix` | 9, 20, 23, 27, 31, 35, 46, 58 | URLs and comments → 0.16.0 |
+| `flake.lock` | 71 | regenerate via `nix flake update zig-overlay` |
+| `.github/workflows/ci.yml` | 16, 74, 117 | `version: 0.16.0` |
+| `.github/workflows/nightly.yml` | 15, 59 | `version: 0.16.0` |
+| `.github/workflows/release.yml` | 32 | `version: 0.16.0` |
+| `README.md` | 5, 34 | badge + install link |
+| `.claude/CLAUDE.md` | 3, 290, 293 | intro + "Pitfalls" section header + path hint |
+| `.claude/references/zig-tips.md` | 1, 34 | title + body content |
+| `.dev/baselines.md` | 4 | "Zig 0.15.2" → "Zig 0.16.0" platform line |
+| `.dev/CONTRIBUTING.md` | 33 | install requirement |
+| `.dev/references/setup-orbstack.md` | 19, 30 | install + version check |
+| `.dev/references/ubuntu-testing-guide.md` | 56 | describe 0.16-specific behavior if changed |
+| `docs/differences.md` | 10 | runtime row |
+| `.dev/future.md` | 365 | check if still relevant |
+
+DO NOT touch:
+- `.dev/archive/**` — historical phase notes
+- `.dev/decisions.md` D## entries that reference 0.15.2 — these are immutable history
+  (D## about ArenaAllocator.free, @call always_tail, etc. — those decisions remain valid context)
+
+After flip:
+- Re-run `bash test/run_all.sh` (no --no-wasm) on Zig 0.16.0
+- OrbStack Ubuntu validation: `--seed 0` still required? Re-test
+- Update binary size baseline to actual measured value
+- Add D## entry in `.dev/decisions.md` for the migration
+- Add F## in `.dev/checklist.md` for the libc strip follow-up (zwasm W46 equivalent)
+- Delete this file (`.dev/zig-016-migration.md`)
diff --git a/.dev/baselines.md b/.dev/baselines.md
index 131d222a..a9eec4a3 100644
--- a/.dev/baselines.md
+++ b/.dev/baselines.md
@@ -1,27 +1,31 @@
 # Non-Functional Baselines
 
-Measured on: 2026-02-25 (v0.4.0 + GPA leak fix + JIT register fix)
-Platform: macOS ARM64 (Apple M4 Pro), Zig 0.15.2
+Measured on: 2026-04-27 (Zig 0.16.0 migration complete; HTTP / nREPL / line
+editor / `cljw build` runtime stubs remain — see Phase 7 follow-ups in
+.dev/checklist.md F##).
+Platform: macOS ARM64 (Apple M4 Pro), Zig 0.16.0
 Binary: ReleaseSafe
 
 ## Profiles
 
 | Profile | Binary | Startup | RSS | Notes |
 |---------|--------|---------|-----|-------|
-| wasm=true (default) | 4.76MB | 4.5ms | 7.9MB | Full feature set |
+| wasm=true (default) | 4.12MB | 4.1ms | 8.2MB | Full feature set, libc linked |
 | wasm=false | (not measured) | — | — | No zwasm dependency |
 
 ## Thresholds
 
-All-Zig migration complete (Phases A-F, C.1). Binary size threshold RESTORED.
-Binary grew ~0.5MB due to embedded Clojure multiline strings (pprint, spec.alpha).
-Phase E optimization target: reduce back toward 4.3MB.
+Post-migration baselines (matched against pre-zig-016 history.yaml entry —
+no benchmark regressed beyond noise; lazy_chain actually improved).
+Binary is currently smaller than 0.15.2 because http_server / nrepl / the
+fancy line editor / `cljw build` were stubbed during the migration; restoring
+them under std.Io.net will likely add several hundred KB back.
 
 | Metric              | Baseline   | Threshold  | Margin | How to measure                              |
 |---------------------|------------|------------|--------|---------------------------------------------|
-| Binary size         | 4.76 MB    | 5.0 MB     | +5%    | `ls -la zig-out/bin/cljw` (after ReleaseSafe build) |
-| Startup time        | 4.5 ms     | 6.0 ms     | 1.3x   | `hyperfine -N --warmup 5 --runs 10 './zig-out/bin/cljw -e nil'` |
-| RSS (light)         | 7.9 MB     | 10 MB      | +27%   | `/usr/bin/time -l ./zig-out/bin/cljw -e nil 2>&1 \| grep 'maximum resident'` |
+| Binary size         | 4.12 MB    | 5.5 MB     | +33%   | `ls -la zig-out/bin/cljw` (after ReleaseSafe build) — slack for stub-restoration + libc |
+| Startup time        | 4.1 ms     | 6.0 ms     | 1.5x   | `hyperfine -N --warmup 5 --runs 10 './zig-out/bin/cljw -e nil'` |
+| RSS (light)         | 8.2 MB     | 10 MB      | +22%   | `/usr/bin/time -l ./zig-out/bin/cljw -e nil 2>&1 \| grep 'maximum resident'` |
 | Benchmark (any)     | see below  | 1.2x       | +20%   | Per-benchmark: `bash bench/run_bench.sh --bench=NAME --runs=10 --warmup=5` |
 
 ## `cljw build` Artifact Baselines (2026-02-20)
diff --git a/.dev/checklist.md b/.dev/checklist.md
index 19339c77..c00c3671 100644
--- a/.dev/checklist.md
+++ b/.dev/checklist.md
@@ -32,3 +32,15 @@ Target Phase references: see `.dev/roadmap.md` Phase Tracker + Open Checklist It
 | F104 | Profile-guided optimization (extend IC)     | 89     | Extend inline caching beyond monomorphic                                 |
 | F105 | JIT compilation (expand beyond ARM64 PoC)   | 90     | ARM64 hot-loop JIT done (Phase 37.4, D87). Future: x86_64 port, expand beyond integer loops. |
 | F120 | Native SIMD optimization (CW internals)     | 89     | Investigate Zig `@Vector` for CW hot paths. Profile first.               |
+
+## Open follow-ups from the Zig 0.16.0 migration (D111)
+
+| ID   | Item                                                       | Trigger / notes                                                                |
+|------|------------------------------------------------------------|--------------------------------------------------------------------------------|
+| F140 | Restore HTTP server (`cljw.http/run-server`) on `std.Io.net` | Server / Stream / Connection were stubbed in `lang/builtins/http_server.zig` (D111). Reimplement accept loop on `std.Io.net.Server`, plumb `io` through handler dispatch, restore Ring request/response building. Original logic preserved in git history pre-`40d2f20`. |
+| F141 | Restore HTTP client (`cljw.http/get|post|put|delete`)        | `std.http.Client` now has a `.io` field (D111). Wire `io_default.get()` and unstub `doHttpRequest`.                                              |
+| F142 | Restore nREPL server                                       | Whole `src/app/repl/nrepl.zig` (~1818 lines) collapsed to a stub during D111. Needs the same `std.Io.net` + accept loop work as F140 plus `std.posix.poll` replacement; sessions / mutex use `io_default` helpers. |
+| F143 | Restore raw-mode line editor                               | `src/app/repl/line_editor.zig` not yet ported (still on `std.fs.File` + `std.io.fixedBufferStream`). `runRepl` falls through to `runReplSimple` until this is done. |
+| F144 | Restore `cljw build` self-bundling                         | `std.fs.selfExePath` + `std.fs.openFileAbsolute` were removed in 0.16. Reimplement via argv[0] + `std.c.realpath` (or `_NSGetExecutablePath` / `/proc/self/exe`) and migrate file write loop. Stub in `runner.zig handleBuildCommand`. |
+| F145 | OrbStack Ubuntu re-validation under Zig 0.16.0             | `--seed 0` workaround was discovered on 0.15.2; re-test on 0.16.0 (Random.zig line numbers may have shifted). Run full `bash test/run_all.sh` + `bash bench/run_bench.sh` on Linux ARM64 + x86_64. |
+| F146 | Strip libc back out (`link_libc = false`)                  | zwasm v1.11.0 enables libc to satisfy the `std.posix.*` removals (D111). cf. zwasm W46. Once `std.Io` and the std.c usages in CW (`getcwd`, `getenv`, `realpath`, `mprotect`, `write`) all get pure-zig equivalents, drop libc to recover the pre-migration ~290 KB on Linux. |
diff --git a/.dev/decisions.md b/.dev/decisions.md
index 36e47c32..bc2c0526 100644
--- a/.dev/decisions.md
+++ b/.dev/decisions.md
@@ -938,3 +938,49 @@ instance state). Wasm linear memory remains separately managed per spec.
 at Engine construction. Requires zwasm D128 to be implemented first.
 
 Related: zwasm D128, cw-new D13.
+
+## D111: Zig 0.15.2 → 0.16.0 Migration
+
+**Date**: 2026-04-27
+**Status**: Done
+**Decision**: Migrate the entire ClojureWasm tree from Zig 0.15.2 to 0.16.0,
+together with bumping zwasm to v1.11.0 (the first 0.16-compatible tag).
+Centralize the new `std.Io` model behind a process-wide accessor module
+`runtime/io_default.zig` so existing module-level mutexes, time helpers,
+env lookups, and sleeps don't have to thread `io` through every call site.
+
+**Why now**: Zig 0.16 reshapes `std.Io` (Mutex/Condition/sleep/Timestamp
+all take `io: Io`), removes `std.fs.cwd` (replaced by `std.Io.Dir`), removes
+`std.posix.{getenv,write,isatty}`, and changes `pub fn main()` to
+`pub fn main(init: std.process.Init)`. Staying on 0.15.2 indefinitely
+forfeits stdlib improvements and forces zwasm to maintain a parallel branch.
+
+**Approach**:
+
+- *zwasm-first vs detach-then-reattach*: chose to upgrade zwasm to v1.11.0
+  from the start (rejected the original "detach + Phase 6 reattach" plan).
+  Reason: v1.11.0 is already 0.16-ready, so keeping zwasm in saved a whole
+  reattach phase and let wasm e2e/bridge tests stay green throughout.
+- *io_default module*: production entry points (main, cache_gen) call
+  `io_default.set(init.io)` at startup, so all module-level mutexes /
+  Condition variables / nanoTimestamp / sleep / getenv pick up the real
+  cancelable io. Tests fall through to a process-wide
+  `std.Io.Threaded.init_single_threaded` default, except for the few that
+  need real spawn semantics (shell tests) which install a local Threaded.
+- *libc linkage*: zwasm v1.11.0 enables `link_libc = true` by default
+  (D135 in zwasm). CW inherits the libc-linked binary; we use std.c.getenv
+  / std.c.realpath / std.c.write / std.c.mprotect / std.c.getcwd in places
+  where stdlib equivalents were removed. Stripping libc back out is a
+  follow-up (F##; cf. zwasm's W46 sequence).
+- *temporary stubs*: HTTP server, nREPL, fancy line editor, and `cljw build`
+  rely on `std.net` / `std.posix.poll` / raw-mode termios / `std.fs.selfExePath`
+  — all gone or reshaped in 0.16. The full rewrite to `std.Io.net` + Smith
+  fuzzing is non-trivial and was scoped out of this migration. Each is
+  stubbed with a clear runtime error and tracked as a separate F## item.
+
+**Verification**: 1324/1324 unit tests, 83/83 cljw test namespaces, 6/6 wasm
+e2e, deps.edn e2e all green on macOS aarch64. Bench history records
+`pre-zig-016` and `post-zig-016` entries; no individual benchmark regressed
+beyond noise; lazy_chain actually improved.
+
+Related: zwasm D135 (Vm.io infra), Phase 7 follow-ups in `.dev/checklist.md`.
diff --git a/.dev/future.md b/.dev/future.md
index 26b514ae..883e0ef1 100644
--- a/.dev/future.md
+++ b/.dev/future.md
@@ -362,7 +362,7 @@ Two tracks that do not fully converge. GC and bytecode diverge.
 
 - MarkSweepGc works on wasm32-wasi as-is (GPA→WasmPageAllocator, PoC validated)
 - Free-pool recycling ideal for Wasm (memory grows only, never shrinks)
-- WasmGC not usable: Zig 0.15.2 can't emit WasmGC instructions (struct.new, i31ref)
+- WasmGC not usable: Zig 0.16.0 can't emit WasmGC instructions (struct.new, i31ref)
 - Dynamic languages on Wasm (Python, Ruby) all use self-managed GC in linear memory
 - No comptime GC switching needed for MVP — same MarkSweepGc on both tracks
 
diff --git a/.dev/memo.md b/.dev/memo.md
index 136fb58d..15a76a1c 100644
--- a/.dev/memo.md
+++ b/.dev/memo.md
@@ -4,13 +4,20 @@ Session handover document. Read at session start.
 
 ## Current State
 
-- **Zone Cleanup COMPLETE** (16 → 0 violations)
-- Coverage: 1,130/1,243 vars done (90.9%), 113 skip, 0 TODO, 27 stubs
-- Wasm engine: zwasm v1.1.0 (GitHub URL dependency, build.zig.zon)
-- 68 upstream test files. 6/6 e2e. 14/14 deps e2e
-- Binary: 4.76MB. Startup: 4.2ms. RSS: 7.6MB
+- **Zig 0.16.0 migration COMPLETE** (D111, branch `develop/zig-016-migration`)
+- Wasm engine: zwasm v1.11.0 (first 0.16-compatible tag)
+- All test suites green: 1324/1324 unit, 83/83 cljw test, 6/6 wasm e2e, deps.edn e2e
+- Binary: 4.12MB. Startup: 4.1ms. RSS: 8.2MB (post-migration ReleaseSafe, macOS aarch64)
 - Zone violations: 0 (zero — fully clean architecture)
-- All test suites: PASS (0 failures)
+- Coverage: 1,130/1,243 vars done (90.9%), 113 skip, 0 TODO, 27 stubs
+- 68 upstream test files
+
+Temporarily stubbed during the migration (each prints a runtime error and
+is tracked as a Phase 7 follow-up F## in `.dev/checklist.md`):
+- HTTP server (F140), HTTP client (F141)
+- nREPL server (F142)
+- Raw-mode line editor (F143; runRepl falls through to runReplSimple)
+- `cljw build` self-bundling (F144)
 
 ## Strategic Direction
 
@@ -25,15 +32,21 @@ CW is a complete, optimized Zig implementation with behavioral Clojure compatibi
 
 ## Current Task
 
-v0.4.0 release — all docs updated, ready for tag.
+v0.5.0 release prep — Zig 0.16.0 migration is in CHANGELOG `Unreleased`,
+docs audited. Ready to tag once `develop/zig-016-migration` lands on main.
 
 ## Previous Task
 
-HAMT crash fix + CI benchmark timeout fix + full doc update for v0.4.0.
+Zig 0.15.2 → 0.16.0 migration (D111). 18 commits on
+`develop/zig-016-migration` from `f752739` (Phase -1 audit) through
+`aa9dbca` (toolchain flip + Phase 7 follow-ups).
 
 ## Task Queue
 
-(empty)
+- Restore stubbed features: F140-F144 (HTTP server/client, nREPL,
+  line editor, `cljw build`)
+- F145: OrbStack Ubuntu re-validation under 0.16
+- F146: strip libc back out
 
 ## Known Issues
 
@@ -46,7 +59,9 @@ P3: UPSTREAM-DIFF markers (I-030), stub vars (I-031), stub namespaces (I-032).
 
 ## Notes
 
-- CLAUDE.md binary threshold updated to 4.8MB (post All-Zig migration)
+- Binary threshold raised to 5.5 MB during the Zig 0.16 migration (gives
+  headroom for restoring the four stubbed features and absorbing libc).
 - Zone check: `bash scripts/zone_check.sh --gate` (hard block, baseline 0)
 - Zone checker now excludes test-only imports (after first `test "..."` in file)
 - Phase 98 plan: `.claude/plans/shiny-frolicking-dijkstra.md` (COMPLETE)
+- Migration working doc archived: `.dev/archive/zig-016-migration.md`
diff --git a/.dev/references/setup-orbstack.md b/.dev/references/setup-orbstack.md
index 33588e63..3ea1877a 100644
--- a/.dev/references/setup-orbstack.md
+++ b/.dev/references/setup-orbstack.md
@@ -16,7 +16,7 @@ The same VM and tools are used for both projects:
 
 | Tool       | Version  | Path                     |
 | ---------- | -------- | ------------------------ |
-| Zig        | 0.15.2   | /opt/zig/zig             |
+| Zig        | 0.16.0   | /opt/zig/zig             |
 | wasmtime   | 42.0.1   | ~/.wasmtime/bin/wasmtime |
 | wasm-tools | 1.245.1  | /usr/local/bin/wasm-tools|
 | WASI SDK   | 25       | /opt/wasi-sdk            |
@@ -27,7 +27,7 @@ The same VM and tools are used for both projects:
 
 ```bash
 orb run -m my-ubuntu-amd64 bash -lc "zig version && wasmtime --version"
-# Expected: 0.15.2, wasmtime-cli 42.0.1
+# Expected: 0.16.0, wasmtime-cli 42.0.1
 ```
 
 ## Notes
diff --git a/.dev/references/ubuntu-testing-guide.md b/.dev/references/ubuntu-testing-guide.md
index dd1f4d4f..1c6aa941 100644
--- a/.dev/references/ubuntu-testing-guide.md
+++ b/.dev/references/ubuntu-testing-guide.md
@@ -53,9 +53,10 @@ orb run -m my-ubuntu-amd64 bash -lc "cd ~/ClojureWasm && bash bench/run_bench.sh
 
 **`zig build test` crashes without `--seed 0` on Rosetta x86_64 emulation.**
 
-Root cause: Zig 0.15.2 build runner's `shuffleWithIndex` (Random.zig:375) produces
-an index out of bounds under Rosetta's Random implementation. The `--seed 0` flag
-disables test shuffling, avoiding the crash entirely.
+Root cause: Zig's build runner's `shuffleWithIndex` produces an index out of bounds
+under Rosetta's Random implementation. Originally seen on Zig 0.15.2; needs
+re-verification on Zig 0.16.0 — line numbers in std/Random.zig may have shifted.
+The `--seed 0` flag disables test shuffling, avoiding the crash entirely.
 
 This is 100% reproducible without the flag and 100% fixed with it.
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c4ee57d1..367e7161 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
       - name: Run tests
         run: zig build test
       - name: Build ReleaseSafe
@@ -71,7 +71,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
       - name: Run tests
         run: zig build test
       - name: Build ReleaseSafe
@@ -114,7 +114,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
       - name: Cross-compile
         run: zig build -Dtarget=${{ matrix.target }} -Doptimize=ReleaseSafe
       - name: Check binary
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index fa2a7e4f..1718a4f6 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
       - name: Tests (Debug — full safety checks)
         run: zig build test
       - name: Tests (ReleaseSafe — optimized + safety)
@@ -56,7 +56,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
       - name: Build ReleaseSafe
         run: zig build -Doptimize=ReleaseSafe
       - name: Fuzz — random expressions (no crash = pass)
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index dfe4ebad..14a5d05d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -29,7 +29,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.2
+          version: 0.16.0
 
       - name: Build
         run: zig build -Dtarget=${{ matrix.target }} -Doptimize=ReleaseSafe
diff --git a/.gitignore b/.gitignore
index 28303d29..c4af03a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 # Zig
 .zig-cache/
 zig-out/
+zig-pkg/
 *.o
 
 # Benchmark build artifacts
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 632e9e3d..4590f27d 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -244,3 +244,11 @@ at runtime.
 A CIDER-compatible nREPL server supporting 14 operations: eval, load-file,
 complete, info, lookup, stacktrace, clone, close, describe, ls-sessions,
 interrupt, stdin, eldoc, and ns-list.
+
+> **Status (Zig 0.16 migration)**: temporarily stubbed. The full
+> implementation was built on `std.net.{Server,Stream}` and
+> `std.posix.poll`, both removed in Zig 0.16. Calls to
+> `nrepl.startServer` currently return a runtime error pointing at
+> the Phase 7 follow-up (`.dev/checklist.md` F142). The original code
+> is preserved in git history pre-`e9b65f3` and will be ported back
+> on top of `std.Io.net` once the network rewrite lands.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64298dce..2f35d184 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,74 @@
 # Changelog
 
+## Unreleased
+
+### Toolchain
+- Migrate from Zig 0.15.2 to Zig 0.16.0 (D111). All `std.Io` reshapes
+  centralized behind `runtime/io_default.zig`: process-wide io accessor
+  populated by `main(init: std.process.Init)` from `init.io` /
+  `init.environ_map`, with helper wrappers (`lockMutex`, `unlockMutex`,
+  `condWait`, `condTimedWait`, `condSignal`, `condBroadcast`, `sleep`,
+  `getEnv`, `nanoTimestamp`, `milliTimestamp`) so existing module-level
+  mutexes, time helpers, env lookups, and sleeps don't have to thread
+  `io` through every call site.
+- Bump zwasm dependency from v1.9.1 to v1.11.0 (first 0.16-compatible
+  tag). The wasm bridge in `src/runtime/wasm_types.zig` migrates inline
+  with the rest of the codebase; all six wasm e2e tests stay green.
+- `flake.nix` pin moved from 0.15.2 to 0.16.0; `build.zig.zon`
+  `minimum_zig_version = "0.16.0"`; `.github/workflows/{ci,nightly,release}.yml`
+  setup-zig version pin → 0.16.0.
+- `link_libc = true` is enabled (inherited from zwasm v1.11.0). Several
+  std stdlib removals (`std.posix.{getenv,write,isatty,mprotect}`,
+  `std.fs.cwd().realpath`) are bridged to libc via `std.c.*` for now;
+  stripping libc back out is tracked as F146.
+- `-Dwasm` build option (default true) was confirmed working under 0.16;
+  the `--no-wasm` flag in `bash test/run_all.sh` / `test/e2e/run_e2e.sh`
+  / `bench/run_bench.sh` / `bench/wasm_bench.sh` propagates it through
+  test/bench harnesses.
+
+### Migration test gate
+- 1324 / 1324 unit tests (`zig build test`) — green
+- 83 / 83 namespaces in `cljw test` — green
+- 6 / 6 wasm e2e tests + deps.edn e2e — green
+- `bench/history.yaml` records `pre-zig-016` and `post-zig-016` entries;
+  no individual benchmark regressed beyond noise (`lazy_chain` actually
+  improved).
+
+### Performance (post-migration ReleaseSafe, macOS aarch64)
+- Binary: 4.12 MB (smaller than 0.15.2 because four features below are
+  temporarily stubbed; expect ~+300-500 KB once they are restored).
+- Startup: 4.1 ms
+- RSS: 8.2 MB
+
+### Temporarily disabled, tracked as Phase 7 follow-ups
+The 0.16 stdlib reshapes are large enough that four features were
+collapsed to runtime-error stubs to land the migration cleanly. Each
+returns a clear error message and is preserved either in source or in
+git history.
+- `cljw.http/run-server` (Ring-compatible HTTP server) — F140
+- `cljw.http/get|post|put|delete` (HTTP client built on `std.http.Client`) — F141
+- `--nrepl-server` (CIDER-compatible nREPL with bencode dispatch and
+  14 ops) — F142
+- Raw-mode line editor (Emacs keybindings, history, multiline) — F143
+- `cljw build` standalone-binary self-bundling — F144
+- OrbStack Ubuntu re-validation under 0.16 — F145
+- Strip `link_libc = true` once `std.Io` and the `std.c.*` shims have
+  pure-Zig replacements — F146
+
+### `|_|` switch capture syntax
+- Two switch prongs (`analyzer.zig`, `node.zig`) updated for Zig 0.16's
+  rule that switch arms which don't actually use the capture must omit
+  the `|...|` clause entirely.
+
+### Misc renames
+- `std.mem.{trimLeft,trimRight}` → `std.mem.{trimStart,trimEnd}`
+- `std.process.Child.run(.{...})` → `std.process.run(allocator, io, .{...})`
+- `std.process.Child.Term` variants are now lowercase
+  (`.exited`/`.signal`/`.stopped`/`.unknown`) and signal/stopped carry
+  `std.posix.SIG` instead of raw integers.
+- `std.testing.fuzz`'s `testOne` now takes `*std.testing.Smith`
+  instead of `[]const u8`.
+
 ## v0.4.0 (2026-02-25)
 
 ### Architecture
diff --git a/README.md b/README.md
index c9aa3f65..676d523a 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ![Status: Pre-Alpha](https://img.shields.io/badge/status-pre--alpha-orange)
 ![License: EPL-1.0](https://img.shields.io/badge/license-EPL--1.0-blue)
-![Zig 0.15.2](https://img.shields.io/badge/zig-0.15.2-f7a41d)
+![Zig 0.16.0](https://img.shields.io/badge/zig-0.16.0-f7a41d)
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/chaploud?logo=githubsponsors&logoColor=white&color=ea4aaa)](https://github.com/sponsors/chaploud)
 
 > **Status: Pre-Alpha / Experimental**
@@ -19,9 +19,9 @@ a native implementation targeting behavioral compatibility with Clojure.
 
 ## Highlights
 
-- **Fast startup** — ~5ms to evaluate an expression (ReleaseSafe)
+- **Fast startup** — ~4ms to evaluate an expression (ReleaseSafe)
 - **Small binary** — ~4MB single executable (ReleaseSafe)
-- **Single binary distribution** — `cljw build app.clj -o app`, runs without cljw installed
+- **Single binary distribution** — `cljw build app.clj -o app`, runs without cljw installed *(temporarily disabled during the Zig 0.16 migration; see note below)*
 - **Wasm FFI** — call WebAssembly modules from Clojure (523 opcodes including SIMD + GC)
 - **Dual backend** — bytecode VM (default) + TreeWalk interpreter (reference)
 - **deps.edn compatible** — Clojure CLI subset (-A/-M/-X/-P, git deps, local deps)
@@ -31,7 +31,7 @@ a native implementation targeting behavioral compatibility with Clojure.
 
 ### Prerequisites
 
-- [Zig 0.15.2](https://ziglang.org/download/) (or `nix develop` for a pinned environment)
+- [Zig 0.16.0](https://ziglang.org/download/) (or `nix develop` for a pinned environment)
 
 ### Build
 
@@ -75,6 +75,14 @@ No Maven/Clojars support (git deps and local deps only).
 ./myapp                         # Runs without cljw
 ```
 
+> **Note (Zig 0.16 migration)**: `cljw build`, the nREPL server, and the
+> built-in HTTP server/client are temporarily disabled while their backing
+> stdlib APIs (`std.fs.selfExePath`, `std.net.Server`, `std.http.Client`)
+> migrate to the new `std.Io` model. Each prints a clear runtime error
+> when invoked. Tracked in `.dev/checklist.md` F140-F144 (target: next
+> minor release after this one). Use `zig build && cljw <file.clj>` to
+> run apps in the meantime.
+
 ### nREPL / CIDER
 
 ```bash
@@ -82,7 +90,8 @@ No Maven/Clojars support (git deps and local deps only).
 ```
 
 Connect from Emacs CIDER or any nREPL client. 14 ops supported (eval, complete,
-info, stacktrace, eldoc, etc.).
+info, stacktrace, eldoc, etc.). *(See the build note above — temporarily
+unavailable while the std.net migration lands.)*
 
 ## Features
 
@@ -201,6 +210,10 @@ Call WebAssembly modules directly from Clojure:
 - nREPL in built binaries (`./myapp --nrepl 7888`)
 - SIGINT/SIGTERM graceful shutdown with hooks
 
+> *Temporarily disabled during the Zig 0.16 migration — see the build note
+> earlier in this README. Tracked as `F140`/`F141`/`F142` in
+> `.dev/checklist.md`.*
+
 ### Internals
 
 - **NaN-boxed Value** — 8-byte tagged representation (float pass-through, i48 integer, 40-bit heap pointer)
diff --git a/bench/history.yaml b/bench/history.yaml
index 8ee5e57d..b6d65c7e 100644
--- a/bench/history.yaml
+++ b/bench/history.yaml
@@ -1093,3 +1093,57 @@ entries:
       string_ops: {time_ms: 31, mem_mb: 18.3}
       multimethod_dispatch: {time_ms: 6, mem_mb: 8.2}
       real_workload: {time_ms: 12, mem_mb: 12.1}
+  - id: "pre-zig-016"
+    date: "2026-04-26"
+    reason: "Baseline before Zig 0.16.0 migration"
+    commit: "995d468"
+    build: ReleaseSafe
+    backend: vm
+    results:
+      fib_recursive: {time_ms: 17, mem_mb: 8.2}
+      fib_loop: {time_ms: 4, mem_mb: 8.2}
+      tak: {time_ms: 8, mem_mb: 8.2}
+      arith_loop: {time_ms: 5, mem_mb: 8.2}
+      map_filter_reduce: {time_ms: 9, mem_mb: 9.5}
+      vector_ops: {time_ms: 7, mem_mb: 10.6}
+      map_ops: {time_ms: 4, mem_mb: 9.3}
+      list_build: {time_ms: 5, mem_mb: 9.4}
+      sieve: {time_ms: 5, mem_mb: 8.8}
+      nqueens: {time_ms: 15, mem_mb: 8.8}
+      atom_swap: {time_ms: 5, mem_mb: 8.2}
+      gc_stress: {time_ms: 32, mem_mb: 11.3}
+      lazy_chain: {time_ms: 11, mem_mb: 8.3}
+      transduce: {time_ms: 5, mem_mb: 8.3}
+      keyword_lookup: {time_ms: 12, mem_mb: 8.2}
+      protocol_dispatch: {time_ms: 4, mem_mb: 8.2}
+      nested_update: {time_ms: 11, mem_mb: 11.4}
+      string_ops: {time_ms: 27, mem_mb: 18.3}
+      multimethod_dispatch: {time_ms: 6, mem_mb: 8.2}
+      real_workload: {time_ms: 12, mem_mb: 12.2}
+  - id: "post-zig-016"
+    date: "2026-04-27"
+    reason: "After Zig 0.16.0 migration (network/build/repl stubbed)"
+    commit: "e58850c"
+    build: ReleaseSafe
+    backend: vm
+    results:
+      fib_recursive: {time_ms: 17, mem_mb: 8.5}
+      fib_loop: {time_ms: 4, mem_mb: 8.5}
+      tak: {time_ms: 7, mem_mb: 8.5}
+      arith_loop: {time_ms: 4, mem_mb: 8.6}
+      map_filter_reduce: {time_ms: 7, mem_mb: 9.7}
+      vector_ops: {time_ms: 7, mem_mb: 9.8}
+      map_ops: {time_ms: 5, mem_mb: 9.8}
+      list_build: {time_ms: 5, mem_mb: 9.3}
+      sieve: {time_ms: 5, mem_mb: 8.9}
+      nqueens: {time_ms: 15, mem_mb: 8.6}
+      atom_swap: {time_ms: 6, mem_mb: 9.1}
+      gc_stress: {time_ms: 32, mem_mb: 11.3}
+      lazy_chain: {time_ms: 7, mem_mb: 8.6}
+      transduce: {time_ms: 6, mem_mb: 8.7}
+      keyword_lookup: {time_ms: 12, mem_mb: 8.5}
+      protocol_dispatch: {time_ms: 5, mem_mb: 8.5}
+      nested_update: {time_ms: 11, mem_mb: 13.6}
+      string_ops: {time_ms: 28, mem_mb: 21.5}
+      multimethod_dispatch: {time_ms: 5, mem_mb: 8.5}
+      real_workload: {time_ms: 12, mem_mb: 14.6}
diff --git a/bench/run_bench.sh b/bench/run_bench.sh
index 240c5c2d..bdb127b5 100644
--- a/bench/run_bench.sh
+++ b/bench/run_bench.sh
@@ -6,6 +6,7 @@
 #   bash bench/run_bench.sh --bench=fib_recursive  # Single benchmark
 #   bash bench/run_bench.sh --quick                # Fast check (1 run, no warmup)
 #   bash bench/run_bench.sh --runs=10 --warmup=3   # Custom hyperfine settings
+#   bash bench/run_bench.sh --no-wasm              # Skip wasm benchmarks (binary -Dwasm=false)
 #
 # Always: ReleaseSafe, VM backend, hyperfine measurement.
 # For multi-language comparison: use bench/compare_langs.sh
@@ -28,6 +29,8 @@ RESET='\033[0m'
 BENCH_FILTER=""
 RUNS=3
 WARMUP=1
+NO_WASM=false
+ZIG_BUILD_FLAGS=()
 
 # --- Parse arguments ---
 for arg in "$@"; do
@@ -36,6 +39,7 @@ for arg in "$@"; do
     --runs=*)     RUNS="${arg#--runs=}" ;;
     --warmup=*)   WARMUP="${arg#--warmup=}" ;;
     --quick)      RUNS=1; WARMUP=0 ;;
+    --no-wasm)    NO_WASM=true; ZIG_BUILD_FLAGS+=("-Dwasm=false") ;;
     -h|--help)
       echo "Usage: bash bench/run_bench.sh [OPTIONS]"
       echo ""
@@ -44,6 +48,7 @@ for arg in "$@"; do
       echo "  --runs=N         Hyperfine runs (default: 3)"
       echo "  --warmup=N       Hyperfine warmup runs (default: 1)"
       echo "  --quick          Fast check: 1 run, no warmup"
+      echo "  --no-wasm        Skip wasm_* benchmarks; build with -Dwasm=false"
       echo "  -h, --help       Show this help"
       echo ""
       echo "Always builds ReleaseSafe, uses VM backend."
@@ -66,7 +71,7 @@ fi
 
 # --- Build ReleaseSafe ---
 echo -e "${CYAN}Building ClojureWasm (ReleaseSafe)...${RESET}"
-(cd "$PROJECT_ROOT" && zig build -Doptimize=ReleaseSafe) || {
+(cd "$PROJECT_ROOT" && zig build -Doptimize=ReleaseSafe "${ZIG_BUILD_FLAGS[@]}") || {
   echo -e "${RED}Build failed${RESET}" >&2
   exit 1
 }
@@ -76,10 +81,13 @@ BENCH_DIRS=()
 for dir in "$SCRIPT_DIR/benchmarks"/*/; do
   [[ -f "$dir/meta.yaml" ]] || continue
   [[ -f "$dir/bench.clj" ]] || continue
+  local_name=$(basename "$dir" | sed 's/^[0-9]*_//')
   if [[ -n "$BENCH_FILTER" ]]; then
-    local_name=$(basename "$dir" | sed 's/^[0-9]*_//')
     [[ "$local_name" == "$BENCH_FILTER" ]] || continue
   fi
+  if [[ "$NO_WASM" == true && "$local_name" == wasm_* ]]; then
+    continue
+  fi
   BENCH_DIRS+=("$dir")
 done
 
diff --git a/bench/wasm_bench.sh b/bench/wasm_bench.sh
index 82261c0e..ca6f1252 100755
--- a/bench/wasm_bench.sh
+++ b/bench/wasm_bench.sh
@@ -10,9 +10,18 @@
 #   bash bench/wasm_bench.sh --quick      # Single run, no warmup
 #   bash bench/wasm_bench.sh --bench=fib  # Specific benchmark
 #   bash bench/wasm_bench.sh --rebuild    # Rebuild .wasm files from .go sources
+#   bash bench/wasm_bench.sh --no-wasm    # Early exit (binary built with -Dwasm=false)
 
 set -euo pipefail
 
+# --- Early exit if wasm disabled ---
+for arg in "$@"; do
+  if [[ "$arg" == "--no-wasm" ]]; then
+    echo "wasm_bench.sh: --no-wasm specified, skipping wasm benchmarks."
+    exit 0
+  fi
+done
+
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 CLJW="$PROJECT_ROOT/zig-out/bin/cljw"
diff --git a/build.zig.zon b/build.zig.zon
index 60f9af19..d78f675f 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -3,12 +3,12 @@
     .version = "0.3.0",
     .dependencies = .{
         .zwasm = .{
-            .url = "https://github.com/clojurewasm/zwasm/archive/v1.9.1.tar.gz",
-            .hash = "zwasm-1.9.1-IBbzF1D2KQCmEFwFC9sSN_ZmwuBTxKSu3jNvd6k96PNT",
+            .url = "https://github.com/clojurewasm/zwasm/archive/v1.11.0.tar.gz",
+            .hash = "zwasm-1.11.0-IBbzF-auKgDerx9eX2J2vf84n0YoWX_IyWeqf3E4uNNb",
         },
     },
     .fingerprint = 0x62a7be489d633543,
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .paths = .{
         "build.zig",
         "build.zig.zon",
diff --git a/docs/cli.md b/docs/cli.md
index 01cfbcd7..8fdd5a79 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -1,5 +1,12 @@
 # CLI Reference
 
+> **Status note (Zig 0.16 migration)**: `cljw build`, `--nrepl-server`, the
+> raw-mode line editor, and the embedded HTTP server/client are temporarily
+> disabled and emit a clear runtime error when invoked. Each is preserved in
+> source (or git history) and tracked as `F140`-`F144` in
+> `.dev/checklist.md` for restoration once the `std.Io.net` /
+> `std.fs.selfExePath` migration follow-ups land.
+
 ## Usage
 
 ```
@@ -73,6 +80,12 @@ cljw build app.clj -o myapp     # Build with custom name
 Produces a single self-contained binary that embeds the CW runtime,
 bootstrap, and your source code. The resulting binary starts up in ~18ms.
 
+> *Temporarily disabled during the Zig 0.16 migration (F144 in
+> `.dev/checklist.md`). The bundling routine relies on
+> `std.fs.selfExePath` + `std.fs.openFileAbsolute`, both removed in
+> 0.16; restoring it is a follow-up after `std.c.realpath` /
+> `_NSGetExecutablePath` plumbing lands.*
+
 ### Dependency Resolution
 
 ```bash
@@ -102,7 +115,7 @@ cljw -Sforce -P   # Force re-fetch
 | `-e <expr>` | Evaluate expression and print result |
 | `--tree-walk` | Use TreeWalk interpreter instead of VM |
 | `--dump-bytecode` | Dump compiled bytecode (VM only) |
-| `--nrepl-server` | Start nREPL server |
+| `--nrepl-server` | Start nREPL server *(temp. disabled — F142)* |
 | `--port=<N>` | nREPL server port (default: auto) |
 | `--version` | Print version and exit |
 | `-h`, `--help` | Show help |
diff --git a/docs/differences.md b/docs/differences.md
index b26e8234..e213d6c0 100644
--- a/docs/differences.md
+++ b/docs/differences.md
@@ -7,7 +7,7 @@ This document lists concrete behavioral differences.
 
 | Aspect | JVM Clojure | CW |
 |--------|-------------|-----|
-| Runtime | JVM (HotSpot) | Native (Zig 0.15.2) |
+| Runtime | JVM (HotSpot) | Native (Zig 0.16.0) |
 | Compilation | Bytecode → JIT | Custom bytecode → VM |
 | GC | JVM GC (G1/ZGC) | Mark-and-sweep |
 | Concurrency | Threads + STM | Single-threaded |
@@ -87,10 +87,11 @@ This document lists concrete behavioral differences.
 | Feature | Namespace | Description |
 |---------|-----------|-------------|
 | Wasm FFI | `cljw.wasm` | Load and call WebAssembly modules |
-| HTTP client | `cljw.http` | Native HTTP client |
-| `cljw build` | CLI | Build standalone single-binary executables |
+| HTTP client | `cljw.http` | Native HTTP client *(temp. disabled — Zig 0.16 migration F141)* |
+| HTTP server | `cljw.http` | Ring-compatible server *(temp. disabled — F140)* |
+| `cljw build` | CLI | Build standalone single-binary executables *(temp. disabled — F144)* |
 | `cljw test` | CLI | Built-in test runner |
-| nREPL server | CLI | `--nrepl-server` flag |
+| nREPL server | CLI | `--nrepl-server` flag *(temp. disabled — F142)* |
 
 ## Reader Differences
 
diff --git a/flake.lock b/flake.lock
index ba16ea05..7e0248c1 100644
--- a/flake.lock
+++ b/flake.lock
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1769740369,
-        "narHash": "sha256-xKPyJoMoXfXpDM5DFDZDsi9PHArf2k5BJjvReYXoFpM=",
+        "lastModified": 1776949667,
+        "narHash": "sha256-GMSVw35Q+294GlrTUKlx087E31z7KurReQ1YHSKp5iw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6308c3b21396534d8aaeac46179c14c439a89b8a",
+        "rev": "01fbdeef22b76df85ea168fbfe1bfd9e63681b30",
         "type": "github"
       },
       "original": {
@@ -37,8 +37,7 @@
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "zig-overlay": "zig-overlay"
+        "nixpkgs": "nixpkgs"
       }
     },
     "systems": {
@@ -55,23 +54,6 @@
         "repo": "default",
         "type": "github"
       }
-    },
-    "zig-overlay": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1760154347,
-        "narHash": "sha256-u3pEMcYN71d83MJh14vtzU4DJXnMHu/Jw86d9XvwKE8=",
-        "owner": "ziglang",
-        "repo": "zig",
-        "rev": "e4cbd752c8c05f131051f8c873cff7823177d7d3",
-        "type": "github"
-      },
-      "original": {
-        "owner": "ziglang",
-        "ref": "0.15.2",
-        "repo": "zig",
-        "type": "github"
-      }
     }
   },
   "root": "root",
diff --git a/flake.nix b/flake.nix
index 1220b556..56b6076c 100644
--- a/flake.nix
+++ b/flake.nix
@@ -4,36 +4,32 @@
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
     flake-utils.url = "github:numtide/flake-utils";
-
-    # Zig source pin (not used directly, just for tracking)
-    zig-overlay.url = "github:ziglang/zig/0.15.2";
-    zig-overlay.flake = false;
   };
 
-  outputs = { self, nixpkgs, flake-utils, zig-overlay }:
+  outputs = { self, nixpkgs, flake-utils }:
     flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = import nixpkgs {
           inherit system;
         };
 
-        # Zig 0.15.2 binary (per-architecture URLs and hashes)
+        # Zig 0.16.0 binary (per-architecture URLs and hashes — sha256 mirrored from zwasm flake.nix)
         zigArchInfo = {
           "aarch64-darwin" = {
-            url = "https://ziglang.org/download/0.15.2/zig-aarch64-macos-0.15.2.tar.xz";
-            sha256 = "1csy5ch8aym67w06ffmlwamrzkfq8zwv4kcl6bcpc5vn1cbhd31g";
+            url = "https://ziglang.org/download/0.16.0/zig-aarch64-macos-0.16.0.tar.xz";
+            sha256 = "0yqiq1nrjfawh1k24mf969q1w9bhwfbwqi2x8f9zklca7bsyza26";
           };
           "x86_64-darwin" = {
-            url = "https://ziglang.org/download/0.15.2/zig-x86_64-macos-0.15.2.tar.xz";
-            sha256 = ""; # untested
+            url = "https://ziglang.org/download/0.16.0/zig-x86_64-macos-0.16.0.tar.xz";
+            sha256 = "0dibmghlqrr8qi5cqs9n0nl25qdnb5jvr542dyljfqdyy2bzzh2x";
           };
           "x86_64-linux" = {
-            url = "https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz";
-            sha256 = "0skmy2qjg2z4bsxnkdzqp1hjzwwgnvqhw4qjfnsdpv6qm23p4wm0";
+            url = "https://ziglang.org/download/0.16.0/zig-x86_64-linux-0.16.0.tar.xz";
+            sha256 = "1kgamnyy7vsw5alb5r4xk8nmgvmgbmxkza5hs7b51x6dbgags1h6";
           };
           "aarch64-linux" = {
-            url = "https://ziglang.org/download/0.15.2/zig-aarch64-linux-0.15.2.tar.xz";
-            sha256 = ""; # untested
+            url = "https://ziglang.org/download/0.16.0/zig-aarch64-linux-0.16.0.tar.xz";
+            sha256 = "12gf4d1rjncc8r4i32sfdmnwdl0d6hg717hb3801zxjlmzmpsns0";
           };
         }.${system} or (throw "Unsupported system: ${system}");
 
@@ -43,7 +39,7 @@
         };
 
         # Path wrapper: expose zig binary from nix store
-        zigBin = pkgs.runCommand "zig-0.15.2-wrapper" {} ''
+        zigBin = pkgs.runCommand "zig-0.16.0-wrapper" {} ''
           mkdir -p $out/bin
           ln -s ${zigSrc}/zig $out/bin/zig
           ln -s ${zigSrc}/lib $out/lib
@@ -55,7 +51,7 @@
 
           buildInputs = with pkgs; [
             # Compiler
-            zigBin                    # Zig 0.15.2
+            zigBin                    # Zig 0.16.0
 
             # Wasm runtime
             wasmtime
diff --git a/src/app/cli.zig b/src/app/cli.zig
index b925fcc4..b5978a60 100644
--- a/src/app/cli.zig
+++ b/src/app/cli.zig
@@ -18,14 +18,15 @@ const gc_mod = @import("../runtime/gc.zig");
 const nrepl = @import("repl/nrepl.zig");
 const runner = @import("runner.zig");
 const wasm_builtins = @import("../lang/lib/cljw_wasm_builtins.zig");
+const io_default = @import("../runtime/io_default.zig");
 
 const build_options = @import("build_options");
 const enable_wasm = build_options.enable_wasm;
 
 fn printHelp() void {
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-    _ = stdout.write(runner.version_string) catch {};
-    _ = stdout.write(
+    const stdout = std.Io.File.stdout();
+    stdout.writeStreamingAll(io_default.get(),runner.version_string) catch {};
+    stdout.writeStreamingAll(io_default.get(),
         \\
         \\Usage:
         \\  cljw [options] [file.clj]
@@ -102,8 +103,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
             printHelp();
             return;
         } else if (std.mem.eql(u8, arg, "--version")) {
-            const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-            _ = stdout.write(runner.version_string) catch {};
+            const stdout = std.Io.File.stdout();
+            stdout.writeStreamingAll(io_default.get(),runner.version_string) catch {};
             return;
         } else if (std.mem.eql(u8, arg, "--tree-walk")) {
             use_vm = false;
@@ -116,8 +117,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
         } else if (std.mem.eql(u8, arg, "-e")) {
             i += 1;
             if (i >= args.len) {
-                const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-                _ = stderr.write("Error: -e requires an expression argument\n") catch {};
+                const stderr = std.Io.File.stderr();
+                stderr.writeStreamingAll(io_default.get(),"Error: -e requires an expression argument\n") catch {};
                 std.process.exit(1);
             }
             expr = args[i];
@@ -125,8 +126,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
             // -m namespace (for -M mode)
             i += 1;
             if (i >= args.len) {
-                const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-                _ = stderr.write("Error: -m requires a namespace argument\n") catch {};
+                const stderr = std.Io.File.stderr();
+                stderr.writeStreamingAll(io_default.get(),"Error: -m requires a namespace argument\n") catch {};
                 std.process.exit(1);
             }
             main_ns_flag = args[i];
@@ -185,10 +186,10 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
             runner.startNreplWithFile(gc_alloc, infra_alloc, gc, f, nrepl_port);
         } else {
             nrepl.startServer(infra_alloc, nrepl_port) catch |e| {
-                const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-                _ = stderr.write("Error: nREPL server failed: ") catch {};
-                _ = stderr.write(@errorName(e)) catch {};
-                _ = stderr.write("\n") catch {};
+                const stderr = std.Io.File.stderr();
+                stderr.writeStreamingAll(io_default.get(),"Error: nREPL server failed: ") catch {};
+                stderr.writeStreamingAll(io_default.get(),@errorName(e)) catch {};
+                stderr.writeStreamingAll(io_default.get(),"\n") catch {};
                 std.process.exit(1);
             };
         }
@@ -221,14 +222,14 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
         const deps_config = deps_config_opt orelse {
             // deps.edn flags used but no deps.edn found
             if (mode != .resolve_only and mode != .show_path) {
-                const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-                _ = stderr.write("Error: No deps.edn found. -A/-M/-X flags require deps.edn.\n") catch {};
+                const stderr = std.Io.File.stderr();
+                stderr.writeStreamingAll(io_default.get(),"Error: No deps.edn found. -A/-M/-X flags require deps.edn.\n") catch {};
                 std.process.exit(1);
             }
             // -P with no deps.edn is a no-op, -Spath shows "."
             if (mode == .show_path) {
-                const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-                _ = stdout.write(".\n") catch {};
+                const stdout = std.Io.File.stdout();
+                stdout.writeStreamingAll(io_default.get(),".\n") catch {};
             }
             return;
         };
@@ -241,16 +242,16 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
         const resolved = deps_mod.resolveAliases(config_alloc, deps_config, alias_names);
 
         // Print warnings
-        const stderr_file: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
+        const stderr_file = std.Io.File.stderr();
         for (resolved.warnings) |warning| {
-            _ = stderr_file.write(warning) catch {};
-            _ = stderr_file.write("\n") catch {};
+            stderr_file.writeStreamingAll(io_default.get(),warning) catch {};
+            stderr_file.writeStreamingAll(io_default.get(),"\n") catch {};
         }
 
         if (s_verbose) {
-            _ = stderr_file.write("Resolved aliases: ") catch {};
-            if (alias_str) |s| _ = stderr_file.write(s) catch {};
-            _ = stderr_file.write("\n") catch {};
+            stderr_file.writeStreamingAll(io_default.get(),"Resolved aliases: ") catch {};
+            if (alias_str) |s| stderr_file.writeStreamingAll(io_default.get(),s) catch {};
+            stderr_file.writeStreamingAll(io_default.get(),"\n") catch {};
         }
 
         // Apply resolved paths
@@ -295,24 +296,24 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
         switch (mode) {
             .resolve_only => {
                 // -P: Dependencies resolved above. Done.
-                const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-                _ = stdout.write("Dependencies resolved.\n") catch {};
+                const stdout = std.Io.File.stdout();
+                stdout.writeStreamingAll(io_default.get(),"Dependencies resolved.\n") catch {};
                 return;
             },
             .show_path => {
                 // -Spath: Print all load paths
-                const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+                const stdout = std.Io.File.stdout();
                 for (resolved.paths, 0..) |path, pi| {
-                    if (pi > 0) _ = stdout.write(":") catch {};
+                    if (pi > 0) stdout.writeStreamingAll(io_default.get(), ":") catch {};
                     if (config_dir) |dir| {
                         var buf: [4096]u8 = undefined;
                         const full = std.fmt.bufPrint(&buf, "{s}/{s}", .{ dir, path }) catch continue;
-                        _ = stdout.write(full) catch {};
+                        stdout.writeStreamingAll(io_default.get(),full) catch {};
                     } else {
-                        _ = stdout.write(path) catch {};
+                        stdout.writeStreamingAll(io_default.get(),path) catch {};
                     }
                 }
-                _ = stdout.write("\n") catch {};
+                stdout.writeStreamingAll(io_default.get(),"\n") catch {};
                 return;
             },
             .alias_repl => {
@@ -325,8 +326,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
                     const dir = std.fs.path.dirname(f) orelse ".";
                     ns_ops.addLoadPath(dir) catch {};
                     const max_file_size = 10 * 1024 * 1024;
-                    const file_bytes = std.fs.cwd().readFileAlloc(infra_alloc, f, max_file_size) catch {
-                        _ = stderr_file.write("Error: could not read file\n") catch {};
+                    const file_bytes = std.Io.Dir.cwd().readFileAlloc(io_default.get(), f, infra_alloc, .limited(max_file_size)) catch {
+                        stderr_file.writeStreamingAll(io_default.get(),"Error: could not read file\n") catch {};
                         std.process.exit(1);
                     };
                     defer infra_alloc.free(file_bytes);
@@ -353,8 +354,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
                         const dir = std.fs.path.dirname(f) orelse ".";
                         ns_ops.addLoadPath(dir) catch {};
                         const max_file_size = 10 * 1024 * 1024;
-                        const file_bytes = std.fs.cwd().readFileAlloc(infra_alloc, f, max_file_size) catch {
-                            _ = stderr_file.write("Error: could not read file\n") catch {};
+                        const file_bytes = std.Io.Dir.cwd().readFileAlloc(io_default.get(), f, infra_alloc, .limited(max_file_size)) catch {
+                            stderr_file.writeStreamingAll(io_default.get(),"Error: could not read file\n") catch {};
                             std.process.exit(1);
                         };
                         defer infra_alloc.free(file_bytes);
@@ -363,7 +364,7 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
                         runner.evalAndPrint(gc_alloc, infra_alloc, gc, file_bytes, use_vm, dump_bytecode, .file);
                         return;
                     }
-                    _ = stderr_file.write("Error: -M requires -m <namespace> or a file argument\n") catch {};
+                    stderr_file.writeStreamingAll(io_default.get(),"Error: -M requires -m <namespace> or a file argument\n") catch {};
                     std.process.exit(1);
                 };
                 runner.runMainNs(gc_alloc, infra_alloc, gc, ns, use_vm);
@@ -372,7 +373,7 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
             .exec_mode => {
                 // -X: Exec mode — invoke a function
                 const fn_name = exec_fn_arg orelse resolved.exec_fn orelse {
-                    _ = stderr_file.write("Error: -X requires a function name\n") catch {};
+                    stderr_file.writeStreamingAll(io_default.get(),"Error: -X requires a function name\n") catch {};
                     std.process.exit(1);
                 };
                 runner.runExecFn(gc_alloc, infra_alloc, gc, fn_name, exec_extra_args[0..exec_extra_count], resolved.exec_args, use_vm);
@@ -394,8 +395,8 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
     applyConfig(config, config_dir);
 
     if (s_verbose) {
-        const stderr_out: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-        _ = stderr_out.write("Verbose: standard mode (no alias flags)\n") catch {};
+        const stderr_out = std.Io.File.stderr();
+        stderr_out.writeStreamingAll(io_default.get(), "Verbose: standard mode (no alias flags)\n") catch {};
     }
     if (s_repro) {
         // -Srepro: exclude user config (no-op for now, CW has no user config dir yet)
@@ -413,9 +414,9 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
         ns_ops.detectAndAddSrcPath(dir) catch {};
 
         const max_file_size = 10 * 1024 * 1024; // 10MB
-        const file_bytes = std.fs.cwd().readFileAlloc(infra_alloc, f, max_file_size) catch {
-            const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-            _ = stderr.write("Error: could not read file (max 10MB)\n") catch {};
+        const file_bytes = std.Io.Dir.cwd().readFileAlloc(io_default.get(), f, infra_alloc, .limited(max_file_size)) catch {
+            const stderr = std.Io.File.stderr();
+            stderr.writeStreamingAll(io_default.get(),"Error: could not read file (max 10MB)\n") catch {};
             std.process.exit(1);
         };
         defer infra_alloc.free(file_bytes);
@@ -440,11 +441,11 @@ pub fn run(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc,
 /// Handle `cljw new <project-name>` subcommand.
 /// Creates a new project directory with deps.edn, src/, and test/ scaffolding.
 pub fn handleNewCommand(new_args: []const [:0]const u8) void {
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+    const stderr = std.Io.File.stderr();
+    const stdout = std.Io.File.stdout();
 
     if (new_args.len == 0) {
-        _ = stderr.write("Usage: cljw new <project-name>\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Usage: cljw new <project-name>\n") catch {};
         std.process.exit(1);
     }
 
@@ -453,7 +454,7 @@ pub fn handleNewCommand(new_args: []const [:0]const u8) void {
     // Validate project name (alphanumeric, hyphens, underscores)
     for (project_name) |c| {
         if (!std.ascii.isAlphanumeric(c) and c != '-' and c != '_' and c != '.') {
-            _ = stderr.write("Error: invalid project name (use alphanumeric, hyphens, underscores)\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error: invalid project name (use alphanumeric, hyphens, underscores)\n") catch {};
             std.process.exit(1);
         }
     }
@@ -462,7 +463,7 @@ pub fn handleNewCommand(new_args: []const [:0]const u8) void {
     var ns_name_buf: [256]u8 = undefined;
     const ns_name = blk: {
         if (project_name.len > ns_name_buf.len) {
-            _ = stderr.write("Error: project name too long\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error: project name too long\n") catch {};
             std.process.exit(1);
         }
         @memcpy(ns_name_buf[0..project_name.len], project_name);
@@ -481,68 +482,65 @@ pub fn handleNewCommand(new_args: []const [:0]const u8) void {
     };
 
     // Create project directory
-    std.fs.cwd().makeDir(project_name) catch |e| {
+    std.Io.Dir.cwd().createDir(io_default.get(), project_name, .default_dir) catch |e| {
         if (e == error.PathAlreadyExists) {
-            _ = stderr.write("Error: directory already exists\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error: directory already exists\n") catch {};
         } else {
-            _ = stderr.write("Error creating directory\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error creating directory\n") catch {};
         }
         std.process.exit(1);
     };
 
-    var project_dir = std.fs.cwd().openDir(project_name, .{}) catch {
-        _ = stderr.write("Error: cannot open project directory\n") catch {};
+    var project_dir = std.Io.Dir.cwd().openDir(io_default.get(), project_name, .{}) catch {
+        stderr.writeStreamingAll(io_default.get(),"Error: cannot open project directory\n") catch {};
         std.process.exit(1);
     };
-    defer project_dir.close();
+    defer project_dir.close(io_default.get());
+
+    const proj_io = io_default.get();
 
     // Create subdirectories
-    project_dir.makePath("src") catch {};
-    project_dir.makePath("test") catch {};
+    project_dir.createDirPath(proj_io, "src") catch {};
+    project_dir.createDirPath(proj_io, "test") catch {};
+
+    // Helper: write a file inside project_dir with the given contents.
+    const writeProjectFile = struct {
+        fn run(dir: *std.Io.Dir, w_io: std.Io, sub_path: []const u8, contents: []const u8) void {
+            const f = dir.createFile(w_io, sub_path, .{}) catch return;
+            defer f.close(w_io);
+            f.writeStreamingAll(w_io, contents) catch {};
+        }
+    }.run;
 
     // Write deps.edn
     {
         var buf: [1024]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buf);
-        const w = stream.writer();
-        w.print("{{:paths [\"src\"]\n :deps {{}}\n :aliases\n {{:test {{:extra-paths [\"test\"]}}}}}}\n", .{}) catch {};
-        project_dir.writeFile(.{ .sub_path = "deps.edn", .data = stream.getWritten() }) catch {};
+        const data = std.fmt.bufPrint(&buf, "{{:paths [\"src\"]\n :deps {{}}\n :aliases\n {{:test {{:extra-paths [\"test\"]}}}}}}\n", .{}) catch return;
+        writeProjectFile(&project_dir, proj_io, "deps.edn", data);
     }
 
     // Write src/<file_name>.clj
     {
         var path_buf: [512]u8 = undefined;
-        var path_stream = std.io.fixedBufferStream(&path_buf);
-        path_stream.writer().print("src/{s}.clj", .{file_name}) catch {};
-        const src_path = path_stream.getWritten();
-
+        const src_path = std.fmt.bufPrint(&path_buf, "src/{s}.clj", .{file_name}) catch return;
         var buf: [1024]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buf);
-        const w = stream.writer();
-        w.print("(ns {s})\n\n(defn -main [& args]\n  (println \"Hello from {s}!\"))\n", .{ ns_name, ns_name }) catch {};
-        project_dir.writeFile(.{ .sub_path = src_path, .data = stream.getWritten() }) catch {};
+        const data = std.fmt.bufPrint(&buf, "(ns {s})\n\n(defn -main [& args]\n  (println \"Hello from {s}!\"))\n", .{ ns_name, ns_name }) catch return;
+        writeProjectFile(&project_dir, proj_io, src_path, data);
     }
 
     // Write test/<file_name>_test.clj
     {
         var path_buf: [512]u8 = undefined;
-        var path_stream = std.io.fixedBufferStream(&path_buf);
-        path_stream.writer().print("test/{s}_test.clj", .{file_name}) catch {};
-        const test_path = path_stream.getWritten();
-
+        const test_path = std.fmt.bufPrint(&path_buf, "test/{s}_test.clj", .{file_name}) catch return;
         var buf: [1024]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buf);
-        const w = stream.writer();
-        w.print("(ns {s}-test\n  (:require [clojure.test :refer [deftest is testing run-tests]]\n            [{s} :refer :all]))\n\n(deftest greeting-test\n  (testing \"main function\"\n    (is (= 1 1))))\n\n(run-tests)\n", .{ ns_name, ns_name }) catch {};
-        project_dir.writeFile(.{ .sub_path = test_path, .data = stream.getWritten() }) catch {};
+        const data = std.fmt.bufPrint(&buf, "(ns {s}-test\n  (:require [clojure.test :refer [deftest is testing run-tests]]\n            [{s} :refer :all]))\n\n(deftest greeting-test\n  (testing \"main function\"\n    (is (= 1 1))))\n\n(run-tests)\n", .{ ns_name, ns_name }) catch return;
+        writeProjectFile(&project_dir, proj_io, test_path, data);
     }
 
     {
         var msg_buf: [1024]u8 = undefined;
-        var msg_stream = std.io.fixedBufferStream(&msg_buf);
-        const w = msg_stream.writer();
-        w.print("Project '{s}' created!\n\n  cd {s}\n  cljw -M -m {s}    # Run main\n  cljw test          # Run tests\n  cljw               # Start REPL\n", .{ project_name, project_name, ns_name }) catch {};
-        _ = stdout.write(msg_stream.getWritten()) catch {};
+        const msg = std.fmt.bufPrint(&msg_buf, "Project '{s}' created!\n\n  cd {s}\n  cljw -M -m {s}    # Run main\n  cljw test          # Run tests\n  cljw               # Start REPL\n", .{ project_name, project_name, ns_name }) catch return;
+        stdout.writeStreamingAll(proj_io, msg) catch {};
     }
 }
 
@@ -592,16 +590,16 @@ pub fn findDepsEdnFile(allocator: Allocator, start_dir: ?[]const u8) ?DepsEdnFil
 fn readFileFromDir(allocator: Allocator, dir: []const u8, filename: []const u8) ?[]const u8 {
     var buf: [4096]u8 = undefined;
     const path = std.fmt.bufPrint(&buf, "{s}/{s}", .{ dir, filename }) catch return null;
-    return std.fs.cwd().readFileAlloc(allocator, path, 10_000) catch null;
+    return std.Io.Dir.cwd().readFileAlloc(io_default.get(), path, allocator, .limited(10_000)) catch null;
 }
 
 /// Convert a DepsConfig (from deps.zig parser) to ProjectConfig for applyConfig.
 fn projectConfigFromDepsConfig(allocator: Allocator, deps_config: deps_mod.DepsConfig) ProjectConfig {
     // Print warnings to stderr
-    const stderr_file: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
+    const stderr_file = std.Io.File.stderr();
     for (deps_config.warnings) |warning| {
-        _ = stderr_file.write(warning) catch {};
-        _ = stderr_file.write("\n") catch {};
+        stderr_file.writeStreamingAll(io_default.get(),warning) catch {};
+        stderr_file.writeStreamingAll(io_default.get(),"\n") catch {};
     }
 
     // Convert deps
@@ -729,17 +727,17 @@ fn warnIfLeinProject(dir: []const u8) void {
     var buf: [4096]u8 = undefined;
     const path = std.fmt.bufPrint(&buf, "{s}/project.clj", .{dir}) catch return;
     // Check if project.clj exists
-    std.fs.cwd().access(path, .{}) catch return;
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-    _ = stderr.write("Warning: Found project.clj (Leiningen) but no deps.edn. ClojureWasm uses deps.edn for dependencies.\n") catch {};
-    _ = stderr.write("  Run 'cljw new <name>' to create a deps.edn project, or create deps.edn manually.\n") catch {};
+    std.Io.Dir.cwd().access(io_default.get(),path, .{}) catch return;
+    const stderr = std.Io.File.stderr();
+    stderr.writeStreamingAll(io_default.get(),"Warning: Found project.clj (Leiningen) but no deps.edn. ClojureWasm uses deps.edn for dependencies.\n") catch {};
+    stderr.writeStreamingAll(io_default.get(),"  Run 'cljw new <name>' to create a deps.edn project, or create deps.edn manually.\n") catch {};
 }
 
 pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_root: ?[]const u8, force: bool, resolve_deps: bool, allow_fetch: bool) void {
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
+    const stderr = std.Io.File.stderr();
 
     // Cache location: ~/.cljw/gitlibs/<sha-prefix>/<repo-name>
-    const home = std.posix.getenv("HOME") orelse return;
+    const home = io_default.getEnv("HOME") orelse return;
     var dir_buf: [4096]u8 = undefined;
 
     // Extract repo name from URL (last path component, without .git)
@@ -757,7 +755,7 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
 
     // Check if already cached
     if (!force) {
-        if (std.fs.cwd().access(cache_dir, .{})) |_| {
+        if (std.Io.Dir.cwd().access(io_default.get(),cache_dir, .{})) |_| {
             // Already cached — add to load path
             if (deps_root) |root| {
                 var root_buf: [4096]u8 = undefined;
@@ -811,23 +809,23 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
 
     if (!allow_fetch) {
         // Not cached and not allowed to fetch
-        _ = stderr.write("Warning: git dependency not cached: ") catch {};
-        _ = stderr.write(url) catch {};
-        _ = stderr.write("\n  Run 'cljw -P' to download dependencies first.\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Warning: git dependency not cached: ") catch {};
+        stderr.writeStreamingAll(io_default.get(),url) catch {};
+        stderr.writeStreamingAll(io_default.get(),"\n  Run 'cljw -P' to download dependencies first.\n") catch {};
         return;
     }
 
     // Clone the repo
-    _ = stderr.write("Fetching: ") catch {};
-    _ = stderr.write(url) catch {};
-    _ = stderr.write(" @ ") catch {};
-    _ = stderr.write(sha) catch {};
-    _ = stderr.write("\n") catch {};
+    stderr.writeStreamingAll(io_default.get(),"Fetching: ") catch {};
+    stderr.writeStreamingAll(io_default.get(),url) catch {};
+    stderr.writeStreamingAll(io_default.get()," @ ") catch {};
+    stderr.writeStreamingAll(io_default.get(),sha) catch {};
+    stderr.writeStreamingAll(io_default.get(),"\n") catch {};
 
     // Create parent directories
     var parent_buf: [4096]u8 = undefined;
     const parent_dir = std.fmt.bufPrint(&parent_buf, "{s}/.cljw/gitlibs/{s}", .{ home, sha_prefix }) catch return;
-    std.fs.cwd().makePath(parent_dir) catch {};
+    std.Io.Dir.cwd().createDirPath(io_default.get(),parent_dir) catch {};
 
     // Clone and checkout specific SHA
     // Use a temp dir, then rename to final location
@@ -835,7 +833,7 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
     const tmp_dir = std.fmt.bufPrint(&tmp_buf, "{s}/.cljw/gitlibs/.tmp-{s}", .{ home, sha_prefix }) catch return;
 
     // Clean up any leftover tmp dir
-    std.fs.cwd().deleteTree(tmp_dir) catch {};
+    std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
 
     // git clone --depth 1 (for tag) or full clone (for arbitrary sha)
     var clone_buf: [8192]u8 = undefined;
@@ -844,21 +842,20 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
     else
         std.fmt.bufPrint(&clone_buf, "git clone {s} {s} 2>&1", .{ url, tmp_dir }) catch return;
 
-    const clone_result = std.process.Child.run(.{
-        .allocator = std.heap.page_allocator,
+    const clone_result = std.process.run(std.heap.page_allocator, io_default.get(), .{
         .argv = &.{ "/bin/sh", "-c", clone_cmd },
     }) catch {
-        _ = stderr.write("Error: git clone failed\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Error: git clone failed\n") catch {};
         return;
     };
     defer std.heap.page_allocator.free(clone_result.stdout);
     defer std.heap.page_allocator.free(clone_result.stderr);
 
-    if (clone_result.term.Exited != 0) {
-        _ = stderr.write("Error: git clone failed: ") catch {};
-        _ = stderr.write(clone_result.stderr) catch {};
-        _ = stderr.write("\n") catch {};
-        std.fs.cwd().deleteTree(tmp_dir) catch {};
+    if (clone_result.term.exited != 0) {
+        stderr.writeStreamingAll(io_default.get(),"Error: git clone failed: ") catch {};
+        stderr.writeStreamingAll(io_default.get(),clone_result.stderr) catch {};
+        stderr.writeStreamingAll(io_default.get(),"\n") catch {};
+        std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
         return;
     }
 
@@ -867,12 +864,12 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
         var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
         defer arena.deinit();
         if (!validateGitTag(arena.allocator(), tmp_dir, t, sha)) {
-            _ = stderr.write("ERROR: Git tag \"") catch {};
-            _ = stderr.write(t) catch {};
-            _ = stderr.write("\" does not match SHA ") catch {};
-            _ = stderr.write(sha) catch {};
-            _ = stderr.write("\n") catch {};
-            std.fs.cwd().deleteTree(tmp_dir) catch {};
+            stderr.writeStreamingAll(io_default.get(),"ERROR: Git tag \"") catch {};
+            stderr.writeStreamingAll(io_default.get(),t) catch {};
+            stderr.writeStreamingAll(io_default.get(),"\" does not match SHA ") catch {};
+            stderr.writeStreamingAll(io_default.get(),sha) catch {};
+            stderr.writeStreamingAll(io_default.get(),"\n") catch {};
+            std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
             return;
         }
     }
@@ -881,30 +878,29 @@ pub fn resolveGitDep(url: []const u8, sha: []const u8, tag: ?[]const u8, deps_ro
     if (tag == null) {
         var checkout_buf: [8192]u8 = undefined;
         const checkout_cmd = std.fmt.bufPrint(&checkout_buf, "cd {s} && git checkout {s} 2>&1", .{ tmp_dir, sha }) catch return;
-        const checkout_result = std.process.Child.run(.{
-            .allocator = std.heap.page_allocator,
+        const checkout_result = std.process.run(std.heap.page_allocator, io_default.get(), .{
             .argv = &.{ "/bin/sh", "-c", checkout_cmd },
         }) catch {
-            _ = stderr.write("Error: git checkout failed\n") catch {};
-            std.fs.cwd().deleteTree(tmp_dir) catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error: git checkout failed\n") catch {};
+            std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
             return;
         };
         defer std.heap.page_allocator.free(checkout_result.stdout);
         defer std.heap.page_allocator.free(checkout_result.stderr);
 
-        if (checkout_result.term.Exited != 0) {
-            _ = stderr.write("Error: git checkout failed: ") catch {};
-            _ = stderr.write(checkout_result.stderr) catch {};
-            _ = stderr.write("\n") catch {};
-            std.fs.cwd().deleteTree(tmp_dir) catch {};
+        if (checkout_result.term.exited != 0) {
+            stderr.writeStreamingAll(io_default.get(),"Error: git checkout failed: ") catch {};
+            stderr.writeStreamingAll(io_default.get(),checkout_result.stderr) catch {};
+            stderr.writeStreamingAll(io_default.get(),"\n") catch {};
+            std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
             return;
         }
     }
 
     // Rename to final location
-    std.fs.cwd().rename(tmp_dir, cache_dir) catch {
+    std.Io.Dir.rename(std.Io.Dir.cwd(), tmp_dir, std.Io.Dir.cwd(), cache_dir, io_default.get()) catch {
         // If target already exists (race condition), that's fine — use it
-        std.fs.cwd().deleteTree(tmp_dir) catch {};
+        std.Io.Dir.cwd().deleteTree(io_default.get(),tmp_dir) catch {};
     };
 
     // Add to load path
@@ -961,14 +957,13 @@ fn validateGitTag(alloc: Allocator, repo_dir: []const u8, tag_name: []const u8,
     var cmd_buf: [8192]u8 = undefined;
     const cmd = std.fmt.bufPrint(&cmd_buf, "cd {s} && git rev-parse {s}^{{commit}} 2>/dev/null || git rev-parse {s} 2>/dev/null", .{ repo_dir, tag_name, tag_name }) catch return false;
 
-    const result = std.process.Child.run(.{
-        .allocator = alloc,
+    const result = std.process.run(alloc, io_default.get(), .{
         .argv = &.{ "/bin/sh", "-c", cmd },
     }) catch return false;
     defer alloc.free(result.stdout);
     defer alloc.free(result.stderr);
 
-    if (result.term.Exited != 0) return false;
+    if (result.term.exited != 0) return false;
 
     const tag_sha = std.mem.trim(u8, result.stdout, " \t\r\n");
     if (tag_sha.len == 0) return false;
diff --git a/src/app/repl/nrepl.zig b/src/app/repl/nrepl.zig
index fd82d547..b0da2087 100644
--- a/src/app/repl/nrepl.zig
+++ b/src/app/repl/nrepl.zig
@@ -6,1813 +6,44 @@
 // the terms of this license.
 // You must not remove this notice, or any other, from this software.
 
-//! nREPL server — TCP-based nREPL protocol implementation.
+//! nREPL server — stubbed during the Zig 0.16 migration.
 //!
-//! CIDER/Calva/Conjure compatible minimum ops:
-//! clone, close, describe, eval, load-file,
-//! completions, info, lookup, eldoc, ls-sessions, ns-list
+//! The full implementation (~1800 lines covering bencode dispatch,
+//! session/state, eval/load-file/completions/info/eldoc ops, lookup,
+//! ns-list, stacktrace) was built on std.net.{Server,Stream}, std.Thread.{
+//! Mutex,Condition} and std.posix.poll — all of which were removed or
+//! reshaped in Zig 0.16. The original code is preserved in git history
+//! (`git show develop/zig-016-migration~N:src/app/repl/nrepl.zig`) and
+//! will be ported back in a Phase 7 follow-up F## task once the std.Io.net
+//! migration patterns are established. The accept loop, in particular,
+//! needs to integrate with the new lifecycle.acceptWithShutdownCheck
+//! (also stubbed) on top of std.Io.net.Server.
 
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const bencode = @import("bencode.zig");
-const BencodeValue = bencode.BencodeValue;
-const clj = @import("../../root.zig");
-const Env = clj.env.Env;
-const Namespace = clj.namespace.Namespace;
-const Value = clj.value.Value;
-const Var = clj.var_mod.Var;
-const bootstrap = clj.bootstrap;
-const io_mod = clj.builtin_io;
-const registry = clj.builtin_registry;
-const err_mod = clj.err;
-const lifecycle = @import("../../runtime/lifecycle.zig");
+const Env = @import("../../runtime/env.zig").Env;
 const gc_mod = @import("../../runtime/gc.zig");
 
-// ====================================================================
-// Types
-// ====================================================================
+pub const StartError = error{NreplDisabledDuringMigration};
 
-/// Session — tracks per-client state.
-const Session = struct {
-    id: []const u8,
-    ns_name: []const u8,
-};
-
-/// Server state shared across all client threads.
-pub const ServerState = struct {
-    env: *Env,
-    sessions: std.StringHashMapUnmanaged(Session),
-    mutex: std.Thread.Mutex,
-    running: bool,
-    gpa: Allocator,
-    gc: ?*gc_mod.MarkSweepGc,
-    port_file_written: bool,
-    /// Last error info saved from eval (for stacktrace op).
-    last_error_info: ?err_mod.Info = null,
-    /// Saved call stack frames from last eval error.
-    last_error_stack: [64]err_mod.StackFrame = @splat(err_mod.StackFrame{}),
-    last_error_stack_depth: u8 = 0,
-    /// Persistent copy of error message (msg_buf is threadlocal and gets overwritten).
-    last_error_msg_buf: [512]u8 = undefined,
-    /// Active client threads (joined on shutdown to prevent memory leaks).
-    client_threads: std.ArrayList(std.Thread) = .empty,
-    /// Active client streams (closed on shutdown to unblock read).
-    client_streams: std.ArrayList(std.net.Stream) = .empty,
-};
-
-// ====================================================================
-// Server entry point
-// ====================================================================
-
-/// Start the nREPL server on the given port (0 = OS auto-assign).
-/// Bootstraps its own Env from scratch with GC for Value collection.
-pub fn startServer(gpa_allocator: Allocator, port: u16) !void {
-    // Two allocators: GPA for infrastructure, GC for Values.
-    // GC collects transient Values after each eval (F113).
-    var gc = gc_mod.MarkSweepGc.init(gpa_allocator);
-    defer gc.deinit();
-    const gc_alloc = gc.allocator();
-
-    var env = Env.init(gpa_allocator);
-    defer env.deinit();
-    env.gc = @ptrCast(&gc);
-    @import("../../runtime/wasm_types.zig").setGc(&gc);
-
-    registry.registerBuiltins(&env) catch {
-        std.debug.print("Error: failed to register builtins\n", .{});
-        return;
-    };
-    bootstrap.loadCore(gc_alloc, &env) catch {
-        std.debug.print("Error: failed to load core.clj\n", .{});
-        return;
-    };
-    bootstrap.loadTest(gc_alloc, &env) catch {
-        std.debug.print("Error: failed to load clojure.test\n", .{});
-        return;
-    };
-    // clojure.set is now registered as Zig builtins in registry.zig (Phase B.6)
-
-    // Grow threshold after bootstrap (many live Values in Vars)
-    gc.threshold = @max(gc.bytes_allocated * 2, gc.threshold);
-
-    // Define REPL vars (*1, *2, *3, *e)
-    _ = bootstrap.evalString(gc_alloc, &env, "(def *1 nil) (def *2 nil) (def *3 nil) (def *e nil)") catch {};
-
-    try runServerLoop(gpa_allocator, &env, &gc, port);
-}
-
-/// Start nREPL server on an already-bootstrapped Env.
-/// Used by built binaries (cljw build) with --nrepl flag.
-pub fn startServerWithEnv(gpa_allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc, port: u16) !void {
-    // Ensure REPL vars exist (*e may not be defined in user code)
-    _ = bootstrap.evalString(gc.allocator(), env, "(def *e nil)") catch {};
-
-    try runServerLoop(gpa_allocator, env, gc, port);
-}
-
-/// TCP listen/accept loop shared by startServer and startServerWithEnv.
-fn runServerLoop(gpa_allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc, port: u16) !void {
-    var state = ServerState{
-        .env = env,
-        .sessions = .empty,
-        .mutex = .{},
-        .running = true,
-        .gpa = gpa_allocator,
-        .gc = gc,
-        .port_file_written = false,
-    };
-    defer {
-        if (state.port_file_written) {
-            std.fs.cwd().deleteFile(".nrepl-port") catch {};
-        }
-        // Shutdown client sockets to unblock read() (returns 0/EOF), then join threads.
-        // Using shutdown() instead of close() avoids double-close — handleClient
-        // will close() the fd after messageLoop exits.
-        // Use raw syscall because std.posix.shutdown maps BADF to unreachable/panic,
-        // but the client may have already disconnected and closed the fd.
-        for (state.client_streams.items) |s| {
-            _ = std.posix.system.shutdown(s.handle, 2); // SHUT_RDWR = 2
-        }
-        state.client_streams.deinit(gpa_allocator);
-        for (state.client_threads.items) |t| {
-            t.join();
-        }
-        state.client_threads.deinit(gpa_allocator);
-        // Free sessions
-        var iter = state.sessions.iterator();
-        while (iter.next()) |entry| {
-            gpa_allocator.free(entry.value_ptr.id);
-            gpa_allocator.free(entry.value_ptr.ns_name);
-        }
-        state.sessions.deinit(gpa_allocator);
-    }
-
-    // TCP listen
-    const address = std.net.Address.parseIp("127.0.0.1", port) catch unreachable;
-    var server = try address.listen(.{ .reuse_address = true });
-    defer server.deinit();
-
-    const actual_port = server.listen_address.getPort();
-
-    // Write .nrepl-port file
-    {
-        var port_buf: [10]u8 = undefined;
-        const port_str = std.fmt.bufPrint(&port_buf, "{d}", .{actual_port}) catch unreachable;
-        std.fs.cwd().writeFile(.{ .sub_path = ".nrepl-port", .data = port_str }) catch {};
-        state.port_file_written = true;
-    }
-
-    std.debug.print("nREPL server started on port {d} on host 127.0.0.1 - nrepl://127.0.0.1:{d}\n", .{ actual_port, actual_port });
-
-    // Accept loop (poll-based with shutdown check)
-    while (state.running and !lifecycle.isShutdownRequested()) {
-        const conn = lifecycle.acceptWithShutdownCheck(&server) orelse break;
-
-        const thread = std.Thread.spawn(.{}, handleClient, .{ &state, conn }) catch |e| {
-            std.debug.print("thread spawn error: {s}\n", .{@errorName(e)});
-            conn.stream.close();
-            continue;
-        };
-        state.client_threads.append(gpa_allocator, thread) catch {
-            thread.detach();
-            continue;
-        };
-        state.client_streams.append(gpa_allocator, conn.stream) catch {};
-    }
-
-    std.debug.print("nREPL server shutting down\n", .{});
-}
-
-/// Client connection handler (thread entry).
-fn handleClient(state: *ServerState, conn: std.net.Server.Connection) void {
-    defer conn.stream.close();
-    messageLoop(state, conn.stream);
-}
-
-/// Bencode message loop — read, decode, dispatch.
-fn messageLoop(state: *ServerState, stream: std.net.Stream) void {
-    var recv_buf: [65536]u8 = undefined;
-    var pending: std.ArrayList(u8) = .empty;
-    defer pending.deinit(state.gpa);
-
-    while (true) {
-        const n = stream.read(&recv_buf) catch break;
-        if (n == 0) break;
-
-        pending.appendSlice(state.gpa, recv_buf[0..n]) catch break;
-
-        while (pending.items.len > 0) {
-            var arena = std.heap.ArenaAllocator.init(state.gpa);
-            defer arena.deinit();
-
-            const result = bencode.decode(arena.allocator(), pending.items) catch |e| {
-                switch (e) {
-                    error.UnexpectedEof => break,
-                    else => return,
-                }
-            };
-
-            const msg = switch (result.value) {
-                .dict => |d| d,
-                else => {
-                    shiftPending(&pending, result.consumed);
-                    continue;
-                },
-            };
-
-            dispatchOp(state, msg, stream, arena.allocator());
-            shiftPending(&pending, result.consumed);
-        }
-    }
+pub fn startServer(gpa_allocator: Allocator, port: u16) StartError!void {
+    _ = gpa_allocator;
+    _ = port;
+    std.debug.print(
+        \\nrepl: temporarily disabled while the std.net → std.Io.net migration
+        \\       lands. Tracked as a Phase 7 follow-up. Use cljw -e/--repl in
+        \\       the meantime.
+        \\
+    , .{});
+    return error.NreplDisabledDuringMigration;
 }
 
-/// Remove consumed bytes from pending buffer.
-fn shiftPending(pending: *std.ArrayList(u8), n: usize) void {
-    if (n >= pending.items.len) {
-        pending.clearRetainingCapacity();
-    } else {
-        std.mem.copyForwards(u8, pending.items[0..], pending.items[n..]);
-        pending.items.len -= n;
-    }
-}
-
-// ====================================================================
-// Op dispatch
-// ====================================================================
-
-/// Unified op handler signature.
-const OpHandler = *const fn (*ServerState, []const BencodeValue.DictEntry, std.net.Stream, Allocator) void;
-
-/// Dispatch table entry: op name -> handler function.
-const OpEntry = struct {
-    name: []const u8,
-    handler: OpHandler,
-};
-
-/// Comptime dispatch table — all supported nREPL ops.
-const op_table = [_]OpEntry{
-    .{ .name = "clone", .handler = opClone },
-    .{ .name = "close", .handler = opClose },
-    .{ .name = "describe", .handler = opDescribe },
-    .{ .name = "eval", .handler = opEval },
-    .{ .name = "load-file", .handler = opLoadFile },
-    .{ .name = "ls-sessions", .handler = opLsSessions },
-    .{ .name = "completions", .handler = opCompletions },
-    .{ .name = "complete", .handler = opCompletions },
-    .{ .name = "info", .handler = opInfo },
-    .{ .name = "lookup", .handler = opInfo },
-    .{ .name = "eldoc", .handler = opEldoc },
-    .{ .name = "ns-list", .handler = opNsList },
-    .{ .name = "stdin", .handler = opStdin },
-    .{ .name = "interrupt", .handler = opInterrupt },
-    .{ .name = "stacktrace", .handler = opStacktrace },
-    .{ .name = "analyze-last-stacktrace", .handler = opStacktrace },
-    .{ .name = "macroexpand", .handler = opMacroexpand },
-};
-
-/// Route incoming message to the appropriate op handler.
-fn dispatchOp(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const op = bencode.dictGetString(msg, "op") orelse {
-        sendError(stream, msg, "missing-op", "No op specified", allocator);
-        return;
-    };
-
-    inline for (op_table) |entry| {
-        if (std.mem.eql(u8, op, entry.name)) {
-            entry.handler(state, msg, stream, allocator);
-            return;
-        }
-    }
-
-    // Unknown op — return done so editors don't hang
-    sendDone(stream, msg, allocator);
-}
-
-// ====================================================================
-// Op implementations
-// ====================================================================
-
-/// clone: create a new session.
-fn opClone(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const session_id = generateUUID(allocator) catch return;
-
-    state.mutex.lock();
-    const ns_name = state.gpa.dupe(u8, "user") catch {
-        state.mutex.unlock();
-        return;
-    };
-    const id_persistent = state.gpa.dupe(u8, session_id) catch {
-        state.mutex.unlock();
-        return;
-    };
-    state.sessions.put(state.gpa, id_persistent, .{
-        .id = id_persistent,
-        .ns_name = ns_name,
-    }) catch {
-        state.mutex.unlock();
-        return;
-    };
-    state.mutex.unlock();
-
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        .{ .key = "new-session", .value = .{ .string = session_id } },
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// close: destroy a session.
-fn opClose(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    if (bencode.dictGetString(msg, "session")) |sid| {
-        state.mutex.lock();
-        if (state.sessions.fetchRemove(sid)) |entry| {
-            state.gpa.free(entry.value.id);
-            state.gpa.free(entry.value.ns_name);
-        }
-        state.mutex.unlock();
-    }
-    sendDone(stream, msg, allocator);
-}
-
-/// describe: server information and supported ops.
-fn opDescribe(
-    _: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    // Generate ops dict from dispatch table (single source of truth)
-    const ops_entries = comptime blk: {
-        var entries: [op_table.len]BencodeValue.DictEntry = undefined;
-        for (op_table, 0..) |entry, i| {
-            entries[i] = .{ .key = entry.name, .value = .{ .dict = &.{} } };
-        }
-        break :blk entries;
-    };
-
-    const version_entries = [_]BencodeValue.DictEntry{
-        .{ .key = "major", .value = .{ .integer = 0 } },
-        .{ .key = "minor", .value = .{ .integer = 3 } },
-        .{ .key = "incremental", .value = .{ .integer = 0 } },
-    };
-
-    const clj_version = [_]BencodeValue.DictEntry{
-        .{ .key = "major", .value = .{ .integer = 1 } },
-        .{ .key = "minor", .value = .{ .integer = 11 } },
-        .{ .key = "incremental", .value = .{ .integer = 0 } },
-        .{ .key = "qualifier", .value = .{ .string = "" } },
-    };
-
-    const aux_entries = [_]BencodeValue.DictEntry{
-        .{ .key = "current-ns", .value = .{ .string = "user" } },
-    };
-
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        .{ .key = "ops", .value = .{ .dict = &ops_entries } },
-        .{ .key = "versions", .value = .{ .dict = &.{
-            .{ .key = "clojure-wasm", .value = .{ .dict = &version_entries } },
-            .{ .key = "clojure", .value = .{ .dict = &clj_version } },
-            .{ .key = "nrepl", .value = .{ .dict = &version_entries } },
-        } } },
-        .{ .key = "aux", .value = .{ .dict = &aux_entries } },
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// eval: evaluate Clojure code.
-fn opEval(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const code = bencode.dictGetString(msg, "code") orelse {
-        sendError(stream, msg, "eval-error", "No code provided", allocator);
-        return;
-    };
-
-    // Input size limit for nREPL (1MB)
-    if (code.len > 1_048_576) {
-        sendError(stream, msg, "eval-error", "Input exceeds maximum size (1MB)", allocator);
-        return;
-    }
-
-    // Resolve session namespace
-    const session_id = bencode.dictGetString(msg, "session");
-    const ns_name = if (bencode.dictGetString(msg, "ns")) |n|
-        n
-    else if (session_id) |sid| blk: {
-        state.mutex.lock();
-        defer state.mutex.unlock();
-        break :blk if (state.sessions.get(sid)) |s| s.ns_name else "user";
-    } else "user";
-
-    // Serialize evaluation
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    // Switch namespace
-    if (state.env.findNamespace(ns_name)) |ns| {
-        state.env.current_ns = ns;
-    }
-
-    // Set source file from nREPL message (CIDER sends "file" key for eval-in-buffer)
-    const err_import = @import("../../runtime/error.zig");
-    const nrepl_file = bencode.dictGetString(msg, "file");
-    const prev_source_file = err_import.getSourceFile();
-    if (nrepl_file) |f| {
-        err_import.setSourceFile(f);
-    }
-    defer err_import.setSourceFile(prev_source_file);
-
-    // Set up output capture
-    var capture_buf: std.ArrayList(u8) = .empty;
-    defer capture_buf.deinit(state.gpa);
-    io_mod.setOutputCapture(state.gpa, &capture_buf);
-    defer io_mod.setOutputCapture(null, null);
-
-    // Use GC allocator for Value allocation so transient values are collected.
-    const eval_alloc = if (state.gc) |gc| gc.allocator() else state.gpa;
-
-    // Dupe code with eval allocator so it outlives the message decode arena.
-    // evalString's Reader and Analyzer may reference the source string.
-    const code_persistent = eval_alloc.dupe(u8, code) catch {
-        sendError(stream, msg, "eval-error", "Out of memory", allocator);
-        return;
-    };
-
-    // Evaluate via bootstrap (TreeWalk) using GC allocator for Value allocation.
-    const result = bootstrap.evalString(eval_alloc, state.env, code_persistent);
-
-    // Flush captured output
-    if (capture_buf.items.len > 0) {
-        const out_entries = [_]BencodeValue.DictEntry{
-            idEntry(msg),
-            sessionEntry(msg),
-            .{ .key = "out", .value = .{ .string = capture_buf.items } },
-        };
-        sendBencode(stream, &out_entries, allocator);
-    }
-
-    if (result) |val| {
-        // Update *1, *2, *3 (shift history)
-        updateReplVar(state, "*3", "*2");
-        updateReplVar(state, "*2", "*1");
-        setReplVar(state, "*1", val);
-
-        // Format value as string
-        var val_buf: [65536]u8 = undefined;
-        var val_stream = std.io.fixedBufferStream(&val_buf);
-        writeValue(val_stream.writer(), val);
-        const val_str = val_stream.getWritten();
-
-        const current_ns_name = if (state.env.current_ns) |ns| ns.name else "user";
-
-        const val_entries = [_]BencodeValue.DictEntry{
-            idEntry(msg),
-            sessionEntry(msg),
-            .{ .key = "value", .value = .{ .string = val_str } },
-            .{ .key = "ns", .value = .{ .string = current_ns_name } },
-        };
-        sendBencode(stream, &val_entries, allocator);
-        sendDone(stream, msg, allocator);
-    } else |_| {
-        // Error — bind *e and save error state for stacktrace op
-        const err_info = err_import.getLastError();
-        const err_msg = if (err_info) |info| info.message else "evaluation failed";
-
-        setReplVar(state, "*e", Value.initString(allocator, err_msg));
-
-        // Save error info into ServerState for stacktrace op
-        err_import.saveCallStack();
-        const saved_stack = err_import.getSavedCallStack();
-        state.last_error_stack_depth = @intCast(saved_stack.len);
-        if (saved_stack.len > 0) {
-            @memcpy(state.last_error_stack[0..saved_stack.len], saved_stack);
-        }
-        if (err_info) |info| {
-            // Copy message to persistent buffer (threadlocal msg_buf gets overwritten)
-            const msg_len = @min(info.message.len, state.last_error_msg_buf.len);
-            @memcpy(state.last_error_msg_buf[0..msg_len], info.message[0..msg_len]);
-            state.last_error_info = .{
-                .kind = info.kind,
-                .phase = info.phase,
-                .message = state.last_error_msg_buf[0..msg_len],
-                .location = info.location,
-            };
-        } else {
-            state.last_error_info = null;
-        }
-
-        sendEvalError(stream, msg, err_msg, err_info, allocator);
-        err_import.clearCallStack();
-    }
-
-    // Update session namespace
-    if (session_id) |sid| {
-        if (state.sessions.getPtr(sid)) |session| {
-            if (state.env.current_ns) |ns| {
-                state.gpa.free(session.ns_name);
-                session.ns_name = state.gpa.dupe(u8, ns.name) catch session.ns_name;
-            }
-        }
-    }
-
-    // GC safe point — collect transient Values after eval (F113)
-    if (state.gc) |gc| {
-        gc.collectIfNeeded(.{ .env = state.env });
-    }
-}
-
-/// Send eval error response with location info.
-fn sendEvalError(
-    stream: std.net.Stream,
-    msg: []const BencodeValue.DictEntry,
-    err_msg: []const u8,
-    err_info: ?err_mod.Info,
-    allocator: Allocator,
-) void {
-    // Build rich error string: "TypeError: msg (file:line:col)"
-    const rich_msg = if (err_info) |info| blk: {
-        const class = kindToClassName(info.kind);
-        if (info.location.line > 0) {
-            const file = info.location.file orelse "REPL";
-            break :blk std.fmt.allocPrint(allocator, "{s}: {s} ({s}:{d}:{d})\n", .{
-                class, info.message, file, info.location.line, info.location.column,
-            }) catch err_msg;
-        }
-        break :blk std.fmt.allocPrint(allocator, "{s}: {s}\n", .{
-            class, info.message,
-        }) catch err_msg;
-    } else err_msg;
-
-    const ex_class = if (err_info) |info| kindToClassName(info.kind) else "Exception";
-
-    const err_entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "err", .value = .{ .string = rich_msg } },
-    };
-    sendBencode(stream, &err_entries, allocator);
-
-    const ex_entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "ex", .value = .{ .string = ex_class } },
-        .{ .key = "root-ex", .value = .{ .string = ex_class } },
-    };
-    sendBencode(stream, &ex_entries, allocator);
-
-    const status_items = [_]BencodeValue{
-        .{ .string = "done" },
-        .{ .string = "eval-error" },
-    };
-    const done_entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "status", .value = .{ .list = &status_items } },
-    };
-    sendBencode(stream, &done_entries, allocator);
-}
-
-/// load-file: evaluate file content as code.
-fn opLoadFile(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const file_content = bencode.dictGetString(msg, "file") orelse {
-        sendError(stream, msg, "eval-error", "No file content provided", allocator);
-        return;
-    };
-
-    // Extract file-path for source tracking (CIDER sends this in load-file)
-    const file_path = bencode.dictGetString(msg, "file-path");
-
-    // Build a synthetic eval message with code = file content
-    var eval_msg_buf: [10]BencodeValue.DictEntry = undefined;
-    var eval_msg_len: usize = 0;
-
-    for (msg) |entry| {
-        if (eval_msg_len >= eval_msg_buf.len) break;
-        if (std.mem.eql(u8, entry.key, "op")) {
-            eval_msg_buf[eval_msg_len] = .{ .key = "op", .value = .{ .string = "eval" } };
-        } else if (std.mem.eql(u8, entry.key, "file")) {
-            eval_msg_buf[eval_msg_len] = .{ .key = "code", .value = .{ .string = file_content } };
-        } else if (std.mem.eql(u8, entry.key, "file-path")) {
-            // Map file-path to "file" key for eval's source file tracking
-            eval_msg_buf[eval_msg_len] = .{ .key = "file", .value = .{ .string = entry.value.string } };
-        } else {
-            eval_msg_buf[eval_msg_len] = entry;
-        }
-        eval_msg_len += 1;
-    }
-
-    // If file-path was not in the message, add it from file-name or synthesize
-    if (file_path == null) {
-        if (bencode.dictGetString(msg, "file-name")) |fname| {
-            if (eval_msg_len < eval_msg_buf.len) {
-                eval_msg_buf[eval_msg_len] = .{ .key = "file", .value = .{ .string = fname } };
-                eval_msg_len += 1;
-            }
-        }
-    }
-
-    opEval(state, eval_msg_buf[0..eval_msg_len], stream, allocator);
-}
-
-/// macroexpand: expand macros in a form.
-/// Supports "expander" key: "macroexpand-1" or "macroexpand" (default).
-fn opMacroexpand(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const code = bencode.dictGetString(msg, "code") orelse {
-        sendError(stream, msg, "macroexpand-error", "No code provided", allocator);
-        return;
-    };
-
-    const expander = bencode.dictGetString(msg, "expander") orelse "macroexpand";
-
-    // Build expression: (<expander> '<code>)
-    const expr = std.fmt.allocPrint(allocator, "({s} '{s})", .{ expander, code }) catch {
-        sendError(stream, msg, "macroexpand-error", "Out of memory", allocator);
-        return;
-    };
-
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    // Resolve session namespace
-    const ns_name = if (bencode.dictGetString(msg, "ns")) |n|
-        n
-    else if (bencode.dictGetString(msg, "session")) |sid|
-        if (state.sessions.get(sid)) |s| s.ns_name else "user"
-    else
-        "user";
-
-    if (state.env.findNamespace(ns_name)) |ns| {
-        state.env.current_ns = ns;
-    }
-
-    const eval_alloc = if (state.gc) |gc| gc.allocator() else state.gpa;
-    const expr_persistent = eval_alloc.dupe(u8, expr) catch {
-        sendError(stream, msg, "macroexpand-error", "Out of memory", allocator);
-        return;
-    };
-
-    const result = bootstrap.evalString(eval_alloc, state.env, expr_persistent);
-
-    if (result) |val| {
-        var val_buf: [65536]u8 = undefined;
-        var val_stream = std.io.fixedBufferStream(&val_buf);
-        writeValue(val_stream.writer(), val);
-        const expansion = val_stream.getWritten();
-
-        const entries = [_]BencodeValue.DictEntry{
-            idEntry(msg),
-            sessionEntry(msg),
-            .{ .key = "expansion", .value = .{ .string = expansion } },
-            statusDone(),
-        };
-        sendBencode(stream, &entries, allocator);
-    } else |_| {
-        sendError(stream, msg, "macroexpand-error", "Macroexpansion failed", allocator);
-    }
-}
-
-/// ls-sessions: list active sessions.
-fn opLsSessions(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    var session_list: std.ArrayList(BencodeValue) = .empty;
-    var iter = state.sessions.iterator();
-    while (iter.next()) |entry| {
-        session_list.append(allocator, .{ .string = entry.value_ptr.id }) catch {};
-    }
-
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        .{ .key = "sessions", .value = .{ .list = session_list.items } },
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// completions: symbol prefix completion.
-fn opCompletions(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const prefix = bencode.dictGetString(msg, "prefix") orelse
-        bencode.dictGetString(msg, "symbol") orelse "";
-
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    var completions: std.ArrayList(BencodeValue) = .empty;
-
-    // Current namespace vars + refers
-    if (state.env.current_ns) |ns| {
-        collectCompletions(allocator, &completions, &ns.mappings, prefix, ns.name);
-        collectCompletions(allocator, &completions, &ns.refers, prefix, null);
-    }
-
-    // clojure.core vars
-    if (state.env.findNamespace("clojure.core")) |core_ns| {
-        collectCompletions(allocator, &completions, &core_ns.mappings, prefix, "clojure.core");
-    }
-
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        .{ .key = "completions", .value = .{ .list = completions.items } },
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// Collect completion candidates from a VarMap.
-fn collectCompletions(
-    allocator: Allocator,
-    completions: *std.ArrayList(BencodeValue),
-    var_map: *const clj.namespace.VarMap,
-    prefix: []const u8,
-    ns_name: ?[]const u8,
-) void {
-    var iter = var_map.iterator();
-    while (iter.next()) |entry| {
-        const name = entry.key_ptr.*;
-        if (prefix.len == 0 or std.mem.startsWith(u8, name, prefix)) {
-            const v: *const Var = entry.value_ptr.*;
-            if (v.isPrivate()) continue;
-
-            var comp_entries_buf: [3]BencodeValue.DictEntry = undefined;
-            var comp_len: usize = 0;
-            comp_entries_buf[comp_len] = .{ .key = "candidate", .value = .{ .string = name } };
-            comp_len += 1;
-            if (ns_name) |ns| {
-                comp_entries_buf[comp_len] = .{ .key = "ns", .value = .{ .string = ns } };
-                comp_len += 1;
-            }
-            comp_entries_buf[comp_len] = .{ .key = "type", .value = .{ .string = "var" } };
-            comp_len += 1;
-
-            const comp_dict = allocator.dupe(BencodeValue.DictEntry, comp_entries_buf[0..comp_len]) catch continue;
-            completions.append(allocator, .{ .dict = comp_dict }) catch {};
-        }
-    }
-}
-
-/// info / lookup: symbol documentation.
-fn opInfo(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const sym_name = bencode.dictGetString(msg, "sym") orelse
-        bencode.dictGetString(msg, "symbol") orelse {
-        sendDone(stream, msg, allocator);
-        return;
-    };
-
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    const v = resolveSymbol(state.env, sym_name, bencode.dictGetString(msg, "ns"));
-    if (v == null) {
-        const status_items = [_]BencodeValue{
-            .{ .string = "done" },
-            .{ .string = "no-info" },
-        };
-        const entries = [_]BencodeValue.DictEntry{
-            idEntry(msg),
-            .{ .key = "status", .value = .{ .list = &status_items } },
-        };
-        sendBencode(stream, &entries, allocator);
-        return;
-    }
-
-    const var_ptr = v.?;
-    var info_entries: std.ArrayList(BencodeValue.DictEntry) = .empty;
-    info_entries.append(allocator, idEntry(msg)) catch {};
-    info_entries.append(allocator, .{ .key = "name", .value = .{ .string = var_ptr.sym.name } }) catch {};
-    if (var_ptr.ns_name.len > 0) {
-        info_entries.append(allocator, .{ .key = "ns", .value = .{ .string = var_ptr.ns_name } }) catch {};
-    }
-    if (var_ptr.doc) |doc| {
-        info_entries.append(allocator, .{ .key = "doc", .value = .{ .string = doc } }) catch {};
-    }
-    if (var_ptr.arglists) |arglists| {
-        info_entries.append(allocator, .{ .key = "arglists-str", .value = .{ .string = arglists } }) catch {};
-    }
-    if (var_ptr.file) |file| {
-        info_entries.append(allocator, .{ .key = "file", .value = .{ .string = file } }) catch {};
-    }
-    if (var_ptr.line > 0) {
-        info_entries.append(allocator, .{ .key = "line", .value = .{ .integer = @intCast(var_ptr.line) } }) catch {};
-    }
-    if (var_ptr.added) |added| {
-        info_entries.append(allocator, .{ .key = "added", .value = .{ .string = added } }) catch {};
-    }
-    info_entries.append(allocator, statusDone()) catch {};
-
-    sendBencode(stream, info_entries.items, allocator);
-}
-
-/// eldoc: function argument list for editor display.
-fn opEldoc(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const sym_name = bencode.dictGetString(msg, "sym") orelse
-        bencode.dictGetString(msg, "symbol") orelse
-        bencode.dictGetString(msg, "ns") orelse {
-        sendDone(stream, msg, allocator);
-        return;
-    };
-
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    const v = resolveSymbol(state.env, sym_name, bencode.dictGetString(msg, "ns"));
-    if (v == null) {
-        sendDone(stream, msg, allocator);
-        return;
-    }
-
-    const var_ptr = v.?;
-    var eldoc_entries: std.ArrayList(BencodeValue.DictEntry) = .empty;
-    eldoc_entries.append(allocator, idEntry(msg)) catch {};
-    eldoc_entries.append(allocator, .{ .key = "name", .value = .{ .string = var_ptr.sym.name } }) catch {};
-    if (var_ptr.ns_name.len > 0) {
-        eldoc_entries.append(allocator, .{ .key = "ns", .value = .{ .string = var_ptr.ns_name } }) catch {};
-    }
-    if (var_ptr.arglists) |arglists| {
-        const eldoc_list = [_]BencodeValue{.{ .string = arglists }};
-        eldoc_entries.append(allocator, .{ .key = "eldoc", .value = .{ .list = &eldoc_list } }) catch {};
-    }
-    if (var_ptr.doc) |doc| {
-        eldoc_entries.append(allocator, .{ .key = "docstring", .value = .{ .string = doc } }) catch {};
-    }
-    eldoc_entries.append(allocator, .{ .key = "type", .value = .{ .string = "function" } }) catch {};
-    eldoc_entries.append(allocator, statusDone()) catch {};
-
-    sendBencode(stream, eldoc_entries.items, allocator);
-}
-
-/// ns-list: list all namespaces.
-fn opNsList(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    var ns_list: std.ArrayList(BencodeValue) = .empty;
-    var iter = state.env.namespaces.iterator();
-    while (iter.next()) |entry| {
-        ns_list.append(allocator, .{ .string = entry.key_ptr.* }) catch {};
-    }
-
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        .{ .key = "ns-list", .value = .{ .list = ns_list.items } },
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// stdin: input stub (not supported, returns done).
-fn opStdin(
-    _: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    sendDone(stream, msg, allocator);
-}
-
-/// interrupt: cancel evaluation stub (not supported, returns done).
-fn opInterrupt(
-    _: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    const status_items = [_]BencodeValue{
-        .{ .string = "done" },
-        .{ .string = "session-idle" },
-    };
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "status", .value = .{ .list = &status_items } },
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// stacktrace / analyze-last-stacktrace: return error + call stack from last eval error.
-/// CIDER sends this after receiving an eval-error status.
-fn opStacktrace(
-    state: *ServerState,
-    msg: []const BencodeValue.DictEntry,
-    stream: std.net.Stream,
-    allocator: Allocator,
-) void {
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    const err_info = state.last_error_info orelse {
-        // No saved error
-        const status_items = [_]BencodeValue{
-            .{ .string = "done" },
-            .{ .string = "no-error" },
-        };
-        const entries = [_]BencodeValue.DictEntry{
-            idEntry(msg),
-            sessionEntry(msg),
-            .{ .key = "status", .value = .{ .list = &status_items } },
-        };
-        sendBencode(stream, &entries, allocator);
-        return;
-    };
-
-    // Build stacktrace frame list
-    const stack = state.last_error_stack[0..state.last_error_stack_depth];
-    var frame_list: std.ArrayList(BencodeValue) = .empty;
-
-    for (stack) |frame| {
-        const fn_name = frame.fn_name orelse "unknown";
-        const ns_str = frame.ns orelse "";
-        const file_str = frame.file orelse "REPL";
-        const var_name = if (frame.ns) |ns|
-            std.fmt.allocPrint(allocator, "{s}/{s}", .{ ns, fn_name }) catch fn_name
-        else
-            fn_name;
-
-        const clj_flag = [_]BencodeValue{.{ .string = "clj" }};
-        const frame_entries = allocator.dupe(BencodeValue.DictEntry, &.{
-            .{ .key = "name", .value = .{ .string = var_name } },
-            .{ .key = "file", .value = .{ .string = file_str } },
-            .{ .key = "line", .value = .{ .integer = @intCast(frame.line) } },
-            .{ .key = "type", .value = .{ .string = "clj" } },
-            .{ .key = "flags", .value = .{ .list = allocator.dupe(BencodeValue, &clj_flag) catch &.{} } },
-            .{ .key = "ns", .value = .{ .string = ns_str } },
-            .{ .key = "fn", .value = .{ .string = fn_name } },
-            .{ .key = "var", .value = .{ .string = var_name } },
-        }) catch continue;
-        frame_list.append(allocator, .{ .dict = frame_entries }) catch {};
-    }
-
-    // If no frames, add a synthetic frame from error location
-    if (frame_list.items.len == 0) {
-        const file_str = if (err_info.location.file) |f| f else "REPL";
-        const clj_flag = [_]BencodeValue{.{ .string = "clj" }};
-        const frame_entries = allocator.dupe(BencodeValue.DictEntry, &.{
-            .{ .key = "name", .value = .{ .string = "eval" } },
-            .{ .key = "file", .value = .{ .string = file_str } },
-            .{ .key = "line", .value = .{ .integer = @intCast(err_info.location.line) } },
-            .{ .key = "type", .value = .{ .string = "clj" } },
-            .{ .key = "flags", .value = .{ .list = allocator.dupe(BencodeValue, &clj_flag) catch &.{} } },
-            .{ .key = "ns", .value = .{ .string = "" } },
-            .{ .key = "fn", .value = .{ .string = "eval" } },
-            .{ .key = "var", .value = .{ .string = "eval" } },
-        }) catch &.{};
-        frame_list.append(allocator, .{ .dict = frame_entries }) catch {};
-    }
-
-    // CIDER accumulates causes as separate messages until "done" arrives.
-    // Send cause data first, then done as a separate message.
-    const cause_entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "class", .value = .{ .string = kindToClassName(err_info.kind) } },
-        .{ .key = "message", .value = .{ .string = err_info.message } },
-        .{ .key = "stacktrace", .value = .{ .list = frame_list.items } },
-    };
-    sendBencode(stream, &cause_entries, allocator);
-    sendDone(stream, msg, allocator);
-}
-
-/// Map error.Kind to a human-readable exception class name.
-fn kindToClassName(kind: err_mod.Kind) []const u8 {
-    return switch (kind) {
-        .syntax_error => "SyntaxError",
-        .number_error => "NumberFormatError",
-        .string_error => "StringError",
-        .name_error => "NameError",
-        .arity_error => "ArityError",
-        .value_error => "ValueError",
-        .type_error => "TypeError",
-        .arithmetic_error => "ArithmeticError",
-        .index_error => "IndexOutOfBoundsError",
-        .io_error => "IOException",
-        .internal_error => "InternalError",
-        .out_of_memory => "OutOfMemoryError",
-    };
-}
-
-// ====================================================================
-// Helpers
-// ====================================================================
-
-/// Set a REPL var (*1, *2, *3, *e) to a value.
-fn setReplVar(state: *ServerState, name: []const u8, val: Value) void {
-    if (state.env.current_ns) |ns| {
-        if (ns.resolve(name)) |v| {
-            v.bindRoot(val);
-        }
-    }
-}
-
-/// Copy one REPL var's value to another (*3 = *2, *2 = *1).
-fn updateReplVar(state: *ServerState, target: []const u8, source: []const u8) void {
-    if (state.env.current_ns) |ns| {
-        const src_val = if (ns.resolve(source)) |v| v.deref() else Value.nil_val;
-        if (ns.resolve(target)) |tv| {
-            tv.bindRoot(src_val);
-        }
-    }
-}
-
-/// Resolve a symbol in the environment.
-fn resolveSymbol(env: *Env, sym_name: []const u8, ns_hint: ?[]const u8) ?*Var {
-    // Qualified name (ns/name)
-    if (std.mem.indexOfScalar(u8, sym_name, '/')) |slash| {
-        const ns_part = sym_name[0..slash];
-        const name_part = sym_name[slash + 1 ..];
-        if (env.findNamespace(ns_part)) |ns| {
-            return ns.resolve(name_part);
-        }
-    }
-
-    // Namespace hint
-    if (ns_hint) |ns_name| {
-        if (env.findNamespace(ns_name)) |ns| {
-            if (ns.resolve(sym_name)) |v| return v;
-        }
-    }
-
-    // Current namespace
-    if (env.current_ns) |ns| {
-        if (ns.resolve(sym_name)) |v| return v;
-    }
-
-    // clojure.core
-    if (env.findNamespace("clojure.core")) |core_ns| {
-        return core_ns.resolve(sym_name);
-    }
-
-    return null;
-}
-
-/// UUID v4 generation.
-fn generateUUID(allocator: Allocator) ![]const u8 {
-    var bytes: [16]u8 = undefined;
-    std.crypto.random.bytes(&bytes);
-
-    // v4: version (bits 48-51) = 0100, variant (bits 64-65) = 10
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-
-    return std.fmt.allocPrint(allocator, "{x:0>2}{x:0>2}{x:0>2}{x:0>2}-{x:0>2}{x:0>2}-{x:0>2}{x:0>2}-{x:0>2}{x:0>2}-{x:0>2}{x:0>2}{x:0>2}{x:0>2}{x:0>2}{x:0>2}", .{
-        bytes[0],  bytes[1],  bytes[2],  bytes[3],
-        bytes[4],  bytes[5],
-        bytes[6],  bytes[7],
-        bytes[8],  bytes[9],
-        bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15],
-    });
-}
-
-/// Build "id" entry from request message.
-fn idEntry(msg: []const BencodeValue.DictEntry) BencodeValue.DictEntry {
-    return .{
-        .key = "id",
-        .value = .{ .string = bencode.dictGetString(msg, "id") orelse "" },
-    };
-}
-
-/// Build "session" entry from request message.
-fn sessionEntry(msg: []const BencodeValue.DictEntry) BencodeValue.DictEntry {
-    return .{
-        .key = "session",
-        .value = .{ .string = bencode.dictGetString(msg, "session") orelse "" },
-    };
-}
-
-/// Build status "done" entry.
-fn statusDone() BencodeValue.DictEntry {
-    const done_items = [_]BencodeValue{.{ .string = "done" }};
-    return .{ .key = "status", .value = .{ .list = &done_items } };
-}
-
-/// Encode and send a bencode dict over a TCP stream.
-fn sendBencode(
-    stream: std.net.Stream,
-    entries: []const BencodeValue.DictEntry,
-    allocator: Allocator,
-) void {
-    var buf: std.ArrayList(u8) = .empty;
-    bencode.encode(allocator, &buf, .{ .dict = entries }) catch return;
-    stream.writeAll(buf.items) catch {};
-}
-
-/// Send a simple "done" response.
-fn sendDone(
-    stream: std.net.Stream,
-    msg: []const BencodeValue.DictEntry,
-    allocator: Allocator,
-) void {
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        statusDone(),
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// Send an error response.
-fn sendError(
-    stream: std.net.Stream,
-    msg: []const BencodeValue.DictEntry,
-    status: []const u8,
-    err_msg: []const u8,
-    allocator: Allocator,
-) void {
-    const status_items = [_]BencodeValue{
-        .{ .string = "done" },
-        .{ .string = status },
-    };
-    const entries = [_]BencodeValue.DictEntry{
-        idEntry(msg),
-        sessionEntry(msg),
-        .{ .key = "err", .value = .{ .string = err_msg } },
-        .{ .key = "status", .value = .{ .list = &status_items } },
-    };
-    sendBencode(stream, &entries, allocator);
-}
-
-/// Format a Value as a Clojure-readable string.
-/// Equivalent to pr-str semantics.
-fn writeValue(w: anytype, val: Value) void {
-    switch (val.tag()) {
-        .nil => w.print("nil", .{}) catch {},
-        .boolean => w.print("{}", .{val.asBoolean()}) catch {},
-        .integer => w.print("{d}", .{val.asInteger()}) catch {},
-        .float => w.print("{d}", .{val.asFloat()}) catch {},
-        .string => w.print("\"{s}\"", .{val.asString()}) catch {},
-        .keyword => {
-            const k = val.asKeyword();
-            if (k.ns) |ns| {
-                w.print(":{s}/{s}", .{ ns, k.name }) catch {};
-            } else {
-                w.print(":{s}", .{k.name}) catch {};
-            }
-        },
-        .symbol => {
-            const s = val.asSymbol();
-            if (s.ns) |ns| {
-                w.print("{s}/{s}", .{ ns, s.name }) catch {};
-            } else {
-                w.print("{s}", .{s.name}) catch {};
-            }
-        },
-        .list => {
-            const lst = val.asList();
-            w.print("(", .{}) catch {};
-            for (lst.items, 0..) |item, i| {
-                if (i > 0) w.print(" ", .{}) catch {};
-                writeValue(w, item);
-            }
-            w.print(")", .{}) catch {};
-        },
-        .vector => {
-            const vec = val.asVector();
-            w.print("[", .{}) catch {};
-            for (vec.items, 0..) |item, i| {
-                if (i > 0) w.print(" ", .{}) catch {};
-                writeValue(w, item);
-            }
-            w.print("]", .{}) catch {};
-        },
-        .map => {
-            const m = val.asMap();
-            w.print("{{", .{}) catch {};
-            var i: usize = 0;
-            while (i < m.entries.len) : (i += 2) {
-                if (i > 0) w.print(", ", .{}) catch {};
-                writeValue(w, m.entries[i]);
-                w.print(" ", .{}) catch {};
-                writeValue(w, m.entries[i + 1]);
-            }
-            w.print("}}", .{}) catch {};
-        },
-        .hash_map => {
-            const hm = val.asHashMap();
-            w.print("{{", .{}) catch {};
-            // Use arena allocator for temporary entry collection
-            var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-            defer arena.deinit();
-            const entries = hm.toEntries(arena.allocator()) catch &[_]Value{};
-            var i: usize = 0;
-            while (i < entries.len) : (i += 2) {
-                if (i > 0) w.print(", ", .{}) catch {};
-                writeValue(w, entries[i]);
-                w.print(" ", .{}) catch {};
-                writeValue(w, entries[i + 1]);
-            }
-            w.print("}}", .{}) catch {};
-        },
-        .set => {
-            const s = val.asSet();
-            w.print("#{{", .{}) catch {};
-            for (s.items, 0..) |item, i| {
-                if (i > 0) w.print(" ", .{}) catch {};
-                writeValue(w, item);
-            }
-            w.print("}}", .{}) catch {};
-        },
-        .fn_val => w.print("#<fn>", .{}) catch {},
-        .builtin_fn => w.print("#<builtin>", .{}) catch {},
-        .atom => {
-            const a = val.asAtom();
-            w.print("(atom ", .{}) catch {};
-            writeValue(w, a.value);
-            w.print(")", .{}) catch {};
-        },
-        .volatile_ref => {
-            const v = val.asVolatile();
-            w.print("#<volatile ", .{}) catch {};
-            writeValue(w, v.value);
-            w.print(">", .{}) catch {};
-        },
-        .regex => {
-            const p = val.asRegex();
-            w.print("#\"{s}\"", .{p.source}) catch {};
-        },
-        .char => {
-            const c = val.asChar();
-            var buf: [4]u8 = undefined;
-            const len = std.unicode.utf8Encode(c, &buf) catch 0;
-            _ = w.write("\\") catch {};
-            _ = w.write(buf[0..len]) catch {};
-        },
-        .protocol => w.print("#<protocol {s}>", .{val.asProtocol().name}) catch {},
-        .protocol_fn => {
-            const pf = val.asProtocolFn();
-            w.print("#<protocol-fn {s}/{s}>", .{ pf.protocol.name, pf.method_name }) catch {};
-        },
-        .multi_fn => w.print("#<multifn {s}>", .{val.asMultiFn().name}) catch {},
-        .lazy_seq => {
-            const ls = val.asLazySeq();
-            if (ls.realized) |r| {
-                writeValue(w, r);
-            } else {
-                w.print("#<lazy-seq>", .{}) catch {};
-            }
-        },
-        .cons => {
-            w.print("(", .{}) catch {};
-            var current = val;
-            var first = true;
-            while (true) {
-                if (current.tag() == .cons) {
-                    const c = current.asCons();
-                    if (!first) w.print(" ", .{}) catch {};
-                    writeValue(w, c.first);
-                    first = false;
-                    current = c.rest;
-                } else if (current.tag() == .nil) {
-                    break;
-                } else if (current.tag() == .list) {
-                    // Rest is a regular list — inline its elements
-                    const lst = current.asList();
-                    for (lst.items) |item| {
-                        if (!first) w.print(" ", .{}) catch {};
-                        writeValue(w, item);
-                        first = false;
-                    }
-                    break;
-                } else if (current.tag() == .lazy_seq) {
-                    const ls = current.asLazySeq();
-                    if (ls.realized) |r| {
-                        if (!first) w.print(" ", .{}) catch {};
-                        // Realized lazy-seq: continue traversal
-                        if (r.tag() == .cons or r.tag() == .list or r.tag() == .nil) {
-                            current = r;
-                            continue;
-                        }
-                        writeValue(w, r);
-                    }
-                    break;
-                } else {
-                    // Non-nil, non-seq rest (shouldn't happen in Clojure)
-                    if (!first) w.print(" ", .{}) catch {};
-                    writeValue(w, current);
-                    break;
-                }
-            }
-            w.print(")", .{}) catch {};
-        },
-        .var_ref => {
-            const v = val.asVarRef();
-            w.print("#'{s}/{s}", .{ v.ns_name, v.sym.name }) catch {};
-        },
-        .delay => {
-            const d = val.asDelay();
-            if (d.realized) {
-                w.print("#delay[", .{}) catch {};
-                if (d.getCached()) |v| writeValue(w, v) else w.print("nil", .{}) catch {};
-                w.print("]", .{}) catch {};
-            } else {
-                w.print("#delay[pending]", .{}) catch {};
-            }
-        },
-        .future => {
-            const f = val.asFuture();
-            const thread_pool = @import("../../runtime/thread_pool.zig");
-            const result: *thread_pool.FutureResult = @ptrCast(@alignCast(f.result));
-            if (f.cancelled) {
-                w.print("#future[cancelled]", .{}) catch {};
-            } else if (result.isDone()) {
-                w.print("#future[", .{}) catch {};
-                writeValue(w, result.value);
-                w.print("]", .{}) catch {};
-            } else {
-                w.print("#future[pending]", .{}) catch {};
-            }
-        },
-        .promise => {
-            const p = val.asPromise();
-            const thread_pool = @import("../../runtime/thread_pool.zig");
-            const sync: *thread_pool.FutureResult = @ptrCast(@alignCast(p.sync));
-            if (sync.isDone()) {
-                w.print("#promise[", .{}) catch {};
-                writeValue(w, sync.value);
-                w.print("]", .{}) catch {};
-            } else {
-                w.print("#promise[pending]", .{}) catch {};
-            }
-        },
-        .agent => {
-            const a = val.asAgent();
-            const inner = a.getInner();
-            if (inner.isInErrorState()) {
-                w.print("#agent[FAILED ", .{}) catch {};
-            } else {
-                w.print("#agent[", .{}) catch {};
-            }
-            writeValue(w, inner.state);
-            w.print("]", .{}) catch {};
-        },
-        .ref => {
-            const r = val.asRef();
-            const inner: *clj.value.RefInner = @ptrCast(@alignCast(r.inner));
-            w.print("#ref[", .{}) catch {};
-            writeValue(w, inner.currentVal());
-            w.print("]", .{}) catch {};
-        },
-        .reduced => writeValue(w, val.asReduced().value),
-        .transient_vector => w.print("#<TransientVector>", .{}) catch {},
-        .transient_map => w.print("#<TransientMap>", .{}) catch {},
-        .transient_set => w.print("#<TransientSet>", .{}) catch {},
-        .chunked_cons => {
-            const cc = val.asChunkedCons();
-            w.print("(", .{}) catch {};
-            var i: usize = 0;
-            while (i < cc.chunk.count()) : (i += 1) {
-                if (i > 0) w.print(" ", .{}) catch {};
-                const elem = cc.chunk.nth(i) orelse Value.nil_val;
-                writeValue(w, elem);
-            }
-            if (cc.more.tag() != .nil) w.print(" ...", .{}) catch {};
-            w.print(")", .{}) catch {};
-        },
-        .chunk_buffer => w.print("#<ChunkBuffer>", .{}) catch {},
-        .array_chunk => w.print("#<ArrayChunk>", .{}) catch {},
-        .wasm_module => w.print("#<WasmModule>", .{}) catch {},
-        .wasm_fn => w.print("#<WasmFn {s}>", .{val.asWasmFn().name}) catch {},
-        .matcher => w.print("#<Matcher>", .{}) catch {},
-        .array => {
-            const arr = val.asArray();
-            w.print("#<{s}[{d}]>", .{ @tagName(arr.element_type), arr.items.len }) catch {};
-        },
-        .big_int => w.print("#<BigInt>", .{}) catch {},
-        .ratio => w.print("#<Ratio>", .{}) catch {},
-        .big_decimal => w.print("#<BigDecimal>", .{}) catch {},
-    }
-}
-
-// ====================================================================
-// Tests
-// ====================================================================
-
-test "nrepl - generateUUID format" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const uuid = try generateUUID(allocator);
-
-    // UUID v4 format: 8-4-4-4-12 hex chars = 36 total
-    try std.testing.expectEqual(@as(usize, 36), uuid.len);
-    try std.testing.expectEqual(@as(u8, '-'), uuid[8]);
-    try std.testing.expectEqual(@as(u8, '-'), uuid[13]);
-    try std.testing.expectEqual(@as(u8, '-'), uuid[18]);
-    try std.testing.expectEqual(@as(u8, '-'), uuid[23]);
-
-    // Version nibble (position 14) should be '4'
-    try std.testing.expectEqual(@as(u8, '4'), uuid[14]);
-
-    // Variant nibble (position 19) should be 8, 9, a, or b
-    const variant = uuid[19];
-    try std.testing.expect(variant == '8' or variant == '9' or variant == 'a' or variant == 'b');
-}
-
-test "nrepl - generateUUID uniqueness" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    const uuid1 = try generateUUID(allocator);
-    const uuid2 = try generateUUID(allocator);
-    try std.testing.expect(!std.mem.eql(u8, uuid1, uuid2));
-}
-
-test "nrepl - idEntry extracts id from message" {
-    const msg = [_]BencodeValue.DictEntry{
-        .{ .key = "id", .value = .{ .string = "42" } },
-        .{ .key = "op", .value = .{ .string = "eval" } },
-    };
-    const entry = idEntry(&msg);
-    try std.testing.expectEqualSlices(u8, "id", entry.key);
-    try std.testing.expectEqualSlices(u8, "42", entry.value.string);
-}
-
-test "nrepl - idEntry returns empty when no id" {
-    const msg = [_]BencodeValue.DictEntry{
-        .{ .key = "op", .value = .{ .string = "eval" } },
-    };
-    const entry = idEntry(&msg);
-    try std.testing.expectEqualSlices(u8, "", entry.value.string);
-}
-
-test "nrepl - sessionEntry extracts session" {
-    const msg = [_]BencodeValue.DictEntry{
-        .{ .key = "session", .value = .{ .string = "abc-123" } },
-    };
-    const entry = sessionEntry(&msg);
-    try std.testing.expectEqualSlices(u8, "session", entry.key);
-    try std.testing.expectEqualSlices(u8, "abc-123", entry.value.string);
-}
-
-test "nrepl - statusDone produces done list" {
-    const entry = statusDone();
-    try std.testing.expectEqualSlices(u8, "status", entry.key);
-    const list = entry.value.list;
-    try std.testing.expectEqual(@as(usize, 1), list.len);
-    try std.testing.expectEqualSlices(u8, "done", list[0].string);
-}
-
-test "nrepl - writeValue integer" {
-    var buf: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    writeValue(stream.writer(), Value.initInteger(42));
-    try std.testing.expectEqualSlices(u8, "42", stream.getWritten());
-}
-
-test "nrepl - writeValue string" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-
-    var buf: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    writeValue(stream.writer(), Value.initString(arena.allocator(), "hello"));
-    try std.testing.expectEqualSlices(u8, "\"hello\"", stream.getWritten());
-}
-
-test "nrepl - writeValue nil" {
-    var buf: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    writeValue(stream.writer(), Value.nil_val);
-    try std.testing.expectEqualSlices(u8, "nil", stream.getWritten());
-}
-
-test "nrepl - writeValue boolean" {
-    var buf: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    writeValue(stream.writer(), Value.true_val);
-    try std.testing.expectEqualSlices(u8, "true", stream.getWritten());
-}
-
-test "nrepl - writeValue keyword" {
-    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena.deinit();
-
-    var buf: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    writeValue(stream.writer(), Value.initKeyword(arena.allocator(), .{ .name = "foo", .ns = null }));
-    try std.testing.expectEqualSlices(u8, ":foo", stream.getWritten());
-}
-
-test "nrepl - dispatch table covers all expected ops" {
-    // Verify key ops are in the dispatch table
-    const expected_ops = [_][]const u8{
-        "clone",     "close",        "describe",    "eval",
-        "load-file", "ls-sessions",  "completions", "complete",
-        "info",      "lookup",       "eldoc",       "ns-list",
-        "stdin",     "interrupt",    "stacktrace",  "analyze-last-stacktrace",
-        "macroexpand",
-    };
-    for (expected_ops) |expected| {
-        var found = false;
-        for (op_table) |entry| {
-            if (std.mem.eql(u8, entry.name, expected)) {
-                found = true;
-                break;
-            }
-        }
-        try std.testing.expect(found);
-    }
-}
-
-test "nrepl - describe ops generated from dispatch table" {
-    // Verify describe response has same op count as dispatch table
-    comptime {
-        var count: usize = 0;
-        for (op_table) |_| count += 1;
-        if (count != 17) @compileError("expected 17 ops in dispatch table");
-    }
-}
-
-test "nrepl - kindToClassName maps all kinds" {
-    // Verify all error kinds have a class name
-    try std.testing.expectEqualSlices(u8, "SyntaxError", kindToClassName(.syntax_error));
-    try std.testing.expectEqualSlices(u8, "NumberFormatError", kindToClassName(.number_error));
-    try std.testing.expectEqualSlices(u8, "StringError", kindToClassName(.string_error));
-    try std.testing.expectEqualSlices(u8, "NameError", kindToClassName(.name_error));
-    try std.testing.expectEqualSlices(u8, "ArityError", kindToClassName(.arity_error));
-    try std.testing.expectEqualSlices(u8, "ValueError", kindToClassName(.value_error));
-    try std.testing.expectEqualSlices(u8, "TypeError", kindToClassName(.type_error));
-    try std.testing.expectEqualSlices(u8, "ArithmeticError", kindToClassName(.arithmetic_error));
-    try std.testing.expectEqualSlices(u8, "IndexOutOfBoundsError", kindToClassName(.index_error));
-    try std.testing.expectEqualSlices(u8, "IOException", kindToClassName(.io_error));
-    try std.testing.expectEqualSlices(u8, "InternalError", kindToClassName(.internal_error));
-    try std.testing.expectEqualSlices(u8, "OutOfMemoryError", kindToClassName(.out_of_memory));
-}
-
-test "nrepl - stacktrace op returns no-error when no previous error" {
-    // Test stacktrace with no saved error state
-    const allocator = std.testing.allocator;
-    var arena = std.heap.ArenaAllocator.init(allocator);
-    defer arena.deinit();
-
-    // Create minimal ServerState (no env needed for stacktrace)
-    var state = ServerState{
-        .env = undefined,
-        .sessions = .empty,
-        .mutex = .{},
-        .running = true,
-        .gpa = allocator,
-        .gc = null,
-        .port_file_written = false,
-    };
-
-    // Call opStacktrace with a mock stream via TCP
-    const address = std.net.Address.parseIp("127.0.0.1", 0) catch unreachable;
-    var server = try address.listen(.{ .reuse_address = true });
-    defer server.deinit();
-    const port = server.listen_address.getPort();
-
-    const ClientThread = struct {
-        fn run(p: u16, s: *ServerState) !void {
-            const alloc = std.testing.allocator;
-            const addr = std.net.Address.parseIp("127.0.0.1", p) catch unreachable;
-            var stream = try std.net.tcpConnectToAddress(addr);
-            defer stream.close();
-
-            var a = std.heap.ArenaAllocator.init(alloc);
-            defer a.deinit();
-
-            const m = [_]BencodeValue.DictEntry{
-                .{ .key = "op", .value = .{ .string = "stacktrace" } },
-                .{ .key = "id", .value = .{ .string = "42" } },
-                .{ .key = "session", .value = .{ .string = "test-session" } },
-            };
-            opStacktrace(s, &m, stream, a.allocator());
-        }
-    };
-
-    const client_thread = try std.Thread.spawn(.{}, ClientThread.run, .{ port, &state });
-
-    const conn = try server.accept();
-    defer conn.stream.close();
-
-    var recv_buf: [4096]u8 = undefined;
-    const n = try conn.stream.read(&recv_buf);
-    try std.testing.expect(n > 0);
-
-    var decode_arena = std.heap.ArenaAllocator.init(allocator);
-    defer decode_arena.deinit();
-    const result = try bencode.decode(decode_arena.allocator(), recv_buf[0..n]);
-    const dict = result.value.dict;
-
-    // Verify no-error status
-    const status_val = bencode.dictGet(dict, "status").?;
-    const status_list = status_val.list;
-    try std.testing.expect(status_list.len == 2);
-    try std.testing.expectEqualSlices(u8, "done", status_list[0].string);
-    try std.testing.expectEqualSlices(u8, "no-error", status_list[1].string);
-
-    client_thread.join();
-}
-
-test "nrepl - stacktrace op returns frames when error saved" {
-    const allocator = std.testing.allocator;
-
-    var state = ServerState{
-        .env = undefined,
-        .sessions = .empty,
-        .mutex = .{},
-        .running = true,
-        .gpa = allocator,
-        .gc = null,
-        .port_file_written = false,
-    };
-
-    // Simulate saved error state
-    const err_msg = "Divide by zero";
-    @memcpy(state.last_error_msg_buf[0..err_msg.len], err_msg);
-    state.last_error_info = .{
-        .kind = .arithmetic_error,
-        .phase = .eval,
-        .message = state.last_error_msg_buf[0..err_msg.len],
-        .location = .{ .file = "REPL", .line = 1 },
-    };
-    state.last_error_stack[0] = .{
-        .fn_name = "my-fn",
-        .ns = "user",
-        .file = "REPL",
-        .line = 1,
-    };
-    state.last_error_stack_depth = 1;
-
-    // Use TCP for mock stream
-    const address = std.net.Address.parseIp("127.0.0.1", 0) catch unreachable;
-    var server = try address.listen(.{ .reuse_address = true });
-    defer server.deinit();
-    const port = server.listen_address.getPort();
-
-    const ClientThread = struct {
-        fn run(p: u16, s: *ServerState) !void {
-            const alloc = std.testing.allocator;
-            const addr = std.net.Address.parseIp("127.0.0.1", p) catch unreachable;
-            var stream = try std.net.tcpConnectToAddress(addr);
-            defer stream.close();
-
-            var a = std.heap.ArenaAllocator.init(alloc);
-            defer a.deinit();
-
-            const m = [_]BencodeValue.DictEntry{
-                .{ .key = "op", .value = .{ .string = "stacktrace" } },
-                .{ .key = "id", .value = .{ .string = "7" } },
-                .{ .key = "session", .value = .{ .string = "sess-1" } },
-            };
-            opStacktrace(s, &m, stream, a.allocator());
-        }
-    };
-
-    const client_thread = try std.Thread.spawn(.{}, ClientThread.run, .{ port, &state });
-
-    const conn = try server.accept();
-    defer conn.stream.close();
-
-    var recv_buf: [8192]u8 = undefined;
-    const n = try conn.stream.read(&recv_buf);
-    try std.testing.expect(n > 0);
-
-    var decode_arena = std.heap.ArenaAllocator.init(allocator);
-    defer decode_arena.deinit();
-    const result = try bencode.decode(decode_arena.allocator(), recv_buf[0..n]);
-    const dict = result.value.dict;
-
-    // Verify class and message
-    try std.testing.expectEqualSlices(u8, "ArithmeticError", bencode.dictGetString(dict, "class").?);
-    try std.testing.expectEqualSlices(u8, "Divide by zero", bencode.dictGetString(dict, "message").?);
-
-    // Verify stacktrace is a list with at least one frame
-    const st_val = bencode.dictGet(dict, "stacktrace").?;
-    const st_list = st_val.list;
-    try std.testing.expect(st_list.len >= 1);
-
-    // Verify first frame has expected fields
-    const frame_dict = st_list[0].dict;
-    try std.testing.expectEqualSlices(u8, "user/my-fn", bencode.dictGetString(frame_dict, "name").?);
-    try std.testing.expectEqualSlices(u8, "REPL", bencode.dictGetString(frame_dict, "file").?);
-    try std.testing.expectEqualSlices(u8, "clj", bencode.dictGetString(frame_dict, "type").?);
-    try std.testing.expectEqualSlices(u8, "my-fn", bencode.dictGetString(frame_dict, "fn").?);
-    try std.testing.expectEqualSlices(u8, "user", bencode.dictGetString(frame_dict, "ns").?);
-    const line_val = bencode.dictGetInt(frame_dict, "line");
-    try std.testing.expect(line_val != null);
-    try std.testing.expectEqual(@as(i64, 1), line_val.?);
-
-    client_thread.join();
-}
-
-test "nrepl - TCP integration: describe op" {
-    // Start server on random port
-    const allocator = std.testing.allocator;
-
-    const address = std.net.Address.parseIp("127.0.0.1", 0) catch unreachable;
-    var server = try address.listen(.{ .reuse_address = true });
-    defer server.deinit();
-    const port = server.listen_address.getPort();
-
-    // Client thread: connect and send describe request
-    const ClientThread = struct {
-        fn run(p: u16) !void {
-            const alloc = std.testing.allocator;
-            var decode_arena = std.heap.ArenaAllocator.init(alloc);
-            defer decode_arena.deinit();
-
-            const addr = std.net.Address.parseIp("127.0.0.1", p) catch unreachable;
-            var stream = try std.net.tcpConnectToAddress(addr);
-            defer stream.close();
-
-            // Send describe request
-            var send_buf: std.ArrayList(u8) = .empty;
-            defer send_buf.deinit(alloc);
-            const msg_entries = [_]BencodeValue.DictEntry{
-                .{ .key = "op", .value = .{ .string = "describe" } },
-                .{ .key = "id", .value = .{ .string = "1" } },
-            };
-            try bencode.encode(alloc, &send_buf, .{ .dict = &msg_entries });
-            try stream.writeAll(send_buf.items);
-
-            // Read response
-            var recv_buf: [4096]u8 = undefined;
-            const n = try stream.read(&recv_buf);
-            try std.testing.expect(n > 0);
-
-            // Decode and verify (use arena to avoid leak)
-            const result = try bencode.decode(decode_arena.allocator(), recv_buf[0..n]);
-            const dict = result.value.dict;
-            try std.testing.expectEqualSlices(u8, "1", bencode.dictGetString(dict, "id").?);
-            // Should have ops key
-            try std.testing.expect(bencode.dictGet(dict, "ops") != null);
-        }
-    };
-
-    const client_thread = try std.Thread.spawn(.{}, ClientThread.run, .{port});
-
-    // Server side: accept one connection and process one message
-    const conn = try server.accept();
-    defer conn.stream.close();
-
-    // Read request
-    var recv_buf: [4096]u8 = undefined;
-    const n = try conn.stream.read(&recv_buf);
-    if (n > 0) {
-        var arena = std.heap.ArenaAllocator.init(allocator);
-        defer arena.deinit();
-        const result = bencode.decode(arena.allocator(), recv_buf[0..n]) catch unreachable;
-        const msg = result.value.dict;
-        opDescribe(undefined, msg, conn.stream, arena.allocator());
-    }
-
-    client_thread.join();
+pub fn startServerWithEnv(
+    gpa_allocator: Allocator,
+    env: *Env,
+    gc: *gc_mod.MarkSweepGc,
+    port: u16,
+) StartError!void {
+    _ = .{ gpa_allocator, env, gc, port };
+    return startServer(gpa_allocator, port);
 }
diff --git a/src/app/runner.zig b/src/app/runner.zig
index a8b883a2..e2c47c6b 100644
--- a/src/app/runner.zig
+++ b/src/app/runner.zig
@@ -26,6 +26,7 @@ const ns_ops = @import("../lang/builtins/ns_ops.zig");
 const http_server = @import("../lang/builtins/http_server.zig");
 const lifecycle = @import("../runtime/lifecycle.zig");
 const deps_mod = @import("deps.zig");
+const io_default = @import("../runtime/io_default.zig");
 
 const build_options = @import("build_options");
 pub const version_string = "ClojureWasm v" ++ build_options.version ++ "\n";
@@ -82,16 +83,20 @@ pub fn handleEmbedded(alloc: Allocator, allocator: Allocator, gc: *gc_mod.MarkSw
 // === REPL ===
 
 pub fn runRepl(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void {
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-    const is_tty = std.posix.isatty(std.posix.STDOUT_FILENO);
-
-    // Use line editor if stdin is a TTY, otherwise fall back to simple reader
-    if (!std.posix.isatty(std.posix.STDIN_FILENO)) {
+    const stdout = std.Io.File.stdout();
+    const repl_io = io_default.get();
+    const is_tty = stdout.isTty(repl_io) catch false;
+
+    // Always use the simple reader during the Zig 0.16 migration. The
+    // line_editor module needs porting (raw-mode termios + fs.File +
+    // std.io.fixedBufferStream all changed in 0.16) and is tracked as a
+    // Phase 7 follow-up. The simple reader provides functional REPL.
+    if (true) {
         runReplSimple(allocator, env, gc);
         return;
     }
 
-    _ = stdout.write(version_string) catch {};
+    stdout.writeStreamingAll(io_default.get(),version_string) catch {};
 
     var editor = line_editor.LineEditor.init(allocator, env);
     defer editor.deinit();
@@ -102,7 +107,7 @@ pub fn runRepl(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void {
         editor.setNsPrompt(ns_name);
 
         const source = editor.readInput() orelse {
-            _ = stdout.write("\n") catch {};
+            stdout.writeStreamingAll(io_default.get(),"\n") catch {};
             break;
         };
 
@@ -116,7 +121,7 @@ pub fn runRepl(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void {
             break;
         }
         if (std.mem.eql(u8, trimmed, ":help") or std.mem.eql(u8, trimmed, ":h")) {
-            _ = stdout.write(
+            stdout.writeStreamingAll(io_default.get(),
                 \\REPL commands:
                 \\  :quit, :exit, :q   Exit REPL
                 \\  :help, :h          Show this help
@@ -160,8 +165,8 @@ pub fn runRepl(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void {
 
 /// Simple REPL for non-TTY stdin (piped input).
 fn runReplSimple(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void {
-    const stdin: std.fs.File = .{ .handle = std.posix.STDIN_FILENO };
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+    const stdin = std.Io.File.stdin();
+    const stdout = std.Io.File.stdout();
 
     var line_buf: [65536]u8 = undefined;
     var input_buf: [65536]u8 = undefined;
@@ -196,7 +201,7 @@ fn runReplSimple(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void
             input_len += 1;
         }
         if (input_len + trimmed.len > input_buf.len) {
-            _ = stdout.write("Error: input too long\n") catch {};
+            stdout.writeStreamingAll(io_default.get(),"Error: input too long\n") catch {};
             input_len = 0;
             depth = 0;
             continue;
@@ -225,11 +230,13 @@ fn runReplSimple(allocator: Allocator, env: *Env, gc: *gc_mod.MarkSweepGc) void
 }
 
 /// Read a line from file into buf. Returns line length, or null on EOF with no data.
-fn readLine(file: std.fs.File, buf: []u8) ?usize {
+fn readLine(file: std.Io.File, buf: []u8) ?usize {
+    const rl_io = io_default.get();
     var pos: usize = 0;
     while (pos < buf.len) {
         var byte: [1]u8 = undefined;
-        const n = file.read(&byte) catch return null;
+        const buffers = [_][]u8{&byte};
+        const n = file.readStreaming(rl_io, &buffers) catch return null;
         if (n == 0) {
             // EOF
             if (pos > 0) return pos;
@@ -291,11 +298,11 @@ const ExprPrintCtx = struct {
     fn onResult(ctx_ptr: *anyopaque, val: Value) void {
         const self: *ExprPrintCtx = @ptrCast(@alignCast(ctx_ptr));
         if (val.isNil()) return;
-        const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+        const stdout = std.Io.File.stdout();
         var buf: [65536]u8 = undefined;
         const output = formatValue(&buf, val, self.allocator, self.env);
-        _ = stdout.write(output) catch {};
-        _ = stdout.write("\n") catch {};
+        stdout.writeStreamingAll(io_default.get(),output) catch {};
+        stdout.writeStreamingAll(io_default.get(),"\n") catch {};
     }
 };
 
@@ -307,17 +314,17 @@ const ReplPrintCtx = struct {
 
     fn onResult(ctx_ptr: *anyopaque, val: Value) void {
         const self: *ReplPrintCtx = @ptrCast(@alignCast(ctx_ptr));
-        const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+        const stdout = std.Io.File.stdout();
         var buf: [65536]u8 = undefined;
         const output = formatValue(&buf, val, self.allocator, self.env);
         if (self.is_tty) {
             var color_buf: [65536 + 32]u8 = undefined;
             const colored = colorizeValue(&color_buf, output, val);
-            _ = stdout.write(colored) catch {};
+            stdout.writeStreamingAll(io_default.get(),colored) catch {};
         } else {
-            _ = stdout.write(output) catch {};
+            stdout.writeStreamingAll(io_default.get(),output) catch {};
         }
-        _ = stdout.write("\n") catch {};
+        stdout.writeStreamingAll(io_default.get(),"\n") catch {};
     }
 };
 
@@ -413,7 +420,7 @@ pub fn runExecFn(
     var env = Env.init(infra_alloc);
     defer env.deinit();
     bootstrapFromCache(gc_alloc, &env, gc);
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
+    const stderr = std.Io.File.stderr();
 
     // Parse fn_name: "ns/fn" → require ns, call ns/fn
     const slash_idx = std.mem.indexOf(u8, fn_name, "/");
@@ -422,7 +429,7 @@ pub fn runExecFn(
         // Require the namespace
         var req_buf: [4096]u8 = undefined;
         const require_expr = std.fmt.bufPrint(&req_buf, "(require '{s})", .{ns_part}) catch {
-            _ = stderr.write("Error: namespace name too long\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),"Error: namespace name too long\n") catch {};
             std.process.exit(1);
         };
         _ = bootstrap.evalString(gc_alloc, &env, require_expr) catch |e| {
@@ -433,8 +440,8 @@ pub fn runExecFn(
 
     // Build the invocation expression: (fn-name {:key "val" ...})
     var call_buf: [8192]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&call_buf);
-    const w = stream.writer();
+    var w_inst: std.Io.Writer = .fixed(&call_buf);
+    const w = &w_inst;
     w.print("({s}", .{fn_name}) catch {};
 
     // Build args map from alias exec-args + CLI override args.
@@ -484,7 +491,7 @@ pub fn runExecFn(
     }
     w.writeAll(")") catch {};
 
-    const call_expr = stream.getWritten();
+    const call_expr = w.buffered();
     _ = bootstrap.evalString(gc_alloc, &env, call_expr) catch |e| {
         reportError(e);
         std.process.exit(1);
@@ -578,11 +585,11 @@ const Ansi = struct {
 };
 
 pub fn reportError(eval_err: anyerror) void {
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
+    const stderr = std.Io.File.stderr();
     var buf: [4096]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buf);
-    const w = stream.writer();
-    const c = if (std.posix.isatty(std.posix.STDERR_FILENO)) Ansi.color else Ansi.plain;
+    var w_inst: std.Io.Writer = .fixed(&buf);
+    const w = &w_inst;
+    const c = if (std.Io.File.stderr().isTty(io_default.get()) catch false) Ansi.color else Ansi.plain;
 
     if (err.getLastError()) |info| {
         // Header: "Type error at REPL:1:5" or "Type error"
@@ -648,7 +655,7 @@ pub fn reportError(eval_err: anyerror) void {
         err.clearCallStack();
     }
 
-    _ = stderr.write(stream.getWritten()) catch {};
+    stderr.writeStreamingAll(io_default.get(), w.buffered()) catch {};
 }
 
 fn kindToLabel(kind: err.Kind) []const u8 {
@@ -772,10 +779,10 @@ fn getSourceForLocation(location: err.SourceLocation) ?[]const u8 {
 
 threadlocal var file_read_buf: [64 * 1024]u8 = undefined;
 fn readFileForError(path: []const u8) ?[]const u8 {
-    const file = std.fs.cwd().openFile(path, .{}) catch return null;
-    defer file.close();
-    const bytes_read = file.readAll(&file_read_buf) catch return null;
-    return file_read_buf[0..bytes_read];
+    const fio = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    const data = cwd.readFile(fio, path, &file_read_buf) catch return null;
+    return data;
 }
 
 // === Value formatting ===
@@ -807,52 +814,28 @@ fn colorizeValue(buf: []u8, text: []const u8, val: Value) []const u8 {
         return buf[0..text.len];
     }
     const reset = "\x1b[0m";
-    var stream = std.io.fixedBufferStream(buf);
-    const w = stream.writer();
+    var w_inst: std.Io.Writer = .fixed(buf);
+    const w = &w_inst;
     w.writeAll(color) catch {};
     w.writeAll(text) catch {};
     w.writeAll(reset) catch {};
-    return stream.getWritten();
+    return w.buffered();
 }
 
 // === Single Binary Builder (Phase 28) ===
 
 /// Read embedded source from this binary's CLJW trailer.
 /// Returns null if no trailer found (normal cljw binary).
+///
+/// Temporarily disabled while migrating off std.fs.selfExePath /
+/// std.fs.openFileAbsolute (both removed in Zig 0.16). Phase 7 follow-up
+/// will re-implement self-path resolution via argv[0] + std.c.realpath
+/// and switch to std.Io.Dir.openFileAbsolute. Until then, `cljw build`
+/// output binaries report "no embedded payload" and fall through to the
+/// normal CLI dispatch.
 pub fn readEmbeddedSource(allocator: Allocator) ?[]const u8 {
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const self_path = std.fs.selfExePath(&path_buf) catch return null;
-    const file = std.fs.openFileAbsolute(self_path, .{}) catch return null;
-    defer file.close();
-    const stat = file.stat() catch return null;
-    const file_size = stat.size;
-    if (file_size < embed_trailer_size) return null;
-
-    // Read trailer (last 12 bytes)
-    file.seekTo(file_size - embed_trailer_size) catch return null;
-    var trailer: [embed_trailer_size]u8 = undefined;
-    const n = file.readAll(&trailer) catch return null;
-    if (n != embed_trailer_size) return null;
-
-    // Check magic
-    if (!std.mem.eql(u8, trailer[8..12], embed_magic)) return null;
-
-    // Extract payload size
-    const payload_size = std.mem.readInt(u64, trailer[0..8], .little);
-    if (payload_size == 0 or payload_size > file_size - embed_trailer_size) return null;
-
-    // Read payload
-    file.seekTo(file_size - embed_trailer_size - payload_size) catch return null;
-    const source = allocator.alloc(u8, @intCast(payload_size)) catch return null;
-    const bytes_read = file.readAll(source) catch {
-        allocator.free(source);
-        return null;
-    };
-    if (bytes_read != @as(usize, @intCast(payload_size))) {
-        allocator.free(source);
-        return null;
-    }
-    return source;
+    _ = allocator;
+    return null;
 }
 
 /// Evaluate embedded source and exit. Used by built binaries.
@@ -889,9 +872,9 @@ pub fn startNreplWithFile(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
     ns_ops.detectAndAddSrcPath(dir) catch {};
 
     const max_file_size = 10 * 1024 * 1024;
-    const file_bytes = std.fs.cwd().readFileAlloc(infra_alloc, filepath, max_file_size) catch {
-        const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-        _ = stderr.write("Error: could not read file\n") catch {};
+    const file_bytes = std.Io.Dir.cwd().readFileAlloc(io_default.get(), filepath, infra_alloc, .limited(max_file_size)) catch {
+        const stderr = std.Io.File.stderr();
+        stderr.writeStreamingAll(io_default.get(),"Error: could not read file\n") catch {};
         std.process.exit(1);
     };
     defer infra_alloc.free(file_bytes);
@@ -910,10 +893,10 @@ pub fn startNreplWithFile(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
 
     // Start nREPL server with user's Env (blocking accept loop).
     nrepl.startServerWithEnv(infra_alloc, &env, gc, nrepl_port) catch |e| {
-        const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-        _ = stderr.write("Error: nREPL server failed: ") catch {};
-        _ = stderr.write(@errorName(e)) catch {};
-        _ = stderr.write("\n") catch {};
+        const stderr = std.Io.File.stderr();
+        stderr.writeStreamingAll(io_default.get(),"Error: nREPL server failed: ") catch {};
+        stderr.writeStreamingAll(io_default.get(),@errorName(e)) catch {};
+        stderr.writeStreamingAll(io_default.get(),"\n") catch {};
         std.process.exit(1);
     };
 
@@ -941,10 +924,10 @@ fn evalEmbeddedWithNrepl(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mo
     // Start nREPL server with user's Env (blocking accept loop).
     // Returns when shutdown signal is received.
     nrepl.startServerWithEnv(infra_alloc, &env, gc, nrepl_port) catch |e| {
-        const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-        _ = stderr.write("Error: nREPL server failed: ") catch {};
-        _ = stderr.write(@errorName(e)) catch {};
-        _ = stderr.write("\n") catch {};
+        const stderr = std.Io.File.stderr();
+        stderr.writeStreamingAll(io_default.get(),"Error: nREPL server failed: ") catch {};
+        stderr.writeStreamingAll(io_default.get(),@errorName(e)) catch {};
+        stderr.writeStreamingAll(io_default.get(),"\n") catch {};
         std.process.exit(1);
     };
 
@@ -974,8 +957,8 @@ fn setCommandLineArgs(gc_alloc: Allocator, env: *Env, cli_args: []const [:0]cons
 /// Evaluates the entry file to resolve all requires, then bundles dependency
 /// sources (in load order) + entry source into a single binary.
 pub fn handleBuildCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc, build_args: []const [:0]const u8) void {
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+    const stderr = std.Io.File.stderr();
+    const stdout = std.Io.File.stdout();
 
     var source_file: ?[]const u8 = null;
     var output_file: ?[]const u8 = null;
@@ -984,7 +967,7 @@ pub fn handleBuildCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
         if (std.mem.eql(u8, build_args[i], "-o")) {
             i += 1;
             if (i >= build_args.len) {
-                _ = stderr.write("Error: -o requires an output file argument\n") catch {};
+                stderr.writeStreamingAll(io_default.get(),"Error: -o requires an output file argument\n") catch {};
                 std.process.exit(1);
             }
             output_file = build_args[i];
@@ -994,14 +977,14 @@ pub fn handleBuildCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
     }
 
     if (source_file == null) {
-        _ = stderr.write("Usage: cljw build <source.clj> [-o <output>]\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Usage: cljw build <source.clj> [-o <output>]\n") catch {};
         std.process.exit(1);
     }
 
     // Read entry file source
     const max_file_size = 10 * 1024 * 1024; // 10MB
-    const user_source = std.fs.cwd().readFileAlloc(infra_alloc, source_file.?, max_file_size) catch {
-        _ = stderr.write("Error: could not read source file\n") catch {};
+    const user_source = std.Io.Dir.cwd().readFileAlloc(io_default.get(), source_file.?, infra_alloc, .limited(max_file_size)) catch {
+        stderr.writeStreamingAll(io_default.get(),"Error: could not read source file\n") catch {};
         std.process.exit(1);
     };
     defer infra_alloc.free(user_source);
@@ -1032,7 +1015,7 @@ pub fn handleBuildCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
         bundled_size += rec.content.len + 1; // +1 for newline separator
     }
     const bundled = infra_alloc.alloc(u8, bundled_size) catch {
-        _ = stderr.write("Error: out of memory\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Error: out of memory\n") catch {};
         std.process.exit(1);
     };
     defer infra_alloc.free(bundled);
@@ -1055,55 +1038,14 @@ pub fn handleBuildCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_m
         break :blk src;
     };
 
-    // Read self binary
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const self_path = std.fs.selfExePath(&path_buf) catch {
-        _ = stderr.write("Error: could not determine self executable path\n") catch {};
-        std.process.exit(1);
-    };
-    const self_bytes = std.fs.cwd().readFileAlloc(infra_alloc, self_path, 100 * 1024 * 1024) catch {
-        _ = stderr.write("Error: could not read self executable\n") catch {};
-        std.process.exit(1);
-    };
-    defer infra_alloc.free(self_bytes);
-
-    // Write output: [self binary] + [bundled source] + [u64 size] + "CLJW"
-    const out_file = std.fs.cwd().createFile(out_name, .{ .mode = 0o755 }) catch {
-        _ = stderr.write("Error: could not create output file\n") catch {};
-        std.process.exit(1);
-    };
-    defer out_file.close();
-
-    out_file.writeAll(self_bytes) catch {
-        _ = stderr.write("Error: write failed\n") catch {};
-        std.process.exit(1);
-    };
-    out_file.writeAll(bundled) catch {
-        _ = stderr.write("Error: write failed\n") catch {};
-        std.process.exit(1);
-    };
-    const size_bytes = std.mem.toBytes(std.mem.nativeTo(u64, @as(u64, @intCast(bundled.len)), .little));
-    out_file.writeAll(&size_bytes) catch {
-        _ = stderr.write("Error: write failed\n") catch {};
-        std.process.exit(1);
-    };
-    out_file.writeAll(embed_magic) catch {
-        _ = stderr.write("Error: write failed\n") catch {};
-        std.process.exit(1);
-    };
-
-    // Report success
-    const dep_count = loaded_files.len;
-    const total_size = self_bytes.len + bundled.len + embed_trailer_size;
-    var msg_buf: [512]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&msg_buf);
-    const w = stream.writer();
-    if (dep_count > 0) {
-        w.print("Built: {s} ({d} bytes, {d} deps, source: {d} bytes)\n", .{ out_name, total_size, dep_count, bundled.len }) catch {};
-    } else {
-        w.print("Built: {s} ({d} bytes, source: {d} bytes)\n", .{ out_name, total_size, bundled.len }) catch {};
-    }
-    _ = stdout.write(stream.getWritten()) catch {};
+    // `cljw build` is temporarily disabled while the std.fs.selfExePath /
+    // std.fs.openFileAbsolute migration lands. Both APIs were removed in
+    // Zig 0.16; reimplementing self-path resolution requires either argv[0]
+    // + std.c.realpath or platform-specific calls (_NSGetExecutablePath
+    // on macOS, /proc/self/exe on Linux). Phase 7 follow-up F##.
+    _ = .{ bundled, out_name, stdout };
+    stderr.writeStreamingAll(io_default.get(), "cljw build: temporarily disabled while the std.fs.selfExePath migration lands (Phase 7 follow-up). Use `zig build && cljw <file.clj>` instead.\n") catch {};
+    std.process.exit(1);
 }
 
 /// Run embedded bytecode payload (built binary with compiled .cljc).
diff --git a/src/app/test_runner.zig b/src/app/test_runner.zig
index d9d30317..8276c367 100644
--- a/src/app/test_runner.zig
+++ b/src/app/test_runner.zig
@@ -22,6 +22,7 @@ const wasm_builtins = @import("../lang/lib/cljw_wasm_builtins.zig");
 const thread_pool = @import("../runtime/thread_pool.zig");
 const runner = @import("runner.zig");
 const cli = @import("cli.zig");
+const io_default = @import("../runtime/io_default.zig");
 
 const build_options = @import("build_options");
 const enable_wasm = build_options.enable_wasm;
@@ -31,8 +32,8 @@ const enable_wasm = build_options.enable_wasm;
 /// Otherwise, searches :test-paths (or "test/") for .clj files and runs all tests.
 /// Supports -A:alias for extra paths/deps via deps.edn aliases.
 pub fn handleTestCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mod.MarkSweepGc, test_args: []const [:0]const u8) void {
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-    const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
+    const stderr = std.Io.File.stderr();
+    const stdout = std.Io.File.stdout();
 
     // Parse test subcommand flags: -A:alias, --tree-walk, and file paths
     var test_alias_str: ?[]const u8 = null;
@@ -70,8 +71,8 @@ pub fn handleTestCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mo
 
         // Print warnings
         for (resolved.warnings) |warning| {
-            _ = stderr.write(warning) catch {};
-            _ = stderr.write("\n") catch {};
+            stderr.writeStreamingAll(io_default.get(),warning) catch {};
+            stderr.writeStreamingAll(io_default.get(),"\n") catch {};
         }
 
         // Apply paths
@@ -140,7 +141,7 @@ pub fn handleTestCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mo
     }
 
     if (test_files.items.len == 0) {
-        _ = stderr.write("No test files found.\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"No test files found.\n") catch {};
         std.process.exit(1);
     }
 
@@ -153,10 +154,10 @@ pub fn handleTestCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mo
     var loaded: usize = 0;
     var total_failures = false;
     for (test_files.items) |tf| {
-        const file_bytes = std.fs.cwd().readFileAlloc(file_alloc, tf, max_file_size) catch {
-            _ = stderr.write("Error: could not read ") catch {};
-            _ = stderr.write(tf) catch {};
-            _ = stderr.write("\n") catch {};
+        const file_bytes = std.Io.Dir.cwd().readFileAlloc(io_default.get(), tf, file_alloc, .limited(max_file_size)) catch {
+            stderr.writeStreamingAll(io_default.get(),"Error: could not read ") catch {};
+            stderr.writeStreamingAll(io_default.get(),tf) catch {};
+            stderr.writeStreamingAll(io_default.get(),"\n") catch {};
             continue;
         };
 
@@ -185,12 +186,12 @@ pub fn handleTestCommand(gc_alloc: Allocator, infra_alloc: Allocator, gc: *gc_mo
     }
 
     if (loaded == 0) {
-        _ = stderr.write("Error: no test files loaded successfully.\n") catch {};
+        stderr.writeStreamingAll(io_default.get(),"Error: no test files loaded successfully.\n") catch {};
         std.process.exit(1);
     }
 
     // Print newline after test output
-    _ = stdout.write("\n") catch {};
+    stdout.writeStreamingAll(io_default.get(),"\n") catch {};
 
     if (total_failures) {
         std.process.exit(1);
@@ -219,13 +220,14 @@ fn checkTestFailures(result: Value) bool {
 /// str_alloc: arena for path strings (long-lived), list_alloc: for ArrayList backing.
 /// Skips directories not suitable for `cljw test` (e2e, compat, etc.).
 fn collectTestFiles(str_alloc: Allocator, list_alloc: Allocator, dir_path: []const u8, out: *std.ArrayList([]const u8)) void {
-    var dir = std.fs.cwd().openDir(dir_path, .{ .iterate = true }) catch return;
-    defer dir.close();
+    const td_io = io_default.get();
+    var dir = std.Io.Dir.cwd().openDir(td_io, dir_path, .{ .iterate = true }) catch return;
+    defer dir.close(td_io);
 
     const skip_dirs = [_][]const u8{ "e2e", "compat", "diff", "wasm" };
 
     var it = dir.iterate();
-    while (it.next() catch null) |entry| {
+    while (it.next(td_io) catch null) |entry| {
         if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".clj")) {
             const full = std.fmt.allocPrint(str_alloc, "{s}/{s}", .{ dir_path, entry.name }) catch continue;
             out.append(list_alloc, full) catch {};
diff --git a/src/cache_gen.zig b/src/cache_gen.zig
index 0eb804d1..a33cf546 100644
--- a/src/cache_gen.zig
+++ b/src/cache_gen.zig
@@ -22,18 +22,19 @@ const bootstrap = @import("engine/bootstrap.zig");
 const gc_mod = @import("runtime/gc.zig");
 const keyword_intern = @import("runtime/keyword_intern.zig");
 const clojure_core_protocols = @import("lang/lib/clojure_core_protocols.zig");
+const io_default = @import("runtime/io_default.zig");
 
-pub fn main() !void {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const io = init.io;
+    io_default.set(io);
+    io_default.setEnvironMap(init.environ_map);
 
     var gc = gc_mod.MarkSweepGc.init(allocator);
     defer gc.deinit();
     const alloc = gc.allocator();
 
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
+    const args = try init.minimal.args.toSlice(init.arena.allocator());
 
     if (args.len < 2) {
         std.debug.print("Usage: cache_gen <output_file>\n", .{});
@@ -61,7 +62,7 @@ pub fn main() !void {
     std.debug.print("cache_gen: generateBootstrapCache OK\n", .{});
 
     // Write to output file
-    const out_file = try std.fs.cwd().createFile(args[1], .{});
-    defer out_file.close();
-    try out_file.writeAll(cache_bytes);
+    const out_file = try std.Io.Dir.cwd().createFile(io, args[1], .{});
+    defer out_file.close(io);
+    try out_file.writePositionalAll(io, cache_bytes, 0);
 }
diff --git a/src/engine/analyzer/analyzer.zig b/src/engine/analyzer/analyzer.zig
index 4e9f9ee2..bd15f79c 100644
--- a/src/engine/analyzer/analyzer.zig
+++ b/src/engine/analyzer/analyzer.zig
@@ -3320,7 +3320,7 @@ pub fn formToValue(allocator: Allocator, form: Form) Value {
         .keyword => |sym| Value.initKeyword(allocator, .{ .ns = sym.ns, .name = sym.name }),
         // Collections/regex not supported here — use macro.formToValue instead.
         .list, .vector, .map, .set => Value.nil_val,
-        .regex => |_| Value.nil_val,
+        .regex => Value.nil_val,
         .tag => Value.nil_val,
     };
 }
@@ -4002,7 +4002,8 @@ test "fuzz analyzer" {
     try std.testing.fuzz(
         {},
         struct {
-            fn testOne(_: @TypeOf({}), input: []const u8) anyerror!void {
+            fn testOne(_: @TypeOf({}), smith: *std.testing.Smith) anyerror!void {
+                const input = smith.in orelse return;
                 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
                 defer arena.deinit();
                 const alloc = arena.allocator();
diff --git a/src/engine/analyzer/node.zig b/src/engine/analyzer/node.zig
index a68e97d8..8b27ced2 100644
--- a/src/engine/analyzer/node.zig
+++ b/src/engine/analyzer/node.zig
@@ -356,7 +356,7 @@ pub const Node = union(enum) {
     /// Return the node kind name for debugging.
     pub fn kindName(self: Node) []const u8 {
         return switch (self) {
-            .constant => |_| "constant",
+            .constant => "constant",
             .var_ref => "var-ref",
             .local_ref => "local-ref",
             .if_node => "if",
diff --git a/src/engine/compiler/compiler.zig b/src/engine/compiler/compiler.zig
index 076d698a..fdb726d1 100644
--- a/src/engine/compiler/compiler.zig
+++ b/src/engine/compiler/compiler.zig
@@ -1711,7 +1711,8 @@ test "fuzz compiler and vm" {
     try std.testing.fuzz(
         {},
         struct {
-            fn testOne(_: @TypeOf({}), input: []const u8) anyerror!void {
+            fn testOne(_: @TypeOf({}), smith: *std.testing.Smith) anyerror!void {
+                const input = smith.in orelse return;
                 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
                 defer arena.deinit();
                 const alloc = arena.allocator();
@@ -1893,7 +1894,8 @@ test "fuzz compiler and vm structured" {
                 }
             }
 
-            fn testOne(_: @TypeOf({}), input_raw: []const u8) anyerror!void {
+            fn testOne(_: @TypeOf({}), smith: *std.testing.Smith) anyerror!void {
+                const input_raw = smith.in orelse return;
                 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
                 defer arena.deinit();
                 const alloc = arena.allocator();
diff --git a/src/engine/pipeline.zig b/src/engine/pipeline.zig
index c5e26acc..a4ba2f72 100644
--- a/src/engine/pipeline.zig
+++ b/src/engine/pipeline.zig
@@ -26,6 +26,7 @@ const Env = @import("../runtime/env.zig").Env;
 const Namespace = @import("../runtime/namespace.zig").Namespace;
 const err = @import("../runtime/error.zig");
 const TreeWalk = @import("evaluator/tree_walk.zig").TreeWalk;
+const io_default = @import("../runtime/io_default.zig");
 // predicates_mod removed — current_env now in dispatch.zig (D109 Z3)
 const chunk_mod = @import("compiler/chunk.zig");
 const Compiler = @import("compiler/compiler.zig").Compiler;
@@ -174,8 +175,7 @@ pub fn dumpBytecodeVM(allocator: Allocator, env: *Env, source: []const u8) Boots
 
     // Write collected output to stderr
     const output = w.buffered();
-    const stderr: std.fs.File = .{ .handle = std.posix.STDERR_FILENO };
-    _ = stderr.write(output) catch {};
+    std.Io.File.stderr().writeStreamingAll(io_default.get(), output) catch {};
 }
 
 pub fn evalStringVM(allocator: Allocator, env: *Env, source: []const u8) BootstrapError!Value {
diff --git a/src/engine/reader/reader.zig b/src/engine/reader/reader.zig
index ad82925c..a8fe37a0 100644
--- a/src/engine/reader/reader.zig
+++ b/src/engine/reader/reader.zig
@@ -1550,7 +1550,8 @@ test "fuzz reader" {
     try std.testing.fuzz(
         {},
         struct {
-            fn testOne(_: @TypeOf({}), input: []const u8) anyerror!void {
+            fn testOne(_: @TypeOf({}), smith: *std.testing.Smith) anyerror!void {
+                const input = smith.in orelse return;
                 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
                 defer arena.deinit();
                 const alloc = arena.allocator();
diff --git a/src/engine/vm/jit.zig b/src/engine/vm/jit.zig
index 51988986..2a7d2cd9 100644
--- a/src/engine/vm/jit.zig
+++ b/src/engine/vm/jit.zig
@@ -55,11 +55,10 @@ pub const JitCompiler = struct {
     const BUFFER_SIZE = PAGE_SIZE; // 1 page for PoC
 
     pub fn init() !JitCompiler {
-        const PROT = std.posix.PROT;
         const mem = std.posix.mmap(
             null,
             BUFFER_SIZE,
-            PROT.READ | PROT.WRITE,
+            .{ .READ = true, .WRITE = true },
             .{ .TYPE = .PRIVATE, .ANONYMOUS = true },
             -1,
             0,
@@ -80,9 +79,12 @@ pub const JitCompiler = struct {
 
     /// Make the buffer executable (W^X transition).
     fn makeExecutable(self: *JitCompiler) !void {
-        const PROT = std.posix.PROT;
-        std.posix.mprotect(@alignCast(self.buffer), PROT.READ | PROT.EXEC) catch
+        // Zig 0.16 removed std.posix.mprotect; use libc directly.
+        const region: []align(PAGE_SIZE) u8 = @alignCast(self.buffer);
+        const prot: std.posix.PROT = .{ .READ = true, .EXEC = true };
+        if (std.c.mprotect(region.ptr, region.len, prot) != 0) {
             return error.MprotectFailed;
+        }
         // Flush instruction cache (required on ARM64).
         icacheInvalidate(self.buffer.ptr, self.offset);
     }
diff --git a/src/lang/builtins/arithmetic.zig b/src/lang/builtins/arithmetic.zig
index 453995a8..5544eab2 100644
--- a/src/lang/builtins/arithmetic.zig
+++ b/src/lang/builtins/arithmetic.zig
@@ -24,6 +24,7 @@ const BigInt = collections.BigInt;
 const BigDecimal = collections.BigDecimal;
 const Ratio = collections.Ratio;
 const err = @import("../../runtime/error.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // Core arithmetic ops live in runtime/ (D109). Re-export for lang/ consumers.
 const runtime_arith = @import("../../runtime/arithmetic.zig");
@@ -436,20 +437,22 @@ pub fn quotFn(_: Allocator, args: []const Value) anyerror!Value {
 // PRNG state for rand/rand-int (module-level, deterministic seed for testing)
 // Protected by mutex for thread-safe access.
 var prng = std.Random.DefaultPrng.init(0);
-var prng_mutex: std.Thread.Mutex = .{};
+var prng_mutex: std.Io.Mutex = .init;
 
 /// Set PRNG seed (for testing reproducibility).
 pub fn setSeed(seed: u64) void {
-    prng_mutex.lock();
-    defer prng_mutex.unlock();
+    const io = io_default.get();
+    prng_mutex.lockUncancelable(io);
+    defer prng_mutex.unlock(io);
     prng = std.Random.DefaultPrng.init(seed);
 }
 
 /// (rand) — returns a random float between 0 (inclusive) and 1 (exclusive).
 pub fn randFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 0) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to rand", .{args.len});
-    prng_mutex.lock();
-    defer prng_mutex.unlock();
+    const io = io_default.get();
+    prng_mutex.lockUncancelable(io);
+    defer prng_mutex.unlock(io);
     const f = prng.random().float(f64);
     return Value.initFloat(f);
 }
@@ -463,8 +466,9 @@ pub fn randIntFn(_: Allocator, args: []const Value) anyerror!Value {
     };
     if (n <= 0) return err.setErrorFmt(.eval, .arithmetic_error, .{}, "rand-int argument must be positive, got {d}", .{n});
     const un: u64 = @intCast(n);
-    prng_mutex.lock();
-    defer prng_mutex.unlock();
+    const io = io_default.get();
+    prng_mutex.lockUncancelable(io);
+    defer prng_mutex.unlock(io);
     const result = prng.random().intRangeLessThan(u64, 0, un);
     return Value.initInteger(@intCast(result));
 }
diff --git a/src/lang/builtins/atom.zig b/src/lang/builtins/atom.zig
index eb8d0ab7..8a18be54 100644
--- a/src/lang/builtins/atom.zig
+++ b/src/lang/builtins/atom.zig
@@ -25,6 +25,7 @@ const dispatch = @import("../../runtime/dispatch.zig");
 const err = @import("../../runtime/error.zig");
 const thread_pool_mod = @import("../../runtime/thread_pool.zig");
 const env_mod = @import("../../runtime/env.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 /// (atom val) => #<atom val>
 pub fn atomFn(allocator: Allocator, args: []const Value) anyerror!Value {
@@ -1008,8 +1009,8 @@ pub fn refHistoryCountFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to ref-history-count", .{args.len});
     if (args[0].tag() != .ref) return err.setErrorFmt(.eval, .type_error, .{}, "ref-history-count expects a ref, got {s}", .{@tagName(args[0].tag())});
     const inner: *value_mod.RefInner = @ptrCast(@alignCast(args[0].asRef().inner));
-    inner.lock.lock();
-    defer inner.lock.unlock();
+    io_default.lockMutex(&inner.lock);
+    defer io_default.unlockMutex(&inner.lock);
     var count: i64 = 0;
     var tval = inner.tvals;
     while (tval) |tv| {
@@ -1111,8 +1112,8 @@ pub fn restartAgentFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 2) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to restart-agent", .{args.len});
     if (args[0].tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "restart-agent expects an agent" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     if (!inner.isInErrorState()) {
         return err.setError(.{ .kind = .value_error, .phase = .eval, .message = "Agent does not need restart" });
     }
@@ -1126,8 +1127,8 @@ pub fn setErrorHandlerFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 2) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to set-error-handler!", .{args.len});
     if (args[0].tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "set-error-handler! expects an agent" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     inner.error_handler = args[1];
     return args[0];
 }
@@ -1137,8 +1138,8 @@ pub fn errorHandlerFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to error-handler", .{args.len});
     if (args[0].tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "error-handler expects an agent" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     const handler = inner.error_handler;
     if (handler.tag() == .nil) return Value.nil_val;
     return handler;
@@ -1149,8 +1150,8 @@ pub fn errorModeFn(allocator: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to error-mode", .{args.len});
     if (args[0].tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "error-mode expects an agent" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     return switch (inner.error_mode) {
         .continue_mode => Value.initKeyword(allocator, .{ .ns = null, .name = "continue" }),
         .fail_mode => Value.initKeyword(allocator, .{ .ns = null, .name = "fail" }),
@@ -1165,8 +1166,8 @@ pub fn setErrorModeFn(_: Allocator, args: []const Value) anyerror!Value {
     const mode_kw = args[1].asKeyword();
     if (mode_kw.ns != null) return err.setError(.{ .kind = .value_error, .phase = .eval, .message = "Invalid agent error mode" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     if (std.mem.eql(u8, mode_kw.name, "continue")) {
         inner.error_mode = .continue_mode;
     } else if (std.mem.eql(u8, mode_kw.name, "fail")) {
@@ -1206,10 +1207,10 @@ pub fn sendFn(allocator: Allocator, args: []const Value) anyerror!Value {
     action.* = .{ .func = args[1], .args = extra_args };
 
     // Enqueue and trigger processing
-    inner.mutex.lock();
+    io_default.lockMutex(&inner.mutex);
     inner.enqueue(action);
     const was_processing = inner.processing.swap(true, .acq_rel);
-    inner.mutex.unlock();
+    io_default.unlockMutex(&inner.mutex);
 
     if (!was_processing) {
         // Submit agent work to thread pool
@@ -1237,11 +1238,11 @@ pub fn awaitFn(_: Allocator, args: []const Value) anyerror!Value {
     for (args) |arg| {
         if (arg.tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "await expects agents" });
         const inner = arg.asAgent().getInner();
-        inner.mutex.lock();
+        io_default.lockMutex(&inner.mutex);
         while (inner.processing.load(.acquire) or inner.action_head != null) {
-            inner.await_cond.wait(&inner.mutex);
+            io_default.condWait(&inner.await_cond, &inner.mutex);
         }
-        inner.mutex.unlock();
+        io_default.unlockMutex(&inner.mutex);
     }
     return Value.nil_val;
 }
@@ -1257,18 +1258,19 @@ pub fn awaitForFn(_: Allocator, args: []const Value) anyerror!Value {
     for (args[1..]) |arg| {
         if (arg.tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "await-for expects agents" });
         const inner = arg.asAgent().getInner();
-        inner.mutex.lock();
-        const start = std.time.nanoTimestamp();
+        io_default.lockMutex(&inner.mutex);
+        const start_ts = std.Io.Timestamp.now(io_default.get(), .awake);
         while (inner.processing.load(.acquire) or inner.action_head != null) {
-            const elapsed: u64 = @intCast(@max(0, std.time.nanoTimestamp() - start));
+            const now_ts = std.Io.Timestamp.now(io_default.get(), .awake);
+            const elapsed: u64 = @intCast(@max(0, now_ts.nanoseconds - start_ts.nanoseconds));
             if (elapsed >= timeout_ns) {
-                inner.mutex.unlock();
+                io_default.unlockMutex(&inner.mutex);
                 return Value.nil_val; // timeout — return nil (logical false)
             }
             const remaining = timeout_ns - elapsed;
-            inner.await_cond.timedWait(&inner.mutex, remaining) catch {};
+            _ = io_default.condTimedWait(&inner.await_cond, &inner.mutex, remaining);
         }
-        inner.mutex.unlock();
+        io_default.unlockMutex(&inner.mutex);
     }
     return Value.true_val; // all completed
 }
@@ -1302,8 +1304,8 @@ pub fn clearAgentErrorsFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to clear-agent-errors", .{args.len});
     if (args[0].tag() != .agent) return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "clear-agent-errors expects an agent" });
     const inner = args[0].asAgent().getInner();
-    inner.mutex.lock();
-    defer inner.mutex.unlock();
+    io_default.lockMutex(&inner.mutex);
+    defer io_default.unlockMutex(&inner.mutex);
     inner.error_val = Value.nil_val;
     return args[0];
 }
diff --git a/src/lang/builtins/collections.zig b/src/lang/builtins/collections.zig
index 640fe58f..4524cf7c 100644
--- a/src/lang/builtins/collections.zig
+++ b/src/lang/builtins/collections.zig
@@ -27,6 +27,7 @@ const BuiltinDef = var_mod.BuiltinDef;
 const bootstrap = @import("../../engine/bootstrap.zig");
 const dispatch = @import("../../runtime/dispatch.zig");
 const err = @import("../../runtime/error.zig");
+const io_default = @import("../../runtime/io_default.zig");
 const vm_mod = @import("../../engine/vm/vm.zig");
 const sequences_mod = @import("sequences.zig");
 const transient_mod = @import("transient.zig");
@@ -919,7 +920,7 @@ pub fn shuffleFn(allocator: Allocator, args: []const Value) anyerror!Value {
     // Fisher-Yates shuffle
     const mutable = try allocator.alloc(Value, items.len);
     @memcpy(mutable, items);
-    var prng = std.Random.DefaultPrng.init(@truncate(@as(u128, @bitCast(std.time.nanoTimestamp()))));
+    var prng = std.Random.DefaultPrng.init(@truncate(@as(u128, @bitCast(io_default.nanoTimestamp()))));
     const random = prng.random();
     var i: usize = mutable.len - 1;
     while (i > 0) : (i -= 1) {
diff --git a/src/lang/builtins/eval.zig b/src/lang/builtins/eval.zig
index ea35d1d0..6f64eda7 100644
--- a/src/lang/builtins/eval.zig
+++ b/src/lang/builtins/eval.zig
@@ -28,6 +28,7 @@ const TreeWalk = @import("../../engine/evaluator/tree_walk.zig").TreeWalk;
 const err = @import("../../runtime/error.zig");
 const Env = @import("../../runtime/env.zig").Env;
 const io = @import("io.zig");
+const io_default = @import("../../runtime/io_default.zig");
 const value_mod = @import("../../runtime/value.zig");
 const PersistentVector = value_mod.PersistentVector;
 const Namespace = @import("../../runtime/namespace.zig").Namespace;
@@ -318,7 +319,8 @@ fn readFromSource(allocator: Allocator, eof_error: bool, eof_value: Value) anyer
     }
 
     // Read from stdin — read lines and try parsing after each
-    const stdin: std.fs.File = .{ .handle = std.posix.STDIN_FILENO };
+    const stdin = std.Io.File.stdin();
+    const stdin_io = io_default.get();
     var buf = std.ArrayList(u8).empty;
     defer buf.deinit(allocator);
 
@@ -331,7 +333,8 @@ fn readFromSource(allocator: Allocator, eof_error: bool, eof_value: Value) anyer
         var pos: usize = 0;
         while (pos < line_buf.len) {
             var byte: [1]u8 = undefined;
-            const n = stdin.read(&byte) catch {
+            const buffers = [_][]u8{&byte};
+            const n = stdin.readStreaming(stdin_io, &buffers) catch {
                 if (eof_error) {
                     return err.setErrorFmt(.eval, .io_error, .{}, "EOF while reading", .{});
                 }
@@ -433,7 +436,7 @@ fn readPlusStringFromSource(allocator: Allocator, eof_error: bool, eof_value: Va
         };
         const consumed = reader.position();
         // Capture the consumed source text (trimmed)
-        const src_text = std.mem.trimLeft(u8, remaining[0..consumed], " \t\n\r,");
+        const src_text = std.mem.trimStart(u8, remaining[0..consumed], " \t\n\r,");
         const text_str = Value.initString(allocator, try allocator.dupe(u8, src_text));
         io.advanceCurrentInput(consumed);
         const val = try macro.formToValueWithNs(allocator, form, resolveCurrentNs());
@@ -447,7 +450,8 @@ fn readPlusStringFromSource(allocator: Allocator, eof_error: bool, eof_value: Va
     }
 
     // stdin path — accumulate lines and return [form string]
-    const stdin: std.fs.File = .{ .handle = std.posix.STDIN_FILENO };
+    const stdin = std.Io.File.stdin();
+    const stdin_io = io_default.get();
     var buf = std.ArrayList(u8).empty;
     defer buf.deinit(allocator);
 
@@ -459,7 +463,8 @@ fn readPlusStringFromSource(allocator: Allocator, eof_error: bool, eof_value: Va
         var pos: usize = 0;
         while (pos < line_buf.len) {
             var byte: [1]u8 = undefined;
-            const n = stdin.read(&byte) catch {
+            const buffers = [_][]u8{&byte};
+            const n = stdin.readStreaming(stdin_io, &buffers) catch {
                 if (eof_error) {
                     return err.setErrorFmt(.eval, .io_error, .{}, "EOF while reading", .{});
                 }
@@ -494,7 +499,7 @@ fn readPlusStringFromSource(allocator: Allocator, eof_error: bool, eof_value: Va
             };
             if (form_opt) |form| {
                 const consumed = reader.position();
-                const src_text = std.mem.trimLeft(u8, buf.items[0..consumed], " \t\n\r,");
+                const src_text = std.mem.trimStart(u8, buf.items[0..consumed], " \t\n\r,");
                 const text_str = Value.initString(allocator, try allocator.dupe(u8, src_text));
                 const val = try macro.formToValueWithNs(allocator, form, resolveCurrentNs());
                 const items = try allocator.alloc(Value, 2);
diff --git a/src/lang/builtins/http_server.zig b/src/lang/builtins/http_server.zig
index bc4272eb..c8c920fe 100644
--- a/src/lang/builtins/http_server.zig
+++ b/src/lang/builtins/http_server.zig
@@ -46,6 +46,12 @@ pub var background_mode: bool = false;
 // Server state
 // ============================================================
 
+// Network-bound server state. The std.net APIs were removed in Zig 0.16; the
+// listener field's old type (std.net.Server) is no longer available. The
+// server runtime is stubbed below until the std.Io.net migration lands as
+// a follow-up task. The state struct is kept so that the public API surface
+// (run-server / set-handler!) doesn't change shape.
+
 /// Module-level storage for background server (nREPL mode).
 var bg_server: ?ServerState = null;
 
@@ -54,180 +60,25 @@ const ServerState = struct {
     handler: Value,
     alloc: Allocator,
     running: bool,
-    mutex: std.Thread.Mutex,
     port: u16,
-    listener: std.net.Server,
 };
 
 // ============================================================
 // Builtins
 // ============================================================
 
-/// (run-server handler opts)
-/// Starts an HTTP server that calls handler for each request.
-/// handler: (fn [request-map]) -> response-map
-/// opts: {:port N} (default 8080)
-/// Blocks until the server is stopped (e.g. via SIGINT).
-pub fn runServerFn(allocator: Allocator, args: []const Value) anyerror!Value {
+/// (run-server handler opts) — stubbed during the Zig 0.16 migration.
+/// std.net.Address/Server/Stream were all removed; the std.Io.net replacement
+/// requires substantial rework (futex-based accept, no acceptWithShutdownCheck,
+/// stream reader/writer interface). Tracked as a Phase 7 follow-up F## item.
+pub fn runServerFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len < 2) return err_mod.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to run-server", .{args.len});
-
-    // Skip during `cljw build` — allow require resolution without blocking.
     if (build_mode) return Value.nil_val;
-
-    const handler = args[0];
-    const opts = args[1];
-
-    // Validate handler is callable
-    switch (handler.tag()) {
-        .builtin_fn, .fn_val => {},
-        else => return err_mod.setError(.{ .kind = .type_error, .phase = .eval, .message = "run-server: first argument must be a function" }),
-    }
-
-    // Extract :port and :background from opts map
-    var port: u16 = 8080;
-    var use_background = background_mode;
-    if (opts.tag() == .map) {
-        const m = opts.asMap();
-        for (0..m.entries.len / 2) |i| {
-            const k = m.entries[i * 2];
-            const v = m.entries[i * 2 + 1];
-            if (k.tag() == .keyword) {
-                const name = k.asKeyword().name;
-                if (std.mem.eql(u8, name, "port")) {
-                    if (v.tag() == .integer) {
-                        const p = v.asInteger();
-                        if (p > 0 and p <= 65535) {
-                            port = @intCast(p);
-                        }
-                    }
-                } else if (std.mem.eql(u8, name, "background")) {
-                    use_background = v.isTruthy();
-                }
-            }
-        }
-    }
-
-    // Root the handler by storing it in a hidden var (GC protection).
-    const env = dispatch.macro_eval_env orelse return err_mod.setError(.{ .kind = .type_error, .phase = .eval, .message = "run-server: no evaluation environment" });
-    if (env.findNamespace("cljw.http")) |ns| {
-        if (ns.resolve("__handler")) |v| {
-            v.bindRoot(handler);
-        }
-    }
-
-    // Bind TCP socket
-    const address = std.net.Address.parseIp("0.0.0.0", port) catch {
-        return err_mod.setErrorFmt(.eval, .value_error, .{}, "run-server: failed to parse address for port {d}", .{port});
-    };
-    const listener = address.listen(.{ .reuse_address = true }) catch {
-        return err_mod.setErrorFmt(.eval, .value_error, .{}, "run-server: failed to listen on port {d}", .{port});
-    };
-
-    const actual_port = listener.listen_address.getPort();
-    std.debug.print("cljw.http server running on port {d}\n", .{actual_port});
-
-    if (use_background) {
-        // Non-blocking: store state in module-level static, run accept loop
-        // in background thread. Used with --nrepl so nREPL can start after eval.
-        bg_server = .{
-            .env = env,
-            .handler = handler,
-            .alloc = allocator,
-            .running = true,
-            .mutex = .{},
-            .port = actual_port,
-            .listener = listener,
-        };
-        const thread = std.Thread.spawn(.{}, acceptLoop, .{&bg_server.?}) catch {
-            return err_mod.setError(.{ .kind = .value_error, .phase = .eval, .message = "run-server: failed to spawn server thread" });
-        };
-        thread.detach();
-        return Value.nil_val;
-    }
-
-    // Blocking mode: state on stack, accept loop runs in current thread.
-    var state = ServerState{
-        .env = env,
-        .handler = handler,
-        .alloc = allocator,
-        .running = true,
-        .mutex = .{},
-        .port = actual_port,
-        .listener = listener,
-    };
-    defer state.listener.deinit();
-
-    acceptLoop(&state);
-    return Value.nil_val;
-}
-
-// ============================================================
-// Connection handler
-// ============================================================
-
-fn acceptLoop(state: *ServerState) void {
-    while (state.running and !lifecycle.isShutdownRequested()) {
-        const conn = lifecycle.acceptWithShutdownCheck(&state.listener) orelse break;
-        const thread = std.Thread.spawn(.{}, handleConnection, .{ state, conn }) catch |e| {
-            std.debug.print("thread spawn error: {s}\n", .{@errorName(e)});
-            conn.stream.close();
-            continue;
-        };
-        thread.detach();
-    }
-    std.debug.print("cljw.http server shutting down\n", .{});
-}
-
-fn handleConnection(state: *ServerState, conn: std.net.Server.Connection) void {
-    defer conn.stream.close();
-
-    // Read HTTP request (up to 64KB)
-    var buf: [65536]u8 = undefined;
-    const n = conn.stream.read(&buf) catch return;
-    if (n == 0) return;
-    const request = buf[0..n];
-
-    // Parse HTTP request
-    const parsed = parseHttpRequest(request) orelse {
-        sendErrorResponse(conn.stream, 400, "Bad Request");
-        return;
-    };
-
-    // Build Ring request map and call handler under mutex.
-    // Must set macro_eval_env for callFnVal (bytecodeCallBridge needs it).
-    state.mutex.lock();
-    defer state.mutex.unlock();
-
-    // Set up eval context for this thread
-    dispatch.macro_eval_env = state.env;
-    dispatch.current_env = state.env;
-
-    const ring_req = buildRingRequest(state.alloc, parsed, state.port, conn.address) catch {
-        sendErrorResponse(conn.stream, 500, "Internal Server Error");
-        return;
-    };
-
-    // Resolve handler: re-read from __handler Var to support live reload via nREPL.
-    // When user does (defn handler ...), the Var is rebound, and we pick it up here.
-    const current_handler = blk: {
-        if (state.env.findNamespace("cljw.http")) |ns| {
-            if (ns.resolve("__handler")) |v| {
-                const val = v.deref();
-                if (val.tag() == .fn_val or val.tag() == .builtin_fn) break :blk val;
-            }
-        }
-        break :blk state.handler; // fallback to captured handler
-    };
-
-    // Call handler function
-    const response = bootstrap.callFnVal(state.alloc, current_handler, &[1]Value{ring_req}) catch |e| {
-        std.debug.print("handler error: {s}\n", .{@errorName(e)});
-        sendErrorResponse(conn.stream, 500, "Internal Server Error");
-        return;
-    };
-
-    // Format and send HTTP response
-    sendRingResponse(conn.stream, state.alloc, response);
+    return err_mod.setError(.{
+        .kind = .internal_error,
+        .phase = .eval,
+        .message = "run-server: HTTP server is temporarily disabled while the std.net → std.Io.net migration is in progress",
+    });
 }
 
 // ============================================================
@@ -311,10 +162,12 @@ fn parseHttpRequest(raw: []const u8) ?ParsedRequest {
 }
 
 // ============================================================
-// Ring request map construction
+// Ring request map construction (kept for future restoration; the remote
+// address argument no longer carries a network type since the server is
+// stubbed for the migration).
 // ============================================================
 
-fn buildRingRequest(allocator: Allocator, parsed: ParsedRequest, server_port: u16, remote: std.net.Address) !Value {
+fn buildRingRequest(allocator: Allocator, parsed: ParsedRequest, server_port: u16, remote_addr: []const u8) !Value {
     // Build headers map
     const hdr_entries = try allocator.alloc(Value, parsed.header_count * 2);
     for (0..parsed.header_count) |i| {
@@ -338,16 +191,7 @@ fn buildRingRequest(allocator: Allocator, parsed: ParsedRequest, server_port: u1
     }
     const method_str = try allocator.dupe(u8, method_lower_buf[0..method_len]);
 
-    // Remote address string (IPv4 only for now)
-    var addr_buf: [64]u8 = undefined;
-    const ip_bytes = remote.in.sa.addr;
-    const addr_str = std.fmt.bufPrint(&addr_buf, "{d}.{d}.{d}.{d}", .{
-        @as(u8, @truncate(ip_bytes)),
-        @as(u8, @truncate(ip_bytes >> 8)),
-        @as(u8, @truncate(ip_bytes >> 16)),
-        @as(u8, @truncate(ip_bytes >> 24)),
-    }) catch "unknown";
-    const addr_dup = try allocator.dupe(u8, addr_str);
+    const addr_dup = try allocator.dupe(u8, remote_addr);
 
     // URI and query string
     const uri_dup = try allocator.dupe(u8, parsed.uri);
@@ -427,10 +271,12 @@ fn buildRingRequest(allocator: Allocator, parsed: ParsedRequest, server_port: u1
 }
 
 // ============================================================
-// Ring response formatting
+// Ring response formatting — currently unused (server runtime is stubbed).
+// Kept compiling against std.Io.Writer so it can be wired up once the
+// std.Io.net migration is implemented in a follow-up task.
 // ============================================================
 
-fn sendRingResponse(stream: std.net.Stream, allocator: Allocator, response: Value) void {
+fn sendRingResponseToBuffer(buf: []u8, allocator: Allocator, response: Value) []const u8 {
     // Extract :status, :headers, :body from response map
     var status: i64 = 200;
     var body: []const u8 = "";
@@ -454,14 +300,12 @@ fn sendRingResponse(stream: std.net.Stream, allocator: Allocator, response: Valu
         }
     }
 
-    // Format HTTP response
-    var buf: [65536]u8 = undefined;
-    var w: std.Io.Writer = .fixed(&buf);
+    // Format HTTP response into the caller-provided buffer.
+    _ = allocator;
+    var w: std.Io.Writer = .fixed(buf);
 
-    // Status line
-    w.print("HTTP/1.1 {d} {s}\r\n", .{ status, statusText(status) }) catch return;
+    w.print("HTTP/1.1 {d} {s}\r\n", .{ status, statusText(status) }) catch return w.buffered();
 
-    // Headers from response map
     var has_content_type = false;
     var has_content_length = false;
     if (resp_headers) |hdrs| {
@@ -470,38 +314,16 @@ fn sendRingResponse(stream: std.net.Stream, allocator: Allocator, response: Valu
             const v = hdrs.entries[i * 2 + 1];
             const hdr_name = if (k.tag() == .string) k.asString() else if (k.tag() == .keyword) k.asKeyword().name else continue;
             const hdr_val = if (v.tag() == .string) v.asString() else continue;
-            w.print("{s}: {s}\r\n", .{ hdr_name, hdr_val }) catch return;
+            w.print("{s}: {s}\r\n", .{ hdr_name, hdr_val }) catch return w.buffered();
             if (std.ascii.eqlIgnoreCase(hdr_name, "content-type")) has_content_type = true;
             if (std.ascii.eqlIgnoreCase(hdr_name, "content-length")) has_content_length = true;
         }
     }
-
-    // Default headers
-    if (!has_content_type) {
-        w.print("Content-Type: text/plain; charset=utf-8\r\n", .{}) catch return;
-    }
-    if (!has_content_length) {
-        w.print("Content-Length: {d}\r\n", .{body.len}) catch return;
-    }
-    w.print("Connection: close\r\n", .{}) catch return;
-    w.print("\r\n", .{}) catch return;
-
-    // Send header + body
-    const header_bytes = w.buffered();
-    stream.writeAll(header_bytes) catch return;
-    if (body.len > 0) {
-        stream.writeAll(body) catch return;
-    }
-    _ = allocator;
-}
-
-fn sendErrorResponse(stream: std.net.Stream, status: u16, message: []const u8) void {
-    var buf: [512]u8 = undefined;
-    var w: std.Io.Writer = .fixed(&buf);
-    w.print("HTTP/1.1 {d} {s}\r\nContent-Type: text/plain\r\nContent-Length: {d}\r\nConnection: close\r\n\r\n{s}", .{
-        status, statusText(status), message.len, message,
-    }) catch return;
-    stream.writeAll(w.buffered()) catch {};
+    if (!has_content_type) w.print("Content-Type: text/plain; charset=utf-8\r\n", .{}) catch return w.buffered();
+    if (!has_content_length) w.print("Content-Length: {d}\r\n", .{body.len}) catch return w.buffered();
+    w.print("Connection: close\r\n\r\n", .{}) catch return w.buffered();
+    w.writeAll(body) catch return w.buffered();
+    return w.buffered();
 }
 
 fn statusText(code: i64) []const u8 {
@@ -525,99 +347,34 @@ fn statusText(code: i64) []const u8 {
 }
 
 // ============================================================
-// HTTP client
+// HTTP client — temporarily disabled while std.http.Client migrates to the
+// std.Io interface (Client now requires an `.io` field). Tracked as a
+// Phase 7 follow-up F## item.
 // ============================================================
 
-/// Shared implementation for HTTP client requests.
-/// method: .GET, .POST, .PUT, .DELETE
-/// args[0]: url (string)
-/// args[1]: opts (map, optional) — {:body "..." :headers {...}}
-fn doHttpRequest(allocator: Allocator, method: std.http.Method, args: []const Value) anyerror!Value {
+fn httpRequestStub(args: []const Value) anyerror!Value {
     if (args.len < 1) return err_mod.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to http request", .{args.len});
-
-    const url_val = args[0];
-    if (url_val.tag() != .string) return err_mod.setError(.{ .kind = .type_error, .phase = .eval, .message = "http request: url must be a string" });
-    const url = url_val.asString();
-
-    // Extract :body and :headers from opts
-    var payload: ?[]const u8 = null;
-    var extra_headers_buf: [32]std.http.Header = undefined;
-    var extra_header_count: usize = 0;
-    if (args.len >= 2 and args[1].tag() == .map) {
-        const opts = args[1].asMap();
-        for (0..opts.entries.len / 2) |i| {
-            const k = opts.entries[i * 2];
-            const v = opts.entries[i * 2 + 1];
-            if (k.tag() == .keyword) {
-                const name = k.asKeyword().name;
-                if (std.mem.eql(u8, name, "body") and v.tag() == .string) {
-                    payload = v.asString();
-                } else if (std.mem.eql(u8, name, "headers") and v.tag() == .map) {
-                    const hdrs = v.asMap();
-                    for (0..hdrs.entries.len / 2) |j| {
-                        if (extra_header_count >= extra_headers_buf.len) break;
-                        const hk = hdrs.entries[j * 2];
-                        const hv = hdrs.entries[j * 2 + 1];
-                        if (hk.tag() == .string and hv.tag() == .string) {
-                            extra_headers_buf[extra_header_count] = .{
-                                .name = hk.asString(),
-                                .value = hv.asString(),
-                            };
-                            extra_header_count += 1;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Perform HTTP request using Zig std.http.Client
-    var client: std.http.Client = .{ .allocator = allocator };
-    defer client.deinit();
-
-    var response_buf = std.Io.Writer.Allocating.init(allocator);
-    defer response_buf.deinit();
-
-    const result = client.fetch(.{
-        .location = .{ .url = url },
-        .method = method,
-        .payload = payload,
-        .extra_headers = extra_headers_buf[0..extra_header_count],
-        .response_writer = &response_buf.writer,
-    }) catch {
-        return err_mod.setErrorFmt(.eval, .value_error, .{}, "HTTP request failed for {s}", .{url});
-    };
-
-    // Build response map: {:status N :body "..."}
-    const body_data = response_buf.toOwnedSlice() catch "";
-    const entries = try allocator.alloc(Value, 4);
-    entries[0] = Value.initKeyword(allocator, .{ .ns = null, .name = "status" });
-    entries[1] = Value.initInteger(@intFromEnum(result.status));
-    entries[2] = Value.initKeyword(allocator, .{ .ns = null, .name = "body" });
-    entries[3] = Value.initString(allocator, body_data);
-    const resp_map = try allocator.create(PersistentArrayMap);
-    resp_map.* = .{ .entries = entries };
-    return Value.initMap(resp_map);
+    return err_mod.setError(.{
+        .kind = .internal_error,
+        .phase = .eval,
+        .message = "http client (get/post/put/delete) is temporarily disabled while the std.http.Client → std.Io migration is in progress",
+    });
 }
 
-/// (http/get url) or (http/get url opts) -> {:status N :body "..."}
-pub fn getFn(allocator: Allocator, args: []const Value) anyerror!Value {
-    return doHttpRequest(allocator, .GET, args);
+pub fn getFn(_: Allocator, args: []const Value) anyerror!Value {
+    return httpRequestStub(args);
 }
 
-/// (http/post url opts) -> {:status N :body "..."}
-pub fn postFn(allocator: Allocator, args: []const Value) anyerror!Value {
-    return doHttpRequest(allocator, .POST, args);
+pub fn postFn(_: Allocator, args: []const Value) anyerror!Value {
+    return httpRequestStub(args);
 }
 
-/// (http/put url opts) -> {:status N :body "..."}
-pub fn putFn(allocator: Allocator, args: []const Value) anyerror!Value {
-    return doHttpRequest(allocator, .PUT, args);
+pub fn putFn(_: Allocator, args: []const Value) anyerror!Value {
+    return httpRequestStub(args);
 }
 
-/// (http/delete url) or (http/delete url opts) -> {:status N :body "..."}
-pub fn deleteFn(allocator: Allocator, args: []const Value) anyerror!Value {
-    return doHttpRequest(allocator, .DELETE, args);
+pub fn deleteFn(_: Allocator, args: []const Value) anyerror!Value {
+    return httpRequestStub(args);
 }
 
 // ============================================================
diff --git a/src/lang/builtins/io.zig b/src/lang/builtins/io.zig
index 947a88fc..7bc22010 100644
--- a/src/lang/builtins/io.zig
+++ b/src/lang/builtins/io.zig
@@ -24,6 +24,7 @@ const err = @import("../../runtime/error.zig");
 const PersistentList = value_mod.PersistentList;
 const bootstrap = @import("../../engine/bootstrap.zig");
 const dispatch = @import("../../runtime/dispatch.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // ============================================================
 // Output capture for testing
@@ -42,8 +43,7 @@ pub fn writeOutput(data: []const u8) void {
     if (capture_buf) |buf| {
         buf.appendSlice(capture_alloc.?, data) catch {};
     } else {
-        const stdout: std.fs.File = .{ .handle = std.posix.STDOUT_FILENO };
-        _ = stdout.writeAll(data) catch {};
+        std.Io.File.stdout().writeStreamingAll(io_default.get(), data) catch {};
     }
 }
 
@@ -367,11 +367,9 @@ pub fn slurpFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "slurp expects a string filename, got {s}", .{@tagName(args[0].tag())}),
     };
 
-    const cwd = std.fs.cwd();
-    const file = cwd.openFile(path, .{}) catch return error.FileNotFound;
-    defer file.close();
-
-    const content = file.readToEndAlloc(allocator, 10 * 1024 * 1024) catch return error.IOError;
+    const io = io_default.get();
+    const content = std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(10 * 1024 * 1024)) catch
+        return error.FileNotFound;
     return Value.initString(allocator, content);
 }
 
@@ -413,22 +411,22 @@ pub fn spitFn(allocator: Allocator, args: []const Value) anyerror!Value {
         }
     }
 
-    const cwd = std.fs.cwd();
+    const io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
     if (append) {
-        const file = cwd.openFile(path, .{ .mode = .write_only }) catch {
-            // File doesn't exist, create it
-            const new_file = cwd.createFile(path, .{}) catch return error.IOError;
-            defer new_file.close();
-            new_file.writeAll(content) catch return error.IOError;
-            return Value.nil_val;
-        };
-        defer file.close();
-        file.seekFromEnd(0) catch return error.IOError;
-        file.writeAll(content) catch return error.IOError;
+        // Read existing content if any, then rewrite atomically
+        const existing = cwd.readFileAlloc(io, path, allocator, .unlimited) catch null;
+        defer if (existing) |e| allocator.free(e);
+        const file = cwd.createFile(io, path, .{}) catch return error.IOError;
+        defer file.close(io);
+        if (existing) |e| {
+            file.writeStreamingAll(io, e) catch return error.IOError;
+        }
+        file.writeStreamingAll(io, content) catch return error.IOError;
     } else {
-        const file = cwd.createFile(path, .{}) catch return error.IOError;
-        defer file.close();
-        file.writeAll(content) catch return error.IOError;
+        const file = cwd.createFile(io, path, .{}) catch return error.IOError;
+        defer file.close(io);
+        file.writeStreamingAll(io, content) catch return error.IOError;
     }
 
     return Value.nil_val;
@@ -445,13 +443,15 @@ pub fn readLineFn(allocator: Allocator, args: []const Value) anyerror!Value {
         return maybe_val orelse Value.nil_val;
     }
 
-    const stdin: std.fs.File = .{ .handle = std.posix.STDIN_FILENO };
+    const stdin = std.Io.File.stdin();
+    const io = io_default.get();
     var buf: [8192]u8 = undefined;
     var pos: usize = 0;
 
     while (pos < buf.len) {
         var byte: [1]u8 = undefined;
-        const n = stdin.read(&byte) catch return Value.nil_val;
+        const buffers = [_][]u8{&byte};
+        const n = stdin.readStreaming(io, &buffers) catch return Value.nil_val;
         if (n == 0) {
             // EOF
             if (pos > 0) break;
@@ -485,12 +485,8 @@ pub fn loadFileFn(allocator: Allocator, args: []const Value) anyerror!Value {
     };
 
     // Read file content
-    const cwd = std.fs.cwd();
-    const file = cwd.openFile(path, .{}) catch
-        return err.setErrorFmt(.eval, .io_error, .{}, "Could not open file: {s}", .{path});
-    defer file.close();
-
-    const content = file.readToEndAlloc(allocator, 10 * 1024 * 1024) catch
+    const io = io_default.get();
+    const content = std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(10 * 1024 * 1024)) catch
         return err.setErrorFmt(.eval, .io_error, .{}, "Could not read file: {s}", .{path});
 
     // Evaluate all forms using bootstrap pipeline
@@ -514,11 +510,9 @@ pub fn lineSeqFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "line-seq expects a string filename, got {s}", .{@tagName(args[0].tag())}),
     };
 
-    const cwd = std.fs.cwd();
-    const file = cwd.openFile(path, .{}) catch return error.FileNotFound;
-    defer file.close();
-
-    const content = file.readToEndAlloc(allocator, 10 * 1024 * 1024) catch return error.IOError;
+    const io = io_default.get();
+    const content = std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(10 * 1024 * 1024)) catch
+        return error.FileNotFound;
     if (content.len == 0) return Value.nil_val;
 
     // Split by newlines
@@ -641,10 +635,11 @@ pub fn deleteFileFn(allocator: Allocator, args: []const Value) anyerror!Value {
 
     const silently = if (args.len > 1) args[1].isTruthy() else false;
 
-    const cwd = std.fs.cwd();
-    cwd.deleteFile(path) catch |e| {
+    const io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    cwd.deleteFile(io, path) catch |e| {
         // Try as directory
-        cwd.deleteDir(path) catch {
+        cwd.deleteDir(io, path) catch {
             if (!silently) {
                 return err.setErrorFmt(.eval, .io_error, .{}, "Could not delete file: {s} ({s})", .{ path, @errorName(e) });
             }
@@ -682,8 +677,8 @@ pub fn makeParentsFn(allocator: Allocator, args: []const Value) anyerror!Value {
     // Get parent directory
     const parent = std.fs.path.dirname(path) orelse return Value.initBoolean(false);
 
-    const cwd = std.fs.cwd();
-    cwd.makePath(parent) catch |e| {
+    const io = io_default.get();
+    std.Io.Dir.cwd().createDirPath(io, parent) catch |e| {
         return err.setErrorFmt(.eval, .io_error, .{}, "Could not create parent directories: {s} ({s})", .{ parent, @errorName(e) });
     };
 
@@ -735,20 +730,21 @@ pub fn copyFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "copy expects string paths, got {s}", .{@tagName(args[1].tag())}),
     };
 
-    const cwd = std.fs.cwd();
+    const io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
 
     // Read source file
-    const content = cwd.readFileAlloc(allocator, src_path, 100 * 1024 * 1024) catch |e| {
+    const content = cwd.readFileAlloc(io, src_path, allocator, .limited(100 * 1024 * 1024)) catch |e| {
         return err.setErrorFmt(.eval, .io_error, .{}, "copy: could not read {s} ({s})", .{ src_path, @errorName(e) });
     };
 
     // Write to destination
-    const dst_file = cwd.createFile(dst_path, .{}) catch |e| {
+    const dst_file = cwd.createFile(io, dst_path, .{}) catch |e| {
         return err.setErrorFmt(.eval, .io_error, .{}, "copy: could not create {s} ({s})", .{ dst_path, @errorName(e) });
     };
-    defer dst_file.close();
+    defer dst_file.close(io);
 
-    dst_file.writeAll(content) catch |e| {
+    dst_file.writeStreamingAll(io, content) catch |e| {
         return err.setErrorFmt(.eval, .io_error, .{}, "copy: could not write to {s} ({s})", .{ dst_path, @errorName(e) });
     };
 
@@ -768,8 +764,8 @@ pub fn resourceFn(allocator: Allocator, args: []const Value) anyerror!Value {
     };
 
     // Check if file exists relative to cwd
-    const cwd = std.fs.cwd();
-    const stat = cwd.statFile(name) catch return Value.nil_val;
+    const io = io_default.get();
+    const stat = std.Io.Dir.cwd().statFile(io, name, .{}) catch return Value.nil_val;
     _ = stat;
 
     return args[0];
@@ -1039,11 +1035,12 @@ test "slurp - read existing file" {
     defer arena.deinit();
     const alloc = arena.allocator();
     // Create a temp file
-    const cwd = std.fs.cwd();
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
     const tmp_path = "/tmp/cljw_test_slurp.txt";
-    const file = try cwd.createFile(tmp_path, .{});
-    defer file.close();
-    try file.writeAll("hello world");
+    const file = try cwd.createFile(test_io, tmp_path, .{});
+    defer file.close(test_io);
+    try file.writeStreamingAll(test_io,"hello world");
 
     const args = [_]Value{Value.initString(alloc, tmp_path)};
     const result = try slurpFn(alloc, &args);
@@ -1083,10 +1080,9 @@ test "spit - write new file" {
     try testing.expect(result.isNil());
 
     // Verify content
-    const cwd = std.fs.cwd();
-    const file = try cwd.openFile(tmp_path, .{});
-    defer file.close();
-    const content = try file.readToEndAlloc(testing.allocator, 1024);
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    const content = try cwd.readFileAlloc(test_io, tmp_path, testing.allocator, .limited(1024));
     defer testing.allocator.free(content);
     try testing.expectEqualStrings("hello spit", content);
 }
@@ -1109,10 +1105,9 @@ test "spit - overwrite existing file" {
     };
     _ = try spitFn(alloc, &args2);
 
-    const cwd = std.fs.cwd();
-    const file = try cwd.openFile(tmp_path, .{});
-    defer file.close();
-    const content = try file.readToEndAlloc(testing.allocator, 1024);
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    const content = try cwd.readFileAlloc(test_io, tmp_path, testing.allocator, .limited(1024));
     defer testing.allocator.free(content);
     try testing.expectEqualStrings("second", content);
 }
@@ -1137,10 +1132,9 @@ test "spit - append mode" {
     };
     _ = try spitFn(alloc, &args2);
 
-    const cwd = std.fs.cwd();
-    const file = try cwd.openFile(tmp_path, .{});
-    defer file.close();
-    const content = try file.readToEndAlloc(testing.allocator, 1024);
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    const content = try cwd.readFileAlloc(test_io, tmp_path, testing.allocator, .limited(1024));
     defer testing.allocator.free(content);
     try testing.expectEqualStrings("hello world", content);
 }
@@ -1166,11 +1160,12 @@ test "line-seq - read file as list of lines" {
     const alloc = arena.allocator();
 
     // Create a temp file with multiple lines
-    const cwd = std.fs.cwd();
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
     const tmp_path = "/tmp/cljw_test_line_seq.txt";
-    const file = try cwd.createFile(tmp_path, .{});
-    try file.writeAll("line1\nline2\nline3\n");
-    file.close();
+    const file = try cwd.createFile(test_io, tmp_path, .{});
+    try file.writeStreamingAll(test_io,"line1\nline2\nline3\n");
+    file.close(test_io);
 
     const args = [_]Value{Value.initString(alloc, tmp_path)};
     const result = try lineSeqFn(alloc, &args);
@@ -1189,11 +1184,12 @@ test "line-seq - no trailing newline" {
     defer arena.deinit();
     const alloc = arena.allocator();
 
-    const cwd = std.fs.cwd();
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
     const tmp_path = "/tmp/cljw_test_line_seq2.txt";
-    const file = try cwd.createFile(tmp_path, .{});
-    try file.writeAll("line1\nline2");
-    file.close();
+    const file = try cwd.createFile(test_io, tmp_path, .{});
+    try file.writeStreamingAll(test_io,"line1\nline2");
+    file.close(test_io);
 
     const args = [_]Value{Value.initString(alloc, tmp_path)};
     const result = try lineSeqFn(alloc, &args);
@@ -1209,10 +1205,11 @@ test "line-seq - empty file" {
     defer arena.deinit();
     const alloc = arena.allocator();
 
-    const cwd = std.fs.cwd();
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
     const tmp_path = "/tmp/cljw_test_line_seq3.txt";
-    const file = try cwd.createFile(tmp_path, .{});
-    file.close();
+    const file = try cwd.createFile(test_io, tmp_path, .{});
+    file.close(test_io);
 
     const args = [_]Value{Value.initString(alloc, tmp_path)};
     const result = try lineSeqFn(alloc, &args);
@@ -1285,12 +1282,13 @@ test "make-parents and delete-file" {
     try testing.expect(mk_result.isTruthy());
 
     // Verify parent dir exists
-    const cwd = std.fs.cwd();
-    const stat = try cwd.statFile("/tmp/cljw_test_mkp/sub");
+    const test_io = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    const stat = try cwd.statFile(test_io, "/tmp/cljw_test_mkp/sub", .{});
     try testing.expect(stat.kind == .directory);
 
     // Clean up
-    try cwd.deleteDir("/tmp/cljw_test_mkp/sub");
-    try cwd.deleteDir("/tmp/cljw_test_mkp");
+    try cwd.deleteDir(test_io, "/tmp/cljw_test_mkp/sub");
+    try cwd.deleteDir(test_io, "/tmp/cljw_test_mkp");
 }
 
diff --git a/src/lang/builtins/ns_ops.zig b/src/lang/builtins/ns_ops.zig
index 50181f98..478a8dc1 100644
--- a/src/lang/builtins/ns_ops.zig
+++ b/src/lang/builtins/ns_ops.zig
@@ -20,6 +20,7 @@ const collections = @import("../../runtime/collections.zig");
 const bootstrap = @import("../../engine/bootstrap.zig");
 const dispatch = @import("../../runtime/dispatch.zig");
 const err = @import("../../runtime/error.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // ============================================================
 // Load path infrastructure
@@ -49,7 +50,7 @@ var loaded_file_records: std.ArrayList(LoadedFileRecord) = .empty;
 var track_loaded_files: bool = false;
 
 /// Mutex protecting loaded_libs, loading_libs, and loaded_file_records.
-var ns_mutex: std.Thread.Mutex = .{};
+var ns_mutex: std.Io.Mutex = .init;
 
 /// Enable file tracking for cljw build. Call before evaluating entry file.
 pub fn enableFileTracking() void {
@@ -117,8 +118,9 @@ pub fn deinit() void {
 /// (each file gets a fresh Env + bootstrap, so loaded_libs must match).
 pub fn resetLoadedLibs() void {
     const alloc = loaded_libs_allocator orelse return;
-    ns_mutex.lock();
-    defer ns_mutex.unlock();
+    const io = io_default.get();
+    ns_mutex.lockUncancelable(io);
+    defer ns_mutex.unlock(io);
 
     // Free loaded_libs keys
     var iter = loaded_libs.iterator();
@@ -179,9 +181,10 @@ pub fn detectAndAddSrcPath(start_dir: []const u8) !void {
         var current = start_dir;
         for (0..10) |_| {
             const src_path = std.fmt.bufPrint(&buf, "{s}/src", .{current}) catch break;
-            if (std.fs.cwd().openDir(src_path, .{})) |dir| {
+            const lp_io = io_default.get();
+            if (std.Io.Dir.cwd().openDir(lp_io, src_path, .{})) |dir| {
                 var d = dir;
-                d.close();
+                d.close(lp_io);
                 try addLoadPath(src_path);
                 return;
             } else |_| {}
@@ -194,15 +197,17 @@ pub fn detectAndAddSrcPath(start_dir: []const u8) !void {
 }
 
 pub fn isLibLoaded(name: []const u8) bool {
-    ns_mutex.lock();
-    defer ns_mutex.unlock();
+    const io = io_default.get();
+    ns_mutex.lockUncancelable(io);
+    defer ns_mutex.unlock(io);
     return loaded_libs.contains(name);
 }
 
 pub fn markLibLoaded(name: []const u8) !void {
     const alloc = loaded_libs_allocator orelse return;
-    ns_mutex.lock();
-    defer ns_mutex.unlock();
+    const io = io_default.get();
+    ns_mutex.lockUncancelable(io);
+    defer ns_mutex.unlock(io);
     if (!loaded_libs.contains(name)) {
         const owned = try alloc.dupe(u8, name);
         try loaded_libs.put(alloc, owned, {});
@@ -260,10 +265,8 @@ fn loadResource(allocator: Allocator, env: *@import("../../runtime/env.zig").Env
         for (extensions) |ext| {
             const full_path = std.fmt.bufPrint(&buf, "{s}/{s}{s}", .{ base, resource, ext }) catch continue;
 
-            const cwd = std.fs.cwd();
-            if (cwd.openFile(full_path, .{})) |file| {
-                defer file.close();
-                const content = file.readToEndAlloc(allocator, 10 * 1024 * 1024) catch continue;
+            const lf_io = io_default.get();
+            if (std.Io.Dir.cwd().readFileAlloc(lf_io, full_path, allocator, .limited(10 * 1024 * 1024))) |content| {
 
                 // Dupe content for build tracking before evaluation (content
                 // allocated by GC allocator may not survive evaluation).
@@ -288,8 +291,9 @@ fn loadResource(allocator: Allocator, env: *@import("../../runtime/env.zig").Env
                 // (depth-first order: lib.util.math before lib.core).
                 if (tracked_content) |tc| {
                     if (loaded_libs_allocator) |tracking_alloc| {
-                        ns_mutex.lock();
-                        defer ns_mutex.unlock();
+                        const tio = io_default.get();
+                        ns_mutex.lockUncancelable(tio);
+                        defer ns_mutex.unlock(tio);
                         loaded_file_records.append(tracking_alloc, .{ .content = tc }) catch {};
                     }
                 }
@@ -1166,8 +1170,9 @@ fn requireLib(allocator: Allocator, env: *@import("../../runtime/env.zig").Env,
     // top of the file. This matches JVM Clojure behavior where circular
     // requires see partially-loaded namespaces.
     {
-        ns_mutex.lock();
-        defer ns_mutex.unlock();
+        const io = io_default.get();
+        ns_mutex.lockUncancelable(io);
+        defer ns_mutex.unlock(io);
         if (loading_libs.contains(ns_name)) {
             return;
         }
@@ -1177,13 +1182,15 @@ fn requireLib(allocator: Allocator, env: *@import("../../runtime/env.zig").Env,
     const alloc = loaded_libs_allocator orelse return;
     const loading_key = try alloc.dupe(u8, ns_name);
     {
-        ns_mutex.lock();
-        defer ns_mutex.unlock();
+        const io = io_default.get();
+        ns_mutex.lockUncancelable(io);
+        defer ns_mutex.unlock(io);
         try loading_libs.put(alloc, loading_key, {});
     }
     defer {
-        ns_mutex.lock();
-        defer ns_mutex.unlock();
+        const io = io_default.get();
+        ns_mutex.lockUncancelable(io);
+        defer ns_mutex.unlock(io);
         // Remove from loading set when done (whether success or error)
         if (loading_libs.fetchRemove(ns_name)) |kv| {
             alloc.free(kv.key);
@@ -1776,8 +1783,9 @@ test "detectAndAddSrcPath - finds src/ directory" {
     defer deinit();
 
     // Create temp project structure: .zig-cache/test-src-detect/src/
-    std.fs.cwd().makePath(".zig-cache/test-src-detect/src") catch {};
-    defer std.fs.cwd().deleteTree(".zig-cache/test-src-detect") catch {};
+    const t1_io = io_default.get();
+    std.Io.Dir.cwd().createDirPath(t1_io, ".zig-cache/test-src-detect/src") catch {};
+    defer std.Io.Dir.cwd().deleteTree(t1_io, ".zig-cache/test-src-detect") catch {};
 
     try detectAndAddSrcPath(".zig-cache/test-src-detect");
 
@@ -1794,9 +1802,10 @@ test "detectAndAddSrcPath - walks up to find src/" {
     defer deinit();
 
     // Create: .zig-cache/test-src-walk/src/ and .zig-cache/test-src-walk/deep/nested/
-    std.fs.cwd().makePath(".zig-cache/test-src-walk/src") catch {};
-    std.fs.cwd().makePath(".zig-cache/test-src-walk/deep/nested") catch {};
-    defer std.fs.cwd().deleteTree(".zig-cache/test-src-walk") catch {};
+    const t2_io = io_default.get();
+    std.Io.Dir.cwd().createDirPath(t2_io, ".zig-cache/test-src-walk/src") catch {};
+    std.Io.Dir.cwd().createDirPath(t2_io, ".zig-cache/test-src-walk/deep/nested") catch {};
+    defer std.Io.Dir.cwd().deleteTree(t2_io, ".zig-cache/test-src-walk") catch {};
 
     // Starting from deep/nested, should walk up and find src/
     try detectAndAddSrcPath(".zig-cache/test-src-walk/deep/nested");
@@ -1824,11 +1833,13 @@ test "require - loads file from load path" {
     try bootstrap.loadCore(alloc, env);
 
     // Create a temp directory with a .clj file
-    const tmp_dir = std.fs.cwd().makeOpenPath("zig-cache/test-require", .{}) catch return;
-    defer std.fs.cwd().deleteTree("zig-cache/test-require") catch {};
+    const t3_io = io_default.get();
+    var tmp_dir = std.Io.Dir.cwd().createDirPathOpen(t3_io, "zig-cache/test-require", .{}) catch return;
+    defer tmp_dir.close(t3_io);
+    defer std.Io.Dir.cwd().deleteTree(t3_io, "zig-cache/test-require") catch {};
 
     // Write test_util.clj: (ns test-util) (def greeting "hello from test-util")
-    tmp_dir.writeFile(.{
+    tmp_dir.writeFile(t3_io, .{
         .sub_path = "test_util.clj",
         .data = "(ns test-util)\n(def greeting \"hello from test-util\")\n",
     }) catch return;
diff --git a/src/lang/builtins/shell.zig b/src/lang/builtins/shell.zig
index e0e79415..c9106d2f 100644
--- a/src/lang/builtins/shell.zig
+++ b/src/lang/builtins/shell.zig
@@ -21,6 +21,7 @@ const collections = @import("../../runtime/collections.zig");
 const err = @import("../../runtime/error.zig");
 const bootstrap = @import("../../engine/bootstrap.zig");
 const dispatch = @import("../../runtime/dispatch.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // ============================================================
 // sh implementation
@@ -92,46 +93,58 @@ pub fn shFn(allocator: Allocator, args: []const Value) anyerror!Value {
         }
     }
 
-    // Spawn subprocess
-    var child = std.process.Child.init(argv, allocator);
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Pipe;
-    child.stdin_behavior = if (input != null) .Pipe else .Close;
-    if (dir) |d| child.cwd = d;
+    // Spawn subprocess via std.process.run (collects stdout+stderr+wait in one call).
+    // For input mode, std.process.spawn is used so we can write stdin manually.
+    const proc_io = io_default.get();
+    var stdout_data: []u8 = "";
+    var stderr_data: []u8 = "";
+    var term: std.process.Child.Term = .{ .exited = 0 };
 
-    try child.spawn();
-
-    // Write stdin if provided
     if (input) |in_data| {
+        var child = try std.process.spawn(proc_io, .{
+            .argv = argv,
+            .cwd = if (dir) |d| .{ .path = d } else .inherit,
+            .stdin = .pipe,
+            .stdout = .pipe,
+            .stderr = .pipe,
+        });
         if (child.stdin) |stdin_file| {
-            var stdin = stdin_file;
-            stdin.writeAll(in_data) catch {};
-            stdin.close();
+            stdin_file.writeStreamingAll(proc_io, in_data) catch {};
+            stdin_file.close(proc_io);
             child.stdin = null;
         }
+        if (child.stdout) |stdout_file| {
+            var rbuf: [4096]u8 = undefined;
+            var r = stdout_file.reader(proc_io, &rbuf);
+            stdout_data = r.interface.allocRemaining(allocator, .limited(10 * 1024 * 1024)) catch "";
+        }
+        if (child.stderr) |stderr_file| {
+            var rbuf: [4096]u8 = undefined;
+            var r = stderr_file.reader(proc_io, &rbuf);
+            stderr_data = r.interface.allocRemaining(allocator, .limited(10 * 1024 * 1024)) catch "";
+        }
+        term = child.wait(proc_io) catch |e| {
+            return err.setErrorFmt(.eval, .io_error, .{}, "sh: wait failed: {s}", .{@errorName(e)});
+        };
+    } else {
+        const result = std.process.run(allocator, proc_io, .{
+            .argv = argv,
+            .cwd = if (dir) |d| .{ .path = d } else .inherit,
+            .stdout_limit = .limited(10 * 1024 * 1024),
+            .stderr_limit = .limited(10 * 1024 * 1024),
+        }) catch |e| {
+            return err.setErrorFmt(.eval, .io_error, .{}, "sh: spawn failed: {s}", .{@errorName(e)});
+        };
+        stdout_data = result.stdout;
+        stderr_data = result.stderr;
+        term = result.term;
     }
 
-    // Read stdout and stderr
-    const stdout_data = if (child.stdout) |stdout_file| blk: {
-        var stdout = stdout_file;
-        break :blk stdout.readToEndAlloc(allocator, 10 * 1024 * 1024) catch "";
-    } else "";
-
-    const stderr_data = if (child.stderr) |stderr_file| blk: {
-        var stderr = stderr_file;
-        break :blk stderr.readToEndAlloc(allocator, 10 * 1024 * 1024) catch "";
-    } else "";
-
-    // Wait for exit
-    const term = child.wait() catch |e| {
-        return err.setErrorFmt(.eval, .io_error, .{}, "sh: wait failed: {s}", .{@errorName(e)});
-    };
-
     const exit_code: i64 = switch (term) {
-        .Exited => |code| @intCast(code),
-        .Signal => |sig| -@as(i64, @intCast(sig)),
-        .Stopped => |sig| -@as(i64, @intCast(sig)),
-        .Unknown => |code| -@as(i64, @intCast(code)),
+        .exited => |code| @intCast(code),
+        .signal => |sig| -@as(i64, @intCast(@intFromEnum(sig))),
+        .stopped => |sig| -@as(i64, @intCast(@intFromEnum(sig))),
+        .unknown => |code| -@as(i64, @intCast(code)),
     };
 
     // Build result map: {:exit N :out "..." :err "..."}
@@ -232,10 +245,23 @@ pub const with_sh_env_def = BuiltinDef{
 
 const testing = std.testing;
 
+/// Test helper: set up a real std.Io.Threaded and install it as the default
+/// io for the duration of the calling test. The default io_default points
+/// at `std.Io.Threaded.init_single_threaded`, whose allocator is `.failing`
+/// — fine for mutex-only paths but not for `std.process.spawn`, which needs
+/// to allocate Future closures.
+fn setupTestIo(alloc: Allocator, threaded: *std.Io.Threaded) void {
+    threaded.* = std.Io.Threaded.init(alloc, .{});
+    io_default.set(threaded.io());
+}
+
 test "sh - echo hello" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const alloc = arena.allocator();
+    var th: std.Io.Threaded = undefined;
+    setupTestIo(alloc, &th);
+    defer th.deinit();
 
     const result = try shFn(alloc, &[_]Value{
         Value.initString(alloc, "echo"),
@@ -262,6 +288,9 @@ test "sh - with :in" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const alloc = arena.allocator();
+    var th: std.Io.Threaded = undefined;
+    setupTestIo(alloc, &th);
+    defer th.deinit();
 
     const result = try shFn(alloc, &[_]Value{
         Value.initString(alloc, "cat"),
@@ -282,6 +311,9 @@ test "sh - with :dir" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const alloc = arena.allocator();
+    var th: std.Io.Threaded = undefined;
+    setupTestIo(alloc, &th);
+    defer th.deinit();
 
     const result = try shFn(alloc, &[_]Value{
         Value.initString(alloc, "pwd"),
@@ -304,6 +336,9 @@ test "sh - nonexistent command returns non-zero exit" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const alloc = arena.allocator();
+    var th: std.Io.Threaded = undefined;
+    setupTestIo(alloc, &th);
+    defer th.deinit();
 
     const result = try shFn(alloc, &[_]Value{
         Value.initString(alloc, "false"),
diff --git a/src/lang/builtins/strings.zig b/src/lang/builtins/strings.zig
index 7c967a4c..ad921252 100644
--- a/src/lang/builtins/strings.zig
+++ b/src/lang/builtins/strings.zig
@@ -1079,7 +1079,7 @@ pub fn trimNewlineFn(allocator: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to trim-newline", .{args.len});
     if (args[0].tag() != .string) return err.setErrorFmt(.eval, .type_error, .{}, "trim-newline expects a string, got {s}", .{@tagName(args[0].tag())});
     const s = args[0].asString();
-    const trimmed = std.mem.trimRight(u8, s, "\r\n");
+    const trimmed = std.mem.trimEnd(u8, s, "\r\n");
     return Value.initString(allocator, trimmed);
 }
 
diff --git a/src/lang/builtins/system.zig b/src/lang/builtins/system.zig
index 12145bae..6a39d0fa 100644
--- a/src/lang/builtins/system.zig
+++ b/src/lang/builtins/system.zig
@@ -17,6 +17,7 @@ const Value = @import("../../runtime/value.zig").Value;
 const var_mod = @import("../../runtime/var.zig");
 const BuiltinDef = var_mod.BuiltinDef;
 const err = @import("../../runtime/error.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // ============================================================
 // Builtins
@@ -26,7 +27,7 @@ const err = @import("../../runtime/error.zig");
 /// Returns nanosecond timestamp (monotonic clock).
 pub fn nanoTimeFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 0) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to System/nanoTime", .{args.len});
-    const ns: i128 = std.time.nanoTimestamp();
+    const ns: i128 = io_default.nanoTimestamp();
     // Clojure returns long (64-bit), truncate i128 to i64
     const truncated: i64 = @intCast(@as(i128, @rem(ns, std.math.maxInt(i64))));
     return Value.initInteger(truncated);
@@ -36,7 +37,7 @@ pub fn nanoTimeFn(_: Allocator, args: []const Value) anyerror!Value {
 /// Returns milliseconds since epoch (wall clock).
 pub fn currentTimeMillisFn(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 0) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to System/currentTimeMillis", .{args.len});
-    const ms = std.time.milliTimestamp();
+    const ms = io_default.milliTimestamp();
     return Value.initInteger(ms);
 }
 
@@ -49,14 +50,7 @@ pub fn getenvFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "System/getenv expects a string, got {s}", .{@tagName(args[0].tag())}),
     };
 
-    // Need null-terminated key for posix getenv
-    const key_z = try allocator.alloc(u8, key.len + 1);
-    defer allocator.free(key_z);
-    @memcpy(key_z[0..key.len], key);
-    key_z[key.len] = 0;
-
-    const result = std.posix.getenv(key_z[0..key.len]);
-    if (result) |val| {
+    if (io_default.getEnv(key)) |val| {
         const owned = try allocator.alloc(u8, val.len);
         @memcpy(owned, val);
         return Value.initString(allocator, owned);
@@ -101,18 +95,21 @@ fn getSystemProperty(allocator: Allocator, key: []const u8) !?Value {
     const builtin = @import("builtin");
 
     if (std.mem.eql(u8, key, "user.dir")) {
-        // Current working directory
+        // Current working directory — std.fs.cwd().realpath was removed in 0.16.
+        // Use libc getcwd via std.c (we link libc anyway after the migration).
         var buf: [4096]u8 = undefined;
-        const cwd = std.fs.cwd().realpath(".", &buf) catch return null;
-        return Value.initString(allocator, try allocator.dupe(u8, cwd));
+        const ptr = std.c.getcwd(&buf, buf.len) orelse return null;
+        const len = std.mem.indexOfScalar(u8, &buf, 0) orelse buf.len;
+        _ = ptr;
+        return Value.initString(allocator, try allocator.dupe(u8, buf[0..len]));
     } else if (std.mem.eql(u8, key, "user.home")) {
         // Home directory
-        if (std.posix.getenv("HOME")) |home| {
+        if (io_default.getEnv("HOME")) |home| {
             return Value.initString(allocator, try allocator.dupe(u8, home));
         }
         return null;
     } else if (std.mem.eql(u8, key, "user.name")) {
-        if (std.posix.getenv("USER")) |user| {
+        if (io_default.getEnv("USER")) |user| {
             return Value.initString(allocator, try allocator.dupe(u8, user));
         }
         return null;
@@ -146,7 +143,7 @@ fn getSystemProperty(allocator: Allocator, key: []const u8) !?Value {
         }
         return Value.initString(allocator, "\n");
     } else if (std.mem.eql(u8, key, "java.io.tmpdir")) {
-        if (std.posix.getenv("TMPDIR")) |tmpdir| {
+        if (io_default.getEnv("TMPDIR")) |tmpdir| {
             return Value.initString(allocator, try allocator.dupe(u8, tmpdir));
         }
         return Value.initString(allocator, "/tmp");
@@ -181,7 +178,7 @@ fn threadSleepFn(_: Allocator, args: []const Value) anyerror!Value {
         else => return err.setError(.{ .kind = .type_error, .phase = .eval, .message = "Thread/sleep expects a number" }),
     };
     if (ms > 0) {
-        std.Thread.sleep(@intCast(ms * std.time.ns_per_ms));
+        io_default.sleep(@intCast(ms * std.time.ns_per_ms));
     }
     return Value.nil_val;
 }
diff --git a/src/lang/interop/classes/buffered_writer.zig b/src/lang/interop/classes/buffered_writer.zig
index 15f98d4c..6f7e12e2 100644
--- a/src/lang/interop/classes/buffered_writer.zig
+++ b/src/lang/interop/classes/buffered_writer.zig
@@ -22,6 +22,7 @@ const value_mod = @import("../../../runtime/value.zig");
 const Value = value_mod.Value;
 const err = @import("../../../runtime/error.zig");
 const constructors = @import("../constructors.zig");
+const io_default = @import("../../../runtime/io_default.zig");
 
 pub const class_name = "java.io.BufferedWriter";
 
@@ -48,14 +49,21 @@ const State = struct {
 
     fn flush(self: *State) !void {
         if (self.closed) return error.Closed;
-        const file = if (self.append_mode)
-            std.fs.cwd().openFile(self.path, .{ .mode = .write_only }) catch
-                std.fs.cwd().createFile(self.path, .{}) catch return error.FileNotFound
-        else
-            std.fs.cwd().createFile(self.path, .{}) catch return error.FileNotFound;
-        defer file.close();
-        if (self.append_mode) file.seekFromEnd(0) catch {};
-        file.writeAll(self.buf.items) catch return error.FileNotFound;
+        const io = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        if (self.append_mode) {
+            // Append: read existing content, then rewrite with new bytes appended.
+            const existing = cwd.readFileAlloc(io, self.path, std.heap.smp_allocator, .unlimited) catch null;
+            defer if (existing) |e| std.heap.smp_allocator.free(e);
+            const file = cwd.createFile(io, self.path, .{}) catch return error.FileNotFound;
+            defer file.close(io);
+            if (existing) |e| file.writeStreamingAll(io, e) catch return error.FileNotFound;
+            file.writeStreamingAll(io, self.buf.items) catch return error.FileNotFound;
+        } else {
+            const file = cwd.createFile(io, self.path, .{}) catch return error.FileNotFound;
+            defer file.close(io);
+            file.writeStreamingAll(io, self.buf.items) catch return error.FileNotFound;
+        }
         self.buf.clearRetainingCapacity();
     }
 
diff --git a/src/lang/interop/classes/file.zig b/src/lang/interop/classes/file.zig
index d9d6fd82..2b484d13 100644
--- a/src/lang/interop/classes/file.zig
+++ b/src/lang/interop/classes/file.zig
@@ -19,6 +19,7 @@ const value_mod = @import("../../../runtime/value.zig");
 const Value = value_mod.Value;
 const err = @import("../../../runtime/error.zig");
 const constructors = @import("../constructors.zig");
+const io_default = @import("../../../runtime/io_default.zig");
 
 pub const class_name = "java.io.File";
 
@@ -69,78 +70,83 @@ pub fn dispatchMethod(allocator: Allocator, method: []const u8, obj: Value, rest
         }
         return Value.nil_val;
     } else if (std.mem.eql(u8, method, "getAbsolutePath")) {
-        const cwd = std.fs.cwd();
-        const abs = cwd.realpathAlloc(allocator, path) catch {
-            // If path doesn't exist, try to construct absolute from cwd
-            if (std.fs.path.isAbsolute(path)) {
-                return Value.initString(allocator, try allocator.dupe(u8, path));
-            }
-            var buf: [std.fs.max_path_bytes]u8 = undefined;
-            const cwd_path = cwd.realpath(".", &buf) catch return Value.initString(allocator, try allocator.dupe(u8, path));
-            const joined = try std.fs.path.join(allocator, &.{ cwd_path, path });
-            return Value.initString(allocator, joined);
-        };
-        return Value.initString(allocator, abs);
-    } else if (std.mem.eql(u8, method, "exists")) {
-        const cwd = std.fs.cwd();
+        // Zig 0.16's std.Io.Dir lacks realpath. Use libc realpath via std.c
+        // (we link libc) for resolution; fall back to a manual cwd-join when
+        // the path doesn't exist yet.
         if (std.fs.path.isAbsolute(path)) {
-            const stat = std.fs.openDirAbsolute(path, .{});
-            if (stat) |d| {
-                var dir = d;
-                dir.close();
-                return Value.true_val;
-            } else |_| {}
-            // Try as file
-            const file = std.fs.openFileAbsolute(path, .{}) catch return Value.false_val;
-            file.close();
-            return Value.true_val;
+            return Value.initString(allocator, try allocator.dupe(u8, path));
         }
-        // Relative path
-        _ = cwd.statFile(path) catch return Value.false_val;
+        var buf: [4096]u8 = undefined;
+        const path_z = try allocator.dupeZ(u8, path);
+        defer allocator.free(path_z);
+        if (std.c.realpath(path_z, &buf)) |resolved| {
+            const len = std.mem.indexOfScalar(u8, &buf, 0) orelse buf.len;
+            _ = resolved;
+            return Value.initString(allocator, try allocator.dupe(u8, buf[0..len]));
+        }
+        // Fall back: cwd-join
+        var cwd_buf: [4096]u8 = undefined;
+        if (std.c.getcwd(&cwd_buf, cwd_buf.len)) |_| {
+            const cwd_len = std.mem.indexOfScalar(u8, &cwd_buf, 0) orelse cwd_buf.len;
+            const joined = try std.fs.path.join(allocator, &.{ cwd_buf[0..cwd_len], path });
+            return Value.initString(allocator, joined);
+        }
+        return Value.initString(allocator, try allocator.dupe(u8, path));
+    } else if (std.mem.eql(u8, method, "exists")) {
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        _ = cwd.statFile(fio, path, .{}) catch return Value.false_val;
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "isDirectory")) {
-        const cwd = std.fs.cwd();
-        const stat = cwd.statFile(path) catch return Value.false_val;
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const stat = cwd.statFile(fio, path, .{}) catch return Value.false_val;
         return Value.initBoolean(stat.kind == .directory);
     } else if (std.mem.eql(u8, method, "isFile")) {
-        const cwd = std.fs.cwd();
-        const stat = cwd.statFile(path) catch return Value.false_val;
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const stat = cwd.statFile(fio, path, .{}) catch return Value.false_val;
         return Value.initBoolean(stat.kind == .file);
     } else if (std.mem.eql(u8, method, "canRead")) {
-        const cwd = std.fs.cwd();
-        const file = cwd.openFile(path, .{}) catch return Value.false_val;
-        file.close();
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const file = cwd.openFile(fio, path, .{}) catch return Value.false_val;
+        file.close(fio);
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "canWrite")) {
-        const cwd = std.fs.cwd();
-        const file = cwd.openFile(path, .{ .mode = .write_only }) catch return Value.false_val;
-        file.close();
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const file = cwd.openFile(fio, path, .{ .mode = .write_only }) catch return Value.false_val;
+        file.close(fio);
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "length")) {
-        const cwd = std.fs.cwd();
-        const stat = cwd.statFile(path) catch return Value.initInteger(0);
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const stat = cwd.statFile(fio, path, .{}) catch return Value.initInteger(0);
         return Value.initInteger(@intCast(stat.size));
     } else if (std.mem.eql(u8, method, "delete")) {
-        const cwd = std.fs.cwd();
-        cwd.deleteFile(path) catch {
-            cwd.deleteDir(path) catch return Value.false_val;
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        cwd.deleteFile(fio, path) catch {
+            cwd.deleteDir(fio, path) catch return Value.false_val;
         };
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "mkdir")) {
-        const cwd = std.fs.cwd();
-        cwd.makeDir(path) catch return Value.false_val;
+        const fio = io_default.get();
+        std.Io.Dir.cwd().createDir(fio, path, .default_dir) catch return Value.false_val;
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "mkdirs")) {
-        const cwd = std.fs.cwd();
-        cwd.makePath(path) catch return Value.false_val;
+        const fio = io_default.get();
+        std.Io.Dir.cwd().createDirPath(fio, path) catch return Value.false_val;
         return Value.true_val;
     } else if (std.mem.eql(u8, method, "list")) {
         return listDir(allocator, path);
     } else if (std.mem.eql(u8, method, "lastModified")) {
-        const cwd = std.fs.cwd();
-        const stat = cwd.statFile(path) catch return Value.initInteger(0);
+        const fio = io_default.get();
+        const cwd = std.Io.Dir.cwd();
+        const stat = cwd.statFile(fio, path, .{}) catch return Value.initInteger(0);
         // Convert nanoseconds to milliseconds
-        const mtime_ns: i128 = stat.mtime;
+        const mtime_ns: i128 = @intCast(stat.mtime.nanoseconds);
         const mtime_ms: i64 = @intCast(@divTrunc(mtime_ns, 1_000_000));
         return Value.initInteger(mtime_ms);
     }
@@ -150,13 +156,14 @@ pub fn dispatchMethod(allocator: Allocator, method: []const u8, obj: Value, rest
 
 /// List directory entries, returning a Clojure vector of filename strings.
 fn listDir(allocator: Allocator, path: []const u8) anyerror!Value {
-    const cwd = std.fs.cwd();
-    var dir = cwd.openDir(path, .{ .iterate = true }) catch return Value.nil_val;
-    defer dir.close();
+    const fio = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+    var dir = cwd.openDir(fio, path, .{ .iterate = true }) catch return Value.nil_val;
+    defer dir.close(fio);
 
     var names = std.ArrayList(Value).empty;
     var iter = dir.iterate();
-    while (iter.next() catch null) |entry| {
+    while (iter.next(fio) catch null) |entry| {
         const name = try allocator.dupe(u8, entry.name);
         try names.append(allocator, Value.initString(allocator, name));
     }
diff --git a/src/lang/interop/classes/uuid.zig b/src/lang/interop/classes/uuid.zig
index d28f1c0d..81f6c4a5 100644
--- a/src/lang/interop/classes/uuid.zig
+++ b/src/lang/interop/classes/uuid.zig
@@ -18,6 +18,7 @@ const value_mod = @import("../../../runtime/value.zig");
 const Value = value_mod.Value;
 const err = @import("../../../runtime/error.zig");
 const constructors = @import("../constructors.zig");
+const io_default = @import("../../../runtime/io_default.zig");
 
 pub const class_name = "java.util.UUID";
 
@@ -65,7 +66,7 @@ pub fn construct(allocator: Allocator, args: []const Value) anyerror!Value {
 pub fn randomUUID(allocator: Allocator) anyerror!Value {
     // Generate 16 random bytes
     var bytes: [16]u8 = undefined;
-    std.crypto.random.bytes(&bytes);
+    std.Io.randomSecure(io_default.get(), &bytes) catch std.Io.random(io_default.get(), &bytes);
 
     // Set version 4: byte[6] = (byte[6] & 0x0f) | 0x40
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
diff --git a/src/lang/lib/cljw_wasm_builtins.zig b/src/lang/lib/cljw_wasm_builtins.zig
index d4cbd886..12fa0720 100644
--- a/src/lang/lib/cljw_wasm_builtins.zig
+++ b/src/lang/lib/cljw_wasm_builtins.zig
@@ -24,6 +24,7 @@ const WasmModule = wasm_types.WasmModule;
 const WasmFn = wasm_types.WasmFn;
 const WasmValType = wasm_types.WasmValType;
 const wit_parser = @import("../../runtime/wasm_wit_parser.zig");
+const io_default = @import("../../runtime/io_default.zig");
 
 // Wasm module registry: maps module names to resolved file paths.
 // Populated by deps.edn :cljw/wasm-deps processing.
@@ -59,22 +60,19 @@ pub fn wasmLoadFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "wasm/load expects a string path, got {s}", .{@tagName(args[0].tag())}),
     };
 
+    const wio = io_default.get();
+    const cwd = std.Io.Dir.cwd();
+
     // Try direct path first, then wasm dep registry
     const path = blk: {
-        const cwd = std.fs.cwd();
-        if (cwd.access(path_arg, .{})) |_| break :blk path_arg else |_| {}
+        if (cwd.access(wio, path_arg, .{})) |_| break :blk path_arg else |_| {}
         if (resolveWasmPath(path_arg)) |resolved| break :blk resolved;
         break :blk path_arg; // fall through to get standard error
     };
 
     // Read .wasm binary from disk
-    const cwd = std.fs.cwd();
-    const file = cwd.openFile(path, .{}) catch
+    const wasm_bytes = cwd.readFileAlloc(wio, path, allocator, .limited(64 * 1024 * 1024)) catch
         return err.setErrorFmt(.eval, .io_error, .{}, "wasm/load: file not found: {s}", .{path});
-    defer file.close();
-
-    const wasm_bytes = file.readToEndAlloc(allocator, 64 * 1024 * 1024) catch
-        return error.IOError;
 
     // Parse opts map if present
     var imports_val_opt: ?Value = null;
@@ -111,12 +109,8 @@ pub fn wasmLoadFn(allocator: Allocator, args: []const Value) anyerror!Value {
 
     // Parse and attach WIT info if :wit provided
     if (wit_path_opt) |wit_path| {
-        const wit_file = cwd.openFile(wit_path, .{}) catch
+        const wit_src = cwd.readFileAlloc(wio, wit_path, allocator, .limited(1 * 1024 * 1024)) catch
             return err.setErrorFmt(.eval, .io_error, .{}, "wasm/load: WIT file not found: {s}", .{wit_path});
-        defer wit_file.close();
-
-        const wit_src = wit_file.readToEndAlloc(allocator, 1 * 1024 * 1024) catch
-            return error.IOError;
 
         const ifaces = wit_parser.parse(allocator, wit_src) catch
             return err.setErrorFmt(.eval, .io_error, .{}, "wasm/load: failed to parse WIT file: {s}", .{wit_path});
@@ -154,13 +148,9 @@ pub fn wasmLoadWasiFn(allocator: Allocator, args: []const Value) anyerror!Value
         else => return err.setErrorFmt(.eval, .type_error, .{}, "wasm/load-wasi expects a string path, got {s}", .{@tagName(args[0].tag())}),
     };
 
-    const cwd = std.fs.cwd();
-    const file = cwd.openFile(path, .{}) catch
+    const wasi_io = io_default.get();
+    const wasm_bytes = std.Io.Dir.cwd().readFileAlloc(wasi_io, path, allocator, .limited(64 * 1024 * 1024)) catch
         return err.setErrorFmt(.eval, .io_error, .{}, "wasm/load-wasi: file not found: {s}", .{path});
-    defer file.close();
-
-    const wasm_bytes = file.readToEndAlloc(allocator, 64 * 1024 * 1024) catch
-        return error.IOError;
 
     const wasm_mod = WasmModule.loadWasi(allocator, wasm_bytes) catch
         return err.setErrorFmt(.eval, .io_error, .{}, "wasm/load-wasi: failed to instantiate module: {s}", .{path});
diff --git a/src/lang/lib/clojure_java_browse.zig b/src/lang/lib/clojure_java_browse.zig
index 0f95a3b6..d761e1f6 100644
--- a/src/lang/lib/clojure_java_browse.zig
+++ b/src/lang/lib/clojure_java_browse.zig
@@ -15,6 +15,7 @@ const BuiltinDef = var_mod.BuiltinDef;
 const err = @import("../../runtime/error.zig");
 const registry = @import("../registry.zig");
 const NamespaceDef = registry.NamespaceDef;
+const io_default = @import("../../runtime/io_default.zig");
 
 // ============================================================
 // Implementation
@@ -30,11 +31,14 @@ fn browseUrlFn(allocator: Allocator, args: []const Value) anyerror!Value {
         else => return err.setErrorFmt(.eval, .type_error, .{}, "browse-url: argument must be a string", .{}),
     };
 
+    _ = allocator;
     const open_cmd = openCommand();
     if (open_cmd) |cmd| {
-        var child = std.process.Child.init(&.{ cmd, url_str }, allocator);
-        child.spawn() catch return args[0]; // silently fail if spawn fails
-        _ = child.wait() catch {};
+        const proc_io = io_default.get();
+        var child = std.process.spawn(proc_io, .{
+            .argv = &.{ cmd, url_str },
+        }) catch return args[0]; // silently fail if spawn fails
+        _ = child.wait(proc_io) catch {};
         return args[0];
     }
 
diff --git a/src/main.zig b/src/main.zig
index 6a798694..68ea86d1 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -24,11 +24,12 @@ const runner = @import("app/runner.zig");
 const cli = @import("app/cli.zig");
 const test_runner = @import("app/test_runner.zig");
 const clojure_core_protocols = @import("lang/lib/clojure_core_protocols.zig");
+const io_default = @import("runtime/io_default.zig");
 
-pub fn main() !void {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    io_default.set(init.io);
+    io_default.setEnvironMap(init.environ_map);
 
     // Two allocators:
     //   allocator (GPA)   — for infrastructure (Env, Namespace, Var, HashMaps)
@@ -39,8 +40,7 @@ pub fn main() !void {
     defer gc.dumpAllocProfile(); // 37.1: dump allocation profile at exit
     const alloc = gc.allocator();
 
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
+    const args = try init.minimal.args.toSlice(init.arena.allocator());
 
     // Initialize keyword intern table (uses GPA for permanent keyword strings)
     keyword_intern.init(allocator);
diff --git a/src/runtime/concurrency_test.zig b/src/runtime/concurrency_test.zig
index bf94d0b2..a82f6e30 100644
--- a/src/runtime/concurrency_test.zig
+++ b/src/runtime/concurrency_test.zig
@@ -16,6 +16,7 @@ const std = @import("std");
 const gc_mod = @import("gc.zig");
 const MarkSweepGc = gc_mod.MarkSweepGc;
 const thread_pool = @import("thread_pool.zig");
+const io_default = @import("io_default.zig");
 const FutureResult = thread_pool.FutureResult;
 
 const testing = std.testing;
@@ -96,12 +97,12 @@ test "57.2 — GC collection during concurrent allocation" {
         fn run(gc: *MarkSweepGc, stop: *std.atomic.Value(bool), count: *std.atomic.Value(u32)) void {
             while (!stop.load(.acquire)) {
                 // Force collection (no marking — all allocations are unreachable)
-                gc.gc_mutex.lock();
-                gc.gc_mutex.unlock();
+                io_default.lockMutex(&gc.gc_mutex);
+                io_default.unlockMutex(&gc.gc_mutex);
                 // Calling full collect would sweep everything since nothing is marked.
                 // Instead, just verify we can acquire the lock safely while others allocate.
                 _ = count.fetchAdd(1, .monotonic);
-                std.Thread.sleep(1_000_000); // 1ms between "collections"
+                io_default.sleep(1_000_000); // 1ms between "collections"
             }
         }
     };
@@ -124,7 +125,7 @@ test "57.2 — GC collection during concurrent allocation" {
     spawned += 1;
 
     // Let them run for 50ms
-    std.Thread.sleep(50_000_000);
+    io_default.sleep(50_000_000);
     stop_flag.store(true, .release);
 
     for (threads[0..spawned]) |t| t.join();
@@ -148,7 +149,7 @@ test "57.3 — FutureResult stress: many concurrent set/get pairs" {
     const Producer = struct {
         fn run(r: *FutureResult, id: usize) void {
             // Simulate some work
-            std.Thread.sleep(@as(u64, @intCast(id)) * 500_000); // 0.5ms * id
+            io_default.sleep(@as(u64, @intCast(id)) * 500_000); // 0.5ms * id
             const val = @import("value.zig").Value.initInteger(@intCast(id * 42));
             r.setResult(val);
         }
diff --git a/src/runtime/gc.zig b/src/runtime/gc.zig
index 7113a0a7..6b9129a3 100644
--- a/src/runtime/gc.zig
+++ b/src/runtime/gc.zig
@@ -23,6 +23,7 @@ const ns_mod = @import("namespace.zig");
 const var_mod = @import("var.zig");
 const collections = @import("collections.zig");
 const HAMTNode = collections.HAMTNode;
+const io_default = @import("io_default.zig");
 
 /// GC root set — references to all live value sources.
 ///
@@ -195,8 +196,9 @@ pub const MarkSweepGc = struct {
     threshold: usize = 1024 * 1024, // 1MB initial; grows via threshold *= 2
 
     /// Mutex protecting all GC state (allocations, free pools, counters).
-    /// Serializes allocation and collection across threads.
-    gc_mutex: std.Thread.Mutex = .{},
+    /// Serializes allocation and collection across threads. Uses the
+    /// process-wide `runtime/io_default` for lock/unlock io.
+    gc_mutex: std.Io.Mutex = .init,
 
     /// When > 0, collectIfNeeded() skips collection.
     /// Used during valueToForm to prevent GC from collecting the macro
@@ -436,8 +438,9 @@ pub const MarkSweepGc = struct {
     /// participate in future mark-sweep cycles normally.
     fn msAlloc(ptr: *anyopaque, len: usize, alignment: Alignment, ret_addr: usize) ?[*]u8 {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         // Fast path: try free pool first — exact (size, alignment) match, O(1) pop
         for (self.free_pools[0..self.free_pool_count]) |*pool| {
             if (pool.size == len and pool.alignment == alignment) {
@@ -478,8 +481,9 @@ pub const MarkSweepGc = struct {
 
     fn msResize(ptr: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) bool {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         if (self.backing.rawResize(memory, alignment, new_len, ret_addr)) {
             const addr = @intFromPtr(memory.ptr);
             if (self.allocations.getPtr(addr)) |info| {
@@ -493,8 +497,9 @@ pub const MarkSweepGc = struct {
 
     fn msRemap(ptr: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) ?[*]u8 {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         const result = self.backing.rawRemap(memory, alignment, new_len, ret_addr) orelse return null;
         const old_addr = @intFromPtr(memory.ptr);
         const new_addr = @intFromPtr(result);
@@ -523,8 +528,9 @@ pub const MarkSweepGc = struct {
 
     fn msFree(ptr: *anyopaque, memory: []u8, alignment: Alignment, ret_addr: usize) void {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         const addr = @intFromPtr(memory.ptr);
         if (self.allocations.get(addr)) |info| {
             self.bytes_allocated -|= info.len;
@@ -544,8 +550,9 @@ pub const MarkSweepGc = struct {
 
     fn gcCollect(ptr: *anyopaque, roots: RootSet) void {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         traceRoots(self, roots);
         self.sweep();
         self.sweepFinalizers();
@@ -553,8 +560,9 @@ pub const MarkSweepGc = struct {
 
     fn gcShouldCollect(ptr: *anyopaque) bool {
         const self: *MarkSweepGc = @ptrCast(@alignCast(ptr));
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         return self.bytes_allocated >= self.threshold;
     }
 
@@ -569,8 +577,9 @@ pub const MarkSweepGc = struct {
     /// Run a GC cycle if the allocation threshold has been reached.
     /// Traces roots, sweeps dead allocations, and grows threshold if needed.
     pub fn collectIfNeeded(self: *MarkSweepGc, roots: RootSet) void {
-        self.gc_mutex.lock();
-        defer self.gc_mutex.unlock();
+        const io = io_default.get();
+        self.gc_mutex.lockUncancelable(io);
+        defer self.gc_mutex.unlock(io);
         if (self.suppress_count > 0) return; // Suppressed (e.g. during valueToForm)
         if (self.bytes_allocated < self.threshold) return;
         traceRoots(self, roots);
diff --git a/src/runtime/io_default.zig b/src/runtime/io_default.zig
new file mode 100644
index 00000000..4c5fc8c3
--- /dev/null
+++ b/src/runtime/io_default.zig
@@ -0,0 +1,160 @@
+// Copyright (c) 2026 chaploud. All rights reserved.
+// The use and distribution terms for this software are covered by the
+// Eclipse Public License 1.0 (https://opensource.org/license/epl-1-0)
+// which can be found in the file LICENSE at the root of this distribution.
+// By using this software in any fashion, you are agreeing to be bound by
+// the terms of this license.
+// You must not remove this notice, or any other, from this software.
+
+//! Process-wide default `std.Io` accessor.
+//!
+//! Zig 0.16 removed `std.Thread.Mutex` and friends; the replacement
+//! `std.Io.Mutex` requires an `io` argument for lock/unlock. CW carries
+//! many module-level mutexes (interned keywords, hooks, namespaces, etc.)
+//! that don't have access to an `init.io` value at the call site.
+//!
+//! This module exposes a single shared `std.Io` that defaults to a
+//! single-threaded io suitable for tests and pre-init code paths.
+//! Production entry points (main, cache_gen) call `set(init.io)` early
+//! to upgrade the shared io to the real cancelable one used by
+//! `thread_pool.zig`. After that, every mutex picks up the production io.
+
+const std = @import("std");
+
+var single_threaded: std.Io.Threaded = .init_single_threaded;
+var current_io: std.Io = undefined;
+var initialized: bool = false;
+
+/// Return the process-wide default io. Lazily initializes to a single-
+/// threaded io on first call so tests and ad-hoc callers don't have to
+/// remember to call `set()`.
+pub fn get() std.Io {
+    if (!initialized) {
+        current_io = single_threaded.io();
+        initialized = true;
+    }
+    return current_io;
+}
+
+/// Override the process-wide default io. Production entry points
+/// (main/cache_gen) call this with `init.io` so the thread_pool path
+/// gets the real cancelable mutex semantics.
+pub fn set(io: std.Io) void {
+    current_io = io;
+    initialized = true;
+}
+
+// =====================================================================
+// Convenience helpers — mirror the deleted std.Thread.{Mutex,Condition}
+// API surface so call sites that previously passed no io argument keep
+// roughly the same shape.
+// =====================================================================
+
+/// Lock a mutex using the default io. Uncancelable variant: never
+/// returns an error, matching the old std.Thread.Mutex.lock() shape.
+pub fn lockMutex(m: *std.Io.Mutex) void {
+    m.lockUncancelable(get());
+}
+
+pub fn unlockMutex(m: *std.Io.Mutex) void {
+    m.unlock(get());
+}
+
+/// std.Io.Condition.wait, but uncancelable and uses default io.
+pub fn condWait(cond: *std.Io.Condition, mutex: *std.Io.Mutex) void {
+    cond.waitUncancelable(get(), mutex);
+}
+
+/// Timed wait on a condition. Returns true on timeout, false on signal/broadcast.
+/// Mirrors zwasm's `condTimedWait` (D135). The deadline is computed once
+/// outside the loop so spurious wake-ups don't extend the wait.
+pub fn condTimedWait(cond: *std.Io.Condition, mutex: *std.Io.Mutex, timeout_ns: u64) bool {
+    const io = get();
+    var epoch = cond.epoch.load(.acquire);
+    _ = cond.state.fetchAdd(.{ .waiters = 1, .signals = 0 }, .monotonic);
+    mutex.unlock(io);
+    defer mutex.lockUncancelable(io);
+
+    const start = std.Io.Timestamp.now(io, .awake);
+    const deadline_ts = start.addDuration(.fromNanoseconds(@intCast(timeout_ns)));
+    const deadline_clock_ts: std.Io.Clock.Timestamp = .{ .raw = deadline_ts, .clock = .awake };
+    const timeout: std.Io.Timeout = .{ .deadline = deadline_clock_ts };
+
+    while (true) {
+        // futexWaitTimeout returns Cancelable!void — error.Timeout is not in
+        // that error set, so the timeout case is detected by checking the
+        // current Timestamp against the deadline rather than via the error.
+        std.Io.futexWaitTimeout(io, u32, &cond.epoch.raw, epoch, timeout) catch {};
+        epoch = cond.epoch.load(.acquire);
+        const cur = cond.state.load(.monotonic);
+        if (cur.signals > 0) {
+            const new_state: @TypeOf(cur) = .{
+                .waiters = cur.waiters - 1,
+                .signals = cur.signals - 1,
+            };
+            if (cond.state.cmpxchgWeak(cur, new_state, .acquire, .monotonic) == null) {
+                return false;
+            }
+        }
+        // Check if deadline passed (timeout case)
+        const now_ts = std.Io.Timestamp.now(io, .awake);
+        if (now_ts.nanoseconds >= deadline_ts.nanoseconds) return true;
+    }
+}
+
+pub fn condSignal(cond: *std.Io.Condition) void {
+    cond.signal(get());
+}
+
+pub fn condBroadcast(cond: *std.Io.Condition) void {
+    cond.broadcast(get());
+}
+
+/// Sleep for `ns` nanoseconds. Replaces std.Thread.sleep(ns).
+pub fn sleep(ns: u64) void {
+    std.Io.sleep(get(), .fromNanoseconds(@intCast(ns)), .awake) catch {};
+}
+
+// =====================================================================
+// Environment access — mirrors zwasm/platform.setEnvironMap. The Process
+// init block carries an `environ_map` we can borrow from main/cache_gen
+// so other modules can read env vars without calling libc's getenv.
+// =====================================================================
+
+var env_map_ref: ?*const std.process.Environ.Map = null;
+
+pub fn setEnvironMap(m: *const std.process.Environ.Map) void {
+    env_map_ref = m;
+}
+
+/// Look up an environment variable. Falls back to libc's getenv when
+/// `setEnvironMap` was never called (tests, pre-init code) — we always
+/// link libc as part of the 0.16 migration.
+pub fn getEnv(name: []const u8) ?[]const u8 {
+    if (env_map_ref) |m| {
+        return m.get(name);
+    }
+    var stack_buf: [512]u8 = undefined;
+    if (name.len >= stack_buf.len) return null;
+    @memcpy(stack_buf[0..name.len], name);
+    stack_buf[name.len] = 0;
+    const z_ptr: [*:0]const u8 = @ptrCast(&stack_buf);
+    const raw = std.c.getenv(z_ptr) orelse return null;
+    return std.mem.span(@as([*:0]const u8, @ptrCast(raw)));
+}
+
+// =====================================================================
+// Time helpers
+// =====================================================================
+
+/// Nanoseconds since some monotonic epoch. Replaces std.time.nanoTimestamp().
+pub fn nanoTimestamp() i128 {
+    const ts = std.Io.Timestamp.now(get(), .real);
+    return @intCast(ts.nanoseconds);
+}
+
+/// Milliseconds since the wall-clock epoch. Replaces std.time.milliTimestamp().
+pub fn milliTimestamp() i64 {
+    const ts = std.Io.Timestamp.now(get(), .real);
+    return @intCast(@divTrunc(ts.nanoseconds, std.time.ns_per_ms));
+}
diff --git a/src/runtime/keyword_intern.zig b/src/runtime/keyword_intern.zig
index a92d4218..9afa92c2 100644
--- a/src/runtime/keyword_intern.zig
+++ b/src/runtime/keyword_intern.zig
@@ -14,13 +14,14 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const value_mod = @import("value.zig");
 const Value = value_mod.Value;
+const io_default = @import("io_default.zig");
 
 /// Global keyword intern table.
 /// Keys are "ns/name" or "name" strings, owned by this table.
 /// Protected by mutex for thread-safe access.
 var table: std.StringArrayHashMapUnmanaged(void) = .empty;
 var intern_allocator: ?Allocator = null;
-var mutex: std.Thread.Mutex = .{};
+var mutex: std.Io.Mutex = .init;
 
 /// Initialize the intern table with an allocator.
 /// Must be called once before any intern/find operations.
@@ -44,8 +45,9 @@ pub fn deinit() void {
 pub fn intern(ns: ?[]const u8, name: []const u8) void {
     const alloc = intern_allocator orelse return;
     const key = formatKey(alloc, ns, name) catch return;
-    mutex.lock();
-    defer mutex.unlock();
+    const io = io_default.get();
+    mutex.lockUncancelable(io);
+    defer mutex.unlock(io);
     if (table.contains(key)) {
         alloc.free(key);
         return;
@@ -60,8 +62,9 @@ pub fn contains(ns: ?[]const u8, name: []const u8) bool {
     const alloc = intern_allocator orelse return false;
     const key = formatKey(alloc, ns, name) catch return false;
     defer alloc.free(key);
-    mutex.lock();
-    defer mutex.unlock();
+    const io = io_default.get();
+    mutex.lockUncancelable(io);
+    defer mutex.unlock(io);
     return table.contains(key);
 }
 
diff --git a/src/runtime/lifecycle.zig b/src/runtime/lifecycle.zig
index 1b4de817..d73029c7 100644
--- a/src/runtime/lifecycle.zig
+++ b/src/runtime/lifecycle.zig
@@ -20,6 +20,7 @@ const Value = @import("value.zig").Value;
 const dispatch = @import("dispatch.zig");
 const Env = @import("env.zig").Env;
 const thread_pool = @import("thread_pool.zig");
+const io_default = @import("io_default.zig");
 
 // ============================================================
 // Shutdown flag
@@ -60,11 +61,11 @@ pub fn installSignalHandlers() void {
     std.posix.sigaction(std.posix.SIG.PIPE, &ignore_action, null);
 }
 
-fn handleShutdownSignal(_: i32) callconv(.c) void {
+fn handleShutdownSignal(_: std.posix.SIG) callconv(.c) void {
     shutdown_requested.store(true, .release);
     // Write newline to stderr so the shell prompt appears cleanly.
     // write() is async-signal-safe.
-    _ = std.posix.write(std.posix.STDERR_FILENO, "\n") catch {};
+    _ = std.c.write(std.posix.STDERR_FILENO, "\n", 1);
 }
 
 // ============================================================
@@ -73,27 +74,13 @@ fn handleShutdownSignal(_: i32) callconv(.c) void {
 
 /// Wait for a connection on the listener socket, checking shutdown flag
 /// every ~1 second. Returns null if shutdown was requested.
-pub fn acceptWithShutdownCheck(server: *std.net.Server) ?std.net.Server.Connection {
-    const fd = server.stream.handle;
-    var fds = [1]std.posix.pollfd{
-        .{ .fd = fd, .events = std.posix.POLL.IN, .revents = 0 },
-    };
-
-    while (!isShutdownRequested()) {
-        const ready = std.posix.poll(&fds, 1000) catch |e| {
-            std.debug.print("poll error: {s}\n", .{@errorName(e)});
-            if (isShutdownRequested()) return null;
-            continue;
-        };
-        if (ready == 0) continue; // timeout — check flag and retry
-
-        // Socket is ready for accept
-        return server.accept() catch |e| {
-            if (isShutdownRequested()) return null;
-            std.debug.print("accept error: {s}\n", .{@errorName(e)});
-            continue;
-        };
-    }
+///
+/// Stubbed during the Zig 0.16 migration: std.net.Server (and the matching
+/// std.posix.poll) was removed in 0.16. Re-implement on top of std.Io.net
+/// once the network rewrite lands (Phase 7 follow-up F##). The only callers
+/// were http_server (already stubbed) and the nREPL accept loop.
+pub fn acceptWithShutdownCheck(server: anytype) @TypeOf(null) {
+    _ = server;
     return null;
 }
 
@@ -110,13 +97,14 @@ const ShutdownHook = struct {
 };
 
 var hooks: [MAX_HOOKS]?ShutdownHook = .{null} ** MAX_HOOKS;
-var hook_mutex: std.Thread.Mutex = .{};
+var hook_mutex: std.Io.Mutex = .init;
 
 /// Register a shutdown hook. Returns true on success, false if table is full
 /// or key already exists.
 pub fn addShutdownHook(key: []const u8, func: Value) bool {
-    hook_mutex.lock();
-    defer hook_mutex.unlock();
+    const io = io_default.get();
+    hook_mutex.lockUncancelable(io);
+    defer hook_mutex.unlock(io);
 
     // Check for duplicate key
     for (&hooks) |*slot| {
@@ -147,8 +135,9 @@ pub fn addShutdownHook(key: []const u8, func: Value) bool {
 
 /// Remove a shutdown hook by key. Returns true if found and removed.
 pub fn removeShutdownHook(key: []const u8) bool {
-    hook_mutex.lock();
-    defer hook_mutex.unlock();
+    const io = io_default.get();
+    hook_mutex.lockUncancelable(io);
+    defer hook_mutex.unlock(io);
 
     for (&hooks) |*slot| {
         if (slot.*) |h| {
@@ -164,10 +153,11 @@ pub fn removeShutdownHook(key: []const u8) bool {
 /// Run all registered shutdown hooks. Call before process exit.
 /// env must be provided to set up eval context for Clojure fn calls.
 pub fn runShutdownHooks(allocator: Allocator, env_ptr: *Env) void {
-    hook_mutex.lock();
+    const hooks_io = io_default.get();
+    hook_mutex.lockUncancelable(hooks_io);
     // Copy hooks to local array to release mutex before calling Clojure fns
     var local_hooks: [MAX_HOOKS]?ShutdownHook = hooks;
-    hook_mutex.unlock();
+    hook_mutex.unlock(hooks_io);
 
     // Set eval context for callFnVal (bytecodeCallBridge needs it)
     dispatch.macro_eval_env = env_ptr;
diff --git a/src/runtime/stm.zig b/src/runtime/stm.zig
index e8cba3a2..3bea1417 100644
--- a/src/runtime/stm.zig
+++ b/src/runtime/stm.zig
@@ -28,6 +28,7 @@ const RefInner = value_mod.RefInner;
 const TVal = value_mod.TVal;
 const err = @import("error.zig");
 const dispatch = @import("dispatch.zig");
+const io_default = @import("io_default.zig");
 
 const RETRY_LIMIT: u32 = 10000;
 
@@ -145,8 +146,8 @@ pub const LockingTransaction = struct {
         if (self.vals.get(inner)) |v| return v;
 
         // Walk history chain for version at or before read_point
-        inner.lock.lock();
-        defer inner.lock.unlock();
+        io_default.lockMutex(&inner.lock);
+        defer io_default.unlockMutex(&inner.lock);
 
         var tval = inner.tvals;
         while (tval) |tv| {
@@ -163,12 +164,12 @@ pub const LockingTransaction = struct {
     /// Set a ref's value within this transaction.
     pub fn doSet(self: *LockingTransaction, inner: *RefInner, val: Value) !void {
         // Check for write-write conflict
-        inner.lock.lock();
+        io_default.lockMutex(&inner.lock);
         if (inner.currentPoint() > self.read_point) {
-            inner.lock.unlock();
+            io_default.unlockMutex(&inner.lock);
             return error.STMRetry;
         }
-        inner.lock.unlock();
+        io_default.unlockMutex(&inner.lock);
 
         self.vals.put(self.allocator, inner, val) catch return error.OutOfMemory;
         self.sets.put(self.allocator, inner, {}) catch return error.OutOfMemory;
@@ -178,8 +179,8 @@ pub const LockingTransaction = struct {
     pub fn doCommute(self: *LockingTransaction, allocator: Allocator, inner: *RefInner, func: Value, args: []const Value) anyerror!Value {
         // Get current in-transaction value (or read from ref)
         const current = self.vals.get(inner) orelse blk: {
-            inner.lock.lock();
-            defer inner.lock.unlock();
+            io_default.lockMutex(&inner.lock);
+            defer io_default.unlockMutex(&inner.lock);
             break :blk inner.currentVal();
         };
 
@@ -208,12 +209,12 @@ pub const LockingTransaction = struct {
         // If already set in this transaction, ensure is implicit
         if (self.sets.contains(inner)) return;
 
-        inner.lock.lock();
+        io_default.lockMutex(&inner.lock);
         if (inner.currentPoint() > self.read_point) {
-            inner.lock.unlock();
+            io_default.unlockMutex(&inner.lock);
             return error.STMRetry;
         }
-        inner.lock.unlock();
+        io_default.unlockMutex(&inner.lock);
 
         self.ensures.put(self.allocator, inner, {}) catch return error.OutOfMemory;
     }
@@ -229,7 +230,7 @@ pub const LockingTransaction = struct {
             // Skip if also in sets (alter takes precedence)
             if (self.sets.contains(inner)) continue;
 
-            inner.lock.lock();
+            io_default.lockMutex(&inner.lock);
 
             // Replay all commute fns against the current committed value
             var current = inner.currentVal();
@@ -238,21 +239,21 @@ pub const LockingTransaction = struct {
                 call_args[0] = current;
                 @memcpy(call_args[1..], cfn.args);
                 current = dispatch.callFnVal(allocator, cfn.func, call_args) catch |e| {
-                    inner.lock.unlock();
+                    io_default.unlockMutex(&inner.lock);
                     return e;
                 };
             }
 
             self.vals.put(self.allocator, inner, current) catch {
-                inner.lock.unlock();
+                io_default.unlockMutex(&inner.lock);
                 return error.OutOfMemory;
             };
             self.sets.put(self.allocator, inner, {}) catch {
-                inner.lock.unlock();
+                io_default.unlockMutex(&inner.lock);
                 return error.OutOfMemory;
             };
 
-            inner.lock.unlock();
+            io_default.unlockMutex(&inner.lock);
         }
 
         // Phase 2: Validate and acquire locks on all modified refs
@@ -260,7 +261,7 @@ pub const LockingTransaction = struct {
         var sets_iter = self.sets.iterator();
         while (sets_iter.next()) |entry| {
             const inner = entry.key_ptr.*;
-            inner.lock.lock();
+            io_default.lockMutex(&inner.lock);
             if (inner.currentPoint() > self.read_point) {
                 // Conflict — unlock all and retry
                 self.unlockAll();
@@ -273,7 +274,7 @@ pub const LockingTransaction = struct {
         while (ensures_iter.next()) |entry| {
             const inner = entry.key_ptr.*;
             if (!self.sets.contains(inner)) {
-                inner.lock.lock();
+                io_default.lockMutex(&inner.lock);
                 if (inner.currentPoint() > self.read_point) {
                     self.unlockAll();
                     self.unlockEnsures();
@@ -343,7 +344,7 @@ pub const LockingTransaction = struct {
     fn unlockAll(self: *LockingTransaction) void {
         var it = self.sets.iterator();
         while (it.next()) |entry| {
-            entry.key_ptr.*.lock.unlock();
+            io_default.unlockMutex(&entry.key_ptr.*.lock);
         }
     }
 
@@ -351,7 +352,7 @@ pub const LockingTransaction = struct {
         var it = self.ensures.iterator();
         while (it.next()) |entry| {
             if (!self.sets.contains(entry.key_ptr.*)) {
-                entry.key_ptr.*.lock.unlock();
+                io_default.unlockMutex(&entry.key_ptr.*.lock);
             }
         }
     }
@@ -406,7 +407,7 @@ pub fn createRef(allocator: Allocator, initial_val: Value, opts: RefOptions) !Va
         .faults = 0,
         .min_history = opts.min_history,
         .max_history = opts.max_history,
-        .lock = .{},
+        .lock = .init,
         .tinfo = null,
         .validator = opts.validator,
         .meta_val = opts.meta orelse Value.nil_val,
diff --git a/src/runtime/thread_pool.zig b/src/runtime/thread_pool.zig
index 7e6b4e69..25a42627 100644
--- a/src/runtime/thread_pool.zig
+++ b/src/runtime/thread_pool.zig
@@ -22,14 +22,15 @@ const var_mod = @import("var.zig");
 const dispatch = @import("dispatch.zig");
 const ns_mod = @import("namespace.zig");
 const err_mod = @import("error.zig");
+const io_default = @import("io_default.zig");
 
 /// Result of an asynchronous computation.
 ///
 /// Thread-safe: guarded by internal mutex + condition variable.
 /// deref blocks until result is available (or timeout).
 pub const FutureResult = struct {
-    mutex: std.Thread.Mutex = .{},
-    cond: std.Thread.Condition = .{},
+    mutex: std.Io.Mutex = .init,
+    cond: std.Io.Condition = .init,
     state: State = .pending,
     value: Value = Value.nil_val,
     err_value: Value = Value.nil_val,
@@ -38,10 +39,10 @@ pub const FutureResult = struct {
 
     /// Block until result is available, then return it.
     pub fn get(self: *FutureResult) Value {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        io_default.lockMutex(&self.mutex);
+        defer io_default.unlockMutex(&self.mutex);
         while (self.state == .pending) {
-            self.cond.wait(&self.mutex);
+            io_default.condWait(&self.cond, &self.mutex);
         }
         return self.value;
     }
@@ -49,37 +50,37 @@ pub const FutureResult = struct {
     /// Block until result is available or timeout (nanoseconds).
     /// Returns null on timeout.
     pub fn getWithTimeout(self: *FutureResult, timeout_ns: u64) ?Value {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        io_default.lockMutex(&self.mutex);
+        defer io_default.unlockMutex(&self.mutex);
         if (self.state != .pending) return self.value;
-        self.cond.timedWait(&self.mutex, timeout_ns) catch {};
+        _ = io_default.condTimedWait(&self.cond, &self.mutex, timeout_ns);
         if (self.state != .pending) return self.value;
         return null;
     }
 
     /// Check if result is available without blocking.
     pub fn isDone(self: *FutureResult) bool {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        io_default.lockMutex(&self.mutex);
+        defer io_default.unlockMutex(&self.mutex);
         return self.state != .pending;
     }
 
     /// Set successful result and wake all waiters.
     pub fn setResult(self: *FutureResult, val: Value) void {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        io_default.lockMutex(&self.mutex);
+        defer io_default.unlockMutex(&self.mutex);
         self.value = val;
         self.state = .done;
-        self.cond.broadcast();
+        io_default.condBroadcast(&self.cond);
     }
 
     /// Set error result and wake all waiters.
     pub fn setError(self: *FutureResult, err_val: Value) void {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        io_default.lockMutex(&self.mutex);
+        defer io_default.unlockMutex(&self.mutex);
         self.err_value = err_val;
         self.state = .@"error";
-        self.cond.broadcast();
+        io_default.condBroadcast(&self.cond);
     }
 };
 
@@ -109,8 +110,8 @@ const WorkItem = struct {
 /// the GC from sweeping the thread handles during collection.
 pub const ThreadPool = struct {
     threads: []std.Thread,
-    queue_mutex: std.Thread.Mutex = .{},
-    queue_cond: std.Thread.Condition = .{},
+    queue_mutex: std.Io.Mutex = .init,
+    queue_cond: std.Io.Condition = .init,
     work_items: std.ArrayList(WorkItem),
     shutdown_flag: std.atomic.Value(bool),
     source_env: *env_mod.Env,
@@ -133,7 +134,7 @@ pub const ThreadPool = struct {
         var spawned: usize = 0;
         errdefer {
             pool.shutdown_flag.store(true, .release);
-            pool.queue_cond.broadcast();
+            io_default.condBroadcast(&pool.queue_cond);
             for (threads[0..spawned]) |t| t.join();
             pool_allocator.free(threads);
             pool_allocator.destroy(pool);
@@ -156,8 +157,8 @@ pub const ThreadPool = struct {
         const parent_ns = if (dispatch.macro_eval_env) |env| env.current_ns else null;
         const parent_bindings = var_mod.getCurrentBindingFrame();
 
-        self.queue_mutex.lock();
-        defer self.queue_mutex.unlock();
+        io_default.lockMutex(&self.queue_mutex);
+        defer io_default.unlockMutex(&self.queue_mutex);
         try self.work_items.append(pool_allocator, .{
             .kind = .function,
             .func = func,
@@ -165,7 +166,7 @@ pub const ThreadPool = struct {
             .parent_ns = parent_ns,
             .parent_bindings = parent_bindings,
         });
-        self.queue_cond.signal();
+        io_default.condSignal(&self.queue_cond);
         return result;
     }
 
@@ -175,15 +176,15 @@ pub const ThreadPool = struct {
         const parent_ns = if (dispatch.macro_eval_env) |env| env.current_ns else null;
         const parent_bindings = var_mod.getCurrentBindingFrame();
 
-        self.queue_mutex.lock();
-        defer self.queue_mutex.unlock();
+        io_default.lockMutex(&self.queue_mutex);
+        defer io_default.unlockMutex(&self.queue_mutex);
         try self.work_items.append(pool_allocator, .{
             .kind = .agent,
             .agent_obj = agent_obj,
             .parent_ns = parent_ns,
             .parent_bindings = parent_bindings,
         });
-        self.queue_cond.signal();
+        io_default.condSignal(&self.queue_cond);
     }
 
     /// Shut down the pool: signal workers to exit, then join all threads.
@@ -191,9 +192,9 @@ pub const ThreadPool = struct {
         self.shutdown_flag.store(true, .release);
         // Wake all waiting workers
         {
-            self.queue_mutex.lock();
-            defer self.queue_mutex.unlock();
-            self.queue_cond.broadcast();
+            io_default.lockMutex(&self.queue_mutex);
+            defer io_default.unlockMutex(&self.queue_mutex);
+            io_default.condBroadcast(&self.queue_cond);
         }
         for (self.threads) |t| {
             t.join();
@@ -219,16 +220,16 @@ pub const ThreadPool = struct {
 
         while (true) {
             // Get next work item (blocking)
-            pool.queue_mutex.lock();
+            io_default.lockMutex(&pool.queue_mutex);
             while (pool.work_items.items.len == 0) {
                 if (pool.shutdown_flag.load(.acquire)) {
-                    pool.queue_mutex.unlock();
+                    io_default.unlockMutex(&pool.queue_mutex);
                     return;
                 }
-                pool.queue_cond.wait(&pool.queue_mutex);
+                io_default.condWait(&pool.queue_cond, &pool.queue_mutex);
             }
             const item = pool.work_items.orderedRemove(0);
-            pool.queue_mutex.unlock();
+            io_default.unlockMutex(&pool.queue_mutex);
 
             // Set up thread context from parent
             thread_env.current_ns = item.parent_ns;
@@ -281,16 +282,16 @@ pub const ThreadPool = struct {
 
         while (true) {
             // Dequeue next action under lock
-            inner.mutex.lock();
+            io_default.lockMutex(&inner.mutex);
             const action = inner.dequeue();
             if (action == null) {
                 // Queue empty — clear processing flag and wake await waiters
                 inner.processing.store(false, .release);
-                inner.await_cond.broadcast();
-                inner.mutex.unlock();
+                io_default.condBroadcast(&inner.await_cond);
+                io_default.unlockMutex(&inner.mutex);
                 return;
             }
-            inner.mutex.unlock();
+            io_default.unlockMutex(&inner.mutex);
 
             const act = action.?;
 
@@ -324,11 +325,11 @@ pub const ThreadPool = struct {
                     break :blk Value.initString(gc_alloc, @errorName(e));
                 };
 
-                inner.mutex.lock();
+                io_default.lockMutex(&inner.mutex);
                 if (inner.error_handler.tag() != .nil) {
                     // Call error handler: (handler agent exception)
                     const handler = inner.error_handler;
-                    inner.mutex.unlock();
+                    io_default.unlockMutex(&inner.mutex);
                     const handler_args = [2]Value{ Value.initAgent(agent_obj), err_val };
                     // JVM: Agent error handler exceptions are silently caught.
                     _ = dispatch.callFnVal(gc_alloc, handler, &handler_args) catch {};
@@ -342,7 +343,7 @@ pub const ThreadPool = struct {
                             // :continue mode — ignore error, keep going
                         },
                     }
-                    inner.mutex.unlock();
+                    io_default.unlockMutex(&inner.mutex);
                 }
 
                 pool_allocator.free(full_args);
@@ -352,9 +353,9 @@ pub const ThreadPool = struct {
             };
 
             // Update state
-            inner.mutex.lock();
+            io_default.lockMutex(&inner.mutex);
             inner.state = new_state;
-            inner.mutex.unlock();
+            io_default.unlockMutex(&inner.mutex);
 
             pool_allocator.free(full_args);
             pool_allocator.free(act.args);
@@ -372,7 +373,7 @@ pub const ThreadPool = struct {
 
 /// Global thread pool instance. Initialized lazily on first future/pmap call.
 var global_pool: ?*ThreadPool = null;
-var pool_mutex: std.Thread.Mutex = .{};
+var pool_mutex: std.Io.Mutex = .init;
 
 /// Cached *agent* dynamic var pointer (set by bootstrap after core.clj loads).
 var agent_var: ?*var_mod.Var = null;
@@ -384,8 +385,8 @@ pub fn initAgentVar(v: *var_mod.Var) void {
 
 /// Get or create the global thread pool.
 pub fn getGlobalPool(env: *env_mod.Env) !*ThreadPool {
-    pool_mutex.lock();
-    defer pool_mutex.unlock();
+    io_default.lockMutex(&pool_mutex);
+    defer io_default.unlockMutex(&pool_mutex);
     if (global_pool) |pool| return pool;
     const pool = try ThreadPool.init(env, 0);
     global_pool = pool;
@@ -394,13 +395,13 @@ pub fn getGlobalPool(env: *env_mod.Env) !*ThreadPool {
 
 /// Shut down the global thread pool (call at program exit).
 pub fn shutdownGlobalPool() void {
-    pool_mutex.lock();
+    io_default.lockMutex(&pool_mutex);
     const pool = global_pool orelse {
-        pool_mutex.unlock();
+        io_default.unlockMutex(&pool_mutex);
         return;
     };
     global_pool = null;
-    pool_mutex.unlock();
+    io_default.unlockMutex(&pool_mutex);
     pool.shutdown();
 }
 
@@ -431,7 +432,7 @@ test "FutureResult — concurrent set and get" {
     // Spawn a thread that sets the result after a brief delay
     const t = try std.Thread.spawn(.{}, struct {
         fn run(r: *FutureResult) void {
-            std.Thread.sleep(5_000_000); // 5ms
+            io_default.sleep(5_000_000); // 5ms
             r.setResult(Value.initInteger(99));
         }
     }.run, .{&result});
diff --git a/src/runtime/value.zig b/src/runtime/value.zig
index 87c1c213..c8b18f60 100644
--- a/src/runtime/value.zig
+++ b/src/runtime/value.zig
@@ -412,8 +412,8 @@ pub const AgentInner = struct {
     error_val: Value = Value.nil_val,
     error_handler: Value = Value.nil_val,
     error_mode: ErrorMode = .continue_mode,
-    mutex: std.Thread.Mutex = .{},
-    await_cond: std.Thread.Condition = .{},
+    mutex: std.Io.Mutex = .init,
+    await_cond: std.Io.Condition = .init,
     pending_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
     processing: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
     action_head: ?*AgentAction = null,
@@ -481,7 +481,7 @@ pub const RefInner = struct {
     faults: u32, // read fault counter (triggers history growth)
     min_history: u32,
     max_history: u32,
-    lock: std.Thread.Mutex,
+    lock: std.Io.Mutex,
     tinfo: ?*anyopaque, // *TxInfo if write-locked by a transaction
     validator: ?Value,
     meta_val: Value, // metadata map
diff --git a/src/runtime/wasm_types.zig b/src/runtime/wasm_types.zig
index e70ca1ea..b6a82f80 100644
--- a/src/runtime/wasm_types.zig
+++ b/src/runtime/wasm_types.zig
@@ -26,6 +26,7 @@ const zwasm = if (enable_wasm) @import("zwasm") else struct {};
 const wasm_alloc = if (enable_wasm) std.heap.smp_allocator else std.heap.page_allocator;
 
 const gc_mod = @import("gc.zig");
+const io_default = @import("io_default.zig");
 
 /// GC reference for finalizer registration. Set by main.zig after bootstrap.
 var gc_ref: ?*gc_mod.MarkSweepGc = null;
@@ -363,11 +364,12 @@ const HostContext = struct {
 const MAX_CONTEXTS = 256;
 var host_contexts: [MAX_CONTEXTS]?HostContext = [_]?HostContext{null} ** MAX_CONTEXTS;
 var next_context_id: usize = 0;
-var context_mutex: std.Thread.Mutex = .{};
+var context_mutex: std.Io.Mutex = .init;
 
 fn allocContext(ctx: HostContext) !usize {
-    context_mutex.lock();
-    defer context_mutex.unlock();
+    const io = io_default.get();
+    context_mutex.lockUncancelable(io);
+    defer context_mutex.unlock(io);
     var id = next_context_id;
     var tried: usize = 0;
     while (tried < MAX_CONTEXTS) : ({
@@ -387,12 +389,13 @@ fn allocContext(ctx: HostContext) !usize {
 fn hostTrampoline(ctx_ptr: *anyopaque, context_id: usize) anyerror!void {
     if (comptime !enable_wasm) unreachable;
     const vm: *zwasm.Vm = @ptrCast(@alignCast(ctx_ptr));
-    context_mutex.lock();
+    const io = io_default.get();
+    context_mutex.lockUncancelable(io);
     const ctx = host_contexts[context_id] orelse {
-        context_mutex.unlock();
+        context_mutex.unlock(io);
         return error.Trap;
     };
-    context_mutex.unlock();
+    context_mutex.unlock(io);
 
     var args_buf: [16]Value = undefined;
     const pc = ctx.param_count;
diff --git a/test/e2e/run_e2e.sh b/test/e2e/run_e2e.sh
index 043054dc..1f7161ce 100755
--- a/test/e2e/run_e2e.sh
+++ b/test/e2e/run_e2e.sh
@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 # E2E test runner for ClojureWasm
 # Runs all .clj test files in test/e2e/ subdirectories
-# Usage: bash test/e2e/run_e2e.sh [--tree-walk] [--dir=wasm]
+# Usage: bash test/e2e/run_e2e.sh [--tree-walk] [--dir=wasm] [--no-wasm]
+#   --no-wasm: skip test/e2e/wasm/ (when binary built with -Dwasm=false)
 
 set -euo pipefail
 
@@ -12,10 +13,12 @@ CLJW="$ROOT_DIR/zig-out/bin/cljw"
 # Parse args
 TREE_WALK=""
 TEST_DIR=""
+NO_WASM=false
 for arg in "$@"; do
   case "$arg" in
     --tree-walk) TREE_WALK="--tree-walk" ;;
     --dir=*) TEST_DIR="${arg#--dir=}" ;;
+    --no-wasm) NO_WASM=true ;;
   esac
 done
 
@@ -32,7 +35,14 @@ else
   TEST_FILES=$(find "$SCRIPT_DIR" -name '*_test.clj' -type f | sort)
 fi
 
-if [ -z "$TEST_FILES" ]; then
+# Filter out wasm/ tests when --no-wasm
+if [ "$NO_WASM" = true ]; then
+  TEST_FILES=$(echo "$TEST_FILES" | grep -v "/wasm/" || true)
+  if [ -z "$TEST_FILES" ]; then
+    echo "No non-wasm e2e tests to run (--no-wasm)."
+    exit 0
+  fi
+elif [ -z "$TEST_FILES" ]; then
   echo "No test files found."
   exit 1
 fi
diff --git a/test/run_all.sh b/test/run_all.sh
index a3c33ae4..f48ab3dd 100755
--- a/test/run_all.sh
+++ b/test/run_all.sh
@@ -2,8 +2,9 @@
 # Unified test runner for ClojureWasm.
 # Runs all test suites and reports a unified summary.
 #
-# Usage: bash test/run_all.sh [--quick]
-#   --quick: skip release build and benchmarks (faster iteration)
+# Usage: bash test/run_all.sh [--quick] [--no-wasm]
+#   --quick:   skip release build and benchmarks (faster iteration)
+#   --no-wasm: skip wasm-dependent suites (use when binary built with -Dwasm=false)
 
 set -euo pipefail
 
@@ -12,9 +13,14 @@ PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
 cd "$PROJECT_DIR"
 
 QUICK=false
-if [[ "${1:-}" == "--quick" ]]; then
-    QUICK=true
-fi
+NO_WASM=false
+ZIG_BUILD_FLAGS=()
+for arg in "$@"; do
+    case "$arg" in
+        --quick)   QUICK=true ;;
+        --no-wasm) NO_WASM=true; ZIG_BUILD_FLAGS+=("-Dwasm=false") ;;
+    esac
+done
 
 PASS=0
 FAIL=0
@@ -39,11 +45,11 @@ echo "=== ClojureWasm Full Test Suite ==="
 echo ""
 
 # 1. Zig unit tests
-run_suite "zig build test" zig build test
+run_suite "zig build test" zig build test "${ZIG_BUILD_FLAGS[@]}"
 
 # 2. Release build
 if [[ "$QUICK" == false ]]; then
-    run_suite "zig build -Doptimize=ReleaseSafe" zig build -Doptimize=ReleaseSafe
+    run_suite "zig build -Doptimize=ReleaseSafe" zig build -Doptimize=ReleaseSafe "${ZIG_BUILD_FLAGS[@]}"
 fi
 
 # 3. Upstream regression suite (cljw test)
@@ -73,8 +79,10 @@ else
     fi
 fi
 
-# 4. Core e2e tests (wasm)
-run_suite "e2e tests (wasm)" bash test/e2e/run_e2e.sh
+# 4. Core e2e tests
+E2E_FLAGS=()
+[[ "$NO_WASM" == true ]] && E2E_FLAGS+=("--no-wasm")
+run_suite "e2e tests" bash test/e2e/run_e2e.sh "${E2E_FLAGS[@]}"
 
 # 5. Deps e2e tests
 run_suite "deps.edn e2e tests" bash test/e2e/deps/run_deps_e2e.sh