@@ -858,3 +858,17 @@ accepted:
       a closed set.
     derives_from: "ADR-0171 (rt merge — internals need a public qualified home for macro expansions) + ADR-0059 no-JVM (cljw owns the cljw.* namespace surface) + F-011 (every public var's home ns now MATCHES clj; only the extra internal ns is cljw-specific)."
     pin: "test/e2e/phase15_namespace.sh — `ad053-internal-ns` locks (find-ns 'cljw.internal) present, `ad053-rt-gone` locks the old `rt` ns absent, `ad053-no-leak` locks __-internals out of clojure.core's publics."
+  - id: "AD-054"
+    summary: "Class-name completion (nREPL `completions` on an uppercase / dotted prefix) offers cljw's CLOSED class universe — the `rt.types` registry (host surfaces, deftypes, the java.lang/java.math default imports) — where mainline scans the whole JVM classpath and leaks internal classes (`java.lang.CharacterData00`, `sun.nio.cs.ext.Big5`, …)."
+    example: "prefix \"Character\" => cljw [Character, java.lang.Character] / mainline additionally java.lang.CharacterData00…, com.sun.… (26 candidates). Every cljw candidate resolves; the mainline extras are not even loadable classes for user code."
+    why: |-
+      cljw has no classpath and no JVM-internal classes to enumerate
+      (ADR-0059); its class universe IS the rt.types registry, which is
+      exactly the set `resolveJavaSurface` resolves — completion never
+      offers a class name that would not resolve (a stronger guarantee than
+      mainline's, whose classpath scan surfaces package-private internals
+      user code cannot construct). Faking the JVM-internal names would be a
+      lie with zero utility. The completion fixtures therefore assert
+      cljw ⊆ mainline + a curated MUST list for class groups, not equality.
+    derives_from: "ADR-0059 no-JVM (no classpath, no JVM-internal classes) + ADR-0029/ADR-0050 (rt.types is the closed host-class SSOT; resolveJavaSurface defines reachability) + F-011 (every class a user can actually USE completes identically; only the un-usable classpath leak differs)."
+    pin: "test/e2e/phase14_nrepl_completion.sh — classes|Character / classes|Big subset assertions + the MUST-NOT java.lang.CharacterData00 lock (cljw never fakes the leak)."
@@ -50,13 +50,23 @@
   `__`-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).
+- **COMPLETION PARITY LANDED (2026-07-16)**: nREPL `completions` now
+  carries the built-in's sources — special forms + literals, vars
+  (dash-fuzzy `ma-i`→`map-indexed`), namespaces/aliases (dot-fuzzy),
+  classes (closed rt.types universe via the shared
+  `runtime/host_class_resolve.zig`; **AD-054** pins the
+  no-classpath-leak divergence), `Class/` static members
+  (camelCase-aware — the require-less java-interop ask), interned
+  keywords — by-name sorted. Fixture-driven e2e
+  `phase14_nrepl_completion` (23 probes, JVM-free; capture/audit =
+  `scripts/completion_oracle.py`). Character gained isEmoji×6 (UCD
+  emoji-data.txt via the generator) + isJavaLetter(OrDigit); statics
+  126/128 (out: TYPE by design, codePointOf = D-561). Var-existence
+  gaps mainline completion shows (defmacro-as-var /
+  default-data-readers / definline / defstruct) → the D-562 inventory.
+- **ARC (user-directed 2026-07-15, the landing point)**: (1) completion
+  parity — DONE. (2) AD full inventory + convergence (**D-562**) —
+  NEXT. (3) THEN cut a release tag.
 - **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
 
@@ -178,7 +178,7 @@ tiers:
         # 16.0.0 tables; corpus test/diff/clj_corpus/character.txt locks
         # clj parity). getName is explicit-unsupported (D-561). Instance
         # methods on .char: charValue / compareTo (+ universal Object).
