Update app.py

app.py

@@ -1,160 +1,208 @@
-"""
-RVC Voice Conversion – HuggingFace Space
-Simple, fast, GPU/CPU auto-detected.
-"""
 from __future__ import annotations
 
 import logging
 import os
-import queue
-import shutil
 import sys
-import tempfile
-import threading
+import json
 import time
-import uuid
+import shutil
 import zipfile
-from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+import traceback
+import subprocess
+import math
+import re
+import queue
+import tempfile
 from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict, List, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
-import torch
-
-# ── Path bootstrap ────────────────────────────────────────────────────────────
-BASE_DIR = Path(__file__).parent
-sys.path.insert(0, str(BASE_DIR))
-
-MODELS_DIR = BASE_DIR / "rvc_models"
-OUTPUT_DIR = BASE_DIR / "outputs"
-MODELS_DIR.mkdir(exist_ok=True)
-OUTPUT_DIR.mkdir(exist_ok=True)
+import warnings
+warnings.filterwarnings("ignore")
+
+# =============================================================================
+# CONFIGURACAO CRITICA: URVC_MODELS_DIR antes de qualquer import do ultimate_rvc
+# =============================================================================
+BASE_DIR = Path("/mnt/agents/output")
+MODELS_DIR = BASE_DIR / "models"
+OUTPUTS_DIR = BASE_DIR / "outputs"
+JOBS_DIR = BASE_DIR / "jobs"
+UPLOAD_TEMP = BASE_DIR / "upload_temp"
+
+for d in [MODELS_DIR, OUTPUTS_DIR, JOBS_DIR, UPLOAD_TEMP]:
+    d.mkdir(parents=True, exist_ok=True)
+
+URVC_DIR = MODELS_DIR / "urvc"
+os.environ.setdefault("URVC_MODELS_DIR", str(URVC_DIR))
+
+HF_CACHE_DIR = BASE_DIR / "hf_cache"
+HF_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+os.environ["HF_HOME"] = str(HF_CACHE_DIR)
+os.environ["TRANSFORMERS_CACHE"] = str(HF_CACHE_DIR)
+os.environ["HF_HUB_CACHE"] = str(HF_CACHE_DIR)
+
+# =============================================================================
+# CPU threading otimizado
+# =============================================================================
+try:
+    _NUM_CORES = len(os.sched_getaffinity(0))
+except AttributeError:
+    _NUM_CORES = os.cpu_count() or 1
 
-os.environ.setdefault("URVC_MODELS_DIR", str(MODELS_DIR / "urvc"))
+import torch
+torch.set_num_threads(_NUM_CORES)
+try:
+    torch.set_num_interop_threads(_NUM_CORES)
+except RuntimeError:
+    pass  # ja foi configurado em outro ponto do processo
+os.environ["OMP_NUM_THREADS"] = str(_NUM_CORES)
+os.environ["MKL_NUM_THREADS"] = str(_NUM_CORES)
+os.environ["NUMEXPR_NUM_THREADS"] = str(_NUM_CORES)
+os.environ["OPENBLAS_NUM_THREADS"] = str(_NUM_CORES)
+torch.set_float32_matmul_precision("high")
 
+# =============================================================================
+# Logging
+# =============================================================================
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     datefmt="%H:%M:%S",
 )
-
 for _noisy in ("httpx", "httpcore", "faiss", "faiss.loader", "transformers", "torch"):
     logging.getLogger(_noisy).setLevel(logging.WARNING)
 logger = logging.getLogger("rvc_space")
 
-# ── CPU threading ─────────────────────────────────────────────────────────────
-try:
-    _NUM_CORES = len(os.sched_getaffinity(0))
-except AttributeError:
-    _NUM_CORES = os.cpu_count() or 1
-torch.set_num_threads(_NUM_CORES)
-torch.set_num_interop_threads(_NUM_CORES)
-os.environ["OMP_NUM_THREADS"]      = str(_NUM_CORES)
-os.environ["MKL_NUM_THREADS"]      = str(_NUM_CORES)
-os.environ["NUMEXPR_NUM_THREADS"]  = str(_NUM_CORES)
-os.environ["OPENBLAS_NUM_THREADS"] = str(_NUM_CORES)
-torch.set_float32_matmul_precision("high")
-torch.backends.mkldnn.enabled = True
-logger.info("CPU threads: %d  |  matmul: high  |  oneDNN: enabled", _NUM_CORES)
-
-# ── Device ────────────────────────────────────────────────────────────────────
-if torch.cuda.is_available():
-    DEVICE = "cuda"
-    DEVICE_LABEL = f"🟢 GPU  ·  {torch.cuda.get_device_name(0)}"
-else:
-    DEVICE = "cpu"
-    DEVICE_LABEL = f"🔵 CPU  ·  {_NUM_CORES} cores"
-logger.info("Device: %s", DEVICE_LABEL)
-
-# ── Built-in models ───────────────────────────────────────────────────────────
-BUILTIN_MODELS = [
-    {
-        "name": "Vestia Zeta v1",
-        "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/zeta.zip",
-    },
-    {
-        "name": "Vestia Zeta v2",
-        "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/zetaTest.zip",
-    },
-    {
-        "name": "Ayunda Risu",
-        "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/risu.zip",
-    },
-    {
-        "name": "Gawr Gura",
-        "url": "https://huggingface.co/Gigrig/GigrigRVC/resolve/41d46f087b9c7d70b93acf100f1cb9f7d25f3831/GawrGura_RVC_v2_Ov2Super_e275_s64075.zip",
-    },
-]
-
-# Max input duration in seconds (warn user beyond this)
-MAX_INPUT_DURATION = 300  # 5 minutes
+# =============================================================================
+# CONFIG
+# =============================================================================
+JOBS_FILE = JOBS_DIR / "jobs.json"
+JOBS_LOCK = threading.Lock()
+SR_TARGET = 48000
+MAX_INPUT_DURATION = 600
 
-# Output file TTL — delete files older than this on each conversion
-OUTPUT_TTL_SECONDS = 21600  # 1 hour
+STATUS_WAITING = "⏱️ Esperando"
+STATUS_CONVERTING = "⏳ Convertendo"
+STATUS_DONE = "✅ Done"
+STATUS_FAILED = "❌ Falha"
 
-# Max jobs to keep in memory
-MAX_JOBS = 50
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DEVICE_LABEL = f"{'GPU' if DEVICE == 'cuda' else 'CPU'} ({torch.cuda.get_device_name(0) if DEVICE == 'cuda' else 'CPU'})"
 
-# ── Lazy VoiceConverter ───────────────────────────────────────────────────────
-_vc_instance = None
+BUILTIN_MODELS = [
+    {"name": "Vestia Zeta v1", "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/zeta.zip"},
+    {"name": "Vestia Zeta v2", "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/zetaTest.zip"},
+    {"name": "Ayunda Risu", "url": "https://huggingface.co/megaaziib/my-rvc-models-collection/resolve/main/risu.zip"},
+    {"name": "Gawr Gura", "url": "https://huggingface.co/Gigrig/GigrigRVC/resolve/41d46f087b9c7d70b93acf100f1cb9f7d25f3831/GawrGura_RVC_v2_Ov2Super_e275_s64075.zip"},
+]
 
+CSS = """
+#header { text-align: center; margin-bottom: 1rem; }
+#header h1 { margin-bottom: 0.2rem; }
+#status { text-align: center; font-size: 0.9rem; color: #666; }
+.gr-box { border-radius: 8px; }
+footer { display: none !important; }
+"""
 
-def _get_vc():
-    global _vc_instance
-    if _vc_instance is None:
-        logger.info("Loading VoiceConverter…")
-        from ultimate_rvc.rvc.infer.infer import VoiceConverter
-        _vc_instance = VoiceConverter()
-        logger.info("VoiceConverter ready.")
-    return _vc_instance
+# =============================================================================
+# DEPENDENCIES
+# =============================================================================
+def _install_package(package_name: str) -> bool:
+    try:
+        print(f"[INSTALL] Tentando instalar {package_name}...")
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", package_name, "-q"],
+            capture_output=True, text=True, timeout=180
+        )
+        if result.returncode == 0:
+            print(f"[INSTALL] {package_name} instalado com sucesso")
+            import importlib
+            importlib.invalidate_caches()
+            return True
+        else:
+            print(f"[INSTALL] {package_name} falhou: {result.stderr[-300:]}")
+            return False
+    except Exception as e:
+        print(f"[INSTALL] {package_name} erro: {e}")
+        return False
 
 
-# ── Output file cleanup ───────────────────────────────────────────────────────
-def _cleanup_old_outputs() -> None:
-    """Delete output files older than OUTPUT_TTL_SECONDS."""
-    now = time.time()
-    for f in OUTPUT_DIR.iterdir():
-        if f.is_file() and (now - f.stat().st_mtime) > OUTPUT_TTL_SECONDS:
-            try:
-                f.unlink()
-                logger.info("Cleaned up old output: %s", f.name)
-            except Exception:
-                pass
+def _ensure_librosa():
+    try:
+        import librosa
+        return librosa
+    except ImportError:
+        _install_package("scipy")
+        if _install_package("librosa"):
+            import librosa
+            return librosa
+        raise RuntimeError("Nao foi possivel instalar librosa")
 
 
-# ── Model helpers ─────────────────────────────────────────────────────────────
-def list_models() -> list[str]:
-    if not MODELS_DIR.exists():
-        return []
-    return sorted(p.name for p in MODELS_DIR.iterdir()
-                  if p.is_dir() and list(p.glob("*.pth")))
+def _ensure_soundfile():
+    try:
+        import soundfile as sf
+        return sf
+    except ImportError:
+        if _install_package("soundfile"):
+            import soundfile as sf
+            return sf
+        raise RuntimeError("Nao foi possivel instalar soundfile")
 
 
-def _pth_and_index(name: str) -> tuple[str, str]:
-    d = MODELS_DIR / name
-    pths = list(d.glob("*.pth"))
-    idxs = list(d.glob("*.index"))
-    if not pths:
-        raise FileNotFoundError(f"No .pth file found in model '{name}'")
-    return str(pths[0]), str(idxs[0]) if idxs else ""
+def _ensure_ultimate_rvc():
+    try:
+        from ultimate_rvc.rvc.infer.infer import VoiceConverter
+        return VoiceConverter
+    except ImportError:
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "ultimate-rvc", "-q"],
+                capture_output=True, text=True, timeout=300
+            )
+            if result.returncode == 0:
+                import importlib
+                importlib.invalidate_caches()
+                from ultimate_rvc.rvc.infer.infer import VoiceConverter
+                return VoiceConverter
+        except Exception:
+            pass
+        raise RuntimeError("Nao foi possivel instalar ultimate-rvc")
 
 
-def _extract_zip(zip_path: str | Path, dest_name: str) -> None:
-    dest = MODELS_DIR / dest_name
-    dest.mkdir(exist_ok=True)
-    with zipfile.ZipFile(zip_path, "r") as zf:
-        zf.extractall(dest)
-    for nested in list(dest.rglob("*.pth")) + list(dest.rglob("*.index")):
-        target = dest / nested.name
-        if nested != target:
-            shutil.move(str(nested), str(target))
+def _ensure_demucs():
+    try:
+        import demucs
+        return demucs
+    except ImportError:
+        if _install_package("demucs"):
+            import demucs
+            return demucs
+        raise RuntimeError("Nao foi possivel instalar demucs")
 
 
+def _ensure_requests():
+    try:
+        import requests
+        return requests
+    except ImportError:
+        if _install_package("requests"):
+            import requests
+            return requests
+        raise RuntimeError("Nao foi possivel instalar requests")
+
+
+# =============================================================================
+# DOWNLOAD HELPERS
+# =============================================================================
 def _download_file(url: str, dest: Path) -> None:
