Deploy Sensorflow Studio

.gitignore

@@ -65,7 +65,6 @@ temp/
 # Generated runtime/test artifacts
 runs/labeleval/
 runs/megaeval/
-runs/platform/
 runs/pipeline/frame_test/
 runs/pipeline/qg_test/
 runs/pipeline/roundtrip/

app_backend.py

@@ -1467,9 +1467,9 @@ app.include_router(labeleval_router)
 from sensorflow.megaeval.api import router as megaeval_router
 app.include_router(megaeval_router)
 
-# Population-scale foundation (container quality, multi-model compare, multi-gate, evidence).
-from sensorflow.platform.api import router as platform_router
-app.include_router(platform_router)
+# BEV-Fusion perception engine (camera+LiDAR fusion, masklet tracking, self-eval).
+from sensorflow.bevfusion.api import router as bevfusion_router
+app.include_router(bevfusion_router)
 
 # Mount static folder
 static_dir = Path(__file__).parent / "static"

sensorflow/bevfusion/__init__.py

@@ -0,0 +1,53 @@
+"""BEV-Fusion perception engine (inspired by BEVFusion) with masklet-style
+temporal propagation (inspired by SAM 3).
+
+What this package does
+----------------------
+Fuses camera and LiDAR evidence in a unified bird's-eye-view (BEV) plane to
+produce better auto-labels than a single-sensor (camera-primary) labeler, and
+demonstrates the improvement with the platform's own evaluation machinery on
+synthetic scenes with known ground truth.
+
+Concept mapping (paper -> this implementation)
+----------------------------------------------
+BEVFusion:
+    - "Lift camera features to BEV via calibrated geometry"
+        -> :mod:`geometry`: pinhole projection with a 6-DoF camera-to-ego
+           extrinsic; monocular detections are back-projected along the viewing
+           ray into the BEV plane with an anisotropic (along-ray-elongated)
+           position covariance.
+    - "Rasterize LiDAR features into a BEV grid"
+        -> :mod:`fusion`: LiDAR detections are splatted into a metric BEV
+           occupancy/feature grid with tight isotropic covariance.
+    - "Fuse the modality feature maps in the shared BEV space"
+        -> :mod:`fusion.fuse_maps`: per-cell fusion of existence evidence
+           (noisy-OR), class evidence (reliability-weighted histograms; camera
+           weighted higher), and geometry evidence (inverse-variance weighted
+           accumulators; LiDAR dominates position where present).
+    - "Decode fused BEV features into 3D boxes"
+        -> :mod:`fusion.decode_bev`: peak extraction + ray-aware NMS +
+           continuous weighted decoding of center/dims/yaw/class.
+
+SAM 3 masklets:
+    - "Propagate each object's identity through time, surviving brief
+      disappearances without re-identification"
+        -> :mod:`masklet.BEVMaskletTracker`: association in the stable BEV
+           plane (Hungarian on BEV distance + class + size, extending
+           :mod:`sensorflow.temporal_tracker`), with Kalman-predicted BEV
+           position carrying identity across short dropouts and emitting
+           propagated ("masklet") boxes during occlusion gaps.
+
+What is simulated vs. real
+--------------------------
+There are NO learned features and NO neural networks here (the platform is
+numpy-only by design). Camera/LiDAR "detections" are sampled from ground truth
+with realistic, modality-specific failure modes (camera: occlusion/night
+misses and depth ambiguity but good class discrimination; LiDAR: accurate
+geometry, degraded at long range and in rain, weak class discrimination).
+The fusion itself is honest geometric + probabilistic math, and the measured
+improvement arises from real sensor complementarity in that math: LiDAR
+existence evidence recovers camera misses, camera class evidence flows along
+the viewing ray to LiDAR-anchored cells, and inverse-variance weighting gives
+fused boxes near-LiDAR position accuracy. Nothing in the comparison report is
+hardcoded; every number is computed at runtime from the fused outputs.
+"""

sensorflow/bevfusion/api.py

@@ -0,0 +1,69 @@
+"""FastAPI router for the BEV-Fusion perception engine (included by app_backend).
+
+Endpoints:
+    POST /api/bevfusion/run     generate scenes, run both engines, evaluate, persist
+    GET  /api/bevfusion/report  latest comparison report (per-cohort deltas + explanations)
+    GET  /api/bevfusion/status  run inventory + engine identifiers
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from sensorflow.bevfusion import evaluate as evaluate_mod
+from sensorflow.bevfusion.engines import BASELINE_ENGINE, FUSED_ENGINE
+
+router = APIRouter(prefix="/api/bevfusion")
+
+
+class RunRequest(BaseModel):
+    n_sequences: int = Field(6, ge=1, le=24)
+    frames_per_sequence: int = Field(24, ge=8, le=60)
+    seed: int = 7
+
+
+@router.post("/run")
+def run(req: RunRequest):
+    report = evaluate_mod.run_comparison(
+        n_sequences=req.n_sequences,
+        frames_per_sequence=req.frames_per_sequence,
+        seed=req.seed,
+    )
+    return report
+
+
+@router.get("/report")
+def report():
+    rep = evaluate_mod.latest_report()
+    if rep is None:
+        raise HTTPException(404, "No BEV-fusion comparison has been run yet; "
+                                 "POST /api/bevfusion/run first")
+    return rep
+
+
+@router.get("/status")
+def status():
+    runs_dir = evaluate_mod.RUNS_DIR
+    runs = []
+    if runs_dir.exists():
+        for p in sorted(runs_dir.glob("bevrun-*.json")):
+            try:
+                with open(p) as f:
+                    r = json.load(f)
+                runs.append({"run_id": r["run_id"], "created_at": r["created_at"],
+                             "params": r["params"],
+                             "recommendation": r.get("recommendation")})
+            except Exception:
+                continue
+    latest: Optional[dict] = runs[-1] if runs else None
+    return {
+        "engines": {"baseline": BASELINE_ENGINE, "candidate": FUSED_ENGINE},
+        "n_runs": len(runs),
+        "runs": runs,
+        "latest": latest,
+        "ready": latest is not None,
+    }

sensorflow/bevfusion/engines.py

@@ -0,0 +1,120 @@
+"""The two auto-label engines under comparison.
+
+perception-v1-camera (baseline)
+    Camera-primary label generation: monocular detections are lifted to 3D
+    directly (noisy range along the ray, ground-plane z) and associated
+    frame-to-frame with a greedy nearest-neighbour matcher — no motion model,
+    no gap tolerance. Expected weaknesses (all measured, none hardcoded):
+    misses under occlusion and at night, position error growing with range,
+    ID switches/fragmentation whenever detection drops for even one frame or
+    the depth estimate jumps.
+
+perception-v3-bevfusion (candidate)
+    Camera + LiDAR fused in the shared BEV grid (fusion.py), decoded to boxes,
+    then tracked with BEV Hungarian association + masklet propagation
+    (masklet.py). The improvement comes from the fusion math: LiDAR existence
+    recovers camera misses, camera semantics label LiDAR geometry, and
+    inverse-variance weighting gives near-LiDAR position accuracy.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Dict, List
+
+from sensorflow.bevfusion.geometry import BEVGrid
+from sensorflow.bevfusion.fusion import build_modality_map, decode_bev, fuse_maps
+from sensorflow.bevfusion.masklet import BEVMaskletTracker
+from sensorflow.bevfusion.scenes import SceneSequence
+from sensorflow.bevfusion.sensors import (
+    Detection, camera_rng, lidar_rng, simulate_camera, simulate_lidar,
+)
+from sensorflow.schemas.unified_frame import Object3D
+
+BASELINE_ENGINE = "perception-v1-camera"
+FUSED_ENGINE = "perception-v3-bevfusion"
+
+
+class FrameToFrameTracker:
+    """Deliberately naive baseline association: greedy NN against the previous
+    frame only. Any dropout or large position jitter spawns a new identity."""
+
+    def __init__(self, gate: float = 3.0):
+        self.gate = gate
+        self.prev: List[Dict] = []  # [{track_id, x, y}]
+        self.next_id = 1
+
+    def update(self, boxes: List[Dict]) -> List[Dict]:
+        used = set()
+        for box in sorted(boxes, key=lambda b: -b.get("confidence", 0.0)):
+            best, best_d = None, self.gate
+            for i, p in enumerate(self.prev):
+                if i in used:
+                    continue
+                d = math.hypot(box["bbox_3d"][0] - p["x"], box["bbox_3d"][1] - p["y"])
+                if d < best_d:
+                    best, best_d = i, d
+            if best is not None:
+                used.add(best)
+                box["track_id"] = self.prev[best]["track_id"]
+            else:
+                box["track_id"] = self.next_id
+                self.next_id += 1
+        self.prev = [{"track_id": b["track_id"], "x": b["bbox_3d"][0], "y": b["bbox_3d"][1]}
+                     for b in boxes]
+        return boxes
+
+
+def _det_to_box(det: Detection) -> Dict:
+    return {
+        "bbox_3d": [det.x, det.y, det.z, det.dims[0], det.dims[1], det.dims[2], det.yaw],
+        "class_name": det.class_name,
+        "class_confidence": det.class_confidence,
+        "confidence": det.confidence,
+        "propagated": False,
+    }
+
+
+def run_baseline(seq: SceneSequence, seed: int, seq_index: int) -> Dict[str, List[Dict]]:
+    """Camera-only labels per frame. Uses the same camera detections (same rng
+    stream) as the fused engine, so the comparison isolates the fusion."""
+    rng = camera_rng(seed, seq_index)
+    tracker = FrameToFrameTracker(gate=3.0)
+    out: Dict[str, List[Dict]] = {}
+    for frame in seq.frames:
+        boxes = [_det_to_box(d) for d in simulate_camera(frame, seq, rng)]
+        out[frame.frame_id] = tracker.update(boxes)
+    return out
+
+
+def run_fused(seq: SceneSequence, seed: int, seq_index: int,
+              grid: BEVGrid = None):
+    """BEV-fused labels per frame, tracked with masklet propagation."""
+    grid = grid or BEVGrid()
+    cam_gen = camera_rng(seed, seq_index)
+    lid_gen = lidar_rng(seed, seq_index)
+    tracker = BEVMaskletTracker(bounds=(grid.x_min, grid.x_max, grid.y_min, grid.y_max))
+    out: Dict[str, List[Dict]] = {}
+    stats = {"camera_detections": 0, "lidar_detections": 0, "fused_boxes": 0}
+
+    for frame in seq.frames:
+        cam_dets = simulate_camera(frame, seq, cam_gen)
+        lid_dets = simulate_lidar(frame, seq, lid_gen)
+        stats["camera_detections"] += len(cam_dets)
+        stats["lidar_detections"] += len(lid_dets)
+
+        cam_map = build_modality_map(cam_dets, grid, "camera")
+        lid_map = build_modality_map(lid_dets, grid, "lidar")
+        decoded = decode_bev(fuse_maps(cam_map, lid_map))
+        stats["fused_boxes"] += len(decoded)
+
+        proposals = [Object3D(bbox_3d=b["bbox_3d"], class_name=b["class_name"],
+                              confidence=b["confidence"]) for b in decoded]
+        tracked = tracker.update(frame.frame_id, proposals)
+        propagated_ids = getattr(tracker, "last_propagated", set())
+        out[frame.frame_id] = [{
+            "bbox_3d": t.bbox_3d, "class_name": t.class_name,
+            "confidence": t.confidence, "track_id": t.track_id,
+            "propagated": t.track_id in propagated_ids,
+        } for t in tracked]
+    return out, stats

sensorflow/bevfusion/evaluate.py

