omnius 1.0.678 → 1.0.680

package/README.md

@@ -234,12 +234,14 @@ The same surface drives the **Generate** tab in the web UI (`http://127.0.0.1:11
 - `/indicator` reconciles daemon ownership and health before launching the tray; the tray polls every 10 seconds and turns its version row into a retryable verified-update action only when an update exists.
 - Dashboard, tray, and TUI update actions now share an exact-version global transaction with live phase/output and package, executable, daemon, hash, restart, and tray verification.
 - TTS exposes GLaDOS, Overwatch, `luxtts:announcer-testchamber03`, and configurable Voicebox models; ASR independently exposes Whisper, managed `transcribe-cli`, Nemotron readiness, and pinned Microsoft VibeVoice ASR with Jetson/ARM64 CUDA-aware setup.
+- LuxTTS auto-setup on Jetson ARM64 requires CPU ONNX Runtime at import time, validates CUDA Torch separately against the host runtime, preserves existing caches during repair, and never substitutes generic PyPI Torch or automatic sudo for an AGX Orin deployment.
 - `/realtime` and REST `realtime: true` provide short, natural, SOUL.md-aware conversation for ASR/TTS clients.
 - Endpoint setup and sponsor setup aggregate models from all enabled endpoints, including external OpenAI-compatible routers.
 - `/sponsor` can expose text inference and media generation for image, video, sound, and music with per-modality limits.
 - Sponsor and COHERE status surfaces now use shared telemetry concepts: concurrency, request rate, daily tokens, peer usage, model usage, and remote system metrics.
 - The TUI reports token production rate as `t/s`, supports Shift+Enter multiline input, and renders dynamic shell output inside bounded Unicode cards.
 - Telegram state is scoped by user and group, supports durable reply preferences, and feeds raw platform/tool failures back into the agent loop.
+- Telegram media ingress is byte- and duration-bounded, cache-only before routing, deduplicated by Telegram file identity, and evidence-gated after admission. Speech uses scoped transcription; music/general audio uses typed semantic or explicitly acoustic-only analysis without false listening claims.
 - Ollama pool cleanup now accounts for process groups and orphan runner processes that can keep VRAM pinned.
 - REST documentation is available both as human docs and as Omnius-discoverable docs skills.
 
@@ -504,8 +506,7 @@ The MCP equivalent uses a transport such as
 | `GET` | `/v1/context/restore` | Build restore prompt |
 | `POST` | `/v1/context/compact` | Request compaction |
 
-Context-window dumps are written before backend inference for main agents,
-sub-agents, internal runners, and adversary audits. Query
+Context-window dumps are written before backend inference for main agents, sub-agents, internal runners, and adversary audits. Query
 `GET /v1/context/window-dumps?agent_type=main` for summaries with signal/noise
 metrics, or fetch a full payload by id. Dumps include focus-supervisor state when
 a next-action contract is active. Set `OMNIUS_CONTEXT_WINDOW_DUMP_DIR` to move

package/assets/voice/detect-torch.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+"""
+detect-torch.py — Reusable PyTorch version and install URL detection.
+
+Detects the current platform/architecture/GPU environment and outputs
+the correct pip install arguments for PyTorch + torchaudio.
+
+Supports:
+  - x86_64 Linux with NVIDIA CUDA (cu118, cu121, cu124)
+  - x86_64 Linux CPU-only
+  - aarch64 Linux (ARM) CPU-only
+  - aarch64 Linux Jetson (NVIDIA GPU via JetPack wheels)
+  - macOS x86_64 (CPU)
+  - macOS arm64 / Apple Silicon (MPS via default PyPI)
+  - Windows x86_64 (CUDA or CPU)
+
+Output: JSON to stdout with fields:
+  {
+    "platform": "linux",
+    "arch": "x86_64" | "aarch64" | "arm64",
+    "accelerator": "cuda" | "mps" | "cpu",
+    "cuda_version": "12.4" | null,
+    "is_jetson": false,
+    "pip_args": ["torch", "torchaudio", "--index-url", "..."],
+    "pip_args_str": "torch torchaudio --index-url ...",
+    "description": "x86_64 Linux CUDA 12.4"
+  }
+
+Usage from shell:
+  python3 scripts/detect-torch.py
+  python3 scripts/detect-torch.py --pip-args   # just the pip install args
+  python3 scripts/detect-torch.py --index-url  # just the --index-url value
+
+Usage from Node.js (via child_process):
+  const result = execSync('python3 scripts/detect-torch.py').toString();
+  const spec = JSON.parse(result);
+  await shell(`pip install ${spec.pip_args_str}`);
+
+Derived from hydra/service_router/.services/depth_any/app.py bootstrap logic.
+"""
+
+import json
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+
+def detect_cuda_version():
+    """Detect NVIDIA CUDA version from nvidia-smi or nvcc."""
+    # Try nvidia-smi first (works even without nvcc)
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader,nounits"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            # nvidia-smi works — now get CUDA version
+            result2 = subprocess.run(
+                ["nvidia-smi"],
+                capture_output=True, text=True, timeout=5
+            )
+            if result2.returncode == 0:
+                import re
+                match = re.search(r"CUDA Version:\s*(\d+\.\d+)", result2.stdout)
+                if match:
+                    return match.group(1)
+    except Exception:
+        pass
+
+    # Try nvcc (Jetson, or systems with CUDA toolkit)
+    try:
+        result = subprocess.run(
+            ["nvcc", "--version"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            import re
+            match = re.search(r"release (\d+\.\d+)", result.stdout)
+            if match:
+                return match.group(1)
+    except Exception:
+        pass
+
+    return None
+
+
+def is_jetson():
+    """Detect NVIDIA Jetson (aarch64 + /etc/nv_tegra_release)."""
+    return (
+        platform.machine().lower() in ("aarch64", "arm64")
+        and Path("/etc/nv_tegra_release").exists()
+    )
+
+
+def jetson_torch_wheel_url():
+    """Find the best Jetson PyTorch wheel URL from NVIDIA's index."""
+    import re
+    import urllib.request
+
+    py_tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
+
+    # Check env override first
+    env_wheel = os.environ.get("JETSON_TORCH_WHEEL")
+    if env_wheel:
+        return env_wheel
+
+    # Try NVIDIA's Jetson wheel index
+    release_text = ""
+    try:
+        release_text = Path("/etc/nv_tegra_release").read_text()
+    except Exception:
+        pass
+
+    # Determine JetPack version -> index URL
+    indexes = []
+    if "R36" in release_text and "REVISION: 4" in release_text:
+        indexes.extend([
+            "https://developer.download.nvidia.com/compute/redist/jp/v61",
+            "https://developer.download.nvidia.com/compute/redist/jp/v60",
+        ])
+    elif "R36" in release_text:
+        indexes.append("https://developer.download.nvidia.com/compute/redist/jp/v60")
+    elif "R35" in release_text:
+        indexes.append("https://developer.download.nvidia.com/compute/redist/jp/v51")
+    else:
+        indexes.extend([
+            "https://developer.download.nvidia.com/compute/redist/jp/v60",
+            "https://developer.download.nvidia.com/compute/redist/jp/v51",
+        ])
+
+    for idx_url in indexes:
+        try:
+            with urllib.request.urlopen(f"{idx_url}/pytorch/", timeout=10) as resp:
+                html = resp.read().decode("utf-8", "ignore")
+            pattern = rf'href="(torch-([0-9a-zA-Z\\.\\+]+)\\.nv[^"]*{py_tag}[^"]*linux_aarch64\\.whl)"'
+            matches = re.findall(pattern, html)
+            best = None
+            for fname, ver in matches:
+                base_ver = ver.split("+")[0]
+                parts = tuple(int(x) for x in base_ver.split(".")[:3] if x.isdigit())
+                if best is None or parts > best[0]:
+                    best = (parts, fname, base_ver)
+            if best:
+                return f"{idx_url}/pytorch/{best[1]}"
+        except Exception:
+            continue
+
+    return None
+
+
+def detect_torch_spec():
+    """Detect the optimal PyTorch install spec for this system."""
+    machine = platform.machine().lower()
+    system = platform.system().lower()
+
+    spec = {
+        "platform": system,
+        "arch": machine,
+        "accelerator": "cpu",
+        "cuda_version": None,
+        "is_jetson": False,
+        "pip_args": [],
+        "pip_args_str": "",
+        "torchaudio_version": None,
+        "error": None,
+        "description": "",
+    }
+
+    # ── macOS ──────────────────────────────────────────────────────────
+    if system == "darwin":
+        if machine in ("arm64", "aarch64"):
+            # Apple Silicon — MPS acceleration via default PyPI wheels
+            spec["accelerator"] = "mps"
+            spec["pip_args"] = ["torch", "torchaudio"]
+            spec["description"] = "macOS Apple Silicon (MPS)"
+        else:
+            # Intel Mac — CPU only
+            spec["pip_args"] = ["torch", "torchaudio"]
+            spec["description"] = "macOS Intel (CPU)"
+        spec["pip_args_str"] = " ".join(spec["pip_args"])
+        return spec
+
+    # ── Windows ────────────────────────────────────────────────────────
+    if system == "windows":
+        cuda_ver = detect_cuda_version()
+        if cuda_ver:
+            spec["accelerator"] = "cuda"
+            spec["cuda_version"] = cuda_ver
+            major_minor = cuda_ver.split(".")
+            cu_tag = f"cu{major_minor[0]}{major_minor[1]}" if len(major_minor) >= 2 else "cu124"
+            spec["pip_args"] = ["torch", "torchaudio", "--index-url", f"https://download.pytorch.org/whl/{cu_tag}"]
+            spec["description"] = f"Windows CUDA {cuda_ver}"
+        else:
+            spec["pip_args"] = ["torch", "torchaudio", "--index-url", "https://download.pytorch.org/whl/cpu"]
+            spec["description"] = "Windows CPU"
+        spec["pip_args_str"] = " ".join(spec["pip_args"])
+        return spec
+
+    # ── Linux ──────────────────────────────────────────────────────────
+
+    # Check for Jetson first (aarch64 + NVIDIA GPU via JetPack)
+    if is_jetson():
+        spec["is_jetson"] = True
+        spec["accelerator"] = "cuda"
+        spec["cuda_version"] = detect_cuda_version()
+
+        wheel_url = jetson_torch_wheel_url()
+        if wheel_url:
+            # Jetson needs wheel URL directly (not index-url)
+            spec["pip_args"] = [wheel_url]
+            spec["pip_args_str"] = wheel_url
+            import re
+            version_match = re.search(r"/torch-(\d+)\.(\d+)", wheel_url)
+            if version_match:
+                spec["torchaudio_version"] = f"{version_match.group(1)}.{version_match.group(2)}.0"
+            spec["description"] = f"Jetson aarch64 CUDA {spec['cuda_version'] or '?'} (JetPack wheel)"
+        else:
+            # Generic PyPI ARM Torch is not a JetPack ABI contract. Fail
+            # closed instead of installing a wheel that can report an old or
+            # insufficient driver on otherwise healthy Orin hardware.
+            spec["error"] = (
+                "No environment-matched NVIDIA Jetson Torch wheel was found. "
+                "Set JETSON_TORCH_WHEEL to an exact wheel for this L4T, CUDA, "
+                "Python ABI, and architecture."
+            )
+            spec["description"] = f"Jetson aarch64 CUDA {spec['cuda_version'] or '?'} (unsupported until an exact wheel is supplied)"
+        return spec
+
+    # Non-Jetson aarch64 (ARM server, Raspberry Pi, etc.)
+    if machine in ("aarch64", "arm64", "armv7l"):
+        cuda_ver = detect_cuda_version()
+        if cuda_ver:
+            spec["accelerator"] = "cuda"
+            spec["cuda_version"] = cuda_ver
+            # ARM + CUDA (e.g., Grace Hopper) — use generic pip (PyTorch publishes aarch64+cuda wheels on PyPI)
+            spec["pip_args"] = ["torch", "torchaudio"]
+            spec["description"] = f"Linux aarch64 CUDA {cuda_ver}"
+        else:
+            # ARM CPU — PyTorch publishes aarch64 CPU wheels on PyPI since 2.0+
+            # Do NOT use --index-url whl/cpu (no aarch64 there)
+            spec["pip_args"] = ["torch", "torchaudio"]
+            spec["description"] = "Linux aarch64 CPU"
+        spec["pip_args_str"] = " ".join(spec["pip_args"])
+        return spec
+
+    # x86_64 Linux
+    cuda_ver = detect_cuda_version()
+    if cuda_ver:
+        spec["accelerator"] = "cuda"
+        spec["cuda_version"] = cuda_ver
+        # Map CUDA version to PyTorch index tag
+        major = int(cuda_ver.split(".")[0])
+        minor = int(cuda_ver.split(".")[1]) if "." in cuda_ver else 0
+        if major >= 12 and minor >= 4:
+            cu_tag = "cu124"
+        elif major >= 12 and minor >= 1:
+            cu_tag = "cu121"
+        elif major >= 11 and minor >= 8:
+            cu_tag = "cu118"
+        else:
+            cu_tag = "cu121"  # default fallback
+        spec["pip_args"] = ["torch", "torchaudio", "--index-url", f"https://download.pytorch.org/whl/{cu_tag}"]
+        spec["description"] = f"Linux x86_64 CUDA {cuda_ver} ({cu_tag})"
+    else:
+        spec["pip_args"] = ["torch", "torchaudio", "--index-url", "https://download.pytorch.org/whl/cpu"]
+        spec["description"] = "Linux x86_64 CPU"
+
+    spec["pip_args_str"] = " ".join(spec["pip_args"])
+    return spec
+
+
+def main():
+    spec = detect_torch_spec()
+
+    if len(sys.argv) > 1:
+        flag = sys.argv[1]
+        if flag == "--pip-args":
+            print(spec["pip_args_str"])
+            return
+        elif flag == "--index-url":
+            for i, arg in enumerate(spec["pip_args"]):
+                if arg == "--index-url" and i + 1 < len(spec["pip_args"]):
+                    print(spec["pip_args"][i + 1])
+                    return
+            print("")  # no index-url (use default PyPI)
+            return
+        elif flag == "--description":
+            print(spec["description"])
+            return
+        elif flag == "--accelerator":
+            print(spec["accelerator"])
+            return
+        elif flag == "--json":
+            pass  # fall through to JSON output
+        else:
+            print(f"Unknown flag: {flag}", file=sys.stderr)
+            print("Usage: detect-torch.py [--pip-args|--index-url|--description|--accelerator|--json]", file=sys.stderr)
+            sys.exit(1)
+
+    print(json.dumps(spec, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/dist/api/py-embed.js

@@ -244667,6 +244667,13 @@ var MODEL_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODE
 var CLASS_MAP_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODEL_REVISION}/yamnet_class_map.csv`;
 var SETUP_TIMEOUT_MS = 20 * 6e4;
 
+// packages/execution/dist/audio-input-conditioning.js
+init_process_async();
+var AUDIO_MODEL_SAMPLE_RATE_HZ = 16e3;
+var AUDIO_MODEL_MAX_WINDOW_SECONDS = 6;
+var MAX_PCM_BYTES = AUDIO_MODEL_SAMPLE_RATE_HZ * AUDIO_MODEL_MAX_WINDOW_SECONDS * 2;
+var MAX_SOURCE_BYTES = 128 * 1024 * 1024;
+
 // packages/execution/dist/speaker-diarization-runtime.js
 init_model_store();
 init_process_async();
@@ -293085,7 +293092,6 @@ import { homedir as homedir5, tmpdir as tmpdir3 } from "node:os";
 init_cuda_device_filter();
 init_process_async();
 var VENV_DIR = join5(homedir5(), ".omnius", "audio-ml-venv");
-var VENV_PIP = join5(VENV_DIR, "bin", "pip");
 var VENV_PYTHON = join5(VENV_DIR, "bin", "python3");
 
 // packages/execution/dist/tools/visual-memory.js
@@ -293095,7 +293101,7 @@ import { homedir as homedir6, tmpdir as tmpdir4 } from "node:os";
 var VMEM_DIR = join6(homedir6(), ".omnius", "visual-memory");
 var VENV_DIR2 = join6(homedir6(), ".omnius", "vision-ml-venv");
 var VENV_PY = join6(VENV_DIR2, "bin", "python3");
-var VENV_PIP2 = join6(VENV_DIR2, "bin", "pip");
+var VENV_PIP = join6(VENV_DIR2, "bin", "pip");
 
 // packages/execution/dist/tools/multimodal-memory.js
 import { join as join7 } from "node:path";