chore: publish PPE Sentinel Space

.dockerignore

@@ -0,0 +1,10 @@
+.git
+.venv
+__pycache__
+.pytest_cache
+.hf-cache
+artifacts
+dist
+tests
+docs
+deploy

.env.example

@@ -0,0 +1,8 @@
+OPENAI_API_KEY=
+OPENAI_MODEL=gpt-5.2
+DETECTION_THRESHOLD=0.26
+DEFAULT_REQUIRED_ITEMS=helmet,vest
+MAX_UPLOAD_SIZE_MB=60
+MAX_VIDEO_SAMPLES=10
+APP_HOST=0.0.0.0
+APP_PORT=7860

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HF_HOME=/app/.hf-cache
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg libgl1 libglib2.0-0 && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,22 @@
+---
+title: PPE Sentinel
+emoji: 🦺
+colorFrom: amber
+colorTo: slate
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# PPE Sentinel
+
+Upload construction photos or short videos to detect workers, helmets, vests, masks, and gloves.
+
+## Space secrets
+
+- `OPENAI_API_KEY`
+
+## Notes
+
+- The first run downloads the zero-shot detection model from Hugging Face.
+- For production usage, keep videos short and enable persistent storage if you want artifact history.

app/__init__.py

@@ -0,0 +1 @@
+"""PPE Sentinel application package."""

app/api/routes.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+
+from app.core.config import settings
+from app.models.schemas import AnalyzeResponse
+from app.services.detection import analyze_image_bytes, analyze_video_bytes
+from app.services.reporting import build_openai_report, build_rule_based_report
+
+
+router = APIRouter()
+templates = Jinja2Templates(directory=str(settings.templates_dir))
+
+IMAGE_TYPES = {".jpg", ".jpeg", ".png", ".webp"}
+VIDEO_TYPES = {".mp4", ".mov", ".avi", ".mkv", ".webm"}
+
+
+def parse_required_items(value: str | None) -> list[str]:
+    if not value:
+        return list(settings.required_items)
+    items = [item.strip().lower() for item in value.split(",") if item.strip()]
+    return items or list(settings.required_items)
+
+
+@router.get("/", response_class=HTMLResponse)
+async def index(request: Request) -> HTMLResponse:
+    return templates.TemplateResponse(
+        request=request,
+        name="index.html",
+        context={
+            "app_name": settings.app_name,
+            "tagline": settings.app_tagline,
+            "default_required_items": list(settings.required_items),
+            "openai_enabled": bool(settings.openai_api_key),
+        },
+    )
+
+
+@router.get("/health")
+async def health() -> JSONResponse:
+    return JSONResponse(
+        {"status": "ok", "model": settings.grounding_model_id, "openai_enabled": bool(settings.openai_api_key)}
+    )
+
+
+@router.post("/api/analyze", response_model=AnalyzeResponse)
+async def analyze(
+    file: UploadFile = File(...),
+    required_items: str = Form(""),
+    generate_ai_summary: bool = Form(True),
+) -> AnalyzeResponse:
+    suffix = Path(file.filename or "upload.bin").suffix.lower()
+    if suffix not in IMAGE_TYPES | VIDEO_TYPES:
+        raise HTTPException(status_code=400, detail="Unsupported file type. Upload an image or a short video.")
+
+    payload = await file.read()
+    if len(payload) > settings.max_upload_size_mb * 1024 * 1024:
+        raise HTTPException(status_code=400, detail=f"File exceeds {settings.max_upload_size_mb} MB upload limit.")
+
+    chosen_required_items = parse_required_items(required_items)
+    filename = file.filename or "upload"
+
+    try:
+        if suffix in IMAGE_TYPES:
+            detections, workers, site_summary, annotated_asset = analyze_image_bytes(payload, chosen_required_items)
+            media_type = "image"
+            frames = []
+        else:
+            detections, workers, site_summary, annotated_asset, frames = analyze_video_bytes(payload, chosen_required_items)
+            media_type = "video"
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {exc}") from exc
+
+    report = (
+        build_openai_report(filename, media_type, site_summary, workers, chosen_required_items)
+        if generate_ai_summary
+        else build_rule_based_report(filename, media_type, site_summary, workers, chosen_required_items)
+    )
+
+    return AnalyzeResponse(
+        media_type=media_type,
+        filename=filename,
+        required_items=chosen_required_items,
+        site_summary=site_summary,
+        detections=detections,
+        workers=workers,
+        report=report,
+        annotated_asset=annotated_asset,
+        frames=frames,
+    )

app/core/config.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+load_dotenv(BASE_DIR / ".env")
+
+
+@dataclass(slots=True)
+class Settings:
+    app_name: str = "PPE Sentinel"
+    app_tagline: str = "Industrial-grade PPE compliance intelligence"
+    environment: str = os.getenv("APP_ENV", "development")
+    host: str = os.getenv("APP_HOST", "0.0.0.0")
+    port: int = int(os.getenv("APP_PORT", "7860"))
+    detection_threshold: float = float(os.getenv("DETECTION_THRESHOLD", "0.26"))
+    max_upload_size_mb: int = int(os.getenv("MAX_UPLOAD_SIZE_MB", "60"))
+    max_video_samples: int = int(os.getenv("MAX_VIDEO_SAMPLES", "10"))
+    openai_api_key: str = os.getenv("OPENAI_API_KEY", "")
+    openai_model: str = os.getenv("OPENAI_MODEL", "gpt-5.2")
+    grounding_model_id: str = os.getenv("GROUNDING_MODEL_ID", "IDEA-Research/grounding-dino-tiny")
+    hf_cache_dir: str = os.getenv("HF_HOME", str(BASE_DIR / ".hf-cache"))
+    required_items: tuple[str, ...] = field(
+        default_factory=lambda: tuple(
+            item.strip()
+            for item in os.getenv("DEFAULT_REQUIRED_ITEMS", "helmet,vest").split(",")
+            if item.strip()
+        )
+    )
+    artifacts_dir: Path = field(default_factory=lambda: BASE_DIR / "artifacts")
+    static_dir: Path = field(default_factory=lambda: BASE_DIR / "app" / "static")
+    templates_dir: Path = field(default_factory=lambda: BASE_DIR / "app" / "templates")
+
+    def ensure_directories(self) -> None:
+        self.artifacts_dir.mkdir(parents=True, exist_ok=True)
+        Path(self.hf_cache_dir).mkdir(parents=True, exist_ok=True)
+
+
+settings = Settings()
+settings.ensure_directories()