-    """Download a single file if not already present."""
+    requests = _ensure_requests()
     if dest.exists():
         return
     dest.parent.mkdir(parents=True, exist_ok=True)
-    logger.info("Downloading %s …", dest.name)
-    import requests
+    logger.info("Downloading %s ...", dest.name)
     r = requests.get(url, stream=True, timeout=300)
     r.raise_for_status()
     with tempfile.NamedTemporaryFile(delete=False, dir=dest.parent, suffix=".tmp") as tmp:
@@ -165,15 +213,25 @@ def _download_file(url: str, dest: Path) -> None:
     logger.info("%s ready.", dest.name)
 
 
+def _extract_zip(zip_path: str | Path, dest_name: str) -> None:
+    dest = MODELS_DIR / dest_name
+    dest.mkdir(exist_ok=True)
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(dest)
+    for nested in list(dest.rglob("*.pth")) + list(dest.rglob("*.index")):
+        target = dest / nested.name
+        if nested != target:
+            shutil.move(str(nested), str(target))
+
+
 def _download_model_entry(model: dict) -> str:
-    """Download a single built-in model zip. Returns model name."""
-    import requests
+    requests = _ensure_requests()
     name = model["name"]
     dest = MODELS_DIR / name
     if dest.exists() and list(dest.glob("*.pth")):
         logger.info("Model already present: %s", name)
         return name
-    logger.info("Downloading model: %s …", name)
+    logger.info("Downloading model: %s ...", name)
     with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp:
         r = requests.get(model["url"], stream=True, timeout=300)
         r.raise_for_status()
@@ -187,33 +245,22 @@ def _download_model_entry(model: dict) -> str:
 
 
 def _startup_downloads() -> str:
-    """
-    Download all required assets in parallel at startup.
-    Returns name of first built-in model as the default selection.
-    """
-    import requests  # noqa: F401 — ensure available before threads
-
-    # Build task list: predictors + embedders + models all in one pool
+    _ensure_requests()
     predictor_base = "https://huggingface.co/JackismyShephard/ultimate-rvc/resolve/main/Resources/predictors"
-    embedder_base  = "https://huggingface.co/JackismyShephard/ultimate-rvc/resolve/main/Resources/embedders"
-    predictors_dir = MODELS_DIR / "urvc" / "rvc" / "predictors"
-    embedders_dir  = MODELS_DIR / "urvc" / "rvc" / "embedders"
+    embedder_base = "https://huggingface.co/JackismyShephard/ultimate-rvc/resolve/main/Resources/embedders"
+    predictors_dir = URVC_DIR / "rvc" / "predictors"
+    embedders_dir = URVC_DIR / "rvc" / "embedders"
 
     file_tasks = [
-        (f"{predictor_base}/rmvpe.pt",              predictors_dir / "rmvpe.pt"),
-        (f"{predictor_base}/fcpe.pt",               predictors_dir / "fcpe.pt"),
+        (f"{predictor_base}/rmvpe.pt", predictors_dir / "rmvpe.pt"),
+        (f"{predictor_base}/fcpe.pt", predictors_dir / "fcpe.pt"),
         (f"{embedder_base}/contentvec/pytorch_model.bin", embedders_dir / "contentvec" / "pytorch_model.bin"),
-        (f"{embedder_base}/contentvec/config.json",       embedders_dir / "contentvec" / "config.json"),
+        (f"{embedder_base}/contentvec/config.json", embedders_dir / "contentvec" / "config.json"),
     ]
 
     with ThreadPoolExecutor(max_workers=8) as pool:
-        # Submit file downloads
-        file_futures = {pool.submit(_download_file, url, dest): dest.name
-                        for url, dest in file_tasks}
-        # Submit model downloads
-        model_futures = {pool.submit(_download_model_entry, m): m["name"]
-                         for m in BUILTIN_MODELS}
-
+        file_futures = {pool.submit(_download_file, url, dest): dest.name for url, dest in file_tasks}
+        model_futures = {pool.submit(_download_model_entry, m): m["name"] for m in BUILTIN_MODELS}
         all_futures = {**file_futures, **model_futures}
         for future in as_completed(all_futures):
             try:
@@ -224,389 +271,988 @@ def _startup_downloads() -> str:
     return BUILTIN_MODELS[0]["name"]
 
 
-# ── Upload handler ────────────────────────────────────────────────────────────
-def upload_model(zip_file, model_name):
-    import gradio as gr
-    if not zip_file:
-        return "⚠️ No file provided.", gr.update(), gr.update()
-    name = (model_name or "").strip() or Path(zip_file).stem
+# =============================================================================
+# JOBS SYSTEM
+# =============================================================================
+def load_jobs() -> dict:
+    with JOBS_LOCK:
+        if JOBS_FILE.exists():
+            try:
+                with open(JOBS_FILE, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+
+
+def save_jobs(jobs: dict):
+    with JOBS_LOCK:
+        JOBS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = JOBS_FILE.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(jobs, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, JOBS_FILE)
+
+
+def create_job(job_id: str, model_name: str, pitch: int, f0_method: str,
+               input_file_path: str, settings: dict) -> dict:
+    jobs = load_jobs()
+    jobs[job_id] = {
+        "id": job_id,
+        "model": model_name,
+        "pitch": pitch,
+        "f0_method": f0_method,
+        "input_file": input_file_path,
+        "settings": settings,
+        "status": STATUS_WAITING,
+        "created_at": datetime.now().isoformat(),
+        "started_at": None,
+        "finished_at": None,
+        "error": None,
+        "outputs": {},
+        "log_file": str(JOBS_DIR / f"{job_id}.log")
+    }
+    save_jobs(jobs)
+    return jobs[job_id]
+
+
+def update_job_status(job_id: str, status: str, error: str = None, outputs: dict = None):
+    jobs = load_jobs()
+    if job_id in jobs:
+        jobs[job_id]["status"] = status
+        if status == STATUS_CONVERTING and jobs[job_id]["started_at"] is None:
+            jobs[job_id]["started_at"] = datetime.now().isoformat()
+        if status in [STATUS_DONE, STATUS_FAILED]:
+            jobs[job_id]["finished_at"] = datetime.now().isoformat()
+        if error:
+            jobs[job_id]["error"] = error
+        if outputs:
+            jobs[job_id]["outputs"] = outputs
+        save_jobs(jobs)
+
+
+def append_log(job_id: str, message: str):
+    if job_id == "_global":
+        return
+    jobs = load_jobs()
+    if job_id in jobs:
+        log_path = Path(jobs[job_id]["log_file"])
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(f"[{timestamp}] {message}\n")
+
+
+def get_jobs_table():
+    jobs = load_jobs()
+    rows = []
+    for job_id, job in sorted(jobs.items(), key=lambda x: x[1].get("created_at", ""), reverse=True):
+        duration = "-"
+        if job.get("started_at") and job.get("finished_at"):
+            try:
+                start = datetime.fromisoformat(job["started_at"])
+                end = datetime.fromisoformat(job["finished_at"])
+                duration = f"{(end - start).total_seconds() / 60:.1f}"
+            except Exception:
+                pass
+        if job["status"] == STATUS_DONE:
+            download = "✅"
+        elif job["status"] == STATUS_FAILED:
+            download = "❌"
+        elif job["status"] == STATUS_CONVERTING:
+            download = "⏳"
+        else:
+            download = "⏱️"
+        rows.append([job_id, job["model"], job["status"], duration, download])
+    return rows
+
+
+def get_queue_info():
+    jobs = load_jobs()
+    waiting = sum(1 for j in jobs.values() if j["status"] == STATUS_WAITING)
+    converting = sum(1 for j in jobs.values() if j["status"] == STATUS_CONVERTING)
+    done = sum(1 for j in jobs.values() if j["status"] == STATUS_DONE)
+    failed = sum(1 for j in jobs.values() if j["status"] == STATUS_FAILED)
+    return f"**Fila:** {waiting} esperando · {converting} convertendo · {done} concluidos · {failed} falhas"
+
+
+def poll_job(job_id: str):
+    if not job_id or not job_id.strip():
+        return "Digite um Job ID", None
+    job_id = job_id.strip()
+    jobs = load_jobs()
+    if job_id not in jobs:
+        return f"Job '{job_id}' nao encontrado", None
+    job = jobs[job_id]
+    if job["status"] == STATUS_DONE:
+        outputs = job.get("outputs", {})
+        out = outputs.get("saida")
+        if out and os.path.exists(out):
+            return "✅ Job concluido!", out
+        job_dir = OUTPUTS_DIR / job_id
+        if job_dir.exists():
+            for ext in [".wav", ".flac", ".mp3", ".opus"]:
+                fallback = str(job_dir / f"saida{ext}")
+                if os.path.exists(fallback):
+                    return "✅ Job concluido!", fallback
+        return "✅ Concluido, mas arquivo nao encontrado", None
+    elif job["status"] == STATUS_FAILED:
+        return f"❌ Falhou: {job.get('error', 'Erro desconhecido')}", None
+    elif job["status"] == STATUS_CONVERTING:
+        return "⏳ Ainda convertendo...", None
+    else:
+        return "⏱️ Na fila, aguardando...", None
+
+
+# =============================================================================
+# AUDIO UTILS
+# =============================================================================
+def ensure_wav(input_path: str, output_wav: str) -> str:
+    cmd = ["ffmpeg", "-y", "-i", input_path, "-acodec", "pcm_s16le", "-ar", str(SR_TARGET), "-ac", "2", output_wav]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"FFmpeg falhou: {result.stderr[:500]}")
+    return output_wav
+
+
+def safe_write_wav(path: str, audio, sr: int):
+    sf = _ensure_soundfile()
+    import numpy as np
+    if audio.ndim == 1:
+        audio = np.stack([audio, audio], axis=-1)
+    elif audio.ndim == 2 and audio.shape[0] == 2 and audio.shape[1] > 2:
+        audio = audio.T
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    sf.write(path, audio, sr, format="WAV", subtype="PCM_16")
+
+
+def get_audio_duration(wav_path: str) -> float:
+    """Duracao em segundos de um WAV garantido (nao engole erros)."""
+    sf = _ensure_soundfile()
+    info = sf.info(wav_path)
+    return float(info.duration)
+
+
+def extract_audio_from_video(video_path: str, output_wav: str) -> str:
+    cmd = ["ffmpeg", "-y", "-i", video_path, "-vn", "-acodec", "pcm_s16le", "-ar", str(SR_TARGET), "-ac", "2", output_wav]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"FFmpeg falhou ao extrair audio do video: {result.stderr[:500]}")
+    return output_wav
+
+
+def separate_audio_demucs(input_wav: str, output_dir: str, job_id: str) -> Tuple[str, str]:
+    _ensure_demucs()
+    from demucs.pretrained import get_model
+    from demucs.apply import apply_model
+    append_log(job_id, "Separando vocal/instrumental com Demucs...")
+    model = get_model("htdemucs")
+    model.cpu()
+    model.eval()
+    librosa = _ensure_librosa()
+    import numpy as np
+    wav_np, sr = librosa.load(input_wav, sr=44100, mono=False)
+    if wav_np.ndim == 1:
+        wav_np = np.stack([wav_np, wav_np])
+    elif wav_np.ndim == 2:
+        if wav_np.shape[0] > wav_np.shape[1]:
+            wav_np = wav_np.T
+    if wav_np.shape[0] > 2:
+        wav_np = wav_np[:2]
+    elif wav_np.shape[0] == 1:
+        wav_np = np.repeat(wav_np, 2, axis=0)
+    wav = torch.from_numpy(wav_np).float().unsqueeze(0)
+    with torch.no_grad():
+        sources = apply_model(model, wav, device="cpu", progress=False)
+    sources = sources[0]
+    source_names = model.sources
+    vocal_idx = source_names.index("vocals")
+    vocals = sources[vocal_idx].cpu().numpy()
+    instrumental = torch.zeros_like(sources[0])
+    for i, name in enumerate(source_names):
+        if name != "vocals":
+            instrumental += sources[i]
+    instrumental = instrumental.cpu().numpy()
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    vocal_path = os.path.join(output_dir, "entrada_acapella.wav")
+    inst_path = os.path.join(output_dir, "entrada_instrumental.wav")
+    safe_write_wav(vocal_path, vocals.T, 44100)
+    safe_write_wav(inst_path, instrumental.T, 44100)
+    vocal_48k = os.path.join(output_dir, "entrada_acapella_48k.wav")
+    inst_48k = os.path.join(output_dir, "entrada_instrumental_48k.wav")
+    ensure_wav(vocal_path, vocal_48k)
+    ensure_wav(inst_path, inst_48k)
+    return vocal_48k, inst_48k
+
+
+def apply_reverb_wav(wav_path: str, room: float, damp: float, wet: float, job_id: str):
+    """Aplica reverb simples (convolucao com resposta ao impulso exponencial)
+    no WAV in-place. Qualquer falha aqui NUNCA derruba o job: loga e segue."""
     try:
