aioli-cli 0.1.43__tar.gz → 0.1.45__tar.gz

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aioli-cli
-Version: 0.1.43
+Version: 0.1.45
 Summary: aioli — local-first AI media suite CLI (images, video, music, voice, podcast)
 Author: aioli contributors
 License: MIT

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.43"
+version = "0.1.45"
 description = "aioli — local-first AI media suite CLI (images, video, music, voice, podcast)"
 readme = "README.md"
 requires-python = ">=3.12"

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_cli/main.py

@@ -6,6 +6,7 @@ from typing import Any
 import typer
 from rich.console import Console
 from rich.table import Table
+from rich.text import Text
 
 from aioli_cli.registry import registry
 from aioli_contract import AioliConfig, run_checks
@@ -67,8 +68,12 @@ def doctor() -> None:
     table.add_column("status")
     table.add_column("detail")
     ok = True
+    # Text(): las celdas de detalle son datos literales (los paths pueden
+    # traer '[') — nunca markup. Sin esto, la lista de raíces `[p1, p2]`
+    # se interpreta como tag de cierre y `aioli doctor` crashea con
+    # MarkupError (verify round 3, issue 1).
     for check in run_checks():
-        table.add_row(check.name, "✅" if check.ok else "❌", check.hint)
+        table.add_row(check.name, "✅" if check.ok else "❌", Text(check.hint))
         ok = ok and check.ok
     for plugin in registry.all():
         if plugin.checks is None:
@@ -77,7 +82,7 @@ def doctor() -> None:
             table.add_row(
                 f"{plugin.name}/{check.name}",
                 "✅" if check.ok else "❌",
-                check.hint,
+                Text(check.hint),
             )
             ok = ok and check.ok
     try:
@@ -124,12 +129,12 @@ def doctor() -> None:
                     table.add_row(
                         f"readiness/{check.name}",
                         "✅" if check.ok else "❌",
-                        check.hint,
+                        Text(check.hint),
                     )
                     ok = ok and check.ok
     except (ImportError, OSError, RuntimeError):
         pass
-    table.add_row("models_dir", "📁", str(cfg.models_dir))
+    table.add_row("models_dir", "📁", Text(str(cfg.models_dir)))
     table.add_row("plugins", "🔌", ", ".join(registry.names()) or "(none yet)")
     console.print(table)
     if not ok:

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_contract/ui.py

