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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.44"
+version = "0.1.46"
 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.46}/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:
@@ -270,8 +275,10 @@ def models_list(
     bin_dir = default_bin_dir()
     wanted = _wanted(plugin, backend)
     roots = _plugin_roots(wanted, cfg, models_root)
-    distinct = ", ".join(sorted({str(r) for r in roots.values()}))
-    table = Table(title=f"aioli models → {distinct}")
+    distinct_roots = sorted({str(r) for r in roots.values()})
+    for root_str in distinct_roots:
+        console.print(f"📁 {root_str}")
+    table = Table(title="aioli models")
     table.add_column("plugin")
     table.add_column("engine")
     table.add_column("kind")

{aioli_cli-0.1.44 → aioli_cli-0.1.46}/src/aioli_contract/fetch.py

@@ -39,6 +39,36 @@ from typing import Any, Protocol
 from urllib.error import HTTPError
 from urllib.parse import urlsplit
 
+# O_NOFOLLOW no existe en Windows (NT): getattr portatil. En NT la proteccion
+# symlink se cubre por la verificacion post-escritura ya existente
+# (_read_lock/is_symlink + chequeo del .part antes de abrir + recibo).
+_O_NOFOLLOW = getattr(os, "O_NOFOLLOW", 0)
+
+
+def _is_executable(path: Path) -> bool:
+    """Ejecutabilidad portatil para recibos.
+
+    POSIX: bit X como hoy. NT: os.access(X_OK) es True para cualquier
+    fichero, asi que ademas se exige cabecera PE ("MZ") o extension
+    .exe/.bat. Sin esto, verify venderia "ok" con motor falso en Windows.
+    """
+    try:
+        if not path.is_file():
+            return False
+        if os.name != "nt":
+            return bool(os.access(path, os.X_OK))
+        if not os.access(path, os.X_OK):
+            return False
+        if path.suffix.lower() in (".exe", ".bat"):
+            return True
+        try:
+            with open(path, "rb") as fh:
+                return fh.read(2) == b"MZ"
+        except OSError:
+            return False
+    except OSError:
+        return False
+
 
 class Progress(Protocol):
     def update(self, path: Path, done_bytes: int, total_bytes: int) -> None: ...
@@ -189,7 +219,7 @@ def _dest_lock(lock_path: Path, timeout: float = _LOCK_TIMEOUT) -> Iterator[None
     deadline = time.monotonic() + timeout
     while True:
         try:
-            fd = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW)
+            fd = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | _O_NOFOLLOW)
             with os.fdopen(fd, "wb") as fh:
                 fh.write(me)
             break
@@ -217,7 +247,7 @@ def _dest_lock(lock_path: Path, timeout: float = _LOCK_TIMEOUT) -> Iterator[None
         while not stop.wait(interval):
             fresh = f"{os.getpid()} {time.time()}".encode()
             try:
-                fd = os.open(lock_path, os.O_WRONLY | os.O_TRUNC | os.O_NOFOLLOW)
+                fd = os.open(lock_path, os.O_WRONLY | os.O_TRUNC | _O_NOFOLLOW)
                 with os.fdopen(fd, "wb") as fh:
                     fh.write(fresh)
             except OSError:
@@ -446,7 +476,7 @@ def _verify_bundle(entry: ModelFile, dest: Path, quick: bool) -> str:
         return "corrupt"
     if entry.executable:
         try:
-            if not os.access(exe, os.X_OK):
+            if not _is_executable(exe):
                 return "corrupt"
         except OSError:
             return "corrupt"
@@ -760,7 +790,7 @@ def _fetch_attempt(
         total = entry_size or ((expect + start) if expect is not None else 0)
         # O_NOFOLLOW: si entre el chequeo y la apertura alguien planta
         # un symlink, la apertura falla (ELOOP) en vez de escribir fuera.
-        flags = os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW
+        flags = os.O_WRONLY | os.O_CREAT | _O_NOFOLLOW
         flags |= os.O_APPEND if start > 0 else os.O_TRUNC
         try:
             fd = os.open(part, flags, 0o644)

{aioli_cli-0.1.44 → aioli_cli-0.1.46}/src/aioli_contract/readiness.py

@@ -140,11 +140,35 @@ def check_sdk(spec: BackendSpec) -> ProbeOutcome:
     return ProbeOutcome(Readiness.DESCONOCIDO, f"{target or spec.backend} no instalado{extra}")
 
 
+def _nt_executable(path: Path) -> bool:
+    """True si el fichero parece ejecutable Windows (MZ o .exe/.bat)."""
+    if path.suffix.lower() in (".exe", ".bat"):
+        return True
+    try:
+        with open(path, "rb") as fh:
+            return fh.read(2) == b"MZ"
+    except OSError:
+        return False
+
+
 def check_exec_bit(path: Path) -> ProbeOutcome:
-    """Bit X vía stat (estable V3: sin bit X es desconocido, nunca éxito)."""
+    """Bit X vía stat (estable V3: sin bit X es desconocido, nunca éxito).
+
+    NT: os.access(X_OK) es True para cualquier fichero, así que además se
+    exige cabecera PE ("MZ") o extensión .exe/.bat. POSIX no cambia (bit X).
+    """
     try:
         if not path.is_file():
             return ProbeOutcome(Readiness.DESCONOCIDO, f"{path} no es fichero")
+        if os.name == "nt":
+            if not os.access(path, os.X_OK):
+                return ProbeOutcome(Readiness.DESCONOCIDO, f"{path} sin bit X")
+            if _nt_executable(path):
+                return ProbeOutcome(Readiness.MOTOR, f"{path} ejecutable")
+            return ProbeOutcome(
+                Readiness.DESCONOCIDO,
+                f"{path} no ejecutable en Windows (sin MZ ni .exe/.bat)",
+            )
         if os.access(path, os.X_OK):
             return ProbeOutcome(Readiness.MOTOR, f"{path} ejecutable")
         return ProbeOutcome(Readiness.DESCONOCIDO, f"{path} sin bit X")

{aioli_cli-0.1.44 → aioli_cli-0.1.46}/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.46}/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.46}/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.46}/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"]