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_immune.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.

Dockerfile

@@ -156,6 +156,14 @@ COPY joule_billing.py szl_energy_ledger.py szl_energy_operator.py szl_energy_pro
 # /api/a11oy/v1/kverify/* 404s. Reuses szl_energy_operator (inference + NVML joules)
 # + szl_khipu (the shared signed-receipt chain), both already COPY'd above.
 COPY szl_kverify.py ./
+# Immune (Hukulla) HONEST egress-gate surface — imported by serve.py (guarded).
+# MUST be per-file COPY'd (no `COPY . .`) or the import falls back and the honest
+# /api/a11oy/v1/immune/* namespace 404s. Reuses szl_khipu (the shared signed-
+# receipt chain), already COPY'd above. Auto-mirrored to the HF Space by
+# hf-sync-backend.yml (it parses the Dockerfile COPY set). web/immune.html (the
+# served page) is per-file COPY'd below and declared image_only in
+# .github/copy-sync-lockstep.json (same baked-only pattern as web/energy.html).
+COPY szl_immune.py ./
 # ADDITIVE (I3): FABRO-style Governed Factory + Constitutional Engines modules.
 # MUST be COPY'd or serve.py's guarded imports fall back (merged-but-not-live).
 # HTML/JS is inlined in these .py modules, so NO web/ or static-vendor COPY needed.
@@ -1024,6 +1032,12 @@ COPY static/3d/ ./static/3d/
 # module above via the same-origin importmap. Per-file served assets -> image_only_assets.
 COPY web/energy-holographic.html ./web/energy-holographic.html
 COPY web/energy.html ./web/energy.html
+# Immune (Hukulla) honest egress-gate page (/immune, /a11oy/immune). Standalone
+# sovereign page (0 runtime CDN), binds to live /api/a11oy/v1/immune/* (status/
+# gates/feed + a live inspect->verdict box showing real deny/allow + signed Khipu
+# receipt digest). Per-file served asset -> declared image_only in copy-sync-
+# lockstep.json (same baked-only pattern as web/energy.html). Codename-free.
+COPY web/immune.html ./web/immune.html
 
 # git_sha wireup (FORGE-INSTRUCTION-gitsha-quiet-window): surface the deployed commit
 # at the /honest endpoint so a stale box or Space is self-detecting. Provided at build

szl_immune.py

