launcher/locales/en/main.ftl

cluster-not-found = Cluster "{ $name }" not found
nccl-config-missing = NCCL config not found
cluster-auto-fail = No suitable cluster found
cluster-selected = ✅ Auto-selected cluster: { $name } ({ $nodes } { $nodes ->
        [one] node
       *[other] nodes
    })
container-log-header = 📜 Latest container logs:
cluster-stopping = 🛑 Stopping cluster '{ $name }'...
cluster-all-stopped = ✅ All containers stopped.
cluster-section = === Cluster: { $name } ===
doctor-header = 🩺 Doctor: { $name } ({ $engine }) [backend: { $backend }]
doctor-node-section = --- { $name } ---
doctor-all-passed = ✅ All checks passed!
doctor-checks-failed = ⚠ Some checks failed. Run with --repair to auto-fix.
doctor-repairing = 🔧 Repairing image...
doctor-repaired = ✅ Repaired image: { $tag }
doctor-dry-build = (dry-run) Would build { $tag } on { $node }
logs-follow-head = 📜 Following logs for '{ $name }' (head node)...
logs-section = --- { $name } ---
health-cluster-header = === { $name } === { $nodes } { $nodes ->
        [one] node
       *[other] nodes
    }
health-switch-off = 🚫 switch off
health-interface-down = 🌐 interface down
health-all-online = ✅ all online
health-partial-online =  ({ $online } online, { $offline } offline)
health-node-online-cluster-down = ◍ { $name } ({ $ip }){ $net } — online (cluster offline)
health-free-count = — { $free } free
health-cluster-down = ⏻ cluster offline
health-soft-off = ⚙ { $list } off (non-blocking)
health-net-status =  [net: { $details }]
health-no-containers = (no containers)
health-no-containers-inline = , no containers
exec-header = ⚡ exec: { $cmd } ({ $nodes } { $nodes ->
        [one] node
       *[other] nodes
    })
exec-section = --- { $name } ---
exec-failed = ✗ { $name } :: { $cmd } :: { $error }
exec-completed-errors = exec completed with errors (some nodes reported failures)
power-off-dryrun = dry-run: skipping actual shutdown + HA call
power-off-mikrotik-skip = { $entity } is a RouterOS API device ({ $address }) — HA skipped
power-off-mikrotik-would = would: RouterOS /system/shutdown { $name } ({ $address })
power-off-mikrotik-failed = { $name }: RouterOS shutdown failed ({ $error })
power-on-mikrotik-manual = { $name }: RouterOS device — no remote power-on; power it on manually
power-on-mikrotik-manual-would = would: power on { $name } manually (RouterOS has no remote on)
power-off-mikrotik-relay = { $name }: relay { $relay } switched off (power cut)
power-off-mikrotik-relay-would = would: turn off relay { $relay } (cuts power to { $name })
power-off-mikrotik-relay-failed = { $name }: could not switch off relay { $relay } ({ $error }) — verify the outlet is de-energized
power-on-mikrotik-relay-would = would: turn on relay { $relay} (powers on { $name})
power-off-would = would: { $action } { $target }
power-off-shutdown-failed = ✗ { $name } :: { $cmd } :: { $error }
power-off-waiting = ⏳ waiting { $secs }s for nodes to settle
power-off-no-ha = no [home_assistant] config; OS shutdown was performed above
power-off-ssh-failures = some nodes reported SSH failures during shutdown
power-off-extras-skipped = subset power off ({ $nodes }): keeping cluster-level extras on ({ $extras }) — they are shared by the nodes that stay up
power-off-extras-held = keeping { $entity } on — still in use by an active run on cluster(s): { $clusters }
power-on-dryrun = dry-run: skipping actual HA call
power-on-would-on = would: HA turn_on { $entity }
power-on-would-skip = would skip: { $name } (no entity)
power-on-head = 💡 power on: { $nodes } node(s)
ha-invalid-entity = { $name }: invalid entity '{ $entity }': { $error }
ha-call-failed = HA { $service } { $entity }: { $error }
ha-skip-no-entity = ⚠ { $name }: no `entity` configured, skipping HA
ha-extra-failed = HA { $service } { $extra } ({ $label }): { $error }
power-switch-would-off = would: HA turn_off { $entity }
power-switch-would-off-extra = would: HA turn_off { $extra } (from extras)
power-switch-would-on = would: HA turn_on { $entity }
power-switch-would-on-extra = would: HA turn_on { $extra } (to extras)
power-switch-shutdown-failed = ✗ { $name } shutdown: { $error }
power-switch-waiting = ⏳ waiting { $secs }s for shutdown
power-switch-no-ha = no [home_assistant] config; OS shutdown was performed
power-off-entity-would = would: HA turn_off { $entity }
pre-serve-skip = ⏭ Skipping pre-serve hooks (--skip-before-serve)
pre-serve-failed = pre-serve: node { $name } failed: { $error }
pre-serve-run = { $node } ({ $tag }) :: { $cmd }
pre-serve-ignored = ⚠ { $cmd } ignored: { $error }
host-key-header = Discovered host keys:
host-key-line = { $name } ({ $ip }) -> host_key = { $key }
host-key-error = { $name } ({ $ip }) -> error: { $error }
host-key-no-match = (no nodes matched)
recipe-starting = 🚀 Starting recipe: { $name } ({ $engine }) [backend: { $backend }]
cold-applied = ❄ --cold: applied the recipe's cold_args over its args
cold-no-block = ❄ --cold: recipe '{ $name }' has no cold_args; serving with normal args
cluster-switch-off-detected = ⚠️ Cluster switch appears to be off
cluster-switch-powered-on = ✅ Cluster switch powered on
cluster-waiting-for-nodes = ⏳ Waiting for nodes to become available...
cluster-nodes-available = ✅ All nodes are now available
cluster-nodes-not-available-timeout = ❌ Timeout waiting for nodes to become available
logs-header = 📜 Logs for cluster '{ $name }' ({ $count } nodes)
engine-started = ✅ { $engine } started on { $name } (rank { $rank })
engine-start-failed = Failed to start { $engine } on { $name } (rank { $rank }): { $error }
cluster-started = 🎉 Cluster started! API → http://{ $ip }:{ $port }

