@@ -22,7 +22,8 @@ public class MetaRequirement(TypeId typeId, string name) : MetaData(typeId, name
 
     /// <summary>
     /// 1 solution · 2 segment · 3 service · 4 object · 5 member. Architectural
-    /// requirements carry none — they are object-independent by definition.
+    /// requirements carry it OPTIONALLY: absent means a flat, object-independent policy,
+    /// present opts the node into a levelled tree (e.g. a quality taxonomy).
     /// ADR-0039: resolving — @level may be inherited via extends.
     /// </summary>
     public int? Level
@@ -41,7 +42,7 @@ public int? Level
     }
 
     /// <summary>
-    /// The lifecycle status (a closed enum: live / partial / abandoned / superseded).
+    /// The lifecycle status (a closed enum: planned / live / partial / abandoned / superseded).
     /// ADR-0039: resolving — inheritable via extends.
     /// </summary>
     public string? Status => Attr(REQUIREMENT_ATTR_STATUS) as string;
 
@@ -4406,7 +4406,7 @@ private static void validateObjectIndexLookupFields(MetaObject obj) {
     // type/subtype, not the container's; same reason source @kind/@role and
     // relationship @onDelete/@onUpdate use post-load passes).
     //
-    //   @status must be one of: live / partial / abandoned / superseded
+    //   @status must be one of: planned / live / partial / abandoned / superseded
     //
     // This is the mechanism the capability ledger was made registered vocabulary
     // FOR (requirements-as-metadata ruling, Amendment 3): a typo'd status is
 
@@ -181,10 +181,10 @@ protected MetaRequirement(String subType, String name) {
      * be lifted here or the declared child rule is unreachable.</p>
      *
      * <p>WHICH subtypes may nest stays the registry's decision, not this method's: the
-     * spec declares the nested-{@code requirement} child rule on {@code functional} only
-     * ({@code architectural} is object-independent and carries none), and
-     * {@code applyStrictStructuralChildren} is what puts that rule on the type
-     * definition. Every other same-type combination still hits the base refusal.</p>
+     * spec declares the nested-{@code requirement} child rule on BOTH subtypes -- a
+     * functional tree nests by capability, an architectural one may nest under a quality
+     * taxonomy -- and {@code applyStrictStructuralChildren} is what puts that rule on the
+     * type definition. Every other same-type combination still hits the base refusal.</p>
      */
     @Override
     protected void checkValidChild(MetaData data) {
@@ -293,16 +293,20 @@ public List<MetaRequirement> getChildRequirements() {
 
     /**
      * 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.
+     *
+     * <p>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.</p>
      */
     public boolean mayReferenceModel() {
-        if (isArchitectural()) {
-            return true;
-        }
         Integer level = getLevel();
-        return level != null && level >= LINK_FLOOR_LEVEL;
+        if (level == null) {
+            return isArchitectural();
+        }
+        return level >= LINK_FLOOR_LEVEL;
     }
 
     /**
 
@@ -167,17 +167,29 @@ public void architecturalRequirement_basicLoad_succeeds() {
         assertNotNull("requirement.architectural child found", req);
         assertEquals(MetaRequirement.SUBTYPE_ARCHITECTURAL, req.getSubType());
         assertTrue("isArchitectural()", req.isArchitectural());
-        assertEquals("architectural carries no level", null, req.getLevel());
+        assertEquals("a FLAT architectural node carries no level", null, req.getLevel());
         assertEquals(List.of("acme::shop::Order", "acme::shop::Customer"), req.getImplementedBy());
         assertTrue("architectural may always reference the model", req.mayReferenceModel());
     }
 
     // ---------------------------------------------------------------------------
-    // (3b) requirement.architectural declares NO nested-requirement child rule
+    // (3b) requirement.architectural DOES nest -- it declares the same
+    //      nested-requirement child rule as functional.
+    //
+    //      This test previously asserted the opposite, on the reasoning that an
+    //      architectural requirement is object-independent and so has no tier to
+    //      contain. That reasoning holds for a FLAT policy and stopped being the
+    //      whole story when `@level` became optional on architectural: levelling
+    //      is opt-in so a quality taxonomy (an ISO/IEC 25010 characteristic at
+    //      L1, its sub-characteristic at L2) can organise the non-functional set
+    //      the same way a capability taxonomy organises the functional one.
+    //      Declaring the child rule on `functional` only made an architectural
+    //      node nestable under a FUNCTIONAL parent but never under another
+    //      architectural one -- an omission rather than a design.
     // ---------------------------------------------------------------------------
 
     @Test
-    public void architecturalRequirement_doesNotNest() {
+    public void architecturalRequirement_nests() {
         String json = "{ \"metadata.root\": { \"package\": \"acme::test\", \"children\": ["
             + "  { \"requirement.architectural\": { \"name\": \"uuidPrimaryKeys\","
             + "      \"@status\": \"live\","
@@ -193,27 +205,77 @@ public void architecturalRequirement_doesNotNest() {
             + "] } }";
 
         MetaDataLoader loader = strictLoader("test-requirement-architectural-nesting");
-        MetaDataException caught = null;
-        try {
-            load(loader, json);
-        } catch (MetaDataException e) {
-            caught = e;
-        }
+        MetaRoot root = load(loader, json);
 
         String messages = loader.getErrors().stream()
             .map(Throwable::getMessage).reduce("", (a, b) -> a + " | " + b);
-        if (caught != null) {
-            messages += " | THROWN: " + caught.getClass().getName() + ": " + caught.getMessage();
-        }
-        boolean refused = caught != null || !loader.getErrors().isEmpty();
-        assertTrue("architectural is object-independent by definition and declares no "
-            + "nested-requirement child rule in spec/metamodel/requirement.json; "
-            + "messages=" + messages, refused);
-        // The refusal must come from the REGISTRY's per-subtype child rule (sourced from
-        // the spec file), not from MetaData's blanket same-type ban — the latter is what
-        // MetaRequirement.checkValidChild deliberately lifts.
-        assertTrue("refused by the registered child rule; messages=" + messages,
-            messages.contains("requirement.architectural does not accept child"));
+        assertTrue("a nested requirement loads clean under architectural; messages=" + messages,
+            loader.getErrors().isEmpty());
+
+        MetaRequirement req = firstRequirement(root);
+        assertNotNull("requirement.architectural child found", req);
+        assertEquals(1, req.getChildren().stream()
+            .filter(c -> MetaRequirement.TYPE_REQUIREMENT.equals(c.getType())).count());
+    }
+
+    // ---------------------------------------------------------------------------
+    // (3c) A LEVELLED architectural tree -- the shape the optional @level exists
+    //      for, and the one that was inexpressible while only `functional`
+    //      declared the nested-requirement child rule.
+    // ---------------------------------------------------------------------------
+
+    @Test
+    public void architecturalRequirement_levelledTreeLoads() {
+        String json = "{ \"metadata.root\": { \"package\": \"acme::test\", \"children\": ["
+            + "  { \"requirement.architectural\": { \"name\": \"security\","
+            + "      \"@level\": 1,"
+            + "      \"@status\": \"live\","
+            + "      \"@statement\": \"The system protects the data it holds.\","
+            + "      \"@violation\": \"A record readable by someone with no claim to it.\","
+            + "      \"children\": ["
+            + "        { \"requirement.architectural\": { \"name\": \"integrity\","
+            + "            \"@level\": 2,"
+            + "            \"@status\": \"partial\","
+            + "            \"@disposition\": \"deferred\","
+            + "            \"@trackedBy\": [\"acme/platform#412\"],"
+            + "            \"@statement\": \"A stored value changes only under control.\","
+            + "            \"@violation\": \"A number that changed with nothing explaining it.\","
+            + "            \"children\": ["
+            + "              { \"requirement.architectural\": { \"name\": \"ordersAreAppendOnly\","
+            + "                  \"@level\": 4,"
+            + "                  \"@status\": \"live\","
+            + "                  \"@statement\": \"An order row is appended, never mutated.\","
+            + "                  \"@violation\": \"An order total edited in place.\","
+            + "                  \"@implementedBy\": [\"acme::shop::Order\"] } }"
+            + "            ] } }"
+            + "      ] } }"
+            + "] } }";
+
+        MetaDataLoader loader = strictLoader("test-requirement-architectural-levelled");
+        MetaRoot root = load(loader, json);
+
+        String messages = loader.getErrors().stream()
+            .map(Throwable::getMessage).reduce("", (a, b) -> a + " | " + b);
+        assertTrue("a levelled architectural tree loads clean; messages=" + messages,
+            loader.getErrors().isEmpty());
+
+        MetaRequirement l1 = firstRequirement(root);
+        assertNotNull("L1 architectural found", l1);
+        assertEquals(Integer.valueOf(1), l1.getLevel());
+        // An organisational tier may not reference the model, on either subtype,
+        // once it has opted into a tree by carrying a level.
+        assertTrue("L1 is organisational", !l1.mayReferenceModel());
+
+        MetaRequirement l2 = (MetaRequirement) l1.getChildren().stream()
+            .filter(c -> c instanceof MetaRequirement).findFirst().orElseThrow();
+        assertEquals("deferred", l2.getDisposition());
+        assertEquals(List.of("acme/platform#412"), l2.getTrackedBy());
+        assertTrue("partial has outstanding work", l2.hasOutstandingWork());
+
+        MetaRequirement l4 = (MetaRequirement) l2.getChildren().stream()
+            .filter(c -> c instanceof MetaRequirement).findFirst().orElseThrow();
+        assertTrue("the link floor may reference the model", l4.mayReferenceModel());
+        assertEquals(List.of("acme::shop::Order"), l4.getImplementedBy());
     }
 
     // ---------------------------------------------------------------------------
 
@@ -219,7 +219,9 @@ describe("requirement.* — it is metadata", () => {
               implementedBy: ["acme::shop::Order"]
 `), OTHER);
     expect(r.loadError ?? "").toContain("not one of the allowed values");
-    expect(r.loadError ?? "").toContain("live, partial, abandoned, superseded");
+    // The FULL set, `planned` included. Asserting the tail alone passed by
+    // substring luck and would have stayed green if `planned` were dropped.
+    expect(r.loadError ?? "").toContain("planned, live, partial, abandoned, superseded");
   });
 
   test("THE LOADER rejects an undeclared attr on a requirement (ADR-0023)", async () => {