Add honest SDA deployment-source evidence

README.md

@@ -100,14 +100,23 @@ receipt — never inflated.**
 
 ## Tech / sovereignty
 
-Pure static HTML/CSS/JS. **0 runtime CDN** — `three.js` r160 (MIT) is **vendored** locally under
+Static HTML/CSS/JS behind a small hardened read-only Python file server. **0 runtime CDN** — `three.js` r160 (MIT) is **vendored** locally under
 `assets/three.module.min.js` (see `assets/THREE_LICENSE.txt`). The COP canvas, score panel, verify widget,
-and fabric reader are self-contained. **System fonts only** (Calibri / system-ui stack). No server,
-no build step.
+and fabric reader are self-contained. **System fonts only** (Calibri / system-ui stack). There is no
+application database, write API, or frontend build step.
 
 Mobile system per the estate mobile spec: ≥12px font floor, ≥44px tap targets, `safe-area-inset`,
 0px horizontal overflow at 320/360/390/768, `prefers-reduced-motion`, WCAG AA.
 
+### Deployment-source evidence
+
+`GET /.well-known/szl-source.json` reports the measured Hugging Face repository head and the
+source-resolution boundary. The inferred name-matched repository `szl-holdings/sda` returned GitHub
+`404`, so the document states `PENDING_SOURCE_RESOLUTION` / `UNKNOWN`, leaves `source.commit` null,
+and explicitly does not claim GitHub parity, a reproducible build, or exact serving-process provenance.
+`?refresh=1` bypasses the short repository-head cache. The response is read-only, `no-store`, and
+inherits the same security headers as the rest of the Space.
+
 ## Branding
 
 Deep-space dark, teal `#01696F` / cyan `#3DD6FF` / violet `#7C5CFF` glow, glassmorphism, system fonts —

server.py

