launcher/locales/es/main.ftl

cluster-not-found = Cluster "{ $name }" no encontrado
nccl-config-missing = Configuración NCCL no encontrada
cluster-auto-fail = No se encontró un cluster adecuado
cluster-selected = ✅ Cluster seleccionado automáticamente: { $name } ({ $nodes } { $nodes ->
        [one] nodo
       *[other] nodos
    })
container-log-header = 📜 Logs de contenedor más recientes:
cluster-stopping = 🛑 Deteniendo cluster '{ $name }'...
cluster-all-stopped = ✅ Todos los contenedores detenidos.
cluster-section = === Cluster: { $name } ===
doctor-header = 🩺 Doctor: { $name } ({ $engine }) [backend: { $backend }]

doctor-node-section = --- { $name } ---
doctor-all-passed = ✅ ¡Todas las comprobaciones superadas!
doctor-checks-failed = ⚠ Algunas comprobaciones fallaron. Ejecute con --repair para auto-corregir.
doctor-repairing = 🔧 Reparando imagen...
doctor-repaired = ✅ Imagen reparada: { $tag }
doctor-dry-build = (dry-run) Se construiría { $tag } en { $node }
logs-follow-head = 📜 Siguiendo logs de '{ $name }' (nodo principal)...
logs-section = --- { $name } ---
health-cluster-header = === { $name } === { $nodes } { $nodes ->
        [one] nodo
       *[other] nodos
    }

health-switch-off = 🚫 switch apagado
health-interface-down = 🌐 interfaz caída
health-all-online = ✅ todos en línea
health-partial-online =   ({ $online } en línea, { $offline } sin conexión)

health-node-online-cluster-down =   ◍ { $name } ({ $ip }){ $net } — en línea (cluster fuera de línea)
health-free-count = — { $free } libres
health-cluster-down = ⏻ clúster sin conexión

health-soft-off = ⚙ { $list } apagado (no bloqueante)
health-net-status =  [red: { $details }]
health-no-containers = (sin contenedores)
health-no-containers-inline = , sin contenedores
exec-header = ⚡ exec: { $cmd } ({ $nodes } { $nodes ->
        [one] nodo
       *[other] nodos
    })

exec-section = --- { $name } ---
exec-failed = ✗ { $name } :: { $cmd } :: { $error }

exec-completed-errors = exec completó con errores (algunos nodos reportaron fallos)
power-off-dryrun = dry-run: omitiendo apagado real + llamada HA
power-off-mikrotik-skip = { $entity } es un dispositivo de la API de RouterOS ({ $address }) — HA se omite
power-off-mikrotik-would = haría: RouterOS /system/shutdown { $name } ({ $address })
power-off-mikrotik-failed = { $name }: fallo el apagado de RouterOS ({ $error })
power-on-mikrotik-manual = { $name }: dispositivo RouterOS — sin encendido remoto; enciéndalo manualmente
power-on-mikrotik-manual-would = haría: encender { $name} manualmente (RouterOS no tiene on remoto)
power-off-mikrotik-relay = { $name }: enchufe { $relay } apagado (sin alimentación)
power-off-mikrotik-relay-would = acción: apagar el enchufe { $relay } (corta la corriente de { $name })
power-off-mikrotik-relay-failed = { $name }: no se pudo apagar el enchufe { $relay } ({ $error }) — verifique que quede sin corriente
power-on-mikrotik-relay-would = haría: activar el relé { $relay} (enciende { $name})
power-off-would = sería: { $action } { $target }
power-off-shutdown-failed = ✗ { $name } :: { $cmd } :: { $error }

power-off-waiting = ⏳ esperando { $secs}s para que los nodos se asienten
power-off-no-ha = sin config [home_assistant]; el apagado de SO se realizó arriba
power-off-ssh-failures = algunos nodos reportaron fallos SSH durante el apagado
power-off-extras-skipped = apagado parcial ({ $nodes }): se mantienen las entidades del clúster ({ $extras }) — son compartidas por los nodos activos
power-on-dryrun = dry-run: omitiendo llamada HA real
power-on-would-on = sería: HA turn_on { $entity }
power-on-would-skip = se omitiría: { $name } (sin entity)
power-on-head = 💡 encender: { $nodes } nodo(s)
ha-invalid-entity = { $name }: entity inválido '{ $entity }': { $error }
ha-call-failed = HA { $service } { $entity }: { $error }

