feat(lab): measure RAVNOVES00 R1 quality baseline

src/k1link/web/advanced_laboratory_api.py

@@ -39,6 +39,11 @@ from k1link.compute.e37_acceptance_contract import (
     E37AcceptanceContractError,
     read_e37_acceptance_contract,
 )
+from k1link.compute.e38_perception_baseline import (
+    E38PerceptionBaseline,
+    E38PerceptionBaselineError,
+    read_e38_perception_baseline,
+)
 
 LABORATORY_ADVANCED_CATALOG_SCHEMA: Final = (
     "missioncore.laboratory-advanced-catalog/v1"
@@ -50,6 +55,7 @@ _E33_RESULT_ID = re.compile(r"^e33-worker-shadow-[a-f0-9]{64}$")
 _E34_RESULT_ID = re.compile(r"^e34-temporal-occupied-[a-f0-9]{64}$")
 _E35_RESULT_ID = re.compile(r"^e35-degradation-recovery-[a-f0-9]{64}$")
 _E37_RESULT_ID = re.compile(r"^e37-ravnoves-acceptance-[a-f0-9]{64}$")
+_E38_RESULT_ID = re.compile(r"^e38-perception-baseline-[a-f0-9]{64}$")
 
 RootProvider = Callable[[], Path | None]
 
@@ -118,6 +124,15 @@ def _read_e37_cached(
     return read_e37_acceptance_contract(Path(root_text))
 
 
+@lru_cache(maxsize=16)
+def _read_e38_cached(
+    root_text: str,
+    signature: tuple[int, ...],
+) -> E38PerceptionBaseline:
+    del signature
+    return read_e38_perception_baseline(Path(root_text))
+
+
 def _configured_root(provider: RootProvider) -> Path | None:
     value = provider()
     if value is None:
@@ -555,6 +570,40 @@ def _project_e37(result: E37AcceptanceContract) -> dict[str, object]:
     }
 
 
+def _project_e38(result: E38PerceptionBaseline) -> dict[str, object]:
+    identity = _object(result.manifest.get("identity"), "E38 identity")
+    source = _object(identity.get("source"), "E38 source")
+    execution = _object(identity.get("execution"), "E38 execution")
+    profile = _object(identity.get("profile"), "E38 profile")
+    metrics = _object(result.report.get("metrics"), "E38 metrics")
+    dimensions = _object(metrics.get("dimensions"), "E38 dimensions")
+    quality_gate = _object(result.report.get("quality_gate"), "E38 gate")
+    return {
+        "result_id": result.result_id,
+        "created_at_utc": result.manifest.get("created_at_utc"),
+        "source_session_id": source.get("session_id"),
+        "source_display_name": source.get("display_name"),
+        "status": result.report.get("status"),
+        "profile_id": profile.get("profile_id"),
+        "worker_node": execution.get("worker_node"),
+        "quality_gate_passed": quality_gate.get("passed"),
+        "metrics": {
+            "development_items": metrics.get("development_items"),
+            "validation_items": metrics.get("validation_items"),
+            "terminal_outcomes": metrics.get("terminal_outcomes"),
+            "accounting_fraction": metrics.get("accounting_fraction"),
+            "false_free_claims": metrics.get("false_free_claims"),
+            "high_severity_failures": metrics.get("high_severity_failures"),
+            "dimensions": copy.deepcopy(dimensions),
+        },
+        "blocking_checks": copy.deepcopy(quality_gate.get("blocking_checks")),
+        "decision": copy.deepcopy(result.report.get("decision")),
+        "limitations": copy.deepcopy(result.report.get("limitations")),
+        "authority": copy.deepcopy(result.report.get("authority")),
+        "access": "read-only",
+    }
+
+
 def _empty_catalog(configured: bool) -> dict[str, object]:
     return {
         "schema_version": LABORATORY_ADVANCED_CATALOG_SCHEMA,
@@ -574,6 +623,7 @@ def build_advanced_laboratory_router(
     e34_root_provider: RootProvider = lambda: None,
     e35_root_provider: RootProvider = lambda: None,
     e37_root_provider: RootProvider = lambda: None,
+    e38_root_provider: RootProvider = lambda: None,
 ) -> APIRouter:
     router = APIRouter(prefix="/api/v1/laboratory", tags=["laboratory"])
 
@@ -803,4 +853,37 @@ def build_advanced_laboratory_router(
             "invalid_total": invalid_total,
         }
 
+    @router.get("/e38/results")
+    def list_e38_results(
+        limit: int = Query(default=1, ge=1, le=10),
+    ) -> dict[str, object]:
+        root = _configured_root(e38_root_provider)
+        if root is None:
+            return _empty_catalog(False)
+        candidates = _candidates(root, _E38_RESULT_ID)
+        items: list[dict[str, object]] = []
+        invalid_total = 0
+        for candidate in candidates:
+            try:
+                result = _read_e38_cached(
+                    str(candidate.resolve()),
+                    _result_signature(candidate),
+                )
+                if len(items) < limit:
+                    items.append(_project_e38(result))
+            except (
+                E38PerceptionBaselineError,
+                KeyError,
+                OSError,
+                TypeError,
+                ValueError,
+            ):
+                invalid_total += 1
+        return {
+            **_empty_catalog(True),
+            "items": items,
+            "candidate_total": len(candidates),
+            "invalid_total": invalid_total,
+        }
+
     return router

src/k1link/web/app.py

@@ -543,6 +543,13 @@ app.include_router(
             / "e37"
             / "results"
         ),
+        e38_root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "e38"
+            / "results"
+        ),
     )
 )
 app.include_router(