exec-both-specified = Specify either --cluster or --recipe, not both
exec-missing = Must specify either --cluster or --recipe
exec-node-not-found = Node '{ $name }' not found in cluster '{ $cluster }'
exec-cluster-empty = Cluster '{ $name }' has no nodes
exec-cannot-use-alias = Cannot use --alias together with a trailing command
exec-must-specify = Must specify either --alias <name> or a command after `--`
exec-unknown-alias-empty = Unknown alias @{ $name } (no aliases configured)
exec-unknown-alias-list = Unknown alias @{ $name }; known aliases: { $aliases }
mods-uploading = 📤 Uploading mods to { $node }...
mods-uploaded = ✅ Mods uploaded to { $node }
mods-entrypoint-required = Recipe '{ $name }' has mods but no entrypoint; entrypoint is required when mods are present

after-stop-failed = after_stop: node { $name } failed: { $error }
after-stop-run = { $node } ({ $tag }) :: { $cmd }
after-stop-ignored = ⚠ { $cmd } ignored: { $error }
solo-node-selected = 🎯 Solo: selected node { $name } in cluster { $cluster }

# --- Strings that previously bypassed the i18n system (hardcoded) ---
boot-wait = ⏳ Waiting { $secs }s for nodes to boot...
doctor-found-repaired = 🩺 Found repaired image: { $tag }
tmux-waiting-head = ⏳ Waiting for head node to be ready...
tmux-head-ready = ✅ Head node ready. Starting worker nodes...
tmux-head-api-ready = Head node API ready (attempt { $attempt })
tmux-session-started = ✅ Session started on { $name }
tmux-stopped = ✅ Stopped '{ $sess }' on { $name }
tmux-all-stopped = ✅ All tmux sessions stopped.
tmux-all-ok = ✅ ALL OK
tmux-issues = ⚠️  { $issues }
tmux-cluster-healthy = ✅ Cluster is healthy!
tmux-node-section = --- { $name } ({ $sess }) ---
tmux-node-no-output = --- { $name } — no output ---
tmux-session-created = ✅ tmux session created on { $name }
tmux-no-pty = (russh does not support interactive PTY. Use the following command directly:)
sync-digest-match = '{ $name }' OK (digest matches)
sync-syncing = { $name } ({ $ip }): syncing...
sync-synced = { $name } OK
sync-fabric-fallback = { $name }: 200G fabric hop failed ({ $err }) — falling back to 10G mgmt; fix node-to-node ssh over the fabric NICs (authorized_keys / host keys for the 200.x addresses)
health-node-offline = ✗ { $name } ({ $ip }) — offline
health-node-idle = ○ { $name } ({ $ip }){ $net }
health-node-online = ● { $name } ({ $ip }){ $net }
health-container-count = , { $count } { $count ->
        [one] container
       *[other] containers
    }
