@@ -22,23 +22,33 @@ public static boolean isActive() {
   }
 
   /*
-   * tagId bit layout: [63 intercepted] [62-48 globalSerial (15 bits)] [47-32 fieldPos]
-   * [31-0 nameHash]. Bit 63 (the sign bit) marks a tag the tag interceptor must see, so the check
-   * is a single {@code tagId < 0}. globalSerial is globally unique per known tag; fieldPos is its
-   * slot in the global positional layout (TagMap.knownEntries index); nameHash is
-   * TagMap.Entry#_hash(name) and is layout-independent. Unknown (string-only) tags have the upper
-   * 32 bits zero. NOTE: TagMap.Entry decodes nameHash inline as (int) tagId on its hot path, so the
-   * low-32 encoding here must stay in sync with that.
+   * tagId bit layout: [63 intercepted] [62-48 globalSerial (15 bits)] [47-32 slot (16 bits)] [31-0
+   * reserved, zero]. Bit 63 (the sign bit) marks a tag the tag interceptor must see, so the check is
+   * a single {@code tagId < 0}. globalSerial is globally unique per known tag. The middle 16 bits
+   * carry the tag's SLOT: one globally stable coordinate assigned by graph-coloring the tag
+   * co-occurrence graph (the resolved tag set of each concrete span type, plus the trace-level
+   * tier, is a clique). Co-occurring tags always get distinct slots; slots are reused only between
+   * tags that never appear together, so slotCount stays bounded by the largest clique (≤ 64) and
+   * fits one {@code long} occupancy mask — the dense store's single-tier presence fast path (see
+   * {@link TagMap}). The low 32 bits are unused for known ids (the whole id is fully determined by
+   * serial + slot, so the generator can emit a literal). The low 32 bits are being carved for
+   * cross-cutting flags; bit 2 is the trace/span LEVEL bit (set ⟹ trace-level), and bits 1-0 are
+   * reserved for the dd/otel applicability flags that land with increment 1. The level bit lets
+   * read-through skip the shadow check across the trace/span boundary — trace and span tags reuse
+   * the same slots, so occupancy alone can't tell them apart, but a span map (no trace-level tags)
+   * can never shadow a trace-level ancestor entry (see {@link TagMap}). Unknown (string-only) custom
+   * tags are NOT known ids — they key off {@code TagMap.Entry#_hash(name)} in their own bucket path
+   * and never enter here.
    */