@@ -34,11 +34,16 @@ __all__ = [
     "AIOLI_GREEN",
     "AIOLI_MARK",
     "PROMPT_STYLE",
+    "QUALITY_PRESETS",
+    "apply_quality_preset",
+    "ask_quality_preset",
     "confirm",
     "header",
     "is_interactive",
+    "measured_eta_hint",
     "number",
     "plain",
+    "quality_preset_steps",
     "select",
     "style",
     "summary_panel",
@@ -274,3 +279,113 @@ def confirm(
         amark=amark,
         **kwargs,
     )
+
+
+# ── Presets de calidad rapido|calidad (un solo sitio) ─────────────────────
+# `--preset` en image/video generate y pregunta opcional en sus wizards.
+# El preset SOLO toca los pasos; el CFG queda estándar ("rapido = menos
+# steps/CFG estándar; calidad = más steps"). Flags explícitos mandan siempre
+# sobre el preset (ver `apply_quality_preset`).
+
+QUALITY_PRESETS: tuple[str, str] = ("rapido", "calidad")
+
+IMAGE_QUALITY_STEPS: dict[str, int] = {"rapido": 8, "calidad": 30}
+VIDEO_QUALITY_STEPS: dict[str, int] = {"rapido": 4, "calidad": 16}
+
+_QUALITY_STEPS_BY_DOMAIN: dict[str, dict[str, int]] = {
+    "image": IMAGE_QUALITY_STEPS,
+    "video": VIDEO_QUALITY_STEPS,
+}
+
+
+def quality_preset_steps(preset: str | None, domain: str) -> int | None:
+    """Pasos que impone un preset de calidad, o None sin preset.
+
+    `ValueError` con preset o dominio desconocidos: el llamador lo convierte
+    en error accionable (exit 2), nunca en traceback.
+    """
+    if preset is None:
+        return None
+    try:
+        table = _QUALITY_STEPS_BY_DOMAIN[domain]
+    except KeyError:
+        raise ValueError(f"dominio desconocido {domain!r}") from None
+    try:
+        return table[preset]
+    except KeyError:
+        raise ValueError(
+            f"preset desconocido {preset!r} (usa {'|'.join(QUALITY_PRESETS)})"
+        ) from None
+
+
+def apply_quality_preset(preset: str | None, steps: int | None, domain: str) -> int | None:
+    """Resuelve pasos con precedencia flags > preset > defaults.
+
+    Un `--steps` explícito manda siempre; el preset solo rellena cuando no
+    hay paso explícito; sin preset se devuelve None (cada plugin aplica su
+    default). Valida el preset aunque haya paso explícito: un typo no pasa
+    en silencio.
+    """
+    preset_steps = quality_preset_steps(preset, domain)
+    if steps is not None:
+        return steps
+    return preset_steps
+
+
+def ask_quality_preset() -> str | None:
+    """Pregunta opcional de preset para los wizards (misma copia en todos).
+
+    Devuelve None (estándar, el del modelo), "rapido" o "calidad".
+    Quien llama gatea TTY antes: esto bloquea en stdin.
+    """
+    return select(
+        "Calidad",
+        [
+            {"name": "Estándar (la del modelo)", "value": None},
+            {"name": "Rápida (menos pasos)", "value": "rapido"},
+            {"name": "Calidad (más pasos)", "value": "calidad"},
+        ],
+        instruction="rapido = menos pasos · calidad = más pasos  (↑↓ elegir · Ctrl-C cancelar)",
+        qmark="⚡",
+        amark="⚡",
+    )
+
+
+def measured_eta_hint(rel_path: str) -> str | None:
+    """Estimación honesta para el resumen del wizard, o None sin dato.
+
+    Busca el modelo en el probe store (`aioli image probe` guarda `secs`
+    medidos en ESTE equipo): si hay medición devuelve "~Ns (medido aquí)".
+    Sin medición devuelve None y el llamador OMITE la fila: jamás se inventa
+    un tiempo estimado (regla H3.1).
+    """
+    try:
+        from aioli_contract.probe import load_store  # noqa: PLC0415
+    except Exception:  # noqa: BLE001 — sin probe no hay ETA, nunca crash
+        return None
+    try:
+        store = load_store()
+    except Exception:  # noqa: BLE001 — store corrupto: sin ETA, nunca crash
+        return None
+    best: float | None = None
+    try:
+        for _hw, plugins in store.items():
+            if not isinstance(plugins, dict):
+                continue
+            for _plugin, models in plugins.items():
+                if not isinstance(models, dict):
+                    continue
+                entry = models.get(rel_path)
+                if not isinstance(entry, dict):
+                    continue
+                for mode in entry.values():
+                    if not isinstance(mode, dict):
+                        continue
+                    secs = mode.get("secs")
+                    if isinstance(secs, (int, float)) and secs > 0:
+                        best = secs if best is None else min(best, secs)
+    except Exception:  # noqa: BLE001 — forma inesperada: sin ETA
+        return None
+    if best is None:
+        return None
+    return f"~{best:.0f}s (medido aquí)"

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_image/cli.py

@@ -11,18 +11,20 @@ from pathlib import Path
 
 import typer
 
-from aioli_contract.ui import is_interactive
+from aioli_contract.ui import apply_quality_preset, is_interactive
 
 from . import stub
 from .companions import CompanionError
 from .config import (
+    composed_scan_roots,
     ensure_user_config,
     load_config_safe,
     load_state,
-    models_search_dirs,
+    toml_scan_roots,
 )
 from .launcher import (
     _companion_skip_note,
+    _scan_for_launch,
     build_probe_trials,
     cmd_doctor,
     launch_convert,
@@ -32,7 +34,7 @@ from .launcher import (
     launch_serve,
 )
 from .launcher import _scan_with_spinner as _scan_merged
-from .models import find_model_by_name
+from .models import ModelInfo, find_model_by_name
 from .ui import console, models_table, print_banner, show_model_info
 
 app = typer.Typer(
@@ -40,10 +42,40 @@ app = typer.Typer(
 )
 
 
+# `_toml_scan_roots` movió a `config.toml_scan_roots` (F1): el doctor la
+# reúsa via `composed_scan_roots` para ver las mismas raíces que el CLI.
+# Alias por compat con llamadores/tests existentes.
+_toml_scan_roots = toml_scan_roots
+
+
 def _resolve_context(models_dir: Path | None) -> tuple[list[Path], dict]:
-    """Seed user config, resolve models search dirs + merged config."""
+    """Seed user config, resolve models search dirs + merged config.
+
+    Roots = `composed_scan_roots`: `models_search_dirs` (explicit/--models-dir
+    > env > fresh + legacy) plus any `[paths]` roots declared in models.toml —
+    la misma composición que usa el doctor por defecto (F1); ver
+    `config.toml_scan_roots` para el rationale add-vs-replace (AC6/AC8).
+    """
     ensure_user_config()
-    return models_search_dirs(models_dir), load_config_safe()
+    config = load_config_safe()
+    return composed_scan_roots(models_dir, config), config
+
+
+def _scan_or_exit(mds: list[Path], config: dict, model_name: str | None = None) -> list[ModelInfo]:
+    """Scan models, failing with exit 3 ONLY when the selected model is broken.
+
+    Unrelated broken models degrade to warning+skip (same `skip_broken`
+    pattern as `list`): `info -m X` / `generate -m X` / `probe -m X` fail
+    only when X itself is the broken one; model-less flows (`model_name`
+    `None`: wizard, all-probe) never abort over other models. The
+    `CompanionError` for the selected model is shown cleanly (exit 3)
+    instead of leaking a raw traceback.
+    """
+    try:
+        return _scan_for_launch(mds, config, model_name)
+    except CompanionError as e:  # safety net: _scan_for_launch already exits 3
+        console.print(f"[red]{e}[/]")
+        raise typer.Exit(3) from None
 
 
 def availability_lines(machine: object | None = None) -> list[str]:
@@ -84,8 +116,17 @@ def list_models(
 ) -> None:
     """List discovered diffusion models."""
     mds, config = _resolve_context(models_dir)
-    wired = _scan_merged(mds, config)
+    # skip_broken: es una lista, no un lanzamiento. Un modelo con el companion
+    # declarado ausente se avisa y se omite; los demás siguen visibles.
+    # category="image": el wizard/lista/probe sin -m solo ofrece image (AC1/AC2).
+    wired = _scan_merged(mds, config, skip_broken=True, category="image")
     if not wired:
+        try:
+            _scan_merged(mds, config, category="image")
+        except CompanionError as e:
+            console.print(f"[yellow]⚠ {e}[/]")
+            console.print("[red]All models skipped: broken companions.[/]")
+            raise typer.Exit(1) from None
         console.print(f"[red]No models found in {', '.join(str(d) for d in mds)}[/]")
         raise typer.Exit(1)
     families = {m.family for m in wired}
@@ -103,7 +144,7 @@ def model_info(
 ) -> None:
     """Show details for one model."""
     mds, config = _resolve_context(models_dir)
-    wired = _scan_merged(mds, config)
+    wired = _scan_or_exit(mds, config, model)
     m = find_model_by_name(model, wired)
     if m is None:
         console.print(f"[red]Model not found: {model}[/]")
@@ -126,6 +167,11 @@ def generate(
     height: int | None = typer.Option(None, "-H", "--height"),
     steps: int | None = typer.Option(None, "--steps"),
     cfg: float | None = typer.Option(None, "--cfg", help="CFG scale."),
+    preset: str | None = typer.Option(
+        None,
+        "--preset",
+        help="rapido|calidad: ajusta los pasos (CFG estándar); --steps manda.",
+    ),
     seed: int | None = typer.Option(None, "--seed"),
     sampling_method: str | None = typer.Option(None, "--sampling-method"),
     scheduler: str | None = typer.Option(None, "--scheduler"),
@@ -167,6 +213,14 @@ def generate(
     models_dir: Path | None = typer.Option(None, "--models-dir"),
 ) -> None:
     """Generate an image (or video with --video-frames > 1)."""
+    # isinstance: llamada directa (tests) deja el OptionInfo sin resolver;
+    # el CLI siempre entrega str|None.
+    if isinstance(preset, str):
+        try:
+            apply_quality_preset(preset, None, "image")
+        except ValueError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(2) from None
     mds, config = _resolve_context(models_dir)
     if prompt is None:
         # Sin prompt: wizard si hay TTY, error accionable si no (nunca colgar CI).
@@ -177,7 +231,7 @@ def generate(
             )
             raise typer.Exit(2)
         with console.status("  [dim]scanning models…[/]", spinner="dots"):
-            wired = _scan_merged(mds, config)
+            wired = _scan_or_exit(mds, config)
         if not wired:
             console.print(f"[red]No models found in {', '.join(str(d) for d in mds)}[/]")
             raise typer.Exit(1)
@@ -195,11 +249,15 @@ def generate(
             height = wiz["height"]
         if output is None and wiz["output"]:
             output = Path(wiz["output"])
+        wiz_preset = preset if preset is not None else wiz.get("preset")
+        eff_steps = apply_quality_preset(wiz_preset, steps, "image")
         parts: list[str] = [f'aioli image generate "{prompt}"']
         if model:
             parts.append(f"-m {model}")
         if width is not None and height is not None:
             parts += [f"-W {width}", f"-H {height}"]
+        if wiz_preset is not None:
+            parts.append(f"--preset {wiz_preset}")
         if output is not None:
             parts.append(f"-o {output}")
         console.print(f"[dim]$ {' '.join(parts)}[/]")
@@ -215,7 +273,7 @@ def generate(
             out=output,
             width=width,
             height=height,
-            steps=steps,
+            steps=eff_steps,
             cfg=cfg,
             seed=seed,
             sampling_method=sampling_method,
@@ -253,7 +311,7 @@ def generate(
         from aioli_contract.probe import hardware_fingerprint, lookup
 
         with console.status("  [dim]scanning models…[/]", spinner="dots"):
-            known_models = _scan_merged(mds, config)
+            known_models = _scan_or_exit(mds, config, model)
         m = find_model_by_name(model, known_models)
         if m is not None:
             rec = lookup("image", m.rel_path, hardware_fingerprint())
@@ -270,7 +328,7 @@ def generate(
         out=output,
         width=width,
         height=height,
-        steps=steps,
+        steps=apply_quality_preset(preset, steps, "image"),
         cfg=cfg,
         seed=seed,
         sampling_method=sampling_method,
@@ -378,7 +436,7 @@ def probe(
     sd_cli = require_sd_cli()
     hw = hardware_fingerprint()
     console.print(f"[dim]hardware: {hw}[/]")
-    models = _scan_merged(mds, config)
+    models = _scan_or_exit(mds, config, model)
     if model:
         m = find_model_by_name(model, models)
         models = [m] if m else []
@@ -391,14 +449,11 @@ def probe(
         mroot = Path(m.root) if m.root else mds[0]
         try:
             trials = build_probe_trials(
-                m, models_dir=mroot, config=config, sd_cli=sd_cli, modes=modes
+                m, models_dir=mroot, config=config, sd_cli=sd_cli, modes=modes, search_dirs=mds
             )
         except CompanionError as exc:
             # Modelo que no se puede cablear: se reporta y se sigue con los
-            # demás (igual que el escaneo fail-soft), nunca traceback crudo.
-            # Ojo: build_probe_trials resuelve los dirs de config, no las
-            # raíces de `--models-dir`, así que puede fallar aunque el scan
-            # haya pasado.
+            # demás (defensa en profundidad; el scan ya filtra los rotos).
             console.print(f"  [red]⚠ {m.name}: {_companion_skip_note(exc)}[/]")
             continue
         for t in trials:

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_image/companions.py

@@ -321,11 +321,12 @@ def find_companions(
         # substring collisions (e.g. "ae.safetensors" is a substring of
         # "z_image_vae.safetensors").
         if role == "llm" and model.preferred_llm:
+            hint_in = model.preferred_llm.lower()
             preferred = [
                 m
                 for m in matches
-                if model.preferred_llm in m.name.lower()
-                and not _would_be_substring_collision(model.preferred_llm, m.name.lower())
+                if hint_in in m.name.lower()
+                and not _would_be_substring_collision(hint_in, m.name.lower())
             ]
             if not preferred:
                 # The hint is not in this dir: look in the other configured
@@ -413,19 +414,26 @@ def _preferred_llm_elsewhere(
         if tdir in seen or not tdir.is_dir():
             continue
         seen.add(tdir)
-        for f in tdir.iterdir():
-            if not f.is_file() or f.suffix.lower() != ".gguf":
-                continue
-            if f.name == model.name or not pattern.search(f.name):
-                continue
-            low = f.name.lower()
-            if hint not in low or _would_be_substring_collision(hint, low):
-                continue
-            if model_group:
-                cand_group = _candidate_group(f.name)
-                if cand_group and cand_group != model_group:
+        try:
+            entries = list(tdir.iterdir())
+        except OSError:
+            continue
+        for f in entries:
+            try:
+                if not f.is_file() or f.suffix.lower() != ".gguf":
+                    continue
+                if f.name == model.name or not pattern.search(f.name):
                     continue
-            size_gb = f.stat().st_size / (1024**3)
+                low = f.name.lower()
+                if hint not in low or _would_be_substring_collision(hint, low):
+                    continue
+                if model_group:
+                    cand_group = _candidate_group(f.name)
+                    if cand_group and cand_group != model_group:
+                        continue
+                size_gb = f.stat().st_size / (1024**3)
+            except OSError:
+                continue
             out.append(Companion(role="llm", flag="--llm", path=f, approx_gb=size_gb))
     if not out:
         roots = ", ".join(str(r) for r in [own_dir, *searched])

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_image/config.py

@@ -14,6 +14,7 @@ import json
 import os
 import shutil
 import tomllib
+import warnings
 from pathlib import Path
 from typing import Any
 
@@ -92,6 +93,136 @@ def models_search_dirs(explicit: Path | None = None) -> list[Path]:
     return dirs or [legacy.resolve()]
 
 
+def _category_subdir_or_flat(base: Path, cat: str) -> Path:
+    """`<base>/<cat>` si existe y no esta vacio; si no, `<base>` plano (E7)."""
+    from .models_data import CATEGORIES
+
+    if base.name in CATEGORIES:
+        return base
+    cand = base / cat
+    try:
+        if cand.is_dir() and any(cand.iterdir()):
+            return cand.resolve()
+    except OSError:
+        pass
+    return base
+
+
+def resolve_category_dirs(
+    cat: str, explicit_root: Path | str | None = None, config: dict | None = None
+) -> list[Path]:
+    """Raices de scan para una categoria (`image`/`video`, extensible).
+
+    Precedencia (AC4): `[paths.<cat>]` > `--models-dir`/`IMAGE|AIOLI_MODELS_DIR`
+    como root+`/<cat>` > fresh XDG+legacy `~/ai/models`+`/<cat>`. `<root>/<cat>`
+    ausente o vacio implica scan plano de `<root>` (legacy flat + E7). `[]`
+    deshabilita la categoria sin fallback (E2). Un `explicit_root` que ya
+    termina en `/image|/video` es base final (E1). Entradas `[paths]` relativas
+    se resuelven contra CWD (E3, se recomienda absoluto). Categorias
+    desconocidas en `[paths]` se ignoran con warning (E6).
+    """
+    from .models_data import CATEGORIES
+
+    cfg = config if config is not None else load_config_safe()
+    raw_paths = cfg.get("paths", {}) or {}
+    if not isinstance(raw_paths, dict):
+        raw_paths = {}
+    unknown = [k for k in raw_paths if k not in CATEGORIES]
+    if unknown:
+        warnings.warn(
+            f"Unknown categor{'y' if len(unknown) == 1 else 'ies'} in [paths]: "
+            + ", ".join(sorted(unknown))
+            + " (ignored)",
+            UserWarning,
+            stacklevel=2,
+        )
+    if cat in raw_paths:
+        entries = raw_paths[cat]
+        if isinstance(entries, (str, os.PathLike)):
+            entries = [entries]
+        return [Path(e).expanduser().resolve() for e in entries]
+    if explicit_root is not None:
+        base = Path(explicit_root).expanduser().resolve()
+        if base.name in CATEGORIES:
+            return [base]
+        return [_category_subdir_or_flat(base, cat)]
+    for var in ("IMAGE_MODELS_DIR", "AIOLI_MODELS_DIR"):
+        override = os.environ.get(var, "").strip()
+        if override:
+            base = Path(override).expanduser().resolve()
+            if base.name in CATEGORIES:
+                return [base]
+            return [_category_subdir_or_flat(base, cat)]
+    bases: list[Path] = []
+    fresh = _xdg_data_home() / "aioli" / "models"
+    legacy = Path.home() / "ai" / "models"
+    if fresh.is_dir():
+        bases.append(fresh.resolve())
+    try:
+        legacy_resolved = legacy.resolve()
+    except OSError:
+        legacy_resolved = legacy
+    if legacy.is_dir() and legacy_resolved not in bases:
+        bases.append(legacy_resolved)
+    if not bases:
+        bases = [legacy_resolved]
+    out: list[Path] = []
+    for base in bases:
+        d = _category_subdir_or_flat(base, cat)
+        if d not in out:
+            out.append(d)
+    return out
+
+
+def toml_scan_roots(models_dir: Path | None, config: dict) -> list[Path]:
+    """Extra scan roots contributed by `[paths]` in models.toml (AC3/AC4).
+
+    The CLI scan is cross-category ON PURPOSE (AC6: `-m <video>` must
+    resolve), so TOML entries are ADDED to the base `models_search_dirs`
+    roots and the engine's category filter keeps governing model-less
+    flows (wizard/list/probe). Replacing the base roots with
+    `resolve_category_dirs("image")` output would hide every video model
+    from `-m <video>` whenever `[paths].image` is declared — hence add.
+
+    Only TOML-declared roots are appended: the env/fresh/legacy fallback
+    branches of `resolve_category_dirs` already are (or are parents of)
+    the base roots, and adding `<root>/<cat>` would scan models twice
+    under different `rel_path` (`m.gguf` vs `image/m.gguf`), defeating
+    the rel_path dedupe. Without `[paths]` the result is byte-identical
+    to `models_search_dirs` (AC8). `[paths].<cat> = []` adds nothing
+    here: E2 disable is enforced by `resolve_category_dirs` at unit
+    level (documented divergence, see design.md E2).
+    """
+    paths = config.get("paths")
+    if not isinstance(paths, dict) or not paths:
+        return []
+    from .models_data import CATEGORIES  # noqa: PLC0415
+
+    extra: list[Path] = []
+    for cat in CATEGORIES:
+        if cat not in paths:
+            continue
+        # Full config on purpose: a declared cat returns exactly its TOML
+        # entries (precedence AC4 inside resolve_category_dirs) and unknown
+        # `[paths]` keys still raise the E6 warning at the call site.
+        for root in resolve_category_dirs(cat, models_dir, config):
+            if root not in extra:
+                extra.append(root)
+    return extra
+
+
+def composed_scan_roots(models_dir: Path | None = None, config: dict | None = None) -> list[Path]:
+    """Raíces de scan canónicas: `models_search_dirs` + extra `[paths]` TOML.
+
+    Composición compartida (F1): la usa `_resolve_context` (CLI) y
+    `category_checks` (doctor) como default, para que ambos vean las mismas
+    raíces — un `[paths].video` custom aparece también en el doctor.
+    `config=None` carga la config de usuario.
+    """
+    cfg = load_config_safe() if config is None else config
+    return models_search_dirs(models_dir) + toml_scan_roots(models_dir, cfg)
+
+
 def resolve_output_dir() -> Path:
     """Output directory for generated images.
 

{aioli_cli-0.1.43 → aioli_cli-0.1.45}/src/aioli_image/data/models.toml

@@ -323,9 +323,19 @@ preferred_llm = "gemma-3-12b"
 preferred_vae = "ltx-2.3-22b-dev_video_vae"
 encoder_mode = "balanced-v2"
 
-# MiniMax H3 Ref2VA — image-to-video + audio (ruta ai.manz.dev). Diffusion
-# 11.4 GB (pruned Q4) + qwen3vl-32B-minimax (13.1 GB Q2) + VAEs ≈ 27 GB →
-# pensado para las 2 GPUs (--gpu auto). En 1 GPU de 16 GB necesita offload.
+# LTX-2.5-Distilled (22B) — video nativo, vía sd-cli vid_gen. Pesa 14.6 GiB
+# el Q4_K_M y 11.8 GiB el Q3_K_S (16.0 / 13.2 GiB contando su VAE de 1.4 GiB),
+# así que los dos llevan tier `high` — igual que los 22B de ltx-2.3: `_compute_
+# encoder_mode` responde `balanced-v2` (diffusión en CPU) en auto/cuda0/cuda1 en
+# esta doble tarjeta, o sea que NINGUNO queda residente en VRAM. El tier NO lo
+# valida el probe de esta máquina: las 6 combinaciones abortan en ~1.1 s por
+# validación de metadatos del runtime (falta el VAE variante conv y el Gemma4 en
+# GGUF → docs/WEIGHTS.md "Pendientes"), antes de asignar VRAM. Se re-probea al
+# entrar esos pesos.
+# `no_llm`: el único companion utilizable del dir es el VAE; el
+# `gemma4-...-comfy-int8-convrot.safetensors` es un proyector CLIP de ComfyUI,
+# no un LLM de sd.cpp, así que NO se declara preferred_llm (degradación con
+# VAE-only, nunca crash).
 [models."video/minimax_h3_ref2va_pruned-Q4_K_M.gguf"]
 family = "minimax"
 vram_tier = "high"
@@ -346,12 +356,15 @@ encoder_mode = "balanced-v2"
 # Stack: difusion Q4_K_M 4.19 GB + VAE 2.1 (NO intercambiable con el de 1.x) +
 # Qwen3-VL-8B-Instruct GGUF (~5 GB) + su mmproj para editar.
 #   - dims multiplos de 32 y euler: handoff V8.4.
-#   - cfg 6.0 PROVISIONAL: docs/qwen_image_2.1.md no esta en los checkouts
-#     locales del engine (engine Aug-30 / engine-v3 2026-09-17); los docs de
-#     qwen-image 1.x y Edit usan cfg 2.5 + --flow-shift 3. Fijar en el
-#     smoke-test con el runtime day-0.
-#   - encoder_mode sin curar: la familia manda balanced-v2 (seguro pero lento);
-#     4.2 GB + 5 GB LLM + 0.25 GB VAE ≈ 9.4 GB sugiere "balanced" o "gpu".
+#   - cfg 6.0, euler, dims %32 y "flow schedule segun resolucion" (sin
+#     --flow-shift) FIJADOS por docs/qwen_image_2.1.md de sd.cpp master, leida
+#     2026-09-21 (los checkouts locales del engine son Aug-30 / 2026-09-17 y aun
+#     no la traen; 1.x y Edit usan cfg 2.5 + --flow-shift 3, NO vale aqui). Lo
+#     que la doc no fija sigue provisional: steps (20) y encoder_mode.
+#   - encoder_mode sin curar: el probe no pasa de la validacion de metadatos con
+#     el runtime vigente (runtimes-v4 / sd-cli de298c2), asi que no hay dato
+#     observational. Tamano real en disco: 3.9 difusor + 4.7 LLM + 1.1 mmproj +
+#     0.6 VAE = 10.3 GB -> "balanced" o "gpu" siguen siendo la hipotesis.
 # `wants_llm_vision = true` es lo que deja adjuntar el mmproj con --llm_vision
 # (companions.py): sin flag, un mmproj en la carpeta no se toca nunca.
 [models."image/Qwen-Image-2.1-Q4_K_M.gguf"]
@@ -387,7 +400,8 @@ family = "ltx"
 experimental = true
 requires_runtime = "post-2026-09-20"
 vram_tier = "high"
-preferred_llm = "gemma4"
+preferred_llm = ""
+no_llm = true  # hasta que exista el gemma4-...-Q8_0.gguf convertido
 preferred_vae = "ltx-2.5-video-vae-conv"
 preferred_audio_vae = "ltx-2.5-audio-vae"
 deny_roles = ["embeddings_connectors"]
@@ -400,7 +414,8 @@ family = "ltx"
 experimental = true
 requires_runtime = "post-2026-09-20"
 vram_tier = "high"
-preferred_llm = "gemma4"
+preferred_llm = ""
+no_llm = true  # hasta que exista el gemma4-...-Q8_0.gguf convertido
 preferred_vae = "ltx-2.5-video-vae-conv"
 preferred_audio_vae = "ltx-2.5-audio-vae"
 deny_roles = ["embeddings_connectors"]