omnius 1.0.410 → 1.0.411

package/dist/index.js

@@ -555654,6 +555654,169 @@ function buildYolo26BootstrapPlan(model = DEFAULT_YOLO26_MODEL) {
     packages: ["ultralytics>=8.4.0", "opencv-python-headless", "yt-dlp", "numpy"]
   };
 }
+function buildYolo26DeploymentOptions() {
+  const yolo26Models = YOLO26_SCALES.flatMap((scale) => Object.values(YOLO26_TASKS).map((task) => `yolo26${scale}${task.suffix}.pt`));
+  const yoloeModels = YOLO26_SCALES.flatMap((scale) => [`yoloe-26${scale}-seg.pt`, `yoloe-26${scale}-seg-pf.pt`]);
+  return {
+    defaultModel: DEFAULT_YOLO26_MODEL,
+    scales: [...YOLO26_SCALES],
+    tasks: YOLO26_TASKS,
+    families: {
+      yolo26: {
+        description: "YOLO26 closed-vocabulary models for detection, segmentation, semantic segmentation, pose, OBB, and classification.",
+        models: yolo26Models
+      },
+      "yoloe-26": {
+        description: "YOLOE-26 open-vocabulary segmentation models for text, visual, or prompt-free detection/segmentation workflows.",
+        models: yoloeModels
+      }
+    },
+    yoloePromptModes: [
+      { mode: "text", description: "Set open-vocabulary classes with model.set_classes([...]) before prediction or export." },
+      { mode: "prompt_free", description: "Use YOLOE prompt-free weights such as yoloe-26s-seg-pf.pt for built-in large-vocabulary discovery." },
+      { mode: "visual", description: "Use YOLOE visual prompts where supported by the installed Ultralytics version; exported prompts are static." }
+    ],
+    exportFormats: YOLO26_EXPORT_FORMATS,
+    headModes: [
+      { value: true, name: "end2end", description: "YOLO26 default one-to-one head; NMS-free output optimized for deployment latency." },
+      { value: false, name: "one-to-many", description: "Traditional output requiring NMS post-processing; useful for compatibility or accuracy-sensitive pipelines." }
+    ],
+    exportArguments: [
+      "format",
+      "imgsz",
+      "quantize",
+      "dynamic",
+      "simplify",
+      "opset",
+      "workspace",
+      "nms",
+      "batch",
+      "device",
+      "data",
+      "fraction",
+      "end2end",
+      "optimize",
+      "keras",
+      "name"
+    ]
+  };
+}
+function normalizeYolo26Scale(value2) {
+  const scale = String(value2 ?? "n").trim().toLowerCase();
+  return YOLO26_SCALES.includes(scale) ? scale : "n";
+}
+function normalizeYolo26Task(value2) {
+  const raw = String(value2 ?? "detect").trim().toLowerCase();
+  const aliases = {
+    detection: "detect",
+    det: "detect",
+    instance: "segment",
+    segmentation: "segment",
+    seg: "segment",
+    sem: "semantic",
+    semantic_segmentation: "semantic",
+    keypoint: "pose",
+    keypoints: "pose",
+    classify: "classify",
+    classification: "classify",
+    cls: "classify",
+    oriented: "obb",
+    oriented_detection: "obb"
+  };
+  const normalized = aliases[raw] ?? raw;
+  return Object.prototype.hasOwnProperty.call(YOLO26_TASKS, normalized) ? normalized : "detect";
+}
+function normalizeYolo26Family(value2) {
+  const raw = String(value2 ?? "yolo26").trim().toLowerCase();
+  if (["yoloe", "yoloe26", "yoloe-26", "open-vocabulary", "open_vocab"].includes(raw))
+    return "yoloe-26";
+  return "yolo26";
+}
+function resolveYolo26Model(args) {
+  const explicit = args["yolo_model"] ?? args["model"];
+  if (typeof explicit === "string" && explicit.trim())
+    return explicit.trim();
+  const family = normalizeYolo26Family(args["yolo_family"] ?? args["family"] ?? args["variant"]);
+  const scale = normalizeYolo26Scale(args["yolo_scale"] ?? args["scale"]);
+  const promptMode = String(args["yoloe_prompt_mode"] ?? args["prompt_mode"] ?? "").trim().toLowerCase();
+  const promptFree = promptMode === "prompt_free" || promptMode === "prompt-free" || promptMode === "pf" || args["prompt_free"] === true;
+  if (family === "yoloe-26")
+    return `yoloe-26${scale}-seg${promptFree ? "-pf" : ""}.pt`;
+  const task = normalizeYolo26Task(args["yolo_task"] ?? args["task"]);
+  return `yolo26${scale}${YOLO26_TASKS[task].suffix}.pt`;
+}
+function normalizeYolo26ExportFormat(value2) {
+  const raw = String(value2 ?? "onnx").trim().toLowerCase().replace(/-/g, "_");
+  const aliases = {
+    trt: "engine",
+    tensorrt: "engine",
+    tf_saved_model: "saved_model",
+    savedmodel: "saved_model",
+    tensorflow_saved_model: "saved_model",
+    graphdef: "pb",
+    edge_tpu: "edgetpu",
+    tflite: "litert",
+    tensorflow_lite: "litert",
+    lite_rt: "litert",
+    torch: "pytorch",
+    pt: "pytorch"
+  };
+  const normalized = aliases[raw] ?? raw;
+  if (YOLO26_EXPORT_FORMATS.some((entry) => entry.format === normalized))
+    return normalized;
+  throw new Error(`Unsupported YOLO26 export format: ${String(value2)}. Use one of: ${YOLO26_EXPORT_FORMATS.map((entry) => entry.format).join(", ")}`);
+}
+function optionalBoolean(args, key) {
+  if (!(key in args) || args[key] === void 0 || args[key] === null || args[key] === "")
+    return void 0;
+  if (typeof args[key] === "boolean")
+    return args[key];
+  const raw = String(args[key]).trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(raw))
+    return true;
+  if (["0", "false", "no", "off"].includes(raw))
+    return false;
+  return void 0;
+}
+function optionalNumber(args, key) {
+  if (!(key in args) || args[key] === void 0 || args[key] === null || args[key] === "")
+    return void 0;
+  const n2 = Number(args[key]);
+  return Number.isFinite(n2) ? n2 : void 0;
+}
+function exportOptionsFromArgs(args, format3) {
+  const options2 = { format: format3 };
+  for (const key of ["imgsz", "opset", "workspace", "batch", "fraction"]) {
+    const n2 = optionalNumber(args, key);
+    if (n2 !== void 0)
+      options2[key] = n2;
+  }
+  for (const key of ["dynamic", "simplify", "nms", "optimize", "keras", "end2end"]) {
+    const b = optionalBoolean(args, key);
+    if (b !== void 0)
+      options2[key] = b;
+  }
+  const quantize = args["quantize"] ?? args["precision"];
+  if (quantize !== void 0 && quantize !== null && String(quantize).trim()) {
+    const asNumber2 = Number(quantize);
+    options2["quantize"] = Number.isFinite(asNumber2) ? asNumber2 : String(quantize).trim();
+  }
+  for (const key of ["device", "data", "name"]) {
+    const value2 = args[key];
+    if (typeof value2 === "string" && value2.trim())
+      options2[key] = value2.trim();
+  }
+  return options2;
+}
+function stringListFromArg(value2) {
+  if (Array.isArray(value2)) {
+    return value2.map((item) => String(item).trim()).filter(Boolean);
+  }
+  if (typeof value2 === "string") {
+    return value2.split(/[,;\n]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}
 function sourceKind(args) {
   const explicit = String(args["source_kind"] ?? args["source_type"] ?? "").toLowerCase();
   if (["camera", "youtube", "file", "direct"].includes(explicit))
@@ -555797,6 +555960,59 @@ async function ensureRuntime(autoBootstrap) {
     return { ok: false, python: plan.python, error: err instanceof Error ? err.message : String(err) };
   }
 }
+async function exportYolo26Model(python, model, options2, yoloeClasses = []) {
+  const cfgPath = join92(tmpdir19(), `omnius-yolo26-export-${Date.now()}.json`);
+  const scriptPath2 = join92(tmpdir19(), `omnius-yolo26-export-${Date.now()}.py`);
+  writeFileSync39(cfgPath, JSON.stringify({ model, options: options2, yoloeClasses }, null, 2), "utf8");
+  writeFileSync39(scriptPath2, String.raw`
+import json, sys
+from ultralytics import YOLO
+try:
+    from ultralytics import YOLOE
+except Exception:
+    YOLOE = None
+
+cfg_path = sys.argv[1]
+with open(cfg_path, "r", encoding="utf-8") as fh:
+    cfg = json.load(fh)
+
+model_name = cfg["model"]
+options = cfg["options"]
+yoloe_classes = [str(x).strip() for x in cfg.get("yoloeClasses", []) if str(x).strip()]
+model = YOLOE(model_name) if str(model_name).startswith("yoloe-") and YOLOE is not None else YOLO(model_name)
+if yoloe_classes and hasattr(model, "set_classes"):
+    model.set_classes(yoloe_classes)
+artifact = model.export(**options)
+print(json.dumps({
+    "success": True,
+    "model": model_name,
+    "format": options.get("format"),
+    "artifact": str(artifact),
+    "options": options,
+    "yoloe_classes": yoloe_classes,
+}))
+`, "utf8");
+  try {
+    const raw = await execFileText(python, [scriptPath2, cfgPath], {
+      timeout: 30 * 6e4,
+      maxBuffer: 64 * 1024 * 1024,
+      env: { ...process.env, PYTHONUNBUFFERED: "1" }
+    });
+    const jsonLine2 = raw.trim().split("\n").reverse().find((line) => line.trim().startsWith("{") && line.trim().endsWith("}"));
+    if (!jsonLine2)
+      throw new Error(`YOLO26 export returned no JSON result; stdout tail: ${raw.slice(-1e3)}`);
+    return JSON.parse(jsonLine2);
+  } finally {
+    try {
+      rmSync10(cfgPath, { force: true });
+    } catch {
+    }
+    try {
+      rmSync10(scriptPath2, { force: true });
+    } catch {
+    }
+  }
+}
 function makePythonScript() {
   return String.raw`
 import json, os, sys, time
@@ -555818,6 +556034,8 @@ def main():
     os.makedirs(out_dir, exist_ok=True)
     crop_dir = os.path.join(out_dir, "crops")
     os.makedirs(crop_dir, exist_ok=True)
+    segment_dir = os.path.join(out_dir, "segments")
+    os.makedirs(segment_dir, exist_ok=True)
     source_kind = cfg["source_kind"]
     source = cfg["source"]
     media_path = None
@@ -555827,6 +556045,10 @@ def main():
         import cv2
         import numpy as np
         from ultralytics import YOLO
+        try:
+            from ultralytics import YOLOE
+        except Exception:
+            YOLOE = None
     except Exception as exc:
         print(json.dumps({"success": False, "error": "python imports failed: " + str(exc)}))
         return
@@ -555869,16 +556091,26 @@ def main():
         return
 
     yolo_model = cfg.get("yolo_model") or "yolo26n.pt"
-    model = YOLO(yolo_model) if cfg.get("detect_objects", True) else None
+    yoloe_classes = [str(x).strip() for x in (cfg.get("yoloe_classes") or []) if str(x).strip()]
+    yoloe_prompt_mode = cfg.get("yoloe_prompt_mode") or ("text" if yoloe_classes else "prompt_free" if str(yolo_model).endswith("-pf.pt") else "closed_set")
+    use_yoloe = str(yolo_model).startswith("yoloe-") and YOLOE is not None
+    model = (YOLOE(yolo_model) if use_yoloe else YOLO(yolo_model)) if cfg.get("detect_objects", True) else None
+    if model is not None and yoloe_classes and hasattr(model, "set_classes"):
+        try:
+            model.set_classes(yoloe_classes)
+        except TypeError:
+            model.set_classes(list(yoloe_classes))
     face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
     objects = []
     faces = []
+    segments = []
     track_stats = {}
     max_frames = int(cfg.get("max_frames") or 8)
     interval = float(cfg.get("sample_interval_sec") or 1.0)
     duration = float(cfg.get("duration_sec") or 8.0)
     conf = float(cfg.get("confidence") or 0.25)
     imgsz = int(cfg.get("imgsz") or 640)
+    end2end = cfg.get("end2end", None)
     start_wall = time.time()
     frame_index = 0
 
@@ -555902,10 +556134,17 @@ def main():
 
         if model is not None:
             try:
+                predict_kwargs = {"verbose": False, "conf": conf, "imgsz": imgsz}
+                if end2end is not None:
+                    predict_kwargs["end2end"] = bool(end2end)
+                if cfg.get("agnostic_nms", None) is not None:
+                    predict_kwargs["agnostic_nms"] = bool(cfg.get("agnostic_nms"))
+                elif use_yoloe:
+                    predict_kwargs["agnostic_nms"] = True
                 if cfg.get("track_objects", True):
-                    results = model.track(frame, persist=True, verbose=False, conf=conf, imgsz=imgsz)
+                    results = model.track(frame, persist=True, **predict_kwargs)
                 else:
-                    results = model.predict(frame, verbose=False, conf=conf, imgsz=imgsz)
+                    results = model.predict(frame, **predict_kwargs)
                 r = results[0] if results else None
                 if r is not None and getattr(r, "boxes", None) is not None:
                     boxes = r.boxes
@@ -555935,6 +556174,44 @@ def main():
                         st["last_seen_sec"] = max(st["last_seen_sec"], ts)
                         st["observations"] += 1
                         st["confidence_sum"] += c
+                    want_segments = bool(cfg.get("segment_objects") or cfg.get("extract_segments") or use_yoloe)
+                    if want_segments and getattr(r, "masks", None) is not None and getattr(r.masks, "data", None) is not None:
+                        mask_data = r.masks.data.cpu().numpy()
+                        max_segments = int(cfg.get("max_segments_per_frame") or 8)
+                        for i, raw_mask in enumerate(mask_data[:max_segments]):
+                            label = str(names.get(int(cls[i]), int(cls[i]))) if i < len(cls) else "object"
+                            c = float(confs[i]) if i < len(confs) else 0.0
+                            box = xyxy[i] if i < len(xyxy) else [0, 0, frame.shape[1], frame.shape[0]]
+                            mask = (raw_mask > 0.5).astype("uint8") * 255
+                            if mask.shape[:2] != frame.shape[:2]:
+                                mask = cv2.resize(mask, (frame.shape[1], frame.shape[0]), interpolation=cv2.INTER_NEAREST)
+                            x1, y1, x2, y2 = [int(max(0, round(float(v)))) for v in box]
+                            x1 = min(x1, frame.shape[1] - 1)
+                            x2 = min(max(x2, x1 + 1), frame.shape[1])
+                            y1 = min(y1, frame.shape[0] - 1)
+                            y2 = min(max(y2, y1 + 1), frame.shape[0])
+                            mask_path = os.path.join(segment_dir, f"seg_f{frame_index:04d}_{i:02d}_mask.png")
+                            cv2.imwrite(mask_path, mask)
+                            crop_path = None
+                            if cfg.get("extract_segments", False):
+                                crop_bgr = frame[y1:y2, x1:x2]
+                                crop_alpha = mask[y1:y2, x1:x2]
+                                if crop_bgr.size > 0 and crop_alpha.size > 0:
+                                    crop_rgba = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2BGRA)
+                                    crop_rgba[:, :, 3] = crop_alpha
+                                    crop_path = os.path.join(segment_dir, f"seg_f{frame_index:04d}_{i:02d}_{label.replace('/', '_')}.png")
+                                    cv2.imwrite(crop_path, crop_rgba)
+                            area_ratio = float((mask > 0).sum()) / max(1.0, float(frame.shape[0] * frame.shape[1]))
+                            segments.append({
+                                "frame_index": frame_index,
+                                "timestamp_sec": round(float(ts), 3),
+                                "label": label,
+                                "confidence": c,
+                                "bbox_xyxy": [int(x1), int(y1), int(x2), int(y2)],
+                                "mask_path": mask_path,
+                                "crop_path": crop_path,
+                                "area_ratio": round(area_ratio, 6),
+                            })
             except Exception as exc:
                 objects.append({"frame_index": frame_index, "timestamp_sec": round(float(ts), 3), "label": "yolo_error", "confidence": 0.0, "bbox_xyxy": [0,0,0,0], "error": str(exc)})
 
@@ -555984,6 +556261,9 @@ def main():
         "objects": objects,
         "tracks": tracks,
         "faces": faces,
+        "segments": segments,
+        "yoloe_classes": yoloe_classes,
+        "yoloe_prompt_mode": yoloe_prompt_mode,
     }))
 
 if __name__ == "__main__":
@@ -555995,8 +556275,13 @@ function mockResult(args, workingDir) {
   const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
   const outDir = join92(workingDir, ".omnius", "live-media", `mock-${Date.now().toString(36)}`);
   mkdirSync47(join92(outDir, "crops"), { recursive: true });
+  mkdirSync47(join92(outDir, "segments"), { recursive: true });
   const facePath = join92(outDir, "crops", "face_f0000_00.jpg");
+  const maskPath = join92(outDir, "segments", "seg_f0001_00_mask.png");
+  const segmentPath = join92(outDir, "segments", "seg_f0001_00_red_cup.png");
   writeFileSync39(facePath, "mock face crop", "utf8");
+  writeFileSync39(maskPath, "mock segment mask", "utf8");
+  writeFileSync39(segmentPath, "mock extracted segment", "utf8");
   return {
     success: true,
     source_kind: kind,
@@ -556016,10 +556301,22 @@ function mockResult(args, workingDir) {
       { track_id: "1", label: "person", first_seen_sec: 0, last_seen_sec: 0, observations: 1, mean_confidence: 0.91 },
       { track_id: "2", label: "red cup", first_seen_sec: 1, last_seen_sec: 2, observations: 2, mean_confidence: 0.84 }
     ],
-    faces: [{ frame_index: 0, timestamp_sec: 0, crop_path: facePath, bbox_xyxy: [20, 30, 80, 90], confidence: 0.5 }]
+    faces: [{ frame_index: 0, timestamp_sec: 0, crop_path: facePath, bbox_xyxy: [20, 30, 80, 90], confidence: 0.5 }],
+    segments: [{
+      frame_index: 1,
+      timestamp_sec: 1,
+      label: "red cup",
+      confidence: 0.84,
+      bbox_xyxy: [130, 140, 180, 210],
+      mask_path: maskPath,
+      crop_path: segmentPath,
+      area_ratio: 0.012
+    }],
+    yoloe_classes: stringListFromArg(args["yoloe_classes"] ?? args["classes"]),
+    yoloe_prompt_mode: String(args["yoloe_prompt_mode"] ?? "closed_set")
   };
 }
-var LIVE_MEDIA_ROOT, YOLO26_VENV, DEFAULT_YOLO26_MODEL, LiveMediaLoopTool;
+var LIVE_MEDIA_ROOT, YOLO26_VENV, DEFAULT_YOLO26_MODEL, YOLO26_SCALES, YOLO26_TASKS, YOLO26_EXPORT_FORMATS, LiveMediaLoopTool;
 var init_live_media_loop = __esm({
   "packages/execution/dist/tools/live-media-loop.js"() {
     "use strict";
@@ -556033,14 +556330,44 @@ var init_live_media_loop = __esm({
     LIVE_MEDIA_ROOT = join92(homedir28(), ".omnius", "runtimes", "live-media");
     YOLO26_VENV = join92(LIVE_MEDIA_ROOT, ".venv-yolo26");
     DEFAULT_YOLO26_MODEL = "yolo26n.pt";
+    YOLO26_SCALES = ["n", "s", "m", "l", "x"];
+    YOLO26_TASKS = {
+      detect: { suffix: "", description: "Object detection" },
+      segment: { suffix: "-seg", description: "Instance segmentation" },
+      semantic: { suffix: "-sem", description: "Semantic segmentation" },
+      pose: { suffix: "-pose", description: "Pose/keypoints" },
+      obb: { suffix: "-obb", description: "Oriented object detection" },
+      classify: { suffix: "-cls", description: "Image classification" }
+    };
+    YOLO26_EXPORT_FORMATS = [
+      { format: "pytorch", artifact: "yolo26n.pt", description: "Native PyTorch checkpoint", arguments: [], precisions: ["fp32"] },
+      { format: "torchscript", artifact: "yolo26n.torchscript", description: "TorchScript runtime artifact", arguments: ["imgsz", "quantize", "dynamic", "optimize", "nms", "batch", "device"], precisions: ["fp32", "fp16"] },
+      { format: "onnx", artifact: "yolo26n.onnx", description: "ONNX Runtime and cross-platform inference", arguments: ["imgsz", "quantize", "dynamic", "simplify", "opset", "nms", "batch", "data", "fraction", "device"], precisions: ["fp32", "fp16", "int8"] },
+      { format: "openvino", artifact: "yolo26n_openvino_model/", description: "Intel OpenVINO CPU/iGPU/NPU deployment", arguments: ["imgsz", "quantize", "dynamic", "nms", "batch", "data", "fraction", "device"], precisions: ["fp32", "fp16", "int8"] },
+      { format: "engine", artifact: "yolo26n.engine", description: "NVIDIA TensorRT engine", arguments: ["imgsz", "quantize", "dynamic", "simplify", "workspace", "nms", "batch", "data", "fraction", "device"], precisions: ["fp32", "fp16", "int8"] },
+      { format: "coreml", artifact: "yolo26n.mlpackage", description: "Apple CoreML deployment", arguments: ["imgsz", "dynamic", "quantize", "nms", "batch", "device"], precisions: ["fp32", "fp16", "int8", "w8a16"] },
+      { format: "saved_model", artifact: "yolo26n_saved_model/", description: "TensorFlow SavedModel", arguments: ["imgsz", "keras", "quantize", "nms", "batch", "data", "fraction", "device"], precisions: ["fp32", "int8"] },
+      { format: "pb", artifact: "yolo26n.pb", description: "TensorFlow GraphDef", arguments: ["imgsz", "batch", "device"], precisions: ["fp32"] },
+      { format: "edgetpu", artifact: "yolo26n_edgetpu.tflite", description: "Google Coral Edge TPU", arguments: ["imgsz", "quantize", "data", "fraction", "device"], precisions: ["int8"] },
+      { format: "paddle", artifact: "yolo26n_paddle_model/", description: "PaddlePaddle", arguments: ["imgsz", "batch", "device"], precisions: ["fp32"] },
+      { format: "mnn", artifact: "yolo26n.mnn", description: "MNN mobile/embedded runtime", arguments: ["imgsz", "batch", "quantize", "device"], precisions: ["fp32", "fp16", "int8"] },
+      { format: "ncnn", artifact: "yolo26n_ncnn_model/", description: "Tencent NCNN mobile/embedded runtime", arguments: ["imgsz", "quantize", "batch", "device"], precisions: ["fp32", "fp16"] },
+      { format: "imx", artifact: "yolo26n_imx_model/", description: "Sony IMX500", arguments: ["imgsz", "quantize", "data", "fraction", "nms", "device"], precisions: ["int8", "w8a16"] },
+      { format: "rknn", artifact: "yolo26n_rknn_model/", description: "Rockchip RKNN", arguments: ["imgsz", "batch", "name", "quantize", "data", "fraction", "device"], precisions: ["fp16", "int8"] },
+      { format: "executorch", artifact: "yolo26n_executorch_model/", description: "PyTorch ExecuTorch", arguments: ["imgsz", "batch", "device"], precisions: ["fp32"] },
+      { format: "axelera", artifact: "yolo26n_axelera_model/", description: "Axelera AI deployment", arguments: ["imgsz", "batch", "quantize", "data", "fraction", "device"], precisions: ["int8"] },
+      { format: "deepx", artifact: "yolo26n_deepx_model/", description: "DEEPX accelerator deployment", arguments: ["imgsz", "quantize", "data", "optimize", "device"], precisions: ["int8"] },
+      { format: "qnn", artifact: "yolo26n_qnn.onnx", description: "Qualcomm QNN HTP", arguments: ["imgsz", "batch", "name", "quantize", "data", "fraction", "device"], precisions: ["w8a16"] },
+      { format: "litert", artifact: "yolo26n.tflite", description: "Google LiteRT / TensorFlow Lite successor", arguments: ["imgsz", "quantize", "batch", "data", "fraction", "device"], precisions: ["fp32", "int8", "w8a16", "w8a32"] }
+    ];
     LiveMediaLoopTool = class {
       workingDir;
       name = "live_media_loop";
-      description = "Watch a live or file media source in a bounded loop: YouTube/direct video/local file/camera, YOLO26 object detection/tracking, face cropping, optional face familiarity recall, ASR/audio comprehension, and visual trigger evaluation. Use this for live video input, object tracking, face crops, visual reminders/triggers, and 'watch this video/camera and react when X appears'.";
+      description = "Watch a live or file media source in a bounded loop: YouTube/direct video/local file/camera, YOLO26/YOLOE object detection/tracking, open-vocabulary segmentation masks, extracted transparent object crops, face cropping, optional face familiarity recall, ASR/audio comprehension, and visual trigger evaluation. Use this for live video input, object tracking, object segmentation/extraction, face crops, visual reminders/triggers, and 'watch this video/camera and react when X appears'.";
       parameters = {
         type: "object",
         properties: {
-          action: { type: "string", enum: ["watch", "analyze", "ensure", "status"] },
+          action: { type: "string", enum: ["watch", "analyze", "ensure", "status", "deployment_options", "options", "export"] },
           source_kind: { type: "string", enum: ["youtube", "camera", "file", "direct"] },
           url: { type: "string", description: "YouTube or direct video URL" },
           path: { type: "string", description: "Local media path" },
@@ -556053,6 +556380,36 @@ var init_live_media_loop = __esm({
           sample_interval_sec: { type: "number", description: "Seconds between sampled frames, default 1" },
           max_frames: { type: "number", description: "Max sampled frames, default 8" },
           yolo_model: { type: "string", description: "Ultralytics model, default yolo26n.pt" },
+          yolo_family: { type: "string", enum: ["yolo26", "yoloe-26"], description: "Model family when yolo_model is omitted." },
+          yolo_task: { type: "string", enum: ["detect", "segment", "semantic", "pose", "obb", "classify"], description: "YOLO26 task suffix when yolo_model is omitted." },
+          yolo_scale: { type: "string", enum: ["n", "s", "m", "l", "x"], description: "YOLO26 model scale when yolo_model is omitted." },
+          yoloe_prompt_mode: { type: "string", enum: ["closed_set", "text", "prompt_free", "visual"], description: "YOLOE prompting mode. text uses yoloe_classes; prompt_free uses *-seg-pf weights when no explicit yolo_model is set." },
+          prompt_mode: { type: "string", description: "Alias for yoloe_prompt_mode." },
+          prompt_free: { type: "boolean", description: "Alias for yoloe_prompt_mode=prompt_free." },
+          yoloe_classes: { type: ["array", "string"], description: "YOLOE text prompt classes, e.g. ['person','bus'] or comma-separated string." },
+          classes: { type: ["array", "string"], description: "Alias for yoloe_classes." },
+          segment_objects: { type: "boolean", description: "Capture instance segmentation masks when model returns masks. Enabled automatically for YOLOE." },
+          extract_segments: { type: "boolean", description: "Save transparent RGBA crops for segmented objects." },
+          max_segments_per_frame: { type: "number", description: "Limit saved mask/crop artifacts per sampled frame, default 8." },
+          agnostic_nms: { type: "boolean", description: "Override YOLOE agnostic NMS behavior." },
+          export_format: { type: "string", description: "YOLO26 export format for action=export, e.g. onnx, engine, openvino, coreml, saved_model, rknn, ncnn, litert." },
+          format: { type: "string", description: "Alias for export_format when action=export." },
+          quantize: { type: ["string", "number"], description: "Export precision: 8/int8/w8a8, 16/fp16/w16a16, 32/fp32, w8a16, or w8a32 where supported." },
+          precision: { type: ["string", "number"], description: "Alias for quantize." },
+          end2end: { type: "boolean", description: "YOLO26 one-to-one NMS-free head when true; set false for traditional one-to-many/NMS pipeline." },
+          imgsz: { type: "number", description: "YOLO input/export image size, default 640." },
+          dynamic: { type: "boolean", description: "Enable dynamic input size for supported export formats." },
+          simplify: { type: "boolean", description: "Simplify ONNX/TensorRT export graphs when supported." },
+          opset: { type: "number", description: "ONNX opset version." },
+          workspace: { type: "number", description: "TensorRT workspace size in GiB." },
+          nms: { type: "boolean", description: "Embed NMS in supported exports. Not available for YOLO26 end2end exports." },
+          batch: { type: "number", description: "Export batch size." },
+          device: { type: "string", description: "Export/inference device, e.g. cpu, 0, mps, npu:0, dla:0." },
+          data: { type: "string", description: "Calibration dataset yaml for INT8/W8A16 exports." },
+          fraction: { type: "number", description: "Calibration data fraction for quantized export." },
+          optimize: { type: "boolean", description: "Export optimization for supported targets." },
+          keras: { type: "boolean", description: "Keras SavedModel export option." },
+          name: { type: "string", description: "Target/chip/name option for formats such as RKNN or QNN." },
           auto_bootstrap: { type: "boolean", description: "Create managed YOLO26 venv if missing, default true" },
           detect_objects: { type: "boolean" },
           track_objects: { type: "boolean" },
@@ -556071,9 +556428,27 @@ var init_live_media_loop = __esm({
       async execute(args) {
         const start2 = performance.now();
         const action = String(args["action"] ?? "watch").toLowerCase();
-        const yoloModel = String(args["yolo_model"] ?? DEFAULT_YOLO26_MODEL);
+        const yoloModel = resolveYolo26Model(args);
         const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
         const plan = buildYolo26BootstrapPlan(yoloModel);
+        if (action === "deployment_options" || action === "options") {
+          const options2 = buildYolo26DeploymentOptions();
+          const text2 = [
+            "YOLO26 / YOLOE deployment options",
+            `default model: ${options2.defaultModel}`,
+            `scales: ${options2.scales.join(", ")}`,
+            `tasks: ${Object.entries(options2.tasks).map(([task, meta]) => `${task}${meta.suffix}`).join(", ")}`,
+            `formats: ${options2.exportFormats.map((entry) => entry.format).join(", ")}`,
+            `YOLOE prompt modes: ${options2.yoloePromptModes.map((entry) => entry.mode).join(", ")}`,
+            "head modes: end2end=true for default NMS-free one-to-one head; end2end=false for traditional one-to-many/NMS pipeline"
+          ].join("\n");
+          return {
+            success: true,
+            output: text2,
+            llmContent: JSON.stringify(options2, null, 2),
+            durationMs: performance.now() - start2
+          };
+        }
         if (action === "status" || action === "ensure") {
           const runtime = action === "ensure" ? await ensureRuntime(args["auto_bootstrap"] !== false) : await ensureRuntime(false);
           return {
@@ -556084,13 +556459,69 @@ var init_live_media_loop = __esm({
               `python: ${plan.python}`,
               `model: ${plan.model}`,
               `packages: ${plan.packages.join(", ")}`,
+              `deployment formats: ${YOLO26_EXPORT_FORMATS.map((entry) => entry.format).join(", ")}`,
               runtime.error ? `error: ${runtime.error}` : ""
             ].filter(Boolean).join("\n"),
             error: runtime.ok ? void 0 : runtime.error,
-            llmContent: JSON.stringify({ ...plan, ready: runtime.ok }, null, 2),
+            llmContent: JSON.stringify({ ...plan, ready: runtime.ok, deploymentOptions: buildYolo26DeploymentOptions() }, null, 2),
             durationMs: performance.now() - start2
           };
         }
+        if (action === "export") {
+          let format3;
+          try {
+            format3 = normalizeYolo26ExportFormat(args["export_format"] ?? args["format"] ?? args["deploy_format"]);
+          } catch (err) {
+            return { success: false, output: "", error: err instanceof Error ? err.message : String(err), durationMs: performance.now() - start2 };
+          }
+          if (format3 === "pytorch") {
+            const payload = { success: true, model: yoloModel, format: format3, artifact: yoloModel, options: { format: format3 } };
+            return {
+              success: true,
+              output: `YOLO26 native PyTorch model selected: ${yoloModel}`,
+              llmContent: JSON.stringify(payload, null, 2),
+              durationMs: performance.now() - start2
+            };
+          }
+          const exportOptions = exportOptionsFromArgs(args, format3);
+          const yoloeClasses = stringListFromArg(args["yoloe_classes"] ?? args["classes"]);
+          if (Boolean(args["mock"]) || process.env["OMNIUS_LIVE_MEDIA_MOCK"] === "1") {
+            const payload = {
+              success: true,
+              model: yoloModel,
+              format: format3,
+              artifact: `${basename19(yoloModel, ".pt")}.${format3 === "engine" ? "engine" : format3}`,
+              options: exportOptions,
+              yoloe_classes: yoloeClasses,
+              mock: true
+            };
+            return {
+              success: true,
+              output: `YOLO26 export plan (mock): ${yoloModel} -> ${format3}`,
+              llmContent: JSON.stringify(payload, null, 2),
+              durationMs: performance.now() - start2
+            };
+          }
+          const runtime = await ensureRuntime(args["auto_bootstrap"] !== false);
+          if (!runtime.ok)
+            return { success: false, output: "", error: runtime.error, durationMs: performance.now() - start2 };
+          try {
+            const exported = await exportYolo26Model(runtime.python, yoloModel, exportOptions, yoloeClasses);
+            return {
+              success: true,
+              output: [
+                `YOLO26 export complete: ${yoloModel}`,
+                `format: ${format3}`,
+                `artifact: ${String(exported["artifact"] ?? "")}`,
+                `options: ${JSON.stringify(exportOptions)}`
+              ].join("\n"),
+              llmContent: JSON.stringify(exported, null, 2),
+              durationMs: performance.now() - start2
+            };
+          } catch (err) {
+            return { success: false, output: "", error: err instanceof Error ? err.message : String(err), durationMs: performance.now() - start2 };
+          }
+        }
         const mock = Boolean(args["mock"]) || process.env["OMNIUS_LIVE_MEDIA_MOCK"] === "1";
         let result;
         if (mock) {
@@ -556118,6 +556549,13 @@ var init_live_media_loop = __esm({
             sample_interval_sec: Number(args["sample_interval_sec"] ?? 1),
             max_frames: Number(args["max_frames"] ?? 8),
             rotate_degrees: rotation,
+            end2end: optionalBoolean(args, "end2end"),
+            yoloe_classes: stringListFromArg(args["yoloe_classes"] ?? args["classes"]),
+            yoloe_prompt_mode: String(args["yoloe_prompt_mode"] ?? args["prompt_mode"] ?? ""),
+            segment_objects: args["segment_objects"] !== false,
+            extract_segments: args["extract_segments"] !== false,
+            max_segments_per_frame: Number(args["max_segments_per_frame"] ?? 8),
+            agnostic_nms: optionalBoolean(args, "agnostic_nms"),
             detect_objects: args["detect_objects"] !== false,
             track_objects: args["track_objects"] !== false,
             crop_faces: args["crop_faces"] !== false,
@@ -556215,10 +556653,13 @@ var init_live_media_loop = __esm({
         if (result.media_path)
           lines.push(`media: ${result.media_path}`);
         lines.push(`YOLO model: ${result.yolo_model} (${result.yolo_live ? "live" : "mock/harness"})`);
+        if (result.yoloe_prompt_mode && result.yoloe_prompt_mode !== "closed_set") {
+          lines.push(`YOLOE prompt mode: ${result.yoloe_prompt_mode}${result.yoloe_classes?.length ? ` classes=${result.yoloe_classes.join(", ")}` : ""}`);
+        }
         if (result.rotate_degrees)
           lines.push(`frame rotation correction: ${result.rotate_degrees} degrees clockwise`);
         lines.push(`sampled: ${result.frames_sampled} frame(s) over ${result.duration_observed_sec.toFixed(1)}s`);
-        lines.push(`objects: ${result.objects.length} detection(s), tracks: ${result.tracks.length}, face crops: ${result.faces.length}`);
+        lines.push(`objects: ${result.objects.length} detection(s), tracks: ${result.tracks.length}, face crops: ${result.faces.length}, segments: ${result.segments?.length ?? 0}`);
         const objectSummary = summarizeObjects(result.objects);
         if (objectSummary.length) {
           lines.push("");
@@ -556240,6 +556681,13 @@ var init_live_media_loop = __esm({
             lines.push(`- ${basename19(face.crop_path)} at ${face.timestamp_sec.toFixed(1)}s ${face.crop_path}`);
           }
         }
+        if (result.segments?.length) {
+          lines.push("");
+          lines.push("## Segments");
+          for (const segment of result.segments.slice(0, 12)) {
+            lines.push(`- ${segment.label} conf=${segment.confidence.toFixed(2)} mask=${segment.mask_path}${segment.crop_path ? ` crop=${segment.crop_path}` : ""} area=${(segment.area_ratio ?? 0).toFixed(4)}`);
+          }
+        }
         if (audioEvidence.length) {
           lines.push("");
           lines.push("## Audio Evidence");
@@ -556263,11 +556711,14 @@ var init_live_media_loop = __esm({
             media_path: result.media_path,
             yolo_model: result.yolo_model,
             yolo_live: result.yolo_live,
+            yoloe_classes: result.yoloe_classes ?? [],
+            yoloe_prompt_mode: result.yoloe_prompt_mode,
             rotate_degrees: result.rotate_degrees ?? 0,
             frames_sampled: result.frames_sampled,
             objects: result.objects.slice(0, 80),
             tracks: result.tracks.slice(0, 40),
             faces: result.faces.slice(0, 20),
+            segments: (result.segments ?? []).slice(0, 40),
             audio_evidence: audioEvidence,
             trigger_hits: hits,
             artifacts_dir: result.output_dir
@@ -557548,6 +557999,7 @@ __export(dist_exports2, {
   buildToolManifestFromModule: () => buildToolManifestFromModule,
   buildWorkboardSynthesisContext: () => buildWorkboardSynthesisContext,
   buildYolo26BootstrapPlan: () => buildYolo26BootstrapPlan,
+  buildYolo26DeploymentOptions: () => buildYolo26DeploymentOptions,
   builtInMediaModelCatalog: () => builtInMediaModelCatalog,
   canInvokeTool: () => canInvokeTool,
   checkConstraints: () => checkConstraints,
@@ -557781,6 +558233,7 @@ __export(dist_exports2, {
   resolveMediaCudaVisibleDevicesForEnv: () => resolveMediaCudaVisibleDevicesForEnv,
   resolveMediaModel: () => resolveMediaModel,
   resolveSecret: () => resolveSecret,
+  resolveYolo26Model: () => resolveYolo26Model,
   revokeSecret: () => revokeSecret,
   runBenchmark: () => runBenchmark,
   runBuild: () => runBuild,
@@ -602192,7 +602645,9 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
         plainAscii,
         renderer: "image-to-ascii",
         width,
-        height
+        height,
+        imageWidth: dimensions?.width,
+        imageHeight: dimensions?.height
       };
     }
     return {
@@ -602200,11 +602655,24 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
       ascii: previewFailure(result.error || "renderer unavailable", width),
       renderer: "image-to-ascii",
       width,
-      height
+      height,
+      imageWidth: dimensions?.width,
+      imageHeight: dimensions?.height
     };
   }
   const fallback = await convertWithFfmpeg(imagePath, width, height, timeoutMs);
-  if (fallback) return { path: imagePath, ascii: fallback, plainAscii: fallback, renderer: "ffmpeg", width, height };
+  if (fallback) {
+    return {
+      path: imagePath,
+      ascii: fallback,
+      plainAscii: fallback,
+      renderer: "ffmpeg",
+      width,
+      height,
+      imageWidth: dimensions?.width,
+      imageHeight: dimensions?.height
+    };
+  }
   return null;
 }
 function formatImageAsciiContext(preview, label) {
@@ -602323,10 +602791,45 @@ function parseJsonObjectFromText(value2) {
   const direct = parseJsonObject3(value2);
   if (direct) return direct;
   const text2 = String(value2 ?? "");
-  const start2 = text2.indexOf("{");
-  const end = text2.lastIndexOf("}");
-  if (start2 < 0 || end <= start2) return null;
-  return parseJsonObject3(text2.slice(start2, end + 1));
+  const candidates = [];
+  let depth = 0;
+  let start2 = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    const ch = text2[i2];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) start2 = i2;
+      depth++;
+      continue;
+    }
+    if (ch === "}" && depth > 0) {
+      depth--;
+      if (depth === 0 && start2 >= 0) {
+        candidates.push(text2.slice(start2, i2 + 1));
+        start2 = -1;
+      }
+    }
+  }
+  for (const candidate of candidates.reverse()) {
+    const parsed = parseJsonObject3(candidate);
+    if (parsed) return parsed;
+  }
+  return null;
 }
 function normalizeLiveCameraRotation(value2) {
   if (value2 === void 0 || value2 === null || value2 === "") return 0;
@@ -602418,21 +602921,59 @@ function truncateCell(value2, width) {
 function stripDashboardAnsi(value2) {
   return value2.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
 }
+function dashboardVisibleWidth(value2) {
+  return stripDashboardAnsi(value2).length;
+}
+function truncateAnsiCell(value2, width) {
+  value2 = String(value2 ?? "").replace(/\r?\n/g, " ");
+  if (width <= 0) return "";
+  let out = "";
+  let visible = 0;
+  let i2 = 0;
+  let sawAnsi = false;
+  while (i2 < value2.length && visible < width) {
+    DASHBOARD_ANSI_STICKY_PATTERN.lastIndex = i2;
+    const ansi5 = DASHBOARD_ANSI_STICKY_PATTERN.exec(value2);
+    if (ansi5) {
+      sawAnsi = true;
+      out += ansi5[0];
+      i2 = DASHBOARD_ANSI_STICKY_PATTERN.lastIndex;
+      continue;
+    }
+    const codePoint = value2.codePointAt(i2);
+    if (codePoint == null) break;
+    const ch = String.fromCodePoint(codePoint);
+    out += ch;
+    i2 += ch.length;
+    visible++;
+  }
+  const currentWidth = dashboardVisibleWidth(out);
+  if (currentWidth < width) out += " ".repeat(width - currentWidth);
+  return sawAnsi ? `${out}\x1B[0m` : out;
+}
 function dashboardPreviewLines(camera) {
-  const raw = camera.plainAscii && !isLowInformationAsciiPreview(camera.plainAscii) ? camera.plainAscii : "";
-  return raw.replace(/\r/g, "").split("\n").map((line) => stripDashboardAnsi(line).replace(/\s+$/g, "")).filter((line) => line.trim().length > 0);
+  const raw = camera.ascii || camera.plainAscii || "";
+  return raw.replace(/\r/g, "").split("\n").map((line) => line.replace(/\s+$/g, "")).filter((line) => stripDashboardAnsi(line).trim().length > 0);
 }
 function dashboardPreviewAspect(lines) {
   const widths = lines.map((line) => stripDashboardAnsi(line).length).filter((n2) => n2 > 0);
   const maxWidth = Math.max(1, ...widths);
   return Math.max(0.12, Math.min(1.6, lines.length / maxWidth));
 }
+function cameraDashboardAspect(camera, lines) {
+  const frameWidth = Number(camera.frameWidth ?? 0);
+  const frameHeight = Number(camera.frameHeight ?? 0);
+  if (frameWidth > 0 && frameHeight > 0) {
+    return Math.max(0.12, Math.min(1.4, frameHeight / frameWidth * 0.52));
+  }
+  return dashboardPreviewAspect(lines);
+}
 function fitDashboardPane(lines, paneWidth, paneHeight, fallback) {
   const source = lines.length > 0 ? lines : [fallback];
   const normalized = [];
   for (let i2 = 0; i2 < paneHeight; i2++) {
     const sourceIndex = source.length <= paneHeight ? i2 : Math.min(source.length - 1, Math.floor(i2 * source.length / paneHeight));
-    normalized.push(truncateCell(source[sourceIndex] ?? "", paneWidth));
+    normalized.push(truncateAnsiCell(source[sourceIndex] ?? "", paneWidth));
   }
   while (normalized.length < paneHeight) normalized.push(" ".repeat(paneWidth));
   return normalized;
@@ -602451,7 +602992,7 @@ function liveDashboardPreviewWidthForSources(sourceCount, termWidth = process.st
 function formatCameraPane(camera, paneWidth, paneHeight, now2) {
   const contentWidth = Math.max(10, paneWidth - 2);
   const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
-  const title = `${compactSourceId(camera.source)} ${age}s`;
+  const title = `${compactSourceId(camera.source)} ${age}s${cameraPaneBadge(camera)}`;
   const topTitle = ` ${title} `;
   const left = Math.max(0, Math.floor((contentWidth - topTitle.length) / 2));
   const right = Math.max(0, contentWidth - topTitle.length - left);
@@ -602460,7 +603001,7 @@ function formatCameraPane(camera, paneWidth, paneHeight, now2) {
   const previewLines = dashboardPreviewLines(camera);
   const fallback = camera.framePath ? "preview refreshing" : camera.error ? "capture failed" : "awaiting frame";
   const body = fitDashboardPane(previewLines, contentWidth, paneHeight, fallback);
-  return [top, ...body.map((line) => `│${truncateCell(line, contentWidth)}│`), bottom];
+  return [top, ...body.map((line) => `│${truncateAnsiCell(line, contentWidth)}│`), bottom];
 }
 function pushDashboardWrapped(lines, value2, width) {
   const contentWidth = Math.max(10, width - 2);
@@ -602654,9 +603195,152 @@ function summarizeInference(value2) {
   const sampled = lines.find((line) => /^objects:/i.test(line));
   return sampled ? trimOneLine(sampled, 160) : trimOneLine(lines.slice(0, 4).join("; "), 160);
 }
+function boundedConfidence(value2) {
+  const n2 = Number(value2);
+  return Number.isFinite(n2) ? Math.max(0, Math.min(1, n2)) : void 0;
+}
+function mergeClassificationInto(map2, item) {
+  const label = trimOneLine(item.label || item.kind, 80) || item.kind;
+  const key = `${item.kind}:${label}:${item.trackId ?? ""}:${item.evidencePath ?? ""}`;
+  const existing = map2.get(key);
+  const count = Math.max(1, Number(item.count ?? 1));
+  if (!existing) {
+    map2.set(key, { ...item, label, count });
+    return;
+  }
+  const total = existing.count + count;
+  const confidence2 = existing.confidence !== void 0 || item.confidence !== void 0 ? ((existing.confidence ?? 0) * existing.count + (item.confidence ?? 0) * count) / total : void 0;
+  map2.set(key, {
+    ...existing,
+    count: total,
+    confidence: confidence2,
+    updatedAt: Math.max(existing.updatedAt, item.updatedAt)
+  });
+}
+function classificationsFromLiveMediaPayload(payload, sampledAt, fallbackSource) {
+  if (!payload) return [];
+  const map2 = /* @__PURE__ */ new Map();
+  void fallbackSource;
+  for (const object of payload.objects ?? []) {
+    const label = trimOneLine(object.label || "object", 80) || "object";
+    mergeClassificationInto(map2, {
+      kind: "object",
+      label,
+      count: 1,
+      confidence: boundedConfidence(object.confidence),
+      trackId: object.track_id === void 0 || object.track_id === null ? void 0 : String(object.track_id),
+      updatedAt: observedAtFromOffset(sampledAt, payload, Number(object.timestamp_sec ?? 0))
+    });
+  }
+  for (const track of payload.tracks ?? []) {
+    const label = trimOneLine(track.label || "object", 80) || "object";
+    mergeClassificationInto(map2, {
+      kind: "track",
+      label,
+      count: 1,
+      confidence: boundedConfidence(track.mean_confidence),
+      trackId: track.track_id === void 0 || track.track_id === null ? void 0 : String(track.track_id),
+      updatedAt: observedAtFromOffset(sampledAt, payload, Number(track.last_seen_sec ?? track.first_seen_sec ?? 0))
+    });
+  }
+  for (const face of payload.faces ?? []) {
+    const identity3 = parseFaceIdentity(face);
+    const label = identity3.status === "known" && identity3.name ? identity3.name : "unknown face";
+    mergeClassificationInto(map2, {
+      kind: identity3.status === "known" ? "identity" : "face",
+      label,
+      count: 1,
+      confidence: boundedConfidence(identity3.confidence ?? face.confidence),
+      evidencePath: typeof face.crop_path === "string" ? face.crop_path : void 0,
+      updatedAt: observedAtFromOffset(sampledAt, payload, Number(face.timestamp_sec ?? 0))
+    });
+  }
+  for (const segment of payload.segments ?? []) {
+    const label = trimOneLine(segment.label || "segment", 80) || "segment";
+    mergeClassificationInto(map2, {
+      kind: "segment",
+      label,
+      count: 1,
+      confidence: boundedConfidence(segment.confidence),
+      evidencePath: typeof segment.crop_path === "string" && segment.crop_path ? segment.crop_path : typeof segment.mask_path === "string" ? segment.mask_path : void 0,
+      updatedAt: observedAtFromOffset(sampledAt, payload, Number(segment.timestamp_sec ?? 0))
+    });
+  }
+  for (const hit of payload.trigger_hits ?? []) {
+    const label = trimOneLine(hit.triggerName || hit.matched || "visual trigger", 80) || "visual trigger";
+    mergeClassificationInto(map2, {
+      kind: "trigger",
+      label,
+      count: 1,
+      confidence: boundedConfidence(hit.confidence),
+      updatedAt: sampledAt
+    });
+  }
+  return [...map2.values()].sort((a2, b) => {
+    const aPriority = a2.kind === "face" || a2.kind === "identity" ? 0 : a2.kind === "segment" ? 1 : a2.kind === "object" ? 2 : 3;
+    const bPriority = b.kind === "face" || b.kind === "identity" ? 0 : b.kind === "segment" ? 1 : b.kind === "object" ? 2 : 3;
+    if (aPriority !== bPriority) return aPriority - bPriority;
+    return (b.confidence ?? 0) - (a2.confidence ?? 0);
+  }).slice(0, 24).map((item) => ({ ...item }));
+}
+function classificationsFromClipSummary(summary, observedAt, evidencePath) {
+  const parsed = parseJsonObjectFromText(summary);
+  const matches = Array.isArray(parsed?.["matches"]) ? parsed["matches"] : [];
+  return matches.slice(0, 8).map((match) => {
+    const label = trimOneLine(
+      match["label"] ?? match["name"] ?? match["title"] ?? match["id"] ?? "visual-memory match",
+      80
+    ) || "visual-memory match";
+    return {
+      kind: "clip",
+      label,
+      count: 1,
+      confidence: boundedConfidence(match["score"] ?? match["similarity"] ?? match["confidence"]),
+      evidencePath,
+      updatedAt: observedAt
+    };
+  });
+}
+function mergeCameraClassifications(existing, incoming, limit = 24) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const item of [...existing ?? [], ...incoming]) {
+    mergeClassificationInto(map2, item);
+  }
+  const merged = [...map2.values()].sort((a2, b) => b.updatedAt - a2.updatedAt || (b.confidence ?? 0) - (a2.confidence ?? 0)).slice(0, limit);
+  return merged.length > 0 ? merged : existing;
+}
+function cameraClassificationsSummary(camera, maxChars = 220) {
+  const items = (camera.classifications ?? []).sort((a2, b) => {
+    const aPriority = a2.kind === "face" || a2.kind === "identity" ? 0 : a2.kind === "segment" ? 1 : a2.kind === "object" ? 2 : a2.kind === "track" ? 3 : 4;
+    const bPriority = b.kind === "face" || b.kind === "identity" ? 0 : b.kind === "segment" ? 1 : b.kind === "object" ? 2 : b.kind === "track" ? 3 : 4;
+    if (aPriority !== bPriority) return aPriority - bPriority;
+    return (b.confidence ?? 0) - (a2.confidence ?? 0);
+  }).slice(0, 8).map((item) => {
+    const count = item.count > 1 ? ` x${item.count}` : "";
+    const confidence2 = item.confidence !== void 0 ? ` ${item.confidence.toFixed(2)}` : "";
+    return `${item.kind}:${item.label}${count}${confidence2}`;
+  });
+  return trimOneLine(items.join("; "), maxChars);
+}
+function cameraPaneBadge(camera) {
+  const classifications = camera.classifications ?? [];
+  const faceCount = classifications.filter((item) => item.kind === "face" || item.kind === "identity").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const objectCount = classifications.filter((item) => item.kind === "object").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const segmentCount = classifications.filter((item) => item.kind === "segment").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const trackCount = classifications.filter((item) => item.kind === "track").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const triggerCount = classifications.filter((item) => item.kind === "trigger").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const parts = [
+    faceCount > 0 ? `F${faceCount}` : "",
+    segmentCount > 0 ? `S${segmentCount}` : "",
+    objectCount > 0 ? `O${objectCount}` : "",
+    trackCount > 0 ? `T${trackCount}` : "",
+    triggerCount > 0 ? `!${triggerCount}` : ""
+  ].filter(Boolean);
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
 function cameraSnapshotSummary(camera) {
   if (camera.error) return `error: ${trimOneLine(camera.error, 160)}`;
-  return camera.summary || summarizeInference(camera.inference);
+  return camera.summary || (camera.classifications?.length ? `classifications: ${cameraClassificationsSummary(camera)}` : "") || summarizeInference(camera.inference);
 }
 function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
   const width = Math.max(60, opts.width ?? 100);
@@ -602681,13 +603365,14 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
     for (let start2 = 0; start2 < cameras.length; start2 += paneCount) {
       const group = cameras.slice(start2, start2 + paneCount);
       const sourceLines = group.map((camera) => dashboardPreviewLines(camera));
-      const aspect = Math.max(0.22, Math.min(0.7, Math.max(...sourceLines.map(dashboardPreviewAspect))));
+      const aspects = group.map((camera, idx) => cameraDashboardAspect(camera, sourceLines[idx] ?? []));
+      const aspect = Math.max(0.18, Math.min(0.92, Math.max(...aspects)));
       const paneHeight = Math.max(10, Math.min(32, Math.round(paneContentWidth * aspect)));
       const panes = group.map((camera) => formatCameraPane(camera, paneWidth, paneHeight, now2));
       const rowCount = Math.max(...panes.map((pane) => pane.length));
       for (let row = 0; row < rowCount; row++) {
         const body = panes.map((pane) => pane[row] ?? " ".repeat(paneWidth)).join(" ");
-        lines.push(`│${truncateCell(body, innerWidth)}│`);
+        lines.push(`│${truncateAnsiCell(body, innerWidth)}│`);
       }
     }
   }
@@ -602698,8 +603383,10 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
   for (const camera of cameras) {
     const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
     const rotation = camera.orientation ? formatCameraRotation(camera.orientation.rotation) : "upright/no correction";
+    const classifications = cameraClassificationsSummary(camera);
     const detailLines = [
       `${compactSourceId(camera.source)} age=${age}s rotation=${rotation}`,
+      classifications ? `classifications: ${classifications}` : "",
       cameraSnapshotSummary(camera),
       camera.framePath ? `frame: ${camera.displayPath || camera.framePath}` : "",
       camera.orientation?.evidence ? `orientation: ${trimOneLine(camera.orientation.evidence, 120)}` : ""
@@ -602729,7 +603416,7 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
 function parseLiveMediaPayload(value2) {
   const parsed = parseJsonObject3(value2);
   if (!parsed) return null;
-  if (!Array.isArray(parsed["objects"]) && !Array.isArray(parsed["tracks"]) && !Array.isArray(parsed["faces"])) return null;
+  if (!Array.isArray(parsed["objects"]) && !Array.isArray(parsed["tracks"]) && !Array.isArray(parsed["faces"]) && !Array.isArray(parsed["segments"])) return null;
   return parsed;
 }
 function observedAtFromOffset(sampledAt, payload, offsetSec) {
@@ -602826,6 +603513,21 @@ function observationsFromLiveMediaPayload(payload, sampledAt, fallbackSource) {
       evidence: identity3.evidence
     });
   }
+  for (const segment of (payload.segments ?? []).slice(0, 24)) {
+    const label = String(segment.label || "segment");
+    const observedAt = observedAtFromOffset(sampledAt, payload, Number(segment.timestamp_sec ?? 0));
+    const evidencePath = typeof segment.crop_path === "string" && segment.crop_path ? segment.crop_path : typeof segment.mask_path === "string" ? segment.mask_path : void 0;
+    events.push({
+      id: stableEventId("camera_segment", source, observedAt, `${label}:${segment.frame_index ?? ""}:${evidencePath ?? ""}`),
+      kind: "camera_segment",
+      observedAt,
+      source,
+      title: `Segmented ${label}`,
+      summary: `frame=${segment.frame_index ?? "?"} t=${Number(segment.timestamp_sec ?? 0).toFixed(1)}s conf=${Number(segment.confidence ?? 0).toFixed(2)} area=${Number(segment.area_ratio ?? 0).toFixed(4)} mask=${segment.mask_path ?? "none"} crop=${segment.crop_path ?? "none"} bbox=${JSON.stringify(segment.bbox_xyxy ?? [])}`,
+      confidence: typeof segment.confidence === "number" ? segment.confidence : void 0,
+      evidencePath
+    });
+  }
   const faceCount = people.length;
   if (faceCount === 0) {
     const personTracks = (payload.tracks ?? []).filter((track) => String(track.label || "").toLowerCase() === "person").slice(0, 8);
@@ -602951,8 +603653,8 @@ function loadLiveSensorConfig(repoRoot) {
       ...DEFAULT_CONFIG7,
       ...parsed,
       cameraOrientation: sanitizeCameraOrientation(parsed.cameraOrientation),
-      videoIntervalMs: Math.max(1500, Number(parsed.videoIntervalMs ?? DEFAULT_CONFIG7.videoIntervalMs)),
-      audioIntervalMs: Math.max(3e3, Number(parsed.audioIntervalMs ?? DEFAULT_CONFIG7.audioIntervalMs))
+      videoIntervalMs: Math.max(MIN_VIDEO_INTERVAL_MS, Number(parsed.videoIntervalMs ?? DEFAULT_CONFIG7.videoIntervalMs)),
+      audioIntervalMs: Math.max(MIN_AUDIO_INTERVAL_MS, Number(parsed.audioIntervalMs ?? DEFAULT_CONFIG7.audioIntervalMs))
     };
   } catch {
     return { ...DEFAULT_CONFIG7 };
@@ -602996,6 +603698,8 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
       const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
       const rotation = camera.orientation ? formatCameraRotation(camera.orientation.rotation) : "upright/no correction";
       lines.push(`- ${camera.source} age=${age}s rotation=${rotation}${camera.framePath ? ` frame=${camera.framePath}` : ""}${camera.error ? ` error=${trimOneLine(camera.error, 240)}` : ""}`);
+      const classifications = cameraClassificationsSummary(camera);
+      if (classifications) lines.push(`  classifications: ${classifications}`);
       const summary = cameraSnapshotSummary(camera);
       if (summary) lines.push(`  summary: ${summary}`);
     }
@@ -603050,6 +603754,8 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
     lines.push(`timestamp: ${nowIso3(snapshot.video.updatedAt)} age=${Math.max(0, Math.round(age / 1e3))}s source=${snapshot.video.source}${snapshot.video.orientation ? ` rotation=${formatCameraRotation(snapshot.video.orientation.rotation)}` : ""}${age > maxAgeMs ? " STALE" : ""}`);
     if (snapshot.video.error) lines.push(`error: ${snapshot.video.error}`);
     if (snapshot.video.framePath) lines.push(`frame: ${snapshot.video.framePath}`);
+    const classifications = cameraClassificationsSummary(snapshot.video);
+    if (classifications) lines.push(`Live classifications: ${classifications}`);
     if (snapshot.video.asciiContext) lines.push(snapshot.video.asciiContext);
     if (snapshot.video.inference) {
       lines.push("Video inference:");
@@ -603066,6 +603772,8 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
       lines.push(`timestamp: ${nowIso3(camera.updatedAt)} age=${Math.max(0, Math.round(age / 1e3))}s rotation=${rotation}${age > maxAgeMs ? " STALE" : ""}`);
       if (camera.error) lines.push(`error: ${camera.error}`);
       if (camera.framePath) lines.push(`frame: ${camera.framePath}`);
+      const classifications = cameraClassificationsSummary(camera);
+      if (classifications) lines.push(`classifications: ${classifications}`);
       lines.push(`summary: ${cameraSnapshotSummary(camera)}`);
     }
   }
@@ -603316,13 +604024,17 @@ function formatLiveStatus(snapshot) {
   }
   return lines.join("\n");
 }
-var DEFAULT_CONFIG7, managers, LiveSensorManager;
+var MIN_VIDEO_INTERVAL_MS, LOW_LATENCY_VIDEO_INTERVAL_MS, MIN_AUDIO_INTERVAL_MS, LOW_LATENCY_AUDIO_INTERVAL_MS, DEFAULT_CONFIG7, managers, DASHBOARD_ANSI_STICKY_PATTERN, LiveSensorManager;
 var init_live_sensors = __esm({
   "packages/cli/src/tui/live-sensors.ts"() {
     "use strict";
     init_dist5();
     init_async_process();
     init_image_ascii_preview();
+    MIN_VIDEO_INTERVAL_MS = 250;
+    LOW_LATENCY_VIDEO_INTERVAL_MS = 250;
+    MIN_AUDIO_INTERVAL_MS = 1500;
+    LOW_LATENCY_AUDIO_INTERVAL_MS = 2e3;
     DEFAULT_CONFIG7 = {
       videoEnabled: false,
       audioEnabled: false,
@@ -603332,10 +604044,11 @@ var init_live_sensors = __esm({
       asrEnabled: false,
       audioAnalysisEnabled: false,
       cameraOrientation: {},
-      videoIntervalMs: 5e3,
-      audioIntervalMs: 9e3
+      videoIntervalMs: 1e3,
+      audioIntervalMs: 6e3
     };
     managers = /* @__PURE__ */ new Map();
+    DASHBOARD_ANSI_STICKY_PATTERN = /\x1B\[[0-?]*[ -/]*[@-~]/y;
     LiveSensorManager = class {
       constructor(repoRoot) {
         this.repoRoot = repoRoot;
@@ -603541,10 +604254,11 @@ var init_live_sensors = __esm({
         this.config = {
           ...this.config,
           ...patch,
-          videoIntervalMs: Math.max(1500, Number(patch.videoIntervalMs ?? this.config.videoIntervalMs)),
-          audioIntervalMs: Math.max(3e3, Number(patch.audioIntervalMs ?? this.config.audioIntervalMs))
+          videoIntervalMs: Math.max(MIN_VIDEO_INTERVAL_MS, Number(patch.videoIntervalMs ?? this.config.videoIntervalMs)),
+          audioIntervalMs: Math.max(MIN_AUDIO_INTERVAL_MS, Number(patch.audioIntervalMs ?? this.config.audioIntervalMs))
         };
         this.persist();
+        this.clearLoopTimers();
         this.ensureLoops();
         this.emitStatus();
         return this.getConfig();
@@ -603570,8 +604284,8 @@ var init_live_sensors = __esm({
           audioEnabled: true,
           asrEnabled: true,
           audioAnalysisEnabled: true,
-          videoIntervalMs: options2.lowLatency === false ? this.config.videoIntervalMs : Math.min(this.config.videoIntervalMs, 1500),
-          audioIntervalMs: options2.lowLatency === false ? this.config.audioIntervalMs : Math.min(this.config.audioIntervalMs, 3e3)
+          videoIntervalMs: options2.lowLatency === false ? this.config.videoIntervalMs : Math.min(this.config.videoIntervalMs, LOW_LATENCY_VIDEO_INTERVAL_MS),
+          audioIntervalMs: options2.lowLatency === false ? this.config.audioIntervalMs : Math.min(this.config.audioIntervalMs, LOW_LATENCY_AUDIO_INTERVAL_MS)
         });
         for (const source of this.activeVideoSources()) {
           const current = this.getCameraOrientation(source);
@@ -603684,6 +604398,10 @@ var init_live_sensors = __esm({
           ascii: preview?.ascii,
           plainAscii: preview?.plainAscii,
           renderer: preview?.renderer,
+          previewWidth: preview?.width,
+          previewHeight: preview?.height,
+          frameWidth: preview?.imageWidth,
+          frameHeight: preview?.imageHeight,
           asciiContext,
           rotation,
           orientation
@@ -603694,7 +604412,8 @@ var init_live_sensors = __esm({
           [source]: {
             ...cameraView,
             summary: this.snapshot.cameras?.[source]?.summary,
-            inference: this.snapshot.cameras?.[source]?.inference
+            inference: this.snapshot.cameras?.[source]?.inference,
+            classifications: this.snapshot.cameras?.[source]?.classifications
           }
         };
         this.snapshot.events = mergeRecentById(this.snapshot.events, [{
@@ -603727,7 +604446,11 @@ var init_live_sensors = __esm({
           displayPath,
           ascii: preview?.ascii,
           plainAscii: preview?.plainAscii,
-          renderer: preview?.renderer
+          renderer: preview?.renderer,
+          frameWidth: preview?.imageWidth,
+          frameHeight: preview?.imageHeight,
+          previewWidth: preview?.width,
+          previewHeight: preview?.height
         };
       }
       async recognizeFrameObjects(framePath, source, observedAt = Date.now(), options2 = {}) {
@@ -603784,20 +604507,27 @@ var init_live_sensors = __esm({
             action: "watch",
             source_kind: "camera",
             camera: source,
-            duration_sec: 2.5,
-            sample_interval_sec: 1,
-            max_frames: 2,
+            yolo_family: "yoloe-26",
+            yolo_scale: "n",
+            yoloe_prompt_mode: "prompt_free",
+            duration_sec: 0.75,
+            sample_interval_sec: 0.25,
+            max_frames: 1,
             rotate_degrees: orientation?.rotation ?? 0,
             auto_bootstrap: true,
             audio_mode: "none",
             detect_objects: true,
             track_objects: true,
+            segment_objects: true,
+            extract_segments: true,
+            max_segments_per_frame: 8,
             crop_faces: true,
             recognize_faces: true
           });
           inference = result.success ? String(result.output || result.llmContent || "") : `Video inference failed: ${result.error || result.output || "unknown error"}`;
           const livePayload = result.success ? parseLiveMediaPayload(result.llmContent || result.output) : null;
           const observations = observationsFromLiveMediaPayload(livePayload, sampledAt, source);
+          const classifications = classificationsFromLiveMediaPayload(livePayload, sampledAt, source);
           this.snapshot.events = mergeRecentById(this.snapshot.events, observations.events, 50);
           this.snapshot.people = mergeRecentById(this.snapshot.people, observations.people, 24);
           const existing = this.snapshot.cameras?.[source] ?? this.snapshot.video ?? { updatedAt: Date.now(), source };
@@ -603807,6 +604537,7 @@ var init_live_sensors = __esm({
             source,
             inference,
             summary: summarizeInference(inference),
+            classifications: mergeCameraClassifications(existing.classifications, classifications),
             rotation: orientation?.rotation ?? 0,
             orientation,
             ...preview.ok ? { error: void 0 } : { error: preview.message }
@@ -603845,6 +604576,10 @@ var init_live_sensors = __esm({
           const current = this.snapshot.cameras?.[source];
           if (current) {
             current.summary = [current.summary, clipSummary ? `clip: ${trimOneLine(clipSummary, 160)}` : ""].filter(Boolean).join(" | ");
+            current.classifications = mergeCameraClassifications(
+              current.classifications,
+              classificationsFromClipSummary(clipSummary, sampledAt, preview.framePath)
+            );
             this.snapshot.cameras = { ...this.snapshot.cameras ?? {}, [source]: current };
             if (this.snapshot.video?.source === source) this.snapshot.video = current;
             this.persist();
@@ -604002,30 +604737,63 @@ ${analysis}` : ""
           this.audioInFlight = false;
         }
       }
+      clearLoopTimers() {
+        if (this.videoTimer) {
+          clearTimeout(this.videoTimer);
+          this.videoTimer = null;
+        }
+        if (this.audioTimer) {
+          clearTimeout(this.audioTimer);
+          this.audioTimer = null;
+        }
+      }
+      scheduleVideoLoop(delayMs) {
+        if (!this.config.videoEnabled || this.videoTimer) return;
+        this.videoTimer = setTimeout(async () => {
+          this.videoTimer = null;
+          if (!this.config.videoEnabled) return;
+          try {
+            await this.sampleVideoNow(this.config.inferEnabled || this.config.clipEnabled);
+          } catch {
+          } finally {
+            if (this.config.videoEnabled) {
+              this.scheduleVideoLoop(this.config.videoIntervalMs);
+            }
+          }
+        }, Math.max(0, delayMs));
+        this.videoTimer.unref?.();
+      }
+      scheduleAudioLoop(delayMs) {
+        const wantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+        if (!wantsAudio || this.audioTimer) return;
+        this.audioTimer = setTimeout(async () => {
+          this.audioTimer = null;
+          const stillWantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+          if (!stillWantsAudio) return;
+          try {
+            await this.sampleAudioNow();
+          } catch {
+          } finally {
+            const wantsNext = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+            if (wantsNext) {
+              this.scheduleAudioLoop(this.config.audioIntervalMs);
+            }
+          }
+        }, Math.max(0, delayMs));
+        this.audioTimer.unref?.();
+      }
       ensureLoops() {
         if (this.config.videoEnabled && !this.videoTimer) {
-          void this.sampleVideoNow(this.config.inferEnabled || this.config.clipEnabled).catch(() => {
-          });
-          this.videoTimer = setInterval(() => {
-            void this.sampleVideoNow(this.config.inferEnabled || this.config.clipEnabled).catch(() => {
-            });
-          }, this.config.videoIntervalMs);
-          this.videoTimer.unref?.();
+          this.scheduleVideoLoop(0);
         } else if (!this.config.videoEnabled && this.videoTimer) {
-          clearInterval(this.videoTimer);
+          clearTimeout(this.videoTimer);
           this.videoTimer = null;
         }
         const wantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
         if (wantsAudio && !this.audioTimer) {
-          void this.sampleAudioNow().catch(() => {
-          });
-          this.audioTimer = setInterval(() => {
-            void this.sampleAudioNow().catch(() => {
-            });
-          }, this.config.audioIntervalMs);
-          this.audioTimer.unref?.();
+          this.scheduleAudioLoop(0);
         } else if (!wantsAudio && this.audioTimer) {
-          clearInterval(this.audioTimer);
+          clearTimeout(this.audioTimer);
           this.audioTimer = null;
         }
       }