-        _extract_zip(zip_file, name)
-        models = list_models()
-        return (
-            f"✅ Model **{name}** loaded successfully.",
-            gr.update(choices=models, value=name),
-            gr.update(value=[[m] for m in models]),
-        )
-    except Exception as exc:
-        logger.exception("Model upload failed")
-        return f"❌ Error: {exc}", gr.update(), gr.update()
+        import numpy as np
+        from scipy.signal import fftconvolve
+        sf = _ensure_soundfile()
+        audio, sr = sf.read(wav_path, always_2d=True)
+        if audio.shape[0] < sr // 4:
+            append_log(job_id, "[Reverb] Audio muito curto, pulando.")
+            return wav_path
+
+        room = float(np.clip(room, 0.0, 1.0))
+        damp = float(np.clip(damp, 0.0, 1.0))
+        wet = float(np.clip(wet, 0.0, 1.0))
+
+        decay_time = 0.05 + room * 0.95          # 0.05s .. 1.0s
+        n_ir = max(16, int(sr * decay_time))
+        t = np.arange(n_ir, dtype=np.float32) / sr
+        ir = np.exp(-6.0 * t / max(decay_time, 1e-3)).astype(np.float32)
+
+        if damp > 0.01:  # suaviza a cauda (absorcao das altas frequencias)
+            k = max(2, int(1 + damp * 12))
+            kernel = np.ones(k, dtype=np.float32) / k
+            for _ in range(2):
+                ir = np.convolve(ir, kernel, mode="same")
+        ir *= np.random.default_rng(0).standard_normal(n_ir).astype(np.float32) * 0.5 + 0.5
+        ir = ir / (np.sqrt(np.sum(ir ** 2)) + 1e-8)
+
+        wet_sig = np.zeros_like(audio)
+        for ch in range(audio.shape[1]):
+            wet_sig[:, ch] = fftconvolve(audio[:, ch], ir, mode="full")[:audio.shape[0]]
+
+        mixed = (1.0 - wet) * audio + wet * wet_sig
+        peak = np.max(np.abs(mixed)) + 1e-8
+        if peak > 0.95:
+            mixed = mixed / peak * 0.95
+        sf.write(wav_path, mixed, sr, format="WAV", subtype="PCM_16")
+        append_log(job_id, f"[Reverb] Aplicado (room={room}, damp={damp}, wet={wet})")
+        return wav_path
+    except Exception as e:
+        append_log(job_id, f"[Reverb] Falhou (ignorado, sem reverb): {e}")
+        logger.warning("[Reverb] falhou: %s", e)
+        return wav_path
+
+
+def mix_vocal_instrumental(vocal_path: str, inst_path: str, output_path: str, job_id: str):
+    append_log(job_id, "Mixando vocal + instrumental...")
+    librosa = _ensure_librosa()
+    import numpy as np
+    v, sr_v = librosa.load(vocal_path, sr=SR_TARGET, mono=True)
+    i, sr_i = librosa.load(inst_path, sr=SR_TARGET, mono=True)
+    min_len = min(len(v), len(i))
+    v = v[:min_len]
+    i = i[:min_len]
+    mixed = v * 0.85 + i * 1.0
+    mixed = mixed / (np.max(np.abs(mixed)) + 1e-8) * 0.95
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    safe_write_wav(output_path, mixed, SR_TARGET)
+    append_log(job_id, f"Mix final: {output_path}")
+    return output_path
+
+
+# =============================================================================
+# FORMAT CONVERSION — CONVERTE WAV PARA O FORMATO ESCOLHIDO
+# =============================================================================
+def get_format_ext(fmt: str) -> str:
+    mapping = {"WAV": ".wav", "FLAC": ".flac", "MP3": ".mp3", "OPUS": ".opus"}
+    return mapping.get(str(fmt).upper(), ".wav")
+
+
+def get_zip_path(job_dir: Path, job_id: str, fmt: str) -> Path:
+    """Nome do ZIP SEMPRE deterministico — usado na criacao (process_job)
+    e na busca (load_downloads)."""
+    return job_dir / f"rvc_{job_id}_all_{str(fmt).upper()}.zip"
+
+
+def convert_audio_format(input_wav: str, output_path: str, fmt: str, job_id: str):
+    """Converte um arquivo WAV para o formato escolhido (WAV/FLAC/MP3/OPUS)."""
+    fmt = str(fmt).upper()
+    append_log(job_id, f"[Format] Convertendo para {fmt}: {output_path}")
+
+    if not os.path.exists(input_wav):
+        raise FileNotFoundError(f"Arquivo de entrada nao encontrado: {input_wav}")
+
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+    tmp_leftover = output_path + ".tmp_convert.wav"
+    if os.path.exists(tmp_leftover):
+        try:
+            os.remove(tmp_leftover)
+        except Exception:
+            pass
+
+    if os.path.abspath(input_wav) == os.path.abspath(output_path):
+        if fmt == "WAV":
+            append_log(job_id, f"[Format] Ja esta em WAV no caminho correto: {output_path}")
+            return output_path
+        shutil.copy2(input_wav, tmp_leftover)
+        input_wav = tmp_leftover
+        append_log(job_id, f"[Format] Criado temporario para evitar sobrescrita: {tmp_leftover}")
+
+    try:
+        if fmt == "WAV":
+            shutil.copy2(input_wav, output_path)
+        elif fmt == "FLAC":
+            cmd = ["ffmpeg", "-y", "-i", input_wav, "-acodec", "flac", "-compression_level", "5", output_path]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                raise RuntimeError(f"FFmpeg FLAC falhou: {result.stderr[:300]}")
+        elif fmt == "MP3":
+            cmd = ["ffmpeg", "-y", "-i", input_wav, "-acodec", "libmp3lame", "-q:a", "2", output_path]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                raise RuntimeError(f"FFmpeg MP3 falhou: {result.stderr[:300]}")
+        elif fmt == "OPUS":
+            cmd = ["ffmpeg", "-y", "-i", input_wav, "-acodec", "libopus", "-b:a", "128k", output_path]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                raise RuntimeError(f"FFmpeg OPUS falhou: {result.stderr[:300]}")
+        else:
+            raise ValueError(f"Formato nao suportado: {fmt}")
+    finally:
+        if os.path.exists(tmp_leftover):
+            try:
+                os.remove(tmp_leftover)
+            except Exception:
+                pass
 
+    if not os.path.exists(output_path) or os.path.getsize(output_path) < 1024:
+        raise RuntimeError(f"Arquivo convertido nao foi criado ou esta vazio: {output_path}")
 
-# ── Refresh handler ───────────────────────────────────────────────────────────
-def refresh_models():
-    import gradio as gr
-    models = list_models()
-    return gr.update(value=[[m] for m in models]), gr.update(choices=models)
+    append_log(job_id, f"[Format] OK: {output_path} ({os.path.getsize(output_path) // 1024}KB)")
+    return output_path
 
 
-# ── Autotune visibility toggle ────────────────────────────────────────────────
-def toggle_autotune(enabled):
-    import gradio as gr
-    return gr.update(visible=enabled)
+# =============================================================================
+# RVC INFERENCE — ultimate-rvc (SEM erro de HuBERT: a lib cuida de tudo)
+# =============================================================================
+_vc_instance = None
+_vc_lock = threading.Lock()
 
 
-# ── ffmpeg is pre-installed on HuggingFace Spaces ────────────────────────────
-def _ffmpeg_bin() -> str:
-    return "ffmpeg"
+def _get_vc():
+    global _vc_instance
+    if _vc_instance is None:
+        with _vc_lock:
+            if _vc_instance is None:
+                logger.info("[VC] Carregando VoiceConverter...")
+                VoiceConverter = _ensure_ultimate_rvc()
+                _vc_instance = VoiceConverter()
+                logger.info("[VC] VoiceConverter pronto.")
+    return _vc_instance
 
 
-# ── Reverb effect via pedalboard ─────────────────────────────────────────────
-def _apply_reverb(audio_path: str, room_size: float, damping: float, wet_level: float) -> None:
-    """Apply reverb in-place to a WAV file using pedalboard."""
-    try:
-        from pedalboard import Pedalboard, Reverb
-        from pedalboard.io import AudioFile
-        import tempfile, shutil
-
-        tmp = audio_path + ".reverb.tmp.wav"
-        board = Pedalboard([
-            Reverb(
-                room_size=room_size,
-                damping=damping,
-                wet_level=wet_level,
-                dry_level=1.0 - wet_level,
-                width=1.0,
-            )
-        ])
-        with AudioFile(audio_path) as f:
-            with AudioFile(tmp, "w", f.samplerate, f.num_channels) as out:
-                while f.tell() < f.frames:
-                    chunk = f.read(f.samplerate)
-                    out.write(board(chunk, f.samplerate, reset=False))
-        shutil.move(tmp, audio_path)
-        logger.info("Reverb applied (room=%.2f, damp=%.2f, wet=%.2f)", room_size, damping, wet_level)
-    except Exception as exc:
-        logger.warning("Reverb failed: %s", exc)
-
-
-# ── Upload to temp.sh ────────────────────────────────────────────────────────
-def _upload_to_tempsh(file_path: str) -> str | None:
-    """Upload a file to temp.sh and return the download URL, or None on failure."""
+def _pth_and_index(model_name: str) -> tuple[str, str]:
+    d = MODELS_DIR / model_name
+    pths = list(d.glob("*.pth"))
+    idxs = list(d.glob("*.index"))
+    if not pths:
+        raise FileNotFoundError(f"Nenhum .pth encontrado em '{model_name}'")
+    return str(pths[0]), str(idxs[0]) if idxs else ""
+
+
+def rvc_infer_ultimate(
+    model_name: str,
+    input_audio_path: str,
+    pitch: int,
+    f0_method: str,
+    output_path: str,
+    job_id: str,
+    index_rate: float = 0.75,
+    protect: float = 0.5,
+    filter_radius: int = 3,
+    volume_envelope: float = 0.25,
+    clean_audio: bool = False,
+    clean_strength: float = 0.5,
+    split_audio: bool = False,
+    autotune: bool = False,
+    autotune_strength: float = 1.0,
+):
+    append_log(job_id, f"[VC] Iniciando conversao com modelo: {model_name}")
+    model_path, index_path = _pth_and_index(model_name)
+    append_log(job_id, f"[VC] Modelo: {model_path}")
+    append_log(job_id, f"[VC] Index: {index_path or 'N/A'}")
+    vc = _get_vc()
+    append_log(job_id, f"[VC] Params: pitch={pitch}, f0={f0_method}, index_rate={index_rate}, protect={protect}")
     try:
