feat(runtime): ADR-0171 — merge the rt kernel ns into clojure.core; internals to cljw.internal

Smell-audited: 3: the ADR-0171 full-merge (DA-fork Alt 2, committed
4018266) — data-layer fix over display normalization per F-011/F-013;
retired 3 ADs as parity; the rehome-idempotency leak and the two
stragglers (diff fixture, RegisterError test) were caught by the gate
and fixed before commit.

Zig builtins + bootstrap macros now intern with home ns = clojure.core
(the mainline shape): `(resolve '+)` → `#'clojure.core/+`, doc/meta :ns,
eldoc/lookup/completion ns fields, callable printing (`#<clojure.core/+>`),
and `(ns-publics 'clojure.core)` all match clj at the data layer. The
`__`-prefixed kernel helpers (48 + 9 dash-named ones renamed `__*`)
re-home to the new `cljw.internal` ns via Env.rehomeInternals; macro
expansions and the bundled .clj reference them qualified. The `rt` ns is
deleted: Env.init, the per-ns rt refer in both backends, the
resolveQualified clojure.core refers-exception, and syntax-quote's
per-site rt→clojure.core rename all dissolve. Reader `@x` now lowers to
clojure.core/deref (= clj); `or` emissions qualify to clojure.core/or.
The re-find rebind hazard is closed by making the builtin
cljw.internal/__re-find (core.clj's wrapper owns the public name).
serialize VERSION 5→6 (pre-merge archives bake "rt" var_refs).

AD ledger: AD-011 (ns-publics omission), AD-038 (rt/deref reader form),
AD-049 (spec s/form rt/ qualification) retired as PARITY with pins
flipped; AD-025 text refreshed; new AD-053 pins cljw.internal's
existence + rt's absence + the no-leak invariant. D-562 records the
user-directed arc (completion parity → AD inventory → release tag).

Author: chaploud

.dev/accepted_divergences.yaml

@@ -24,6 +24,27 @@
 # md-table-align no longer pads it to ~800 KB of whitespace.
 
 active:
+  - id: "D-562"
+    status: |-
+      open (2026-07-15, USER-DIRECTED landing point for the current arc).
+      Full inventory of .dev/accepted_divergences.yaml (49 rows): for EACH
+      AD decide (a) KEEP — inherent to cljw's nature (no-JVM identity
+      hashes, tz/locale-free edge target, NaN-box representation …); or
+      (b) CONVERGE — historically-motivated, now retirable: un-accept per
+      accepted_divergences.md (remove row + flip pin to parity + fix), or
+      IMPLEMENT the missing feature that blocks parity. Work the checklist
+      row by row (record per-AD verdict inline here or in a
+      private/notes checklist as the loop proceeds so autonomy survives
+      compaction). Precedent this cycle: ADR-0171 retired AD-011/038/049
+      as parity (rt merge) — the same class of "old structural excuse
+      dissolved" is what this sweep hunts. ORDER within the arc (user):
+      (1) finish the CIDER completion parity unit (incl. java-interop
+      class/static completion without require, good design), (2) this AD
+      inventory + convergence work, (3) THEN cut a release tag — the
+      arc's landing point.
+    category: "clj-parity"
+    barrier: "none — user-directed; ordered after the completion-parity unit"
+    last_reviewed: "2026-07-15"
   - id: "D-561"
     status: |-
       open (2026-07-15, Character/* completion cycle). `Character/getName` is
@@ -4546,7 +4567,7 @@ discharged:
       skips `.var_ref` + `.ns` (Env-lifetime, never GC-allocated — also closed a
       latent `.var_ref` hole). Corpus `namespace` (12), e2e phase15_namespace
       (11), unit test for the membrane. AD-010 (`#object[Namespace …]` print) +
-      AD-011 (clojure.core ns-publics omits rt-referred prims). Deferred: D-231
+      AD-011 (retired 2026-07-15: ADR-0171 made ns-publics parity). Deferred: D-231
       (Var-as-IFn), `remove-ns` (tombstone/lifetime), `*out*` (separate). Unblocks
       D-227 (clojure.test) + D-158 (real-lib). Cross-ref ADR-0083 / D-227 / F-004.
       ORIGINAL: now (structural, surfaced 2026-06-03 by D-227 design probe) — no Namespace value type / *ns* / ns-reflection.

.dev/debt.yaml

@@ -44,12 +44,19 @@
   now advertises `versions.clojurewasm` (babashka-precedent CIDER-banner
   key; CIDER upstream patch draft + init.el advice:
   `private/notes/cider-clojurewasm-banner-patch.md`).
-- **NEXT (user-directed 2026-07-15)**: CIDER completion parity — kill the
-  `(rt)` ns leak (show clojure.core), add kind annotations (<s>/<m>/<v>),
-  class + static-member candidates. Design directive: mechanically
-  extract the canonical surface FROM mainline clj into a data file
-  (EDN; F-013 definition-derived), cljw consumes it via a fixed
-  convention/layer — parity audit falls out as a by-product.
+- **ADR-0171 LANDED (2026-07-15)**: the `rt` kernel ns is GONE — Zig
+  builtins + bootstrap macros intern into clojure.core (home ns matches
+  mainline: `(resolve '+)` → `#'clojure.core/+`; ns-publics parity);
+  `__`-internals live in the new `cljw.internal` ns (macro expansions
+  call them qualified). Retired AD-011/038/049 as PARITY (pins flipped);
+  new AD-053 pins cljw.internal's existence. serialize VERSION 6.
+- **ARC (user-directed 2026-07-15, the landing point)**: (1) CIDER
+  completion parity — kind annotations, class + static-member candidates
+  (java-interop completion without require), keywords, special forms,
+  sort; oracle harness `scripts/completion_oracle.py` + fixtures landed
+  (red baseline 5/18). (2) AD full inventory + convergence (**D-562**).
+  (3) THEN cut a release tag. Cron re-fire 2026-07-16 03:02 JST is set
+  (session-only).
 - **First task on resume**: self-select from the live `active:` list,
   easiest-first (D-523's architecture/wasm-demo residual + D-522 drain 3
   landed 2026-07-14; D-430 is DISCHARGED — the prior pointer here was

.dev/handover.md

@@ -40,3 +40,4 @@ private/
 .clj-kondo/
 .lsp/
 test/conformance/verified_projects/*/.cpcache/
+__pycache__/

.gitignore

@@ -705,13 +705,13 @@ fn analyzeSymbol(
         // analysis (which blocks a lib whose CORE is pure but a peripheral fn
         // touches such a class — e.g. integrant's `(clojure.lang.RT/baseLoader)`
         // in its optional hierarchy loader), rewrite it to a loud runtime
-        // `(rt/__unsupported-host-ref "ns/name")`. The enclosing fn DEFINES, the
+        // `(cljw.internal/__unsupported-host-ref "ns/name")`. The enclosing fn DEFINES, the
         // namespace LOADS, and the ref errors only if actually evaluated. Covers
         // both call-head and value positions (both reach analyzeSymbol). AD-008.
         if (isDeferredHostNs(ns_name)) {
             const full = try std.fmt.allocPrint(arena, "{s}/{s}", .{ ns_name, sym.name });
             const items = try arena.alloc(Form, 2);
-            items[0] = .{ .data = .{ .symbol = .{ .ns = "rt", .name = "__unsupported-host-ref" } }, .location = form.location };
+            items[0] = .{ .data = .{ .symbol = .{ .ns = "cljw.internal", .name = "__unsupported-host-ref" } }, .location = form.location };
             items[1] = .{ .data = .{ .string = full }, .location = form.location };
             const call_form: Form = .{ .data = .{ .list = items }, .location = form.location };
             return analyze(arena, env.rt, env, scope, call_form, macro_table);

src/eval/analyzer/analyzer.zig

@@ -78,7 +78,7 @@ fn qualifySym(env: *Env, s: SymbolRef, loc: SourceLocation) Form {
     if (BARE_SYMS.has(s.name) or hasDot(s.name) or (s.name.len > 0 and (s.name[0] == '.' or s.name[0] == '%')))
         return .{ .data = .{ .symbol = s }, .location = loc };
     const cur = env.current_ns orelse return .{ .data = .{ .symbol = s }, .location = loc };
-    var home = if (cur.resolve(s.name)) |v|
+    const home = if (cur.resolve(s.name)) |v|
         v.ns.name
     else if (s.name.len > 0 and s.name[0] >= 'A' and s.name[0] <= 'Z')
         // An unresolved capitalized symbol is a class name (`Throwable`,
@@ -88,11 +88,6 @@ fn qualifySym(env: *Env, s: SymbolRef, loc: SourceLocation) Form {
         return .{ .data = .{ .symbol = s }, .location = loc }
     else
         cur.name;
-    // cljw's `rt` ns is the implementation home of what clj calls `clojure.core`
-    // (primitives are interned in `rt` + referred everywhere; `clojure.core/+`
-    // also resolves). Present them as `clojure.core/…` so a syntax-quoted core
-    // symbol matches clj (`` `+ `` → clojure.core/+, not rt/+).
-    if (std.mem.eql(u8, home, "rt")) home = "clojure.core";
     return .{ .data = .{ .symbol = .{ .ns = home, .name = s.name } }, .location = loc };
 }
 

src/eval/analyzer/syntax_quote.zig

@@ -557,32 +557,23 @@ fn evalInNs(env: *Env, n: node_mod.InNsNode) !Value {
 
 /// `(ns foo)` / `(ns foo (:refer-clojure))`. ADR-0035 D1 + D9
 /// second amendment. When `:refer-clojure` is in effect (default
-/// true), the cw v1 widened semantic refers BOTH `rt` AND
-/// `clojure.core` into the entering ns (divergence from JVM which
-/// has no rt ns). When `refer_clojure = false`, the ns switch is
-/// naked — same shape as `(in-ns 'foo)`. The widening makes the
-/// refer mechanism grep-traceable from the `.clj` head: every
-/// user-visible refer of rt + clojure.core comes from a
-/// `(:refer-clojure)` directive (boot-time fan-out for user/
-/// remains in bootstrap.zig + primitive.zig + macro_transforms.zig).
+/// true), `clojure.core`'s publics are referred into the entering ns
+/// (the mainline shape; Zig builtins live there per ADR-0171). When
+/// `refer_clojure = false`, the ns switch is naked — same shape as
+/// `(in-ns 'foo)`. Boot-time fan-out for user/ remains in
+/// bootstrap.zig + primitive.zig + macro_transforms.zig.
 fn evalNs(rt: *Runtime, env: *Env, n: node_mod.NsNode) !Value {
     env.setCurrentNs(try env.findOrCreateNs(n.name));
     // `(ns ^{…} name {:attr …} "doc" …)` → ns meta: attr merge first, then
     // the docstring (an explicit doc wins over an attr :doc) — D-239/D-554.
     if (!n.attr_meta.isNil()) try meta_mod.mergeNsMeta(rt, env.current_ns.?, n.attr_meta);
     if (n.doc) |d| try meta_mod.setNsDoc(rt, env.current_ns.?, d);
     if (n.refer_clojure) {
-        // Row 14.7 (D-098): filters apply to both rt/ and clojure.core
-        // (the two auto-refer sources). `rt/` is cw-side primitives;
-        // its `+` / `-` / etc. are what `:exclude [+]` shadows.
-        if (env.findNs("rt")) |rt_ns| {
-            try env.referAllWithFilter(rt_ns, env.current_ns.?, n.refer_clojure_exclude, n.refer_clojure_only);
-        }
+        // Row 14.7 (D-098): the `:exclude`/`:only` filter applies to
+        // clojure.core — the single auto-refer source (Zig builtins
+        // intern there directly per ADR-0171).
         if (env.findNs("clojure.core")) |cc_ns| {
-            // ADR-0035 D9 revision: clojure.core OVERRIDES rt on collision —
-            // the public layer's redefinition (e.g. matcher-arity re-find)
-            // wins over the internal primitive.
-            try env.referAllOverriding(cc_ns, env.current_ns.?, n.refer_clojure_exclude, n.refer_clojure_only);
+            try env.referAllWithFilter(cc_ns, env.current_ns.?, n.refer_clojure_exclude, n.refer_clojure_only);
         }
     }
     // Row 14.7 (D-098): walk ns-level (:require [...]) libspecs. Each

src/eval/backend/tree_walk.zig

@@ -1207,19 +1207,16 @@ inline fn stepOnce(
             // ADR-0035 D9 second amendment + ADR-0036 dual-
             // backend parity contract. Mirror of post-T3
             // tree_walk::evalNs when `refer_clojure = true`.
-            // op_in_ns logic + referAll(rt) + referAll(clojure.core).
+            // op_in_ns logic + referAll(clojure.core) — the single
+            // core surface per ADR-0171.
             if (instr.operand >= chunk.constants.len)
                 return raiseInternal("vm: op_ns_with_refer_clojure constant index out of range");
             const name_val = chunk.constants[instr.operand];
             if (!name_val.isString())
                 return raiseInternal("vm: op_ns_with_refer_clojure constant is not a String");
             env.setCurrentNs(try env.findOrCreateNs(string_mod.asString(name_val)));
-            if (env.findNs("rt")) |rt_ns| {
-                try env.referAll(rt_ns, env.current_ns.?);
-            }
             if (env.findNs("clojure.core")) |clojure_core_ns| {
-                // ADR-0035 D9 revision: clojure.core overrides rt on collision.
-                try env.referAllOverriding(clojure_core_ns, env.current_ns.?, &.{}, null);
+                try env.referAll(clojure_core_ns, env.current_ns.?);
             }
             if (sp >= stack.len)
                 return raiseInternal("vm: operand stack overflow");
@@ -1229,7 +1226,7 @@ inline fn stepOnce(
         .op_ns_with_filter => {
             // D-098: mirror of tree_walk::evalNs's refer-clojure branch
             // with the `:exclude`/`:only` filter. Enter the ns, apply the
-            // docstring meta (D-239 sibling), then refer rt + clojure.core
+            // docstring meta (D-239 sibling), then refer clojure.core
             // through referAllWithFilter (skipped when the ns form had no
             // refer-clojure step — the entry's flag).
             if (instr.operand >= chunk.ns_filters.len)
@@ -1244,12 +1241,8 @@ inline fn stepOnce(
             }
             if (f.doc) |d| try meta_mod.setNsDoc(rt, env.current_ns.?, d);
             if (f.refer_clojure) {
-                if (env.findNs("rt")) |rt_ns| {
-                    try env.referAllWithFilter(rt_ns, env.current_ns.?, f.exclude, f.only);
-                }
                 if (env.findNs("clojure.core")) |clojure_core_ns| {
-                    // ADR-0035 D9 revision: clojure.core overrides rt on collision.
-                    try env.referAllOverriding(clojure_core_ns, env.current_ns.?, f.exclude, f.only);
+                    try env.referAllWithFilter(clojure_core_ns, env.current_ns.?, f.exclude, f.only);
                 }
             }
             if (sp >= stack.len)

src/eval/backend/vm.zig

@@ -75,7 +75,7 @@ const tree_walk = @import("../backend/tree_walk.zig");
 const Function = tree_walk.Function;
 
 pub const MAGIC: [4]u8 = .{ 'C', 'L', 'J', 'W' };
-pub const VERSION: u16 = 5; // v5: NsFilterEntry attr_const (D-554); v4: doc + refer_clojure
+pub const VERSION: u16 = 6; // v6: rt ns merged into clojure.core (ADR-0171) — pre-v6 archives bake "rt" var_refs that no longer resolve; v5: NsFilterEntry attr_const (D-554)
 
 pub const SerializeError = error{
     OutOfMemory,

src/eval/bytecode/serialize.zig

@@ -610,7 +610,7 @@ pub const Reader = struct {
         return Form{ .data = .{ .list = items }, .location = loc };
     }
 
-    /// `@x` reader macro → `(rt/deref x)` (mirrors `readQuote`). The `deref`
+    /// `@x` reader macro → `(clojure.core/deref x)` (mirrors `readQuote`). The `deref`
     /// symbol is NS-QUALIFIED so a local `deref` binding cannot capture it:
     /// `(let [deref f] @a)` derefs `a`, not calls `f` (clj hygiene, which uses
     /// `clojure.core/deref`). cljw qualifies to the `rt` primitive ns — the
@@ -627,7 +627,7 @@ pub const Reader = struct {
             return error_catalog.raise(.eof_unexpected, loc, .{});
 
         const items = self.allocator.alloc(Form, 2) catch return error.OutOfMemory;
-        items[0] = Form{ .data = .{ .symbol = .{ .ns = "rt", .name = "deref" } }, .location = loc };
+        items[0] = Form{ .data = .{ .symbol = .{ .ns = "clojure.core", .name = "deref" } }, .location = loc };
         items[1] = inner;
         return Form{ .data = .{ .list = items }, .location = loc };
     }