power-off-head = 🛑 power off: { $nodes } node(s) — sudo shutdown now
power-switch-head = 🔌 switch: { $from } → { $to } ({ $nodes } node(s) + { $entities } entity(ies) to disable)
power-switch-powering-on = 💡 switch: powering on { $nodes } node(s) + { $entities } entity(ies) to { $to }
health-task-join = task join: { $error }
health-no-recipes = No sm121 containers running.
health-running-recipes = Running recipes:
health-recipe-line =   { $recipe } — { $nodes } { $nodes ->
        [one] node
       *[other] nodes
    }: { $list }
tmux-ray-backend = 🐍 Ray backend detected — starting head node first...
tmux-mp-backend = 🔗 MP backend detected — starting all nodes in parallel...
tmux-following-logs = 📜 Following logs from '{ $sess }' on { $name }...
tmux-deploy-ignored-opts = ⚠️ tmux deploy: ignoring Docker-only CLI opts: { $opts }
tmux-mods-unsupported = Recipe '{ $name }' uses [mods], which is Docker-only. tmux deployment does not support mods.
tmux-composed-model-unsupported = Recipe '{ $name }' uses [composed_model], which is Docker-only. tmux deployment does not support composed model directories.
tmux-health-section = Tmux:
tmux-health-entry-running = { $recipe } — { $node }: running (API: { $api })
tmux-health-entry-degraded = { $recipe } — { $node }: degraded (session exists, process dead)
tmux-health-all-stopped = { $count ->
    [one] { $count } tmux recipe configured, all stopped
   *[other] { $count } tmux recipes configured, all stopped
}
tmux-api-ok = 200
tmux-api-down = down
venv-preparing = 🔧 Preparing venv: { $venv }
venv-exists = ✓ venv already exists on { $name }
venv-creating = venv not found on { $name } — creating...
venv-created = ✓ venv created successfully on { $name }
venv-not-created = venv was not created successfully on { $name } — setup commands ran but activate script is missing
composed-dir-dry-run = [dry-run] would build composed model dir '{ $host }' on '{ $node }' (mount: { $mount }, { $sources } { $sources ->
        [one] source
       *[other] sources
    }, { $files } { $files ->
        [one] file
       *[other] files
    }, { $local } { $local ->
        [one] local file
       *[other] local files
    })
composed-dir-built = Built composed model dir '{ $host }' on '{ $node }' ({ $sources } { $sources ->
        [one] source
       *[other] sources
    }, { $files } { $files ->
        [one] file
       *[other] files
    }, { $local } { $local ->
        [one] local file
       *[other] local files
    })

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

# sm121 report
report-title = Tested recipes ({ $count })
report-serving = Interactive recipe report: { $url }  (live updates; Ctrl-C to stop)
report-col-model = Model
report-col-quant = Quant
report-col-recipe = Recipe
report-col-prov = Provenance
report-col-engine = Engine
report-col-nodes = Nodes×TP
report-col-reports = Reports
report-col-last = Last bench
report-col-points = Points
report-col-score = Score /100
report-col-tps1 = Tok/s c1
report-col-tps2 = Tok/s c2
stop-not-verified = Containers not verified stopped on: { $nodes }
report-col-up = Up
report-col-launches = Launches

dry-run-would-push = [dry-run] would push { $ref } (and refresh { $latest }) after the build
push-mapping-failed = cannot map [registry].base { $base } to a push ref for { $image }
pushing-image = Pushing image to { $ref } (tmux: { $session })...
push-timeout = Push of { $ref } on { $node } timed out after { $elapsed } — inspect tmux session { $session } / log { $log } on the node.
push-failed = Push of { $ref } on { $node } failed after { $elapsed }.\n{ $log }\nHint: if the log says unauthorized/denied — run `docker login { $host }` on { $node } (the launcher stores no registry credentials).
pushed-image = Pushed { $ref } and refreshed { $latest } ({ $elapsed })
push-running = Push running for { $elapsed }...
push-already-published = { $ref } already published ({ $label}): unchanged image digest — skipping, use --force to re-publish

power-on-on = { $name }: turned on
power-on-cycled = { $name }: plug was on, node down — power cycled
power-on-was-on = { $name }: plug already on (node up?) — left as is
power-on-skip = { $name }: no HA entity — skipped
power-on-failed = { $name }: HA call failed: { $error }
power-on-cycling = ⟳ { $name }: plug reads on but the node is down — cycling { $entity }
power-on-off-wait-timeout = { $name }: plug did not report off within 10 s (relay may have stuck)