@@ -0,0 +1,422 @@
+"""Self-evaluation: baseline vs BEV-fused labeler on identical scenes.
+
+Generates N deterministic sequences with known ground truth, runs both
+engines on the *same* sensor detection streams, evaluates both against ground
+truth with the platform's existing metrics (BEV IoU from
+sensorflow.metrics.perception_3d; ID-switch and fragmentation rates from
+sensorflow.metrics.temporal_mot; plus nuScenes-style center-distance matching,
+per-cohort recall, position error and IDF1 computed here), and produces a
+comparison report mirroring the shape of the megaeval compare machinery
+(headline_deltas / per-cohort deltas / policy / blockers / PROMOTE
+recommendation). Every number is computed at runtime from the engine outputs.
+
+Matching is center-distance based (2.0 m, nuScenes convention) rather than
+IoU-thresholded, so the baseline's monocular depth error degrades recall and
+position error smoothly instead of zeroing everything out; BEV IoU is still
+reported for matched pairs.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+from uuid import uuid4
+
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+
+from sensorflow.bevfusion.engines import (
+    BASELINE_ENGINE, FUSED_ENGINE, run_baseline, run_fused,
+)
+from sensorflow.bevfusion.masklet import tracks_to_dicts
+from sensorflow.bevfusion.scenes import (
+    SAFETY_CLASSES, SceneSequence, generate_sequences, gt_tracks,
+)
+from sensorflow.metrics.perception_3d import bev_iou
+from sensorflow.metrics.temporal_mot import (
+    compute_id_swap_rate, compute_track_fragmentation_rate,
+)
+
+RUNS_DIR = Path("runs/bevfusion")
+MATCH_DIST_M = 2.0
+
+DEFAULT_POLICY = {
+    "max_recall_drop": 0.010,
+    "max_precision_drop": 0.015,
+    "max_safety_recall_drop": 0.005,
+    "max_cohort_recall_drop": 0.050,
+    "min_cohort_support": 20,
+}
+
+COHORT_EXPLANATIONS = {
+    "overall": "Fused existence evidence (noisy-OR of camera and LiDAR) plus "
+               "inverse-variance geometry gives higher recall and near-LiDAR "
+               "position accuracy wherever either sensor fires.",
+    "day": "Both sensors healthy: fusion mainly sharpens positions "
+           "(LiDAR-dominated inverse-variance weighting) and suppresses "
+           "single-modality ghosts at the decode threshold.",
+    "night": "The camera misses heavily in low light; LiDAR is unaffected by "
+             "darkness, so LiDAR existence evidence in the BEV grid recovers "
+             "the missed objects and the class comes from LiDAR geometry "
+             "templates or temporal continuity.",
+    "clear": "Nominal conditions; improvement is dominated by monocular depth "
+             "error being replaced by LiDAR geometry.",
+    "rain": "Rain degrades LiDAR at range (spray attenuation) and the camera "
+            "mildly; each modality covers part of the other's losses, so the "
+            "fused map keeps existence evidence where either survives.",
+    "occluded": "Camera line of sight is blocked; LiDAR (mounted higher, "
+                "sensing 3D structure) keeps partial returns, and masklet "
+                "propagation carries identity and a predicted box through the "
+                "remaining gap frames.",
+    "long_range": "Beyond ~45 m LiDAR thins out and monocular depth error "
+                  "exceeds the match gate; fusion helps where LiDAR still "
+                  "fires, and camera bearing keeps existence alive elsewhere.",
+}
+
+
+# ------------------------------------------------------------------ matching
+
+
+def _match_frame(pred_boxes: List[Dict], gt_boxes: List, dist_m: float = MATCH_DIST_M):
+    """Greedy center-distance matching. Returns (pairs, unmatched_pred_idx)."""
+    cands = []
+    for pi, p in enumerate(pred_boxes):
+        for gi, g in enumerate(gt_boxes):
+            d = math.hypot(p["bbox_3d"][0] - g.bbox_3d[0], p["bbox_3d"][1] - g.bbox_3d[1])
+            if d <= dist_m:
+                cands.append((d, pi, gi))
+    cands.sort()
+    used_p, used_g, pairs = set(), set(), []
+    for d, pi, gi in cands:
+        if pi in used_p or gi in used_g:
+            continue
+        pairs.append((pi, gi, d))
+        used_p.add(pi)
+        used_g.add(gi)
+    unmatched_pred = [i for i in range(len(pred_boxes)) if i not in used_p]
+    return pairs, unmatched_pred
+
+
+def _gt_cohorts(gt, seq: SceneSequence) -> List[str]:
+    cohorts = ["overall", seq.time_of_day, seq.weather]
+    if gt.occluded:
+        cohorts.append("occluded")
+    if gt.distance > 40.0:
+        cohorts.append("long_range")
+    return cohorts
+
+
+# ------------------------------------------------------------------ IDF1
+
+
+def compute_idf1(pred_tracks: List[Dict], gt_tracks_list: List[Dict],
+                 dist_m: float = MATCH_DIST_M) -> float:
+    """IDF1 via optimal 1:1 track assignment (Hungarian on frame overlaps)."""
+    if not pred_tracks or not gt_tracks_list:
+        return 0.0
+    n_pred = sum(len(t["frames"]) for t in pred_tracks)
+    n_gt = sum(len(t["frames"]) for t in gt_tracks_list)
+    overlap = np.zeros((len(pred_tracks), len(gt_tracks_list)))
+    for i, pt in enumerate(pred_tracks):
+        pframes = {f["frame_id"]: f["bbox_3d"] for f in pt["frames"]}
+        for j, gt in enumerate(gt_tracks_list):
+            n = 0
+            for f in gt["frames"]:
+                pb = pframes.get(f["frame_id"])
+                if pb is not None and math.hypot(pb[0] - f["bbox_3d"][0],
+                                                 pb[1] - f["bbox_3d"][1]) <= dist_m:
+                    n += 1
+            overlap[i, j] = n
+    rows, cols = linear_sum_assignment(-overlap)
+    idtp = float(overlap[rows, cols].sum())
+    return round(2.0 * idtp / max(n_pred + n_gt, 1), 4)
+
+
+# ------------------------------------------------------------------ engine evaluation
+
+
+def evaluate_engine(sequences: List[SceneSequence],
+                    preds_by_seq: Dict[str, Dict[str, List[Dict]]]) -> Dict:
+    """Evaluate one engine's per-frame labels against ground truth."""
+    cohort_stats: Dict[str, Dict] = {}
+    class_stats: Dict[str, Dict] = {}
+    tp = fp = fn = 0
+    ious: List[float] = []
+    pos_errors: List[float] = []
+    class_correct = class_total = 0
+    safety_tp = safety_fn = 0
+
+    def _coh(name):
+        return cohort_stats.setdefault(name, {"n_gt": 0, "matched": 0,
+                                              "pos_errors": [], "ious": [], "fp": 0})
+
+    for seq in sequences:
+        preds = preds_by_seq[seq.sequence_id]
+        for frame in seq.frames:
+            pred_boxes = preds.get(frame.frame_id, [])
+            pairs, unmatched_pred = _match_frame(pred_boxes, frame.gt)
+            matched_gt = {gi for _, gi, _ in pairs}
+
+            for pi, gi, d in pairs:
+                p, g = pred_boxes[pi], frame.gt[gi]
+                tp += 1
+                iou = bev_iou(p["bbox_3d"], g.bbox_3d)
+                ious.append(iou)
+                pos_errors.append(d)
+                class_total += 1
+                if p["class_name"] == g.class_name:
+                    class_correct += 1
+                if g.class_name in SAFETY_CLASSES:
+                    safety_tp += 1
+                cs = class_stats.setdefault(g.class_name, {"n_gt": 0, "matched": 0})
+                cs["n_gt"] += 1
+                cs["matched"] += 1
+                for name in _gt_cohorts(g, seq):
+                    c = _coh(name)
+                    c["n_gt"] += 1
+                    c["matched"] += 1
+                    c["pos_errors"].append(d)
+                    c["ious"].append(iou)
+
+            for gi, g in enumerate(frame.gt):
+                if gi in matched_gt:
+                    continue
+                fn += 1
+                if g.class_name in SAFETY_CLASSES:
+                    safety_fn += 1
+                class_stats.setdefault(g.class_name, {"n_gt": 0, "matched": 0})["n_gt"] += 1
+                for name in _gt_cohorts(g, seq):
+                    _coh(name)["n_gt"] += 1
+
+            for pi in unmatched_pred:
+                fp += 1
+                _coh("overall")["fp"] += 1
+                _coh(seq.time_of_day)["fp"] += 1
+                _coh(seq.weather)["fp"] += 1
+
+    precision = tp / (tp + fp) if tp + fp else 0.0
+    recall = tp / (tp + fn) if tp + fn else 0.0
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+
+    # Tracking metrics via the platform's temporal MOT module + IDF1.
+    # Track ids restart per sequence (one tracker per sequence), so namespace
+    # them with the sequence id before pooling.
+    pred_tracks: List[Dict] = []
+    for seq in sequences:
+        for t in tracks_to_dicts(preds_by_seq[seq.sequence_id]):
+            t["track_id"] = f"{seq.sequence_id}:{t['track_id']}"
+            pred_tracks.append(t)
+    gts = gt_tracks(sequences)
+    id_switch_rate = compute_id_swap_rate(pred_tracks, gts)
+    frag_rate = compute_track_fragmentation_rate(pred_tracks, gts)
+    idf1 = compute_idf1(pred_tracks, gts)
+
+    cohorts = {}
+    for name, c in cohort_stats.items():
+        cohorts[name] = {
+            "n_gt": c["n_gt"],
+            "recall": round(c["matched"] / c["n_gt"], 4) if c["n_gt"] else None,
+            "position_error_m": round(float(np.mean(c["pos_errors"])), 4) if c["pos_errors"] else None,
+            "mean_iou": round(float(np.mean(c["ious"])), 4) if c["ious"] else None,
+            "false_positives": c["fp"],
+        }
+    per_class = {
+        cls: {"n_gt": s["n_gt"],
+              "recall": round(s["matched"] / s["n_gt"], 4) if s["n_gt"] else None}
+        for cls, s in sorted(class_stats.items())
+    }
+
+    return {
+        "headline": {
+            "precision": round(precision, 4),
+            "recall": round(recall, 4),
+            "f1": round(f1, 4),
+            "mean_iou": round(float(np.mean(ious)), 4) if ious else 0.0,
+            "position_error_m": round(float(np.mean(pos_errors)), 4) if pos_errors else None,
+            "class_accuracy": round(class_correct / class_total, 4) if class_total else None,
+            "safety_recall": round(safety_tp / (safety_tp + safety_fn), 4)
+                             if safety_tp + safety_fn else None,
+            "id_switch_rate": round(id_switch_rate, 4),
+            "fragmentation_rate": round(frag_rate, 4),
+            "idf1": idf1,
+        },
+        "counts": {"tp": tp, "fp": fp, "fn": fn,
+                   "pred_tracks": len(pred_tracks), "gt_tracks": len(gts)},
+        "cohorts": cohorts,
+        "per_class": per_class,
+    }
+
+
+# ------------------------------------------------------------------ comparison report
+
+# Metrics where lower is better.
+_LOWER_IS_BETTER = {"position_error_m", "id_switch_rate", "fragmentation_rate"}
+_HEADLINE_ORDER = ["precision", "recall", "f1", "mean_iou", "position_error_m",
+                   "class_accuracy", "safety_recall", "id_switch_rate",
+                   "fragmentation_rate", "idf1"]
+
+
+def build_comparison(base_eval: Dict, cand_eval: Dict,
+                     policy: Optional[Dict] = None) -> Dict:
+    """Comparison report mirroring the megaeval compare shape
+    (headline_deltas / per-cohort / policy / blockers / recommendation)."""
+    policy = {**DEFAULT_POLICY, **(policy or {})}
+    bh, ch = base_eval["headline"], cand_eval["headline"]
+
+    headline_deltas = []
+    for m in _HEADLINE_ORDER:
+        b, c = bh.get(m), ch.get(m)
+        if b is None or c is None:
+            continue
+        delta = round(c - b, 4)
+        headline_deltas.append({
+            "metric": m, "baseline": b, "candidate": c, "delta": delta,
+            "improved": (delta < 0) if m in _LOWER_IS_BETTER else (delta > 0),
+        })
+
+    per_cohort = []
+    for name, b in base_eval["cohorts"].items():
+        c = cand_eval["cohorts"].get(name)
+        if not c or b["recall"] is None or c["recall"] is None:
+            continue
+        per_cohort.append({
+            "cohort": name,
+            "n_gt": c["n_gt"],
+            "recall_baseline": b["recall"], "recall_candidate": c["recall"],
+            "recall_delta": round(c["recall"] - b["recall"], 4),
+            "position_error_baseline_m": b["position_error_m"],
+            "position_error_candidate_m": c["position_error_m"],
+            "mean_iou_baseline": b["mean_iou"], "mean_iou_candidate": c["mean_iou"],
+            "explanation": COHORT_EXPLANATIONS.get(name, ""),
+        })
+    per_cohort.sort(key=lambda x: x["recall_delta"], reverse=True)
+
+    per_class = []
+    for cls, b in base_eval["per_class"].items():
+        c = cand_eval["per_class"].get(cls)
+        if not c or b["recall"] is None or c["recall"] is None:
+            continue
+        per_class.append({"class": cls, "n_gt": c["n_gt"],
+                          "recall_baseline": b["recall"],
+                          "recall_candidate": c["recall"],
+                          "recall_delta": round(c["recall"] - b["recall"], 4)})
+
+    hd = {h["metric"]: h["delta"] for h in headline_deltas}
+    blockers: List[str] = []
+    if hd.get("recall", 0) < -policy["max_recall_drop"]:
+        blockers.append(f"headline recall dropped {hd['recall']:+.4f}")
+    if hd.get("precision", 0) < -policy["max_precision_drop"]:
+        blockers.append(f"headline precision dropped {hd['precision']:+.4f}")
+    if hd.get("safety_recall", 0) < -policy["max_safety_recall_drop"]:
+        blockers.append(f"safety recall dropped {hd['safety_recall']:+.4f}")
+    for c in per_cohort:
+        if c["n_gt"] >= policy["min_cohort_support"] and \
+                c["recall_delta"] < -policy["max_cohort_recall_drop"]:
+            blockers.append(
+                f"REGRESSION: cohort {c['cohort']} recall "
+                f"{c['recall_baseline']*100:.1f}% -> {c['recall_candidate']*100:.1f}%")
+
+    improvements = [f"{h['metric']}: {h['baseline']} -> {h['candidate']} "
+                    f"({h['delta']:+.4f})" for h in headline_deltas if h["improved"]]
+
+    return {
+        "headline_deltas": headline_deltas,
+        "per_cohort": per_cohort,
+        "per_class": per_class,
+        "policy": policy,
+        "blockers": blockers,
+        "improvements": improvements,
+        "recommendation": "DO_NOT_PROMOTE" if blockers else "PROMOTE",
+    }
+
+
+# ------------------------------------------------------------------ orchestration
+
+
+def run_comparison(n_sequences: int = 6, frames_per_sequence: int = 24,
+                   seed: int = 7, out_dir: Optional[Path] = None,
+                   persist: bool = True) -> Dict:
+    """Generate scenes, run both engines, evaluate both, build + persist report."""
+    sequences = generate_sequences(n_sequences=n_sequences,
+                                   frames_per_sequence=frames_per_sequence, seed=seed)
+
+    baseline_preds: Dict[str, Dict[str, List[Dict]]] = {}
+    fused_preds: Dict[str, Dict[str, List[Dict]]] = {}
+    fusion_stats = {"camera_detections": 0, "lidar_detections": 0, "fused_boxes": 0}
+    for qi, seq in enumerate(sequences):
+        baseline_preds[seq.sequence_id] = run_baseline(seq, seed, qi)
+        fused, stats = run_fused(seq, seed, qi)
+        fused_preds[seq.sequence_id] = fused
+        for k in fusion_stats:
+            fusion_stats[k] += stats[k]
+
+    base_eval = evaluate_engine(sequences, baseline_preds)
+    cand_eval = evaluate_engine(sequences, fused_preds)
+    comparison = build_comparison(base_eval, cand_eval)
+
+    n_frames = sum(len(s.frames) for s in sequences)
+    n_gt = sum(len(f.gt) for s in sequences for f in s.frames)
+    process_units = _record_process_units(fusion_stats, n_frames, n_gt)
+
+    report = {
+        "run_id": f"bevrun-{uuid4().hex[:10]}",
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "params": {"n_sequences": n_sequences,
+                   "frames_per_sequence": frames_per_sequence, "seed": seed},
+        "engines": {"baseline": BASELINE_ENGINE, "candidate": FUSED_ENGINE},
+        "scale": {"frames": n_frames, "gt_boxes": n_gt, **fusion_stats},
+        "baseline": base_eval,
+        "candidate": cand_eval,
+        **comparison,
+        "process_units": process_units,
+        "notes": (
+            "Honest simulation: no learned features; detections are sampled from "
+            "ground truth with modality-specific failure models (camera: occlusion/"
+            "night misses + monocular depth ambiguity, good semantics; LiDAR: "
+            "accurate geometry, range/rain degradation, weak semantics). The "
+            "improvement arises at runtime from geometric+probabilistic fusion in "
+            "the BEV grid and masklet propagation — sensor complementarity is real."
+        ),
+    }
+
+    if persist:
+        out = Path(out_dir) if out_dir else RUNS_DIR
+        out.mkdir(parents=True, exist_ok=True)
+        with open(out / f"{report['run_id']}.json", "w") as f:
+            json.dump(report, f, indent=2)
+        with open(out / "latest.json", "w") as f:
+            json.dump(report, f, indent=2)
+    return report
+
+
+def _record_process_units(fusion_stats: Dict, n_frames: int, n_gt: int) -> Dict:
+    """Record fusion-stage process units via the platform's accounting
+    (best effort: skipped silently if the evaluation store is unavailable)."""
+    units = {}
+    try:
+        from sensorflow.evaluation.process_units import ProcessMeter
+        from sensorflow.evaluation.records import get_store
+        meter = ProcessMeter(get_store(), run_id="bevfusion")
+        units["bev_camera_projection"] = meter.record(
+            "bev_camera_projection", fusion_stats["camera_detections"], factor=0.2)
+        units["bev_lidar_rasterization"] = meter.record(
+            "bev_lidar_rasterization", fusion_stats["lidar_detections"], factor=0.2)
+        units["bev_fusion"] = meter.record("bev_fusion", n_frames, factor=0.8)
+        units["masklet_tracking"] = meter.record(
+            "masklet_tracking", fusion_stats["fused_boxes"], factor=0.3)
+        units["label_evaluation"] = meter.record("label_evaluation", n_gt, factor=0.5)
+        units["total"] = sum(units.values())
+    except Exception:
+        units = {"total": 0, "note": "process accounting unavailable"}
+    return units
+
+
+def latest_report(out_dir: Optional[Path] = None) -> Optional[Dict]:
+    path = (Path(out_dir) if out_dir else RUNS_DIR) / "latest.json"
+    if not path.exists():
+        return None
+    with open(path) as f:
+        return json.load(f)

