Deploy Sensorflow Studio

.gitignore

@@ -65,6 +65,7 @@ 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,6 +1467,10 @@ 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)
+
 # Mount static folder
 static_dir = Path(__file__).parent / "static"
 if static_dir.exists():

sensorflow/platform/__init__.py

@@ -0,0 +1,15 @@
+"""Population-scale evaluation foundation — extends MegaEval + LabelEval.
+
+Phase 1: schemas, aggregate levels, metrics, container quality, model compare,
+multi-gate skeleton, evidence packages. Phases 2–7 leave TODO hooks only.
+"""
+
+from sensorflow.platform.levels import AggregateLevel, EvaluationScope
+from sensorflow.platform.entities import Provenance, EvidencePackage
+
+__all__ = [
+    "AggregateLevel",
+    "EvaluationScope",
+    "Provenance",
+    "EvidencePackage",
+]

sensorflow/platform/api.py

@@ -0,0 +1,237 @@
+"""Platform Phase 1 FastAPI routes — mount into existing app_backend.
+
+Routes:
+  /api/evaluations/...
+  /api/containers/...
+  /api/models/compare
+  /api/gates/...
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from sensorflow.platform import levels
+from sensorflow.platform.container_quality import build_container_quality_profile
+from sensorflow.platform.compare import compare_models
+from sensorflow.platform.evidence import build_evidence_package, export_evidence_package
+from sensorflow.platform.gates import evaluate_multi_gates, list_gate_defs, load_gate_config, save_gate_config
+from sensorflow.platform.levels import AggregateLevel, EvaluationScope
+
+router = APIRouter(prefix="/api")
+
+
+# ------------------------------------------------------------------ requests
+
+
+class EvaluationCreateRequest(BaseModel):
+    level: AggregateLevel = AggregateLevel.POPULATION
+    dataset_id: Optional[str] = None
+    population_id: Optional[str] = None
+    run_id: Optional[str] = None
+    container_id: Optional[str] = None
+    mega_container_id: Optional[int] = None
+    drive_id: Optional[str] = None
+    scene_id: Optional[str] = None
+    sequence_id: Optional[str] = None
+    frame_id: Optional[str] = None
+    cohort_filters: Dict[str, List[str]] = Field(default_factory=dict)
+    model_version: Optional[str] = None
+    label_version: Optional[str] = None
+
+
+class ModelCompareRequest(BaseModel):
+    run_ids: List[str] = Field(..., min_length=2)
+    baseline_run_id: Optional[str] = None
+    policy: Dict[str, Any] = Field(default_factory=dict)
+
+
+class GateEvaluateRequest(BaseModel):
+    sequence_id: Optional[str] = None
+    candidate_run_id: Optional[str] = None
+    baseline_run_id: Optional[str] = None
+
+
+class GateConfigUpdate(BaseModel):
+    gates: Dict[str, Any] = Field(default_factory=dict)
+
+
+class EvidenceExportRequest(BaseModel):
+    evaluation_id: Optional[str] = None
+    run_id: Optional[str] = None
+    dataset_id: Optional[str] = None
+    sequence_id: Optional[str] = None
+    candidate_run_id: Optional[str] = None
+    baseline_run_id: Optional[str] = None
+    persist: bool = True
+
+
+# ------------------------------------------------------------------ evaluations
+
+
+@router.get("/evaluations/levels")
+def evaluation_levels():
+    return {
+        "levels": [lvl.value for lvl in AggregateLevel.ladder()],
+        "backends": {lvl.value: levels.LEVEL_BACKEND[lvl] for lvl in AggregateLevel},
+    }
+
+
+@router.post("/evaluations/scope")
+def create_evaluation_scope(req: EvaluationCreateRequest):
+    scope = EvaluationScope(**req.model_dump())
+    return {
+        "scope": levels.summarize_scope(scope),
+        "message": "Phase 1 scope descriptor — queries still served by MegaEval/LabelEval backends",
+    }
+
+
+@router.get("/evaluations/{run_id}")
+def get_evaluation_summary(run_id: str):
+    """Unified evaluation summary for a MegaEval run (async job status preserved)."""
+    try:
+        from sensorflow.megaeval.runs import get_mega_store
+        run = get_mega_store().runs.get(run_id)
+    except Exception as exc:
+        raise HTTPException(500, str(exc)) from exc
+    if run is None:
+        raise HTTPException(404, f"Unknown evaluation run {run_id}")
+    scope = EvaluationScope(
+        level=AggregateLevel.POPULATION,
+        evaluation_id=run.run_id,
+        run_id=run.run_id,
+        population_id=run.population_id,
+        model_version=run.model_version,
+        label_version=getattr(run, "label_version", None),
+    )
+    return {
+        "evaluation_id": run.run_id,
+        "status": run.status,
+        "scope": levels.summarize_scope(scope),
+        "headline": run.headline,
+        "model_version": run.model_version,
+        "population_id": run.population_id,
+        "lineage": getattr(run, "lineage", None),
+        "progress": getattr(run, "progress", None),
+    }
+
+
+@router.post("/evaluations/evidence")
+def export_evidence(req: EvidenceExportRequest):
+    package = build_evidence_package(
+        evaluation_id=req.evaluation_id,
+        run_id=req.run_id,
+        dataset_id=req.dataset_id,
+        sequence_id=req.sequence_id,
+        candidate_run_id=req.candidate_run_id,
+        baseline_run_id=req.baseline_run_id,
+    )
+    path = None
+    if req.persist:
+        path = str(export_evidence_package(package))
+    return {"package": package.model_dump(), "path": path}
+
+
+# ------------------------------------------------------------------ containers
+
+
+@router.get("/containers/quality")
+def containers_quality(
+    run_id: str,
+    sort: str = "highest_risk",
+    limit: int = 50,
+    offset: int = 0,
+):
+    try:
+        return build_container_quality_profile(
+            run_id, sort=sort, limit=limit, offset=offset
+        )
+    except KeyError as exc:
+        raise HTTPException(404, str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(409, str(exc)) from exc
+
+
+@router.get("/containers/{container_id}/quality")
+def container_quality(container_id: int, run_id: str):
+    try:
+        return build_container_quality_profile(run_id, container_id=container_id)
+    except KeyError as exc:
+        raise HTTPException(404, str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(409, str(exc)) from exc
+
+
+# ------------------------------------------------------------------ models compare
+
+
+@router.post("/models/compare")
+def models_compare(req: ModelCompareRequest):
+    try:
+        return compare_models(
+            req.run_ids,
+            baseline_run_id=req.baseline_run_id,
+            policy=req.policy or None,
+        )
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
+    except KeyError as exc:
+        raise HTTPException(404, str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(409, str(exc)) from exc
+
+
+# ------------------------------------------------------------------ gates
+
+
+@router.get("/gates")
+def gates_list():
+    cfg = load_gate_config()
+    return {
+        "config_path": str(cfg.get("schema_version")),
+        "gates": [g.model_dump() for g in list_gate_defs(cfg)],
+        "order": ["scenario", "coverage", "regression", "safety", "quality", "launch", "release"],
+    }
+
+
+@router.get("/gates/config")
+def gates_config():
+    return load_gate_config()
+
+
+@router.post("/gates/config")
+def gates_config_update(req: GateConfigUpdate):
+    cfg = load_gate_config()
+    for name, patch in req.gates.items():
+        if name not in cfg["gates"]:
+            cfg["gates"][name] = patch
+        else:
+            cfg["gates"][name].update(patch)
+    save_gate_config(cfg)
+    return cfg
+
+
+@router.post("/gates/evaluate")
+def gates_evaluate(req: GateEvaluateRequest):
+    return evaluate_multi_gates(
+        sequence_id=req.sequence_id,
+        candidate_run_id=req.candidate_run_id,
+        baseline_run_id=req.baseline_run_id,
+    )
+
+
+@router.get("/gates/status")
+def gates_status(
+    sequence_id: Optional[str] = None,
+    candidate_run_id: Optional[str] = None,
+    baseline_run_id: Optional[str] = None,
+):
+    """Multi-gate readiness skeleton for UI cards."""
+    return evaluate_multi_gates(
+        sequence_id=sequence_id,
+        candidate_run_id=candidate_run_id,
+        baseline_run_id=baseline_run_id,
+    )

sensorflow/platform/compare.py

@@ -0,0 +1,122 @@
+"""Multi-model comparison (A vs B vs C) wrapping MegaEval comparative analytics.
+
+Does not invent a second compare engine — delegates pairwise compare_runs and
+folds results into a multi-way delta table.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from sensorflow.megaeval import analysis
+from sensorflow.megaeval.runs import MegaStore, get_mega_store
+from sensorflow.platform.metrics_engine import delta_metrics, round4
+
+
+def _headline_map(run) -> Dict[str, Optional[float]]:
+    h = run.headline or {}
+    return {k: h.get(k) for k in (
+        "precision", "recall", "f1", "mean_iou", "safety_recall", "anomaly_rate"
+    )}
+
+
+def compare_models(
+    run_ids: List[str],
+    *,
+    baseline_run_id: Optional[str] = None,
+    policy: Optional[Dict] = None,
+    store: Optional[MegaStore] = None,
+) -> Dict[str, Any]:
+    """Compare 2+ published MegaEval runs (model versions A/B/C…).
+
+    If baseline_run_id is omitted, the first id is the baseline.
+    """
+    if len(run_ids) < 2:
+        raise ValueError("compare_models requires at least two run_ids")
+    store = store or get_mega_store()
+    baseline_id = baseline_run_id or run_ids[0]
+    if baseline_id not in run_ids:
+        run_ids = [baseline_id, *run_ids]
+
+    runs = []
+    for rid in run_ids:
+        run = store.runs.get(rid)
+        if run is None:
+            raise KeyError(f"Unknown evaluation run {rid}")
+        if run.status != "published":
+            raise RuntimeError(f"Run {rid} is {run.status}; results require published")
+        runs.append(run)
+
+    baseline = next(r for r in runs if r.run_id == baseline_id)
+    candidates = [r for r in runs if r.run_id != baseline_id]
+
+    models = [{
+        "run_id": r.run_id,
+        "model_version": r.model_version,
+        "role": "baseline" if r.run_id == baseline_id else "candidate",
+        "headline": _headline_map(r),
+    } for r in runs]
+
+    # Multi-way metric table: one row per metric, columns per model
+    metric_keys = ["precision", "recall", "f1", "mean_iou", "safety_recall", "anomaly_rate"]
+    matrix = []
+    for key in metric_keys:
+        row: Dict[str, Any] = {"metric": key}
+        for r in runs:
+            row[r.model_version] = round4(r.headline.get(key)) if r.headline.get(key) is not None else None
+        base_v = baseline.headline.get(key)
+        deltas = {}
+        for c in candidates:
+            cv = c.headline.get(key)
+            if base_v is not None and cv is not None:
+                deltas[c.model_version] = round4(float(cv) - float(base_v))
+        row["deltas_vs_baseline"] = deltas
+        matrix.append(row)
+
+    pairwise = []
+    recommendations = []
+    for cand in candidates:
+        cmp = analysis.compare_runs(store, cand, baseline, policy)
+        pairwise.append({
+            "baseline_run_id": baseline.run_id,
+            "candidate_run_id": cand.run_id,
+            "baseline_model": baseline.model_version,
+            "candidate_model": cand.model_version,
+            "recommendation": cmp.get("recommendation"),
+            "blockers": cmp.get("blockers") or [],
+            "headline": cmp.get("headline_deltas") or delta_metrics(
+                _headline_map(baseline), _headline_map(cand)
+            ),
+            "per_class": cmp.get("per_class") or [],
+            "regressions": (cmp.get("regressions") or cmp.get("worst_cohorts") or [])[:10],
+        })
+        recommendations.append({
+            "candidate": cand.model_version,
+            "recommendation": cmp.get("recommendation"),
+            "blocker_count": len(cmp.get("blockers") or []),
+        })
+
+    # Also surface LabelEval registry models when present (non-fatal)
+    registry = []
+    try:
+        from sensorflow.evaluation.records import get_store
+        for m in get_store().all("models"):
+            registry.append({
+                "model_id": m.model_id,
+                "model_version": m.model_version,
+                "metrics": m.metrics.model_dump() if hasattr(m.metrics, "model_dump") else {},
+                "regression_status": m.regression_status,
+            })
+    except Exception:
+        pass
+
+    return {
+        "baseline_run_id": baseline.run_id,
+        "run_ids": run_ids,
+        "models": models,
+        "metric_matrix": matrix,
+        "pairwise": pairwise,
+        "recommendations": recommendations,
+        "label_eval_registry": registry,
+        "policy": {**analysis.DEFAULT_PROMOTION_POLICY, **(policy or {})},
+    }