ha-skip-no-entity = ⚠ { $name }: sin `entity` configurado, omitiendo HA
ha-extra-failed = HA { $service } { $extra } ({ $label }): { $error }

power-switch-would-off = sería: HA turn_off { $entity }
power-switch-would-off-extra = sería: HA turn_off { $extra } (de extras)
power-switch-would-on = sería: HA turn_on { $entity }
power-switch-would-on-extra = sería: HA turn_on { $extra } (a extras)
power-switch-shutdown-failed = ✗ { $name } apagado: { $error }
power-switch-waiting = ⏳ esperando { $secs}s para apagado
power-switch-no-ha = sin config [home_assistant]; el apagado de SO se realizó
power-off-entity-would = sería: HA turn_off { $entity }
pre-serve-skip = ⏭ Omitiendo hooks pre-serve (--skip-before-serve)
pre-serve-failed = pre-serve: nodo { $name } falló: { $error }
pre-serve-run = { $node } ({ $tag }) :: { $cmd }
pre-serve-ignored = ⚠ { $cmd } ignorado: { $error }
host-key-header = Claves de host descubiertas:
host-key-line = { $name } ({ $ip }) -> host_key = { $key }
host-key-error = { $name } ({ $ip }) -> error: { $error }
host-key-no-match = (ningún nodo coincidió)
recipe-starting = 🚀 Iniciando receta: { $name } ({ $engine }) [backend: { $backend }]
cold-applied = ❄ --cold: aplicados los cold_args de la receta sobre sus args
cold-no-block = ❄ --cold: la receta '{ $name }' no tiene cold_args; se sirve con args normales
cluster-switch-off-detected = ⚠️ El switch del cluster parece estar apagado
cluster-switch-powered-on = ✅ Switch del cluster encendido
cluster-waiting-for-nodes = ⏳ Esperando que los nodos estén disponibles...
cluster-nodes-available = ✅ Todos los nodos ya están disponibles
cluster-nodes-not-available-timeout = ❌ Tiempo de espera agotado para nodos disponibles
logs-header = 📜 Logs del cluster '{ $name }' ({ $count } nodos)
engine-started = ✅ { $engine } iniciado en { $name } (rango { $rank })
engine-start-failed = Falló iniciar { $engine } en { $name } (rango { $rank }): { $error }
cluster-started = 🎉 ¡Cluster iniciado! API → http://{ $ip }:{ $port }

exec-both-specified = Especifique --cluster o --recipe, no ambos
exec-missing = Debe especificar --cluster o --recipe
exec-node-not-found = Nodo '{ $name }' no encontrado en cluster '{ $cluster }'
exec-cluster-empty = Cluster '{ $name }' no tiene nodos
exec-cannot-use-alias = No se puede usar --alias junto con un comando final
exec-must-specify = Debe especificar --alias <nombre> o un comando después de `--`
exec-unknown-alias-empty = Alias desconocido @{ $name } (sin alias configurados)
exec-unknown-alias-list = Alias desconocido @{ $name }; alias conocidos: { $aliases }
mods-uploading = 📤 Subiendo mods a { $node }...
mods-uploaded = ✅ Mods subidos a { $node }
mods-entrypoint-required = La receta '{ $name }' tiene mods pero no tiene entrypoint; se requiere entrypoint cuando hay mods

after-stop-failed = after_stop: nodo { $name } falló: { $error }
after-stop-run = { $node } ({ $tag }) :: { $cmd }
after-stop-ignored = ⚠ { $cmd } ignorado: { $error }
solo-node-selected = 🎯 Solo: nodo { $name } seleccionado en cluster { $cluster }

