launcher/locales/de/main.ftl

cluster-not-found = Cluster "{ $name }" nicht gefunden
nccl-config-missing = NCCL-Konfiguration nicht gefunden
cluster-auto-fail = Kein geeigneter Cluster gefunden
cluster-selected = ✅ Automatisch ausgewählter Cluster: { $name } ({ $nodes } { $nodes ->
        [one] Knoten
       *[other] Knoten
    })
container-log-header = 📜 Neueste Container-Logs:
cluster-stopping = 🛑 Cluster '{ $name }' wird gestoppt...
cluster-all-stopped = ✅ Alle Container gestoppt.
cluster-section = === Cluster: { $name } ===
container-count = Container gesamt: { $count }
no-sm121-containers = (keine sm121-Container)
docker-unavailable = ✗ Docker nicht verfügbar
ssh-error = { $node } ({ $ip }): ✗ SSH-Fehler: { $error }
task-join-error = ✗ Fehler beim Aufgaben-Join: { $error }
doctor-header = 🩺 Doctor: { $name } ({ $engine }) [Backend: { $backend }]
doctor-node-section = --- { $name } ---
doctor-all-passed = ✅ Alle Prüfungen bestanden!
doctor-checks-failed = ⚠ Einige Prüfungen fehlgeschlagen. Mit --repair zum Auto-Fix ausführen.
doctor-repairing = 🔧 Image wird repariert...
doctor-repaired = ✅ Image repariert: { $tag }
doctor-dry-build = (dry-run) Würde { $tag } auf { $node } bauen
logs-follow-head = 📜 Logs für '{ $name }' (Head-Knoten) werden verfolgt...
logs-section = --- { $name } ---
stop-failed = Stop fehlgeschlagen auf { $name }: { $error }
remove-failed = Remove fehlgeschlagen auf { $name }: { $error }
failed-to = { $action } fehlgeschlagen auf { $name }: { $error }
health-section = === Cluster: { $name } ===
health-cluster-header = === { $name } === { $nodes } { $nodes ->
        [one] Knoten
       *[other] Knoten
    }
health-switch-off = 🚫 Switch aus
health-interface-down = 🌐 Schnittstelle down
health-all-online = ✅ alle online
health-partial-online =  ({ $online } online, { $offline } offline)
health-node-online-cluster-down =   ◍ { $name } ({ $ip }){ $net } — online (Cluster offline)
health-free-count = — { $free } frei
health-cluster-down = ⏻ Cluster offline
health-soft-off = ⚙ { $list } aus (nicht blockierend)
health-net-status =  [Netz: { $details }]
health-no-containers = (keine Container)
health-no-containers-inline = , keine Container
health-total = Container gesamt: { $count }
health-docker-unavailable = ✗ Docker nicht verfügbar
docker-error-line = { $err }
exec-header = ⚡ exec: { $cmd } ({ $nodes } { $nodes ->
        [one] Knoten
       *[other] Knoten
    })