sensorflow/bevfusion/fusion.py

@@ -0,0 +1,275 @@
+"""BEV rasterization, per-cell modality fusion, and box decoding.
+
+This is the numpy analogue of BEVFusion's shared-BEV-space fusion:
+
+1. Each modality's detections are splatted into a metric BEV feature map
+   (:class:`ModalityBEV`) as Gaussian evidence. The splat covariance is the
+   detection's position covariance (floored at the cell size for existence so
+   tight LiDAR kernels are not lost between cell centers). Three kinds of
+   evidence are accumulated per cell:
+
+   - existence: noisy-OR of (confidence x kernel) — "is something here?";
+   - geometry: inverse-variance weighted votes for the detection's continuous
+     mean/dims/yaw (weight = confidence x kernel / worst-axis variance), so
+     LiDAR dominates position wherever it has evidence and there is no grid
+     quantization in the decoded centers;
+   - class: reliability-weighted class histograms. Camera class evidence is
+     splatted with an inflated along-ray kernel: monocular semantics is
+     positionally vague along the ray, which is precisely what lets a camera
+     label flow to the LiDAR-anchored cell of the same object even when the
+     camera's depth estimate is metres off.
+
+2. :func:`fuse_maps` fuses per cell: noisy-OR for existence, summed
+   inverse-variance geometry accumulators, summed weighted class histograms
+   (camera weight 1.0 vs LiDAR 0.35 — camera is the semantics expert).
+
+3. :func:`decode_bev` extracts local existence maxima above a threshold,
+   applies euclidean NMS plus ray-aware NMS (two peaks on the same bearing
+   within the monocular depth-ambiguity band are one object — the fused,
+   LiDAR-anchored peak wins over the camera's displaced ghost), then decodes
+   each surviving peak's neighbourhood into a 3D box with class + confidence.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+import numpy as np
+from scipy.ndimage import maximum_filter
+
+from sensorflow.bevfusion.geometry import BEVGrid
+from sensorflow.bevfusion.scenes import CLASSES
+from sensorflow.bevfusion.sensors import Detection
+
+CLASS_INDEX = {c: i for i, c in enumerate(CLASSES)}
+
+# Modality reliability weights for class evidence (camera >> lidar).
+CLASS_WEIGHT = {"camera": 1.0, "lidar": 0.35}
+# Camera class evidence is smeared further along the ray (see module docstring).
+CAMERA_CLASS_SIGMA_SCALE = 2.0
+
+
+@dataclass
+class ModalityBEV:
+    """Per-modality BEV feature map built by splatting detections."""
+
+    grid: BEVGrid
+    modality: str = "camera"
+    miss: np.ndarray = field(default=None)          # prod(1 - c*g): existence complement
+    sum_w: np.ndarray = field(default=None)
+    sum_wx: np.ndarray = field(default=None)
+    sum_wy: np.ndarray = field(default=None)
+    sum_wz: np.ndarray = field(default=None)
+    sum_wl: np.ndarray = field(default=None)
+    sum_ww: np.ndarray = field(default=None)
+    sum_wh: np.ndarray = field(default=None)
+    sum_wsin: np.ndarray = field(default=None)
+    sum_wcos: np.ndarray = field(default=None)
+    class_hist: np.ndarray = field(default=None)    # (nx, ny, n_classes)
+
+    def __post_init__(self):
+        nx, ny = self.grid.nx, self.grid.ny
+        self.miss = np.ones((nx, ny))
+        for name in ("sum_w", "sum_wx", "sum_wy", "sum_wz", "sum_wl", "sum_ww",
+                     "sum_wh", "sum_wsin", "sum_wcos"):
+            setattr(self, name, np.zeros((nx, ny)))
+        self.class_hist = np.zeros((nx, ny, len(CLASSES)))
+
+    @property
+    def existence(self) -> np.ndarray:
+        return 1.0 - self.miss
+
+    # -- splatting
+
+    def _window(self, mx: float, my: float, ex: float, ey: float):
+        g = self.grid
+        ix0 = max(0, int((mx - ex - g.x_min) / g.cell))
+        ix1 = min(g.nx, int((mx + ex - g.x_min) / g.cell) + 1)
+        iy0 = max(0, int((my - ey - g.y_min) / g.cell))
+        iy1 = min(g.ny, int((my + ey - g.y_min) / g.cell) + 1)
+        if ix0 >= ix1 or iy0 >= iy1:
+            return None
+        xs = g.x_min + (np.arange(ix0, ix1) + 0.5) * g.cell
+        ys = g.y_min + (np.arange(iy0, iy1) + 0.5) * g.cell
+        X, Y = np.meshgrid(xs, ys, indexing="ij")
+        return (slice(ix0, ix1), slice(iy0, iy1)), X - mx, Y - my
+
+    @staticmethod
+    def _kernel(dx: np.ndarray, dy: np.ndarray, cov: np.ndarray) -> np.ndarray:
+        inv = np.linalg.inv(cov)
+        q = inv[0, 0] * dx * dx + (inv[0, 1] + inv[1, 0]) * dx * dy + inv[1, 1] * dy * dy
+        return np.exp(-0.5 * q)
+
+    def splat(self, det: Detection) -> None:
+        cov = np.array(det.cov, dtype=float)
+        # Floor the existence/geometry kernel at ~the cell size so tight LiDAR
+        # Gaussians are not lost between cell centers (grid smoothing only:
+        # geometry votes still use the true covariance for their weights).
+        floor = (0.8 * self.grid.cell) ** 2
+        cov_splat = cov + np.eye(2) * floor
+        ex = 3.0 * math.sqrt(cov_splat[0, 0])
+        ey = 3.0 * math.sqrt(cov_splat[1, 1])
+        win = self._window(det.x, det.y, ex, ey)
+        if win is None:
+            return
+        sl, dx, dy = win
+        g = self._kernel(dx, dy, cov_splat)
+
+        # Existence: noisy-OR accumulation.
+        self.miss[sl] *= (1.0 - det.confidence * g)
+
+        # Geometry: inverse-variance weighted votes for the *continuous* mean.
+        # The kernel is normalized to unit mass so each detection contributes
+        # exactly one measurement of total weight conf/sigma_eff^2 no matter
+        # how widely its kernel is spread — proper inverse-variance fusion.
+        eigvals = np.linalg.eigvalsh(cov)
+        sigma_eff_sq = float(max(eigvals[-1], 1e-4))  # worst-axis variance
+        g_mass = float(g.sum())
+        if g_mass <= 1e-12:
+            return
+        w = det.confidence * (g / g_mass) / sigma_eff_sq
+        self.sum_w[sl] += w
+        self.sum_wx[sl] += w * det.x
+        self.sum_wy[sl] += w * det.y
+        self.sum_wz[sl] += w * det.z
+        self.sum_wl[sl] += w * det.dims[0]
+        self.sum_ww[sl] += w * det.dims[1]
+        self.sum_wh[sl] += w * det.dims[2]
+        self.sum_wsin[sl] += w * math.sin(det.yaw)
+        self.sum_wcos[sl] += w * math.cos(det.yaw)
+
+        # Class: reliability-weighted histogram; camera semantics smeared
+        # further along the ray so labels reach the LiDAR-anchored cell.
+        cls_idx = CLASS_INDEX.get(det.class_name)
+        if cls_idx is None:
+            return
+        if self.modality == "camera":
+            cov_cls = cov * (CAMERA_CLASS_SIGMA_SCALE ** 2) + np.eye(2) * floor
+        else:
+            cov_cls = cov * 4.0 + np.eye(2) * floor
+        exc = 3.0 * math.sqrt(cov_cls[0, 0])
+        eyc = 3.0 * math.sqrt(cov_cls[1, 1])
+        winc = self._window(det.x, det.y, exc, eyc)
+        if winc is None:
+            return
+        slc, dxc, dyc = winc
+        gc = self._kernel(dxc, dyc, cov_cls)
+        wc = det.confidence * det.class_confidence * CLASS_WEIGHT.get(self.modality, 0.5)
+        self.class_hist[slc[0], slc[1], cls_idx] += wc * gc
+
+
+def build_modality_map(dets: List[Detection], grid: BEVGrid, modality: str) -> ModalityBEV:
+    bev = ModalityBEV(grid=grid, modality=modality)
+    for det in dets:
+        if det.modality == modality:
+            bev.splat(det)
+    return bev
+
+
+@dataclass
+class FusedBEV:
+    grid: BEVGrid
+    existence: np.ndarray
+    sum_w: np.ndarray
+    sum_wx: np.ndarray
+    sum_wy: np.ndarray
+    sum_wz: np.ndarray
+    sum_wl: np.ndarray
+    sum_ww: np.ndarray
+    sum_wh: np.ndarray
+    sum_wsin: np.ndarray
+    sum_wcos: np.ndarray
+    class_hist: np.ndarray
+
+
+def fuse_maps(cam: ModalityBEV, lidar: ModalityBEV) -> FusedBEV:
+    """Per-cell confidence-weighted fusion of the two modality feature maps."""
+    return FusedBEV(
+        grid=cam.grid,
+        existence=1.0 - cam.miss * lidar.miss,  # noisy-OR across modalities
+        sum_w=cam.sum_w + lidar.sum_w,
+        sum_wx=cam.sum_wx + lidar.sum_wx,
+        sum_wy=cam.sum_wy + lidar.sum_wy,
+        sum_wz=cam.sum_wz + lidar.sum_wz,
+        sum_wl=cam.sum_wl + lidar.sum_wl,
+        sum_ww=cam.sum_ww + lidar.sum_ww,
+        sum_wh=cam.sum_wh + lidar.sum_wh,
+        sum_wsin=cam.sum_wsin + lidar.sum_wsin,
+        sum_wcos=cam.sum_wcos + lidar.sum_wcos,
+        class_hist=cam.class_hist + lidar.class_hist,
+    )
+
+
+def decode_bev(fused: FusedBEV, threshold: float = 0.30,
+               nms_radius_m: float = 2.0, gather_radius_m: float = 2.0,
+               ray_nms_bearing_deg: float = 1.5,
+               ray_nms_range_m: float = 6.0) -> List[Dict]:
+    """Decode fused BEV cells into 3D boxes with class + confidence."""
+    grid = fused.grid
+    e = fused.existence
+    local_max = (e >= maximum_filter(e, size=5)) & (e >= threshold)
+    ixs, iys = np.nonzero(local_max)
+    if ixs.size == 0:
+        return []
+    order = np.argsort(-e[ixs, iys])
+    peaks = [(int(ixs[i]), int(iys[i])) for i in order]
+
+    accepted: List[Dict] = []
+    gather_cells = max(1, int(round(gather_radius_m / grid.cell)))
+    for ix, iy in peaks:
+        cx, cy = grid.center(ix, iy)
+        suppress = False
+        for box in accepted:
+            bx, by = box["_peak_xy"]
+            if math.hypot(cx - bx, cy - by) < nms_radius_m:
+                suppress = True
+                break
+            # Ray-aware NMS: same bearing, within the monocular depth
+            # ambiguity band -> the weaker peak is the camera's range ghost.
+            db = abs(math.atan2(cy, cx) - math.atan2(by, bx))
+            db = min(db, 2 * math.pi - db)
+            if math.degrees(db) < ray_nms_bearing_deg and \
+                    abs(math.hypot(cx, cy) - math.hypot(bx, by)) < ray_nms_range_m:
+                suppress = True
+                break
+        if suppress:
+            continue
+
+        x0, x1 = max(0, ix - gather_cells), min(grid.nx, ix + gather_cells + 1)
+        y0, y1 = max(0, iy - gather_cells), min(grid.ny, iy + gather_cells + 1)
+        sl = (slice(x0, x1), slice(y0, y1))
+        w = float(fused.sum_w[sl].sum())
+        if w <= 1e-9:
+            continue
+        x = float(fused.sum_wx[sl].sum() / w)
+        y = float(fused.sum_wy[sl].sum() / w)
+        z = float(fused.sum_wz[sl].sum() / w)
+        l = float(fused.sum_wl[sl].sum() / w)
+        wd = float(fused.sum_ww[sl].sum() / w)
+        h = float(fused.sum_wh[sl].sum() / w)
+        yaw = float(math.atan2(fused.sum_wsin[sl].sum(), fused.sum_wcos[sl].sum()))
+        hist = fused.class_hist[sl].sum(axis=(0, 1))
+        hist_total = float(hist.sum())
+        cls_idx = int(np.argmax(hist)) if hist_total > 0 else 0
+        accepted.append({
+            "bbox_3d": [x, y, z, l, wd, h, yaw],
+            "class_name": CLASSES[cls_idx],
+            "class_confidence": round(float(hist[cls_idx] / hist_total), 4) if hist_total > 0 else 0.0,
+            "confidence": round(float(e[ix, iy]), 4),
+            "_peak_xy": (cx, cy),
+        })
+
+    for box in accepted:
+        box.pop("_peak_xy", None)
+    return accepted
+
+
+def fuse_frame(camera_dets: List[Detection], lidar_dets: List[Detection],
+               grid: Optional[BEVGrid] = None, threshold: float = 0.30) -> List[Dict]:
+    """Convenience: full rasterize -> fuse -> decode for one frame."""
+    grid = grid or BEVGrid()
+    cam_map = build_modality_map(camera_dets, grid, "camera")
+    lidar_map = build_modality_map(lidar_dets, grid, "lidar")
+    return decode_bev(fuse_maps(cam_map, lidar_map), threshold=threshold)

sensorflow/bevfusion/geometry.py

@@ -0,0 +1,108 @@
+"""Calibrated camera geometry + metric BEV grid.
+
+Coordinate conventions (matching the rest of the platform, e.g.
+sensorflow/evaluation/synthetic.py): ego frame has x forward (m), y left (m),
+z up (m), ground plane at z=0.
+
+The camera uses the standard optical convention (z forward, x right, y down);
+`make_camera_extrinsic` builds the 6-DoF camera-to-ego transform, mirroring
+the Calibration.camera_to_ego 4x4 matrices in
+sensorflow/schemas/unified_frame.py.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import numpy as np
+
+# Default intrinsics, consistent with the existing synthetic generator
+# (sensorflow/evaluation/synthetic.py: CAM_W, CAM_H, CAM_F).
+CAM_W, CAM_H, CAM_F = 800, 450, 500.0
+
+
+def make_intrinsics(fx: float = CAM_F, fy: float = CAM_F,
+                    cx: float = CAM_W / 2, cy: float = CAM_H / 2) -> np.ndarray:
+    return np.array([[fx, 0.0, cx], [0.0, fy, cy], [0.0, 0.0, 1.0]])
+
+
+def make_camera_extrinsic(tx: float = 0.2, ty: float = 0.0, tz: float = 1.5,
+                          yaw: float = 0.0) -> np.ndarray:
+    """4x4 camera-to-ego transform for a forward-looking camera.
+
+    Camera axes expressed in the ego frame (before yaw): optical axis
+    z_cam -> +x_ego, x_cam (image right) -> -y_ego, y_cam (image down) -> -z_ego.
+    """
+    base = np.array([
+        [0.0, 0.0, 1.0],   # ego x row: from cam z
+        [-1.0, 0.0, 0.0],  # ego y row: from -cam x
+        [0.0, -1.0, 0.0],  # ego z row: from -cam y
+    ])
+    c, s = math.cos(yaw), math.sin(yaw)
+    rz = np.array([[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]])
+    T = np.eye(4)
+    T[:3, :3] = rz @ base
+    T[:3, 3] = [tx, ty, tz]
+    return T
+
+
+def project_to_image(point_ego: np.ndarray, cam_to_ego: np.ndarray,
+                     K: np.ndarray) -> Optional[Tuple[float, float, float]]:
+    """Ego-frame point -> (u, v, range). None if behind the camera."""
+    R, t = cam_to_ego[:3, :3], cam_to_ego[:3, 3]
+    p_cam = R.T @ (np.asarray(point_ego, dtype=float) - t)
+    if p_cam[2] < 0.5:  # behind or too close to the optical center
+        return None
+    u = K[0, 0] * p_cam[0] / p_cam[2] + K[0, 2]
+    v = K[1, 1] * p_cam[1] / p_cam[2] + K[1, 2]
+    rng = float(np.linalg.norm(p_cam))
+    return float(u), float(v), rng
+
+
+def backproject(u: float, v: float, range_est: float, cam_to_ego: np.ndarray,
+                K: np.ndarray) -> np.ndarray:
+    """Pixel + estimated range along the viewing ray -> ego-frame 3D point.
+
+    This is the monocular "lift" step: the bearing (pixel) is precise, the
+    range is whatever the depth estimate says — hence the along-ray
+    uncertainty that the BEV fusion exploits.
+    """
+    d_cam = np.array([(u - K[0, 2]) / K[0, 0], (v - K[1, 2]) / K[1, 1], 1.0])
+    d_cam /= np.linalg.norm(d_cam)
+    R, t = cam_to_ego[:3, :3], cam_to_ego[:3, 3]
+    return R @ (d_cam * range_est) + t
+
+
+@dataclass(frozen=True)
+class BEVGrid:
+    """Metric BEV grid over the ego frame (x forward, y left)."""
+
+    x_min: float = 0.0
+    x_max: float = 80.0
+    y_min: float = -25.0
+    y_max: float = 25.0
+    cell: float = 0.5
+
+    @property
+    def nx(self) -> int:
+        return int(round((self.x_max - self.x_min) / self.cell))
+
+    @property
+    def ny(self) -> int:
+        return int(round((self.y_max - self.y_min) / self.cell))
+
+    def index(self, x: float, y: float) -> Optional[Tuple[int, int]]:
+        ix = int((x - self.x_min) / self.cell)
+        iy = int((y - self.y_min) / self.cell)
+        if 0 <= ix < self.nx and 0 <= iy < self.ny:
+            return ix, iy
+        return None
+
+    def center(self, ix: int, iy: int) -> Tuple[float, float]:
+        return (self.x_min + (ix + 0.5) * self.cell,
+                self.y_min + (iy + 0.5) * self.cell)
+
+    def contains(self, x: float, y: float) -> bool:
+        return self.x_min <= x < self.x_max and self.y_min <= y < self.y_max

