@@ -105,8 +105,8 @@ accepted:
     derives_from: "F-005 (numeric tower: auto-promote on overflow is the chosen cljw surface)"
     pin: "none — clj diverges (throws) by design; cljw's promote result is pinned by the D-165/overflow cycle's e2e (campaign C7, next session)"
   - id: "AD-009"
-    summary: "cljw carries ONE hash system: `(hash x)` (hasheq) is clj-PORTABLE for value types (2026-07-16 leaf-formula alignment), and `.hashCode` / format `%h` DELEGATE to it — where clj/JVM has a SECOND, Java-side `Object.hashCode` system (`(.hashCode \"abc\")` → 96354 ≠ `(hash \"abc\")` → 74834163) that cljw does not reproduce. Residual hasheq divergences: defrecord/deftype instances (per-run descriptor seed) and >i64 ratio/BigDecimal components."
-    example: '(hash "abc") => 74834163 BOTH ; (hash :user/k) / (hash 1/2) / (hash 1.5M) / (hash [1 2]) all match clj (corpus hash_compare.txt) ; (.hashCode "abc") => cljw 74834163 (= hash) / clj 96354 (Java String.hashCode) ; (hash (->Pt 1 2)) => cljw per-run / clj -1763326040'
+    summary: "cljw carries ONE hash system: `(hash x)` (hasheq) is clj-PORTABLE for value types incl. defrecords (2026-07-16 alignment), and `.hashCode` / format `%h` DELEGATE to it — where clj/JVM has a SECOND, Java-side `Object.hashCode` system (`(.hashCode \"abc\")` → 96354 ≠ `(hash \"abc\")` → 74834163) that cljw does not reproduce. Residual hasheq divergences: >i64 ratio/BigDecimal components; deftype stays identity-based."
+    example: '(hash "abc") => 74834163 BOTH ; (hash :user/k) / (hash 1/2) / (hash 1.5M) / (hash [1 2]) all match clj (corpus hash_compare.txt) ; (.hashCode "abc") => cljw 74834163 (= hash) / clj 96354 (Java String.hashCode) ; (hash (->Pt 1 2)) => -1763326040 BOTH (records joined 2026-07-16)'
     why: |-
       The 2026-07-16 D-562 sweep aligned every leaf hasheq formula with clj:
       strings (Murmur3.hashInt over Java String.hashCode), keywords/symbols
@@ -120,11 +120,13 @@ accepted:
       JVM's SECOND hash system — `Object.hashCode` (Java 31-fold String
       hash, per-class formulas, identity hashes) — `(.hashCode x)` and
       format `%h`/`%H` delegate to the single hasheq (D-207/D-216).
-      Residual hasheq gaps: defrecord/deftype hasheq seeds on the per-run
-      descriptor pointer (clj XORs the ns-qualified record-name hash — the
-      AD-035 ns-qualification residual would unlock parity), and ratio /
-      BigDecimal components beyond i64 keep the cljw-native managed hash.
-    derives_from: "ADR-0059 (no-JVM: no second Object.hashCode system, no identity hashes) + F-011 (the observable `(hash x)` values now MATCH clj for data; the single-hash delegation is the internal-representation freedom) + AD-028 (the mapHash/mapHasheq sibling) + AD-035 (the record-name residual)."
+      Residual hasheq gaps: ratio / BigDecimal components beyond i64 keep
+      the cljw-native managed hash, and a bare-registered descriptor with
+      no defining ns (unit-test contexts) keeps the descriptor-pointer
+      seed. defrecord instances joined parity 2026-07-16 (the D-563(a)
+      ns-qualification: type-hash XOR mapHasheq, corpus
+      records_method_values.txt).
+    derives_from: "ADR-0059 (no-JVM: no second Object.hashCode system, no identity hashes) + F-011 (the observable `(hash x)` values now MATCH clj for data; the single-hash delegation is the internal-representation freedom) + AD-028 (the mapHash/mapHasheq sibling)."
     pin: "test/diff/clj_corpus/hash_compare.txt — 30+ `(hash …)` golden values locked against real clj across every aligned type; test/diff/clj_corpus/object_methods.txt — `(= (.hashCode \"abc\") (hash \"abc\"))` → true (single-system delegation locked); test/e2e/phase14_format.sh — `%h` lowercase-hex rendering."
   - id: "AD-010"
     summary: "a Namespace value prints as `#object[Namespace \"<name>\"]` (no JVM class FQN, no `0xADDR` identity hash)"