-  public static int globalSerial(long tagId) {
+  public static int serialNum(long tagId) {
     return (int) ((tagId >>> 48) & 0x7FFF);
   }
 
   /**
-   * Flag bit (the sign bit) marking a tag the tag interceptor must process — reserved/"virtual"
-   * tags AND intercepted-but-stored tags (e.g. http.method, which the interceptor side-effects and
-   * also stores). Encoded in the id so {@code DDSpanContext.setTag(long)} can route with a single
-   * sign test ({@link #isIntercepted}) instead of resolving the name. Non-intercepted tags (peer.*,
+   * Flag bit (the sign bit) marking a tag the tag interceptor must process — reserved tags AND
+   * intercepted-but-stored tags (e.g. http.method, which the interceptor side-effects and also
+   * stores). Encoded in the id so {@code DDSpanContext.setTag(long)} can route with a single sign
+   * test ({@link #isIntercepted}) instead of resolving the name. Non-intercepted tags (peer.*,
    * base.service, …) leave it clear and take the fast store path. Must agree with the interceptor's
    * name-based {@code needsIntercept} for every assigned id.
    */
@@ -54,78 +64,115 @@ public static long intercepted(long tagId) {
     return tagId | INTERCEPTED;
   }
 
-  public static int fieldPos(long tagId) {
-    return (int) ((tagId >>> 32) & 0xFFFF);
+  /**
+   * Trace/span LEVEL bit (low-32 carve, bit 2). Set marks a trace-level tag (lives on the
+   * TraceSegment's own TagMap); clear marks a span-level tag. Trace and span tags reuse the same
+   * coloring slots, so this bit is what lets read-through tell the two levels apart — a span map
+   * (no trace-level tags) can never shadow a trace-level ancestor entry, so its shadow check is
+   * skipped (see {@link TagMap#parentDenseVisible}).
+   */
+  public static final long LEVEL_TRACE = 1L << 2;
+
+  /** True if the tagId names a trace-level tag. */
+  public static boolean isTraceLevel(long tagId) {
+    return (tagId & LEVEL_TRACE) != 0L;
   }
 
-  public static int nameHash(long tagId) {
-    return (int) tagId;
+  /** Returns the tagId with the {@link #LEVEL_TRACE} flag set. */
+  public static long traceLevel(long tagId) {
+    return tagId | LEVEL_TRACE;
   }
 
+  // The middle 16 bits [47-32] hold the tag's SLOT: one globally stable coordinate from graph
+  // coloring the co-occurrence graph. Co-occurring tags get distinct slots and slotCount stays
+  // bounded by the largest clique (<= 64), so the dense store's presence fast path is a single
+  // occupancy long (1L << slot); a clear bit proves the tag absent and enables an O(1) append. See
+  // TagMap's dense-store fast path.
+  static final int SLOT_SHIFT = 32;
+  static final int SLOT_MASK = 0xFFFF; // 16 bits
+
   /**
-   * globalSerial partition. {@code [1, FIRST_STORED_SERIAL)} is reserved for "virtual" tags that
-   * are specially handled (redirected to span fields or processed by the tag interceptor) and are
-   * NOT stored in the TagMap — these are hand-assigned in tracer core. {@code [FIRST_STORED_SERIAL,
-   * ..]} is for generated convention tags that ARE stored (slotted/bucketed). {@code globalSerial
-   * == 0} means unknown / string-only. Both core and the code generator must agree on this
-   * boundary.
+   * The tag's slot: its globally stable coloring coordinate, or {@link #NO_SLOT} when it has none
+   * (reserved or deliberately bucket-only). Drives the dense store's single occupancy mask.
+   */
+  public static int slot(long tagId) {
+    return (int) ((tagId >>> SLOT_SHIFT) & SLOT_MASK);
+  }
+
+  /**
+   * globalSerial partition. {@code [1, FIRST_STORED_SERIAL)} is the RESERVED tier and {@code
+   * [FIRST_STORED_SERIAL, ..]} is the STORED tier; {@code globalSerial == 0} means unknown /
+   * string-only. Both core and the code generator must agree on this boundary.
+   *
+   * <p><b>Reserved</b> is the shared mechanism: the tracer reserves the key and handles it itself
+   * instead of putting it in the TagMap. It says nothing about whether a value exists — that splits
+   * into two kinds (the {@code kind:} in the overlay):
+   *
+   * <ul>
+   *   <li><b>structural</b> — the value <i>does</i> exist, it just lives in a first-class
+   *       span/trace field (service, resource.name, error, span.type, origin), not the tag map.
+   *   <li><b>directive</b> — there is <i>no</i> stored value; the key is a command that triggers
+   *       trace behavior (sampling.priority, manual.keep, measured).
+   * </ul>
+   *
+   * "virtual" over-claims non-existence (wrong for structural) and "built-in" over-claims existence
+   * (wrong for directive), so the tier is named for the mechanism they share: reserved. These are
+   * hand-assigned in the overlay. <b>Stored</b> tags are the generated convention tags that ARE put
+   * in the map (slotted/bucketed).
    */
   public static final int FIRST_STORED_SERIAL = 256;
 
-  /** True if the tagId names a reserved "virtual"/specially-handled tag (not stored in the map). */
+  /** True if the tagId names a reserved (structural/directive) tag — handled, not stored. */
   public static boolean isReserved(long tagId) {
-    int globalSerial = globalSerial(tagId);
-    return globalSerial > 0 && globalSerial < FIRST_STORED_SERIAL;
+    int serialNum = serialNum(tagId);
+    return serialNum > 0 && serialNum < FIRST_STORED_SERIAL;
   }
 
   /** True if the tagId names a generated, map-stored (slotted/bucketed) tag. */
   public static boolean isStored(long tagId) {
-    return globalSerial(tagId) >= FIRST_STORED_SERIAL;
+    return serialNum(tagId) >= FIRST_STORED_SERIAL;
   }
 
   /**
-   * Sentinel {@code fieldPos} meaning "no positional slot". It is the maximum value the 16-bit
-   * fieldPos field can hold, so it always compares {@code >= slotCount()} and routes to the hash
-   * buckets rather than the fast positional array. Two kinds of tagId use it:
+   * Sentinel {@code slot} meaning "no positional slot". It is the maximum value the 16-bit slot
+   * field can hold, so it always compares {@code >= slotCount()} and routes to the hash buckets
+   * rather than the fast positional array. Two kinds of tagId use it:
    *
    * <ul>
-   *   <li>Reserved/virtual tags ({@code globalSerial < FIRST_STORED_SERIAL}) — not stored at all;
-   *       the sentinel just guarantees an incidental store never lands in a slot.
+   *   <li>Reserved tags ({@code globalSerial < FIRST_STORED_SERIAL}) — not stored at all; the
+   *       sentinel just guarantees an incidental store never lands in a slot.
    *   <li>Unslotted stored tags ({@code globalSerial >= FIRST_STORED_SERIAL}) — "low-priority" tags
    *       that get a stable id (and so {@code keyOf}/{@code nameOf} unification with their string
-   *       form) but are deliberately not given a slot, so they live in the buckets and don't widen
-   *       {@code knownEntries[]} for every span. {@code getEntry(long)} for these resolves the name
-   *       and rehashes — the cost of not owning a slot.
+   *       form) but are deliberately not given a slot, so they live in the buckets. {@code
+   *       getEntry(long)} for these resolves the name and rehashes — the cost of not owning a slot.
    * </ul>
    */
-  public static final int NO_SLOT = 0xFFFF;
+  public static final int NO_SLOT = SLOT_MASK; // slot all-ones sentinel (16 bits)
 
   /**
    * True if the tagId names a stored tag that deliberately has no positional slot (bucket-only).
    */
   public static boolean isUnslotted(long tagId) {
-    return isStored(tagId) && fieldPos(tagId) == NO_SLOT;
+    return isStored(tagId) && slot(tagId) == NO_SLOT;
   }
 
   /**
-   * Builds a tagId from its parts: {@code globalSerial} (globally unique per known tag), {@code
-   * fieldPos} (the tag's slot within its span type's positional table), and the tag {@code name}
-   * (whose hash is computed via the same function the runtime uses, so the low 32 bits match {@link
-   * TagMap.Entry#hash()}). Inverse of {@link #globalSerial}/{@link #fieldPos}/{@link #nameHash}.
-   * Intended for the code generator and tests.
+   * Builds a tagId from its {@code serialNum} (globally unique per known tag) and {@code slot} (its
+   * coloring coordinate, or {@link #NO_SLOT}). The low 32 bits are zero, so the id is fully
+   * determined by these parts — the generator emits it as a literal. Inverse of {@link
+   * #serialNum}/{@link #slot}. Intended for the code generator and tests.
    */
-  public static long tagId(int globalSerial, int fieldPos, String name) {
-    long nameHash = TagMap.Entry._hash(name) & 0xFFFFFFFFL;
-    return ((long) globalSerial << 48) | ((long) (fieldPos & 0xFFFF) << 32) | nameHash;
+  public static long makeTagId(int serialNum, int slot) {
+    return ((long) serialNum << 48) | ((long) (slot & SLOT_MASK) << SLOT_SHIFT);
   }
 
   /**
-   * Builds a tagId with no positional slot ({@code fieldPos == }{@link #NO_SLOT}). Use for reserved
-   * "virtual" tags and for "low-priority" stored tags that get a stable id but are intentionally
-   * kept out of the fast slot array (they route to the hash buckets). See {@link #NO_SLOT}.
+   * Builds a tagId with no positional slot ({@code slot == }{@link #NO_SLOT}). Use for reserved
+   * tags and for "low-priority" stored tags that get a stable id but are intentionally kept out of
+   * the fast slot array (they route to the hash buckets). See {@link #NO_SLOT}.
    */
-  public static long tagId(int globalSerial, String name) {
-    return tagId(globalSerial, NO_SLOT, name);
+  public static long makeTagId(int serialNum) {
+    return makeTagId(serialNum, NO_SLOT);
   }
 
   // Number of positional slots in the global layout = (max stored fieldPos) + 1, declared by the