-        import subprocess
-        result = subprocess.run(
-            ["curl", "-s", "-F", f"file=@{file_path}", "https://temp.sh/upload"],
-            capture_output=True,
-            text=True,
-            timeout=120,
+        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+        vc.convert_audio(
+            audio_input_path=input_audio_path,
+            audio_output_path=output_path,
+            model_path=model_path,
+            index_path=index_path,
+            pitch=pitch,
+            f0_method=f0_method,
+            index_rate=index_rate,
+            volume_envelope=volume_envelope,
+            protect=protect,
+            split_audio=split_audio,
+            f0_autotune=autotune,
+            f0_autotune_strength=autotune_strength,
+            clean_audio=clean_audio,
+            clean_strength=clean_strength,
+            export_format="WAV",
+            filter_radius=filter_radius,
         )
-        url = result.stdout.strip()
-        if url.startswith("https://"):
-            logger.info("Uploaded to temp.sh: %s", url)
-            return url
-        else:
-            logger.warning("temp.sh upload failed: %s", result.stdout or result.stderr)
-            return None
-    except Exception as exc:
-        logger.warning("temp.sh upload error: %s", exc)
-        return None
+        append_log(job_id, f"[VC] Conversao concluida: {output_path}")
+        return output_path
+    except Exception as e:
+        append_log(job_id, f"[VC] ERRO na conversao: {e}")
+        traceback.print_exc()
+        raise
 
 
-# ── Background job queue ─────────────────────────────────────────────────────
+# =============================================================================
+# WORKER — fila por queue, converte tudo para o formato escolhido
+# =============================================================================
 _job_queue: queue.Queue = queue.Queue()
 
-# Job status store: job_id -> {"status": str, "url": str|None, "model": str}
-_jobs: dict[str, dict] = {}
-_jobs_lock = threading.Lock()
-
 
-def _worker() -> None:
-    """Single background worker — processes one job at a time from the queue."""
-    while True:
-        job = _job_queue.get()
-        job_id  = job["id"]
-        try:
-            _start_time = time.time()
-            with _jobs_lock:
-                _jobs[job_id]["status"] = "⏳ Converting…"
-
-            logger.info("[Job %s] Starting conversion (model: %s)", job_id, job["model_name"])
-
-            model_path, index_path = _pth_and_index(job["model_name"])
-            _cleanup_old_outputs()
-
-            is_opus = job["output_format"].upper() == "OPUS"
-            engine_format = "WAV" if is_opus else job["output_format"]
-            ts = int(time.time())
-            wav_path = OUTPUT_DIR / f"output-{ts}.wav"
-            out_path = OUTPUT_DIR / (
-                f"output-{ts}.opus" if is_opus
-                else f"output-{ts}.{job['output_format'].lower()}"
-            )
+def process_job(job_id: str):
+    jobs = load_jobs()
+    if job_id not in jobs:
+        return
+    job = jobs[job_id]
+    try:
+        update_job_status(job_id, STATUS_CONVERTING)
+        append_log(job_id, "=" * 50)
+        append_log(job_id, f"Job {job_id} | Modelo: {job['model']} | Pitch: {job['pitch']}")
+
+        job_output_dir = OUTPUTS_DIR / job_id
+        job_output_dir.mkdir(parents=True, exist_ok=True)
+
+        model_dir = MODELS_DIR / job["model"]
+        if not model_dir.exists():
+            raise FileNotFoundError(f"Modelo '{job['model']}' nao encontrado")
+        if not list(model_dir.glob("*.pth")):
+            raise FileNotFoundError(f"Nenhum .pth em '{job['model']}'")
+
+        input_file = job.get("input_file")
+        if not input_file or not os.path.exists(input_file):
+            raise FileNotFoundError(f"Arquivo de entrada nao encontrado: {input_file}")
+
+        entrada_wav = str(job_output_dir / "entrada.wav")
+        ensure_wav(input_file, entrada_wav)
+        append_log(job_id, "Entrada WAV 48kHz OK")
+
+        # FIX: checagem de duracao DEPOIS do ffmpeg (WAV garantido) e sem
+        # engolir o ValueError — o bug antigo silenciava o limite.
+        duration = get_audio_duration(entrada_wav)
+        append_log(job_id, f"Duracao: {duration:.1f}s")
+        if duration > MAX_INPUT_DURATION:
+            raise ValueError(f"Audio muito longo: {duration:.0f}s (max: {MAX_INPUT_DURATION // 60} min)")
+
+        append_log(job_id, "Separando com Demucs...")
+        entrada_acapella, entrada_instrumental = separate_audio_demucs(entrada_wav, str(job_output_dir), job_id)
+        append_log(job_id, "Separacao OK")
+
+        saida_acapella_wav = str(job_output_dir / "saida_acapella.wav")
+        settings = job.get("settings", {})
+        output_fmt = settings.get("format", "WAV")
+        ext = get_format_ext(output_fmt)
+
+        rvc_infer_ultimate(
+            model_name=job["model"],
+            input_audio_path=entrada_acapella,
+            pitch=job["pitch"],
+            f0_method=job["f0_method"],
+            output_path=saida_acapella_wav,
+            job_id=job_id,
+            protect=settings.get("protect", 0.5),
+            index_rate=settings.get("index_rate", 0.75),
+            filter_radius=settings.get("filter_radius", 3),
+            volume_envelope=settings.get("vol_env", 0.25),
+            clean_audio=settings.get("clean", False),
+            clean_strength=settings.get("clean_strength", 0.5),
+            split_audio=settings.get("split", False),
+            autotune=settings.get("autotune", False),
+            autotune_strength=settings.get("autotune_strength", 1.0),
+        )
 
-            vc = _get_vc()
-            vc.convert_audio(
-                audio_input_path=job["audio_input"],
-                audio_output_path=str(wav_path),
-                model_path=model_path,
-                index_path=index_path,
-                pitch=job["pitch"],
-                f0_method=job["f0_method"],
-                index_rate=job["index_rate"],
-                volume_envelope=job["volume_envelope"],
-                protect=job["protect"],
-                split_audio=job["split_audio"],
-                f0_autotune=job["autotune"],
-                f0_autotune_strength=job["autotune_strength"],
-                clean_audio=job["clean_audio"],
-                clean_strength=job["clean_strength"],
-                export_format=engine_format,
-                filter_radius=job["filter_radius"],
+        # Reverb aplicado de verdade na voz convertida (antes do mix)
+        if settings.get("reverb", False):
+            apply_reverb_wav(
+                saida_acapella_wav,
+                room=settings.get("reverb_room", 0.15),
+                damp=settings.get("reverb_damp", 0.7),
+                wet=settings.get("reverb_wet", 0.15),
+                job_id=job_id,
             )
 
-            if is_opus:
-                import subprocess
-                subprocess.run(
-                    [
-                        _ffmpeg_bin(), "-y",
-                        "-i", str(wav_path),
-                        "-c:a", "libopus",
-                        "-b:a", "64000",
-                        "-vbr", "off",
-                        "-ar", "48000",
-                        str(out_path),
-                    ],
-                    check=True, capture_output=True,
-                )
-                wav_path.unlink(missing_ok=True)
-
-            # Apply reverb if enabled (operates on the final output file)
-            if job.get("reverb"):
-                _apply_reverb(
-                    str(out_path),
-                    room_size=job.get("reverb_room_size", 0.15),
-                    damping=job.get("reverb_damping", 0.7),
-                    wet_level=job.get("reverb_wet_level", 0.15),
-                )
-
-            # Upload to temp.sh
-            temp_url = _upload_to_tempsh(str(out_path))
-
-            _elapsed = time.time() - _start_time
-            _elapsed_str = f"{_elapsed:.0f}s" if _elapsed < 60 else f"{_elapsed/60:.1f}m"
-            with _jobs_lock:
-                _jobs[job_id]["elapsed"] = _elapsed_str
-                if temp_url:
-                    _jobs[job_id]["status"] = "✅ Done"
-                    _jobs[job_id]["url"]    = temp_url
-                    _jobs[job_id]["file"]   = str(out_path)
-                    logger.info("[Job %s] Complete in %s → %s", job_id, _elapsed_str, temp_url)
-                else:
-                    _jobs[job_id]["status"] = "✅ Done"
-                    _jobs[job_id]["file"]   = str(out_path)
-                    logger.info("[Job %s] Complete in %s (no temp.sh URL)", job_id, _elapsed_str)
-
-        except Exception as exc:
-            _elapsed = time.time() - _start_time if "_start_time" in dir() else 0
-            _elapsed_str = f"{_elapsed:.0f}s" if _elapsed < 60 else f"{_elapsed/60:.1f}m"
-            logger.exception("[Job %s] Failed after %s: %s", job_id, _elapsed_str, exc)
-            with _jobs_lock:
-                _jobs[job_id]["status"]  = f"❌ Failed"
-                _jobs[job_id]["elapsed"] = _elapsed_str
-                _jobs[job_id]["file"]    = None
+        saida_final_wav = str(job_output_dir / "saida.wav")
+        mix_vocal_instrumental(saida_acapella_wav, entrada_instrumental, saida_final_wav, job_id)
+
+        append_log(job_id, f"[Format] Convertendo 5 arquivos para {output_fmt}...")
+        internal_files = {
+            "entrada": entrada_wav,
+            "entrada_acapella": entrada_acapella,
+            "entrada_instrumental": entrada_instrumental,
+            "saida_acapella": saida_acapella_wav,
+            "saida": saida_final_wav,
+        }
+
+        outputs = {}
+        for label, src_path in internal_files.items():
+            dst_path = str(job_output_dir / f"{label}{ext}")
+            append_log(job_id, f"[Format] {label}: {src_path} -> {dst_path}")
+            outputs[label] = convert_audio_format(src_path, dst_path, output_fmt, job_id)
+
+        append_log(job_id, f"[Format] 5 arquivos processados para {output_fmt}")
+
+        for k, v in outputs.items():
+            if not os.path.exists(v) or os.path.getsize(v) < 1024:
+                raise RuntimeError(f"Output invalido: {k} -> {v}")
+
+        zip_path = get_zip_path(job_output_dir, job_id, output_fmt)
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for k, v in outputs.items():
+                if os.path.exists(v):
+                    zf.write(v, arcname=os.path.basename(v))
+        append_log(job_id, f"ZIP criado: {zip_path}")
+
+        update_job_status(job_id, STATUS_DONE, outputs=outputs)
+        append_log(job_id, "Conversao concluida!")
+
+    except Exception as e:
+        error_msg = str(e)
+        tb = traceback.format_exc()
+        append_log(job_id, f"ERRO: {error_msg}")
+        append_log(job_id, f"Traceback: {tb}")
+        update_job_status(job_id, STATUS_FAILED, error=error_msg)
+    finally:
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+
+
+def _worker_loop() -> None:
+    while True:
+        job_id = None
+        try:
+            job_id = _job_queue.get()
+            if job_id is None:
+                break
+            process_job(job_id)
+        except Exception as e:
+            logger.error("Worker error: %s", e)
+            traceback.print_exc()
         finally:
-            _job_queue.task_done()
+            if job_id is not None:
+                try:
+                    _job_queue.task_done()
+                except ValueError:
+                    pass
 
 
-# Start the single background worker thread
-_worker_thread = threading.Thread(target=_worker, daemon=True)
+_worker_thread = threading.Thread(target=_worker_loop, daemon=True)
 _worker_thread.start()
 logger.info("Background worker started.")
 
 
-# ── Conversion ────────────────────────────────────────────────────────────────
-def convert(
-    audio_mic, audio_file, model_name,
-    pitch, f0_method,
-    index_rate, protect, volume_envelope,
-    clean_audio, clean_strength,
-    split_audio, autotune, autotune_strength,
-    filter_radius,
-    output_format,
-    reverb=False,
-    reverb_room_size=0.15,
-    reverb_damping=0.7,
-    reverb_wet_level=0.15,
-):
-    """Submit a job to the background worker and return immediately."""
-    audio_input = audio_mic or audio_file
-    if audio_input is None:
-        return "⚠️ Please record or upload audio first.", None
-    if not model_name:
-        return "⚠️ No model selected.", None
-
-    # Check input duration upfront before queuing
+# =============================================================================
+# MODELS UI
+# =============================================================================
+def validate_zip(zip_path: str) -> tuple[bool, str]:
     try:
-        import soundfile as sf
-        info = sf.info(audio_input)
-        duration = info.duration
-        if duration > MAX_INPUT_DURATION:
-            return (
-                f"⚠️ Audio is {duration:.0f}s — max is {MAX_INPUT_DURATION//60} min. "
-                f"Please trim your audio.", None
-            )
-        logger.info("Input duration: %.1fs", duration)
-    except Exception:
-        pass
-
-    # Validate model exists before queuing
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            files = zf.namelist()
+            has_pth = any(f.endswith(".pth") for f in files)
+            if not has_pth:
+                return False, "Falta .pth no ZIP"
+            return True, "ZIP valido"
+    except Exception as e:
+        return False, f"Erro no ZIP: {str(e)}"
+
+
+def is_valid_rvc_checkpoint(ckpt) -> bool:
+    if not isinstance(ckpt, dict):
+        return False
+    for key, val in ckpt.items():
+        if isinstance(val, torch.Tensor):
+            return True
+        elif isinstance(val, dict):
+            for k2, v2 in val.items():
+                if isinstance(v2, torch.Tensor):
+                    return True
+    return len(ckpt) > 0
+
+
+def upload_model(zip_file, model_name: str):
+    import gradio as gr
+    if not zip_file:
+        return "❌ Nenhum arquivo selecionado", gr.update(choices=get_model_names()), refresh_models()
+    if not model_name or not model_name.strip():
+        model_name = Path(str(zip_file)).stem
+    model_name = model_name.strip()
+    valid, msg = validate_zip(zip_file)
+    if not valid:
+        return f"❌ {msg}", gr.update(choices=get_model_names()), refresh_models()
+    model_dir = MODELS_DIR / model_name
+    if model_dir.exists():
+        shutil.rmtree(model_dir)
+    model_dir.mkdir(parents=True, exist_ok=True)
     try:
-        _pth_and_index(model_name)
-    except FileNotFoundError as exc:
-        return f"❌ {exc}", None
-
-    job_id = uuid.uuid4().hex[:8]
-    job = {
-        "id":               job_id,
-        "audio_input":      audio_input,
-        "model_name":       model_name,
-        "pitch":            pitch,
-        "f0_method":        f0_method,
-        "index_rate":       index_rate,
-        "volume_envelope":  volume_envelope,
-        "protect":          protect,
-        "split_audio":      split_audio,
-        "autotune":         autotune,
-        "autotune_strength": autotune_strength,
-        "clean_audio":      clean_audio,
-        "clean_strength":   clean_strength,
-        "filter_radius":    filter_radius,
-        "output_format":    output_format,
-        "reverb":           reverb,
-        "reverb_room_size": reverb_room_size,
-        "reverb_damping":   reverb_damping,
-        "reverb_wet_level": reverb_wet_level,
-    }
+        with zipfile.ZipFile(zip_file, "r") as zf:
+            zf.extractall(str(model_dir))
+        for nested in list(model_dir.rglob("*.pth")) + list(model_dir.rglob("*.index")):
+            target = model_dir / nested.name
+            if nested != target:
+                shutil.move(str(nested), str(target))
+    except Exception as e:
+        return f"❌ Erro ao extrair: {str(e)}", gr.update(choices=get_model_names()), refresh_models()
+    try:
+        pth_files = list(model_dir.glob("*.pth"))
+        if pth_files:
+            ckpt = torch.load(str(pth_files[0]), map_location="cpu", weights_only=False)
+            if not is_valid_rvc_checkpoint(ckpt):
+                shutil.rmtree(model_dir)
+                return "❌ Checkpoint invalido (nao eh RVC)", gr.update(choices=get_model_names()), refresh_models()
+    except Exception as e:
+        shutil.rmtree(model_dir)
+        return f"❌ Erro no checkpoint: {str(e)}", gr.update(choices=get_model_names()), refresh_models()
+    choices = get_model_names()
+    return f"✅ Modelo '{model_name}' enviado!", gr.update(choices=choices), refresh_models()
 
-    with _jobs_lock:
-        if len(_jobs) >= MAX_JOBS:
-            oldest = next(iter(_jobs))
-            del _jobs[oldest]
-            logger.info("Removed oldest job %s (limit: %d)", oldest, MAX_JOBS)
-        _jobs[job_id] = {"status": "🕐 Queued…", "url": None, "file": None, "model": model_name}
 
-    _job_queue.put(job)
-    queue_size = _job_queue.qsize()
+def refresh_models():
+    models = []
+    if MODELS_DIR.exists():
+        for d in sorted(MODELS_DIR.iterdir()):
+            if d.is_dir() and d.name != URVC_DIR.name:
+                pth = len(list(d.glob("*.pth")))
+                idx = len(list(d.glob("*.index")))
+                models.append([d.name, pth, idx, datetime.fromtimestamp(d.stat().st_ctime).strftime("%Y-%m-%d %H:%M")])
+    return models
+
+
+def get_model_names():
+    models = []
+    if MODELS_DIR.exists():
+        for d in sorted(MODELS_DIR.iterdir()):
+            if d.is_dir() and d.name != URVC_DIR.name and list(d.glob("*.pth")):
+                models.append(d.name)
+    return models
+
+
+def delete_model(model_name: str):
+    import gradio as gr
+    if not model_name or not model_name.strip():
+        return "❌ Digite o nome do modelo", gr.update(choices=get_model_names()), refresh_models()
+    model_dir = MODELS_DIR / model_name.strip()
+    if not model_dir.exists():
+        return "❌ Modelo nao encontrado", gr.update(choices=get_model_names()), refresh_models()
+    shutil.rmtree(model_dir)
+    choices = get_model_names()
+    return "✅ Modelo excluido", gr.update(choices=choices), refresh_models()
 
-    logger.info("[Job %s] Queued (model: %s, queue depth: %d)", job_id, model_name, queue_size)
 
-    msg = (
-        "🕐 Job **" + job_id + "** queued — you can close this tab.\n\n"
-        "Check the **📋 Jobs** tab for your download link when done.\n\n"
-        "_(Queue position: " + str(queue_size) + ")_"
-    )
-    return msg, None
+def toggle_autotune(v):
+    import gradio as gr
+    return gr.update(visible=v)
 
 
-def poll_job(job_id: str) -> tuple[str, str | None]:
-    """Check status of a submitted job. Returns (status_msg, file_path_or_None)."""
-    with _jobs_lock:
-        job = _jobs.get(job_id)
-    if not job:
-        return f"❌ Job {job_id} not found.", None
-    status = job["status"]
-    url    = job.get("url")
-    file   = job.get("file")
-    if url:
-        return f"{status}  ·  🔗 [Download link]({url})  ·  _(expires in 3 days)_", file
-    return status, file
+def _refresh_models_ui():
+    import gradio as gr
+    return refresh_models(), gr.update(choices=get_model_names())
+
+
+# =============================================================================
+# JOBS UI
+# =============================================================================
+def submit_job(mic_file, upload_file, video_file, model_name: str, pitch: int, f0_method: str,
+               index_rate: float, protect: float, filter_radius: int,
+               vol_env: float, clean: bool, clean_strength: float,
+               split: bool, autotune: bool, autotune_strength: float,
+               fmt_radio: str,
+               reverb: bool, reverb_room: float, reverb_damp: float, reverb_wet: float):
+    import numpy as np
+    if not model_name:
+        return "❌ Escolha um modelo RVC", None
+
+    input_file = None
+    input_source = None
+    if mic_file is not None:
+        input_file = mic_file
+        input_source = "mic"
+    elif upload_file is not None:
+        input_file = upload_file
+        input_source = "upload"
+    elif video_file is not None:
+        input_file = video_file
+        input_source = "video"
+
+    if not input_file:
+        return "❌ Forneca um audio ou video", None
+
+    model_dir = MODELS_DIR / model_name
+    if not model_dir.exists():
+        return "❌ Modelo nao encontrado", None
+
+    job_id = f"rvc_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{np.random.randint(1000, 9999)}"
+    job_input_dir = JOBS_DIR / job_id
+    job_input_dir.mkdir(parents=True, exist_ok=True)
+    input_path = str(input_file)
+    if not os.path.exists(input_path):
+        return "❌ Arquivo nao encontrado", None
+
+    input_ext = os.path.splitext(input_path)[1] or ".wav"
+    saved_input = str(job_input_dir / f"input{input_ext}")
 
+    try:
+        if input_source == "video":
+            audio_wav = str(job_input_dir / "input_audio.wav")
+            extract_audio_from_video(input_path, audio_wav)
+            saved_input = audio_wav
+        else:
+            shutil.copy2(input_path, saved_input)
+    except Exception as e:
+        return f"❌ Erro ao processar: {str(e)}", None
+
+    settings = {
+        "index_rate": index_rate, "protect": protect, "filter_radius": filter_radius,
+        "vol_env": vol_env, "clean": clean, "clean_strength": clean_strength,
+        "split": split, "autotune": autotune, "autotune_strength": autotune_strength,
+        "reverb": reverb, "reverb_room": reverb_room, "reverb_damp": reverb_damp, "reverb_wet": reverb_wet,
+        "format": fmt_radio,
+    }
+    create_job(job_id, model_name, pitch, f0_method, saved_input, settings)
+    append_log(job_id, f"Job criado. Entrada: {saved_input} ({os.path.getsize(saved_input)} bytes) | Formato: {fmt_radio}")
+    _job_queue.put(job_id)
+    return f"✅ Job **{job_id}** criado! Acompanhe na aba 📋 Jobs.", None
+
+
+def delete_job(job_id: str):
+    if not job_id or not job_id.strip():
+        return "❌ Digite o ID", get_jobs_table()
+    job_id = job_id.strip()
+    jobs = load_jobs()
+    if job_id not in jobs:
+        return "❌ Job nao encontrado", get_jobs_table()
+    for d in [JOBS_DIR / job_id, OUTPUTS_DIR / job_id]:
+        if d.exists():
+            shutil.rmtree(d)
+    log_file = Path(jobs[job_id]["log_file"])
+    if log_file.exists():
+        log_file.unlink()
+    del jobs[job_id]
+    save_jobs(jobs)
+    return "✅ Job excluido", get_jobs_table()
+
+
+def view_logs(job_id: str):
+    if not job_id or not job_id.strip():
+        return "Digite um Job ID"
+    job_id = job_id.strip()
+    jobs = load_jobs()
+    if job_id not in jobs:
+        return "Job nao encontrado"
+    log_file = Path(jobs[job_id]["log_file"])
+    if not log_file.exists():
+        return "Nenhum log ainda"
+    with open(log_file, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# =============================================================================
+# DOWNLOADS UI — robusto: revalida disco, gera formato sob demanda,
+# reconstrói ZIP, e suporta "reparo" de jobs falhos com arquivos parciais.
+# FIX PRINCIPAL: os caminhos servidos ao Gradio ficam sob BASE_DIR, que e
+# liberado via gr.set_static_paths + allowed_paths no launch (fim do arquivo).
+# =============================================================================
+def get_done_jobs():
+    jobs = load_jobs()
+    done = []
+    for job_id, job in sorted(jobs.items(), key=lambda x: x[1].get("created_at", ""), reverse=True):
+        if job["status"] == STATUS_DONE:
+            done.append(job_id)
+            continue
+        if job["status"] == STATUS_FAILED:
+            job_dir = OUTPUTS_DIR / job_id
+            if job_dir.exists() and ((job_dir / "saida.wav").exists() or (job_dir / "saida_acapella.wav").exists()):
+                done.append(f"{job_id} (reparo)")
+    return done
+
+
+def load_downloads(job_id):
+    """Retorna 7 valores: 5x audio_path, zip_path, status_msg."""
+    EMPTY = None
 
-# ── Startup ───────────────────────────────────────────────────────────────────
-_startup_status = ""
-_default_model = ""
-try:
-    _default_model = _startup_downloads()
-    _startup_status = f"✅ Ready &nbsp;·&nbsp; {DEVICE_LABEL}"
-except Exception as _e:
-    _startup_status = f"⚠️ Some assets unavailable: {_e} &nbsp;·&nbsp; {DEVICE_LABEL}"
-    logger.warning("Startup download issue: %s", _e)
-
-_initial_models = list_models()
-_initial_value = _default_model if _default_model in _initial_models else (
-    _initial_models[0] if _initial_models else None
-)
+    try:
+        if job_id is None or str(job_id).strip() == "":
+            return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, "Selecione um job no dropdown e clique em Carregar"
 
+        if isinstance(job_id, (list, tuple)) and len(job_id) > 0:
+            job_id = job_id[0]
 
-# ── Log helpers ───────────────────────────────────────────────────────────────
+        job_id = str(job_id).strip().replace(" (reparo)", "").strip()
+        if not job_id:
+            return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, "Selecione um job no dropdown e clique em Carregar"
 
+        jobs = load_jobs()
 
-def get_jobs_table() -> list[list]:
-    """Return job list as rows: [ID, Model, Status, Time, Download Link]."""
-    with _jobs_lock:
-        jobs = list(_jobs.items())
-    if not jobs:
-        return [["—", "—", "No jobs yet", "—", "—"]]
-    rows = []
-    for job_id, info in reversed(jobs):
-        url = info.get("url")
-        link = f"[⬇️]({url})" if url else "—"
-        rows.append([
-            job_id,
-            info.get("model", ""),
-            info.get("status", ""),
-            info.get("elapsed", "—"),
-            link,
-        ])
-    return rows
+        if job_id not in jobs:
+            return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, f"Job '{job_id}' nao encontrado"
+
+        job = jobs[job_id]
+        job_dir = OUTPUTS_DIR / job_id
+        has_files = job_dir.exists() and (
+            (job_dir / "saida.wav").exists() or (job_dir / "saida_acapella.wav").exists()
+        )
+        if job.get("status") != STATUS_DONE and not has_files:
+            return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, f"Job nao concluido: {job.get('status', 'desconhecido')}"
+
+        if not job_dir.exists():
+            return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, f"Diretorio do job nao encontrado: {job_dir}"
+
+        fmt = job.get("settings", {}).get("format", "WAV")
+        ext = get_format_ext(fmt)
+
+        labels = ["entrada", "entrada_acapella", "entrada_instrumental", "saida_acapella", "saida"]
+        wav_fallbacks = {
+            "entrada": ["entrada.wav"],
+            "entrada_acapella": ["entrada_acapella.wav", "entrada_acapella_48k.wav"],
+            "entrada_instrumental": ["entrada_instrumental.wav", "entrada_instrumental_48k.wav"],
+            "saida_acapella": ["saida_acapella.wav"],
+            "saida": ["saida.wav"],
+        }
+
+        def _ok(p):
+            return bool(p) and os.path.exists(p) and os.path.getsize(p) > 1024
+
+        audio_outputs = []
+        missing = []
+        existing = []
+        found_paths = {}
+
+        for label in labels:
+            found = None
+            primary = str(job_dir / f"{label}{ext}")
+            fallbacks = [str(job_dir / w) for w in wav_fallbacks[label]]
+
+            # 1) arquivo ja no formato pedido
+            if _ok(primary):
+                found = primary
+
+            # 2) formato pedido ausente e nao eh WAV -> gerar sob demanda do WAV
+            if not found and fmt != "WAV":
+                for wav in fallbacks:
+                    if _ok(wav):
+                        try:
+                            append_log(job_id, f"[Downloads] Gerando {fmt} sob demanda para {label}...")
+                            found = convert_audio_format(wav, primary, fmt, job_id)
+                        except Exception as conv_e:
+                            logger.warning("[Downloads] Falha ao gerar %s para %s: %s", fmt, label, conv_e)
+                            found = wav
+                            append_log(job_id, f"[Downloads] Fallback para WAV em {label}: {conv_e}")
+                        break
+
+            # 3) fallback final para WAV (quando fmt==WAV, chega direto aqui)
+            if not found:
+                for cand in fallbacks:
+                    if _ok(cand):
+                        found = cand
+                        break
+
+            if found:
+                audio_outputs.append(found)
+                existing.append(f"{label} ({os.path.getsize(found) // 1024}KB)")
+                found_paths[label] = found
+            else:
+                audio_outputs.append(EMPTY)
+                missing.append(label)
+                logger.warning("[Downloads] Nenhum arquivo encontrado para %s", label)
+
+        zip_path = get_zip_path(job_dir, job_id, fmt)
+        zip_out = EMPTY
+        try:
+            needs_rebuild = True
+            if zip_path.exists() and zip_path.stat().st_size > 1024:
+                try:
+                    with zipfile.ZipFile(zip_path, "r") as zf:
+                        names_in_zip = set(zf.namelist())
+                    expected_names = {os.path.basename(p) for p in found_paths.values()}
+                    needs_rebuild = not expected_names.issubset(names_in_zip)
+                except Exception:
+                    needs_rebuild = True
+
+            if needs_rebuild and found_paths:
+                with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+                    for label, path in found_paths.items():
+                        zf.write(path, arcname=os.path.basename(path))
+                logger.info("[Downloads] ZIP (re)criado: %s", zip_path)
+
+            if zip_path.exists() and zip_path.stat().st_size > 1024:
+                zip_out = str(zip_path)
+        except Exception as e:
+            logger.warning("[Downloads] Erro ZIP: %s", e)
+
+        model_name = job.get("model", "?")
+        pitch = job.get("pitch", "?")
+
+        if missing:
+            status_msg = f"⚠️ {len(existing)}/5 arquivos OK | Faltando: {', '.join(missing)} | {model_name} | Pitch: {pitch} | Formato: {fmt}"
+        else:
+            size_mb = zip_path.stat().st_size / (1024 * 1024) if zip_out is not None else 0
+            status_msg = f"✅ 5 arquivos + ZIP ({size_mb:.1f} MB) | {model_name} | Pitch: {pitch} | Formato: {fmt}"
 
+        logger.info("[Downloads] Job %s: %s", job_id, status_msg)
+        return tuple(audio_outputs) + (zip_out, status_msg)
 
-def get_queue_info() -> str:
-    """Return a short queue status string."""
-    qs = _job_queue.qsize()
-    total = len(_jobs)
-    running = sum(1 for j in _jobs.values() if j.get("status", "").startswith("⏳"))
-    done    = sum(1 for j in _jobs.values() if j.get("status", "").startswith("✅"))
-    failed  = sum(1 for j in _jobs.values() if j.get("status", "").startswith("❌"))
-    return (
-        f"**Queue:** {qs} waiting  ·  "
-        f"**Running:** {running}  ·  "
-        f"**Done:** {done}  ·  "
-        f"**Failed:** {failed}  ·  "
-        f"**Total:** {total}"
-    )
+    except Exception as e:
+        logger.error("[Downloads] Erro inesperado: %s", e, exc_info=True)
+        return EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, f"❌ Erro interno: {str(e)}"
 
 
-# ── Gradio UI ─────────────────────────────────────────────────────────────────
+def refresh_downloads():
+    import gradio as gr
+    choices = get_done_jobs()
+    return gr.update(choices=choices, value=None)
+
+
+# =============================================================================
+# STARTUP
+# =============================================================================
+startup_status = ""
+_default_model = ""
+try:
+    if os.environ.get("RVC_SKIP_STARTUP_DOWNLOADS") == "1":
+        logger.info("RVC_SKIP_STARTUP_DOWNLOADS=1 — pulando downloads do startup.")
+        _default_model = BUILTIN_MODELS[0]["name"]
+    else:
+        _default_model = _startup_downloads()
+    startup_status = f"✅ Ready · {DEVICE_LABEL}"
+except Exception as e:
+    startup_status = f"⚠️ Startup issue: {e} · {DEVICE_LABEL}"
+    logger.warning("Startup: %s", e)
+
+initial_models = get_model_names()
+initial_value = _default_model if _default_model in initial_models else (initial_models[0] if initial_models else None)
+
+
+# =============================================================================
+# GRADIO UI
+# FIX DE DOWNLOADS: libera BASE_DIR para o servidor de arquivos do Gradio.
+# Sem isso, os players/botoes de download falham com erro de arquivo quando
+# o job esta pronto (o Gradio bloqueia caminhos fora do diretorio do app).
+# =============================================================================
 import gradio as gr
 
-_CSS = """
-#header { text-align: center; padding: 20px 0 8px; }
-#header h1 { font-size: 2rem; margin: 0; }
-#header p  { opacity: .65; margin: 4px 0 0; }
-#status    { text-align: center; font-size: .82rem; opacity: .7; margin-bottom: 8px; }
-footer { display: none !important; }
-"""
+gr.set_static_paths(paths=[str(BASE_DIR)])
 
-with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
+with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600), css=CSS) as demo:
 
     gr.HTML(f"""
-        <div id="header">
-            <h1>🎙️ RVC Voice Conversion</h1>
-            <p>Retrieval-Based Voice Conversion · record or upload · custom models · GPU/CPU auto</p>
-        </div>
-        <p id="status">{_startup_status}</p>
+    <div id="header">
+        <h1>🎙️ RVC Voice Conversion</h1>
+        <p>Retrieval-Based Voice Conversion · record or upload · custom models · GPU/CPU auto</p>
+    </div>
+    <p id="status">{startup_status}</p>
     """)
 
     with gr.Tabs():
 
         # ── TAB 1: Convert ────────────────────────────────────────────────────
-        with gr.Tab("🎤  Convert"):
+        with gr.Tab("🎤 Convert"):
             with gr.Row():
-
                 with gr.Column(scale=1):
-                    gr.Markdown("### 🔊 Input Audio")
+                    gr.Markdown("### 🔊 Input Audio / Video")
                     with gr.Tabs():
                         with gr.Tab("🎙️ Microphone"):
                             inp_mic = gr.Audio(
@@ -620,11 +1266,15 @@ with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
                                 type="filepath",
                                 label="Upload audio (wav / mp3 / flac / ogg …)",
                             )
+                        with gr.Tab("🎬 Upload Video"):
+                            inp_video = gr.Video(
+                                label="Upload video (mp4 / mov / avi / mkv …)",
+                            )
 
                     gr.Markdown("### 🤖 Model")
                     model_dd = gr.Dropdown(
-                        choices=_initial_models,
-                        value=_initial_value,
+                        choices=initial_models,
+                        value=initial_value,
                         label="Active Voice Model",
                         interactive=True,
                     )
@@ -672,71 +1322,71 @@ with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
                                 label="Reduction Strength",
                             )
                         with gr.Row():
