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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aioli-cli
-Version: 0.1.44
+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.44 → aioli_cli-0.1.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.44"
+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.44 → 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.44 → 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.44 → aioli_cli-0.1.45}/src/aioli_image/cli.py

@@ -11,15 +11,16 @@ 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,
@@ -41,10 +42,23 @@ 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]:
@@ -104,10 +118,11 @@ def list_models(
     mds, config = _resolve_context(models_dir)
     # 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.
-    wired = _scan_merged(mds, config, skip_broken=True)
+    # 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)
+            _scan_merged(mds, config, category="image")
         except CompanionError as e:
             console.print(f"[yellow]⚠ {e}[/]")
             console.print("[red]All models skipped: broken companions.[/]")
@@ -152,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"),
@@ -193,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).
@@ -221,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)}[/]")
@@ -241,7 +273,7 @@ def generate(
             out=output,
             width=width,
             height=height,
-            steps=steps,
+            steps=eff_steps,
             cfg=cfg,
             seed=seed,
             sampling_method=sampling_method,
@@ -296,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,

{aioli_cli-0.1.44 → 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.44 → aioli_cli-0.1.45}/src/aioli_image/data/models.toml

@@ -356,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"]

aioli_cli-0.1.45/src/aioli_image/doctor.py

@@ -0,0 +1,150 @@
+"""Image plugin checks, mapped onto the aioli contract."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from aioli_contract.doctor import Check
+from aioli_image.config import default_models_dir
+
+
+def _top_component(rel_path: str) -> str:
+    """Primer tramo del rel_path en minusculas ("" si vive en el root plano)."""
+    parts = rel_path.replace("\\", "/").lstrip("./").split("/")
+    return parts[0].lower() if len(parts) > 1 else ""
+
+
+def category_checks(
+    config: dict | None = None, search_dirs: list[Path] | None = None
+) -> list[Check]:
+    """Reporte agrupado por categoria + avisos de modelos mal ubicados (AC9).
+
+    Solo informa: raices usadas y conteo por categoria, y un aviso por cada
+    modelo mal ubicado (video en `image/`, imagen en `video/`, video en root
+    plano) con ruta y categoria detectada. Nunca propone mover ni toca nada.
+    Incluye el warning E6 de claves `[paths]` desconocidas (canal canonico:
+    el `warnings.warn` de `resolve_category_dirs`, aqui capturado y volcado
+    como check para que `status`/`doctor` lo muestren).
+    """
+    import warnings  # noqa: PLC0415
+
+    from aioli_image.config import (  # noqa: PLC0415
+        composed_scan_roots,
+        load_config_safe,
+        resolve_category_dirs,
+    )
+    from aioli_image.launcher import _scan_with_spinner  # noqa: PLC0415
+    from aioli_image.models_data import CATEGORIES  # noqa: PLC0415
+
+    cfg = load_config_safe() if config is None else config
+    roots: dict[str, list[Path]] = {}
+    e6: list[str] = []
+    for cat in CATEGORIES:
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            roots[cat] = resolve_category_dirs(cat, None, cfg)
+        for w in caught:
+            msg = str(w.message)
+            if "Unknown categor" in msg and msg not in e6:
+                e6.append(msg)
+    if search_dirs is not None:
+        scan_roots = list(search_dirs)
+    else:
+        # Default F1: misma composición que el CLI (`_resolve_context`) —
+        # base + raíces `[paths]` TOML — para que el doctor no contradiga
+        # al scan cuando hay raíces custom.
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            scan_roots = composed_scan_roots(None, cfg)
+        for w in caught:
+            msg = str(w.message)
+            if "Unknown categor" in msg and msg not in e6:
+                e6.append(msg)
+    scan_roots = list(dict.fromkeys(scan_roots))
+    models = _scan_with_spinner(scan_roots, cfg, skip_broken=True)
+    counts = {cat: sum(1 for m in models if m.category == cat) for cat in CATEGORIES}
+    parts = [
+        f"{cat}: {counts[cat]} [{', '.join(str(d) for d in roots[cat]) or '—'}]"
+        for cat in CATEGORIES
+    ]
+    out = [Check(name="models-by-category", ok=True, hint=" | ".join(parts))]
+    misplaced: list[str] = []
+    for m in models:
+        top = _top_component(m.rel_path)
+        if m.category == "video" and top == "image":
+            misplaced.append(f"{m.rel_path} (categoria detectada: video, vive en image/)")
+        elif m.category == "image" and top == "video":
+            misplaced.append(f"{m.rel_path} (categoria detectada: image, vive en video/)")
+        elif m.category == "video" and top not in ("image", "video"):
+            misplaced.append(f"{m.rel_path} (categoria detectada: video, en root plano)")
+    if misplaced:
+        out.append(
+            Check(
+                name="models:misplaced",
+                ok=False,
+                hint="mal ubicado: " + "; ".join(misplaced),
+            )
+        )
+    else:
+        out.append(Check(name="models:misplaced", ok=True, hint="ninguno"))
+    for msg in e6:
+        out.append(Check(name="paths:unknown", ok=False, hint=msg))
+    return out
+
+
+def image_checks() -> list[Check]:
+    """Read-only preflight: sd-cli, models dir, per-category model scan, deps.
+
+    Ya no es "fast": `category_checks` embebe un escaneo real (skip_broken)
+    sobre las raíces compuestas (F1).
+    """
+    from aioli_image.launcher import resolve_sd_cli
+
+    results: list[Check] = []
+
+    try:
+        sd = resolve_sd_cli()
+        from aioli_contract.fetch import smoke_runtime  # noqa: PLC0415
+        from aioli_contract.readiness import Readiness, check_exec_bit  # noqa: PLC0415
+
+        # V3: la misma vara que el motor unificado — sin bit X (o
+        # ruta-a-directorio) es FAIL sin ejecutar nada.
+        strict = check_exec_bit(sd)
+        if strict.readiness != Readiness.MOTOR:
+            results.append(Check(name="sd-cli", ok=False, hint=f"{sd} ({strict.note})"))
+        else:
+            ok, note = smoke_runtime(sd)
+            results.append(Check(name="sd-cli", ok=ok, hint=f"{sd} ({note})"))
+    except FileNotFoundError:
+        results.append(
+            Check(
+                name="sd-cli",
+                ok=False,
+                hint="not found — set $IMAGE_SD_CLI_BIN (stub generate works regardless)",
+            )
+        )
+
+    md = default_models_dir()
+    results.append(
+        Check(
+            name="models-dir",
+            ok=md.exists(),
+            hint=f"{md} {'exists' if md.exists() else 'missing — set $IMAGE_MODELS_DIR'}",
+        )
+    )
+    results.extend(category_checks())
+
+    import importlib.util
+
+    for module in ("PIL", "rich"):
+        ok = importlib.util.find_spec(module) is not None
+        results.append(
+            Check(
+                name=f"pkg:{module}",
+                ok=ok,
+                hint=f"'{module}' importable"
+                if ok
+                else f"'{module}' missing — pip install pillow (image) / reinstall aioli-cli",
+            )
+        )
+    return results

{aioli_cli-0.1.44 → aioli_cli-0.1.45}/src/aioli_image/gpu.py

@@ -147,10 +147,13 @@ def gpu_flags(mode: str, devices: list[GpuDevice]) -> tuple[list[str], dict[str,
 
     cudas = [d for d in devices if d.vram_mb > 0]
     if mode == "auto" and len(cudas) >= 2:
-        return (["--auto-fit", "--max-vram", _max_vram_arg(cudas)], None)
+        return (["--auto-fit", "on", "--max-vram", _max_vram_arg(cudas)], None)
 
     if mode == "split" and len(cudas) >= 2:
-        return (["--auto-fit", "--split-mode", "layer", "--max-vram", _max_vram_arg(cudas)], None)
+        return (
+            ["--auto-fit", "on", "--split-mode", "layer", "--max-vram", _max_vram_arg(cudas)],
+            None,
+        )
 
     # Single GPU or unknown mode → current behavior (no changes).
     return ([], None)