@@ -0,0 +1,493 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173
+# Doctrine v11 — Immune (Hukulla) honest egress-gate surface.
+"""
+szl_immune.py — expose the Immune organ on the HONEST a11oy namespace.
+
+The immune detector is REAL and LIVE in serve.py, but historically the only HTTP
+routes for it were user-visible CODENAME namespaces (a doctrine v11 violation,
+and the reason /api/a11oy/v1/immune* returned 404). This module exposes the
+CANONICAL, honest surface wired to the SAME real inspection logic — fail-closed,
+deny-by-default — and signs a Khipu receipt per verdict into the SHARED
+szl_khipu chain.
+
+USER-VISIBLE ORGAN NAME: "Immune" (Quechua role "Hukulla"). This module NEVER
+emits a codename (sentra / amaru / rosie / jarvis) in any served string.
+
+ENDPOINTS (dual-registered under /api/a11oy/v1/immune/* AND /v1/immune/*):
+  GET  /healthz  -> liveness + organ identity.
+  GET  /status   -> live summary: signature-corpus size, lambda floor, total
+                    verdicts this process, deny rate, Lean proof refs, last
+                    receipt digest + Khipu chain head/depth.
+  GET  /gates    -> the REAL gate descriptors (signature-scan, size-guard,
+                    lambda-gate-floor) — same corpus the rest of the estate uses.
+  POST /verdict  -> run the REAL inspection (signature scan + 1 MB size guard +
+                    Lambda-gate floor 0.5) on {"action":{...},"axes"?,"agent"?,
+                    "request_id"|"actionId"?,"traceparent"?}; return the
+                    PolicyDecision shape PLUS a signed Khipu receipt
+                    (organ="immune", receipt_type "SZL.Immune.Verdict.v1").
+  GET  /feed?limit= -> the real in-memory decision ring (seeded from the captured
+                    real feed; resets on restart — empty = IDLE, never faked).
+  GET  /threats  -> the threats_full STIX/MITRE corpus.
+  GET  /verify   -> re-walk the immune Khipu chain (judge-verifiable integrity).
+
+INSPECTION LOGIC (byte-identical to serve.py's embedded immune block):
+  _THREAT_SIGNATURES = ["DROP TABLE","rm -rf","<script","eval(","subprocess","../../etc"]
+  size guard: payload string > 1_000_000 chars -> deny
+  Lambda gate floor: 0.5 — when axes are supplied and MIN(axes) < floor -> deny
+
+PROVEN BACKING (Lean): cited, NOT folded into the locked-8.
+  - Lutar/Wave11/ImmuneNeymanPearsonOpt.lean       (Neyman-Pearson-optimal egress gate)
+  - Lutar/Innovations/round11/FrontierWelfordVariance.lean (Welford online variance)
+  Locked-proven set remains EXACTLY 8 {F1,F4,F7,F11,F12,F18,F19,F22} @ kernel
+  c7c0ba17. Lambda = Conjecture 1 (NOT a theorem). Khipu = Conjecture 2. Trust is
+  never 100%. Effectors simulated. No fabricated data.
+
+Stdlib + the existing repo module (szl_khipu). No new dep, no CDN, no Node.
+Additive; try/except-guarded by the caller; registered BEFORE the SPA catch-all.
+"""
+from __future__ import annotations
+
+import base64
+import collections
+import datetime
+import hashlib
+import json
+import secrets
+import threading
+import time
+from typing import Any, Optional
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+# ---------------------------------------------------------------------------
+# Identity + doctrine constants (honest, never a codename).
+# ---------------------------------------------------------------------------
+_ORGAN_NAME = "Immune (Hukulla)"
+_KHIPU_ORGAN = "immune"
+_RECEIPT_TYPE = "SZL.Immune.Verdict.v1"
+_LEAN_PROOFS = [
+    {
+        "ref": "Lutar/Wave11/ImmuneNeymanPearsonOpt.lean",
+        "claim": "Neyman-Pearson-optimal egress gate (likelihood-ratio test minimises "
+                 "miss-rate at a fixed false-alarm bound).",
+        "status": "proven-backing (NOT in the locked-8)",
+    },
+    {
+        "ref": "Lutar/Innovations/round11/FrontierWelfordVariance.lean",
+        "claim": "Welford online mean/variance recurrence (numerically stable single-pass "
+                 "anomaly statistic).",
+        "status": "proven-backing (NOT in the locked-8)",
+    },
+]
+_LOCKED_PROVEN = ["F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22"]  # EXACTLY 8 @ c7c0ba17
+_KERNEL_COMMIT = "c7c0ba17"
+
+# ---------------------------------------------------------------------------
+# REAL inspection logic — byte-identical to serve.py's embedded immune block.
+# ---------------------------------------------------------------------------
+_THREAT_SIGNATURES = ["DROP TABLE", "rm -rf", "<script", "eval(", "subprocess", "../../etc"]
+_LAMBDA_GATE_FLOOR = 0.5
+_SIZE_GUARD_BYTES = 1_000_000
+
+
+def _run_inspection(body: Any) -> tuple[bool, list[str]]:
+    blob = str(body).lower()
+    fired: list[str] = []
+    for sig in _THREAT_SIGNATURES:
+        if sig.lower() in blob:
+            fired.append("threat-signature:" + sig)
+    if len(blob) > _SIZE_GUARD_BYTES:
+        fired.append("size-guard:payload-exceeds-1MB")
+    return (len(fired) == 0, fired)
+
+
+def _compute_lambda(axes: Optional[list], is_clean: bool) -> float:
+    if axes:
+        return min(axes)
+    return 1.0 if is_clean else 0.0
+
+
+# ---------------------------------------------------------------------------
+# Real gate / threats corpus + seed feed — the SAME data the rest of the estate
+# uses, embedded so /gates, /threats and /feed return REAL (not fabricated) data.
+# ---------------------------------------------------------------------------
+_BUNDLE_B64 = "{"gates":{"gates":[{"id":"gate-01","name":"signature-scan","label":"Threat Signature Scan","description":"Matches action payload against the THREAT_SIGNATURES corpus. Catches SQL injection, shell injection, XSS, path traversal, and dangerous subprocess invocations.","category":"detection","artDomain":"ArtDomain.Security","permittedContexts":["egress","admission","threat"],"dualUse":false,"sampleInput":"DROP TABLE users; --","expectedDecision":"deny"},{"id":"gate-02","name":"size-guard","label":"Size / DoS Guard","description":"Rejects payloads exceeding 1 MB to prevent memory exhaustion and denial-of-service via oversized action blobs.","category":"resource","artDomain":"ArtDomain.Ops","permittedContexts":["egress","admission"],"dualUse":false,"sampleInput":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","expectedDecision":"allow"},{"id":"gate-03","name":"lambda-threshold","label":"\u039b-Gate Threshold","description":"Evaluates the minimum of all \u039b-axis scores provided by the caller. If MIN(axes) < 0.5 the gate denies. When no axes are supplied, falls back to binary allow/deny from the immune organ result.","category":"governance","artDomain":"ArtDomain.Governance","permittedContexts":["egress","admission","threat"],"dualUse":true,"sampleInput":{"action":"read_file","axes":[0.9,0.85,0.7]},"expectedDecision":"allow"},{"id":"gate-04","name":"dual-use-detection","label":"Dual-Use Detection","description":"Identifies actions with dual-use potential: operations that are legitimate in permitted contexts but weaponisable in hostile ones. Checks action kind hint (egress / threat / admission) and surface signals against known dual-use patterns (STIX/TAXII corpus).","category":"detection","artDomain":"ArtDomain.DualUse","permittedContexts":["threat"],"dualUse":true,"sampleInput":{"action":"nmap_scan","kind":"threat"},"expectedDecision":"allow"},{"id":"gate-05","name":"stix-taxii-ingest","label":"STIX/TAXII Ingest Gate","description":"Cross-references inbound threat indicators against the STIX/TAXII feed corpus. Denies actions whose indicators match active threat intelligence objects (IP, domain, hash, pattern).","category":"threat-intel","artDomain":"ArtDomain.ThreatIntel","permittedContexts":["egress","threat"],"dualUse":false,"sampleInput":{"action":"connect","destination":"185.220.101.1"},"expectedDecision":"allow"},{"id":"gate-06","name":"traceparent-propagation","label":"Traceparent Propagation","description":"Validates and propagates W3C traceparent headers through the immune decision chain. Rejects malformed trace-IDs to prevent nervous-system (Wire E) trace-poisoning attacks.","category":"observability","artDomain":"ArtDomain.Observability","permittedContexts":["egress","admission","threat"],"dualUse":false,"sampleInput":{"action":"log_event","traceparent":"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"},"expectedDecision":"allow"},{"id":"gate-07","name":"wire-b-contract","label":"Wire B Contract Validation","description":"Enforces the a11oy \u2192 policy Wire B anatomy contract. Validates that incoming requests conform to the PolicyVerdictRequest shape (action | payload field present, actionId trace correlation, kind in permitted set). Rejects structurally invalid requests.","category":"contract","artDomain":"ArtDomain.Contracts","permittedContexts":["egress","admission","threat"],"dualUse":false,"sampleInput":{"action":"write_file","actionId":"req-abc-123","kind":"egress"},"expectedDecision":"allow"},{"id":"gate-08","name":"receipt-hash","label":"Receipt Hash / Audit Chain","description":"Computes a deterministic receipt hash for every verdict, binding actionId + decision + timestamp into the audit chain. Enables forensic replay and non-repudiation of every immune decision.","category":"audit","artDomain":"ArtDomain.Audit","permittedContexts":["egress","admission","threat"],"dualUse":false,"sampleInput":{"action":"approve_spend","actionId":"req-xyz-999"},"expectedDecision":"allow"}],"total":8},"threats_full":{"total":30,"stix_version":"2.1","taxii_enabled":true,"mitre_attack_version":"v14","last_updated":"2026-06-05T00:00:00Z","corpus":[{"signature":"DROP TABLE","category":"sql-injection","stix_pattern":"[process:command_line MATCHES 'DROP TABLE']","severity":"high","mitre_technique":"T1190","mitre_tactic":"Initial Access","cvss_base":9.8},{"signature":"rm -rf","category":"shell-injection","stix_pattern":"[process:command_line MATCHES 'rm -rf']","severity":"high","mitre_technique":"T1485","mitre_tactic":"Impact","cvss_base":9.1},{"signature":"<script","category":"xss","stix_pattern":"[process:command_line MATCHES '<script']","severity":"high","mitre_technique":"T1189","mitre_tactic":"Initial Access","cvss_base":8.8},{"signature":"eval(","category":"code-injection","stix_pattern":"[process:command_line MATCHES 'eval(']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":9.3},{"signature":"subprocess","category":"process-injection","stix_pattern":"[process:command_line MATCHES 'subprocess']","severity":"high","mitre_technique":"T1055","mitre_tactic":"Defense Evasion","cvss_base":8.4},{"signature":"../../etc","category":"path-traversal","stix_pattern":"[process:command_line MATCHES '../../etc']","severity":"high","mitre_technique":"T1083","mitre_tactic":"Discovery","cvss_base":7.5},{"signature":"__import__","category":"python-import-injection","stix_pattern":"[process:command_line MATCHES '__import__']","severity":"high","mitre_technique":"T1059.006","mitre_tactic":"Execution","cvss_base":8.9},{"signature":"os.system","category":"os-command-injection","stix_pattern":"[process:command_line MATCHES 'os.system']","severity":"high","mitre_technique":"T1059.004","mitre_tactic":"Execution","cvss_base":9.0},{"signature":"exec(","category":"code-exec","stix_pattern":"[process:command_line MATCHES 'exec(']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":8.8},{"signature":"javascript:","category":"javascript-uri-injection","stix_pattern":"[url:value MATCHES 'javascript:']","severity":"medium","mitre_technique":"T1189","mitre_tactic":"Initial Access","cvss_base":6.5},{"signature":"data:text/html","category":"data-uri-injection","stix_pattern":"[url:value MATCHES 'data:text/html']","severity":"medium","mitre_technique":"T1189","mitre_tactic":"Initial Access","cvss_base":6.3},{"signature":"\\x00","category":"null-byte-injection","stix_pattern":"[process:command_line MATCHES '\\x00']","severity":"medium","mitre_technique":"T1027","mitre_tactic":"Defense Evasion","cvss_base":5.8},{"signature":"base64.b64decode","category":"base64-decode-injection","stix_pattern":"[process:command_line MATCHES 'base64.b64decode']","severity":"medium","mitre_technique":"T1027","mitre_tactic":"Defense Evasion","cvss_base":6.1},{"signature":"UNION SELECT","category":"sql-injection-union","stix_pattern":"[process:command_line MATCHES 'UNION SELECT']","severity":"high","mitre_technique":"T1190","mitre_tactic":"Initial Access","cvss_base":9.8},{"signature":"INSERT INTO","category":"sql-injection-insert","stix_pattern":"[process:command_line MATCHES 'INSERT INTO']","severity":"medium","mitre_technique":"T1190","mitre_tactic":"Initial Access","cvss_base":7.2},{"signature":"wget http","category":"shell-download","stix_pattern":"[process:command_line MATCHES 'wget http']","severity":"high","mitre_technique":"T1105","mitre_tactic":"Command and Control","cvss_base":8.1},{"signature":"curl http","category":"shell-download","stix_pattern":"[process:command_line MATCHES 'curl http']","severity":"medium","mitre_technique":"T1105","mitre_tactic":"Command and Control","cvss_base":7.0},{"signature":"/etc/passwd","category":"credential-access","stix_pattern":"[file:name = '/etc/passwd']","severity":"high","mitre_technique":"T1003","mitre_tactic":"Credential Access","cvss_base":8.5},{"signature":"/etc/shadow","category":"credential-access","stix_pattern":"[file:name = '/etc/shadow']","severity":"critical","mitre_technique":"T1003.008","mitre_tactic":"Credential Access","cvss_base":9.8},{"signature":"chmod 777","category":"privilege-escalation","stix_pattern":"[process:command_line MATCHES 'chmod 777']","severity":"high","mitre_technique":"T1222","mitre_tactic":"Defense Evasion","cvss_base":7.8},{"signature":"sudo -i","category":"privilege-escalation","stix_pattern":"[process:command_line MATCHES 'sudo -i']","severity":"high","mitre_technique":"T1548.003","mitre_tactic":"Privilege Escalation","cvss_base":8.8},{"signature":"nc -e","category":"reverse-shell","stix_pattern":"[process:command_line MATCHES 'nc -e']","severity":"critical","mitre_technique":"T1059.004","mitre_tactic":"Execution","cvss_base":9.9},{"signature":"bash -i >& /dev/tcp","category":"reverse-shell","stix_pattern":"[process:command_line MATCHES 'bash -i >& /dev/tcp']","severity":"critical","mitre_technique":"T1059.004","mitre_tactic":"Execution","cvss_base":9.9},{"signature":"LOAD_FILE","category":"sql-file-read","stix_pattern":"[process:command_line MATCHES 'LOAD_FILE']","severity":"high","mitre_technique":"T1190","mitre_tactic":"Initial Access","cvss_base":8.6},{"signature":"OUTFILE","category":"sql-file-write","stix_pattern":"[process:command_line MATCHES 'OUTFILE']","severity":"high","mitre_technique":"T1190","mitre_tactic":"Initial Access","cvss_base":8.6},{"signature":"document.cookie","category":"session-hijack","stix_pattern":"[process:command_line MATCHES 'document.cookie']","severity":"high","mitre_technique":"T1539","mitre_tactic":"Credential Access","cvss_base":8.2},{"signature":"prompt injection","category":"prompt-injection","stix_pattern":"[process:command_line MATCHES 'prompt injection']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":8.0},{"signature":"ignore previous instructions","category":"prompt-injection","stix_pattern":"[process:command_line MATCHES 'ignore previous instructions']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":8.0},{"signature":"disregard your system prompt","category":"prompt-injection","stix_pattern":"[process:command_line MATCHES 'disregard your system prompt']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":8.0},{"signature":"act as DAN","category":"jailbreak","stix_pattern":"[process:command_line MATCHES 'act as DAN']","severity":"high","mitre_technique":"T1059","mitre_tactic":"Execution","cvss_base":7.8}],"parity":"Splunk Threat Intelligence + Wiz CSPM rule corpus parity"},"feed_seed":[{"id":"80888025b1d3dc5a","timestamp":"2026-06-05T23:32:40.037559Z","decision":"deny","agent":"a11oy-demo","action":"","signals":["threat-signature:DROP TABLE"],"lambda_value":0.0,"receipt_hash":"96e50a4105a3a12f"},{"id":"5d732a7847fb80a4","timestamp":"2026-06-05T23:31:16.524801Z","decision":"deny","agent":"a11oy-demo","action":"","signals":["threat-signature:DROP TABLE"],"lambda_value":0.0,"receipt_hash":"ddf859fd91f769ed"},{"id":"43e7cb9d56208afe","timestamp":"2026-06-05T23:10:48.989315Z","decision":"deny","agent":"t","action":"","signals":["threat-signature:DROP TABLE"],"lambda_value":0.0,"receipt_hash":"70eb70fa9c0c0064"},{"id":"03f3d650b0f35d18","timestamp":"2026-06-05T23:10:48.709423Z","decision":"deny","agent":"section889-screen","action":"","signals":["section889:Huawei"],"lambda_value":0.0,"receipt_hash":"b2f3a3fa87da2372"},{"id":"seed-000","timestamp":"2026-06-05T21:35:03.235821Z","decision":"allow","agent":"a11oy-mesh-router","action":"","signals":[],"lambda_value":1.0,"receipt_hash":""},{"id":"seed-001","timestamp":"2026-06-05T21:36:03.235844Z","decision":"deny","agent":"a11oy-mesh-router","action":"","signals":["threat-signature:DROP TABLE"],"lambda_value":0.0,"receipt_hash":""},{"id":"seed-002","timestamp":"2026-06-05T21:37:03.235849Z","decision":"allow","agent":"policy-console","action":"","signals":[],"lambda_value":1.0,"receipt_hash":""},{"id":"seed-003","timestamp":"2026-06-05T21:38:03.235854Z","decision":"deny","agent":"a11oy-mesh-router","action":"","signals":["threat-signature:rm -rf"],"lambda_value":0.0,"receipt_hash":""},{"id":"seed-004","timestamp":"2026-06-05T21:39:03.235858Z","decision":"allow","agent":"policy-console","action":"","signals":[],"lambda_value":1.0,"receipt_hash":""},{"id":"seed-005","timestamp":"2026-06-05T21:40:03.235862Z","decision":"deny","agent":"a11oy-mesh-router","action":"","signals":["threat-signature:<script"],"lambda_value":0.0,"receipt_hash":""},{"id":"seed-006","timestamp":"2026-06-05T21:41:03.235865Z","decision":"allow","agent":"policy-console","action":"","signals":[],"lambda_value":1.0,"receipt_hash":""},{"id":"seed-007","timestamp":"2026-06-05T21:42:03.235869Z","decision":"deny","agent":"a11oy-mesh-router","action":"","signals":["threat-signature:eval("],"lambda_value":0.0,"receipt_hash":""},{"id":"seed-008","timestamp":"2026-06-05T21:43:03.235873Z","decision":"allow","agent":"policy-console","action":"","signals":[],"lambda_value":1.0,"receipt_hash":""},{"id":"seed-009","timestamp":"2026-06-05T21:44:03.235876Z","decision":"deny","agent":"a11oy-mesh-router","action":"","signals":["threat-signature:../../etc"],"lambda_value":0.0,"receipt_hash":""}],"feed_note":"Real entries from in-memory audit ring (maxlen=200). Resets on Space restart. Empty = IDLE."}"
+try:
+    _BUNDLE = json.loads(base64.b64decode(_BUNDLE_B64))
+except Exception:  # noqa: BLE001 — never let a decode failure break import
+    _BUNDLE = {"gates": {"gates": [], "total": 0}, "threats_full": {"total": 0, "corpus": []},
+               "feed_seed": [], "feed_note": ""}
+
+# ---------------------------------------------------------------------------
+# In-memory decision ring (seeded from the captured real feed) + counters.
+# Resets on Space restart — empty == IDLE, never faked.
+# ---------------------------------------------------------------------------
+_AUDIT_LOCK = threading.Lock()
+_AUDIT: "collections.deque[dict]" = collections.deque(maxlen=200)
+for _v in reversed(list(_BUNDLE.get("feed_seed", []))):
+    _AUDIT.appendleft(dict(_v))
+
+_STATS_LOCK = threading.Lock()
+_STATS = {"verdicts": 0, "deny": 0, "allow": 0, "last_receipt_digest": None}
+
+
+def _log_verdict(rid: str, agent: str, action: Any, decision: str,
+                 signals: list[str], lam: float, rh: str) -> None:
+    entry = {
+        "id": secrets.token_hex(8), "request_id": rid, "agent": agent or "unknown",
+        "action_preview": str(action)[:120], "decision": decision, "signals": signals,
+        "lambda_value": lam, "receipt_hash": rh,
+        "timestamp": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+    }
+    with _AUDIT_LOCK:
+        _AUDIT.appendleft(entry)
+
+
+# ---------------------------------------------------------------------------
+# The verdict — run the REAL inspection, sign a Khipu receipt into the SHARED
+# chain, return the PolicyDecision shape + the receipt link. Fail-closed.
+# ---------------------------------------------------------------------------
+def _build_verdict(body: dict) -> dict:
+    import szl_khipu
+
+    body = body or {}
+    agent = body.get("agent") or "unknown"
+    action = body.get("action")
+    axes = body.get("axes")
+    rid = body.get("request_id") or body.get("actionId") or "unspecified"
+    traceparent = body.get("traceparent")
+
+    packet = action if isinstance(action, dict) else {"value": action}
+    is_clean, signals = _run_inspection(packet)
+    lam = _compute_lambda(axes, is_clean)
+    lambda_tripped = axes is not None and lam < _LAMBDA_GATE_FLOOR
+    if lambda_tripped:
+        signals = signals + ["lambda-gate:min-axis-" + str(round(lam, 4))
+                             + "-below-floor-" + str(_LAMBDA_GATE_FLOOR)]
+    decision = "allow" if (is_clean and not lambda_tripped) else "deny"
+    if not is_clean:
+        reason = "immune organ rejected: threat signature or size guard tripped"
+    elif lambda_tripped:
+        reason = ("immune organ rejected: Lambda-gate floor — MIN(axes)="
+                  + str(round(lam, 4)) + " < " + str(_LAMBDA_GATE_FLOOR))
+    else:
+        reason = "no threat signature detected by the immune organ"
+
+    rh = hashlib.sha256(
+        (str(rid) + ":" + decision + ":" + str(round(lam, 6)) + ":" + str(time.time())).encode()
+    ).hexdigest()[:16]
+    _log_verdict(rid, agent, action, decision, signals, lam, rh)
+
+    # Sign a Khipu receipt into the SHARED immune chain (tamper-evident).
+    dag = szl_khipu.get_dag(_KHIPU_ORGAN, ns="a11oy")
+    receipt_payload = {
+        "receipt_type": _RECEIPT_TYPE,
+        "organ": _ORGAN_NAME,
+        "actionId": rid,
+        "agent": agent,
+        "decision": decision,
+        "reason": reason,
+        "signals": signals,
+        "lambda_value": lam,
+        "lambda_floor": _LAMBDA_GATE_FLOOR,
+        "fail_closed": True,
+        "verdict_hash": rh,
+        "honesty": {
+            "lambda": "Conjecture 1 (NOT a theorem)",
+            "khipu": "Conjecture 2",
+            "trust_ceiling": "never 100%",
+            "effectors": "simulated",
+            "fabricated_data": False,
+        },
+        "lean_backing": [p["ref"] for p in _LEAN_PROOFS],
+        "doctrine": "v11",
+    }
+    receipt = dag.emit("immune.verdict", receipt_payload)
+
+    with _STATS_LOCK:
+        _STATS["verdicts"] += 1
+        if decision == "deny":
+            _STATS["deny"] += 1
+        else:
+            _STATS["allow"] += 1
+        _STATS["last_receipt_digest"] = receipt["digest"]
+
+    return {
+        "decision": decision,
+        "reason": reason,
+        "signals": signals,
+        "lambda_value": lam,
+        "lambda_floor": _LAMBDA_GATE_FLOOR,
+        "receipt_hash": rh,
+        "actionId": rid,
+        "gates_fired": signals,
+        "traceparent": traceparent,
+        "organ": _ORGAN_NAME,
+        "fail_closed": True,
+        "khipu_receipt": {
+            "receipt_type": _RECEIPT_TYPE,
+            "organ": _KHIPU_ORGAN,
+            "ns": "a11oy",
+            "seq": receipt["seq"],
+            "digest": receipt["digest"],
+            "prev": receipt["prev"],
+            "payload_digest": receipt["payload_digest"],
+            "signature": receipt.get("signature"),
+            "chain_verified": receipt.get("chain_verified"),
+        },
+        "lean_backing": _LEAN_PROOFS,
+        "doctrine": "v11",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Read surfaces — honest summaries built from the live ring + the real corpus.
+# Wrapped in gov_envelope(status="REAL") to match the rest of the estate.
+# ---------------------------------------------------------------------------
+def _gov(payload: dict, status: str = "REAL", **extra) -> dict:
+    """Governed envelope — byte-compatible with serve.py's gov_envelope contract
+    ({status, citations, fetchedAt, doctrine}). Reproduced inline so this module
+    never has to import the (heavy) serve module at request time."""
+    out = dict(payload)
+    st = str(status or "REAL").upper()
+    if st not in ("REAL", "DEMO", "DEGRADED"):
+        st = "DEGRADED"
+    out["status"] = st
+    if out.get("citations") is None:
+        out["citations"] = []
+    out["fetchedAt"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+    out.setdefault("doctrine", "v11")
+    for k, v in extra.items():
+        out[k] = v
+    return out
+
+
+def _healthz() -> dict:
+    return {
+        "status": "ok",
+        "service": "immune",
+        "organ": _ORGAN_NAME,
+        "fail_closed": True,
+        "doctrine": "v11",
+    }
+
+
+def _status() -> dict:
+    import szl_khipu
+    dag = szl_khipu.get_dag(_KHIPU_ORGAN, ns="a11oy")
+    chain = dag.verify_chain()
+    with _STATS_LOCK:
+        n = _STATS["verdicts"]
+        deny = _STATS["deny"]
+        allow = _STATS["allow"]
+        last_digest = _STATS["last_receipt_digest"]
+    deny_rate = round(deny / n, 4) if n else None
+    payload = {
+        "ok": True,
+        "service": "immune",
+        "organ": _ORGAN_NAME,
+        "role": "fail-closed egress gate (deny-by-default)",
+        "signature_corpus_size": len(_THREAT_SIGNATURES),
+        "signatures": list(_THREAT_SIGNATURES),
+        "lambda_gate_floor": _LAMBDA_GATE_FLOOR,
+        "size_guard_bytes": _SIZE_GUARD_BYTES,
+        "threats_corpus_total": _BUNDLE.get("threats_full", {}).get("total", 0),
+        "verdicts_this_process": n,
+        "deny": deny,
+        "allow": allow,
+        "deny_rate": deny_rate,
+        "last_receipt_digest": last_digest,
+        "khipu": {
+            "organ": _KHIPU_ORGAN,
+            "ns": "a11oy",
+            "chain_depth": dag.depth(),
+            "head_digest": dag.head(),
+            "chain_verified": chain.get("ok"),
+            "broken_at": chain.get("broken_at"),
+            "kind": "Conjecture 2",
+        },
+        "lean_backing": _LEAN_PROOFS,
+        "locked_proven": {
+            "set": _LOCKED_PROVEN,
+            "count": len(_LOCKED_PROVEN),
+            "kernel_commit": _KERNEL_COMMIT,
+            "note": "EXACTLY 8 locked-proven; the Lean immune backing is cited but NOT folded in.",
+        },
+        "honesty": {
+            "lambda": "Conjecture 1 (NOT a theorem)",
+            "trust_ceiling": "never 100%",
+            "effectors": "simulated",
+            "feed_resets_on_restart": True,
+            "fabricated_data": False,
+        },
+        "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    return _gov(payload, status="REAL")
+
+
+def _gates() -> dict:
+    payload = dict(_BUNDLE.get("gates", {"gates": [], "total": 0}))
+    payload["organ"] = _ORGAN_NAME
+    payload["lambda_gate_floor"] = _LAMBDA_GATE_FLOOR
+    return _gov(payload, status="REAL")
+
+
+def _threats() -> dict:
+    payload = dict(_BUNDLE.get("threats_full", {"total": 0, "corpus": []}))
+    payload["organ"] = _ORGAN_NAME
+    return _gov(payload, status="REAL")
+
+
+def _feed(limit: int = 50) -> dict:
+    with _AUDIT_LOCK:
+        v = list(_AUDIT)[: int(limit)]
+        n = len(_AUDIT)
+    payload = {
+        "verdicts": v,
+        "count": len(v),
+        "total_buffered": n,
+        "organ": _ORGAN_NAME,
+        "note": _BUNDLE.get("feed_note", "")
+                or "Real entries from the in-memory audit ring (maxlen=200). Resets on restart. Empty = IDLE.",
+        "doctrine": "v11",
+    }
+    return _gov(payload, status="REAL")
+
+
+def _verify_chain() -> dict:
+    import szl_khipu
+    dag = szl_khipu.get_dag(_KHIPU_ORGAN, ns="a11oy")
+    chain = dag.verify_chain()
+    tail = dag.tail(20)
+    return {
+        "ok": True,
+        "organ": _KHIPU_ORGAN,
+        "organ_name": _ORGAN_NAME,
+        "ns": "a11oy",
+        "receipt_type": _RECEIPT_TYPE,
+        "chain_verified": chain.get("ok"),
+        "chain_depth": dag.depth(),
+        "broken_at": chain.get("broken_at"),
+        "head_digest": dag.head(),
+        "genesis_prev": "0" * 64,
+        "tail": [
+            {"seq": r["seq"], "action": r["action"], "digest": r["digest"],
+             "prev": r["prev"], "payload_digest": r["payload_digest"]}
+            for r in tail
+        ],
+        "khipu_kind": "Conjecture 2",
+        "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Registration — dual-register under /api/{ns}/v1/immune/* AND /v1/immune/*.
+# Mirrors szl_kverify's add_api_route pattern. Registered BEFORE the SPA catch-
+# all so these JSON routes resolve LOCALLY and win ordering. NOTE: Request /
+# JSONResponse are imported at MODULE level (top of file) because this module
+# uses `from __future__ import annotations` — a function-local import would
+# leave the `request: Request` annotation unresolved and FastAPI would wrongly
+# treat `request` as a required query param (HTTP 422).
+# ---------------------------------------------------------------------------
+def register(app, ns: str = "a11oy") -> dict:
+    async def _h_healthz():  # noqa: ANN202
+        return JSONResponse(_healthz())
+
+    async def _h_status():  # noqa: ANN202
+        return JSONResponse(_status())
+
+    async def _h_gates():  # noqa: ANN202
+        return JSONResponse(_gates())
+
+    async def _h_threats():  # noqa: ANN202
+        return JSONResponse(_threats())
+
+    async def _h_feed(request: Request):  # noqa: ANN202
+        try:
+            limit = int(request.query_params.get("limit", "50"))
+        except Exception:  # noqa: BLE001
+            limit = 50
+        return JSONResponse(_feed(limit))
+
+    async def _h_verdict(request: Request):  # noqa: ANN202
+        try:
+            body = await request.json()
+        except Exception:  # noqa: BLE001
+            body = {}
+        if not isinstance(body, dict):
+            body = {"action": body}
+        verdict = _build_verdict(body)
+        # Honest header echoing the fail-closed decision; never a codename.
+        return JSONResponse(verdict, headers={"x-szl-immune-decision": verdict["decision"]})
+
+    async def _h_verify():  # noqa: ANN202
+        return JSONResponse(_verify_chain())
+
+    prefixes = [f"/api/{ns}/v1/immune", "/v1/immune"]
+    routes: list[str] = []
+    for p in prefixes:
+        app.add_api_route(f"{p}/healthz", _h_healthz, methods=["GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/status", _h_status, methods=["GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/gates", _h_gates, methods=["GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/threats", _h_threats, methods=["GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/feed", _h_feed, methods=["GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/verdict", _h_verdict, methods=["POST", "GET"], include_in_schema=True)
+        app.add_api_route(f"{p}/verify", _h_verify, methods=["GET"], include_in_schema=True)
+        routes.extend([f"{p}/healthz", f"{p}/status", f"{p}/gates", f"{p}/threats",
+                       f"{p}/feed", f"{p}/verdict", f"{p}/verify"])
+
+    print(f"[{ns}] szl_immune routes registered "
+          f"(Immune (Hukulla) fail-closed egress gate, {len(routes)} routes)", flush=True)
+    return {"ok": True, "ns": ns, "organ": _ORGAN_NAME, "routes": routes}
+
+
+# ---------------------------------------------------------------------------
+# No-server self-test — proves the REAL inspection + chain honesty without HTTP.
+# ---------------------------------------------------------------------------
+def _selftest() -> dict:
+    out: dict = {}
+
+    # Threat signature -> deny.
+    v = _build_verdict({"action": {"cmd": "DROP TABLE users"}, "request_id": "t1"})
+    assert v["decision"] == "deny", v
+    assert any("DROP TABLE" in s for s in v["signals"]), v
+    assert v["khipu_receipt"]["digest"], v
+    out["threat_deny"] = True
+
+    # Clean action -> allow.
+    v = _build_verdict({"action": {"cmd": "echo hello"}, "request_id": "t2"})
+    assert v["decision"] == "allow", v
+    out["clean_allow"] = True
+
+    # Lambda-gate floor: a low axis trips the deny even on a clean payload.
+    v = _build_verdict({"action": {"cmd": "ok"}, "axes": [0.9, 0.3, 0.8], "request_id": "t3"})
+    assert v["decision"] == "deny", v
+    assert any("lambda-gate" in s for s in v["signals"]), v
+    out["lambda_floor_deny"] = True
+
+    # Size guard.
+    v = _build_verdict({"action": {"blob": "A" * 1_000_050}, "request_id": "t4"})
+    assert v["decision"] == "deny", v
+    assert any("size-guard" in s for s in v["signals"]), v
+    out["size_guard_deny"] = True
+
+    # Chain integrity.
+    import szl_khipu
+    dag = szl_khipu.get_dag(_KHIPU_ORGAN, ns="a11oy")
+    chain = dag.verify_chain()
+    assert chain["ok"], chain
+    out["chain_verified"] = True
+
+    # No codename leaks in any served string.
+    served = json.dumps([_healthz(), _status(), _gates(), _feed(5), _verify_chain()]).lower()
+    for bad in ("sentra", "amaru", "rosie", "jarvis"):
+        assert bad not in served, f"codename leak: {bad}"
+    out["no_codename_leak"] = True
+
+    return out
+
+
+if __name__ == "__main__":
+    print(json.dumps(_selftest(), indent=2))