-                            split_cb    = gr.Checkbox(value=False, label="Split Long Audio")
+                            split_cb = gr.Checkbox(value=False, label="Split Long Audio")
                             autotune_cb = gr.Checkbox(value=False, label="Autotune")
-                        autotune_sl = gr.Slider(
-                            0.0, 1.0, value=1.0, step=0.05,
-                            label="Autotune Strength",
-                            visible=False,
-                        )
-                        autotune_cb.change(
-                            fn=toggle_autotune,
-                            inputs=autotune_cb,
-                            outputs=autotune_sl,
-                        )
-
-                        gr.Markdown("**🎛️ Reverb**")
-                        reverb_cb = gr.Checkbox(value=False, label="Enable Reverb")
-                        with gr.Group(visible=False) as reverb_group:
-                            reverb_room_sl = gr.Slider(
-                                0.0, 1.0, value=0.15, step=0.05,
-                                label="Room Size",
-                                info="Larger = bigger sounding space",
+                            autotune_sl = gr.Slider(
+                                0.0, 1.0, value=1.0, step=0.05,
+                                label="Autotune Strength",
+                                visible=False,
                             )
-                            reverb_damp_sl = gr.Slider(
-                                0.0, 1.0, value=0.7, step=0.05,
-                                label="Damping",
-                                info="Higher = more absorption, less echo tail",
+                            autotune_cb.change(
+                                fn=toggle_autotune,
+                                inputs=autotune_cb,
+                                outputs=autotune_sl,
                             )
-                            reverb_wet_sl = gr.Slider(
-                                0.0, 1.0, value=0.15, step=0.05,
-                                label="Wet Level",
-                                info="How much reverb is mixed in (0.15 = subtle)",
-                            )
-                        reverb_cb.change(
-                            fn=lambda v: gr.update(visible=v),
-                            inputs=reverb_cb,
-                            outputs=reverb_group,
+
+                    gr.Markdown("**🎛️ Reverb**")
+                    reverb_cb = gr.Checkbox(value=False, label="Enable Reverb")
+                    with gr.Group(visible=False) as reverb_group:
+                        reverb_room_sl = gr.Slider(
+                            0.0, 1.0, value=0.15, step=0.05,
+                            label="Room Size",
+                            info="Larger = bigger sounding space",
+                        )
+                        reverb_damp_sl = gr.Slider(
+                            0.0, 1.0, value=0.7, step=0.05,
+                            label="Damping",
+                            info="Higher = more absorption, less echo tail",
                         )
+                        reverb_wet_sl = gr.Slider(
+                            0.0, 1.0, value=0.15, step=0.05,
+                            label="Wet Level",
+                            info="How much reverb is mixed in (0.15 = subtle)",
+                        )
+                    reverb_cb.change(
+                        fn=lambda v: gr.update(visible=v),
+                        inputs=reverb_cb,
+                        outputs=reverb_group,
+                    )
 
                     fmt_radio = gr.Radio(
-                        choices=["WAV", "MP3", "FLAC", "OPUS"],
+                        choices=["WAV", "FLAC", "MP3", "OPUS"],
                         value="WAV",
                         label="Output Format",
                         info="OPUS = small file (~64 kbps, Telegram/Discord quality)",
                     )
                     convert_btn = gr.Button(
-                        "🚀  Convert Voice",
+                        "🚀 Convert Voice",
                         variant="primary",
                     )
 
                     gr.Markdown("### 🎧 Output")
                     out_status = gr.Markdown(value="")
-                    out_audio  = gr.Audio(label="Result (if still on page)", type="filepath", interactive=False)
+                    out_audio = gr.Audio(label="Result (if still on page)", type="filepath", interactive=False)
 
                     gr.Markdown("#### 🔍 Check Job Status")
                     with gr.Row():
-                        job_id_box  = gr.Textbox(
+                        job_id_box = gr.Textbox(
                             label="Job ID",
-                            placeholder="e.g. a3f2b1c9",
+                            placeholder="e.g. rvc_20260709_195302_7848",
                             scale=3,
                         )
                         poll_btn = gr.Button("🔄 Check", scale=1)
                     poll_status = gr.Markdown(value="")
-                    poll_audio  = gr.Audio(label="Result", type="filepath", interactive=False)
+                    poll_audio = gr.Audio(label="Result", type="filepath", interactive=False)
 
         # ── TAB 2: Models ─────────────────────────────────────────────────────
-        with gr.Tab("📦  Models"):
+        with gr.Tab("📦 Models"):
             gr.Markdown("""
             ### Upload a Custom RVC Model
             Provide a **`.zip`** containing:
@@ -748,22 +1398,23 @@ with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
             """)
             with gr.Row():
                 with gr.Column(scale=1):
-                    up_zip    = gr.File(label="Model ZIP", file_types=[".zip"])
-                    up_name   = gr.Textbox(
+                    up_zip = gr.File(label="Model ZIP", file_types=[".zip"], type="filepath")
+                    up_name = gr.Textbox(
                         label="Model Name",
                         placeholder="Leave blank to use zip filename",
                     )
-                    up_btn    = gr.Button("📤  Load Model", variant="primary")
+                    up_btn = gr.Button("📤 Load Model", variant="primary")
                     up_status = gr.Textbox(label="Status", interactive=False, lines=2)
                 with gr.Column(scale=1):
                     gr.Markdown("### Loaded Models")
                     models_table = gr.Dataframe(
-                        col_count=(1, "fixed"),
-                        value=[[m] for m in _initial_models],
+                        headers=["Modelo", ".pth", ".index", "Data"],
+                        col_count=(4, "fixed"),
+                        value=refresh_models(),
                         interactive=False,
                         label="",
                     )
-                    refresh_btn = gr.Button("🔄  Refresh")
+                    refresh_btn = gr.Button("🔄 Refresh")
 
             up_btn.click(
                 fn=upload_model,
@@ -771,88 +1422,170 @@ with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
                 outputs=[up_status, model_dd, models_table],
             )
             refresh_btn.click(
-                fn=refresh_models,
+                fn=_refresh_models_ui,
                 outputs=[models_table, model_dd],
             )
 
+            gr.Markdown("### 🗑️ Delete Model")
+            with gr.Row():
+                del_model_name = gr.Textbox(label="Model Name", placeholder="Nome do modelo a excluir")
+                del_model_btn = gr.Button("🗑️ Delete", variant="stop")
+            del_model_status = gr.Textbox(label="Status", interactive=False)
+            del_model_btn.click(
+                fn=delete_model,
+                inputs=[del_model_name],
+                outputs=[del_model_status, model_dd, models_table],
+            )
+
         # ── TAB 3: Jobs ───────────────────────────────────────────────────────
         with gr.Tab("📋 Jobs"):
             gr.Markdown("All submitted jobs, newest first. Click **Refresh** to update.")
-            queue_status = gr.Markdown(value=get_queue_info, every=10)
+            queue_status = gr.Markdown(value=get_queue_info())
             jobs_table = gr.Dataframe(
-            headers=["Job ID", "Model", "Status", "Time", "Download"],
-            col_count=(5, "fixed"),
-            value=get_jobs_table,
-            interactive=False,
-            wrap=True,
-            datatype=["str", "str", "str", "str", "markdown"],
-            every=10,
-        )
-        refresh_jobs_btn = gr.Button("🔄 Refresh")
+                headers=["Job ID", "Model", "Status", "Time", "Download"],
+                col_count=(5, "fixed"),
+                value=get_jobs_table(),
+                interactive=False,
+                wrap=True,
+                datatype=["str", "str", "str", "str", "markdown"],
+            )
+            refresh_jobs_btn = gr.Button("🔄 Refresh")
+
+            def _refresh_jobs():
+                return get_queue_info(), get_jobs_table()
+
+            refresh_jobs_btn.click(fn=_refresh_jobs, outputs=[queue_status, jobs_table])
+
+            gr.Markdown("### 🔍 Manage Job")
+            with gr.Row():
+                with gr.Column():
+                    job_id_manage = gr.Textbox(label="Job ID", placeholder="ex: rvc_20260528_123456_7890")
+                with gr.Column():
+                    view_logs_btn = gr.Button("📄 Ver Logs")
+                    delete_job_btn = gr.Button("🗑️ Excluir Job", variant="stop")
+            logs_output = gr.Textbox(label="Logs", lines=20, interactive=False, max_lines=50)
+            job_action_status = gr.Textbox(label="Status", interactive=False)
+
+            view_logs_btn.click(fn=view_logs, inputs=job_id_manage, outputs=logs_output)
+            delete_job_btn.click(fn=delete_job, inputs=job_id_manage, outputs=[job_action_status, jobs_table])
+
+        # ── TAB 4: Downloads ──────────────────────────────────────────────────
+        with gr.Tab("📥 Downloads"):
+            gr.Markdown("### 🎵 Baixar os 5 arquivos no formato escolhido + ZIP")
+            gr.Markdown("**Instrução:** Selecione um job e clique em **Carregar** para ver os arquivos.")
 
-        def _refresh_jobs():
-            return get_queue_info(), get_jobs_table()
+            with gr.Row():
+                with gr.Column(scale=3):
+                    dl_job_dd = gr.Dropdown(
+                        choices=get_done_jobs(),
+                        value=None,
+                        label="Job Concluido",
+                        info="Apenas jobs com status ✅ Done",
+                        interactive=True,
+                        allow_custom_value=True,
+                    )
+                with gr.Column(scale=1):
+                    dl_refresh_btn = gr.Button("🔄 Atualizar Lista")
+                    dl_load_btn = gr.Button("📂 Carregar Job", variant="primary")
+
+            dl_status = gr.Markdown(value="Aguardando seleção...")
 
-        refresh_jobs_btn.click(fn=_refresh_jobs, outputs=[queue_status, jobs_table])
+            gr.Markdown("---")
+            gr.Markdown("### 🎧 Arquivos de Áudio")
 
-        # ── TAB 4: Help ───────────────────────────────────────────────────────
-        with gr.Tab("ℹ️  Help"):
+            with gr.Row():
+                dl_wav1 = gr.Audio(label="🎵 Voz original com música", type="filepath", interactive=False)
+                dl_wav2 = gr.Audio(label="🎤 Voz original isolada", type="filepath", interactive=False)
+
+            with gr.Row():
+                dl_wav3 = gr.Audio(label="🎸 Instrumental original", type="filepath", interactive=False)
+                dl_wav4 = gr.Audio(label="🎙️ RVC cantando acapella", type="filepath", interactive=False)
+
+            with gr.Row():
+                dl_wav5 = gr.Audio(label="🏆 RESULTADO FINAL", type="filepath", interactive=False)
+
+            gr.Markdown("---")
+            gr.Markdown("### 📦 ZIP")
+            dl_zip = gr.File(label="📥 ZIP com todos os arquivos", type="filepath", interactive=False)
+
+            dl_refresh_btn.click(
+                fn=refresh_downloads,
+                outputs=[dl_job_dd],
+            )
+
+            dl_load_btn.click(
+                fn=load_downloads,
+                inputs=[dl_job_dd],
+                outputs=[dl_wav1, dl_wav2, dl_wav3, dl_wav4, dl_wav5, dl_zip, dl_status],
+            )
+
+            dl_job_dd.change(
+                fn=load_downloads,
+                inputs=[dl_job_dd],
+                outputs=[dl_wav1, dl_wav2, dl_wav3, dl_wav4, dl_wav5, dl_zip, dl_status],
+                queue=False,
+            )
+
+        # ── TAB 5: Help ───────────────────────────────────────────────────────
+        with gr.Tab("ℹ️ Help"):
             gr.Markdown(f"""
-            ## How it works
-            RVC (Retrieval-Based Voice Conversion) transforms a voice recording to sound
-            like a target speaker using only that speaker's model file.
+            ## Como funciona
+            RVC (Retrieval-Based Voice Conversion) transforma uma gravacao de voz para soar
+            como um locutor-alvo usando apenas o arquivo de modelo desse locutor.
 
             ---
 
-            ## Quick Guide
-            1. Open the **Convert** tab
-            2. **Record** via microphone or **upload** an audio file (wav, mp3, flac, ogg …)
-            3. Choose a **model** from the dropdown — 4 models are pre-loaded on startup
-            4. Set **Pitch Shift** if needed (e.g. male → female: try +12 semitones)
-            5. Click **🚀 Convert Voice** and wait for the result
+            ## Guia Rapido
+            1. Abra a aba **Convert**
+            2. **Grave** pelo microfone ou **envie** um arquivo de audio (wav, mp3, flac, ogg …)
+            3. Escolha um **modelo** no dropdown — 4 modelos pre-carregados no startup
+            4. Ajuste o **Pitch Shift** se necessario (ex: masculino → feminino: tente +12 semitons)
+            5. Escolha o **Formato de Saída** (WAV/FLAC/MP3/OPUS)
+            6. Clique em **🚀 Convert Voice** e aguarde o resultado
+            7. Baixe tudo na aba **📥 Downloads**
 
             ---
 
-            ## Built-in Models
-            | Model | Description |
+            ## Modelos Pre-instalados
+            | Modelo | Descricao |
             |---|---|
-            | **Vestia Zeta v1** | Hololive ID VTuber, v1 model |
-            | **Vestia Zeta v2** | Hololive ID VTuber, v2 model (recommended) |
+            | **Vestia Zeta v1** | Hololive ID VTuber, modelo v1 |
+            | **Vestia Zeta v2** | Hololive ID VTuber, modelo v2 (recomendado) |
             | **Ayunda Risu** | Hololive ID VTuber |
             | **Gawr Gura** | Hololive EN VTuber |
 
             ---
 
-            ## Pitch Extraction Methods
-            | Method | Speed | Quality | Best for |
+            ## Metodos de Extracao de Pitch
+            | Metodo | Velocidade | Qualidade | Melhor para |
             |---|---|---|---|
-            | **rmvpe** | ⚡⚡⚡ | ★★★★ | General use (default) |
-            | **fcpe** | ⚡⚡ | ★★★★ | Singing |
-            | **crepe** | ⚡ | ★★★★★ | Highest quality, slow |
-            | **crepe-tiny** | ⚡⚡ | ★★★ | Low resource |
+            | **rmvpe** | ⚡⚡⚡ | ★★★★ | Uso geral (padrao) |
+            | **fcpe** | ⚡⚡ | ★★★★ | Cantar |
+            | **crepe** | ⚡ | ★★★★★ | Maior qualidade, mais lento |
+            | **crepe-tiny** | ⚡⚡ | ★★★ | Baixo recurso |
 
             ---
 
-            ## Advanced Settings
-            | Setting | Description |
+            ## Configuracoes Avancadas
+            | Configuracao | Descricao |
             |---|---|
-            | **Index Rate** | Influence of FAISS index on output timbre (0.75 recommended) |
-            | **Protect Consonants** | Prevents artefacts on consonants (0.5 = max) |
-            | **Respiration Filter Radius** | Smooths pitch curve — higher reduces breath noise (0–7, default 3) |
-            | **Volume Envelope Mix** | 0.25 = natural blend · 1 = preserve input loudness |
-            | **Noise Reduction** | Removes background noise before conversion |
-            | **Split Long Audio** | Chunks audio for recordings > 60 s |
-            | **Autotune** | Snaps pitch to nearest musical note |
+            | **Index Rate** | Influencia do indice FAISS no timbre (0.75 recomendado) |
+            | **Protect Consonants** | Previne artefatos em consoantes (0.5 = max) |
+            | **Respiration Filter Radius** | Suaviza curva de pitch — maior reduz ruido de respiracao (0–7, padrao 3) |
+            | **Volume Envelope Mix** | 0.25 = mistura natural · 1 = preserva loudness de entrada · 0 = saida do modelo |
+            | **Noise Reduction** | Remove ruido de fundo antes da conversao |
+            | **Split Long Audio** | Divide audio em chunks para gravacoes > 60 s |
+            | **Autotune** | Ajusta pitch para nota musical mais proxima |
+            | **Reverb** | Aplicado na voz convertida antes do mix final |
 
             ---
 
-            ## Output Formats
-            | Format | Size | Quality |
-            |---|---|---|
-            | **WAV** | Large | Lossless |
-            | **FLAC** | Medium | Lossless compressed |
-            | **MP3** | Small | Lossy |
-            | **OPUS** | Tiny (~64 kbps) | Telegram/Discord quality |
+            ## 5 Saidas Geradas (no formato escolhido)
+            1. **entrada** — Audio original completo (voz + musica)
+            2. **entrada_acapella** — Voz original isolada pelo Demucs
+            3. **entrada_instrumental** — Musica/instrumental isolado pelo Demucs
+            4. **saida_acapella** — Voz convertida pelo RVC (acapella)
+            5. **saida** — RESULTADO FINAL: voz RVC + instrumental original mixados
 
             ---
 
@@ -861,22 +1594,29 @@ with gr.Blocks(title="RVC Voice Conversion", delete_cache=(3600, 3600)) as demo:
 
             ---
 
-            ## Credits
+            ## Creditos
             Engine: [Ultimate RVC](https://github.com/JackismyShephard/ultimate-rvc)
             """)
 
-    # Wire convert button after all tabs so jobs_table is defined
-    def _submit_and_extract_id(*args):
-        status, audio = convert(*args)
-        import re
-        match = re.search(r"[a-f0-9]{8}", status or "")
+    # Wire convert button after all tabs
+    def _submit_and_extract_id(mic_file, upload_file, video_file, model_name, pitch, f0_method,
+                               index_rate, protect, vol_env, clean, clean_strength,
+                               split, autotune, autotune_strength, filter_radius, fmt_radio,
+                               reverb, reverb_room, reverb_damp, reverb_wet):
+        status, audio = submit_job(mic_file, upload_file, video_file, model_name, pitch, f0_method,
+                                   index_rate, protect, filter_radius, vol_env,
+                                   clean, clean_strength,
+                                   split, autotune, autotune_strength,
+                                   fmt_radio,
+                                   reverb, reverb_room, reverb_damp, reverb_wet)
+        match = re.search(r"rvc_\d{8}_\d{6}_\d{4}", status or "")
         job_id = match.group(0) if match else ""
         return status, audio, job_id, get_queue_info(), get_jobs_table()
 
     convert_btn.click(
         fn=_submit_and_extract_id,
         inputs=[
-            inp_mic, inp_file, model_dd,
+            inp_mic, inp_file, inp_video, model_dd,
             pitch_sl, f0_radio,
             index_rate_sl, protect_sl, vol_env_sl,
             clean_cb, clean_sl,
@@ -905,7 +1645,6 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.getenv("PORT", 7860)),
-        max_threads=10,
+        allowed_paths=[str(BASE_DIR)],   # <- FIX: libera downloads de /mnt/agents/output
         ssr_mode=False,
-        css=_CSS,
-    )
+    )