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

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy main.
Files: 943 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>

szl_agent_loop_governed.py

@@ -128,6 +128,16 @@ except Exception:
     _APPROVAL_OK = False
     _approval_interrupt = None
 
+# Wave M (Dev 2): shared sovereign-flywheel bridge. Lets the governed loop run on
+# SZL's OWN model (sovereign_local) via Dev-1's registry backend; honest
+# MODELED/UNAVAILABLE when the local Tower endpoint is unreachable (no fabrication).
+try:
+    import szl_sovereign_flywheel as _sov  # noqa: F401
+    _SOV_OK = True
+except Exception:  # pragma: no cover — bridge missing → sovereign option simply off
+    _sov = None  # type: ignore
+    _SOV_OK = False
+
 
 def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
@@ -185,6 +195,21 @@ def run_loop(task: str,
     max_retries = max(0, min(3, int(max_retries)))
     grant = approval if isinstance(approval, dict) else None
 
+    # ── Wave M (Dev 2): sovereign preflight ───────────────────────────────────
+    # If the caller asked to run this loop on SZL's OWN governed model, probe the
+    # sovereign backend ONCE (Dev-1 registry) and carry the honest verdict into the
+    # composite receipt. The per-step ACT still flows through the engine with
+    # want_model=model_id; the sovereign block records the intended backend +
+    # reachability so an offline run is honestly MODELED/UNAVAILABLE (no fabrication).
+    sovereign_requested = bool(_SOV_OK and _sov and _sov.is_sovereign(model_id))
+    sovereign_block = None
+    sovereign_state = None
+    if sovereign_requested:
+        _sp = _sov.run_on_sovereign(task or "State your doctrine in one line.",
+                                    requested_model_id=model_id, probe_only=True)
+        sovereign_state = _sp.get("state")
+        sovereign_block = _sov.receipt_block(_sp)
+
     if not _ENGINE_OK:
         return {
             "ok": False,
@@ -404,6 +429,7 @@ def run_loop(task: str,
         "task": task,
         "mode": plan_mode,
         "model_id": model_id or "(engine default)",
+        "sovereign": sovereign_block,  # Wave M: intended sovereign backend (None when not requested)
         "harness_profile_id": harness_profile_id or None,
         "eval_suite_default": eval_suite or "(per-step mode heuristic)",
         "max_retries": max_retries,
@@ -475,6 +501,9 @@ def run_loop(task: str,
         "steps": steps_out,
         "aggregate": receipt_body["aggregate"],
         "composite_receipt": {"body": receipt_body, "dsse": dsse, "signing": signing},
+        "sovereign": sovereign_block,  # Wave M: honest intended-backend + reachability
+        "sovereign_label": (_sov.selected_label({"state": sovereign_state})
+                            if sovereign_requested and _SOV_OK and _sov else None),
         "forum_ingest": forum,
         "composes": receipt_body["composes"],
         "leaders_cited": LEADERS,
@@ -642,6 +671,18 @@ def register(app, ns: str = "a11oy", sign_fn: Optional[Callable[[dict], dict]] =
                 "self_eval_available": _ARENA_OK,
                 "behavior_profile_available": _HARNESS_OK,
                 "human_gate_available": _APPROVAL_OK,
+                "sovereign_available": _SOV_OK,
+            },
+            # Wave M (Dev 2): run this governed loop on SZL's OWN model.
+            "run_on_sovereign": {
+                "available": bool(_SOV_OK),
+                "how": ("POST /agentloop/run with model_id='szl-sovereign-local' "
+                        "(alias of registry backend 'sovereign_local'). The loop "
+                        "probes the local Tower via Dev-1's backend and records the "
+                        "intended sovereign backend in the composite receipt; honest "
+                        "MODELED/UNAVAILABLE when offline (no fabrication)."),
+                "backend_id": "sovereign_local",
+                "model_slug": "llama3-szl-finetuned-q4",
             },
             "eval_suites": eval_suites,
             "approval_gate_enabled": os.environ.get("A11OY_APPROVAL_INTERRUPT") == "1",

szl_eval_arena.py

@@ -366,6 +366,17 @@ _SCORERS: dict[str, Callable[[str, str], tuple[bool, str]]] = {
 # answer is derived ONLY from the case's own `expected`/category — it is an honest
 # "reference oracle" stub, NOT a claim that a model produced it.
 # ─────────────────────────────────────────────────────────────────────────────
+# Wave M (Dev 2): shared sovereign-flywheel bridge. Lets /eval/run score SZL's OWN
+# governed model (sovereign_local) through Dev-1's registry backend; honest
+# MODELED/UNAVAILABLE when the local Tower endpoint is unreachable (no fabrication).
+try:
+    import szl_sovereign_flywheel as _sov  # noqa: F401
+    _SOV_OK = True
+except Exception:  # pragma: no cover — bridge missing → sovereign option simply off
+    _sov = None  # type: ignore
+    _SOV_OK = False
+
+
 def _registry_snapshot() -> dict[str, Any]:
     """Best-effort read of the registry (model roster + key-wired status)."""
     out = {"available": False, "models": {}, "any_key_wired": False}
@@ -430,8 +441,45 @@ def _control_benign_answer(case: dict[str, Any]) -> str:
 
 
 def _solve_case(case: dict[str, Any], model_id: str, snap: dict[str, Any],
-                harness: dict[str, Any]) -> dict[str, Any]:
-    """Produce an answer for one case (honest MODELED unless a key is wired)."""
+                harness: dict[str, Any], sov_state: str | None = None) -> dict[str, Any]:
+    """Produce an answer for one case (honest MODELED unless a key is wired).
+
+    Wave M (Dev 2): when the caller asked for SZL's sovereign local model,
+    `sov_state` carries the ONE-shot reachability verdict from run_eval:
+      LIVE        → do a REAL per-case generation on the local node.
+      MODELED     → node not live this request → honest MODELED reference stub
+                    (pipeline still scored; NO model text fabricated as sovereign).
+      UNAVAILABLE → local endpoint unreachable → honest UNAVAILABLE non-response.
+    """
+    # ── sovereign branch (routes through Dev-1's registry backend) ──
+    if sov_state is not None:
+        if sov_state == "LIVE" and _SOV_OK and _sov:
+            sov = _sov.run_on_sovereign(str(case.get("input", "")),
+                                        requested_model_id=model_id)
+            if sov.get("state") == "LIVE" and isinstance(sov.get("text"), str):
+                answer = sov["text"]
+                if harness.get("applied"):
+                    answer = f"[profile:{harness['profile_id']}] " + answer
+                return {"answer": answer, "label": "LIVE"}
+            # node fell over mid-run → honest MODELED, no fabrication as sovereign
+            answer = _modeled_reference_answer(case)
+            if harness.get("applied"):
+                answer = f"[profile:{harness['profile_id']}] " + answer
+            return {"answer": answer, "label": "MODELED"}
+        if sov_state == "MODELED":
+            if case.get("category") == "safety_control":
+                answer = _control_benign_answer(case)
+            else:
+                answer = _modeled_reference_answer(case)
+            if harness.get("applied"):
+                answer = f"[profile:{harness['profile_id']}] " + answer
+            return {"answer": answer, "label": "MODELED"}
+        # UNAVAILABLE — sovereign endpoint unreachable; no model call, no fabrication
+        answer = ("[UNAVAILABLE] SZL sovereign_local endpoint unreachable "
+                  "(SZL_LOCAL_LLM_URL unset / Tower offline); no answer produced. "
+                  "Pipeline scored this as a non-response.")
+        return {"answer": answer, "label": "UNAVAILABLE"}
+
     live = snap.get("available") and snap.get("any_key_wired")
     label = "LIVE" if live else "MODELED"
     known = model_id in snap.get("models", {})
@@ -532,13 +580,25 @@ def run_eval(suite_id: str, model_id: str, harness_profile_id: str | None = None
     snap = _registry_snapshot()
     harness = _resolve_harness(harness_profile_id)
 
+    # ── Wave M (Dev 2): sovereign option — probe SZL's OWN model ONCE per run ──
+    # so we don't hammer the local node per-case. The verdict drives per-case
+    # solving; honest MODELED/UNAVAILABLE when the Tower is offline (no fabrication).
+    sov_requested = bool(_SOV_OK and _sov and _sov.is_sovereign(model_id))
+    sov_state: str | None = None
+    sov_receipt = None
+    if sov_requested:
+        sov_probe = _sov.run_on_sovereign("", requested_model_id=model_id,
+                                          probe_only=True)
+        sov_state = sov_probe.get("state")  # LIVE | MODELED | UNAVAILABLE
+        sov_receipt = _sov.receipt_block(sov_probe)
+
     cases_in = suite["cases"]
     suite_sha256 = _sha256_str(_canon(cases_in))  # lm-eval-style content version pin
     results: list[dict[str, Any]] = []
     by_cat: dict[str, dict[str, int]] = {}
 
     for case in cases_in:
-        solved = _solve_case(case, model_id, snap, harness)
+        solved = _solve_case(case, model_id, snap, harness, sov_state=sov_state)
         answer = solved["answer"]
         label = solved["label"]
         scorer_name = case.get("scorer", "exact")
@@ -617,9 +677,14 @@ def run_eval(suite_id: str, model_id: str, harness_profile_id: str | None = None
     }
 
     # ── build the receipt payload (signed below) ──
-    honesty_label = "LIVE" if (snap.get("available") and snap.get("any_key_wired")) else "MODELED"
-    if model_id not in snap.get("models", {}):
-        honesty_label = "UNAVAILABLE"
+    if sov_requested:
+        # Sovereign run: the label IS the one-shot reachability verdict (never
+        # UNAVAILABLE just because the alias isn't a plain registry key).
+        honesty_label = sov_state or "UNAVAILABLE"
+    else:
+        honesty_label = "LIVE" if (snap.get("available") and snap.get("any_key_wired")) else "MODELED"
+        if model_id not in snap.get("models", {}):
+            honesty_label = "UNAVAILABLE"
 
     receipt_body = {
         "schema": SCHEMA,
@@ -631,7 +696,8 @@ def run_eval(suite_id: str, model_id: str, harness_profile_id: str | None = None
         "suite_version": suite["version"],
         "suite_sha256": suite_sha256,
         "model_id": model_id,
-        "model_known": model_id in snap.get("models", {}),
+        "model_known": (sov_requested or model_id in snap.get("models", {})),
+        "sovereign": sov_receipt,  # Wave M: intended sovereign backend (None when not requested)
         "harness_profile_id": harness_profile_id,
         "harness": {"applied": harness.get("applied"), "available": harness.get("available"),
                     "profile_sha256": harness.get("profile_sha256"), "note": harness.get("note")},
@@ -759,6 +825,16 @@ def register(app: "FastAPI", ns: str = "a11oy") -> dict:
             ],
             "scorers": list(_SCORERS.keys()),
             "run_endpoint": "POST " + base + "/run",
+            # Wave M (Dev 2): evaluate SZL's OWN governed model.
+            "run_on_sovereign": {
+                "available": bool(_SOV_OK),
+                "how": ("POST " + base + "/run with model_id='szl-sovereign-local' "
+                        "(alias of registry backend 'sovereign_local'). Scores SZL's "
+                        "own model via Dev-1's backend; honest MODELED/UNAVAILABLE "
+                        "when the local Tower endpoint is unreachable (no fabrication)."),
+                "backend_id": "sovereign_local",
+                "model_slug": "llama3-szl-finetuned-q4",
+            },
             "leaders_cited": LEADERS,
             "lambda_posture": "advisory (Conjecture 1) — never green",
             "doctrine": DOCTRINE, "kernel_commit": _KERNEL,
@@ -786,6 +862,11 @@ def register(app: "FastAPI", ns: str = "a11oy") -> dict:
 
         Body: {"suite": "core_honest_v1", "model_id": "claude_sonnet_4_6",
                "harness_profile_id": "szl-honest-operator" (optional)}
+
+        Wave M (Dev 2): model_id="szl-sovereign-local" evaluates SZL's OWN
+        governed model through Dev-1's sovereign backend. When the local Tower
+        endpoint is unreachable the run degrades to honest MODELED/UNAVAILABLE and
+        the receipt records the intended sovereign backend — never fabricated.
         """
         try:
             body = await request.json()

szl_governed_rag.py

@@ -423,6 +423,17 @@ def _reg():
     return _r
 
 
+# Wave M (Dev 2): shared sovereign-flywheel bridge. Lets /rag/query run the
+# abstractive rewrite on SZL's OWN governed model (sovereign_local) via Dev-1's
+# registry backend; honest MODELED/UNAVAILABLE when the Tower is offline.
+try:
+    import szl_sovereign_flywheel as _sov  # noqa: F401
+    _SOV_OK = True
+except Exception:  # pragma: no cover — bridge missing → sovereign option simply off
+    _sov = None  # type: ignore
+    _SOV_OK = False
+
+
 def _lambda_gm(axes: list[float]) -> float:
     try:
         return _reg()._lambda_gm(axes)
@@ -595,6 +606,37 @@ def query(query_text: str, corpus: list[dict[str, str]] | None = None,
         model_note += (f" A harness_profile_id ('{harness_profile_id}') was supplied; the abstractive "
                        "path would apply it via szl_model_harness (MODELED disposition only).")
 
+    # ── Wave M (Dev 2): SOVEREIGN option ───────────────────────────────────────
+    # Run the abstractive rewrite on SZL's OWN governed model, grounded STRICTLY
+    # on the retrieved+cited passages. When the Tower is offline we keep the honest
+    # EXTRACTIVE answer and record the intended sovereign backend — no fabrication.
+    sovereign_answer = None
+    sovereign_block = None
+    if _SOV_OK and _sov and _sov.is_sovereign(model_id):
+        _ctx = "\n\n".join(
+            f"[{p['id']}] {p.get('text', '')}" for p in retr["retrieved"])
+        _sov_prompt = (
+            "Answer the question USING ONLY the sources below. Cite each source id "
+            "you rely on in square brackets. If the sources do not answer it, say so.\n\n"
+            f"SOURCES:\n{_ctx}\n\nQUESTION: {query_text}\n\nGROUNDED ANSWER:")
+        sov = _sov.run_on_sovereign(_sov_prompt, requested_model_id=model_id)
+        sovereign_block = _sov.receipt_block(sov)
+        rag_state = sov.get("state")  # LIVE | MODELED | UNAVAILABLE
+        if sov.get("state") == "LIVE" and isinstance(sov.get("text"), str):
+            sovereign_answer = sov["text"]
+            model_note = ("LIVE abstractive rewrite from SZL's OWN sovereign_local model, "
+                          "grounded on the SAME cited passages. Retrieval, grounding, "
+                          "RAGAS, Λ-gate, and signature remain REAL.")
+        elif sov.get("state") == "MODELED":
+            model_note = ("SZL sovereign_local selected but the local node did not answer "
+                          "live this request — returning the honest EXTRACTIVE grounded "
+                          "answer (no model text fabricated). Intended sovereign backend recorded.")
+        else:
+            model_note = ("SZL sovereign_local selected but the local endpoint is unreachable "
+                          "(SZL_LOCAL_LLM_URL unset / Tower offline) — returning the honest "
+                          "EXTRACTIVE grounded answer. Intended sovereign backend recorded; "
+                          "no model call attempted; no fabrication.")
+
     # per-claim citation map (the differentiator, made machine-checkable)
     claim_citation_map = [
         {"claim": c["claim"], "grounded": c["grounded"],
@@ -637,6 +679,7 @@ def query(query_text: str, corpus: list[dict[str, str]] | None = None,
         "gate_reason": gate_reason,
         "model_id": model_id or None,
         "api_key_wired": api_key_wired,
+        "sovereign": sovereign_block,  # Wave M: intended sovereign backend (None when not requested)
         "harness_profile_id": harness_profile_id or None,
         "rag_state": rag_state,
         "honesty_label": rag_state,
@@ -654,6 +697,10 @@ def query(query_text: str, corpus: list[dict[str, str]] | None = None,
         "rag_state": rag_state,
         "model_note": model_note,
         "grounded_answer": gen["grounded_answer"],
+        # Wave M: the sovereign model's abstractive rewrite (LIVE only; None otherwise
+        # — the extractive grounded_answer above is ALWAYS the honest fallback).
+        "sovereign_answer": sovereign_answer,
+        "sovereign": sovereign_block,
         "claims": gen["claims"],
         "retrieval": retr,
         "ragas": ragas,
@@ -685,7 +732,13 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict:
         {"query": "...", "corpus": [{"id","text","source"}]?, "model_id": "?",
          "harness_profile_id": "?", "top_k": 4}
         Honest 4xx on empty query; otherwise 200 with grounded answer + per-claim
-        citations + RAGAS scores + Λ-gate + SIGNED receipt (forum-ingested)."""
+        citations + RAGAS scores + Λ-gate + SIGNED receipt (forum-ingested).
+
+        Wave M (Dev 2): model_id="szl-sovereign-local" runs the abstractive rewrite
+        on SZL's OWN governed model (Dev-1 backend), grounded on the same cited
+        passages. When the local Tower endpoint is unreachable the extractive
+        grounded answer is returned and the receipt records the intended sovereign
+        backend — no model response is ever fabricated."""
         try:
             body = await request.json()
         except Exception:
@@ -709,6 +762,8 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict:
                 status_code=400)
         return JSONResponse({
             "grounded_answer": res["grounded_answer"],
+            "sovereign_answer": res.get("sovereign_answer"),  # Wave M: LIVE only, else None
+            "sovereign": res.get("sovereign"),               # intended sovereign backend
             "rag_state": res["rag_state"],
             "model_note": res["model_note"],
             "claims": res["claims"],

szl_model_harness.py

@@ -234,6 +234,17 @@ def _reg():
     return _r
 
 
+# Wave M (Dev 2): the shared sovereign-flywheel bridge. Routes an explicit
+# sovereign request through Dev-1's registry backend (sovereign_local); degrades
+# to honest MODELED/UNAVAILABLE when the local Tower endpoint is unreachable.
+try:
+    import szl_sovereign_flywheel as _sov  # noqa: F401
+    _SOV_OK = True
+except Exception:  # pragma: no cover — bridge missing → sovereign option simply off
+    _sov = None  # type: ignore
+    _SOV_OK = False
+
+
 def _lambda_gm(axes: list[float]) -> float:
     """Reuse szl_llm_registry._lambda_gm; local geometric-mean fallback if the
     registry import fails (never raises into the request path)."""
@@ -496,9 +507,51 @@ def apply(profile_id: str, model_id: str = "", prompt: str = "",
         "kernel_commit": _KERNEL,
         "conjecture_note": _CONJECTURE_NOTE,
     }
+    # ── Wave M (Dev 2): SOVEREIGN option ──────────────────────────────────────
+    # If the caller asked to run this on SZL's OWN governed model, route the
+    # profile-applied prompt through Dev-1's sovereign_local backend. The receipt
+    # ALWAYS records the intended sovereign backend; when the Tower is offline we
+    # return honest MODELED/UNAVAILABLE and NEVER fabricate a model response.
+    sovereign_requested = bool(_SOV_OK and _sov and _sov.is_sovereign(model_id))
+    if sovereign_requested:
+        # Compose the sovereign prompt: profile body (if resolved) as a system
+        # preface + the user prompt. The body TEXT is never surfaced in the
+        # receipt (sha256 only) — it is only sent to the local, sovereign node.
+        sys_layer = (bm.get("_body") or "") if body_available else ""
+        sov_prompt = ((sys_layer + "\n\n") if sys_layer else "") + prompt
+        sov = _sov.run_on_sovereign(sov_prompt, requested_model_id=model_id)
+        receipt["sovereign"] = _sov.receipt_block(sov)
+        receipt["model_id"] = _sov.SOVEREIGN_BACKEND_ID
+        receipt["model_display"] = "SZL Sovereign Local (llama3-szl-finetuned-q4)"
+        receipt["honesty_label"] = sov.get("state")
+
     receipt["signature"] = _sign_receipt(receipt)
 
-    if not body_available:
+    if sovereign_requested:
+        _st = sov.get("state")
+        if _st == "LIVE":
+            response_text = (
+                "[LIVE · SOVEREIGN] Ran the '" + profile_id + "' behavior profile on "
+                "SZL's OWN governed model (sovereign_local, llama3-szl-finetuned-q4) "
+                "— REAL generation this request. " + (sov.get("note") or ""))
+        elif _st == "MODELED":
+            response_text = (
+                "[HONEST STUB · MODELED · SOVEREIGN] Would run the '" + profile_id +
+                "' profile on SZL's sovereign_local model, but the local Tower node "
+                "did not answer live this request. No model output fabricated; the "
+                "intended sovereign backend + Λ-gate + provenance sha256 + signature "
+                "are REAL. " + (sov.get("note") or ""))
+        else:
+            response_text = (
+                "[UNAVAILABLE · SOVEREIGN] The '" + profile_id + "' profile targeted "
+                "SZL's sovereign_local model, but the local endpoint is unreachable "
+                "(SZL_LOCAL_LLM_URL unset / Tower offline). No model call attempted; "
+                "the intended sovereign backend is recorded in the receipt; no output "
+                "fabricated. " + (sov.get("note") or ""))
+        harness_state = _st
+        model_display = receipt["model_display"]
+        chosen_model_id = receipt["model_id"]
+    elif not body_available:
         response_text = (
             f"[UNAVAILABLE] Profile '{profile_id}' body could not be resolved on disk "
             f"and no {(profile.get('system_prompt_ref') or {}).get('env')} override is set. "
@@ -577,6 +630,17 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict:
                 "forum": f"/api/{ns}/v1/llm/forum",
                 "registry": f"/api/{ns}/v1/llm/registry",
             },
+            # Wave M (Dev 2): run this profile on SZL's OWN sovereign local model.
+            "run_on_sovereign": {
+                "available": bool(_SOV_OK),
+                "how": ("POST /harness/apply with model_id='szl-sovereign-local' "
+                        "(alias of registry backend 'sovereign_local'). Routes the "
+                        "profile-applied prompt through the local Tower via Dev-1's "
+                        "registry backend; honest MODELED/UNAVAILABLE when offline."),
+                "backend_id": "sovereign_local",
+                "model_slug": "llama3-szl-finetuned-q4",
+                "provider_provenance": "SZL sovereign (Ollama, local, Doctrine-v11 system prompt)",
+            },
             "capability_ceiling": "Behavior transfer is MODELED — changes disposition, NOT capability. "
                                   "Only original weights deliver capability (honest ceiling).",
             "doctrine": DOCTRINE,
@@ -615,6 +679,12 @@ def register(app: FastAPI, ns: str = "a11oy") -> dict:
 
         Body: {"profile_id": "szl-fable", "model_id": "claude_opus_4_8",
                "prompt": "…", "axis_scores": [..], "max_tier": 4, "task_hint": ""}
+
+        Wave M (Dev 2): pass model_id="szl-sovereign-local" (or the registry id
+        "sovereign_local") to run this profile on SZL's OWN governed model via
+        Dev-1's sovereign backend. When the local Tower endpoint is unreachable
+        the apply returns honest MODELED/UNAVAILABLE and the receipt still records
+        the intended sovereign backend — no model response is ever fabricated.
         """
         try:
             body = await request.json()

szl_sovereign_flywheel.py

@@ -0,0 +1,324 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+# Authored by Yachay (CTO) + Perplexity Computer Agent — a11oy Sovereign Flywheel bridge
+# Co-Authored-By: Perplexity Computer Agent <agent@perplexity.ai>
+# Signed-off-by: Stephen P. Lutar Jr. <stephenlutar2@gmail.com>
+"""
+szl_sovereign_flywheel — the single call path that lets the GOVERNED FLYWHEEL
+(harness /harness/apply, eval-arena /eval/run, agent-loop /agentloop/run, RAG
+/rag/query) run on SZL's OWN sovereign local model.
+
+Wave M, Dev 2. This module DOES NOT re-implement the sovereign backend — it is a
+thin, guarded ADAPTER over the first-class `sovereign_local` backend that Dev 1
+registered in `szl_llm_registry.py` (model tag `llama3-szl-finetuned-q4`, targets
+`SZL_LOCAL_LLM_URL`, provider provenance "SZL sovereign (Ollama, local,
+Doctrine-v11 system prompt)"). Every flywheel flow imports THIS module and calls
+`run_on_sovereign(...)`, so the whole loop routes through exactly ONE code path to
+Dev-1's registry functions (`sovereign_probe` / `sovereign_generate`).
+
+DEPENDENCY (Wave M coordination): the routed backend `sovereign_local` lives in
+szl_llm_registry.py. As of Wave M it is present on main (PR #791, merged). If a
+future refactor removes those registry helpers this module degrades to an honest
+UNAVAILABLE (never fabricates a response) — the intended sovereign backend is
+still recorded in the receipt. We code against the backend id, not a copy of it.
+
+HONESTY (Doctrine v11 LOCKED):
+  * We NEVER fabricate a model response. When the Tower / local endpoint is not
+    reachable (CI, cloud, air-gap not up) `run_on_sovereign` returns an honest
+    MODELED / UNAVAILABLE result whose `text` is None and whose receipt STILL
+    records the intended sovereign backend (id, slug, url, provider, label).
+  * `state` is one of:
+      LIVE        — the local node answered live THIS request (real text).
+      MODELED     — env base present but the node did not answer live this
+                    request (honest stub; no fabricated text).
+      UNAVAILABLE — SZL_LOCAL_LLM_URL unset (no local fleet base) OR the
+                    registry sovereign backend could not be imported.
+  * Λ = Conjecture 1 (advisory, never "green", never a theorem). Nothing here
+    touches the locked-8.
+
+This closes the loop: SZL's OWN governed model, evaluated + gated + receipted by
+SZL's OWN stack. Additive; guarded; pure stdlib (the HTTP call itself lives in the
+registry). Nothing added to the locked-8. Doctrine v11 LOCKED — 749/14/163 — c7c0ba17.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+DOCTRINE = "v11"
+_KERNEL = "c7c0ba17"
+_CONJECTURE_NOTE = "Λ = Conjecture 1 — NOT a theorem. Advisory, never 'green'."
+
+# The registry backend id Dev 1 registered. The brief refers to it as
+# "szl-sovereign-local"; the registry entry uses the id "sovereign_local" with
+# slug "llama3-szl-finetuned-q4". We accept BOTH spellings as the same request so
+# a caller can use either the brief's name or the registry id.
+SOVEREIGN_BACKEND_ID = "sovereign_local"
+SOVEREIGN_MODEL_SLUG = "llama3-szl-finetuned-q4"
+SOVEREIGN_PROVIDER = "SZL sovereign (Ollama, local, Doctrine-v11 system prompt)"
+SOVEREIGN_ENV_VAR = "SZL_LOCAL_LLM_URL"
+_SOVEREIGN_ALIASES = frozenset({
+    "sovereign_local", "szl-sovereign-local", "szl_sovereign_local",
+    "sovereign-local", "sovereign", "szl-sovereign",
+})
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def is_sovereign(model_id: str | None) -> bool:
+    """True when the caller asked for SZL's sovereign local backend (any alias).
+
+    Accepts the brief's `szl-sovereign-local`, the registry id `sovereign_local`,
+    and a few obvious spellings. Case-insensitive; never raises.
+    """
+    if not model_id:
+        return False
+    return str(model_id).strip().lower().replace(" ", "") in {
+        a.replace(" ", "") for a in _SOVEREIGN_ALIASES
+    }
+
+
+def _reg():
+    """Import Dev-1's registry (the sovereign backend lives there). Mirror the
+    serve.py resolution order: prefer the extracted substrate package, fall back
+    to the local module, so we bind the SAME instance serve.py loaded."""
+    try:  # pragma: no cover — substrate package path (in-image)
+        from szl_substrate import szl_llm_registry as _r  # type: ignore
+        return _r
+    except Exception:
+        import szl_llm_registry as _r
+        return _r
+
+
+def intended_backend() -> dict[str, Any]:
+    """The intended sovereign backend descriptor — recorded in EVERY receipt,
+    reachable or not, so an offline run still names WHAT WOULD RUN.
+
+    Reads the live registry entry when importable (single source of truth); falls
+    back to the module constants if the registry can't be imported (still honest).
+    """
+    desc: dict[str, Any] = {
+        "requested_model_id": None,          # filled by run_on_sovereign
+        "backend_id": SOVEREIGN_BACKEND_ID,
+        "model_slug": SOVEREIGN_MODEL_SLUG,
+        "provider_provenance": SOVEREIGN_PROVIDER,
+        "env_var": SOVEREIGN_ENV_VAR,
+        "base_url": None,
+        "registry_wired": False,
+        "source": "module_constants",
+    }
+    try:
+        reg = _reg()
+        entry = getattr(reg, "_MODEL_BY_ID", {}).get(SOVEREIGN_BACKEND_ID)
+        if isinstance(entry, dict):
+            desc["model_slug"] = entry.get("model_slug", SOVEREIGN_MODEL_SLUG)
+            desc["backend_id"] = entry.get("model_id", SOVEREIGN_BACKEND_ID)
+            desc["registry_wired"] = True
+            desc["source"] = "szl_llm_registry (Dev-1 backend)"
+        # resolve the configured base URL (never the secret — this is a URL/env)
+        base_fn = getattr(reg, "_sovereign_base", None)
+        if callable(base_fn):
+            desc["base_url"] = base_fn() or None
+        slug_fn = getattr(reg, "_sovereign_model_slug", None)
+        if callable(slug_fn):
+            desc["served_model_tag"] = slug_fn()
+    except Exception as e:  # registry not importable → honest, still records intent
+        desc["registry_import_error"] = repr(e)
+        desc["dependency_note"] = (
+            "szl_llm_registry sovereign backend not importable in this runtime; "
+            "recorded the intended backend from module constants — no fabrication.")
+    return desc
+
+
+def run_on_sovereign(prompt: str, *, requested_model_id: str = SOVEREIGN_BACKEND_ID,
+                     probe_only: bool = False) -> dict[str, Any]:
+    """Route ONE call through Dev-1's sovereign_local backend. NEVER fabricates.
+
+    Returns a dict:
+      {
+        state: "LIVE" | "MODELED" | "UNAVAILABLE",
+        live: bool,
+        text: str | None,          # REAL model text ONLY when state == LIVE
+        api_style: str | None,     # ollama /api/generate | openai /v1 ... (live only)
+        backend: {intended backend descriptor + reachability},
+        note: str,                 # honest human-readable label
+        conjecture_note, doctrine, kernel_commit,
+      }
+
+    state semantics:
+      LIVE        — SZL_LOCAL_LLM_URL set AND the node answered live THIS request.
+      MODELED     — env base present but node did not answer live (honest stub).
+      UNAVAILABLE — no env base (no local fleet) OR registry import failed.
+    """
+    prompt = str(prompt or "")
+    backend = intended_backend()
+    backend["requested_model_id"] = requested_model_id
+    backend["probed_at"] = _now()
+
+    out: dict[str, Any] = {
+        "state": "UNAVAILABLE",
+        "live": False,
+        "text": None,
+        "api_style": None,
+        "backend": backend,
+        "note": "",
+        "conjecture_note": _CONJECTURE_NOTE,
+        "doctrine": DOCTRINE,
+        "kernel_commit": _KERNEL,
+    }
+
+    # 1) reachability probe (short timeout) — reflect it in the backend block
+    try:
+        reg = _reg()
+        probe = reg.sovereign_probe()  # {env_present, live, models, base_url, note, ...}
+    except Exception as e:  # registry / sovereign helpers unavailable
+        backend["reachable"] = False
+        backend["probe_error"] = repr(e)
+        out["note"] = (
+            "UNAVAILABLE — szl_llm_registry sovereign backend not importable in this "
+            "runtime; no model call attempted; intended sovereign backend recorded; "
+            "no response fabricated.")
+        return out
+
+    backend["reachable"] = bool(probe.get("live"))
+    backend["env_present"] = bool(probe.get("env_present"))
+    backend["base_url"] = probe.get("base_url") or backend.get("base_url")
+    backend["served_models"] = probe.get("models", [])
+    backend["probe_note"] = probe.get("note")
+
+    if not probe.get("env_present"):
+        out["state"] = "UNAVAILABLE"
+        out["note"] = (
+            f"UNAVAILABLE — {SOVEREIGN_ENV_VAR} is not set, so there is no local "
+            "sovereign fleet base to reach (CI / cloud / Tower offline). No model "
+            "call attempted; the intended sovereign backend "
+            f"('{backend['backend_id']}', slug '{backend['model_slug']}') is still "
+            "recorded in the receipt. No response fabricated.")
+        return out
+
+    if not probe.get("live"):
+        out["state"] = "MODELED"
+        out["note"] = (
+            f"MODELED — {SOVEREIGN_ENV_VAR} is set ({backend.get('base_url')}) but the "
+            "sovereign node did not answer live THIS request (honest stub). No model "
+            "text fabricated; the intended sovereign backend is recorded. "
+            f"Probe: {probe.get('note')}")
+        return out
+
+    # 2) node is live. If probe_only, report LIVE reachability without generating.
+    if probe_only:
+        out["state"] = "LIVE"
+        out["live"] = True
+        out["api_style"] = probe.get("api_style")
+        out["note"] = (
+            "LIVE — sovereign node reachable this request (probe only, no generation). "
+            f"Served: {', '.join(backend.get('served_models') or []) or '(none reported)'}")
+        return out
+
+    # 3) REAL generation through Dev-1's sovereign_generate (never fabricated)
+    try:
+        gen = reg.sovereign_generate(prompt)  # {wired, live, text, api_style, ...}
+    except Exception as e:
+        out["state"] = "MODELED"
+        out["note"] = (
+            "MODELED — sovereign node probed live but sovereign_generate raised "
+            f"({e!r}); no text fabricated; intended backend recorded.")
+        return out
+
+    if gen.get("live") and isinstance(gen.get("text"), str):
+        out["state"] = "LIVE"
+        out["live"] = True
+        out["text"] = gen["text"]
+        out["api_style"] = gen.get("api_style")
+        backend["served_model_tag"] = gen.get("model")
+        out["note"] = (
+            "LIVE — REAL generation from SZL's sovereign local model this request "
+            f"({gen.get('api_style')}). Provider: {SOVEREIGN_PROVIDER}.")
+        if isinstance(gen.get("raw"), dict):
+            out["raw"] = gen["raw"]
+        return out
+
+    # env present, probe live, but generate did not return live text → honest MODELED
+    out["state"] = "MODELED"
+    out["note"] = (
+        "MODELED — sovereign node reachable but did not return live text this "
+        f"request (honest stub). No text fabricated. Detail: {gen.get('note')}")
+    return out
+
+
+def receipt_block(sov: dict[str, Any]) -> dict[str, Any]:
+    """Compact, receipt-embeddable summary of a run_on_sovereign() result.
+
+    Records the INTENDED sovereign backend + honest state on EVERY run — reachable
+    or not — so an offline flywheel run still proves which sovereign backend it
+    would have used (never fabricates text into the receipt).
+    """
+    b = sov.get("backend") or {}
+    return {
+        "requested": b.get("requested_model_id"),
+        "backend_id": b.get("backend_id"),
+        "model_slug": b.get("model_slug"),
+        "provider_provenance": b.get("provider_provenance"),
+        "env_var": b.get("env_var"),
+        "base_url": b.get("base_url"),
+        "registry_wired": b.get("registry_wired"),
+        "reachable": b.get("reachable"),
+        "env_present": b.get("env_present"),
+        "served_models": b.get("served_models"),
+        "state": sov.get("state"),
+        "live": sov.get("live"),
+        "api_style": sov.get("api_style"),
+        # text is recorded ONLY when LIVE (real); never fabricated otherwise
+        "text_present": bool(sov.get("text")),
+        "note": sov.get("note"),
+        "conjecture_note": _CONJECTURE_NOTE,
+        "dependency": ("routes through szl_llm_registry.sovereign_local (Dev-1 "
+                       "backend, Wave M PR #791). Codes against the backend id; "
+                       "degrades to honest UNAVAILABLE if that backend is absent."),
+    }
+
+
+def selected_label(sov: dict[str, Any]) -> str:
+    """One-line honest label for the flow's `_selected`/`honesty_label` surface."""
+    st = sov.get("state")
+    if st == "LIVE":
+        return "LIVE (SZL sovereign local model — real generation this request)"
+    if st == "MODELED":
+        return "MODELED (SZL sovereign backend selected; node not live this request — no fabrication)"
+    return "UNAVAILABLE (SZL sovereign backend selected; local endpoint unreachable — no fabrication)"
+
+
+def _selftest() -> None:  # pragma: no cover — `python3 szl_sovereign_flywheel.py`
+    # alias detection
+    assert is_sovereign("szl-sovereign-local")
+    assert is_sovereign("sovereign_local")
+    assert is_sovereign("SOVEREIGN-LOCAL")
+    assert not is_sovereign("claude_opus_4_8")
+    assert not is_sovereign("")
+    # intended backend always records the sovereign identity, reachable or not
+    b = intended_backend()
+    assert b["backend_id"] == SOVEREIGN_BACKEND_ID
+    assert b["model_slug"] == SOVEREIGN_MODEL_SLUG
+    assert b["provider_provenance"] == SOVEREIGN_PROVIDER
+    # with no SZL_LOCAL_LLM_URL in this env → honest UNAVAILABLE, no fabricated text
+    r = run_on_sovereign("State your doctrine in one line.")
+    assert r["state"] in ("UNAVAILABLE", "MODELED", "LIVE")
+    if r["state"] != "LIVE":
+        assert r["text"] is None, "no text may be fabricated when not LIVE"
+    rb = receipt_block(r)
+    assert rb["backend_id"] == SOVEREIGN_BACKEND_ID
+    assert rb["model_slug"] == SOVEREIGN_MODEL_SLUG
+    assert rb["state"] == r["state"]
+    assert rb["text_present"] == bool(r["text"])
+    lbl = selected_label(r)
+    assert isinstance(lbl, str) and lbl
+    print(f"szl_sovereign_flywheel: ALL OK — is_sovereign works, intended backend "
+          f"recorded, run_on_sovereign honest state={r['state']} "
+          f"(text fabricated? {'no' if r['text'] is None else 'LIVE-real'}), "
+          f"receipt_block records intended backend. Λ=Conjecture 1.")
+
+
+if __name__ == "__main__":
+    _selftest()