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

Verified against gate-house's own committed files before editing, not the inbox
message: GH-DEC-2026-017 in decisions/decisions.md at gate-house@def0af2,
amendments A9-A13 in docs/amendments/v0.8-section-11-declaration-amendments.md,
and sections 3, 4 and 11 of net-kingdom's security-layer-model_v0.8.md. The
ruling and docs/layer-declaration-precedence.md's secondary account agreed.

INTENT.md's frontmatter is the declaration; layer.yaml is a derived artifact,
now marked derived: true / derived_from: INTENT.md, and it does not govern.

standard_version is removed from BOTH forms. The ruling's general form is that a
layer declaration must not carry a standard version, and INTENT.md is the
declaration, so removing it from the sidecar alone would have left the field in
the only file that actually declares. INTENT.md's version-pinned `standard:`
path is de-versioned for the same reason: a pinned path reads as a validity
condition. The version ops-warden assented at stays with the assent, ADR-0010.

NO LAYER VALUE IS CHANGED. INTENT.md still says Staff and layer.yaml still says
staff. Section 3's vocabulary is closed, four tokens, and case-insensitive: the
two forms were never in disagreement about a layer, and the ruling asked nobody
to re-spell anything. The comment marking the divergence is rewritten from
"unruled, do not touch" to "ruled, folding case is the checker's job".

check_layer_conformance.py would have rejected the conforming declaration this
ruling produces -- it listed standard_version as a required key. It now reads
INTENT.md as the governing form, ASCII-folds before comparing, validates both
values against the closed four-token vocabulary (Taxonomy included; omitting it
is the defect A9 records against the estate's other validator), requires the
derived marking, rejects a returning standard_version in either file, and
reports a post-fold disagreement between the forms as a finding rather than
resolving it away by precedence.

The test asserts the fold, not equality. An equality assertion here would be
this repository quietly performing the re-spelling the ruling declined to order;
the fold still fails on a real layer divergence.

pep-stance.yaml is untouched. A stance map is not a layer declaration, and the
sidecar schema beyond the derived marking and the version is explicitly not
ruled.

layer.yaml is the form seven repositories copied, so the adopter change set is
written out in wiki/playbooks/netkingdom-layer-declaration.md -- including the
trap that an adopter which also copied the checker turns a conforming
declaration into MALFORMED exit 2 by removing the field alone. No other
repository is edited here.

Still open: where the removed version lives. A12 says the derived conformance
record "already MUST" carry it; ops-warden has a re-runnable checker that emits
nothing durable. Asked of gate-house in message 4220413a, unanswered, and left
open rather than answered by choosing. Nothing above depends on it.

Carries WARDEN-WP-0034-T06 to done.

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

tests/test_layer_conformance.py

@@ -25,15 +25,62 @@ def _decl() -> dict:
     return yaml.safe_load((ROOT / "layer.yaml").read_text())
 
 
+def _intent_frontmatter() -> dict:
+    lines = (ROOT / "INTENT.md").read_text().splitlines()
+    assert lines[0].strip() == "---", "INTENT.md must carry frontmatter — it is the declaration"
+    end = next(i for i, ln in enumerate(lines[1:], 1) if ln.strip() == "---")
+    return yaml.safe_load("\n".join(lines[1:end]))
+
+
+def _fold(value: str) -> str:
+    return str(value).strip().encode("ascii", "ignore").decode().lower()
+
+
 class TestDeclaration:
     def test_declares_staff_layer_in_its_own_voice(self):
         d = _decl()
         assert d["repository"] == "ops-warden"
-        assert d["layer"] == "staff"
-        assert d["standard_version"] == "0.7"
+        assert _fold(d["layer"]) == "staff"
         # §11: "only the repository's own file, in its own voice, conforms."
         assert d["declared_by"] == "docs/adr/ADR-0010"
 
+    def test_intent_md_carries_the_governing_declaration(self):
+        """GH-DEC-2026-017 §1 / A11: INTENT.md's frontmatter is the declaration."""
+        assert _fold(_intent_frontmatter()["layer"]) == "staff"
+
+    def test_sidecar_is_marked_derived_and_names_its_source(self):
+        """§11's derived-artifact rule, applied to the layer sidecar."""
+        d = _decl()
+        assert d["derived"] is True
+        assert d["derived_from"] == "INTENT.md"
+
+    def test_the_two_forms_agree_once_case_is_folded(self):
+        """A11: the derived form must agree; A9: comparison folds case.
+
+        `Staff` in INTENT.md and `staff` in layer.yaml are the SAME value. This
+        test is deliberately a fold rather than an equality: the ruling asked
+        nobody to re-spell anything, and an equality assertion here would be this
+        repository quietly doing the re-spelling the ruling declined to order.
+        The next *real* divergence — a different layer — still fails.
+        """
+        assert _fold(_decl()["layer"]) == _fold(_intent_frontmatter()["layer"])
+
+    def test_layer_is_in_section_3_closed_vocabulary(self):
+        """A9: {Taxonomy, Tooling, Engine, Staff}, closed, case-insensitive."""
+        vocabulary = {"taxonomy", "tooling", "engine", "staff"}
+        assert _fold(_intent_frontmatter()["layer"]) in vocabulary
+        assert _fold(_decl()["layer"]) in vocabulary
+
+    def test_no_declaration_carries_a_standard_version(self):
+        """GH-DEC-2026-017 §5 / A12 — and the regression guard on its return.
+
+        The field was removed from the estate's reference form, not just from
+        this file. A field that is present will be branched on, so absence is
+        asserted rather than trusted.
+        """
+        assert "standard_version" not in _decl()
+        assert "standard_version" not in _intent_frontmatter()
+
     def test_every_tooling_contact_maps_to_a_declared_shape(self):
         """§11 mechanical check — the guard against a new undeclared client."""
         result = subprocess.run(