cluster-not-found = Cluster "{ $name }" non trovato
nccl-config-missing = Config NCCL non trovata
cluster-auto-fail = Nessun cluster adatto trovato
cluster-selected = ✅ Cluster selezionato automaticamente: { $name } ({ $nodes } { $nodes ->
        [one] nodo
       *[other] nodi
    })
container-log-header = 📜 Log dei container più recenti:
cluster-stopping = 🛑 Arresto del cluster '{ $name }'...
cluster-all-stopped = ✅ Tutti i container arrestati.
cluster-section = === Cluster: { $name } ===
container-count = Container totali: { $count }
no-sm121-containers = (nessun container sm121)
docker-unavailable = ✗ Docker non disponibile
ssh-error = { $node } ({ $ip }): ✗ Errore SSH: { $error }
task-join-error = ✗ Errore di join dell'attività: { $error }
doctor-header = 🩺 Doctor: { $name } ({ $engine }) [backend: { $backend }]

doctor-node-section = --- { $name } ---
doctor-all-passed = ✅ Tutti i controlli superati!
doctor-checks-failed = ⚠ Alcuni controlli falliti. Eseguire con --repair per l'auto-fix.
doctor-repairing = 🔧 Riparazione dell'immagine...
doctor-repaired = ✅ Immagine riparata: { $tag }
doctor-dry-build = (dry-run) Costruirebbe { $tag } su { $node }
logs-follow-head = 📜 Seguendo i log di '{ $name }' (nodo head)...
logs-section = --- { $name } ---
stop-failed = Arresto fallito su { $name }: { $error }
remove-failed = Rimozione fallita su { $name }: { $error }
failed-to = { $action } fallita su { $name }: { $error }
health-section = === Cluster: { $name } ===
health-cluster-header = === { $name } === { $nodes } { $nodes ->
        [one] nodo
       *[other] nodi
    }

health-switch-off = 🚫 switch spento
health-interface-down = 🌐 interfaccia down
health-all-online = ✅ tutti online
health-partial-online =   ({ $online } online, { $offline } offline)

health-node-online-cluster-down =   ◍ { $name } ({ $ip }){ $net } — online (cluster offline)
health-free-count = — { $free } liberi
health-cluster-down = ⏻ cluster offline

health-soft-off = ⚙ { $list } spento (non bloccante)
health-net-status =  [rete: { $details }]
health-no-containers = (nessun container)
health-no-containers-inline = , nessun container
health-total = Container totali: { $count }
health-docker-unavailable = ✗ Docker non disponibile
docker-error-line = { $err }
exec-header = ⚡ exec: { $cmd } ({ $nodes } { $nodes ->
        [one] nodo
       *[other] nodi
    })

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

exec-completed-errors = exec completato con errori (alcuni nodi hanno riportato fallimenti)
power-off-dryrun = dry-run: saltando spegnimento reale + chiamata HA
power-off-mikrotik-skip = { $entity } è un dispositivo API RouterOS ({ $address }) — HA saltato
power-off-mikrotik-would = eseguirebbe: RouterOS /system/shutdown { $name } ({ $address })
power-off-mikrotik-failed = { $name }: arresto RouterOS fallito ({ $error })
power-on-mikrotik-manual = { $name }: dispositivo RouterOS — nessun accensione remota; accendere manualmente
power-on-mikrotik-manual-would = eseguirebbe: accendere { $name} manualmente (RouterOS non ha on remoto)
power-off-mikrotik-relay = { $name }: presa { $relay } spenta (alimentazione interrotta)
power-off-mikrotik-relay-would = azione: spegnere la presa { $relay } (toglie corrente a { $name })
power-off-mikrotik-relay-failed = { $name }: impossibile spegnere la presa { $relay } ({ $error }) — verificare che sia senza corrente
power-on-mikrotik-relay-would = eseguirebbe: attivare il relé { $relay} (alimenta { $name})
power-off-would = sarebbe: { $action } { $target }
power-off-shutdown-failed = ✗ { $name } :: { $cmd } :: { $error }