sensorflow/bevfusion/masklet.py

@@ -0,0 +1,150 @@
+"""Masklet-style temporal propagation with BEV association.
+
+Extends the platform's :class:`sensorflow.temporal_tracker.TemporalTracker`
+(Kalman + Hungarian) with the two ideas this feature needs, mapping to SAM 3's
+masklet propagation:
+
+- association happens in the stable metric BEV plane with a richer cost:
+  BEV center distance + class-mismatch penalty + size-difference penalty
+  (fused boxes have reliable LiDAR geometry, so size/class gating is safe);
+- masklet propagation: a track whose object briefly disappears (e.g. a 2-3
+  frame camera occlusion that LiDAR also partially loses) keeps its identity
+  alive via the Kalman-predicted BEV position and *emits propagated boxes*
+  for the gap frames (confidence-decayed, flagged ``propagated``), so brief
+  dropouts are bridged without spawning new IDs and without fragmenting the
+  track — the direct analogue of a masklet being carried through frames where
+  the object is not re-detected.
+
+The baseline camera labeler deliberately uses frame-to-frame greedy
+association with no motion model and no gap tolerance (see engines.py), which
+is what makes ID switches and fragmentation measurable.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+from sensorflow.schemas.unified_frame import Object3D
+from sensorflow.temporal_tracker import TemporalTracker
+
+
+class BEVMaskletTracker(TemporalTracker):
+    """BEV Hungarian association + masklet propagation across dropouts."""
+
+    def __init__(self, max_age: int = 6, distance_gate: float = 4.0,
+                 propagate_max: int = 3, min_hits_to_propagate: int = 2,
+                 class_penalty: float = 1.5, size_penalty: float = 0.3,
+                 dt: float = 0.1,
+                 bounds: Tuple[float, float, float, float] = (0.0, 80.0, -25.0, 25.0)):
+        super().__init__(max_age=max_age, distance_gate=distance_gate)
+        self.dt = dt
+        self.propagate_max = propagate_max
+        self.min_hits_to_propagate = min_hits_to_propagate
+        self.class_penalty = class_penalty
+        self.size_penalty = size_penalty
+        self.bounds = bounds
+
+    # -- association: BEV distance + class + size (replaces the parent cost)
+
+    def _associate(self, proposals: List[Object3D]) -> List[Tuple[int, int]]:
+        from scipy.optimize import linear_sum_assignment
+
+        track_ids = list(self.tracks.keys())
+        cost = np.full((len(track_ids), len(proposals)), 1e6)
+        for ti, tid in enumerate(track_ids):
+            track = self.tracks[tid]
+            last_dims = track.history[-1]["bbox_3d"][3:6] if track.history else [4.5, 1.9, 1.6]
+            for pi, prop in enumerate(proposals):
+                dist = math.hypot(track.state[0] - prop.bbox_3d[0],
+                                  track.state[1] - prop.bbox_3d[1])
+                if dist >= self.distance_gate:
+                    continue
+                c = dist
+                if track.class_name != prop.class_name:
+                    c += self.class_penalty
+                c += self.size_penalty * (abs(last_dims[0] - prop.bbox_3d[3])
+                                          + abs(last_dims[1] - prop.bbox_3d[4]))
+                cost[ti, pi] = c
+
+        row_ind, col_ind = linear_sum_assignment(cost)
+        return [(track_ids[r], c) for r, c in zip(row_ind, col_ind)
+                if cost[r, c] < 1e6]
+
+    # -- update with masklet propagation
+
+    def update(self, frame_id: str, proposals: List[Object3D]) -> List[Object3D]:
+        out = super().update(frame_id, proposals)
+        self.last_propagated: set = set()
+
+        # The parent Kalman observes position only, so its velocity estimate
+        # converges too slowly to bridge gaps for fast objects. Blend in a
+        # finite-difference velocity from the last two *real* measurements
+        # (SORT-style), which the constant-velocity prediction then carries
+        # through occlusion gaps.
+        for track in self.tracks.values():
+            if track.missed_frames != 0:
+                continue  # not matched this frame
+            real_idx = [i for i, h in enumerate(track.history) if not h.get("propagated")]
+            if len(real_idx) >= 2:
+                i1, i0 = real_idx[-1], real_idx[-2]
+                span = max(i1 - i0, 1)  # frames elapsed (propagated entries fill gaps)
+                dx = track.history[i1]["bbox_3d"][0] - track.history[i0]["bbox_3d"][0]
+                dy = track.history[i1]["bbox_3d"][1] - track.history[i0]["bbox_3d"][1]
+                v_meas = np.array([dx, dy]) / (span * self.dt)
+                track.state[2:4] = 0.5 * track.state[2:4] + 0.5 * v_meas
+
+        # Track-level class voting: identity persistence lets high-confidence
+        # camera semantics (or the modal LiDAR template guess) stabilize the
+        # per-frame class of every box the track emits.
+        if not hasattr(self, "_class_votes"):
+            self._class_votes: Dict[int, Dict[str, float]] = {}
+        for prop in out:
+            votes = self._class_votes.setdefault(prop.track_id, {})
+            votes[prop.class_name] = votes.get(prop.class_name, 0.0) + prop.confidence
+            best = max(votes, key=votes.get)
+            prop.class_name = best
+            if prop.track_id in self.tracks:
+                self.tracks[prop.track_id].class_name = best
+
+        for track in self.tracks.values():
+            if track.missed_frames == 0 or not track.history:
+                continue  # matched (or spawned) this frame
+            if not (1 <= track.missed_frames <= self.propagate_max):
+                continue
+            real_hits = sum(1 for h in track.history if not h.get("propagated"))
+            if real_hits < self.min_hits_to_propagate:
+                continue
+            px, py = float(track.state[0]), float(track.state[1])
+            x0, x1, y0, y1 = self.bounds
+            if not (x0 <= px < x1 and y0 <= py < y1):
+                continue  # object likely left the field of view: do not hallucinate
+            last_box = track.history[-1]["bbox_3d"]
+            bbox = [px, py, last_box[2], last_box[3], last_box[4], last_box[5], last_box[6]]
+            conf = round(track.confidence * (0.8 ** track.missed_frames), 4)
+            track.history.append({
+                "frame_id": frame_id, "bbox_3d": bbox,
+                "confidence": conf, "propagated": True,
+            })
+            prop = Object3D(bbox_3d=bbox, class_name=track.class_name,
+                            confidence=conf, track_id=track.track_id)
+            self.last_propagated.add(track.track_id)
+            out.append(prop)
+        return out
+
+
+def tracks_to_dicts(per_frame: Dict[str, List[Dict]]) -> List[Dict]:
+    """Group per-frame labeled boxes (with track_id) into MOT-shaped tracks."""
+    tracks: Dict[object, Dict] = {}
+    for frame_id in sorted(per_frame.keys()):
+        for box in per_frame[frame_id]:
+            tid = box.get("track_id")
+            if tid is None:
+                continue
+            entry = tracks.setdefault(tid, {"track_id": tid,
+                                            "class_name": box.get("class_name", "unknown"),
+                                            "frames": []})
+            entry["frames"].append({"frame_id": frame_id, "bbox_3d": box["bbox_3d"]})
+    return list(tracks.values())

sensorflow/bevfusion/scenes.py

@@ -0,0 +1,132 @@
+"""Deterministic synthetic multi-sensor scenes with known 3D ground truth.
+
+Mirrors the conventions of the existing evaluation generator
+(sensorflow/evaluation/synthetic.py: ego drives +x at 10 m/s, objects have
+world-frame kinematics, class dimensions from CLASS_DIMS) but is purpose-built
+for the sensor-simulation study: every ground-truth box carries a per-frame
+camera-occlusion flag (planted contiguous occlusion windows) so that both
+sensor simulators and the cohort evaluation can reason about occlusion.
+
+Conditions cycle deterministically across sequences (day/clear, night/clear,
+day/rain) so every cohort is well represented at any n_sequences >= 3.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import List
+
+import numpy as np
+from pydantic import BaseModel, Field
+
+# Reuse the platform's class dimension priors rather than duplicating them.
+from sensorflow.evaluation.synthetic import CLASS_DIMS, CLASS_POOL
+
+CLASSES = list(CLASS_DIMS.keys())
+SAFETY_CLASSES = {"pedestrian", "cyclist", "motorcycle"}
+
+DT = 0.1
+EGO_SPEED = 10.0
+
+
+class GTBox(BaseModel):
+    instance_id: str
+    class_name: str
+    bbox_3d: List[float]  # [x, y, z, l, w, h, yaw] ego frame
+    occluded: bool = False  # camera line-of-sight blocked this frame
+    distance: float = 0.0
+
+
+class SceneFrame(BaseModel):
+    frame_id: str
+    index: int
+    gt: List[GTBox] = Field(default_factory=list)
+
+
+class SceneSequence(BaseModel):
+    sequence_id: str
+    time_of_day: str = "day"    # day | night
+    weather: str = "clear"      # clear | rain
+    frames: List[SceneFrame] = Field(default_factory=list)
+
+
+def generate_sequences(n_sequences: int = 6, frames_per_sequence: int = 24,
+                       seed: int = 7) -> List[SceneSequence]:
+    """Generate deterministic sequences with planted camera-occlusion windows."""
+    sequences: List[SceneSequence] = []
+    for qi in range(n_sequences):
+        rng = np.random.default_rng(seed * 100003 + qi * 7919)
+        time_of_day = "night" if qi % 3 == 1 else "day"
+        weather = "rain" if qi % 3 == 2 else "clear"
+        seq = SceneSequence(sequence_id=f"bev-seq-{seed}-{qi}",
+                            time_of_day=time_of_day, weather=weather)
+
+        num_objects = int(rng.integers(7, 11))
+        objects = []
+        for oi in range(num_objects):
+            cls = CLASS_POOL[int(rng.integers(0, len(CLASS_POOL)))]
+            l, w, h = CLASS_DIMS[cls]
+            # Rejection-sample spawn positions so objects start >= 5 m apart
+            # (keeps BEV peaks separable; documented decode limitation).
+            for _ in range(30):
+                x0 = float(rng.uniform(10, 68))
+                y0 = float(rng.uniform(-13, 13))
+                if all(math.hypot(x0 - o["x"], y0 - o["y"]) >= 5.0 for o in objects):
+                    break
+            heading = (float(rng.uniform(-math.pi, math.pi)) if cls == "pedestrian"
+                       else float(rng.choice([0.0, math.pi, math.pi / 2, -math.pi / 2])))
+            speed = {"pedestrian": 1.4, "cyclist": 4.5, "motorcycle": 9.0,
+                     "vehicle": 8.0, "truck": 7.0}[cls] * float(rng.uniform(0.6, 1.2))
+            objects.append({
+                "iid": f"{seq.sequence_id}-obj-{oi}", "cls": cls, "dims": (l, w, h),
+                "x": x0, "y": y0,
+                "vx": speed * math.cos(heading), "vy": speed * math.sin(heading),
+                "yaw": heading,
+            })
+
+        # Plant camera-occlusion windows: 2 objects per sequence lose camera
+        # line of sight for a contiguous 2-3 frame window mid-sequence.
+        occlusion = {}
+        if objects and frames_per_sequence >= 10:
+            occluded_idx = rng.choice(len(objects), size=min(2, len(objects)), replace=False)
+            for k, oi in enumerate(occluded_idx):
+                start = int(rng.integers(4, max(5, frames_per_sequence - 6)))
+                length = int(rng.integers(2, 4))
+                occlusion[objects[int(oi)]["iid"]] = (start, start + length)
+
+        for fi in range(frames_per_sequence):
+            ego_x = EGO_SPEED * DT * fi
+            frame = SceneFrame(frame_id=f"{seq.sequence_id}-f{fi:04d}", index=fi)
+            for obj in objects:
+                wx = obj["x"] + obj["vx"] * DT * fi
+                wy = obj["y"] + obj["vy"] * DT * fi
+                rel_x, rel_y = wx - ego_x, wy
+                if rel_x < 3.0 or rel_x > 78.0 or abs(rel_y) > 22.0:
+                    continue
+                l, w, h = obj["dims"]
+                win = occlusion.get(obj["iid"])
+                frame.gt.append(GTBox(
+                    instance_id=obj["iid"],
+                    class_name=obj["cls"],
+                    bbox_3d=[round(rel_x, 3), round(rel_y, 3), round(h / 2, 3),
+                             l, w, h, round(obj["yaw"], 4)],
+                    occluded=bool(win and win[0] <= fi < win[1]),
+                    distance=round(math.hypot(rel_x, rel_y), 3),
+                ))
+            seq.frames.append(frame)
+        sequences.append(seq)
+    return sequences
+
+
+def gt_tracks(sequences: List[SceneSequence]) -> List[dict]:
+    """Ground-truth tracks in the shape expected by sensorflow.metrics.temporal_mot."""
+    by_instance: dict = {}
+    for seq in sequences:
+        for frame in seq.frames:
+            for gt in frame.gt:
+                entry = by_instance.setdefault(
+                    gt.instance_id,
+                    {"instance_id": gt.instance_id, "track_id": gt.instance_id,
+                     "class_name": gt.class_name, "frames": []})
+                entry["frames"].append({"frame_id": frame.frame_id, "bbox_3d": gt.bbox_3d})
+    return list(by_instance.values())

