@@ -24,6 +24,11 @@
 # 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
@@ -655,23 +660,6 @@ active:
     barrier: |-
       `src/lang/primitive/` (math / core / error today, 3 files) will grow with collection / sequence / io / numeric / type / spec primitives across Phase 5-14. ROADMAP A6 ≤ 1000-lines cap will breach on `core.zig` (general primitives bucket) first. Sub-directory restructure (`primitive/core/`, `primitive/sequence/`, etc.) should land when the second primitive file passes ~500 lines. Owner picks exact split shape **within F-NNN envelope** (= F-005 numeric tower primitives organisation must remain coherent across the split). | each Phase 5+ primitive wave
     last_reviewed: "2026-05-28"
-  - id: "D-239"
-    status: "RE-NARROWED 2026-07-02 (audit): barrier opening ns + ref remain is half-stale — ref meta landed via D-533 (reset-meta! on refs verified). NS meta is the only remainder. ORIGINAL: now (PARTIAL: var + atom + AGENT + REF landed — agent meta via D-441 (agent.zig:110 + metadata.zig dispatch); REF meta via D-533 (2026-06-25: Ref.meta field + `(ref v :meta m)` ctor kwarg + meta/reset-meta! dispatch; `with-meta` on a ref correctly THROWS — clj's Ref is not IObj, so that is clj-parity, not a gap). Only NS meta still deferred. Corrected 2026-06-17 audit (agent) + 2026-06-25 audit (ref).)"
-    category: "runtime"
-    quality_floor: "metadata: alter-meta!/reset-meta! on namespace / ref / agent refs"
-    barrier: |-
-      **`alter-meta!` / `reset-meta!` cover Var + atom + agent refs; ns + ref
-      still deferred.** The Zig primitive `reset-meta!` mutates a Var's `.meta`
-      field, an atom's `.meta` slot, or an agent's meta (agent.zig:110 + the
-      metadata.zig dispatch, landed via D-441); `alter-meta!` is a core.clj defn
-      over it. clj also supports these on **namespaces and refs** — cljw has no
-      meta slot on Namespace (it is not yet a first-class Value-with-meta; see
-      ADR-0085 namespace-as-value), and ref is a Phase-15 concurrency type. A
-      `(reset-meta! <ns-or-ref> …)` raises `reset_meta_target_not_ref`. Barrier
-      dissolves when (a) Namespace gains a meta slot reachable through a namespace
-      Value (ADR-0085 follow-on), and (b) Phase 15 lands ref. potemkin's
-      `namespaces.clj` alter-meta! on a namespace is the first real consumer.
-      corpus alter_meta (8) covers the var/atom surface.
   - id: "D-245"
     status: "now (ADR-0092, 2026-06-05) — `locking` LANDED as Option A (header spinlock + threadlocal reentrancy held-set, runtime/concurrency/object_monitor.zig). Correct, reentrant, GC-safe (safepoint-polling spin), clj-result-equivalent (mutual-exclusion e2e = 400). The Option C blocking-monitor inflation is this row."
     category: "concurrency"
@@ -6534,6 +6522,12 @@ discharged:
     barrier: "DISCHARGED (was: no UTF-16 hasher)."
     last_reviewed: "2026-07-06"
 