power-off-waiting = ⏳ attesa { $secs}s per assestamento dei nodi
power-off-no-ha = nessuna config [home_assistant]; spegnimento OS eseguito sopra
power-off-ssh-failures = alcuni nodi hanno riportato errori SSH durante lo spegnimento
power-on-dryrun = dry-run: saltando chiamata HA reale
power-on-would-on = sarebbe: HA turn_on { $entity }
power-on-would-skip = saltato: { $name } (nessuna entity)
power-on-head = 💡 accensione: { $nodes } nodo/i
ha-invalid-entity = { $name }: entity non valida '{ $entity }': { $error }
ha-call-failed = HA { $service } { $entity }: { $error }

ha-skip-no-entity = ⚠ { $name }: nessuna `entity` configurata, salto HA
ha-extra-invalid = { $label } ({ $extra }): entity non valida '{ $extra }'
ha-extra-failed = HA { $service } { $extra } ({ $label }): { $error }

power-switch-would-off = sarebbe: HA turn_off { $entity }
power-switch-would-off-extra = sarebbe: HA turn_off { $extra } (da extras)
power-switch-would-on = sarebbe: HA turn_on { $entity }
power-switch-would-on-extra = sarebbe: HA turn_on { $extra } (verso extras)
power-switch-shutdown-failed = ✗ { $name } spegnimento: { $error }
power-switch-waiting = ⏳ attesa { $secs}s per spegnimento
ha-entity-error = { $name }: entità '{ $entity }': { $error }
power-switch-no-ha = nessuna config [home_assistant]; spegnimento OS eseguito
power-off-entity-would = sarebbe: HA turn_off { $entity }
pre-serve-skip = ⏭ Saltando hook pre-serve (--skip-before-serve)
pre-serve-failed = pre-serve: nodo { $name } fallito: { $error }
pre-serve-run = { $node } ({ $tag }) :: { $cmd }
pre-serve-ignored = ⚠ { $cmd } ignorato: { $error }
host-key-header = Chiavi host scoperte:
host-key-line = { $name } ({ $ip }) -> host_key = { $key }
host-key-error = { $name } ({ $ip }) -> errore: { $error }
host-key-no-match = (nessun nodo corrisponde)
recipe-starting = 🚀 Avvio ricetta: { $name } ({ $engine }) [backend: { $backend }]
cluster-switch-off-detected = ⚠️ Lo switch del cluster sembra spento
cluster-switch-powered-on = ✅ Switch del cluster acceso
cluster-waiting-for-nodes = ⏳ In attesa che i nodi siano disponibili...
cluster-nodes-available = ✅ Tutti i nodi ora sono disponibili
cluster-nodes-not-available-timeout = ❌ Timeout nell'attesa della disponibilità dei nodi
ha-config-required-for-power-on = ❌ Config HA richiesta per l'accensione
logs-header = 📜 Log del cluster '{ $name }' ({ $count } nodi)
engine-started = ✅ { $engine } avviato su { $name } (rango { $rank })
engine-start-failed = Avvio di { $engine } su { $name } (rango { $rank }) fallito: { $error }
cluster-started = 🎉 Cluster avviato! API → http://{ $ip }:{ $port }

exec-both-specified = Specificare --cluster o --recipe, non entrambi
exec-missing = Specificare --cluster o --recipe
exec-node-not-found = Nodo '{ $name }' non trovato nel cluster '{ $cluster }'
exec-cluster-empty = Il cluster '{ $name }' non ha nodi
exec-cannot-use-alias = Impossibile usare --alias con un comando finale
exec-must-specify = Specificare --alias <nome> o un comando dopo `--`
exec-unknown-alias-empty = Alias sconosciuto @{ $name } (nessun alias configurato)
exec-unknown-alias-list = Alias sconosciuto @{ $name }; alias noti: { $aliases }
mods-uploading = 📤 Caricamento mod su { $node }...
mods-uploaded = ✅ Mod caricati su { $node }
mods-entrypoint-required = La ricetta '{ $name }' ha mod ma nessun entrypoint; l'entrypoint è obbligatorio quando sono presenti mod
power-off-container-stop-failed = ⚠️ Impossibile arrestare i container sul nodo { $name }: { $error}

