feat(lab): publish E39 refinement result

src/k1link/web/advanced_laboratory_api.py

@@ -44,6 +44,11 @@ from k1link.compute.e38_perception_baseline import (
     E38PerceptionBaselineError,
     read_e38_perception_baseline,
 )
+from k1link.compute.e39_perception_refinement import (
+    E39PerceptionRefinement,
+    E39PerceptionRefinementError,
+    read_e39_perception_refinement,
+)
 
 LABORATORY_ADVANCED_CATALOG_SCHEMA: Final = (
     "missioncore.laboratory-advanced-catalog/v1"
@@ -56,6 +61,7 @@ _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}$")
+_E39_RESULT_ID = re.compile(r"^e39-perception-refinement-[a-f0-9]{64}$")
 
 RootProvider = Callable[[], Path | None]
 
@@ -133,6 +139,15 @@ def _read_e38_cached(
     return read_e38_perception_baseline(Path(root_text))
 
 
+@lru_cache(maxsize=16)
+def _read_e39_cached(
+    root_text: str,
+    signature: tuple[int, ...],
+) -> E39PerceptionRefinement:
+    del signature
+    return read_e39_perception_refinement(Path(root_text))
+
+
 def _configured_root(provider: RootProvider) -> Path | None:
     value = provider()
     if value is None:
@@ -604,6 +619,46 @@ def _project_e38(result: E38PerceptionBaseline) -> dict[str, object]:
     }
 
 
+def _project_e39(result: E39PerceptionRefinement) -> dict[str, object]:
+    identity = _object(result.manifest.get("identity"), "E39 identity")
+    source = _object(identity.get("source"), "E39 source")
+    execution = _object(identity.get("execution"), "E39 execution")
+    profile = _object(identity.get("profile"), "E39 profile")
+    metrics = _object(result.report.get("metrics"), "E39 metrics")
+    dimensions = _object(metrics.get("dimensions"), "E39 dimensions")
+    quality_gate = _object(result.report.get("quality_gate"), "E39 gate")
+    development_cv = _object(
+        result.report.get("development_cross_validation"),
+        "E39 development CV",
+    )
+    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"),
+        "development_cross_validation": copy.deepcopy(development_cv),
+        "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")),
+        "method": copy.deepcopy(result.report.get("method")),
+        "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,
@@ -624,6 +679,7 @@ def build_advanced_laboratory_router(
     e35_root_provider: RootProvider = lambda: None,
     e37_root_provider: RootProvider = lambda: None,
     e38_root_provider: RootProvider = lambda: None,
+    e39_root_provider: RootProvider = lambda: None,
 ) -> APIRouter:
     router = APIRouter(prefix="/api/v1/laboratory", tags=["laboratory"])
 
@@ -886,4 +942,37 @@ def build_advanced_laboratory_router(
             "invalid_total": invalid_total,
         }
 
+    @router.get("/e39/results")
+    def list_e39_results(
+        limit: int = Query(default=1, ge=1, le=10),
+    ) -> dict[str, object]:
+        root = _configured_root(e39_root_provider)
+        if root is None:
+            return _empty_catalog(False)
+        candidates = _candidates(root, _E39_RESULT_ID)
+        items: list[dict[str, object]] = []
+        invalid_total = 0
+        for candidate in candidates:
+            try:
+                result = _read_e39_cached(
+                    str(candidate.resolve()),
+                    _result_signature(candidate),
+                )
+                if len(items) < limit:
+                    items.append(_project_e39(result))
+            except (
+                E39PerceptionRefinementError,
+                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

@@ -550,6 +550,13 @@ app.include_router(
             / "e38"
             / "results"
         ),
+        e39_root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "e39"
+            / "results"
+        ),
     )
 )
 app.include_router(