deploy(hf): sync szl-holdings/a11oy@6acc6c7522620b51915373c278d52c7a95ffb3bd derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy 6acc6c7522620b51915373c278d52c7a95ffb3bd.
Files: 1353 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

a11oy_command_center.py

@@ -10,12 +10,21 @@ Additive tabs:
   GET+HEAD /command
   GET+HEAD /command/constellation
   GET+HEAD /command/brain
+  GET+HEAD /constellation   (host-root; declared so SPA fallback cannot 404 it)
   GET+HEAD /command/{rest}
+
+Host-root /brain is Hickok dual-stream. Do not steal it.
 """
 from pathlib import Path
 from typing import List
 
 MOUNTS = ("/command",)
+SPECIFIC = (
+    ("/command/constellation", "constellation.html"),
+    ("/command/brain", "second-brain.html"),
+    ("/constellation", "constellation.html"),
+)
+CATCHALL = "/command/{rest:path}"
 
 
 def _spa_path() -> Path:
@@ -49,12 +58,24 @@ def _existing_paths(app) -> set:
         return set()
 
 
-def _front_move(app, paths: set) -> None:
+def _drop_paths(app, paths: set) -> None:
+    """Remove exact path registrations so we can replace SPA stubs."""
     router = getattr(app, "router", app)
     routes = getattr(router, "routes", None)
     if not routes:
         return
-    chosen = [r for r in routes if getattr(r, "path", None) in paths]
+    keep = [r for r in list(routes) if getattr(r, "path", None) not in paths]
+    routes[:] = keep
+
+
+def _front_move(app, paths: list) -> None:
+    """Park exact routes at the front, in given order. Never include the catch-all."""
+    router = getattr(app, "router", app)
+    routes = getattr(router, "routes", None)
+    if not routes:
+        return
+    wanted = set(paths)
+    chosen = [r for r in routes if getattr(r, "path", None) in wanted]
     if not chosen:
         return
     for r in chosen:
@@ -62,6 +83,8 @@ def _front_move(app, paths: set) -> None:
             routes.remove(r)
         except ValueError:
             pass
+    order = {p: i for i, p in enumerate(paths)}
+    chosen.sort(key=lambda r: order.get(getattr(r, "path", ""), 99))
     for r in reversed(chosen):
         routes.insert(0, r)
 
@@ -73,7 +96,7 @@ def register(app, ns: str = "a11oy") -> List[str]:
     if not spa.is_file():
         return [f"command-center SPA missing at {spa}"]
 
-    from starlette.responses import FileResponse
+    from starlette.responses import FileResponse, JSONResponse
     from starlette.routing import Route
 
     async def _spa(_request=None, rest: str = ""):
@@ -85,15 +108,24 @@ def register(app, ns: str = "a11oy") -> List[str]:
             page = _page(name)
             if page.is_file():
                 return FileResponse(page, media_type="text/html; charset=utf-8")
-            return FileResponse(spa, media_type="text/html; charset=utf-8")
+            return JSONResponse(
+                {
+                    "status": "NOT_FOUND",
+                    "reason": "constellation page missing from image",
+                    "page": name,
+                },
+                status_code=404,
+            )
         return _handler
 
+    specific_paths = {path for path, _name in SPECIFIC}
+    _drop_paths(app, specific_paths)
     existing = _existing_paths(app)
     mounted: set = set()
     router = getattr(app, "router", app)
 
     def _add(path: str, handler, methods: List[str]) -> None:
-        if path in existing and path != "/command/{rest:path}":
+        if path in existing and path != CATCHALL:
             registered.append("%s already registered (skipped)" % path)
             return
         try:
@@ -106,14 +138,11 @@ def register(app, ns: str = "a11oy") -> List[str]:
 
     for path in MOUNTS:
         _add(path, _spa, ["GET", "HEAD"])
-    _add("/command/constellation", _file("constellation.html"), ["GET", "HEAD"])
-    _add("/command/brain", _file("second-brain.html"), ["GET", "HEAD"])
-    _add("/command/{rest:path}", _spa, ["GET", "HEAD"])
-    _front_move(
-        app,
-        mounted | set(MOUNTS) | {"/command/constellation", "/command/brain", "/command/{rest:path}"},
-    )
-    registered.append("command-center on /command (does not steal /console; not a landing door)")
+    for path, name in SPECIFIC:
+        _add(path, _file(name), ["GET", "HEAD"])
+    _add(CATCHALL, _spa, ["GET", "HEAD"])
+    _front_move(app, [path for path, _name in SPECIFIC] + list(MOUNTS))
+    registered.append("command-center on /command (constellation/brain beat catch-all; /brain host-root untouched)")
     return registered
 
 
@@ -137,7 +166,10 @@ def _selftest() -> None:
     async def _console(_req):
         return HTMLResponse("<html><body>operator console</body></html>")
 
-    app = Starlette(routes=[Route("/console", _console)])
+    async def _hickok(_req):
+        return HTMLResponse("<html><body>Hickok dual-stream</body></html>")
+
+    app = Starlette(routes=[Route("/console", _console), Route("/brain", _hickok)])
     out = register(app, ns="a11oy")
     assert any("/command" in row for row in out), out
     c = TestClient(app)
@@ -145,14 +177,18 @@ def _selftest() -> None:
         r = c.get(path)
         assert r.status_code == 200, (path, r.status_code)
     if _page("constellation.html").is_file():
-        assert "Constellation" in c.get("/command/constellation").text
+        for path in ("/command/constellation", "/constellation"):
+            body = c.get(path).text
+            assert "Constellation" in body, path
+            assert "Control before capability" not in body
     if _page("second-brain.html").is_file():
         br = c.get("/command/brain")
         assert br.status_code == 200
         assert "Second Brain" in br.text
         assert "F1" in br.text
+    assert "Hickok" in c.get("/brain").text
     assert c.get("/console").status_code == 200
-    print("a11oy_command_center: ALL OK (brain + constellation additive; /console untouched)")
+    print("a11oy_command_center: ALL OK (constellation beats catch-all; /brain host-root untouched)")
 
 
 if __name__ == "__main__":

a11oy_deva_feeds.py

@@ -433,6 +433,55 @@ def _cached_fetch(key: str, url: str, ttl: float, parser=None,
     return result
 
 
+_READINESS_PUBLIC_FRESHNESS = frozenset({"live", "cached"})
+
+
+def _readiness_public_source(entry: Any) -> Any:
+    """Publish one DEV-A source wrapper under the readiness truth contract.
+
+    No-value failures remain explicit ``UNAVAILABLE`` evidence and carry the
+    instant at which the failure was observed. Last-good values may be served as
+    ``cached`` only when their original observation timestamp is retained.
+    """
+    normalized = entry
+    if _HAS_VF and hasattr(_vf, "_readiness_public_source"):
+        try:
+            normalized = _vf._readiness_public_source(entry)
+        except Exception:
+            normalized = entry
+    if not isinstance(normalized, dict):
+        return normalized
+    freshness = normalized.get("freshness")
+    if not isinstance(freshness, dict):
+        return normalized
+
+    out = dict(normalized)
+    public = dict(freshness)
+    status = str(public.get("status") or "").strip().lower()
+    if out.get("value") is None:
+        public["status"] = "UNAVAILABLE"
+        if public.get("fetched_at") is None:
+            public["fetched_at"] = datetime.now(timezone.utc).isoformat()
+        if not str(public.get("error") or "").strip():
+            public["error"] = "source returned no observed value"
+    elif status not in _READINESS_PUBLIC_FRESHNESS:
+        if public.get("fetched_at") is None:
+            age_s = public.get("age_s")
+            if (
+                isinstance(age_s, (int, float))
+                and not isinstance(age_s, bool)
+                and math.isfinite(float(age_s))
+            ):
+                observed = time.time() - max(0.0, float(age_s))
+                public["fetched_at"] = datetime.fromtimestamp(
+                    observed, tz=timezone.utc
+                ).isoformat()
+        if public.get("fetched_at") is not None:
+            public["status"] = "cached"
+    out["freshness"] = public
+    return out
+
+
 # ===========================================================================
 # GOVERNED TURN — delegate to the proven machinery in a11oy_vertical_feeds.
 # ===========================================================================
@@ -956,12 +1005,17 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict[str, Any]:
             (feed_dob_violations, (60,), {}),
             (feed_treasury, (8,), {}),
         ])
-        return JSONResponse({"tab": "pulse", "hpd": hpd, "dob": dob, "rates": rates, "doctrine": DOCTRINE})
+        return JSONResponse({"tab": "pulse",
+                             "hpd": _readiness_public_source(hpd),
+                             "dob": _readiness_public_source(dob),
+                             "rates": rates, "doctrine": DOCTRINE})
 
     @app.get(base + "/re/distress", include_in_schema=False)
     async def _re_distress(limit: Annotated[int, Query(ge=1, le=1000)] = 300):
         hpd = await _run_blocking(feed_hpd_violations, limit)
-        return JSONResponse({"tab": "distress", "hpd": hpd, "doctrine": DOCTRINE})
+        return JSONResponse({"tab": "distress",
+                             "hpd": _readiness_public_source(hpd),
+                             "doctrine": DOCTRINE})
 
     @app.get(base + "/re/ownership", include_in_schema=False)
     async def _re_ownership():

a11oy_vertical_feeds.py

@@ -1890,8 +1890,10 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict[str, Any]:
             (feed_nyc_dob, (30,), {}),
             (feed_treasury, (6,), {}),
         ])
-        return JSONResponse({"vertical": "realestate", "hpd_litigations": hpd,
-                             "dob_violations": dob, "rates": rates,
+        return JSONResponse({"vertical": "realestate",
+                             "hpd_litigations": _readiness_public_source(hpd),
+                             "dob_violations": _readiness_public_source(dob),
+                             "rates": rates,
                              "sources_cited": cited_leaders("realestate"), "doctrine": DOCTRINE})
 
     # ---- SHARED: governed turn, ledger, roi ----

console/assets/brain-frontier-v7.json

@@ -858,12 +858,12 @@
       "candidateState": "DISCOVERED_REVIEW_REQUIRED",
       "contentAccess": "HANDLES_ONLY",
       "kind": "source-document",
-      "nodeId": "frontier:2400e6eeb1096daf6c4408b350dedff5",
+      "nodeId": "frontier:0496b555a1c6096f645c095a54a520e4",
       "path": "README.md",
       "repository": "szl-holdings/anatomy",
-      "revision": "3c8aab384383314e284b19b24961ae976f01c44b",
-      "sha256": "0eb0ee280e428e95fbd1c12750fd020780cb4eff2d86233dcdd4348de43ecd19",
-      "title": "Living Anatomy · v7 — YACHAY Neural Quant brain"
+      "revision": "6422274e284c443f640c3899fc4dbb7947bd5b30",
+      "sha256": "140dfc00d2963fc95aa63751ea082ebbd6dca804bb2bb73fb2cd9f48ebeccf6b",
+      "title": "Living Anatomy · What's new in v4 — dissection tools"
     },
     {
       "admission": "DISCOVERED_REVIEW_REQUIRED",
@@ -871,12 +871,12 @@
       "candidateState": "DISCOVERED_REVIEW_REQUIRED",
       "contentAccess": "HANDLES_ONLY",
       "kind": "source-document",
-      "nodeId": "frontier:1619fc20c09f72750b5184231d7522c3",
+      "nodeId": "frontier:045f25cf150ad87033dfb108dfa82a0d",
       "path": "README.md",
-      "repository": "szl-holdings/ouroboros",
-      "revision": "62e9779edddb21694d27c1a7c2c8ccc74157949f",
-      "sha256": "551bcd8902903024117d834a808e1580bf03f75e201170f0895ae44aaa7db8bb",
-      "title": "Ouroboros Runtime · ▶️ Live demo"
+      "repository": "szl-holdings/szl-ouroboros",
+      "revision": "cd8a451ca2be19f71653dcb4ef50e15e6836e697",
+      "sha256": "5cc957baf65a8ca1a800824c68de6f683c3868d9cbbe511c4d39d9647a1bd74d",
+      "title": "Ouroboros Runtime · Continuous Codex frontier loop"
     },
     {
       "admission": "REFERENCE_ONLY_NO_PROVIDER_MUTATION",
@@ -917,6 +917,19 @@
       "sha256": "e4a5db4dd4999f9fff034f6206503e9193177ce93a5ed16c22b2f7809f343d59",
       "title": "Nemo Witness · R1–R5 prompt/answer contract"
     },
+    {
+      "admission": "DISCOVERED_REVIEW_REQUIRED",
+      "authority": "NONE",
+      "candidateState": "DISCOVERED_REVIEW_REQUIRED",
+      "contentAccess": "HANDLES_ONLY",
+      "kind": "source-document",
+      "nodeId": "frontier:01e71648eb1b513c4c8cede0232e2a9f",
+      "path": "README.md",
+      "repository": "szl-holdings/szl-kernels",
+      "revision": "45a56d0b132945e06a2d88a104f26c4840abebe2",
+      "sha256": "116e0b8e0097aed00e3c88c775bb1cebc73e047842ecfd38350dba36182e8483",
+      "title": "Governed Kernel Suite · Cookbook"
+    },
     {
       "admission": "REFERENCE_ONLY_EXECUTION_AUTHORITY_NONE",
       "authority": "NONE",
@@ -981,19 +994,6 @@
       "revision": "b37fa90cc48921f15883c23932cc6ded9152f9f1",
       "sha256": "f95df366bed6374733cb3f30ed9fff7d8a8912bc251039ee9a892bc82d2d4445",
       "title": "Public estate · PURIQ Finance"
-    },
-    {
-      "admission": "REFERENCE_ONLY_NO_PROVIDER_MUTATION",
-      "authority": "NONE",
-      "candidateState": "DISCOVERED_REVIEW_REQUIRED",
-      "contentAccess": "HANDLES_ONLY",
-      "kind": "estate-surface",
-      "nodeId": "frontier:35674d65c290943ac3dd4e32b6d79dbf",
-      "path": "governance/public-estate.v1.json",
-      "repository": "szl-holdings/a11oy",
-      "revision": "b37fa90cc48921f15883c23932cc6ded9152f9f1",
-      "sha256": "7180e76d943ebca11753704dad3f1480c559572dcdbd985c443809dadac1b49a",
-      "title": "Public estate · Lyte"
     }
   ],
   "loop": [
@@ -1005,13 +1005,13 @@
   ],
   "schema": "szl.a11oy.brain-frontier-holographic-v7/v1",
   "selected_handle_count": 72,
-  "snapshot_sha256": "a7fb19262db48f2b63c25e4c85718f6c3bb63fc08b565b7f9057ee5f45bb69d3",
+  "snapshot_sha256": "e8f600fad7b9bdc4d316e41946f78f89bb754bf193fd6613e3f9cfd4cc36f417",
   "sources": {
     "anatomy": {
       "holographic_v7_path": "/api/anatomy/v1/holographic-v7",
       "live_origin": "https://betterwithage-anatomy.hf.space",
       "repository": "szl-holdings/anatomy",
-      "revision": "3c8aab384383314e284b19b24961ae976f01c44b"
+      "revision": "075a2484c1e520d4e5767c1a2780de9bd8827e6c"
     },
     "formulas": {
       "repository": "szl-holdings/szl-formulas",
@@ -1020,15 +1020,15 @@
     "ouroboros": {
       "repository": "szl-holdings/szl-ouroboros",
       "review_workflow": ".github/workflows/codex-frontier-review.yml",
-      "revision": "baea67498d625d388fc12de0e1fa987185887a15"
+      "revision": "371b611716d459ca7e96d1bde7630c813bfcdd83"
     },
     "second_brain": {
-      "candidate_count": 123,
-      "candidate_file_sha256": "550343d1856832de87c45339a49ac831fa459e78f3919d0a72ae2ade5f2f7adb",
-      "candidate_set_sha256": "550343d1856832de87c45339a49ac831fa459e78f3919d0a72ae2ade5f2f7adb",
+      "candidate_count": 129,
+      "candidate_file_sha256": "fb15e2d2822a9afb445c3eae7e077a7c250a59565fdd395a9e11f2247b12a884",
+      "candidate_set_sha256": "fb15e2d2822a9afb445c3eae7e077a7c250a59565fdd395a9e11f2247b12a884",
       "repository": "szl-holdings/szl-second-brain",
-      "revision": "5d77a5b4705401e8d318b164a3076b4163f357e9",
-      "state_sha256": "cd96ca8f27cbfeccfdc1568e62c0f07e8adc4d5687d5fb288f6894419432e5fa"
+      "revision": "1d3960c69235f117b7ec2b5ea97472f81fb588f5",
+      "state_sha256": "ffafd9d7259aa3281fb00f40f13ff3fc4443cded40b026276414d09a6be61a39"
     }
   },
   "state": "SOURCE_BOUND_REVIEW_MEMORY",

szl_lyte_lattice.py

@@ -6,6 +6,7 @@ szl_lyte_lattice.py — BIND_AS_A11OY_PACKAGE status surface.
 
 Cites szl-holdings/lyte-lattice @ 9db7f25. Not a second flagship.
 Not a production certificate of a-11-oy.com.
+Also serves GET /unify flock ledger (KEEP/FOLD/UNIFY). Not a Hub Space.
 """
 from __future__ import annotations
 