+  - id: "D-239"
+    status: "DISCHARGED 2026-07-06 — the LAST remainder (namespace meta) landed; alter-meta!/reset-meta!/meta now cover Var + atom + agent + ref + NAMESPACE. Namespace gained a meta slot (env.zig; GC-rooted in root_set's ns_vars walk as the walk enters each ns); reset-meta!'s .ns arm + metaOf's .ns arm; the stale 'var or atom' catalog template updated. SIBLING also landed same cycle: the `(ns name \"docstring\")` docstring — previously silently SKIPPED — now lands as {:doc …} ns meta in BOTH backends (NsNode.doc; tree_walk evalNs + VM op_ns_with_filter via NsFilterEntry.doc/refer_clojure + bytecode v4 serialization; shared meta.setNsDoc helper so semantics cannot drift; diff case per the ADR-0036 contract). e2e phase15_ns_docstring (5 cases incl. ns-doc-meta/ns-alter-meta); clj-oracle-verified ({:doc \"my doc\", :k 1} after alter-meta!). The ns ATTR-MAP + name-symbol meta remain skipped -> split to D-554 (needs a Value-in-node + rooting design). HISTORY: var (D-183) + atom + agent (D-441) + ref (D-533) landed earlier."
+    category: "runtime"
+    barrier: "DISCHARGED (was: ns meta slot missing)."
+    last_reviewed: "2026-07-06"
+
 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`).
 
@@ -1177,8 +1177,13 @@ pub fn analyzeNs(
 
     var i: usize = 2;
     // Optional docstring + attr-map after the name (clj: `(ns name doc? attrs?
-    // refs*)`) — real libs open with a docstring; skip before the directives.
-    if (i < items.len and items[i].data == .string) i += 1;
+    // refs*)`). The docstring lands as `{:doc …}` on the ns meta at execution
+    // (D-239 sibling); the attr-map is still skipped (D-554).
+    var doc: ?[]const u8 = null;
+    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;
     while (i < items.len) : (i += 1) {
         const directive = items[i];
@@ -1223,6 +1228,7 @@ pub fn analyzeNs(
     const n = try arena.create(Node);
     n.* = .{ .ns_node = .{
         .name = ns_name,
+        .doc = doc,
         .refer_clojure = refer_clojure,
         .refer_clojure_exclude = refer_clojure_exclude,
         .refer_clojure_only = refer_clojure_only,
 
@@ -548,6 +548,8 @@ 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).
+    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;
 
@@ -38,6 +38,7 @@ const host_class = @import("../../runtime/error/host_class.zig");
 const tree_walk = @import("tree_walk.zig");
 const ex_info_mod = @import("../../runtime/collection/ex_info.zig");
 const keyword_mod = @import("../../runtime/keyword.zig");
+const meta_mod = @import("../../runtime/meta.zig");
 const td_mod = @import("../../runtime/type_descriptor.zig");
 const object_method = @import("object_method.zig");
 const clojure_lang_method = @import("clojure_lang_method.zig");
@@ -1222,18 +1223,23 @@ 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, then
-            // refer rt + clojure.core through referAllWithFilter.
+            // with the `:exclude`/`:only` filter. Enter the ns, apply the
+            // docstring meta (D-239 sibling), then refer rt + 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)
                 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));
-            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);
+            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);
+                }
             }
             if (sp >= stack.len)
                 return raiseInternal("vm: operand stack overflow");
 
@@ -782,8 +782,10 @@ 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) {
-            if (n.refer_clojure) {
+        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) {
+                // 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;
                 const filter_idx: u16 = @intCast(self.ns_filters.items.len);
                 const name_dup = try self.arena.dupe(u8, n.name);
@@ -794,7 +796,8 @@ const Compiler = struct {
                     for (only, 0..) |o, i| od[i] = try self.arena.dupe(u8, o);
                     break :blk od;
                 } else null;
-                try self.ns_filters.append(self.arena, .{ .name = name_dup, .exclude = exclude_dup, .only = only_dup });
+                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 });
                 try self.emit(.op_ns_with_filter, filter_idx);
             } else {
                 const name_val = try string_mod.alloc(self.rt, n.name);
 
@@ -642,6 +642,11 @@ pub const NsFilterEntry = struct {
     name: []const u8,
     exclude: []const []const u8 = &.{},
     only: ?[]const []const u8 = null,
+    /// `(ns name "docstring" …)` → `{:doc …}` on the ns meta (D-239 sibling).
+    doc: ?[]const u8 = null,
+    /// 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,
 };
 
 /// 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 = 3;
+pub const VERSION: u16 = 4; // v4: NsFilterEntry doc + refer_clojure (D-239 sibling)
 
 pub const SerializeError = error{
     OutOfMemory,
@@ -612,6 +612,14 @@ pub fn serializeChunk(allocator: std.mem.Allocator, chunk: BytecodeChunk) ![]u8
         } else {
             try writeU8(w, 0);
         }
+        // v4: docstring (has-flag + bytes) + refer_clojure flag (D-239 sibling).
+        if (nf.doc) |d| {
+            try writeU8(w, 1);
+            try writeLenPrefixed(w, d);
+        } else {
+            try writeU8(w, 0);
+        }
+        try writeU8(w, if (nf.refer_clojure) 1 else 0);
     }
     try writeU32(w, @intCast(chunk.ctor_sites.len));
     for (chunk.ctor_sites) |ct| {
@@ -738,7 +746,15 @@ pub fn deserializeChunk(allocator: std.mem.Allocator, rt: *Runtime, env: *@impor
             }
             only = only_buf;
         }
-        ns_filters[i] = .{ .name = name_dup, .exclude = exclude, .only = only };
+        // v4: docstring + refer_clojure flag (D-239 sibling).
+        const has_doc = try r.readU8();
+        var doc: ?[]const u8 = null;
+        if (has_doc != 0) {
+            const db = try r.readLenPrefixed();
+            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 };
     }
 
     const ctor_count = try r.readU32();
