Normalize a Bare CR Too, Through One Helper Both Digests Share

`payload_digest` reduced CRLF and left a bare CR alone, while the installer
reads a snippet in text mode, where a bare CR arrives as a newline and
installs as one. A snippet carrying CR-only endings therefore installed
normalized content and hashed to something else, and the machine was
reported STALE against its own content.

Four sites were doing this replacement by hand and two of them disagreed,
which is the arrangement that produced the defect. They all call one helper
now, so the two digests cannot normalize differently.

Two cases added. The first builds the CR-only variant from the normalized
form rather than by replacing newlines in the file, because these snippets
are CRLF in this repository and a blind replace produces a doubled CR
rather than a bare one. My first version of that test made exactly that
mistake and failed against the fixed code.

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

Author: ptr727

host-setup/agent-safety/install.py

@@ -136,6 +136,19 @@ def git(*args):
     return ref
 
 
+def normalized(data):
+    """Line endings reduced to newlines, covering CRLF and a bare CR.
+
+    One helper rather than a replace at each site. Both digests have to normalize identically or a
+    machine drifts on nothing, and a site that handled CRLF while missing CR did exactly that: the
+    installer reads a snippet in text mode, so a bare CR arrives as a newline and installs as one,
+    while a digest that left it alone reported the machine STALE against its own content.
+    """
+    if isinstance(data, bytes):
+        return data.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
+    return data.replace("\r\n", "\n").replace("\r", "\n")
+
+
 def payload_digest():
     """One digest over the content this kit installs, normalized the way the installer writes it.
 
@@ -150,7 +163,7 @@ def payload_digest():
     """
     h = hashlib.sha256()
     for name in PAYLOAD_FILES:
-        raw = (HERE / name).read_bytes().replace(b"\r\n", b"\n")
+        raw = normalized((HERE / name).read_bytes())
         # A snippet is embedded stripped, so trailing whitespace is not installed content.
         # The hook is copied byte for byte, so nothing about it is stripped.
         if name.endswith(".md"):
@@ -213,8 +226,8 @@ def installed_digest(claude_home):
     if not hook.is_file() or not claude_md.is_file():
         return None
     h = hashlib.sha256()
-    h.update(hook.read_bytes().replace(b"\r\n", b"\n"))
-    text = claude_md.read_text(encoding="utf-8", errors="replace").replace("\r\n", "\n")
+    h.update(normalized(hook.read_bytes()))
+    text = normalized(claude_md.read_text(encoding="utf-8", errors="replace"))
     for marker in ("agent-safety", "fleet-bootstrap"):
         found = re.search(rf"<!-- {marker} v\d+ start -->.*?<!-- {marker} v\d+ end -->", text, re.DOTALL)
         if not found:
@@ -536,7 +549,7 @@ def reject(where, held, want):
     if claude_md.exists():
         raw = claude_md.read_bytes()
         newline = "\r\n" if b"\r\n" in raw else "\n"
-        existing = raw.decode("utf-8").replace("\r\n", "\n").replace("\r", "\n")
+        existing = normalized(raw.decode("utf-8"))
     else:
         newline, existing = "\n", ""
     for marker, filename in blocks:

host-setup/agent-safety/test_install.py

@@ -412,6 +412,29 @@ def test_trailing_whitespace_on_a_snippet_is_not_reported_as_drift(self):
         finally:
             target.write_bytes(original)
 
+    def test_a_bare_cr_in_a_snippet_is_not_reported_as_drift(self):
+        """The installer reads snippets in text mode, so a bare CR arrives and installs as a newline.
+
+        A digest normalizing CRLF but not CR reported the machine STALE against its own content.
+        """
+        baseline = install.payload_digest()
+        target = HERE / "claude-md-safety.md"
+        original = target.read_bytes()
+        try:
+            # Built from the normalized form, since the snippets are CRLF in this repo.
+            # A blind newline replace would turn each CRLF into a doubled CR rather than a bare one.
+            target.write_bytes(install.normalized(original).replace(b"\n", b"\r"))
+            self.assertEqual(install.payload_digest(), baseline)
+        finally:
+            target.write_bytes(original)
+
+    def test_every_normalization_site_agrees(self):
+        """The two digests must normalize identically, or a machine drifts against nothing."""
+        for raw, want in ((b"a\r\nb", b"a\nb"), (b"a\rb", b"a\nb"), (b"a\nb", b"a\nb")):
+            self.assertEqual(install.normalized(raw), want)
+        for raw, want in (("a\r\nb", "a\nb"), ("a\rb", "a\nb"), ("a\nb", "a\nb")):
+            self.assertEqual(install.normalized(raw), want)
+
     def test_a_real_edit_to_a_snippet_is_still_reported(self):
         """The normalization must not swallow a change that does reach the installed block."""
         baseline = install.payload_digest()