@@ -66,6 +67,29 @@ _WAVES = [
     {"id": "W3", "name": "Plane edge", "cells": ["N19", "N20", "N21", "N22", "N23", "N24", "N25", "N26", "N27"], "admitted": 8, "blocked": 1},
 ]
 
+_FLOCK_KEEP = [
+    {"slug": "a11oy", "dest": "https://a-11-oy.com/console", "why": "Command Center. One front door."},
+    {"slug": "killinchu", "dest": "https://szlholdings-killinchu.hf.space/elite", "why": "Counter-UAS."},
+    {"slug": "immune", "dest": "https://a-11-oy.com/immune", "why": "SENTRA / YAWAR. Fold lattice here."},
+    {"slug": "lyte", "dest": "https://a-11-oy.com/lyte", "why": "Admitted observability cell."},
+    {"slug": "vertical-services", "dest": "https://a-11-oy.com/spaces", "why": "Five engines, one runtime."},
+]
+_FLOCK_FOLD = [
+    {"slug": "immune-lattice", "into": "immune"},
+    {"slug": "counsel", "into": "ayllu"},
+    {"slug": "ayllu", "into": "https://a11oy.net/ayllu/"},
+    {"slug": "sentra", "into": "vertical-services"},
+    {"slug": "finance", "into": "vertical-services"},
+    {"slug": "terra", "into": "vertical-services"},
+    {"slug": "david-leads", "into": "https://a-11-oy.com"},
+]
+_FLOCK_UNIFY = [
+    {"slug": "szl-command-lab", "into": "a11oy"},
+    {"slug": "szl-model-inference-lab", "into": "a11oy"},
+    {"slug": "szl-frontier", "into": "a11oy"},
+    {"slug": "szl-constellation", "into": "a11oy"},
+]
+
 
 def _unsigned_receipt(payload: Dict[str, Any]) -> Dict[str, Any]:
     blob = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