@@ -511,24 +513,6 @@ accepted:
       locks. See ADR-0152 (the conscious election + the DA's seq_cst analysis).
     derives_from: "ADR-0152 (uniform acquire/release volatile-grade ordering) — JMM volatile = seq_cst across volatile accesses; cljw's acquire/release omits the IRIW cross-cell total order. Substrate: atom.zig/volatile.zig/iref.zig/agent.zig + the D-444 deftype field path."
     pin: "test/e2e/phase14_deftype_mutable.sh — the :volatile-mutable field increments correctly (the by-construction half: the field IS atomic acquire/release; the IRIW gap itself is non-deterministic + untestable)"
-  - id: "AD-035"
-    summary: "A defrecord prints with its SIMPLE name (`#R{:x 1, :y 2}`), not clj's namespace-qualified `#user.R{:x 1, :y 2}`."
-    example: '(pr-str (->R 1 2)) => cljw "#R{:x 1, :y 2}" / clj "#user.R{:x 1, :y 2}" ; with extras: cljw "#R{:x 1, :y 2, :z 9}" / clj "#user.R{:x 1, :y 2, :z 9}"'
-    why: |-
-      cljw registers a defrecord/deftype by its SIMPLE name (the descriptor's
-      `fqcn` is `R`, not `user.R`) — the same no-JVM-Class simple-name surface
-      AD-003 records for `(class x)`. clj prints a record reader-tag qualified by
-      its defining namespace because the JVM record class IS `user.R`; cljw has
-      no defining-ns on the descriptor (ADR-0059, no JVM Class hierarchy), so it
-      prints the simple name it actually carries. The record CONTENT (declared
-      fields + extmap entries, in declared-then-extmap order) is byte-identical
-      to clj modulo this prefix — verified across assoc/dissoc/get/keys/vals/
-      count/seq/merge/select-keys/find/update/assoc-in/reduce-kv (D-086). Adding
-      the ns prefix would require threading a defining-ns through every record
-      descriptor purely for the print fiction, contradicting the AD-003 simple-
-      name policy for no behavioural gain.
-    derives_from: "ADR-0059 (no-JVM Class hierarchy) + AD-003 (simple class name, not FQCN); no_jvm_specific_assumption.md. Records carry only a simple `fqcn`, so the printer emits `#<simple>{…}`."
-    pin: "test/e2e/phase9_record_extmap.sh — record_extmap_print locks cljw's `#R{:x 1, :y 2, :z 9}` (simple name, no `user.` prefix)"
   - id: "AD-036"
     summary: "The 2-arg array ctors `(byte-array size n)` / `(short-array size n)` / `(char-array size n)` FILL with a number init; clj throws (`IllegalArgumentException`, 'Don't know how to create ISeq from: java.lang.Long') because the JVM `Numbers` overload for those element types has no number-fill branch."
     example: "(vec (byte-array 3 65)) => cljw [65 65 65] / clj THROWS ; (int (aget (char-array 3 65) 0)) => cljw 65 / clj THROWS ; matching cases agree: (vec (int-array 5 7)) => [7 7 7 7 7], (vec (byte-array 3 [1 2])) => [1 2 0]"
 
@@ -28,14 +28,18 @@ active:
     status: |-
       open (2026-07-16, the D-562 inventory's enumerated residuals — each
       verified against real clj this cycle, deferred with a named reason):
-      (a) **defrecord ns-qualified identity** — clj prints `#user.Pt{…}`
-      (readable, reader-constructible) and hashes records as
-      (ns-qualified-name-hash XOR map-hasheq); cljw's descriptor carries
-      only the simple name, so print shows `#Pt{…}` (AD-035) and record
-      hasheq seeds on the per-run descriptor pointer (AD-009 residual).
-      Discharge = store the defining ns on the deftype/defrecord
-      TypeDescriptor, print qualified, hash per clj's formula — one
-      descriptor change unlocks both.
+      (a) DISCHARGED 2026-07-16 — defrecord ns-qualified identity landed:
+      TypeDescriptor carries defining_ns + a precomputed record_type_hash;
+      records print `#user.Pt{…}`, the READER constructs them back
+      (`#ns.Name{…}` → recordFromMap), and record hasheq matches clj
+      (type-hash XOR mapHasheq; corpus records_method_values.txt,
+      AD-035 retired as parity). deftype `(class …)` naming stays simple
+      (AD-003/044 scope — revisit only with a consumer).
+      (a2) NEW: Clojure 1.12 METHOD VALUES — the static form
+      (`(every? Character/isWhitespace s)`, brew-user report 2026-07-16)
+      landed via the analyzer's Java-surface value-position branch; the
+      `Class/.instanceMethod` and `Class/new` 1.12 forms are NOT yet
+      carried (implement when a consumer appears; same branch extends).
       (b) **Var source meta** — clj vars carry :line/:file/:column from
       the compiler; cljw def sites know their SourceLocation but drop it.
       Adding it converges `(meta #'x)` and clojure.test's
 
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Send eval(s) to a running cljw/clj nREPL server — the quick debug tool.
+
+Usage:
+  python3 scripts/nrepl_send.py 7888 "(+ 1 2)"
+  python3 scripts/nrepl_send.py 7888 -            # read code from stdin
+  python3 scripts/nrepl_send.py 7888 --op describe
+  python3 scripts/nrepl_send.py 7888 --op completions --prefix "Char" [--ns user]
+
+Prints every response dict the server sends for the request (value / out /
+err / status), so a REPL-only failure ("works in CLI, breaks over nREPL")
+is reproducible outside the editor. NOTE: "eval" here is the nREPL wire
+OP name — evaluation happens in the TARGET nREPL server the caller
+already controls; this script never eval()s anything locally. Uses the shared bencode client
+(scripts/nrepl_bencode.py); no dependencies beyond python3.
+"""
+import argparse
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from nrepl_bencode import NreplClient
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("port", type=int)
+    ap.add_argument("code", nargs="?", help="code to eval; '-' reads stdin")
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--op", default="eval", help="nREPL op (default eval)")
+    ap.add_argument("--prefix", help="completions prefix")
+    ap.add_argument("--ns", help="ns for the op")
+    ap.add_argument("--sym", help="lookup/eldoc symbol")
+    args = ap.parse_args()
+
+    cl = NreplClient(args.host, args.port)
+    try:
+        cl.clone()
+        msg = {"op": args.op}
+        if args.op == "eval":
+            code = args.code or "-"
+            msg["code"] = sys.stdin.read() if code == "-" else code
+        elif args.code:
+            msg["code"] = args.code
+        if args.prefix is not None:
+            msg["prefix"] = args.prefix
+        if args.ns is not None:
+            msg["ns"] = args.ns
+        if args.sym is not None:
+            msg["sym"] = args.sym
+        for r in cl.request(msg):
+            print(r)
+    finally:
+        cl.close()
+
+
+if __name__ == "__main__":
+    main()
@@ -698,6 +698,14 @@ fn analyzeSymbol(
                 // per-Runtime value at analyze time (handled inside the helper).
                 return try makeConstant(arena, try staticFieldValue(env.rt, sf), form);
             }
+            // Clojure 1.12 METHOD VALUES: a bare `Class/method` in value
+            // position is the static method as a first-class fn —
+            // `(every? Character/isWhitespace s)`. The host surface's
+            // method_val already IS a callable builtin Value, so the
+            // symbol lifts to that constant directly.
+            if (td.lookupMethod(null, sym.name)) |me| {
+                return try makeConstant(arena, me.method_val, form);
+            }
         }
         // ADR-0113: an unresolved `clojure.lang.*` / `clojure.asm.*` qualified
         // reference is a JVM-internal class cljw has no value for (ADR-0059) —
@@ -1246,6 +1254,27 @@ fn vectorFormToValue(rt: *Runtime, env: *Env, items: []const Form) AnalyzeError!
 fn liftTagged(rt: *Runtime, env: *Env, t: TaggedForm, loc: SourceLocation) AnalyzeError!Value {
     const inner = try formToValue(rt, env, t.form.*);
 
+    // clj reads `#ns.Name{…}` as a RECORD constructor (the qualified
+    // record print form round-trips through the reader). A dotted tag is
+    // resolved against rt.types by its simple name; the descriptor must
+    // be a defrecord whose defining ns matches the tag's prefix.
+    if (t.tag.ns == null) {
+        if (std.mem.findScalarLast(u8, t.tag.name, '.')) |dot| {
+            const simple = t.tag.name[dot + 1 ..];
+            if (rt.types.get(simple)) |td| {
+                const matches_ns = td.defining_ns != null and
+                    std.mem.eql(u8, td.defining_ns.?, t.tag.name[0..dot]);
+                const map_arg = inner.tag() == .array_map or inner.tag() == .hash_map;
+                if (td.kind == .defrecord and matches_ns and map_arg) {
+                    return type_descriptor.recordFromMap(rt, td, inner) catch |e| switch (e) {
+                        error.OutOfMemory => error.OutOfMemory,
+                        else => error_catalog.raise(.reader_tag_unknown, loc, .{ .tag = symFullName(t.tag) }),
+                    };
+                }
+            }
+        }
+    }
+
     if (rt.data_readers_var) |dr_opaque| {
         const dr_var: *const env_mod.Var = @ptrCast(@alignCast(dr_opaque));
         const table = dr_var.deref();
 
@@ -1419,7 +1419,7 @@ test "every wire ValueTag has BOTH a write and a read arm (symmetry gate)" {
             .fn_val => try tree_walk.allocFunctionFromSerialized(&rt, 0, &[_]tree_walk.SerializedMethod{}, null),
             .type_descriptor => blk: {
                 const td_mod = @import("../../runtime/type_descriptor.zig");
-                const td = try td_mod.registerType(&rt, "SymGateType", &.{}, &.{}, .deftype);
+                const td = try td_mod.registerType(&rt, "SymGateType", null, &.{}, &.{}, .deftype);
                 break :blk try td_mod.makeTypeDescriptorRef(&rt, td);
             },
         };
@@ -1455,7 +1455,7 @@ test "type_descriptor constant round-trips by name (ADR-0034 am5; D-452)" {
     const type_descriptor = @import("../../runtime/type_descriptor.zig");
     // The defining chunk has run by load time → the type is registered. Mirror
     // that here by registering BEFORE deserialize.
-    const td = try type_descriptor.registerType(&rt, "ZipLoc", &.{}, &.{}, .defrecord);
+    const td = try type_descriptor.registerType(&rt, "ZipLoc", null, &.{}, &.{}, .defrecord);
     const ref = try type_descriptor.makeTypeDescriptorRef(&rt, td);
 
     const consts = [_]Value{ Value.initInteger(1), ref };
@@ -1575,7 +1575,7 @@ test "chunk completeness gate: every side-table + entry field round-trips (D-365
     // A registered host class so the static-dispatch descriptor re-resolves at
     // deserialize (resolveJavaSurface(rt, env, fqcn) returns this rt.types entry;
     // freeChunk does NOT free `descriptor`, which rt.types owns → no double-free).
-    const int_td = try type_descriptor.registerType(&rt, "java.lang.Integer", &.{}, &.{}, .native);
+    const int_td = try type_descriptor.registerType(&rt, "java.lang.Integer", null, &.{}, &.{}, .native);
 
     const call_sites = [_]CallSiteEntry{
         // instance dispatch (descriptor null, field_only false)
 
@@ -27,7 +27,6 @@ const protocol_mod = @import("../../runtime/protocol.zig");
 const symbol_mod = @import("../../runtime/symbol.zig");
 const string_mod = @import("../../runtime/collection/string.zig");
 const vector_mod = @import("../../runtime/collection/vector.zig");
-const map_mod = @import("../../runtime/collection/map.zig");
 const td_mod = @import("../../runtime/type_descriptor.zig");
 const keyword_mod = @import("../../runtime/keyword.zig");
 const host_interface = @import("../../runtime/host_interface.zig");
@@ -335,8 +334,8 @@ pub fn nativeType(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocat
 /// JVM reference: clojure.core/defrecord in clojure/core_deftype.clj L387.
 /// cw v1 tier: A (row 7.4 cycle 2 — descriptor kind landed).
 pub fn defrecordPrim(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
-    _ = env;
-    return registerTypePrim(rt, args, loc, .defrecord, "__defrecord!");
+    const dns: ?[]const u8 = if (env.current_ns) |ns| ns.name else null;
+    return registerTypePrim(rt, dns, args, loc, .defrecord, "__defrecord!");
 }
 
 /// `(rt/__map->record TypeRef m)` — clj's `Record/create`: build a defrecord
@@ -357,27 +356,8 @@ pub fn mapToRecordPrim(rt: *Runtime, env: *Env, args: []const Value, loc: Source
     if (args[0].tag() != .type_descriptor)
         return error_catalog.raise(.type_arg_invalid, loc, .{ .fn_name = "map->record", .expected = "record type", .actual = @tagName(args[0].tag()) });
     const td = td_mod.asTypeDescriptorRef(args[0]);
-    const m = args[1];
-    const layout = td.field_layout orelse &[_]td_mod.TypeDescriptor.FieldEntry{};
-    // Declared field values, by keyword (nil when `m` lacks the key / is nil).
-    const fields = try rt.gpa.alloc(Value, layout.len);
-    defer rt.gpa.free(fields);
-    for (layout, 0..) |fe, i| {
-        const kw = try keyword_mod.intern(rt, null, fe.name);
-        fields[i] = if (!m.isNil() and try map_mod.contains(m, kw)) try map_mod.get(m, kw) else Value.nil_val;
-    }
-    // extmap = `m` minus the declared keys, normalized to nil when empty so the
-    // result `=`/hashes as a plain (no-extras) record would.
-    var ext: Value = Value.nil_val;
-    if (!m.isNil()) {
-        ext = m;
-        for (layout) |fe| {
-            const kw = try keyword_mod.intern(rt, null, fe.name);
-            ext = try map_mod.dissoc(rt, ext, kw);
-        }
-        if (map_mod.count(ext) == 0) ext = Value.nil_val;
-    }
-    return td_mod.allocInstanceFull(rt, td, fields, Value.nil_val, ext);
+    // Construction core shared with the record-literal reader (D-563(a)).
+    return td_mod.recordFromMap(rt, td, args[1]);
 }
 
 /// `(rt/__deftype! 'Name ['field-syms...])` — register a fresh
@@ -389,8 +369,8 @@ pub fn mapToRecordPrim(rt: *Runtime, env: *Env, args: []const Value, loc: Source
 /// Implements clojure.core/deftype registration (JVM reference:
 /// clojure.core/deftype in clojure/core_deftype.clj). cw v1 tier: A.
 pub fn deftypePrim(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
-    _ = env;
-    return registerTypePrim(rt, args, loc, .deftype, "__deftype!");
+    const dns: ?[]const u8 = if (env.current_ns) |ns| ns.name else null;
+    return registerTypePrim(rt, dns, args, loc, .deftype, "__deftype!");
 }
 
 /// Shared registration body for `__defrecord!` / `__deftype!` — the two
@@ -400,6 +380,7 @@ pub fn deftypePrim(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLoca
 /// + downstream `extend-type` resolve `Name` to a usable Value.
 fn registerTypePrim(
     rt: *Runtime,
+    defining_ns: ?[]const u8,
     args: []const Value,
     loc: SourceLocation,
     kind: td_mod.TypeKind,
@@ -462,7 +443,7 @@ fn registerTypePrim(
         }
     }
 
-    const td = try td_mod.registerType(rt, name_sym.name, field_names, field_volatile, kind);
+    const td = try td_mod.registerType(rt, name_sym.name, defining_ns, field_names, field_volatile, kind);
     return td_mod.makeTypeDescriptorRef(rt, td);
 }