feat(perception): qualify bounded temporal stability

src/k1link/compute/__init__.py

@@ -36,7 +36,9 @@ from .jobs import (
 )
 from .lab_instances import (
     PublishedIntegratedLabInstance,
+    PublishedTemporalLabInstance,
     publish_e21_lab_instance,
+    publish_e22_lab_instance,
     publish_integrated_lab_instance,
 )
 from .live_perception import (
@@ -115,6 +117,7 @@ __all__ = [
     "LivePerceptionIngress",
     "IntegratedPerceptionOverlayStore",
     "PublishedIntegratedLabInstance",
+    "PublishedTemporalLabInstance",
     "IntegratedPerceptionResult",
     "LiveReplayQualificationResult",
     "MultiratePerceptionArtifact",
@@ -144,6 +147,7 @@ __all__ = [
     "validate_live_replay_qualification_result",
     "validate_integrated_perception_result",
     "publish_e21_lab_instance",
+    "publish_e22_lab_instance",
     "publish_integrated_lab_instance",
     "validate_multirate_perception_qualification_result",
     "prepare_recorded_qualification_slice",

src/k1link/compute/lab_instances.py

@@ -27,6 +27,10 @@ from .integrated_perception import (
     validate_integrated_perception_result,
 )
 from .jobs import CameraComputeJob, validate_camera_compute_job
+from .temporal_stability import (
+    TemporalStabilityBuild,
+    build_temporal_stability_result,
+)
 
 
 @dataclass(frozen=True, slots=True)
@@ -36,6 +40,14 @@ class PublishedIntegratedLabInstance:
     result: IntegratedPerceptionResult
 
 
+@dataclass(frozen=True, slots=True)
+class PublishedTemporalLabInstance:
+    binding: LabSessionBinding
+    job: CameraComputeJob
+    result: IntegratedPerceptionResult
+    build: TemporalStabilityBuild
+
+
 def publish_integrated_lab_instance(
     *,
     repository_root: Path,
@@ -241,6 +253,114 @@ def publish_e21_lab_instance(
     return PublishedIntegratedLabInstance(binding=binding, job=lab_job, result=validated)
 
 
+def publish_e22_lab_instance(
+    *,
+    repository_root: Path,
+    source_result_root: Path,
+    profile_path: Path,
+    lab_session_id: str,
+    lab_id: str,
+    display_name: str,
+) -> PublishedTemporalLabInstance:
+    """Derive and publish one bounded temporal-stability LAB comparison."""
+
+    root = repository_root.expanduser().resolve(strict=True)
+    jobs_root = root / ".runtime" / "compute-jobs"
+    results_root = root / ".runtime" / "compute-experiments" / "e10" / "worker-results"
+    packs_root = root / ".runtime" / "compute-experiments" / "e10" / "lidar-packs"
+    source_path = source_result_root.expanduser().resolve(strict=True)
+    source_document = _read_object(source_path / "result.json", source_path)
+    identity = source_document.get("identity")
+    if not isinstance(identity, dict) or not isinstance(identity.get("job_id"), str):
+        raise SessionIntegrityError("E22 source has no job identity")
+    source = validate_integrated_perception_result(
+        jobs_root / identity["job_id"],
+        source_path,
+        packs_root,
+    )
+    if not source.accepted:
+        raise SessionIntegrityError("E22 source result is not accepted")
+
+    lab_job = _publish_lab_job(source.job, jobs_root, lab_session_id)
+    lab_pack = _publish_lab_pack(source, lab_job, packs_root, lab_session_id)
+    build = build_temporal_stability_result(
+        source=source,
+        lab_job=lab_job,
+        lab_pack=lab_pack,
+        results_root=results_root,
+        profile_path=profile_path,
+    )
+    validated = validate_integrated_perception_result(
+        lab_job.job_root,
+        build.result_root,
+        packs_root,
+    )
+    if not validated.accepted:
+        failed = [
+            name
+            for name, accepted in build.report["acceptance"]["checks"].items()
+            if not accepted
+        ]
+        raise SessionIntegrityError(
+            f"E22 temporal acceptance failed: {', '.join(failed)}"
+        )
+
+    store = SessionStore(root)
+    source_lab = store.get_lab_instance(source.job.session_id)
+    source_session_id = (
+        source.job.session_id
+        if source_lab is None
+        else source_lab.source_session_id
+    )
+    publish_lab_replay_cache(
+        store.data_dir,
+        source_session_id=source_session_id,
+        lab_session_id=lab_session_id,
+        timeline_start_ns=round(validated.timeline_start_seconds * 1_000_000_000),
+        timeline_end_ns=round(validated.timeline_end_seconds * 1_000_000_000),
+    )
+    metrics = build.report["metrics"]
+    binding = store.publish_lab_instance(
+        session_id=lab_session_id,
+        source_session_id=source_session_id,
+        display_name=display_name,
+        lab_id=lab_id,
+        result_kind="e22-temporal-stability",
+        result_id=validated.result_id,
+        source_result_id=source.result_id,
+        config_sha256=build.profile_sha256,
+        run_created_at_utc=validated.created_at_utc,
+        duration_seconds=(
+            validated.timeline_end_seconds - validated.timeline_start_seconds
+        ),
+        include_recorded_media=False,
+        provenance={
+            "schema_version": "missioncore.e22-lab-publication/v1",
+            "storage_mode": "bounded-derived-replay-and-temporal-projection",
+            "source_result_id": source.result_id,
+            "source_lab_session_id": (
+                None if source_lab is None else source_lab.session_id
+            ),
+            "source_payloads_mutated": False,
+            "lookahead_frames": 0,
+            "peak_track_states": metrics["runtime"]["peak_track_states"],
+            "camera_frame_processing_p95_ms": metrics["runtime"][
+                "camera_frame_processing_ms"
+            ]["p95"],
+            "semantic_frame_processing_p95_ms": metrics["runtime"][
+                "semantic_frame_processing_ms"
+            ]["p95"],
+            "quality_reductions": metrics["reductions"],
+        },
+    )
+    return PublishedTemporalLabInstance(
+        binding=binding,
+        job=lab_job,
+        result=validated,
+        build=build,
+    )
+
+
 def _validate_e21_inputs(
     e21_root: Path,
     worker_root: Path,

src/k1link/device_plugins/xgrids_k1/cli.py

@@ -20,6 +20,7 @@ from k1link.artifacts import write_json_atomic
 from k1link.compute import (
     prepare_camera_compute_job,
     publish_e21_lab_instance,
+    publish_e22_lab_instance,
     publish_integrated_lab_instance,
 )
 from k1link.device_plugins.xgrids_k1.analyze import (
@@ -433,6 +434,69 @@ def publish_e21_lab(
     )
 
 
+@lab_app.command("publish-e22")
+def publish_e22_lab(
+    result: Annotated[
+        Path,
+        typer.Option(
+            exists=True,
+            file_okay=False,
+            readable=True,
+            resolve_path=True,
+            help="Accepted integrated result used as the immutable E22 baseline.",
+        ),
+    ],
+    profile: Annotated[
+        Path,
+        typer.Option(
+            exists=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+            help="Bounded E22 temporal-stability profile.",
+        ),
+    ],
+    session_id: Annotated[
+        str,
+        typer.Option("--session-id", help="New immutable LAB session id."),
+    ],
+    lab_id: Annotated[
+        str,
+        typer.Option("--lab-id", help="LAB marker, for example 'LAB E22'."),
+    ],
+    display_name: Annotated[
+        str,
+        typer.Option("--display-name", help="Operator-facing saved-session title."),
+    ],
+) -> None:
+    """Build and publish a bounded 2D/3D/semantic temporal-stability run."""
+
+    repository_root = Path(__file__).resolve().parents[4]
+    try:
+        published = publish_e22_lab_instance(
+            repository_root=repository_root,
+            source_result_root=result,
+            profile_path=profile,
+            lab_session_id=session_id,
+            lab_id=lab_id,
+            display_name=display_name,
+        )
+    except (OSError, SessionIntegrityError, ValueError) as exc:
+        console.print(f"[red]E22 LAB publication failed:[/red] {exc}")
+        raise typer.Exit(code=2) from exc
+    reductions = published.build.report["metrics"]["reductions"]
+    console.print(
+        "[green]E22 LAB instance published.[/green] "
+        f"session={published.binding.session_id}; "
+        f"source={published.binding.source_session_id}; "
+        f"result={published.binding.result_id}; "
+        f"2d_reduction={reductions['tracking_2d_acceleration_p95_fraction']:.3f}; "
+        f"3d_center_reduction={reductions['cuboid_center_step_p95_fraction']:.3f}; "
+        f"3d_yaw_reduction={reductions['cuboid_yaw_step_p95_fraction']:.3f}; "
+        "source_payloads_mutated=false"
+    )
+
+
 @app.command("serve")
 def serve_console(
     port: Annotated[