launcher/locales/it/main.ftl

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 } ===
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 } ---
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
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-off-extras-skipped = spegnimento parziale ({ $nodes }): entità del cluster lasciate accese ({ $extras }) — condivise dai nodi attivi
power-off-extras-held = { $entity } lasciata accesa — ancora in uso da un'esecuzione attiva sul/i cluster: { $clusters }
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-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
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 }]
cold-applied = ❄ --cold: applicati i cold_args della ricetta sopra i suoi args
cold-no-block = ❄ --cold: la ricetta '{ $name }' non ha cold_args; servizio con args normali
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
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

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-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-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 })

# --- recipe repos (src/recipe_repos.rs) ---
git-failed = git { $cmd } è fallito: { $err }
recipe-repo-archived-skip = repository di ricette archiviato — salto: { $url }
recipe-repo-synced = repository di ricette sincronizzato: { $url } → { $dir }
recipe-repo-watch = repos watch: { $n } repo sincronizzati, prossima re-sincronizzazione tra { $interval } min (Ctrl-C per fermare)
recipe-repo-unreachable = repository di ricette '{ $url }' non raggiungibile — salto ({ $err }); proseguo con i repository raggiungibili
repos-registry-corrupt = il registro dei repository '{ $path }' è corrotto ({ $err }) — lo sposto in '{ $bak }' e riparto
repos-registry-backup-failed = impossibile salvare una copia del registro corrotto { $path }
repos-none-configured = nessun [[recipe_repos]] configurato
repos-col-repo = repository
repos-col-state = stato
repos-col-last = ultima sincronizzazione
repos-col-count = ricette
repos-state-archived = archiviato
repos-state-synced = sincronizzato
repos-state-not-cloned = non clonato
repos-sync-dry-reclone = [dry-run] riclonerebbe il repository di ricette { $url } → { $dir }
repos-sync-dry-sync = [dry-run] clonerebbe/aggiornerebbe il repository di ricette { $url } → { $dir }
repos-none-synced = nessun repository di ricette sincronizzato (tutti irraggiungibili o archiviati)
archive-config-dir-fail = impossibile determinare la directory di configurazione globale (dirs::config_dir)
archive-dry-archive = [dry-run] archiverebbe '{ $url }' in { $path }
archive-dry-unarchive = [dry-run] de-archiverebbe '{ $url }' in { $path }
archive-done = archiviato '{ $url }' in { $path }
unarchive-done = de-archiviato '{ $url }' in { $path }

# --- promote (src/promote.rs) ---
promote-repo-not-configured = il repository '{ $url }' non è una voce [[recipe_repos]] configurata — aggiungilo alla configurazione (il promote richiede il suo token per il push)
promote-checkout-missing = il repository '{ $url }' non è sincronizzato — esegui `sm121 repos sync` (dry-run: nessun I/O git)
promote-checkout-sync-fail = il repository '{ $url }' non è sincronizzato — sincronizzalo prima (sm121 repos sync)
promote-detached-head = il checkout { $path } è in detached HEAD — passa prima a un branch
promote-same-repo = --from e --to devono essere repository diversi
promote-recipe-not-in-source = la ricetta '{ $recipe }' non è stata trovata nel checkout del repository di origine ({ $path }) — il checkout è aggiornato? (sm121 repos sync)
promote-recipe-in-target = la ricetta '{ $recipe }' esiste già nel repository di destinazione — sovrascrittura rifiutata (rimuovila prima lì)
promote-cp-failed = cp è fallito: { $err }
promote-cp-context = esecuzione di cp
promote-target-dir-context = directory recipes/ della destinazione
promote-run-start = promuovo '{ $recipe }' da { $from } a { $to } ({ $count } { $count ->
        [one] passo
       *[other] passi
    })
promote-source-checkout = checkout di origine: { $path }
promote-target-checkout = checkout di destinazione: { $path }
promote-step-line = [{ $side }] { $description }
promote-done = promossa '{ $recipe }' — la destinazione ce l'ha; la prossima sincronizzazione di entrambi i repository consolida lo spostamento
promote-dry-head = [dry-run] promuoverebbe '{ $recipe }' da { $from } a { $to }:
promote-dry-suppressed = (soppresso: -d dry-run ha precedenza su --apply)
promote-run-apply-hint = esegui di nuovo con --apply per applicare

# --- registry image source (src/docker/registry_pull.rs) ---
registry-needs-registry = --image-source registry richiede una sezione [registry] nella configurazione
registry-ref-map-fail = impossibile mappare l'immagine '{ $image }' a un ref del registro sotto base '{ $base }' (il nome immagine deve essere un semplice <name>[:tag])
registry-pull-context = pull dal registro su '{ $node }'
registry-present = l'immagine '{ $image }' dal registro è già presente su '{ $node }' (etichetta checksum corrispondente)
registry-pulled = scaricata '{ $ref }' → '{ $image }' su '{ $node }' (etichetta checksum verificata)
registry-dry-run = [dry-run] --image-source registry: scaricherebbe { $ref } → tag '{ $image }' su { $count } { $count ->
        [one] nodo
       *[other] nodi
    } (checksum { $checksum }…)
registry-tag-not-found = { $node }: il tag '{ $ref }' non è nel registro — compila e fai push prima (sm121 build --recipe { $recipe } --build-node <node>), o torna a --image-source repo
registry-tag-failed = { $node }: docker tag fallito dopo il download
registry-label-mismatch = { $node }: l'etichetta sm121.checksum dell'immagine scaricata è '{ $got }', atteso '{ $checksum }' — il tag del registro non contiene questa build
registry-output-unparseable = { $node }: output del download non interpretabile: { $out }
registry-pull-failed = --image-source registry è fallito su: { $failed }

# --- drop_caches hook (src/docker/mod.rs) ---
drop-caches-start = Svuoto la cache di pagina su tutti i nodi...
drop-caches-failed = drop_caches su { $node } è fallito: { $err }