sensorflow/platform/container_quality.py

@@ -0,0 +1,132 @@
+"""Container quality profiles — wraps MegaEval container table + metric engine."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from sensorflow.megaeval import population as pop_mod
+from sensorflow.megaeval.population import DIMENSIONS
+from sensorflow.megaeval.runs import CONTAINER_STATUS, EvaluationRun, MegaStore, get_mega_store
+from sensorflow.platform.metrics_engine import container_quality_metrics, aggregate_container_rows
+
+
+def _enrich_row(r: Dict[str, Any]) -> Dict[str, Any]:
+    tp, fp, fn = int(r["tp"]), int(r["fp"]), int(r["fn"])
+    sum_iou = float(r.get("sum_iou") or 0.0)
+    n = int(r.get("n_objects") or 0)
+    verified = int(r.get("verified") or 0)
+    reviewed = int(r.get("reviewed") or 0)
+    # MegaEval does not yet track disputed/auto_accept/hitl separately;
+    # approximate: reviewed-verified ≈ HITL queue residue; rest unverified.
+    hitl = max(0, reviewed - verified)
+    auto_accepted = 0  # TODO(Phase 2): wire triage auto-accept
+    disputed = 0  # TODO(Phase 2): grader disagreement → disputed
+    metrics = container_quality_metrics(
+        tp=tp, fp=fp, fn=fn, sum_iou=sum_iou, n_objects=n,
+        verified=verified, reviewed=reviewed, disputed=disputed,
+        auto_accepted=auto_accepted, hitl=hitl,
+        anomalies=int(r.get("anomalies") or 0),
+    )
+    dims = {dim: DIMENSIONS[dim][int(r[dim])] for dim in pop_mod.CONTAINER_DIMS if dim in r}
+    return {
+        "container_id": int(r["container_id"]),
+        "status": CONTAINER_STATUS[int(r["status"])] if "status" in r else None,
+        "risk_score": round(float(r.get("risk_score") or 0), 4),
+        "dims": dims,
+        "drill_down": {
+            "object_endpoint": f"/api/megaeval/runs/{{run_id}}/containers/{int(r['container_id'])}/objects",
+            "annotation_ids": [],  # forensic load on demand
+        },
+        **metrics,
+    }
+
+
+def build_container_quality_profile(
+    run_id: str,
+    *,
+    container_id: Optional[int] = None,
+    sort: str = "highest_risk",
+    limit: int = 50,
+    offset: int = 0,
+    store: Optional[MegaStore] = None,
+) -> Dict[str, Any]:
+    store = store or get_mega_store()
+    run = store.runs.get(run_id)
+    if run is None:
+        raise KeyError(f"Unknown evaluation run {run_id}")
+    if run.status != "published":
+        raise RuntimeError(f"Run {run_id} is {run.status}; publish before quality profile")
+
+    art = store.artifacts(run_id)
+    df = art["containers"].copy()
+    tp, fp, fn = df["tp"], df["fp"], df["fn"]
+    with np.errstate(divide="ignore", invalid="ignore"):
+        df["recall"] = np.where((tp + fn) > 0, tp / (tp + fn), np.nan)
+        df["precision"] = np.where((tp + fp) > 0, tp / (tp + fp), np.nan)
+        df["mean_iou"] = np.where(tp > 0, df["sum_iou"] / tp, np.nan)
+
+    if container_id is not None:
+        df = df[df["container_id"] == int(container_id)]
+        if df.empty:
+            raise KeyError(f"Unknown container {container_id} in run {run_id}")
+
+    sort_map = {
+        "highest_risk": ("risk_score", False),
+        "worst_recall": ("recall", True),
+        "worst_precision": ("precision", True),
+        "worst_iou": ("mean_iou", True),
+        "most_anomalies": ("anomalies", False),
+        "least_verified": ("verified", True),
+    }
+    metric, ascending = sort_map.get(sort, sort_map["highest_risk"])
+    df = df.sort_values(metric, ascending=ascending, na_position="last")
+    total = len(df)
+    page = df.iloc[offset: offset + max(1, min(limit, 500))]
+
+    rows: List[Dict[str, Any]] = []
+    for _, series in page.iterrows():
+        rows.append(_enrich_row(series.to_dict()))
+
+    summary = aggregate_container_rows(rows) if rows else container_quality_metrics(
+        tp=0, fp=0, fn=0
+    )
+
+    return {
+        "run_id": run_id,
+        "model_version": run.model_version,
+        "population_id": run.population_id,
+        "container_id": container_id,
+        "total": total,
+        "sort": sort,
+        "offset": offset,
+        "limit": limit,
+        "summary": summary,
+        "containers": rows,
+        "verification_headline": summary.get("verification"),
+    }
+
+
+def profile_from_counts(
+    *,
+    container_id: str,
+    tp: int,
+    fp: int,
+    fn: int,
+    sum_iou: float = 0.0,
+    n_objects: int = 0,
+    verified: int = 0,
+    reviewed: int = 0,
+    disputed: int = 0,
+    auto_accepted: int = 0,
+    hitl: int = 0,
+    anomalies: int = 0,
+) -> Dict[str, Any]:
+    """Unit-testable path without MegaStore."""
+    metrics = container_quality_metrics(
+        tp=tp, fp=fp, fn=fn, sum_iou=sum_iou, n_objects=n_objects or (tp + fp),
+        verified=verified, reviewed=reviewed, disputed=disputed,
+        auto_accepted=auto_accepted, hitl=hitl, anomalies=anomalies,
+    )
+    return {"container_id": container_id, **metrics}

sensorflow/platform/entities.py

@@ -0,0 +1,306 @@
+"""Platform entity schemas with versioning / provenance.
+
+Prefer these as the shared vocabulary across LabelEval + MegaEval.
+Existing store models in evaluation.records remain the persistence layer for
+label QA; MegaEval continues to use npz cubes. These Pydantic models are the
+contract for APIs, evidence packages, and later lakehouse rows.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Literal, Optional
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _id(prefix: str) -> str:
+    return f"{prefix}-{uuid4().hex[:10]}"
+
+
+class Provenance(BaseModel):
+    """Lineage fields required on durable evaluation artifacts."""
+
+    created_at: str = Field(default_factory=_now)
+    created_by: str = "system"
+    schema_version: str = "platform-1.0"
+    parent_ids: List[str] = Field(default_factory=list)
+    source_system: str = "sensorflow"  # labeleval | megaeval | pipeline | platform
+    seed: Optional[int] = None
+    code_version: str = "phase1"
+    notes: str = ""
+
+
+class VersionedEntity(BaseModel):
+    version: str = "v1"
+    provenance: Provenance = Field(default_factory=Provenance)
+
+
+# ------------------------------------------------------------------ hierarchy
+
+
+class DatasetEntity(VersionedEntity):
+    dataset_id: str
+    name: str = ""
+    population_id: Optional[str] = None  # MegaEval link
+    num_frames: int = 0
+    gt_type: Optional[str] = None
+
+
+class Container(VersionedEntity):
+    """Scene/segment holding related objects (MegaEval container_id)."""
+
+    container_id: str
+    dataset_id: Optional[str] = None
+    run_id: Optional[str] = None
+    mega_container_id: Optional[int] = None
+    drive_id: Optional[str] = None
+    scene_id: Optional[str] = None
+    dims: Dict[str, str] = Field(default_factory=dict)
+    n_objects: int = 0
+
+
+class Group(VersionedEntity):
+    """Logical grouping: verification bucket OR cohort alias."""
+
+    group_id: str
+    kind: Literal["verification", "cohort", "custom"] = "custom"
+    dataset_id: Optional[str] = None
+    member_ids: List[str] = Field(default_factory=list)
+    label: str = ""
+
+
+class Drive(VersionedEntity):
+    drive_id: str
+    dataset_id: Optional[str] = None
+    scene_ids: List[str] = Field(default_factory=list)
+    container_ids: List[str] = Field(default_factory=list)
+    description: str = ""
+
+
+class SceneEntity(VersionedEntity):
+    scene_id: str
+    dataset_id: Optional[str] = None
+    drive_id: Optional[str] = None
+    sequence_ids: List[str] = Field(default_factory=list)
+    description: str = ""
+
+
+class ScenarioEntity(VersionedEntity):
+    scenario_id: str
+    scenario_type: str
+    dataset_id: Optional[str] = None
+    frame_ids: List[str] = Field(default_factory=list)
+    description: str = ""
+
+
+class FrameEntity(VersionedEntity):
+    frame_id: str
+    dataset_id: Optional[str] = None
+    scene_id: Optional[str] = None
+    sequence_id: Optional[str] = None
+    container_id: Optional[str] = None
+    index: int = 0
+    timestamp_us: int = 0
+
+
+class Sensor(VersionedEntity):
+    sensor_id: str
+    modality: Literal["lidar", "camera", "radar", "ultrasonic", "other"] = "lidar"
+    frame_id: Optional[str] = None
+    calibration_ref: Optional[str] = None
+
+
+class ObjectEntity(VersionedEntity):
+    object_id: str
+    class_name: str = "vehicle"
+    frame_id: Optional[str] = None
+    container_id: Optional[str] = None
+    track_id: Optional[str] = None
+    bbox_3d: Optional[List[float]] = None
+
+
+class Trajectory(VersionedEntity):
+    trajectory_id: str
+    track_id: Optional[str] = None
+    object_ids: List[str] = Field(default_factory=list)
+    frame_ids: List[str] = Field(default_factory=list)
+
+
+class Label(VersionedEntity):
+    """Alias contract for Annotation — hypothesis, never assumed correct."""
+
+    label_id: str
+    annotation_id: Optional[str] = None
+    frame_id: Optional[str] = None
+    object_id: Optional[str] = None
+    class_name: str = ""
+    confidence: float = 0.0
+    status: str = "PENDING"
+    model_version: Optional[str] = None
+
+
+class AnnotationEntity(Label):
+    """Explicit Annotation mirror for API clarity."""
+
+    pass
+
+
+# ------------------------------------------------------------------ models / eval
+
+
+class ModelEntity(VersionedEntity):
+    model_id: str
+    name: str = ""
+    status: str = "ready"
+
+
+class ModelVersion(VersionedEntity):
+    model_version_id: str
+    model_id: str
+    model_version: str
+    checkpoint_ref: Optional[str] = None
+    trained_on_dataset: Optional[str] = None
+    metrics: Dict[str, Any] = Field(default_factory=dict)
+
+
+class Metric(VersionedEntity):
+    metric_id: str
+    name: str
+    value: Optional[float] = None
+    unit: str = "ratio"
+    higher_is_better: bool = True
+    support: Optional[int] = None
+    level: str = "container"  # AggregateLevel value
+    exact: bool = True
+
+
+class Evaluation(VersionedEntity):
+    evaluation_id: str
+    level: str
+    dataset_id: Optional[str] = None
+    population_id: Optional[str] = None
+    run_id: Optional[str] = None
+    model_version: Optional[str] = None
+    label_version: Optional[str] = None
+    scope_ref: Optional[str] = None  # container/cohort/drive id
+    metrics: List[Metric] = Field(default_factory=list)
+    status: str = "created"
+
+
+class Cohort(VersionedEntity):
+    cohort_id: str
+    filters: Dict[str, List[str]] = Field(default_factory=dict)
+    group_by: List[str] = Field(default_factory=list)
+    n: int = 0
+    run_id: Optional[str] = None
+
+
+class Embedding(VersionedEntity):
+    embedding_id: str
+    ref_type: str = "container"  # container | object | frame
+    ref_id: str
+    dim: int = 0
+    # TODO(Phase 3): vector payload / external vector-DB handle
+    vector_ref: Optional[str] = None
+
+
+class Anomaly(VersionedEntity):
+    anomaly_id: str
+    annotation_id: Optional[str] = None
+    container_id: Optional[str] = None
+    score: float = 0.0
+    is_anomaly: bool = False
+    detector_scores: Dict[str, float] = Field(default_factory=dict)
+
+
+class Conflict(VersionedEntity):
+    """Safety / label conflict placeholder — Phase 4 fills SSAM DRAC/DeltaS."""
+
+    conflict_id: str
+    kind: str = "label"  # label | trajectory | ssam_drac | ssam_deltas
+    entity_ids: List[str] = Field(default_factory=list)
+    severity: str = "medium"
+    # TODO(Phase 4): full SSAM conflict engine fields
+    detail: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ODDDefinition(VersionedEntity):
+    odd_id: str
+    name: str
+    axes: Dict[str, List[str]] = Field(default_factory=dict)
+    # TODO(Phase 5): combinatorial coverage rules
+    description: str = ""
+
+
+class ODDObservation(VersionedEntity):
+    observation_id: str
+    odd_id: str
+    observed_axes: Dict[str, str] = Field(default_factory=dict)
+    covered: bool = False
+    support: int = 0
+    run_id: Optional[str] = None
+
+
+class QualityGateDef(VersionedEntity):
+    gate_id: str
+    name: str
+    gate_type: Literal[
+        "scenario", "coverage", "regression", "safety", "release", "quality", "launch"
+    ]
+    thresholds: Dict[str, float] = Field(default_factory=dict)
+    config_path: Optional[str] = None
+    enabled: bool = True
+
+
+class GateResult(VersionedEntity):
+    result_id: str
+    gate_id: str
+    gate_type: str
+    passed: Optional[bool] = None  # None = not yet evaluated (skeleton)
+    failures: List[Dict[str, Any]] = Field(default_factory=list)
+    metrics: Dict[str, Any] = Field(default_factory=dict)
+    thresholds: Dict[str, float] = Field(default_factory=dict)
+    scope_ref: Optional[str] = None
+    ready: bool = False  # False until Phase N wires real checks
+    message: str = ""
+
+
+class HumanReviewEntity(VersionedEntity):
+    review_id: str
+    task_id: Optional[str] = None
+    annotation_id: Optional[str] = None
+    reviewer: str = "human-reviewer"
+    action: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ComputeUsage(VersionedEntity):
+    usage_id: str = Field(default_factory=lambda: _id("compute"))
+    stage: str = ""
+    units: int = 0
+    run_id: str = ""
+    evaluation_id: Optional[str] = None
+    hardware: str = "cpu"
+
+
+class EvidencePackage(VersionedEntity):
+    """Exportable evaluation artifact — Phase 1 stub with real fields when available."""
+
+    package_id: str = Field(default_factory=lambda: _id("evidence"))
+    evaluation_id: str
+    dataset_id: Optional[str] = None
+    dataset_version: Optional[str] = None
+    population_id: Optional[str] = None
+    model_versions: List[str] = Field(default_factory=list)
+    label_version: Optional[str] = None
+    metrics: Dict[str, Any] = Field(default_factory=dict)
+    thresholds: Dict[str, Any] = Field(default_factory=dict)
+    gate_results: List[Dict[str, Any]] = Field(default_factory=list)
+    compute_usage: List[Dict[str, Any]] = Field(default_factory=list)
+    drill_down_ids: Dict[str, List[str]] = Field(default_factory=dict)
+    placeholders: List[str] = Field(default_factory=list)

