chore(sync): mirror backend .py + Dockerfile to Space (hf-sync-backend)

Automated backend sync from szl-holdings/a11oy main via hf-sync-backend.
Updated (differed from the Space): a11oy_warhacker_obs.py, serve.py
Deleted (gone from the repo + Dockerfile COPY set): (none)

Keeps the Space-built backend (serve.py + the Dockerfile-COPY'd .py
modules) identical to GitHub main so the Space never rebuilds from a
stale backend, new endpoints don't 404 there, and orphaned modules
removed from the repo don't linger in the Space tree.

a11oy_warhacker_obs.py

@@ -59,17 +59,26 @@ SLSA_NOTE = "SLSA L1 honest build-provenance on the 5 organ images (cosign .att)
 # roles and any *.hf.space probe URL redacted before they reach a JSONResponse.
 # Single source of truth is the shared szl_codename_gate.MAP (mirrors the JS
 # sanitizer). Code-internal keys are unchanged; only the served fields are.
+# The banned codename->public-role map and the sanitizer live in ONE place only:
+# szl_codename_gate (allowlisted enumeration-for-detection, byte-identical across
+# apps, always shipped in the image). We import the map+sanitize from there and
+# DO NOT re-declare the codename literals here, so this file never enumerates a
+# banned token (Doctrine v7 §1 banned-token gate stays green) while still being
+# fully sanitized. The import is robust: normal import first, then a path-based
+# importlib load of the sibling module file if sys.path resolution ever fails.
 try:  # shared module, present in every app image
     from szl_codename_gate import MAP as _CODENAME_MAP, sanitize as _codename_sanitize
-except Exception:  # pragma: no cover — belt-and-suspenders fallback, never a bare codename
-    _CODENAME_MAP = {"amaru": "YACHAY", "rosie": "Operator", "sentra": "CHAPAQ", "jarvis": "Operator"}
-    import re as _cn_re
-    _cn_pat = _cn_re.compile("(" + "|".join(_CODENAME_MAP) + ")", _cn_re.IGNORECASE)
-
-    def _codename_sanitize(text):  # type: ignore[no-redef]
-        if text is None:
-            return text
-        return _cn_pat.sub(lambda m: _CODENAME_MAP.get(m.group(0).lower(), m.group(0)), str(text))
+except Exception:  # pragma: no cover — resolve the sibling module by file path
+    import importlib.util as _ilu, os as _ilos
+    _gate_path = _ilos.path.join(_ilos.path.dirname(_ilos.path.abspath(__file__)),
+                                 "szl_codename_gate.py")
+    _spec = _ilu.spec_from_file_location("szl_codename_gate", _gate_path)
+    if _spec is None or _spec.loader is None:  # truly unreachable in-image
+        raise RuntimeError("szl_codename_gate.py not found beside a11oy_warhacker_obs.py")
+    _gate = _ilu.module_from_spec(_spec)
+    _spec.loader.exec_module(_gate)
+    _CODENAME_MAP = _gate.MAP
+    _codename_sanitize = _gate.sanitize
 
 
 def _public_organ(organ: str) -> str:

serve.py

@@ -5689,6 +5689,180 @@ async def a11oy_command_log_v2() -> JSONResponse:
     return JSONResponse(_a11oy_build_chain(24))
 
 
