@@ -73,17 +73,59 @@ public IReadOnlyList<string> VerifiedBy
         }
     }
 
+    /// <summary>
+    /// What was DECIDED about the outstanding work — a different question from whether the
+    /// work is done, which is what <c>@status</c> answers. <c>null</c> means UNDECIDED, a
+    /// real state and the one a review exists to find.
+    /// ADR-0039: resolving — inheritable via extends.
+    /// </summary>
+    public string? Disposition => Attr(REQUIREMENT_ATTR_DISPOSITION) as string;
+
+    /// <summary>
+    /// Issue/ticket references for outstanding work. Free-form and NEVER resolved —
+    /// <c>verify</c> has no network, so unlike <c>@verifiedBy</c> nothing here is checked
+    /// to exist.
+    /// ADR-0039: resolving — inheritable via extends.
+    /// </summary>
+    public IReadOnlyList<string> TrackedBy
+    {
+        get
+        {
+            var v = Attr(REQUIREMENT_ATTR_TRACKED_BY);
+            return v is IReadOnlyList<string> list ? list : [];
+        }
+    }
+
+    /// <summary>
+    /// Intended but not built. Its nodes may legitimately not exist yet, and it must NOT
+    /// count toward object coverage — planning a capability cannot be allowed to silence
+    /// the warning that nothing implements it.
+    /// </summary>
+    public bool IsPlanned() => Status == REQUIREMENT_STATUS_PLANNED;
+
+    /// <summary>True when there is outstanding work, so a <c>@disposition</c> says something.</summary>
+    public bool HasOutstandingWork()
+    {
+        string? status = Status;
+        return status is not null
+            && REQUIREMENT_STATUSES_WITH_OUTSTANDING_WORK.Contains(status);
+    }
+
     /// <summary>
     /// True when this requirement is permitted to reference the model at all.
-    /// Architectural requirements always may (their claim set is the point); functional
-    /// ones only at or below the link floor, so the organisational tiers stay
-    /// organisational.
+    ///
+    /// An UNLEVELLED architectural requirement always may — its claim set is the whole
+    /// point, and that is the original flat form. Once a level is PRESENT the node has
+    /// opted into a tree, and the link floor applies to it exactly as it does to a
+    /// functional one, so an "ISO 25010 Security" grouping node cannot quietly start
+    /// naming entities. Levelling is the opt-in; enforcing the floor unconditionally would
+    /// have broken every existing flat policy.
     /// </summary>
     public bool MayReferenceModel()
     {
-        if (IsArchitectural()) return true;
         int? level = Level;
-        return level is not null && level.Value >= REQUIREMENT_LINK_FLOOR_LEVEL;
+        if (level is null) return IsArchitectural();
+        return level.Value >= REQUIREMENT_LINK_FLOOR_LEVEL;
     }
 
     /// <summary>
 
@@ -9,12 +9,16 @@
 
 from ...meta_data import MetaData
 from .requirement_constants import (
+    REQUIREMENT_ATTR_DISPOSITION,
     REQUIREMENT_ATTR_IMPLEMENTED_BY,
     REQUIREMENT_ATTR_LEVEL,
     REQUIREMENT_ATTR_STATUS,
+    REQUIREMENT_ATTR_TRACKED_BY,
     REQUIREMENT_ATTR_VERIFIED_BY,
     REQUIREMENT_LINK_FLOOR_LEVEL,
+    REQUIREMENT_STATUS_PLANNED,
     REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES,
+    REQUIREMENT_STATUSES_WITH_OUTSTANDING_WORK,
     REQUIREMENT_SUBTYPE_ARCHITECTURAL,
     REQUIREMENT_SUBTYPE_FUNCTIONAL,
 )
@@ -31,8 +35,9 @@ def is_architectural(self) -> bool:
 
     def level(self) -> int | None:
         """ADR-0039: resolving. 1 solution · 2 segment · 3 service · 4 object ·
-        5 member. Architectural requirements carry none — they are
-        object-independent by definition."""
+        5 member. REQUIRED on functional; OPTIONAL on architectural, where absent
+        means a flat object-independent policy and present opts the node into a
+        levelled tree (e.g. a quality taxonomy over the non-functional set)."""
         v = self.get_meta_attr(REQUIREMENT_ATTR_LEVEL)
         return v if isinstance(v, int) and not isinstance(v, bool) else None
 
@@ -53,15 +58,46 @@ def verified_by(self) -> list[str]:
         v = self.get_meta_attr(REQUIREMENT_ATTR_VERIFIED_BY)
         return [str(x) for x in v] if isinstance(v, list) else []
 
+    def disposition(self) -> str | None:
+        """ADR-0039: resolving. What was DECIDED about the outstanding work — a
+        different question from whether the work is done, which is what
+        ``status`` answers. ``None`` means UNDECIDED, a real state and the one a
+        review exists to find."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_DISPOSITION)
+        return v if isinstance(v, str) else None
+
+    def tracked_by(self) -> list[str]:
+        """ADR-0039: resolving. Issue/ticket references for outstanding work.
+        Free-form and NEVER resolved — verify has no network, so unlike
+        ``verified_by`` nothing here is checked to exist."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_TRACKED_BY)
+        return [str(x) for x in v] if isinstance(v, list) else []
+
+    def is_planned(self) -> bool:
+        """Intended but not built. Its nodes may legitimately not exist yet, and
+        it must NOT count toward object coverage — planning a capability cannot
+        be allowed to silence the warning that nothing implements it."""
+        return self.status() == REQUIREMENT_STATUS_PLANNED
+
+    def has_outstanding_work(self) -> bool:
+        """True when there is outstanding work, so a ``disposition`` says
+        something."""
+        s = self.status()
+        return s is not None and s in REQUIREMENT_STATUSES_WITH_OUTSTANDING_WORK
+
     def may_reference_model(self) -> bool:
         """True when this requirement is permitted to reference the model at all.
-        Architectural requirements always may (their claim set is the point);
-        functional ones only at or below the link floor, so the organisational
-        tiers stay organisational."""
-        if self.is_architectural():
-            return True
+
+        An UNLEVELLED architectural requirement always may — its claim set is the
+        whole point, and that is the original flat form. Once a level is PRESENT
+        the node has opted into a tree, and the link floor applies to it exactly
+        as it does to a functional one, so an "ISO 25010 Security" grouping node
+        cannot quietly start naming entities. Levelling is the opt-in; enforcing
+        the floor unconditionally would have broken every existing flat policy."""
         lvl = self.level()
-        return lvl is not None and lvl >= REQUIREMENT_LINK_FLOOR_LEVEL
+        if lvl is None:
+            return self.is_architectural()
+        return lvl >= REQUIREMENT_LINK_FLOOR_LEVEL
 
     def requires_live_nodes(self) -> bool:
         """True when a dangling ``@implementedBy`` is an ERROR rather than