Feat: add fleet mode and inference telemetry worker

.gitattributes

@@ -0,0 +1 @@
+*.onnx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -35,7 +35,8 @@ that auto-filters spam.
 - **Frontend:** React + Vite + TypeScript, Tailwind CSS, react-leaflet (OpenStreetMap), Recharts,
   lucide-react.
 
----
+---Read test_dashboard.py
+
 
 ## Setup
 

backend/app/api/fleet.py

@@ -0,0 +1,135 @@
+"""Fleet Mode telemetry ingestion.
+
+Mounted phones run inference locally and send only compact hazard telemetry plus an optional
+privacy-processed thumbnail. This endpoint intentionally does no model inference and no DBSCAN in
+the request path.
+"""
+from __future__ import annotations
+
+import base64
+import io
+import uuid
+from datetime import datetime, timedelta, timezone
+
+from fastapi import APIRouter, Depends, HTTPException
+from PIL import Image, UnidentifiedImageError
+from sqlmodel import Session
+
+from app.config import settings
+from app.db.repository import Repository
+from app.db.session import get_session
+from app.models.schemas import (
+    FleetTelemetryIn,
+    FleetTelemetryResponse,
+    GeoSource,
+    HazardType,
+    Severity,
+    Source,
+)
+from app.models.tables import HazardReport
+
+router = APIRouter(prefix="/fleet", tags=["fleet"])
+
+
+def _utc(dt: datetime) -> datetime:
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+def _severity_from_area(area_frac: float | None) -> Severity:
+    if area_frac is None:
+        return Severity.low
+    if area_frac >= settings.SEV_HIGH:
+        return Severity.high
+    if area_frac >= settings.SEV_MED:
+        return Severity.medium
+    return Severity.low
+
+
+def _validate_timestamp(ts: datetime) -> datetime:
+    observed_at = _utc(ts)
+    now = datetime.now(timezone.utc)
+    if observed_at < now - timedelta(hours=settings.FLEET_MAX_EVENT_AGE_HOURS):
+        raise HTTPException(status_code=422, detail="Telemetry timestamp is too old.")
+    if observed_at > now + timedelta(minutes=settings.FLEET_MAX_CLOCK_SKEW_MINUTES):
+        raise HTTPException(status_code=422, detail="Telemetry timestamp is in the future.")
+    return observed_at
+
+
+def _store_thumbnail(thumbnail_b64: str | None) -> str | None:
+    if not thumbnail_b64:
+        return None
+
+    raw_b64 = thumbnail_b64.split(",", 1)[1] if "," in thumbnail_b64 else thumbnail_b64
+    if len(raw_b64) > settings.FLEET_MAX_THUMBNAIL_BYTES * 2:
+        raise HTTPException(status_code=413, detail="Thumbnail payload is too large.")
+
+    try:
+        data = base64.b64decode(raw_b64, validate=True)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail="Thumbnail is not valid Base64.") from exc
+
+    if len(data) > settings.FLEET_MAX_THUMBNAIL_BYTES:
+        raise HTTPException(status_code=413, detail="Thumbnail payload is too large.")
+
+    try:
+        img = Image.open(io.BytesIO(data)).convert("RGB")
+    except (UnidentifiedImageError, OSError) as exc:
+        raise HTTPException(status_code=422, detail="Thumbnail is not a valid image.") from exc
+
+    img.thumbnail((320, 320))
+    out = io.BytesIO()
+    img.save(out, format="JPEG", quality=62, optimize=True)
+
+    fleet_dir = settings.MEDIA_DIR / "fleet"
+    fleet_dir.mkdir(parents=True, exist_ok=True)
+    filename = f"{uuid.uuid4().hex}.jpg"
+    path = fleet_dir / filename
+    path.write_bytes(out.getvalue())
+    return f"media/fleet/{filename}"
+
+
+@router.post("/telemetry", response_model=FleetTelemetryResponse)
+async def ingest_telemetry(
+    payload: FleetTelemetryIn,
+    session: Session = Depends(get_session),
+) -> FleetTelemetryResponse:
+    if payload.hazard_type == HazardType.other:
+        raise HTTPException(status_code=422, detail="Fleet telemetry requires a concrete hazard type.")
+    if payload.confidence < settings.FLEET_MIN_CONFIDENCE:
+        raise HTTPException(status_code=422, detail="Detection confidence is below the fleet threshold.")
+    if payload.bbox is not None and len(payload.bbox) != 4:
+        raise HTTPException(status_code=422, detail="bbox must contain [x1, y1, x2, y2].")
+
+    observed_at = _validate_timestamp(payload.timestamp)
+    repo = Repository(session)
+    if payload.client_event_id:
+        duplicate = repo.get_report_by_client_event(payload.client_event_id)
+        if duplicate is not None:
+            return FleetTelemetryResponse(
+                status="accepted",
+                report_id=duplicate.id,
+                queued_for_cluster=False,
+            )
+
+    thumbnail_path = _store_thumbnail(payload.thumbnail_b64)
+    report = HazardReport(
+        observed_at=observed_at,
+        source=Source.fleet_stream,
+        hazard_type=payload.hazard_type,
+        severity=_severity_from_area(payload.bbox_area_frac),
+        confidence=round(payload.confidence, 4),
+        lat=payload.lat,
+        lon=payload.lon,
+        geo_source=GeoSource.device,
+        media_path=thumbnail_path or "",
+        thumbnail_path=thumbnail_path,
+        bbox=payload.bbox or [],
+        bbox_area_frac=payload.bbox_area_frac,
+        device_speed=payload.speed,
+        client_event_id=payload.client_event_id,
+        auto_validated=True,
+    )
+    report = repo.add_report(report)
+    return FleetTelemetryResponse(status="accepted", report_id=report.id, queued_for_cluster=True)

backend/app/config.py

@@ -41,6 +41,13 @@ class Settings(BaseSettings):
     DBSCAN_EPS_M: float = 20.0   # cluster radius in metres
     DBSCAN_MIN_SAMPLES: int = 1  # single reports still form a (low-confidence) cluster
     RECLUSTER_RADIUS_M: float = 200.0  # bounding box around a new report to re-cluster
+    FLEET_CLUSTER_EPS_M: float = 25.0
+    FLEET_CLUSTER_INTERVAL_SECONDS: int = 300
+    FLEET_CLUSTER_LOOKBACK_HOURS: int = 24 * 14
+    FLEET_MIN_CONFIDENCE: float = 0.35
+    FLEET_MAX_THUMBNAIL_BYTES: int = 160_000
+    FLEET_MAX_EVENT_AGE_HOURS: int = 24
+    FLEET_MAX_CLOCK_SKEW_MINUTES: int = 5
 
     # --- Anonymization ---
     ANON_BLUR_KERNEL: int = 31  # Gaussian blur kernel (odd); scaled by region size at runtime

backend/app/db/repository.py

@@ -5,7 +5,7 @@ This is the single swap boundary: moving SQLite -> Postgres/PostGIS should only
 """
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 from sqlalchemy import case, func
 from sqlmodel import Session, select
@@ -28,6 +28,10 @@ class Repository:
     def get_report(self, report_id: str) -> HazardReport | None:
         return self.session.get(HazardReport, report_id)
 
+    def get_report_by_client_event(self, client_event_id: str) -> HazardReport | None:
+        stmt = select(HazardReport).where(HazardReport.client_event_id == client_event_id)
+        return self.session.exec(stmt).first()
+
     def reports_near(self, lat: float, lon: float, radius_m: float) -> list[HazardReport]:
         """Reports within a lat/lon bounding box around a point (cheap pre-filter for dedup).
 
@@ -73,6 +77,16 @@ class Repository:
         )
         return list(self.session.exec(stmt).all())
 
+    def reports_for_batch_clustering(self, lookback_hours: int) -> list[HazardReport]:
+        """Active reports considered by the periodic Fleet Mode clustering pass."""
+        cutoff = datetime.now(timezone.utc) - timedelta(hours=lookback_hours)
+        stmt = (
+            select(HazardReport)
+            .where(HazardReport.status != Status.fixed)
+            .where(HazardReport.created_at >= cutoff)
+        )
+        return list(self.session.exec(stmt).all())
+
     def assign_cluster(self, report_ids: list[str], cluster_id: str) -> None:
         for rid in report_ids:
             r = self.session.get(HazardReport, rid)
@@ -81,6 +95,14 @@ class Repository:
                 self.session.add(r)
         self.session.commit()
 
+    def clear_cluster_assignments(self, report_ids: list[str]) -> None:
+        for rid in report_ids:
+            r = self.session.get(HazardReport, rid)
+            if r is not None:
+                r.cluster_id = None
+                self.session.add(r)
+        self.session.commit()
+
     # --- Clusters --------------------------------------------------------------
     def add_cluster(self, cluster: HazardCluster) -> HazardCluster:
         self.session.add(cluster)
@@ -202,6 +224,9 @@ class Repository:
         )
         return list(self.session.exec(stmt).all())
 
+    def count_reports_by_source(self) -> dict[str, int]:
+        return self._counts(HazardReport.source)
+
     def reports_over_time(self) -> list[tuple[str, int]]:
         """(date, report-count) grouped by calendar day, ascending."""
         day = func.date(HazardReport.created_at)

backend/app/db/session.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 
+from sqlalchemy import inspect, text
 from sqlmodel import Session, SQLModel, create_engine
 
 from app.config import settings
@@ -20,6 +21,63 @@ def init_db() -> None:
     from app.models import tables  # noqa: F401
 
     SQLModel.metadata.create_all(engine)
