launcher/locales/fr/main.ftl

cluster-not-found = Cluster « { $name } » introuvable
nccl-config-missing = Configuration NCCL introuvable
cluster-auto-fail = Aucun cluster approprié trouvé
cluster-selected = ✅ Cluster sélectionné automatiquement : { $name } ({ $nodes } { $nodes ->
        [one] nœud
       *[other] nœuds
    })
container-log-header = 📜 Logs de conteneur les plus récents :
cluster-stopping = 🛑 Arrêt du cluster '{ $name }'...
cluster-all-stopped = ✅ Tous les conteneurs arrêtés.
cluster-section = === Cluster : { $name } ===
doctor-header = 🩺 Doctor: { $name } ({ $engine }) [backend : { $backend }]

doctor-node-section = --- { $name } ---
doctor-all-passed = ✅ Toutes les vérifications réussies !
doctor-checks-failed = ⚠ Certaines vérifications ont échoué. Lancez avec --repair pour la correction automatique.
doctor-repairing = 🔧 Réparation de l'image...
doctor-repaired = ✅ Image réparée : { $tag }
doctor-dry-build = (dry-run) Construirait { $tag } sur { $node }
logs-follow-head = 📜 Suivi des logs de '{ $name }' (nœud head)...
logs-section = --- { $name } ---
health-cluster-header = === { $name } === { $nodes } { $nodes ->
        [one] nœud
       *[other] nœuds
    }

health-switch-off = 🚫 switch éteint
health-interface-down = 🌐 interface indisponible
health-all-online = ✅ tous en ligne
health-partial-online =   ({ $online } en ligne, { $offline } hors ligne)

health-node-online-cluster-down =   ◍ { $name } ({ $ip }){ $net } — en ligne (cluster hors ligne)
health-free-count = — { $free } libres
health-cluster-down = ⏻ cluster hors ligne

health-soft-off = ⚙ { $list } éteint (non bloquant)
health-net-status =  [réseau : { $details }]
health-no-containers = (aucun conteneur)
health-no-containers-inline = , aucun conteneur
exec-header = ⚡ exec : { $cmd } ({ $nodes } { $nodes ->
        [one] nœud
       *[other] nœuds
    })

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

exec-completed-errors = exec terminé avec des erreurs (certains nœuds ont signalé des échecs)
power-off-dryrun = dry-run : extinction réelle + appel HA ignorés
power-off-mikrotik-skip = { $entity } est un appareil API RouterOS ({ $address }) — HA ignoré
power-off-mikrotik-would = ferait : RouterOS /system/shutdown { $name } ({ $address })
power-off-mikrotik-failed = { $name } : arrêt RouterOS en échec ({ $error })
power-on-mikrotik-manual = { $name } : appareil RouterOS — pas d'allumage distant ; allumer manuellement
power-on-mikrotik-manual-would = ferait : allumer { $name} manuellement (RouterOS n'a pas d'on distant)
power-off-mikrotik-relay = { $name }: prise { $relay } coupée (alimentation interrompue)
power-off-mikrotik-relay-would = action : couper la prise { $relay } (coupe le courant de { $name })
power-off-mikrotik-relay-failed = { $name }: impossible de couper la prise { $relay } ({ $error }) — vérifier que le courant est coupé
power-on-mikrotik-relay-would = ferait : activer le relais { $relay} (alimente { $name})
power-off-would = serait : { $action } { $target }
power-off-shutdown-failed = ✗ { $name } :: { $cmd } :: { $error }

