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): Dockerfile, szl_scaling.py
Deleted (gone from the repo + Dockerfile COPY set): szl_conjecture_factory.py

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.

Dockerfile

@@ -82,7 +82,7 @@ COPY knowledge.json ./static/knowledge.json
 COPY knowledge.json szl_parity_gaps.py a11oy_warhacker_obs.py serve.py a11oy_wireA_metrics.py cathedral.html a11oy_operator_organ.py a11oy_hf_assets.py szl_b2_secdata.py gates_manifest.json a11oy_code_orchestrator.py a11oy_agent_loop.py a11oy_org_rag.py a11oy_mcp_client.py szl_rag.py a11oy_code_ide.html wayra_serve.py wayra_snapshot.json wayra_digests_7d.json szl_khipu_os_routes.py ./
 COPY szl_khipu_consensus.py szl_puriq_formulas.py ayni_os_serve.py szl_live_wires.py live_wires.html live_wires_3d.js szl_dsse.py szl_provenance.py szl_be_hardening.py szl_unay.py szl_khipu_lmdb.py szl_khipu_replicate.py szl_unay_routes.py szl_warhacker_aliases.py a11oy_v4_hickok.py szl_khipu.py szl_formulas.py a11oy_v4_formulas.py szl_anatomy_3d.py szl_anatomy_routes.py ./
 COPY _vendor_blobs.py szl_v4_fleet.py operator_shell_v4.py szl_bridge.py szl_bridge_schemas.py agent.html a11oy_bridge_cli.py szl_ken.py a11oy_formula_endpoints.py a11oy_formulas_page.py a11oy_frontier_patch.py a11oy_v4_agent.py szl_brain.py szl_wire.py szl_hub.py szl_rosie_companion.py szl_receipt_substrate.py szl_alloy_embed_fabric.py szl_ayni_quorum.py szl_agentic_loop.py ./
-COPY szl_formula_wiring.py a11oy_code_engine.py a11oy_code.py a11oy_seismic.py szl_warhacker_real.py szl_warhacker_demos.py NOTICE_warhacker_demos.txt szl_llm_registry.py szl_elite_console.py szl_alloy_models.py ./
+COPY szl_formula_wiring.py a11oy_code_engine.py a11oy_code.py a11oy_seismic.py szl_warhacker_real.py szl_warhacker_demos.py NOTICE_warhacker_demos.txt szl_llm_registry.py szl_elite_console.py szl_alloy_models.py szl_scaling.py ./
 
 # Copy serve orchestrator and gates manifest
 # ADDITIVE (live-ops): orchestration + AI-observability module — per-file COPY Dockerfile
@@ -532,7 +532,7 @@ ENV A11OY_ALLOY_GGUF=/app/models/qwen2.5-coder-0.5b-instruct-q4_k_m.gguf
 # Signed-off-by: Yachay <yachay@szlholdings.ai>
 # ---------------------------------------------------------------------------
 COPY a11oy_live_feeds.py a11oy_signing_key.py a11oy_dev1_endpoints.py a11oy_vertical_feeds.py a11oy_deva_feeds.py a11oy_devb_endpoints.py a11oy_amaru_feeds.py szl_governance_gateway.py szl_abacus_verify.py szl_decision_uncertainty.py szl_gor_audit.py szl_sovereign_search.py szl_consensus_clusters.py szl_mission_ledger.py szl_budget_router.py szl_wave910_proofs.py szl_evidence_research.py szl_uds_fleet.py szl_readiness.py szl_quantum_bio.py ./
-COPY szl_unified_formulas.py szl_cuas_formulas.py szl_contracting.py szl_bounties.py szl_putnam.py szl_connectors_serve.py szl_connector_mcp.py szl_conjecture_factory.py ./
+COPY szl_unified_formulas.py szl_cuas_formulas.py szl_contracting.py szl_bounties.py szl_putnam.py szl_connectors_serve.py szl_connector_mcp.py ./
 COPY live_snapshots/ ./live_snapshots/
 
 # ADDITIVE (Investor-WOW Layer, 2026-06-08, Dev1): a11oy_dev1_endpoints.py exposes

szl_conjecture_factory.py

