fix: close two audit-residual gaps — Python YAML byte-compare + LF .gitattributes

Two persistent gaps surfaced by the conformance-framework QA audit
(2026-05-26). Neither blocks current tests, but both are real
contract-violation footguns waiting to surface.

1. Python YAML conformance was comparing parsed JSON trees, not canonical
bytes. The canonical-serializer contract (spec/conformance-tests.md:54-84)
specifies 2-space indent, alphabetically-sorted @-attrs,
declaration-ordered children, and a trailing newline — ALL part of the
cross-port byte-exact contract. A tree compare would silently pass
regressions in any of these. TS does `expect(got).toBe(want)`; C# + Java
do trimmed-string compare. Python now matches: byte-compare with only
trailing-newline normalization.

2. Added a top-level .gitattributes forcing LF line endings on
fixtures/** and *.mustache files. Without this, a Windows clone with
default `core.autocrlf=true` silently converts these to CRLF on
checkout, then byte-equality assertions fail for filesystem reasons
rather than engine reasons. Render-conformance is particularly exposed:
its whole reason-for-being is byte-exact rendered output to defend
prompt-cache hits.

Verification:
- Python YAML conformance: 6/6 still green (assertion shape changed,
  fixtures already correct under LF)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

.gitattributes

@@ -0,0 +1,16 @@
+# Conformance fixtures rely on byte-exact cross-port comparison. Force LF on
+# all fixture inputs/outputs so a Windows clone with default
+# `core.autocrlf=true` doesn't silently rewrite line endings and break the
+# byte-equality gate for filesystem reasons rather than engine reasons.
+#
+# Files affected:
+# - fixtures/conformance/*/expected.json + input/*.json (canonical metamodel)
+# - fixtures/yaml-conformance/*/{input.yaml,expected.json}
+# - fixtures/render-conformance/*/{expected.txt,template.mustache,payload.json,meta.json}
+# - fixtures/verify-conformance/*/{template.mustache,payload.json,expected-drift.json,options.json,partials/*.mustache}
+# - fixtures/persistence-conformance/**/*.yaml
+fixtures/** text eol=lf
+
+# Mustache templates carry cross-port byte-exact contracts elsewhere too
+# (test resources, snapshots).
+*.mustache text eol=lf

server/python/tests/conformance/test_yaml_conformance.py

@@ -122,10 +122,16 @@ def test_yaml_conformance(fix: YamlFixture) -> None:
         assert codes == [], (
             f"{fix.name}: expected no errors but got {codes}"
         )
-        want_tree = json.loads((fix.dir / "expected.json").read_text())
-        got_tree = json.loads(canonical)
-        assert got_tree == want_tree, (
-            f"{fix.name}: canonical mismatch\n"
-            f"  want: {json.dumps(want_tree, indent=2, sort_keys=True)}\n"
-            f"  got:  {json.dumps(got_tree, indent=2, sort_keys=True)}"
+        # Byte-compare per the canonical-serializer contract
+        # (spec/conformance-tests.md): 2-space indent, sorted @-attrs,
+        # declaration-ordered children, trailing newline are ALL part of the
+        # cross-port contract. A tree compare would silently pass regressions
+        # in any of these. Trim only the trailing newline so authors don't
+        # have to fight editors-that-trim. TS does `expect(got).toBe(want)`;
+        # C# + Java do trimmed-string compare. Python now matches.
+        want = (fix.dir / "expected.json").read_text(encoding="utf-8")
+        assert canonical.strip() == want.strip(), (
+            f"{fix.name}: canonical byte mismatch\n"
+            f"--- want ---\n{want}\n"
+            f"--- got ---\n{canonical}"
         )