exec-section = --- { $name } ---
exec-failed = ✗ { $name } :: { $cmd } :: { $error }
exec-completed-errors = exec mit Fehlern abgeschlossen (einige Knoten meldeten Fehler)
power-off-dryrun = dry-run: tatsächliches Herunterfahren + HA-Aufruf übersprungen
power-off-mikrotik-skip = { $entity } ist ein RouterOS-API-Gerät ({ $address }) — HA wird übersprungen
power-off-mikrotik-would = würde: RouterOS /system/shutdown { $name } ({ $address })
power-off-mikrotik-failed = { $name }: RouterOS-Shutdown fehlgeschlagen ({ $error })
power-on-mikrotik-manual = { $name }: RouterOS-Gerät — kein Remote-Einschalten; manuell einschalten
power-on-mikrotik-manual-would = würde: { $name} manuell einschalten (RouterOS hat kein Remote-On)
power-on-mikrotik-relay-would = würde: Relais { $relay} einschalten (versorgt { $name} mit Strom)
power-off-would = würde: { $action } { $target }
power-off-shutdown-failed = ✗ { $name } :: { $cmd } :: { $error }
power-off-waiting = ⏳ warte { $secs}s bis Knoten sich beruhigen
power-off-no-ha = keine [home_assistant]-Konfig; OS-Herunterfahren oben ausgeführt
power-off-ssh-failures = einige Knoten meldeten SSH-Fehler beim Herunterfahren
power-on-dryrun = dry-run: tatsächlicher HA-Aufruf übersprungen
power-on-would-on = würde: HA turn_on { $entity }
power-on-would-skip = würde überspringen: { $name } (keine Entity)
power-on-head = 💡 einschalten: { $nodes } Knoten
ha-invalid-entity = { $name }: ungültige Entity '{ $entity }': { $error }
ha-call-failed = HA { $service } { $entity }: { $error }
ha-skip-no-entity = ⚠ { $name }: keine `entity` konfiguriert, HA übersprungen
ha-extra-invalid = { $label } ({ $extra }): ungültige Entity '{ $extra }'
ha-extra-failed = HA { $service } { $extra } ({ $label }): { $error }
power-switch-would-off = würde: HA turn_off { $entity }
power-switch-would-off-extra = würde: HA turn_off { $extra } (von Extras)
power-switch-would-on = würde: HA turn_on { $entity }
power-switch-would-on-extra = würde: HA turn_on { $extra } (zu Extras)
power-switch-shutdown-failed = ✗ { $name } Herunterfahren: { $error }
power-switch-waiting = ⏳ warte { $secs}s auf Herunterfahren
ha-entity-error = { $name }: Entity '{ $entity }': { $error }
power-switch-no-ha = keine [home_assistant]-Konfig; OS-Herunterfahren ausgeführt
power-off-entity-would = würde: HA turn_off { $entity }
pre-serve-skip = ⏭ Pre-Serve-Hooks übersprungen (--skip-before-serve)
pre-serve-failed = pre-serve: Knoten { $name } fehlgeschlagen: { $error }
pre-serve-run = { $node } ({ $tag }) :: { $cmd }
pre-serve-ignored = ⚠ { $cmd } ignoriert: { $error }
host-key-header = Erkannte Host-Schlüssel:
host-key-line = { $name } ({ $ip }) -> host_key = { $key }
host-key-error = { $name } ({ $ip }) -> Fehler: { $error }
host-key-no-match = (keine Knoten matched)
recipe-starting = 🚀 Rezept wird gestartet: { $name } ({ $engine }) [Backend: { $backend }]
cluster-switch-off-detected = ⚠️ Cluster-Schalter scheint aus zu sein
cluster-switch-powered-on = ✅ Cluster-Schalter eingeschaltet
cluster-waiting-for-nodes = ⏳ Warte, bis Knoten verfügbar sind...
cluster-nodes-available = ✅ Alle Knoten sind jetzt verfügbar
cluster-nodes-not-available-timeout = ❌ Timeout beim Warten auf Knoten-Verfügbarkeit
ha-config-required-for-power-on = ❌ HA-Konfig für Einschalten erforderlich
logs-header = 📜 Logs für Cluster '{ $name }' ({ $count } Knoten)
engine-started = ✅ { $engine } auf { $name } gestartet (Rang { $rank })
engine-start-failed = { $engine } auf { $name } (Rang { $rank }) konnte nicht gestartet werden: { $error }
cluster-started = 🎉 Cluster gestartet! API → http://{ $ip }:{ $port }