-        methods: [isDigit, isLetter, isLetterOrDigit, isWhitespace, isUpperCase, isLowerCase, isTitleCase, isSpaceChar, isDefined, isMirrored, isIdeographic, isAlphabetic, isJavaIdentifierStart, isJavaIdentifierPart, isUnicodeIdentifierStart, isUnicodeIdentifierPart, isIdentifierIgnorable, toUpperCase, toLowerCase, toTitleCase, digit, getNumericValue, getType, getDirectionality, forDigit, codePointAt, codePointBefore, codePointCount, offsetByCodePoints, toChars, toString, charCount, isSurrogate, isHighSurrogate, isLowSurrogate, isISOControl, isBmpCodePoint, isValidCodePoint, isSupplementaryCodePoint, highSurrogate, lowSurrogate, toCodePoint, isSurrogatePair, hashCode, compare, valueOf, isSpace, reverseBytes]
+        methods: [isDigit, isLetter, isLetterOrDigit, isWhitespace, isUpperCase, isLowerCase, isTitleCase, isSpaceChar, isDefined, isMirrored, isIdeographic, isAlphabetic, isJavaIdentifierStart, isJavaIdentifierPart, isJavaLetter, isJavaLetterOrDigit, isUnicodeIdentifierStart, isUnicodeIdentifierPart, isIdentifierIgnorable, isEmoji, isEmojiPresentation, isEmojiModifier, isEmojiModifierBase, isEmojiComponent, isExtendedPictographic, toUpperCase, toLowerCase, toTitleCase, digit, getNumericValue, getType, getDirectionality, forDigit, codePointAt, codePointBefore, codePointCount, offsetByCodePoints, toChars, toString, charCount, isSurrogate, isHighSurrogate, isLowSurrogate, isISOControl, isBmpCodePoint, isValidCodePoint, isSupplementaryCodePoint, highSurrogate, lowSurrogate, toCodePoint, isSurrogatePair, hashCode, compare, valueOf, isSpace, reverseBytes]
         static_fields: [MIN_VALUE, MAX_VALUE, MIN_RADIX, MAX_RADIX, SIZE, BYTES, MIN_CODE_POINT, MAX_CODE_POINT, MIN_SUPPLEMENTARY_CODE_POINT, MIN_HIGH_SURROGATE, MAX_HIGH_SURROGATE, MIN_LOW_SURROGATE, MAX_LOW_SURROGATE, MIN_SURROGATE, MAX_SURROGATE, UNASSIGNED, UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER, OTHER_LETTER, NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK, DECIMAL_DIGIT_NUMBER, LETTER_NUMBER, OTHER_NUMBER, SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, PRIVATE_USE, SURROGATE, DASH_PUNCTUATION, START_PUNCTUATION, END_PUNCTUATION, CONNECTOR_PUNCTUATION, OTHER_PUNCTUATION, MATH_SYMBOL, CURRENCY_SYMBOL, MODIFIER_SYMBOL, OTHER_SYMBOL, INITIAL_QUOTE_PUNCTUATION, FINAL_QUOTE_PUNCTUATION, DIRECTIONALITY_UNDEFINED, DIRECTIONALITY_LEFT_TO_RIGHT, DIRECTIONALITY_RIGHT_TO_LEFT, DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, DIRECTIONALITY_EUROPEAN_NUMBER, DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, DIRECTIONALITY_ARABIC_NUMBER, DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, DIRECTIONALITY_NONSPACING_MARK, DIRECTIONALITY_BOUNDARY_NEUTRAL, DIRECTIONALITY_PARAGRAPH_SEPARATOR, DIRECTIONALITY_SEGMENT_SEPARATOR, DIRECTIONALITY_WHITESPACE, DIRECTIONALITY_OTHER_NEUTRALS, DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING, DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE, DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING, DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE, DIRECTIONALITY_POP_DIRECTIONAL_FORMAT, DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE, DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE, DIRECTIONALITY_FIRST_STRONG_ISOLATE, DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE]
         clojure_peer_vars: []
       - fqn: java.lang.Math
 
@@ -57,9 +57,15 @@
     "Other_ID_Start", "Other_ID_Continue", "Ideographic",
 ]
 
+# UCD emoji/emoji-data.txt properties (JVM Character.isEmoji* family).
+EMOJI_PROPS = [
+    "Emoji", "Emoji_Presentation", "Emoji_Modifier",
+    "Emoji_Modifier_Base", "Emoji_Component", "Extended_Pictographic",
+]
+
 
 def fetch(name: str) -> str:
