I5: GRC alignment (coverage matrix, 13 Lambda->NIST mapping, OPA/Rego, OSCAL, DSSE schema) + shared platform-dynamics math. ALIGNS WITH, not certified.

Dockerfile

@@ -764,6 +764,19 @@ COPY scripts/check_tau_eval.py ./scripts/check_tau_eval.py
 COPY lean4agent/WorkflowInvariants.lean ./lean4agent/WorkflowInvariants.lean
 COPY lean4agent/README.md ./lean4agent/README.md
 
+# GRC ALIGNMENT surface (Lane I5) — in-product ISO 42001 / NIST AI RMF / 800-53 /
+# EU AI Act coverage matrix, 13 Λ→NIST mapping, OPA/Rego gates, OSCAL component-def,
+# DSSE Receipt Schema v2. Explicit per-file COPY (this Dockerfile never uses COPY . .).
+# serve.py imports a11oy_grc which imports a11oy_grc_data; the OSCAL JSON + Rego bundle
+# ship in the image for audit. szl_cuas_formulas.py (shared, byte-identical w/ killinchu)
+# is already COPY'd above for the active-flux router + platform-dynamics math.
+COPY a11oy_grc.py a11oy_grc_data.py ./
+COPY compliance/oscal/a11oy-component-definition.json ./compliance/oscal/a11oy-component-definition.json
+COPY compliance/rego/classification_boundary.rego ./compliance/rego/classification_boundary.rego
+COPY compliance/rego/human_override_required.rego ./compliance/rego/human_override_required.rego
+COPY compliance/rego/deployment_readiness.rego ./compliance/rego/deployment_readiness.rego
+COPY compliance/rego/manifest.json ./compliance/rego/manifest.json
+
 CMD ["python", "serve.py"]
 
 

a11oy_grc.py