@@ -832,6 +848,7 @@ pub fn freeChunk(allocator: std.mem.Allocator, chunk: BytecodeChunk) void {
             for (only) |o| allocator.free(o);
             allocator.free(only);
         }
+        if (nf.doc) |d| allocator.free(d);
     }
     allocator.free(chunk.ns_filters);
     for (chunk.ctor_sites) |ct| allocator.free(ct.type_name);
@@ -1545,7 +1562,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 => true,
+            .name, .exclude, .only, .doc, .refer_clojure => true,
         };
         try testing.expect(classified);
     }
@@ -1571,7 +1588,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 },
+        .{ .name = "app.core", .exclude = &nf_exclude, .only = &nf_only, .doc = "the ns doc", .refer_clojure = false },
     };
     const ctor_sites = [_]CtorEntry{
         .{ .type_name = "java.io.File", .arg_count = 1 },
@@ -1625,11 +1642,13 @@ test "chunk completeness gate: every side-table + entry field round-trips (D-365
     try testing.expectEqual(@as(usize, 1), round.libspecs[0].exclude.len);
     try testing.expectEqualStrings("map", round.libspecs[0].exclude[0]);
 
-    // ns_filters — exclude + only
+    // ns_filters — exclude + only + doc + refer_clojure (v4)
     try testing.expectEqual(@as(usize, 1), round.ns_filters.len);
     try testing.expectEqualStrings("app.core", round.ns_filters[0].name);
     try testing.expectEqualStrings("reduce", round.ns_filters[0].exclude[0]);
     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);
 
     // ctor_sites
     try testing.expectEqual(@as(usize, 1), round.ctor_sites.len);
@@ -1798,6 +1817,8 @@ test "round-trips ns_filters with no :only (null) — bare (ns x (:require …))
     try testing.expectEqualStrings("mylib.greet", round.ns_filters[0].name);
     try testing.expectEqual(@as(usize, 0), round.ns_filters[0].exclude.len);
     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);
 }
 
 test "round-trips instructions" {
 
@@ -477,6 +477,10 @@ pub const InNsNode = struct {
 /// is what `evalNs` passes to `findOrCreateNs`.
 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,
     /// 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 docstring lands as {:doc} ns meta (D-239 sibling)" {
+    var f: Fixture = undefined;
+    try Fixture.init(&f, testing.allocator);
+    defer f.deinit();
+    // `(ns x "d")` sets {:doc "d"} on the ns meta in BOTH backends (tree_walk
+    // evalNs + VM op_ns_with_filter's side-table doc). Count of the meta map
+    // (1 entry) keeps the assertion Value-comparable in the minimal fixture.
+    try f.check("(do (ns diff-ns-doc \"the doc\" (:refer-clojure)) (count (meta (find-ns 'diff-ns-doc))))", 1);
+}
+
 // The ADR-0035 D9 refer-override (clojure.core wins over rt on collision)
 // is NOT diff-cased here: `compare` reuses one env across both backend runs,
 // so a def/in-ns-mutating source diverges by residue, not by backend. The
 
@@ -5,9 +5,9 @@
 //! collection (sharing internals) with the new meta. `vary-meta` is a
 //! core.clj defn over these. Same-type ops (assoc/conj/dissoc) already
 //! thread `.meta` so metadata is preserved. `reset-meta!` (here) +
-//! `alter-meta!` (core.clj) mutate a Var's / atom's meta slot; namespace /
-//! ref / agent meta and symbol/keyword meta are deferred (D-239).
-//! Metadata cycle 2026-05-30; discharges D-075.
+//! `alter-meta!` (core.clj) mutate a Var's / atom's / agent's / ref's /
+//! namespace's meta slot (D-239 complete); keyword meta stays rejected
+//! (clj parity). Metadata cycle 2026-05-30; discharges D-075.
 
 const Value = @import("../../runtime/value/value.zig").Value;
 const Runtime = @import("../../runtime/runtime.zig").Runtime;
@@ -58,6 +58,12 @@ pub fn resetMetaFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLoca
         .atom => atom.setMeta(r, m),
         .agent => agent.setMeta(r, m),
         .ref => ref_mod.setMeta(r, m),
+        // Namespace meta (D-239 last remainder): mutate the ns's meta slot
+        // (GC-rooted by root_set's ns_vars walk).
+        .ns => {
+            const ns: *env_mod.Namespace = @constCast(r.decodePtr(*const env_mod.Namespace));
+            ns.meta = m;
+        },
         else => return error_catalog.raise(.reset_meta_target_not_ref, loc, .{ .actual = @tagName(r.tag()) }),
     }
     return m;