@@ -24,11 +24,6 @@
 # md-table-align no longer pads it to ~800 KB of whitespace.
 
 active:
-  - id: "D-554"
-    status: "open (2026-07-06, split from D-239's discharge). The `(ns name {:attr-map} …)` ATTR-MAP and `(ns ^{:m 1} name)` name-symbol meta are still SKIPPED at analysis (special_forms.zig analyzeNs) — only the docstring lands as {:doc} ns meta. clj merges name-sym meta + attr-map + docstring into the ns meta. Rare vs the docstring (libs mostly use :author/:added attr-maps); needs a Form->Value map conversion at analysis + ADR-0169-style rooting OR an arena-thread of the literal into both backends (the doc rode NsFilterEntry as a plain string; a map needs a Value). Mechanise via phase15_ns_docstring e2e when landed."
-    category: "clj-parity"
-    barrier: "none hard — design choice: formToValue at analysis (needs AnalysisFrame rooting for the map Value in NsNode) vs re-analyzing the attr-map Form at execution. Take up easiest-first or on a lib whose ns attr-map meta is read programmatically."
-    last_reviewed: "2026-07-06"
   - id: "D-547"
     status: |-
       open (2026-07-01, NARROWED same day). Enforcement-honesty sweep — surfaced by the
@@ -6473,6 +6468,12 @@ discharged:
     barrier: "DISCHARGED (was: static-member gap catalog+fill, ADR-0166 row 5)."
     last_reviewed: "2026-07-07"
 
+  - id: "D-554"
+    status: "DISCHARGED 2026-07-07. The `(ns ^{…} name {:attr …})` ATTR-MAP and name-symbol reader meta now MERGE into the ns meta (attr wins over name-meta; an explicit docstring wins over an attr :doc — clj ns-macro merge order). The design barrier dissolved with D-556: the attr map is lifted at analysis via formToValue + pushAnalysisRoot, and production seams persist their AnalysisFrame roots (persisted_analysis_roots) for the arena's lifetime — so embedding the Value in NsNode is GC-safe with NO new rooting machinery. Both backends per ADR-0036: tree_walk evalNs -> meta.mergeNsMeta (new; over the new map.mergeInto); the VM rides the chunk literal pool (NsFilterEntry.attr_const u32 index, NO_ATTR sentinel; bytecode v5 with coverage-guard + round-trip asserts). e2e phase15_ns_docstring (7 cases incl. ns-attr-meta / ns-name-sym-meta); diff case diff-ns-attr; clj-oracle-verified ({:doc :author :added} + ^{:k 1} -> :k 1). ORIGINAL: split from D-239's discharge as the needs-a-Value-in-node residual."
+    category: "clj-parity"
+    barrier: "DISCHARGED (was: ns attr-map skipped at analysis)."
+    last_reviewed: "2026-07-07"
+
 conventions: |-
   - Structure: two top-level lists — `active:` and `discharged:`. Active entries carry id / status / category / barrier (+ optional quality_floor / last_reviewed); discharged entries carry id / discharged_at / resolution. Edit as YAML (no Markdown table to align).
   - New debt: grep `.dev/debt.yaml` for class-overlap before adding (per `.claude/rules/debt_dedup.md`).
 
