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 } ===
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 } ---
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
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-off-mikrotik-relay = { $name }: Steckdose { $relay } abgeschaltet (Strom unterbrochen)
power-off-mikrotik-relay-would = würde: Steckdose { $relay } abschalten (trennt { $name } vom Strom)
power-off-mikrotik-relay-failed = { $name }: Steckdose { $relay } konnte nicht abgeschaltet werden ({ $error }) — Stromlosigkeit prüfen
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-off-extras-skipped = teilweises Ausschalten ({ $nodes }): Cluster-Entitäten bleiben an ({ $extras }) — sie werden von den aktiven Knoten mitgenutzt
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-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
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 }]
cold-applied = ❄ --cold: die cold_args des Rezepts über seine args gelegt
cold-no-block = ❄ --cold: Rezept '{ $name }' hat keine cold_args; Start mit normalen args
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
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

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

power-on-on = { $name }: eingeschaltet
power-on-cycled = { $name }: Steckdose war on, Knoten war aus — Stromzyklus
power-on-was-on = { $name }: Steckdose bereits on (Knoten aktiv?) — unverändert
power-on-skip = { $name }: keine HA-Entität — übersprungen
power-on-failed = { $name }: HA-Fehler: { $error }
power-on-cycling = ⟳ { $name }: Steckdose ist on, aber der Knoten antwortet nicht — Stromzyklus { $entity }
power-on-off-wait-timeout = { $name }: Steckdose meldete nicht off binnen 10 s (Relay klemmt evtl.)

report-col-launches = Starts
report-col-up = Läuft
report-col-engine = Engine
report-col-last = Letzter Bench
report-col-model = Modell
report-col-nodes = Knoten×TP
report-col-points = Punkte
report-col-prov = Herkunft
report-col-quant = Quant.
stop-not-verified = Container nicht als gestoppt verifiziert auf: { $nodes }

report-col-recipe = Rezept
report-col-reports = Reports
report-col-score = Score /100
report-col-tps1 = Tok/s c1
report-col-tps2 = Tok/s c2
report-serving = Interaktiver Rezept-Report: { $url }  (Live-Updates; Ctrl-C zum Stoppen)
report-title = Getestete Rezepte ({ $count })

# --- recipe repos (src/recipe_repos.rs) ---
git-failed = git { $cmd } fehlgeschlagen: { $err }
recipe-repo-archived-skip = Rezept-Repo ist archiviert — überspringe: { $url }
recipe-repo-synced = Rezept-Repo synchronisiert: { $url } → { $dir }
recipe-repo-watch = repos-Watch: { $n } Repo(s) synchronisiert, nächste Re-Synchronisierung in { $interval } Min (Strg-C zum Beenden)
recipe-repo-unreachable = Rezept-Repo '{ $url }' nicht erreichbar — überspringe ({ $err }); fahre mit den erreichbaren Repos fort
repos-registry-corrupt = Repos-Registry '{ $path }' ist beschädigt ({ $err }) — verschiebe sie nach '{ $bak }' und beginne neu
repos-registry-backup-failed = beschädigte Registry { $path } konnte nicht gesichert werden
repos-none-configured = keine [[recipe_repos]] konfiguriert
repos-col-repo = Repo
repos-col-state = Status
repos-col-last = letzte Synchronisierung
repos-col-count = Rezepte
repos-state-archived = archiviert
repos-state-synced = synchronisiert
repos-state-not-cloned = nicht geklont
repos-sync-dry-reclone = [dry-run] würde das Rezept-Repo neu klonen { $url } → { $dir }
repos-sync-dry-sync = [dry-run] würde das Rezept-Repo klonen/aktualisieren { $url } → { $dir }
repos-none-synced = kein Rezept-Repo synchronisiert (alle unerreichbar oder archiviert)
archive-config-dir-fail = globales Konfigurationsverzeichnis konnte nicht ermittelt werden (dirs::config_dir)
archive-dry-archive = [dry-run] würde '{ $url }' archivieren in { $path }
archive-dry-unarchive = [dry-run] würde '{ $url }' dearchivieren in { $path }
archive-done = archiviert '{ $url }' in { $path }
unarchive-done = dearchiviert '{ $url }' in { $path }