sensorflow/bevfusion/sensors.py

@@ -0,0 +1,225 @@
+"""Camera and LiDAR detection simulators with modality-specific failure modes.
+
+These stand in for the learned detection backbones of a real BEVFusion stack.
+Detections are sampled from ground truth with honest, physically motivated
+error models — the complementarity that the fusion exploits is real:
+
+Camera ("perception-v1-camera" front end):
+    - misses under occlusion (line of sight blocked), at night (with a
+      distance ramp: dark + small pixels), lightly in rain;
+    - monocular depth ambiguity: range estimate noisy (~7% of range), bearing
+      precise -> anisotropic BEV covariance elongated along the viewing ray;
+    - good class discrimination (94% correct, confusions within size groups);
+    - occasional false positives (glare phantoms, more at night).
+
+LiDAR:
+    - accurate range/geometry (~0.1-0.2 m position, ~3.5% dims);
+    - degraded at long distance (sparse returns beyond ~45 m) and in heavy
+      rain (spray attenuation growing with distance); mild degradation under
+      partial occlusion (fewer returns, but the sensor sits higher and sees
+      in 3D, so much less than the camera);
+    - weak class discrimination: geometry-template guess with low confidence
+      (semantics is the camera's job);
+    - unaffected by night — this is the key complementarity for night recall.
+
+All randomness is seeded per (seed, sequence, modality): deterministic.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import List, Optional
+
+import numpy as np
+from pydantic import BaseModel, Field
+
+from sensorflow.bevfusion.geometry import (
+    backproject, make_camera_extrinsic, make_intrinsics, project_to_image,
+    CAM_W, CAM_H,
+)
+from sensorflow.bevfusion.scenes import CLASS_DIMS, CLASSES, SceneFrame, SceneSequence
+
+# Class confusion groups (similar appearance / similar footprint).
+_CONFUSION = {
+    "vehicle": ["truck"],
+    "truck": ["vehicle"],
+    "pedestrian": ["cyclist"],
+    "cyclist": ["pedestrian", "motorcycle"],
+    "motorcycle": ["cyclist"],
+}
+
+DEFAULT_K = make_intrinsics()
+DEFAULT_CAM_TO_EGO = make_camera_extrinsic(tx=0.2, ty=0.0, tz=1.5)
+
+
+class Detection(BaseModel):
+    """A single-modality detection expressed in the ego/BEV frame."""
+
+    modality: str  # "camera" | "lidar"
+    x: float
+    y: float
+    z: float = 0.0
+    cov: List[List[float]] = Field(default_factory=lambda: [[0.04, 0.0], [0.0, 0.04]])
+    dims: List[float] = Field(default_factory=lambda: [4.5, 1.9, 1.6])  # l, w, h
+    yaw: float = 0.0
+    class_name: str = "vehicle"
+    class_confidence: float = 0.5
+    confidence: float = 0.5
+    source_instance_id: Optional[str] = None  # debug/tests only; engines never read it
+
+
+def _ray_cov(x: float, y: float, sigma_along: float, sigma_cross: float,
+             origin_x: float = 0.2, origin_y: float = 0.0) -> List[List[float]]:
+    """BEV covariance elongated along the sensor->object ray."""
+    theta = math.atan2(y - origin_y, x - origin_x)
+    c, s = math.cos(theta), math.sin(theta)
+    rot = np.array([[c, -s], [s, c]])
+    cov = rot @ np.diag([sigma_along ** 2, sigma_cross ** 2]) @ rot.T
+    return cov.tolist()
+
+
+# ------------------------------------------------------------------ camera
+
+
+def simulate_camera(frame: SceneFrame, seq: SceneSequence, rng: np.random.Generator,
+                    cam_to_ego: np.ndarray = DEFAULT_CAM_TO_EGO,
+                    K: np.ndarray = DEFAULT_K) -> List[Detection]:
+    night = seq.time_of_day == "night"
+    rain = seq.weather == "rain"
+    dets: List[Detection] = []
+
+    for gt in frame.gt:
+        gx, gy, gz, l, w, h, yaw = gt.bbox_3d
+        d = gt.distance
+        p_miss = 0.04 + 0.10 * min(1.0, d / 70.0)
+        if gt.occluded:
+            p_miss += 0.82
+        if night:
+            p_miss += 0.35 + 0.25 * min(1.0, d / 60.0)
+        if rain:
+            p_miss += 0.06
+        if rng.random() < min(p_miss, 0.97):
+            continue
+
+        proj = project_to_image(np.array([gx, gy, gz]), cam_to_ego, K)
+        if proj is None:
+            continue
+        u, v, r_true = proj
+        u += float(rng.normal(0, 0.4))
+        v += float(rng.normal(0, 0.4))
+        if not (0 <= u <= CAM_W and 0 <= v <= CAM_H):
+            continue
+
+        # Monocular depth: multiplicative range noise along the precise ray.
+        r_est = r_true * float(1.0 + rng.normal(0, 0.07))
+        p_ego = backproject(u, v, max(r_est, 1.0), cam_to_ego, K)
+        dims = [max(0.3, dim * float(1.0 + rng.normal(0, 0.10))) for dim in (l, w, h)]
+
+        if rng.random() < 0.94:
+            cls = gt.class_name
+        else:
+            cls = str(rng.choice(_CONFUSION[gt.class_name]))
+        sigma_along = max(0.35, 0.07 * d)
+        sigma_cross = max(0.12, 0.004 * d)
+        dets.append(Detection(
+            modality="camera",
+            x=float(p_ego[0]), y=float(p_ego[1]), z=dims[2] / 2,  # ground-plane assumption
+            cov=_ray_cov(float(p_ego[0]), float(p_ego[1]), sigma_along, sigma_cross),
+            dims=dims,
+            yaw=float(yaw + rng.normal(0, math.radians(8))),
+            class_name=cls,
+            class_confidence=float(np.clip(rng.normal(0.88, 0.05), 0.5, 0.99)),
+            confidence=float(np.clip(0.88 - d / 250.0 + rng.normal(0, 0.05), 0.30, 0.99)),
+            source_instance_id=gt.instance_id,
+        ))
+
+    # False positives: glare/texture phantoms, more frequent at night.
+    if rng.random() < (0.10 if night else 0.05):
+        fx = float(rng.uniform(8, 70))
+        fy = float(rng.uniform(-15, 15))
+        cls = str(rng.choice(CLASSES))
+        l, w, h = CLASS_DIMS[cls]
+        d = math.hypot(fx, fy)
+        dets.append(Detection(
+            modality="camera", x=fx, y=fy, z=h / 2,
+            cov=_ray_cov(fx, fy, max(0.35, 0.07 * d), max(0.12, 0.004 * d)),
+            dims=[l, w, h], yaw=float(rng.uniform(-math.pi, math.pi)),
+            class_name=cls, class_confidence=0.55,
+            confidence=float(rng.uniform(0.35, 0.55)),
+        ))
+    return dets
+
+
+# ------------------------------------------------------------------ lidar
+
+
+def _template_class(dims: List[float], rng: np.random.Generator) -> str:
+    """Weak geometric classification: nearest size template, often confused.
+
+    Real LiDAR-only detectors get geometry right but semantics wrong; we model
+    that as a 55% template guess / 45% confusion-group draw.
+    """
+    best, best_err = "vehicle", float("inf")
+    for cls, (tl, tw, th) in CLASS_DIMS.items():
+        err = (math.log(dims[0] / tl) ** 2 + math.log(dims[1] / tw) ** 2
+               + math.log(dims[2] / th) ** 2)
+        if err < best_err:
+            best, best_err = cls, err
+    if rng.random() < 0.55:
+        return best
+    return str(rng.choice(_CONFUSION[best] + [best]))
+
+
+def simulate_lidar(frame: SceneFrame, seq: SceneSequence,
+                   rng: np.random.Generator) -> List[Detection]:
+    rain = seq.weather == "rain"
+    dets: List[Detection] = []
+
+    for gt in frame.gt:
+        gx, gy, gz, l, w, h, yaw = gt.bbox_3d
+        d = gt.distance
+        p_miss = 0.02 + 0.60 * max(0.0, (d - 45.0) / 35.0)
+        if rain:
+            p_miss += 0.03 + 0.25 * max(0.0, (d - 25.0) / 50.0)
+        if gt.occluded:
+            p_miss += 0.15  # partial returns: far milder than the camera's 0.82
+        if rng.random() < min(p_miss, 0.97):
+            continue
+
+        sigma = 0.10 + 0.0015 * d
+        dims = [max(0.3, dim * float(1.0 + rng.normal(0, 0.035))) for dim in (l, w, h)]
+        dets.append(Detection(
+            modality="lidar",
+            x=float(gx + rng.normal(0, sigma)),
+            y=float(gy + rng.normal(0, sigma)),
+            z=float(gz + rng.normal(0, sigma)),
+            cov=[[sigma ** 2, 0.0], [0.0, sigma ** 2]],
+            dims=dims,
+            yaw=float(yaw + rng.normal(0, math.radians(3))),
+            class_name=_template_class(dims, rng),
+            class_confidence=float(np.clip(rng.normal(0.40, 0.05), 0.2, 0.6)),
+            confidence=float(np.clip(0.93 - 0.5 * max(0.0, (d - 40.0) / 40.0)
+                                     - (0.08 if rain else 0.0) + rng.normal(0, 0.03),
+                                     0.30, 0.99)),
+            source_instance_id=gt.instance_id,
+        ))
+
+    # Rain clutter (spray) false positives: weak, usually below decode threshold.
+    if rain and rng.random() < 0.06:
+        fx, fy = float(rng.uniform(5, 40)), float(rng.uniform(-12, 12))
+        dets.append(Detection(
+            modality="lidar", x=fx, y=fy, z=0.5,
+            cov=[[0.04, 0.0], [0.0, 0.04]],
+            dims=[0.8, 0.8, 1.0], yaw=0.0,
+            class_name="pedestrian", class_confidence=0.25,
+            confidence=float(rng.uniform(0.30, 0.45)),
+        ))
+    return dets
+
+
+def camera_rng(seed: int, seq_index: int) -> np.random.Generator:
+    return np.random.default_rng(seed * 100003 + seq_index * 7919 + 1)
+
+
+def lidar_rng(seed: int, seq_index: int) -> np.random.Generator:
+    return np.random.default_rng(seed * 100003 + seq_index * 7919 + 2)

src/pages/CommandCenterPage.tsx

@@ -40,9 +40,6 @@ import CompareTab from '../components/megaeval/CompareTab';
 import ReviewTab from '../components/megaeval/ReviewTab';
 import ShiftTab from '../components/megaeval/ShiftTab';
 import LineageCard from '../components/megaeval/LineageCard';
-import ContainerQualityPanel from '../components/platform/ContainerQualityPanel';
-import ModelComparePanel from '../components/platform/ModelComparePanel';
-import GateStatusPanel from '../components/platform/GateStatusPanel';
 
 const ACTIVE_STATUSES: RunStatus[] = ['created', 'queued', 'running', 'reducing', 'materializing'];
 
@@ -52,7 +49,6 @@ type TabId =
   | 'containers'
   | 'investigation'
   | 'compare'
-  | 'gates'
   | 'review'
   | 'shift'
   | 'lineage';
@@ -294,49 +290,28 @@ export default function CommandCenterPage() {
             <Tab label="Containers" value="containers" />
             <Tab label="Investigation" value="investigation" />
             <Tab label="Compare" value="compare" />
-            <Tab label="Gates" value="gates" />
             <Tab label="Review" value="review" />
             <Tab label="Shift" value="shift" />
             <Tab label="Lineage" value="lineage" />
           </Tabs>
 
           {tab === 'quality' ? (
-            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
-              <QualityTab runId={selectedRun.run_id} runs={runs} refreshKey={publishTick} />
-              <ContainerQualityPanel runId={selectedRun.run_id} refreshKey={publishTick} />
-            </Box>
+            <QualityTab runId={selectedRun.run_id} runs={runs} refreshKey={publishTick} />
           ) : null}
           {tab === 'cohorts' ? <CohortTab runId={selectedRun.run_id} refreshKey={publishTick} /> : null}
           {tab === 'containers' ? (
-            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
-              <ContainerQualityPanel runId={selectedRun.run_id} refreshKey={publishTick} />
-              <ContainersTab
-                runId={selectedRun.run_id}
-                refreshKey={publishTick}
-                drillContainerId={drillContainerId}
-                onDrill={setDrillContainerId}
-              />
-            </Box>
+            <ContainersTab
+              runId={selectedRun.run_id}
+              refreshKey={publishTick}
+              drillContainerId={drillContainerId}
+              onDrill={setDrillContainerId}
+            />
           ) : null}
           {tab === 'investigation' ? (
             <InvestigationTab runId={selectedRun.run_id} onOpenContainer={openContainer} />
           ) : null}
           {tab === 'compare' ? (
-            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
-              <ModelComparePanel
-                runId={selectedRun.run_id}
-                baselineRunId={baselineRunId}
-                refreshKey={publishTick}
-              />
-              <CompareTab runId={selectedRun.run_id} baselineRunId={baselineRunId} refreshKey={publishTick} />
-            </Box>
-          ) : null}
-          {tab === 'gates' ? (
-            <GateStatusPanel
-              candidateRunId={selectedRun.run_id}
-              baselineRunId={baselineRunId}
-              refreshKey={publishTick}
-            />
+            <CompareTab runId={selectedRun.run_id} baselineRunId={baselineRunId} refreshKey={publishTick} />
           ) : null}
           {tab === 'review' ? (
             <ReviewTab runId={selectedRun.run_id} review={review} onReview={setReview} />

src/pages/EvaluationPage.tsx

@@ -20,7 +20,6 @@ import {
 import { useLabelEval } from '../context/LabelEvalContext';
 import EvidencePanel from '../components/labeleval/EvidencePanel';
 import CopilotDrawer from '../components/labeleval/CopilotDrawer';
-import GateStatusPanel from '../components/platform/GateStatusPanel';
 import { SectionCard, StatusChip, LoadingBox, ErrorNote, fmtNum, fmtPct } from '../components/labeleval/shared';
 
 const PAGE_SIZE = 15;
@@ -91,7 +90,6 @@ export default function EvaluationPage() {
 
   return (
     <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
-      <GateStatusPanel candidateRunId={null} baselineRunId={null} />
       <SectionCard title="Evaluation Record Explorer">
         <Box sx={{ display: 'flex', alignItems: 'center', gap: 2, mb: 2 }}>
           <Typography variant="body2" sx={{ color: '#8a949e' }}>

src/pages/QualityEnginePage.tsx

@@ -5,7 +5,6 @@ import LabelEvaluationEngine from '../components/labeleval/LabelEvaluationEngine
 import StrictQualityValidation from '../components/labeleval/StrictQualityValidation';
 import GroundTruthComparison from '../components/labeleval/GroundTruthComparison';
 import GraderDisagreement from '../components/labeleval/GraderDisagreement';
-import GateStatusPanel from '../components/platform/GateStatusPanel';
 import { LoadingBox, ErrorNote } from '../components/labeleval/shared';
 
 export default function QualityEnginePage() {
@@ -21,7 +20,6 @@ export default function QualityEnginePage() {
       {metrics.error && !metrics.data ? <ErrorNote error={metrics.error} /> : null}
 
       <LabelEvaluationEngine pipeline={pipeline ?? null} />
-      <GateStatusPanel candidateRunId={null} baselineRunId={null} />
       <StrictQualityValidation metrics={metrics.data} />
       <GroundTruthComparison metrics={metrics.data} />
       <GraderDisagreement metrics={metrics.data} />

tests/test_bevfusion/test_e2e.py

@@ -0,0 +1,110 @@
+"""End-to-end self-evaluation: fused engine must measurably beat the baseline
+on identical scenes, deterministically — plus the API surface."""
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from sensorflow.bevfusion import evaluate as evaluate_mod
+from sensorflow.bevfusion.api import router as bevfusion_router
+from sensorflow.bevfusion.evaluate import run_comparison
+
+
+@pytest.fixture(scope="module")
+def report():
+    return run_comparison(n_sequences=6, frames_per_sequence=24, seed=7, persist=False)
+
+
+def _headline(report, metric, who):
+    row = next(h for h in report["headline_deltas"] if h["metric"] == metric)
+    return row[who]
+
+
+def _cohort(report, name):
+    return next(c for c in report["per_cohort"] if c["cohort"] == name)
+
+
+def test_fused_beats_baseline_on_recall_and_geometry(report):
+    assert _headline(report, "recall", "delta") >= 0.20
+    assert _headline(report, "mean_iou", "delta") >= 0.10
+    # Fused position error must be at most 60% of the monocular baseline.
+    assert _headline(report, "position_error_m", "candidate") <= \
+        0.6 * _headline(report, "position_error_m", "baseline")
+    assert _headline(report, "safety_recall", "delta") >= 0.10
+
+
+def test_night_and_occluded_cohorts_recover_substantially(report):
+    night = _cohort(report, "night")
+    assert night["recall_delta"] >= 0.30, night
+    occluded = _cohort(report, "occluded")
+    assert occluded["recall_delta"] >= 0.30, occluded
+    assert night["explanation"] and occluded["explanation"]
+
+
+def test_tracking_id_switches_drop(report):
+    base = _headline(report, "id_switch_rate", "baseline")
+    cand = _headline(report, "id_switch_rate", "candidate")
+    assert cand <= 0.5 * base, (base, cand)
+    assert _headline(report, "idf1", "delta") >= 0.20
+    assert _headline(report, "fragmentation_rate", "candidate") <= \
+        _headline(report, "fragmentation_rate", "baseline")
+
+
+def test_recommendation_is_promote_with_no_blockers(report):
+    assert report["recommendation"] == "PROMOTE"
+    assert report["blockers"] == []
+    assert len(report["improvements"]) >= 5
+    assert report["engines"] == {"baseline": "perception-v1-camera",
+                                 "candidate": "perception-v3-bevfusion"}
+
+
+def test_comparison_is_deterministic(report):
+    again = run_comparison(n_sequences=6, frames_per_sequence=24, seed=7, persist=False)
+    assert again["headline_deltas"] == report["headline_deltas"]
+    assert again["per_cohort"] == report["per_cohort"]
+
+
+def test_persistence_writes_latest_report(tmp_path):
+    rep = run_comparison(n_sequences=3, frames_per_sequence=12, seed=3,
+                         out_dir=tmp_path, persist=True)
+    assert (tmp_path / "latest.json").exists()
+    assert (tmp_path / f"{rep['run_id']}.json").exists()
+
+
+# ------------------------------------------------------------------ API
+
+
+@pytest.fixture()
+def client(tmp_path, monkeypatch):
+    monkeypatch.setattr(evaluate_mod, "RUNS_DIR", tmp_path)
+    app = FastAPI()
+    app.include_router(bevfusion_router)
+    return TestClient(app)
+
+
+def test_api_run_report_status_lifecycle(client):
+    r = client.get("/api/bevfusion/report")
+    assert r.status_code == 404
+
+    r = client.post("/api/bevfusion/run",
+                    json={"n_sequences": 3, "frames_per_sequence": 12, "seed": 11})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["recommendation"] in ("PROMOTE", "DO_NOT_PROMOTE")
+    assert body["headline_deltas"] and body["per_cohort"]
+
+    r = client.get("/api/bevfusion/report")
+    assert r.status_code == 200
+    assert r.json()["run_id"] == body["run_id"]
+
+    r = client.get("/api/bevfusion/status")
+    assert r.status_code == 200
+    status = r.json()
+    assert status["ready"] is True
+    assert status["n_runs"] == 1
+    assert status["engines"]["candidate"] == "perception-v3-bevfusion"
+
+
+def test_api_rejects_out_of_range_params(client):
+    r = client.post("/api/bevfusion/run", json={"n_sequences": 0})
+    assert r.status_code == 422

tests/test_bevfusion/test_fusion.py

@@ -0,0 +1,76 @@
+"""BEV fusion behavior: complementarity mechanics with hand-planted evidence."""
+
+import math
+
+from sensorflow.bevfusion.fusion import fuse_frame
+from sensorflow.bevfusion.sensors import Detection
+
+
+def _lidar(x, y, cls="cyclist", cls_conf=0.4, conf=0.9, dims=(0.7, 0.7, 1.75)):
+    return Detection(modality="lidar", x=x, y=y, z=dims[2] / 2,
+                     cov=[[0.0144, 0.0], [0.0, 0.0144]], dims=list(dims), yaw=0.3,
+                     class_name=cls, class_confidence=cls_conf, confidence=conf)
+
+
+def _camera(x, y, cls="pedestrian", cls_conf=0.9, conf=0.85, dims=(0.7, 0.7, 1.75),
+            sigma_along=1.4, sigma_cross=0.12):
+    theta = math.atan2(y, x)
+    c, s = math.cos(theta), math.sin(theta)
+    sa2, sc2 = sigma_along**2, sigma_cross**2
+    cov = [[c*c*sa2 + s*s*sc2, c*s*(sa2 - sc2)],
+           [c*s*(sa2 - sc2), s*s*sa2 + c*c*sc2]]
+    return Detection(modality="camera", x=x, y=y, z=dims[2] / 2, cov=cov,
+                     dims=list(dims), yaw=0.3, class_name=cls,
+                     class_confidence=cls_conf, confidence=conf)
+
+
+def test_fusion_recovers_planted_camera_miss_from_lidar_evidence():
+    """Camera saw nothing (night/occlusion); LiDAR evidence alone must decode."""
+    boxes = fuse_frame(camera_dets=[], lidar_dets=[_lidar(30.0, 2.0)])
+    assert len(boxes) == 1
+    box = boxes[0]
+    assert math.hypot(box["bbox_3d"][0] - 30.0, box["bbox_3d"][1] - 2.0) < 0.5
+    assert box["confidence"] >= 0.30
+
+
+def test_camera_class_flows_to_lidar_anchored_detection():
+    """Camera depth is 3 m off but its class evidence smears along the ray and
+    labels the LiDAR-anchored cell; geometry snaps to LiDAR (inverse-variance)."""
+    true_x, true_y = 20.0, 0.0
+    cam = _camera(23.0, 0.0, cls="pedestrian", cls_conf=0.9)   # +3 m range error
+    lid = _lidar(true_x, true_y, cls="cyclist", cls_conf=0.4)  # weak wrong class
+    boxes = fuse_frame([cam], [lid])
+    # Ray-aware NMS must collapse the camera's range ghost into one object.
+    assert len(boxes) == 1
+    box = boxes[0]
+    assert math.hypot(box["bbox_3d"][0] - true_x, box["bbox_3d"][1] - true_y) < 0.5, \
+        "fused position must be LiDAR-anchored, not the camera's depth estimate"
+    assert box["class_name"] == "pedestrian", \
+        "camera semantics must win over the weak LiDAR template class"
+
+
+def test_camera_only_detection_survives_when_lidar_missing():
+    """Long-range/sparse LiDAR: the camera's evidence alone keeps existence."""
+    cam = _camera(55.0, -4.0, conf=0.8, sigma_along=3.85, sigma_cross=0.22)
+    boxes = fuse_frame([cam], [])
+    assert len(boxes) == 1
+    assert math.hypot(boxes[0]["bbox_3d"][0] - 55.0, boxes[0]["bbox_3d"][1] + 4.0) < 1.0
+
+
+def test_weak_single_modality_clutter_is_suppressed_at_decode():
+    """Low-confidence rain clutter stays below the fused decode threshold."""
+    clutter = _lidar(20.4, 3.4, conf=0.25, cls_conf=0.25)
+    assert fuse_frame([], [clutter]) == []
+
+
+def test_both_modalities_beat_camera_alone_on_position():
+    true_x, true_y = 40.0, 5.0
+    cam = _camera(43.0, 5.375, sigma_along=2.8, sigma_cross=0.16)  # ~3 m range error
+    lid = _lidar(40.1, 5.05)
+    fused = fuse_frame([cam], [lid])
+    cam_only = fuse_frame([cam], [])
+    assert len(fused) == 1 and len(cam_only) == 1
+    err_fused = math.hypot(fused[0]["bbox_3d"][0] - true_x, fused[0]["bbox_3d"][1] - true_y)
+    err_cam = math.hypot(cam_only[0]["bbox_3d"][0] - true_x, cam_only[0]["bbox_3d"][1] - true_y)
+    assert err_fused < 0.4
+    assert err_fused < err_cam / 3