exec-both-specified = Entweder --cluster oder --recipe angeben, nicht beides
exec-missing = Entweder --cluster oder --recipe angeben
exec-node-not-found = Knoten '{ $name }' in Cluster '{ $cluster }' nicht gefunden
exec-cluster-empty = Cluster '{ $name }' hat keine Knoten
exec-cannot-use-alias = --alias nicht zusammen mit einem abschließenden Befehl verwenden
exec-must-specify = Entweder --alias <Name> oder einen Befehl nach `--` angeben
exec-unknown-alias-empty = Unbekannter Alias @{ $name } (keine Aliasse konfiguriert)
exec-unknown-alias-list = Unbekannter Alias @{ $name }; bekannte Aliasse: { $aliases }
mods-uploading = 📤 Lade Mods auf { $node } hoch...
mods-uploaded = ✅ Mods auf { $node } hochgeladen
mods-entrypoint-required = Rezept '{ $name }' hat Mods aber keinen Entrypoint; Entrypoint ist bei Mods erforderlich
power-off-container-stop-failed = ⚠️ Container auf Knoten { $name } konnten nicht gestoppt werden: { $error}

after-stop-failed = after_stop: Knoten { $name } fehlgeschlagen: { $error }
after-stop-run = { $node } ({ $tag }) :: { $cmd }
after-stop-ignored = ⚠ { $cmd } ignoriert: { $error }
solo-node-selected = 🎯 Solo: Knoten { $name } in Cluster { $cluster } ausgewählt

# --- Strings, die bisher das i18n-System umgingen (hardcodiert) ---
boot-wait = ⏳ Warte { $secs}s auf Boot der Knoten...
doctor-found-repaired = 🩺 Repariertes Image gefunden: { $tag }
tmux-waiting-head = ⏳ Warte, bis Head-Knoten bereit ist...
tmux-head-ready = ✅ Head-Knoten bereit. Worker-Knoten werden gestartet...
tmux-head-api-ready = Head-Knoten-API bereit (Versuch { $attempt })
tmux-session-started = ✅ Sitzung auf { $name } gestartet
tmux-stopped = ✅ '{ $sess }' auf { $name } gestoppt
tmux-all-stopped = ✅ Alle tmux-Sitzungen gestoppt.
tmux-all-ok = ✅ ALLES OK
tmux-issues = ⚠️  { $issues }
tmux-cluster-healthy = ✅ Cluster ist gesund!
tmux-node-section = --- { $name } ({ $sess }) ---
tmux-node-no-output = --- { $name } — keine Ausgabe ---
tmux-session-created = ✅ tmux-Sitzung auf { $name } erstellt
tmux-no-pty = (russh unterstützt kein interaktives PTY. Befehl direkt ausführen:)
sync-digest-match = '{ $name }' OK (Digest stimmt überein)
sync-syncing = { $name } ({ $ip }): synchronisiere...
sync-synced = { $name } OK
sync-fabric-fallback = { $name }: 200G-Fabric-Hop fehlgeschlagen ({ $err }) — Fallback auf 10G-Verwaltung; node-to-node-SSH über die Fabric-NICs prüfen (authorized_keys / Host-Keys für 200.x-Adressen)
health-node-offline =   ✗ { $name } ({ $ip }) — nicht erreichbar
health-node-idle =   ○ { $name } ({ $ip }){ $net }
health-node-online =   ● { $name } ({ $ip }){ $net }
health-container-count = , { $count } { $count ->
        [one] Container
       *[other] Container
    }
power-off-head = 🛑 ausschalten: { $nodes } Knoten — sudo shutdown now
power-switch-head = 🔸 umschalten: { $from } → { $to } ({ $nodes } Knoten + { $entities } Entities zu deaktivieren)
power-switch-powering-on = 💡 umschalten: { $nodes } Knoten + { $entities } Entities einschalten nach { $to }
health-task-join = Aufgaben-Join-Fehler: { $error }
health-no-recipes = Keine sm121-Container laufen.
health-running-recipes = Laufende Rezepte:
health-recipe-line =   { $recipe } — { $nodes } { $nodes ->
        [one] Knoten
       *[other] Knoten
    }: { $list }
