feat(lab): publish M4.8 assisted regression evidence

src/k1link/web/advanced_laboratory_api.py

@@ -56,6 +56,7 @@ from k1link.compute.e40_perception_product_gate import (
     read_e40_perception_product_gate,
 )
 from k1link.laboratory import LaboratoryEvidenceDefinition, LaboratoryEvidenceRegistry
+from k1link.laboratory.evidence_registry import LaboratoryEvidenceVariant
 from k1link.web.l3_pointpillars_visual_api import latest_l3_visual_identity
 from k1link.web.l31_pointpillars_ravnoves_api import latest_l31_identity
 from k1link.web.l32_pointpillars_camera_review_api import latest_l32_identity
@@ -259,7 +260,10 @@ def _advanced_index(
     specs: tuple[_AdvancedIndexSpec, ...],
 ) -> dict[str, object]:
     items: list[dict[str, object]] = []
+    selected_work_ids: set[str] = set()
     for work_id, provider, pattern, document_name, schema_version in specs:
+        if work_id in selected_work_ids:
+            continue
         root = _configured_root(provider)
         if root is None:
             continue
@@ -273,6 +277,7 @@ def _advanced_index(
                         schema_version=schema_version,
                     )
                 )
+                selected_work_ids.add(work_id)
                 break
             except (json.JSONDecodeError, OSError, TypeError, ValueError):
                 continue