# --- recipe repos (src/recipe_repos.rs) ---
git-failed = git { $cmd } failed: { $err }
recipe-repo-archived-skip = recipe repo archived — skipping: { $url }
recipe-repo-synced = recipe repo synced: { $url } → { $dir }
recipe-repo-watch = repos watch: { $n } repo(s) synced, next re-sync in { $interval } min (Ctrl-C to stop)
recipe-repo-unreachable = recipe repo '{ $url }' unreachable — skipping ({ $err }); continuing with the reachable repos
repos-registry-corrupt = repos registry '{ $path }' is corrupt ({ $err }) — moving it to '{ $bak }' and starting fresh
repos-registry-backup-failed = could not back up corrupt registry { $path }
repos-none-configured = no [[recipe_repos]] configured
repos-col-repo = repo
repos-col-state = state
repos-col-last = last sync
repos-col-count = recipes
repos-state-archived = archived
repos-state-synced = synced
repos-state-not-cloned = not cloned
repos-sync-dry-reclone = [dry-run] would re-clone recipe repo { $url } → { $dir }
repos-sync-dry-sync = [dry-run] would clone/pull recipe repo { $url } → { $dir }
repos-none-synced = no recipe repos synced (all unreachable or archived)
archive-config-dir-fail = cannot determine the global config dir (dirs::config_dir)
archive-dry-archive = [dry-run] would archive '{ $url }' in { $path }
archive-dry-unarchive = [dry-run] would unarchive '{ $url }' in { $path }
archive-done = archived '{ $url }' in { $path }
unarchive-done = unarchived '{ $url }' in { $path }

# --- promote (src/promote.rs) ---
promote-repo-not-configured = repo '{ $url }' is not a configured [[recipe_repos]] entry — add it to the config (the promote needs its token for the push)
promote-checkout-missing = repo '{ $url }' is not synced — run `sm121 repos sync` (dry-run: no git I/O)
promote-checkout-sync-fail = repo '{ $url }' is not synced — sync it first (sm121 repos sync)
promote-detached-head = checkout { $path } is in detached HEAD — check out a branch first
promote-same-repo = --from and --to must be different repos
promote-recipe-not-in-source = recipe '{ $recipe }' not found in the source repo's checkout ({ $path }) — is the checkout current? (sm121 repos sync)
promote-recipe-in-target = recipe '{ $recipe }' already exists in the target repo — refusing to overwrite (remove it there first)
promote-cp-failed = cp failed: { $err }
promote-cp-context = running cp
promote-target-dir-context = target recipes/ dir
promote-run-start = promoting '{ $recipe }' from { $from } to { $to } ({ $count } { $count ->
        [one] step
       *[other] steps
    })
promote-source-checkout = source checkout: { $path }
promote-target-checkout = target checkout: { $path }
promote-step-line = [{ $side }] { $description }
promote-done = promoted '{ $recipe }' — the target now has it; the next sync of both repos keeps the move
promote-dry-head = [dry-run] promote '{ $recipe }' from { $from } to { $to }:
promote-dry-suppressed = (suppressed: -d dry-run wins over --apply)
promote-run-apply-hint = re-run with --apply to execute

# --- registry image source (src/docker/registry_pull.rs) ---
registry-needs-registry = --image-source registry requires a [registry] section in the config
registry-ref-map-fail = cannot map image '{ $image }' to a registry ref under base '{ $base }' (the image name must be a bare <name>[:tag])
registry-pull-context = registry pull on '{ $node }'
registry-present = registry image '{ $image }' already present on '{ $node }' (checksum label matches)
registry-pulled = pulled '{ $ref }' → '{ $image }' on '{ $node }' (checksum label verified)
registry-dry-run = [dry-run] --image-source registry: pull { $ref } → tag '{ $image }' on { $count } { $count ->
        [one] node
       *[other] nodes
    } (checksum { $checksum }…)
registry-tag-not-found = { $node }: tag '{ $ref }' not found in the registry — build + push it first (sm121 build --recipe { $recipe } --build-node <node>), or fall back to --image-source repo
registry-tag-failed = { $node }: docker tag failed after the pull
registry-label-mismatch = { $node }: the pulled image's sm121.checksum label is '{ $got }', expected '{ $checksum }' — the registry tag does not carry this build
registry-output-unparseable = { $node }: unparseable pull output: { $out }
registry-pull-failed = --image-source registry failed on: { $failed }

# --- drop_caches hook (src/docker/mod.rs) ---
drop-caches-start = Dropping page cache on all nodes...
drop-caches-failed = drop_caches on { $node } failed: { $err }