tmux-ray-backend = 🐍 Ray-Backend erkannt — Head-Knoten wird zuerst gestartet...
tmux-mp-backend = 🔗 MP-Backend erkannt — alle Knoten werden parallel gestartet...
tmux-following-logs = 📜 Logs von '{ $sess }' auf { $name } werden verfolgt...
composed-dir-dry-run = [Testlauf] Zusammengestelltes Modellverzeichnis '{ $host }' auf '{ $node }' würde erstellt (Mount: { $mount }, { $sources } { $sources ->
        [one] Quelle
       *[other] Quellen
    }, { $files } { $files ->
        [one] Datei
       *[other] Dateien
    }, { $local } { $local ->
        [one] lokale Datei
       *[other] lokale Dateien
    })
composed-dir-built = Zusammengestelltes Modellverzeichnis '{ $host }' auf '{ $node }' erstellt ({ $sources } { $sources ->
        [one] Quelle
       *[other] Quellen
    }, { $files } { $files ->
        [one] Datei
       *[other] Dateien
    }, { $local } { $local ->
        [one] lokale Datei
       *[other] lokale Dateien
    })
tmux-mods-unsupported = Recipe '{ $name }' verwendet [mods], was Docker-only ist. tmux-Bereitstellung unterstützt keine mods.
tmux-deploy-ignored-opts = ⚠️ tmux-Bereitstellung: ignoriere Docker-only CLI-Optionen: { $opts }
tmux-composed-model-unsupported = Recipe '{ $name }' verwendet [composed_model], was Docker-only ist. tmux-Bereitstellung unterstützt keine zusammengesetzten Modelldateien.
tmux-health-section = Tmux:
tmux-health-entry-running = { $recipe } — { $node }: laufend (API: { $api })
tmux-health-entry-degraded = { $recipe } — { $node }: degradiert (Sitzung existiert, Prozess tot)
tmux-health-entry-stopped = { $recipe } — { $node }: gestoppt
tmux-health-all-stopped = { $count ->
    [one] { $count } tmux-Rezept konfiguriert, alle gestoppt
   *[other] { $count } tmux-Rezepte konfiguriert, alle gestoppt
}
tmux-api-ok = 200
tmux-api-down = aus
venv-preparing = 🔧 Bereite venv vor: { $venv }
venv-exists = ✓ venv existiert bereits auf { $name }
venv-creating = venv nicht gefunden auf { $name } — erstelle...
venv-created = ✓ venv erfolgreich erstellt auf { $name }
venv-prepare-failed = Venv-Vorbereitung: Knoten { $name } fehlgeschlagen: { $error }
venv-not-created = venv wurde nicht erfolgreich auf { $name } erstellt — Setup-Befehle wurden ausgeführt, aber das activate-Skript fehlt

# health render module (plain/md/html)
health-nodes-count = { $nodes } { $nodes ->
        [one] Knoten
       *[other] Knoten
    }
health-col-node = Knoten
health-col-address = Adresse
health-col-status = Status
health-col-containers = Container
health-col-container = Container
health-col-image = Image
health-col-recipe = Rezept
health-col-cluster = Cluster
health-col-nodes = Knoten
health-status-online = ● online
health-status-offline = ✗ offline
health-container-line =     { $name }  { $status }  { $image }

dry-run-would-push = [dry-run] würde nach dem Build { $ref} pushen (und { $latest} aktualisieren)
push-mapping-failed = kann [registry].base { $base } nicht auf einen Push-Ref für { $image } abbilden
pushing-image = Image nach { $ref } wird gepusht (tmux: { $session })...
push-timeout = Push von { $ref} auf { $node} ist nach { $elapsed} abgelaufen — tmux-Session { $session} / Log { $log} auf dem Knoten prüfen.
push-failed = Push von { $ref} auf { $node} ist nach { $elapsed} fehlgeschlagen.\n{ $log }\nHinweis: Wenn das Log unauthorized/denied zeigt — `docker login { $host }` auf { $node} ausführen (der Launcher speichert keine Registry-Credentials).
pushed-image = Image { $ref} gepusht, { $latest} aktualisiert ({ $elapsed })
push-running = Push läuft seit { $elapsed }...
push-already-published = { $ref} bereits veröffentlicht ({ $label}): unveränderter Image-Digest — übersprungen, zum erneuten Push --force nutzen