+# ===========================================================================
+# ADDITIVE (Research-3D live wiring, Forge 2026-06-14): four dedicated, HONEST
+# data endpoints, one per Research-3D console tab (ouro_spiral, abacus_manifold,
+# consensus_basin, gemstones_frontier). Each is a SUPERSET of what the tab
+# already consumed (so the frontend is a URL swap, not a rewrite) and carries a
+# server-attested `data_kind` provenance field:
+#     live   -> derived from a real in-process producer (live router catalog)
+#     proxy  -> a clearly-labelled structural heuristic over REAL receipts
+#     sample -> derived, no live per-receipt telemetry in this image
+# NO fabricated data. Lambda = Conjecture 1; Khipu BFT = Conjecture 2; locked-
+# proven stays EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22}. The deterministic
+# in-image receipt chain carries no loop_depth / vote / round metadata, so the
+# loop-depth + consensus endpoints serve an HONEST proxy that AUTO-UPGRADES to
+# `live` the moment those fields are emitted. Registered BEFORE the SPA/proxy
+# catch-all (/{full_path:path}); stdlib-only; fail-safe.
+# ===========================================================================
+_R3D_LOCKED8 = "{F1,F4,F7,F11,F12,F18,F19,F22}"
+
+def _r3d_chain(n: int = 50) -> dict:
+    try:
+        return _a11oy_build_chain(n)
+    except Exception:
+        return {"depth": 0, "chain_verified": False, "receipts": []}
+
+def _r3d_loop_meta(r: dict):
+    for k in ("loop_depth", "loop", "R", "ut_step"):
+        v = r.get(k)
+        if v is not None:
+            return v
+    return None
+
+def _r3d_router_metrics_payload() -> dict:
+    rs = _a11oy_router_stats_payload()
+    routes = rs.get("routes", [])
+    live = rs.get("source") == "szl_brain.TIERS"
+    return {
+        "data_kind": "live" if live else "sample",
+        "mode": rs.get("mode", "live"),
+        "routes": routes,
+        "tiers": routes,
+        "servedThisWindow": rs.get("servedThisWindow", 0),
+        "width_depth_available": False,
+        "source": rs.get("source", ""),
+        "doctrine": "v11",
+        "honesty": ("Per-tier throughput / model / license from the router catalog -- LIVE "
+                    "when the brain catalog (szl_brain.TIERS) is up, else honest_stub_catalog fallback "
+                    "with data_kind DOWNGRADED to sample. Model width/depth shape is NOT measured, so any "
+                    "width/depth scaling point stays a clearly-labelled SAMPLE. "
+                    "Lambda = Conjecture 1; locked-proven stays exactly 8 " + _R3D_LOCKED8 + "."),
+    }
+
+def _r3d_routing_graph_payload() -> dict:
+    rs = _a11oy_router_stats_payload()
+    routes = rs.get("routes", [])
+    nodes = [{"id": r.get("tier", "T%d" % i), "organ": r.get("organ", ""),
+              "model": r.get("model", ""), "throughput": r.get("throughput", 0),
+              "license": r.get("license", "")} for i, r in enumerate(routes)]
+    edges = [{"source": routes[i].get("tier"), "target": routes[i + 1].get("tier")}
+             for i in range(len(routes) - 1)]
+    ch = _r3d_chain(50)
+    live = rs.get("source") == "szl_brain.TIERS"
+    return {
+        "data_kind": "live" if live else "sample",
+        "mode": rs.get("mode", "live"),
+        "nodes": nodes,
+        "edges": edges,
+        "routes": routes,
+        "receipts": ch.get("receipts", []),
+        "source": rs.get("source", ""),
+        "surface": ("GraphRouter routing-envelope score s = lambda*e_hat - (1-lambda)*c_hat "
+                    "is a DERIVED heuristic, never a measured loss"),
+        "doctrine": "v11",
+        "honesty": ("Routing nodes/edges are the /router/stats per-tier catalog -- LIVE when the "
+                    "brain catalog (szl_brain.TIERS) is up, else honest_stub_catalog fallback with "
+                    "data_kind DOWNGRADED to sample (real "
+                    "organ -> tier -> model escalation path); receipts are the real in-image "
+                    "chain. The manifold surface is a derived heuristic, never a measured loss. "
+                    "Lambda = Conjecture 1; locked-proven stays exactly 8 " + _R3D_LOCKED8 + "."),
+    }
+
+def _r3d_loop_depth_payload() -> dict:
+    ch = _r3d_chain(50)
+    recs = ch.get("receipts", [])
+    has_meta = any(_r3d_loop_meta(r) is not None for r in recs)
+    agg = {}
+    for r in recs:
+        track = r.get("caller") or r.get("kind") or "agent"
+        slot = agg.setdefault(track, {"count": 0, "meta": None})
+        slot["count"] += 1
+        mv = _r3d_loop_meta(r)
+        if mv is not None:
+            slot["meta"] = mv
+    tracks = []
+    for k in sorted(agg):
+        slot = agg[k]
+        live_track = has_meta and slot["meta"] is not None
+        tracks.append({
+            "agent": k,
+            "depth": slot["meta"] if live_track else slot["count"],
+            "source": "loop_depth metadata" if live_track else "receipt-density proxy",
+        })
+    return {
+        "data_kind": "live" if has_meta else "proxy",
+        "hasMeta": has_meta,
+        "tracks": tracks,
+        "receipts": recs,
+        "depth": ch.get("depth", len(recs)),
+        "chain_verified": ch.get("chain_verified", False),
+        "doctrine": "v11",
+        "honesty": ("Reasoning loop-depth R is read from receipt loop_depth metadata when "
+                    "present (live); receipts in this image carry none, so R is a clearly-"
+                    "labelled DEPTH PROXY from per-track receipt density -- a structural "
+                    "heuristic, never a measured latent-reasoning depth. Auto-upgrades to live "
+                    "when loop_depth is emitted. Lambda = Conjecture 1; locked-proven stays "
+                    "exactly 8 " + _R3D_LOCKED8 + "."),
+    }
+
+def _r3d_consensus_votes_payload() -> dict:
+    ch = _r3d_chain(50)
+    recs = ch.get("receipts", [])
+    has_votes = any((r.get("votes") is not None or r.get("round") is not None) for r in recs)
+    n = len(recs)
+    out = []
+    for idx, r in enumerate(recs):
+        z = (idx + 1) / n if n else 0.0
+        out.append({
+            "seq": r.get("seq", idx),
+            "kind": r.get("kind", ""),
+            "hash": r.get("hash", ""),
+            "prev_hash": r.get("prev_hash", ""),
+            "converged": idx >= n - 1,
+            "z": round(z, 4),
+            "source": "vote/round metadata" if has_votes else "chain-depth proxy",
+        })
+    return {
+        "data_kind": "live" if has_votes else "sample",
+        "chain_verified": ch.get("chain_verified", False),
+        "receipts": out,
+        "quorum": {"n": 4, "f": 1, "rule": "3-of-4 (n >= 3f+1)",
+                   "status": "Conjecture 2 (Khipu BFT) -- structural heuristic, NOT a BFT proof"},
+        "doctrine": "v11",
+        "honesty": ("Receipts in this image carry no per-receipt vote/round metadata, so the "
+                    "convergence Z is a clearly-labelled chain-depth PROXY over the REAL "
+                    "prev_hash chain (F4 acyclicity, F22 layer order). Auto-upgrades to live "
+                    "vote/round when emitted. Khipu BFT = Conjecture 2; Lambda = Conjecture 1; "
+                    "locked-proven stays exactly 8 " + _R3D_LOCKED8 + "."),
+    }
+
+@app.get("/api/a11oy/v1/router/metrics")
+@app.get("/v1/router/metrics")
+async def _r3d_router_metrics() -> JSONResponse:
+    return JSONResponse(_r3d_router_metrics_payload())
+
+@app.get("/api/a11oy/v1/chaski/routing-graph")
+@app.get("/v1/chaski/routing-graph")
+@app.get("/api/chaski/routing-graph")
+async def _r3d_routing_graph() -> JSONResponse:
+    return JSONResponse(_r3d_routing_graph_payload())
+
+@app.get("/api/a11oy/v1/reason/loop-depth")
+@app.get("/v1/reason/loop-depth")
+async def _r3d_loop_depth() -> JSONResponse:
+    return JSONResponse(_r3d_loop_depth_payload())
+
+@app.get("/api/a11oy/v1/consensus/votes")
+@app.get("/v1/consensus/votes")
+async def _r3d_consensus_votes() -> JSONResponse:
+    return JSONResponse(_r3d_consensus_votes_payload())
+
+print("[a11oy] research-3d endpoints registered BEFORE proxy: /api/a11oy/v1/"
+      "{router/metrics,chaski/routing-graph,reason/loop-depth,consensus/votes}",
+      file=sys.stderr)
+
+
 @app.get("/api/a11oy/v1/ledger")
 async def a11oy_ledger_v2() -> JSONResponse:
     ch = _a11oy_build_chain(24)