after-stop-failed = after_stop: nodo { $name } fallito: { $error }
after-stop-run = { $node } ({ $tag }) :: { $cmd }
after-stop-ignored = ⚠ { $cmd } ignorato: { $error }
solo-node-selected = 🎯 Solo: nodo { $name } selezionato nel cluster { $cluster }

# --- Stringhe che prima eludevano il sistema i18n (hardcodate) ---
boot-wait = ⏳ Attesa { $secs}s per l'avvio dei nodi...
doctor-found-repaired = 🩺 Trovata immagine riparata: { $tag }
tmux-waiting-head = ⏳ In attesa che il nodo head sia pronto...
tmux-head-ready = ✅ Nodo head pronto. Avvio dei nodi worker...
tmux-head-api-ready = API del nodo head pronta (tentativo { $attempt })
tmux-session-started = ✅ Sessione avviata su { $name }
tmux-stopped = ✅ '{ $sess }' arrestata su { $name }
tmux-all-stopped = ✅ Tutte le sessioni tmux arrestate.
tmux-all-ok = ✅ TUTTO OK
tmux-issues = ⚠️  { $issues }
tmux-cluster-healthy = ✅ Il cluster è sano!
tmux-node-section = --- { $name } ({ $sess }) ---
tmux-node-no-output = --- { $name } — nessun output ---
tmux-session-created = ✅ Sessione tmux creata su { $name }
tmux-no-pty = (russh non supporta PTY interattivo. Usa il seguente comando direttamente:)
sync-digest-match = '{ $name }' OK (digest corrisponde)
sync-syncing = { $name } ({ $ip }): sincronizzazione...
sync-synced = { $name } OK
sync-fabric-fallback = { $name }: hop 200G non riuscito ({ $err }) — fallback su mgmt 10G; correggere ssh nodo-nodo sulla fabric (authorized_keys / host key per gli indirizzi 200.x)
health-node-offline =   ✗ { $name } ({ $ip }) — offline
health-node-idle = ○ { $name } ({ $ip }){ $net }

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

health-container-count = , { $count } { $count ->
        [one] contenitore
       *[other] contenitori
    }

power-off-head = 🛑 spegnimento: { $nodes } nodo/i — sudo shutdown now
power-switch-head = 🔌 commuta: { $from } → { $to } ({ $nodes } nodo/i + { $entities } entità da disattivare)
power-switch-powering-on = 💡 commuta: accensione { $nodes } nodo/i + { $entities } entità verso { $to }
health-task-join = errore di join dell'attività: { $error }
health-no-recipes = Nessun container sm121 in esecuzione.
health-running-recipes = Ricette in esecuzione:
health-recipe-line =   { $recipe } — { $nodes } { $nodes ->
        [one] nodo
       *[other] nodi
    }: { $list }

tmux-ray-backend = 🐍 Backend Ray rilevato — avvio del nodo head per primo...
tmux-mp-backend = 🔗 Backend MP rilevato — avvio di tutti i nodi in parallelo...
tmux-following-logs = 📜 Seguendo i log da '{ $sess }' su { $name }...
composed-dir-dry-run = [prova] verrebbe creata la directory del modello composto '{ $host }' su '{ $node }' (montaggio: { $mount }, { $sources } { $sources ->
        [one] sorgente
       *[other] sorgenti
    }, { $files } { $files ->
        [one] file
       *[other] file
    }, { $local } { $local ->
        [one] file locale
       *[other] file locali
    })
composed-dir-built = Creata directory del modello composto '{ $host }' su '{ $node }' ({ $sources } { $sources ->
        [one] sorgente
       *[other] sorgenti
    }, { $files } { $files ->
        [one] file
       *[other] file
    }, { $local } { $local ->
        [one] file locale
       *[other] file locali
    })