sensorflow/platform/evidence.py

@@ -0,0 +1,140 @@
+"""Evidence package export — JSON stub with real fields when available."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from sensorflow.platform.entities import EvidencePackage, Provenance, _id
+
+EVIDENCE_DIR = Path("runs/platform/evidence")
+
+
+def build_evidence_package(
+    *,
+    evaluation_id: Optional[str] = None,
+    run_id: Optional[str] = None,
+    dataset_id: Optional[str] = None,
+    sequence_id: Optional[str] = None,
+    candidate_run_id: Optional[str] = None,
+    baseline_run_id: Optional[str] = None,
+    include_gates: bool = True,
+) -> EvidencePackage:
+    placeholders: List[str] = []
+    metrics: Dict[str, Any] = {}
+    model_versions: List[str] = []
+    population_id = None
+    label_version = None
+    dataset_version = None
+    compute_usage: List[Dict[str, Any]] = []
+    drill: Dict[str, List[str]] = {}
+    thresholds: Dict[str, Any] = {}
+    gate_results: List[Dict[str, Any]] = []
+
+    eval_id = evaluation_id or run_id or _id("eval")
+
+    # MegaEval run headline
+    if run_id or candidate_run_id:
+        rid = run_id or candidate_run_id
+        try:
+            from sensorflow.megaeval.runs import get_mega_store
+            store = get_mega_store()
+            run = store.runs.get(rid)  # type: ignore[arg-type]
+            if run:
+                metrics["headline"] = dict(run.headline or {})
+                model_versions.append(run.model_version)
+                population_id = run.population_id
+                label_version = getattr(run, "label_version", None)
+                drill["run_ids"] = [run.run_id]
+            else:
+                placeholders.append(f"mega_run_missing:{rid}")
+        except Exception as exc:
+            placeholders.append(f"mega_run_error:{exc}")
+    else:
+        placeholders.append("run_id")
+
+    if baseline_run_id:
+        try:
+            from sensorflow.megaeval.runs import get_mega_store
+            br = get_mega_store().runs.get(baseline_run_id)
+            if br:
+                model_versions.append(br.model_version)
+                drill.setdefault("run_ids", []).append(br.run_id)
+        except Exception:
+            placeholders.append("baseline_run")
+
+    # LabelEval dataset + process units
+    if dataset_id:
+        try:
+            from sensorflow.evaluation.records import get_store
+            from sensorflow.evaluation.process_units import usage_summary
+            store = get_store()
+            ds = store.get("datasets", dataset_id)
+            if ds:
+                dataset_version = ds.version
+                drill["dataset_ids"] = [dataset_id]
+            else:
+                placeholders.append(f"dataset_missing:{dataset_id}")
+            summary = usage_summary(store)
+            compute_usage = [summary] if isinstance(summary, dict) else list(summary or [])
+        except Exception as exc:
+            placeholders.append(f"labeleval_error:{exc}")
+            compute_usage = []
+    else:
+        placeholders.append("dataset_id")
+
+    if include_gates:
+        try:
+            from sensorflow.platform.gates import evaluate_multi_gates, load_gate_config
+            cfg = load_gate_config()
+            thresholds = {k: v.get("thresholds", {}) for k, v in cfg.get("gates", {}).items()}
+            gate_payload = evaluate_multi_gates(
+                sequence_id=sequence_id,
+                candidate_run_id=candidate_run_id or run_id,
+                baseline_run_id=baseline_run_id,
+            )
+            gate_results = gate_payload.get("gates") or []
+        except Exception as exc:
+            placeholders.append(f"gates_error:{exc}")
+
+    if not metrics:
+        placeholders.append("metrics")
+    if not model_versions:
+        placeholders.append("model_versions")
+        model_versions = ["placeholder-model"]
+    if not compute_usage:
+        compute_usage = [{"stage": "platform_evidence", "units": 0, "note": "placeholder"}]
+        placeholders.append("compute_usage_detail")
+
+    return EvidencePackage(
+        package_id=_id("evidence"),
+        evaluation_id=eval_id,
+        dataset_id=dataset_id,
+        dataset_version=dataset_version,
+        population_id=population_id,
+        model_versions=model_versions,
+        label_version=label_version,
+        metrics=metrics,
+        thresholds=thresholds,
+        gate_results=gate_results,
+        compute_usage=compute_usage,
+        drill_down_ids=drill,
+        placeholders=sorted(set(placeholders)),
+        provenance=Provenance(
+            source_system="platform",
+            notes="Phase 1 evidence stub — fill placeholders in later phases",
+            parent_ids=[x for x in [run_id, dataset_id, sequence_id] if x],
+        ),
+    )
+
+
+def export_evidence_package(package: EvidencePackage, path: Optional[Path] = None) -> Path:
+    EVIDENCE_DIR.mkdir(parents=True, exist_ok=True)
+    path = path or (EVIDENCE_DIR / f"{package.package_id}.json")
+    # Append-only: never overwrite an existing package id silently
+    if path.exists():
+        path = EVIDENCE_DIR / f"{package.package_id}-{_id('rev')}.json"
+    with open(path, "w") as f:
+        json.dump(package.model_dump(), f, indent=2)
+    return path

sensorflow/platform/gates.py

@@ -0,0 +1,264 @@
+"""Multi-gate readiness skeleton — config-driven thresholds.
+
+Extends existing QualityGate + LaunchGateEvaluator toward:
+  Scenario | Coverage | Regression | Safety | Release
+
+Phases 4–6 fill Safety/ODD/Release deeply; Phase 1 returns honest ready=False
+for unwired gates and real results for quality/launch when sequence artifacts exist.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from sensorflow.platform.entities import GateResult, QualityGateDef, Provenance, _id
+
+DEFAULT_GATE_CONFIG_PATH = Path("runs/platform/gate_config.json")
+
+# Config-driven defaults — never hard-code safety cutoffs in callers.
+DEFAULT_GATE_CONFIG: Dict[str, Any] = {
+    "schema_version": "platform-gates-1.0",
+    "gates": {
+        "scenario": {
+            "enabled": True,
+            "ready": False,  # Phase 5/6
+            "thresholds": {"min_scenario_types_covered": 5},
+            "message": "TODO(Phase 5): scenario coverage vs ODDDefinition",
+        },
+        "coverage": {
+            "enabled": True,
+            "ready": False,
+            "thresholds": {"min_cohort_support": 200, "min_dim_coverage": 0.8},
+            "message": "TODO(Phase 5): ODD combinatorial coverage via MegaEval cube",
+        },
+        "regression": {
+            "enabled": True,
+            "ready": True,  # can use MegaEval compare / LabelEval regression when run_ids provided
+            "thresholds": {
+                "max_recall_drop": 0.010,
+                "max_precision_drop": 0.015,
+                "max_safety_recall_drop": 0.005,
+            },
+            "message": "Uses MegaEval promotion policy when candidate/baseline runs supplied",
+        },
+        "safety": {
+            "enabled": True,
+            "ready": False,
+            "thresholds": {},  # filled in Phase 4 from config only
+            "message": "TODO(Phase 4): SSAM DRAC/DeltaS conflict engine",
+        },
+        "release": {
+            "enabled": True,
+            "ready": False,
+            "thresholds": {"require_all_prior_passed": 1.0},
+            "message": "TODO(Phase 6): release orchestration after Safety+Regression",
+        },
+        "quality": {
+            "enabled": True,
+            "ready": True,
+            "thresholds": {
+                "map_3d": 0.65,
+                "orientation_error_deg": 5.0,
+                "id_swap_rate": 0.02,
+                "track_fragmentation_rate": 0.05,
+                "position_error_m": 2.0,
+            },
+            "message": "Delegates to sensorflow.quality_gate.QualityGate when sequence_id set",
+        },
+        "launch": {
+            "enabled": True,
+            "ready": True,
+            "thresholds": {
+                "map_3d": 0.65,
+                "orientation_error_deg": 5.0,
+                "id_swap_rate": 0.02,
+                "track_fragmentation_rate": 0.05,
+            },
+            "message": "Delegates to LaunchGateEvaluator when sequence_id set",
+        },
+    },
+}
+
+
+def load_gate_config(path: Optional[Path] = None) -> Dict[str, Any]:
+    path = path or DEFAULT_GATE_CONFIG_PATH
+    if path.exists():
+        with open(path) as f:
+            cfg = json.load(f)
+        # merge missing keys from defaults without wiping user thresholds
+        merged = json.loads(json.dumps(DEFAULT_GATE_CONFIG))
+        for gname, gcfg in (cfg.get("gates") or {}).items():
+            if gname in merged["gates"]:
+                merged["gates"][gname].update(gcfg)
+            else:
+                merged["gates"][gname] = gcfg
+        return merged
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(DEFAULT_GATE_CONFIG, f, indent=2)
+    return json.loads(json.dumps(DEFAULT_GATE_CONFIG))
+
+
+def save_gate_config(cfg: Dict[str, Any], path: Optional[Path] = None) -> Path:
+    path = path or DEFAULT_GATE_CONFIG_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(cfg, f, indent=2)
+    return path
+
+
+GATE_ORDER = ["scenario", "coverage", "regression", "safety", "quality", "launch", "release"]
+
+
+def list_gate_defs(cfg: Optional[Dict[str, Any]] = None) -> List[QualityGateDef]:
+    cfg = cfg or load_gate_config()
+    out = []
+    for name in GATE_ORDER:
+        g = cfg["gates"].get(name, {})
+        out.append(QualityGateDef(
+            gate_id=f"gate-{name}",
+            name=name.title(),
+            gate_type=name,  # type: ignore[arg-type]
+            thresholds=dict(g.get("thresholds") or {}),
+            config_path=str(DEFAULT_GATE_CONFIG_PATH),
+            enabled=bool(g.get("enabled", True)),
+            version="v1",
+            provenance=Provenance(source_system="platform", notes=g.get("message", "")),
+        ))
+    return out
+
+
+def evaluate_multi_gates(
+    *,
+    sequence_id: Optional[str] = None,
+    candidate_run_id: Optional[str] = None,
+    baseline_run_id: Optional[str] = None,
+    config_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    cfg = load_gate_config(config_path)
+    results: List[GateResult] = []
+
+    for name in GATE_ORDER:
+        g = cfg["gates"][name]
+        if not g.get("enabled", True):
+            continue
+        ready = bool(g.get("ready", False))
+        thresholds = dict(g.get("thresholds") or {})
+        result = GateResult(
+            result_id=_id("gateres"),
+            gate_id=f"gate-{name}",
+            gate_type=name,
+            thresholds=thresholds,
+            ready=ready,
+            message=g.get("message", ""),
+            scope_ref=sequence_id or candidate_run_id,
+            passed=None,
+        )
+
+        if name == "quality" and sequence_id and ready:
+            result = _eval_quality(sequence_id, thresholds, result)
+        elif name == "launch" and sequence_id and ready:
+            result = _eval_launch(sequence_id, result)
+        elif name == "regression" and candidate_run_id and baseline_run_id and ready:
+            result = _eval_regression(candidate_run_id, baseline_run_id, thresholds, result)
+        elif not ready:
+            result.passed = None
+            result.message = g.get("message") or f"{name} gate skeleton — not yet wired"
+        else:
+            result.passed = None
+            result.message = f"{name} gate ready but missing required inputs"
+
+        results.append(result)
+
+    # Overall readiness: all ready gates that produced a boolean must pass;
+    # unwired gates block "release ready" but do not fail the suite silently.
+    wired = [r for r in results if r.ready and r.passed is not None]
+    unwired = [r for r in results if not r.ready]
+    all_wired_passed = all(r.passed for r in wired) if wired else False
+
+    return {
+        "config_path": str(config_path or DEFAULT_GATE_CONFIG_PATH),
+        "sequence_id": sequence_id,
+        "candidate_run_id": candidate_run_id,
+        "baseline_run_id": baseline_run_id,
+        "gates": [r.model_dump() for r in results],
+        "summary": {
+            "wired_count": len(wired),
+            "unwired_count": len(unwired),
+            "wired_all_passed": all_wired_passed,
+            "release_ready": False,  # Phase 6
+            "unwired_gate_types": [r.gate_type for r in unwired],
+        },
+    }
+
+
+def _eval_quality(sequence_id: str, thresholds: Dict[str, float], result: GateResult) -> GateResult:
+    try:
+        from sensorflow.quality_gate import QualityGate
+        from sensorflow.schemas.unified_frame import UnifiedSequence
+
+        manifest = Path("runs/pipeline") / sequence_id / "manifest.json"
+        tracks_path = Path("runs/pipeline") / sequence_id / "tracks.json"
+        if not manifest.exists() or not tracks_path.exists():
+            result.passed = False
+            result.failures = [{"metric": "artifacts", "message": "manifest/tracks missing"}]
+            result.message = "Quality gate: run ingest/auto-label/track first"
+            return result
+        sequence = UnifiedSequence.load(manifest)
+        pred_tracks = json.loads(tracks_path.read_text())
+        gate = QualityGate(thresholds=thresholds)
+        out = gate.evaluate(sequence, pred_tracks)
+        result.passed = bool(out.get("passed"))
+        result.metrics = out.get("metric_card") or {}
+        result.failures = out.get("quality_report", {}).get("failures") or out.get("failures") or []
+        result.message = "QualityGate evaluated"
+    except Exception as exc:
+        result.passed = False
+        result.failures = [{"error": str(exc)}]
+        result.message = f"Quality gate error: {exc}"
+    return result
+
+
+def _eval_launch(sequence_id: str, result: GateResult) -> GateResult:
+    try:
+        from sensorflow.launch_gate_evaluator import LaunchGateEvaluator
+        evaluator = LaunchGateEvaluator()
+        out = evaluator.evaluate(sequence_id)
+        result.passed = bool(out.get("passed"))
+        result.failures = out.get("failures") or []
+        result.metrics = out.get("metrics") or {}
+        result.thresholds = evaluator.thresholds
+        result.message = "LaunchGateEvaluator evaluated"
+    except Exception as exc:
+        result.passed = False
+        result.failures = [{"error": str(exc)}]
+        result.message = f"Launch gate error: {exc}"
+    return result
+
+
+def _eval_regression(
+    candidate_run_id: str,
+    baseline_run_id: str,
+    thresholds: Dict[str, float],
+    result: GateResult,
+) -> GateResult:
+    try:
+        from sensorflow.platform.compare import compare_models
+        cmp = compare_models(
+            [baseline_run_id, candidate_run_id],
+            baseline_run_id=baseline_run_id,
+            policy=thresholds,
+        )
+        pair = (cmp.get("pairwise") or [{}])[0]
+        rec = pair.get("recommendation")
+        result.passed = rec == "PROMOTE"
+        result.failures = [{"blocker": b} for b in (pair.get("blockers") or [])]
+        result.metrics = {"recommendation": rec, "headline": pair.get("headline")}
+        result.message = f"Regression gate: {rec}"
+    except Exception as exc:
+        result.passed = False
+        result.failures = [{"error": str(exc)}]
+        result.message = f"Regression gate error: {exc}"
+    return result

sensorflow/platform/levels.py

@@ -0,0 +1,112 @@
+"""Evaluation abstraction across aggregate levels.
+
+Unifies LabelEval (frame/annotation) and MegaEval (container/cohort/population)
+into one ladder without duplicating storage.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class AggregateLevel(str, Enum):
+    FRAME = "frame"
+    CLIP = "clip"  # sequence / short clip
+    SCENE = "scene"
+    DRIVE = "drive"
+    CONTAINER = "container"
+    DATASET = "dataset"
+    COHORT = "cohort"
+    POPULATION = "population"
+
+    @classmethod
+    def ladder(cls) -> List["AggregateLevel"]:
+        return [
+            cls.FRAME,
+            cls.CLIP,
+            cls.SCENE,
+            cls.DRIVE,
+            cls.CONTAINER,
+            cls.DATASET,
+            cls.COHORT,
+            cls.POPULATION,
+        ]
+
+    def parent(self) -> Optional["AggregateLevel"]:
+        ladder = self.ladder()
+        i = ladder.index(self)
+        return ladder[i + 1] if i + 1 < len(ladder) else None
+
+    def child(self) -> Optional["AggregateLevel"]:
+        ladder = self.ladder()
+        i = ladder.index(self)
+        return ladder[i - 1] if i > 0 else None
+
+
+# Which backend owns primary aggregates at each level
+LEVEL_BACKEND: Dict[AggregateLevel, str] = {
+    AggregateLevel.FRAME: "labeleval",
+    AggregateLevel.CLIP: "labeleval",
+    AggregateLevel.SCENE: "labeleval",
+    AggregateLevel.DRIVE: "platform",  # stub until Phase 5/6
+    AggregateLevel.CONTAINER: "megaeval",
+    AggregateLevel.DATASET: "labeleval",
+    AggregateLevel.COHORT: "megaeval",
+    AggregateLevel.POPULATION: "megaeval",
+}
+
+
+class EvaluationScope(BaseModel):
+    """Points at one aggregate cell without inventing a second DB."""
+
+    level: AggregateLevel
+    evaluation_id: Optional[str] = None
+    dataset_id: Optional[str] = None
+    population_id: Optional[str] = None
+    run_id: Optional[str] = None
+    container_id: Optional[str] = None
+    mega_container_id: Optional[int] = None
+    drive_id: Optional[str] = None
+    scene_id: Optional[str] = None
+    sequence_id: Optional[str] = None
+    frame_id: Optional[str] = None
+    cohort_filters: Dict[str, List[str]] = Field(default_factory=dict)
+    model_version: Optional[str] = None
+    label_version: Optional[str] = None
+
+    def backend(self) -> str:
+        return LEVEL_BACKEND[self.level]
+
+    def drill_down_hint(self) -> AggregateLevel:
+        child = self.level.child()
+        return child or self.level
+
+
+def summarize_scope(scope: EvaluationScope) -> Dict[str, Any]:
+    return {
+        "level": scope.level.value,
+        "backend": scope.backend(),
+        "parent_level": scope.level.parent().value if scope.level.parent() else None,
+        "child_level": scope.level.child().value if scope.level.child() else None,
+        "refs": {
+            k: v
+            for k, v in {
+                "evaluation_id": scope.evaluation_id,
+                "dataset_id": scope.dataset_id,
+                "population_id": scope.population_id,
+                "run_id": scope.run_id,
+                "container_id": scope.container_id,
+                "mega_container_id": scope.mega_container_id,
+                "drive_id": scope.drive_id,
+                "scene_id": scope.scene_id,
+                "sequence_id": scope.sequence_id,
+                "frame_id": scope.frame_id,
+                "model_version": scope.model_version,
+            }.items()
+            if v is not None
+        },
+        "cohort_filters": scope.cohort_filters,
+    }

sensorflow/platform/metrics_engine.py

@@ -0,0 +1,163 @@
+"""Metric engine: precision/recall/F1/IoU + verification rates.
+
+Pure functions — no I/O. Callers feed counts from MegaEval containers or
+LabelEval match stats.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Optional, Sequence
+
+
+def safe_div(num: float, den: float) -> Optional[float]:
+    if den <= 0:
+        return None
+    return num / den
+
+
+def round4(v: Optional[float]) -> Optional[float]:
+    return None if v is None else round(float(v), 4)
+
+
+def precision_recall_f1(tp: int, fp: int, fn: int) -> Dict[str, Optional[float]]:
+    precision = safe_div(tp, tp + fp)
+    recall = safe_div(tp, tp + fn)
+    f1 = None
+    if precision is not None and recall is not None and (precision + recall) > 0:
+        f1 = 2 * precision * recall / (precision + recall)
+    return {
+        "precision": round4(precision),
+        "recall": round4(recall),
+        "f1": round4(f1),
+        "tp": tp,
+        "fp": fp,
+        "fn": fn,
+    }
+
+
+def mean_iou(sum_iou: float, tp: int) -> Optional[float]:
+    return round4(safe_div(sum_iou, tp))
+
+
+def verification_rates(
+    *,
+    n_objects: int,
+    verified: int = 0,
+    reviewed: int = 0,
+    disputed: int = 0,
+    auto_accepted: int = 0,
+    hitl: int = 0,
+    unverified: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Verification / HITL funnel rates at container (or dataset) scope.
+
+    unverified defaults to n_objects - verified when not provided.
+    """
+    n = max(0, int(n_objects))
+    verified = max(0, int(verified))
+    reviewed = max(0, int(reviewed))
+    disputed = max(0, int(disputed))
+    auto_accepted = max(0, int(auto_accepted))
+    hitl = max(0, int(hitl))
+    if unverified is None:
+        unverified = max(0, n - verified)
+
+    def rate(count: int) -> Optional[float]:
+        return round4(safe_div(count, n)) if n > 0 else None
+
+    return {
+        "n_objects": n,
+        "verified": verified,
+        "unverified": unverified,
+        "disputed": disputed,
+        "auto_accepted": auto_accepted,
+        "hitl": hitl,
+        "reviewed": reviewed,
+        "verified_rate": rate(verified),
+        "unverified_rate": rate(unverified),
+        "disputed_rate": rate(disputed),
+        "auto_accept_rate": rate(auto_accepted),
+        "hitl_rate": rate(hitl),
+        "review_coverage": rate(reviewed),
+    }
+
+
+def container_quality_metrics(
+    *,
+    tp: int,
+    fp: int,
+    fn: int,
+    sum_iou: float = 0.0,
+    n_objects: int = 0,
+    verified: int = 0,
+    reviewed: int = 0,
+    disputed: int = 0,
+    auto_accepted: int = 0,
+    hitl: int = 0,
+    anomalies: int = 0,
+) -> Dict[str, Any]:
+    prf = precision_recall_f1(tp, fp, fn)
+    n = n_objects or (tp + fp)
+    ver = verification_rates(
+        n_objects=n,
+        verified=verified,
+        reviewed=reviewed,
+        disputed=disputed,
+        auto_accepted=auto_accepted,
+        hitl=hitl,
+    )
+    return {
+        **prf,
+        "mean_iou": mean_iou(sum_iou, tp),
+        "anomalies": anomalies,
+        "anomaly_rate": round4(safe_div(anomalies, n)) if n else None,
+        "verification": ver,
+    }
+
+
+def aggregate_container_rows(rows: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    """Roll up a page of container metric dicts into one profile summary."""
+    tp = fp = fn = verified = reviewed = disputed = auto_acc = hitl = anomalies = n = 0
+    sum_iou = 0.0
+    for r in rows:
+        tp += int(r.get("tp") or 0)
+        fp += int(r.get("fp") or 0)
+        fn += int(r.get("fn") or 0)
+        verified += int(r.get("verified") or 0)
+        reviewed += int(r.get("reviewed") or 0)
+        disputed += int(r.get("disputed") or 0)
+        auto_acc += int(r.get("auto_accepted") or 0)
+        hitl += int(r.get("hitl") or 0)
+        anomalies += int(r.get("anomalies") or 0)
+        n += int(r.get("n_objects") or 0)
+        mi = r.get("mean_iou")
+        tpi = int(r.get("tp") or 0)
+        if mi is not None and tpi > 0:
+            sum_iou += float(mi) * tpi
+        elif r.get("sum_iou") is not None:
+            sum_iou += float(r["sum_iou"])
+    return container_quality_metrics(
+        tp=tp, fp=fp, fn=fn, sum_iou=sum_iou, n_objects=n,
+        verified=verified, reviewed=reviewed, disputed=disputed,
+        auto_accepted=auto_acc, hitl=hitl, anomalies=anomalies,
+    )
+
+
+def delta_metrics(
+    baseline: Dict[str, Optional[float]],
+    candidate: Dict[str, Optional[float]],
+    keys: Optional[Iterable[str]] = None,
+) -> List[Dict[str, Any]]:
+    keys = list(keys or ("precision", "recall", "f1", "mean_iou", "safety_recall", "anomaly_rate"))
+    out = []
+    for k in keys:
+        b, c = baseline.get(k), candidate.get(k)
+        if b is None or c is None:
+            continue
+        out.append({
+            "metric": k,
+            "baseline": round4(float(b)),
+            "candidate": round4(float(c)),
+            "delta": round4(float(c) - float(b)),
+        })
+    return out

src/components/platform/ContainerQualityPanel.tsx

@@ -0,0 +1,94 @@
+/**
+ * Container quality cards/table with verification rates (Phase 1 foundation).
+ * Extends MegaEval ContainersTab data via /api/containers/quality.
+ */
+import Box from '@mui/material/Box';
+import Table from '@mui/material/Table';
+import TableBody from '@mui/material/TableBody';
+import TableCell from '@mui/material/TableCell';
+import TableHead from '@mui/material/TableHead';
+import TableRow from '@mui/material/TableRow';
+import Typography from '@mui/material/Typography';
+import { useContainerQuality } from '../../services/platform';
+import { ErrorNote, LoadingBox, MetricCard, SectionCard, fmtPct } from '../labeleval/shared';
+
+export default function ContainerQualityPanel({
+  runId,
+  refreshKey = 0,
+}: {
+  runId: string | null;
+  refreshKey?: number;
+}) {
+  const poll = useContainerQuality(runId, refreshKey);
+
+  if (!runId) {
+    return (
+      <SectionCard title="Container quality">
+        <Typography variant="body2" color="text.secondary">
+          Select a published evaluation run to load container quality profiles.
+        </Typography>
+      </SectionCard>
+    );
+  }
+  if (poll.error && !poll.data) return <ErrorNote error={poll.error} />;
+  if (poll.loading && !poll.data) return <LoadingBox label="Loading container quality…" />;
+  const data = poll.data;
+  if (!data) return null;
+
+  const v = data.verification_headline || data.summary?.verification;
+
+  return (
+    <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+      <SectionCard
+        title="Container quality profile"
+        action={
+          <Typography variant="caption" color="text.secondary">
+            {data.total} containers · {data.model_version}
+          </Typography>
+        }
+      >
+        <Box sx={{ display: 'flex', gap: 1.5, flexWrap: 'wrap', mb: 2 }}>
+          <MetricCard label="Precision" value={fmtPct(data.summary.precision)} />
+          <MetricCard label="Recall" value={fmtPct(data.summary.recall)} />
+          <MetricCard label="F1" value={fmtPct(data.summary.f1)} />
+          <MetricCard label="Mean IoU" value={fmtPct(data.summary.mean_iou)} />
+          <MetricCard label="Verified" value={fmtPct(v?.verified_rate)} sub={`${v?.verified ?? 0} labels`} />
+          <MetricCard label="HITL rate" value={fmtPct(v?.hitl_rate)} />
+          <MetricCard label="Unverified" value={fmtPct(v?.unverified_rate)} />
+          <MetricCard label="Disputed" value={fmtPct(v?.disputed_rate)} sub="Phase 2 hook" />
+        </Box>
+
+        <Table size="small">
+          <TableHead>
+            <TableRow>
+              <TableCell>Container</TableCell>
+              <TableCell>Status</TableCell>
+              <TableCell align="right">P</TableCell>
+              <TableCell align="right">R</TableCell>
+              <TableCell align="right">F1</TableCell>
+              <TableCell align="right">IoU</TableCell>
+              <TableCell align="right">Verified</TableCell>
+              <TableCell align="right">HITL</TableCell>
+              <TableCell align="right">Risk</TableCell>
+            </TableRow>
+          </TableHead>
+          <TableBody>
+            {data.containers.slice(0, 20).map((c) => (
+              <TableRow key={c.container_id} hover>
+                <TableCell>#{c.container_id}</TableCell>
+                <TableCell>{c.status ?? '—'}</TableCell>
+                <TableCell align="right">{fmtPct(c.precision)}</TableCell>
+                <TableCell align="right">{fmtPct(c.recall)}</TableCell>
+                <TableCell align="right">{fmtPct(c.f1)}</TableCell>
+                <TableCell align="right">{fmtPct(c.mean_iou)}</TableCell>
+                <TableCell align="right">{fmtPct(c.verification?.verified_rate)}</TableCell>
+                <TableCell align="right">{fmtPct(c.verification?.hitl_rate)}</TableCell>
+                <TableCell align="right">{c.risk_score.toFixed(2)}</TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </SectionCard>
+    </Box>
+  );
+}

src/components/platform/GateStatusPanel.tsx

@@ -0,0 +1,84 @@
+/**
+ * Multi-gate readiness skeleton: Scenario / Coverage / Regression / Safety / Release
+ * (+ quality / launch when wired).
+ */
+import Box from '@mui/material/Box';
+import Chip from '@mui/material/Chip';
+import Typography from '@mui/material/Typography';
+import { CheckCircle2, CircleDashed, XCircle } from 'lucide-react';
+import { useGateStatus } from '../../services/platform';
+import { ErrorNote, LoadingBox, SectionCard } from '../labeleval/shared';
+
+const DISPLAY_ORDER = ['scenario', 'coverage', 'regression', 'safety', 'quality', 'launch', 'release'];
+
+function statusChip(passed: boolean | null, ready: boolean) {
+  if (!ready) {
+    return <Chip size="small" icon={<CircleDashed size={14} />} label="Skeleton" variant="outlined" />;
+  }
+  if (passed === true) {
+    return <Chip size="small" color="success" icon={<CheckCircle2 size={14} />} label="Pass" />;
+  }
+  if (passed === false) {
+    return <Chip size="small" color="error" icon={<XCircle size={14} />} label="Fail" />;
+  }
+  return <Chip size="small" label="Pending inputs" variant="outlined" />;
+}
+
+export default function GateStatusPanel({
+  candidateRunId,
+  baselineRunId,
+  refreshKey = 0,
+}: {
+  candidateRunId: string | null;
+  baselineRunId: string | null;
+  refreshKey?: number;
+}) {
+  const poll = useGateStatus(candidateRunId, baselineRunId, refreshKey);
+
+  if (poll.error && !poll.data) return <ErrorNote error={poll.error} />;
+  if (poll.loading && !poll.data) return <LoadingBox label="Loading gate status…" />;
+  const data = poll.data;
+  if (!data) return null;
+
+  const byType = Object.fromEntries(data.gates.map((g) => [g.gate_type, g]));
+
+  return (
+    <SectionCard
+      title="Multi-gate readiness"
+      action={
+        <Typography variant="caption" color="text.secondary">
+          {data.summary.release_ready
+            ? 'Release ready'
+            : `${data.summary.unwired_count} gates still Phase 2–6 stubs`}
+        </Typography>
+      }
+    >
+      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+        {DISPLAY_ORDER.map((type) => {
+          const g = byType[type];
+          if (!g) return null;
+          return (
+            <Box
+              key={type}
+              sx={{
+                display: 'flex',
+                alignItems: 'center',
+                gap: 1.5,
+                py: 0.75,
+                borderBottom: '1px solid #232a31',
+              }}
+            >
+              <Typography sx={{ minWidth: 110, fontWeight: 600, textTransform: 'capitalize' }}>
+                {type}
+              </Typography>
+              {statusChip(g.passed, g.ready)}
+              <Typography variant="body2" color="text.secondary" sx={{ flex: 1 }}>
+                {g.message}
+              </Typography>
+            </Box>
+          );
+        })}
+      </Box>
+    </SectionCard>
+  );
+}

src/components/platform/ModelComparePanel.tsx

@@ -0,0 +1,117 @@
+/**
+ * Multi-model compare panel (A vs B vs C) — wraps /api/models/compare.
+ */
+import { useMemo } from 'react';
+import Alert from '@mui/material/Alert';
+import Box from '@mui/material/Box';
+import Table from '@mui/material/Table';
+import TableBody from '@mui/material/TableBody';
+import TableCell from '@mui/material/TableCell';
+import TableHead from '@mui/material/TableHead';
+import TableRow from '@mui/material/TableRow';
+import Typography from '@mui/material/Typography';
+import { compareModels } from '../../services/platform';
+import { usePoll } from '../../services/labeleval';
+import { ErrorNote, LoadingBox, SectionCard, fmtPct } from '../labeleval/shared';
+
+export default function ModelComparePanel({
+  runId,
+  baselineRunId,
+  extraRunIds = [],
+  refreshKey = 0,
+}: {
+  runId: string | null;
+  baselineRunId: string | null;
+  extraRunIds?: string[];
+  refreshKey?: number;
+}) {
+  const runIds = useMemo(() => {
+    const ids = [baselineRunId, runId, ...extraRunIds].filter(Boolean) as string[];
+    return [...new Set(ids)];
+  }, [runId, baselineRunId, extraRunIds]);
+
+  const cmp = usePoll(
+    () =>
+      runIds.length >= 2
+        ? compareModels(runIds, baselineRunId)
+        : Promise.resolve(null),
+    null,
+    [runIds.join(','), baselineRunId, refreshKey]
+  );
+
+  if (runIds.length < 2) {
+    return (
+      <Alert severity="info" variant="outlined">
+        Select a baseline run (and optionally more candidates) to compare models A / B / C.
+      </Alert>
+    );
+  }
+  if (cmp.error && !cmp.data) return <ErrorNote error={cmp.error} />;
+  if (cmp.loading && !cmp.data) return <LoadingBox label="Comparing models…" />;
+  const data = cmp.data;
+  if (!data) return null;
+
+  const modelNames = data.models.map((m) => m.model_version);
+
+  return (
+    <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+      <SectionCard
+        title="Model compare (A / B / C)"
+        action={
+          <Typography variant="caption" color="text.secondary">
+            Baseline {data.baseline_run_id.slice(0, 8)}…
+          </Typography>
+        }
+      >
+        <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap', mb: 2 }}>
+          {data.recommendations.map((r) => (
+            <Alert
+              key={r.candidate}
+              severity={r.recommendation === 'PROMOTE' ? 'success' : 'warning'}
+              variant="outlined"
+              sx={{ py: 0 }}
+            >
+              {r.candidate}: {r.recommendation}
+              {r.blocker_count ? ` (${r.blocker_count} blockers)` : ''}
+            </Alert>
+          ))}
+        </Box>
+
+        <Table size="small">
+          <TableHead>
+            <TableRow>
+              <TableCell>Metric</TableCell>
+              {modelNames.map((m) => (
+                <TableCell key={m} align="right">
+                  {m}
+                </TableCell>
+              ))}
+            </TableRow>
+          </TableHead>
+          <TableBody>
+            {data.metric_matrix.map((row) => (
+              <TableRow key={row.metric}>
+                <TableCell>{row.metric}</TableCell>
+                {modelNames.map((m) => {
+                  const v = row[m] as number | null | undefined;
+                  const d = row.deltas_vs_baseline?.[m];
+                  return (
+                    <TableCell key={m} align="right">
+                      {fmtPct(v ?? null)}
+                      {d !== undefined && d !== null ? (
+                        <Typography component="span" variant="caption" sx={{ ml: 0.5, color: d < 0 ? '#c62828' : '#2e7d32' }}>
+                          {d >= 0 ? '+' : ''}
+                          {(d * 100).toFixed(1)}pp
+                        </Typography>
+                      ) : null}
+                    </TableCell>
+                  );
+                })}
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </SectionCard>
+    </Box>
+  );
+}

src/pages/CommandCenterPage.tsx

@@ -40,6 +40,9 @@ 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'];
 
@@ -49,6 +52,7 @@ type TabId =
   | 'containers'
   | 'investigation'
   | 'compare'
+  | 'gates'
   | 'review'
   | 'shift'
   | 'lineage';
@@ -290,28 +294,49 @@ 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' ? (
-            <QualityTab runId={selectedRun.run_id} runs={runs} refreshKey={publishTick} />
+            <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>
           ) : null}
           {tab === 'cohorts' ? <CohortTab runId={selectedRun.run_id} refreshKey={publishTick} /> : null}
           {tab === 'containers' ? (
-            <ContainersTab
-              runId={selectedRun.run_id}
-              refreshKey={publishTick}
-              drillContainerId={drillContainerId}
-              onDrill={setDrillContainerId}
-            />
+            <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>
           ) : null}
           {tab === 'investigation' ? (
             <InvestigationTab runId={selectedRun.run_id} onOpenContainer={openContainer} />
           ) : null}
           {tab === 'compare' ? (
-            <CompareTab runId={selectedRun.run_id} baselineRunId={baselineRunId} refreshKey={publishTick} />
+            <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}
+            />
           ) : null}
           {tab === 'review' ? (
             <ReviewTab runId={selectedRun.run_id} review={review} onReview={setReview} />

src/pages/EvaluationPage.tsx

@@ -20,6 +20,7 @@ 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;
@@ -90,6 +91,7 @@ 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,6 +5,7 @@ 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() {
@@ -20,6 +21,7 @@ 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} />

src/services/platform.ts

@@ -0,0 +1,165 @@
+/**
+ * Platform Phase 1 API client — container quality, multi-model compare, gates, evidence.
+ */
+import { usePoll } from './labeleval';
+
+async function handle<T>(res: Response): Promise<T> {
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`API ${res.status}: ${body || res.statusText}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+function get<T>(url: string): Promise<T> {
+  return fetch(url).then((res) => handle<T>(res));
+}
+
+function post<T>(url: string, body?: unknown): Promise<T> {
+  return fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  }).then((res) => handle<T>(res));
+}
+
+export type VerificationRates = {
+  n_objects: number;
+  verified: number;
+  unverified: number;
+  disputed: number;
+  auto_accepted: number;
+  hitl: number;
+  reviewed: number;
+  verified_rate: number | null;
+  unverified_rate: number | null;
+  disputed_rate: number | null;
+  auto_accept_rate: number | null;
+  hitl_rate: number | null;
+  review_coverage: number | null;
+};
+
+export type ContainerQualityRow = {
+  container_id: number;
+  status: string | null;
+  risk_score: number;
+  precision: number | null;
+  recall: number | null;
+  f1: number | null;
+  mean_iou: number | null;
+  verification: VerificationRates;
+  dims: Record<string, string>;
+};
+
+export type ContainerQualityProfile = {
+  run_id: string;
+  model_version: string;
+  total: number;
+  summary: {
+    precision: number | null;
+    recall: number | null;
+    f1: number | null;
+    mean_iou: number | null;
+    verification: VerificationRates;
+  };
+  containers: ContainerQualityRow[];
+  verification_headline: VerificationRates;
+};
+
+export type GateResultRow = {
+  result_id: string;
+  gate_id: string;
+  gate_type: string;
+  passed: boolean | null;
+  ready: boolean;
+  message: string;
+  failures: Array<Record<string, unknown>>;
+  thresholds: Record<string, number>;
+};
+
+export type GateStatusResponse = {
+  gates: GateResultRow[];
+  summary: {
+    wired_count: number;
+    unwired_count: number;
+    wired_all_passed: boolean;
+    release_ready: boolean;
+    unwired_gate_types: string[];
+  };
+};
+
+export type ModelCompareResponse = {
+  baseline_run_id: string;
+  run_ids: string[];
+  models: Array<{
+    run_id: string;
+    model_version: string;
+    role: string;
+    headline: Record<string, number | null>;
+  }>;
+  metric_matrix: Array<{
+    metric: string;
+    deltas_vs_baseline: Record<string, number | null>;
+    [model: string]: unknown;
+  }>;
+  pairwise: Array<{
+    candidate_model: string;
+    recommendation: string;
+    blockers: string[];
+  }>;
+  recommendations: Array<{ candidate: string; recommendation: string; blocker_count: number }>;
+};
+
+export const getContainerQuality = (runId: string, limit = 25) =>
+  get<ContainerQualityProfile>(
+    `/api/containers/quality?run_id=${encodeURIComponent(runId)}&limit=${limit}`
+  );
+
+export const compareModels = (runIds: string[], baselineRunId?: string | null) =>
+  post<ModelCompareResponse>('/api/models/compare', {
+    run_ids: runIds,
+    baseline_run_id: baselineRunId ?? undefined,
+  });
+
+export const getGateStatus = (params?: {
+  sequence_id?: string;
+  candidate_run_id?: string;
+  baseline_run_id?: string;
+}) => {
+  const q = new URLSearchParams();
+  if (params?.sequence_id) q.set('sequence_id', params.sequence_id);
+  if (params?.candidate_run_id) q.set('candidate_run_id', params.candidate_run_id);
+  if (params?.baseline_run_id) q.set('baseline_run_id', params.baseline_run_id);
+  const qs = q.toString();
+  return get<GateStatusResponse>(`/api/gates/status${qs ? `?${qs}` : ''}`);
+};
+
+export const getEvaluationLevels = () =>
+  get<{ levels: string[]; backends: Record<string, string> }>('/api/evaluations/levels');
+
+export const exportEvidence = (body: Record<string, unknown>) =>
+  post<{ package: Record<string, unknown>; path: string | null }>('/api/evaluations/evidence', body);
+
+export function useContainerQuality(runId: string | null, refreshKey = 0) {
+  return usePoll(
+    () => (runId ? getContainerQuality(runId) : Promise.resolve(null)),
+    null,
+    [runId, refreshKey]
+  );
+}
+
+export function useGateStatus(
+  candidateRunId: string | null,
+  baselineRunId: string | null,
+  refreshKey = 0
+) {
+  return usePoll(
+    () =>
+      getGateStatus({
+        candidate_run_id: candidateRunId ?? undefined,
+        baseline_run_id: baselineRunId ?? undefined,
+      }),
+    8000,
+    [candidateRunId, baselineRunId, refreshKey]
+  );
+}

tests/test_platform/__init__.py

@@ -0,0 +1 @@
+# Phase 1 platform foundation tests

tests/test_platform/test_foundation.py

@@ -0,0 +1,285 @@
+"""Phase 1 platform foundation tests — metrics, container quality, compare, gates, evidence."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from sensorflow.platform.metrics_engine import (
+    aggregate_container_rows,
+    container_quality_metrics,
+    delta_metrics,
+    precision_recall_f1,
+    verification_rates,
+)
+from sensorflow.platform.container_quality import profile_from_counts
+from sensorflow.platform.levels import AggregateLevel, EvaluationScope, summarize_scope
+from sensorflow.platform.gates import (
+    DEFAULT_GATE_CONFIG,
+    evaluate_multi_gates,
+    list_gate_defs,
+    load_gate_config,
+)
+from sensorflow.platform.evidence import build_evidence_package, export_evidence_package
+from sensorflow.platform.compare import compare_models
+from sensorflow.platform.entities import EvidencePackage, Provenance
+
+
+# ------------------------------------------------------------------ metrics
+
+
+def test_precision_recall_f1_basic():
+    out = precision_recall_f1(tp=8, fp=2, fn=2)
+    assert out["precision"] == 0.8
+    assert out["recall"] == 0.8
+    assert out["f1"] == 0.8
+
+
+def test_precision_recall_empty():
+    out = precision_recall_f1(0, 0, 0)
+    assert out["precision"] is None
+    assert out["recall"] is None
+    assert out["f1"] is None
+
+
+def test_verification_rates():
+    v = verification_rates(
+        n_objects=100,
+        verified=40,
+        reviewed=55,
+        disputed=5,
+        auto_accepted=30,
+        hitl=15,
+    )
+    assert v["verified_rate"] == 0.4
+    assert v["hitl_rate"] == 0.15
+    assert v["disputed_rate"] == 0.05
+    assert v["auto_accept_rate"] == 0.3
+    assert v["unverified"] == 60
+
+
+def test_container_quality_metrics_bundle():
+    m = container_quality_metrics(
+        tp=10, fp=5, fn=5, sum_iou=7.0, n_objects=20,
+        verified=8, reviewed=12, hitl=4, anomalies=2,
+    )
+    assert m["precision"] == pytest.approx(10 / 15, rel=1e-3)
+    assert m["mean_iou"] == 0.7
+    assert m["verification"]["verified_rate"] == 0.4
+    assert m["anomaly_rate"] == 0.1
+
+
+def test_aggregate_container_rows():
+    rows = [
+        {"tp": 5, "fp": 1, "fn": 1, "sum_iou": 4.0, "n_objects": 10, "verified": 3, "reviewed": 4},
+        {"tp": 5, "fp": 1, "fn": 1, "sum_iou": 3.5, "n_objects": 10, "verified": 5, "reviewed": 6},
+    ]
+    agg = aggregate_container_rows(rows)
+    assert agg["tp"] == 10
+    assert agg["verification"]["verified"] == 8
+
+
+def test_delta_metrics():
+    deltas = delta_metrics(
+        {"precision": 0.9, "recall": 0.8},
+        {"precision": 0.88, "recall": 0.85},
+        keys=["precision", "recall"],
+    )
+    assert deltas[0]["delta"] == pytest.approx(-0.02)
+    assert deltas[1]["delta"] == pytest.approx(0.05)
+
+
+def test_profile_from_counts():
+    p = profile_from_counts(
+        container_id="c-1", tp=4, fp=1, fn=1, sum_iou=3.2,
+        n_objects=10, verified=2, reviewed=5, hitl=3,
+    )
+    assert p["container_id"] == "c-1"
+    assert p["f1"] is not None
+    assert p["verification"]["hitl"] == 3
+
+
+# ------------------------------------------------------------------ levels
+
+
+def test_aggregate_ladder():
+    ladder = AggregateLevel.ladder()
+    assert ladder[0] == AggregateLevel.FRAME
+    assert ladder[-1] == AggregateLevel.POPULATION
+    assert AggregateLevel.CONTAINER.parent() == AggregateLevel.DATASET
+    assert AggregateLevel.FRAME.child() is None
+
+
+def test_evaluation_scope_summary():
+    scope = EvaluationScope(
+        level=AggregateLevel.CONTAINER,
+        run_id="run-1",
+        mega_container_id=42,
+        model_version="model-v1",
+    )
+    s = summarize_scope(scope)
+    assert s["backend"] == "megaeval"
+    assert s["refs"]["mega_container_id"] == 42
+
+
+# ------------------------------------------------------------------ gates
+
+
+def test_gate_defs_include_multi_gate_skeleton(tmp_path: Path):
+    cfg_path = tmp_path / "gates.json"
+    cfg = load_gate_config(cfg_path)
+    assert cfg_path.exists()
+    defs = list_gate_defs(cfg)
+    types = {d.gate_type for d in defs}
+    for required in ("scenario", "coverage", "regression", "safety", "release", "quality", "launch"):
+        assert required in types
+
+
+def test_evaluate_multi_gates_skeleton(tmp_path: Path, monkeypatch):
+    cfg_path = tmp_path / "gates.json"
+    monkeypatch.setattr(
+        "sensorflow.platform.gates.DEFAULT_GATE_CONFIG_PATH", cfg_path
+    )
+    # rewrite load to use tmp
+    from sensorflow.platform import gates as gates_mod
+    monkeypatch.setattr(gates_mod, "DEFAULT_GATE_CONFIG_PATH", cfg_path)
+    out = gates_mod.evaluate_multi_gates()
+    assert out["summary"]["unwired_count"] >= 3
+    assert out["summary"]["release_ready"] is False
+    types = [g["gate_type"] for g in out["gates"]]
+    assert "scenario" in types and "safety" in types
+    skeleton = [g for g in out["gates"] if g["gate_type"] == "safety"][0]
+    assert skeleton["ready"] is False
+    assert skeleton["passed"] is None
+
+
+def test_gate_config_thresholds_are_config_driven():
+    assert "map_3d" in DEFAULT_GATE_CONFIG["gates"]["quality"]["thresholds"]
+    assert DEFAULT_GATE_CONFIG["gates"]["safety"]["ready"] is False
+
+
+# ------------------------------------------------------------------ evidence
+
+
+def test_evidence_package_stub(tmp_path: Path, monkeypatch):
+    monkeypatch.setattr(
+        "sensorflow.platform.evidence.EVIDENCE_DIR", tmp_path
+    )
+    pkg = build_evidence_package(evaluation_id="eval-test")
+    assert isinstance(pkg, EvidencePackage)
+    assert pkg.evaluation_id == "eval-test"
+    assert "model_versions" in pkg.placeholders or pkg.model_versions
+    path = export_evidence_package(pkg, tmp_path / f"{pkg.package_id}.json")
+    assert path.exists()
+    raw = json.loads(path.read_text())
+    assert raw["evaluation_id"] == "eval-test"
+    assert "gate_results" in raw
+    assert "compute_usage" in raw
+    assert "provenance" in raw
+
+    # append-only: second export with same path gets a revision file
+    path2 = export_evidence_package(pkg, path)
+    assert path2 != path
+    assert path2.exists()
+
+
+# ------------------------------------------------------------------ compare (unit, no mega store)
+
+
+def test_compare_models_requires_two_runs():
+    with pytest.raises(ValueError):
+        compare_models(["only-one"])
+
+
+class _FakeRun:
+    def __init__(self, run_id, model_version, headline, status="published"):
+        self.run_id = run_id
+        self.model_version = model_version
+        self.headline = headline
+        self.status = status
+        self.population_id = "pop-1"
+        self.label_version = "labels-v1"
+
+
+class _FakeStore:
+    def __init__(self, runs):
+        self.runs = {r.run_id: r for r in runs}
+
+    def artifacts(self, run_id):
+        raise NotImplementedError
+
+
+def test_compare_models_matrix(monkeypatch):
+    a = _FakeRun("run-a", "model-A", {
+        "precision": 0.9, "recall": 0.8, "f1": 0.85,
+        "mean_iou": 0.7, "safety_recall": 0.75, "anomaly_rate": 0.1,
+    })
+    b = _FakeRun("run-b", "model-B", {
+        "precision": 0.88, "recall": 0.82, "f1": 0.85,
+        "mean_iou": 0.71, "safety_recall": 0.74, "anomaly_rate": 0.09,
+    })
+    c = _FakeRun("run-c", "model-C", {
+        "precision": 0.91, "recall": 0.79, "f1": 0.845,
+        "mean_iou": 0.69, "safety_recall": 0.78, "anomaly_rate": 0.11,
+    })
+    store = _FakeStore([a, b, c])
+
+    def fake_compare(store, cand, base, policy=None):
+        return {
+            "recommendation": "PROMOTE",
+            "blockers": [],
+            "headline_deltas": [],
+            "per_class": [],
+            "regressions": [],
+        }
+
+    monkeypatch.setattr("sensorflow.megaeval.analysis.compare_runs", fake_compare)
+    out = compare_models(
+        ["run-a", "run-b", "run-c"],
+        baseline_run_id="run-a",
+        store=store,
+    )
+    assert len(out["models"]) == 3
+    assert len(out["pairwise"]) == 2
+    assert len(out["metric_matrix"]) >= 3
+    recall_row = next(r for r in out["metric_matrix"] if r["metric"] == "recall")
+    assert recall_row["model-B"] == 0.82
+    assert recall_row["deltas_vs_baseline"]["model-B"] == pytest.approx(0.02)
+
+
+# ------------------------------------------------------------------ API smoke (optional FastAPI)
+
+
+def test_platform_router_mounts():
+    from fastapi.testclient import TestClient
+    from sensorflow.platform.api import router
+    from fastapi import FastAPI
+
+    app = FastAPI()
+    app.include_router(router)
+    client = TestClient(app)
+    levels = client.get("/api/evaluations/levels")
+    assert levels.status_code == 200
+    body = levels.json()
+    assert "population" in body["levels"]
+    assert body["backends"]["container"] == "megaeval"
+
+    gates = client.get("/api/gates")
+    assert gates.status_code == 200
+    assert any(g["gate_type"] == "scenario" for g in gates.json()["gates"])
+
+    status = client.get("/api/gates/status")
+    assert status.status_code == 200
+    assert status.json()["summary"]["release_ready"] is False
+
+    evidence = client.post("/api/evaluations/evidence", json={
+        "evaluation_id": "api-eval-1",
+        "persist": False,
+    })
+    assert evidence.status_code == 200
+    assert evidence.json()["package"]["evaluation_id"] == "api-eval-1"
+
+    bad = client.post("/api/models/compare", json={"run_ids": ["x"]})
+    assert bad.status_code == 422 or bad.status_code == 400