# --- Cadenas que antes eludían el sistema i18n (hardcodeadas) ---
boot-wait = ⏳ Esperando { $secs}s para el arranque de nodos...
doctor-found-repaired = 🩺 Imagen reparada encontrada: { $tag }
tmux-waiting-head = ⏳ Esperando que el nodo principal esté listo...
tmux-head-ready = ✅ Nodo principal listo. Iniciando nodos worker...
tmux-head-api-ready = API del nodo principal lista (intento { $attempt })
tmux-session-started = ✅ Sesión iniciada en { $name }
tmux-stopped = ✅ '{ $sess }' detenida en { $name }
tmux-all-stopped = ✅ Todas las sesiones tmux detenidas.
tmux-all-ok = ✅ TODO OK
tmux-issues = ⚠️  { $issues }
tmux-cluster-healthy = ✅ ¡El cluster está sano!
tmux-node-section = --- { $name } ({ $sess }) ---
tmux-node-no-output = --- { $name } — sin salida ---
tmux-session-created = ✅ Sesión tmux creada en { $name }
tmux-no-pty = (russh no soporta PTY interactivo. Use el siguiente comando directamente:)
sync-digest-match = '{ $name }' OK (digest coincide)
sync-syncing = { $name } ({ $ip }): sincronizando...
sync-synced = { $name } OK
sync-fabric-fallback = { $name }: el salto por 200G falló ({ $err }) — fallback a mgmt 10G; arreglar ssh nodo-a-nodo por la fabrica (authorized_keys / host keys para las direcciones 200.x)
health-node-offline =   ✗ { $name } ({ $ip }) — desconectado
health-node-idle = ○ { $name } ({ $ip }){ $net }

health-node-online = ● { $name } ({ $ip }){ $net }

health-container-count = , { $count } { $count ->
        [one] contenedor
       *[other] contenedores
    }

power-off-head = 🛑 apagar: { $nodes } nodo(s) — sudo shutdown now
power-switch-head = 🔌 conmutar: { $from } → { $to } ({ $nodes } nodo(s) + { $entities } entidade(s) a desactivar)
power-switch-powering-on = 💡 conmutar: encendiendo { $nodes } nodo(s) + { $entities } entidade(s) a { $to }
health-task-join = error de unión de tarea: { $error }
health-no-recipes = No hay contenedores sm121 ejecutándose.
health-running-recipes = Recetas en ejecución:
health-recipe-line =   { $recipe } — { $nodes } { $nodes ->
        [one] nodo
       *[other] nodos
    }: { $list }

tmux-ray-backend = 🐍 Backend Ray detectado — iniciando nodo principal primero...
tmux-mp-backend = 🔗 Backend MP detectado — iniciando todos los nodos en paralelo...
tmux-following-logs = 📜 Siguiendo logs de '{ $sess }' en { $name }...
composed-dir-dry-run = [simulación] se crearía el directorio de modelo compuesto '{ $host }' en '{ $node }' (montaje: { $mount }, { $sources } { $sources ->
        [one] fuente
       *[other] fuentes
    }, { $files } { $files ->
        [one] archivo
       *[other] archivos
    }, { $local } { $local ->
        [one] archivo local
       *[other] archivos locales
    })
composed-dir-built = Creado directorio de modelo compuesto '{ $host }' en '{ $node }' ({ $sources } { $sources ->
        [one] fuente
       *[other] fuentes
    }, { $files } { $files ->
        [one] archivo
       *[other] archivos
    }, { $local } { $local ->
        [one] archivo local
       *[other] archivos locales
    })
tmux-mods-unsupported = Recipe '{ $name }' usa [mods], que es Docker-only. El despliegue tmux no admite mods.
tmux-deploy-ignored-opts = ⚠️ tmux deploy: ignorando opciones CLI Docker-only: { $opts }
tmux-composed-model-unsupported = Recipe '{ $name }' usa [composed_model], que es Docker-only. El despliegue tmux no admite directorios de modelos compuestos.
tmux-health-section = Tmux:
tmux-health-entry-running = { $recipe } — { $node }: en ejecución (API: { $api })
tmux-health-entry-degraded = { $recipe } — { $node }: degradado (la sesión existe, proceso muerto)
tmux-health-all-stopped = { $count ->
    [one] { $count } receta de tmux configurada, todas detenidas
   *[other] { $count } recetas de tmux configuradas, todas detenidas
}
tmux-api-ok = 200
tmux-api-down = caído
venv-preparing = 🔧 Preparando venv: { $venv }
venv-exists = ✓ venv ya existe en { $name }
venv-creating = venv no encontrado en { $name } — creando...
venv-created = ✓ venv creado correctamente en { $name }
venv-not-created = venv no se creó correctamente en { $name } — los comandos de configuración se ejecutaron pero falta el script activate

