feat(segmentation): add YSAM2 variants and mission-aware detector mapping

app.py

@@ -61,6 +61,7 @@ from utils.threat_chat import chat_about_threats
 from utils.relevance import evaluate_relevance
 from utils.enrichment import run_enrichment
 from utils.schemas import AssessmentStatus
+from models.segmenters.model_loader import get_segmenter_detector
 from utils.mission_parser import parse_mission_text, build_broad_queries, MissionParseError
 
 logging.basicConfig(level=logging.INFO)
@@ -260,7 +261,7 @@ async def detect_endpoint(
         mode: Detection mode (object_detection, segmentation, drone_detection)
         queries: Comma-separated object classes for object_detection mode
         detector: Model to use (hf_yolov8, detr_resnet50, grounding_dino)
-        segmenter: Segmentation model to use (GSAM2-S, GSAM2-B, GSAM2-L)
+        segmenter: Segmentation model to use (GSAM2-S/B/L, YSAM2-S/B/L)
         enable_depth: Whether to run legacy depth estimation (default: False)
         drone_detection uses the dedicated drone_yolo model.
 
@@ -302,7 +303,6 @@ async def detect_endpoint(
                 output_path,
                 query_list,
                 segmenter_name=segmenter,
-                detector_name="grounding_dino",
                 num_maskmem=7,
             )
         except ValueError as exc:
@@ -439,16 +439,23 @@ async def detect_async_endpoint(
     mission_mode = "LEGACY"
 
     detector_name = detector
+    mission_detector = detector  # detector key used for mission query parsing
     if mode == "drone_detection":
         detector_name = "drone_yolo"
+        mission_detector = "drone_yolo"
     elif mode == "segmentation":
-        # Grounded-SAM2 uses Grounding DINO (open-vocabulary) for keyframe prompts.
-        detector_name = "grounding_dino"
+        # Segmenter registry owns detector selection (GSAM2→GDINO, YSAM2→YOLO).
+        # detector_name=None so the job doesn't forward it (avoids duplicate kwarg).
+        try:
+            mission_detector = get_segmenter_detector(segmenter)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+        detector_name = None
 
     if queries.strip():
         try:
-            mission_spec = parse_mission_text(queries.strip(), detector_name, video_path=str(input_path))
-            query_list = build_broad_queries(detector_name, mission_spec)
+            mission_spec = parse_mission_text(queries.strip(), mission_detector, video_path=str(input_path))
+            query_list = build_broad_queries(mission_detector, mission_spec)
             mission_mode = "MISSION"
             logging.info(
                 "Mission parsed: mode=%s classes=%s broad_queries=%s domain=%s(%s)",

frontend/index.html

@@ -78,6 +78,9 @@
                   <option value="GSAM2-L" data-kind="segmentation">GSAM2-L</option>
                   <option value="GSAM2-B" data-kind="segmentation">GSAM2-B</option>
                   <option value="GSAM2-S" data-kind="segmentation">GSAM2-S</option>
+                  <option value="YSAM2-L" data-kind="segmentation">YSAM2-L (Fast)</option>
+                  <option value="YSAM2-B" data-kind="segmentation">YSAM2-B (Fast)</option>
+                  <option value="YSAM2-S" data-kind="segmentation">YSAM2-S (Fast)</option>
                 </optgroup>
                 <optgroup label="Drone Detection Models">
                   <option value="drone_yolo" data-kind="drone">Drone</option>

models/segmenters/grounded_sam2.py

@@ -349,7 +349,9 @@ class GroundedSAM2Segmenter(Segmenter):
         self.num_maskmem = num_maskmem  # None = use default (7)
         self._detector_name = detector_name  # None = "grounding_dino"
         _size_suffix = {"small": "S", "base": "B", "large": "L"}
-        self.name = f"GSAM2-{_size_suffix[model_size]}"
+        _det_prefix = {"hf_yolov8": "YSAM2"}
+        _prefix = _det_prefix.get(detector_name, "GSAM2")
+        self.name = f"{_prefix}-{_size_suffix[model_size]}"
 
         if device:
             self.device = device

models/segmenters/model_loader.py

@@ -1,19 +1,56 @@
 import os
 from functools import lru_cache
-from typing import Callable, Dict, Optional
+from typing import Callable, Dict, Optional, Tuple
 
 from .base import Segmenter
 from .grounded_sam2 import GroundedSAM2Segmenter
 
 DEFAULT_SEGMENTER = "GSAM2-L"
+_DEFAULT_SEGMENTER_DETECTOR = "grounding_dino"
+
+_SEGMENTER_SPECS: Dict[str, Tuple[str, Optional[str]]] = {
+    "GSAM2-S": ("small", None),
+    "GSAM2-B": ("base", None),
+    "GSAM2-L": ("large", None),
+    "YSAM2-S": ("small", "hf_yolov8"),
+    "YSAM2-B": ("base", "hf_yolov8"),
+    "YSAM2-L": ("large", "hf_yolov8"),
+}
+
+
+def _build_factory(model_size: str, detector_name: Optional[str]) -> Callable[..., Segmenter]:
+    def _factory(**kw) -> Segmenter:
+        if detector_name is None:
+            return GroundedSAM2Segmenter(model_size=model_size, **kw)
+        # YSAM2 keys own detector selection; drop accidental caller overrides.
+        kw.pop("detector_name", None)
+        return GroundedSAM2Segmenter(
+            model_size=model_size,
+            detector_name=detector_name,
+            **kw,
+        )
+
+    return _factory
+
 
 _REGISTRY: Dict[str, Callable[..., Segmenter]] = {
-    "GSAM2-S": lambda **kw: GroundedSAM2Segmenter(model_size="small", **kw),
-    "GSAM2-B": lambda **kw: GroundedSAM2Segmenter(model_size="base", **kw),
-    "GSAM2-L": lambda **kw: GroundedSAM2Segmenter(model_size="large", **kw),
+    name: _build_factory(model_size, detector_name)
+    for name, (model_size, detector_name) in _SEGMENTER_SPECS.items()
 }
 
 
+def get_segmenter_detector(segmenter_name: str) -> str:
+    """Return the detector key associated with a segmenter (for mission parsing)."""
+    spec = _SEGMENTER_SPECS.get(segmenter_name)
+    if spec is None:
+        available = ", ".join(sorted(_REGISTRY))
+        raise ValueError(
+            f"Unknown segmenter '{segmenter_name}'. Available: {available}"
+        )
+    detector_name = spec[1]
+    return detector_name or _DEFAULT_SEGMENTER_DETECTOR
+
+
 def _create_segmenter(name: str, **kwargs) -> Segmenter:
     """Create a new segmenter instance."""
     try:

utils/roofline.py

@@ -24,6 +24,10 @@ _MODEL_FLOPS: Dict[str, float] = {
     "GSAM2-S": 48.0,             # SAM2 small encoder
     "GSAM2-B": 96.0,             # SAM2 base encoder
     "GSAM2-L": 200.0,            # SAM2 large encoder
+    # YSAM2 uses the same SAM2 backbone; detector differences are reflected in timing.
+    "YSAM2-S": 48.0,
+    "YSAM2-B": 96.0,
+    "YSAM2-L": 200.0,
     "gsam2_tiny": 24.0,          # SAM2 tiny encoder
 }
 
@@ -37,6 +41,9 @@ _MODEL_BYTES: Dict[str, float] = {
     "GSAM2-S": 92.0,
     "GSAM2-B": 180.0,
     "GSAM2-L": 400.0,
+    "YSAM2-S": 92.0,
+    "YSAM2-B": 180.0,
+    "YSAM2-L": 400.0,
     "gsam2_tiny": 46.0,
 }