Add honest deployment-source attestation

README.md

@@ -79,6 +79,10 @@ Part of the **SZL Holdings** governed-AI estate — *governed AI you can prove*:
 
 - **Flagship:** [a11oy command console → a-11-oy.com](https://a-11-oy.com)
 - **Orgs:** [GitHub · szl-holdings](https://github.com/szl-holdings) · [Hugging Face · SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS)
+
+## Deployment-source attestation
+
+`GET /.well-known/szl-source.json` reports the measured Hugging Face deployment revision. No verifiable direct GitHub source is currently declared, so the source relation remains `UNKNOWN_SOURCE_RELATION`; GitHub parity and reproducible builds are explicitly `NOT_CLAIMED`.
 - **Related Spaces:** [◇ holographic](https://huggingface.co/spaces/SZLHOLDINGS/holographic) · [🫀 anatomy](https://huggingface.co/spaces/SZLHOLDINGS/anatomy) · [🦅 killinchu](https://huggingface.co/spaces/SZLHOLDINGS/killinchu)
 
 **Status:** responding as of 2026-07-09 (HF Space root probe, this session).

server.py

@@ -17,10 +17,23 @@ verify fetches to a11oy / killinchu / a-11-oy.com), so the hologram and the live
 HUD keep working. Everything else is 'self' — zero CDN.
 """
 import functools
+import json
+import urllib.parse
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 
+from szl_source_attestation import build_attestation
+
 PORT = 7860
 DIRECTORY = "/app"
+SPACE_ID = "SZLHOLDINGS/cosmos"
+SOURCE_OBSERVATION = {
+    "repository": None,
+    "commit": None,
+    "path": None,
+    "relation": "no-verifiable-direct-source-observed",
+    "state": "UNKNOWN",
+    "evidence_url": None,
+}
 
 CONTENT_SECURITY_POLICY = (
     "default-src 'self'; "
@@ -37,6 +50,33 @@ CONTENT_SECURITY_POLICY = (
 
 
 class HardenedHandler(SimpleHTTPRequestHandler):
+    def _send_json(self, payload):
+        body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("X-SZL-Transport-State", str(payload["transport_state"]))
+        self.send_header("X-SZL-Evidence-State", str(payload["evidence_state"]))
+        self.send_header("X-SZL-Verification-State", str(payload["verification_state"]))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        parsed = urllib.parse.urlsplit(self.path)
+        if parsed.path == "/.well-known/szl-source.json":
+            force = urllib.parse.parse_qs(parsed.query).get("refresh") == ["1"]
+            self._send_json(
+                build_attestation(
+                    SPACE_ID,
+                    SOURCE_OBSERVATION,
+                    "UNKNOWN_SOURCE_RELATION",
+                    force=force,
+                )
+            )
+            return
+        super().do_GET()
+
     def end_headers(self):
         self.send_header("Content-Security-Policy", CONTENT_SECURITY_POLICY)
         self.send_header(

szl_source_attestation.py

@@ -0,0 +1,98 @@
+"""Honest deployment-source attestation shared by the small public Spaces.
+
+The deployed Hugging Face revision is measured independently of any GitHub
+source observation.  A source reference never implies artifact parity or a
+reproducible build.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+import time
+import urllib.request
+from datetime import datetime, timezone
+
+
+_SHA = re.compile(r"^[0-9a-f]{40}$")
+_CACHE_LOCK = threading.Lock()
+_CACHE: dict[str, dict[str, object]] = {}
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _valid_sha(value: object) -> str | None:
+    candidate = str(value or "").strip().lower()
+    return candidate if _SHA.fullmatch(candidate) else None
+
+
+def measure_hf_revision(space_id: str, force: bool = False) -> dict[str, object]:
+    env_revision = _valid_sha(os.environ.get("SPACE_REPOSITORY_COMMIT"))
+    if env_revision:
+        return {
+            "hf_revision": env_revision,
+            "revision_state": "MEASURED",
+            "measurement_method": "SPACE_REPOSITORY_COMMIT",
+        }
+
+    now = time.monotonic()
+    with _CACHE_LOCK:
+        cached = _CACHE.get(space_id)
+        if not force and cached and now - float(cached["stored_at"]) < 60:
+            return dict(cached["measurement"])  # type: ignore[arg-type]
+
+    revision = None
+    error = None
+    req = urllib.request.Request(
+        f"https://huggingface.co/api/spaces/{space_id}?expand[]=sha",
+        headers={"Accept": "application/json", "User-Agent": "szl-source-attestation/1.0"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=4) as response:
+            revision = _valid_sha(json.load(response).get("sha"))
+    except Exception as exc:
+        error = type(exc).__name__
+
+    measurement: dict[str, object] = {
+        "hf_revision": revision,
+        "revision_state": "MEASURED" if revision else "UNAVAILABLE",
+        "measurement_method": "HUGGINGFACE_API" if revision else "UNAVAILABLE",
+    }
+    if error:
+        measurement["measurement_error"] = error
+    with _CACHE_LOCK:
+        _CACHE[space_id] = {"stored_at": time.monotonic(), "measurement": dict(measurement)}
+    return measurement
+
+
+def build_attestation(
+    space_id: str,
+    source: dict[str, object],
+    alignment_state: str,
+    force: bool = False,
+) -> dict[str, object]:
+    measurement = measure_hf_revision(space_id, force=force)
+    return {
+        "schema": "szl.deployment-source/v1",
+        "observed_at": _now_iso(),
+        "transport_state": "REACHABLE",
+        "evidence_state": "COMPUTED" if measurement["hf_revision"] else "UNAVAILABLE",
+        "verification_state": "STRUCTURAL_ONLY",
+        "authority_state": "READ_ONLY",
+        "source": dict(source),
+        "deployment": {"hf_space": space_id, **measurement},
+        "alignment_state": alignment_state,
+        "attestation_state": "UNSIGNED_STRUCTURAL",
+        "claims": {
+            "github_parity": "NOT_CLAIMED",
+            "reproducible_build": "NOT_CLAIMED",
+        },
+        "limits": [
+            "The Hugging Face revision is measured independently from the source observation.",
+            "A GitHub reference does not establish deployed-artifact equivalence.",
+            "This unsigned structural attestation does not claim a reproducible build or GitHub parity.",
+        ],
+    }

tests/test_source_attestation.py

@@ -0,0 +1,57 @@
+import functools
+import json
+import os
+import sys
+import threading
+import unittest
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+from unittest.mock import patch
+from urllib.request import urlopen
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+import server  # noqa: E402
+
+
+class SourceAttestationTests(unittest.TestCase):
+    def test_unknown_source_does_not_claim_parity(self):
+        with patch.dict(os.environ, {"SPACE_REPOSITORY_COMMIT": "a" * 40}):
+            payload = server.build_attestation(
+                server.SPACE_ID,
+                server.SOURCE_OBSERVATION,
+                "UNKNOWN_SOURCE_RELATION",
+            )
+        self.assertEqual("szl.deployment-source/v1", payload["schema"])
+        self.assertEqual("a" * 40, payload["deployment"]["hf_revision"])
+        self.assertEqual("MEASURED", payload["deployment"]["revision_state"])
+        self.assertEqual("UNKNOWN", payload["source"]["state"])
+        self.assertIsNone(payload["source"]["repository"])
+        self.assertEqual("NOT_CLAIMED", payload["claims"]["github_parity"])
+        self.assertEqual("NOT_CLAIMED", payload["claims"]["reproducible_build"])
+
+    def test_well_known_route_returns_uncacheable_json(self):
+        handler = functools.partial(server.HardenedHandler, directory=str(ROOT))
+        httpd = ThreadingHTTPServer(("127.0.0.1", 0), handler)
+        thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+        thread.start()
+        try:
+            with patch.dict(os.environ, {"SPACE_REPOSITORY_COMMIT": "b" * 40}):
+                with urlopen(
+                    f"http://127.0.0.1:{httpd.server_port}/.well-known/szl-source.json",
+                    timeout=3,
+                ) as response:
+                    payload = json.load(response)
+                    self.assertEqual(200, response.status)
+                    self.assertEqual("no-store", response.headers["Cache-Control"])
+                    self.assertEqual("COMPUTED", response.headers["X-SZL-Evidence-State"])
+                    self.assertEqual("b" * 40, payload["deployment"]["hf_revision"])
+        finally:
+            httpd.shutdown()
+            httpd.server_close()
+            thread.join(timeout=3)
+
+
+if __name__ == "__main__":
+    unittest.main()