@@ -18,10 +18,32 @@ read-only cross-origin verify fetches to a-11-oy.com and killinchu, so the
 WebGL scene and the SDA verify widget keep working.
 """
 import functools
+import json
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import parse_qs, urlsplit
+
+from szl_source_attestation import build_attestation
 
 PORT = 7860
 DIRECTORY = "/app"
+SPACE_ID = "SZLHOLDINGS/sda"
+HF_OVERLAY_BASE_REVISION = "05cd77a1e728f59ab920e04bd632e7ff64a25b2e"
+SOURCE_OBSERVATION = {
+    "repository": "szl-holdings/sda",
+    "commit": None,
+    "path": "",
+    "state": "PENDING_SOURCE_RESOLUTION",
+    "relation": "UNKNOWN",
+    "evidence_url": "https://api.github.com/repos/szl-holdings/sda",
+    "observation": {
+        "observed_at": "2026-07-11T22:00:20Z",
+        "http_status": 404,
+        "meaning": (
+            "The inferred name-matched GitHub repository was not found. "
+            "No source commit or parity claim is available."
+        ),
+    },
+}
 
 CONTENT_SECURITY_POLICY = (
     "default-src 'self'; "
@@ -44,6 +66,33 @@ class HardenedHandler(SimpleHTTPRequestHandler):
     def version_string(self):
         return "szl"
 
+    def _send_json(self, payload, status=200):
+        body = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        self.send_response(status)
+        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", "REACHABLE")
+        self.send_header("X-SZL-Evidence-State", payload.get("evidence_state", "UNAVAILABLE"))
+        self.send_header("X-SZL-Authority-State", "READ_ONLY")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        parsed = urlsplit(self.path)
+        if parsed.path == "/.well-known/szl-source.json":
+            force = parse_qs(parsed.query).get("refresh", ["0"])[0] == "1"
+            payload = build_attestation(
+                space_id=SPACE_ID,
+                source=SOURCE_OBSERVATION,
+                alignment_state="UNKNOWN",
+                overlay_base_revision=HF_OVERLAY_BASE_REVISION,
+                force=force,
+            )
+            self._send_json(payload)
+            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,135 @@
+"""Honest deployment-source evidence for a public Hugging Face Space.
+
+The Hugging Face repository head is measured independently from GitHub source
+observations. A source reference never implies byte parity, a reproducible
+build, or proof of the exact process revision during a rolling deployment.
+"""
+from __future__ import annotations
+
+import json
+import re
+import threading
+import time
+import urllib.request
+from datetime import datetime, timezone
+from typing import Any
+
+
+_SHA = re.compile(r"^[0-9a-f]{40}$")
+_CACHE_LOCK = threading.Lock()
+_CACHE: dict[str, dict[str, Any]] = {}
+
+
+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_head(space_id: str, force: bool = False) -> dict[str, Any]:
+    """Measure the Hub repository head; never label it as process provenance."""
+    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"])
+
+    endpoint = (
+        f"https://huggingface.co/api/spaces/{space_id}"
+        "?expand[]=sha&expand[]=lastModified"
+    )
+    request = urllib.request.Request(
+        endpoint,
+        headers={
+            "Accept": "application/json",
+            "User-Agent": "szl-source-attestation/2.0",
+        },
+    )
+    revision = None
+    last_modified = None
+    error = None
+    try:
+        with urllib.request.urlopen(request, timeout=4) as response:
+            payload = json.load(response)
+        revision = _valid_sha(payload.get("sha"))
+        candidate_time = payload.get("lastModified")
+        if isinstance(candidate_time, str) and "T" in candidate_time:
+            last_modified = candidate_time
+    except Exception as exc:  # the contract reports unavailability, never guesses
+        error = type(exc).__name__
+
+    measurement: dict[str, Any] = {
+        "hf_revision": revision,
+        "last_modified": last_modified,
+        "observed_at": _now_iso(),
+        "state": "MEASURED" if revision else "UNAVAILABLE",
+        "method": "HUGGINGFACE_API" if revision else "UNAVAILABLE",
+        "resolver": endpoint,
+    }
+    if error:
+        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, Any],
+    alignment_state: str,
+    overlay_base_revision: str,
+    force: bool = False,
+) -> dict[str, Any]:
+    measurement = measure_hf_head(space_id, force=force)
+    revision = measurement["hf_revision"]
+    return {
+        "schema": "szl.deployment-source/v1",
+        "source": dict(source),
+        "deployment": {
+            "hf_space": space_id,
+            "hf_revision": revision,
+        },
+        "built_at": measurement["last_modified"],
+        "observed_at": measurement["observed_at"],
+        "transport_state": "REACHABLE",
+        "evidence_state": "COMPUTED" if revision else "UNAVAILABLE",
+        "verification_state": "STRUCTURAL_ONLY",
+        "authority_state": "READ_ONLY",
+        "alignment_state": alignment_state,
+        "attestation_state": "UNSIGNED_STRUCTURAL",
+        "claims": {
+            "github_parity": "NOT_CLAIMED",
+            "reproducible_build": "NOT_CLAIMED",
+            "running_process_revision": "NOT_CLAIMED",
+        },
+        "extensions": {
+            "schema": "szl.deployment-source-evidence/v1",
+            "deployment_revision_evidence": {
+                **measurement,
+                "semantics": (
+                    "Measured Hugging Face repository head; external verification "
+                    "must confirm runtime SHA convergence after deployment."
+                ),
+            },
+            "overlay": {
+                "base_revision": overlay_base_revision,
+                "base_revision_semantics": (
+                    "Hugging Face head inspected before this attestation overlay."
+                ),
+            },
+        },
+        "limits": [
+            "The Hugging Face revision is measured independently from GitHub evidence.",
+            "A GitHub observation does not establish deployed-artifact equivalence.",
+            "Repository-head evidence is not proof of the exact process revision during a rolling deploy.",
+            "This unsigned structural document does not establish SLSA provenance or reproducible builds.",
+        ],
+    }
+

tests/test_source_attestation.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import functools
+import json
+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
+import szl_source_attestation  # noqa: E402
+
+
+MEASUREMENT = {
+    "hf_revision": "a" * 40,
+    "last_modified": "2026-07-11T22:00:00.000Z",
+    "observed_at": "2026-07-11T22:00:01Z",
+    "state": "MEASURED",
+    "method": "TEST_FIXTURE",
+    "resolver": "https://example.invalid/hf-head",
+}
+
+
+class SourceAttestationTests(unittest.TestCase):
+    def test_unknown_source_never_invents_commit_or_parity(self):
+        with patch.object(szl_source_attestation, "measure_hf_head", return_value=MEASUREMENT):
+            payload = szl_source_attestation.build_attestation(
+                space_id=server.SPACE_ID,
+                source=server.SOURCE_OBSERVATION,
+                alignment_state="UNKNOWN",
+                overlay_base_revision=server.HF_OVERLAY_BASE_REVISION,
+            )
+        self.assertIsNone(payload["source"]["commit"])
+        self.assertEqual("PENDING_SOURCE_RESOLUTION", payload["source"]["state"])
+        self.assertEqual("UNKNOWN", payload["source"]["relation"])
+        self.assertEqual("UNKNOWN", payload["alignment_state"])
+        self.assertEqual("NOT_CLAIMED", payload["claims"]["github_parity"])
+        self.assertEqual("a" * 40, payload["deployment"]["hf_revision"])
+
+    def test_well_known_route_is_json_no_store_and_hardened(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.object(szl_source_attestation, "measure_hf_head", return_value=MEASUREMENT):
+                with urlopen(
+                    f"http://127.0.0.1:{httpd.server_port}/.well-known/szl-source.json?refresh=1",
+                    timeout=3,
+                ) as response:
+                    payload = json.load(response)
+                    self.assertEqual(200, response.status)
+                    self.assertEqual("application/json; charset=utf-8", response.headers["Content-Type"])
+                    self.assertEqual("no-store", response.headers["Cache-Control"])
+                    self.assertEqual("nosniff", response.headers["X-Content-Type-Options"])
+                    self.assertIn("default-src 'self'", response.headers["Content-Security-Policy"])
+                    self.assertEqual("COMPUTED", response.headers["X-SZL-Evidence-State"])
+                    self.assertEqual("UNKNOWN", payload["alignment_state"])
+        finally:
+            httpd.shutdown()
+            httpd.server_close()
+            thread.join(timeout=3)
+
+
+if __name__ == "__main__":
+    unittest.main()
+