# --- promote (src/promote.rs) ---
promote-repo-not-configured = Repo '{ $url }' ist kein konfigurierter [[recipe_repos]]-Eintrag — füge es der Config hinzu (das Promote braucht sein Token für den Push)
promote-checkout-missing = Repo '{ $url }' ist nicht synchronisiert — führe `sm121 repos sync` aus (dry-run: kein git-I/O)
promote-checkout-sync-fail = Repo '{ $url }' ist nicht synchronisiert — zuerst synchronisieren (sm121 repos sync)
promote-detached-head = Checkout { $path } ist im detached HEAD — vorher einen Branch auschecken
promote-same-repo = --from und --to müssen unterschiedliche Repos sein
promote-recipe-not-in-source = Rezept '{ $recipe }' im Checkout des Quell-Repos nicht gefunden ({ $path }) — ist der Checkout aktuell? (sm121 repos sync)
promote-recipe-in-target = Rezept '{ $recipe }' existiert bereits im Ziel-Repo — Überschreiben verweigert (dort zuerst löschen)
promote-cp-failed = cp fehlgeschlagen: { $err }
promote-cp-context = cp ausführen
promote-target-dir-context = recipes/-Verzeichnis des Ziels
promote-run-start = promote '{ $recipe }' von { $from } nach { $to } ({ $count } { $count ->
        [one] Schritt
       *[other] Schritte
    })
promote-source-checkout = Quell-Checkout: { $path }
promote-target-checkout = Ziel-Checkout: { $path }
promote-step-line = [{ $side }] { $description }
promote-done = promoted '{ $recipe }' — das Ziel hat es jetzt; die nächste Synchronisierung beider Repos festigt den Umzug
promote-dry-head = [dry-run] promote '{ $recipe }' von { $from } nach { $to }:
promote-dry-suppressed = (unterdrückt: -d dry-run hat Vorrang vor --apply)
promote-run-apply-hint = mit --apply erneut ausführen

# --- registry image source (src/docker/registry_pull.rs) ---
registry-needs-registry = --image-source registry erfordert eine [registry]-Sektion in der Config
registry-ref-map-fail = Image '{ $image }' konnte keinem Registry-Ref unter Base '{ $base }' zugeordnet werden (der Image-Name muss ein schlichtes <name>[:tag] sein)
registry-pull-context = Registry-Pull auf '{ $node }'
registry-present = Registry-Image '{ $image }' ist auf '{ $node }' bereits vorhanden (Checksum-Label stimmt überein)
registry-pulled = gezogen '{ $ref }' → '{ $image }' auf '{ $node }' (Checksum-Label verifiziert)
registry-dry-run = [dry-run] --image-source registry: würde { $ref } ziehen → Tag '{ $image }' auf { $count } { $count ->
        [one] Knoten
       *[other] Knoten
    } (Checksum { $checksum }…)
registry-tag-not-found = { $node }: Tag '{ $ref }' ist nicht in der Registry — erst build + push (sm121 build --recipe { $recipe } --build-node <node>) oder zurück auf --image-source repo
registry-tag-failed = { $node }: docker tag nach dem Pull fehlgeschlagen
registry-label-mismatch = { $node }: das sm121.checksum-Label des gezogenen Images ist '{ $got }', erwartet '{ $checksum }' — der Registry-Tag trägt diesen Build nicht
registry-output-unparseable = { $node }: nicht auswertbare Pull-Ausgabe: { $out }
registry-pull-failed = --image-source registry fehlgeschlagen auf: { $failed }

# --- drop_caches hook (src/docker/mod.rs) ---
drop-caches-start = Leere den Page-Cache auf allen Knoten...
drop-caches-failed = drop_caches auf { $node } fehlgeschlagen: { $err }