@@ -60,11 +60,15 @@ active:
       (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).
+      (a2) DISCHARGED 2026-07-17 — all three 1.12 method-value forms now
+      carried: statics (2026-07-16), `Class/.instanceMethod` (instance
+      method as receiver-first fn — the ADR-0174 merged tables made
+      cljw's method ABI already receiver-first, so `method_val` IS the
+      fn; native-backed classes fall back to the tag-keyed descriptor)
+      and `Class/new` (the `<init>` entry as a fn). analyzeSymbol lifts
+      the value; call heads fall through to analyzeCall. e2e: 6 cases on
+      phase14_host_class_identity (map String/.length, Thread/new,
+      StringBuilder chain, Date/new higher-order), clj-1.12-oracle-matched.
       (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
 
@@ -615,6 +615,31 @@ fn classValueKeyFor(name: []const u8) ?[]const u8 {
     return null;
 }
 
+/// Clojure 1.12 qualified method values (D-563 a2): `Class/.member` is the
+/// INSTANCE method as a receiver-first fn (`(map String/.length xs)`), and
+/// `Class/new` is the constructor as a fn (`(map java.util.Date/new ms)`).
+/// cljw's method ABI already takes the receiver as args[0], so the entry's
+/// `method_val` IS the fn value — no wrapper. For a native-backed class
+/// (String/Long/… — instance methods live on the tag-keyed native
+/// descriptor, not the static surface) fall back there. Returns null when
+/// the name is not one of the two forms or the member is absent (the
+/// caller's member-miss diagnostic then names the dotted spelling).
+fn qualifiedMemberValue(rt: *Runtime, td: *const type_descriptor.TypeDescriptor, class_head: []const u8, name: []const u8) ?Value {
+    if (std.mem.eql(u8, name, "new")) {
+        if (td.lookupMethod(null, "<init>")) |me| return me.method_val;
+        return null;
+    }
+    if (name.len > 1 and name[0] == '.') {
+        const mname = name[1..];
+        if (td.lookupMethod(null, mname)) |me| return me.method_val;
+        if (class_name.nativeTagFor(class_head)) |tag| {
+            const ntd = rt.nativeDescriptor(tag) catch return null;
+            if (ntd.lookupMethod(null, mname)) |me| return me.method_val;
+        }
+    }
+    return null;
+}
+
 /// Resolve a bare (dot-free) class name through the current ns's `(:import …)`
 /// map to its FQCN; qualified + unimported names pass through unchanged. Reuses
 /// `ns.imports` (D-235) — the same map `(Class. …)` consults — so an imported
@@ -743,6 +768,11 @@ fn analyzeSymbol(
         // the descriptor carries a static field of this name, the symbol
         // IS that constant — emit it directly (no Var resolution follows).
         if (special_forms.resolveJavaSurface(env.rt, env, ns_name)) |td| {
+            // 1.12 qualified method values: `Class/.member` (instance method
+            // as receiver-first fn) + `Class/new` (ctor as fn) — D-563 a2.
+            if (qualifiedMemberValue(env.rt, td, ns_name, sym.name)) |mv| {
+                return try makeConstant(arena, mv, form);
+            }
             if (td.lookupStaticField(sym.name)) |sf| {
                 // ADR-0087: a heap-singleton static field resolves to the live
                 // per-Runtime value at analyze time (handled inside the helper).
@@ -914,6 +944,11 @@ fn analyzeList(
                 if (td.lookupStaticField(head.name)) |sf| {
                     if (items.len == 1)
                         return try makeConstant(arena, try staticFieldValue(rt, sf), form);
+                } else if (qualifiedMemberValue(rt, td, ns_head, head.name) != null) {
+                    // 1.12 `(Class/.member recv …)` / `(Class/new …)` call
+                    // head: resolvable as a method value — fall through to
+                    // analyzeCall, whose head analysis (analyzeSymbol) lifts
+                    // the fn constant and the call applies it (D-563 a2).
                 } else if (!isDeferredHostNs(ns_head) and env.findNsOrAlias(ns_head) == null) {
                     // ADR-0174 D3: the class RESOLVED but has neither a method
                     // nor a static field of this name — raise the call-position
 
@@ -81,6 +81,15 @@ assert_eq 'def_shadows_class' "$(run '(def System 42) System' | tail -1)" '42'
 # --- user code sees a clean class value through higher-order use ---
 assert_eq 'group_by_class' "$(run '(contains? (group-by class [(java.util.Date. 0) (java.util.Date. 1)]) java.util.Date)')" 'true'
 
+# --- Clojure 1.12 qualified method values (D-563 a2): Class/.instanceMethod
+#     is the instance method as a receiver-first fn; Class/new is the ctor fn ---
+assert_eq 'qual_instance_call'  "$(run '(String/.length "abc")')" '3'
+assert_eq 'qual_instance_value' "$(run '(map String/.length ["a" "bb"])')" '(1 2)'
+assert_eq 'qual_instance_merged' "$(run '(java.util.Date/.getTime (java.util.Date. 42))')" '42'
+assert_eq 'ctor_value_class' "$(run '(class (Thread/new (fn [])))')" 'java.lang.Thread'
+assert_eq 'ctor_value_chain' "$(run '(StringBuilder/.toString (StringBuilder/new "hi"))')" '"hi"'
+assert_eq 'ctor_value_higher_order' "$(run '(map java.util.Date/new [1 2])')" '(#inst "1970-01-01T00:00:00.001-00:00" #inst "1970-01-01T00:00:00.002-00:00")'
+
 # --- ADR-0174 D4: Class is a first-class marker (clj: java.lang.Class) ---
 assert_eq 'class_of_class'      "$(run '(class Long)')" 'Class'
 assert_eq 'class_of_host_class' "$(run '(class (class (java.util.Date. 0)))')" 'Class'