# health render module (plain/md/html)
health-nodes-count = { $nodes } { $nodes ->
        [one] nodo
       *[other] nodos
    }
health-col-node = Nodo
health-col-address = Dirección
health-col-status = Estado

health-col-containers = Contenedores
health-col-container = Contenedor

health-col-image = Imagen

health-col-recipe = Receta
health-col-cluster = Clúster

health-col-nodes = Nodos
health-status-online = ● en línea

health-status-offline = ✗ sin conexión

health-container-line =     { $name }  { $status }  { $image }

dry-run-would-push = [dry-run] haría push de { $ref} (y actualizaría { $latest }) tras el build
push-mapping-failed = no se puede mapear [registry].base { $base } a un ref de push para { $image }
pushing-image = Haciendo push de la imagen a { $ref} (tmux: { $session })...
push-timeout = El push de { $ref} en { $node} expiró tras { $elapsed} — inspeccionar la sesión tmux { $session} / el log { $log} en el nodo.
push-failed = El push de { $ref} en { $node} falló tras { $elapsed}.\n{ $log }\nSugerencia: si el log dice unauthorized/denied — ejecutar `docker login { $host }` en { $node} (el launcher no guarda credenciales del registro).
pushed-image = Imagen { $ref} con push hecho, { $latest} actualizada ({ $elapsed })
push-running = Push en curso desde hace { $elapsed }...
push-already-published = { $ref} ya publicado ({ $label}): digest de imagen sin cambios — omitido, use --force para volver a publicar

power-on-on = { $name }: encendido
power-on-cycled = { $name }: el enchufe estaba on con el nodo apagado — ciclo de energía
power-on-was-on = { $name }: el enchufe ya está on (¿nodo activo?) — sin cambios
power-on-skip = { $name }: sin entidad de HA — omitido
power-on-failed = { $name }: fallo de HA: { $error }
power-on-cycling = ⟳ { $name }: el enchufe está on pero el nodo no responde — ciclando { $entity }
power-on-off-wait-timeout = { $name }: el enchufe no reportó off en 10 s (relé posiblemente atascado)

report-col-launches = Ejecuciones
report-col-up = Activo
report-col-engine = Motor
report-col-last = Último bench
report-col-model = Modelo
report-col-nodes = Nodos×TP
report-col-points = Puntos
report-col-prov = Procedencia
report-col-quant = Cuant.
stop-not-verified = Contenedores no verificados como detenidos en: { $nodes }

report-col-recipe = Receta
report-col-reports = Informes
report-col-score = Puntuación /100
report-col-tps1 = Tok/s c1
report-col-tps2 = Tok/s c2
report-serving = Informe interactivo de recetas: { $url }  (actualizaciones en vivo; Ctrl-C para parar)
report-title = Recetas probadas ({ $count })

# --- recipe repos (src/recipe_repos.rs) ---
git-failed = git { $cmd } falló: { $err }
recipe-repo-archived-skip = repositorio de recetas archivado — omitiendo: { $url }
recipe-repo-synced = repositorio de recetas sincronizado: { $url } → { $dir }
recipe-repo-watch = repos watch: { $n } repos sincronizados, próxima re-sincronización en { $interval } min (Ctrl-C para detener)
recipe-repo-unreachable = repositorio de recetas '{ $url }' inaccesible — omitiendo ({ $err }); continuando con los repositorios accesibles
repos-registry-corrupt = el registro de repositorios '{ $path }' está corrupto ({ $err }) — moviéndolo a '{ $bak }' y empezando de nuevo
repos-registry-backup-failed = no se pudo respaldar el registro corrupto { $path }
repos-none-configured = no hay [[recipe_repos]] configurados
repos-col-repo = repositorio
repos-col-state = estado
repos-col-last = última sincronización
repos-col-count = recetas
repos-state-archived = archivado
repos-state-synced = sincronizado
repos-state-not-cloned = sin clonar
repos-sync-dry-reclone = [dry-run] volvería a clonar el repositorio de recetas { $url } → { $dir }
repos-sync-dry-sync = [dry-run] clonaría/actualizaría el repositorio de recetas { $url } → { $dir }
repos-none-synced = ningún repositorio de recetas sincronizado (todos inaccesibles o archivados)
archive-config-dir-fail = no se pudo determinar el directorio de configuración global (dirs::config_dir)
archive-dry-archive = [dry-run] archivaría '{ $url }' en { $path }
archive-dry-unarchive = [dry-run] desarchivaría '{ $url }' en { $path }
archive-done = archivado '{ $url }' en { $path }
unarchive-done = desarchivado '{ $url }' en { $path }