tests/test_bevfusion/test_geometry.py

@@ -0,0 +1,57 @@
+"""BEV projection geometry: known extrinsic -> known pixel / known BEV cell."""
+
+import math
+
+import numpy as np
+
+from sensorflow.bevfusion.geometry import (
+    BEVGrid, backproject, make_camera_extrinsic, make_intrinsics, project_to_image,
+)
+
+
+def test_known_extrinsic_projects_optical_axis_to_principal_point():
+    K = make_intrinsics()  # fx=fy=500, cx=400, cy=225
+    T = make_camera_extrinsic(tx=0.2, ty=0.0, tz=1.5)
+    # A point straight down the optical axis maps exactly to the principal point.
+    u, v, rng = project_to_image(np.array([20.2, 0.0, 1.5]), T, K)
+    assert abs(u - 400.0) < 1e-9
+    assert abs(v - 225.0) < 1e-9
+    assert abs(rng - 20.0) < 1e-9
+
+
+def test_known_extrinsic_off_axis_pixel_matches_analytic_formula():
+    K = make_intrinsics()
+    T = make_camera_extrinsic(tx=0.2, ty=0.0, tz=1.5)
+    px, py, pz = 10.2, 2.0, 0.8
+    u, v, rng = project_to_image(np.array([px, py, pz]), T, K)
+    # For this extrinsic: x_cam = -(y-ty), y_cam = -(z-tz), z_cam = x-tx.
+    x_c, y_c, z_c = -(py - 0.0), -(pz - 1.5), px - 0.2
+    assert abs(u - (500.0 * x_c / z_c + 400.0)) < 1e-9
+    assert abs(v - (500.0 * y_c / z_c + 225.0)) < 1e-9
+    assert abs(rng - math.sqrt(x_c**2 + y_c**2 + z_c**2)) < 1e-9
+
+
+def test_backprojection_round_trip_recovers_ego_point():
+    K = make_intrinsics()
+    T = make_camera_extrinsic(tx=0.2, ty=0.0, tz=1.5, yaw=0.05)
+    point = np.array([34.0, -6.5, 1.1])
+    u, v, rng = project_to_image(point, T, K)
+    recovered = backproject(u, v, rng, T, K)
+    np.testing.assert_allclose(recovered, point, atol=1e-9)
+
+
+def test_point_behind_camera_is_rejected():
+    K = make_intrinsics()
+    T = make_camera_extrinsic()
+    assert project_to_image(np.array([-5.0, 0.0, 1.5]), T, K) is None
+
+
+def test_known_bev_cell_and_center():
+    grid = BEVGrid(x_min=0.0, x_max=80.0, y_min=-25.0, y_max=25.0, cell=0.5)
+    assert grid.nx == 160 and grid.ny == 100
+    # (30.3, 2.1): ix = 30.3/0.5 = 60, iy = (2.1+25)/0.5 = 54
+    assert grid.index(30.3, 2.1) == (60, 54)
+    cx, cy = grid.center(60, 54)
+    assert abs(cx - 30.25) < 1e-9 and abs(cy - 2.25) < 1e-9
+    assert grid.index(90.0, 0.0) is None
+    assert grid.index(10.0, -30.0) is None