power-off-waiting = ⏳ attente { $secs}s pour stabilisation des nœuds
power-off-no-ha = pas de config [home_assistant] ; l'extinction OS a été effectuée ci-dessus
power-off-ssh-failures = certains nœuds ont signalé des erreurs SSH pendant l'extinction
power-on-dryrun = dry-run : appel HA réel ignoré
power-on-would-on = serait : HA turn_on { $entity }
power-on-would-skip = serait ignoré : { $name } (pas d'entity)
power-on-head = 💡 allumage : { $nodes } nœud(s)
ha-invalid-entity = { $name } : entity invalide '{ $entity }' : { $error }
ha-call-failed = HA { $service } { $entity } : { $error }

ha-skip-no-entity = ⚠ { $name } : pas d'`entity` configurée, HA ignoré
ha-extra-failed = HA { $service } { $extra } ({ $label }) : { $error }

power-switch-would-off = serait : HA turn_off { $entity }
power-switch-would-off-extra = serait : HA turn_off { $extra } (des extras)
power-switch-would-on = serait : HA turn_on { $entity }
power-switch-would-on-extra = serait : HA turn_on { $extra } (vers extras)
power-switch-shutdown-failed = ✗ { $name } extinction : { $error }
power-switch-waiting = ⏳ attente { $secs}s pour l'extinction
power-switch-no-ha = pas de config [home_assistant] ; l'extinction OS a été effectuée
power-off-entity-would = serait : HA turn_off { $entity }
pre-serve-skip = ⏭ Hooks pre-serve ignorés (--skip-before-serve)
pre-serve-failed = pre-serve : nœud { $name } échec : { $error }
pre-serve-run = { $node } ({ $tag }) :: { $cmd }
pre-serve-ignored = ⚠ { $cmd } ignoré : { $error }
host-key-header = Clés hôtes découvertes :
host-key-line = { $name } ({ $ip }) -> host_key = { $key }
host-key-error = { $name } ({ $ip }) -> erreur : { $error }
host-key-no-match = (aucun nœud correspondant)
recipe-starting = 🚀 Démarrage de la recette : { $name } ({ $engine }) [backend : { $backend }]
cluster-switch-off-detected = ⚠️ L'interrupteur du cluster semble éteint
cluster-switch-powered-on = ✅ Interrupteur du cluster allumé
cluster-waiting-for-nodes = ⏳ En attente de la disponibilité des nœuds...
cluster-nodes-available = ✅ Tous les nœuds sont maintenant disponibles
cluster-nodes-not-available-timeout = ❌ Délai dépassé en attente des nœuds
logs-header = 📜 Logs du cluster '{ $name }' ({ $count } nœuds)
engine-started = ✅ { $engine } démarré sur { $name } (rang { $rank })
engine-start-failed = Échec du démarrage de { $engine } sur { $name } (rang { $rank }) : { $error }
cluster-started = 🎉 Cluster démarré ! API → http://{ $ip }:{ $port }

exec-both-specified = Spécifier --cluster ou --recipe, pas les deux
exec-missing = Spécifier --cluster ou --recipe
exec-node-not-found = Nœud '{ $name }' introuvable dans le cluster '{ $cluster }'
exec-cluster-empty = Le cluster '{ $name }' n'a pas de nœuds
exec-cannot-use-alias = Impossible d'utiliser --alias avec une commande finale
exec-must-specify = Spécifier --alias <nom> ou une commande après `--`
exec-unknown-alias-empty = Alias inconnu @{ $name } (aucun alias configuré)
exec-unknown-alias-list = Alias inconnu @{ $name } ; alias connus : { $aliases }
mods-uploading = 📤 Téléchargement des mods vers { $node }...
mods-uploaded = ✅ Mods téléchargés vers { $node }
mods-entrypoint-required = La recette '{ $name }' a des mods mais pas d'entrypoint ; l'entrypoint est requis quand des mods sont présents

after-stop-failed = after_stop : nœud { $name } échec : { $error }
after-stop-run = { $node } ({ $tag }) :: { $cmd }
after-stop-ignored = ⚠ { $cmd } ignoré : { $error }
solo-node-selected = 🎯 Solo : nœud { $name } sélectionné dans le cluster { $cluster }

# --- Chaînes qui contornaient auparavant le système i18n (hardcodées) ---
boot-wait = ⏳ Attente { $secs}s du démarrage des nœuds...
doctor-found-repaired = 🩺 Image réparée trouvée : { $tag }
tmux-waiting-head = ⏳ Attente de la disponibilité du nœud head...
tmux-head-ready = ✅ Nœud head prêt. Démarrage des nœuds worker...
tmux-head-api-ready = API du nœud head prête (tentative { $attempt })
tmux-session-started = ✅ Session démarrée sur { $name }
tmux-stopped = ✅ '{ $sess }' arrêtée sur { $name }
tmux-all-stopped = ✅ Toutes les sessions tmux arrêtées.
tmux-all-ok = ✅ TOUT EST OK
tmux-issues = ⚠️  { $issues }
tmux-cluster-healthy = ✅ Le cluster est sain !
tmux-node-section = --- { $name } ({ $sess }) ---
tmux-node-no-output = --- { $name } — aucune sortie ---
tmux-session-created = ✅ Session tmux créée sur { $name }
tmux-no-pty = (russh ne supporte pas le PTY interactif. Utilisez la commande suivante directement :)
sync-digest-match = '{ $name }' OK (digest correspond)
sync-syncing = { $name } ({ $ip }) : synchronisation...
sync-synced = { $name } OK
sync-fabric-fallback = { $name }: saut 200G échoué ({ $err }) — repli sur mgmt 10G ; corriger le ssh inter-nœuds sur le fabric (authorized_keys / host keys pour les adresses 200.x)
health-node-offline =   ✗ { $name } ({ $ip }) — hors ligne
health-node-idle = ○ { $name } ({ $ip }){ $net }

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

health-container-count = , { $count } { $count ->
        [one] conteneur
       *[other] conteneurs
    }

power-off-head = 🛑 extinction : { $nodes } nœud(s) — sudo shutdown now
power-switch-head = 🔌 commutation : { $from } → { $to } ({ $nodes } nœud(s) + { $entities } entité(s) à désactiver)
power-switch-powering-on = 💡 commutation : allumage de { $nodes } nœud(s) + { $entities } entité(s) vers { $to }
health-task-join = erreur de jointure de tâche : { $error }
health-no-recipes = Aucun conteneur sm121 en cours d'exécution.
health-running-recipes = Recettes en cours d'exécution :
health-recipe-line =   { $recipe } — { $nodes } { $nodes ->
        [one] nœud
       *[other] nœuds
    } : { $list }

tmux-ray-backend = 🐍 Backend Ray détecté — démarrage du nœud head en premier...
tmux-mp-backend = 🔗 Backend MP détecté — démarrage de tous les nœuds en parallèle...
tmux-following-logs = 📜 Suivi des logs de '{ $sess }' sur { $name }...
composed-dir-dry-run = [simulation] création du répertoire de modèle composé '{ $host }' sur '{ $node }' (montage : { $mount }, { $sources } { $sources ->
        [one] source
       *[other] sources
    }, { $files } { $files ->
        [one] fichier
       *[other] fichiers
    }, { $local } { $local ->
        [one] fichier local
       *[other] fichiers locaux
    })
composed-dir-built = Répertoire de modèle composé créé : '{ $host }' sur '{ $node }' ({ $sources } { $sources ->
        [one] source
       *[other] sources
    }, { $files } { $files ->
        [one] fichier
       *[other] fichiers
    }, { $local } { $local ->
        [one] fichier local
       *[other] fichiers locaux
    })
tmux-mods-unsupported = Recipe '{ $name }' utilise [mods], ce qui est Docker-only. Le déploiement tmux ne prend pas en charge les mods.
tmux-deploy-ignored-opts = ⚠️ tmux deploy : ignore les options CLI Docker-only : { $opts }
tmux-composed-model-unsupported = Recipe '{ $name }' utilise [composed_model], ce qui est Docker-only. Le déploiement tmux ne prend pas en charge les répertoires de modèles composés.
tmux-health-section = Tmux:
tmux-health-entry-running = { $recipe } — { $node }: en cours (API : { $api })
tmux-health-entry-degraded = { $recipe } — { $node }: dégradé (la session existe, processus mort)
tmux-health-all-stopped = { $count ->
    [one] { $count } recette tmux configurée, toutes arrêtées
   *[other] { $count } recettes tmux configurées, toutes arrêtées
}
tmux-api-ok = 200
tmux-api-down = arrêté
venv-preparing = 🔧 Préparation du venv : { $venv }
venv-exists = ✓ venv existe déjà sur { $name }
venv-creating = venv non trouvé sur { $name } — création...
venv-created = ✓ venv créé avec succès sur { $name }
venv-not-created = venv n'a pas été créé avec succès sur { $name } — les commandes de configuration ont été exécutées mais le script activate est manquant

# health render module (plain/md/html)
health-nodes-count = { $nodes } { $nodes ->
        [one] nœud
       *[other] nœuds
    }
health-col-node = Nœud
health-col-address = Adresse
health-col-status = Statut

health-col-containers = Conteneurs
health-col-container = Conteneur

health-col-image = Image

health-col-recipe = Recette
health-col-cluster = Cluster

health-col-nodes = Nœuds
health-status-online = ● en ligne

health-status-offline = ✗ hors ligne

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

dry-run-would-push = [dry-run] pousserait { $ref} (et mettrait à jour { $latest }) après le build
push-mapping-failed = impossible d'associer [registry].base { $base } à un ref de push pour { $image }
pushing-image = Push de l'image vers { $ref} (tmux : { $session })...
push-timeout = Le push de { $ref} sur { $node} a expiré après { $elapsed} — examiner la session tmux { $session} / le log { $log} sur le nœud.
push-failed = Le push de { $ref} sur { $node} a échoué après { $elapsed}.\n{ $log }\nAstuce : si le log affiche unauthorized/denied — exécuter `docker login { $host }` sur { $node} (le launcher ne stocke aucune credential de registre).
pushed-image = Image { $ref} poussée, { $latest} mise à jour ({ $elapsed })
push-running = Push en cours depuis { $elapsed }...
push-already-published = { $ref} déjà publié ({ $label}) : digest d'image inchangé — ignoré, utiliser --force pour repousser

power-on-on = { $name }: allumé
power-on-cycled = { $name }: la prise était on mais le nœud est éteint — alimentation recycler
power-on-was-on = { $name }: prise déjà on (nœud actif ?) — laissée telle quelle
power-on-skip = { $name }: pas d'entité HA — ignoré
power-on-failed = { $name }: échec HA : { $error }
power-on-cycling = ⟳ { $name }: la prise est on mais le nœud ne répond pas — cycle d'alimentation { $entity }
power-on-off-wait-timeout = { $name }: la prise n'a pas signalé off en 10 s (relais possiblement bloqué)

report-col-launches = Lancements
report-col-up = Actif
report-col-engine = Moteur
report-col-last = Dernier bench
report-col-model = Modèle
report-col-nodes = Nœuds×TP
report-col-points = Points
report-col-prov = Provenance
report-col-quant = Quant.
stop-not-verified = Conteneurs non vérifiés comme arrêtés sur : { $nodes }

report-col-recipe = Recette
report-col-reports = Rapports
report-col-score = Score /100
report-col-tps1 = Tok/s c1
report-col-tps2 = Tok/s c2
report-serving = Rapport interactif des recettes : { $url }  (mises à jour en direct ; Ctrl-C pour arrêter)
report-title = Recettes testées ({ $count })

# --- recipe repos (src/recipe_repos.rs) ---
git-failed = git { $cmd } a échoué : { $err }
recipe-repo-archived-skip = dépôt de recettes archivé — ignoré : { $url }
recipe-repo-synced = dépôt de recettes synchronisé : { $url } → { $dir }
recipe-repo-watch = repos watch : { $n } dépôt(s) synchronisé(s), prochaine re-synchronisation dans { $interval } min (Ctrl-C pour arrêter)
recipe-repo-unreachable = dépôt de recettes '{ $url }' injoignable — ignoré ({ $err}) ; poursuite avec les dépôts joignables
repos-registry-corrupt = le registre des dépôts '{ $path }' est corrompu ({ $err }) — déplacé vers '{ $bak }' et repart de zéro
repos-registry-backup-failed = impossible de sauvegarder le registre corrompu { $path }
repos-none-configured = aucun [[recipe_repos]] configuré
repos-col-repo = dépôt
repos-col-state = état
repos-col-last = dernière synchro
repos-col-count = recettes
repos-state-archived = archivé
repos-state-synced = synchronisé
repos-state-not-cloned = non cloné
repos-sync-dry-reclone = [dry-run] re-clonerait le dépôt de recettes { $url } → { $dir }
repos-sync-dry-sync = [dry-run] clonerait/mettrait à jour le dépôt de recettes { $url } → { $dir }
repos-none-synced = aucun dépôt de recettes synchronisé (tous injoignables ou archivés)
archive-config-dir-fail = impossible de déterminer le répertoire de config global (dirs::config_dir)
archive-dry-archive = [dry-run] archiverait '{ $url }' dans { $path }
archive-dry-unarchive = [dry-run] désarchiverait '{ $url }' dans { $path }
archive-done = archivé '{ $url }' dans { $path }
unarchive-done = désarchivé '{ $url }' dans { $path }

# --- promote (src/promote.rs) ---
promote-repo-not-configured = le dépôt '{ $url }' n'est pas une entrée [[recipe_repos]] configurée — ajoute-le à la config (le promote a besoin de son token pour le push)
promote-checkout-missing = le dépôt '{ $url }' n'est pas synchronisé — lance `sm121 repos sync` (dry-run : pas d'I/O git)
promote-checkout-sync-fail = le dépôt '{ $url }' n'est pas synchronisé — synchronise-le d'abord (sm121 repos sync)
promote-detached-head = le checkout { $path } est en detached HEAD — passe d'abord sur une branche
promote-same-repo = --from et --to doivent être des dépôts différents
promote-recipe-not-in-source = la recette '{ $recipe }' est introuvable dans le checkout du dépôt source ({ $path }) — le checkout est-il à jour ? (sm121 repos sync)
promote-recipe-in-target = la recette '{ $recipe }' existe déjà dans le dépôt cible — écrasement refusé (supprime-la d'abord là-bas)
promote-cp-failed = cp a échoué : { $err }
promote-cp-context = exécution de cp
promote-target-dir-context = répertoire recipes/ de la cible
promote-run-start = promotion de '{ $recipe }' de { $from } vers { $to } ({ $count } { $count ->
        [one] étape
       *[other] étapes
    })
promote-source-checkout = checkout source : { $path }
promote-target-checkout = checkout cible : { $path }
promote-step-line = [{ $side }] { $description }
promote-done = promue '{ $recipe }' — la cible l'a désormais ; la prochaine synchro des deux dépôts consolide le déplacement
promote-dry-head = [dry-run] promouvrait '{ $recipe }' de { $from } vers { $to } :
promote-dry-suppressed = (supprimé : -d dry-run l'emporte sur --apply)
promote-run-apply-hint = relance avec --apply pour exécuter

# --- registry image source (src/docker/registry_pull.rs) ---
registry-needs-registry = --image-source registry exige une section [registry] dans la config
registry-ref-map-fail = impossible de mapper l'image '{ $image }' vers un ref du registre sous base '{ $base }' (le nom d'image doit être un simple <name>[:tag])
registry-pull-context = pull du registre sur '{ $node }'
registry-present = l'image '{ $image }' du registre est déjà présente sur '{ $node }' (label checksum identique)
registry-pulled = récupérée '{ $ref }' → '{ $image }' sur '{ $node }' (label checksum vérifié)
registry-dry-run = [dry-run] --image-source registry : tirerait { $ref } → tag '{ $image }' sur { $count } { $count ->
        [one] nœud
       *[other] nœuds
    } (checksum { $checksum }…)
registry-tag-not-found = { $node } : le tag '{ $ref }' n'est pas dans le registre — build + push d'abord (sm121 build --recipe { $recipe } --build-node <node>), ou reviens à --image-source repo
registry-tag-failed = { $node } : docker tag a échoué après le pull
registry-label-mismatch = { $node } : le label sm121.checksum de l'image récupérée est '{ $got }', attendu '{ $checksum }' — le tag du registre ne porte pas cette build
registry-output-unparseable = { $node } : sortie du pull ininterprétable : { $out }
registry-pull-failed = --image-source registry a échoué sur : { $failed }

# --- drop_caches hook (src/docker/mod.rs) ---
drop-caches-start = Vide le cache de pages sur tous les nœuds...
drop-caches-failed = drop_caches sur { $node } a échoué : { $err }