# --- promote (src/promote.rs) ---
promote-repo-not-configured = el repositorio '{ $url }' no es una entrada [[recipe_repos]] configurada — añádelo a la configuración (el promote necesita su token para el push)
promote-checkout-missing = el repositorio '{ $url }' no está sincronizado — ejecuta `sm121 repos sync` (dry-run: sin I/O de git)
promote-checkout-sync-fail = el repositorio '{ $url }' no está sincronizado — sincronízalo primero (sm121 repos sync)
promote-detached-head = el checkout { $path } está en detached HEAD — cambia a una rama primero
promote-same-repo = --from y --to deben ser repositorios distintos
promote-recipe-not-in-source = la receta '{ $recipe }' no se encontró en el checkout del repositorio de origen ({ $path }) — ¿está actualizado el checkout? (sm121 repos sync)
promote-recipe-in-target = la receta '{ $recipe }' ya existe en el repositorio de destino — no se sobrescribe (elimínala allí primero)
promote-cp-failed = cp falló: { $err }
promote-cp-context = ejecutando cp
promote-target-dir-context = directorio recipes/ del destino
promote-run-start = promoviendo '{ $recipe }' de { $from } a { $to } ({ $count } { $count ->
        [one] paso
       *[other] pasos
    })
promote-source-checkout = checkout de origen: { $path }
promote-target-checkout = checkout de destino: { $path }
promote-step-line = [{ $side }] { $description }
promote-done = promovida '{ $recipe }' — el destino ya la tiene; la próxima sincronización de ambos repositorios consolida el movimiento
promote-dry-head = [dry-run] promovería '{ $recipe }' de { $from } a { $to }:
promote-dry-suppressed = (suprimido: -d dry-run tiene prioridad sobre --apply)
promote-run-apply-hint = vuelve a ejecutar con --apply para aplicarlo

# --- registry image source (src/docker/registry_pull.rs) ---
registry-needs-registry = --image-source registry requiere una sección [registry] en la configuración
registry-ref-map-fail = no se pudo mapear la imagen '{ $image }' a un ref del registro bajo base '{ $base }' (el nombre de la imagen debe ser un <name>[:tag] simple)
registry-pull-context = pull del registro en '{ $node }'
registry-present = la imagen '{ $image }' del registro ya está en '{ $node }' (la etiqueta checksum coincide)
registry-pulled = descargada '{ $ref }' → '{ $image }' en '{ $node }' (etiqueta checksum verificada)
registry-dry-run = [dry-run] --image-source registry: descargaría { $ref } → etiqueta '{ $image }' en { $count } { $count ->
        [one] nodo
       *[other] nodos
    } (checksum { $checksum }…)
registry-tag-not-found = { $node }: el tag '{ $ref }' no está en el registro — compílalo y haz push primero (sm121 build --recipe { $recipe } --build-node <node>), o vuelve a --image-source repo
registry-tag-failed = { $node }: docker tag falló tras la descarga
registry-label-mismatch = { $node }: la etiqueta sm121.checksum de la imagen descargada es '{ $got }', se esperaba '{ $checksum }' — el tag del registro no lleva esta build
registry-output-unparseable = { $node }: salida de la descarga ilegible: { $out }
registry-pull-failed = --image-source registry falló en: { $failed }

# --- drop_caches hook (src/docker/mod.rs) ---
drop-caches-start = Vaciando la caché de páginas en todos los nodos...
drop-caches-failed = drop_caches en { $node } falló: { $err }