tmux-mods-unsupported = Recipe '{ $name }' usa [mods], che è Docker-only. Il deployment tmux non supporta i mods.
tmux-deploy-ignored-opts = ⚠️ tmux deploy: ignoro le opzioni CLI Docker-only: { $opts }
tmux-composed-model-unsupported = Recipe '{ $name }' usa [composed_model], che è Docker-only. Il deployment tmux non supporta directory di modelli composti.
tmux-health-section = Tmux:
tmux-health-entry-running = { $recipe } — { $node }: in esecuzione (API: { $api })
tmux-health-entry-degraded = { $recipe } — { $node }: degradata (la sessione esiste, processo morto)
tmux-health-entry-stopped = { $recipe } — { $node }: fermato
tmux-health-all-stopped = { $count ->
    [one] { $count } ricetta tmux configurata, tutte fermate
   *[other] { $count } ricette tmux configurate, tutte fermate
}
tmux-api-ok = 200
tmux-api-down = giù
venv-preparing = 🔧 Preparazione venv: { $venv }
venv-exists = ✓ venv esiste già su { $name }
venv-creating = venv non trovato su { $name } — creazione...
venv-created = ✓ venv creato con successo su { $name }
venv-prepare-failed = preparazione venv: nodo { $name } fallito: { $error }
venv-not-created = venv non creato correttamente su { $name } — i comandi di configurazione sono stati eseguiti ma manca lo script activate

# health render module (plain/md/html)
health-nodes-count = { $nodes } { $nodes ->
        [one] nodo
       *[other] nodi
    }
health-col-node = Nodo
health-col-address = Indirizzo
health-col-status = Stato

health-col-containers = Container
health-col-container = Contenitore

health-col-image = Immagine

health-col-recipe = Ricetta
health-col-cluster = Cluster

health-col-nodes = Nodi
health-status-online = ● online

health-status-offline = ✗ offline

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

dry-run-would-push = [dry-run] farebbe push di { $ref} (e aggiornerebbe { $latest }) dopo il build
push-mapping-failed = impossibile mappare [registry].base { $base } a un ref di push per { $image}
pushing-image = Push dell'immagine su { $ref} (tmux: { $session })...
push-timeout = Il push di { $ref} su { $node} è scaduto dopo { $elapsed} — ispezionare la sessione tmux { $session} / il log { $log} sul nodo.
push-failed = Il push di { $ref} su { $node} è fallito dopo { $elapsed}.\n{ $log }\nSuggerimento: se il log dice unauthorized/denied — eseguire `docker login { $host }` su { $node} (il launcher non salva credenziali del registro).
pushed-image = Immagine { $ref} pushata, { $latest} aggiornata ({ $elapsed })
push-running = Push in corso da { $elapsed }...
push-already-published = { $ref} già pubblicato ({ $label}): digest immagine invariato — saltato, usare --force per ripubblicare

power-on-on = { $name }: acceso
power-on-cycled = { $name }: la presa era on con il nodo spento — alimentazione ri-ciclata
power-on-was-on = { $name }: la presa è già on (nodo attivo?) — lasciata com'è
power-on-skip = { $name }: nessuna entità HA — saltato
power-on-failed = { $name }: errore HA: { $error }
power-on-cycling = ⟳ { $name }: la presa è on ma il nodo non risponde — ciclo di alimentazione { $entity }
power-on-off-wait-timeout = { $name }: la presa non ha riportato off entro 10 s (relè forse bloccato)

report-col-launches = Esecuzioni
report-col-up = Attivo
report-col-engine = Motore
report-col-last = Ultimo bench
report-col-model = Modello
report-col-nodes = Nodi×TP
report-col-points = Punti
report-col-prov = Provenienza
report-col-quant = Quant.
stop-not-verified = Contenitori non verificati come fermati su: { $nodes }

report-col-recipe = Ricetta
report-col-reports = Report
report-col-score = Punteggio /100
report-col-tps1 = Tok/s c1
report-col-tps2 = Tok/s c2
report-serving = Report interattivo delle ricette: { $url }  (aggiornamenti live; Ctrl-C per fermare)
report-title = Ricette testate ({ $count })