-    cache = Path(f"/tmp/ucd_{UCD_VERSION}_{name}")
+    cache = Path(f"/tmp/ucd_{UCD_VERSION}_{name.replace('/', '_')}")
     if cache.exists():
         return cache.read_text()
     print(f"downloading {name} …", file=sys.stderr)
@@ -205,9 +211,10 @@ def numeric_others(rows):
     return sorted(out)
 
 
-def parse_prop_list(text: str):
-    """{prop_name: [(lo,hi),...]} for the PROPS subset of PropList.txt."""
-    props = {p: [] for p in PROPS}
+def parse_prop_list(text: str, wanted=None):
+    """{prop_name: [(lo,hi),...]} for the wanted subset of a
+    range;prop-format UCD file (PropList.txt / emoji-data.txt)."""
+    props = {p: [] for p in (wanted or PROPS)}
     for line in text.splitlines():
         line = line.split("#", 1)[0].strip()
         if not line:
@@ -261,7 +268,7 @@ def table(name, ranges):
         f"    .{{ .lo = 0x{lo:X}, .hi = 0x{hi:X}, .v = {v} }}," for lo, hi, v in bidi_tagged
     )
     prop_tables = "\n\n".join(
-        table(f"PROP_{p.upper()}", props[p]) for p in PROPS
+        table(f"PROP_{p.upper()}", props[p]) for p in (PROPS + EMOJI_PROPS)
     )
     mirrored_table = table("BIDI_MIRRORED", mirrored)
     dec_rows = "\n".join(
@@ -374,14 +381,21 @@ def table(name, ranges):
     return inRanges(&BIDI_MIRRORED, cp);
 }}
 
-/// The contributory properties the JVM classification formulas reference.
+/// The contributory properties the JVM classification formulas reference,
+/// plus the emoji/emoji-data.txt properties (Character.isEmoji* family).
 pub const Prop = enum {{
     other_uppercase,
     other_lowercase,
     other_alphabetic,
     other_id_start,
     other_id_continue,
     ideographic,
+    emoji,
+    emoji_presentation,
+    emoji_modifier,
+    emoji_modifier_base,
+    emoji_component,
+    extended_pictographic,
 }};
 
 /// True iff `cp` carries the PropList.txt contributory property.
@@ -393,6 +407,12 @@ def table(name, ranges):
         .other_id_start => &PROP_OTHER_ID_START,
         .other_id_continue => &PROP_OTHER_ID_CONTINUE,
         .ideographic => &PROP_IDEOGRAPHIC,
+        .emoji => &PROP_EMOJI,
+        .emoji_presentation => &PROP_EMOJI_PRESENTATION,
+        .emoji_modifier => &PROP_EMOJI_MODIFIER,
+        .emoji_modifier_base => &PROP_EMOJI_MODIFIER_BASE,
+        .emoji_component => &PROP_EMOJI_COMPONENT,
+        .extended_pictographic => &PROP_EXTENDED_PICTOGRAPHIC,
     }};
     return inRanges(ranges, cp);
 }}
@@ -465,6 +485,12 @@ def table(name, ranges):
     try std.testing.expectEqual(@as(?i32, -2), numericValue(0xBD)); // ½
     try std.testing.expect(isMirrored('(') and isMirrored('<'));
     try std.testing.expect(!isMirrored('a'));