app/main.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from app.api.routes import router
+from app.core.config import settings
+
+
+app = FastAPI(title=settings.app_name)
+app.mount("/static", StaticFiles(directory=str(settings.static_dir)), name="static")
+app.mount("/artifacts", StaticFiles(directory=str(settings.artifacts_dir)), name="artifacts")
+app.include_router(router)

app/models/schemas.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class BoundingBox(BaseModel):
+    xmin: float
+    ymin: float
+    xmax: float
+    ymax: float
+
+    @property
+    def width(self) -> float:
+        return max(0.0, self.xmax - self.xmin)
+
+    @property
+    def height(self) -> float:
+        return max(0.0, self.ymax - self.ymin)
+
+
+class Detection(BaseModel):
+    label: str
+    score: float
+    box: BoundingBox
+
+
+class WorkerCompliance(BaseModel):
+    worker_id: str
+    status: Literal["compliant", "non-compliant"]
+    score: float
+    required_items: list[str]
+    present_items: list[str]
+    missing_items: list[str]
+    box: BoundingBox
+
+
+class ExecutiveReport(BaseModel):
+    source: Literal["openai", "rules"]
+    title: str
+    summary: str
+    actions: list[str] = Field(default_factory=list)
+
+
+class MediaAsset(BaseModel):
+    kind: Literal["image", "video_storyboard"]
+    url: str
+    width: int | None = None
+    height: int | None = None
+
+
+class FrameAnalysis(BaseModel):
+    timestamp_seconds: float
+    total_workers: int
+    compliant_workers: int
+    non_compliant_workers: int
+    risk_level: Literal["low", "medium", "high"]
+    thumbnail_url: str
+
+
+class SiteSummary(BaseModel):
+    total_workers: int
+    compliant_workers: int
+    non_compliant_workers: int
+    compliance_rate: float
+    detected_items: dict[str, int]
+    missing_items: dict[str, int]
+    status: Literal["clear", "attention"]
+
+
+class AnalyzeResponse(BaseModel):
+    media_type: Literal["image", "video"]
+    filename: str
+    required_items: list[str]
+    site_summary: SiteSummary
+    detections: list[Detection]
+    workers: list[WorkerCompliance]
+    report: ExecutiveReport
+    annotated_asset: MediaAsset
+    frames: list[FrameAnalysis] = Field(default_factory=list)

app/services/compliance.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+from app.models.schemas import BoundingBox, Detection, SiteSummary, WorkerCompliance
+
+
+LABEL_ALIASES = {
+    "person": "person",
+    "worker": "person",
+    "helmet": "helmet",
+    "hard hat": "helmet",
+    "safety helmet": "helmet",
+    "hardhat": "helmet",
+    "vest": "vest",
+    "safety vest": "vest",
+    "reflective vest": "vest",
+    "high visibility vest": "vest",
+    "hi vis vest": "vest",
+    "hi-vis vest": "vest",
+    "mask": "mask",
+    "face mask": "mask",
+    "respirator mask": "mask",
+    "glove": "gloves",
+    "gloves": "gloves",
+    "safety gloves": "gloves",
+}
+
+
+def normalize_label(label: str) -> str:
+    cleaned = re.sub(r"\s+", " ", label.strip().lower())
+    return LABEL_ALIASES.get(cleaned, cleaned)
+
+
+def center_of(box: BoundingBox) -> tuple[float, float]:
+    return ((box.xmin + box.xmax) / 2, (box.ymin + box.ymax) / 2)
+
+
+def intersection_area(box_a: BoundingBox, box_b: BoundingBox) -> float:
+    x_left = max(box_a.xmin, box_b.xmin)
+    y_top = max(box_a.ymin, box_b.ymin)
+    x_right = min(box_a.xmax, box_b.xmax)
+    y_bottom = min(box_a.ymax, box_b.ymax)
+    if x_right <= x_left or y_bottom <= y_top:
+        return 0.0
+    return (x_right - x_left) * (y_bottom - y_top)
+
+
+def iou(box_a: BoundingBox, box_b: BoundingBox) -> float:
+    inter = intersection_area(box_a, box_b)
+    union = box_a.width * box_a.height + box_b.width * box_b.height - inter
+    if union <= 0:
+        return 0.0
+    return inter / union
+
+
+def item_matches_person(item: Detection, person: Detection) -> bool:
+    ix, iy = center_of(item.box)
+    inside_box = person.box.xmin <= ix <= person.box.xmax and person.box.ymin <= iy <= person.box.ymax
+    if not inside_box and intersection_area(item.box, person.box) <= 0:
+        return False
+
+    height = max(person.box.height, 1.0)
+    rel_y = (iy - person.box.ymin) / height
+
+    if item.label == "helmet":
+        return rel_y <= 0.42
+    if item.label == "mask":
+        return rel_y <= 0.5
+    if item.label == "vest":
+        return 0.18 <= rel_y <= 0.88
+    if item.label == "gloves":
+        return 0.2 <= rel_y <= 1.02
+    return True
+
+
+def class_aware_nms(detections: list[Detection], threshold: float = 0.45) -> list[Detection]:
+    grouped: dict[str, list[Detection]] = {}
+    for detection in detections:
+        grouped.setdefault(detection.label, []).append(detection)
+
+    final: list[Detection] = []
+    for group in grouped.values():
+        kept: list[Detection] = []
+        for detection in sorted(group, key=lambda item: item.score, reverse=True):
+            if any(iou(detection.box, existing.box) >= threshold for existing in kept):
+                continue
+            kept.append(detection)
+        final.extend(kept)
+    return final
+
+
+def evaluate_site(detections: list[Detection], required_items: list[str]) -> tuple[list[WorkerCompliance], SiteSummary]:
+    canonical_required = [normalize_label(item) for item in required_items]
+    people = [item for item in detections if item.label == "person"]
+    workers: list[WorkerCompliance] = []
+    detected_counter: Counter[str] = Counter()
+    missing_counter: Counter[str] = Counter()
+
+    for item in detections:
+        if item.label != "person":
+            detected_counter[item.label] += 1
+
+    for index, person in enumerate(sorted(people, key=lambda item: item.box.xmin), start=1):
+        attached_items = {
+            item.label
+            for item in detections
+            if item.label != "person" and item_matches_person(item, person)
+        }
+        missing_items = [item for item in canonical_required if item not in attached_items]
+        for missing in missing_items:
+            missing_counter[missing] += 1
+
+        present_items = [item for item in canonical_required if item in attached_items]
+        score = 100.0 if not canonical_required else round((len(present_items) / len(canonical_required)) * 100, 1)
+        workers.append(
+            WorkerCompliance(
+                worker_id=f"W-{index:02d}",
+                status="compliant" if not missing_items else "non-compliant",
+                score=score,
+                required_items=canonical_required,
+                present_items=present_items,
+                missing_items=missing_items,
+                box=person.box,
+            )
+        )
+
+    compliant_workers = sum(1 for worker in workers if worker.status == "compliant")
+    total_workers = len(workers)
+    compliance_rate = round((compliant_workers / total_workers) * 100, 1) if total_workers else 0.0
+    summary = SiteSummary(
+        total_workers=total_workers,
+        compliant_workers=compliant_workers,
+        non_compliant_workers=max(total_workers - compliant_workers, 0),
+        compliance_rate=compliance_rate,
+        detected_items=dict(sorted(detected_counter.items())),
+        missing_items=dict(sorted(missing_counter.items())),
+        status="clear" if total_workers and compliant_workers == total_workers else "attention",
+    )
+    return workers, summary
+
+
+def frame_risk_level(summary: SiteSummary) -> str:
+    if summary.non_compliant_workers == 0:
+        return "low"
+    if summary.compliance_rate >= 60:
+        return "medium"
+    return "high"

