omnius 1.0.410 → 1.0.412

package/dist/index.js

@@ -41456,17 +41456,30 @@ function isTranscribable(path12) {
   const ext = extname4(path12).toLowerCase();
   return AUDIO_EXTS.has(ext) || VIDEO_EXTS.has(ext);
 }
+async function requireTranscribeCliFrom(packageDir) {
+  const { createRequire: createRequire11 } = await import("node:module");
+  const req3 = createRequire11(import.meta.url);
+  const distPath = join40(packageDir, "dist", "index.js");
+  if (existsSync38(distPath))
+    return req3(distPath);
+  return req3(packageDir);
+}
 async function loadTranscribeCli() {
   if (_tcChecked)
     return _tcModule;
   _tcChecked = true;
+  try {
+    const { createRequire: createRequire11 } = await import("node:module");
+    const req3 = createRequire11(import.meta.url);
+    _tcModule = req3("transcribe-cli");
+    return _tcModule;
+  } catch {
+  }
   try {
     const globalRoot = (await execFileText("npm", ["root", "-g"], { timeout: 5e3 })).trim();
     const tcPath = join40(globalRoot, "transcribe-cli");
     if (existsSync38(join40(tcPath, "dist", "index.js"))) {
-      const { createRequire: createRequire11 } = await import("node:module");
-      const req3 = createRequire11(import.meta.url);
-      _tcModule = req3(join40(tcPath, "dist", "index.js"));
+      _tcModule = await requireTranscribeCliFrom(tcPath);
       return _tcModule;
     }
   } catch {
@@ -41478,9 +41491,7 @@ async function loadTranscribeCli() {
       for (const ver of readdirSync61(nvmBase)) {
         const tcPath = join40(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
         if (existsSync38(join40(tcPath, "dist", "index.js"))) {
-          const { createRequire: createRequire11 } = await import("node:module");
-          const req3 = createRequire11(import.meta.url);
-          _tcModule = req3(join40(tcPath, "dist", "index.js"));
+          _tcModule = await requireTranscribeCliFrom(tcPath);
           return _tcModule;
         }
       }
@@ -41489,6 +41500,58 @@ async function loadTranscribeCli() {
   }
   return null;
 }
+async function ensureManagedTranscribeCliRuntime() {
+  const packageDir = join40(MANAGED_TRANSCRIBE_CLI_DIR, "node_modules", "transcribe-cli");
+  if (existsSync38(join40(packageDir, "dist", "index.js"))) {
+    try {
+      _managedTranscribeCliReady = true;
+      _tcModule = await requireTranscribeCliFrom(packageDir);
+      _tcChecked = true;
+      return _tcModule;
+    } catch {
+    }
+  }
+  if (_managedTranscribeCliChecked && !_managedTranscribeCliReady)
+    return null;
+  _managedTranscribeCliChecked = true;
+  try {
+    mkdirSync22(MANAGED_TRANSCRIBE_CLI_DIR, { recursive: true });
+    if (!existsSync38(join40(MANAGED_TRANSCRIBE_CLI_DIR, "package.json"))) {
+      writeFileSync21(join40(MANAGED_TRANSCRIBE_CLI_DIR, "package.json"), JSON.stringify({ private: true, dependencies: {} }, null, 2), "utf8");
+    }
+    await execFileText("npm", ["install", "--prefix", MANAGED_TRANSCRIBE_CLI_DIR, "transcribe-cli@^2.0.1"], {
+      timeout: 18e4,
+      env: transcriptionPythonEnv()
+    });
+    _managedTranscribeCliReady = true;
+    _tcModule = await requireTranscribeCliFrom(packageDir);
+    _tcChecked = true;
+    return _tcModule;
+  } catch {
+    _managedTranscribeCliReady = false;
+    return null;
+  }
+}
+async function ensureTranscribeCliPythonModule(python) {
+  if (_transcribeCliPythonModuleChecked)
+    return;
+  _transcribeCliPythonModuleChecked = true;
+  try {
+    await execFileText(python, ["-c", "import transcribe_cli"], {
+      timeout: 1e4,
+      env: transcriptionPythonEnv()
+    });
+    return;
+  } catch {
+  }
+  try {
+    await execFileText(python, ["-m", "pip", "install", "-U", "transcribe-cli"], {
+      timeout: 3e5,
+      env: transcriptionPythonEnv()
+    });
+  } catch {
+  }
+}
 function isYouTubeUrl(url) {
   return /(?:youtube\.com\/(?:watch|shorts|live|embed|v\/)|youtu\.be\/)/i.test(url);
 }
@@ -41519,7 +41582,7 @@ function formatTime(seconds) {
   const s2 = Math.floor(seconds % 60);
   return `${String(m2).padStart(2, "0")}:${String(s2).padStart(2, "0")}`;
 }
-var AUDIO_EXTS, VIDEO_EXTS, MAX_TRANSCRIBE_URL_BYTES, MANAGED_ASR_VENV, _tcModule, _tcChecked, _managedAsrReady, TranscribeFileTool, YT_DLP_VENV, TranscribeUrlTool, YouTubeDownloadTool;
+var AUDIO_EXTS, VIDEO_EXTS, MAX_TRANSCRIBE_URL_BYTES, MANAGED_ASR_VENV, MANAGED_TRANSCRIBE_CLI_DIR, _tcModule, _tcChecked, _managedAsrReady, _managedTranscribeCliChecked, _managedTranscribeCliReady, _transcribeCliPythonModuleChecked, TranscribeFileTool, YT_DLP_VENV, TranscribeUrlTool, YouTubeDownloadTool;
 var init_transcribe_tool = __esm({
   "packages/execution/dist/tools/transcribe-tool.js"() {
     "use strict";
@@ -41551,9 +41614,13 @@ var init_transcribe_tool = __esm({
     ]);
     MAX_TRANSCRIBE_URL_BYTES = 100 * 1024 * 1024;
     MANAGED_ASR_VENV = join40(homedir11(), ".omnius", "runtimes", "asr", ".venv-whisper");
+    MANAGED_TRANSCRIBE_CLI_DIR = join40(homedir11(), ".omnius", "runtimes", "asr", "transcribe-cli-node");
     _tcModule = null;
     _tcChecked = false;
     _managedAsrReady = false;
+    _managedTranscribeCliChecked = false;
+    _managedTranscribeCliReady = false;
+    _transcribeCliPythonModuleChecked = false;
     TranscribeFileTool = class {
       name = "transcribe_file";
       description = "Transcribe a local audio or video file to text using Whisper (faster-whisper). Supports MP3, WAV, FLAC, AAC, M4A, OGG, MP4, MKV, AVI, MOV, WebM. Returns the full transcription text with optional speaker diarization. Transcription is 100% local — no API keys needed.";
@@ -41628,7 +41695,15 @@ var init_transcribe_tool = __esm({
         if (effectiveModel !== askedModel)
           model = effectiveModel;
         const failures = [];
-        const tc = await loadTranscribeCli();
+        let managedPython = "";
+        try {
+          managedPython = await this.ensureManagedWhisperRuntime();
+          process.env.TRANSCRIBE_PYTHON = managedPython;
+          await ensureTranscribeCliPythonModule(managedPython);
+        } catch (err) {
+          failures.push(`managed ASR runtime bootstrap: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const tc = await loadTranscribeCli() ?? await ensureManagedTranscribeCliRuntime();
         if (tc) {
           try {
             const result = await withProcessEnv(transcriptionPythonEnv(), () => tc.transcribe(filePath, {
@@ -41641,6 +41716,8 @@ var init_transcribe_tool = __esm({
           } catch (err) {
             failures.push(`transcribe-cli module: ${err instanceof Error ? err.message : String(err)}`);
           }
+        } else {
+          failures.push("transcribe-cli npm package unavailable after managed auto-install");
         }
         const cli = await this.execViaCli(filePath, model, diarize, start2);
         if (cli.success)
@@ -555654,6 +555731,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 +556037,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 +556111,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 +556122,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 +556168,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 +556211,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 +556251,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 +556338,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 +556352,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 +556378,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 +556407,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 +556457,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 +556505,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 +556536,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 +556626,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 +556730,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 +556758,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 +556788,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 +558076,7 @@ __export(dist_exports2, {
   buildToolManifestFromModule: () => buildToolManifestFromModule,
   buildWorkboardSynthesisContext: () => buildWorkboardSynthesisContext,
   buildYolo26BootstrapPlan: () => buildYolo26BootstrapPlan,
+  buildYolo26DeploymentOptions: () => buildYolo26DeploymentOptions,
   builtInMediaModelCatalog: () => builtInMediaModelCatalog,
   canInvokeTool: () => canInvokeTool,
   checkConstraints: () => checkConstraints,
@@ -557781,6 +558310,7 @@ __export(dist_exports2, {
   resolveMediaCudaVisibleDevicesForEnv: () => resolveMediaCudaVisibleDevicesForEnv,
   resolveMediaModel: () => resolveMediaModel,
   resolveSecret: () => resolveSecret,
+  resolveYolo26Model: () => resolveYolo26Model,
   revokeSecret: () => revokeSecret,
   runBenchmark: () => runBenchmark,
   runBuild: () => runBuild,
@@ -602192,7 +602722,9 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
         plainAscii,
         renderer: "image-to-ascii",
         width,
-        height
+        height,
+        imageWidth: dimensions?.width,
+        imageHeight: dimensions?.height
       };
     }
     return {
@@ -602200,11 +602732,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 +602868,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;
@@ -602361,9 +602941,9 @@ function parseCameraOrientationDecision(value2) {
 }
 function formatCameraRotation(rotation) {
   if (rotation === 0) return "upright/no correction";
-  if (rotation === 90) return "90 degrees clockwise";
-  if (rotation === 180) return "180 degrees";
-  return "90 degrees counter-clockwise";
+  if (rotation === 90) return "90 degrees clockwise correction";
+  if (rotation === 180) return "180 degrees correction";
+  return "90 degrees counter-clockwise correction";
 }
 function sanitizeCameraOrientation(value2) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return {};
@@ -602418,21 +602998,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 +603069,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 +603078,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);
@@ -602586,6 +603204,116 @@ function fallbackLiveAudioIntakeDecision(transcript) {
     reason: addressed ? "fallback detected direct address or question shape" : "fallback could not establish that ambient speech was addressed to Omnius"
   };
 }
+function parseLiveSpeechDecision(value2) {
+  const parsed = parseJsonObjectFromText(value2);
+  if (!parsed) return null;
+  const speak = parsed["speak"];
+  const confidence2 = Math.max(0, Math.min(1, Number(parsed["confidence"] ?? 0)));
+  if (typeof speak !== "boolean" || !Number.isFinite(confidence2)) return null;
+  const actionRaw = String(parsed["action"] ?? (speak ? "speak" : "silent")).toLowerCase();
+  const action = actionRaw === "speak" || actionRaw === "silent" || actionRaw === "queue_review" ? actionRaw : speak ? "speak" : "silent";
+  return {
+    speak,
+    text: trimOneLine(parsed["text"] ?? "", 180),
+    confidence: confidence2,
+    action,
+    reason: trimOneLine(parsed["reason"] ?? "", 220) || "live speech arbiter decision"
+  };
+}
+function fallbackLiveSpeechDecision(proposal) {
+  if (proposal.kind === "unknown_person") {
+    return {
+      speak: true,
+      text: proposal.defaultText,
+      confidence: 0.72,
+      action: "speak",
+      reason: "unknown person visible and identity clarification is useful"
+    };
+  }
+  if (proposal.kind === "audio_intent") {
+    return {
+      speak: true,
+      text: proposal.defaultText,
+      confidence: 0.68,
+      action: "speak",
+      reason: "audio intake classified speech as addressed to Omnius"
+    };
+  }
+  if (proposal.urgency === "high") {
+    return {
+      speak: true,
+      text: proposal.defaultText,
+      confidence: 0.6,
+      action: "speak",
+      reason: "high-urgency live trigger"
+    };
+  }
+  return {
+    speak: false,
+    text: "",
+    confidence: 0.55,
+    action: "silent",
+    reason: "ambient event did not justify interrupting with speech"
+  };
+}
+async function classifyLiveSpeech(proposal, config) {
+  const now2 = Date.now();
+  if (config?.backendUrl && config.model) {
+    const url = `${config.backendUrl.replace(/\/+$/, "")}/v1/chat/completions`;
+    const body = {
+      model: config.model,
+      temperature: 0,
+      max_tokens: 180,
+      think: false,
+      messages: [
+        {
+          role: "system",
+          content: [
+            "You are Omnius' live audio/video speech arbiter.",
+            "Decide whether the agent should speak aloud into the physical environment right now.",
+            "Speak rarely. Do not narrate routine detections or every frame.",
+            "Speak when directly addressed, when an unknown person should be politely identified, or when an important visual/audio trigger needs immediate clarification.",
+            "Never invent a person's identity. If asking identity, ask one short natural question.",
+            "Keep spoken text under 16 words.",
+            'Return only JSON: {"speak": boolean, "text": "short utterance", "confidence": 0.0-1.0, "action": "speak"|"silent"|"queue_review", "reason": "brief evidence"}.'
+          ].join("\n")
+        },
+        {
+          role: "user",
+          content: [
+            `kind=${proposal.kind}`,
+            `source=${proposal.source}`,
+            `urgency=${proposal.urgency}`,
+            `summary=${proposal.summary}`,
+            `evidence=${proposal.evidence}`,
+            `default_utterance=${proposal.defaultText}`
+          ].join("\n").slice(0, 1600)
+        }
+      ]
+    };
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3).unref();
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (resp.ok) {
+        const json = await resp.json();
+        const parsed = parseLiveSpeechDecision(json.choices?.[0]?.message?.content ?? "");
+        if (parsed) return { ...parsed, source: "live-arbiter", updatedAt: now2 };
+      }
+    } catch {
+    }
+  }
+  return { ...fallbackLiveSpeechDecision(proposal), source: "fallback", updatedAt: now2 };
+}
 async function classifyLiveAudioIntake(transcript, config) {
   const now2 = Date.now();
   const clean5 = transcript.trim();
@@ -602654,9 +603382,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 +603552,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 +603570,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 +603603,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 +603700,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 +603840,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 };
@@ -602977,6 +603866,8 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
   lines.push("<live-sensor-context>");
   lines.push("## LIVE SENSOR STATUS");
   lines.push("Live sensor context is operator-enabled ambient input. Treat it as current perceptual evidence for this turn; if it is stale, missing, or insufficient, use camera/audio tools to refresh before answering what you see or hear.");
+  lines.push('Live world-model rule: when the user asks what is around, who is present, what changed, what is heard, or asks a deictic question like "what do you see", treat the live camera/audio fields as first-class context. Be curious and tool-capable: refresh stale sensors, inspect frame paths, query vision/CLIP/visual_memory/audio tools, and combine metadata into a concise answer. Do not rely only on summaries when the task requires current perception.');
+  lines.push("Live speech rule: in low-latency voice/live modes, short spoken replies are appropriate for direct address, identity clarification, or important visual/audio triggers. Do not narrate every frame.");
   lines.push("Identity rule: never invent names for observed people. If a person is unknown and identity matters, ask the user or the person for their name, then store the association with visual_memory(action='enroll', image='<face crop>', name='<name>') when a face crop is available, or multimodal_memory(action='meet', person_name='<name>') when live voice/name context is available.");
   lines.push(`Snapshot file: ${liveSnapshotPath(snapshot.repoRoot)}`);
   lines.push(`Streams: video=${snapshot.config.videoEnabled ? "on" : "off"} infer=${snapshot.config.inferEnabled ? "on" : "off"} clip=${snapshot.config.clipEnabled ? "on" : "off"} audio=${snapshot.config.audioEnabled ? "on" : "off"} asr=${snapshot.config.asrEnabled ? "on" : "off"} sounds=${snapshot.config.audioAnalysisEnabled ? "on" : "off"} output-monitor=${snapshot.config.audioOutputEnabled ? "on" : "off"}`);
@@ -602996,6 +603887,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 +603943,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 +603961,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)}`);
     }
   }
@@ -603117,6 +604014,16 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
 function formatLiveSensorContext(repoRoot) {
   return formatLiveSensorContextFromSnapshot(readLiveSensorSnapshot(repoRoot));
 }
+function isLiveSensorSnapshotActive(snapshot) {
+  const cfg = snapshot?.config;
+  if (!cfg) return false;
+  return Boolean(
+    cfg.videoEnabled || cfg.audioEnabled || cfg.audioOutputEnabled || cfg.inferEnabled || cfg.clipEnabled || cfg.asrEnabled || cfg.audioAnalysisEnabled
+  );
+}
+function isLiveSensorActiveForRepo(repoRoot) {
+  return isLiveSensorSnapshotActive(readLiveSensorSnapshot(repoRoot));
+}
 async function discoverAudioInputs() {
   const devices = [];
   const errors = [];
@@ -603250,31 +604157,101 @@ print(json.dumps({"ok": True, "scores": scores}))
 async function tryRecordAudioDevice(device, durationSec, outputPath3) {
   await recordAudioSample(device, durationSec, outputPath3);
 }
+function hasLiveAudioSignal(activity) {
+  if (!activity) return false;
+  return activity.peak >= 0.025 || activity.rmsDb > -48 || activity.activeRatio >= 0.025;
+}
+function audioCaptureMethod(device) {
+  return device.startsWith("pulse:") ? "pulse/ffmpeg" : "arecord";
+}
 async function recordAudioSampleWithRecovery(preferred, devices, durationSec, outputPath3) {
   const ordered = [];
   const add3 = (id2) => {
     const clean5 = String(id2 ?? "").trim();
     if (clean5 && !ordered.includes(clean5)) ordered.push(clean5);
   };
-  add3(preferred);
-  for (const device of devices.filter((entry) => entry.source === "pulse" || entry.source === "pipewire")) add3(device.id);
+  const preferredInput = preferredLiveAudioInputId(devices, preferred);
+  add3(preferredInput);
+  if (preferred && !isAudioOutputMonitorId(preferred)) add3(preferred);
+  for (const device of rankLiveAudioInputDevices(devices, preferred).filter((entry) => !isAudioOutputMonitorDevice(entry))) add3(device.id);
   add3("pulse:default");
   add3("default");
-  for (const device of devices.filter((entry) => entry.source !== "pulse" && entry.source !== "pipewire")) add3(device.id);
+  for (const device of rankLiveAudioInputDevices(devices, preferred).filter((entry) => isAudioOutputMonitorDevice(entry))) add3(device.id);
   const errors = [];
+  const attempts = [];
+  let firstQuietCapture = null;
   for (const candidate of ordered) {
+    attempts.push(candidate);
     try {
       await tryRecordAudioDevice(candidate, durationSec, outputPath3);
-      return { ok: true, device: candidate, method: candidate.startsWith("pulse:") ? "pulse/ffmpeg" : "arecord", errors };
+      const activity = readPcm16WavActivity(outputPath3);
+      const method = audioCaptureMethod(candidate);
+      if (hasLiveAudioSignal(activity)) {
+        return { ok: true, device: candidate, method, errors, attempts, activity, signalDetected: true };
+      }
+      if (!firstQuietCapture) {
+        firstQuietCapture = {
+          device: candidate,
+          method,
+          activity,
+          bytes: readFileSync88(outputPath3),
+          errors: [...errors]
+        };
+      }
+      errors.push(`${candidate}: captured but no live input signal detected`);
     } catch (err) {
       errors.push(`${candidate}: ${err instanceof Error ? err.message : String(err)}`.slice(0, 360));
     }
   }
-  return { ok: false, device: preferred || "default", method: "none", errors };
+  if (firstQuietCapture) {
+    writeFileSync56(outputPath3, firstQuietCapture.bytes);
+    return {
+      ok: true,
+      device: firstQuietCapture.device,
+      method: firstQuietCapture.method,
+      errors,
+      attempts,
+      activity: firstQuietCapture.activity,
+      signalDetected: false
+    };
+  }
+  return { ok: false, device: preferredInput || preferred || "default", method: "none", errors, attempts };
 }
 function firstDeviceId(devices) {
   return devices.find((device) => device.id && !/metadata\/non-capture/i.test(device.detail ?? ""))?.id ?? devices[0]?.id;
 }
+function isAudioOutputMonitorId(id2) {
+  return /(?:\.monitor\b|sink\.monitor|alsa_output|output\.monitor)/i.test(String(id2 ?? ""));
+}
+function isAudioOutputMonitorDevice(device) {
+  if (!device) return false;
+  return isAudioOutputMonitorId(device.id) || isAudioOutputMonitorId(device.label) || isAudioOutputMonitorId(device.detail);
+}
+function preferredLiveAudioInputId(devices, configured) {
+  const usable = devices.filter((device) => device.id && !isAudioOutputMonitorDevice(device));
+  if (configured && usable.some((device) => device.id === configured)) return configured;
+  return rankLiveAudioInputDevices(devices, configured)[0]?.id ?? firstDeviceId(devices);
+}
+function liveAudioDeviceRank(device, configured) {
+  let rank = 0;
+  if (device.id === configured) rank -= 40;
+  if (isAudioOutputMonitorDevice(device)) rank += 500;
+  if (device.source === "pulse" || device.source === "pipewire") rank -= 20;
+  if (device.source === "alsa") rank -= 10;
+  if (device.source === "default") rank += 30;
+  if (/metadata\/non-capture/i.test(device.detail ?? "")) rank += 300;
+  return rank;
+}
+function rankLiveAudioInputDevices(devices, configured) {
+  const seen = /* @__PURE__ */ new Set();
+  const ranked = [];
+  for (const device of devices) {
+    if (!device.id || seen.has(device.id)) continue;
+    seen.add(device.id);
+    ranked.push(device);
+  }
+  return ranked.sort((a2, b) => liveAudioDeviceRank(a2, configured) - liveAudioDeviceRank(b, configured));
+}
 function getLiveSensorManager(repoRoot) {
   const key = repoRoot;
   let manager = managers.get(key);
@@ -603316,13 +604293,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 +604313,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;
@@ -603363,6 +604345,13 @@ var init_live_sensors = __esm({
       lastAgentReviewAt = 0;
       autoOrientationInFlight = /* @__PURE__ */ new Set();
       lastFeedbackAt = /* @__PURE__ */ new Map();
+      lastClipAt = /* @__PURE__ */ new Map();
+      nextVideoSourceIndex = 0;
+      liveSpeechSink = null;
+      liveSpeechEnabled = false;
+      lastLiveSpeechAt = 0;
+      lastLiveSpeechByKey = /* @__PURE__ */ new Map();
+      liveSpeechInFlight = /* @__PURE__ */ new Set();
       intakeAgentConfig;
       setStatusSink(sink) {
         this.statusSink = sink ?? null;
@@ -603374,6 +604363,12 @@ var init_live_sensors = __esm({
       setAgentActionSink(sink) {
         this.agentActionSink = sink ?? null;
       }
+      setLiveSpeechSink(sink) {
+        this.liveSpeechSink = sink ?? null;
+      }
+      setLiveSpeechEnabled(enabled2) {
+        this.liveSpeechEnabled = enabled2;
+      }
       setAudioIntakeAgentConfig(config) {
         this.intakeAgentConfig = config && config.backendUrl && config.model ? { backendUrl: config.backendUrl, model: config.model, apiKey: config.apiKey } : void 0;
       }
@@ -603469,16 +604464,14 @@ var init_live_sensors = __esm({
           if (!framePath) return `Camera orientation detection captured ${target}, but no frame path was returned.`;
           const cvScores = await scoreCameraOrientationWithOpenCv(framePath);
           const cvDecision = cvScores ? chooseCameraOrientationFromScores(cvScores) : null;
-          if (cvDecision && cvDecision.confidence >= 0.68) {
-            const orientation2 = this.setCameraRotation(target, cvDecision.rotation, "auto", cvDecision.reason, cvDecision.confidence);
-            return orientation2 ? `Auto orientation for ${target}: ${describeCameraOrientation(orientation2)}` : `Auto orientation for ${target} could not be persisted.`;
-          }
           const prompt = [
             "Determine whether this camera frame is upright for a human viewer.",
             "Return only JSON with this schema:",
             '{"rotation_degrees":0|90|180|270,"confidence":0.0-1.0,"reason":"brief visual evidence"}',
             "rotation_degrees is the clockwise correction to apply to future frames so they are upright.",
-            "Use 90 if the image must rotate clockwise; use 270 if it must rotate counter-clockwise; use 180 if upside down; use 0 if already upright or inconclusive."
+            "Use 90 if the image must rotate clockwise; use 270 if it must rotate counter-clockwise; use 180 if upside down; use 0 if already upright or inconclusive.",
+            "If the visible scene is sideways, choose the correction direction that makes people, faces, screens, and text upright; if the opposite direction would make them sideways, do not choose it.",
+            cvDecision ? `Computer-vision candidate: ${formatCameraRotation(cvDecision.rotation)} confidence=${cvDecision.confidence.toFixed(2)} evidence=${cvDecision.reason}` : "Computer-vision candidate: unavailable."
           ].join("\n");
           const vision = await new VisionTool(this.repoRoot).execute({
             action: "query",
@@ -603501,9 +604494,10 @@ var init_live_sensors = __esm({
             }
             return `Camera orientation detection for ${target} was inconclusive. Vision output did not contain a structured rotation decision.`;
           }
-          const useCv = cvDecision && (cvDecision.confidence > (decision2.confidence ?? 0) + 0.12 || cvDecision.rotation !== decision2.rotation && cvDecision.confidence >= 0.62 && (decision2.confidence ?? 0) < 0.76);
-          const selected = useCv ? cvDecision : decision2;
-          const evidence = useCv ? cvDecision.reason : `${decision2.reason || boundedText(vision.llmContent || vision.output, 320)}${cvDecision ? `; cv=${cvDecision.reason}` : ""}`;
+          const visionConfidence = decision2.confidence ?? 0;
+          const useCv = Boolean(cvDecision) && (visionConfidence < 0.55 || cvDecision.rotation === decision2.rotation && cvDecision.confidence > visionConfidence + 0.18);
+          const selected = useCv && cvDecision ? cvDecision : decision2;
+          const evidence = useCv ? cvDecision?.reason ?? "" : `${decision2.reason || boundedText(vision.llmContent || vision.output, 320)}${cvDecision ? `; cv=${cvDecision.reason}` : ""}`;
           const orientation = this.setCameraRotation(target, selected.rotation, "auto", evidence, selected.confidence);
           return orientation ? `Auto orientation for ${target}: ${describeCameraOrientation(orientation)}` : `Auto orientation for ${target} could not be persisted.`;
         } finally {
@@ -603532,7 +604526,10 @@ var init_live_sensors = __esm({
           errors
         };
         if (!this.config.selectedCamera) this.config.selectedCamera = firstDeviceId(video);
-        if (!this.config.selectedAudioInput) this.config.selectedAudioInput = firstDeviceId(inputs.devices);
+        const preferredInput = preferredLiveAudioInputId(inputs.devices, this.config.selectedAudioInput);
+        if (!this.config.selectedAudioInput || isAudioOutputMonitorId(this.config.selectedAudioInput) && preferredInput && !isAudioOutputMonitorId(preferredInput)) {
+          this.config.selectedAudioInput = preferredInput;
+        }
         if (!this.config.selectedAudioOutput) this.config.selectedAudioOutput = firstDeviceId(outputs.devices);
         this.persist();
         return this.devices;
@@ -603541,16 +604538,18 @@ 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();
       }
       stopAll() {
         this.agentActionEnabled = false;
+        this.liveSpeechEnabled = false;
         this.configure({
           videoEnabled: false,
           audioEnabled: false,
@@ -603563,6 +604562,7 @@ var init_live_sensors = __esm({
       }
       startRunMode(options2 = {}) {
         this.agentActionEnabled = Boolean(options2.agent);
+        this.liveSpeechEnabled = Boolean(options2.speech ?? options2.agent);
         this.configure({
           videoEnabled: true,
           inferEnabled: true,
@@ -603570,8 +604570,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);
@@ -603594,7 +604594,7 @@ var init_live_sensors = __esm({
             }, 6e4);
           });
         }
-        void this.sampleVideoNow(true).catch((err) => {
+        void this.sampleVideoNow(true, { mode: "all" }).catch((err) => {
           this.emitFeedback({
             kind: "error",
             title: "Live video sample failed",
@@ -603684,6 +604684,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 +604698,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 +604732,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 = {}) {
@@ -603780,24 +604789,33 @@ var init_live_sensors = __esm({
         const sampledAt = Date.now();
         if (forceInfer && source) {
           const loop = new LiveMediaLoopTool(this.repoRoot);
+          const inferFromCapturedFrame = preview.ok && Boolean(preview.framePath);
           const result = await loop.execute({
             action: "watch",
-            source_kind: "camera",
-            camera: source,
-            duration_sec: 2.5,
-            sample_interval_sec: 1,
-            max_frames: 2,
-            rotate_degrees: orientation?.rotation ?? 0,
+            source_kind: inferFromCapturedFrame ? "file" : "camera",
+            ...inferFromCapturedFrame ? { path: preview.framePath } : { camera: source },
+            yolo_family: "yoloe-26",
+            yolo_scale: "n",
+            yoloe_prompt_mode: "prompt_free",
+            duration_sec: inferFromCapturedFrame ? 0.1 : 0.75,
+            sample_interval_sec: inferFromCapturedFrame ? 0.1 : 0.25,
+            max_frames: 1,
+            rotate_degrees: inferFromCapturedFrame ? 0 : 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;
+          if (livePayload) livePayload.source = source;
           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 +604825,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 }
@@ -603831,6 +604850,16 @@ var init_live_sensors = __esm({
               `${unknownPeople.length} unknown individual(s) observed on live camera ${source}`,
               unknownPeople.map((entry) => `${entry.cropPath || entry.trackId || entry.source} ${entry.evidence || ""}`).join("; ")
             );
+            this.maybeSpeakLive({
+              key: `unknown-person:${source}`,
+              kind: "unknown_person",
+              source,
+              summary: `${unknownPeople.length} unknown individual(s) observed on live camera ${source}`,
+              evidence: unknownPeople.map((entry) => `${entry.cropPath || entry.trackId || entry.source} ${entry.evidence || ""}`).join("; "),
+              defaultText: "I see someone here, but I do not know who. Who is there?",
+              urgency: "high",
+              observedAt: sampledAt
+            }, 9e4);
           }
           const triggerEvents = observations.events.filter((entry) => entry.kind === "visual_trigger");
           if (triggerEvents.length > 0) {
@@ -603838,13 +604867,29 @@ var init_live_sensors = __esm({
               `Visual trigger hit in live camera stream ${source}`,
               triggerEvents.map((entry) => entry.summary).join("; ")
             );
+            this.maybeSpeakLive({
+              key: `visual-trigger:${source}:${triggerEvents[0]?.title ?? "trigger"}`,
+              kind: "visual_trigger",
+              source,
+              summary: `Visual trigger hit in live camera stream ${source}`,
+              evidence: triggerEvents.map((entry) => entry.summary).join("; "),
+              defaultText: "I noticed something important in view. Should I inspect it?",
+              urgency: "high",
+              observedAt: sampledAt
+            }, 45e3);
           }
         }
-        if (this.config.clipEnabled && preview.ok && preview.framePath && source) {
+        const lastClip = this.lastClipAt.get(source) ?? 0;
+        if (this.config.clipEnabled && preview.ok && preview.framePath && source && sampledAt - lastClip >= 5e3) {
+          this.lastClipAt.set(source, sampledAt);
           clipSummary = await this.recognizeFrameObjects(preview.framePath, source, sampledAt, { emit: false });
           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();
@@ -603855,14 +604900,16 @@ ${inference}` : "", clipSummary ? `
 CLIP visual memory:
 ${clipSummary}` : ""].filter(Boolean).join("\n");
       }
-      async sampleVideoNow(forceInfer = this.config.inferEnabled) {
+      async sampleVideoNow(forceInfer = this.config.inferEnabled, options2 = {}) {
         if (this.videoInFlight) return "Video sampler is already running.";
         this.videoInFlight = true;
         try {
-          const sources = this.activeVideoSources();
+          const allSources = this.activeVideoSources();
+          if (allSources.length === 0) return "No camera selected. Use /live refresh after connecting hardware.";
+          const sources = options2.mode === "round-robin" ? [allSources[this.nextVideoSourceIndex++ % allSources.length]] : allSources;
           if (sources.length === 0) return "No camera selected. Use /live refresh after connecting hardware.";
           const outputs = [];
-          const previewWidth = liveDashboardPreviewWidthForSources(sources.length);
+          const previewWidth = liveDashboardPreviewWidthForSources(allSources.length);
           for (const source of sources) {
             outputs.push(await this.sampleSingleVideoNow(source, forceInfer, previewWidth));
           }
@@ -603877,7 +604924,9 @@ ${output}`).join("\n\n");
         if (this.audioInFlight) return "Audio sampler is already running.";
         this.audioInFlight = true;
         try {
-          const input = this.config.selectedAudioInput || firstDeviceId(this.devices.audioInputs) || "default";
+          const preferredInput = preferredLiveAudioInputId(this.devices.audioInputs, this.config.selectedAudioInput) || "default";
+          const input = this.config.selectedAudioInput && !isAudioOutputMonitorId(this.config.selectedAudioInput) ? this.config.selectedAudioInput : preferredInput;
+          if (input !== this.config.selectedAudioInput) this.config.selectedAudioInput = input;
           const outputDir2 = liveDir(this.repoRoot);
           ensureLiveDir(this.repoRoot);
           const recordingPath = join124(outputDir2, `audio-${Date.now()}.wav`);
@@ -603908,7 +604957,10 @@ ${output}`).join("\n\n");
           if (capture.device !== this.config.selectedAudioInput) {
             this.config.selectedAudioInput = capture.device;
           }
-          const activity = readPcm16WavActivity(recordingPath);
+          const activity = capture.activity ?? readPcm16WavActivity(recordingPath);
+          if (capture.ok && capture.signalDetected === false) {
+            audioErrors.push(`No live input signal detected after probing ${capture.attempts?.length ?? 1} audio source(s); using quiet capture from ${capture.device}`);
+          }
           if (this.config.asrEnabled) {
             try {
               const asr = await new TranscribeFileTool(this.repoRoot).execute({ path: recordingPath, model: "tiny" });
@@ -603985,6 +605037,16 @@ ${output}`).join("\n\n");
               "Live audio intake classified speech as intended for Omnius",
               `transcript=${transcript}; confidence=${intake.confidence.toFixed(2)}; reason=${intake.reason}`
             );
+            this.maybeSpeakLive({
+              key: `audio-intent:${capture.device}:${transcript.slice(0, 48)}`,
+              kind: "audio_intent",
+              source: capture.device,
+              summary: "Live audio intake classified speech as intended for Omnius",
+              evidence: `transcript=${transcript}; confidence=${intake.confidence.toFixed(2)}; reason=${intake.reason}`,
+              defaultText: "I heard you. I am checking the live context now.",
+              urgency: "high",
+              observedAt: this.snapshot.audio.updatedAt
+            }, 2e4);
           }
           this.emitDashboard();
           return [
@@ -604002,30 +605064,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, { mode: "round-robin" });
+          } 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;
         }
       }
@@ -604060,7 +605155,7 @@ ${analysis}` : ""
       maybeRequestAgentReview(reason, evidence) {
         if (!this.agentActionEnabled || !this.agentActionSink) return;
         const now2 = Date.now();
-        if (now2 - this.lastAgentReviewAt < 2e4) return;
+        if (now2 - this.lastAgentReviewAt < 6e4) return;
         this.lastAgentReviewAt = now2;
         const prompt = [
           "Live environment PFC review.",
@@ -604083,6 +605178,38 @@ ${analysis}` : ""
         } catch {
         }
       }
+      maybeSpeakLive(proposal, perKeyCooldownMs) {
+        if (!this.liveSpeechEnabled || !this.liveSpeechSink) return;
+        const now2 = Date.now();
+        if (now2 - this.lastLiveSpeechAt < 12e3) return;
+        const lastForKey = this.lastLiveSpeechByKey.get(proposal.key) ?? 0;
+        if (now2 - lastForKey < perKeyCooldownMs) return;
+        if (this.liveSpeechInFlight.has(proposal.key)) return;
+        this.liveSpeechInFlight.add(proposal.key);
+        void classifyLiveSpeech(proposal, this.intakeAgentConfig).then((decision2) => {
+          this.lastLiveSpeechByKey.set(proposal.key, Date.now());
+          if (!decision2.speak || !decision2.text.trim()) return;
+          this.lastLiveSpeechAt = Date.now();
+          const text2 = trimOneLine(decision2.text, 180);
+          this.liveSpeechSink?.(text2, decision2);
+          this.emitFeedbackThrottled(`speech:${proposal.key}`, {
+            kind: "speech",
+            title: "Live speech emitted",
+            observedAt: decision2.updatedAt,
+            message: `${text2}
+reason=${decision2.reason} confidence=${decision2.confidence.toFixed(2)} source=${decision2.source}`
+          }, 15e3);
+        }).catch((err) => {
+          this.emitFeedbackThrottled(`speech-error:${proposal.key}`, {
+            kind: "error",
+            title: "Live speech arbiter failed",
+            observedAt: Date.now(),
+            message: err instanceof Error ? err.message : String(err)
+          }, 6e4);
+        }).finally(() => {
+          this.liveSpeechInFlight.delete(proposal.key);
+        });
+      }
       persist() {
         ensureLiveDir(this.repoRoot);
         writeFileSync56(liveConfigPath(this.repoRoot), JSON.stringify(this.config, null, 2), "utf8");
@@ -638440,6 +639567,10 @@ async function showPruneMenu(options2) {
   });
   if (!result.confirmed || !result.key || result.key === "back") return;
   const start2 = (label, o2) => {
+    if (isLiveSensorActiveForRepo(workingDir)) {
+      renderWarning("Live audio/video mode is active; pruning is deferred so sensor, ASR, vision, and reasoning inference stay available. Stop live mode before running prune.");
+      return;
+    }
     renderInfo(`${label} (running in background — summary will follow)…`);
     runPruneWorkerOnce({
       repoRoot: workingDir,
@@ -638475,6 +639606,7 @@ var init_prune_menu = __esm({
     init_render();
     init_kg_prune();
     init_memory_maintenance();
+    init_live_sensors();
     import_chalk2 = __toESM(require_source(), 1);
   }
 });
@@ -647474,6 +648606,7 @@ async function handleSlashCommand(input, ctx3) {
     case "prune": {
       const sub2 = (arg?.trim().split(/\s+/)[0] ?? "").toLowerCase();
       const workingDir = ctx3.repoRoot || process.cwd();
+      const force = /\b--force\b/i.test(arg ?? "");
       const targetMatch = arg?.match(/--target\s+(\d+)/);
       const targetNodes = targetMatch ? parseInt(targetMatch[1], 10) : void 0;
       const { knowledgeGraphStats: knowledgeGraphStats2, formatKgStatsLine: formatKgStatsLine2 } = await Promise.resolve().then(() => (init_kg_prune(), kg_prune_exports));
@@ -647482,6 +648615,10 @@ async function handleSlashCommand(input, ctx3) {
         renderInfo(summary);
       };
       const startBackground = (label, o2) => {
+        if (isLiveSensorActiveForRepo(workingDir) && !force) {
+          renderWarning("Live audio/video mode is active; pruning is deferred so sensor, ASR, vision, and reasoning inference stay available. Stop live mode first, or rerun with --force if you intentionally want pruning to compete with live inference.");
+          return;
+        }
         renderInfo(`${label} (running in background — summary will follow)…`);
         runPruneWorkerOnce2({
           repoRoot: workingDir,
@@ -655805,6 +656942,12 @@ function attachLiveSinks(ctx3, manager, agentEnabled = false) {
     model: ctx3.config.model,
     apiKey: ctx3.config.apiKey
   });
+  const speechEnabled = agentEnabled && Boolean(ctx3.voiceSpeak);
+  manager.setLiveSpeechEnabled(speechEnabled);
+  manager.setLiveSpeechSink(speechEnabled ? (text2) => {
+    if (ctx3.voiceIsEnabled && !ctx3.voiceIsEnabled()) return;
+    ctx3.voiceSpeak?.(text2);
+  } : void 0);
   if (agentEnabled && ctx3.startBackgroundPrompt) {
     manager.setAgentActionSink((prompt) => {
       const id2 = ctx3.startBackgroundPrompt?.(prompt);
@@ -655818,13 +656961,14 @@ async function startLiveVoicechat(ctx3, manager) {
   const agentEnabled = Boolean(ctx3.startBackgroundPrompt);
   attachLiveSinks(ctx3, manager, agentEnabled);
   await ensureLiveInventory(manager);
-  renderInfo(manager.startRunMode({ agent: agentEnabled, lowLatency: true }));
   if (!ctx3.voiceChatStart) {
+    renderInfo(manager.startRunMode({ agent: agentEnabled, lowLatency: true, speech: false }));
     renderWarning("Voice chat is not available in this context; live audio/video feedback remains active.");
     return;
   }
   ctx3.voiceSetMode?.("voicechat");
   if (ctx3.isVoiceChatActive?.()) {
+    renderInfo(manager.startRunMode({ agent: agentEnabled, lowLatency: true, speech: Boolean(ctx3.voiceSpeak) }));
     renderInfo("Voice chat is already active. Live audio/video feedback remains attached.");
     return;
   }
@@ -655835,6 +656979,7 @@ async function startLiveVoicechat(ctx3, manager) {
   try {
     renderInfo("Starting live voicechat with audio/video context...");
     await ctx3.voiceChatStart();
+    renderInfo(manager.startRunMode({ agent: agentEnabled, lowLatency: true, speech: Boolean(ctx3.voiceSpeak) }));
     renderInfo("Live voicechat active: low-latency audio/video context is updating while voice conversation continues.");
   } catch (err) {
     renderError(`Live voicechat failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -655895,7 +657040,7 @@ async function handleLiveCommand(ctx3, arg) {
       renderWarning("Live PFC agent review is unavailable in this context; starting visual/audio feedback only.");
     }
     await ensureLiveInventory(manager);
-    renderInfo(manager.startRunMode({ agent: effectiveAgent, lowLatency: true }));
+    renderInfo(manager.startRunMode({ agent: effectiveAgent, lowLatency: true, speech: effectiveAgent && Boolean(ctx3.voiceSpeak) }));
     return;
   }
   if (sub2 === "chat" || sub2 === "voicechat" || sub2 === "voice") {
@@ -656150,14 +657295,14 @@ async function showLiveMenu(ctx3, manager) {
         continue;
       case "run-live":
         attachLiveSinks(ctx3, manager, false);
-        renderInfo(manager.startRunMode({ agent: false, lowLatency: true }));
+        renderInfo(manager.startRunMode({ agent: false, lowLatency: true, speech: false }));
         continue;
       case "run-agent":
         attachLiveSinks(ctx3, manager, true);
         if (!ctx3.startBackgroundPrompt) {
           renderWarning("Live PFC agent review is unavailable in this context; starting visual/audio feedback only.");
         }
-        renderInfo(manager.startRunMode({ agent: Boolean(ctx3.startBackgroundPrompt), lowLatency: true }));
+        renderInfo(manager.startRunMode({ agent: Boolean(ctx3.startBackgroundPrompt), lowLatency: true, speech: Boolean(ctx3.startBackgroundPrompt && ctx3.voiceSpeak) }));
         continue;
       case "run-chat":
         await startLiveVoicechat(ctx3, manager);
@@ -731385,9 +732530,10 @@ Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.cat
     }, delayMs);
   }
   let activeTask = null;
+  const liveSensorsBusy = () => isLiveSensorActiveForRepo(repoRoot);
   idleMemoryMaintenance = startIdleMemoryMaintenance({
     repoRoot,
-    isBusy: () => Boolean(activeTask) || _interactiveSessionActive,
+    isBusy: () => Boolean(activeTask) || _interactiveSessionActive || liveSensorsBusy(),
     onSummary: (summary) => {
       if (!summary) return;
       writeContent(() => renderInfo(summary));
@@ -733941,6 +735087,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     },
     setLiveMediaStatus(status) {
       statusBar.setLiveMediaStatus(status);
+      if (status.audio || status.video) idleMemoryMaintenance?.notifyActivity();
     },
     liveDynamicBlockHost: {
       registerDynamicBlock: (id2, render2) => statusBar.registerDynamicBlock(id2, render2),