feat(perception): integrate calibrated operator pipeline

Add calibrated K1 projection, recorded and near-live perception qualification, unified Rerun operator layers, bounded replay admission, audited viewer controls, worker experiments, and lab evidence.

src/k1link/viewer/metrics.py

@@ -30,6 +30,12 @@ class MetricsSnapshot(TypedDict):
     device_pgo_progress: int | None
     modeling_reports: int
     modeling_decode_errors: int
+    perception_frames: int
+    perception_dropped: int
+    perception_fps: float
+    perception_end_to_end_ms: float | None
+    perception_end_to_end_p95_ms: float | None
+    perception_stale_ms: float | None
 
 
 class BridgeMetrics:
@@ -56,6 +62,11 @@ class BridgeMetrics:
         self._device_pgo_progress: int | None = None
         self._modeling_reports = 0
         self._modeling_decode_errors = 0
+        self._perception_frames = 0
+        self._perception_dropped = 0
+        self._perception_times: deque[int] = deque()
+        self._perception_latencies_ms: deque[float] = deque(maxlen=512)
+        self._perception_last_publish_monotonic_ns: int | None = None
 
     def received(self, payload_bytes: int) -> None:
         with self._lock:
@@ -93,6 +104,26 @@ class BridgeMetrics:
         with self._lock:
             self._preview_dropped += 1
 
+    def perception_dropped(self) -> None:
+        with self._lock:
+            self._perception_dropped += 1
+
+    def published_perception(
+        self,
+        *,
+        captured_at_epoch_ns: int,
+        published_at_epoch_ns: int,
+        published_monotonic_ns: int,
+    ) -> None:
+        latency_ms = (published_at_epoch_ns - captured_at_epoch_ns) / 1_000_000
+        with self._lock:
+            self._perception_frames += 1
+            self._perception_times.append(published_monotonic_ns)
+            _trim_rate_window(self._perception_times, published_monotonic_ns)
+            self._perception_last_publish_monotonic_ns = published_monotonic_ns
+            if math.isfinite(latency_ms) and latency_ms >= 0:
+                self._perception_latencies_ms.append(latency_ms)
+
     def acquisition_telemetry(
         self,
         *,
@@ -125,7 +156,9 @@ class BridgeMetrics:
         with self._lock:
             _trim_rate_window(self._pcl_times, now_ns)
             _trim_rate_window(self._pose_times, now_ns)
+            _trim_rate_window(self._perception_times, now_ns)
             latencies = list(self._latencies_ms)
+            perception_latencies = list(self._perception_latencies_ms)
             last_latency = latencies[-1] if latencies else None
             p50 = statistics.median(latencies) if latencies else None
             p95 = _percentile(latencies, 0.95) if latencies else None
@@ -151,6 +184,22 @@ class BridgeMetrics:
                 "device_pgo_progress": self._device_pgo_progress,
                 "modeling_reports": self._modeling_reports,
                 "modeling_decode_errors": self._modeling_decode_errors,
+                "perception_frames": self._perception_frames,
+                "perception_dropped": self._perception_dropped,
+                "perception_fps": _window_rate(self._perception_times),
+                "perception_end_to_end_ms": _rounded(
+                    perception_latencies[-1] if perception_latencies else None
+                ),
+                "perception_end_to_end_p95_ms": _rounded(
+                    _percentile(perception_latencies, 0.95)
+                    if perception_latencies
+                    else None
+                ),
+                "perception_stale_ms": _rounded(
+                    None
+                    if self._perception_last_publish_monotonic_ns is None
+                    else (now_ns - self._perception_last_publish_monotonic_ns) / 1_000_000
+                ),
             }