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 } ===
container-count = Conteneurs totaux : { $count }
no-sm121-containers = (aucun conteneur sm121)
docker-unavailable = ✗ Docker indisponible
ssh-error = { $node } ({ $ip }) : ✗ Erreur SSH : { $error }
task-join-error = ✗ Erreur de jointure de tâche : { $error }
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 } ---
stop-failed = Échec de l'arrêt sur { $name } : { $error }
remove-failed = Échec de la suppression sur { $name } : { $error }
failed-to = Échec de { $action } sur { $name } : { $error }
health-section = === Cluster : { $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
health-total = Conteneurs totaux : { $count }
health-docker-unavailable = ✗ Docker indisponible
docker-error-line = { $err }
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-invalid = { $label } ({ $extra }) : entity invalide '{ $extra }'
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
ha-entity-error = { $name } : entité '{ $entity }' : { $error }
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
ha-config-required-for-power-on = ❌ Config HA requise pour l'allumage
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
power-off-container-stop-failed = ⚠️ Échec de l'arrêt des conteneurs sur le nœud { $name } : { $error}

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-entry-stopped = { $recipe } — { $node }: arrêté
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-prepare-failed = préparation venv : nœud { $name } échec : { $error }
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é)