@@ -1,361 +0,0 @@
-"""szl_conjecture_factory.py
-
-Read-only loader that surfaces the SZL Conjecture Factory's output for the
-a11oy /console and killinchu /elite consoles.
-
-It reads the conjecture-disclosure records the factory appends to the szl-lake
-DSSE Khipu ledger (NDJSON), and exposes them with an HONEST status convention
-("live" / "cached" / "unreachable") identical to the other shared console
-modules.
-
-Honesty doctrine (do NOT weaken):
-  * A factory-generated problem is a CONJECTURE, never a theorem. It stays OPEN
-    until a solution is independently verified.
-  * "novelty" is an advisory screen, not a proof of originality.
-  * "difficulty"/"grade" come from a bounded solver run: OPEN means
-    searched-to-budget (NOT proven true); VERIFIED-FINITE certifies only the
-    finite enumerated domain; REFUTED carries a concrete witness.
-  * The cosign/Rekor signature attests the timestamp + content, NOT the truth
-    of the conjecture.
-  * An unreachable source is reported as unreachable; it never confirms novelty
-    and we never fabricate a value.
-
-Stdlib only (urllib/json) so it drops into the console containers with no extra
-dependency, mirroring szl_bounties.py / szl_evidence_research.py.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import time
-import urllib.error
-import urllib.request
-from typing import Any, Dict, List, Optional, Tuple
-
-# --- status labels (shared honest convention) -------------------------------
-STATUS_LIVE = "live"
-STATUS_CACHED = "cached"
-STATUS_UNREACHABLE = "unreachable"
-
-# The factory anchors each disclosure under this receipt kind.
-CONJECTURE_KIND = "conjecture-disclosure-anchor"
-CONJECTURE_MILESTONE_KIND = "conjecture-disclosure"
-
-# Sources, in priority order. Overridable by env for the box/HF containers.
-# The factory anchors its disclosures into the szl-lake DSSE Khipu ledger.
-# NOTE: the two surfaces use DIFFERENT path prefixes for the same file --
-# HF dataset has no `data/` prefix, GitHub raw does. Probed live.
-_DEFAULT_SOURCES = [
-    os.environ.get(
-        "SZL_LAKE_NDJSON_HF",
-        "https://huggingface.co/datasets/szlholdings/szl-lake/resolve/main/khipu/lutar_lean_receipts.ndjson",
-    ),
-    os.environ.get(
-        "SZL_LAKE_NDJSON_GH",
-        "https://raw.githubusercontent.com/szl-holdings/szl-lake/main/data/khipu/lutar_lean_receipts.ndjson",
-    ),
-]
-
-_CACHE_PATH = os.environ.get(
-    "SZL_CONJECTURE_CACHE",
-    os.path.join(os.path.dirname(os.path.abspath(__file__)), ".conjecture_factory_cache.ndjson"),
-)
-
-_HTTP_TIMEOUT = float(os.environ.get("SZL_CONJECTURE_HTTP_TIMEOUT", "6"))
-
-# Verdict tokens we recognise from the factory's own honesty prose when the
-# record does not carry discrete fields. We only read what the factory wrote;
-# we never invent a verdict.
-_NOVELTY_TOKENS = {"novel-candidate", "known-restatement", "duplicate", "inconclusive"}
-_DIFFICULTY_TOKENS = {"open-resistant", "hard", "moderate", "easy", "verified-finite", "refuted"}
-_GRADE_TOKENS = {"OPEN", "VERIFIED-FINITE", "REFUTED", "RETRACTED"}
-_RELEASE_STAGES = {"teaser", "statement", "solution"}
-
-
-def _first_match(text: Optional[str], allowed: set, lower: bool = True) -> Optional[str]:
-    """Return the first single-quoted token in *text* that is in *allowed*."""
-    if not text:
-        return None
-    for tok in re.findall(r"'([^']+)'", text):
-        probe = tok.lower() if lower else tok
-        bucket = {a.lower() for a in allowed} if lower else allowed
-        if probe in bucket:
-            return tok
-    return None
-
-
-def _fetch(url: str) -> Optional[str]:
-    if not url:
-        return None
-    try:
-        req = urllib.request.Request(url, headers={"User-Agent": "szl-conjecture-factory/1.0"})
-        with urllib.request.urlopen(req, timeout=_HTTP_TIMEOUT) as resp:  # nosec - read-only public ledger
-            if getattr(resp, "status", 200) != 200:
-                return None
-            return resp.read().decode("utf-8", "replace")
-    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError, ValueError):
-        return None
-
-
-def _read_cache() -> Optional[str]:
-    try:
-        with open(_CACHE_PATH, "r", encoding="utf-8") as fh:
-            data = fh.read()
-        return data if data.strip() else None
-    except OSError:
-        return None
-
-
-def _write_cache(raw: str) -> None:
-    try:
-        tmp = _CACHE_PATH + ".tmp"
-        with open(tmp, "w", encoding="utf-8") as fh:
-            fh.write(raw)
-        os.replace(tmp, _CACHE_PATH)
-    except OSError:
-        pass
-
-
-def _parse_ndjson(raw: str) -> List[Dict[str, Any]]:
-    out: List[Dict[str, Any]] = []
-    for line in raw.splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            obj = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(obj, dict):
-            out.append(obj)
-    return out
-
-
-def _is_conjecture(rec: Dict[str, Any]) -> bool:
-    return (
-        rec.get("kind") == CONJECTURE_KIND
-        or rec.get("milestone_kind") == CONJECTURE_MILESTONE_KIND
-    )
-
-
-def _normalize(rec: Dict[str, Any]) -> Dict[str, Any]:
-    """Map one ledger record to a console-friendly, honesty-preserving item.
-
-    Prefers discrete fields if the factory writes them; otherwise reads the
-    factory's own honesty prose. Never fabricates a verdict.
-    """
-    honesty = rec.get("honesty") or {}
-    signing = rec.get("signing") or {}
-    source_run = rec.get("source_run") or {}
-
-    novelty = (
-        rec.get("novelty_verdict")
-        or rec.get("novelty")
-        or _first_match(honesty.get("novelty"), _NOVELTY_TOKENS)
-    )
-    difficulty = (
-        rec.get("difficulty_grade")
-        or rec.get("difficulty")
-        or _first_match(honesty.get("difficulty"), _DIFFICULTY_TOKENS)
-    )
-    grade = (
-        rec.get("grade")
-        or rec.get("milestone_status")
-        or _first_match(honesty.get("difficulty"), _GRADE_TOKENS, lower=False)
-    )
-    release_stage = (
-        rec.get("release_stage")
-        or rec.get("stage")
-        or _first_match(honesty.get("status"), _RELEASE_STAGES)
-        or "statement"
-    )
-
-    # Honesty guard: a conjecture is NEVER a theorem and is shown OPEN until
-    # independently verified. Only the factory's own VERIFIED-FINITE / REFUTED
-    # grades may change that; an absent grade defaults to OPEN, not "proved".
-    if not grade:
-        grade = "OPEN"
-
-    return {
-        "id": rec.get("receipt_id") or rec.get("milestone_id") or rec.get("chain_index"),
-        "title": rec.get("milestone_title") or rec.get("title") or "(untitled conjecture)",
-        "statement": rec.get("statement") or honesty.get("conjecture") or "",
-        "novelty": novelty,
-        "difficulty": difficulty,
-        "grade": grade,
-        "release_stage": release_stage,
-        "is_open": grade not in ("VERIFIED-FINITE", "REFUTED"),
-        "organ": rec.get("organ"),
-        "kernel_commit_short": rec.get("kernel_commit_short") or (rec.get("kernel_commit") or "")[:12] or None,
-        "timestamp": rec.get("timestamp"),
-        "chain_index": rec.get("chain_index"),
-        "prev_hash": rec.get("prev_hash"),
-        "honesty": {
-            "status": honesty.get("status"),
-            "conjecture": honesty.get("conjecture"),
-            "novelty": honesty.get("novelty"),
-            "difficulty": honesty.get("difficulty"),
-            "signing": honesty.get("signing"),
-            "doctrine": honesty.get("doctrine") or rec.get("doctrine"),
-        },
-        "receipt": {
-            "receipt_id": rec.get("receipt_id"),
-            "chain_index": rec.get("chain_index"),
-            "predicate_type": signing.get("predicate_type"),
-            "signing_mode": signing.get("mode"),
-            "rekor_log_index": signing.get("rekor_log_index"),
-            "rekor_integrated_time": signing.get("rekor_integrated_time"),
-            "verify_cmd": signing.get("verify_cmd"),
-            "fulcio_identity": signing.get("fulcio_identity"),
-            "source_run_url": source_run.get("url"),
-            "source_run_workflow": source_run.get("workflow"),
-        },
-    }
-
-
-def load_conjectures(force_refresh: bool = True) -> Dict[str, Any]:
-    """Load factory conjectures with an honest live/cached/unreachable status.
-
-    Returns a dict::
-
-        {
-          "status": "live" | "cached" | "unreachable",
-          "source": <url-or-cache-or-None>,
-          "fetched_at": <iso8601 utc>,
-          "count": <int>,
-          "items": [ ...normalized conjecture items... ],
-          "doctrine_banner": <str>,   # honesty banner, always present
-        }
-    """
-    fetched_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-    raw: Optional[str] = None
-    source: Optional[str] = None
-    status = STATUS_UNREACHABLE
-
-    if force_refresh:
-        for url in _DEFAULT_SOURCES:
-            data = _fetch(url)
-            if data is not None:
-                raw, source, status = data, url, STATUS_LIVE
-                _write_cache(data)
-                break
-
-    if raw is None:
-        cached = _read_cache()
-        if cached is not None:
-            raw, source, status = cached, _CACHE_PATH, STATUS_CACHED
-
-    items: List[Dict[str, Any]] = []
-    if raw is not None:
-        for rec in _parse_ndjson(raw):
-            if _is_conjecture(rec):
-                items.append(_normalize(rec))
-
-    # Stable, newest-first ordering by chain_index when available.
-    items.sort(key=lambda it: (it.get("chain_index") or 0), reverse=True)
-
-    return {
-        "status": status,
-        "source": source,
-        "fetched_at": fetched_at,
-        "count": len(items),
-        "items": items,
-        "doctrine_banner": (
-            "Factory output is a set of OPEN conjectures \u2014 generated, not proven. "
-            "Each stays OPEN until a solution is independently verified; novelty is an "
-            "advisory screen; signatures attest timestamp + content, not truth. "
-            "Conjecture 1 (unconditional \u039b uniqueness) is and remains OPEN."
-        ),
-    }
-
-
-def load_conjecture(receipt_id: str, force_refresh: bool = True) -> Optional[Dict[str, Any]]:
-    """Return a single normalized conjecture by receipt_id (or None)."""
-    bundle = load_conjectures(force_refresh=force_refresh)
-    for it in bundle["items"]:
-        if it.get("id") == receipt_id or it.get("receipt", {}).get("receipt_id") == receipt_id:
-            return {**it, "_envelope_status": bundle["status"], "_fetched_at": bundle["fetched_at"]}
-    return None
-
-
-# --- registration (FastAPI, mirrors szl_bounties.register) -------------------
-def register(app, ns: str = "a11oy") -> None:
-    """Attach the Conjecture Factory endpoints for namespace *ns*.
-
-    Mounts (read-only)::
-
-        GET /api/{ns}/v1/conjecture-factory        -> honest bundle
-        GET /api/{ns}/v1/conjecture-factory/{rid}  -> single conjecture (404 if absent)
-
-    Mirrors the szl_bounties.register() convention so the deploy is a one-line
-    import + register() and the module ships byte-identical to both consoles.
-    """
-    try:
-        from fastapi.responses import JSONResponse
-    except Exception:  # pragma: no cover - non-FastAPI host
-        return
-
-    base = "/api/%s/v1/conjecture-factory" % ns
-
-    @app.get(base)
-    async def _conjectures_index():  # noqa: ANN202
-        bundle = load_conjectures(force_refresh=True)
-        return JSONResponse({
-            "layer": "%s conjecture factory" % ns,
-            "honest": bundle["doctrine_banner"],
-            "doctrine": "v11",
-            "status": bundle["status"],
-            "source": bundle["source"],
-            "count": bundle["count"],
-            "conjectures": bundle["items"],
-            "checked_at": bundle["fetched_at"],
-        })
-
-    @app.get(base + "/{rid}")
-    async def _conjecture_one(rid: str):  # noqa: ANN202
-        item = load_conjecture(rid, force_refresh=True)
-        if item is None:
-            return JSONResponse(
-                {"error": "unknown conjecture", "receipt_id": rid},
-                status_code=404,
-            )
-        return JSONResponse({
-            "layer": "%s conjecture" % ns,
-            "doctrine": "v11",
-            "conjecture": item,
-        })
-
-
-# --- offline self-test against a local ledger --------------------------------
-def _selftest(path: str) -> int:
-    """Parse a local NDJSON ledger (no network) and print a summary."""
-    with open(path, "r", encoding="utf-8") as fh:
-        raw = fh.read()
-    recs = _parse_ndjson(raw)
-    conj = [_normalize(r) for r in recs if _is_conjecture(r)]
-    print(f"records={len(recs)} conjectures={len(conj)}")
-    for it in conj:
-        print(
-            f"  - id={it['id'][:16] if it['id'] else None}... "
-            f"title={it['title']!r} novelty={it['novelty']} "
-            f"difficulty={it['difficulty']} grade={it['grade']} "
-            f"stage={it['release_stage']} open={it['is_open']} "
-            f"rekor={it['receipt']['rekor_log_index']}"
-        )
-        # honesty assertions
-        assert it["grade"] != "PROVED", "conjecture must never be graded PROVED"
-        assert "theorem" not in it["title"].lower() or it["is_open"], "conjecture mislabeled as theorem"
-    return 0
-
-
-if __name__ == "__main__":
-    import sys
-
-    target = sys.argv[1] if len(sys.argv) > 1 else None
-    if target:
-        raise SystemExit(_selftest(target))
-    out = load_conjectures()
-    print(json.dumps({k: v for k, v in out.items() if k != "items"}, indent=2))
-    print(f"items={out['count']}")

szl_scaling.py

@@ -0,0 +1,249 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. Jr. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+"""
+szl_scaling.py — SZL metabolic-scaling module. Real deterministic Python.
+SHARED module: byte-identical in a11oy AND killinchu (and read by anatomy via API).
+
+Implements Kleiber's law + the Metabolic Theory of Ecology temperature form + the
+quantum-metabolism (PMF/coherence) bridge, and SZL's OWN unification Φ that couples
+network scaling (M^3/4), thermodynamic activation (Boltzmann/PMF), and quantum
+coherence (τc) — a combination no single source assembles. We CITE every classical
+result and reclaim NONE; the SZL contribution is the unified Φ + the compute-allometry
+analogue, both clearly labeled PROPOSED.
+
+DOCTRINE: locked-proven = EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22} @ c7c0ba17 — this
+module adds NOTHING to the locked 8 (EXPERIMENTAL-tier). Λ = Conjecture 1. The SZL Φ is
+PROPOSED, NOT the formal Λ. Trust never 100%. No fabricated data (live dataset values
+are labeled SAMPLE/attributed; nothing invented).
+
+Citations (cited, NOT reclaimed):
+  - Kleiber 1932, Hilgardia (B = B0·M^3/4): https://pdodds.w3.uvm.edu/files/papers/others/1932/kleiber1932a.pdf
+  - West, Brown & Enquist 1997, Science 276:122 (fractal network): https://www.science.org/doi/10.1126/science.276.5309.122
+  - Banavar, Maritan & Rinaldo 1999, Nature (efficient network, B~M^{D/(D+1)}): https://www.nature.com/articles/20144
+  - Brown, Gillooly, Allen, Savage, West 2004, Ecology 85:1771 (MTE, Boltzmann factor): https://doi.org/10.1890/03-9000
+  - Demetrius & Tuszynski 2010, J R Soc Interface (quantum metabolism / PMF bridge): https://pmc.ncbi.nlm.nih.gov/articles/PMC2842802/
+  - Kaplan et al. 2020, arXiv:2001.08361 (neural scaling laws — compute analogue): https://arxiv.org/abs/2001.08361
+
+Register:  register(app, ns="a11oy")  /  register(app, ns="killinchu")
+Routes:    GET /api/<ns>/v1/scaling/{summary,kleiber,mte,unified,heart,compute,exponents}
+"""
+from __future__ import annotations
+import math
+from typing import Any
+
+# Physical constants
+K_EV = 8.617333262e-5     # Boltzmann constant, eV/K
+R_GAS = 8.314             # J/(mol·K)
+F_FARADAY = 96485.0       # C/mol
+
+STATUS_LEGEND = {
+    "VERIFIED": "deterministic computation reproduces a documented numeric on call",
+    "PROPOSED": "SZL construct (unified Φ / compute-allometry); NOT in locked 8; Λ stays Conjecture 1",
+    "SAMPLE": "illustrative values from public datasets (AnAge/PanTHERIA), attributed, not invented",
+}
+
+SOURCES = {
+    "Kleiber 1932 (B=B0·M^3/4)": "https://pdodds.w3.uvm.edu/files/papers/others/1932/kleiber1932a.pdf",
+    "West-Brown-Enquist 1997 (fractal network)": "https://www.science.org/doi/10.1126/science.276.5309.122",
+    "Banavar-Maritan-Rinaldo 1999 (efficient network)": "https://www.nature.com/articles/20144",
+    "Brown et al. 2004 MTE (Boltzmann factor)": "https://doi.org/10.1890/03-9000",
+    "Demetrius-Tuszynski 2010 (quantum metabolism/PMF)": "https://pmc.ncbi.nlm.nih.gov/articles/PMC2842802/",
+    "Kaplan et al. 2020 (neural scaling laws)": "https://arxiv.org/abs/2001.08361",
+    "AnAge / HAGR dataset": "https://genomics.senescence.info/species/",
+}
+
+
+# ---------------------------------------------------------------------------
+# [K] Kleiber's law — B = B0 · M^β  (β = 3/4)
+# ---------------------------------------------------------------------------
+def kleiber(M_kg: float, B0: float = 70.0, beta: float = 0.75) -> float:
+    """Kleiber's law metabolic rate  B = B0 · M^β  (kcal/day; B0≈70 for mammals, M in kg).
+    Cite Kleiber 1932. [VERIFIED model]"""
+    if M_kg <= 0:
+        return 0.0
+    return B0 * (M_kg ** beta)
+
+
+def banavar_exponent(D: int = 3) -> float:
+    """Banavar-Maritan-Rinaldo dimensional exponent  β = D/(D+1)  (D=3 ⇒ 3/4).
+    Cite Banavar et al. 1999. [VERIFIED]"""
+    return D / (D + 1)
+
+
+# ---------------------------------------------------------------------------
+# [MTE] Temperature-corrected metabolic rate  B = b0 · M^3/4 · e^(−E/kT)
+# ---------------------------------------------------------------------------
+def mte_rate(M_kg: float, T_kelvin: float, b0: float = 70.0,
+             E_eV: float = 0.65, beta: float = 0.75) -> float:
+    """Metabolic Theory of Ecology rate  B = b0 · M^β · exp(−E/kT).
+    E≈0.65 eV activation energy, k=8.617e-5 eV/K. Cite Brown et al. 2004. [VERIFIED model]"""
+    if M_kg <= 0 or T_kelvin <= 0:
+        return 0.0
+    return b0 * (M_kg ** beta) * math.exp(-E_eV / (K_EV * T_kelvin))
+
+
+def heart_rate_scaling(M_kg: float, f0: float = 241.0) -> float:
+    """Heart-rate allometry  f ∝ M^(−1/4)  (bpm; f0≈241 for M in kg, mammals).
+    Ties to anatomy HEART/YUYAY organ. The 'lifetime heartbeats ≈ constant' result
+    follows since lifespan ∝ M^(+1/4). Cite MTE/West. [VERIFIED model]"""
+    if M_kg <= 0:
+        return 0.0
+    return f0 * (M_kg ** -0.25)
+
+
+def lifespan_scaling(M_kg: float, L0: float = 11.8) -> float:
+    """Lifespan allometry  L ∝ M^(+1/4)  (years; L0≈11.8 for M in kg, mammals)."""
+    if M_kg <= 0:
+        return 0.0
+    return L0 * (M_kg ** 0.25)
+
+
+# ---------------------------------------------------------------------------
+# PMF (our bioenergetics lineage) — Δp = ΔΨ − (2.303 RT/F) ΔpH
+# ---------------------------------------------------------------------------
+def proton_motive_force(delta_psi_mV: float, delta_pH: float,
+                        T_kelvin: float = 310.0) -> float:
+    """Proton-motive force  Δp = ΔΨ − (2.303 RT/F) ΔpH  (mV). Mitchell chemiosmosis.
+    Reuses SZL's verified bioenergetics term. [VERIFIED model]"""
+    coeff_mV = 2.303 * R_GAS * T_kelvin / F_FARADAY * 1000.0  # → mV
+    return delta_psi_mV - coeff_mV * delta_pH
+
+
+# ---------------------------------------------------------------------------
+# [SZL-Φ] THE UNIFICATION (PROPOSED — our own construct)
+#   Φ = Φ0 · M^3/4 · exp(−(E − η·Δp_eV)/kT) · (τc/τ0)^(1/4)
+#   network scaling × (Boltzmann activation reduced by PMF) × coherence modulation
+# ---------------------------------------------------------------------------
+def szl_phi(M_kg: float, T_kelvin: float, delta_p_mV: float, tau_c: float,
+            Phi0: float = 70.0, E_eV: float = 0.65, eta: float = 1.0,
+            tau0: float = 6.05, beta: float = 0.75) -> dict[str, Any]:
+    """SZL unified metabolic-coherence scaling Φ (PROPOSED — our own; cites WBE+MTE+
+    Demetrius-Tuszynski). Couples: M^β network scaling, a Boltzmann-Arrhenius activation
+    whose barrier is LOWERED by the proton-motive force (η·Δp converted eV), and a
+    coherence modulation (τc/τ0)^(1/4) tying to our Lindblad τc / Λ-v5 lineage.
+
+    Δp is given in mV; converted to eV per elementary charge (mV/1000 = volts = eV/charge).
+    This is a PROPOSED engineering construct, NOT the formal Λ; Λ stays Conjecture 1. [PROPOSED]"""
+    if M_kg <= 0 or T_kelvin <= 0 or tau_c <= 0 or tau0 <= 0:
+        return {"phi": 0.0, "status": "out_of_domain"}
+    delta_p_eV = (delta_p_mV / 1000.0) * eta          # mV→V→eV per unit charge × coupling η
+    barrier = (E_eV - delta_p_eV)
+    # Activation term as a PMF-ENHANCEMENT factor: the rate is lifted relative to the
+    # no-PMF baseline at the SAME operating temperature by exp(+ηΔp/kT). This isolates the
+    # PMF effect honestly (more PMF → lower barrier → higher rate) without the bare exp(-E/kT)
+    # underflow. exp(−barrier/kT)/exp(−E/kT) = exp(+ηΔp_eV/kT).
+    boltz = math.exp(delta_p_eV / (K_EV * T_kelvin))
+    coh = (tau_c / tau0) ** 0.25
+    phi = Phi0 * (M_kg ** beta) * boltz * coh
+    return {"phi": round(phi, 6),
+            "terms": {"network_M^beta": round(M_kg ** beta, 6),
+                      "pmf_enhancement_exp(eta*dp/kT)": round(boltz, 6),
+                      "coherence_(tau_c/tau0)^0.25": round(coh, 6),
+                      "effective_barrier_eV": round(barrier, 6),
+                      "delta_p_eV": round(delta_p_eV, 6)},
+            "inputs": {"M_kg": M_kg, "T_K": T_kelvin, "delta_p_mV": delta_p_mV, "tau_c": tau_c},
+            "status": "PROPOSED",
+            "note": "SZL unification (WBE network × MTE/PMF activation × coherence); Λ=Conjecture 1"}
+
+
+# ---------------------------------------------------------------------------
+# [SZL-COMPUTE] allometry analogue — neural/agent scaling as a 'metabolism'
+# ---------------------------------------------------------------------------
+def szl_compute_allometry(params_B: float, alpha: float = 0.076,
+                          L0: float = 1.69) -> dict[str, Any]:
+    """SZL compute-allometry analogue: model loss L(N) ≈ L0 · N^(−α) (Kaplan et al. 2020,
+    α≈0.076 for params). We frame model 'capability metabolism' allometrically — compute
+    cost vs capability scales like a metabolic network. PROPOSED analogy, cited to Kaplan;
+    we claim only the allometric FRAMING, not the scaling law. [PROPOSED]"""
+    if params_B <= 0:
+        return {"loss": None, "status": "out_of_domain"}
+    N = params_B * 1e9
+    loss = L0 * (N ** -alpha)
+    return {"params_billions": params_B, "predicted_loss": round(loss, 6),
+            "exponent_alpha": alpha, "cite": "Kaplan et al. 2020 arXiv:2001.08361",
+            "framing": "compute capability as metabolic-network allometry (PROPOSED analogy)",
+            "status": "PROPOSED"}
+
+
+# Universal scaling exponents across domains (for the comparator tab) — all CITED.
+UNIVERSAL_EXPONENTS = [
+    {"domain": "biology", "quantity": "metabolic rate vs mass", "exponent": 0.75, "cite": "Kleiber 1932 / WBE 1997"},
+    {"domain": "biology", "quantity": "heart rate vs mass", "exponent": -0.25, "cite": "MTE 2004"},
+    {"domain": "biology", "quantity": "lifespan vs mass", "exponent": 0.25, "cite": "MTE 2004"},
+    {"domain": "urban", "quantity": "GDP vs population", "exponent": 1.15, "cite": "Bettencourt-West 2007"},
+    {"domain": "urban", "quantity": "infrastructure vs population", "exponent": 0.85, "cite": "Bettencourt-West 2007"},
+    {"domain": "compute", "quantity": "LM loss vs parameters", "exponent": -0.076, "cite": "Kaplan et al. 2020"},
+]
+
+
+def summary() -> dict[str, Any]:
+    """Headline of the SZL scaling module + honest provenance/legend."""
+    return {
+        "title": "SZL Metabolic-Scaling — Kleiber/WBE/MTE + quantum-metabolism, unified (our own Φ)",
+        "status_legend": STATUS_LEGEND, "sources": SOURCES,
+        "doctrine": {"locked_proven": 8, "lambda": "Conjecture 1", "phi": "PROPOSED (not the formal Λ)",
+                     "trust": "never 100%"},
+        "examples": {
+            "kleiber_70kg_human": round(kleiber(70.0), 2),
+            "heart_rate_70kg": round(heart_rate_scaling(70.0), 2),
+            "heart_rate_mouse_0.02kg": round(heart_rate_scaling(0.02), 2),
+            "szl_phi_demo": szl_phi(70.0, 310.0, 121.5, 6.05),
+        },
+        "universal_exponents": UNIVERSAL_EXPONENTS,
+    }
+
+
+def register(app, ns: str) -> None:
+    """Attach the scaling routes under /api/<ns>/v1/scaling/* via add_api_route."""
+    base = f"/api/{ns}/v1/scaling"
+    app.add_api_route(f"{base}/summary", lambda: summary(), methods=["GET"])
+    app.add_api_route(f"{base}/kleiber", lambda M: {"M_kg": float(M), "B_kcal_day": kleiber(float(M))}, methods=["GET"])
+    app.add_api_route(f"{base}/mte",
+                      lambda M, T="310": {"M_kg": float(M), "T_K": float(T), "B": mte_rate(float(M), float(T))},
+                      methods=["GET"])
+    app.add_api_route(f"{base}/heart",
+                      lambda M: {"M_kg": float(M), "bpm": round(heart_rate_scaling(float(M)), 2),
+                                 "lifespan_yr": round(lifespan_scaling(float(M)), 2),
+                                 "lifetime_beats_billion": round(heart_rate_scaling(float(M)) * 60 * 24 * 365 *
+                                                                 lifespan_scaling(float(M)) / 1e9, 3)},
+                      methods=["GET"])
+    app.add_api_route(f"{base}/unified",
+                      lambda M, T="310", dp="121.5", tau_c="6.05": szl_phi(float(M), float(T), float(dp), float(tau_c)),
+                      methods=["GET"])
+    app.add_api_route(f"{base}/compute",
+                      lambda params="70": szl_compute_allometry(float(params)), methods=["GET"])
+    app.add_api_route(f"{base}/exponents", lambda: {"exponents": UNIVERSAL_EXPONENTS}, methods=["GET"])
+
+
+def _selftest() -> None:
+    # Kleiber: 70kg human ≈ 70 * 70^0.75 ≈ 1693 kcal/day (basal-ish ballpark)
+    h = kleiber(70.0)
+    assert 1500 < h < 1900, h
+    # Banavar D=3 -> 0.75
+    assert abs(banavar_exponent(3) - 0.75) < 1e-12
+    # MTE rate positive and increases with temperature
+    assert mte_rate(70.0, 310.0) > mte_rate(70.0, 300.0) > 0
+    # heart-rate scaling: mouse beats far faster than human
+    assert heart_rate_scaling(0.02) > heart_rate_scaling(70.0) > 0
+    # lifetime heartbeats ~ roughly invariant order of magnitude (mouse vs human within ~3x)
+    def beats(M): return heart_rate_scaling(M) * 60 * 24 * 365 * lifespan_scaling(M)
+    r = beats(0.02) / beats(70.0)
+    assert 0.3 < r < 3.0, r   # near-constant lifetime beats (the famous result)
+    # pmf reproduces SZL verified two-ion value ballpark (121.5 mV at dΨ=150, dpH≈0.47)
+    p = proton_motive_force(150.0, 0.47, 310.0)
+    assert 110 < p < 135, p
+    # SZL Φ: PROPOSED, positive, PMF lowers barrier so Φ(with pmf) > Φ(no pmf)
+    phi_pmf = szl_phi(70.0, 310.0, 121.5, 6.05)["phi"]
+    phi_nopmf = szl_phi(70.0, 310.0, 0.0, 6.05)["phi"]
+    assert phi_pmf > phi_nopmf > 0, (phi_pmf, phi_nopmf)
+    # longer coherence -> higher Φ (coherence modulation monotone)
+    assert szl_phi(70.0, 310.0, 121.5, 12.0)["phi"] > szl_phi(70.0, 310.0, 121.5, 3.0)["phi"]
+    # compute allometry: bigger model -> lower loss
+    assert szl_compute_allometry(700)["predicted_loss"] < szl_compute_allometry(7)["predicted_loss"]
+    # out-of-domain guards
+    assert szl_phi(0, 310, 121.5, 6.05)["status"] == "out_of_domain"
+    print("szl_scaling: ALL OK (11 checks)")
+
+
+if __name__ == "__main__":
+    _selftest()