+    _migrate_existing_sqlite()
+
+
+def _migrate_existing_sqlite() -> None:
+    """Small additive migrations for the hackathon SQLite prototype.
+
+    SQLModel's `create_all` creates fresh tables but does not alter existing demo DBs. Fleet Mode
+    adds only nullable/defaulted columns, so simple `ALTER TABLE ADD COLUMN` statements are enough.
+    """
+    if not settings.DB_URL.startswith("sqlite"):
+        return
+
+    inspector = inspect(engine)
+    table_names = set(inspector.get_table_names())
+    if "hazardreport" not in table_names or "hazardcluster" not in table_names:
+        return
+
+    report_cols = {c["name"] for c in inspector.get_columns("hazardreport")}
+    cluster_cols = {c["name"] for c in inspector.get_columns("hazardcluster")}
+    report_additions = {
+        "observed_at": "DATETIME",
+        "device_speed": "FLOAT",
+        "thumbnail_path": "VARCHAR",
+        "bbox_area_frac": "FLOAT",
+        "client_event_id": "VARCHAR",
+    }
+    cluster_additions = {
+        "fleet_report_count": "INTEGER DEFAULT 0",
+        "citizen_report_count": "INTEGER DEFAULT 0",
+        "avg_device_speed": "FLOAT",
+    }
+
+    with engine.begin() as conn:
+        for col, ddl in report_additions.items():
+            if col not in report_cols:
+                conn.execute(text(f"ALTER TABLE hazardreport ADD COLUMN {col} {ddl}"))
+        for col, ddl in cluster_additions.items():
+            if col not in cluster_cols:
+                conn.execute(text(f"ALTER TABLE hazardcluster ADD COLUMN {col} {ddl}"))
+
+        # Normalize pre-Fleet rows to the new public enums.
+        conn.execute(text("UPDATE hazardreport SET source = 'fleet_stream' WHERE source = 'dashcam'"))
+        conn.execute(
+            text(
+                "UPDATE hazardreport SET hazard_type = 'crack' "
+                "WHERE hazard_type IN ('longitudinal_crack', 'transverse_crack', 'alligator_crack')"
+            )
+        )
+        conn.execute(text("UPDATE hazardreport SET hazard_type = 'construction_zone' WHERE hazard_type = 'debris'"))
+        conn.execute(
+            text(
+                "UPDATE hazardcluster SET hazard_type = 'crack' "
+                "WHERE hazard_type IN ('longitudinal_crack', 'transverse_crack', 'alligator_crack')"
+            )
+        )
+        conn.execute(text("UPDATE hazardcluster SET hazard_type = 'construction_zone' WHERE hazard_type = 'debris'"))
+        conn.execute(text("UPDATE hazardreport SET observed_at = created_at WHERE observed_at IS NULL"))
 
 
 def get_session() -> Iterator[Session]:

backend/app/main.py

@@ -5,9 +5,12 @@ dedup, and dashboard endpoints fill in over later milestones.
 """
 from __future__ import annotations
 
-from contextlib import asynccontextmanager
+import asyncio
+import logging
+from contextlib import asynccontextmanager, suppress
 
 from fastapi import FastAPI
+from fastapi.concurrency import run_in_threadpool
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
@@ -16,11 +19,38 @@ from app.config import settings
 from app.config import BACKEND_DIR
 from app.db.session import init_db
 
+logger = logging.getLogger(__name__)
+
+
+def _run_fleet_batch_cluster() -> None:
+    from sqlmodel import Session
+
+    from app.db.session import engine
+    from app.pipeline.dedup import batch_recluster_fleet
+
+    with Session(engine) as session:
+        batch_recluster_fleet(session)
+
+
+async def _fleet_cluster_loop() -> None:
+    while True:
+        await asyncio.sleep(settings.FLEET_CLUSTER_INTERVAL_SECONDS)
+        try:
+            await run_in_threadpool(_run_fleet_batch_cluster)
+        except Exception:
+            logger.exception("Fleet clustering batch failed")
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     init_db()
-    yield
+    fleet_task = asyncio.create_task(_fleet_cluster_loop())
+    try:
+        yield
+    finally:
+        fleet_task.cancel()
+        with suppress(asyncio.CancelledError):
+            await fleet_task
 
 
 app = FastAPI(title="RoadRecon API", version="0.1.0", lifespan=lifespan)
@@ -54,6 +84,13 @@ try:
 except Exception:  # pragma: no cover - routes land in M2/M5
     pass
 
+try:
+    from app.api import fleet as fleet_api
+
+    app.include_router(fleet_api.router)
+except Exception:  # pragma: no cover - routes land in Fleet Mode
+    pass
+
 try:
     from app.api import dashboard as dashboard_api
 

backend/app/models/schemas.py

@@ -4,15 +4,15 @@ from __future__ import annotations
 from datetime import datetime
 from enum import Enum
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class HazardType(str, Enum):
     pothole = "pothole"
-    longitudinal_crack = "longitudinal_crack"
-    transverse_crack = "transverse_crack"
-    alligator_crack = "alligator_crack"
-    debris = "debris"
+    crack = "crack"
+    water_logging = "water_logging"
+    construction_zone = "construction_zone"
+    traffic_block = "traffic_block"
     other = "other"
 
 
@@ -24,7 +24,7 @@ class Severity(str, Enum):
 
 class Source(str, Enum):
     citizen = "citizen"
-    dashcam = "dashcam"
+    fleet_stream = "fleet_stream"
 
 
 class GeoSource(str, Enum):
@@ -80,6 +80,9 @@ class ClusterOut(BaseModel):
     last_seen: datetime
     status: Status
     resolved_at: datetime | None = None
+    fleet_report_count: int = 0
+    citizen_report_count: int = 0
+    avg_device_speed: float | None = None
 
 
 class ReportOut(BaseModel):
@@ -87,6 +90,7 @@ class ReportOut(BaseModel):
 
     id: str
     created_at: datetime
+    observed_at: datetime | None = None
     source: Source
     hazard_type: HazardType
     severity: Severity
@@ -95,7 +99,11 @@ class ReportOut(BaseModel):
     lon: float
     geo_source: GeoSource
     media_path: str
+    thumbnail_path: str | None = None
     bbox: list[float]
+    bbox_area_frac: float | None = None
+    device_speed: float | None = None
+    client_event_id: str | None = None
     status: Status
     auto_validated: bool
     cluster_id: str | None
@@ -132,3 +140,24 @@ class DashboardSummary(BaseModel):
     by_status: dict[str, int]
     reports_over_time: list[TimePoint]
     top_priority: list[ClusterOut]
+
+
+class FleetTelemetryIn(BaseModel):
+    """Telemetry-only payload emitted by an on-device Fleet Mode edge node."""
+
+    lat: float = Field(ge=-90, le=90)
+    lon: float = Field(ge=-180, le=180)
+    hazard_type: HazardType
+    confidence: float = Field(ge=0, le=1)
+    timestamp: datetime
+    speed: float | None = Field(default=None, ge=0)
+    bbox: list[float] | None = None
+    bbox_area_frac: float | None = Field(default=None, ge=0, le=1)
+    thumbnail_b64: str | None = None
+    client_event_id: str | None = Field(default=None, min_length=8, max_length=128)
+
+
+class FleetTelemetryResponse(BaseModel):
+    status: str
+    report_id: str
+    queued_for_cluster: bool

backend/app/models/tables.py

@@ -24,6 +24,7 @@ class HazardReport(SQLModel, table=True):
 
     id: str = Field(default_factory=_uuid, primary_key=True)
     created_at: datetime = Field(default_factory=_now, index=True)
+    observed_at: datetime | None = Field(default_factory=_now, index=True)
     source: Source = Field(index=True)
     hazard_type: HazardType = Field(index=True)
     severity: Severity = Field(index=True)
@@ -31,8 +32,12 @@ class HazardReport(SQLModel, table=True):
     lat: float = Field(index=True)
     lon: float = Field(index=True)
     geo_source: GeoSource
-    media_path: str  # path to the ANONYMIZED image (never the raw one)
+    media_path: str = ""  # path to anonymized citizen media or a privacy-safe fleet thumbnail
+    thumbnail_path: str | None = None
     bbox: list[float] = Field(sa_column=Column(JSON))  # [x1, y1, x2, y2]
+    bbox_area_frac: float | None = None
+    device_speed: float | None = Field(default=None, index=True)
+    client_event_id: str | None = Field(default=None, index=True)
     status: Status = Field(default=Status.reported, index=True)
     # True when CV detected the hazard; False for citizen "report anyway" (awaits officer review).
     auto_validated: bool = Field(default=True, index=True)
@@ -52,6 +57,9 @@ class HazardCluster(SQLModel, table=True):
     last_seen: datetime = Field(default_factory=_now)
     status: Status = Field(default=Status.reported, index=True)  # rolled up from members
     resolved_at: datetime | None = Field(default=None)  # set when status -> fixed (time-to-repair)
+    fleet_report_count: int = Field(default=0, index=True)
+    citizen_report_count: int = Field(default=0, index=True)
+    avg_device_speed: float | None = None
 
 
 class StatusEvent(SQLModel, table=True):

backend/app/pipeline/dedup.py

@@ -9,8 +9,7 @@ bounding box around that point, then upsert the affected clusters.
 """
 from __future__ import annotations
 
-import math
-from collections import Counter
+from collections import Counter, defaultdict
 
 import numpy as np
 from sklearn.cluster import DBSCAN
@@ -18,7 +17,7 @@ from sqlmodel import Session
 
 from app.config import settings
 from app.db.repository import Repository
-from app.models.schemas import HazardType, Severity, Status
+from app.models.schemas import HazardType, Severity, Source, Status
 from app.models.tables import HazardCluster, HazardReport
 
 _EARTH_RADIUS_M = 6_371_000.0
@@ -45,6 +44,114 @@ def _rollup_status(reports: list[HazardReport]) -> Status:
     return max(statuses, key=lambda s: _STATUS_RANK[s])
 
 