@@ -0,0 +1,346 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. Jr. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+"""a11oy_grc.py — in-product GRC ALIGNMENT surface (Lane I5).
+
+Mounts a11oy's Governance / Compliance surface:
+  * GET /api/a11oy/v1/grc/matrix   — honest ISO 42001 / NIST AI RMF / 800-53 / EU AI Act
+                                     coverage matrix (COVERED / PARTIAL / ROADMAP / NA).
+  * GET /api/a11oy/v1/grc/mapping  — 13 Λ axes → NIST AI RMF MEASURE 2 (+ Credo AI labels),
+                                     the Rego policy gates, the version-locked bundle digest,
+                                     and the DSSE Receipt Schema v2 (field → control IDs).
+  * GET /api/a11oy/v1/grc/oscal    — OSCAL component-definition JSON (also published to the
+                                     repo at compliance/oscal/a11oy-component-definition.json).
+  * GET /api/a11oy/v1/grc/info     — capability descriptor.
+  * GET /grc (a.k.a. /compliance)  — self-contained, 0-CDN "Compliance / GRC" page.
+
+Routes are DUAL-REGISTERED at both /api/a11oy/v1/... AND /v1/... (the HF proxy strips the
+/api/a11oy prefix — same convention Dev E's active-flux router uses). A11oy-styled page;
+shared scripts vendored at /static/shared/. Nav link is injected by this module's OWN
+idempotent BaseHTTPMiddleware (mirroring serve.py's _OperatorWidgetInjector) — the console
+SPA source is NOT edited, and the injector NEVER clobbers other devs' nav items.
+
+HONEST (Doctrine v11): a11oy ALIGNS WITH / MAPS TO frameworks — NEVER "certified" or
+"compliant". No third-party certification obtained. Gaps shown honestly. Λ = Conjecture 1;
+locked-proven = 8 @ c7c0ba17; trust never 100%; 0 runtime CDN. Adds NOTHING to the locked-8.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+import a11oy_grc_data as _grc
+
+SOURCES = _grc.SOURCES
+
+
+def info(ns: str = "a11oy") -> Dict[str, Any]:
+    return {
+        "capability": "GRC Alignment — ISO 42001 / NIST AI RMF / 800-53 / EU AI Act",
+        "ns": ns,
+        "summary": ("In-product, HONEST governance coverage matrix; 13 Λ axes mapped to NIST AI "
+                    "RMF MEASURE 2; policy gates as OPA/Rego with a version-locked bundle digest; "
+                    "OSCAL component-definition published to the repo; DSSE Receipt Schema v2 cites "
+                    "control IDs. ALIGNS WITH / MAPS TO — never certified."),
+        "endpoints": {
+            "matrix": f"/api/{ns}/v1/grc/matrix",
+            "mapping": f"/api/{ns}/v1/grc/mapping",
+            "oscal": f"/api/{ns}/v1/grc/oscal",
+            "page": "/grc",
+        },
+        "oscal_artifact": "compliance/oscal/a11oy-component-definition.json",
+        "doctrine": {"locked_proven": 8, "kernel_commit": _grc.KERNEL_COMMIT,
+                     "lambda": "Conjecture 1", "khipu_bft": "Conjecture 2",
+                     "trust": "never 100%", "framing": "aligns with / maps to (NOT certified)"},
+        "sources": SOURCES, "honest": _grc.HONEST_DISCLAIMER,
+        "status": "ALIGNMENT (no third-party certification)",
+    }
+
+
+_COV_COLOR = {"COVERED": "#39d3c4", "PARTIAL": "#e8c074", "ROADMAP": "#6fb1ff", "NA": "#6f8190"}
+_COV_GLYPH = {"COVERED": "●", "PARTIAL": "◐", "ROADMAP": "○", "NA": "—"}
+
+
+def _matrix_rows_html() -> str:
+    rows = []
+    for r in _grc.COVERAGE_MATRIX:
+        col = _COV_COLOR.get(r["coverage"], "#9fb1bf")
+        g = _COV_GLYPH.get(r["coverage"], "·")
+        rows.append(
+            f'<tr><td class="ctl">{r["control"]}</td><td>{r["framework"]}</td>'
+            f'<td>{r["title"]}</td><td class="mech">{r["mechanism"]}</td>'
+            f'<td style="color:{col};white-space:nowrap">{g} {r["coverage"]}</td></tr>')
+    return "".join(rows)
+
+
+def _axes_rows_html() -> str:
+    rows = []
+    for a in _grc.LAMBDA_AXES:
+        col = _COV_COLOR.get(a["coverage"], "#9fb1bf")
+        rows.append(
+            f'<tr><td class="ctl">Λ{a["axis"]}</td><td>{a["lambda_axis"]}</td>'
+            f'<td>{a["nist_measure"]}</td><td>{a["credo_dimension"]}</td>'
+            f'<td class="mech">{a["mechanism"]}</td>'
+            f'<td style="color:{col}">{a["coverage"]}</td></tr>')
+    return "".join(rows)
+
+
+def _page_html(ns: str) -> str:
+    summ = _grc.coverage_summary()
+    digest = _grc.policy_bundle_digest()
+    summ_html = " · ".join(
+        f'<span style="color:{_COV_COLOR.get(k,"#9fb1bf")}">{_COV_GLYPH.get(k,"·")} {k}={v}</span>'
+        for k, v in sorted(summ.items()))
+    return r"""<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Compliance / GRC Alignment — a11oy</title>
+<style>
+ :root{--bg:#070b10;--panel:#0d141c;--line:#1d2a36;--teal:#39d3c4;--gold:#e8c074;--cream:#eef3f6;--para:#9fb1bf;}
+ *{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--cream);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,Arial}
+ a{color:var(--teal);text-decoration:none}
+ header{padding:14px 18px;border-bottom:1px solid var(--line);background:linear-gradient(180deg,#0a1119,#070b10)}
+ h1{font-size:18px;margin:0 0 2px}.sub{color:var(--para);font-size:12.5px;max-width:1040px}
+ .badge{display:inline-block;font-size:10.5px;padding:2px 7px;border-radius:6px;border:1px solid var(--line);margin-right:6px;color:var(--gold);background:#10171f;vertical-align:middle}
+ .wrap{max-width:1080px;margin:0 auto;padding:16px}
+ .panel{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:14px;margin-bottom:14px}
+ .panel h2{font-size:14px;margin:0 0 8px}.pp{color:var(--para);font-size:12px;margin:0 0 10px}
+ table{width:100%;border-collapse:collapse;font-size:12px}
+ th,td{text-align:left;padding:6px 8px;border-bottom:1px solid #131e27;vertical-align:top}
+ th{color:var(--gold);font-weight:600;position:sticky;top:0;background:#0d141c}
+ td.ctl{color:var(--teal);font-variant-numeric:tabular-nums;white-space:nowrap;font-family:ui-monospace,monospace}
+ td.mech{color:var(--para)}
+ .scroll{max-height:420px;overflow:auto;border:1px solid var(--line);border-radius:8px}
+ .disc{font-size:11.5px;color:var(--gold);background:#171206;border:1px solid #3a2e10;border-radius:8px;padding:10px;margin-bottom:14px;line-height:1.6}
+ .crosslinks a{margin-right:14px}
+ .out{white-space:pre-wrap;font:11px ui-monospace,monospace;color:#bfe;background:#06090d;border:1px solid var(--line);border-radius:7px;padding:8px;max-height:240px;overflow:auto}
+ .src{font-size:11px;color:var(--para);margin-top:10px;line-height:1.7}.src a{color:var(--teal)}
+ footer{padding:12px 18px;border-top:1px solid var(--line);color:var(--para);font-size:11px}
+ code{color:var(--teal);font-family:ui-monospace,monospace}
+</style></head><body>
+<header><h1>Compliance / GRC Alignment
+  <span class="badge">ALIGNS WITH · NOT CERTIFIED</span><span class="badge">Λ = Conjecture 1</span>
+  <span class="badge">0 runtime CDN</span></h1>
+ <div class="sub">a11oy's mechanisms cross-referenced to <b>ISO/IEC 42001:2023</b>, <b>NIST AI RMF 1.0</b>,
+  <b>NIST SP 800-53 Rev 5</b>, and the <b>EU AI Act</b>. The 13 Λ trust axes map to NIST AI RMF
+  MEASURE 2; policy gates are published as OPA/Rego; a machine-readable OSCAL component-definition
+  is committed to the repo. <a href="/">← a11oy console</a></div></header>
+<div class="wrap">
+ <div class="disc">__DISC__</div>
+
+ <div class="panel">
+  <h2>Coverage matrix — __SUMM__</h2>
+  <p class="pp">Honest per-control state. <code>COVERED</code> = a specific testable mechanism;
+   <code>PARTIAL</code> = mechanism exists but incomplete; <code>ROADMAP</code> = planned;
+   <code>N/A</code> = out of scope (with reason). EU AI Act self-classification:
+   <b>High-Risk</b> (defense-tech agentic orchestrator).</p>
+  <div class="scroll"><table>
+   <thead><tr><th>Control</th><th>Framework</th><th>Title</th><th>a11oy mechanism</th><th>Coverage</th></tr></thead>
+   <tbody>__MATRIX__</tbody></table></div>
+ </div>
+
+ <div class="panel">
+  <h2>13 Λ axes → NIST AI RMF MEASURE 2 (+ Credo AI / MIT taxonomy)</h2>
+  <p class="pp">Each proprietary Λ axis gets an industry-standard referent so external evaluators
+   recognise it without a custom glossary.</p>
+  <div class="scroll"><table>
+   <thead><tr><th>Λ axis</th><th>Trust dimension</th><th>NIST AI RMF</th><th>Credo AI / MIT</th><th>Mechanism</th><th>State</th></tr></thead>
+   <tbody>__AXES__</tbody></table></div>
+ </div>
+
+ <div class="panel">
+  <h2>Policy gates as OPA/Rego + DSSE Receipt Schema v2</h2>
+  <p class="pp">Gates are published policy-as-code; the bundle is version-locked by a SHA-256
+   digest that every DSSE receipt cites, so a receipt proves WHICH policy version made the
+   decision. Each receipt field maps to specific control IDs (800-53 AU/CM/RA family,
+   EU AI Act Art. 12/14, ISO 42001 A.x). Receipts are ECDSA-P256/DSSE signed; re-verify at
+   <a href="/cosign.pub">/cosign.pub</a>.</p>
+  <div class="pp">policy bundle digest: <code>__DIGEST__</code></div>
+  <details><summary style="cursor:pointer;color:var(--teal)">raw /grc/mapping (Λ→NIST, Rego, DSSE schema)</summary>
+   <div class="out" id="raw-map">loading…</div></details>
+ </div>
+
+ <div class="panel">
+  <h2>OSCAL component-definition</h2>
+  <p class="pp">Machine-readable OSCAL (control source = usnistgov/oscal-content SP 800-53 Rev 5
+   catalog), committed to the repo at
+   <code>compliance/oscal/a11oy-component-definition.json</code> and served live below.
+   ALIGNMENT only — never a certification artifact.</p>
+  <div class="crosslinks pp">
+   <a href="/api/__NS__/v1/grc/matrix" target="_blank">matrix JSON</a>
+   <a href="/api/__NS__/v1/grc/mapping" target="_blank">mapping JSON</a>
+   <a href="/api/__NS__/v1/grc/oscal" target="_blank">OSCAL JSON</a></div>
+  <details><summary style="cursor:pointer;color:var(--teal)">raw /grc/oscal (component-definition)</summary>
+   <div class="out" id="raw-oscal">loading…</div></details>
+ </div>
+
+ <div class="src">Adopted &amp; cited — sources:
+  <a href="https://www.iso.org/standard/81230.html" target="_blank" rel="noopener">ISO/IEC 42001:2023</a> ·
+  <a href="https://airc.nist.gov/airmf-resources/airmf/5-sec-core/" target="_blank" rel="noopener">NIST AI RMF 1.0</a> ·
+  <a href="https://github.com/usnistgov/OSCAL" target="_blank" rel="noopener">OSCAL (usnistgov)</a> ·
+  <a href="https://github.com/usnistgov/oscal-content" target="_blank" rel="noopener">oscal-content</a> ·
+  <a href="https://www.openpolicyagent.org/docs/latest/policy-language/" target="_blank" rel="noopener">OPA / Rego</a> ·
+  <a href="https://airisk.mit.edu/" target="_blank" rel="noopener">MIT AI Risk Repository (Credo AI taxonomy)</a> ·
+  <a href="https://artificialintelligenceact.eu/high-level-summary/" target="_blank" rel="noopener">EU AI Act</a>.</div>
+</div>
+<footer>Doctrine v11 · locked = 8 @ c7c0ba17 · Λ = Conjecture 1 · Khipu BFT = Conjecture 2 ·
+ <b>GRC ALIGNMENT — aligns with / maps to, NOT certified</b> · 0 runtime CDN · trust &lt; 100%.</footer>
+<script src="/static/shared/szl_label_engine.js" defer></script>
+<script src="/static/shared/szl_receipt_cosign.js" defer></script>
+<script src="/static/shared/szl_codename_sanitizer.js" defer></script>
+<script>
+"use strict";
+const API="/api/__NS__/v1/grc";
+async function load(){
+  try{const m=await (await fetch(API+"/mapping")).json();
+    document.getElementById("raw-map").textContent=JSON.stringify(m,null,1);
+  }catch(e){document.getElementById("raw-map").textContent="endpoint unreachable: "+e;}
+  try{const o=await (await fetch(API+"/oscal")).json();
+    document.getElementById("raw-oscal").textContent=JSON.stringify(o,null,1);
+  }catch(e){document.getElementById("raw-oscal").textContent="endpoint unreachable: "+e;}
+}
+load();
+</script></body></html>""" \
+        .replace("__DISC__", _grc.HONEST_DISCLAIMER) \
+        .replace("__SUMM__", summ_html) \
+        .replace("__MATRIX__", _matrix_rows_html()) \
+        .replace("__AXES__", _axes_rows_html()) \
+        .replace("__DIGEST__", digest) \
+        .replace("__NS__", ns)
+
+
+# ── idempotent nav-link injection middleware (mirrors serve.py _OperatorWidgetInjector) ──
+_NAV_MARKER = b'data-view-grc="grc"'
+# inject a nav-item linking to the standalone /grc page; placed right AFTER the existing
+# "Readiness & Compliance" (govern) nav-item if present, else before the first nav-group,
+# else just before </body>. NEVER edits other devs' nav items.
+_NAV_LINK = (b'<div class="nav-item" data-view-grc="grc" '
+             b'onclick="location.href=\'/grc\'" style="cursor:pointer">'
+             b'<span class="ico">\xe2\x9a\x96</span>Compliance / GRC</div>')
+_GOVERN_ANCHOR = b'Readiness &amp; Compliance</div>'
+_GROUP_ANCHOR = b'<div class="nav-group">'
+
+
+def _make_injector():
+    from starlette.middleware.base import BaseHTTPMiddleware
+    from starlette.responses import Response
+
+    class _GrcNavInjector(BaseHTTPMiddleware):
+        async def dispatch(self, request, call_next):
+            resp = await call_next(request)
+            try:
+                ct = (resp.headers.get("content-type") or "").lower()
+                if "text/html" not in ct:
+                    return resp
+                p = request.url.path
+                if (p.startswith("/api/") or p.startswith("/v1/") or p.startswith("/vendor/")
+                        or p.startswith("/assets/") or p.startswith("/static/") or p == "/grc"):
+                    return resp
+                body = b""
+                async for chunk in resp.body_iterator:
+                    body += chunk if isinstance(chunk, (bytes, bytearray)) else str(chunk).encode()
+                if _NAV_MARKER in body:           # idempotent
+                    new_body = body
+                elif _GOVERN_ANCHOR in body:      # after Readiness & Compliance
+                    new_body = body.replace(_GOVERN_ANCHOR, _GOVERN_ANCHOR + _NAV_LINK, 1)
+                elif _GROUP_ANCHOR in body:       # before the first nav-group
+                    new_body = body.replace(_GROUP_ANCHOR, _NAV_LINK + _GROUP_ANCHOR, 1)
+                elif b"</body>" in body:
+                    new_body = body.replace(b"</body>", _NAV_LINK + b"</body>", 1)
+                else:
+                    return resp
+                headers = dict(resp.headers)
+                headers.pop("content-length", None)
+                return Response(content=new_body, status_code=resp.status_code,
+                                headers=headers, media_type="text/html")
+            except Exception:
+                return resp
+
+    return _GrcNavInjector
+
+
+def register(app, ns: str = "a11oy") -> Dict[str, Any]:
+    """Attach the GRC alignment surface. ADDITIVE; BEFORE the SPA/proxy catch-all. Pure
+    stdlib + a11oy_grc_data. 0 CDN. Routes dual-registered at /api/<ns>/v1/grc and /v1/grc."""
+    from starlette.responses import HTMLResponse, JSONResponse
+    registered: List[str] = []
+
+    def _matrix():
+        return JSONResponse(_grc.build_matrix())
+
+    def _mapping():
+        return JSONResponse(_grc.build_mapping())
+
+    def _oscal():
+        return JSONResponse(_grc.build_oscal())
+
+    for prefix in (f"/api/{ns}/v1/grc", "/v1/grc"):
+        app.add_api_route(f"{prefix}/matrix", _matrix, methods=["GET"])
+        app.add_api_route(f"{prefix}/mapping", _mapping, methods=["GET"])
+        app.add_api_route(f"{prefix}/oscal", _oscal, methods=["GET"])
+        app.add_api_route(f"{prefix}/info", lambda: JSONResponse(info(ns)), methods=["GET"])
+        registered.append(f"GET {prefix}/matrix")
+
+    _html = _page_html(ns)
+
+    async def _page():
+        return HTMLResponse(_html)
+    app.add_api_route("/grc", _page, methods=["GET"])
+    app.add_api_route("/compliance", _page, methods=["GET"])
+    registered.append("GET /grc")
+    registered.append("GET /compliance")
+
+    try:
+        app.add_middleware(_make_injector())
+        registered.append("MIDDLEWARE grc nav-link injector")
+    except Exception:
+        pass
+
+    return {"registered": registered, "count": len(registered),
+            "capability": "GRC Alignment", "data_label": "ALIGNMENT"}
+
+
+def _selftest() -> None:
+    from fastapi import FastAPI
+    from fastapi.responses import HTMLResponse
+    from fastapi.testclient import TestClient
+    app = FastAPI()
+    st = register(app, ns="a11oy")
+    assert st["count"] >= 5
+
+    @app.get("/console", response_class=HTMLResponse)
+    def _c():
+        return ('<html><body><div class="nav-group">Operate</div>'
+                '<div class="nav-item" data-view="govern" onclick="go(\'govern\')">'
+                '<span class="ico">x</span>Readiness &amp; Compliance</div>'
+                '</body></html>')
+
+    c = TestClient(app)
+    for ep in ["/api/a11oy/v1/grc/matrix", "/api/a11oy/v1/grc/mapping",
+               "/api/a11oy/v1/grc/oscal", "/api/a11oy/v1/grc/info",
+               "/v1/grc/matrix", "/grc", "/compliance"]:
+        r = c.get(ep)
+        assert r.status_code == 200, (ep, r.status_code)
+    # honesty checks on the page
+    page = c.get("/grc").text
+    assert "ALIGNS WITH" in page and "NOT CERTIFIED" in page
+    assert "certified against" not in page.lower()
+    # nav injection idempotent + placed after govern anchor
+    h1 = c.get("/console").text
+    h2 = c.get("/console").text
+    assert h1.count('data-view-grc="grc"') == 1, "nav must inject exactly once"
+    assert h2.count('data-view-grc="grc"') == 1, "nav must be idempotent"
+    assert "Readiness &amp; Compliance</div><div class=\"nav-item\" data-view-grc" in h1, "must place after govern"
+    # OSCAL endpoint must be valid OSCAL component-definition
+    o = c.get("/api/a11oy/v1/grc/oscal").json()
+    assert "component-definition" in o and o["component-definition"]["components"]
+    # matrix honesty: must contain at least one PARTIAL and one ROADMAP (shows gaps)
+    mx = c.get("/api/a11oy/v1/grc/matrix").json()
+    assert mx["summary"].get("PARTIAL", 0) > 0 and mx["summary"].get("ROADMAP", 0) > 0
+    # 0 CDN: page must only reference /static/shared and same-origin
+    import re
+    ext = re.findall(r'src="(https?://[^"]+)"', page)
+    assert not ext, "no external script src allowed: %s" % ext
+    print("a11oy_grc: ALL OK (%d routes; nav idempotent; honest; OSCAL valid; 0 CDN)" % st["count"])
+
+
+if __name__ == "__main__":
+    _selftest()

a11oy_grc_data.py

@@ -0,0 +1,382 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. Jr. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+"""a11oy_grc_data.py — GRC ALIGNMENT content (Lane I5).
+
+The HONEST, machine-readable substrate for a11oy's in-product Governance/Compliance
+surface. This module holds NO web framework code — it is the pure data + builders that
+a11oy_grc.py (routes/page/nav) and the published OSCAL artifact both consume, so the
+matrix, the Λ→NIST mapping, the Rego bundle metadata, and the OSCAL component-definition
+are all derived from a SINGLE source of truth and can never drift.
+
+DOCTRINE / FRAMING (critical — never overclaim):
+  * a11oy "aligns with" / "maps to" / "provides evidence for" — NEVER "certified against"
+    or "compliant with". No third-party certification has been obtained for ANY framework
+    as of Doctrine v11. Coverage = a11oy's INTERNAL analysis of its mechanisms vs published
+    framework control text. Gaps are shown HONESTLY (more credible than overclaiming).
+  * Coverage states are HONEST: COVERED (specific testable mechanism), PARTIAL (mechanism
+    exists but incomplete), ROADMAP (planned, target version), NA (out of scope w/ reason).
+  * Λ = Conjecture 1 (NOT a closed theorem); Khipu BFT = Conjecture 2; locked-proven = 8
+    @ c7c0ba17; trust never 100%. This surface adds NOTHING to the locked-8.
+
+SOURCES (cited; adopted, NOT reclaimed as SZL theorems):
+  - ISO/IEC 42001:2023 (AI management system) — 38 controls / 9 objectives A.2–A.10.
+  - NIST AI RMF 1.0 — 72 subcategories across GOVERN(19)/MAP(18)/MEASURE(19)/MANAGE(17).
+  - NIST SP 800-53 Rev 5 + usnistgov/OSCAL + usnistgov/oscal-content (catalog source).
+  - Open Policy Agent / Rego (policy-as-code).
+  - Credo AI 10-dimension risk taxonomy (derives from the MIT AI Risk Repository).
+  - EU AI Act (a11oy self-classifies as High-Risk, defense-tech) Art. 9 / Art. 12 / Art. 14.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Dict, List
+
+DOCTRINE_VERSION = "v11"
+KERNEL_COMMIT = "c7c0ba17"
+
+SOURCES: Dict[str, str] = {
+    "ISO/IEC 42001:2023 (AI management system)": "https://www.iso.org/standard/81230.html",
+    "ISO 42001 Annex A control list (reference)": "https://mindsetcyber.com.au/iso-42001-controls-list/",
+    "NIST AI RMF 1.0 Core": "https://airc.nist.gov/airmf-resources/airmf/5-sec-core/",
+    "NIST AI RMF Playbook (subcategory detail)": "https://airc.nist.gov/docs/AI_RMF_Playbook.pdf",
+    "NIST SP 800-53 Rev 5 catalog (OSCAL JSON)":
+        "https://raw.githubusercontent.com/usnistgov/oscal-content/main/nist.gov/SP800-53/rev5/json/NIST_SP-800-53_rev5_catalog.json",
+    "OSCAL (usnistgov/OSCAL)": "https://github.com/usnistgov/OSCAL",
+    "OSCAL content (usnistgov/oscal-content)": "https://github.com/usnistgov/oscal-content",
+    "Open Policy Agent / Rego": "https://www.openpolicyagent.org/docs/latest/policy-language/",
+    "Credo AI risk taxonomy / MIT AI Risk Repository": "https://airisk.mit.edu/",
+    "EU AI Act high-level summary": "https://artificialintelligenceact.eu/high-level-summary/",
+}
+
+HONEST_DISCLAIMER = (
+    "Coverage assessments reflect a11oy's INTERNAL analysis of its mechanisms against "
+    "published framework control text. a11oy ALIGNS WITH / MAPS TO these frameworks; it "
+    "does NOT claim certification. No third-party certification has been obtained for any "
+    "framework as of Doctrine " + DOCTRINE_VERSION + ". Gaps are shown honestly. "
+    "Λ = Conjecture 1; locked-proven = 8 @ " + KERNEL_COMMIT + "; trust never 100%."
+)
+
+# ───────────────────────────────────────────────────────────────────────────
+# 13 Λ axes  →  NIST AI RMF MEASURE 2 subcategories (+ Credo AI / MIT taxonomy label)
+# a11oy's Λ trust score has 13 axes. The first 10 map 1:1 to NIST AI RMF MEASURE 2.1–2.10;
+# the remaining 3 are governance/autonomy axes that map to GOVERN/MAP subcategories. Every
+# row carries the industry-standard Credo AI dimension name so external evaluators recognise
+# the axis without a custom glossary. (UPGRADE #1 + #5 of GRC_ONETRUST_RESEARCH.)
+# ───────────────────────────────────────────────────────────────────────────
+LAMBDA_AXES: List[Dict[str, Any]] = [
+    {"axis": 1, "lambda_axis": "scoring methodology / documentation",
+     "nist_measure": "MEASURE 2.1", "nist_text": "Test methods and metrics for AI risk",
+     "credo_dimension": "Information Integrity (methodology)",
+     "mechanism": "Λ 13-axis scoring rubric documented + exposed in every DSSE receipt", "coverage": "COVERED"},
+    {"axis": 2, "lambda_axis": "factual accuracy / hallucination rate",
+     "nist_measure": "MEASURE 2.2", "nist_text": "Evaluating AI systems for accuracy, interpretability",
+     "credo_dimension": "Information Integrity",
+     "mechanism": "Lean-proven formula verification; factuality axis scored per inference", "coverage": "COVERED"},
+    {"axis": 3, "lambda_axis": "robustness / adversarial resistance",
+     "nist_measure": "MEASURE 2.3", "nist_text": "Evaluating for reliability / robustness",
+     "credo_dimension": "Security (adversarial resistance)",
+     "mechanism": "Red-team / prompt-injection resistance score feeds the robustness axis", "coverage": "PARTIAL"},
+    {"axis": 4, "lambda_axis": "operational resilience",
+     "nist_measure": "MEASURE 2.4", "nist_text": "Evaluating for resilience",
+     "credo_dimension": "Security (resilience)",
+     "mechanism": "Resilience axis from szl_resilience degradation/fallback telemetry", "coverage": "PARTIAL"},
+    {"axis": 5, "lambda_axis": "safety / harm avoidance",
+     "nist_measure": "MEASURE 2.5", "nist_text": "Evaluating for safety",
+     "credo_dimension": "Harmful Content Generation",
+     "mechanism": "Output content-safety classifier feeds the safety axis; gate halts on DENY", "coverage": "COVERED"},
+    {"axis": 6, "lambda_axis": "fairness / demographic parity",
+     "nist_measure": "MEASURE 2.6", "nist_text": "Evaluating for fairness / bias",
+     "credo_dimension": "Fairness and Bias",
+     "mechanism": "Statistical bias detection on outputs feeds the fairness axis", "coverage": "PARTIAL"},
+    {"axis": 7, "lambda_axis": "privacy / data minimization",
+     "nist_measure": "MEASURE 2.7", "nist_text": "Evaluating for privacy",
+     "credo_dimension": "Privacy",
+     "mechanism": "PII detection on inputs/outputs feeds the privacy axis", "coverage": "PARTIAL"},
+    {"axis": 8, "lambda_axis": "transparency / explainability",
+     "nist_measure": "MEASURE 2.8", "nist_text": "Evaluating for transparency / explainability",
+     "credo_dimension": "Information Integrity (transparency)",
+     "mechanism": "Lean-proven formula output exposed in the DSSE receipt for every decision", "coverage": "COVERED"},
+    {"axis": 9, "lambda_axis": "security posture score",
+     "nist_measure": "MEASURE 2.9", "nist_text": "Evaluating for security",
+     "credo_dimension": "Security",
+     "mechanism": "SLSA build posture + signed deployment digest + sentinel rules score", "coverage": "PARTIAL"},
+    {"axis": 10, "lambda_axis": "societal impact / mission alignment",
+     "nist_measure": "MEASURE 2.10", "nist_text": "Evaluating impacts / risks across the lifecycle",
+     "credo_dimension": "Societal Harm",
+     "mechanism": "Authorization-boundary + human-override gate firing rate feeds the impact axis", "coverage": "PARTIAL"},
+    {"axis": 11, "lambda_axis": "autonomy scope / action class",
+     "nist_measure": "MAP 2.1", "nist_text": "AI system categorization — type, capabilities, scope",
+     "credo_dimension": "AI Agency and Autonomy",
+     "mechanism": "Action-class gate thresholds bound autonomous actions; irreversible → human override", "coverage": "COVERED"},
+    {"axis": 12, "lambda_axis": "third-party / vendor risk",
+     "nist_measure": "GOVERN 6.1", "nist_text": "Policies for third-party / supply-chain AI risk",
+     "credo_dimension": "Third-Party and Vendor Risk",
+     "mechanism": "Third-party model attestation + vendor DSSE receipt verification", "coverage": "PARTIAL"},
+    {"axis": 13, "lambda_axis": "malicious-use / intent classification",
+     "nist_measure": "MEASURE 2.5", "nist_text": "Evaluating for safety (misuse intent)",
+     "credo_dimension": "Malicious Use",
+     "mechanism": "Use-case intent classifier + policy gate; DENY on prohibited use class", "coverage": "PARTIAL"},
+]
+
+# ───────────────────────────────────────────────────────────────────────────
+# Honest in-product COVERAGE MATRIX — ISO 42001 / NIST AI RMF / NIST 800-53 / EU AI Act.
+# Each row: control id, framework, the concrete a11oy mechanism, and an HONEST state.
+# (UPGRADE #3 of GRC_ONETRUST_RESEARCH.) States: COVERED / PARTIAL / ROADMAP / NA.
+# ───────────────────────────────────────────────────────────────────────────
+COVERAGE_MATRIX: List[Dict[str, str]] = [
+    # ISO 42001
+    {"control": "A.2.2", "framework": "ISO 42001", "title": "AI policy",
+     "mechanism": "Doctrine v11 is the published AI policy; versioned + change-controlled", "coverage": "COVERED"},
+    {"control": "A.3.2", "framework": "ISO 42001", "title": "AI roles & responsibilities",
+     "mechanism": "Operator role + clearance captured in every DSSE receipt (AC-2/AC-3)", "coverage": "COVERED"},
+    {"control": "A.3.3", "framework": "ISO 42001", "title": "AI risk reporting",
+     "mechanism": "Λ score reported per-inference; no formal periodic risk REPORT output yet", "coverage": "PARTIAL"},
+    {"control": "A.4.6", "framework": "ISO 42001", "title": "Human oversight & monitoring",
+     "mechanism": "human_override_required Rego gate fires before irreversible actions / low Λ", "coverage": "COVERED"},
+    {"control": "A.5.4", "framework": "ISO 42001", "title": "AI system risk management",
+     "mechanism": "13-axis Λ score computed per inference; sealed into the DSSE receipt", "coverage": "COVERED"},
+    {"control": "A.6.4", "framework": "ISO 42001", "title": "Data provenance",
+     "mechanism": "Input hash + model version + lineage recorded in the receipt", "coverage": "COVERED"},
+    {"control": "A.6.6", "framework": "ISO 42001", "title": "AI system verification",
+     "mechanism": "Output hash + Lean-verified formula path; locked-proven = 8 @ c7c0ba17", "coverage": "PARTIAL"},
+    {"control": "A.9.3", "framework": "ISO 42001", "title": "Human oversight (use)",
+     "mechanism": "Human-override gate; irreversible actions require human confirmation", "coverage": "COVERED"},
+    {"control": "A.9.4", "framework": "ISO 42001", "title": "Incident management",
+     "mechanism": "Incident receipt + tamper-evident re-verification at /cosign.pub", "coverage": "PARTIAL"},
+    {"control": "A.10.4", "framework": "ISO 42001", "title": "Supplier monitoring",
+     "mechanism": "Third-party model attestation; vendor DSSE receipt verification", "coverage": "PARTIAL"},
+    # NIST AI RMF
+    {"control": "GOVERN 1.1", "framework": "NIST AI RMF", "title": "AI policies & processes",
+     "mechanism": "Doctrine v11 + policy-gate configuration inventory", "coverage": "COVERED"},
+    {"control": "MAP 2.3", "framework": "NIST AI RMF", "title": "AI capability characterization",
+     "mechanism": "Λ scoring methodology + model registry classification", "coverage": "COVERED"},
+    {"control": "MEASURE 2.8", "framework": "NIST AI RMF", "title": "Transparency / explainability",
+     "mechanism": "Lean-proven formula output exposed in the receipt", "coverage": "COVERED"},
+    {"control": "MEASURE 3.1", "framework": "NIST AI RMF", "title": "Risk tracking over time",
+     "mechanism": "Continuous Λ score with a timestamp chain of receipts", "coverage": "PARTIAL"},
+    {"control": "GOVERN 3.2", "framework": "NIST AI RMF", "title": "Workforce DEI",
+     "mechanism": "Out of scope for an orchestration layer (organizational control)", "coverage": "NA"},
+    {"control": "MANAGE 4.1", "framework": "NIST AI RMF", "title": "Post-incident after-action",
+     "mechanism": "Incident receipt replay + independent re-verification", "coverage": "PARTIAL"},
+    {"control": "MEASURE 4.2", "framework": "NIST AI RMF", "title": "Measurement-effectiveness feedback",
+     "mechanism": "Λ-score calibration feedback loop", "coverage": "ROADMAP"},
+    # NIST 800-53 Rev 5
+    {"control": "AU-2", "framework": "NIST 800-53r5", "title": "Event logging",
+     "mechanism": "DSSE-signed audit event per inference (verdict + rule ID)", "coverage": "COVERED"},
+    {"control": "AU-3", "framework": "NIST 800-53r5", "title": "Content of audit records",
+     "mechanism": "Timestamp + input/output hash in every receipt", "coverage": "COVERED"},
+    {"control": "AU-9", "framework": "NIST 800-53r5", "title": "Protection of audit information",
+     "mechanism": "Records sealed in DSSE envelopes signed by ECDSA-P256; tamper-detectable", "coverage": "COVERED"},
+    {"control": "CM-8", "framework": "NIST 800-53r5", "title": "System component inventory",
+     "mechanism": "Model ID + version + digest recorded per inference", "coverage": "COVERED"},
+    {"control": "RA-3", "framework": "NIST 800-53r5", "title": "Risk assessment",
+     "mechanism": "13-axis Λ trust score is the per-inference risk assessment", "coverage": "COVERED"},
+    {"control": "SI-10", "framework": "NIST 800-53r5", "title": "Information input validation",
+     "mechanism": "Input hash + classification-boundary gate", "coverage": "PARTIAL"},
+    # EU AI Act
+    {"control": "Article 12", "framework": "EU AI Act", "title": "Record-keeping / logging",
+     "mechanism": "Immutable DSSE receipt per inference satisfies automatic logging", "coverage": "COVERED"},
+    {"control": "Article 14", "framework": "EU AI Act", "title": "Human oversight",
+     "mechanism": "Human-in-the-loop override gate; human-on-loop for SIMULATED effectors", "coverage": "COVERED"},
+    {"control": "Article 9", "framework": "EU AI Act", "title": "Risk management system (High-Risk)",
+     "mechanism": "Λ-gated policy enforcement; no formal QMS document yet", "coverage": "ROADMAP"},
+]
+
+# ───────────────────────────────────────────────────────────────────────────
+# Policy gates expressed as OPA / Rego (UPGRADE #2). Each gate carries the controls
+# it satisfies; the bundle is version-locked by a SHA-256 digest that every DSSE receipt
+# cites — so a receipt proves WHICH policy version made the decision.
+# ──────────────────────────────��────────────────────────────────────────────
+REGO_GATES: List[Dict[str, Any]] = [
+    {
+        "name": "classification_boundary",
+        "package": "a11oy.gates.classification_boundary",
+        "controls": ["ISO42001/A.9.6", "NIST80053/AC-3", "EUAIAct/Art.14"],
+        "rego": (
+            "package a11oy.gates.classification_boundary\n\n"
+            "# DENY when output classification exceeds the operator's clearance level.\n"
+            "default allow := false\n\n"
+            "deny[msg] {\n"
+            "  input.output_classification > input.user_clearance_level\n"
+            "  msg := sprintf(\"output classification %v exceeds user clearance %v\",\n"
+            "                 [input.output_classification, input.user_clearance_level])\n"
+            "}\n\n"
+            "allow {\n  count(deny) == 0\n}\n"
+        ),
+    },
+    {
+        "name": "human_override_required",
+        "package": "a11oy.gates.human_override_required",
+        "controls": ["ISO42001/A.9.3", "ISO42001/A.4.6", "NIST80053/AU-2", "EUAIAct/Art.14"],
+        "rego": (
+            "package a11oy.gates.human_override_required\n\n"
+            "# Require a human override for irreversible actions or when Λ < threshold.\n"
+            "default require_human := false\n\n"
+            "require_human {\n  input.action_class == \"irreversible\"\n}\n\n"
+            "require_human {\n  input.lambda_score < input.lambda_halt_threshold\n}\n"
+        ),
+    },
+    {
+        "name": "deployment_readiness",
+        "package": "a11oy.gates.deployment_readiness",
+        "controls": ["ISO27001/8.25", "NIST80053/CM-3", "ISO42001/A.6.7"],
+        "rego": (
+            "package a11oy.gates.deployment_readiness\n\n"
+            "# Block model promotion unless the signed package digest + Λ floor are met.\n"
+            "default promote := false\n\n"
+            "promote {\n"
+            "  input.package_signed == true\n"
+            "  input.slsa_level >= 2\n"
+            "  input.lambda_score >= input.lambda_promote_floor\n"
+            "}\n"
+        ),
+    },
+]
+
+
+def policy_bundle_digest() -> str:
+    """Deterministic SHA-256 over the canonical Rego bundle — the version-lock that every
+    DSSE receipt cites (UPGRADE #2/#4). Stable across calls for a given bundle content."""
+    canon = json.dumps([{ "name": g["name"], "package": g["package"], "rego": g["rego"]}
+                        for g in REGO_GATES], sort_keys=True).encode()
+    return "sha256:" + hashlib.sha256(canon).hexdigest()
+
+
+# ───────────────────────────────────────────────────────────────────────────
+# DSSE Receipt Schema v2 — each field cites the control(s) it provides evidence for
+# (UPGRADE #4). This is a SCHEMA (field→control map), not a fabricated receipt.
+# ───────────────────────────────────────────────────────────────────────────
+DSSE_RECEIPT_SCHEMA_V2: List[Dict[str, Any]] = [
+    {"field": "inference_timestamp_utc", "controls": ["NIST80053/AU-3", "EUAIAct/Art.12", "ISO42001/A.6.5"]},
+    {"field": "model_id_version_digest", "controls": ["NIST80053/CM-8", "NIST80053/CM-2", "EUAIAct/Art.12", "ISO42001/A.6.6"]},
+    {"field": "policy_bundle_digest", "controls": ["NIST80053/CM-3", "EUAIAct/Art.9", "ISO42001/A.9.2"]},
+    {"field": "input_hash_sha256", "controls": ["NIST80053/AU-3", "NIST80053/SI-10", "EUAIAct/Art.12", "ISO42001/A.7.2"]},
+    {"field": "output_hash_sha256", "controls": ["NIST80053/AU-3", "NIST80053/SI-7", "EUAIAct/Art.12", "ISO42001/A.6.6"]},
+    {"field": "policy_gate_verdict_and_rule_id", "controls": ["NIST80053/AU-2", "EUAIAct/Art.9", "EUAIAct/Art.14", "ISO42001/A.9.3"]},
+    {"field": "lambda_score_13axis", "controls": ["NIST80053/RA-3", "EUAIAct/Art.9", "ISO42001/A.5.4"]},
+    {"field": "operator_role_clearance", "controls": ["NIST80053/AC-2", "NIST80053/AC-3", "EUAIAct/Art.14", "ISO42001/A.3.2"]},
+    {"field": "ecdsa_p256_signature", "controls": ["NIST80053/AU-9", "ISO42001/A.4.2"]},
+    {"field": "reverification_endpoint", "controls": ["NIST80053/AU-6", "EUAIAct/Art.12", "ISO42001/A.8.2"]},
+]
+
+
+def coverage_summary() -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for r in COVERAGE_MATRIX:
+        out[r["coverage"]] = out.get(r["coverage"], 0) + 1
+    return out
+
+
+def build_matrix() -> Dict[str, Any]:
+    return {
+        "doctrine": DOCTRINE_VERSION,
+        "kernel_commit": KERNEL_COMMIT,
+        "matrix": COVERAGE_MATRIX,
+        "summary": coverage_summary(),
+        "frameworks": sorted({r["framework"] for r in COVERAGE_MATRIX}),
+        "eu_ai_act_self_classification": "High-Risk (defense-tech agentic orchestrator)",
+        "honest": HONEST_DISCLAIMER,
+        "framing": "aligns with / maps to — NOT certified / compliant",
+        "status": "ALIGNMENT (no third-party certification)",
+        "sources": SOURCES,
+    }
+
+
+def build_mapping() -> Dict[str, Any]:
+    return {
+        "doctrine": DOCTRINE_VERSION,
+        "lambda_axes": LAMBDA_AXES,
+        "axis_count": len(LAMBDA_AXES),
+        "primary_target": "NIST AI RMF MEASURE 2 (10 subcategories) + GOVERN/MAP for governance axes",
+        "taxonomy_alignment": "Credo AI 10-dimension (derives from MIT AI Risk Repository)",
+        "dsse_receipt_schema_v2": DSSE_RECEIPT_SCHEMA_V2,
+        "policy_bundle_digest": policy_bundle_digest(),
+        "rego_gates": [{"name": g["name"], "package": g["package"], "controls": g["controls"], "rego": g["rego"]}
+                       for g in REGO_GATES],
+        "honest": HONEST_DISCLAIMER,
+        "status": "ALIGNMENT",
+        "sources": SOURCES,
+    }
+
+
+def build_oscal() -> Dict[str, Any]:
+    """OSCAL Component Definition (UPGRADE #7) derived from the SAME coverage matrix +
+    Rego gates, so the published artifact and the live matrix can never diverge. Control
+    source = usnistgov/oscal-content SP 800-53 Rev 5 catalog. Honest: alignment, not cert."""
+    import datetime
+    src = SOURCES["NIST SP 800-53 Rev 5 catalog (OSCAL JSON)"]
+    # implemented-requirements from the 800-53 rows of the coverage matrix
+    impl: List[Dict[str, Any]] = []
+    for r in COVERAGE_MATRIX:
+        if r["framework"] != "NIST 800-53r5":
+            continue
+        impl.append({
+            "uuid": "ir-" + hashlib.sha256(r["control"].encode()).hexdigest()[:8],
+            "control-id": r["control"].lower().replace(" ", "-"),
+            "description": f"[{r['coverage']}] {r['mechanism']} (a11oy {r['title']}).",
+            "props": [{"name": "coverage", "ns": "https://szlholdings.ai/ns/oscal", "value": r["coverage"]}],
+        })
+    rego_statements = [{
+        "uuid": "ir-rego-" + hashlib.sha256(g["name"].encode()).hexdigest()[:8],
+        "control-id": "ac-3",
+        "description": f"Rego gate {g['package']} (controls: {', '.join(g['controls'])}). "
+                       f"Bundle digest {policy_bundle_digest()} is cited in every DSSE receipt.",
+    } for g in REGO_GATES]
+    return {
+        "component-definition": {
+            "uuid": "a11oy-comp-def-" + DOCTRINE_VERSION,
+            "metadata": {
+                "title": "a11oy Governed AI Orchestrator — OSCAL Component Definition",
+                "last-modified": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                "version": DOCTRINE_VERSION,
+                "oscal-version": "1.1.2",
+                "remarks": HONEST_DISCLAIMER,
+            },
+            "components": [{
+                "uuid": "a11oy-orchestrator",
+                "type": "software",
+                "title": "a11oy Governed AI Orchestrator",
+                "description": "Governed agentic-AI orchestration layer emitting a DSSE-signed "
+                               "receipt per inference. ALIGNS WITH the controls below; not certified.",
+                "props": [
+                    {"name": "doctrine", "ns": "https://szlholdings.ai/ns/oscal", "value": DOCTRINE_VERSION},
+                    {"name": "kernel-commit", "ns": "https://szlholdings.ai/ns/oscal", "value": KERNEL_COMMIT},
+                    {"name": "policy-bundle-digest", "ns": "https://szlholdings.ai/ns/oscal", "value": policy_bundle_digest()},
+                    {"name": "eu-ai-act-class", "ns": "https://szlholdings.ai/ns/oscal", "value": "High-Risk (self-classified)"},
+                ],
+                "control-implementations": [{
+                    "uuid": "ci-800-53r5",
+                    "source": src,
+                    "description": "a11oy mechanism mapping to NIST SP 800-53 Rev 5 (alignment only).",
+                    "implemented-requirements": impl + rego_statements,
+                }],
+            }],
+        }
+    }
+
+
+def _selftest() -> None:
+    assert len(LAMBDA_AXES) == 13, "must be 13 Λ axes"
+    # axes 1-10 must map to MEASURE 2.1..2.10
+    m2 = [a for a in LAMBDA_AXES if a["nist_measure"].startswith("MEASURE 2.")]
+    assert len(m2) >= 10
+    assert all(v in ("COVERED", "PARTIAL", "ROADMAP", "NA") for v in (r["coverage"] for r in COVERAGE_MATRIX))
+    s = coverage_summary()
+    assert sum(s.values()) == len(COVERAGE_MATRIX)
+    d1 = policy_bundle_digest(); d2 = policy_bundle_digest()
+    assert d1 == d2 and d1.startswith("sha256:")
+    oscal = build_oscal()
+    cd = oscal["component-definition"]
+    assert cd["components"][0]["control-implementations"][0]["implemented-requirements"], "no impl reqs"
+    assert "certified" not in HONEST_DISCLAIMER.lower() or "not" in HONEST_DISCLAIMER.lower()
+    # OSCAL must be valid JSON-serialisable
+    json.dumps(oscal)
+    mp = build_mapping(); mx = build_matrix()
+    assert mp["axis_count"] == 13 and mx["summary"]
+    print("a11oy_grc_data: ALL OK (%d matrix rows, 13 axes, %d gates, %d schema fields)"
+          % (len(COVERAGE_MATRIX), len(REGO_GATES), len(DSSE_RECEIPT_SCHEMA_V2)))
+
+
+if __name__ == "__main__":
+    _selftest()

compliance/oscal/a11oy-component-definition.json

@@ -0,0 +1,138 @@
+{
+  "component-definition": {
+    "uuid": "a11oy-comp-def-v11",
+    "metadata": {
+      "title": "a11oy Governed AI Orchestrator \u2014 OSCAL Component Definition",
+      "last-modified": "2026-06-14T06:40:15.254257+00:00",
+      "version": "v11",
+      "oscal-version": "1.1.2",
+      "remarks": "Coverage assessments reflect a11oy's INTERNAL analysis of its mechanisms against published framework control text. a11oy ALIGNS WITH / MAPS TO these frameworks; it does NOT claim certification. No third-party certification has been obtained for any framework as of Doctrine v11. Gaps are shown honestly. \u039b = Conjecture 1; locked-proven = 8 @ c7c0ba17; trust never 100%."
+    },
+    "components": [
+      {
+        "uuid": "a11oy-orchestrator",
+        "type": "software",
+        "title": "a11oy Governed AI Orchestrator",
+        "description": "Governed agentic-AI orchestration layer emitting a DSSE-signed receipt per inference. ALIGNS WITH the controls below; not certified.",
+        "props": [
+          {
+            "name": "doctrine",
+            "ns": "https://szlholdings.ai/ns/oscal",
+            "value": "v11"
+          },
+          {
+            "name": "kernel-commit",
+            "ns": "https://szlholdings.ai/ns/oscal",
+            "value": "c7c0ba17"
+          },
+          {
+            "name": "policy-bundle-digest",
+            "ns": "https://szlholdings.ai/ns/oscal",
+            "value": "sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba"
+          },
+          {
+            "name": "eu-ai-act-class",
+            "ns": "https://szlholdings.ai/ns/oscal",
+            "value": "High-Risk (self-classified)"
+          }
+        ],
+        "control-implementations": [
+          {
+            "uuid": "ci-800-53r5",
+            "source": "https://raw.githubusercontent.com/usnistgov/oscal-content/main/nist.gov/SP800-53/rev5/json/NIST_SP-800-53_rev5_catalog.json",
+            "description": "a11oy mechanism mapping to NIST SP 800-53 Rev 5 (alignment only).",
+            "implemented-requirements": [
+              {
+                "uuid": "ir-95efdfab",
+                "control-id": "au-2",
+                "description": "[COVERED] DSSE-signed audit event per inference (verdict + rule ID) (a11oy Event logging).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "COVERED"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-941c0684",
+                "control-id": "au-3",
+                "description": "[COVERED] Timestamp + input/output hash in every receipt (a11oy Content of audit records).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "COVERED"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-a0f3ffcd",
+                "control-id": "au-9",
+                "description": "[COVERED] Records sealed in DSSE envelopes signed by ECDSA-P256; tamper-detectable (a11oy Protection of audit information).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "COVERED"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-80c2667f",
+                "control-id": "cm-8",
+                "description": "[COVERED] Model ID + version + digest recorded per inference (a11oy System component inventory).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "COVERED"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-76491072",
+                "control-id": "ra-3",
+                "description": "[COVERED] 13-axis \u039b trust score is the per-inference risk assessment (a11oy Risk assessment).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "COVERED"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-74879421",
+                "control-id": "si-10",
+                "description": "[PARTIAL] Input hash + classification-boundary gate (a11oy Information input validation).",
+                "props": [
+                  {
+                    "name": "coverage",
+                    "ns": "https://szlholdings.ai/ns/oscal",
+                    "value": "PARTIAL"
+                  }
+                ]
+              },
+              {
+                "uuid": "ir-rego-b4e45455",
+                "control-id": "ac-3",
+                "description": "Rego gate a11oy.gates.classification_boundary (controls: ISO42001/A.9.6, NIST80053/AC-3, EUAIAct/Art.14). Bundle digest sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba is cited in every DSSE receipt."
+              },
+              {
+                "uuid": "ir-rego-0abacbce",
+                "control-id": "ac-3",
+                "description": "Rego gate a11oy.gates.human_override_required (controls: ISO42001/A.9.3, ISO42001/A.4.6, NIST80053/AU-2, EUAIAct/Art.14). Bundle digest sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba is cited in every DSSE receipt."
+              },
+              {
+                "uuid": "ir-rego-864d6ebc",
+                "control-id": "ac-3",
+                "description": "Rego gate a11oy.gates.deployment_readiness (controls: ISO27001/8.25, NIST80053/CM-3, ISO42001/A.6.7). Bundle digest sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba is cited in every DSSE receipt."
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}

compliance/rego/classification_boundary.rego

@@ -0,0 +1,18 @@
+# a11oy policy gate: classification_boundary
+# controls: ISO42001/A.9.6, NIST80053/AC-3, EUAIAct/Art.14
+# bundle digest (whole bundle): sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba
+
+package a11oy.gates.classification_boundary
+
+# DENY when output classification exceeds the operator's clearance level.
+default allow := false
+
+deny[msg] {
+  input.output_classification > input.user_clearance_level
+  msg := sprintf("output classification %v exceeds user clearance %v",
+                 [input.output_classification, input.user_clearance_level])
+}
+
+allow {
+  count(deny) == 0
+}

compliance/rego/deployment_readiness.rego

@@ -0,0 +1,14 @@
+# a11oy policy gate: deployment_readiness
+# controls: ISO27001/8.25, NIST80053/CM-3, ISO42001/A.6.7
+# bundle digest (whole bundle): sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba
+
+package a11oy.gates.deployment_readiness
+
+# Block model promotion unless the signed package digest + Λ floor are met.
+default promote := false
+
+promote {
+  input.package_signed == true
+  input.slsa_level >= 2
+  input.lambda_score >= input.lambda_promote_floor
+}

compliance/rego/human_override_required.rego

@@ -0,0 +1,16 @@
+# a11oy policy gate: human_override_required
+# controls: ISO42001/A.9.3, ISO42001/A.4.6, NIST80053/AU-2, EUAIAct/Art.14
+# bundle digest (whole bundle): sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba
+
+package a11oy.gates.human_override_required
+
+# Require a human override for irreversible actions or when Λ < threshold.
+default require_human := false
+
+require_human {
+  input.action_class == "irreversible"
+}
+
+require_human {
+  input.lambda_score < input.lambda_halt_threshold
+}

compliance/rego/manifest.json

@@ -0,0 +1,36 @@
+{
+  "bundle": "a11oy-policy-gates",
+  "doctrine": "v11",
+  "digest": "sha256:4b035da9e752dcdb81c8390974752fc729da8192e60a0459de50a05d4c9563ba",
+  "gates": [
+    {
+      "name": "classification_boundary",
+      "package": "a11oy.gates.classification_boundary",
+      "controls": [
+        "ISO42001/A.9.6",
+        "NIST80053/AC-3",
+        "EUAIAct/Art.14"
+      ]
+    },
+    {
+      "name": "human_override_required",
+      "package": "a11oy.gates.human_override_required",
+      "controls": [
+        "ISO42001/A.9.3",
+        "ISO42001/A.4.6",
+        "NIST80053/AU-2",
+        "EUAIAct/Art.14"
+      ]
+    },
+    {
+      "name": "deployment_readiness",
+      "package": "a11oy.gates.deployment_readiness",
+      "controls": [
+        "ISO27001/8.25",
+        "NIST80053/CM-3",
+        "ISO42001/A.6.7"
+      ]
+    }
+  ],
+  "note": "Version-locked OPA/Rego bundle. Every DSSE receipt cites this digest. ALIGNMENT only."
+}

serve.py

@@ -3500,6 +3500,34 @@ except Exception as _a11oy_af_e:
     _a11oy_af_tb.print_exc()
 # ── end ACTIVE-FLUX ROUTER CROSSOVER ──
 
+# ===========================================================================
+# GRC ALIGNMENT surface (Lane I5) — in-product ISO 42001 / NIST AI RMF / NIST
+# 800-53 Rev 5 / EU AI Act COVERAGE MATRIX (honest COVERED/PARTIAL/ROADMAP/NA per
+# control); the 13 Λ trust axes mapped to NIST AI RMF MEASURE 2 (+ Credo AI / MIT
+# taxonomy labels); policy gates published as OPA/Rego with a version-locked bundle
+# digest that every DSSE receipt cites; an OSCAL component-definition committed to the
+# repo (compliance/oscal/) + served live; and a DSSE Receipt Schema v2 whose every field
+# cites the control IDs it provides evidence for. Endpoints /api/a11oy/v1/grc/{matrix,
+# mapping,oscal,info} (dual-registered at /v1/grc/* for the HF proxy) + a self-contained
+# 0-CDN "Compliance / GRC" page at /grc (alias /compliance). A nav link is injected by
+# this module's OWN idempotent middleware (the console SPA source is NOT edited and other
+# devs' tabs are never clobbered). HONEST (Doctrine v11): a11oy ALIGNS WITH / MAPS TO these
+# frameworks — NEVER "certified" / "compliant"; no third-party certification obtained; gaps
+# shown honestly. Adds NOTHING to the locked-8; Λ = Conjecture 1; trust never 100%; 0 CDN.
+# Additive, try/except-guarded, BEFORE the SPA/proxy catch-all.
+# ===========================================================================
+try:
+    import a11oy_grc as _a11oy_grc
+    _a11oy_grc_status = _a11oy_grc.register(app, ns="a11oy")
+    print(f"[a11oy] GRC alignment registered: {_a11oy_grc_status['count']} routes "
+          f"({_a11oy_grc_status['data_label']}) \u2014 aligns with ISO 42001 / NIST AI RMF / "
+          f"800-53 / EU AI Act (NOT certified)", file=sys.stderr)
+except Exception as _a11oy_grc_e:
+    import traceback as _a11oy_grc_tb
+    print(f"[a11oy] GRC alignment NOT registered: {_a11oy_grc_e!r}", file=sys.stderr)
+    _a11oy_grc_tb.print_exc()
+# ── end GRC ALIGNMENT ──
+
 # ===========================================================================
 # ADDITIVE — Parity Gap Closure + Differentiators (Yachay / Parity Squad, 2026-06-04)
 # Co-Authored-By: Perplexity Computer Agent <agent@perplexity.ai>

szl_cuas_formulas.py

@@ -51,6 +51,11 @@ SOURCES = {
     "Li Yu (李彧) — PI-correction bandwidth in an active-flux observer (LinkedIn 2026)": "https://www.linkedin.com/pulse/how-should-bandwidth-pi-correction-loop-active-flux-observer-%E5%BD%A7-%E6%9D%8E-qxksc",
     "Revised Hybrid Active-Flux encoderless PMSM control (IEEE)": "https://ieeexplore.ieee.org/document/9319155",
     "TI InstaSPIN-FOC / FAST flux observer (SPRUHJ1)": "https://www.ti.com/lit/ug/spruhj1h/spruhj1h.pdf",
+    # Platform dynamics (F-θ) — 6DOF quadcopter MBD + Moore-Penrose control allocation.
+    "Ahmed Hassan — Quadcopter Modeling/Control/Simulation (Simulink 6DOF, Aerospace Blockset; LinkedIn 2026)": "https://www.linkedin.com/posts/ahmedhassan2002_aerospaceengineering-aerospace-uav-activity-7348481891039129600-TbmA",
+    "Moore-Penrose pseudo-inverse control allocation (overview)": "https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse",
+    "Control allocation survey (Johansen & Fossen, Automatica 2013)": "https://doi.org/10.1016/j.automatica.2013.01.035",
+    "Model-Based Design / V-cycle, MIL/SIL/HIL (MathWorks)": "https://www.mathworks.com/solutions/model-based-design.html",
 }
 
 
@@ -370,6 +375,196 @@ def szl_active_flux_observer(psi_f: float = 0.09, Ld: float = 0.0085, Lq: float
     }
 
 
+# ---------------------------------------------------------------------------
+# F-θ  SZL Platform Dynamics — 6DOF quadcopter/interceptor model + Moore-Penrose
+#       pseudo-inverse CONTROL ALLOCATION (thrust distribution). MODELED/SIMULATED.
+#
+# ADOPTED-AND-GENERALIZED, NOT invented here. Ahmed Hassan's Simulink Quadcopter MBD
+# project (full 6DOF model in Aerospace Blockset; control ALLOCATION via the
+# Moore-Penrose pseudo-inverse for optimal thrust distribution; MIL/SIL via Embedded
+# Coder) is the on-domain technique we fold in: it rounds out the killinchu drone-
+# platform puzzle — estimate (active-flux, F-η) → 6DOF dynamics + control allocation
+# (this) → CBF-QP safety clamp (autonomy) → BFT multi-sensor fusion → governed/ROE
+# engage (SIMULATED human-on-loop). Pure stdlib (no numpy): the 4-rotor mixing matrix
+# is small and fixed, so we compute the pseudo-inverse in closed form.
+#
+# HONEST: there is NO live airframe on the demo floor. Every angular rate, attitude,
+# rotor thrust here is a MODELED model output, NOT live telemetry. The effector stays
+# SIMULATED human-on-loop — this computes a thrust allocation + a one-step state
+# derivative, it NEVER actuates a motor or a vessel. EXPERIMENTAL-tier; adds NOTHING
+# to the locked-8; Λ stays Conjecture 1; trust never 100%.
+# ---------------------------------------------------------------------------
+def quad_mixing_matrix(arm_length: float = 0.25, k_thrust: float = 1.0,
+                       k_torque: float = 0.02) -> list[list[float]]:
+    """Quadcopter (X-config) control-effectiveness / mixing matrix B (4×4) mapping the
+    four rotor thrusts f = [f1,f2,f3,f4] (front-right, back-left, front-left, back-right)
+    to the body wrench tau = [T, L, M, N] = [total thrust, roll, pitch, yaw torque]:
+        T = f1 + f2 + f3 + f4
+        L (roll, about x)  =  arm · ( -f1 + f2 - f3 + f4 ) · k_thrust   (right rotors down)
+        M (pitch, about y) =  arm · ( f1 + f2 - f3 - f4 ) · k_thrust    (front rotors up)
+        N (yaw, about z)   =  k_torque · ( f1 + f2 - f3 - f4 )  via reaction torque sign
+    The exact signs encode the X-frame geometry + the CW/CCW spin pattern. This is the
+    standard quadrotor control-allocation matrix. MODELED. [EXPERIMENTAL]"""
+    a = arm_length * k_thrust
+    kt = k_torque
+    # rows: [T, L(roll), M(pitch), N(yaw)] ; cols: f1 f2 f3 f4
+    return [
+        [1.0,  1.0,  1.0,  1.0],     # total thrust
+        [-a,   a,   -a,    a],        # roll torque
+        [a,    a,   -a,   -a],        # pitch torque
+        [kt,  -kt,  -kt,   kt],       # yaw reaction torque (CW/CCW pattern)
+    ]
+
+
+def _mat_mul(A: list[list[float]], B: list[list[float]]) -> list[list[float]]:
+    return [[sum(A[i][k] * B[k][j] for k in range(len(B)))
+             for j in range(len(B[0]))] for i in range(len(A))]
+
+
+def _transpose(A: list[list[float]]) -> list[list[float]]:
+    return [[A[i][j] for i in range(len(A))] for j in range(len(A[0]))]
+
+
+def _inv(A: list[list[float]]) -> list[list[float]]:
+    """Gauss-Jordan inverse of a small square matrix (no numpy). Raises on singular."""
+    n = len(A)
+    M = [list(map(float, A[i])) + [1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
+    for col in range(n):
+        piv = max(range(col, n), key=lambda r: abs(M[r][col]))
+        if abs(M[piv][col]) < 1e-12:
+            raise ValueError("singular matrix")
+        M[col], M[piv] = M[piv], M[col]
+        pv = M[col][col]
+        M[col] = [x / pv for x in M[col]]
+        for r in range(n):
+            if r != col:
+                fac = M[r][col]
+                M[r] = [a - fac * b for a, b in zip(M[r], M[col])]
+    return [row[n:] for row in M]
+
+
+def moore_penrose_pinv(B: list[list[float]]) -> list[list[float]]:
+    """Moore-Penrose pseudo-inverse B+ of a (possibly non-square) matrix, pure stdlib.
+    For a wide/tall full-rank B we use the closed forms:
+        right pinv (rows<=cols, full row rank):  B+ = B^T (B B^T)^-1
+        left  pinv (rows> cols, full col rank):  B+ = (B^T B)^-1 B^T
+    For a square invertible B both reduce to B^-1. This is the minimum-norm /
+    least-squares control allocator. Cite Moore-Penrose; Johansen & Fossen (2013).
+    [EXPERIMENTAL]"""
+    rows, cols = len(B), len(B[0])
+    Bt = _transpose(B)
+    if rows <= cols:
+        # right inverse: B^T (B B^T)^-1
+        BBt = _mat_mul(B, Bt)
+        return _mat_mul(Bt, _inv(BBt))
+    else:
+        # left inverse: (B^T B)^-1 B^T
+        BtB = _mat_mul(Bt, B)
+        return _mat_mul(_inv(BtB), Bt)
+
+
+def szl_control_allocation(tau_cmd: list[float], arm_length: float = 0.25,
+                           k_thrust: float = 1.0, k_torque: float = 0.02,
+                           f_min: float = 0.0, f_max: float = 12.0) -> dict[str, Any]:
+    """Moore-Penrose pseudo-inverse CONTROL ALLOCATION: given a commanded body wrench
+    tau_cmd = [T, L, M, N] (total thrust + roll/pitch/yaw torque), solve for the
+    minimum-norm rotor-thrust vector f = B+ · tau that realizes it, then saturate each
+    rotor to [f_min, f_max] and report the achieved wrench tau_ach = B · f_sat and the
+    allocation residual. This is the optimal (least-norm) thrust distribution — the
+    classic Moore-Penrose allocator from Hassan's Simulink MBD project. MODELED/SIMULATED:
+    NO live airframe; this computes a solution, it never actuates. [EXPERIMENTAL · MODELED]"""
+    B = quad_mixing_matrix(arm_length, k_thrust, k_torque)
+    Bp = moore_penrose_pinv(B)
+    tau = [float(x) for x in (list(tau_cmd) + [0.0, 0.0, 0.0, 0.0])[:4]]
+    # f = B+ tau
+    f_raw = [sum(Bp[i][j] * tau[j] for j in range(4)) for i in range(4)]
+    f_sat = [min(max(v, f_min), f_max) for v in f_raw]
+    saturated = [bool(abs(v - s) > 1e-9) for v, s in zip(f_raw, f_sat)]
+    # achieved wrench tau_ach = B f_sat
+    tau_ach = [sum(B[i][j] * f_sat[j] for j in range(4)) for i in range(4)]
+    resid = [round(tau_ach[i] - tau[i], 6) for i in range(4)]
+    resid_norm = math.sqrt(sum(r * r for r in resid))
+    labels = ["thrust_T", "roll_L", "pitch_M", "yaw_N"]
+    rotors = ["f1_front_right", "f2_back_left", "f3_front_left", "f4_back_right"]
+    return {
+        "tau_cmd": {labels[i]: round(tau[i], 4) for i in range(4)},
+        "rotor_thrust_raw": {rotors[i]: round(f_raw[i], 6) for i in range(4)},
+        "rotor_thrust_sat": {rotors[i]: round(f_sat[i], 6) for i in range(4)},
+        "any_rotor_saturated": any(saturated),
+        "tau_achieved": {labels[i]: round(tau_ach[i], 4) for i in range(4)},
+        "allocation_residual": {labels[i]: resid[i] for i in range(4)},
+        "residual_norm": round(resid_norm, 6),
+        "method": "Moore-Penrose pseudo-inverse f = B⁺·τ (minimum-norm least-squares), then saturate",
+        "mixing_matrix_B": B,
+        "effector": "SIMULATED",
+        "data_label": "MODELED/SIMULATED — no live airframe; computes a thrust solution, never actuates",
+        "doctrine": "adopted Hassan quadcopter MBD control-allocation; NOT added to the locked-8; Λ Conjecture 1",
+        "status": "MODELED",
+    }
+
+
+def szl_6dof_step(state: dict[str, float] | None = None, tau: list[float] | None = None,
+                  mass: float = 1.2, ixx: float = 0.015, iyy: float = 0.015,
+                  izz: float = 0.028, dt: float = 0.01, g: float = 9.81) -> dict[str, Any]:
+    """One-step 6DOF rigid-body dynamics for a quad/interceptor (MODELED/SIMULATED).
+    State = body-frame translational velocity (u,v,w), angular rates (p,q,r), and
+    Euler attitude (phi,theta,psi). Given a body wrench tau=[T,L,M,N] (total thrust
+    along body -z + roll/pitch/yaw torques), integrate ONE Euler step of the Newton-
+    Euler equations:
+        translational:  m(ẇ + ...)  — here reported as body accelerations
+            u̇ = r*v - q*w - g*sin(theta)
+            v̇ = p*w - r*u + g*cos(theta)*sin(phi)
+            ẇ = q*u - p*v + g*cos(theta)*cos(phi) - T/m
+        rotational (Euler):
+            ṗ = (L - (izz-iyy)*q*r)/ixx
+            q̇ = (M - (ixx-izz)*p*r)/iyy
+            ṙ = (N - (iyy-ixx)*p*q)/izz
+        attitude kinematics:  phi̇ = p + ... (small-angle body-rate ≈ Euler-rate).
+    Returns the derivatives + the integrated next state. This is the standard
+    Aerospace-Blockset 6DOF body model (Hassan MBD). NO live airframe; deterministic
+    model output, never actuated. [EXPERIMENTAL · MODELED]"""
+    s = {"u": 0.0, "v": 0.0, "w": 0.0, "p": 0.0, "q": 0.0, "r": 0.0,
+         "phi": 0.0, "theta": 0.0, "psi": 0.0}
+    if state:
+        s.update({k: float(v) for k, v in state.items() if k in s})
+    T, L, M, N = ([float(x) for x in (list(tau or []) + [0.0] * 4)[:4]])
+    u, v, w = s["u"], s["v"], s["w"]
+    p, q, r = s["p"], s["q"], s["r"]
+    phi, theta, psi = s["phi"], s["theta"], s["psi"]
+    # translational body accelerations
+    du = r * v - q * w - g * math.sin(theta)
+    dv = p * w - r * u + g * math.cos(theta) * math.sin(phi)
+    dw = q * u - p * v + g * math.cos(theta) * math.cos(phi) - T / max(mass, 1e-9)
+    # rotational (Newton-Euler)
+    dp = (L - (izz - iyy) * q * r) / max(ixx, 1e-9)
+    dq = (M - (ixx - izz) * p * r) / max(iyy, 1e-9)
+    dr = (N - (iyy - ixx) * p * q) / max(izz, 1e-9)
+    # attitude kinematics (Euler-angle rates; full transport matrix)
+    dphi = p + math.sin(phi) * math.tan(theta) * q + math.cos(phi) * math.tan(theta) * r
+    dtheta = math.cos(phi) * q - math.sin(phi) * r
+    dpsi = (math.sin(phi) / max(math.cos(theta), 1e-6)) * q + (math.cos(phi) / max(math.cos(theta), 1e-6)) * r
+    deriv = {"du": du, "dv": dv, "dw": dw, "dp": dp, "dq": dq, "dr": dr,
+             "dphi": dphi, "dtheta": dtheta, "dpsi": dpsi}
+    nxt = {
+        "u": u + du * dt, "v": v + dv * dt, "w": w + dw * dt,
+        "p": p + dp * dt, "q": q + dq * dt, "r": r + dr * dt,
+        "phi": phi + dphi * dt, "theta": theta + dtheta * dt, "psi": psi + dpsi * dt,
+    }
+    return {
+        "state_in": {k: round(val, 6) for k, val in s.items()},
+        "tau": {"thrust_T": round(T, 4), "roll_L": round(L, 4),
+                "pitch_M": round(M, 4), "yaw_N": round(N, 4)},
+        "derivatives": {k: round(val, 6) for k, val in deriv.items()},
+        "state_next": {k: round(val, 6) for k, val in nxt.items()},
+        "params": {"mass": mass, "Ixx": ixx, "Iyy": iyy, "Izz": izz, "dt": dt, "g": g},
+        "model": "Newton-Euler rigid-body 6DOF (body frame); Aerospace-Blockset shape (Hassan MBD)",
+        "effector": "SIMULATED",
+        "data_label": "MODELED/SIMULATED — no live airframe; deterministic model step, never actuated",
+        "doctrine": "adopted Hassan quadcopter 6DOF MBD; NOT added to the locked-8; Λ Conjecture 1",
+        "status": "MODELED",
+    }
+
+
 def summary(ns: str = "killinchu") -> dict[str, Any]:
     """Headline of all six SZL counter-UAS formulas + honest provenance/legend.
     `ns` names the serving app so the title is accurate on both killinchu and a11oy."""
@@ -386,6 +581,8 @@ def summary(ns: str = "killinchu") -> dict[str, Any]:
             "wta": "SZL-WTA Threat Triage (weapon-target assignment, SIMULATED)",
             "pqbus": "SZL-PQ Receipt Bus (post-quantum receipt chain)",
             "active_flux": "SZL Active-Flux Hybrid Observer (sensorless PMSM; ADOPTED Li Yu/APEC 2001, MODELED)",
+            "platform_allocation": "SZL Platform Dynamics — Moore-Penrose control allocation (ADOPTED Hassan MBD, MODELED)",
+            "platform_6dof": "SZL Platform Dynamics — 6DOF Newton-Euler quad/interceptor step (ADOPTED Hassan MBD, MODELED)",
         },
         "examples": {
             "engage": szl_engageability(N=3.5, Vc=300.0, los_rate=0.02, t_go=4.0, a_max=200.0),
@@ -441,6 +638,28 @@ def register(app, ns: str) -> None:
                 "points": n, "curve": curve, "li_yu_reference": LI_YU_REFERENCE_BODE,
                 "data_label": "MODELED/SIMULATED — no live motor", "status": "MODELED"}
     app.add_api_route(f"{base}/active-flux/bode", _active_flux_bode, methods=["GET"])
+    # F-θ Platform Dynamics — Moore-Penrose control allocation + 6DOF step (ADOPTED Hassan MBD; MODELED).
+    def _alloc(T: str = "11.8", L: str = "0.2", M: str = "0.0", N: str = "0.05",
+               arm: str = "0.25", k_torque: str = "0.02", f_max: str = "12.0"):
+        try:
+            return szl_control_allocation([float(T), float(L), float(M), float(N)],
+                                          arm_length=float(arm), k_torque=float(k_torque),
+                                          f_max=float(f_max))
+        except (ValueError, TypeError) as e:
+            return {"error": {"code": "validation_error", "detail": str(e)}}
+    app.add_api_route(f"{base}/allocation", _alloc, methods=["GET"])
+
+    def _sixdof(T: str = "11.77", L: str = "0.0", M: str = "0.0", N: str = "0.0",
+                p: str = "0.0", q: str = "0.0", r: str = "0.0",
+                phi: str = "0.0", theta: str = "0.1", psi: str = "0.0", dt: str = "0.01"):
+        try:
+            return szl_6dof_step(
+                state={"p": float(p), "q": float(q), "r": float(r),
+                       "phi": float(phi), "theta": float(theta), "psi": float(psi)},
+                tau=[float(T), float(L), float(M), float(N)], dt=float(dt))
+        except (ValueError, TypeError) as e:
+            return {"error": {"code": "validation_error", "detail": str(e)}}
+    app.add_api_route(f"{base}/dynamics", _sixdof, methods=["GET"])
 
 
 def _selftest() -> None:
@@ -484,7 +703,31 @@ def _selftest() -> None:
     obs = szl_active_flux_observer()
     assert obs["status"] == "MODELED" and obs["effector"] == "SIMULATED"
     assert "MODELED/SIMULATED" in obs["data_label"]
-    print("szl_cuas_formulas: ALL OK (19 checks)")
+    # F-θ Platform Dynamics (ADOPTED Hassan MBD; MODELED): pseudo-inverse round-trip.
+    B = quad_mixing_matrix()
+    Bp = moore_penrose_pinv(B)
+    # B is 4x4 invertible -> B B+ = I (within tolerance)
+    BBp = _mat_mul(B, Bp)
+    for i in range(4):
+        for j in range(4):
+            assert abs(BBp[i][j] - (1.0 if i == j else 0.0)) < 1e-6
+    # pure-thrust command -> equal rotor split, zero torque residual
+    al = szl_control_allocation([12.0, 0.0, 0.0, 0.0])
+    rs = al["rotor_thrust_sat"]
+    assert abs(rs["f1_front_right"] - 3.0) < 1e-6 and al["residual_norm"] < 1e-6
+    assert al["status"] == "MODELED" and al["effector"] == "SIMULATED"
+    # roll command on a hover baseline (so no rotor saturates) -> achieved wrench == commanded
+    al2 = szl_control_allocation([8.0, 0.5, 0.0, 0.0])
+    assert not al2["any_rotor_saturated"]
+    assert abs(al2["tau_achieved"]["roll_L"] - 0.5) < 1e-6
+    assert abs(al2["tau_achieved"]["thrust_T"] - 8.0) < 1e-6 and al2["residual_norm"] < 1e-6
+    # 6DOF: hover thrust ~ m*g cancels gravity in w-dot (theta=0)
+    st = szl_6dof_step(state={"theta": 0.0}, tau=[1.2 * 9.81, 0.0, 0.0, 0.0])
+    assert abs(st["derivatives"]["dw"]) < 1e-6 and st["status"] == "MODELED"
+    # roll torque produces a positive p-dot
+    st2 = szl_6dof_step(tau=[0.0, 0.01, 0.0, 0.0])
+    assert st2["derivatives"]["dp"] > 0.0 and st2["effector"] == "SIMULATED"
+    print("szl_cuas_formulas: ALL OK (27 checks)")
 
 
 if __name__ == "__main__":