@@ -290,17 +295,18 @@ def _registry_index_specs(
     return tuple(
         (
             definition.work_id,
-            _evidence_root_provider(definition, runtime_root_provider),
-            definition.result_id_pattern,
-            definition.document_name,
-            definition.result_schema_version,
+            _evidence_root_provider(variant, runtime_root_provider),
+            variant.result_id_pattern,
+            variant.document_name,
+            variant.result_schema_version,
         )
         for definition in registry.definitions
+        for variant in reversed(definition.evidence_variants)
     )
 
 
 def _evidence_root_provider(
-    definition: LaboratoryEvidenceDefinition,
+    definition: LaboratoryEvidenceDefinition | LaboratoryEvidenceVariant,
     runtime_root_provider: RootProvider,
 ) -> RootProvider:
     def result_root_provider() -> Path | None:

src/k1link/web/app.py

@@ -23,15 +23,23 @@ from k1link.compute import (
     RecordedPerceptionOverlayMux,
     RecordedPerceptionOverlayStore,
 )
+from k1link.compute.pipeline_telemetry import JsonlPipelineTelemetrySink
 from k1link.laboratory import (
     LaboratoryEvidenceRegistry,
     LaboratoryEvidenceReportService,
     LaboratoryExecutionRegistry,
+    LaboratoryRunner,
     LaboratoryValueReviewRegistry,
 )
+from k1link.laboratory.m48_raw_evidence import (
+    M48_EXPECTED_THREAT_RESULT_ID,
+    M48RawEvidenceError,
+    M48RawEvidenceReader,
+)
 from k1link.sessions import (
     MaterializedRecording,
     RecordedCameraFrameService,
+    RecordedCameraPlaybackSource,
     RecordedMediaInspector,
     RecordedMediaManifest,
     RecordingPreparationQueueFull,
@@ -116,6 +124,7 @@ from k1link.web.laboratory_report_api import build_laboratory_report_router
 from k1link.web.lidar_api import build_lidar_router
 from k1link.web.lidar_local_surface_service import K1LocalSurfaceReadService
 from k1link.web.m4_threat_replay_api import build_m4_threat_replay_router
+from k1link.web.m48_object_quality_api import build_m48_object_quality_router
 from k1link.web.map_api import (
     MapGatewayConfiguration,
     MapGatewayProxy,
@@ -151,6 +160,13 @@ LABORATORY_EXECUTION_REGISTRY = LaboratoryExecutionRegistry.from_file(
     REPOSITORY_ROOT / "config" / "laboratory-execution.json",
     LABORATORY_EVIDENCE_REGISTRY,
 )
+LABORATORY_RUNNER = LaboratoryRunner(
+    registry=LABORATORY_EXECUTION_REGISTRY,
+    evidence_registry=LABORATORY_EVIDENCE_REGISTRY,
+    sink=JsonlPipelineTelemetrySink(
+        REPOSITORY_ROOT / ".runtime" / "telemetry" / "laboratory-runs.jsonl"
+    ),
+)
 LABORATORY_VALUE_REVIEW_REGISTRY = LaboratoryValueReviewRegistry.from_file(
     REPOSITORY_ROOT / "config" / "laboratory-value-review.json"
 )
@@ -204,6 +220,20 @@ session_recorded_camera_frame_service = (
     if _ffmpeg is not None
     else None
 )
+try:
+    m48_raw_evidence_reader: M48RawEvidenceReader | None = M48RawEvidenceReader.from_repository(
+        repository_root=REPOSITORY_ROOT,
+        threat_result_root=(
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "m4"
+            / "replay-threat"
+            / M48_EXPECTED_THREAT_RESULT_ID
+        ),
+    )
+except (M48RawEvidenceError, OSError, ValueError):
+    m48_raw_evidence_reader = None
 session_legacy_perception_overlay_store = (
     RecordedPerceptionOverlayStore(
         jobs_root=REPOSITORY_ROOT / ".runtime" / "compute-jobs",
@@ -295,6 +325,20 @@ session_recording_preparation_manager = SessionRecordingPreparationManager(
 )
 
 
+def _m48_recorded_camera_playback_source(
+    session_id: str,
+) -> RecordedCameraPlaybackSource:
+    """Publish the durable replay package before exposing its manifest URL."""
+
+    if session_recorded_camera_frame_service is None:
+        raise RuntimeError("recorded camera playback is unavailable")
+    command = session_store.prepare_replay(session_id, speed=1.0, loop=False)
+    snapshot = session_recording_preparation_manager.restore_published(command)
+    if snapshot is None or snapshot.state != "ready" or snapshot.recorded_media is None:
+        raise RuntimeError("recorded camera playback package is not published")
+    return session_recorded_camera_frame_service.playback_source(session_id)
+
+
 def refresh_observation_catalog() -> tuple[str, ...]:
     """Discover completed or recoverable local evidence without copying payloads."""
 
@@ -859,6 +903,47 @@ app.include_router(
         ),
     )
 )
+app.include_router(
+    build_m48_object_quality_router(
+        pack_root_provider=lambda: (
+            REPOSITORY_ROOT / ".runtime" / "compute-experiments" / "m48" / "object-quality-packs"
+        ),
+        workflow_root_provider=lambda: (
+            REPOSITORY_ROOT / ".runtime" / "laboratory-annotations" / "m48-object-quality"
+        ),
+        truth_root_provider=lambda: (
+            REPOSITORY_ROOT / ".runtime" / "compute-experiments" / "m48" / "object-truth-seals"
+        ),
+        result_root_provider=lambda: (
+            REPOSITORY_ROOT / ".runtime" / "compute-experiments" / "m48" / "object-quality-results"
+        ),
+        small_static_result_root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "m48"
+            / "small-static-passage-regression-results"
+        ),
+        camera_frame_provider=(
+            session_recorded_camera_frame_service.extract
+            if session_recorded_camera_frame_service is not None
+            else None
+        ),
+        camera_playback_provider=(
+            _m48_recorded_camera_playback_source
+            if session_recorded_camera_frame_service is not None
+            else None
+        ),
+        spatial_evidence_provider=m48_raw_evidence_reader,
+        evaluation_runner=LABORATORY_RUNNER,
+        evaluation_receipt_root_provider=lambda: (
+            REPOSITORY_ROOT
+            / ".runtime"
+            / "compute-experiments"
+            / "laboratory-run-receipts"
+        ),
+    )
+)
 app.include_router(
     build_e47_semantic_slam_router(
         root_provider=lambda: (