app/services/detection.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import io
+import math
+import os
+import tempfile
+from pathlib import Path
+
+import cv2
+import torch
+from PIL import Image, ImageDraw, ImageOps
+from transformers import AutoModelForZeroShotObjectDetection, AutoProcessor
+
+from app.core.config import settings
+from app.models.schemas import BoundingBox, Detection, FrameAnalysis, MediaAsset, SiteSummary, WorkerCompliance
+from app.services.compliance import class_aware_nms, evaluate_site, frame_risk_level, normalize_label
+from app.services.storage import save_image
+
+
+TEXT_QUERIES = [
+    "person",
+    "helmet",
+    "hard hat",
+    "safety helmet",
+    "safety vest",
+    "reflective vest",
+    "high visibility vest",
+    "face mask",
+    "gloves",
+]
+
+COLOR_MAP = {
+    "person": "#8B5CF6",
+    "helmet": "#22C55E",
+    "vest": "#F59E0B",
+    "mask": "#06B6D4",
+    "gloves": "#EF4444",
+}
+
+
+class PpeDetector:
+    def __init__(self) -> None:
+        self._processor = None
+        self._model = None
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def _ensure_model(self) -> None:
+        if self._processor is not None and self._model is not None:
+            return
+        os.environ.setdefault("HF_HOME", settings.hf_cache_dir)
+        self._processor = AutoProcessor.from_pretrained(settings.grounding_model_id)
+        self._model = AutoModelForZeroShotObjectDetection.from_pretrained(settings.grounding_model_id).to(self._device)
+        self._model.eval()
+
+    def detect_image(self, image: Image.Image) -> list[Detection]:
+        self._ensure_model()
+        prepared = image.convert("RGB")
+        inputs = self._processor(images=prepared, text=[TEXT_QUERIES], return_tensors="pt")
+        inputs = {key: value.to(self._device) if hasattr(value, "to") else value for key, value in inputs.items()}
+
+        with torch.inference_mode():
+            outputs = self._model(**inputs)
+
+        results = self._processor.post_process_grounded_object_detection(
+            outputs,
+            inputs["input_ids"],
+            box_threshold=settings.detection_threshold,
+            text_threshold=0.2,
+            target_sizes=[prepared.size[::-1]],
+        )
+
+        detections: list[Detection] = []
+        for result in results:
+            for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
+                canonical_label = normalize_label(str(label))
+                if canonical_label not in COLOR_MAP:
+                    continue
+                xmin, ymin, xmax, ymax = [float(value) for value in box.tolist()]
+                detections.append(
+                    Detection(
+                        label=canonical_label,
+                        score=round(float(score), 4),
+                        box=BoundingBox(xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax),
+                    )
+                )
+        return class_aware_nms(detections)
+
+
+detector = PpeDetector()
+
+
+def annotate_image(image: Image.Image, detections: list[Detection], workers: list[WorkerCompliance]) -> Image.Image:
+    canvas = image.convert("RGB").copy()
+    draw = ImageDraw.Draw(canvas)
+
+    for detection in detections:
+        color = COLOR_MAP.get(detection.label, "#FFFFFF")
+        box = detection.box
+        draw.rounded_rectangle((box.xmin, box.ymin, box.xmax, box.ymax), outline=color, width=4, radius=12)
+        label = f"{detection.label.upper()} {int(detection.score * 100)}%"
+        draw.text((box.xmin + 8, max(box.ymin - 22, 8)), label, fill=color)
+
+    for worker in workers:
+        color = "#22C55E" if worker.status == "compliant" else "#EF4444"
+        label = f"{worker.worker_id} {worker.status.replace('-', ' ').upper()}"
+        draw.text((worker.box.xmin + 8, worker.box.ymax + 8), label, fill=color)
+
+    return canvas
+
+
+def build_storyboard(frames: list[Image.Image]) -> Image.Image:
+    thumb_width = 380
+    thumb_height = 220
+    cols = 2 if len(frames) > 1 else 1
+    rows = math.ceil(len(frames) / cols)
+    sheet = Image.new("RGB", (cols * thumb_width + 48, rows * thumb_height + 48), "#09101A")
+
+    for index, frame in enumerate(frames):
+        thumb = ImageOps.fit(frame, (thumb_width, thumb_height))
+        x = 24 + (index % cols) * thumb_width
+        y = 24 + (index // cols) * thumb_height
+        sheet.paste(thumb, (x, y))
+    return sheet
+
+
+def analyze_image_bytes(payload: bytes, required_items: list[str]) -> tuple[list[Detection], list[WorkerCompliance], SiteSummary, MediaAsset]:
+    image = Image.open(io.BytesIO(payload)).convert("RGB")
+    detections = detector.detect_image(image)
+    workers, summary = evaluate_site(detections, required_items)
+    annotated = annotate_image(image, detections, workers)
+    url = save_image(annotated, ".png")
+    asset = MediaAsset(kind="image", url=url, width=annotated.width, height=annotated.height)
+    return detections, workers, summary, asset
+
+
+def analyze_video_bytes(
+    payload: bytes, required_items: list[str]
+) -> tuple[list[Detection], list[WorkerCompliance], SiteSummary, MediaAsset, list[FrameAnalysis]]:
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_file:
+        temp_file.write(payload)
+        temp_path = Path(temp_file.name)
+
+    capture = cv2.VideoCapture(str(temp_path))
+    total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+    fps = float(capture.get(cv2.CAP_PROP_FPS) or 1.0)
+    step = max(1, math.ceil(total_frames / max(settings.max_video_samples, 1)))
+
+    sampled_frames: list[Image.Image] = []
+    analyses: list[FrameAnalysis] = []
+    all_detections: list[Detection] = []
+    last_workers: list[WorkerCompliance] = []
+    last_summary: SiteSummary | None = None
+
+    frame_index = 0
+    while capture.isOpened():
+        success, frame = capture.read()
+        if not success:
+            break
+        if frame_index % step != 0:
+            frame_index += 1
+            continue
+
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image = Image.fromarray(rgb)
+        detections = detector.detect_image(image)
+        workers, summary = evaluate_site(detections, required_items)
+        annotated = annotate_image(image, detections, workers)
+        thumb_url = save_image(ImageOps.fit(annotated, (720, 420)), ".png")
+        analyses.append(
+            FrameAnalysis(
+                timestamp_seconds=round(frame_index / max(fps, 1.0), 2),
+                total_workers=summary.total_workers,
+                compliant_workers=summary.compliant_workers,
+                non_compliant_workers=summary.non_compliant_workers,
+                risk_level=frame_risk_level(summary),
+                thumbnail_url=thumb_url,
+            )
+        )
+        sampled_frames.append(annotated)
+        all_detections.extend(detections)
+        last_workers = workers
+        last_summary = summary
+        frame_index += 1
+        if len(sampled_frames) >= settings.max_video_samples:
+            break
+
+    capture.release()
+    temp_path.unlink(missing_ok=True)
+
+    if not sampled_frames or last_summary is None:
+        raise ValueError("No analyzable frames were found in the uploaded video.")
+
+    storyboard = build_storyboard(sampled_frames)
+    asset = MediaAsset(kind="video_storyboard", url=save_image(storyboard, ".png"), width=storyboard.width, height=storyboard.height)
+    deduped_detections = class_aware_nms(all_detections, threshold=0.35)
+    return deduped_detections, last_workers, last_summary, asset, analyses

app/services/reporting.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+
+from openai import OpenAI
+
+from app.core.config import settings
+from app.models.schemas import ExecutiveReport, SiteSummary, WorkerCompliance
+
+
+def build_rule_based_report(
+    filename: str,
+    media_type: str,
+    site_summary: SiteSummary,
+    workers: list[WorkerCompliance],
+    required_items: list[str],
+) -> ExecutiveReport:
+    if site_summary.non_compliant_workers == 0 and site_summary.total_workers > 0:
+        summary = (
+            f"{filename} was analyzed as a {media_type}. All {site_summary.total_workers} detected workers met "
+            f"the required PPE policy for {', '.join(required_items)}."
+        )
+        actions = [
+            "Keep this upload as a positive reference sample for shift leads.",
+            "Continue periodic spot checks to make sure compliance stays above 95%.",
+        ]
+    else:
+        missing_categories = ", ".join(site_summary.missing_items) or "multiple categories"
+        summary = (
+            f"{filename} shows {site_summary.non_compliant_workers} non-compliant workers out of "
+            f"{site_summary.total_workers} detected. Missing PPE is concentrated in {missing_categories}."
+        )
+        actions = [
+            "Escalate the flagged zone to the floor supervisor for an immediate PPE correction round.",
+            "Capture a follow-up scan after the correction to verify the compliance rate has improved.",
+            "Review induction signage near site entry points if the same missing items recur across uploads.",
+        ]
+    return ExecutiveReport(source="rules", title="Shift Safety Snapshot", summary=summary, actions=actions)
+
+
+def build_openai_report(
+    filename: str,
+    media_type: str,
+    site_summary: SiteSummary,
+    workers: list[WorkerCompliance],
+    required_items: list[str],
+) -> ExecutiveReport:
+    if not settings.openai_api_key:
+        return build_rule_based_report(filename, media_type, site_summary, workers, required_items)
+
+    try:
+        client = OpenAI(api_key=settings.openai_api_key)
+        payload = {
+            "filename": filename,
+            "media_type": media_type,
+            "required_items": required_items,
+            "site_summary": site_summary.model_dump(),
+            "workers": [worker.model_dump() for worker in workers],
+        }
+        response = client.responses.create(
+            model=settings.openai_model,
+            max_output_tokens=500,
+            input=[
+                {
+                    "role": "system",
+                    "content": [
+                        {
+                            "type": "input_text",
+                            "text": (
+                                "You are an industrial safety analyst. Write a concise executive summary plus 3 "
+                                "action items. Be specific, operational, and suitable for an enterprise dashboard."
+                            ),
+                        }
+                    ],
+                },
+                {
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": json.dumps(payload, indent=2)}],
+                },
+            ],
+        )
+        text = (response.output_text or "").strip()
+    except Exception:
+        return build_rule_based_report(filename, media_type, site_summary, workers, required_items)
+
+    if not text:
+        return build_rule_based_report(filename, media_type, site_summary, workers, required_items)
+
+    lines = [line.strip("- ").strip() for line in text.splitlines() if line.strip()]
+    title = lines[0][:80] if lines else "AI Safety Summary"
+    summary = lines[1] if len(lines) > 1 else text
+    actions = [line for line in lines[2:5]]
+    if not actions:
+        actions = [
+            "Review the flagged non-compliant workers and trigger a spot correction.",
+            "Re-scan the affected zone after corrective action.",
+            "Track repeat missing-item patterns for training improvements.",
+        ]
+    return ExecutiveReport(source="openai", title=title, summary=summary, actions=actions)

app/services/storage.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+from uuid import uuid4
+
+from PIL import Image
+
+from app.core.config import settings
+
+
+def save_bytes(content: bytes, suffix: str) -> str:
+    filename = f"{uuid4().hex}{suffix}"
+    target = settings.artifacts_dir / filename
+    target.write_bytes(content)
+    return f"/artifacts/{filename}"
+
+
+def save_image(image: Image.Image, suffix: str = ".png") -> str:
+    filename = f"{uuid4().hex}{suffix}"
+    target = settings.artifacts_dir / filename
+    image.save(target)
+    return f"/artifacts/{filename}"
+
+
+def save_text(text: str, suffix: str = ".md") -> str:
+    filename = f"{uuid4().hex}{suffix}"
+    target = settings.artifacts_dir / filename
+    target.write_text(text, encoding="utf-8")
+    return f"/artifacts/{filename}"
+
+
+def absolute_artifact_path(relative_url: str) -> Path:
+    return settings.artifacts_dir / relative_url.replace("/artifacts/", "", 1)

app/static/css/styles.css

@@ -0,0 +1,487 @@
+:root {
+  --bg: #08111f;
+  --panel: rgba(8, 19, 34, 0.8);
+  --panel-strong: #0e1c31;
+  --text: #e9eef9;
+  --muted: #98a6bf;
+  --lime: #8ce06e;
+  --amber: #ffb74d;
+  --red: #ff6b6b;
+  --cyan: #42d1ff;
+  --purple: #9f8cff;
+  --border: rgba(255, 255, 255, 0.09);
+  --shadow: 0 24px 60px rgba(0, 0, 0, 0.3);
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  font-family: "DM Sans", sans-serif;
+  color: var(--text);
+  background:
+    radial-gradient(circle at top left, rgba(66, 209, 255, 0.18), transparent 30%),
+    radial-gradient(circle at top right, rgba(255, 183, 77, 0.16), transparent 26%),
+    linear-gradient(135deg, #07101d 0%, #0f1b31 45%, #08111f 100%);
+}
+
+.noise {
+  position: fixed;
+  inset: 0;
+  pointer-events: none;
+  background-image: linear-gradient(rgba(255, 255, 255, 0.02) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(255, 255, 255, 0.02) 1px, transparent 1px);
+  background-size: 28px 28px;
+  mask-image: linear-gradient(to bottom, rgba(0, 0, 0, 0.7), transparent);
+}
+
+.topbar,
+.page-shell {
+  width: min(1240px, calc(100vw - 32px));
+  margin: 0 auto;
+}
+
+.topbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 22px 0 10px;
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+}
+
+.brand-mark {
+  display: grid;
+  place-items: center;
+  width: 52px;
+  height: 52px;
+  border-radius: 16px;
+  background: linear-gradient(135deg, var(--amber), #f97316);
+  color: #07101d;
+  font-family: "Space Grotesk", sans-serif;
+  font-weight: 700;
+}
+
+.brand h1,
+.hero h2,
+.section-head h3,
+.report-header h4,
+.section-head.minor h4,
+.empty-state h4 {
+  margin: 0;
+  font-family: "Space Grotesk", sans-serif;
+}
+
+.eyebrow {
+  margin: 0 0 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.16em;
+  font-size: 0.72rem;
+  color: var(--muted);
+}
+
+.status-chip,
+.hero-pills span,
+.drop-icon,
+.ghost-button,
+.primary-button,
+.worker-pill,
+.risk-pill {
+  border-radius: 999px;
+}
+
+.status-chip {
+  padding: 10px 16px;
+  border: 1px solid var(--border);
+  background: rgba(255, 255, 255, 0.04);
+}
+
+.status-chip.enabled {
+  color: #09111b;
+  background: linear-gradient(135deg, #7ee787, #9be15d);
+}
+
+.status-chip.muted {
+  color: var(--muted);
+}
+
+.page-shell {
+  padding: 12px 0 42px;
+}
+
+.workspace {
+  display: grid;
+  grid-template-columns: minmax(320px, 390px) minmax(0, 1fr);
+  gap: 22px;
+}
+
+.card {
+  position: relative;
+  border: 1px solid var(--border);
+  background: var(--panel);
+  backdrop-filter: blur(18px);
+  border-radius: 28px;
+  box-shadow: var(--shadow);
+}
+
+.hero {
+  display: grid;
+  grid-template-columns: 1.7fr 1fr;
+  gap: 18px;
+  padding: 28px;
+  margin-bottom: 22px;
+}
+
+.lead {
+  color: var(--muted);
+  line-height: 1.7;
+  max-width: 60ch;
+}
+
+.hero-pills {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 18px;
+}
+
+.hero-pills span,
+.worker-pill,
+.risk-pill {
+  padding: 10px 14px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.05);
+  font-size: 0.9rem;
+}
+
+.hero-metrics {
+  display: grid;
+  gap: 12px;
+}
+
+.hero-metrics div,
+.summary-card,
+.report-panel,
+.timeline-card,
+.worker-card {
+  background: var(--panel-strong);
+  border: 1px solid var(--border);
+  border-radius: 22px;
+}
+
+.hero-metrics div {
+  padding: 18px;
+}
+
+.hero-metrics span {
+  display: block;
+  color: var(--muted);
+  margin-bottom: 8px;
+}
+
+.uploader,
+.results {
+  padding: 24px;
+}
+
+.section-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 14px;
+  align-items: flex-start;
+  margin-bottom: 20px;
+}
+
+.section-head.minor {
+  margin: 10px 0 14px;
+}
+
+.upload-form {
+  display: grid;
+  gap: 16px;
+}
+
+.dropzone {
+  border: 1.5px dashed rgba(255, 255, 255, 0.2);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.05), rgba(255, 255, 255, 0.02));
+  border-radius: 24px;
+  padding: 34px 22px;
+  text-align: center;
+  cursor: pointer;
+  transition: transform 180ms ease, border-color 180ms ease, background 180ms ease;
+}
+
+.dropzone:hover,
+.dropzone.dragging {
+  transform: translateY(-2px);
+  border-color: rgba(255, 183, 77, 0.8);
+  background: linear-gradient(180deg, rgba(255, 183, 77, 0.12), rgba(255, 255, 255, 0.04));
+}
+
+.dropzone input {
+  display: none;
+}
+
+.drop-icon {
+  display: inline-block;
+  padding: 8px 14px;
+  margin-bottom: 14px;
+  background: linear-gradient(135deg, var(--purple), var(--cyan));
+  color: #07101d;
+  font-weight: 700;
+}
+
+.form-grid {
+  display: grid;
+  gap: 16px;
+}
+
+label span {
+  display: block;
+  margin-bottom: 10px;
+  color: var(--muted);
+  font-size: 0.92rem;
+}
+
+input[type="text"] {
+  width: 100%;
+  padding: 14px 16px;
+  border-radius: 16px;
+  border: 1px solid var(--border);
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--text);
+  font: inherit;
+}
+
+.toggle-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 14px 16px;
+  border-radius: 16px;
+  border: 1px solid var(--border);
+  background: rgba(255, 255, 255, 0.04);
+}
+
+input[type="checkbox"] {
+  width: 22px;
+  height: 22px;
+  accent-color: var(--amber);
+}
+
+.ghost-button,
+.primary-button {
+  padding: 12px 16px;
+  border: 1px solid var(--border);
+  font: inherit;
+  cursor: pointer;
+  transition: transform 180ms ease, opacity 180ms ease;
+}
+
+.ghost-button {
+  background: rgba(255, 255, 255, 0.03);
+  color: var(--text);
+}
+
+.primary-button {
+  background: linear-gradient(135deg, var(--amber), #f97316);
+  color: #09111b;
+  font-weight: 700;
+  border: 0;
+}
+
+.ghost-button:hover,
+.primary-button:hover {
+  transform: translateY(-1px);
+}
+
+.file-preview,
+.loading-state,
+.empty-state,
+.report-summary,
+.action-list,
+.worker-meta,
+.timeline-meta {
+  color: var(--muted);
+}
+
+.file-preview,
+.loading-state,
+.empty-state {
+  padding: 16px;
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid var(--border);
+}
+
+.loading-state {
+  min-width: 150px;
+  text-align: center;
+}
+
+.summary-grid,
+.worker-list,
+.timeline-grid {
+  display: grid;
+  gap: 14px;
+}
+
+.summary-grid {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  margin-bottom: 20px;
+}
+
+.summary-card {
+  padding: 18px;
+}
+
+.summary-card span {
+  display: block;
+  color: var(--muted);
+  margin-bottom: 10px;
+}
+
+.summary-card strong {
+  font-size: 2rem;
+  font-family: "Space Grotesk", sans-serif;
+}
+
+.media-panel img {
+  width: 100%;
+  border-radius: 22px;
+  border: 1px solid var(--border);
+  margin-bottom: 18px;
+  background: #06101d;
+}
+
+.report-panel {
+  padding: 20px;
+  margin-bottom: 18px;
+}
+
+.report-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 14px;
+  align-items: flex-start;
+  margin-bottom: 12px;
+}
+
+.action-list {
+  display: grid;
+  gap: 10px;
+}
+
+.action-item,
+.worker-card,
+.timeline-card {
+  padding: 16px;
+}
+
+.action-item {
+  border-radius: 16px;
+  border: 1px solid var(--border);
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.worker-list {
+  grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+}
+
+.worker-card,
+.timeline-card {
+  display: grid;
+  gap: 12px;
+}
+
+.worker-header,
+.timeline-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+}
+
+.worker-card h5,
+.timeline-card h5 {
+  margin: 0;
+  font-family: "Space Grotesk", sans-serif;
+  font-size: 1rem;
+}
+
+.worker-pill.ok,
+.risk-pill.low {
+  color: #0d1b13;
+  background: linear-gradient(135deg, #92f2a4, #7ee787);
+}
+
+.worker-pill.bad,
+.risk-pill.high {
+  color: #2d0909;
+  background: linear-gradient(135deg, #ff9c9c, #ff6b6b);
+}
+
+.risk-pill.medium {
+  color: #2a1804;
+  background: linear-gradient(135deg, #ffd38a, #ffb74d);
+}
+
+.worker-meta strong {
+  color: var(--text);
+}
+
+.timeline-grid {
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  margin-top: 10px;
+}
+
+.timeline-card img {
+  width: 100%;
+  border-radius: 16px;
+  border: 1px solid var(--border);
+}
+
+.hidden {
+  display: none;
+}
+
+@media (max-width: 960px) {
+  .hero,
+  .workspace {
+    grid-template-columns: 1fr;
+  }
+
+  .summary-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 640px) {
+  .topbar {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 12px;
+  }
+
+  .summary-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .uploader,
+  .results,
+  .hero {
+    padding: 18px;
+  }
+
+  .report-header,
+  .section-head {
+    flex-direction: column;
+  }
+}

app/static/js/app.js

@@ -0,0 +1,192 @@
+const form = document.getElementById("analyzeForm");
+const fileInput = document.getElementById("fileInput");
+const requiredItems = document.getElementById("requiredItems");
+const generateAiSummary = document.getElementById("generateAiSummary");
+const submitButton = document.getElementById("submitButton");
+const filePreview = document.getElementById("filePreview");
+const loadingState = document.getElementById("loadingState");
+const emptyState = document.getElementById("emptyState");
+const resultsContent = document.getElementById("resultsContent");
+const summaryGrid = document.getElementById("summaryGrid");
+const annotatedImage = document.getElementById("annotatedImage");
+const reportTitle = document.getElementById("reportTitle");
+const reportSummary = document.getElementById("reportSummary");
+const reportActions = document.getElementById("reportActions");
+const workerList = document.getElementById("workerList");
+const timelineSection = document.getElementById("timelineSection");
+const timelineGrid = document.getElementById("timelineGrid");
+const dropzone = document.getElementById("dropzone");
+const demoPolicyButton = document.getElementById("demoPolicyButton");
+const downloadJsonButton = document.getElementById("downloadJsonButton");
+
+let latestResponse = null;
+
+function setLoading(message, busy = false) {
+  loadingState.textContent = message;
+  submitButton.disabled = busy;
+  submitButton.style.opacity = busy ? "0.7" : "1";
+}
+
+function updateFilePreview() {
+  const file = fileInput.files?.[0];
+  filePreview.textContent = file
+    ? `${file.name} • ${(file.size / (1024 * 1024)).toFixed(2)} MB`
+    : "No file selected yet.";
+}
+
+function createSummaryCard(label, value, tone = "") {
+  const card = document.createElement("article");
+  card.className = `summary-card ${tone}`.trim();
+  card.innerHTML = `<span>${label}</span><strong>${value}</strong>`;
+  return card;
+}
+
+function renderWorkers(workers) {
+  workerList.innerHTML = "";
+  workers.forEach((worker) => {
+    const card = document.createElement("article");
+    card.className = "worker-card";
+    const statusClass = worker.status === "compliant" ? "ok" : "bad";
+    card.innerHTML = `
+      <div class="worker-header">
+        <h5>${worker.worker_id}</h5>
+        <span class="worker-pill ${statusClass}">${worker.status}</span>
+      </div>
+      <div class="worker-meta"><strong>Score:</strong> ${worker.score}%</div>
+      <div class="worker-meta"><strong>Present:</strong> ${worker.present_items.join(", ") || "None"}</div>
+      <div class="worker-meta"><strong>Missing:</strong> ${worker.missing_items.join(", ") || "None"}</div>
+    `;
+    workerList.appendChild(card);
+  });
+}
+
+function renderActions(actions) {
+  reportActions.innerHTML = "";
+  actions.forEach((action) => {
+    const item = document.createElement("div");
+    item.className = "action-item";
+    item.textContent = action;
+    reportActions.appendChild(item);
+  });
+}
+
+function renderTimeline(frames) {
+  timelineGrid.innerHTML = "";
+  if (!frames.length) {
+    timelineSection.classList.add("hidden");
+    return;
+  }
+  timelineSection.classList.remove("hidden");
+  frames.forEach((frame) => {
+    const card = document.createElement("article");
+    card.className = "timeline-card";
+    card.innerHTML = `
+      <div class="timeline-header">
+        <h5>${frame.timestamp_seconds}s</h5>
+        <span class="risk-pill ${frame.risk_level}">${frame.risk_level} risk</span>
+      </div>
+      <img src="${frame.thumbnail_url}" alt="Frame at ${frame.timestamp_seconds} seconds" />
+      <div class="timeline-meta">${frame.compliant_workers}/${frame.total_workers} workers compliant</div>
+    `;
+    timelineGrid.appendChild(card);
+  });
+}
+
+function renderResults(payload) {
+  latestResponse = payload;
+  emptyState.classList.add("hidden");
+  resultsContent.classList.remove("hidden");
+
+  summaryGrid.innerHTML = "";
+  summaryGrid.appendChild(createSummaryCard("Workers", payload.site_summary.total_workers));
+  summaryGrid.appendChild(createSummaryCard("Compliance", `${payload.site_summary.compliance_rate}%`));
+  summaryGrid.appendChild(createSummaryCard("Non-Compliant", payload.site_summary.non_compliant_workers));
+  summaryGrid.appendChild(createSummaryCard("Policy", payload.required_items.join(", ")));
+
+  annotatedImage.src = payload.annotated_asset.url;
+  reportTitle.textContent = payload.report.title;
+  reportSummary.textContent = payload.report.summary;
+  renderActions(payload.report.actions);
+  renderWorkers(payload.workers);
+  renderTimeline(payload.frames || []);
+}
+
+async function handleSubmit(event) {
+  event.preventDefault();
+  const file = fileInput.files?.[0];
+  if (!file) {
+    setLoading("Choose an image or video first");
+    return;
+  }
+
+  const body = new FormData();
+  body.append("file", file);
+  body.append("required_items", requiredItems.value);
+  body.append("generate_ai_summary", generateAiSummary.checked ? "true" : "false");
+
+  setLoading("Analyzing PPE compliance...", true);
+
+  try {
+    const response = await fetch("/api/analyze", {
+      method: "POST",
+      body,
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Error(data.detail || "Analysis failed");
+    }
+    renderResults(data);
+    setLoading("Analysis complete");
+  } catch (error) {
+    setLoading(error.message || "Analysis failed");
+  } finally {
+    submitButton.disabled = false;
+    submitButton.style.opacity = "1";
+  }
+}
+
+function enableDragAndDrop() {
+  ["dragenter", "dragover"].forEach((eventName) => {
+    dropzone.addEventListener(eventName, (event) => {
+      event.preventDefault();
+      dropzone.classList.add("dragging");
+    });
+  });
+
+  ["dragleave", "drop"].forEach((eventName) => {
+    dropzone.addEventListener(eventName, (event) => {
+      event.preventDefault();
+      dropzone.classList.remove("dragging");
+    });
+  });
+
+  dropzone.addEventListener("drop", (event) => {
+    const file = event.dataTransfer?.files?.[0];
+    if (!file) {
+      return;
+    }
+    fileInput.files = event.dataTransfer.files;
+    updateFilePreview();
+  });
+}
+
+demoPolicyButton.addEventListener("click", () => {
+  requiredItems.value = "helmet,vest";
+});
+
+downloadJsonButton.addEventListener("click", () => {
+  if (!latestResponse) {
+    return;
+  }
+  const blob = new Blob([JSON.stringify(latestResponse, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = "ppe-analysis.json";
+  anchor.click();
+  URL.revokeObjectURL(url);
+});
+
+fileInput.addEventListener("change", updateFilePreview);
+form.addEventListener("submit", handleSubmit);
+enableDragAndDrop();

app/templates/index.html

@@ -0,0 +1,156 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{ app_name }}</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&family=Space+Grotesk:wght@500;700&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="/static/css/styles.css" />
+  </head>
+  <body>
+    <div class="noise"></div>
+    <header class="topbar">
+      <div class="brand">
+        <span class="brand-mark">PS</span>
+        <div>
+          <p class="eyebrow">Safety Intelligence</p>
+          <h1>{{ app_name }}</h1>
+        </div>
+      </div>
+      <div class="status-chip {{ 'enabled' if openai_enabled else 'muted' }}">
+        {{ 'OpenAI Reports Ready' if openai_enabled else 'Rule-Based Reports' }}
+      </div>
+    </header>
+
+    <main class="page-shell">
+      <section class="hero card">
+        <div class="hero-copy">
+          <p class="eyebrow">Enterprise PPE Monitoring</p>
+          <h2>{{ tagline }}</h2>
+          <p class="lead">
+            Upload photos or short videos from phones, CCTV exports, or site audits. The app detects workers,
+            scores PPE compliance, and generates a management-ready summary.
+          </p>
+          <div class="hero-pills">
+            <span>Desktop + mobile ready</span>
+            <span>Images + short videos</span>
+            <span>Helmet, vest, mask, gloves</span>
+          </div>
+        </div>
+        <div class="hero-metrics">
+          <div>
+            <span>Detector</span>
+            <strong>Zero-Shot Grounding DINO</strong>
+          </div>
+          <div>
+            <span>Default Policy</span>
+            <strong>{{ default_required_items | join(', ') }}</strong>
+          </div>
+          <div>
+            <span>Designed For</span>
+            <strong>Construction and industrial teams</strong>
+          </div>
+        </div>
+      </section>
+
+      <section class="workspace">
+        <section class="uploader card">
+          <div class="section-head">
+            <div>
+              <p class="eyebrow">Upload</p>
+              <h3>Scan a site image or video</h3>
+            </div>
+            <button id="demoPolicyButton" class="ghost-button" type="button">Use Standard Policy</button>
+          </div>
+
+          <form id="analyzeForm" class="upload-form">
+            <label class="dropzone" for="fileInput" id="dropzone">
+              <input id="fileInput" name="file" type="file" accept="image/*,video/*" required />
+              <span class="drop-icon">Inspect</span>
+              <strong>Drop media here or tap to browse</strong>
+              <small>Supports JPG, PNG, WEBP, MP4, MOV, AVI, MKV, WEBM</small>
+            </label>
+
+            <div class="form-grid">
+              <label>
+                <span>Required PPE policy</span>
+                <input
+                  id="requiredItems"
+                  name="required_items"
+                  type="text"
+                  value="{{ default_required_items | join(',') }}"
+                  placeholder="helmet,vest"
+                />
+              </label>
+              <label class="toggle-row">
+                <span>Generate executive summary</span>
+                <input id="generateAiSummary" name="generate_ai_summary" type="checkbox" checked />
+              </label>
+            </div>
+
+            <div class="file-preview" id="filePreview">No file selected yet.</div>
+            <button class="primary-button" id="submitButton" type="submit">Analyze PPE Compliance</button>
+          </form>
+        </section>
+
+        <section class="results card">
+          <div class="section-head">
+            <div>
+              <p class="eyebrow">Results</p>
+              <h3>Operational command view</h3>
+            </div>
+            <div id="loadingState" class="loading-state">Waiting for upload</div>
+          </div>
+
+          <div id="emptyState" class="empty-state">
+            <h4>Ready for the first scan</h4>
+            <p>The dashboard will populate with worker cards, compliance metrics, evidence snapshots, and the report.</p>
+          </div>
+
+          <div id="resultsContent" class="results-content hidden">
+            <div class="summary-grid" id="summaryGrid"></div>
+            <div class="media-panel">
+              <img id="annotatedImage" alt="Annotated result" />
+            </div>
+            <div class="report-panel">
+              <div class="report-header">
+                <div>
+                  <p class="eyebrow">Executive Summary</p>
+                  <h4 id="reportTitle"></h4>
+                </div>
+                <button id="downloadJsonButton" class="ghost-button" type="button">Download JSON</button>
+              </div>
+              <p id="reportSummary" class="report-summary"></p>
+              <div id="reportActions" class="action-list"></div>
+            </div>
+            <div>
+              <div class="section-head minor">
+                <div>
+                  <p class="eyebrow">Workers</p>
+                  <h4>Compliance roster</h4>
+                </div>
+              </div>
+              <div id="workerList" class="worker-list"></div>
+            </div>
+            <div id="timelineSection" class="timeline-section hidden">
+              <div class="section-head minor">
+                <div>
+                  <p class="eyebrow">Video Timeline</p>
+                  <h4>Sampled compliance frames</h4>
+                </div>
+              </div>
+              <div id="timelineGrid" class="timeline-grid"></div>
+            </div>
+          </div>
+        </section>
+      </section>
+    </main>
+
+    <script src="/static/js/app.js"></script>
+  </body>
+</html>

artifacts/.gitkeep

@@ -0,0 +1 @@
+

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.135.1
+jinja2==3.1.6
+numpy==2.3.3
+openai==2.29.0
+opencv-python-headless==4.13.0.92
+pillow==12.1.1
+pydantic==2.12.0
+python-dotenv==1.2.2
+python-multipart==0.0.20
+torch==2.10.0
+transformers==4.57.6
+uvicorn[standard]==0.38.0