+def _source_value(source: Source | str) -> str:
+    return source.value if hasattr(source, "value") else str(source)
+
+
+def _source_counts(reports: list[HazardReport]) -> tuple[int, int]:
+    fleet = sum(1 for r in reports if _source_value(r.source) == Source.fleet_stream.value)
+    citizen = sum(1 for r in reports if _source_value(r.source) == Source.citizen.value)
+    return fleet, citizen
+
+
+def _avg_device_speed(reports: list[HazardReport]) -> float | None:
+    speeds = [r.device_speed for r in reports if r.device_speed is not None]
+    return round(float(np.mean(speeds)), 2) if speeds else None
+
+
+def _robust_centroid(reports: list[HazardReport]) -> tuple[float, float]:
+    """Median centroid resists GPS wobble from moving bikes better than a raw mean."""
+    return float(np.median([r.lat for r in reports])), float(np.median([r.lon for r in reports]))
+
+
+def _upsert_cluster(repo: Repository, members: list[HazardReport]) -> HazardCluster:
+    lat, lon = _robust_centroid(members)
+    fleet_count, citizen_count = _source_counts(members)
+    existing_id = next((m.cluster_id for m in members if m.cluster_id), None)
+    first_seen = min((m.observed_at or m.created_at) for m in members)
+    last_seen = max((m.observed_at or m.created_at) for m in members)
+    cluster = repo.get_cluster(existing_id) if existing_id else None
+
+    if cluster is None:
+        cluster = HazardCluster(
+            centroid_lat=lat,
+            centroid_lon=lon,
+            hazard_type=_majority_type(members),
+            severity=_max_severity(members),
+            report_count=len(members),
+            first_seen=first_seen,
+            last_seen=last_seen,
+            status=_rollup_status(members),
+            fleet_report_count=fleet_count,
+            citizen_report_count=citizen_count,
+            avg_device_speed=_avg_device_speed(members),
+        )
+        if existing_id:
+            cluster.id = existing_id
+        return repo.add_cluster(cluster)
+
+    cluster.centroid_lat = lat
+    cluster.centroid_lon = lon
+    cluster.hazard_type = _majority_type(members)
+    cluster.severity = _max_severity(members)
+    cluster.report_count = len(members)
+    cluster.first_seen = first_seen
+    cluster.last_seen = last_seen
+    cluster.status = _rollup_status(members)
+    cluster.fleet_report_count = fleet_count
+    cluster.citizen_report_count = citizen_count
+    cluster.avg_device_speed = _avg_device_speed(members)
+    return repo.save_cluster(cluster)
+
+
+def _cluster_reports_by_type(
+    reports: list[HazardReport],
+    session: Session,
+    eps_m: float,
+    fleet_min_samples: int,
+) -> list[HazardCluster]:
+    """Cluster reports per hazard class and keep fleet-only singletons unclustered."""
+    if not reports:
+        return []
+
+    repo = Repository(session)
+    old_cluster_ids = {r.cluster_id for r in reports if r.cluster_id}
+    live_report_ids: set[str] = set()
+    clusters: list[HazardCluster] = []
+
+    reports_by_type: dict[HazardType, list[HazardReport]] = defaultdict(list)
+    for report in reports:
+        reports_by_type[report.hazard_type].append(report)
+
+    eps_rad = eps_m / _EARTH_RADIUS_M
+    for type_reports in reports_by_type.values():
+        coords = np.radians([[r.lat, r.lon] for r in type_reports])
+        labels = DBSCAN(eps=eps_rad, min_samples=1, metric="haversine").fit_predict(coords)
+        groups: dict[int, list[HazardReport]] = {}
+        for label, report in zip(labels, type_reports):
+            groups.setdefault(int(label), []).append(report)
+
+        for members in groups.values():
+            fleet_count, citizen_count = _source_counts(members)
+            if citizen_count == 0 and fleet_count < fleet_min_samples:
+                continue
+            cluster = _upsert_cluster(repo, members)
+            repo.assign_cluster([m.id for m in members], cluster.id)
+            live_report_ids.update(m.id for m in members)
+            clusters.append(cluster)
+
+    skipped_report_ids = [r.id for r in reports if r.id not in live_report_ids and r.cluster_id]
+    if skipped_report_ids:
+        repo.clear_cluster_assignments(skipped_report_ids)
+
+    live_ids = {c.id for c in clusters}
+    for cid in old_cluster_ids - live_ids:
+        if not repo.reports_in_cluster(cid):
+            repo.delete_cluster(cid)
+
+    return clusters
+
+
 def recluster_near(lat: float, lon: float, session: Session, radius_m: float | None = None) -> list[HazardCluster]:
     """Re-cluster all reports near (lat, lon) and upsert their HazardCluster rows.
 
@@ -56,61 +163,26 @@ def recluster_near(lat: float, lon: float, session: Session, radius_m: float | N
     if not reports:
         return []
 
-    coords = np.radians([[r.lat, r.lon] for r in reports])
-    eps_rad = settings.DBSCAN_EPS_M / _EARTH_RADIUS_M
-    labels = DBSCAN(
-        eps=eps_rad,
-        min_samples=settings.DBSCAN_MIN_SAMPLES,
-        metric="haversine",
-    ).fit_predict(coords)
+    return _cluster_reports_by_type(
+        reports,
+        session,
+        eps_m=settings.DBSCAN_EPS_M,
+        fleet_min_samples=1,
+    )
 
-    # Clear stale cluster rows for any cluster these reports previously belonged to, then rebuild.
-    old_cluster_ids = {r.cluster_id for r in reports if r.cluster_id}
 
-    clusters: list[HazardCluster] = []
-    groups: dict[int, list[HazardReport]] = {}
-    for label, report in zip(labels, reports):
-        groups.setdefault(int(label), []).append(report)
-
-    for members in groups.values():
-        lats = [m.lat for m in members]
-        lons = [m.lon for m in members]
-        # Reuse an existing cluster id among the members if present (stable ids across re-clusters).
-        existing_id = next((m.cluster_id for m in members if m.cluster_id), None)
-        first_seen = min(m.created_at for m in members)
-        last_seen = max(m.created_at for m in members)
-        cluster = repo.get_cluster(existing_id) if existing_id else None
-        if cluster is None:
-            cluster = HazardCluster(
-                centroid_lat=float(np.mean(lats)),
-                centroid_lon=float(np.mean(lons)),
-                hazard_type=_majority_type(members),
-                severity=_max_severity(members),
-                report_count=len(members),
-                first_seen=first_seen,
-                last_seen=last_seen,
-                status=_rollup_status(members),
-            )
-            if existing_id:
-                cluster.id = existing_id
-            cluster = repo.add_cluster(cluster)
-        else:
-            cluster.centroid_lat = float(np.mean(lats))
-            cluster.centroid_lon = float(np.mean(lons))
-            cluster.hazard_type = _majority_type(members)
-            cluster.severity = _max_severity(members)
-            cluster.report_count = len(members)
-            cluster.first_seen = first_seen
-            cluster.last_seen = last_seen
-            cluster.status = _rollup_status(members)
-            cluster = repo.save_cluster(cluster)
-        repo.assign_cluster([m.id for m in members], cluster.id)
-        clusters.append(cluster)
-
-    # Drop any old cluster rows that no longer have members (e.g. merged away).
-    live_ids = {c.id for c in clusters}
-    for cid in old_cluster_ids - live_ids:
-        if not repo.reports_in_cluster(cid):
-            repo.delete_cluster(cid)
+def batch_recluster_fleet(session: Session) -> list[HazardCluster]:
+    """Periodic clustering pass for high-frequency Fleet Mode telemetry.
 
