Apply GH-DEC-2026-017: INTENT.md governs, layer.yaml is derived, no version

Verified against gate-house's committed ruling (decisions/decisions.md,
GH-DEC-2026-017) and amendments A9-A13, then ops-warden's reference change set
(a70f559, wiki/playbooks/netkingdom-layer-declaration.md). They agree.

layer.yaml: standard_version removed; derived: true and derived_from:
INTENT.md added; declared_by kept. INTENT.md frontmatter never carried
standard_version, but its standard: value was a version-pinned path; it is
de-versioned as the reference instance did. No layer value is re-spelled:
INTENT.md still says Engine and layer.yaml still says engine.

The checker changes in the same commit because it listed standard_version as
a required key: removing the field alone would have made a conforming
declaration exit 2 MALFORMED. It now reads INTENT.md as the governing form,
requires the derived marking, rejects a returning standard_version in either
form, checks both layer values against the closed four-token vocabulary
(Taxonomy included) after an ASCII fold, and reports a post-fold disagreement
between the forms as a finding rather than resolving it by precedence.

Tests assert the fold, not per-file spelling, and cover fold agreement, a
real disagreement, the closed vocabulary and a returning version. Full suite
430 passed.

role:, pep-stance.yaml and schema_version are untouched (not ruled). Still
open: where the removed version lives in a derived conformance record; asked
of gate-house by ops-warden (4220413a), followed rather than chosen here.

Closes the SECRETS-WP-0008 note that waited on the reference form.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Assistant: claude-code
Assistant-Model: opus
Assistant-Process: 63291@bnt-lap001
Assistant-Session: 8bd77868-ca68-4f49-bb1e-d539ecc0d703

scripts/check_layer_conformance.py

@@ -4,10 +4,21 @@
 Read-only. This is the Engine/Lifecycle adaptation of the ops-warden reference
 checker. §5 Staff shapes do not apply to the owned OpenBao contact.
 
+Two declaration forms are read. Per GH-DEC-2026-017 §1 (amendment A11)
+INTENT.md's frontmatter `layer:` key governs; layer.yaml is a derived artifact
+that must be marked derived, must name INTENT.md, and must agree with it. The
+sidecar is still read, because a disagreement between the two is a finding in
+its own right, reported rather than resolved away by precedence.
+
+Layer values are compared against §3's closed four-token vocabulary after an
+ASCII case-fold (GH-DEC-2026-017 §2-§3, amendment A9). Nothing is re-spelled:
+`Engine` and `engine` are one token. Neither form carries a standard version
+(GH-DEC-2026-017 §5, amendment A12), and its return is rejected.
+
 Mechanical checks:
 
-- a machine-readable declaration exists and says Engine / Lifecycle
-- INTENT.md frontmatter matches that declaration
+- INTENT.md frontmatter carries the governing `layer:` (Engine) and role
+- layer.yaml is marked derived from INTENT.md and agrees with it after folding
 - no authorization decision surface is exposed
 - the PEP stance map is published at the path named in the declaration
 - every OpenBao subprocess adapter lives in a module listed as owned tooling
@@ -35,6 +46,34 @@ DECISION_SURFACE = re.compile(
     r"""\b(evaluate_policy|check_permission|render_decision|pdp_decide)\b"""
 )
 
+# §3's vocabulary: closed, four tokens, compared case-insensitively
+# (GH-DEC-2026-017 §3, amendment A9). Taxonomy is in it.
+LAYER_VOCABULARY = {"taxonomy", "tooling", "engine", "staff"}
+EXPECTED_LAYER = "engine"
+
+
+def _fold(value: object) -> str:
+    """ASCII case-fold, per §3 as amended: two spellings of a token are one token."""
+    return str(value).strip().encode("ascii", "ignore").decode().lower()
+
+
+def _no_standard_version(where: str, data: dict) -> None:
+    if "standard_version" in data:
+        print(
+            f"MALFORMED: {where} carries 'standard_version' — a layer declaration "
+            "MUST NOT carry a standard version (§11 as amended by A12)"
+        )
+        raise SystemExit(2)
+
+
+def _in_vocabulary(where: str, layer: object) -> None:
+    if _fold(layer) not in LAYER_VOCABULARY:
+        print(
+            f"MALFORMED: {where} declares layer {layer!r}, outside §3's closed "
+            f"vocabulary {sorted(LAYER_VOCABULARY)} (case-insensitive)"
+        )
+        raise SystemExit(2)
+
 
 def load_declaration() -> dict:
     if not DECL.exists():