tests/test_bevfusion/test_masklet.py

@@ -0,0 +1,81 @@
+"""Masklet propagation: identity bridges planted occlusion gaps in BEV."""
+
+from sensorflow.bevfusion.engines import FrameToFrameTracker
+from sensorflow.bevfusion.masklet import BEVMaskletTracker, tracks_to_dicts
+from sensorflow.schemas.unified_frame import Object3D
+
+
+def _det(x, y, cls="vehicle", conf=0.9):
+    return Object3D(bbox_3d=[x, y, 0.8, 4.5, 1.9, 1.6, 0.0],
+                    class_name=cls, confidence=conf)
+
+
+def _stream_with_gap(gap_frames=(5, 6), n=11):
+    """Object moving +1.2 m/frame in x; detections missing during the gap."""
+    stream = []
+    for fi in range(n):
+        dets = [] if fi in gap_frames else [_det(10.0 + 1.2 * fi, 3.0)]
+        stream.append((f"f{fi:03d}", dets))
+    return stream
+
+
+def test_masklet_bridges_two_frame_occlusion_without_id_switch():
+    tracker = BEVMaskletTracker()
+    ids_seen = set()
+    propagated_frames = []
+    for frame_id, dets in _stream_with_gap():
+        out = tracker.update(frame_id, dets)
+        assert len(out) == 1, f"expected exactly one box at {frame_id}"
+        ids_seen.add(out[0].track_id)
+        if out[0].track_id in tracker.last_propagated:
+            propagated_frames.append(frame_id)
+    assert len(ids_seen) == 1, "identity must be carried through the gap"
+    assert propagated_frames == ["f005", "f006"], \
+        "gap frames must be filled by propagated masklet boxes"
+
+
+def test_propagated_box_follows_predicted_bev_position():
+    tracker = BEVMaskletTracker()
+    last_real_x = None
+    for frame_id, dets in _stream_with_gap(gap_frames=(5, 6), n=8):
+        out = tracker.update(frame_id, dets)
+        if frame_id == "f004":
+            last_real_x = out[0].bbox_3d[0]
+        if frame_id == "f006":
+            # The Kalman-predicted position must keep moving forward, not
+            # freeze at the last observed position.
+            assert out[0].bbox_3d[0] > last_real_x + 0.5
+
+
+def test_baseline_frame_to_frame_tracker_switches_id_after_gap():
+    tracker = FrameToFrameTracker(gate=3.0)
+    ids_seen = set()
+    for frame_id, dets in _stream_with_gap():
+        boxes = [{"bbox_3d": d.bbox_3d, "class_name": d.class_name,
+                  "confidence": d.confidence} for d in dets]
+        for b in tracker.update(boxes):
+            ids_seen.add(b["track_id"])
+    assert len(ids_seen) >= 2, "the naive baseline must fragment across the gap"
+
+
+def test_track_class_voting_stabilizes_semantics():
+    """One noisy LiDAR-template class flip must not change the track's label."""
+    tracker = BEVMaskletTracker()
+    classes = ["pedestrian", "pedestrian", "cyclist", "pedestrian"]
+    emitted = []
+    for fi, cls in enumerate(classes):
+        out = tracker.update(f"f{fi:03d}", [_det(10.0 + fi, 0.0, cls=cls)])
+        emitted.append(out[0].class_name)
+    assert emitted[2] == "pedestrian", "majority vote must override the flip"
+    assert emitted[-1] == "pedestrian"
+
+
+def test_tracks_to_dicts_groups_by_track_id():
+    per_frame = {
+        "f000": [{"track_id": 1, "class_name": "vehicle", "bbox_3d": [1, 0, 0, 4, 2, 1.5, 0]}],
+        "f001": [{"track_id": 1, "class_name": "vehicle", "bbox_3d": [2, 0, 0, 4, 2, 1.5, 0]},
+                 {"track_id": 2, "class_name": "pedestrian", "bbox_3d": [8, 3, 0, 0.7, 0.7, 1.7, 0]}],
+    }
+    tracks = {t["track_id"]: t for t in tracks_to_dicts(per_frame)}
+    assert len(tracks[1]["frames"]) == 2
+    assert len(tracks[2]["frames"]) == 1