@@ -86,7 +110,6 @@ def _unsigned_receipt(payload: Dict[str, Any]) -> Dict[str, Any]:
 def _khipu_receipt(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     try:
         import szl_khipu  # type: ignore
-
         dag = szl_khipu.get_dag(_KHIPU_ORGAN, ns="a11oy")
         r = dag.emit("lyte-lattice.status", payload)
         signed = bool(r.get("signature"))
@@ -207,41 +230,97 @@ def status() -> Dict[str, Any]:
     return payload
 
 
-def register(app, ns: str = "a11oy") -> Dict[str, Any]:
-    from fastapi.responses import JSONResponse
+def unify_status() -> Dict[str, Any]:
+    payload: Dict[str, Any] = {
+        "ok": True,
+        "service": "unify-flock",
+        "state": "BIND",
+        "bind": _BIND,
+        "certified": False,
+        "proven_trust": False,
+        "hub_write": False,
+        "source": {"repo": _SOURCE, "sha": _SOURCE_SHA},
+        "product": {"url": "https://a-11-oy.com/unify", "certified": False},
+        "keep": _FLOCK_KEEP,
+        "fold": _FLOCK_FOLD,
+        "unify_stragglers": _FLOCK_UNIFY,
+        "policy": "pause+private, never delete",
+        "exact_name_duplicates": [],
+        "lambda": "Conjecture 1",
+        "note": "Flock ledger on the product. Not a new Hub Space.",
+    }
+    blob = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
+    payload["digest"] = hashlib.sha256(blob).hexdigest()
+    payload["signer"] = "UNSIGNED-honest"
+    return payload
 
+
+def unify_page() -> str:
+    s = unify_status()
+    def _rows(items, act, dest_key):
+        return "".join(f"<tr><td>{r['slug']}</td><td>{act}</td><td>{r[dest_key]}</td></tr>" for r in items)
+    return (
+        "<!DOCTYPE html><html lang='en'><head><meta charset='utf-8'/>"
+        "<meta name='viewport' content='width=device-width, initial-scale=1'/>"
+        "<title>Unify flock · SZL Holdings</title>"
+        "<style>body{margin:0;background:#0a0a0a;color:#f5f5f5;font-family:ui-sans-serif,system-ui,sans-serif}"
+        "a{color:#5fb3a3}.wrap{max-width:960px;margin:0 auto;padding:1.4rem}"
+        "table{width:100%;border-collapse:collapse;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:12px}"
+        "th,td{text-align:left;padding:.35rem .4rem;border-bottom:1px solid rgba(201,183,135,.15);color:#9a9a9a}"
+        "th{color:#c9b787;font-size:10px;letter-spacing:.06em;text-transform:uppercase}"
+        ".lede{color:#9a9a9a;max-width:72ch;line-height:1.55}</style></head><body><div class='wrap'>"
+        f"<p>BIND · not certified · digest {s['digest'][:16]}</p>"
+        "<h1>Unify flock</h1>"
+        "<p class='lede'><b>Product tab on a-11-oy.com.</b> GitHub is source. Hub is the registry. "
+        "a11oy.net is RECORD. Never LIVE/RUNNING/PASS. pause+private, never delete.</p>"
+        "<p class='lede'>Nav: <a href='/lyte'>/lyte</a> · <a href='/spaces'>/spaces</a> · <a href='/console'>/console</a></p>"
+        "<h2>KEEP</h2><table><thead><tr><th>slug</th><th>act</th><th>dest</th></tr></thead><tbody>"
+        + _rows(_FLOCK_KEEP, "KEEP", "dest")
+        + "</tbody></table><h2>FOLD</h2><table><thead><tr><th>slug</th><th>act</th><th>into</th></tr></thead><tbody>"
+        + _rows(_FLOCK_FOLD, "FOLD", "into")
+        + "</tbody></table><h2>UNIFY stragglers</h2><table><thead><tr><th>slug</th><th>act</th><th>into</th></tr></thead><tbody>"
+        + _rows(_FLOCK_UNIFY, "UNIFY", "into")
+        + "</tbody></table><p class='lede'>Λ = Conjecture 1 · Doctrine v11 · Never a11oy.com</p></div></body></html>"
+    )
+
+
+def register(app, ns: str = "a11oy") -> Dict[str, Any]:
+    from fastapi.responses import HTMLResponse, JSONResponse
     prefixes = [f"/api/{ns}/v1/lyte", "/v1/lyte"]
+    unify_prefixes = [f"/api/{ns}/v1/unify", "/v1/unify"]
     routes: List[str] = []
     try:
         from starlette.routing import Route
-
-        def _health(_r=None):
-            return JSONResponse(healthz())
-
-        def _status(_r=None):
-            return JSONResponse(status())
-
+        def _health(_r=None): return JSONResponse(healthz())
+        def _status(_r=None): return JSONResponse(status())
+        def _unify_api(_r=None): return JSONResponse(unify_status())
+        def _unify_page(_r=None): return HTMLResponse(unify_page())
         for p in prefixes:
             app.router.routes.insert(0, Route(f"{p}/healthz", _health, methods=["GET"]))
             app.router.routes.insert(0, Route(f"{p}/status", _status, methods=["GET"]))
             routes.extend([f"{p}/healthz", f"{p}/status"])
+        for p in unify_prefixes:
+            app.router.routes.insert(0, Route(f"{p}/status", _unify_api, methods=["GET"]))
+            routes.append(f"{p}/status")
+        for path in ("/unify", f"/{ns}/unify"):
+            app.router.routes.insert(0, Route(path, _unify_page, methods=["GET", "HEAD"]))
+            routes.append(path)
     except Exception:
-        async def _h_health():
-            return JSONResponse(healthz())
-
-        async def _h_status():
-            return JSONResponse(status())
-
+        async def _h_health(): return JSONResponse(healthz())
+        async def _h_status(): return JSONResponse(status())
+        async def _h_unify_api(): return JSONResponse(unify_status())
+        async def _h_unify_page(): return HTMLResponse(unify_page())
         for p in prefixes:
             app.add_api_route(f"{p}/healthz", _h_health, methods=["GET"], include_in_schema=True)
             app.add_api_route(f"{p}/status", _h_status, methods=["GET"], include_in_schema=True)
             routes.extend([f"{p}/healthz", f"{p}/status"])
-
-    print(
-        f"[{ns}] szl_lyte_lattice routes registered "
-        f"(BIND hologram, {len(routes)} routes, not a flagship, not certified)",
-        flush=True,
-    )
+        for p in unify_prefixes:
+            app.add_api_route(f"{p}/status", _h_unify_api, methods=["GET"], include_in_schema=True)
+            routes.append(f"{p}/status")
+        for path in ("/unify", f"/{ns}/unify"):
+            app.add_api_route(path, _h_unify_page, methods=["GET", "HEAD"], include_in_schema=False)
+            routes.append(path)
+    print(f"[{ns}] szl_lyte_lattice routes registered (BIND + unify flock, {len(routes)} routes)", flush=True)
     return {"ok": True, "ns": ns, "organ": _ORGAN_NAME, "bind": _BIND, "certified": False, "routes": routes}
 
 
@@ -250,30 +329,13 @@ def _selftest() -> Dict[str, Any]:
     s = status()
     assert h["ok"] is True and h["certified"] is False and h["hub_running"] is False
     assert s["state"] == "BIND"
-    assert s["honesty"]["certified"] is False
-    assert s["honesty"]["proven_trust"] is False
-    assert s["honesty"]["lyte"] == "STRUCTURAL-ONLY"
-    assert "UNAVAILABLE" in s["honesty"]["energy_joule"]
-    assert s["honesty"]["occupancy"].startswith("UNAVAILABLE")
-    assert s["hub"]["running"] is False
-    assert s["hub"]["state"] == "UNAVAILABLE"
     assert s["source"]["sha"] == _SOURCE_SHA
     assert len(s["frontiers"]) == 28
-    assert s["frontiers"][0]["honesty"] == "STRUCTURAL-ONLY"
-    assert s["frontiers"][-1]["n"] == "N27"
     assert len(s["waves"]) == 3
-    served = json.dumps(s).lower()
-    assert "a11oy.com" in s["honesty"]["never"]
-    assert s["product"]["certified"] is False
-    assert s["khipu_receipt"]["proven_trust"] is False
-    assert s["khipu_receipt"].get("signed") is False or s["khipu_receipt"]["kind"] in (
-        "UNSIGNED-honest",
-        "HASH-LINKED",
-    )
-    assert s["state"] != "LIVE"
-    assert s["state"] != "RUNNING"
-    _ = served
-    return {"ok": True, "state": s["state"], "sha": s["source"]["sha"], "frontiers": len(s["frontiers"])}
+    u = unify_status()
+    assert u["state"] == "BIND" and u["hub_write"] is False
+    assert len(u["keep"]) == 5 and len(u["unify_stragglers"]) == 4
+    return {"ok": True, "state": s["state"], "sha": s["source"]["sha"], "frontiers": 28, "unify": "BIND"}
 
 
 if __name__ == "__main__":