@@ -1178,13 +1178,29 @@ pub fn analyzeNs(
     var i: usize = 2;
     // Optional docstring + attr-map after the name (clj: `(ns name doc? attrs?
     // refs*)`). The docstring lands as `{:doc …}` on the ns meta at execution
-    // (D-239 sibling); the attr-map is still skipped (D-554).
+    // (D-239 sibling); the attr-map and the name-symbol's `^{…}` reader meta
+    // merge into the ns meta too (D-554). The lifted map Values ride the
+    // AnalysisFrame → persisted_analysis_roots (D-556), matching the Node's
+    // arena lifetime, so embedding them in the NsNode is GC-safe.
     var doc: ?[]const u8 = null;
+    var attr_meta: Value = Value.nil_val;
+    if (name_form.meta) |meta_form| {
+        if (meta_form.data == .map) {
+            attr_meta = try analyzer_mod.formToValue(rt, env, meta_form.*);
+            try root_set.pushAnalysisRoot(attr_meta);
+        }
+    }
     if (i < items.len and items[i].data == .string) {
         doc = try arena.dupe(u8, items[i].data.string);
         i += 1;
     }
-    if (i < items.len and items[i].data == .map) i += 1;
+    if (i < items.len and items[i].data == .map) {
+        const m = try analyzer_mod.formToValue(rt, env, items[i]);
+        try root_set.pushAnalysisRoot(m);
+        // clj merges the attr-map OVER the name-symbol meta.
+        attr_meta = if (attr_meta.isNil()) m else map_collection.mergeInto(rt, attr_meta, m) catch return error.OutOfMemory;
+        i += 1;
+    }
     while (i < items.len) : (i += 1) {
         const directive = items[i];
         // D-299: clj accepts a list `(:require …)` OR a vector `[:require …]`
@@ -1229,6 +1245,7 @@ pub fn analyzeNs(
     n.* = .{ .ns_node = .{
         .name = ns_name,
         .doc = doc,
+        .attr_meta = attr_meta,
         .refer_clojure = refer_clojure,
         .refer_clojure_exclude = refer_clojure_exclude,
         .refer_clojure_only = refer_clojure_only,
 
@@ -567,7 +567,9 @@ fn evalInNs(env: *Env, n: node_mod.InNsNode) !Value {
 /// 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 "docstring" …)` → {:doc "…"} on the ns meta (D-239 sibling).
+    // `(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
 
@@ -1233,6 +1233,12 @@ inline fn stepOnce(
                 return raiseInternal("vm: op_ns_with_filter index out of range");
             const f = chunk.ns_filters[instr.operand];
             env.setCurrentNs(try env.findOrCreateNs(f.name));
+            // D-554: attr merge first, then the docstring (doc wins on :doc).
+            if (f.attr_const != opcode_mod.NsFilterEntry.NO_ATTR) {
+                if (f.attr_const >= chunk.constants.len)
+                    return raiseInternal("vm: op_ns_with_filter attr_const out of range");
+                try meta_mod.mergeNsMeta(rt, env.current_ns.?, chunk.constants[f.attr_const]);
+            }
             if (f.doc) |d| try meta_mod.setNsDoc(rt, env.current_ns.?, d);
             if (f.refer_clojure) {
                 if (env.findNs("rt")) |rt_ns| {
 
@@ -782,8 +782,9 @@ const Compiler = struct {
         // trailing op_pop drops the prior nil before the next push, leaving
         // exactly one nil (the ns form's value).
         const has_filter = n.refer_clojure_exclude.len > 0 or n.refer_clojure_only != null;
-        if (has_filter or n.libspecs.len > 0 or n.imports.len > 0 or n.doc != null) {
-            if (n.refer_clojure or n.doc != null) {
+        const has_attr = !n.attr_meta.isNil();
+        if (has_filter or n.libspecs.len > 0 or n.imports.len > 0 or n.doc != null or has_attr) {
+            if (n.refer_clojure or n.doc != null or has_attr) {
                 // A docstring rides the side-table entry too (D-239 sibling);
                 // the entry's `refer_clojure` keeps the no-refer shape honest.
                 if (self.ns_filters.items.len > std.math.maxInt(u16)) return Error.TooManyConstants;
@@ -797,7 +798,10 @@ const Compiler = struct {
                     break :blk od;
                 } else null;
                 const doc_dup: ?[]const u8 = if (n.doc) |d| try self.arena.dupe(u8, d) else null;
-                try self.ns_filters.append(self.arena, .{ .name = name_dup, .exclude = exclude_dup, .only = only_dup, .doc = doc_dup, .refer_clojure = n.refer_clojure });
+                // D-554: the lifted attr map rides the literal pool (index in
+                // the side-table entry) so the chunk stays serializable.
+                const attr_idx: u32 = if (has_attr) try self.addConstant(n.attr_meta) else NsFilterEntry.NO_ATTR;
+                try self.ns_filters.append(self.arena, .{ .name = name_dup, .exclude = exclude_dup, .only = only_dup, .doc = doc_dup, .refer_clojure = n.refer_clojure, .attr_const = attr_idx });
                 try self.emit(.op_ns_with_filter, filter_idx);
             } else {
                 const name_val = try string_mod.alloc(self.rt, n.name);
 
@@ -647,6 +647,12 @@ pub const NsFilterEntry = struct {
     /// False = the ns form had no refer-clojure step (rare); the op skips
     /// the rt/clojure.core refers but still applies name + doc.
     refer_clojure: bool = true,
+    /// D-554: chunk-constants index of the lifted `(ns ^{…} name {:attr …})`
+    /// meta map, or `NO_ATTR` when the form carried none. Riding the literal
+    /// pool keeps the entry serializable (a Value cannot live here).
+    attr_const: u32 = NO_ATTR,
+
+    pub const NO_ATTR: u32 = std.math.maxInt(u32);
 };
 
 /// Compiled bytecode for a single function or top-level form.
 
@@ -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 = 4; // v4: NsFilterEntry doc + refer_clojure (D-239 sibling)
+pub const VERSION: u16 = 5; // v5: NsFilterEntry attr_const (D-554); v4: doc + refer_clojure
 
 pub const SerializeError = error{
     OutOfMemory,
@@ -620,6 +620,8 @@ pub fn serializeChunk(allocator: std.mem.Allocator, chunk: BytecodeChunk) ![]u8
             try writeU8(w, 0);
         }
         try writeU8(w, if (nf.refer_clojure) 1 else 0);
+        // v5: attr-map constants index (D-554; NO_ATTR when absent).
+        try writeU32(w, nf.attr_const);
     }
     try writeU32(w, @intCast(chunk.ctor_sites.len));
     for (chunk.ctor_sites) |ct| {
@@ -754,7 +756,9 @@ pub fn deserializeChunk(allocator: std.mem.Allocator, rt: *Runtime, env: *@impor
             doc = try allocator.dupe(u8, db);
         }
         const refer_clojure = (try r.readU8()) != 0;
-        ns_filters[i] = .{ .name = name_dup, .exclude = exclude, .only = only, .doc = doc, .refer_clojure = refer_clojure };
+        // v5: attr-map constants index (D-554).
+        const attr_const = try r.readU32();
+        ns_filters[i] = .{ .name = name_dup, .exclude = exclude, .only = only, .doc = doc, .refer_clojure = refer_clojure, .attr_const = attr_const };
     }
 
     const ctor_count = try r.readU32();
@@ -1562,7 +1566,7 @@ test "chunk completeness gate: every side-table + entry field round-trips (D-365
     }
     inline for (std.meta.fields(NsFilterEntry)) |f| {
         const classified: bool = switch (@field(std.meta.FieldEnum(NsFilterEntry), f.name)) {
-            .name, .exclude, .only, .doc, .refer_clojure => true,
+            .name, .exclude, .only, .doc, .refer_clojure, .attr_const => true,
         };
         try testing.expect(classified);
     }
@@ -1588,7 +1592,7 @@ test "chunk completeness gate: every side-table + entry field round-trips (D-365
     const nf_exclude = [_][]const u8{"reduce"};
     const nf_only = [_][]const u8{"inc"};
     const ns_filters = [_]NsFilterEntry{
-        .{ .name = "app.core", .exclude = &nf_exclude, .only = &nf_only, .doc = "the ns doc", .refer_clojure = false },
+        .{ .name = "app.core", .exclude = &nf_exclude, .only = &nf_only, .doc = "the ns doc", .refer_clojure = false, .attr_const = 7 },
     };
     const ctor_sites = [_]CtorEntry{
         .{ .type_name = "java.io.File", .arg_count = 1 },
@@ -1649,6 +1653,7 @@ test "chunk completeness gate: every side-table + entry field round-trips (D-365
     try testing.expectEqualStrings("inc", round.ns_filters[0].only.?[0]);
     try testing.expectEqualStrings("the ns doc", round.ns_filters[0].doc.?);
     try testing.expect(!round.ns_filters[0].refer_clojure);
+    try testing.expectEqual(@as(u32, 7), round.ns_filters[0].attr_const);
 
     // ctor_sites
     try testing.expectEqual(@as(usize, 1), round.ctor_sites.len);
@@ -1819,6 +1824,7 @@ test "round-trips ns_filters with no :only (null) — bare (ns x (:require …))
     try testing.expect(round.ns_filters[0].only == null);
     try testing.expect(round.ns_filters[0].doc == null);
     try testing.expect(round.ns_filters[0].refer_clojure);
+    try testing.expectEqual(NsFilterEntry.NO_ATTR, round.ns_filters[0].attr_const);
 }
 
 test "round-trips instructions" {
 
@@ -479,8 +479,12 @@ pub const NsNode = struct {
     name: []const u8,
     /// `(ns name "docstring" …)` — lands as `{:doc "…"}` on the namespace's
     /// meta at execution (clj parity, D-239 sibling). Null = no docstring.
-    /// The attr-map form `(ns name {:author …})` is NOT yet captured (D-554).
     doc: ?[]const u8 = null,
+    /// `(ns ^{…} name {:attr …})` — the name-symbol reader meta merged with
+    /// the attr-map (attr wins), lifted to a map Value at analysis (D-554).
+    /// GC-safe in the node: the lift is pushed to the AnalysisFrame, which
+    /// production seams persist for the arena's lifetime (D-556). nil = none.
+    attr_meta: Value = Value.nil_val,
     /// User wrote `(:refer-clojure)`. When false the auto-refer step is
     /// skipped entirely (cljw-shell-only mode).
     refer_clojure: bool = true,
 
@@ -875,6 +875,16 @@ test "diff: ns_node :refer-clojure :only filter (D-098 VM op_ns_with_filter)" {
     try f.check("(do (ns diff-ns-only (:refer-clojure :only [+])) (+ 1 2))", 3);
 }
 
+test "diff: ns_node attr-map merges into ns meta (D-554)" {
+    var f: Fixture = undefined;
+    try Fixture.init(&f, testing.allocator);
+    defer f.deinit();
+    // `(ns x {:author "a"})` merges the attr-map into the ns meta in BOTH
+    // backends (tree_walk evalNs mergeNsMeta + the VM's attr_const literal-
+    // pool ride). Count keeps the assertion Value-comparable.
+    try f.check("(do (ns diff-ns-attr {:author \"a\" :x 1} (:refer-clojure)) (count (meta (find-ns 'diff-ns-attr))))", 2);
+}
+
 test "diff: ns_node docstring lands as {:doc} ns meta (D-239 sibling)" {
     var f: Fixture = undefined;
     try Fixture.init(&f, testing.allocator);
 
@@ -132,6 +132,22 @@ pub fn count(v: Value) u32 {
 /// safe to call from a non-reentrant primitive walk. A non-map `v` is a
 /// programming error (callers guard the tag). `.sorted_map` is NOT handled
 /// here (different backing structure); callers needing it dispatch separately.
+/// `(merge base overlay)` for two maps: every entry of `overlay` assoc'd
+/// onto `base` (overlay wins on key collision — clj merge's right-bias).
+/// Either side nil ⇒ the other. Non-sorted maps only (forEachEntry's scope).
+pub fn mergeInto(rt: *Runtime, base: Value, overlay: Value) !Value {
+    if (overlay.isNil()) return base;
+    if (base.isNil()) return overlay;
+    const Ctx = struct { rt: *Runtime, acc: Value };
+    var ctx: Ctx = .{ .rt = rt, .acc = base };
+    try forEachEntry(overlay, &ctx, struct {
+        fn put(c: *Ctx, k: Value, v: Value) anyerror!void {
+            c.acc = try assoc(c.rt, c.acc, k, v);
+        }
+    }.put);
+    return ctx.acc;
+}
+
 pub fn forEachEntry(
     v: Value,
     ctx: anytype,