cortiq-gateway/web/js/i18n/en.js

// English — source of truth. Other languages override per key; missing keys fall
// back to English. Keep keys identical across all language files.
export default {
  // brand / common
  "brand.sub": "Gateway",
  "common.loading": "Loading…",
  "common.save": "Save",
  "common.saving": "Saving…",
  "common.cancel": "Cancel",
  "common.add": "Add",
  "common.edit": "Edit",
  "common.delete": "Delete",
  "common.close": "Close",
  "common.test": "Test",
  "common.copy": "Copy",
  "common.copied": "Copied",
  "common.confirm": "Confirm",
  "common.none": "none",
  "common.saved": "Saved",
  "common.error": "Error",
  "common.ok": "OK",
  "common.refresh": "Refresh",
  "common.actions": "Actions",
  "common.optional": "optional",
  "common.search": "Search",
  "common.all": "all",

  // nav
  "nav.dashboard": "Dashboard",
  "nav.models": "Models",
  "nav.import": "Import model",
  "nav.routing": "Routing",
  "nav.protocols": "Protocols",
  "nav.keys": "API keys",
  "nav.playground": "Playground",
  "nav.settings": "Settings",
  "nav.foot": "Gateway · v{v}",
  "nav.billing": "Router key & billing",

  // topbar / status
  "status.router": "Router",
  "status.gateway": "Gateway",
  "status.online": "online",
  "status.offline": "offline",
  "status.checking": "checking…",
  "status.noKey": "no key",
  "theme.toggle": "Theme",
  "logout": "Log out",

  // login
  "login.title": "allaigate Gateway",
  "login.subtitle": "Enter the admin token to manage this gateway.",
  "login.token": "Admin token",
  "login.tokenPlaceholder": "paste admin token",
  "login.submit": "Open console",
  "login.hint": "The token is printed in the gateway log on startup, or set via [admin].token_env.",
  "login.failed": "Invalid admin token.",

  // dashboard
  "dash.title": "Dashboard",
  "dash.subtitle": "Live traffic, cost and routing analytics for your model pool.",
  "dash.clear": "Clear logs",
  "dash.clearConfirm": "Clear all recorded stats and logs? This cannot be undone.",
  "dash.cleared": "Logs cleared",
  "dash.range": "Range",
  "dash.range.1h": "1h",
  "dash.range.24h": "24h",
  "dash.range.7d": "7d",
  "dash.kpi.requests": "Requests",
  "dash.kpi.tokens": "Tokens",
  "dash.kpi.cost": "Cost",
  "dash.kpi.latency": "Avg latency",
  "dash.kpi.success": "Success rate",
  "dash.kpi.failovers": "Failovers",
  "dash.series.title": "Requests over time",
  "dash.series.cost": "Cost over time",
  "dash.series.empty": "No traffic yet in this range.",
  "dash.breakdown.title": "Breakdown",
  "dash.groupby.model": "by model",
  "dash.groupby.tier": "by tier",
  "dash.groupby.label": "by task",
  "dash.groupby.account": "by account",
  "dash.recent.title": "Recent requests",
  "dash.recent.empty": "No requests recorded yet. Try the Playground.",
  "dash.col.time": "Time",
  "dash.col.model": "Model",
  "dash.col.tier": "Tier",
  "dash.col.task": "Task",
  "dash.col.tokens": "Tokens",
  "dash.col.cost": "Cost",
  "dash.col.latency": "Latency",
  "dash.col.outcome": "Outcome",
  "dash.col.requests": "Requests",
  "dash.col.errors": "Errors",
  "dash.health.title": "Health",
  "dash.health.reachable": "reachable",
  "dash.health.unreachable": "unreachable",
  "dash.health.getKey": "Get a router key",

  // models
  "models.title": "Models",
  "models.subtitle": "Your model pool — mix cheap local models with cloud APIs.",
  "models.add": "Add model",
  "models.empty": "No models yet. Add your first model to get started.",
  "models.col.id": "ID",
  "models.col.provider": "Provider",
  "models.col.model": "Model",
  "models.col.tier": "Cost tier",
  "models.col.key": "Key",
  "models.col.caps": "Capabilities",
  "models.col.price": "Price (in/out)",
  "models.probe": "Probe",
  "models.probe.ok": "Reachable ({ms} ms)",
  "models.probe.fail": "Failed: {err}",
  "models.form.addTitle": "Add model",
  "models.form.editTitle": "Edit model",
  "models.form.id": "ID",
  "models.form.idHint": "Unique id used in routing, e.g. local-qwen",
  "models.form.provider": "Provider",
  "models.form.baseUrl": "Base URL",
  "models.form.model": "Model name",
  "models.form.kind": "Kind",
  "models.form.costTier": "Cost tier",
  "models.form.priceIn": "Price in ($/1M)",
  "models.form.priceOut": "Price out ($/1M)",
  "models.form.apiKeyEnv": "API key env name",
  "models.form.apiKeyEnvHint": "Name of the env var / stored secret holding this provider's key.",
  "models.form.caps": "Capabilities",
  "models.form.secret": "Secret value",
  "models.form.secretStored": "stored",
  "models.form.secretEnv": "from env",
  "models.form.secretMissing": "not set",
  "models.form.secretPlaceholder": "set or replace key (write-only)",
  "models.deleteConfirm": "Delete model \"{id}\"?",
  "models.form.idOrModel": "Enter an id or a model name",
  "models.form.apiKey": "API Key",
  "models.form.apiKeyPlaceholder": "paste your API key",
  "models.form.apiKeyNotNeeded": "not required (local server)",
  "models.form.apiKeyHint": "Stored securely on the gateway; it is not shown again.",
  "models.form.keyStored": "A key is saved — leave blank to keep it, or paste a new one.",
  "models.form.keyFromEnv": "Using a key from an environment variable.",
  "models.form.paramsTitle": "Generation & Thinking Parameters (O(1), MTP, Temperature)",
  "models.form.temperature": "Temperature",
  "models.form.temperatureHint": "Generation temperature (0.0 = deterministic, 1.0+ = creative).",
  "models.form.topP": "Top-P (Nucleus Sampling)",
  "models.form.topPHint": "Sampling threshold (0.0 .. 1.0).",
  "models.form.maxTokens": "Max Tokens",
  "models.form.maxTokensHint": "Maximum completion tokens to generate.",
  "models.form.thinkBudget": "Thinking Mode / Think Budget",
  "models.form.thinkBudgetHint": "Reasoning token budget (0 = disabled, N > 0 = max reasoning tokens).",
  "models.form.systemPrompt": "Default System Prompt",
  "models.form.systemPromptHint": "Prepend automatically if request lacks a system prompt.",
  "models.form.systemPromptPlaceholder": "You are a helpful assistant...",
  "models.form.testKey": "Test & load models",
  "models.form.testing": "checking…",
  "models.form.foundModels": "{n} models loaded",
  "models.form.modelPlaceholder": "type to search…",
  "models.form.modelHint": "Click “Test & load models” to pull the list from your key, then pick one.",
  "models.managed": "managed",
  "models.managedHint": "Provided by the managed CMF server (Settings → Local models). Configure it there.",

  // routing
  "routing.title": "Routing",
  "routing.subtitle": "Map complexity tiers to an ordered list of models (priority = fallback).",
  "routing.default": "Default model",
  "routing.defaultHint": "Used when the router is unreachable.",
  "routing.tiers": "Tiers",
  "routing.tierHint": "Drag chips to reorder; first is preferred, the rest are fallbacks.",
  "routing.addModel": "+ add",
  "routing.addTier": "Add tier",
  "routing.tierName": "Tier name",
  "routing.policy": "Policy",
  "routing.policy.mode": "Mode",
  "routing.policy.fixed": "Fixed table",
  "routing.policy.costAware": "Cost-aware",
  "routing.policy.maxCost": "Max cost per request ($)",
  "routing.policy.minClass": "Minimum class per tier",
  "routing.empty": "No models available — add models first.",

  // protocols
  "protocols.title": "Protocols",
  "protocols.subtitle": "Enable only the inbound API surfaces you need. Toggles apply live.",
  "protocols.implemented": "implemented",
  "protocols.planned": "planned",
  "protocols.openai_chat": "OpenAI Chat Completions",
  "protocols.openai_chat.d": "POST /v1/chat/completions — works with OpenAI SDK, LangChain, crewAI.",
  "protocols.openai_completions": "OpenAI Completions (legacy)",
  "protocols.openai_completions.d": "POST /v1/completions — legacy integrations.",
  "protocols.openai_embeddings": "OpenAI Embeddings",
  "protocols.openai_embeddings.d": "POST /v1/embeddings — RAG pipelines.",
  "protocols.openai_models": "OpenAI Models",
  "protocols.openai_models.d": "GET /v1/models — client auto-discovery.",
  "protocols.anthropic_messages": "Anthropic Messages",
  "protocols.anthropic_messages.d": "POST /v1/messages — Claude-native agents.",
  "protocols.mcp": "MCP (Model Context Protocol)",
  "protocols.mcp.d": "JSON-RPC / SSE — MCP-native orchestrators.",
  "protocols.native_passthrough": "Native passthrough",
  "protocols.native_passthrough.d": "POST /route — direct access to the routing decision.",

  // keys
  "keys.title": "API keys",
  "keys.subtitle": "Virtual gateway keys for your agents. Provider keys never leave the gateway.",
  "keys.add": "New key",
  "keys.empty": "No keys configured — the gateway is in open mode (no auth).",
  "keys.openMode": "Open mode: any request is accepted (no key required).",
  "keys.col.key": "Key",
  "keys.col.account": "Account",
  "keys.col.rate": "Rate / min",
  "keys.col.models": "Allowed models",
  "keys.form.title": "New API key",
  "keys.form.account": "Account",
  "keys.form.rate": "Rate limit / min",
  "keys.form.allow": "Allowed models",
  "keys.form.allowHint": "Leave empty to allow all models.",
  "keys.form.custom": "Custom key (optional)",
  "keys.form.customHint": "Leave empty to auto-generate sk-gw-…",
  "keys.created": "Key created — copy it now, it won't be shown again:",
  "keys.revoke": "Revoke",
  "keys.revokeConfirm": "Revoke this key?",
  "keys.allowAll": "all",

  // playground
  "pg.title": "Playground",
  "pg.subtitle": "Send a prompt through the live pipeline and inspect the routing decision.",
  "pg.system": "System prompt",
  "pg.systemPlaceholder": "optional system message",
  "pg.prompt": "Prompt",
  "pg.promptPlaceholder": "Ask something…",
  "pg.mode": "Mode",
  "pg.mode.auto": "Auto (route)",
  "pg.mode.pinned": "Pinned model",
  "pg.profile": "Profile",
  "pg.model": "Model",
  "pg.temp": "Temperature",
  "pg.maxTokens": "Max tokens",
  "pg.send": "Send",
  "pg.stream": "Stream",
  "pg.sending": "Sending…",
  "pg.answer": "Answer",
  "pg.empty": "The answer and routing decision will appear here.",
  "pg.decision": "Routing decision",
  "pg.task": "Task",
  "pg.tier": "Tier",
  "pg.score": "Complexity",
  "pg.selected": "Selected model",
  "pg.source": "Route source",
  "pg.cost": "Cost",
  "pg.latency": "Latency",
  "pg.tokens": "Tokens (in/out)",
  "pg.failover": "Failover",
  "pg.error": "Request failed",

  // settings
  "settings.title": "Settings",
  "settings.subtitle": "Gateway connection, routing input, reliability and observability.",
  "settings.router": "Router connection",
  "settings.router.url": "Router URL",
  "settings.router.keyEnv": "Router key env name",
  "settings.router.timeout": "Timeout (ms)",
  "settings.router.verifyTls": "Verify TLS certificate",
  "settings.router.enabled": "Use the router (off = local models only)",
  "settings.cmf": "Local models (CMF)",
  "settings.cmf.localOnly": "Use only local models",
  "settings.cmf.manage": "Run a local model server",
  "settings.cmf.autoInstall": "Auto-install cortiq (crates.io)",
  "settings.cmf.autoUpdate": "Auto-update cortiq",
  "settings.cmf.model": "Local .cmf model path",
  "settings.cmf.port": "Local server port",
  "settings.cmf.modelId": "Model id in the pool",
  "settings.cmf.note": "Serves a local .cmf via cortiq (github.com/infosave2007/cmf). Works even when the router is unavailable.",
  "settings.cmf.threads": "Worker threads",
  "settings.cmf.gpu": "Use GPU (Metal / wgpu)",
  "settings.cmf.speedNote": "Threads parallelise the decode matvecs (~3x faster; 0 = runtime default). GPU offload mainly helps prefill of long prompts — decode is memory-bandwidth-bound, so on Apple Silicon it is roughly neutral.",
  "settings.cmf.pick": "select a model",
  "settings.cmf.models": "Local models",
  "settings.cmf.modelsHelp": "Each row is one model the gateway runs (its own cortiq serve on its own port) and registers in the pool. Add as many as you have .cmf files and free ports.",
  "settings.cmf.rowHint": "id · .cmf file · port · threads · GPU. Changes apply on restart; deleting a row stops that server.",
  "settings.cmf.addServer": "+ Add local model",
  "settings.cmf.checkPort": "Check port",
  "settings.cmf.portFree": "port is free",
  "settings.cmf.portBusy": "port is in use",
  "settings.cmf.useSuggested": "use {port}",
  "settings.cmf.serving": "serving {model} on :{port}",
  "settings.cmf.intro": "Run models locally with the cortiq engine — works even offline or when the router is down.",
  "settings.cmf.runtime": "cortiq runtime",
  "settings.cmf.runtimeHelp": "The `cortiq` command-line tool that loads and runs .cmf models. Install it once before starting a local server.",
  "settings.cmf.install": "Install cortiq",
  "settings.cmf.reinstall": "Reinstall / update",
  "settings.cmf.installing": "installing… (compiles, a few minutes)",
  "settings.cmf.installedOk": "cortiq installed",
  "settings.cmf.notInstalled": "not installed",
  "settings.cmf.addModel": "Add a model",
  "settings.cmf.addModelHelp": "Models are downloaded and converted in the Import tab (HuggingFace → .cmf). Then point the local server at the .cmf file below.",
  "settings.cmf.importNote": "No model yet? Import one:",
  "settings.cmf.importLink": "Open Import",
  "settings.cmf.modelHelp": "Path to the .cmf file to serve (e.g. models/qwen.cmf), produced by the Import tab. Running several models for different tasks? Import them and switch this path.",
  "settings.cmf.portHelp": "TCP port the local model server listens on (default 8081). Change only if it clashes with another service.",
  "settings.cmf.threadsHelp": "How many CPU cores to use for generation. More = faster (~3× vs 1 core); 0 lets the runtime decide.",
  "settings.cmf.gpuHelp": "Offload matrix math to the GPU (Metal/wgpu). On Apple Silicon this mostly speeds up long prompts — decode is memory-bandwidth-bound.",
  "settings.cmf.localOnlyHelp": "Route every request to the local model, ignoring the router and any cloud providers.",
  "settings.cmf.manageHelp": "The gateway starts `cortiq serve` for the .cmf below at launch and routes to it. Needs cortiq installed (step 1). Applies on restart.",
  "settings.cmf.autoInstallHelp": "If cortiq is missing at startup, install it automatically from crates.io.",
  "settings.cmf.autoUpdateHelp": "On startup, upgrade cortiq to the newest release when a newer one exists.",
  "settings.router.enabledHelp": "Use the cortiq-router to classify each request (task type + complexity) and pick a model. Off = use the local routing table only.",
  "settings.router.verifyTlsHelp": "Verify the router's TLS certificate. Turn off only for a self-signed / IP-bound certificate.",
  "settings.telemetry.metricsHelp": "Expose Prometheus metrics at GET /metrics.",
  "settings.cortiq.echoHelp": "Add a `cortiq` field (task, model, cost) to each response body. Response headers are always sent.",
  "settings.stats.enabledHelp": "Record recent requests to power the dashboard and charts.",
  "settings.cache.enabledHelp": "Semantic cache: return a saved answer when a new prompt is very similar to a past one, skipping the model call. Needs an embedding model in the pool.",
  "settings.log.bodiesHelp": "Log full request/response message bodies. Off by default for privacy.",
  "settings.router.taxonomy": "Taxonomy id",
  "settings.router.getKey": "Get or top up a router key at",
  "settings.router.secret": "Router key (value)",
  "settings.router.saveKey": "Save key",
  "settings.router.keySaved": "Router key saved",
  "settings.router.keyEmpty": "Paste the key first",
  "settings.router.secretHelp": "Paste the key from your api.allaigate.com email, then Save key. This is NOT a “Keys” value — those are for clients calling your gateway.",
  "settings.router.keyStoredMask": "•••••••••••• — key saved (paste again to replace)",
  "settings.router.test": "Test router",
  "router.probe.ok": "Router OK ({ms} ms)",
  "router.probe.noKey": "Router key is not set",
  "router.probe.auth": "Key rejected — invalid or revoked",
  "router.probe.payment": "Payment required — plan expired or quota exhausted",
  "router.probe.quota": "Rate limit exceeded",
  "router.probe.timeout": "Router timed out",
  "router.probe.unreachable": "Router unreachable",
  "router.probe.error": "Router error",
  "router.usage": "Usage",
  "settings.route": "Routing input",
  "settings.route.strategy": "Text strategy",
  "settings.route.maxChars": "Max chars",
  "settings.route.cacheTtl": "Cache TTL",
  "settings.route.profile": "Default profile",
  "settings.route.strategyHelp": "What text is sent to the router for classification: last_user = only the last user message; last_user_plus_system = last user message + system prompt; concat_all = the whole conversation.",
  "settings.route.maxCharsHelp": "Max characters of that text sent to the router (longer is truncated). More = more accurate classification, but slower/pricier router calls.",
  "settings.route.cacheTtlHelp": "How long a routing decision is cached for an identical request before the router is asked again (e.g. 60s, 5m).",
  "settings.route.profileHelp": "Default routing profile when a request doesn't specify one: cost-saver (cheapest), balanced, or quality-first (best model). Biases which model the router picks.",
  "settings.breaker": "Circuit breaker",
  "settings.breaker.threshold": "Error threshold",
  "settings.breaker.cooldown": "Cooldown",
  "settings.log": "Logging",
  "settings.log.level": "Log level",
  "settings.log.bodies": "Log message bodies (privacy off)",
  "settings.telemetry": "Telemetry",
  "settings.telemetry.metrics": "Expose Prometheus /metrics",
  "settings.cortiq": "Response metadata",
  "settings.cortiq.echo": "Echo cortiq routing block in responses",
  "settings.stats": "Statistics",
  "settings.stats.enabled": "Record request statistics",
  "settings.stats.file": "Stats file (JSONL)",
  "settings.stats.retention": "Retention",
  "settings.listen": "Listen address",
  "settings.export": "Export config",
  "settings.import": "Import config",
  "settings.needsRestart": "Saved. Some changes (listen address) require a restart.",

  // toasts / misc
  "toast.saved": "Changes saved",
  "toast.deleted": "Deleted",
  "toast.probing": "Probing…",
  "toast.imported": "Config imported",
  "dash.cache": "Semantic cache",
  "dash.cache.hitRate": "Hit rate",
  "dash.cache.hits": "Hits",
  "dash.cache.saved": "Saved",
  "dash.cache.disabled": "Semantic cache is disabled — enable it in Settings.",
  "settings.cache": "Semantic cache",
  "settings.cache.enabled": "Enable semantic cache",
  "settings.cache.threshold": "Similarity threshold",
  "settings.cache.ttl": "Entry TTL",
  "settings.cache.embed": "Embedding model",
  "settings.cache.note": "Cache settings take effect after a restart.",

  // import (HuggingFace → CMF)
  "import.subtitle": "Search HuggingFace, convert to a local .cmf, and serve it.",
  "import.searchPlaceholder": "Search HuggingFace models (e.g. qwen3, llama)…",
  "import.searching": "Searching…",
  "import.noResults": "No models found.",
  "import.configure": "Configure conversion",
  "import.outName": "Output name",
  "import.outNameHint": "The .cmf file name (letters, digits, - and _).",
  "import.quant": "Quantization",
  "import.convert": "Convert & load",
  "import.converting": "Converting",
  "import.started": "Conversion started",
  "import.failed": "Conversion failed — see the log.",
  "import.register": "Register as local model",
  "import.registered": "Registered as '{id}'. Run cortiq-server to serve it.",
  "import.jobs": "Downloads & Conversions",
  "import.cancel": "Cancel",
  "import.cancelling": "Cancelling — cleaning up partial output…",
  "import.delete": "Delete",
  "import.deleteConfirm": "Delete this model and its converted .cmf file from disk?",
  "import.deleted": "Deleted with its files",
  "import.state.running": "running",
  "import.state.done": "done",
  "import.state.error": "error",
  "import.state.cancelled": "cancelled",
  "import.featuredTitle": "Featured Ready-to-Run .cmf Models",
  "import.featuredSub": "Pre-converted .cmf models from the infosave account on HuggingFace — the list is read live, so newly published models appear here on their own.",
  "import.readyCmfBadge": "Ready .cmf",
  "import.directDownload": "Download",
  "import.q.q8_2f": "8-bit two-field (𝒲×θ) — recommended: best quality/size.",
  "import.q.q8_row": "8-bit per-row — simple, robust.",
  "import.q.q4": "4-bit block — smallest, lower quality.",
  "import.q.q4_tiled": "4-bit tiled (Q4_TILED) — 1.66x faster on Metal GPU.",
  "import.q.vbit": "Variable 3–8 bit — per-expert bit budgets.",
  "import.q.q1t": "1.58-bit ternary (Q1T) — BitNet b1.58 with sparse outliers.",
  "import.q.q1s": "1-bit sparse (Q1S) — 1-bit base with holographic outliers.",
  "import.q.q1p": "1-bit PTQ (Q1P) — 1-bit with error diffusion.",
  "import.q.q1": "1-bit (Q1) — pure binary format.",
  "import.q.f16": "16-bit — no quantization.",
  "import.q.f32": "32-bit — full precision (large file).",

  "import.adv.title": "Advanced settings",
  "import.adv.auto": "auto",
  "import.adv.linearCore": "Linear core",
  "import.adv.linearHint": "How linear-attention layers are carried/folded.",
  "import.adv.nphase": "vmf_phase phases/head",
  "import.adv.vbitShape": "VBIT budget shape",
  "import.adv.meanBits": "VBIT mean bits",
  "import.adv.shard": "Shard max (GB)",
  "import.adv.noShard": "no sharding",
  "import.adv.skipMtp": "skip MTP head",
  "import.adv.o1": "O(1) attention",
  "import.adv.o1Hint": "Constant-memory streaming attention: the KV cache is released after prefill, so long contexts don't grow memory. Weights stay byte-identical — only a load-time hint is recorded; you can switch back anytime (serve with --o1 off). Validated on Qwen3-0.6B: all layers ≈ ×1.18 perplexity.",
  "import.adv.o1Off": "off — exact attention (default)",
  "import.adv.o1All": "all — convert every softmax layer",
  "import.adv.o1Deep": "deep N — only the N deepest layers",
  "import.adv.o1Custom": "custom — explicit layer list",
  "import.adv.o1DeepN": "N deep layers",
  "import.adv.o1Layers": "Layers (comma-separated)",
  "import.adv.o1mHint": "landmark budget (default 32)",
  "import.adv.o1windowHint": "exact-window width (default 128)",
  "import.adv.o1sinkHint": "permanent exact sink keys (default 4)",

  // onboarding (first run)
  "onboarding.title": "Welcome setup",
  "onboarding.welcome": "Welcome to Cortiq Gateway",
  "onboarding.welcomeSub": "Choose your language — you can change it anytime in the header.",
  "onboarding.next": "Next",
  "onboarding.back": "Back",
  "onboarding.skip": "Skip for now",
  "onboarding.skipSetup": "Skip",
  "onboarding.finish": "Finish setup",
  "onboarding.featuredTitle": "Ready-made models (one click)",
  "onboarding.featuredSub": "These are pre-converted .cmf models from infosave on HuggingFace — just Download, no conversion needed. Pick one or more to get started instantly.",
  "onboarding.download": "Download",
  "onboarding.hfTitle": "Any HuggingFace model — auto convert",
  "onboarding.hfSub": "Search any model, pick a quantization, and we convert it to .cmf automatically. No manual config edits.",
  "onboarding.noJobs": "No downloads yet.",
  "onboarding.doneTitle": "You're all set",
  "onboarding.doneSub": "Models you downloaded will be registered automatically. You can add more in Import or Models.",
  "onboarding.doneHint": "Finish connects every completed download as a local model, starts its .cmf server and points routing at it. You can change all of it later in Models.",
  "onboarding.willRegister": "Will be connected as local models",
  "onboarding.nothingToRegister": "No finished downloads yet — nothing to connect. Go back a step to pick a model.",
  "onboarding.registeredN": "Connected {n} model(s): {ids}",
  "onboarding.runtimeMissing": "The cortiq runtime isn't installed — install it in Settings → Local models to serve these.",
  "onboarding.downloaded": "downloaded",
  "onboarding.update": "Update",
  "onboarding.deleteFile": "Delete the .cmf file from disk",
  "onboarding.confirmDelete": "Delete '{id}'? The .cmf file will be removed from disk.",
  "onboarding.unregistered": "Also unregistered: {ids}",

  // playground: media generation + streaming metrics
  "pg.tab.chat": "Chat",
  "pg.tab.image": "Image",
  "pg.tab.video": "Video",
  "pg.generate": "Generate",
  "pg.generating": "Generating…",
  "pg.genFailed": "Generation failed — see the log.",
  "pg.result": "Result",
  "pg.genMetrics": "Generation metrics",
  "pg.imagePromptPlaceholder": "a red fox sitting in snow at sunset, photorealistic, detailed fur",
  "pg.videoPromptPlaceholder": "a corgi in a chef hat flipping a pancake, sizzling sounds and a cheerful bark",
  "pg.imageEmpty": "The generated image will appear here.",
  "pg.videoEmpty": "The generated clip (with audio) will appear here.",
  "pg.width": "Width",
  "pg.height": "Height",
  "pg.steps": "Steps",
  "pg.seed": "Seed",
  "pg.randomSeed": "Random seed",
  "pg.cfgHint": "Guidance scale; ≤ 1 disables CFG and halves the work.",
  "pg.frames": "Frames",
  "pg.framesHint": "At 24 fps; snapped to the model's grid.",
  "pg.quality": "JPEG quality",
  "pg.videoSizeHint": "Multiples of 32; the trained short edge is 768.",
  "pg.videoStepsHint": "The Turbo LoRA is trained for 4 steps.",
  "pg.firstFrame": "First frame (optional)",
  "pg.lastFrame": "Last frame (optional)",
  "pg.keyframeHint": "Turns the run into keyframe-to-video.",
  "pg.resolution": "Resolution",
  "pg.genTime": "Generation time",
  "pg.timePerStep": "Per step",
  "pg.timePerFrame": "Per frame",
  "pg.fileSize": "File size",
  "pg.duration": "Duration",
  "pg.play": "Play",
  "pg.noMediaModels": "No local {kind} model yet. Download one (e.g. from the infosave collection) in Import:",
  "pg.tokSpeed": "Speed",
  "pg.ttft": "First token",

  // ops: logs, system, notices, gallery, chat, snippets, bench
  "nav.logs": "Logs",
  "logs.subtitle": "Recent gateway log — what the terminal would show.",
  "logs.filterPlaceholder": "filter…",
  "logs.pause": "Pause",
  "logs.resume": "Resume",
  "logs.empty": "Nothing matches.",
  "notice.openAdmin": "The admin console is open without a token and reachable from other machines. Set a token if this box is not private.",
  "notice.update": "Update available: v{v}.",
  "dash.sys.title": "System",
  "dash.sys.cores": "cores",
  "dash.sys.disk": "Disk (models)",
  "dash.sys.free": "free",
  "dash.sys.gateway": "gateway",
  "fit.disk": "not enough disk",
  "fit.diskTitle": "The download is larger than the free space on the models disk.",
  "fit.ram": "may not fit in RAM",
  "fit.ramTitle": "The model is close to or larger than this machine's RAM — it may not run.",
  "pg.eta": "left",
  "pg.min": "min",
  "pg.queued": "In queue — position {n}. It starts as soon as the current generation finishes.",
  "pg.gallery": "Recent generations",
  "pg.galDeleteConfirm": "Delete this generation and its files?",
  "pg.clearChat": "Clear",
  "keys.snip.title": "Connect your app",
  "keys.snip.hint": "Paste one of these into your project — only the API key placeholder needs replacing.",
  "keys.snip.withKey": "Snippets below include the key you just created.",
  "keys.snip.openMode": "No API keys are configured — the gateway accepts any key value.",
  "keys.snip.keyPh": "your API key",
  "settings.restart": "Restart everything",
  "settings.restartConfirm": "Restart the gateway and all local model servers? Requests in flight will be dropped.",
  "settings.restarting": "Restarting — the page reloads when the gateway is back…",
  "settings.shutdown": "Stop everything & power off",
  "settings.shutdownConfirm": "Stop all local model servers and power the gateway off? The API and this panel stop answering until you start the gateway again.",
  "settings.shutdownDone": "The gateway is off.",
  "settings.shutdownHint": "All local model servers are stopped and the process has exited. Start the gateway again on the server to bring the panel back.",
  "bench.title": "Local model speed",
  "bench.hint": "Runs `cortiq bench` on this machine — real tok/s, one model at a time.",
  "bench.run": "Measure",
  "bench.running": "measuring…",
  "bench.failed": "failed",
  "bench.none": "No local .cmf chat models yet.",

  // task-based routing
  "task.chitchat": "Small talk",
  "task.code": "Code",
  "task.creative-writing": "Creative writing",
  "task.extraction": "Data extraction",
  "task.math": "Math",
  "task.qa": "Q&A",
  "task.summarization": "Summarization",
  "task.translation": "Translation",
  "routing.tasks.title": "Task-based routing",
  "routing.tasks.hint": "A rule's models go first for that task; the complexity chain below still applies as fallback. Empty = route by complexity only.",
  "routing.tasks.inherit": "by complexity (no rule)",
  "routing.tasks.share": "{p}% of requests (7d)",
  "routing.tasks.fromRouter": "labels live from the router",
  "routing.tasks.builtin": "router unreachable — built-in label set",
  "routing.tasks.addCustom": "Add task",
  "routing.tasks.addPlaceholder": "custom label…",

  // benchmark view
  "nav.benchmark": "Benchmark",
  "bm.title": "Benchmark",
  "bm.subtitle": "Quality and speed probes through the live pipeline: keyword-checked answers, anti-loop detection, tok/s and time-to-first-token per model.",
  "bm.models": "Models to test",
  "bm.quickMode": "Quick test",
  "bm.quickHint": "The fast subset with short answers — about a minute per local model.",
  "bm.suiteInfo": "Built-in suite: {q} quick / {f} full tests, plus your custom ones.",
  "bm.run": "Run",
  "bm.pickModel": "Pick at least one model.",
  "bm.testOf": "test {i} of {n}",
  "bm.results": "Results",
  "bm.quick": "quick",
  "bm.test": "Test",
  "bm.cellHint": "Click a cell to see the model's full answer.",
  "bm.history": "Previous runs (stored in this browser)",
  "bm.custom": "Custom tests",
  "bm.customHint": "Prompt + comma-separated keywords the answer must contain (use | for synonyms). Stored in this browser.",
  "bm.promptPh": "prompt…",
  "bm.checkPh": "keywords, comma-separated",
  "bm.addTest": "Add test",
  "bm.emptyAnswer": "empty answer",
  "bm.loopDetected": "loop detected",

  // benchmark: routing mode, cost, live
  "bm.mode.routing": "Smart routing",
  "bm.mode.models": "Individual models",
  "bm.mode.routingDesc": "The product's core feature under test: every probe goes through cortiq-auto — you see which task the router detected, which model it picked, whether that matches expectations, and what it cost.",
  "bm.mode.modelsDesc": "The same suite pinned to selected models — compare their quality, speed and cost head-to-head, bypassing the router.",
  "bm.answersOk": "answers correct",
  "bm.classAcc": "task classification",
  "bm.modelDist": "Requests went to",
  "bm.expectedLbl": "expected:",
  "bm.answer": "Answer",
  "bm.liveRunning": "running…",
  "bm.spent": "spent",
  "bm.verdict": "🏁 Done: answers {p}, spent {s}",
  "bm.clearHistory": "Clear all",

  // harness auto-setup (API keys view)
  "keys.h.claude": "Claude Code — paste into the terminal (the gateway speaks the Anthropic protocol natively):",
  "keys.h.codex": "Codex — appends the provider to ~/.codex/config.toml and starts:",
  "keys.h.opencode": "OpenCode — writes ~/.config/opencode/opencode.json (overwrites!) and starts:",
  "keys.h.continue": "Continue (VS Code / JetBrains) — appends the model to ~/.continue/config.yaml:",
  "keys.h.cline1": "Cline (VS Code) — in extension settings pick:",
  "keys.h.cline2": "Settings → API Provider → OpenAI Compatible, then paste the values above.",
  "keys.h.note": "cortiq-auto = smart routing: the router picks the model per request. Use an exact model name to pin one. On Windows run the scripts in Git Bash / WSL, or set the same variables via the system environment settings.",
  "keys.h.protoOff": "The Anthropic protocol (/v1/messages) is disabled — Claude Code will not connect.",
  "keys.h.enableProto": "Enable",
  "keys.h.st.installed": "Installed on the gateway machine",
  "keys.h.st.configured": "Already configured for this gateway",
  "keys.h.st.notFound": "Not found on the gateway machine",
  "bm.degraded": "router degraded",
  "bm.routerDegraded": "The router did not answer in time — the request used the fallback chain; classification is not judged.",
  "bm.cutByCap": "budget spent on reasoning — answer never came",
  "shell.uiStale": "The gateway was updated — this page is running an older interface.",
  "shell.reload": "Reload",
  "keys.col.requests": "Requests",
  "keys.col.tokens": "Tokens in/out",
  "keys.col.costAll": "$ all-time",
  "routing.tasks.tier": "Complexity",
  "routing.tasks.tierAuto": "Auto (router)",
  "routing.tasks.tierHint": "Which model serves this task at which complexity; \"any\" leads at every tier. Order = fallback order. High verdicts still escalate over any-tier pins.",
  "routing.tasks.tierAny": "any complexity",
  "routing.tasks.addModel": "model",
  "routing.bands.enable": "My complexity boundaries",
  "routing.bands.hint": "Drag the handles to set where low ends and where high begins — the handles push each other, the numbers update live. The router's continuous score is re-mapped with YOUR boundaries; unchecked = the router's own bands.",
  "tier.low": "low",
  "tier.medium": "medium",
  "tier.high": "high",
  "bm.scoreHint": "The router's continuous complexity score (0..1) — the boundary sliders on the Routing page cut it into tiers.",
  "settings.cache.noEmbed": "The cache is enabled but has NO embedding model to work with — it is doing nothing. Add a model with kind = \"embedding\" to the pool (e.g. an OpenAI text-embedding model) or pick one below.",
  "settings.cache.entries": "entries",
  "settings.cache.hits": "hits",
  "settings.cache.saved": "saved",
  "keys.form.budget": "Monthly budget, $ (0 = unlimited)",
  "keys.form.budgetHint": "Requests are rejected with 429 insufficient_quota once the account's month-to-date spend crosses this.",
  "keys.budgetOf": "budget {b}/mo",
  "dash.kpi.orBalance": "OpenRouter balance",
  "keys.h.install": "Install:",
  "keys.snip.keyInputPh": "paste your API key",
  "keys.snip.apply": "Insert key",
};