+    Fleet-only observations need at least two nearby passes before they become authority-facing
+    clusters. Citizen reports still form single-report clusters so the manual demo remains instant.
+    """
+    repo = Repository(session)
+    reports = repo.reports_for_batch_clustering(settings.FLEET_CLUSTER_LOOKBACK_HOURS)
+    clusters = _cluster_reports_by_type(
+        reports,
+        session,
+        eps_m=settings.FLEET_CLUSTER_EPS_M,
+        fleet_min_samples=max(2, settings.DBSCAN_MIN_SAMPLES),
+    )
     return clusters

backend/app/pipeline/detect.py

@@ -20,14 +20,22 @@ logger = logging.getLogger(__name__)
 _CLASS_TO_HAZARD = {
     "pothole": HazardType.pothole,
     "potholes": HazardType.pothole,
-    "d00": HazardType.longitudinal_crack,   # RDD2022 codes (Option B forward-compat)
-    "d10": HazardType.transverse_crack,
-    "d20": HazardType.alligator_crack,
+    "d00": HazardType.crack,   # RDD2022 codes (Option B forward-compat)
+    "d10": HazardType.crack,
+    "d20": HazardType.crack,
     "d40": HazardType.pothole,
-    "longitudinal_crack": HazardType.longitudinal_crack,
-    "transverse_crack": HazardType.transverse_crack,
-    "alligator_crack": HazardType.alligator_crack,
-    "debris": HazardType.debris,
+    "crack": HazardType.crack,
+    "longitudinal_crack": HazardType.crack,
+    "transverse_crack": HazardType.crack,
+    "alligator_crack": HazardType.crack,
+    "water_logging": HazardType.water_logging,
+    "waterlogging": HazardType.water_logging,
+    "flooded_road": HazardType.water_logging,
+    "construction_zone": HazardType.construction_zone,
+    "construction": HazardType.construction_zone,
+    "roadwork": HazardType.construction_zone,
+    "traffic_block": HazardType.traffic_block,
+    "traffic_jam": HazardType.traffic_block,
 }
 
 

backend/seed.py

@@ -37,8 +37,8 @@ PUNE_SPOTS = [
 
 TYPES = [
     HazardType.pothole, HazardType.pothole, HazardType.pothole,  # weight potholes higher
-    HazardType.alligator_crack, HazardType.longitudinal_crack,
-    HazardType.transverse_crack, HazardType.debris,
+    HazardType.crack, HazardType.crack,
+    HazardType.water_logging, HazardType.construction_zone, HazardType.traffic_block,
 ]
 SEVERITIES = [Severity.low, Severity.medium, Severity.high]
 
@@ -88,7 +88,7 @@ def seed(reset: bool = True, seed_value: int = 42) -> None:
                 created = now - first_offset + timedelta(hours=rng.uniform(0, 24) * k / max(1, n_passes))
                 session.add(
                     HazardReport(
-                        source=rng.choice([Source.citizen, Source.dashcam]),
+                        source=rng.choice([Source.citizen, Source.fleet_stream]),
                         hazard_type=HazardType.other if review_item else htype,
                         severity=Severity.medium if review_item else sev,
                         confidence=0.0 if review_item else round(rng.uniform(0.4, 0.95), 2),
@@ -100,6 +100,8 @@ def seed(reset: bool = True, seed_value: int = 42) -> None:
                         status=Status.pending_review if review_item else Status.reported,
                         auto_validated=not review_item,
                         created_at=created,
+                        observed_at=created,
+                        device_speed=round(rng.uniform(0.0, 11.5), 1) if htype == HazardType.traffic_block else None,
                     )
                 )
                 total_reports += 1

backend/tests/test_dashboard.py

@@ -18,7 +18,7 @@ def _seed_two_passes(c):
         raw = f.read()
     for la, lo in [(18.5204, 73.8567), (18.52047, 73.85676)]:
         c.post("/report", files={"file": ("p.jpg", raw, "image/jpeg")},
-               data={"source": "dashcam", "device_lat": str(la), "device_lon": str(lo), "annotate": "false"})
+               data={"source": "fleet_stream", "device_lat": str(la), "device_lon": str(lo), "annotate": "false"})
 
 
 @needs_model

backend/tests/test_dedup.py

@@ -51,19 +51,19 @@ def test_far_reports_stay_separate(tmp_path):
     assert all(c.report_count == 1 for c in clusters)
 
 
-def test_cluster_severity_is_max_and_type_majority(tmp_path):
+def test_cluster_severity_is_max_and_types_do_not_merge(tmp_path):
     eng = _engine(tmp_path)
     with Session(eng) as s:
         s.add(_report(*PT, sev=Severity.low, htype=HazardType.pothole))
         s.add(_report(*PT, sev=Severity.high, htype=HazardType.pothole))
-        s.add(_report(*NEAR, sev=Severity.medium, htype=HazardType.debris))
+        s.add(_report(*NEAR, sev=Severity.medium, htype=HazardType.crack))
         s.commit()
         clusters = recluster_near(*PT, s)
-    assert len(clusters) == 1
-    c = clusters[0]
+    assert len(clusters) == 2
+    c = next(c for c in clusters if c.hazard_type == HazardType.pothole)
     assert c.severity == Severity.high           # max severity
-    assert c.hazard_type == HazardType.pothole    # majority vote (2 pothole vs 1 debris)
-    assert c.report_count == 3
+    assert c.report_count == 2
+    assert any(c.hazard_type == HazardType.crack and c.report_count == 1 for c in clusters)
 
 
 def test_status_rolls_up_to_active(tmp_path):

backend/tests/test_fleet.py

@@ -0,0 +1,131 @@
+"""Fleet Mode telemetry ingestion and batch clustering tests."""
+from __future__ import annotations
+
+import base64
+import asyncio
+from datetime import datetime, timedelta, timezone
+
+import httpx
+from PIL import Image
+from sqlmodel import Session, SQLModel, create_engine, select
+
+from app.db.session import get_session
+from app.main import app
+from app.models.schemas import GeoSource, HazardType, Source
+from app.models.tables import HazardReport
+from app.pipeline.dedup import batch_recluster_fleet
+
+
+def _payload(**overrides):
+    data = {
+        "lat": 18.5204,
+        "lon": 73.8567,
+        "hazard_type": "pothole",
+        "confidence": 0.82,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "speed": 4.2,
+        "bbox": [10, 20, 120, 150],
+        "bbox_area_frac": 0.12,
+        "client_event_id": "evt-00000001",
+    }
+    data.update(overrides)
+    return data
+
+
+def _tiny_thumbnail_b64() -> str:
+    import io
+
+    img = Image.new("RGB", (24, 24), (80, 120, 160))
+    out = io.BytesIO()
+    img.save(out, format="PNG")
+    return base64.b64encode(out.getvalue()).decode("ascii")
+
+
+def _engine(tmp_path):
+    eng = create_engine(f"sqlite:///{tmp_path/'fleet.db'}", connect_args={"check_same_thread": False})
+    SQLModel.metadata.create_all(eng)
+    return eng
+
+
+async def _post(engine, payload):
+    async def _override():
+        with Session(engine) as s:
+            yield s
+
+    app.dependency_overrides[get_session] = _override
+    try:
+        transport = httpx.ASGITransport(app=app)
+        async with httpx.AsyncClient(transport=transport, base_url="http://test") as c:
+            return await c.post("/fleet/telemetry", json=payload)
+    finally:
+        app.dependency_overrides.clear()
+
+
+def post(engine, payload):
+    return asyncio.run(_post(engine, payload))
+
+
+def test_fleet_telemetry_accepts_minimal_payload(tmp_path):
+    engine = _engine(tmp_path)
+    r = post(engine, _payload())
+    assert r.status_code == 200, r.text
+    j = r.json()
+    assert j["status"] == "accepted"
+    assert j["report_id"]
+    assert j["queued_for_cluster"] is True
+
+    with Session(engine) as s:
+        report = s.get(HazardReport, j["report_id"])
+    assert report is not None
+    assert report.source == Source.fleet_stream
+    assert report.geo_source == GeoSource.device
+    assert report.device_speed == 4.2
+    assert report.hazard_type == HazardType.pothole
+
+
+def test_fleet_telemetry_dedupes_client_event_id(tmp_path):
+    engine = _engine(tmp_path)
+    payload = _payload(client_event_id="evt-same-0001")
+    first = post(engine, payload).json()
+    second = post(engine, payload).json()
+    assert first["report_id"] == second["report_id"]
+    assert second["queued_for_cluster"] is False
+
+
+def test_fleet_telemetry_stores_sanitized_thumbnail(tmp_path):
+    engine = _engine(tmp_path)
+    r = post(engine, _payload(thumbnail_b64=_tiny_thumbnail_b64()))
+    assert r.status_code == 200, r.text
+    with Session(engine) as s:
+        report = s.get(HazardReport, r.json()["report_id"])
+    assert report.thumbnail_path
+    assert report.media_path == report.thumbnail_path
+    assert report.thumbnail_path.startswith("media/fleet/")
+
+
+def test_fleet_telemetry_rejects_invalid_payloads(tmp_path):
+    engine = _engine(tmp_path)
+    assert post(engine, _payload(lat=100)).status_code == 422
+    assert post(engine, _payload(confidence=0.1)).status_code == 422
+    stale = datetime.now(timezone.utc) - timedelta(days=3)
+    assert post(engine, _payload(timestamp=stale.isoformat())).status_code == 422
+    assert post(engine, _payload(hazard_type="other")).status_code == 422
+    assert post(engine, _payload(thumbnail_b64="not-base64")).status_code == 422
+
+
+def test_batch_clustering_collapses_noisy_fleet_reports_by_type(tmp_path):
+    engine = _engine(tmp_path)
+    post(engine, _payload(client_event_id="evt-pothole-1"))
+    post(engine, _payload(lat=18.52048, lon=73.85675, client_event_id="evt-pothole-2"))
+    post(engine, _payload(hazard_type="crack", client_event_id="evt-crack-1"))
+    post(engine, _payload(hazard_type="crack", lat=18.52047, lon=73.85676, client_event_id="evt-crack-2"))
+
+    with Session(engine) as s:
+        clusters = batch_recluster_fleet(s)
+        reports = list(s.exec(select(HazardReport)).all())
+
+    assert len(clusters) == 2
+    assert sorted(c.hazard_type for c in clusters) == [HazardType.crack, HazardType.pothole]
+    assert all(c.report_count == 2 for c in clusters)
+    assert all(c.fleet_report_count == 2 for c in clusters)
+    assert all(r.cluster_id for r in reports)

backend/tests/test_privacy_gate.py

@@ -81,7 +81,7 @@ def test_persisted_media_is_anonymized(client, tmp_path):
     raw_bytes = enc.tobytes()
 
     r = c.post("/report", files={"file": ("c.jpg", raw_bytes, "image/jpeg")},
-               data={"source": "dashcam", "device_lat": "18.5", "device_lon": "73.8"})
+               data={"source": "fleet_stream", "device_lat": "18.5", "device_lon": "73.8"})
     j = r.json()
     assert j["status"] == "ok", j
 

backend/tests/test_review_history.py

@@ -89,7 +89,7 @@ def test_resolution_history_and_time_to_repair(client):
     with open(POTHOLE, "rb") as f:
         raw = f.read()
     c.post("/report", files={"file": ("p.jpg", raw, "image/jpeg")},
-           data={"source": "dashcam", "device_lat": "18.5", "device_lon": "73.8", "annotate": "false"})
+           data={"source": "fleet_stream", "device_lat": "18.5", "device_lon": "73.8", "annotate": "false"})
     cid = c.get("/hazards", params={"bbox": "18,73,19,74.5"}).json()[0]["id"]
 
     c.patch(f"/hazards/{cid}/status", json={"status": "acknowledged"})

backend/tests/test_video.py

@@ -61,7 +61,7 @@ def test_video_pipeline_samples_and_persists(tmp_path):
     eng = create_engine(f"sqlite:///{tmp_path/'v.db'}", connect_args={"check_same_thread": False})
     SQLModel.metadata.create_all(eng)
     with Session(eng) as s:
-        res = process_upload(raw, Source.dashcam, s, device_lat=18.52, device_lon=73.85,
+        res = process_upload(raw, Source.fleet_stream, s, device_lat=18.52, device_lon=73.85,
                              content_type="video/mp4", filename="clip.mp4")
     assert res.status == "ok"
     assert len(res.reports) >= 1

frontend/package-lock.json

@@ -10,6 +10,7 @@
       "dependencies": {
         "leaflet": "^1.9.4",
         "lucide-react": "^1.18.0",
+        "onnxruntime-web": "^1.26.0",
         "react": "^19.2.6",
         "react-dom": "^19.2.6",
         "react-leaflet": "^5.0.0",
@@ -80,6 +81,7 @@
       "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.29.7",
         "@babel/generator": "^7.29.7",
@@ -289,29 +291,6 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@emnapi/core": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
-      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.2.1",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
-      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
     "node_modules/@emnapi/wasi-threads": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
@@ -634,6 +613,63 @@
         "url": "https://github.com/sponsors/Boshen"
       }
     },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
+      "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
+      "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
+      "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.1.tgz",
+      "integrity": "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/@react-leaflet/core": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/@react-leaflet/core/-/core-3.0.0.tgz",
@@ -1073,7 +1109,6 @@
       "version": "24.13.2",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.2.tgz",
       "integrity": "sha512-fRa09kZTgu8o71KFcDjUFuc7F+dEbZYZmkI0mg5YBTRs0yMKjYHsq/c0urDKeDb+D5qVgXOdFcuu+DZPKOITwA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~7.18.0"
@@ -1085,6 +1120,7 @@
       "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
       "devOptional": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "csstype": "^3.2.2"
       }
@@ -1150,6 +1186,7 @@
       "integrity": "sha512-PJ5vePq5/ognBbrIcoC5+SHO5dfpeLPzP9FpLkzWrguoYQEeeSjlJpVwOpo1JRSTEi7dRcwNy4h4dzV70PqHcg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.61.1",
         "@typescript-eslint/types": "8.61.1",
@@ -1380,6 +1417,7 @@
       "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -1574,6 +1612,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.10.12",
         "caniuse-lite": "^1.0.30001782",
@@ -1963,6 +2002,7 @@
       "integrity": "sha512-1y+7C+vi12bUK1IpZeaV3gsH9fHLBmPvYmPx42pvT/E9yG0IC8g3PUZZgp0+JLJl7ZDK0flc2gc+Aw9dpCvIsQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "workspaces": [
         "packages/*"
       ],
@@ -2284,6 +2324,12 @@
         "node": ">=16"
       }
     },
+    "node_modules/flatbuffers": {
+      "version": "25.9.23",
+      "resolved": "https://registry.npmjs.org/flatbuffers/-/flatbuffers-25.9.23.tgz",
+      "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==",
+      "license": "Apache-2.0"
+    },
     "node_modules/flatted": {
       "version": "3.4.2",
       "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
@@ -2366,6 +2412,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/guid-typescript": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/guid-typescript/-/guid-typescript-1.0.9.tgz",
+      "integrity": "sha512-Y8T4vYhEfwJOTbouREvG+3XDsjr8E3kIr7uf+JZ0BYloFsttiHU0WfvANVsR7TxNUJa/WpCnw/Ino/p+DeBhBQ==",
+      "license": "ISC"
+    },
     "node_modules/hasown": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
@@ -2510,6 +2562,7 @@
       "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "jiti": "bin/jiti.js"
       }
@@ -2582,7 +2635,8 @@
       "version": "1.9.4",
       "resolved": "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz",
       "integrity": "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==",
-      "license": "BSD-2-Clause"
+      "license": "BSD-2-Clause",
+      "peer": true
     },
     "node_modules/levn": {
       "version": "0.4.1",
@@ -2895,6 +2949,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -3052,6 +3112,26 @@
         "node": ">= 6"
       }
     },
+    "node_modules/onnxruntime-common": {
+      "version": "1.26.0",
+      "resolved": "https://registry.npmjs.org/onnxruntime-common/-/onnxruntime-common-1.26.0.tgz",
+      "integrity": "sha512-qVyMR4lcWgbkc4getFV+GQijsTnbg/siteoqcDwa3sI/LxbrMSNw4ePyvCq/ymdQaRomCA7YuWmhzsswxvymdw==",
+      "license": "MIT"
+    },
+    "node_modules/onnxruntime-web": {
+      "version": "1.26.0",
+      "resolved": "https://registry.npmjs.org/onnxruntime-web/-/onnxruntime-web-1.26.0.tgz",
+      "integrity": "sha512-LbRr/8zZt2xilI2smrVQGGKINo0U46i8qJp+UXyMBGfqN7KjnH1BiwCwLwyNIVV4i9CKFv7Sf4PwLKWnT8/bEA==",
+      "license": "MIT",
+      "dependencies": {
+        "flatbuffers": "^25.1.24",
+        "guid-typescript": "^1.0.9",
+        "long": "^5.2.3",
+        "onnxruntime-common": "1.26.0",
+        "platform": "^1.3.6",
+        "protobufjs": "^7.2.4"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -3142,6 +3222,7 @@
       "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -3169,6 +3250,12 @@
         "node": ">= 6"
       }
     },
+    "node_modules/platform": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.6.tgz",
+      "integrity": "sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==",
+      "license": "MIT"
+    },
     "node_modules/playwright": {
       "version": "1.61.0",
       "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.0.tgz",
@@ -3236,6 +3323,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.12",
         "picocolors": "^1.1.1",
@@ -3389,6 +3477,29 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/protobufjs": {
+      "version": "7.6.4",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.6.4.tgz",
+      "integrity": "sha512-RJJPTTpvFfHcWLkIa2JFWK4XvtSzS0yEWDmunqHXli1h3JlkbcQZXDZdcWxv+JK3Xsl5/UFDPZ0iGm7DAengYw==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.5",
+        "@protobufjs/eventemitter": "^1.1.1",
+        "@protobufjs/fetch": "^1.1.1",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.1",
+        "@types/node": ">=13.7.0",
+        "long": "^5.3.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -3425,6 +3536,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
       "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -3434,6 +3546,7 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
       "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "scheduler": "^0.27.0"
       },
@@ -3467,6 +3580,7 @@
       "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.3.0.tgz",
       "integrity": "sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/use-sync-external-store": "^0.0.6",
         "use-sync-external-store": "^1.4.0"
@@ -3593,7 +3707,8 @@
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz",
       "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/redux-thunk": {
       "version": "3.1.0",
@@ -3936,6 +4051,7 @@
       "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -3972,7 +4088,6 @@
       "version": "7.18.2",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
       "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/update-browserslist-db": {
@@ -4060,6 +4175,7 @@
       "integrity": "sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "lightningcss": "^1.32.0",
         "picomatch": "^4.0.4",
@@ -4184,6 +4300,7 @@
       "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }

frontend/package.json

@@ -12,6 +12,7 @@
   "dependencies": {
     "leaflet": "^1.9.4",
     "lucide-react": "^1.18.0",
+    "onnxruntime-web": "^1.26.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
     "react-leaflet": "^5.0.0",

frontend/public/models/README.md

@@ -0,0 +1,11 @@
+Place the browser Fleet Mode model here:
+
+```text
+roadrecon-yolov8n-320-int8.onnx
+```
+
+The worker expects a YOLOv8 detector exported at 320x320 with the class order:
+
+```text
+pothole, crack, water_logging, construction_zone, traffic_block
+```

frontend/public/models/roadrecon-yolov8n-320-int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:215ea71e03d0b3f004fc99c67e5eea8adb0cc2a4d171f15fa662d6afd0fdd77d
+size 12753328

frontend/src/App.tsx

@@ -2,6 +2,7 @@ import { BrowserRouter, Navigate, Route, Routes } from "react-router-dom";
 import { I18nProvider } from "./lib/i18n";
 import Report from "./pages/Report";
 import Dashboard from "./pages/Dashboard";
+import FleetMode from "./pages/FleetMode";
 
 export default function App() {
   return (
@@ -10,6 +11,7 @@ export default function App() {
         <Routes>
           <Route path="/" element={<Navigate to="/report" replace />} />
           <Route path="/report" element={<Report />} />
+          <Route path="/fleet" element={<FleetMode />} />
           <Route path="/dashboard" element={<Dashboard />} />
         </Routes>
       </BrowserRouter>

frontend/src/components/ClusterDrawer.tsx

@@ -42,7 +42,15 @@ export default function ClusterDrawer({ cluster, onClose, onStatusChange }: Prop
     }
   }
 
-  const images = detail ? [...new Set(detail.reports.map((r) => r.media_path))].slice(0, 6) : [];
+  const images = detail
+    ? [
+        ...new Set(
+          detail.reports
+            .map((r) => r.thumbnail_path || r.media_path)
+            .filter((path): path is string => Boolean(path)),
+        ),
+      ].slice(0, 6)
+    : [];
 
   return (
     <div className="absolute inset-y-0 right-0 z-[1000] flex w-96 max-w-full flex-col border-l border-line bg-white shadow-xl">

frontend/src/lib/api.ts

@@ -6,10 +6,10 @@ export const API_BASE =
 export type Severity = "low" | "medium" | "high";
 export type HazardType =
   | "pothole"
-  | "longitudinal_crack"
-  | "transverse_crack"
-  | "alligator_crack"
-  | "debris"
+  | "crack"
+  | "water_logging"
+  | "construction_zone"
+  | "traffic_block"
   | "other";
 export type Status = "pending_review" | "reported" | "acknowledged" | "fixed";
 export type GeoSource = "exif" | "device" | "manual";
@@ -48,6 +48,9 @@ export interface Cluster {
   last_seen: string;
   status: Status;
   resolved_at: string | null;
+  fleet_report_count: number;
+  citizen_report_count: number;
+  avg_device_speed: number | null;
 }
 
 export interface StatusEvent {
@@ -59,6 +62,7 @@ export interface StatusEvent {
 export interface ReportOut {
   id: string;
   created_at: string;
+  observed_at: string | null;
   source: string;
   hazard_type: HazardType;
   severity: Severity;
@@ -67,7 +71,11 @@ export interface ReportOut {
   lon: number;
   geo_source: GeoSource;
   media_path: string;
+  thumbnail_path: string | null;
   bbox: number[];
+  bbox_area_frac: number | null;
+  device_speed: number | null;
+  client_event_id: string | null;
   status: Status;
   cluster_id: string | null;
 }
@@ -113,7 +121,7 @@ export async function health(): Promise<{ ok: boolean; service: string }> {
 
 export async function submitReport(opts: {
   file: File;
-  source?: "citizen" | "dashcam";
+  source?: "citizen" | "fleet_stream";
   deviceLat?: number;
   deviceLon?: number;
   force?: boolean;
@@ -169,6 +177,37 @@ export async function getDashboardSummary(): Promise<DashboardSummary> {
   return r.json();
 }
 
+export interface FleetTelemetryPayload {
+  lat: number;
+  lon: number;
+  hazard_type: Exclude<HazardType, "other">;
+  confidence: number;
+  timestamp: string;
+  speed?: number;
+  bbox?: [number, number, number, number];
+  bbox_area_frac?: number;
+  thumbnail_b64?: string;
+  client_event_id?: string;
+}
+
+export interface FleetTelemetryResponse {
+  status: "accepted";
+  report_id: string;
+  queued_for_cluster: boolean;
+}
+
+export async function submitFleetTelemetry(
+  payload: FleetTelemetryPayload,
+): Promise<FleetTelemetryResponse> {
+  const r = await fetch(`${API_BASE}/fleet/telemetry`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  if (!r.ok) throw new Error(`fleet telemetry ${r.status}`);
+  return r.json();
+}
+
 export const SEVERITY_COLOR: Record<Severity, string> = {
   low: "#16a34a",
   medium: "#f59e0b",
@@ -177,9 +216,9 @@ export const SEVERITY_COLOR: Record<Severity, string> = {
 
 export const HAZARD_LABEL: Record<HazardType, string> = {
   pothole: "Pothole",
-  longitudinal_crack: "Longitudinal crack",
-  transverse_crack: "Transverse crack",
-  alligator_crack: "Alligator crack",
-  debris: "Debris",
+  crack: "Crack",
+  water_logging: "Water logging",
+  construction_zone: "Construction zone",
+  traffic_block: "Traffic block",
   other: "Other",
 };

frontend/src/lib/fleetTelemetry.ts

@@ -0,0 +1,83 @@
+import type { FleetTelemetryPayload, HazardType } from "./api";
+
+export type FleetHazardType = Exclude<HazardType, "other">;
+
+export interface FleetDetection {
+  hazard_type: FleetHazardType;
+  confidence: number;
+  bbox: [number, number, number, number];
+}
+
+export interface FleetLocation {
+  lat: number;
+  lon: number;
+  speed: number | null;
+  at: number;
+}
+
+export interface LastFleetReport {
+  lat: number;
+  lon: number;
+  at: number;
+}
+
+export const FLEET_CONFIDENCE = 0.55;
+export const TRAFFIC_BLOCK_CONFIDENCE = 0.45;
+export const TRAFFIC_BLOCK_SPEED_MPS = 2;
+export const TRAFFIC_BLOCK_DWELL_MS = 10_000;
+export const FLEET_DEBOUNCE_METERS = 10;
+
+const EARTH_RADIUS_M = 6_371_000;
+
+export function haversineMeters(a: Pick<FleetLocation, "lat" | "lon">, b: Pick<FleetLocation, "lat" | "lon">): number {
+  const dLat = ((b.lat - a.lat) * Math.PI) / 180;
+  const dLon = ((b.lon - a.lon) * Math.PI) / 180;
+  const lat1 = (a.lat * Math.PI) / 180;
+  const lat2 = (b.lat * Math.PI) / 180;
+  const h =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.sqrt(h));
+}
+
+export function createClientEventId(): string {
+  if ("randomUUID" in crypto) return crypto.randomUUID();
+  return `fleet-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+export function shouldSendFleetReport(
+  detection: FleetDetection,
+  location: FleetLocation,
+  lastReports: Map<FleetHazardType, LastFleetReport>,
+): boolean {
+  const previous = lastReports.get(detection.hazard_type);
+  if (!previous) return true;
+  return haversineMeters(previous, location) > FLEET_DEBOUNCE_METERS;
+}
+
+export function bboxAreaFraction(bbox: [number, number, number, number], frameSize: number): number {
+  const [x1, y1, x2, y2] = bbox;
+  const w = Math.max(0, x2 - x1);
+  const h = Math.max(0, y2 - y1);
+  return Math.min(1, (w * h) / (frameSize * frameSize));
+}
+
+export function toFleetPayload(opts: {
+  detection: FleetDetection;
+  location: FleetLocation;
+  thumbnailB64?: string;
+  frameSize: number;
+}): FleetTelemetryPayload {
+  return {
+    lat: opts.location.lat,
+    lon: opts.location.lon,
+    hazard_type: opts.detection.hazard_type,
+    confidence: opts.detection.confidence,
+    timestamp: new Date().toISOString(),
+    speed: opts.location.speed ?? undefined,
+    bbox: opts.detection.bbox,
+    bbox_area_frac: bboxAreaFraction(opts.detection.bbox, opts.frameSize),
+    thumbnail_b64: opts.thumbnailB64,
+    client_event_id: createClientEventId(),
+  };
+}

frontend/src/lib/i18n.tsx

@@ -68,11 +68,22 @@ const en: Dict = {
   st_acknowledged: "Acknowledged",
   st_fixed: "Resolved",
   hz_pothole: "Pothole",
-  hz_longitudinal_crack: "Longitudinal crack",
-  hz_transverse_crack: "Transverse crack",
-  hz_alligator_crack: "Alligator crack",
-  hz_debris: "Debris",
+  hz_crack: "Crack",
+  hz_water_logging: "Water logging",
+  hz_construction_zone: "Construction zone",
+  hz_traffic_block: "Traffic block",
   hz_other: "Other hazard",
+  fleet_mode: "Fleet Mode",
+  fleet_tagline: "Edge road sensing",
+  fleet_start: "Start",
+  fleet_stop: "Stop",
+  fleet_ready: "Ready",
+  fleet_live: "Live",
+  fleet_sent: "Sent",
+  fleet_infer: "Inference",
+  fleet_frames: "Frames",
+  fleet_speed: "Speed",
+  fleet_last: "Last event",
 };
 
 const hi: Dict = {
@@ -132,11 +143,22 @@ const hi: Dict = {
   st_acknowledged: "स्वीकृत",
   st_fixed: "ठीक किया",
   hz_pothole: "गड्ढा",
-  hz_longitudinal_crack: "अनुदैर्ध्य दरार",
-  hz_transverse_crack: "अनुप्रस्थ दरार",
-  hz_alligator_crack: "मगरमच्छ दरार",
-  hz_debris: "मलबा",
+  hz_crack: "दरार",
+  hz_water_logging: "जलभराव",
+  hz_construction_zone: "निर्माण क्षेत्र",
+  hz_traffic_block: "ट्रैफिक अवरोध",
   hz_other: "अन्य ख़तरा",
+  fleet_mode: "फ्लीट मोड",
+  fleet_tagline: "एज सड़क सेंसिंग",
+  fleet_start: "शुरू करें",
+  fleet_stop: "रोकें",
+  fleet_ready: "तैयार",
+  fleet_live: "लाइव",
+  fleet_sent: "भेजे गए",
+  fleet_infer: "इन्फरेंस",
+  fleet_frames: "फ्रेम",
+  fleet_speed: "गति",
+  fleet_last: "अंतिम इवेंट",
 };
 
 const mr: Dict = {
@@ -196,11 +218,22 @@ const mr: Dict = {
   st_acknowledged: "स्वीकारले",
   st_fixed: "दुरुस्त",
   hz_pothole: "खड्डा",
-  hz_longitudinal_crack: "रेखांशीय भेग",
-  hz_transverse_crack: "आडवी भेग",
-  hz_alligator_crack: "मगर भेग",
-  hz_debris: "कचरा",
+  hz_crack: "भेग",
+  hz_water_logging: "पाणी साचणे",
+  hz_construction_zone: "बांधकाम क्षेत्र",
+  hz_traffic_block: "वाहतूक अडथळा",
   hz_other: "इतर धोका",
+  fleet_mode: "फ्लीट मोड",
+  fleet_tagline: "एज रस्ता सेन्सिंग",
+  fleet_start: "सुरू करा",
+  fleet_stop: "थांबवा",
+  fleet_ready: "तयार",
+  fleet_live: "लाइव्ह",
+  fleet_sent: "पाठवले",
+  fleet_infer: "इन्फरन्स",
+  fleet_frames: "फ्रेम",
+  fleet_speed: "वेग",
+  fleet_last: "शेवटचा इव्हेंट",
 };
 
 const DICTS: Record<Lang, Dict> = { en, hi, mr };

frontend/src/pages/FleetMode.tsx

@@ -0,0 +1,389 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ReactNode } from "react";
+import { Camera, Loader2, RadioTower, ShieldCheck, Square, Zap } from "lucide-react";
+import Masthead from "../components/Masthead";
+import { submitFleetTelemetry, type FleetTelemetryPayload } from "../lib/api";
+import {
+  FLEET_CONFIDENCE,
+  TRAFFIC_BLOCK_CONFIDENCE,
+  TRAFFIC_BLOCK_DWELL_MS,
+  TRAFFIC_BLOCK_SPEED_MPS,
+  haversineMeters,
+  shouldSendFleetReport,
+  toFleetPayload,
+  type FleetDetection,
+  type FleetHazardType,
+  type FleetLocation,
+  type LastFleetReport,
+} from "../lib/fleetTelemetry";
+import { useT } from "../lib/i18n";
+
+const FRAME_SIZE = 320;
+const MODEL_URL = "/models/roadrecon-yolov8n-320-int8.onnx";
+
+type FleetStatus = "idle" | "starting" | "active" | "error";
+type WorkerMessage =
+  | { type: "ready" }
+  | { type: "result"; detections: FleetDetection[]; inferMs: number }
+  | { type: "error"; message: string };
+
+interface Stats {
+  frames: number;
+  detections: number;
+  sent: number;
+  inferMs: number | null;
+  lastHazard: FleetHazardType | null;
+  lastError: string | null;
+}
+
+function formatSpeed(speed: number | null): string {
+  if (speed == null || !Number.isFinite(speed)) return "--";
+  return `${Math.round(speed * 3.6)} km/h`;
+}
+
+export default function FleetMode() {
+  const { t } = useT();
+  const videoRef = useRef<HTMLVideoElement>(null);
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const workerRef = useRef<Worker | null>(null);
+  const streamRef = useRef<MediaStream | null>(null);
+  const watchIdRef = useRef<number | null>(null);
+  const inFlightRef = useRef(false);
+  const processDetectionsRef = useRef<(detections: FleetDetection[]) => void>(() => {});
+  const lastReportsRef = useRef(new Map<FleetHazardType, LastFleetReport>());
+  const pendingClassesRef = useRef(new Set<FleetHazardType>());
+  const locationRef = useRef<FleetLocation | null>(null);
+  const previousLocationRef = useRef<FleetLocation | null>(null);
+  const smoothedSpeedRef = useRef<number | null>(null);
+  const lowSpeedSinceRef = useRef<number | null>(null);
+
+  const [status, setStatus] = useState<FleetStatus>("idle");
+  const [workerReady, setWorkerReady] = useState(false);
+  const [location, setLocation] = useState<FleetLocation | null>(null);
+  const [stats, setStats] = useState<Stats>({
+    frames: 0,
+    detections: 0,
+    sent: 0,
+    inferMs: null,
+    lastHazard: null,
+    lastError: null,
+  });
+
+  const makeThumbnail = useCallback((bbox: [number, number, number, number]): string | undefined => {
+    const src = canvasRef.current;
+    if (!src) return undefined;
+
+    const [x1, y1, x2, y2] = bbox;
+    const pad = Math.max(8, Math.max(x2 - x1, y2 - y1) * 0.2);
+    const sx = Math.max(0, Math.floor(x1 - pad));
+    const sy = Math.max(0, Math.floor(y1 - pad));
+    const ex = Math.min(FRAME_SIZE, Math.ceil(x2 + pad));
+    const ey = Math.min(FRAME_SIZE, Math.ceil(y2 + pad));
+    const sw = Math.max(1, ex - sx);
+    const sh = Math.max(1, ey - sy);
+    const scale = Math.min(160 / sw, 160 / sh, 1);
+    const dw = Math.max(1, Math.round(sw * scale));
+    const dh = Math.max(1, Math.round(sh * scale));
+
+    const out = document.createElement("canvas");
+    out.width = dw;
+    out.height = dh;
+    const ctx = out.getContext("2d");
+    if (!ctx) return undefined;
+
+    ctx.filter = "blur(8px)";
+    ctx.drawImage(src, sx, sy, sw, sh, 0, 0, dw, dh);
+    ctx.filter = "none";
+    ctx.drawImage(
+      src,
+      x1,
+      y1,
+      Math.max(1, x2 - x1),
+      Math.max(1, y2 - y1),
+      (x1 - sx) * scale,
+      (y1 - sy) * scale,
+      Math.max(1, (x2 - x1) * scale),
+      Math.max(1, (y2 - y1) * scale),
+    );
+    return out.toDataURL("image/jpeg", 0.45);
+  }, []);
+
+  const sendDetection = useCallback(
+    async (detection: FleetDetection, loc: FleetLocation) => {
+      if (pendingClassesRef.current.has(detection.hazard_type)) return;
+      if (!shouldSendFleetReport(detection, loc, lastReportsRef.current)) return;
+
+      pendingClassesRef.current.add(detection.hazard_type);
+      const thumbnail = makeThumbnail(detection.bbox);
+      const payload: FleetTelemetryPayload = toFleetPayload({
+        detection,
+        location: loc,
+        thumbnailB64: thumbnail,
+        frameSize: FRAME_SIZE,
+      });
+
+      try {
+        await submitFleetTelemetry(payload);
+        lastReportsRef.current.set(detection.hazard_type, {
+          lat: loc.lat,
+          lon: loc.lon,
+          at: Date.now(),
+        });
+        setStats((s) => ({
+          ...s,
+          sent: s.sent + 1,
+          lastHazard: detection.hazard_type,
+          lastError: null,
+        }));
+      } catch (err) {
+        setStats((s) => ({
+          ...s,
+          lastError: err instanceof Error ? err.message : "Telemetry failed",
+        }));
+      } finally {
+        pendingClassesRef.current.delete(detection.hazard_type);
+      }
+    },
+    [makeThumbnail],
+  );
+
+  const processDetections = useCallback(
+    (detections: FleetDetection[]) => {
+      const loc = locationRef.current;
+      setStats((s) => ({ ...s, detections: s.detections + detections.length }));
+      if (!loc) return;
+
+      const lowSpeedReady =
+        lowSpeedSinceRef.current != null &&
+        Date.now() - lowSpeedSinceRef.current >= TRAFFIC_BLOCK_DWELL_MS;
+      const accepted = detections
+        .filter((d) => {
+          if (d.hazard_type === "traffic_block") {
+            return d.confidence >= TRAFFIC_BLOCK_CONFIDENCE && lowSpeedReady;
+          }
+          return d.confidence >= FLEET_CONFIDENCE;
+        })
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, 2);
+
+      for (const detection of accepted) {
+        void sendDetection(detection, loc);
+      }
+    },
+    [sendDetection],
+  );
+
+  useEffect(() => {
+    processDetectionsRef.current = processDetections;
+  }, [processDetections]);
+
+  useEffect(() => {
+    const worker = new Worker(new URL("../workers/fleetInference.worker.ts", import.meta.url), {
+      type: "module",
+    });
+    workerRef.current = worker;
+    worker.onmessage = (event: MessageEvent<WorkerMessage>) => {
+      const msg = event.data;
+      if (msg.type === "ready") {
+        setWorkerReady(true);
+        return;
+      }
+      if (msg.type === "error") {
+        inFlightRef.current = false;
+        setStatus("error");
+        setStats((s) => ({ ...s, lastError: msg.message }));
+        return;
+      }
+      inFlightRef.current = false;
+      setStats((s) => ({
+        ...s,
+        frames: s.frames + 1,
+        inferMs: msg.inferMs,
+      }));
+      processDetectionsRef.current(msg.detections);
+    };
+    worker.postMessage({ type: "init", modelUrl: MODEL_URL });
+    return () => {
+      worker.terminate();
+      workerRef.current = null;
+    };
+  }, []);
+
+  const onPosition = useCallback((pos: GeolocationPosition) => {
+    const now = Date.now();
+    const previous = previousLocationRef.current;
+    let speed = pos.coords.speed;
+    if ((speed == null || !Number.isFinite(speed)) && previous) {
+      const dt = Math.max(0.1, (now - previous.at) / 1000);
+      speed = haversineMeters(previous, {
+        lat: pos.coords.latitude,
+        lon: pos.coords.longitude,
+      }) / dt;
+    }
+    if (speed != null && Number.isFinite(speed)) {
+      smoothedSpeedRef.current =
+        smoothedSpeedRef.current == null ? speed : smoothedSpeedRef.current * 0.7 + speed * 0.3;
+    }
+    const loc: FleetLocation = {
+      lat: pos.coords.latitude,
+      lon: pos.coords.longitude,
+      speed: smoothedSpeedRef.current,
+      at: now,
+    };
+    if ((loc.speed ?? Number.POSITIVE_INFINITY) < TRAFFIC_BLOCK_SPEED_MPS) {
+      lowSpeedSinceRef.current ??= now;
+    } else {
+      lowSpeedSinceRef.current = null;
+    }
+    previousLocationRef.current = loc;
+    locationRef.current = loc;
+    setLocation(loc);
+  }, []);
+
+  const stop = useCallback(() => {
+    if (watchIdRef.current != null) {
+      navigator.geolocation.clearWatch(watchIdRef.current);
+      watchIdRef.current = null;
+    }
+    streamRef.current?.getTracks().forEach((track) => track.stop());
+    streamRef.current = null;
+    if (videoRef.current) videoRef.current.srcObject = null;
+    inFlightRef.current = false;
+    setStatus("idle");
+  }, []);
+
+  const start = useCallback(async () => {
+    setStatus("starting");
+    setStats((s) => ({ ...s, lastError: null }));
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: {
+          facingMode: { ideal: "environment" },
+          width: { ideal: 1280 },
+          height: { ideal: 720 },
+        },
+        audio: false,
+      });
+      streamRef.current = stream;
+      if (videoRef.current) {
+        videoRef.current.srcObject = stream;
+        await videoRef.current.play();
+      }
+      watchIdRef.current = navigator.geolocation.watchPosition(
+        onPosition,
+        (err) => setStats((s) => ({ ...s, lastError: err.message })),
+        { enableHighAccuracy: true, maximumAge: 1000, timeout: 10_000 },
+      );
+      setStatus("active");
+    } catch (err) {
+      setStatus("error");
+      setStats((s) => ({
+        ...s,
+        lastError: err instanceof Error ? err.message : "Could not start Fleet Mode",
+      }));
+    }
+  }, [onPosition]);
+
+  useEffect(() => {
+    if (status !== "active" || !workerReady) return undefined;
+    const timer = window.setInterval(() => {
+      const video = videoRef.current;
+      const canvas = canvasRef.current;
+      const worker = workerRef.current;
+      if (!video || !canvas || !worker || document.hidden || inFlightRef.current) return;
+      if (video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
+
+      const ctx = canvas.getContext("2d", { willReadFrequently: true });
+      if (!ctx) return;
+      ctx.drawImage(video, 0, 0, FRAME_SIZE, FRAME_SIZE);
+      const imageData = ctx.getImageData(0, 0, FRAME_SIZE, FRAME_SIZE);
+      inFlightRef.current = true;
+      worker.postMessage(
+        { type: "infer", width: FRAME_SIZE, height: FRAME_SIZE, buffer: imageData.data.buffer },
+        [imageData.data.buffer],
+      );
+    }, 1000);
+    return () => window.clearInterval(timer);
+  }, [status, workerReady]);
+
+  useEffect(() => stop, [stop]);
+
+  const active = status === "active";
+  const busy = status === "starting";
+
+  return (
+    <div className="flex min-h-full flex-col bg-paper">
+      <Masthead compact />
+      <main className="mx-auto flex w-full max-w-5xl flex-1 flex-col gap-4 p-4">
+        <div className="flex flex-wrap items-center gap-3 border-b border-line pb-3">
+          <div>
+            <h1 className="text-xl font-bold text-ink">{t("fleet_mode")}</h1>
+            <p className="text-sm text-ink-soft">{t("fleet_tagline")}</p>
+          </div>
+          <button
+            onClick={active || busy ? stop : start}
+            disabled={!workerReady && !active}
+            className={`ml-auto inline-flex items-center gap-2 rounded-md px-4 py-2 text-sm font-semibold text-white ${
+              active ? "bg-sev-high hover:bg-red-700" : "bg-gov-700 hover:bg-gov-900"
+            } disabled:cursor-not-allowed disabled:opacity-50`}
+          >
+            {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : active ? <Square className="h-4 w-4" /> : <Camera className="h-4 w-4" />}
+            {active || busy ? t("fleet_stop") : t("fleet_start")}
+          </button>
+        </div>
+
+        <div className="grid min-h-0 flex-1 gap-4 lg:grid-cols-[minmax(0,1fr)_280px]">
+          <section className="relative min-h-[420px] overflow-hidden rounded-md border border-line bg-black">
+            <video ref={videoRef} muted playsInline className="h-full min-h-[420px] w-full object-cover" />
+            <canvas ref={canvasRef} width={FRAME_SIZE} height={FRAME_SIZE} className="hidden" />
+            <div className="absolute left-3 top-3 flex items-center gap-2 rounded-sm bg-black/65 px-2 py-1 text-xs font-medium text-white">
+              <span className={`h-2 w-2 rounded-full ${active ? "bg-emerald-400" : "bg-slate-400"}`} />
+              {active ? t("fleet_live") : workerReady ? t("fleet_ready") : t("loading")}
+            </div>
+            {stats.lastError && (
+              <div className="absolute inset-x-3 bottom-3 rounded-md bg-red-600/90 px-3 py-2 text-sm font-medium text-white">
+                {stats.lastError}
+              </div>
+            )}
+          </section>
+
+          <aside className="grid content-start gap-3">
+            <Metric icon={<RadioTower className="h-4 w-4" />} label={t("fleet_sent")} value={stats.sent} />
+            <Metric icon={<Zap className="h-4 w-4" />} label={t("fleet_infer")} value={stats.inferMs == null ? "--" : `${stats.inferMs} ms`} />
+            <Metric icon={<Camera className="h-4 w-4" />} label={t("fleet_frames")} value={stats.frames} />
+            <Metric icon={<ShieldCheck className="h-4 w-4" />} label={t("fleet_speed")} value={formatSpeed(location?.speed ?? null)} />
+            <div className="rounded-md border border-line bg-white p-3">
+              <div className="text-xs font-semibold uppercase tracking-wide text-ink-soft">{t("fleet_last")}</div>
+              <div className="mt-1 text-base font-semibold text-ink">
+                {stats.lastHazard ? t(`hz_${stats.lastHazard}`) : "--"}
+              </div>
+              <div className="mt-1 text-xs text-ink-soft">
+                {location ? `${location.lat.toFixed(5)}, ${location.lon.toFixed(5)}` : "--"}
+              </div>
+            </div>
+          </aside>
+        </div>
+      </main>
+    </div>
+  );
+}
+
+function Metric({
+  icon,
+  label,
+  value,
+}: {
+  icon: ReactNode;
+  label: string;
+  value: string | number;
+}) {
+  return (
+    <div className="rounded-md border border-line bg-white p-3">
+      <div className="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide text-ink-soft">
+        {icon}
+        {label}
+      </div>
+      <div className="mt-1 text-2xl font-bold text-ink">{value}</div>
+    </div>
+  );
+}

frontend/src/workers/fleetInference.worker.ts

@@ -0,0 +1,164 @@
+import * as ort from "onnxruntime-web";
+import type { FleetDetection, FleetHazardType } from "../lib/fleetTelemetry";
+
+const HAZARD_CLASSES: FleetHazardType[] = [
+  "pothole",
+  "crack",
+  "water_logging",
+  "construction_zone",
+  "traffic_block",
+];
+
+type WorkerRequest =
+  | { type: "init"; modelUrl: string }
+  | { type: "infer"; width: number; height: number; buffer: ArrayBuffer };
+
+type WorkerResponse =
+  | { type: "ready" }
+  | { type: "result"; detections: FleetDetection[]; inferMs: number }
+  | { type: "error"; message: string };
+
+let session: ort.InferenceSession | null = null;
+
+ort.env.wasm.numThreads = 1;
+
+function post(message: WorkerResponse): void {
+  self.postMessage(message);
+}
+
+async function init(modelUrl: string): Promise<void> {
+  if (session) {
+    post({ type: "ready" });
+    return;
+  }
+  session = await ort.InferenceSession.create(modelUrl, {
+    executionProviders: ["wasm"],
+    graphOptimizationLevel: "all",
+  });
+  post({ type: "ready" });
+}
+
+function preprocess(buffer: ArrayBuffer, width: number, height: number): ort.Tensor {
+  const pixels = new Uint8ClampedArray(buffer);
+  const tensor = new Float32Array(3 * width * height);
+  const plane = width * height;
+
+  for (let i = 0; i < plane; i += 1) {
+    const src = i * 4;
+    tensor[i] = pixels[src] / 255;
+    tensor[plane + i] = pixels[src + 1] / 255;
+    tensor[plane * 2 + i] = pixels[src + 2] / 255;
+  }
+  return new ort.Tensor("float32", tensor, [1, 3, height, width]);
+}
+
+function clipBox(bbox: [number, number, number, number], size: number): [number, number, number, number] {
+  const [x1, y1, x2, y2] = bbox;
+  return [
+    Math.max(0, Math.min(size, x1)),
+    Math.max(0, Math.min(size, y1)),
+    Math.max(0, Math.min(size, x2)),
+    Math.max(0, Math.min(size, y2)),
+  ];
+}
+
+function detectionFromRow(row: ArrayLike<number>, offset: number, stride: number, size: number): FleetDetection | null {
+  const confidence = Number(row[offset + 4]);
+  const classId = Math.round(Number(row[offset + 5]));
+  const hazardType = HAZARD_CLASSES[classId];
+  if (!hazardType || !Number.isFinite(confidence)) return null;
+
+  const bbox: [number, number, number, number] = clipBox(
+    [
+      Number(row[offset]),
+      Number(row[offset + 1]),
+      Number(row[offset + 2]),
+      Number(row[offset + 3]),
+    ],
+    size,
+  );
+  if (bbox[2] <= bbox[0] || bbox[3] <= bbox[1] || stride < 6) return null;
+  return { hazard_type: hazardType, confidence, bbox };
+}
+
+function parseNmsOutput(output: ort.Tensor, size: number): FleetDetection[] | null {
+  const data = output.data as Float32Array;
+  const dims = output.dims;
+  let rows = 0;
+  let stride = 0;
+
+  if (dims.length === 2 && dims[1] >= 6) {
+    rows = dims[0];
+    stride = dims[1];
+  } else if (dims.length === 3 && dims[2] >= 6) {
+    rows = dims[1];
+    stride = dims[2];
+  }
+  if (!rows || !stride) return null;
+
+  const detections: FleetDetection[] = [];
+  for (let r = 0; r < rows; r += 1) {
+    const det = detectionFromRow(data, r * stride, stride, size);
+    if (det && det.confidence > 0.25) detections.push(det);
+  }
+  return detections;
+}
+
+function parseRawYoloOutput(output: ort.Tensor, size: number): FleetDetection[] {
+  const data = output.data as Float32Array;
+  const dims = output.dims;
+  if (dims.length !== 3 || dims[1] < 9) return [];
+
+  const featureCount = dims[1];
+  const boxCount = dims[2];
+  const detections: FleetDetection[] = [];
+  for (let i = 0; i < boxCount; i += 1) {
+    let bestClass = -1;
+    let bestScore = 0;
+    for (let c = 0; c < HAZARD_CLASSES.length; c += 1) {
+      const score = data[(4 + c) * boxCount + i];
+      if (score > bestScore) {
+        bestScore = score;
+        bestClass = c;
+      }
+    }
+    const hazardType = HAZARD_CLASSES[bestClass];
+    if (!hazardType || bestScore <= 0.25) continue;
+
+    const cx = data[i];
+    const cy = data[boxCount + i];
+    const w = data[boxCount * 2 + i];
+    const h = data[boxCount * 3 + i];
+    if (!Number.isFinite(cx + cy + w + h) || featureCount < 9) continue;
+    const bbox = clipBox([cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2], size);
+    detections.push({ hazard_type: hazardType, confidence: bestScore, bbox });
+  }
+  return detections.sort((a, b) => b.confidence - a.confidence).slice(0, 12);
+}
+
+function parseDetections(results: Record<string, ort.Tensor>, size: number): FleetDetection[] {
+  const output = Object.values(results)[0];
+  if (!output) return [];
+  return parseNmsOutput(output, size) ?? parseRawYoloOutput(output, size);
+}
+
+async function infer(width: number, height: number, buffer: ArrayBuffer): Promise<void> {
+  if (!session) throw new Error("Inference worker is not initialized.");
+  const started = performance.now();
+  const tensor = preprocess(buffer, width, height);
+  const inputName = session.inputNames[0];
+  const results = (await session.run({ [inputName]: tensor })) as Record<string, ort.Tensor>;
+  post({
+    type: "result",
+    detections: parseDetections(results, width),
+    inferMs: Math.round(performance.now() - started),
+  });
+}
+
+self.addEventListener("message", (event: MessageEvent<WorkerRequest>) => {
+  const msg = event.data;
+  const task = msg.type === "init" ? init(msg.modelUrl) : infer(msg.width, msg.height, msg.buffer);
+  task.catch((err: unknown) => {
+    post({ type: "error", message: err instanceof Error ? err.message : "Fleet worker failed." });
+  });
+});