@@ -45,7 +84,8 @@ def load_declaration() -> dict:
         "layer",
         "role",
         "repository",
-        "standard_version",
+        "derived",
+        "derived_from",
         "owned_tooling",
         "decision_surfaces_exposed",
         "pep_shaped",
@@ -54,9 +94,18 @@ def load_declaration() -> dict:
         if key not in decl:
             print(f"MALFORMED: layer.yaml has no {key!r}")
             raise SystemExit(2)
-    if decl["layer"] != "engine":
-        print(f"MALFORMED: declared layer is {decl['layer']!r}, expected 'engine'")
+    # §11 derived-artifact rule (GH-DEC-2026-017 §1): marked, naming its source.
+    if decl["derived"] is not True:
+        print("MALFORMED: layer.yaml must be marked 'derived: true' (§11, GH-DEC-2026-017 §1)")
         raise SystemExit(2)
+    if decl["derived_from"] != "INTENT.md":
+        print(
+            f"MALFORMED: layer.yaml derives from {decl['derived_from']!r}; §11 names "
+            "INTENT.md as the governing declaration"
+        )
+        raise SystemExit(2)
+    _no_standard_version("layer.yaml", decl)
+    _in_vocabulary("layer.yaml", decl["layer"])
     if decl["role"] != "lifecycle":
         print(f"MALFORMED: declared role is {decl['role']!r}, expected 'lifecycle'")
         raise SystemExit(2)
@@ -75,7 +124,13 @@ def intent_frontmatter() -> dict:
     if end < 0:
         print("MALFORMED: INTENT.md frontmatter is unclosed")
         raise SystemExit(2)
-    return yaml.safe_load(text[3:end]) or {}
+    front = yaml.safe_load(text[3:end]) or {}
+    if "layer" not in front:
+        print("MALFORMED: INTENT.md frontmatter has no 'layer' key — §11's declaration")
+        raise SystemExit(2)
+    _no_standard_version("INTENT.md frontmatter", front)
+    _in_vocabulary("INTENT.md frontmatter", front["layer"])
+    return front
 
 
 def owned_modules(decl: dict) -> set[str]:
@@ -118,13 +173,24 @@ def main() -> int:
     ap.add_argument("--report", action="store_true")
     args = ap.parse_args()
 
-    decl = load_declaration()
     front = intent_frontmatter()
+    decl = load_declaration()
     ok = True
 
-    if str(front.get("layer", "")).lower() != "engine":
+    governing = front["layer"]
+    if _fold(governing) != EXPECTED_LAYER:
         ok = False
-        print("FINDING: INTENT.md frontmatter layer is not Engine")
+        print(f"FINDING: INTENT.md frontmatter layer is {governing!r}, not Engine")
+    # §11 as amended (A11): a post-fold disagreement between the two forms is a
+    # finding in its own right, reported rather than resolved by precedence.
+    if _fold(decl["layer"]) != _fold(governing):
+        ok = False
+        print(
+            "FINDING: DECLARATION DISAGREEMENT (§11) — "
+            f"INTENT.md (governs) layer: {governing!r}; "
+            f"layer.yaml (derived) layer: {decl['layer']!r}. "
+            "Case is already folded; this is a disagreement about a layer."
+        )
     if str(front.get("role", "")).lower() != "lifecycle":
         ok = False
         print("FINDING: INTENT.md frontmatter role is not Lifecycle")
@@ -161,9 +227,10 @@ def main() -> int:
 
     if args.report:
         print(
-            f"{decl['repository']} — layer: {decl['layer']} "
-            f"role: {decl['role']} (model v{decl['standard_version']})"
+            f"{decl['repository']} — layer: {governing} role: {front.get('role')} "
+            "(declared in INTENT.md; §11 governing form)"
         )
+        print(f"layer.yaml: derived from {decl['derived_from']}, layer: {decl['layer']}")
         print(f"declared by {decl['declared_by']}")
         print(f"pep stance: {decl['pep_stance']}")
         print(f"owned OpenBao modules: {sorted(owned)}")