+    try std.testing.expect(hasProp(.emoji, 0x1F600)); // 😀
+    try std.testing.expect(hasProp(.emoji, '#')); // keycap base is Emoji
+    try std.testing.expect(!hasProp(.emoji_presentation, '#'));
+    try std.testing.expect(hasProp(.emoji_component, '#'));
+    try std.testing.expect(hasProp(.emoji_modifier, 0x1F3FB)); // skin tone
+    try std.testing.expect(hasProp(.extended_pictographic, 0x1F600));
 }}
 """
 
@@ -706,6 +732,7 @@ def main():
     cat_tagged = tagged_ranges(rows, 2, JVM_CAT)
     bidi_tagged = tagged_ranges(rows, 4, JVM_BIDI)
     props = parse_prop_list(fetch("PropList.txt"))
+    props.update(parse_prop_list(fetch("emoji/emoji-data.txt"), EMOJI_PROPS))
     dec = decimal_digits(rows)
     nums = numeric_others(rows)
     mirrored = mirrored_ranges(rows)
 
@@ -290,6 +290,16 @@ const CompletionCollector = struct {
         self.items.append(self.scratch, .{ .dict = entries }) catch return false;
         return true;
     }
+
+    fn candidateLessThan(_: void, a: bencode.Decoded, b: bencode.Decoded) bool {
+        return std.mem.order(u8, a.dict[0].value.str, b.dict[0].value.str) == .lt;
+    }
+
+    /// The nREPL built-in sorts its reply by candidate name
+    /// (`sort-by :candidate`); CIDER preserves server order.
+    fn sortByCandidate(self: *CompletionCollector) void {
+        std.mem.sort(bencode.Decoded, self.items.items, {}, candidateLessThan);
+    }
 };
 
 fn contextNs(ctx: *Ctx, sess: *session_mod.Session) ?*env_mod.Namespace {
@@ -305,15 +315,24 @@ fn opCompletions(ctx: *Ctx) anyerror!void {
     var collector = CompletionCollector{ .scratch = ctx.scratch };
     if (prefix.len > 0) {
         const ns = contextNs(ctx, sess);
-        if (std.mem.findScalar(u8, prefix, '/')) |slash| {
+        if (prefix[0] == ':') {
+            introspect.forEachKeyword(ctx.env.rt, ctx.scratch, prefix[1..], &collector, CompletionCollector.add);
+        } else if (std.mem.findScalar(u8, prefix, '/')) |slash| {
             collector.qualifier = prefix[0..slash];
             if (introspect.resolveQualifier(ctx.env, ns, prefix[0..slash])) |target| {
                 introspect.forEachNsVar(target, prefix[slash + 1 ..], &collector, CompletionCollector.add);
+            } else {
+                // Not a namespace/alias — a `Class/member` static prefix
+                // (`Character/BY` → Character/BYTES <sf>).
+                introspect.forEachStaticMember(ctx.env.rt, ns, prefix[0..slash], prefix[slash + 1 ..], &collector, CompletionCollector.add);
             }
         } else {
+            introspect.forEachSpecialForm(prefix, &collector, CompletionCollector.add);
             introspect.forEachUnqualified(ctx.env, ns, prefix, &collector, CompletionCollector.add);
+            introspect.forEachClass(ctx.env.rt, ns, prefix, &collector, CompletionCollector.add);
         }
     }
+    collector.sortByCandidate();
     try ctx.respond(&.{
         .{ .key = "completions", .value = .{ .list = collector.items.items } },
         .{ .key = "status", .value = try transport.statusValue(ctx.scratch, &.{"done"}) },
 
@@ -51,52 +51,16 @@ const type_descriptor_mod = @import("../../runtime/type_descriptor.zig");
 const TypeDescriptor = type_descriptor_mod.TypeDescriptor;
 
 /// Resolve a head namespace string from `(Class/method)` or `(Class. ...)`
-/// to a `*const TypeDescriptor` in `rt.types`. ADR-0029 D5 keys
-/// descriptors by their cljw-prefixed FQCN (e.g. `"cljw.java.util.UUID"`),
-/// but user source writes the JVM form (e.g. `"java.util.UUID"`). This
-/// helper bridges by trying, in order:
-///   1. Literal `rt.types.get(head)` (e.g. `"java.util.UUID"`; also a
-///      user `(deftype Math …)` shadowing the auto-import — local wins).
-///   2. `rt.types.get("cljw." ++ head)` for the Java prefix translation
-///      (`"java.util.UUID"` → `"cljw.java.util.UUID"`).
-///   3. `rt.types.get("cljw.java.lang." ++ head)` for the `java.lang.*`
-///      auto-import (ADR-0050 § R3): a bare class name like `Math` /
-///      `System` resolves the way JVM Clojure default-imports
-///      `java.lang.*` into every ns. Gated to dot-free heads so a
-///      qualified head (already handled by 1/2) is not re-probed.
-/// Returns `null` if none hit. `env` is read for the current ns's
-/// per-ns `(:import …)` simple-name map (D-235), checked before the
-/// always-on java.lang auto-import.
+/// to a `*const TypeDescriptor` in `rt.types`. The resolution rules
+/// (literal key → `cljw.` prefix → per-ns `(:import …)` map → java.lang
+/// auto-import → java.math Big* defaults) live in
+/// `runtime/host_class_resolve.zig`; `env` supplies the current ns for
+/// the import map (D-235).
 pub fn resolveJavaSurface(rt: *Runtime, env: *Env, head: []const u8) ?*const TypeDescriptor {
-    if (rt.types.get(head)) |td| return td;
-    var buf: [256]u8 = undefined;
-    const prefixed = std.fmt.bufPrint(&buf, "cljw.{s}", .{head}) catch return null;
-    if (rt.types.get(prefixed)) |td| return td;
-    if (std.mem.findScalar(u8, head, '.') == null) {
-        // A `(:import …)` simple name resolves to its FQCN first (D-235),
-        // before the always-on java.lang auto-import.
-        if (env.current_ns) |ns| {
-            if (ns.imports.get(head)) |fqcn| {
-                if (rt.types.get(fqcn)) |td| return td;
-                var ibuf: [256]u8 = undefined;
-                const iprefixed = std.fmt.bufPrint(&ibuf, "cljw.{s}", .{fqcn}) catch return null;
-                if (rt.types.get(iprefixed)) |td| return td;
-            }
-        }
-        var buf2: [256]u8 = undefined;
-        const auto = std.fmt.bufPrint(&buf2, "cljw.java.lang.{s}", .{head}) catch return null;
-        if (rt.types.get(auto)) |td| return td;
-        // Beyond java.lang.*, the JVM default-imports `java.math.BigDecimal` and
-        // `java.math.BigInteger` into every ns (Clojure inherits this). Mirror it
-        // so a bare `BigDecimal`/`BigInteger` resolves to its cljw.java.math
-        // surface (e.g. `BigDecimal/ROUND_FLOOR`, numeric-tower D-097/D-420).
-        if (std.mem.eql(u8, head, "BigDecimal") or std.mem.eql(u8, head, "BigInteger")) {
-            var buf3: [256]u8 = undefined;
-            const m = std.fmt.bufPrint(&buf3, "cljw.java.math.{s}", .{head}) catch return null;
-            if (rt.types.get(m)) |td| return td;
-        }
-    }
-    return null;
+    // Delegates to the shared runtime resolver so the completion surface
+    // (introspect.zig) and the analyzer can never drift: a class name
+    // completes exactly when it resolves here.
+    return @import("../../runtime/host_class_resolve.zig").resolve(rt, env.current_ns, head);
 }
 
 /// Lexical class-name resolution for `instance?`'s class argument, the
 
@@ -282,6 +282,27 @@ pub fn isIdentifierIgnorableCodepoint(cp: u21) bool {
     };
 }
 
+// JVM `Character.isEmoji*` family (JDK 21) — direct reads of the UCD
+// emoji-data.txt properties, generated alongside the contributory ones.
+pub fn isEmojiCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.emoji, cp);
+}
+pub fn isEmojiPresentationCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.emoji_presentation, cp);
+}
+pub fn isEmojiModifierCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.emoji_modifier, cp);
+}
+pub fn isEmojiModifierBaseCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.emoji_modifier_base, cp);
+}
+pub fn isEmojiComponentCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.emoji_component, cp);
+}
+pub fn isExtendedPictographicCodepoint(cp: u21) bool {
+    return unicode_category.hasProp(.extended_pictographic, cp);
+}
+
 /// JVM `Character.toUpperCase` mirror — the SIMPLE 1:1 Unicode map (D-057:
 /// ä→Ä, σ→Σ; ß stays ß — SpecialCasing 1:n belongs to STRING upper-case
 /// only, the JVM full-vs-simple split).