chore: release 0.2.41

At 35% opacity over the dark background the amber medium zone and the
light-red high zone read as the same color right of the medium handle.
Saturation stepped up per zone (45/55/65%) and high uses a deeper red —
green / amber / red now read at a glance.

.dockerignore

@@ -1,4 +1,6 @@
 target
+models
+*.cmf
 .git
 .github
 docs

.github/workflows/release.yml

@@ -21,9 +21,20 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
+      # Skip when this version is already on crates.io — a version can never be
+      # re-uploaded, so publishing one that exists (released by hand, or a re-run
+      # of this job) is a guaranteed failure rather than a real problem.
       - name: Publish to crates.io
         if: ${{ env.CARGO_REGISTRY_TOKEN != '' }}
-        run: cargo publish
+        run: |
+          name=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].name')
+          version=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].version')
+          if curl -sf -H 'User-Agent: cortiq-gateway-release' \
+               "https://crates.io/api/v1/crates/$name/$version" >/dev/null; then
+            echo "$name $version is already published — skipping"
+          else
+            cargo publish
+          fi
 
   # --- prebuilt binaries + GitHub Release -----------------------------------
   release:

CHANGELOG.md

@@ -3,7 +3,193 @@
 All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
-## [0.2.32] - 2026-07-22
+## [0.2.41] - 2026-08-08
+
+### Added
+- **Linked complexity-boundary sliders** on the Routing page: one track, two draggable handles
+  (the low|medium and medium|high boundaries) over green/amber/red zones. Handles push each
+  other, the numbers ride on the handles and the legend updates live — no hand-typed score
+  ranges. The gateway re-maps the router's continuous complexity score with YOUR boundaries
+  (`[routing.bands]`, validated `0 < low < medium < 1`) before tier chains, escalation and
+  stats; unchecked = the router's own bands, untouched behavior.
+
+### Fixed
+- Complexity tier names are translated everywhere they appear (bands legend, tier badges, pair
+  selects, benchmark column, Playground decision): лёгкий/средний/сложный, leicht/mittel/schwer,
+  facile/moyen/difficile, fácil/medio/difícil, 简单/中等/困难, kolay/orta/zor.
+- Benchmark route-judged retries re-ask the SAME prompt after a pause before reaching for a
+  fresh template — difficulty is judged in the background, so the second occurrence is the
+  honest steady-state answer.
+
+## [0.2.40] - 2026-08-08
+
+### Added
+- **Per-key spend accounting** on the API-keys page: requests, tokens in/out and cost per key
+  for a selectable window (24h / 7d / 30d) plus a cumulative all-time cost column — "which
+  department spends what" at a glance.
+- **Bounded stats on disk**: once `stats.jsonl` outgrows `stats.max_file_mb` (default 16, 0
+  disables), records older than the retention window fold into cumulative per-account totals in
+  a small sidecar file (tmp+rename on both) and leave the log. All-time accounting survives
+  compaction and restarts; nothing is ever counted twice.
+- **Per-complexity models inside a task rule**: each task is edited as rows of
+  "model + complexity" pairs — `[routing.tasks.code] low=["cheap"] high=["best"] any=[...]`.
+  The tier-specific pick leads its own tier, `any` (and legacy plain arrays) leads everywhere,
+  the global tier chain and `default` always remain as fallback, and high verdicts still
+  escalate over any-tier pins.
+
+### Changed
+- Benchmark hard probes are generated from wider interdisciplinary pools (6 families each) and
+  retry once with a fresh template — the router's novelty decay no longer flips them red.
+
+### Fixed
+- The `task-rule` badge is honest: it appears only when the rule actually chose the head of the
+  candidate chain, not whenever a rule merely exists for the task.
+
+## [0.2.39] - 2026-08-07
+
+### Added
+- **Benchmark, redesigned into the console** (⏱ sidebar entry): two explicit modes. **Smart
+  routing** (default) sends every probe through `cortiq-auto` and judges the ROUTER — task label
+  vs expected (✓/✗), complexity tier, chosen model with per-request cost, task-rule badge —
+  with KPIs for answer quality, classification accuracy, TTFT, tok/s and money spent, plus a
+  "requests went to" per-model distribution. **Individual models** compares pinned models
+  head-to-head. Results render live row-by-row, runs land in a browser-side history (per-run ×
+  and Clear-all), custom tests supported, ⚡ quick subset (7) vs full suite (17).
+- **Hard probes that exercise the high tier**: two route-judged tests (science / ops pools)
+  generated fresh each run — interdisciplinary prompts rate high reliably while fixed wordings
+  decay with the router's novelty signal. Pass = the router said `high` and the request escalated;
+  the tiny token budget keeps them at cents even on the priciest model.
+- **One-paste harness setup** on the API-keys page: Claude Code (native Anthropic `/v1/messages`,
+  now on by default, one-click enable for older configs), Codex, OpenCode, Continue and Cline —
+  each pre-filled with the gateway URL and the freshly created key. The gateway detects harnesses
+  already installed on its machine (✓ on the tab, "already configured for this gateway" status).
+- **Stale-tab detection**: open consoles notice a gateway restart via the meta start marker and
+  show a reload banner instead of silently running an old interface.
+- Log viewer Clear button (`DELETE /admin/api/logs`).
+
+### Changed
+- **High complexity escalates over task rules**: at tier `high` the tier chain leads and the task
+  rule demotes to fallback — a `code → cheap-model` rule no longer pins the hardest prompts to
+  the cheap model. Low/medium keep task-rule-first semantics (documented in docs/ROUTING).
+- **Honest stream costs**: the final cost rides a closing SSE event (`cortiq_cost_usd`) since the
+  initial header is written before generation; money renders with 4 decimals (last two smaller)
+  and grows precision below $0.0001 instead of collapsing to $0.0000.
+- **Oracle-sized timeouts**: router default 800 ms → 15 s (hosted escalations take ~10 s);
+  provider clients gained a 10 s connect timeout (dead upstreams fail over fast) with no overall
+  cap so long generations and streams are never cut.
+- Benchmark fairness: +256-token reasoning headroom (thinking models aren't cut mid-`<think>`),
+  router degradation shown as "⚠ router degraded" and excluded from accuracy, "budget spent on
+  reasoning" instead of a misleading "empty answer", creative-writing budget 96 → 512.
+- New-key dialog simplified to account / rate limit / optional custom value.
+
+### Fixed
+- `cortiq bench` results showed "error" with newer cortiq releases that pretty-print `--json`:
+  the parser now finds the last balanced JSON object anywhere in the output, and tok/s prefers
+  steady decode speed (the old heuristic could report `allocs_per_token` as tok/s).
+
+## [0.2.38] - 2026-08-07
+
+### Added
+- **Image & video generation in the Playground**: three tabs now — Chat, Image, Video. Image runs
+  `cortiq imagine` over a local text-to-image `.cmf` (Lumina) with width/height/steps/CFG/seed,
+  live step progress and an honest ETA; the P6 PPM result is decoded to a canvas in the browser
+  with one-click PNG export. Video runs `cortiq animate` (MiniMax-H3) with frames/steps/quality
+  and optional first/last keyframes (rasterized to PPM client-side); the MJPEG+PCM AVI is decoded
+  in JS and played on a canvas synced to the wav — no ffmpeg on either side (an mp4 remux happens
+  opportunistically when ffmpeg exists). Local `.cmf` files are classified chat/image/video via
+  `cortiq info`; media packs are never registered as chat servers. Requires cortiq ≥ 0.5.56.
+- **Task-based routing**: `[routing.tasks]` maps a router task label to an ordered model list.
+  A matching rule's models lead the candidate chain and the complexity chain follows as fallback,
+  so a task pin never weakens failover. The Routing page builds the editor from the account's
+  live taxonomy (`GET /v1/taxonomies`), shows each task's share of 7-day traffic, and supports
+  custom labels. Responses whose chain was headed by a rule report `route_source "router+task-rule"`.
+- **Generation gallery** under the media tabs (lazy PPM thumbnails, reopen with seed/steps, delete),
+  and generations **queue up** (with position shown) instead of being rejected.
+- **Chat is a real dialogue**: history is resent, bubbles, Clear, Cmd/Ctrl+Enter — plus live
+  metrics: token counts, tok/s and time-to-first-token.
+- **Exact stream token counts** when the model server provides usage; the gateway fallback counts
+  content chunks (exactly 1/token on cortiq serve) instead of chars/4, flagged as an estimate.
+- **Jobs survive restarts**: import and media job lists persist to `<data>/jobs-*.json` and are
+  reconciled on start — the Register button no longer vanishes because the gateway restarted.
+- **Admin console, ops batch**: Logs viewer in the sidebar (500-line ring, filter/level/pause/copy);
+  a System panel on the dashboard (CPU sparkline + load, RAM incl. the gateway's RSS, free disk at
+  the models dir); "not enough disk / may not fit in RAM" badges on model cards before a download;
+  a Restart-gateway button; an update-available notice (crates.io checked twice a day); config
+  export as the real `gateway.toml` and TOML import (validated, hot-reloaded); "Connect your app"
+  snippets (curl/Python/JS) on the keys page; one-click `cortiq bench --json` on the Models page.
+- **Docker ships the cortiq binary** (built in the builder stage, plus `libvulkan1`): local `.cmf`
+  chat models and media generation now work in containers, where auto-install never could.
+- **Security**: an open admin console listening on 0.0.0.0 outside Docker warns in the log and
+  shows a dismissible banner.
+
+### Fixed
+- The default config pointed at a placeholder `localhost:8080` router with a nonexistent taxonomy,
+  leaving every fresh install with a permanently red "Router: offline" badge. A fresh install now
+  targets the hosted allaigate router and degrades gracefully until a key is set.
+- The wizard's Finish lands on the Playground instead of the Models list.
+
+## [0.2.37] - 2026-08-06
+
+### Added
+- **Zero-argument startup**: `cortiq-gateway` now runs with no flags. The config is created on
+  first launch (repo `config/gateway.toml` when run from a checkout, otherwise
+  `~/.cortiq-gateway/gateway.toml`, or `$CORTIQ_GATEWAY_HOME`), the browser opens by itself,
+  and a busy port is swapped for the next free one. `--no-browser` / `--no-port-search` opt out;
+  `--config` still takes an explicit path.
+- **No admin token required by default**: the console opens without auth. Set `--admin-token`,
+  `[admin].token` or `[admin].token_env` to protect it.
+- **First-run wizard** (`/admin#/onboarding`): pick a language, download a ready-made `.cmf`
+  model, and finish — Finish connects every completed download as a local model, starts its
+  `cortiq serve` and points `routing.default` at it. Nothing to edit by hand.
+- **Ready-made models are read live** from the `infosave` HuggingFace account in both the wizard
+  and Import, with per-variant quantizations, real sizes, an "already downloaded" mark and a
+  delete button. Newly published models appear without a gateway update.
+- **Windows-friendly data dir**: `%APPDATA%` / `%LOCALAPPDATA%` / `%USERPROFILE%` are used before
+  falling back, so running the exe from `Downloads` never writes into `Program Files`.
+- **Full localization**: all 432 UI strings now exist in every language (en, ru, de, fr, es, zh, tr).
+  Import, Settings → Local models, the model form and the whole first-run wizard were English-only
+  in de/fr/es/zh/tr before this release.
+
+### Fixed
+- **Download progress jumped straight to 100% and then hung**: with `-L`, curl prints a complete
+  `0→100%` progress bar for the redirect hop before the transfer starts, and that bar was being
+  parsed as the download's progress. Progress is now derived from bytes on disk against the size
+  reported by the HuggingFace tree (or a `HEAD` request), so the bar and the reported
+  `done / total` bytes track the real transfer.
+- **Re-downloading over an existing file reported 100% instantly**: the previous copy is now
+  removed before the transfer starts, so the size poller cannot read stale bytes.
+- **Downloaded models were not recognised**: the admin UI derived the output file name
+  independently of the gateway, so a finished download did not mark its card as downloaded and the
+  delete button never appeared. The gateway now returns the exact output stem (`local_name`) and
+  the UI sends it back verbatim for download, progress and delete.
+- **Registering a local model produced an unusable pool entry**: with `manage_server = false` the
+  model was added to the static pool pointing at `cortiq_server_url`, where nothing listens —
+  every call failed with `upstream unavailable`. Registration now always creates a managed server
+  the gateway runs itself, and repairs a stale static entry for the same file.
+- **Cancel did nothing during a sharded download**: cancellation was only checked between part
+  files, so a multi-GB part had to finish first. The running transfer is now aborted immediately
+  and the partial output removed.
+- **Deleting a model left the config broken**: removing a `.cmf` now also unregisters the model
+  and stops its managed server instead of leaving a pool entry pointing at a missing file.
+- **Two variants of one repo collapsed into a single job row**; jobs are now keyed by repo + variant.
+- Curl's stderr is captured into the job log, so a failed download explains itself instead of
+  showing a bare exit code.
+
+## [0.2.36] - 2026-07-25
+
+### Fixed
+- **Docker image failed to start when built fresh (`GLIBC_2.39 not found`)**: the floating `rust:1-slim` builder had drifted to Debian trixie while the runtime stayed on bookworm, so a locally built container crashed on startup. Builder and runtime are now pinned to the same Debian release (trixie).
+- **Docker model downloads (curl exit code 23)**: the runtime image was missing `curl`, and the default models dir (`$HOME/.cortiq-gateway/models`) was not writable by the container user, so importing a ready `.cmf` model failed with a write error. The image now bundles `curl`, keeps all gateway state under `/app/data` (`CORTIQ_GATEWAY_HOME`), and runs as root so bind-mounted host folders (Docker Desktop on Windows/macOS) are writable; pass `--user 10001` to harden when not using host bind mounts.
+- **Docker Compose persistence**: added a `cortiq-data` volume at `/app/data` so downloaded models and stats survive `docker compose up --force-recreate`.
+- **Clear import errors**: a models dir that cannot be created now fails the import immediately with the path and reason instead of a cryptic curl exit code; curl exits 23 (write error) and 22 (HTTP error) are annotated with a human-readable hint in the job log.
+
+## [0.2.35] - 2026-07-23
+
+### Fixed
+- **Streaming Pipeline System Prompt Merging**: Fixed system prompt injection in `run_stream` so configured model system prompts and reasoning suppression directives are properly passed into streaming requests.
+- **CMF Reasoning Mode Compatibility**: Fully integrated with `cortiq-engine` v0.5.17 for sampler-level logit bias reasoning token suppression and zero-token thinking bypass.
+
+## [0.2.34] - 2026-07-23
 
 ### Added
 - **Responsive mobile admin console**: Added a hamburger navigation drawer, touch-friendly controls, phone-sized forms and cards, scrollable tables, compact toolbars, safe-area support, and mobile bottom-sheet dialogs across the admin interface.

Cargo.lock

@@ -285,7 +285,7 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "cortiq-gateway"
-version = "0.2.33"
+version = "0.2.41"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -297,10 +297,12 @@ dependencies = [
  "futures",
  "getrandom 0.2.17",
  "mime_guess",
+ "open",
  "reqwest",
  "rust-embed",
  "serde",
  "serde_json",
+ "sysinfo",
  "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
@@ -340,6 +342,16 @@ dependencies = [
  "crypto-common",
 ]
 
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags",
+ "objc2",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.6"
@@ -743,6 +755,25 @@ version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@@ -853,6 +884,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "ntapi"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3b335231dfd352ffb0f8017f3b6027a4917f7df785ea2143d8af2adc66980ae"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
@@ -862,6 +902,63 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-io-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15"
+dependencies = [
+ "libc",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-open-directory"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb82bed227edf5201dfedf072bba4015a33d3d4a98519837295a90f0a23f676d"
+dependencies = [
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -874,6 +971,16 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
+[[package]]
+name = "open"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9cfef937e9c486488c7e3d949ae31c0f1d06bdacd75b99c086cb35356e30408"
+dependencies = [
+ "is-wsl",
+ "libc",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -1400,6 +1507,21 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "sysinfo"
+version = "0.39.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2071df9448915b71c4fe6d25deaf1c22f12bd234f01540b77312bb8e41361e6"
+dependencies = [
+ "libc",
+ "memchr",
+ "ntapi",
+ "objc2-core-foundation",
+ "objc2-io-kit",
+ "objc2-open-directory",
+ "windows",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -1884,6 +2006,22 @@ dependencies = [
  "rustls-pki-types",
 ]
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
@@ -1893,12 +2031,113 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -1959,6 +2198,15 @@ dependencies = [
  "windows_x86_64_msvc 0.53.1",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cortiq-gateway"
-version = "0.2.34"
+version = "0.2.41"
 edition = "2021"
 rust-version = "1.75"
 license = "Apache-2.0"
@@ -10,12 +10,16 @@ homepage = "https://api.allaigate.com"
 readme = "README.md"
 keywords = ["llm", "gateway", "proxy", "openai", "routing"]
 categories = ["web-programming::http-server", "command-line-utilities"]
-# Files shipped in the published crate. The embedded admin SPA (web/) MUST be
-# included because rust-embed compiles it in; docs/screenshots are excluded to
-# keep the crate lean.
+# Files shipped in the published crate. The embedded admin SPA MUST be included
+# because rust-embed compiles it in; docs/screenshots are excluded to keep the
+# crate lean. The web/ subfolders are listed one by one rather than as web/**/*
+# so stray scratch files dropped next to the SPA never end up published.
 include = [
     "src/**/*",
-    "web/**/*",
+    "web/index.html",
+    "web/favicon.svg",
+    "web/css/**/*",
+    "web/js/**/*",
     "config/gateway.example.toml",
     "README.md",
     "CHANGELOG.md",
@@ -54,6 +58,11 @@ tokio-stream = "0.1"
 
 # CLI / config
 clap = { version = "4", features = ["derive"] }
+# open browser on first run (optional)
+open = { version = "5", optional = true }
+
+# host metrics for the admin dashboard (CPU / RAM / disk)
+sysinfo = "0.39"
 
 # errors / logging / metrics
 thiserror = "1"
@@ -61,6 +70,10 @@ anyhow = "1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
+[features]
+default = ["open-browser"]
+open-browser = ["open"]
+
 [profile.release]
 lto = true
 codegen-units = 1

Dockerfile

@@ -1,6 +1,12 @@
 # ---- build stage ------------------------------------------------------------
-FROM rust:1-slim AS builder
+# pin builder and runtime to the same Debian release — a floating `rust:1-slim`
+# drifts to a newer glibc than the runtime image and the binary refuses to start
+FROM rust:1-slim-trixie AS builder
 WORKDIR /app
+# the cortiq runtime CANNOT be auto-installed inside the container (no cargo in
+# the runtime image), so it is compiled here and shipped alongside the gateway —
+# local .cmf chat models and image/video generation work in Docker out of the box
+RUN cargo install cortiq-cli --locked
 # the admin SPA (web/) is embedded at compile time via rust-embed, so it must be present
 COPY Cargo.toml Cargo.lock ./
 COPY src ./src
@@ -8,18 +14,26 @@ COPY web ./web
 RUN cargo build --release
 
 # ---- runtime stage ----------------------------------------------------------
-FROM debian:bookworm-slim
+FROM debian:trixie-slim
+# curl — model imports download ready .cmf files with it;
+# libvulkan1 — optional GPU offload for cortiq (falls back to CPU without a GPU)
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends ca-certificates \
+    && apt-get install -y --no-install-recommends ca-certificates curl libvulkan1 \
     && rm -rf /var/lib/apt/lists/* \
     && useradd -r -u 10001 cortiq \
-    && mkdir -p /app/config
+    && mkdir -p /app/config /app/data/models
 COPY --from=builder /app/target/release/cortiq-gateway /usr/local/bin/cortiq-gateway
+COPY --from=builder /usr/local/cargo/bin/cortiq /usr/local/bin/cortiq
 # ship the example as the default config so `docker run` works out of the box
 COPY config/gateway.example.toml /app/config/gateway.toml
 RUN chown -R 10001:10001 /app
 WORKDIR /app
-USER cortiq
+# all gateway state (downloaded models, stats, secrets) lives under /app/data —
+# mount a volume there to keep it across container recreates
+ENV CORTIQ_GATEWAY_HOME=/app/data
+# runs as root so writes to bind-mounted host folders (Docker Desktop on
+# Windows/macOS) don't fail with permission errors (curl exit code 23);
+# add `--user 10001` to docker run to harden when not using host bind mounts
 EXPOSE 9000
 ENTRYPOINT ["cortiq-gateway"]
 CMD ["--config", "/app/config/gateway.toml"]

README.md

@@ -36,10 +36,12 @@ One OpenAI-compatible endpoint → automatic model selection from your pool
 
 ## ✨ Highlights
 
+- **Zero-config start.** `cortiq-gateway` with no flags: the config is created for you, a busy port is swapped for a free one, the browser opens on a setup wizard that downloads a ready-made local model and wires it into routing — no TOML, no token, no separate model server.
 - **Fast.** Rust/Tokio: **sub-millisecond p99** gateway overhead — ~10× the throughput of Portkey and ~47× of LiteLLM in a like-for-like proxy benchmark ([details](BENCHMARKS.md)).
 - **Drop-in OpenAI API + streaming.** Point any OpenAI client at the gateway and send `model: "cortiq-auto"`; `stream: true` is fully supported (SSE).
 - **Multi-protocol.** OpenAI Chat & Embeddings, **Anthropic Messages** (in/out, streaming), and an **MCP** server (`POST /mcp`) exposing routing as tools for agent orchestrators.
-- **Intelligent routing.** `complexity.tier` → ordered model pool (`low → local`, `high → cloud`), with fallback and graceful degradation when the router is down.
+- **Intelligent routing.** `complexity.tier` → ordered model pool (`low → local`, `high → cloud`), with fallback and graceful degradation when the router is down. Plus **per-task rules** (`[routing.tasks]`): pin translations to a local model and code to your strongest coder — the complexity chain stays as fallback ([docs](docs/ROUTING.md)).
+- **Image & video generation.** The Playground drives local text-to-image (Lumina) and text-to-video (MiniMax-H3) `.cmf` models via `cortiq imagine`/`animate`: live progress with ETA, a generation gallery, PNG export, in-browser AVI playback — no ffmpeg anywhere.
 - **Semantic cache.** Optional embedding-based cache returns a stored answer for prompts semantically near a previous one — skipping the model call (hit-rate & savings on the dashboard).
 - **Built-in multilingual admin console.** Manage models, routing, protocols, keys and secrets from a web UI — **no hand-editing TOML, no restart** (changes are hot-reloaded). Available in **7 languages** (en, ru, de, fr, es, zh, tr) with light/dark themes.
 - **Live analytics.** Per-request stats (tokens, cost, latency, success rate, failovers), time-series charts, breakdowns by model/tier/task, and a Prometheus `GET /metrics` endpoint.
@@ -54,11 +56,13 @@ One OpenAI-compatible endpoint → automatic model selection from your pool
 ```bash
 # Docker (GitHub Container Registry)
 docker run -p 9000:9000 -e CORTIQ_ADMIN_TOKEN=secret \
-  -v "$PWD/config:/app/config" ghcr.io/infosave2007/cortiq-gateway:latest
+  -v "$PWD/config:/app/config" -v cortiq-data:/app/data \
+  ghcr.io/infosave2007/cortiq-gateway:latest
 # → admin console at http://localhost:9000/admin
 
 # from crates.io
 cargo install cortiq-gateway
+cortiq-gateway          # no flags, no config file, no token — see Quick start
 
 # or build from source
 git clone https://github.com/infosave2007/cortiq-gateway
@@ -67,7 +71,10 @@ cargo build --release   # ./target/release/cortiq-gateway
 ```
 
 The image ships a default config and runs out of the box; mount `/app/config` (with a
-`gateway.toml`) to use your own. Tags: `:latest`, `:X.Y.Z`, `:edge` (linux/amd64 + arm64).
+`gateway.toml`) to use your own. Downloaded models and stats live in `/app/data` — mount
+a volume there so they survive container recreates (a host folder works too, e.g.
+`-v "$PWD/models:/app/data/models"`). Tags: `:latest`, `:X.Y.Z`, `:edge`
+(linux/amd64 + arm64).
 
 **Docker Compose** — gateway + a local Ollama model in one command:
 
@@ -98,32 +105,54 @@ The gateway ships with an embedded web console at **`/admin`**:
 | ![Playground](https://raw.githubusercontent.com/infosave2007/cortiq-gateway/master/docs/screenshots/playground.png) |
 | test the live pipeline and see the routing decision |
 
+The console is **open by default** — no token needed. To protect it, set any one of
+`--admin-token <TOKEN>`, `[admin].token`, or `[admin].token_env`:
+
 ```bash
-cargo run --release -- --config config/gateway.toml --admin-token <YOUR_TOKEN>
+cortiq-gateway --admin-token <YOUR_TOKEN>
 # open  http://localhost:9000/admin?token=<YOUR_TOKEN>
 ```
 
-If `--admin-token` / `[admin].token_env` are not set, a token is generated at startup
-and printed to the log. All `/admin/api/*` endpoints require a Bearer admin token;
-secret values are never returned by the API (only their presence: `store` / `env` / `missing`).
+Once a token is set, every `/admin/api/*` endpoint requires it as a Bearer token. Secret
+values are never returned by the API (only their presence: `store` / `env` / `missing`).
 
 ---
 
 ## 🚀 Quick start
 
 ```bash
-# 1. start a router (the hosted allaigate router, or a local cortiq-router)
-#    it listens e.g. on http://localhost:8080 (or https://api.allaigate.com)
-
-# 2. describe your model pool
-cp config/gateway.example.toml config/gateway.toml
-$EDITOR config/gateway.toml
-
-# 3. run the gateway
-cortiq-gateway --config config/gateway.toml
-# Gateway listens on 0.0.0.0:9000 and serves the admin console at /admin
+cortiq-gateway
 ```
 
+That is the whole command. On first run the gateway:
+
+1. **creates its config** — `config/gateway.toml` when started from a checkout, otherwise
+   `~/.cortiq-gateway/gateway.toml` (override with `$CORTIQ_GATEWAY_HOME` or `--config`);
+2. **picks a free port** if 9000 is taken, and writes the choice back to the config;
+3. **opens your browser** on the setup wizard at `/admin#/onboarding`.
+
+The wizard takes you from nothing to a working local model:
+
+| Step | What happens |
+|---|---|
+| **Language** | 7 languages; changeable later from the header |
+| **Ready-made models** | the [`infosave`](https://huggingface.co/infosave) `.cmf` models, read live from HuggingFace — pick a quantization and watch the real download progress |
+| **Any HF model** | search HuggingFace and auto-convert to `.cmf` |
+| **Finish** | every completed download is connected as a local model, its `cortiq serve` is started, `routing.default` points at it, and you land in the Playground |
+
+No TOML editing, no separate "register" step, no manually started model server. Prefer to skip
+the wizard? Add models from the console (**Models**, **Import model**) or hand-write the config —
+both still work, and changes hot-reload without a restart.
+
+```bash
+# explicit config / port / no browser — all optional
+cortiq-gateway --config config/gateway.toml --no-browser --no-port-search
+```
+
+For smart routing across a pool, point `[router]` at the hosted allaigate router or a local
+`cortiq-router` (see [docs/ROUTER.md](docs/ROUTER.md)). Without a router the gateway degrades
+gracefully to the default model, so a local-only setup works out of the box.
+
 Now any OpenAI client works through the gateway:
 
 ```python

README.ru.md

@@ -36,9 +36,11 @@
 
 ## ✨ Ключевое
 
+- **Запуск без конфигурации.** `cortiq-gateway` без флагов: конфиг создаётся сам, занятый порт меняется на свободный, браузер открывается на мастере, который скачивает готовую локальную модель и заводит её в роутинг — без TOML, без токена, без отдельно запущенного сервера модели.
 - **Быстрый.** Rust/Tokio: overhead шлюза с **субмиллисекундным p99** — ~10× к throughput Portkey и ~47× к LiteLLM в сопоставимом бенчмарке ([детали](BENCHMARKS.md)).
 - **Drop-in OpenAI API + стриминг.** Направьте любой OpenAI-клиент на шлюз и шлите `model: "cortiq-auto"`; `stream: true` поддержан (SSE).
-- **Интеллектуальный роутинг.** `complexity.tier` → упорядоченный пул моделей (`low → локально`, `high → облако`), с fallback и мягкой деградацией, если роутер недоступен.
+- **Интеллектуальный роутинг.** `complexity.tier` → упорядоченный пул моделей (`low → локально`, `high → облако`), с fallback и мягкой деградацией, если роутер недоступен. Плюс **правила по задачам** (`[routing.tasks]`): переводы — в локальную модель, код — сильнейшему кодеру; цепочка по сложности остаётся резервом ([доки](docs/ROUTING.ru.md)).
+- **Генерация картинок и видео.** Песочница запускает локальные text-to-image (Lumina) и text-to-video (MiniMax-H3) `.cmf` модели через `cortiq imagine`/`animate`: живой прогресс с ETA, галерея генераций, экспорт в PNG, проигрывание AVI прямо в браузере — без ffmpeg вообще.
 - **Встроенная многоязычная панель управления.** Модели, роутинг, протоколы, ключи и секреты — из веб-интерфейса, **без ручного TOML и без рестарта** (горячая перезагрузка). **7 языков** (en, ru, de, fr, es, zh, tr), тёмная/светлая тема.
 - **Живая аналитика.** Статистика по запросам (токены, стоимость, латентность, доля успеха, failover), графики, разбивка по моделям/полосам/задачам и Prometheus `GET /metrics`.
 - **Playground.** Прогон промпта через живой пайплайн с разбором решения роутинга.
@@ -57,6 +59,7 @@ docker run -p 9000:9000 -e CORTIQ_ADMIN_TOKEN=secret \
 
 # с crates.io
 cargo install cortiq-gateway
+cortiq-gateway          # без флагов, без конфига, без токена — см. Быстрый старт
 
 # или сборка из исходников
 git clone https://github.com/infosave2007/cortiq-gateway
@@ -94,32 +97,54 @@ docker compose exec ollama ollama pull qwen2.5:0.5b   # один раз скач
 | ![Playground](docs/screenshots/playground.png) | ![Дашборд](docs/screenshots/dashboard.png) |
 | **Playground** — тест живого пайплайна с решением роутинга | **Dashboard** — трафик, стоимость, латентность |
 
+Панель **по умолчанию открыта** — токен не нужен. Чтобы закрыть её, задайте любое из
+`--admin-token <ТОКЕН>`, `[admin].token` или `[admin].token_env`:
+
 ```bash
-cargo run --release -- --config config/gateway.toml --admin-token <ВАШ_ТОКЕН>
+cortiq-gateway --admin-token <ВАШ_ТОКЕН>
 # откройте  http://localhost:9000/admin?token=<ВАШ_ТОКЕН>
 ```
 
-Если `--admin-token` / `[admin].token_env` не заданы — токен генерируется при старте и
-печатается в лог. Все эндпоинты `/admin/api/*` требуют Bearer admin-токен; значения
-секретов API наружу не отдаёт (только статус наличия: `store` / `env` / `missing`).
+Когда токен задан, все эндпоинты `/admin/api/*` требуют его как Bearer. Значения секретов
+API наружу не отдаёт (только статус наличия: `store` / `env` / `missing`).
 
 ---
 
 ## 🚀 Быстрый старт
 
 ```bash
-# 1. поднимите роутер (хостовый allaigate или локальный cortiq-router)
-#    он слушает, например, http://localhost:8080 (или https://api.allaigate.com)
-
-# 2. опишите свой пул моделей
-cp config/gateway.example.toml config/gateway.toml
-$EDITOR config/gateway.toml
-
-# 3. запустите шлюз
-cargo run --release -- --config config/gateway.toml
-# Шлюз слушает 0.0.0.0:9000 и отдаёт панель на /admin
+cortiq-gateway
 ```
 
+Это вся команда. При первом запуске шлюз:
+
+1. **создаёт конфиг** — `config/gateway.toml`, если запущен из репозитория, иначе
+   `~/.cortiq-gateway/gateway.toml` (переопределяется через `$CORTIQ_GATEWAY_HOME` или `--config`);
+2. **подбирает свободный порт**, если 9000 занят, и записывает выбор в конфиг;
+3. **открывает браузер** на мастере настройки `/admin#/onboarding`.
+
+Мастер доводит от нуля до работающей локальной модели:
+
+| Шаг | Что происходит |
+|---|---|
+| **Язык** | 7 языков; потом меняется в шапке |
+| **Готовые модели** | `.cmf` модели [`infosave`](https://huggingface.co/infosave), список читается с HuggingFace вживую — выбираете квантизацию и видите реальный прогресс загрузки |
+| **Любая модель с HF** | поиск по HuggingFace и автоконвертация в `.cmf` |
+| **Завершить** | каждая скачанная модель подключается как локальная, поднимается её `cortiq serve`, `routing.default` указывает на неё — и вы попадаете в Песочницу |
+
+Никаких правок TOML, отдельного шага «зарегистрировать» и вручную запущенного сервера модели.
+Мастер не нужен? Добавляйте модели из панели (**Модели**, **Импорт модели**) или пишите конфиг
+руками — оба пути работают, изменения применяются на лету без перезапуска.
+
+```bash
+# явный конфиг / порт / без браузера — всё опционально
+cortiq-gateway --config config/gateway.toml --no-browser --no-port-search
+```
+
+Для умного роутинга по пулу направьте `[router]` на хостовый allaigate или локальный
+`cortiq-router` (см. [docs/ROUTER.ru.md](docs/ROUTER.ru.md)). Без роутера шлюз мягко
+деградирует до модели по умолчанию, поэтому чисто локальная установка работает сразу.
+
 Теперь любой OpenAI-клиент работает через шлюз:
 
 ```python

config/gateway.example.toml

@@ -14,11 +14,11 @@ listen = "0.0.0.0:9000"
 # NOTE: on hard prompts the router escalates to an oracle LLM (~10 s) — for the
 # hosted router set timeout_ms = 12000+, otherwise the gateway degrades to default.
 [router]
-url         = "http://localhost:8080"
+url         = "https://138.226.222.209"   # hosted allaigate router (or your own cortiq-router URL)
 api_key_env = "CORTIQ_ROUTER_KEY"   # name of the env var holding the router key
-timeout_ms  = 800                    # timeout for the /v1/route call (12000+ for oracle)
-taxonomy_id = "general.task-type"    # for allaigate: "data-assistant"
-verify_tls  = true                   # false if the router uses an IP / self-signed cert
+timeout_ms  = 12000                  # hard prompts escalate to an oracle (~10 s)
+taxonomy_id = "data-assistant"       # the hosted router's task taxonomy
+verify_tls  = false                  # the hosted endpoint is IP-bound; true for your own domain
 
 # --- how to pick the text to classify from the conversation -----------------
 [route]
@@ -71,7 +71,7 @@ openai_chat        = true
 openai_completions = true
 openai_embeddings  = true
 openai_models      = true
-anthropic_messages = false
+anthropic_messages = true
 mcp                = false
 native_passthrough = true
 
@@ -119,6 +119,10 @@ enabled   = true
 file      = "config/stats.jsonl"   # empty = in-memory only
 ring_size = 500                     # how many recent requests to keep in the feed
 retention = "7d"                    # aggregate/series depth (replayed on startup)
+# stats.jsonl is compacted once it exceeds this size: old records fold into
+# cumulative per-account totals (sidecar file), so per-key accounting survives
+# while the disk stays bounded. 0 disables.
+max_file_mb = 16
 
 # ============================================================================
 # Semantic cache — returns a cached answer for prompts semantically near a

docker-compose.yml

@@ -17,6 +17,10 @@ services:
       CORTIQ_ROUTER_KEY: ${CORTIQ_ROUTER_KEY:-}
     volumes:
       - ./config/gateway.compose.toml:/app/config/gateway.toml:ro
+      # downloaded .cmf models + stats persist here across recreates; swap the
+      # named volume for a host folder (e.g. ./models:/app/data/models) if you
+      # want the files visible next to the compose file
+      - cortiq-data:/app/data
     depends_on:
       - ollama
     restart: unless-stopped
@@ -30,4 +34,5 @@ services:
     restart: unless-stopped
 
 volumes:
+  cortiq-data:
   ollama:

docs/ROUTER.md

@@ -50,7 +50,7 @@ timeout_ms  = 15000                        # allow for oracle escalation on hard
 
 ```bash
 export CORTIQ_ROUTER_KEY=cortiq_your_key
-cortiq-gateway --config config/gateway.toml
+cortiq-gateway            # --config <path> only if you keep the config elsewhere
 ```
 
 ## API contract

docs/ROUTER.ru.md

@@ -49,7 +49,7 @@ timeout_ms  = 15000                        # запас под oracle-эскал
 
 ```bash
 export CORTIQ_ROUTER_KEY=cortiq_your_key
-cortiq-gateway --config config/gateway.toml
+cortiq-gateway            # --config <путь> нужен, только если конфиг лежит в другом месте
 ```
 
 ## Контракт API

docs/ROUTING.md

@@ -162,3 +162,44 @@ fine-tune the task mask. Over time this makes routing fit your specific pool mor
 enabled = false
 # the ground-truth source is set by the integrator (e.g. the X-Cortiq-Correct-Label header)
 ```
+
+## Task-based routing
+
+The router classifies every request twice: a **task label** (what kind of work it
+is) and a **complexity tier** (how hard it is). Tiers pick *how much model* you
+need; task rules pick *which* model is best at the job:
+
+```toml
+[routing.tasks]
+translation = ["local-qwen"]           # translations are cheap — keep them local
+code        = ["claude-sonnet", "gpt"] # code goes to the strongest coder first
+```
+
+A matching rule's models go **first** in the candidate chain; the complexity
+chain follows as fallback, so a task pin never weakens failover. Tasks without
+a rule route by complexity alone.
+
+**Per-complexity models for a task.** A task rule also accepts a per-tier
+map — "which model serves this task at each complexity":
+
+```toml
+[routing.tasks.code]
+low  = ["cheap-coder"]     # routine code stays cheap
+high = ["best-coder"]      # hard code goes to the strongest coder
+any  = ["generic-coder"]   # leads at every tier after the tier-specific pick
+```
+
+The tier-specific list leads its own tier; `any` (and the legacy plain-array
+form) leads at every tier; the global tier chain and `default` always remain
+as fallback, so a task rule never weakens failover. The admin console's
+Routing page edits this as rows of “model + complexity” pairs per task.
+
+**Exception — high complexity escalates.** When the router rates a request
+`high` (and a `high` chain is configured), the tier chain leads and the task
+rule demotes to fallback. Otherwise a rule like `code → cheap-model` would pin
+even the hardest prompts to the cheap model and the tier system would never
+get a say. Low/medium keep task-rule-first semantics. The available labels come from the router
+(`GET /v1/taxonomies`) — the admin console's Routing page builds the editor
+from your account's live taxonomy and shows each task's share of recent
+traffic. When a rule supplied the head of the chain the response reports
+`route_source: "router+task-rule"`.

docs/ROUTING.ru.md

@@ -160,3 +160,43 @@ cooldown  = "30s"
 enabled = false
 # источник истины задаёт интегратор (например, заголовок X-Cortiq-Correct-Label)
 ```
+
+## Распределение по задачам
+
+Роутер классифицирует каждый запрос дважды: **тип задачи** (что это за работа)
+и **уровень сложности** (насколько она трудна). Уровни выбирают, *сколько
+модели* нужно; правила по задачам — *какая* модель лучше в этом деле:
+
+```toml
+[routing.tasks]
+translation = ["local-qwen"]           # переводы дёшевы — оставляем локально
+code        = ["claude-sonnet", "gpt"] # код — сильнейшему кодеру
+```
+
+Модели подходящего правила идут **первыми** в цепочке кандидатов; цепочка по
+сложности следует за ними как резерв — правило по задаче не ослабляет failover.
+Задачи без правила маршрутизируются только по сложности.
+
+**Модели по сложности внутри задачи.** Правило задачи принимает и карту по
+уровням — «какая модель обслуживает задачу на какой сложности»:
+
+```toml
+[routing.tasks.code]
+low  = ["cheap-coder"]     # рутинный код — дёшево
+high = ["best-coder"]      # сложный код — сильнейшему кодеру
+any  = ["generic-coder"]   # ведёт на всех уровнях после уровневого выбора
+```
+
+Список конкретного уровня ведёт на своём уровне; `any` (и старая форма-массив)
+ведёт на всех; глобальная цепочка уровня и `default` всегда остаются резервом —
+правило задачи не ослабляет failover. На вкладке Роутинг это редактируется
+строками пар «модель + сложность» у каждой задачи.
+
+**Исключение — высокая сложность эскалирует.** Когда роутер оценил запрос как
+`high` (и цепочка `high` настроена), цепочка уровня идёт первой, а правило
+задачи становится резервом. Иначе правило вида `code → дешёвая-модель`
+приковало бы к дешёвой модели даже самые сложные запросы, и система уровней
+не имела бы права голоса. Для low/medium правило задачи ведёт, как и раньше. Список меток приходит
+с роутера (`GET /v1/taxonomies`) — вкладка Роутинг строит редактор по живой
+таксономии аккаунта и показывает долю каждой задачи в трафике. Когда цепочку
+возглавило правило задачи, ответ сообщает `route_source: "router+task-rule"`.

src/bench.rs

@@ -0,0 +1,225 @@
+//! One-click local model benchmark: run `cortiq bench <model> --json` and keep
+//! the parsed result per model, so the Models page can show real tok/s numbers
+//! measured on this machine.
+
+use serde::Serialize;
+use std::collections::HashMap;
+use std::process::Stdio;
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone, Serialize)]
+pub struct BenchRun {
+    pub model: String, // file stem under models_dir
+    pub state: String, // running | done | error
+    pub log: Vec<String>,
+    pub tok_s: Option<f64>,
+    /// The full JSON object the benchmark printed, passed through untouched.
+    pub raw: Option<serde_json::Value>,
+    pub started: u64,
+    pub finished: Option<u64>,
+}
+
+#[derive(Default)]
+pub struct BenchStore {
+    runs: Mutex<HashMap<String, BenchRun>>,
+    busy: Mutex<bool>,
+}
+
+fn now() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+/// tok/s out of the benchmark's JSON: known field names first (steady decode
+/// speed is the honest number), then any `*tok_s*` field as a fallback. The
+/// old loose "contains tok + per" heuristic could grab `allocs_per_token`.
+fn extract_tok_s(v: &serde_json::Value) -> Option<f64> {
+    let obj = v.as_object()?;
+    for want in [
+        "decode_tok_s_steady",
+        "decode_tok_s_incl_prefill",
+        "decode_tok_s",
+        "tok_s",
+        "tok_per_s",
+        "tokens_per_sec",
+    ] {
+        if let Some(n) = obj.get(want).and_then(|x| x.as_f64()) {
+            return Some(n);
+        }
+    }
+    obj.iter()
+        .find(|(k, val)| {
+            let k = k.to_ascii_lowercase();
+            (k.contains("tok_s") || k.contains("tokens_per")) && val.as_f64().is_some()
+        })
+        .and_then(|(_, val)| val.as_f64())
+}
+
+/// Last parseable JSON object in mixed CLI output. Newer cortiq releases
+/// pretty-print the `--json` result over many lines, older ones emit a single
+/// line — this handles both, skipping any log noise around it.
+fn last_json_object(text: &str) -> Option<serde_json::Value> {
+    let mut end = text.len();
+    while let Some(close) = text[..end].rfind('}') {
+        let mut depth = 0i32;
+        let mut start = None;
+        for (i, c) in text[..=close].char_indices().rev() {
+            match c {
+                '}' => depth += 1,
+                '{' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        start = Some(i);
+                        break;
+                    }
+                }
+                _ => {}
+            }
+        }
+        if let Some(st) = start {
+            if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text[st..=close]) {
+                if v.is_object() {
+                    return Some(v);
+                }
+            }
+        }
+        end = close;
+    }
+    None
+}
+
+impl BenchStore {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+    pub fn get(&self, model: &str) -> Option<BenchRun> {
+        self.runs.lock().unwrap().get(model).cloned()
+    }
+    pub fn list(&self) -> Vec<BenchRun> {
+        self.runs.lock().unwrap().values().cloned().collect()
+    }
+}
+
+/// Kick off a benchmark for `<models_dir>/<model>.cmf`. One at a time — a
+/// benchmark loads the whole model and owns the machine while it runs.
+pub fn start(
+    store: Arc<BenchStore>,
+    cmf: &crate::config::CmfCfg,
+    model: String,
+) -> Result<(), String> {
+    let path = std::path::Path::new(&cmf.models_dir).join(format!("{model}.cmf"));
+    if !path.exists() {
+        return Err(format!("model file not found: {}", path.display()));
+    }
+    {
+        let mut busy = store.busy.lock().unwrap();
+        if *busy {
+            return Err("a benchmark is already running — wait for it to finish".into());
+        }
+        *busy = true;
+    }
+    store.runs.lock().unwrap().insert(
+        model.clone(),
+        BenchRun {
+            model: model.clone(),
+            state: "running".into(),
+            log: Vec::new(),
+            tok_s: None,
+            raw: None,
+            started: now(),
+            finished: None,
+        },
+    );
+    let bin = cmf.cortiq_bin.clone();
+    let gpu = cmf.gpu;
+    tokio::spawn(async move {
+        let out = tokio::process::Command::new(&bin)
+            .arg("bench")
+            .arg(&path)
+            .arg("--json")
+            .env("CMF_GPU", if gpu { "1" } else { "0" })
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()
+            .await;
+        let mut g = store.runs.lock().unwrap();
+        let run = g.get_mut(&model).unwrap();
+        run.finished = Some(now());
+        match out {
+            Ok(o) => {
+                let text = format!(
+                    "{}\n{}",
+                    String::from_utf8_lossy(&o.stdout),
+                    String::from_utf8_lossy(&o.stderr)
+                );
+                // keep a readable tail; the JSON line is parsed separately
+                run.log = text
+                    .lines()
+                    .map(|l| l.trim())
+                    .filter(|l| !l.is_empty() && !l.contains("Metal GPU path"))
+                    .map(String::from)
+                    .collect::<Vec<_>>();
+                let n = run.log.len();
+                if n > 30 {
+                    run.log.drain(0..n - 30);
+                }
+                let parsed = last_json_object(&text);
+                match parsed {
+                    Some(v) if o.status.success() => {
+                        run.tok_s = extract_tok_s(&v);
+                        run.raw = Some(v);
+                        run.state = "done".into();
+                    }
+                    _ => run.state = "error".into(),
+                }
+            }
+            Err(e) => {
+                run.log.push(format!("✗ failed to start cortiq bench: {e}"));
+                run.state = "error".into();
+            }
+        }
+        drop(g);
+        *store.busy.lock().unwrap() = false;
+    });
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tok_s_from_common_keys() {
+        let v = serde_json::json!({"tok_s": 42.5, "allocs_per_token": 0});
+        assert_eq!(extract_tok_s(&v), Some(42.5));
+        let v = serde_json::json!({"decode_tokens_per_sec": 31.0});
+        assert_eq!(extract_tok_s(&v), Some(31.0));
+    }
+
+    #[test]
+    fn steady_decode_wins_and_allocs_never_matches() {
+        let v = serde_json::json!({
+            "allocs_per_token": 769.4,
+            "decode_tok_s_incl_prefill": 9.98,
+            "decode_tok_s_steady": 11.86,
+            "prefill_tok_s": 25.5,
+        });
+        assert_eq!(extract_tok_s(&v), Some(11.86));
+        let v = serde_json::json!({"allocs_per_token": 769.4, "seq_len": 140});
+        assert_eq!(extract_tok_s(&v), None);
+    }
+
+    #[test]
+    fn json_found_single_line_and_pretty() {
+        let single = "noise\n{\"tok_s\": 5.0}\nmore noise";
+        assert_eq!(last_json_object(single).unwrap()["tok_s"], 5.0);
+        let pretty = "INFO loading\n{\n  \"decode_tok_s_steady\": 11.86,\n  \"seq_len\": 140\n}\nINFO done {not json";
+        assert_eq!(
+            last_json_object(pretty).unwrap()["decode_tok_s_steady"],
+            11.86
+        );
+        assert!(last_json_object("no braces here").is_none());
+    }
+}

src/cmf_runtime.rs

@@ -197,14 +197,14 @@ impl Default for CmfRuntime {
     }
 }
 
-/// crates.io `newest_version` for `cortiq-cli`.
-async fn latest_crates_version() -> Option<String> {
+/// crates.io `newest_version` for any crate.
+async fn latest_version_of(krate: &str) -> Option<String> {
     let client = reqwest::Client::builder()
         .timeout(Duration::from_secs(10))
         .build()
         .ok()?;
     let body = client
-        .get("https://crates.io/api/v1/crates/cortiq-cli")
+        .get(format!("https://crates.io/api/v1/crates/{krate}"))
         .header("User-Agent", "cortiq-gateway")
         .send()
         .await
@@ -216,6 +216,16 @@ async fn latest_crates_version() -> Option<String> {
     v["crate"]["newest_version"].as_str().map(|s| s.to_string())
 }
 
+/// crates.io `newest_version` for `cortiq-cli`.
+async fn latest_crates_version() -> Option<String> {
+    latest_version_of("cortiq-cli").await
+}
+
+/// Newest published gateway version — the "update available" footer check.
+pub(crate) async fn latest_gateway_version() -> Option<String> {
+    latest_version_of("cortiq-gateway").await
+}
+
 /// `<bin> --version` → the trailing version token (e.g. "cortiq 0.1.2" → "0.1.2").
 pub(crate) fn installed_version(bin: &str) -> Option<String> {
     let out = std::process::Command::new(bin)

src/config.rs

@@ -9,6 +9,9 @@ use std::path::PathBuf;
 /// `$CORTIQ_GATEWAY_HOME`, then `$XDG_DATA_HOME/cortiq-gateway`, then
 /// `~/.cortiq-gateway` — so defaults work regardless of the process CWD
 /// (important once the gateway is installed rather than run from its repo).
+/// On Windows also checks `%APPDATA%`, `%LOCALAPPDATA%` and `%USERPROFILE%`
+/// so double-clicking the exe from `Downloads` does not try to write into
+/// `Program Files`.
 pub fn data_dir() -> PathBuf {
     for (var, sub) in [
         ("CORTIQ_GATEWAY_HOME", ""),
@@ -25,6 +28,20 @@ pub fn data_dir() -> PathBuf {
             }
         }
     }
+    #[cfg(windows)]
+    {
+        for (var, sub) in [
+            ("APPDATA", "cortiq-gateway"),
+            ("LOCALAPPDATA", "cortiq-gateway"),
+            ("USERPROFILE", ".cortiq-gateway"),
+        ] {
+            if let Ok(v) = std::env::var(var) {
+                if !v.is_empty() {
+                    return PathBuf::from(v).join(sub);
+                }
+            }
+        }
+    }
     PathBuf::from("data")
 }
 
@@ -288,7 +305,9 @@ fn default_router_enabled() -> bool {
     true
 }
 fn default_router_timeout() -> u64 {
-    800
+    // the hosted router escalates hard prompts to an oracle (~10 s);
+    // an 800 ms budget silently degraded every one of those to the fallback
+    15_000
 }
 fn default_verify_tls() -> bool {
     true
@@ -379,17 +398,149 @@ pub struct RoutingCfg {
     pub default: String,
     #[serde(default)]
     pub policy: RoutingPolicy,
+    /// Per-task rules: `task_label → ordered model list`. A matching rule's
+    /// models go FIRST; the complexity-tier chain follows as fallback, so a
+    /// task pin never weakens failover. Named field, so a tier cannot be
+    /// called "tasks" — serde extracts it before the flattened tier map.
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub tasks: HashMap<String, TierTargets>,
+    /// Local complexity bands: re-map the router's continuous score into
+    /// low/medium/high with YOUR OWN boundaries. The hosted router's bands
+    /// are global for all customers; these are per-gateway. `None` = keep
+    /// the router's tier verdict as delivered.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bands: Option<TierBands>,
+}
+
+/// Score boundaries: `score ≤ low` → low, `≤ medium` → medium, else high.
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct TierBands {
+    pub low: f32,
+    pub medium: f32,
+}
+
+impl TierBands {
+    pub fn tier_of(&self, score: f32) -> &'static str {
+        if score <= self.low {
+            "low"
+        } else if score <= self.medium {
+            "medium"
+        } else {
+            "high"
+        }
+    }
 }
 
 /// A routing tier is either a list of model_ids or the string `default`.
 /// (`default` is handled by a separate field; only tier lists appear here.)
+///
+/// TASK rules additionally accept a per-complexity map — "which model serves
+/// this task at each tier":
+///
+/// ```toml
+/// [routing.tasks.code]
+/// low    = ["cheap-coder"]
+/// high   = ["big-model"]
+/// any    = ["fallback"]        # leads at every tier after the tier-specific list
+/// ```
+///
+/// The plain-array form stays valid and means "leads at any tier". The
+/// transitional `{ models = [...], tier = "high" }` form is normalized into
+/// the map on load. Untagged: map is tried first, arrays keep parsing as is.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum TierTargets {
+    Map(HashMap<String, TaskTierVal>),
     List(Vec<String>),
     One(String),
 }
 
+/// A value inside a task's per-tier map: a model list, a single model, or the
+/// transitional string value of the legacy `tier = "high"` key.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum TaskTierVal {
+    List(Vec<String>),
+    Str(String),
+}
+
+impl TaskTierVal {
+    fn list(&self) -> Vec<String> {
+        match self {
+            TaskTierVal::List(v) => v.clone(),
+            TaskTierVal::Str(s) => vec![s.clone()],
+        }
+    }
+}
+
+pub const TASK_TIER_KEYS: [&str; 4] = ["any", "low", "medium", "high"];
+
+impl TierTargets {
+    /// Every referenced model id, whatever the syntactic form (validation).
+    pub fn models(&self) -> Vec<String> {
+        match self {
+            TierTargets::Map(m) => {
+                let mut out = Vec::new();
+                for (k, v) in m {
+                    if k == "tier" {
+                        continue; // legacy marker, not a model list
+                    }
+                    out.extend(v.list());
+                }
+                out
+            }
+            TierTargets::List(v) => v.clone(),
+            TierTargets::One(s) => vec![s.clone()],
+        }
+    }
+
+    /// Normalized task rule: `(any_tier_models, per_tier_models)`.
+    /// Legacy `{models, tier}` becomes `per[tier] = models`; a plain array
+    /// becomes `any`.
+    pub fn task_rule(&self) -> (Vec<String>, HashMap<String, Vec<String>>) {
+        match self {
+            TierTargets::Map(m) => {
+                let mut any: Vec<String> = Vec::new();
+                let mut per: HashMap<String, Vec<String>> = HashMap::new();
+                let legacy_tier = m.get("tier").and_then(|v| match v {
+                    TaskTierVal::Str(s) => Some(s.clone()),
+                    _ => None,
+                });
+                for (k, v) in m {
+                    match k.as_str() {
+                        "tier" => {}
+                        "any" | "models" => any.extend(v.list()),
+                        "low" | "medium" | "high" => {
+                            per.entry(k.clone()).or_default().extend(v.list())
+                        }
+                        _ => {}
+                    }
+                }
+                if let Some(tier) = legacy_tier {
+                    // legacy pin: the models were meant for that tier
+                    let moved = std::mem::take(&mut any);
+                    per.entry(tier).or_default().extend(moved);
+                }
+                (any, per)
+            }
+            TierTargets::List(v) => (v.clone(), HashMap::new()),
+            TierTargets::One(s) => (vec![s.clone()], HashMap::new()),
+        }
+    }
+
+    /// Unknown keys inside a task map (validation).
+    pub fn invalid_task_keys(&self) -> Vec<String> {
+        match self {
+            TierTargets::Map(m) => m
+                .keys()
+                .filter(|k| !TASK_TIER_KEYS.contains(&k.as_str()) && *k != "models" && *k != "tier")
+                .cloned()
+                .collect(),
+            _ => Vec::new(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RoutingPolicy {
     #[serde(default = "default_mode")]
@@ -562,6 +713,12 @@ pub struct StatsCfg {
     /// Retention window for aggregates/time-series replayed on startup, e.g. `7d`.
     #[serde(default = "default_stats_retention")]
     pub retention: String,
+    /// Compact the JSONL file once it exceeds this size: records older than
+    /// `retention` fold into cumulative per-account totals (a small sidecar
+    /// file) and are removed, so per-key accounting survives while the disk
+    /// stays bounded. 0 disables compaction.
+    #[serde(default = "default_stats_max_file_mb")]
+    pub max_file_mb: u64,
 }
 impl Default for StatsCfg {
     fn default() -> Self {
@@ -570,6 +727,7 @@ impl Default for StatsCfg {
             file: default_stats_file(),
             ring_size: default_stats_ring(),
             retention: default_stats_retention(),
+            max_file_mb: default_stats_max_file_mb(),
         }
     }
 }
@@ -585,6 +743,9 @@ fn default_stats_ring() -> usize {
 fn default_stats_retention() -> String {
     "7d".into()
 }
+fn default_stats_max_file_mb() -> u64 {
+    16
+}
 
 /// Self-warming shadow loop (docs/SELF_WARMING_GATEWAY.md). While a task
 /// label is not yet promoted, the client is served the CLOUD answer; in
@@ -702,6 +863,74 @@ fn default_semcache_max() -> usize {
     1000
 }
 
+/// Sensible defaults for a fresh install (empty pool — user fills via wizard/UI).
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            listen: "0.0.0.0:9000".to_string(),
+            // The hosted allaigate router — the thing this gateway is built
+            // around. Without a key the pipeline degrades gracefully to local
+            // models and the console asks for one; nothing breaks.
+            router: RouterCfg {
+                enabled: true,
+                url: "https://138.226.222.209".to_string(),
+                timeout_ms: 15_000, // hard prompts escalate to an oracle (~10 s)
+                verify_tls: false,  // the hosted endpoint is IP-bound
+                api_key_env: Some("CORTIQ_ROUTER_KEY".to_string()),
+                taxonomy_id: Some("data-assistant".to_string()),
+            },
+            route: RouteCfg::default(),
+            models: Vec::new(),
+            routing: RoutingCfg {
+                tiers: HashMap::new(),
+                default: String::new(),
+                policy: RoutingPolicy::default(),
+                tasks: HashMap::new(),
+                bands: None,
+            },
+            breaker: BreakerCfg::default(),
+            protocols: ProtocolsCfg {
+                openai_chat: true,
+                openai_completions: true,
+                openai_embeddings: true,
+                openai_models: true,
+                // on by default: the API-keys view ships a Claude Code
+                // auto-setup snippet that targets /v1/messages
+                anthropic_messages: true,
+                mcp: false,
+                native_passthrough: true,
+            },
+            cortiq: CortiqCfg::default(),
+            api_keys: Vec::new(),
+            idempotency: IdempotencyCfg::default(),
+            log: LogCfg::default(),
+            telemetry: TelemetryCfg::default(),
+            admin: AdminCfg::default(),
+            stats: StatsCfg::default(),
+            cache: CacheCfg::default(),
+            shadow: ShadowCfg::default(),
+            cmf: CmfCfg::default(),
+        }
+    }
+}
+
+/// Where the config lives when `--config` is not given.
+/// Repo checkout (`config/gateway.toml` exists or `config/` dir exists) → keep it there;
+/// installed binary (no repo) → `$data_dir/gateway.toml`.
+pub fn default_config_path() -> String {
+    let repo_path = "config/gateway.toml";
+    if std::path::Path::new(repo_path).exists() {
+        return repo_path.to_string();
+    }
+    if std::path::Path::new("Cargo.toml").exists() && std::path::Path::new("config").exists() {
+        return repo_path.to_string();
+    }
+    data_dir()
+        .join("gateway.toml")
+        .to_string_lossy()
+        .into_owned()
+}
+
 impl Config {
     /// Load and validate the config from a file.
     pub fn load(path: &str) -> anyhow::Result<Self> {
@@ -712,6 +941,22 @@ impl Config {
         Ok(cfg)
     }
 
+    /// Load if exists, otherwise create a fresh default config at `path` and return it.
+    /// Never requires the user to create or copy a file by hand.
+    pub fn load_or_create(path: &str) -> anyhow::Result<Self> {
+        if std::path::Path::new(path).exists() {
+            return Self::load(path);
+        }
+        let cfg = Self::default();
+        // ensure parent dir exists
+        if let Some(dir) = std::path::Path::new(path).parent() {
+            let _ = std::fs::create_dir_all(dir);
+        }
+        cfg.save(path)?;
+        eprintln!("created default config at {path} — open /admin to finish setup");
+        Ok(cfg)
+    }
+
     /// Integrity validation: non-empty model pool, valid routing targets.
     pub fn validate(&self) -> anyhow::Result<()> {
         // A managed local CMF model counts as an available model even though it
@@ -755,6 +1000,7 @@ impl Config {
         }
         for (tier, targets) in &self.routing.tiers {
             let list = match targets {
+                TierTargets::Map(_) => targets.models(),
                 TierTargets::List(v) => v.clone(),
                 TierTargets::One(s) => vec![s.clone()],
             };
@@ -768,6 +1014,33 @@ impl Config {
                 }
             }
         }
+        if let Some(b) = &self.routing.bands {
+            if !(b.low > 0.0 && b.low < b.medium && b.medium < 1.0) {
+                anyhow::bail!(
+                    "config: routing.bands must satisfy 0 < low < medium < 1 (got {} / {})",
+                    b.low,
+                    b.medium
+                );
+            }
+        }
+        for (task, targets) in &self.routing.tasks {
+            for id in &targets.models() {
+                if !ids.contains(id.as_str()) {
+                    anyhow::bail!(
+                        "config: routing.tasks.{} references unknown model id '{}'",
+                        task,
+                        id
+                    );
+                }
+            }
+            if let Some(bad) = targets.invalid_task_keys().first() {
+                anyhow::bail!(
+                    "config: routing.tasks.{}.{} is not a tier (use any/low/medium/high)",
+                    task,
+                    bad
+                );
+            }
+        }
         Ok(())
     }
 
@@ -858,6 +1131,7 @@ min_class = { low = "cheap", medium = "mid" }
 
         let low = back.routing.tiers.get("low").expect("low tier present");
         match low {
+            TierTargets::Map(_) => assert_eq!(low.models(), vec!["local-qwen".to_string()]),
             TierTargets::List(v) => assert_eq!(v, &vec!["local-qwen".to_string()]),
             TierTargets::One(s) => assert_eq!(s, "local-qwen"),
         }

src/import.rs

@@ -30,6 +30,47 @@ fn cleanup_output(path: &str) {
     }
 }
 
+/// Bytes an output occupies: a file's length, or the recursive sum for a sharded
+/// `.cmf` directory. 0 when nothing has been written yet.
+pub fn path_size(p: &std::path::Path) -> u64 {
+    match std::fs::metadata(p) {
+        Ok(m) if m.is_file() => m.len(),
+        Ok(m) if m.is_dir() => std::fs::read_dir(p)
+            .map(|rd| {
+                rd.filter_map(|e| e.ok())
+                    .map(|e| path_size(&e.path()))
+                    .sum()
+            })
+            .unwrap_or(0),
+        _ => 0,
+    }
+}
+
+/// Aborts the wrapped task when it goes out of scope — used for the progress
+/// poller so every early return in a download path stops it.
+struct AbortOnDrop(tokio::task::JoinHandle<()>);
+impl Drop for AbortOnDrop {
+    fn drop(&mut self) {
+        self.0.abort();
+    }
+}
+
+/// Drive progress from bytes on disk. curl's own meter is unreliable here (its
+/// bar is redrawn with `\r` into a pipe, and a sharded download runs one curl
+/// per part), but the output size never lies.
+fn spawn_size_poller(store: Arc<JobStore>, id: String, path: String) -> AbortOnDrop {
+    AbortOnDrop(tokio::spawn(async move {
+        let p = std::path::PathBuf::from(&path);
+        loop {
+            tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+            let done = path_size(&p);
+            if done > 0 {
+                store.set_bytes(&id, done);
+            }
+        }
+    }))
+}
+
 fn now() -> u64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -37,16 +78,12 @@ fn now() -> u64 {
         .as_secs()
 }
 
-/// Job id from a hash of (repo, nanos) — unique without a uuid dependency.
-fn gen_id(repo: &str) -> String {
+/// Job id from repo (deterministic) — same repo+variant reuses same id, so
+/// the job list doesn't fill with duplicates and "already downloaded" can be detected.
+pub fn gen_id(repo: &str) -> String {
     use std::hash::{Hash, Hasher};
-    let nanos = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_nanos();
     let mut h = std::collections::hash_map::DefaultHasher::new();
     repo.hash(&mut h);
-    nanos.hash(&mut h);
     format!("{:016x}", h.finish())
 }
 
@@ -58,6 +95,10 @@ pub struct ImportParams {
     pub quant: String,
     #[serde(default)]
     pub name: String, // output basename; empty → derived from repo
+    /// For sharded CMF repos (e.g. DeepSeek with `parts-q2tp-v2`/`parts-q4tp`), which
+    /// variant directory to download. Empty = auto (first .cmf or first variant).
+    #[serde(default)]
+    pub variant: Option<String>,
     // ── advanced ──
     #[serde(default)]
     pub linear_core: Option<String>, // gated_delta_net | vmf_phase
@@ -91,12 +132,17 @@ fn default_quant() -> String {
 }
 
 /// Live state of one conversion job.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Job {
     pub id: String,
     pub repo: String,
     pub quant: String,
     pub output: String,
+    /// Output basename without `.cmf` — the id the UI uses to match a job to the
+    /// featured card that started it, and to the file on disk.
+    pub name: String,
+    /// Sharded-variant directory / `.cmf` filename this job downloads, if any.
+    pub variant: Option<String>,
     pub state: String, // running | done | error | cancelled
     pub log: Vec<String>,
     pub started: u64,
@@ -104,6 +150,10 @@ pub struct Job {
     pub size_bytes: Option<u64>,
     pub progress: Option<f32>, // 0..1, parsed from converter @PROGRESS
     pub phase: Option<String>, // current phase label
+    /// Expected download size (from the HF tree) and bytes already on disk —
+    /// what makes the percentage in the UI real rather than a guess.
+    pub total_bytes: Option<u64>,
+    pub done_bytes: Option<u64>,
 }
 
 #[derive(Default)]
@@ -112,14 +162,60 @@ pub struct JobStore {
     /// Cancel handles, keyed by job id (not serialized). Notifying aborts the
     /// converter process and cleans up its partial output.
     cancels: Mutex<HashMap<String, Arc<Notify>>>,
+    /// When set, every state change lands in this JSON file, so the job list —
+    /// and its Register buttons — survives a gateway restart.
+    persist: Mutex<Option<std::path::PathBuf>>,
+    last_save: Mutex<Option<std::time::Instant>>,
 }
 
 impl JobStore {
     pub fn new() -> Arc<Self> {
         Arc::new(Self::default())
     }
+    /// Load previously saved jobs and start persisting to `path`. A job that
+    /// was `running` when the gateway died is settled as an error — its process
+    /// is gone; the file it produced (if complete) is still on disk.
+    pub fn attach_persistence(&self, path: std::path::PathBuf) {
+        if let Ok(text) = std::fs::read_to_string(&path) {
+            if let Ok(mut jobs) = serde_json::from_str::<Vec<Job>>(&text) {
+                let mut g = self.jobs.lock().unwrap();
+                for j in jobs.drain(..) {
+                    let mut j = j;
+                    if j.state == "running" {
+                        j.state = "error".into();
+                        j.log.push("✗ interrupted by a gateway restart".into());
+                        j.finished = Some(now());
+                    }
+                    g.insert(j.id.clone(), j);
+                }
+            }
+        }
+        *self.persist.lock().unwrap() = Some(path);
+    }
+    fn save(&self, force: bool) {
+        let Some(path) = self.persist.lock().unwrap().clone() else {
+            return;
+        };
+        if !force {
+            let mut last = self.last_save.lock().unwrap();
+            if let Some(t) = *last {
+                if t.elapsed() < std::time::Duration::from_secs(2) {
+                    return;
+                }
+            }
+            *last = Some(std::time::Instant::now());
+        }
+        let jobs: Vec<Job> = self.jobs.lock().unwrap().values().cloned().collect();
+        if let Ok(json) = serde_json::to_vec(&jobs) {
+            let tmp = path.with_extension("json.tmp");
+            if std::fs::write(&tmp, json).is_ok() {
+                let _ = std::fs::rename(&tmp, &path);
+            }
+        }
+    }
     fn insert(&self, job: Job) {
         self.jobs.lock().unwrap().insert(job.id.clone(), job);
+        self.save(true);
     }
     fn set_cancel(&self, id: &str, n: Arc<Notify>) {
         self.cancels.lock().unwrap().insert(id.to_string(), n);
@@ -154,11 +250,52 @@ impl JobStore {
     }
     fn set_progress(&self, id: &str, frac: f32, phase: String) {
         if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
-            j.progress = Some(frac);
+            let f = frac.clamp(0.0, 1.0);
+            let cur = j.progress.unwrap_or(0.0);
+            // monotonic only — never go backwards (curl reprints, re-download),
+            // but an unset bar takes whatever the first reading is
+            if j.progress.is_none() || f > cur + 0.001 {
+                j.progress = Some(f);
+            }
             if !phase.is_empty() {
                 j.phase = Some(phase);
             }
         }
+        self.save(false);
+    }
+    /// Expected total download size, once the HF tree is known.
+    fn set_total(&self, id: &str, total: u64) {
+        if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
+            if total > 0 {
+                j.total_bytes = Some(total);
+            }
+        }
+    }
+    /// Report bytes on disk; derives the percentage whenever the total is known.
+    fn set_bytes(&self, id: &str, done: u64) {
+        let total = {
+            let mut g = self.jobs.lock().unwrap();
+            let Some(j) = g.get_mut(id) else { return };
+            if j.state != "running" {
+                return;
+            }
+            if done > j.done_bytes.unwrap_or(0) {
+                j.done_bytes = Some(done);
+            }
+            j.total_bytes
+        };
+        if let Some(t) = total.filter(|t| *t > 0) {
+            self.set_progress(id, done as f32 / t as f32, "downloading".into());
+        }
+    }
+    fn set_phase(&self, id: &str, phase: String) {
+        if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
+            j.phase = Some(phase);
+            // keep progress as is; if it was 0.0, make it indeterminate (None) so bar animates
+            if j.progress == Some(0.0) {
+                j.progress = None;
+            }
+        }
     }
     fn update_quant(&self, id: &str, quant: String) {
         if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
@@ -173,6 +310,7 @@ impl JobStore {
             j.state = state.into();
             j.finished = Some(now());
         }
+        self.save(true);
     }
     fn finish(&self, id: &str, ok: bool) {
         if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
@@ -180,13 +318,17 @@ impl JobStore {
                 return; // a concurrent cancel already settled this job
             }
             j.finished = Some(now());
-            j.size_bytes = std::fs::metadata(&j.output).ok().map(|m| m.len());
-            let done = ok && j.size_bytes.unwrap_or(0) > 0;
+            let on_disk = path_size(std::path::Path::new(&j.output));
+            j.size_bytes = if on_disk > 0 { Some(on_disk) } else { None };
+            let done = ok && on_disk > 0;
             j.state = if done { "done" } else { "error" }.into();
             if done {
                 j.progress = Some(1.0);
+                j.done_bytes = Some(on_disk);
+                j.total_bytes = Some(j.total_bytes.unwrap_or(on_disk).max(on_disk));
             }
         }
+        self.save(true);
     }
     pub fn get(&self, id: &str) -> Option<Job> {
         self.jobs.lock().unwrap().get(id).cloned()
@@ -202,10 +344,23 @@ impl JobStore {
         cleanup_output(&job.output);
         self.cancels.lock().unwrap().remove(id);
         self.jobs.lock().unwrap().remove(id);
+        self.save(true);
         Ok(true)
     }
     pub fn list(&self) -> Vec<Job> {
-        let mut v: Vec<Job> = self.jobs.lock().unwrap().values().cloned().collect();
+        let mut map: HashMap<String, Job> = HashMap::new();
+        for j in self.jobs.lock().unwrap().values().cloned() {
+            // dedupe by repo+variant — keep the latest (so re-download doesn't create
+            // duplicate rows) while two variants of one repo stay separate rows
+            let key = format!("{}::{}", j.repo, j.variant.clone().unwrap_or_default());
+            match map.get(&key) {
+                Some(prev) if prev.started >= j.started => {}
+                _ => {
+                    map.insert(key, j);
+                }
+            }
+        }
+        let mut v: Vec<Job> = map.into_values().collect();
         v.sort_by_key(|x| std::cmp::Reverse(x.started));
         v.truncate(20);
         v
@@ -242,6 +397,153 @@ pub async fn hf_search(
     resp.json().await.map_err(|e| e.to_string())
 }
 
+pub async fn hf_search_author(
+    author: &str,
+    limit: usize,
+    token: Option<&str>,
+) -> Result<serde_json::Value, String> {
+    let url = format!(
+        "https://huggingface.co/api/models?author={}&limit={}&sort=trendingScore&direction=-1",
+        url_escape(author),
+        limit
+    );
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .map_err(|e| e.to_string())?;
+    let mut req = client.get(&url).header("User-Agent", "cortiq-gateway");
+    if let Some(t) = token {
+        req = req.bearer_auth(t);
+    }
+    let resp = req.send().await.map_err(|e| e.to_string())?;
+    if !resp.status().is_success() {
+        return Err(format!("HuggingFace API {}", resp.status()));
+    }
+    resp.json().await.map_err(|e| e.to_string())
+}
+
+pub async fn hf_model_size(id: &str, token: Option<&str>) -> Option<u64> {
+    let url = format!("https://huggingface.co/api/models/{}", url_escape(id));
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(8))
+        .build()
+        .ok()?;
+    let mut req = client.get(&url).header("User-Agent", "cortiq-gateway");
+    if let Some(t) = token {
+        req = req.bearer_auth(t);
+    }
+    let resp = req.send().await.ok()?;
+    if !resp.status().is_success() {
+        return None;
+    }
+    let v: serde_json::Value = resp.json().await.ok()?;
+    v.get("usedStorage").and_then(|x| x.as_u64())
+}
+
+/// Per-variant sizes for a repo (for CMF repos with sharded directories like
+/// `parts-q2tp-v2`, `parts-q4tp`). Returns `[(variant_name, bytes)]`. For a
+/// single-file repo returns one entry. Empty = tree unreachable.
+pub async fn hf_repo_variants(id: &str, token: Option<&str>) -> Vec<(String, u64)> {
+    let url = format!(
+        "https://huggingface.co/api/models/{}/tree/main?recursive=true",
+        url_escape(id)
+    );
+    let client = match reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+    {
+        Ok(c) => c,
+        Err(_) => return Vec::new(),
+    };
+    let mut req = client.get(&url).header("User-Agent", "cortiq-gateway");
+    if let Some(t) = token {
+        req = req.bearer_auth(t);
+    }
+    let resp = match req.send().await {
+        Ok(r) if r.status().is_success() => r,
+        _ => return Vec::new(),
+    };
+    let arr: serde_json::Value = match resp.json().await {
+        Ok(v) => v,
+        Err(_) => return Vec::new(),
+    };
+    let list = match arr.as_array() {
+        Some(a) => a,
+        None => return Vec::new(),
+    };
+    use std::collections::HashMap;
+    let mut dir_sizes: HashMap<String, u64> = HashMap::new();
+    let mut single_cmf: Vec<(String, u64)> = Vec::new();
+    for item in list {
+        if item.get("type").and_then(|t| t.as_str()) != Some("file") {
+            continue;
+        }
+        let path = match item.get("path").and_then(|p| p.as_str()) {
+            Some(p) => p,
+            None => continue,
+        };
+        let sz = item
+            .get("size")
+            .and_then(|v| v.as_u64())
+            .or_else(|| {
+                item.get("lfs")
+                    .and_then(|l| l.get("size"))
+                    .and_then(|v| v.as_u64())
+            })
+            .unwrap_or(0);
+        if sz == 0 {
+            continue;
+        }
+        if path.to_ascii_lowercase().ends_with(".cmf") {
+            single_cmf.push((path.to_string(), sz));
+        } else if path.contains('/') && path.starts_with("parts-") {
+            let top = path.split('/').next().unwrap_or(path).to_string();
+            *dir_sizes.entry(top).or_default() += sz;
+        }
+    }
+    if !single_cmf.is_empty() {
+        return single_cmf;
+    }
+    let mut out: Vec<(String, u64)> = dir_sizes.into_iter().collect();
+    out.sort_by(|a, b| a.0.cmp(&b.0));
+    out
+}
+
+/// `Content-Length` of a download URL (redirects followed) — the fallback total
+/// when the repo tree didn't tell us how big the file is.
+async fn head_content_length(url: &str, token: Option<&str>) -> Option<u64> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .ok()?;
+    let mut req = client.head(url).header("User-Agent", "cortiq-gateway");
+    if let Some(t) = token {
+        req = req.bearer_auth(t);
+    }
+    let resp = req.send().await.ok()?;
+    if !resp.status().is_success() {
+        return None;
+    }
+    resp.headers()
+        .get(reqwest::header::CONTENT_LENGTH)?
+        .to_str()
+        .ok()?
+        .parse()
+        .ok()
+}
+
+pub fn format_bytes(n: u64) -> String {
+    if n >= 1_000_000_000 {
+        format!("{:.1} GB", n as f64 / 1_000_000_000.0)
+    } else if n >= 1_000_000 {
+        format!("{} MB", n / 1_000_000)
+    } else if n >= 1_000 {
+        format!("{} KB", n / 1_000)
+    } else {
+        format!("{n} B")
+    }
+}
+
 fn url_escape(s: &str) -> String {
     s.chars()
         .map(|c| match c {
@@ -263,6 +565,9 @@ fn sanitize(s: &str) -> String {
         })
         .collect()
 }
+pub fn sanitize_for_id(s: &str) -> String {
+    sanitize(&s.to_lowercase())
+}
 
 /// Kick off a conversion. Returns the job id immediately; progress streams
 /// Map the UI quant label to the native `cortiq` quant flag.
@@ -293,26 +598,52 @@ async fn download_cmf_repo(
     store: Arc<JobStore>,
     id: String,
     cancel: Arc<Notify>,
+    variant: Option<String>,
 ) {
-    store.set_progress(&id, 0.0, "listing files".into());
+    // don't show 0% "listing files" — it looks stuck; show indeterminate "preparing"
+    store.set_phase(&id, "preparing".into());
 
     let tree_url = format!("https://huggingface.co/api/models/{repo}/tree/main?recursive=true");
-    let client = reqwest::Client::new();
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .unwrap_or_else(|_| reqwest::Client::new());
     let mut req = client.get(&tree_url).header("User-Agent", "cortiq-gateway");
     if let Some(t) = &hf_token {
         req = req.bearer_auth(t);
     }
 
-    let mut cmf_rel_path = None;
+    let mut cmf_files: Vec<(String, u64)> = Vec::new();
+    let mut sharded_dirs: std::collections::HashMap<String, Vec<String>> =
+        std::collections::HashMap::new();
+    let mut dir_sizes: std::collections::HashMap<String, u64> = std::collections::HashMap::new();
     if let Ok(resp) = req.send().await {
         if resp.status().is_success() {
             if let Ok(json) = resp.json::<serde_json::Value>().await {
                 if let Some(arr) = json.as_array() {
                     for item in arr {
+                        if item.get("type").and_then(|t| t.as_str()) != Some("file") {
+                            continue;
+                        }
                         if let Some(path) = item.get("path").and_then(|p| p.as_str()) {
+                            let sz = item
+                                .get("size")
+                                .and_then(|v| v.as_u64())
+                                .or_else(|| {
+                                    item.get("lfs")
+                                        .and_then(|l| l.get("size"))
+                                        .and_then(|v| v.as_u64())
+                                })
+                                .unwrap_or(0);
                             if path.to_ascii_lowercase().ends_with(".cmf") {
-                                cmf_rel_path = Some(path.to_string());
-                                break;
+                                cmf_files.push((path.to_string(), sz));
+                            } else if path.contains('/') && path.starts_with("parts-") {
+                                let top = path.split('/').next().unwrap_or(path).to_string();
+                                sharded_dirs
+                                    .entry(top.clone())
+                                    .or_default()
+                                    .push(path.to_string());
+                                *dir_sizes.entry(top).or_default() += sz;
                             }
                         }
                     }
@@ -321,12 +652,174 @@ async fn download_cmf_repo(
         }
     }
 
-    let cmf_path = match cmf_rel_path {
-        Some(p) => p,
-        None => {
-            let repo_name = repo.rsplit('/').next().unwrap_or(&repo);
-            format!("{repo_name}.cmf")
+    // Decide what to download: single .cmf file vs sharded variant directory
+    let is_sharded = !sharded_dirs.is_empty();
+    let chosen_variant = variant
+        .as_deref()
+        .map(|v| v.trim())
+        .filter(|v| !v.is_empty());
+
+    if is_sharded {
+        // pick variant: explicit > first alphabetically
+        let target_dir = if let Some(v) = chosen_variant {
+            if sharded_dirs.contains_key(v) {
+                v.to_string()
+            } else {
+                sharded_dirs.keys().next().cloned().unwrap_or_default()
+            }
+        } else {
+            // prefer smallest? use first sorted
+            let mut keys: Vec<String> = sharded_dirs.keys().cloned().collect();
+            keys.sort();
+            keys.into_iter().next().unwrap_or_default()
+        };
+        let files = sharded_dirs.get(&target_dir).cloned().unwrap_or_default();
+        if files.is_empty() {
+            store.push_line(&id, format!("✗ variant '{target_dir}' not found"));
+            store.finish(&id, false);
+            store.drop_cancel(&id);
+            return;
         }
+        let total_sz = dir_sizes.get(&target_dir).copied().unwrap_or(0);
+        let q = if target_dir.contains("q2tp") {
+            "Q2TP"
+        } else if target_dir.contains("q4tp") {
+            "Q4TP"
+        } else {
+            "READY_CMF"
+        };
+        store.update_quant(&id, q.to_string());
+        store.push_line(
+            &id,
+            format!(
+                "→ downloading {} ({} files, {}) from HuggingFace...",
+                target_dir,
+                files.len(),
+                format_bytes(total_sz)
+            ),
+        );
+        store.set_total(&id, total_sz);
+        store.set_progress(&id, 0.001, "downloading".into());
+
+        // output is a directory: ensure {base}.cmf is a directory
+        let out_dir = std::path::Path::new(&output_abs);
+        // Drop a previous copy first (re-download / update). There is no resume,
+        // so it would be overwritten anyway — and leaving it there would make the
+        // size poller read the old bytes and report 100% before we transfer any.
+        cleanup_output(&output_abs);
+        // if output ends with .cmf and variant is sharded, keep it as dir (e.g. model.cmf/parts-*)
+        // create base dir
+        let _ = std::fs::create_dir_all(out_dir);
+        // live percentage from bytes landing on disk (curl runs quiet, per part)
+        let _poller = spawn_size_poller(store.clone(), id.clone(), output_abs.clone());
+        // download each part file
+        for (idx, rel) in files.iter().enumerate() {
+            let filename = rel.rsplit('/').next().unwrap_or(rel);
+            let dest = out_dir.join(filename);
+            let url = format!("https://huggingface.co/{repo}/resolve/main/{rel}");
+            store.push_line(&id, format!("  [{}/{}] {filename}", idx + 1, files.len()));
+            let mut cmd = tokio::process::Command::new("curl");
+            cmd.arg("-f")
+                .arg("-L")
+                .arg("-s")
+                .arg("-S")
+                .arg("-o")
+                .arg(&dest)
+                .arg(&url);
+            if let Some(t) = &hf_token {
+                cmd.arg("-H").arg(format!("Authorization: Bearer {t}"));
+            }
+            cmd.stdout(Stdio::null());
+            cmd.stderr(Stdio::piped());
+            let mut child = match cmd.spawn() {
+                Ok(c) => c,
+                Err(e) => {
+                    store.push_line(&id, format!("✗ failed {filename}: {e}"));
+                    cleanup_output(&output_abs);
+                    store.finish(&id, false);
+                    store.drop_cancel(&id);
+                    return;
+                }
+            };
+            let t_err = child.stderr.take().map(|s| {
+                let st = store.clone();
+                let jid = id.clone();
+                tokio::spawn(async move {
+                    let mut lines = BufReader::new(s).lines();
+                    while let Ok(Some(l)) = lines.next_line().await {
+                        let l = l.trim().to_string();
+                        if !l.is_empty() {
+                            st.push_line(&jid, l);
+                        }
+                    }
+                })
+            });
+            // Race the part against a cancel — a single part can be many GB, so
+            // waiting for it to finish first would make Cancel look dead.
+            let status = tokio::select! {
+                r = child.wait() => {
+                    if let Some(t) = t_err { t.abort(); }
+                    r.map_err(|e| e.to_string())
+                }
+                _ = cancel.notified() => {
+                    let _ = child.start_kill();
+                    let _ = child.wait().await;
+                    if let Some(t) = t_err { t.abort(); }
+                    cleanup_output(&output_abs);
+                    store.push_line(&id, "✗ cancelled by user — partial output removed".into());
+                    store.set_state(&id, "cancelled");
+                    store.drop_cancel(&id);
+                    return;
+                }
+            };
+            match status {
+                Ok(s) if s.success() => {
+                    // exact byte count after each part (the poller covers the gaps)
+                    let on_disk = path_size(out_dir);
+                    if total_sz > 0 {
+                        store.set_bytes(&id, on_disk);
+                    } else {
+                        let frac = (idx + 1) as f32 / files.len() as f32;
+                        store.set_progress(&id, frac, "downloading".into());
+                    }
+                }
+                Ok(s) => {
+                    store.push_line(&id, format!("✗ failed {filename}: exit {:?}", s.code()));
+                    cleanup_output(&output_abs);
+                    store.finish(&id, false);
+                    store.drop_cancel(&id);
+                    return;
+                }
+                Err(e) => {
+                    store.push_line(&id, format!("✗ failed {filename}: {e}"));
+                    cleanup_output(&output_abs);
+                    store.finish(&id, false);
+                    store.drop_cancel(&id);
+                    return;
+                }
+            }
+        }
+        store.push_line(&id, "✓ done".into());
+        store.finish(&id, true);
+        store.drop_cancel(&id);
+        return;
+    }
+
+    // single-file path (original logic)
+    let (cmf_path, cmf_size) = if !cmf_files.is_empty() {
+        // if variant specified and matches a file prefix, prefer it
+        if let Some(v) = chosen_variant {
+            cmf_files
+                .iter()
+                .find(|(p, _)| p.contains(v))
+                .cloned()
+                .unwrap_or_else(|| cmf_files[0].clone())
+        } else {
+            cmf_files[0].clone()
+        }
+    } else {
+        let repo_name = repo.rsplit('/').next().unwrap_or(&repo);
+        (format!("{repo_name}.cmf"), 0)
     };
 
     let path_lower = cmf_path.to_ascii_lowercase();
@@ -344,13 +837,42 @@ async fn download_cmf_repo(
         };
     store.update_quant(&id, detected_quant);
 
-    store.push_line(&id, format!("→ downloading {cmf_path} from HuggingFace..."));
-    store.set_progress(&id, 0.05, "downloading".into());
-
     let download_url = format!("https://huggingface.co/{repo}/resolve/main/{cmf_path}");
+    // The tree listing is the usual source of the size; ask the CDN directly when
+    // it wasn't (private repo, tree fetch failed) so the bar still gets a total.
+    let total = if cmf_size > 0 {
+        cmf_size
+    } else {
+        head_content_length(&download_url, hf_token.as_deref())
+            .await
+            .unwrap_or(0)
+    };
+    store.push_line(&id, {
+        let sz = if total > 0 {
+            format!(" ({})", format_bytes(total))
+        } else {
+            String::new()
+        };
+        format!("→ downloading {cmf_path}{sz} from HuggingFace...")
+    });
+    store.set_total(&id, total);
+    store.set_progress(&id, 0.001, "downloading".into());
+    // Drop a previous copy first (re-download / update). There is no resume, so
+    // it would be overwritten anyway — and leaving it there would make the size
+    // poller read the old bytes and report 100% before we transfer any.
+    cleanup_output(&output_abs);
+    // Progress comes from bytes on disk only. curl's own meter is worse than
+    // useless here: with -L it prints a complete 0→100% bar for the redirect hop
+    // before the real transfer starts, which used to pin the job at 100%.
+    let _poller = spawn_size_poller(store.clone(), id.clone(), output_abs.clone());
 
     let mut cmd = tokio::process::Command::new("curl");
-    cmd.arg("-f").arg("-L").arg("-#").arg("-o").arg(&output_abs);
+    cmd.arg("-f")
+        .arg("-L")
+        .arg("-s")
+        .arg("-S")
+        .arg("-o")
+        .arg(&output_abs);
 
     if let Some(t) = &hf_token {
         cmd.arg("-H").arg(format!("Authorization: Bearer {t}"));
@@ -370,27 +892,19 @@ async fn download_cmf_repo(
         }
     };
 
+    // -sS leaves stderr for real errors only — drain it into the log so a failure
+    // says what went wrong instead of just an exit code.
     let stderr = child.stderr.take();
     let mut t_err = None;
     if let Some(err_stream) = stderr {
         let store_clone = store.clone();
         let id_clone = id.clone();
         t_err = Some(tokio::spawn(async move {
-            use tokio::io::AsyncReadExt;
-            let mut reader = err_stream;
-            let mut buf = [0u8; 256];
-            while let Ok(n) = reader.read(&mut buf).await {
-                if n == 0 {
-                    break;
-                }
-                let text = String::from_utf8_lossy(&buf[..n]);
-                for word in text.split_whitespace() {
-                    if let Some(num_str) = word.strip_suffix('%') {
-                        if let Ok(pct) = num_str.parse::<f32>() {
-                            let frac = (pct / 100.0).clamp(0.0, 1.0);
-                            store_clone.set_progress(&id_clone, frac, "downloading".into());
-                        }
-                    }
+            let mut lines = BufReader::new(err_stream).lines();
+            while let Ok(Some(l)) = lines.next_line().await {
+                let l = l.trim().to_string();
+                if !l.is_empty() {
+                    store_clone.push_line(&id_clone, l);
                 }
             }
         }));
@@ -406,7 +920,13 @@ async fn download_cmf_repo(
                 }
                 Ok(status) => {
                     cleanup_output(&output_abs);
-                    store.push_line(&id, format!("✗ download failed: exit code {:?}", status.code()));
+                    // curl 23 = write error: almost always a non-writable models dir
+                    let hint = match status.code() {
+                        Some(23) => " (write error — is the models dir writable?)",
+                        Some(22) => " (HTTP error — repo/file not found or auth required)",
+                        _ => "",
+                    };
+                    store.push_line(&id, format!("✗ download failed: exit code {:?}{hint}", status.code()));
                     store.finish(&id, false);
                 }
                 Err(e) => {
@@ -471,12 +991,32 @@ pub fn start_import(store: Arc<JobStore>, cfg: &CmfCfg, p: ImportParams) -> Resu
             }
         }
     }
-    let _ = std::fs::create_dir_all(&cfg.models_dir);
-    let base = if p.name.trim().is_empty() {
+    std::fs::create_dir_all(&cfg.models_dir).map_err(|e| {
+        format!(
+            "cannot create models dir {}: {e} — check that the gateway has write \
+             access (in Docker, mount a writable volume at the models path)",
+            cfg.models_dir
+        )
+    })?;
+    let mut base = if p.name.trim().is_empty() {
         sanitize(p.repo.rsplit('/').next().unwrap_or(&p.repo))
     } else {
         sanitize(&p.name)
     };
+    // for sharded variants make output distinct (e.g. DeepSeek parts-q2tp vs q4tp); single-file CMF ignores variant
+    if let Some(v) = p
+        .variant
+        .as_deref()
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+    {
+        if v.starts_with("parts-") {
+            let vs = sanitize(v);
+            if !base.ends_with(&vs) {
+                base = format!("{base}-{vs}");
+            }
+        }
+    }
     let output = std::path::Path::new(&cfg.models_dir)
         .join(format!("{base}.cmf"))
         .to_string_lossy()
@@ -485,7 +1025,17 @@ pub fn start_import(store: Arc<JobStore>, cfg: &CmfCfg, p: ImportParams) -> Resu
         .map(|d| d.join(format!("{base}.cmf")).to_string_lossy().to_string())
         .unwrap_or_else(|_| output.clone());
 
-    let id = gen_id(&p.repo);
+    let id = gen_id(&format!(
+        "{}::{}",
+        p.repo,
+        p.variant.as_deref().unwrap_or("")
+    ));
+    // if same repo/variant is already running, don't reset progress — just return it
+    if let Some(existing) = store.get(&id) {
+        if existing.state == "running" {
+            return Ok(id);
+        }
+    }
     let is_cmf = is_cmf_repo(&p.repo);
     let quant_display = if is_cmf {
         let r = p.repo.to_lowercase();
@@ -512,6 +1062,13 @@ pub fn start_import(store: Arc<JobStore>, cfg: &CmfCfg, p: ImportParams) -> Resu
         repo: p.repo.clone(),
         quant: quant_display.clone(),
         output: output_abs.clone(),
+        name: base.clone(),
+        variant: p
+            .variant
+            .as_deref()
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .map(str::to_string),
         state: "running".into(),
         log: if is_cmf {
             vec![format!(
@@ -526,6 +1083,8 @@ pub fn start_import(store: Arc<JobStore>, cfg: &CmfCfg, p: ImportParams) -> Resu
         size_bytes: None,
         progress: Some(0.0),
         phase: Some("starting".into()),
+        total_bytes: None,
+        done_bytes: None,
     });
     let cancel = Arc::new(Notify::new());
     store.set_cancel(&id, cancel.clone());
@@ -538,8 +1097,9 @@ pub fn start_import(store: Arc<JobStore>, cfg: &CmfCfg, p: ImportParams) -> Resu
 
     if is_cmf && !use_python {
         let ret_id = id.clone();
+        let variant = p.variant.clone();
         tokio::spawn(async move {
-            download_cmf_repo(p.repo, output_abs, hf_token, store, id, cancel).await;
+            download_cmf_repo(p.repo, output_abs, hf_token, store, id, cancel, variant).await;
         });
         return Ok(ret_id);
     }

src/logbuf.rs

@@ -0,0 +1,78 @@
+//! In-memory ring of recent log lines, so the admin console can show logs to
+//! users who never see the terminal (Docker, autostart, double-clicked exe).
+//! Fed by a second `tracing` layer writing plain text (no ANSI) into the ring
+//! while the normal stdout layer stays colored.
+
+use std::collections::VecDeque;
+use std::io;
+use std::sync::{Arc, Mutex, OnceLock};
+
+const CAP: usize = 500;
+
+fn ring() -> &'static Arc<Mutex<VecDeque<String>>> {
+    static RING: OnceLock<Arc<Mutex<VecDeque<String>>>> = OnceLock::new();
+    RING.get_or_init(|| Arc::new(Mutex::new(VecDeque::with_capacity(CAP))))
+}
+
+/// Last `limit` lines, oldest first.
+pub fn snapshot(limit: usize) -> Vec<String> {
+    let g = ring().lock().unwrap();
+    g.iter()
+        .skip(g.len().saturating_sub(limit))
+        .cloned()
+        .collect()
+}
+
+/// Drop everything in the ring (the admin console's "clear" button).
+pub fn clear() {
+    ring().lock().unwrap().clear();
+}
+
+pub fn push_line(line: &str) {
+    let line = line.trim_end();
+    if line.is_empty() {
+        return;
+    }
+    let mut g = ring().lock().unwrap();
+    if g.len() >= CAP {
+        g.pop_front();
+    }
+    g.push_back(line.to_string());
+}
+
+/// `MakeWriter` for the ring layer: buffers partial writes until a newline.
+#[derive(Clone, Default)]
+pub struct RingMakeWriter;
+
+pub struct RingWriter {
+    buf: String,
+}
+
+impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for RingMakeWriter {
+    type Writer = RingWriter;
+    fn make_writer(&'a self) -> Self::Writer {
+        RingWriter { buf: String::new() }
+    }
+}
+
+impl io::Write for RingWriter {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        self.buf.push_str(&String::from_utf8_lossy(data));
+        while let Some(idx) = self.buf.find('\n') {
+            let line: String = self.buf.drain(..=idx).collect();
+            push_line(&line);
+        }
+        Ok(data.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Drop for RingWriter {
+    fn drop(&mut self) {
+        if !self.buf.is_empty() {
+            push_line(&self.buf.clone());
+        }
+    }
+}

src/main.rs

@@ -9,11 +9,14 @@
 #![allow(dead_code)]
 
 mod admin;
+mod bench;
 mod cache;
 mod cmf_runtime;
 mod config;
 mod error;
 mod import;
+mod logbuf;
+mod media;
 mod model;
 mod pipeline;
 mod promotion;
@@ -25,6 +28,7 @@ mod routing;
 mod secrets;
 mod state;
 mod stats;
+mod sysmon;
 
 use axum::{routing::get, Router};
 use clap::Parser;
@@ -38,54 +42,206 @@ use state::SharedState;
     about = "Universal LLM gateway with intelligent routing"
 )]
 struct Args {
-    /// Path to the TOML config file.
-    #[arg(long, default_value = "config/gateway.toml")]
-    config: String,
+    /// Path to the TOML config file. If omitted, uses `config/gateway.toml` when running
+    /// inside the repo, otherwise `~/.cortiq-gateway/gateway.toml` (or `$CORTIQ_GATEWAY_HOME`).
+    /// Missing file is created automatically — no manual copying needed.
+    #[arg(long)]
+    config: Option<String>,
     /// Admin token for the web panel (overrides `[admin].token_env`).
     #[arg(long)]
     admin_token: Option<String>,
+    /// Do not automatically open the browser on first run.
+    #[arg(long)]
+    no_browser: bool,
+    /// Do not auto-select a free port if the configured one is busy.
+    #[arg(long)]
+    no_port_search: bool,
 }
 
 /// Resolve the admin token: env from `[admin].token_env` → `--admin-token` →
-/// generate a random one. Returns `(token, generated)`.
-fn resolve_admin_token(cfg: &Config, args: &Args) -> (String, bool) {
+///
+/// By default no token is required (open mode). User sets it explicitly via
+/// `--admin-token`, `[admin].token` or `[admin].token_env` if they want auth.
+fn resolve_admin_token(cfg: &Config, args: &Args) -> String {
     if let Some(env) = &cfg.admin.token_env {
         if let Ok(v) = std::env::var(env) {
             if !v.is_empty() {
-                return (v, false);
+                return v;
             }
         }
     }
     if let Some(t) = &args.admin_token {
         if !t.is_empty() {
-            return (t.clone(), false);
+            return t.clone();
         }
     }
     if let Some(t) = &cfg.admin.token {
         if !t.is_empty() {
-            return (t.clone(), false);
+            return t.clone();
         }
     }
-    (admin::random_token(24), true)
+    String::new()
+}
+
+fn is_docker() -> bool {
+    std::path::Path::new("/.dockerenv").exists()
+        || std::fs::read_to_string("/proc/1/cgroup")
+            .map(|s| s.contains("docker") || s.contains("kubepods"))
+            .unwrap_or(false)
+}
+
+fn should_open_browser(args: &Args) -> bool {
+    if args.no_browser {
+        return false;
+    }
+    if std::env::var("CORTIQ_NO_BROWSER")
+        .map(|v| !v.is_empty() && v != "0")
+        .unwrap_or(false)
+    {
+        return false;
+    }
+    if std::env::var("CI").is_ok() || std::env::var("NO_BROWSER").is_ok() {
+        return false;
+    }
+    if is_docker() {
+        return false;
+    }
+    true
+}
+
+fn parse_listen(listen: &str) -> (String, u16) {
+    if let Some((host, port_s)) = listen.rsplit_once(':') {
+        if let Ok(p) = port_s.parse::<u16>() {
+            return (host.to_string(), p);
+        }
+    }
+    (listen.to_string(), 9000)
+}
+
+fn is_port_free(host: &str, port: u16) -> bool {
+    let addr = format!("{host}:{port}");
+    // bind test + connect test (docker port forwarding can make bind succeed while port is still forwarded)
+    if std::net::TcpListener::bind(&addr).is_err() {
+        return false;
+    }
+    use std::net::ToSocketAddrs;
+    let probe_host = if host == "0.0.0.0" { "127.0.0.1" } else { host };
+    if let Ok(mut addrs) = (probe_host, port).to_socket_addrs() {
+        if let Some(a) = addrs.next() {
+            if std::net::TcpStream::connect_timeout(&a, std::time::Duration::from_millis(200))
+                .is_ok()
+            {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+fn resolve_listen(cfg: &mut Config, no_search: bool) -> String {
+    if no_search {
+        return cfg.listen.clone();
+    }
+    let (host, port) = parse_listen(&cfg.listen);
+    let clean_host = if host.is_empty() {
+        "0.0.0.0".to_string()
+    } else {
+        host
+    };
+    if is_port_free(&clean_host, port) {
+        return cfg.listen.clone();
+    }
+    for p in (port + 1)..=port.saturating_add(50) {
+        if is_port_free(&clean_host, p) {
+            let new_listen = format!("{clean_host}:{p}");
+            eprintln!("port {port} busy — switching to free port {p} ({new_listen})");
+            cfg.listen = new_listen.clone();
+            return new_listen;
+        }
+    }
+    if !is_port_free(&clean_host, port) {
+        eprintln!(
+            "warning: port {port} busy and no free port found in next 50, will try to bind anyway"
+        );
+    }
+    cfg.listen.clone()
+}
+
+fn setup_marker_path(config_path: &str) -> std::path::PathBuf {
+    // marker lives next to config file: gateway.toml -> .setup_done
+    std::path::Path::new(config_path)
+        .parent()
+        .unwrap_or_else(|| std::path::Path::new("."))
+        .join(".setup_done")
+}
+
+fn needs_first_run_wizard(cfg: &Config, config_path: &str) -> bool {
+    let marker = setup_marker_path(config_path);
+    if marker.exists() {
+        return false;
+    }
+    // also consider "needs setup" if model pool is empty and no managed cmf
+    if !cfg.models.is_empty() || !cfg.cmf.effective_servers().is_empty() {
+        // still show wizard once if marker missing, but not if user already has models
+        // we treat missing marker + existing models as "already configured" to avoid nagging
+        // persist marker lazily
+        let _ = std::fs::write(&marker, "done");
+        return false;
+    }
+    true
 }
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let args = Args::parse();
+    let config_path = args
+        .config
+        .clone()
+        .unwrap_or_else(config::default_config_path);
 
-    let cfg = Config::load(&args.config)?;
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            tracing_subscriber::EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| cfg.log.level.clone().into()),
-        )
-        .init();
+    let mut cfg = Config::load_or_create(&config_path)?;
+    // auto-pick a free port if the configured one is busy (unless disabled)
+    let original_listen = cfg.listen.clone();
+    let listen = resolve_listen(&mut cfg, args.no_port_search);
+    // persist the resolved port if it changed
+    if listen != original_listen {
+        let _ = cfg.save(&config_path);
+    }
+    {
+        use tracing_subscriber::layer::SubscriberExt;
+        use tracing_subscriber::util::SubscriberInitExt;
+        let filter = tracing_subscriber::EnvFilter::try_from_default_env()
+            .unwrap_or_else(|_| cfg.log.level.clone().into());
+        tracing_subscriber::registry()
+            .with(filter)
+            .with(tracing_subscriber::fmt::layer())
+            // second copy of every line, without ANSI, into the in-memory ring
+            // that backs the admin console's Логи view
+            .with(
+                tracing_subscriber::fmt::layer()
+                    .with_ansi(false)
+                    .with_writer(logbuf::RingMakeWriter),
+            )
+            .init();
+    }
 
-    let listen = cfg.listen.clone();
     let admin_enabled = cfg.admin.enabled;
-    let (admin_token, generated) = resolve_admin_token(&cfg, &args);
+    let admin_token = resolve_admin_token(&cfg, &args);
+    let first_run = needs_first_run_wizard(&cfg, &config_path);
 
-    let state = SharedState::build(cfg, args.config.clone())?;
+    let state = SharedState::build(cfg, config_path.clone())?;
+
+    // Open admin console reachable from other machines: fine on a laptop,
+    // a footgun on a VPS. Flag it for the UI banner and say it in the log.
+    let host_public = listen.starts_with("0.0.0.0") || listen.starts_with("[::]");
+    if admin_enabled && admin_token.is_empty() && host_public && !is_docker() {
+        state
+            .admin_open_public
+            .store(true, std::sync::atomic::Ordering::Relaxed);
+        tracing::warn!(
+            "admin console is OPEN (no token) and listening on {listen} — anyone on              your network can manage this gateway; set a token via --admin-token or              [admin].token if this machine is reachable from outside"
+        );
+    }
 
     // Close the loop with the CMF format (github.com/infosave2007/cmf): install
     // / update cortiq-cli and run a local `cortiq serve` if configured. Runs in
@@ -99,6 +255,7 @@ async fn main() -> anyhow::Result<()> {
 
     let mut app = Router::new()
         .route("/healthz", get(|| async { "ok" }))
+        .route("/health", get(|| async { "ok" }))
         .route("/readyz", get(|| async { "ready" }))
         .route("/metrics", get(admin::metrics))
         .merge(protocols::build_router());
@@ -109,16 +266,78 @@ async fn main() -> anyhow::Result<()> {
             .fallback(admin::assets::fallback);
     }
 
-    let app = app.with_state(state);
+    let cors = tower_http::cors::CorsLayer::new()
+        .allow_origin(tower_http::cors::Any)
+        .allow_methods(tower_http::cors::Any)
+        .allow_headers(tower_http::cors::Any);
 
-    let listener = tokio::net::TcpListener::bind(&listen).await?;
+    let app = app.with_state(state).layer(cors);
+
+    let listener = {
+        let mut attempt = 0u32;
+        loop {
+            match tokio::net::TcpListener::bind(&listen).await {
+                Ok(l) => break l,
+                Err(e) => {
+                    // during self-restart the old process is still letting go of
+                    // the port — retry for a few seconds before giving up
+                    let retrying = std::env::var("CORTIQ_BIND_RETRY").is_ok();
+                    if retrying && attempt < 50 {
+                        attempt += 1;
+                        tokio::time::sleep(std::time::Duration::from_millis(200)).await;
+                        continue;
+                    }
+                    return Err(e.into());
+                }
+            }
+        }
+    };
     tracing::info!("cortiq-gateway listening on {listen}");
     if admin_enabled {
-        tracing::info!("admin console: http://{listen}/admin");
-        if generated {
-            tracing::warn!(
-                "admin token (auto-generated, set [admin].token_env to persist): {admin_token}"
-            );
+        let host_for_url = if listen.starts_with("0.0.0.0:") {
+            listen.replacen("0.0.0.0", "127.0.0.1", 1)
+        } else {
+            listen.clone()
+        };
+        // On first run open the onboarding wizard, otherwise the normal console.
+        let admin_path = if first_run {
+            "/admin#/onboarding"
+        } else {
+            "/admin"
+        };
+        let url = if admin_token.is_empty() {
+            format!("http://{host_for_url}{admin_path}")
+        } else {
+            format!("http://{host_for_url}{admin_path}?token={admin_token}")
+        };
+        if admin_token.is_empty() {
+            tracing::info!("admin console (open, no token): http://{host_for_url}/admin");
+        } else {
+            tracing::info!("admin console: http://{host_for_url}/admin");
+        }
+        if first_run {
+            tracing::info!("first run — opening onboarding wizard at {url}");
+        }
+        if admin_enabled && should_open_browser(&args) {
+            let browser_url = url.clone();
+            tokio::spawn(async move {
+                // give server a moment to be ready
+                tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+                #[cfg(feature = "open-browser")]
+                {
+                    if let Err(e) = open::that(&browser_url) {
+                        tracing::warn!("failed to open browser: {e}");
+                    } else {
+                        tracing::info!("opened browser at {browser_url}");
+                    }
+                }
+                #[cfg(not(feature = "open-browser"))]
+                {
+                    tracing::info!("open browser: {browser_url} (feature disabled)");
+                }
+            });
+        } else if first_run {
+            tracing::info!("open this URL to finish setup: {url}");
         }
     }
     axum::serve(listener, app).await?;

src/media.rs

@@ -0,0 +1,861 @@
+//! Media generation: run `cortiq imagine` (text→image, Lumina) and
+//! `cortiq animate` (text→video+audio, MiniMax-H3) over local `.cmf` files as
+//! tracked background jobs, the same shape as import jobs so the admin UI can
+//! poll progress and fetch the result.
+//!
+//! These models are NOT served by `cortiq serve` — each generation is one CLI
+//! run. The gateway owns the process, parses its progress, and keeps the output
+//! under `<data>/media/<job>/`.
+
+use serde::Serialize;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+use std::sync::{Arc, Mutex};
+use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::sync::Notify;
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+/// Random job id — media jobs are never deduplicated (every run is a new work).
+fn gen_media_id() -> String {
+    let mut b = [0u8; 8];
+    let _ = getrandom::getrandom(&mut b);
+    b.iter().map(|x| format!("{x:02x}")).collect()
+}
+
+/// What a `.cmf` under models_dir can do, decided by `cortiq info`.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Modality {
+    Chat,
+    Image,
+    Video,
+}
+
+/// `cortiq info` output → modality. The arch line names the family; the media
+/// packs also carry their pipeline components (DiT/VAE/vocoder) in the text.
+fn classify_info(info: &str) -> Modality {
+    let lower = info.to_ascii_lowercase();
+    let arch = lower
+        .lines()
+        .find_map(|l| l.trim().strip_prefix("arch:"))
+        .unwrap_or("")
+        .trim()
+        .to_string();
+    // generic arch suffixes first (e.g. "lumina2-image", "mmh3-video"), then
+    // known family names as a fallback for packs without the suffix
+    if arch.contains("video") || arch.contains("mmh3") || arch.contains("minimax") {
+        return Modality::Video;
+    }
+    if arch.contains("image") || arch.contains("lumina") || arch.contains("diffusion") {
+        return Modality::Image;
+    }
+    if lower.contains("text-to-video") {
+        return Modality::Video;
+    }
+    if lower.contains("text-to-image") {
+        return Modality::Image;
+    }
+    Modality::Chat
+}
+
+/// One local `.cmf` with its detected modality.
+#[derive(Clone, Serialize)]
+pub struct MediaModel {
+    pub name: String, // file stem
+    pub path: String,
+    pub size_bytes: u64,
+    pub modality: Modality,
+}
+
+#[derive(Default)]
+struct InfoCache(Mutex<HashMap<String, (u64, u64, Modality)>>); // path → (mtime, size, modality)
+
+/// Modality of one `.cmf`, via `cortiq info` — cached by (path, mtime, size),
+/// so the process runs once per file version.
+pub async fn classify_file(path: &Path, cortiq_bin: &str) -> Modality {
+    static CACHE: std::sync::OnceLock<InfoCache> = std::sync::OnceLock::new();
+    let cache = CACHE.get_or_init(InfoCache::default);
+
+    let size = crate::import::path_size(path);
+    let mtime = std::fs::metadata(path)
+        .ok()
+        .and_then(|m| m.modified().ok())
+        .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let key = path.to_string_lossy().to_string();
+    if let Some(k) = cache
+        .0
+        .lock()
+        .unwrap()
+        .get(&key)
+        .filter(|(m, s, _)| *m == mtime && *s == size)
+        .map(|(_, _, k)| *k)
+    {
+        return k;
+    }
+    let output = tokio::process::Command::new(cortiq_bin)
+        .arg("info")
+        .arg(path)
+        .output()
+        .await;
+    let text = output
+        .map(|o| {
+            format!(
+                "{}{}",
+                String::from_utf8_lossy(&o.stdout),
+                String::from_utf8_lossy(&o.stderr)
+            )
+        })
+        .unwrap_or_default();
+    let k = classify_info(&text);
+    cache.0.lock().unwrap().insert(key, (mtime, size, k));
+    k
+}
+
+/// Scan models_dir and classify every `.cmf` (file or sharded dir).
+pub async fn list_media_models(models_dir: &str, cortiq_bin: &str) -> Vec<MediaModel> {
+    let mut out = Vec::new();
+    let Ok(rd) = std::fs::read_dir(models_dir) else {
+        return out;
+    };
+    for entry in rd.filter_map(|e| e.ok()) {
+        let path = entry.path();
+        let name = path
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string();
+        if !name.to_ascii_lowercase().ends_with(".cmf") {
+            continue;
+        }
+        let size = crate::import::path_size(&path);
+        if size == 0 {
+            continue; // empty or still being written
+        }
+        let modality = classify_file(&path, cortiq_bin).await;
+        out.push(MediaModel {
+            name: name
+                .trim_end_matches(".cmf")
+                .trim_end_matches(".CMF")
+                .to_string(),
+            path: path.to_string_lossy().to_string(),
+            size_bytes: size,
+            modality,
+        });
+    }
+    out.sort_by(|a, b| a.name.cmp(&b.name));
+    out
+}
+
+/// Parameters for one generation, straight from the playground form.
+#[derive(Clone, Debug, serde::Deserialize)]
+pub struct MediaParams {
+    pub model: String, // file stem under models_dir
+    pub kind: String,  // image | video
+    pub prompt: String,
+    #[serde(default)]
+    pub width: Option<u32>,
+    #[serde(default)]
+    pub height: Option<u32>,
+    #[serde(default)]
+    pub steps: Option<u32>,
+    #[serde(default)]
+    pub cfg: Option<f32>, // image only
+    #[serde(default)]
+    pub seed: Option<u64>,
+    #[serde(default)]
+    pub frames: Option<u32>, // video only
+    #[serde(default)]
+    pub quality: Option<u32>, // video only: AVI JPEG quality
+    /// Optional first/last keyframe for video, base64-encoded binary P6 PPM.
+    #[serde(default)]
+    pub first_frame_b64: Option<String>,
+    #[serde(default)]
+    pub last_frame_b64: Option<String>,
+}
+
+/// Live state of one generation.
+#[derive(Clone, Serialize, serde::Deserialize)]
+pub struct MediaJob {
+    pub id: String,
+    pub kind: String, // image | video
+    pub model: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+    pub steps: u32,
+    pub seed: u64,
+    pub frames: Option<u32>,
+    pub state: String, // queued | running | done | error | cancelled
+    pub progress: Option<f32>,
+    pub phase: Option<String>,
+    pub log: Vec<String>,
+    pub started: u64,
+    pub finished: Option<u64>,
+    /// Files this job produced: name → relative kind ("image", "video", "audio", "mp4").
+    pub outputs: Vec<String>,
+    pub out_bytes: Option<u64>,
+}
+
+/// Everything needed to actually launch a queued job when its turn comes.
+struct Prepared {
+    bin: String,
+    args: Vec<String>,
+    gpu: bool,
+    dir: PathBuf,
+    out_path: PathBuf,
+    kind: String,
+}
+
+#[derive(Default)]
+pub struct MediaStore {
+    jobs: Mutex<HashMap<String, MediaJob>>,
+    cancels: Mutex<HashMap<String, Arc<Notify>>>,
+    /// One generation runs at a time — these models take the whole GPU/RAM
+    /// budget — but new requests queue up instead of being rejected.
+    queue: Mutex<std::collections::VecDeque<String>>,
+    current: Mutex<Option<String>>,
+    prepared: Mutex<HashMap<String, Prepared>>,
+    persist: Mutex<Option<PathBuf>>,
+}
+
+impl MediaStore {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+    /// Load saved generations (their files are still under media_dir) and start
+    /// persisting. Jobs that were queued/running when the gateway died settle
+    /// as errors — the process is gone.
+    pub fn attach_persistence(&self, path: PathBuf) {
+        if let Ok(text) = std::fs::read_to_string(&path) {
+            if let Ok(mut jobs) = serde_json::from_str::<Vec<MediaJob>>(&text) {
+                let mut g = self.jobs.lock().unwrap();
+                for mut j in jobs.drain(..) {
+                    if j.state == "running" || j.state == "queued" {
+                        j.state = "error".into();
+                        j.log.push("✗ interrupted by a gateway restart".into());
+                        j.finished = Some(now());
+                    }
+                    g.insert(j.id.clone(), j);
+                }
+            }
+        }
+        *self.persist.lock().unwrap() = Some(path);
+    }
+    fn save(&self) {
+        let Some(path) = self.persist.lock().unwrap().clone() else {
+            return;
+        };
+        let jobs: Vec<MediaJob> = self.jobs.lock().unwrap().values().cloned().collect();
+        if let Ok(json) = serde_json::to_vec(&jobs) {
+            let tmp = path.with_extension("json.tmp");
+            if std::fs::write(&tmp, json).is_ok() {
+                let _ = std::fs::rename(&tmp, &path);
+            }
+        }
+    }
+    /// How many jobs sit in the queue ahead of `id` (0 = next up).
+    pub fn queue_position(&self, id: &str) -> Option<usize> {
+        self.queue.lock().unwrap().iter().position(|x| x == id)
+    }
+    pub fn list(&self) -> Vec<MediaJob> {
+        let mut v: Vec<MediaJob> = self.jobs.lock().unwrap().values().cloned().collect();
+        v.sort_by_key(|j| std::cmp::Reverse(j.started));
+        v.truncate(20);
+        v
+    }
+    pub fn get(&self, id: &str) -> Option<MediaJob> {
+        self.jobs.lock().unwrap().get(id).cloned()
+    }
+    pub fn cancel(self: &Arc<Self>, id: &str, media_dir: &Path) -> bool {
+        let state = self
+            .jobs
+            .lock()
+            .unwrap()
+            .get(id)
+            .map(|j| j.state.clone())
+            .unwrap_or_default();
+        match state.as_str() {
+            "queued" => {
+                self.queue.lock().unwrap().retain(|x| x != id);
+                self.prepared.lock().unwrap().remove(id);
+                let _ = std::fs::remove_dir_all(media_dir.join(id));
+                self.set_cancelled(id);
+                true
+            }
+            "running" => {
+                if let Some(n) = self.cancels.lock().unwrap().get(id) {
+                    n.notify_one();
+                    true
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        }
+    }
+    /// Remove a settled job and its output directory. Err = still running.
+    pub fn delete(&self, id: &str, media_dir: &Path) -> Result<bool, String> {
+        let job = self.jobs.lock().unwrap().get(id).cloned();
+        let Some(job) = job else { return Ok(false) };
+        if job.state == "running" || job.state == "queued" {
+            return Err("cancel the running generation first".into());
+        }
+        let _ = std::fs::remove_dir_all(media_dir.join(id));
+        self.jobs.lock().unwrap().remove(id);
+        self.save();
+        Ok(true)
+    }
+    fn push_line(&self, id: &str, line: String) {
+        if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
+            j.log.push(line);
+            let n = j.log.len();
+            if n > 120 {
+                j.log.drain(0..n - 120);
+            }
+        }
+    }
+    fn set_progress(&self, id: &str, frac: f32, phase: Option<String>) {
+        if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
+            let f = frac.clamp(0.0, 1.0);
+            if j.progress.is_none() || f > j.progress.unwrap() {
+                j.progress = Some(f);
+            }
+            if let Some(p) = phase {
+                j.phase = Some(p);
+            }
+        }
+    }
+    fn finish(self: &Arc<Self>, id: &str, ok: bool, outputs: Vec<String>, out_bytes: u64) {
+        let mut g = self.jobs.lock().unwrap();
+        if let Some(j) = g.get_mut(id) {
+            if j.state == "cancelled" {
+                drop(g);
+                self.after_slot_freed(id);
+                return;
+            }
+            j.finished = Some(now());
+            j.state = if ok { "done" } else { "error" }.into();
+            if ok {
+                j.progress = Some(1.0);
+                j.outputs = outputs;
+                j.out_bytes = Some(out_bytes);
+            }
+        }
+        drop(g);
+        self.after_slot_freed(id);
+    }
+    fn set_cancelled(self: &Arc<Self>, id: &str) {
+        if let Some(j) = self.jobs.lock().unwrap().get_mut(id) {
+            j.state = "cancelled".into();
+            j.finished = Some(now());
+        }
+        self.after_slot_freed(id);
+    }
+    fn after_slot_freed(self: &Arc<Self>, id: &str) {
+        {
+            let mut cur = self.current.lock().unwrap();
+            if cur.as_deref() == Some(id) {
+                *cur = None;
+            }
+        }
+        self.cancels.lock().unwrap().remove(id);
+        self.save();
+        promote_next(self.clone());
+    }
+}
+
+/// Start the next queued generation, if the slot is free.
+fn promote_next(store: Arc<MediaStore>) {
+    let next = {
+        let mut cur = store.current.lock().unwrap();
+        if cur.is_some() {
+            return;
+        }
+        let Some(id) = store.queue.lock().unwrap().pop_front() else {
+            return;
+        };
+        *cur = Some(id.clone());
+        id
+    };
+    let Some(p) = store.prepared.lock().unwrap().remove(&next) else {
+        // job was cancelled while queued and slipped through — free the slot
+        *store.current.lock().unwrap() = None;
+        return;
+    };
+    if let Some(j) = store.jobs.lock().unwrap().get_mut(&next) {
+        j.state = "running".into();
+        j.phase = Some("starting".into());
+        j.started = now();
+    }
+    store.save();
+    let cancel = Arc::new(Notify::new());
+    store
+        .cancels
+        .lock()
+        .unwrap()
+        .insert(next.clone(), cancel.clone());
+    let s = store.clone();
+    tokio::spawn(async move {
+        run_generation(
+            s, next, p.bin, p.args, p.gpu, p.dir, p.out_path, p.kind, cancel,
+        )
+        .await;
+    });
+}
+
+/// Progress markers in `cortiq imagine`/`animate` stdout. The exact wording has
+/// varied between releases, so accept anything that carries an X/Y pair near a
+/// step/frame word, a bare percentage, or the converter-style `@PROGRESS`.
+fn parse_media_progress(line: &str) -> Option<(f32, Option<String>)> {
+    let l = line.trim();
+    if let Some(rest) = l.strip_prefix("@PROGRESS ") {
+        let mut it = rest.splitn(2, ' ');
+        let frac: f32 = it.next()?.trim().parse().ok()?;
+        let phase = it
+            .next()
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        return Some((frac.clamp(0.0, 1.0), phase));
+    }
+    let lower = l.to_ascii_lowercase();
+    // "step 12/30", "denoise 3/4", "frame 7/39" — any word followed by x/y
+    for word in ["step", "frame", "sigma", "denois"] {
+        if let Some(pos) = lower.find(word) {
+            let tail = &lower[pos..];
+            if let Some((x, y)) = extract_ratio(tail) {
+                return Some((x / y, Some(l.to_string())));
+            }
+        }
+    }
+    // bare "42%" (avoid matching sizes like "42%faster")
+    if let Some(idx) = lower.find('%') {
+        let head: String = lower[..idx]
+            .chars()
+            .rev()
+            .take_while(|c| c.is_ascii_digit() || *c == '.')
+            .collect();
+        let num: String = head.chars().rev().collect();
+        if let Ok(p) = num.parse::<f32>() {
+            if (0.0..=100.0).contains(&p) {
+                return Some((p / 100.0, None));
+            }
+        }
+    }
+    None
+}
+
+/// First "N/M" pair in the string with M > 0.
+fn extract_ratio(s: &str) -> Option<(f32, f32)> {
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i].is_ascii_digit() {
+            let start = i;
+            while i < bytes.len() && bytes[i].is_ascii_digit() {
+                i += 1;
+            }
+            if i < bytes.len() && bytes[i] == b'/' {
+                let x: f32 = s[start..i].parse().ok()?;
+                let ystart = i + 1;
+                let mut j = ystart;
+                while j < bytes.len() && bytes[j].is_ascii_digit() {
+                    j += 1;
+                }
+                if j > ystart {
+                    if let Ok(y) = s[ystart..j].parse::<f32>() {
+                        if y > 0.0 && x <= y {
+                            return Some((x, y));
+                        }
+                    }
+                }
+            }
+        } else {
+            i += 1;
+        }
+    }
+    None
+}
+
+/// Root for generated files: `<data>/media`.
+pub fn media_dir() -> PathBuf {
+    crate::config::data_dir().join("media")
+}
+
+const B64: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/// Minimal base64 decode (standard alphabet, padding optional) — the keyframes
+/// are the only base64 input the gateway takes; not worth a dependency.
+fn b64_decode(s: &str) -> Option<Vec<u8>> {
+    let mut lut = [255u8; 256];
+    for (i, c) in B64.iter().enumerate() {
+        lut[*c as usize] = i as u8;
+    }
+    let mut out = Vec::with_capacity(s.len() * 3 / 4);
+    let mut buf = 0u32;
+    let mut bits = 0u32;
+    for c in s.bytes() {
+        if c == b'=' || c == b'\n' || c == b'\r' {
+            continue;
+        }
+        let v = lut[c as usize];
+        if v == 255 {
+            return None;
+        }
+        buf = (buf << 6) | v as u32;
+        bits += 6;
+        if bits >= 8 {
+            bits -= 8;
+            out.push((buf >> bits) as u8);
+        }
+    }
+    Some(out)
+}
+
+/// Kick off a generation. Returns the job id, or an error when another one is
+/// already running / the model file is missing.
+pub fn start_generation(
+    store: Arc<MediaStore>,
+    cmf: &crate::config::CmfCfg,
+    p: MediaParams,
+) -> Result<String, String> {
+    if p.prompt.trim().is_empty() {
+        return Err("empty prompt".into());
+    }
+    let kind = p.kind.as_str();
+    if kind != "image" && kind != "video" {
+        return Err(format!("unknown kind '{kind}'"));
+    }
+    let model_path = Path::new(&cmf.models_dir).join(format!("{}.cmf", p.model));
+    if !model_path.exists() {
+        return Err(format!("model file not found: {}", model_path.display()));
+    }
+
+    let id = gen_media_id();
+    let dir = media_dir().join(&id);
+    if let Err(e) = std::fs::create_dir_all(&dir) {
+        return Err(format!("cannot create media dir {}: {e}", dir.display()));
+    }
+
+    // Optional keyframes (video): decode to PPM files next to the output.
+    let mut first_frame: Option<PathBuf> = None;
+    let mut last_frame: Option<PathBuf> = None;
+    for (b64, slot, name) in [
+        (&p.first_frame_b64, &mut first_frame, "first.ppm"),
+        (&p.last_frame_b64, &mut last_frame, "last.ppm"),
+    ] {
+        if let Some(data) = b64.as_deref().filter(|s| !s.is_empty()) {
+            let bytes = b64_decode(data).ok_or("invalid keyframe base64")?;
+            if !bytes.starts_with(b"P6") {
+                return Err("keyframe must be a binary P6 PPM".into());
+            }
+            let path = dir.join(name);
+            std::fs::write(&path, bytes).map_err(|e| format!("write keyframe: {e}"))?;
+            *slot = Some(path);
+        }
+    }
+
+    let width = p.width.unwrap_or(512).clamp(64, 2048);
+    let height = p
+        .height
+        .unwrap_or(if kind == "video" { 288 } else { 512 })
+        .clamp(64, 2048);
+    let steps = p
+        .steps
+        .unwrap_or(if kind == "video" { 4 } else { 30 })
+        .clamp(1, 200);
+    let seed = p.seed.unwrap_or(42);
+    let frames = p.frames.unwrap_or(39).clamp(1, 1000);
+
+    let out_name = if kind == "image" {
+        "out.ppm"
+    } else {
+        "out.avi"
+    };
+    let out_path = dir.join(out_name);
+
+    let mut args: Vec<String> = if kind == "image" {
+        vec![
+            "imagine".into(),
+            model_path.to_string_lossy().to_string(),
+            "--prompt".into(),
+            p.prompt.clone(),
+            "--width".into(),
+            width.to_string(),
+            "--height".into(),
+            height.to_string(),
+            "--steps".into(),
+            steps.to_string(),
+            "--cfg".into(),
+            format!("{}", p.cfg.unwrap_or(4.0)),
+            "--seed".into(),
+            seed.to_string(),
+            "--out".into(),
+            out_path.to_string_lossy().to_string(),
+        ]
+    } else {
+        let mut a = vec![
+            "animate".into(),
+            model_path.to_string_lossy().to_string(),
+            "--prompt".into(),
+            p.prompt.clone(),
+            "--width".into(),
+            width.to_string(),
+            "--height".into(),
+            height.to_string(),
+            "--frames".into(),
+            frames.to_string(),
+            "--steps".into(),
+            steps.to_string(),
+            "--seed".into(),
+            seed.to_string(),
+            "--quality".into(),
+            p.quality.unwrap_or(92).clamp(10, 100).to_string(),
+            "--out".into(),
+            out_path.to_string_lossy().to_string(),
+        ];
+        if let Some(f) = &first_frame {
+            a.push("--first-frame".into());
+            a.push(f.to_string_lossy().to_string());
+        }
+        if let Some(f) = &last_frame {
+            a.push("--last-frame".into());
+            a.push(f.to_string_lossy().to_string());
+        }
+        a
+    };
+    // keep the model path first for readability in logs
+    let _ = &mut args;
+
+    store.jobs.lock().unwrap().insert(
+        id.clone(),
+        MediaJob {
+            id: id.clone(),
+            kind: kind.to_string(),
+            model: p.model.clone(),
+            prompt: p.prompt.clone(),
+            width,
+            height,
+            steps,
+            seed,
+            frames: (kind == "video").then_some(frames),
+            state: "queued".into(),
+            progress: None,
+            phase: None,
+            log: vec![format!("→ cortiq {}", args.join(" "))],
+            started: now(),
+            finished: None,
+            outputs: Vec::new(),
+            out_bytes: None,
+        },
+    );
+    store.prepared.lock().unwrap().insert(
+        id.clone(),
+        Prepared {
+            bin: cmf.cortiq_bin.clone(),
+            args,
+            gpu: cmf.gpu,
+            dir,
+            out_path,
+            kind: kind.to_string(),
+        },
+    );
+    store.queue.lock().unwrap().push_back(id.clone());
+    store.save();
+    promote_next(store.clone());
+    Ok(id)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn run_generation(
+    store: Arc<MediaStore>,
+    id: String,
+    bin: String,
+    args: Vec<String>,
+    gpu: bool,
+    dir: PathBuf,
+    out_path: PathBuf,
+    kind: String,
+    cancel: Arc<Notify>,
+) {
+    let mut cmd = tokio::process::Command::new(&bin);
+    cmd.args(&args)
+        .env("CMF_GPU", if gpu { "1" } else { "0" })
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+    let mut child = match cmd.spawn() {
+        Ok(c) => c,
+        Err(e) => {
+            store.push_line(&id, format!("✗ failed to start cortiq: {e}"));
+            store.finish(&id, false, Vec::new(), 0);
+            return;
+        }
+    };
+    let mut readers = Vec::new();
+    if let Some(o) = child.stdout.take() {
+        readers.push(tokio::spawn(read_lines(store.clone(), id.clone(), o)));
+    }
+    if let Some(e) = child.stderr.take() {
+        readers.push(tokio::spawn(read_lines(store.clone(), id.clone(), e)));
+    }
+
+    let status = tokio::select! {
+        s = child.wait() => s,
+        _ = cancel.notified() => {
+            let _ = child.start_kill();
+            let _ = child.wait().await;
+            for r in readers { r.abort(); }
+            let _ = std::fs::remove_dir_all(&dir);
+            store.push_line(&id, "✗ cancelled".into());
+            store.set_cancelled(&id);
+            return;
+        }
+    };
+    for r in readers {
+        let _ = r.await;
+    }
+
+    let ok = status.map(|s| s.success()).unwrap_or(false);
+    if !ok || !out_path.exists() {
+        store.push_line(&id, "✗ generation failed — see the log above".into());
+        store.finish(&id, false, Vec::new(), 0);
+        return;
+    }
+
+    let mut outputs = vec![if kind == "image" { "image" } else { "video" }.to_string()];
+    if kind == "video" {
+        // `animate` writes a .wav next to the .avi
+        if dir.join("out.wav").exists() {
+            outputs.push("audio".into());
+        }
+        // opportunistic browser-friendly remux when ffmpeg is present
+        if let Ok(p) = which_ffmpeg() {
+            store.push_line(&id, "→ remuxing to mp4 (ffmpeg found)".into());
+            let mp4 = dir.join("out.mp4");
+            let mut f = tokio::process::Command::new(p);
+            f.arg("-y").arg("-i").arg(dir.join("out.avi"));
+            if dir.join("out.wav").exists() {
+                f.arg("-i")
+                    .arg(dir.join("out.wav"))
+                    .args(["-map", "0:v", "-map", "1:a", "-c:a", "aac"]);
+            }
+            f.args(["-c:v", "libx264", "-pix_fmt", "yuv420p"]).arg(&mp4);
+            f.stdout(Stdio::null()).stderr(Stdio::null());
+            if matches!(f.status().await, Ok(s) if s.success()) && mp4.exists() {
+                outputs.push("mp4".into());
+            }
+        }
+    }
+    let bytes = crate::import::path_size(&out_path);
+    store.push_line(
+        &id,
+        format!("✓ done — {}", crate::import::format_bytes(bytes)),
+    );
+    store.finish(&id, true, outputs, bytes);
+}
+
+/// Strip ANSI color escapes that `tracing` writes even into a pipe.
+fn strip_ansi(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c == '\u{1b}' {
+            for d in chars.by_ref() {
+                if d.is_ascii_alphabetic() {
+                    break;
+                }
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+async fn read_lines(store: Arc<MediaStore>, id: String, stream: impl tokio::io::AsyncRead + Unpin) {
+    let mut lines = BufReader::new(stream).lines();
+    while let Ok(Some(l)) = lines.next_line().await {
+        let l = strip_ansi(l.trim());
+        if l.is_empty() {
+            continue;
+        }
+        // the Metal backend logs one line per pipeline — dozens per run, all identical
+        if l.contains("Metal GPU path") {
+            continue;
+        }
+        if let Some((frac, phase)) = parse_media_progress(&l) {
+            store.set_progress(&id, frac, phase);
+        } else {
+            store.push_line(&id, l);
+        }
+    }
+}
+
+fn which_ffmpeg() -> Result<String, ()> {
+    for p in [
+        "ffmpeg",
+        "/usr/local/bin/ffmpeg",
+        "/opt/homebrew/bin/ffmpeg",
+    ] {
+        if std::process::Command::new(p)
+            .arg("-version")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .map(|s| s.success())
+            .unwrap_or(false)
+        {
+            return Ok(p.to_string());
+        }
+    }
+    Err(())
+}
+
+/// (relative file, content-type) for an output kind of a finished job.
+pub fn output_file(kind: &str) -> Option<(&'static str, &'static str)> {
+    match kind {
+        "image" => Some(("out.ppm", "image/x-portable-pixmap")),
+        "video" => Some(("out.avi", "video/x-msvideo")),
+        "audio" => Some(("out.wav", "audio/wav")),
+        "mp4" => Some(("out.mp4", "video/mp4")),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn progress_parses_common_shapes() {
+        assert_eq!(parse_media_progress("step 15/30").unwrap().0, 0.5);
+        assert_eq!(
+            parse_media_progress("Denoising step 3/4 ...").unwrap().0,
+            0.75
+        );
+        assert_eq!(parse_media_progress("frame 39/39 decoded").unwrap().0, 1.0);
+        assert_eq!(parse_media_progress("@PROGRESS 0.25 vae").unwrap().0, 0.25);
+        assert!(parse_media_progress("loaded 2361 tensors").is_none());
+    }
+
+    #[test]
+    fn classify_by_arch() {
+        assert_eq!(classify_info("  Arch:        lumina2\n"), Modality::Image);
+        assert_eq!(classify_info("  Arch:        mmh3\n"), Modality::Video);
+        assert_eq!(classify_info("  Arch:        qwen3\n"), Modality::Chat);
+    }
+
+    #[test]
+    fn b64_roundtrip() {
+        assert_eq!(b64_decode("UDYgd2g=").unwrap(), b"P6 wh");
+        assert!(b64_decode("!!").is_none());
+    }
+}

src/pipeline.rs

@@ -231,9 +231,30 @@ impl Pipeline {
                         let prof = profile.as_deref().unwrap_or(&live.cfg.route.profile);
                         match live.router.route(&text, prof).await {
                             Ok(Some(dec)) => {
+                                let mut dec = dec;
+                                // per-gateway complexity bands: re-map the
+                                // router's continuous score with the user's
+                                // own boundaries (sliders on the Routing page)
+                                if let Some(b) = &live.cfg.routing.bands {
+                                    if matches!(
+                                        dec.complexity_tier.as_str(),
+                                        "low" | "medium" | "high"
+                                    ) {
+                                        dec.complexity_tier =
+                                            b.tier_of(dec.complexity_score).to_string();
+                                    }
+                                }
                                 let src = dec.source.clone();
-                                let tier = dec.complexity_tier.clone();
-                                (dec, src, live.routing.candidates(&tier))
+                                let (cands, task_rule) = live
+                                    .routing
+                                    .candidates_for(&dec.task_label, &dec.complexity_tier);
+                                // surface which rule chose the head of the chain
+                                let src = if task_rule {
+                                    format!("{src}+task-rule")
+                                } else {
+                                    src
+                                };
+                                (dec, src, cands)
                             }
                             Ok(None) | Err(_) => {
                                 tracing::warn!(
@@ -487,6 +508,20 @@ impl Pipeline {
                 if req_call.params.think_budget.is_none() {
                     req_call.params.think_budget = m_cfg.think_budget;
                 }
+                if let Some(sys) = &m_cfg.system_prompt {
+                    if !sys.trim().is_empty()
+                        && !req_call.messages.iter().any(|m| m.role == "system")
+                    {
+                        req_call.messages.insert(
+                            0,
+                            Message {
+                                role: "system".into(),
+                                content: sys.clone(),
+                                tool_calls: Vec::new(),
+                            },
+                        );
+                    }
+                }
             } else if let Some(s_cfg) = live.cfg.cmf.servers.iter().find(|s| s.id == model_id) {
                 if req_call.params.temperature.is_none() {
                     req_call.params.temperature = s_cfg.temperature;
@@ -500,6 +535,20 @@ impl Pipeline {
                 if req_call.params.think_budget.is_none() {
                     req_call.params.think_budget = s_cfg.think_budget;
                 }
+                if let Some(sys) = &s_cfg.system_prompt {
+                    if !sys.trim().is_empty()
+                        && !req_call.messages.iter().any(|m| m.role == "system")
+                    {
+                        req_call.messages.insert(
+                            0,
+                            Message {
+                                role: "system".into(),
+                                content: sys.clone(),
+                                tool_calls: Vec::new(),
+                            },
+                        );
+                    }
+                }
             }
 
             match provider.chat_stream(req_call).await {
@@ -514,6 +563,11 @@ impl Pipeline {
                         cost_usd: 0.0,
                         failover: attempt > 0,
                     };
+                    // for the client-facing usage estimate when the provider
+                    // sends none: the prompt size is known here, the reply is
+                    // measured inside the tap
+                    let prompt_chars: usize =
+                        req.messages.iter().map(|m| m.content.chars().count()).sum();
                     let tapped = tap_stream(
                         stream,
                         state.stats.clone(),
@@ -523,6 +577,7 @@ impl Pipeline {
                         protocol,
                         directive,
                         started,
+                        prompt_chars,
                     );
                     return Ok((info, Box::pin(tapped)));
                 }
@@ -694,6 +749,7 @@ fn tap_stream(
     protocol: String,
     directive: String,
     started: Instant,
+    prompt_chars: usize,
 ) -> impl futures::Stream<Item = Result<bytes::Bytes>> {
     use futures::StreamExt;
     async_stream::stream! {
@@ -703,12 +759,15 @@ fn tap_stream(
         let mut completion_tokens = 0u32;
         let mut got_usage = false;
         let mut delta_chars = 0usize;
+        let mut delta_chunks = 0u32;
         let mut errored: Option<String> = None;
 
         while let Some(item) = inner.next().await {
+            let mut done_marker = false;
             match &item {
                 Ok(bytes) => {
                     if let Ok(s) = std::str::from_utf8(bytes) {
+                        done_marker = s.contains("data: [DONE]");
                         buf.push_str(s);
                         while let Some(idx) = buf.find("\n\n") {
                             let evt: String = buf.drain(..idx + 2).collect();
@@ -737,6 +796,7 @@ fn tap_stream(
                                             v["choices"][0]["delta"]["content"].as_str()
                                         {
                                             delta_chars += c.chars().count();
+                                            delta_chunks += 1;
                                         }
                                     }
                                 }
@@ -746,12 +806,52 @@ fn tap_stream(
                 }
                 Err(e) => errored = Some(e.to_string()),
             }
+            // The local cortiq server (and some providers) never send a usage
+            // chunk. Clients still deserve token counts, so ahead of [DONE] we
+            // inject one final OpenAI-shaped usage event with the gateway's
+            // estimate (~4 chars/token), flagged `cortiq_estimated` so nobody
+            // mistakes it for the tokenizer's truth.
+            if done_marker {
+                // The initial X-Cortiq-Cost-USD header is always 0 — cost is
+                // only known after generation. Ship the final number (and the
+                // token estimate when the provider sent none) ahead of [DONE].
+                if !got_usage {
+                    prompt_tokens = (prompt_chars / 4) as u32;
+                    completion_tokens = if delta_chunks > 0 {
+                        delta_chunks
+                    } else {
+                        (delta_chars / 4) as u32
+                    };
+                }
+                let cost = provider.price(prompt_tokens, completion_tokens);
+                let mut evt = serde_json::json!({
+                    "object": "chat.completion.chunk",
+                    "model": info.selected_model,
+                    "choices": [],
+                    "cortiq_cost_usd": cost,
+                });
+                if !got_usage {
+                    evt["usage"] = serde_json::json!({
+                        "prompt_tokens": prompt_tokens,
+                        "completion_tokens": completion_tokens,
+                        "total_tokens": prompt_tokens + completion_tokens,
+                    });
+                    evt["cortiq_estimated"] = serde_json::json!(true);
+                    got_usage = true;
+                }
+                yield Ok(bytes::Bytes::from(format!("data: {evt}\n\n")));
+            }
             yield item;
         }
 
         if !got_usage && completion_tokens == 0 {
-            // estimate when the server didn't return usage (~4 chars per token)
-            completion_tokens = (delta_chars / 4) as u32;
+            // stream ended without a [DONE] marker — estimate for the stats
+            completion_tokens = if delta_chunks > 0 {
+                delta_chunks
+            } else {
+                (delta_chars / 4) as u32
+            };
+            prompt_tokens = (prompt_chars / 4) as u32;
         }
         let cost = provider.price(prompt_tokens, completion_tokens);
         stats.record(RequestRecord {

src/providers/anthropic.rs

@@ -32,7 +32,13 @@ impl AnthropicProvider {
             caps: Caps::from_list(&cfg.caps),
             price_in: cfg.price_in,
             price_out: cfg.price_out,
-            http: reqwest::Client::new(),
+            // connect timeout: a dead host fails over in seconds instead of
+            // hanging the request; NO overall timeout — that would cut long
+            // generations and streams (OpenRouter can be slow legitimately)
+            http: reqwest::Client::builder()
+                .connect_timeout(std::time::Duration::from_secs(10))
+                .build()
+                .unwrap_or_else(|_| reqwest::Client::new()),
         })
     }
 

src/providers/openai.rs

@@ -28,7 +28,13 @@ impl OpenAiProvider {
             caps: Caps::from_list(&cfg.caps),
             price_in: cfg.price_in,
             price_out: cfg.price_out,
-            http: reqwest::Client::new(),
+            // connect timeout: a dead host fails over in seconds instead of
+            // hanging the request; NO overall timeout — that would cut long
+            // generations and streams (OpenRouter can be slow legitimately)
+            http: reqwest::Client::builder()
+                .connect_timeout(std::time::Duration::from_secs(10))
+                .build()
+                .unwrap_or_else(|_| reqwest::Client::new()),
         })
     }
 
@@ -48,11 +54,13 @@ impl OpenAiProvider {
         if let Some(m) = req.params.max_tokens {
             body["max_tokens"] = m.into();
         }
+        eprintln!("[to_wire] think_budget={:?}", req.params.think_budget);
         if let Some(tb) = req.params.think_budget {
             body["think_budget"] = tb.into();
             body["reasoning_effort"] = tb.into();
             // cortiq serve uses enable_thinking (bool): 0 = off, >0 = on
             body["enable_thinking"] = (tb > 0).into();
+            eprintln!("[to_wire] SET enable_thinking={}", tb > 0);
         }
         if !req.tools.is_empty() {
             body["tools"] = serde_json::Value::Array(req.tools.clone());
@@ -61,6 +69,10 @@ impl OpenAiProvider {
         for (k, v) in &req.params.passthrough {
             body[k] = v.clone();
         }
+        eprintln!(
+            "[to_wire] enable_thinking={:?}",
+            body.get("enable_thinking")
+        );
         body
     }
 }

src/router_client.rs

@@ -71,6 +71,23 @@ impl RouterClient {
 
     /// Classify text. Returns `Ok(None)` on network error/timeout —
     /// the caller treats this as "router unavailable" and uses the default tier.
+    /// `GET /v1/taxonomies` — the account's taxonomies with their label sets.
+    /// `Ok(None)` when the router is disabled or has no key configured.
+    pub async fn taxonomies(&self) -> anyhow::Result<Option<serde_json::Value>> {
+        if self.url.is_empty() {
+            return Ok(None);
+        }
+        let mut req = self.http.get(format!("{}/v1/taxonomies", self.url));
+        if let Some(k) = &self.api_key {
+            req = req.bearer_auth(k);
+        }
+        let resp = req.send().await?;
+        if !resp.status().is_success() {
+            anyhow::bail!("router /v1/taxonomies: HTTP {}", resp.status());
+        }
+        Ok(Some(resp.json().await?))
+    }
+
     pub async fn route(&self, text: &str, profile: &str) -> anyhow::Result<Option<RouteDecision>> {
         let mut body = serde_json::json!({
             "input": { "text": text },

src/routing.rs

@@ -3,38 +3,117 @@
 
 use crate::config::{Config, TierTargets};
 
+fn to_list(t: &TierTargets) -> Vec<String> {
+    t.models()
+}
+
+/// A task rule, normalized: per-tier model lists ("which model serves this
+/// task at each complexity") plus any-tier models that lead regardless.
+#[derive(Clone, Default)]
+pub struct TaskRule {
+    pub any: Vec<String>,
+    pub per: std::collections::HashMap<String, Vec<String>>,
+}
+
 pub struct RoutingTable {
     tiers: std::collections::HashMap<String, Vec<String>>,
+    /// Per-task rules — a matching rule's models lead the candidate chain.
+    tasks: std::collections::HashMap<String, TaskRule>,
     default: String,
 }
 
 impl RoutingTable {
     pub fn from_config(cfg: &Config) -> Self {
-        let tiers = cfg
-            .routing
-            .tiers
-            .iter()
-            .map(|(tier, targets)| {
-                let list = match targets {
-                    TierTargets::List(v) => v.clone(),
-                    TierTargets::One(s) => vec![s.clone()],
-                };
-                (tier.clone(), list)
-            })
-            .collect();
         Self {
-            tiers,
+            tiers: cfg
+                .routing
+                .tiers
+                .iter()
+                .map(|(tier, targets)| (tier.clone(), to_list(targets)))
+                .collect(),
+            tasks: cfg
+                .routing
+                .tasks
+                .iter()
+                .map(|(task, targets)| {
+                    let (any, per) = targets.task_rule();
+                    (task.clone(), TaskRule { any, per })
+                })
+                .filter(|(_, r)| !r.any.is_empty() || r.per.values().any(|v| !v.is_empty()))
+                .collect(),
             default: cfg.routing.default.clone(),
         }
     }
 
+    /// Candidate chain for `(task, tier)` and whether a task rule shaped it.
+    ///
+    /// Order of preference:
+    ///   1. the task's models FOR THIS TIER (the user said exactly which model
+    ///      serves this task at this complexity);
+    ///   2. at tier=high — the global high chain (escalation: any-tier task
+    ///      models must not undercut it), then the task's any-tier models;
+    ///      otherwise the task's any-tier models, then the global tier chain;
+    ///   3. `default` as the last resort. Deduplicated, empties dropped.
+    pub fn candidates_for(&self, task: &str, tier: &str) -> (Vec<String>, bool) {
+        fn push(out: &mut Vec<String>, id: &str) {
+            if !id.is_empty() && !out.iter().any(|x| x == id) {
+                out.push(id.to_string());
+            }
+        }
+        let mut out: Vec<String> = Vec::new();
+        let rule = self.tasks.get(task);
+        let tier_chain = self
+            .tiers
+            .get(tier)
+            .cloned()
+            .unwrap_or_else(|| vec![self.default.clone()]);
+        if let Some(r) = rule {
+            if let Some(list) = r.per.get(tier) {
+                for id in list {
+                    push(&mut out, id);
+                }
+            }
+        }
+        let escalate = tier == "high" && self.tiers.contains_key("high");
+        if escalate {
+            // high verdicts escalate over any-tier task pins
+            for id in &tier_chain {
+                push(&mut out, id);
+            }
+            if let Some(r) = rule {
+                for id in &r.any {
+                    push(&mut out, id);
+                }
+            }
+        } else {
+            if let Some(r) = rule {
+                for id in &r.any {
+                    push(&mut out, id);
+                }
+            }
+            for id in &tier_chain {
+                push(&mut out, id);
+            }
+        }
+        let d = self.default.clone();
+        push(&mut out, &d);
+        // "task-rule" must mean "the rule chose the head of this chain" — a
+        // rule that exists but lost to the tier chain (math has a high pick,
+        // the request came in low) must not claim the credit.
+        let matched = match (rule, out.first()) {
+            (Some(r), Some(head)) => {
+                r.per.get(tier).map(|v| v.contains(head)).unwrap_or(false)
+                    || r.any.first() == Some(head)
+            }
+            _ => false,
+        };
+        (out, matched)
+    }
+
     /// Candidates for the given complexity tier, in preference order.
     /// If the tier is not defined, the sole candidate is `default`.
     pub fn candidates(&self, tier: &str) -> Vec<String> {
-        self.tiers
-            .get(tier)
-            .cloned()
-            .unwrap_or_else(|| vec![self.default.clone()])
+        self.candidates_for("", tier).0
     }
 
     /// Default model (used when the router is unavailable).
@@ -46,3 +125,119 @@ impl RoutingTable {
 // TODO(v0.2): cost_aware mode and circuit breaker — pick the cheapest available
 // model no lower than min_class[tier], respecting max_cost_usd_per_request,
 // and skip models whose circuit breaker is open.
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn table(tasks: &[(&str, &[&str])], tiers: &[(&str, &[&str])], default: &str) -> RoutingTable {
+        RoutingTable {
+            tiers: tiers
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.iter().map(|s| s.to_string()).collect()))
+                .collect(),
+            tasks: tasks
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        k.to_string(),
+                        TaskRule {
+                            any: v.iter().map(|s| s.to_string()).collect(),
+                            per: Default::default(),
+                        },
+                    )
+                })
+                .collect(),
+            default: default.to_string(),
+        }
+    }
+
+    fn with_task_tier_models(
+        mut t: RoutingTable,
+        task: &str,
+        tier: &str,
+        models: &[&str],
+    ) -> RoutingTable {
+        t.tasks.entry(task.to_string()).or_default().per.insert(
+            tier.to_string(),
+            models.iter().map(|s| s.to_string()).collect(),
+        );
+        t
+    }
+
+    #[test]
+    fn task_rule_leads_tier_chain_follows() {
+        let t = table(
+            &[("translation", &["local"])],
+            &[("low", &["cheap", "local"]), ("high", &["big"])],
+            "cheap",
+        );
+        // dedup: rule model already in the tier chain appears once, first
+        let (c, matched) = t.candidates_for("translation", "low");
+        assert!(matched);
+        assert_eq!(c, vec!["local", "cheap"]);
+    }
+
+    #[test]
+    fn high_tier_escalates_over_task_rule() {
+        let t = table(
+            &[("code", &["cheap-coder"])],
+            &[("low", &["cheap"]), ("high", &["big"])],
+            "cheap",
+        );
+        // medium (no chain defined → default): task rule still leads
+        let (c, m) = t.candidates_for("code", "medium");
+        assert!(m);
+        assert_eq!(c[0], "cheap-coder");
+        // high: tier chain leads, task rule follows as fallback
+        let (c, m) = t.candidates_for("code", "high");
+        // escalation put the global high chain first → the rule did not pick
+        // the head, so no task-rule credit
+        assert!(!m);
+        // default rides along as the very last fallback
+        assert_eq!(c, vec!["big", "cheap-coder", "cheap"]);
+    }
+
+    #[test]
+    fn per_tier_models_lead_their_tier() {
+        let base = table(
+            &[("code", &["generic-coder"])],
+            &[("low", &["cheap"]), ("high", &["big"])],
+            "cheap",
+        );
+        let t = with_task_tier_models(base, "code", "high", &["best-coder"]);
+        // at high: the task's HIGH pick leads, escalation chain next,
+        // any-tier task models after it, default last
+        let (c, m) = t.candidates_for("code", "high");
+        assert!(m);
+        assert_eq!(c, vec!["best-coder", "big", "generic-coder", "cheap"]);
+        // at low: any-tier task models lead as before (and the badge is
+        // honest — the head came from the rule)
+        let (c, m) = t.candidates_for("code", "low");
+        assert!(m);
+        assert_eq!(c, vec!["generic-coder", "cheap"]);
+        // a tier with an explicit pick but no any-models
+        let t2 = with_task_tier_models(
+            table(&[], &[("low", &["cheap"]), ("high", &["big"])], "cheap"),
+            "legal",
+            "high",
+            &["strong"],
+        );
+        let (c, m) = t2.candidates_for("legal", "high");
+        assert!(m);
+        assert_eq!(c, vec!["strong", "big", "cheap"]);
+        // the same rule at LOW did not shape the head → no task-rule credit
+        let (c, m) = t2.candidates_for("legal", "low");
+        assert!(!m);
+        assert_eq!(c, vec!["cheap"]);
+    }
+
+    #[test]
+    fn no_rule_falls_back_to_tier_then_default() {
+        let t = table(&[], &[("low", &["a"])], "d");
+        assert_eq!(t.candidates_for("qa", "low").0, vec!["a", "d"]);
+        let (c, matched) = t.candidates_for("qa", "unknown-tier");
+        assert!(!matched);
+        assert_eq!(c, vec!["d"]);
+    }
+}

src/state.rs

@@ -71,6 +71,17 @@ pub struct AppState {
     pub stats: Arc<Stats>,
     pub promotion: Arc<crate::promotion::Promotion>,
     pub imports: Arc<crate::import::JobStore>,
+    /// Image/video generation jobs (cortiq imagine / animate).
+    pub media: Arc<crate::media::MediaStore>,
+    /// One-click local model benchmarks (cortiq bench --json).
+    pub bench: Arc<crate::bench::BenchStore>,
+    /// Host metrics sampler (CPU / RAM / disk) for the dashboard.
+    pub sysmon: Arc<crate::sysmon::SysMon>,
+    /// Newest cortiq-gateway version on crates.io, when newer than ours.
+    pub gateway_update: Arc<std::sync::Mutex<Option<String>>>,
+    /// Admin console reachable from other machines without a token — the
+    /// footgun banner flag (set at startup, shown by the SPA).
+    pub admin_open_public: std::sync::atomic::AtomicBool,
     /// Managed local CMF model server (install/update/spawn lifecycle + status).
     pub cmf: Arc<crate::cmf_runtime::CmfRuntime>,
     pub cache: Arc<SemanticCache>,
@@ -113,6 +124,30 @@ impl SharedState {
         let stats = Stats::new(&cfg.stats);
         let promotion = crate::promotion::Promotion::new(promotion_cfg(&cfg.shadow));
         let imports = crate::import::JobStore::new();
+        let media = crate::media::MediaStore::new();
+        let bench = crate::bench::BenchStore::new();
+        // jobs survive restarts: files under <data>/, reconciled on load
+        let data = crate::config::data_dir();
+        let _ = std::fs::create_dir_all(&data);
+        imports.attach_persistence(data.join("jobs-import.json"));
+        media.attach_persistence(data.join("jobs-media.json"));
+        let sysmon = crate::sysmon::spawn(cfg.cmf.models_dir.clone());
+        let gateway_update: Arc<std::sync::Mutex<Option<String>>> =
+            Arc::new(std::sync::Mutex::new(None));
+        {
+            // check crates.io for a newer gateway once at start and twice a day
+            let slot = gateway_update.clone();
+            tokio::spawn(async move {
+                loop {
+                    if let Some(latest) = crate::cmf_runtime::latest_gateway_version().await {
+                        let newer =
+                            crate::cmf_runtime::version_lt(env!("CARGO_PKG_VERSION"), &latest);
+                        *slot.lock().unwrap() = newer.then_some(latest);
+                    }
+                    tokio::time::sleep(std::time::Duration::from_secs(12 * 3600)).await;
+                }
+            });
+        }
         let cmf = crate::cmf_runtime::CmfRuntime::new();
         let cache = SemanticCache::new(&cfg.cache);
         let router_status = RouterLastStatus::default();
@@ -122,6 +157,11 @@ impl SharedState {
             stats,
             promotion,
             imports,
+            media,
+            bench,
+            sysmon,
+            gateway_update,
+            admin_open_public: std::sync::atomic::AtomicBool::new(false),
             cmf,
             cache,
             secrets,

src/stats.rs

@@ -55,7 +55,7 @@ pub struct RequestRecord {
     pub error: Option<String>,
 }
 
-#[derive(Clone, Debug, Default, Serialize)]
+#[derive(Clone, Debug, Default, Serialize, serde::Deserialize)]
 pub struct Totals {
     pub requests: u64,
     pub ok: u64,
@@ -130,6 +130,15 @@ struct Inner {
     /// Per-minute buckets — the single source for the windowed admin snapshot.
     buckets: VecDeque<Bucket>,
     recent: VecDeque<RequestRecord>,
+    /// Per-account totals over EVERY record still in the JSONL file (no
+    /// retention gate) — per-key accounting for the keys page.
+    by_account_alltime: HashMap<String, Totals>,
+    /// Per-account totals folded out of the file by compaction. alltime(key)
+    /// = folded + by_account_alltime, with no double counting: a record is
+    /// either in the file or folded, never both.
+    folded: HashMap<String, Totals>,
+    /// Appends since the last compaction size check.
+    writes_since_check: u32,
 }
 
 pub struct Stats {
@@ -137,6 +146,7 @@ pub struct Stats {
     file: Option<String>,
     ring_size: usize,
     retention_secs: u64,
+    max_file_bytes: u64,
     inner: Mutex<Inner>,
 }
 
@@ -152,9 +162,12 @@ impl Stats {
             file,
             ring_size: cfg.ring_size.max(1),
             retention_secs: parse_duration_secs(&cfg.retention).unwrap_or(7 * 86_400),
+            max_file_bytes: cfg.max_file_mb.saturating_mul(1024 * 1024),
             inner: Mutex::new(Inner::default()),
         };
+        s.load_folded();
         s.replay();
+        s.maybe_compact(true);
         std::sync::Arc::new(s)
     }
 
@@ -175,6 +188,11 @@ impl Stats {
                 // push everything to the "recent" ring (it self-limits by size),
                 // but apply to aggregates/series only entries within the window.
                 Self::push_recent(&mut inner, &rec, self.ring_size);
+                inner
+                    .by_account_alltime
+                    .entry(rec.account.clone())
+                    .or_default()
+                    .apply(&rec);
                 if rec.ts >= cutoff {
                     Self::apply_aggregates(&mut inner, &rec, self.retention_secs);
                 }
@@ -233,6 +251,12 @@ impl Stats {
             let mut inner = self.inner.lock().unwrap();
             Self::apply_aggregates(&mut inner, &rec, self.retention_secs);
             Self::push_recent(&mut inner, &rec, self.ring_size);
+            inner
+                .by_account_alltime
+                .entry(rec.account.clone())
+                .or_default()
+                .apply(&rec);
+            inner.writes_since_check += 1;
         }
         if let Some(path) = &self.file {
             if let Ok(line) = serde_json::to_string(&rec) {
@@ -245,6 +269,112 @@ impl Stats {
                 }
             }
         }
+        self.maybe_compact(false);
+    }
+
+    fn totals_path(&self) -> Option<String> {
+        self.file.as_ref().map(|f| format!("{f}.totals.json"))
+    }
+
+    fn load_folded(&self) {
+        let Some(path) = self.totals_path() else {
+            return;
+        };
+        let Ok(content) = std::fs::read_to_string(&path) else {
+            return;
+        };
+        if let Ok(m) = serde_json::from_str::<HashMap<String, Totals>>(&content) {
+            self.inner.lock().unwrap().folded = m;
+        }
+    }
+
+    /// Keep the JSONL bounded: once it outgrows `max_file_bytes`, records
+    /// older than the retention window fold into the cumulative per-account
+    /// sidecar and are dropped from the file (tmp + rename on both files, so
+    /// a crash mid-compaction loses nothing). `force` checks size regardless
+    /// of the write counter (startup).
+    fn maybe_compact(&self, force: bool) {
+        if self.max_file_bytes == 0 {
+            return;
+        }
+        let Some(path) = &self.file else { return };
+        {
+            let mut inner = self.inner.lock().unwrap();
+            if !force {
+                if inner.writes_since_check < 256 {
+                    return;
+                }
+                inner.writes_since_check = 0;
+            }
+        }
+        let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
+        if size <= self.max_file_bytes {
+            return;
+        }
+        let Ok(content) = std::fs::read_to_string(path) else {
+            return;
+        };
+        let cutoff = now_secs().saturating_sub(self.retention_secs);
+        let mut kept = String::with_capacity(content.len() / 2);
+        let mut inner = self.inner.lock().unwrap();
+        for line in content.lines() {
+            let line = line.trim();
+            if line.is_empty() {
+                continue;
+            }
+            match serde_json::from_str::<RequestRecord>(line) {
+                Ok(rec) if rec.ts < cutoff => {
+                    inner
+                        .folded
+                        .entry(rec.account.clone())
+                        .or_default()
+                        .apply(&rec);
+                    // fold = leave by_account_alltime (record leaves the file,
+                    // its share moves from "alltime" into "folded")
+                    if let Some(t) = inner.by_account_alltime.get_mut(&rec.account) {
+                        // subtract by rebuilding is costly; instead track the
+                        // invariant additively: remove the record's share
+                        t.requests = t.requests.saturating_sub(1);
+                        if rec.outcome == "ok" {
+                            t.ok = t.ok.saturating_sub(1);
+                        } else {
+                            t.errors = t.errors.saturating_sub(1);
+                        }
+                        if rec.failover {
+                            t.failovers = t.failovers.saturating_sub(1);
+                        }
+                        t.prompt_tokens = t.prompt_tokens.saturating_sub(rec.prompt_tokens as u64);
+                        t.completion_tokens = t
+                            .completion_tokens
+                            .saturating_sub(rec.completion_tokens as u64);
+                        t.cost_usd = (t.cost_usd - rec.cost_usd).max(0.0);
+                        t.latency_ms_sum = t.latency_ms_sum.saturating_sub(rec.latency_ms);
+                    }
+                }
+                Ok(_) => {
+                    kept.push_str(line);
+                    kept.push('\n');
+                }
+                Err(_) => { /* unparseable line — drop */ }
+            }
+        }
+        // persist the folded totals FIRST, then swap the trimmed file in
+        if let Some(tpath) = self.totals_path() {
+            if let Ok(json) = serde_json::to_string(&inner.folded) {
+                let tmp = format!("{tpath}.tmp");
+                if std::fs::write(&tmp, json).is_ok() {
+                    let _ = std::fs::rename(&tmp, &tpath);
+                }
+            }
+        }
+        let tmp = format!("{path}.tmp");
+        if std::fs::write(&tmp, kept).is_ok() {
+            let _ = std::fs::rename(&tmp, path);
+        }
+        tracing::info!(
+            new_size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0),
+            "stats log compacted (older records folded into cumulative totals)"
+        );
     }
 
     /// Snapshot for the admin API: aggregates + time series for `range_secs` + breakdown by `groupby`.
@@ -303,7 +433,27 @@ impl Stats {
                 .cmp(&a["requests"].as_u64().unwrap_or(0))
         });
 
+        let mut alltime: HashMap<String, Totals> = inner.folded.clone();
+        for (k, t) in &inner.by_account_alltime {
+            alltime.entry(k.clone()).or_default().merge(t);
+        }
+        let alltime_by_account: serde_json::Map<String, serde_json::Value> = alltime
+            .iter()
+            .map(|(k, t)| {
+                (
+                    k.clone(),
+                    serde_json::json!({
+                        "requests": t.requests,
+                        "prompt_tokens": t.prompt_tokens,
+                        "completion_tokens": t.completion_tokens,
+                        "cost_usd": t.cost_usd,
+                    }),
+                )
+            })
+            .collect();
+
         serde_json::json!({
+            "alltime_by_account": alltime_by_account,
             "totals": {
                 "requests": win.requests,
                 "ok": win.ok,
@@ -327,6 +477,9 @@ impl Stats {
     /// Reset all in-memory stats and truncate the JSONL log — the "clear logs"
     /// admin action.
     pub fn clear(&self) {
+        if let Some(tpath) = self.totals_path() {
+            let _ = std::fs::remove_file(tpath);
+        }
         {
             let mut inner = self.inner.lock().unwrap();
             *inner = Inner::default();

src/sysmon.rs

@@ -0,0 +1,86 @@
+//! Host metrics sampler for the admin dashboard: CPU load, RAM, free disk at
+//! the models dir, and the gateway's own RSS. One background task refreshes a
+//! snapshot every 2 s; the API endpoint only reads it.
+
+use serde::Serialize;
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone, Default, Serialize)]
+pub struct Snapshot {
+    pub ts: u64,
+    /// Whole-machine CPU usage 0..100 (average over all cores).
+    pub cpu_percent: f32,
+    pub cores: usize,
+    pub load1: f64,
+    pub ram_total: u64,
+    pub ram_used: u64,
+    /// Disk that holds models_dir.
+    pub disk_total: u64,
+    pub disk_free: u64,
+    /// Resident memory of the gateway process itself.
+    pub process_rss: u64,
+}
+
+pub struct SysMon {
+    snap: Mutex<Snapshot>,
+}
+
+impl SysMon {
+    pub fn snapshot(&self) -> Snapshot {
+        self.snap.lock().unwrap().clone()
+    }
+}
+
+fn now() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+/// Start the sampler. `models_dir` picks which disk's free space is reported.
+pub fn spawn(models_dir: String) -> Arc<SysMon> {
+    let mon = Arc::new(SysMon {
+        snap: Mutex::new(Snapshot::default()),
+    });
+    let ret = mon.clone();
+    tokio::task::spawn_blocking(move || {
+        use sysinfo::{Disks, ProcessesToUpdate, System};
+        let mut sys = System::new();
+        let pid = sysinfo::Pid::from_u32(std::process::id());
+        let models_abs = std::fs::canonicalize(&models_dir)
+            .unwrap_or_else(|_| std::path::PathBuf::from(&models_dir));
+        loop {
+            sys.refresh_cpu_usage();
+            sys.refresh_memory();
+            let _ = sys.refresh_processes(ProcessesToUpdate::Some(&[pid]), true);
+            let disks = Disks::new_with_refreshed_list();
+            // the disk whose mount point is the longest prefix of models_dir
+            let mut best: Option<(usize, u64, u64)> = None;
+            for d in disks.list() {
+                let mp = d.mount_point();
+                if models_abs.starts_with(mp) {
+                    let len = mp.as_os_str().len();
+                    if best.map(|(l, _, _)| len > l).unwrap_or(true) {
+                        best = Some((len, d.total_space(), d.available_space()));
+                    }
+                }
+            }
+            let (disk_total, disk_free) = best.map(|(_, t, f)| (t, f)).unwrap_or((0, 0));
+            let snap = Snapshot {
+                ts: now(),
+                cpu_percent: sys.global_cpu_usage(),
+                cores: sys.cpus().len(),
+                load1: System::load_average().one,
+                ram_total: sys.total_memory(),
+                ram_used: sys.used_memory(),
+                disk_total,
+                disk_free,
+                process_rss: sys.process(pid).map(|p| p.memory()).unwrap_or(0),
+            };
+            *mon.snap.lock().unwrap() = snap;
+            std::thread::sleep(std::time::Duration::from_secs(2));
+        }
+    });
+    ret
+}

web/css/styles.css

@@ -561,6 +561,145 @@ body.modal-open { overflow: hidden; }
   .kpis { grid-template-columns: 1fr; }
 }
 
+/* ---- onboarding ------------------------------------------------------------ */
+.onb-shell { min-height: 100vh; display: flex; align-items: flex-start; justify-content: center; padding: 32px 20px; background: var(--bg-grad); }
+.onb-content { width: 100%; max-width: 860px; }
+.onb-wrap { max-width: 860px; margin: 0 auto; }
+.onb-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 18px; }
+.onb-dots { display: flex; gap: 8px; }
+.onb-dots .dot { width: 28px; height: 6px; border-radius: 999px; background: var(--border); }
+.onb-dots .dot.on { background: var(--accent); }
+.onb-dots .dot.done { background: color-mix(in srgb, var(--accent) 55%, transparent); }
+.onb-title { font-size: 12px; font-weight: 700; color: var(--muted); letter-spacing: 0.04em; text-transform: uppercase; }
+.onb-step h2 { font-size: 22px; margin-bottom: 6px; }
+.onb-langs { display: grid; grid-template-columns: repeat(auto-fill, minmax(132px, 1fr)); gap: 12px; margin: 18px 0; }
+.onb-lang {
+  display: flex; flex-direction: column; align-items: center; gap: 10px;
+  padding: 18px 10px; border-radius: 14px; border: 1.5px solid var(--border);
+  background: var(--card); cursor: pointer; transition: .15s; font-family: inherit;
+}
+.onb-lang:hover { border-color: color-mix(in srgb, var(--accent) 45%, transparent); transform: translateY(-1px); }
+.onb-lang.sel { border-color: var(--accent); background: color-mix(in srgb, var(--accent) 10%, var(--card)); box-shadow: 0 6px 18px rgba(99,102,241,.18); }
+.onb-lang .flag { font-size: 32px; line-height: 1; }
+.onb-lang b { font-size: 14px; font-weight: 700; color: var(--text); }
+/* Featured gallery: the list grows as new models are published, so give it more
+   room than the search grid before it starts scrolling. */
+.featured-section .hf-grid { max-height: min(62vh, 760px); }
+/* Money: 4 decimals, last two de-emphasized */
+.money-tail { font-size: .72em; opacity: .75; margin-left: 1px; }
+
+.seg { flex-wrap: wrap; }
+
+.ok { color: var(--good); }
+
+.pairs { display: flex; flex-direction: column; gap: 6px; align-items: flex-start; }
+.pair-row { display: flex; gap: 6px; align-items: center; }
+.pair-model { min-width: 220px; max-width: 340px; padding: 4px 8px; font-size: 12.5px; }
+.pair-tier { max-width: 150px; padding: 4px 8px; font-size: 12.5px; }
+
+/* Complexity bands slider */
+.bands-wrap { margin: 4px 0 16px; }
+.bands-track { position: relative; height: 14px; border-radius: 8px; background: var(--panel-2, #23252c); margin: 26px 8px 10px; }
+.bands-track.disabled { opacity: .45; pointer-events: none; }
+.bands-zone { position: absolute; top: 0; bottom: 0; }
+.bands-zone.z-low { left: 0; background: color-mix(in srgb, var(--good) 45%, transparent); border-radius: 8px 0 0 8px; }
+.bands-zone.z-med { background: color-mix(in srgb, var(--warn, #f59e0b) 55%, transparent); }
+.bands-zone.z-high { background: color-mix(in srgb, #dc2626 65%, transparent); border-radius: 0 8px 8px 0; }
+.bands-handle { position: absolute; top: -5px; width: 24px; height: 24px; margin-left: -12px; border-radius: 50%;
+  background: var(--fg, #fff); border: 3px solid var(--accent, #6c6cf5); cursor: grab; touch-action: none; z-index: 2; }
+.bands-handle:active { cursor: grabbing; }
+.bands-val { position: absolute; top: -24px; left: 50%; transform: translateX(-50%); font-size: 11.5px;
+  font-family: var(--mono, monospace); color: var(--fg); background: var(--panel, #1b1d23); padding: 1px 6px;
+  border-radius: 6px; border: 1px solid var(--border, #333); white-space: nowrap; }
+.bands-val.raised { top: -46px; }
+.bands-legend { display: flex; gap: 8px; margin: 6px 8px 0; flex-wrap: wrap; }
+
+/* Benchmark view */
+@keyframes bm-in { from { opacity: 0; transform: translateY(-3px); } to { opacity: 1; transform: none; } }
+tbody tr:last-child { animation: bm-in .25s ease; }
+.bm-sum { margin-bottom: 10px; }
+.bm-cell { cursor: pointer; white-space: nowrap; }
+.bm-cell:hover { background: var(--hover); }
+.badge.ok { background: rgba(52,211,153,.15); color: var(--good); }
+
+/* Routing: per-task rule rows */
+.taskrow { align-items: flex-start; }
+.taskname { min-width: 190px; line-height: 1.35; }
+.taskname .mono { font-size: 10.5px; opacity: .75; }
+.chips-empty { padding: 4px 0; font-style: italic; }
+
+/* Shell notices (open admin warning, update available) */
+.notice {
+  display: flex; align-items: center; gap: 8px;
+  padding: 8px 18px; font-size: 13px;
+  border-bottom: 1px solid var(--border-soft, #232833);
+}
+.notice.warn { background: color-mix(in srgb, #e5a54b 12%, var(--bg)); }
+.notice.info { background: color-mix(in srgb, var(--accent) 10%, var(--bg)); }
+.notice .icon-btn { margin-left: auto; }
+
+/* Dashboard host metrics */
+.sysgrid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 16px; }
+.sysitem .k { color: var(--muted); font-size: 12px; }
+.sysitem .v { font-weight: 600; }
+.sysbar {
+  height: 8px; border-radius: 6px; overflow: hidden; margin: 6px 0;
+  background: var(--bg-2, #12151c); border: 1px solid var(--border, #2a2f3a);
+}
+.sysbar i { display: block; height: 100%; background: var(--accent, #5b8def); }
+.sysbar i.bad { background: #e5534b; }
+
+/* Log viewer */
+.logs-view { max-height: 68vh; }
+
+/* Chat dialogue bubbles */
+.chat-log { max-height: 56vh; overflow-y: auto; display: flex; flex-direction: column; gap: 8px; }
+.chat-msg { display: flex; }
+.chat-msg.user { justify-content: flex-end; }
+.chat-bubble {
+  max-width: 85%; padding: 8px 12px; border-radius: 12px;
+  white-space: pre-wrap; word-break: break-word; font-size: 13.5px;
+  background: var(--bg-2, #12151c); border: 1px solid var(--border-soft, #232833);
+}
+.chat-msg.user .chat-bubble {
+  background: color-mix(in srgb, var(--accent) 16%, var(--bg-2));
+  border-color: color-mix(in srgb, var(--accent) 35%, transparent);
+}
+
+/* Generation gallery */
+.gal-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(110px, 1fr)); gap: 8px; }
+.gal-item {
+  position: relative; cursor: pointer; border: 1px solid var(--border, #2a2f3a);
+  border-radius: 8px; overflow: hidden; background: var(--bg-2, #12151c);
+}
+.gal-item:hover { border-color: var(--accent, #5b8def); }
+.gal-thumb { width: 100%; display: block; min-height: 64px; }
+.gal-video { display: flex; align-items: center; justify-content: center; font-size: 28px; height: 72px; }
+.gal-cap { font-size: 10px; color: var(--muted); padding: 3px 6px; }
+.gal-del {
+  position: absolute; top: 2px; right: 2px; z-index: 2;
+  border: 0; border-radius: 50%; width: 18px; height: 18px; line-height: 16px;
+  background: rgba(0,0,0,.55); color: #fff; cursor: pointer; font-size: 12px;
+}
+
+/* Bench + badges */
+.bench-row { gap: 10px; padding: 6px 0; border-top: 1px solid var(--border-soft, #232833); }
+.bench-row:first-of-type { border-top: 0; }
+.badge.warn { background: rgba(229,165,75,.15); color: #e5a54b; }
+.snippet { max-height: 260px; }
+
+/* Playground media tabs: generated image / video frame */
+.media-out { display: flex; flex-direction: column; gap: 8px; }
+.media-canvas {
+  max-width: 100%; height: auto; border-radius: 8px;
+  border: 1px solid var(--border, #2a2f3a); background: #000;
+}
+/* Live download progress inside a featured card (empty until a job runs) */
+.card-prog:empty { display: none; }
+.card-prog { margin-top: 6px; }
+.card-prog .pbar { margin: 4px 0; }
+.card-prog .btn.sm { padding: 0 6px; line-height: 18px; }
+
 @media (prefers-reduced-motion: reduce) {
   .sidebar, .mobile-nav-backdrop { transition: none; }
 }

web/js/api.js

@@ -19,7 +19,10 @@ export function setToken(tok) {
 }
 
 async function j(method, path, body) {
-  const opt = { method, headers: { Authorization: "Bearer " + getToken() } };
+  const tok = getToken();
+  const headers = {};
+  if (tok) headers["Authorization"] = "Bearer " + tok;
+  const opt = { method, headers };
   if (body !== undefined) {
     opt.headers["content-type"] = "application/json";
     opt.body = JSON.stringify(body);
@@ -65,10 +68,12 @@ export const api = {
 
   // routing
   getRouting: () => j("GET", "/routing"),
+  routingLabels: () => j("GET", "/routing/labels"),
   putRouting: (b) => j("PUT", "/routing", b),
 
   // protocols
   getProtocols: () => j("GET", "/protocols"),
+  harnesses: () => j("GET", "/harnesses"),
   putProtocols: (b) => j("PUT", "/protocols", b),
 
   // settings
@@ -114,14 +119,63 @@ export const api = {
   deleteImport: (job) => j("DELETE", "/import/" + encodeURIComponent(job)),
   registerImport: (job) =>
     j("POST", "/import/" + encodeURIComponent(job) + "/register"),
+
+  // media generation (cortiq imagine / animate over local .cmf)
+  mediaModels: () => j("GET", "/media/models"),
+  mediaGenerate: (b) => j("POST", "/media", b),
+  mediaJobs: () => j("GET", "/media"),
+  mediaJob: (id) => j("GET", "/media/" + encodeURIComponent(id)),
+  mediaCancel: (id) => j("POST", "/media/" + encodeURIComponent(id) + "/cancel"),
+  mediaDelete: (id) => j("DELETE", "/media/" + encodeURIComponent(id)),
+
+  // system / logs / lifecycle
+  system: () => j("GET", "/system"),
+  logs: (limit = 300) => j("GET", "/logs?limit=" + limit),
+  clearLogs: () => j("DELETE", "/logs"),
+  restart: () => j("POST", "/restart"),
+  benchStart: (model) => j("POST", "/bench", { model }),
+  benchList: () => j("GET", "/bench"),
+
+  // first-run onboarding
+  setupStatus: () => j("GET", "/setup/status"),
+  // Connects every finished download as a local model unless register === false.
+  setupComplete: (lang, register) => j("POST", "/setup/complete", { lang, register }),
+  setupFeatured: () => j("GET", "/setup/featured"),
+  // `name` is the exact output stem from setup/featured — it wins over the
+  // repo/variant guess so the delete always hits the file the download wrote.
+  deleteSetupFile: (repo, variant, name) =>
+    j(
+      "DELETE",
+      `/setup/file?repo=${encodeURIComponent(repo)}` +
+        (variant ? `&variant=${encodeURIComponent(variant)}` : "") +
+        (name ? `&name=${encodeURIComponent(name)}` : "")
+    ),
 };
 
+// Raw-body POST (no JSON encoding) — the config import takes TOML text as-is.
+export async function postRaw(path, text) {
+  const tok = getToken();
+  const headers = { "content-type": "application/toml" };
+  if (tok) headers["Authorization"] = "Bearer " + tok;
+  const r = await fetch(BASE + path, { method: "POST", headers, body: text });
+  const body = await r.text();
+  if (!r.ok) {
+    let msg = body;
+    try { msg = JSON.parse(body).error?.message || body; } catch { /* raw */ }
+    throw new Error(msg || r.statusText);
+  }
+  return body ? JSON.parse(body) : null;
+}
+
 // Streaming playground: POST /test/stream, calls onDelta(text) per content chunk,
 // returns the routing decision read from X-Cortiq-* response headers.
 export async function testStream(body, onDelta) {
+  const tok = getToken();
+  const headers = { "content-type": "application/json" };
+  if (tok) headers["Authorization"] = "Bearer " + tok;
   const r = await fetch(BASE + "/test/stream", {
     method: "POST",
-    headers: { Authorization: "Bearer " + getToken(), "content-type": "application/json" },
+    headers,
     body: JSON.stringify(body),
   });
   if (r.status === 401) {
@@ -134,6 +188,11 @@ export async function testStream(body, onDelta) {
   const reader = r.body.getReader();
   const dec = new TextDecoder();
   let buf = "";
+  const t0 = performance.now();
+  let ttftMs = null; // time to first content token
+  let usage = null; // OpenAI-style final-chunk usage, when the provider sends it
+  let usageEstimated = false; // gateway-injected estimate rather than tokenizer truth
+  let costUsd = null; // final cost from the gateway's closing event (headers carry 0)
   for (;;) {
     const { done, value } = await reader.read();
     if (done) break;
@@ -146,8 +205,17 @@ export async function testStream(body, onDelta) {
       const data = line.slice(5).trim();
       if (!data || data === "[DONE]") continue;
       try {
-        const d = JSON.parse(data).choices?.[0]?.delta?.content;
-        if (d) onDelta(d);
+        const chunk = JSON.parse(data);
+        if (chunk.usage) {
+          usage = chunk.usage;
+          usageEstimated = !!chunk.cortiq_estimated;
+        }
+        if (chunk.cortiq_cost_usd != null) costUsd = chunk.cortiq_cost_usd;
+        const d = chunk.choices?.[0]?.delta?.content;
+        if (d) {
+          if (ttftMs == null) ttftMs = Math.round(performance.now() - t0);
+          onDelta(d);
+        }
       } catch {
         /* ignore malformed chunk */
       }
@@ -160,6 +228,31 @@ export async function testStream(body, onDelta) {
     score: parseFloat(h.get("x-cortiq-complexity-score") || "0"),
     selected_model: h.get("x-cortiq-selected-model") || "",
     route_source: h.get("x-cortiq-route-source") || "",
-    cost_usd: parseFloat(h.get("x-cortiq-cost-usd") || "0"),
+    cost_usd: costUsd != null ? costUsd : parseFloat(h.get("x-cortiq-cost-usd") || "0"),
+    usage,
+    usage_estimated: usageEstimated,
+    ttft_ms: ttftMs,
   };
 }
+
+// Fetch a media job's output with the admin token and hand back an object URL
+// (plain <img src>/<video src> cannot carry the Authorization header).
+export async function mediaFileUrl(job, kind) {
+  const tok = getToken();
+  const headers = {};
+  if (tok) headers["Authorization"] = "Bearer " + tok;
+  const r = await fetch(`${BASE}/media/${encodeURIComponent(job)}/file/${encodeURIComponent(kind)}`, { headers });
+  if (!r.ok) throw new Error((await r.text()) || r.statusText);
+  return { url: URL.createObjectURL(await r.blob()), size: +(r.headers.get("content-length") || 0) };
+}
+
+// Same fetch, raw bytes — for outputs the browser cannot display natively
+// (P6 PPM, MJPEG AVI) that we decode in JS.
+export async function mediaFileBytes(job, kind) {
+  const tok = getToken();
+  const headers = {};
+  if (tok) headers["Authorization"] = "Bearer " + tok;
+  const r = await fetch(`${BASE}/media/${encodeURIComponent(job)}/file/${encodeURIComponent(kind)}`, { headers });
+  if (!r.ok) throw new Error((await r.text()) || r.statusText);
+  return r.arrayBuffer();
+}

web/js/app.js

@@ -11,6 +11,9 @@ import { renderProtocols } from "./views/protocols.js";
 import { renderKeys } from "./views/keys.js";
 import { renderPlayground } from "./views/playground.js";
 import { renderSettings } from "./views/settings.js";
+import { renderLogs } from "./views/logs.js";
+import { renderBenchmark } from "./views/benchmark.js";
+import { renderOnboarding } from "./views/onboarding.js";
 
 const ROUTES = [
   { id: "dashboard", icon: "▤", view: renderDashboard },
@@ -20,7 +23,10 @@ const ROUTES = [
   { id: "protocols", icon: "⇆", view: renderProtocols },
   { id: "keys", icon: "🔑", view: renderKeys },
   { id: "playground", icon: "✦", view: renderPlayground },
+  { id: "benchmark", icon: "⏱", view: renderBenchmark },
+  { id: "logs", icon: "📜", view: renderLogs },
   { id: "settings", icon: "⚙", view: renderSettings },
+  { id: "onboarding", icon: "✦", view: renderOnboarding, hidden: true },
 ];
 
 export const appState = { meta: null, health: null, version: "" };
@@ -50,7 +56,29 @@ const FAVICON =
     '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="%233b82f6"/><stop offset=".5" stop-color="%238b5cf6"/><stop offset="1" stop-color="%2306b6d4"/></linearGradient></defs><rect width="32" height="32" rx="8" fill="url(%23g)"/><path d="M9 16h14M17 10l6 6-6 6" stroke="white" stroke-width="2.4" fill="none" stroke-linecap="round" stroke-linejoin="round"/></svg>'
   );
 
+// One-line banners under the topbar: open-admin warning, update available.
+function shellNotices() {
+  const host = h("div", {});
+  const m = appState.meta || {};
+  if (m.admin_open_public && !sessionStorage.getItem("hide_open_admin")) {
+    const close = h("button", { class: "icon-btn", title: "×", onClick: (e) => { sessionStorage.setItem("hide_open_admin", "1"); e.target.closest(".notice").remove(); } }, "×");
+    host.appendChild(
+      h("div", { class: "notice warn" }, "⚠ " + t("notice.openAdmin"), " ",
+        h("a", { href: "#/settings" }, t("nav.settings") + " →"), close)
+    );
+  }
+  if (m.update_available) {
+    host.appendChild(
+      h("div", { class: "notice info" },
+        "⬆ " + t("notice.update", { v: m.update_available }),
+        " ", h("code", { class: "mono" }, "cargo install cortiq-gateway"))
+    );
+  }
+  return host;
+}
+
 function sidebar(activeId) {
+  const visibleRoutes = ROUTES.filter((r) => !r.hidden);
   return h(
     "aside",
     { class: "sidebar", id: "sidebar", "aria-label": "Main navigation" },
@@ -61,7 +89,7 @@ function sidebar(activeId) {
       h("div", { class: "brand-copy" }, h("b", {}, "allaigate"), h("div", { class: "sub" }, t("brand.sub"))),
       h("button", { class: "icon-btn nav-close", type: "button", title: "Close menu", "aria-label": "Close menu", onClick: () => setMobileNav(false) }, "×")
     ),
-    ...ROUTES.map((r) =>
+    ...visibleRoutes.map((r) =>
       h(
         "a",
         { class: "nav-item" + (r.id === activeId ? " active" : ""), href: "#/" + r.id, onClick: () => setMobileNav(false) },
@@ -121,7 +149,7 @@ function langSelect() {
       title: "Language",
       onChange: (e) => setLang(e.target.value),
     },
-    ...LANGS.map((l) => h("option", { value: l.code, selected: l.code === getLang() }, l.label))
+    ...LANGS.map((l) => h("option", { value: l.code, selected: l.code === getLang() }, `${l.flag} ${l.label}`))
   );
   return sel;
 }
@@ -202,6 +230,15 @@ function renderShell() {
   const route = currentRoute();
   mobileNavOpen = false;
   document.body.classList.remove("mobile-nav-open");
+  // onboarding — full screen without sidebar/topbar
+  if (route.id === "onboarding") {
+    mount(
+      document.getElementById("app"),
+      h("div", { class: "onb-shell" }, h("div", { class: "onb-content", id: "view" }))
+    );
+    renderView();
+    return;
+  }
   mount(
     document.getElementById("app"),
     h(
@@ -209,7 +246,7 @@ function renderShell() {
       { class: "app" },
       sidebar(route.id),
       h("button", { class: "mobile-nav-backdrop", type: "button", tabindex: "-1", "aria-label": "Close menu", onClick: () => setMobileNav(false) }),
-      h("main", { class: "main" }, topbar(route.id), h("div", { class: "content", id: "view" }))
+      h("main", { class: "main" }, topbar(route.id), shellNotices(), h("div", { class: "content", id: "view" }))
     )
   );
   renderView();
@@ -219,12 +256,30 @@ function showLogin() {
   mount(document.getElementById("app"), renderLogin(boot));
 }
 
+let staleNotified = false;
+async function checkUiFresh() {
+  // the SPA lives in the tab until reload; if the gateway restarted (dev
+  // rebuild, update, config restart) the embedded UI may have changed —
+  // tell the user instead of letting them stare at stale views
+  try {
+    const m = await api.meta();
+    if (appState.meta?.started && m.started && m.started !== appState.meta.started && !staleNotified) {
+      staleNotified = true;
+      const bar = h("div", { class: "callout warn", style: "position:fixed; left:50%; transform:translateX(-50%); bottom:18px; z-index:99; box-shadow:0 8px 24px rgba(0,0,0,.35)" },
+        h("span", {}, "🔄 " + t("shell.uiStale")), " ",
+        h("button", { class: "btn sm primary", onClick: () => location.reload() }, t("shell.reload")));
+      document.body.append(bar);
+    }
+  } catch {}
+}
+
 async function refreshHealth() {
   try {
     appState.health = await api.health();
   } catch {
     appState.health = null;
   }
+  checkUiFresh();
   // re-render topbar only if shell present
   const route = currentRoute();
   const main = document.querySelector(".main");
@@ -241,20 +296,34 @@ export async function boot() {
     setToken(urlTok);
     history.replaceState({}, "", location.pathname + location.hash);
   }
-  if (!getToken()) {
-    showLogin();
-    return;
-  }
+  // try without token first — open mode (no CORTIQ_ADMIN_TOKEN) succeeds,
+  // protected mode returns 401 and we show login
   try {
     appState.meta = await api.meta();
     appState.version = appState.meta.version || "";
   } catch (e) {
     if (String(e.message) === "unauthorized") {
+      // if we have no token stored, show login; with a stale token also show login
       showLogin();
       return;
     }
     // gateway reachable but error — still show shell
+    // if meta failed for other reason but token was present, fall through
+    if (!getToken()) {
+      // open mode but gateway unreachable — still try shell; health will show
+      try {
+        appState.meta = await api.meta();
+        appState.version = appState.meta.version || "";
+      } catch {}
+    }
   }
+  // first-run check — redirect to onboarding if needed (unless already there)
+  try {
+    const st = await api.setupStatus();
+    if (st.needs_setup && location.hash !== "#/onboarding") {
+      location.hash = "#/onboarding";
+    }
+  } catch {}
   if (!location.hash) location.hash = "#/dashboard";
   renderShell();
   refreshHealth();

web/js/i18n.js

@@ -10,13 +10,13 @@ import tr from "./i18n/tr.js";
 
 const DICTS = { en, ru, de, fr, es, zh, tr };
 export const LANGS = [
-  { code: "en", label: "English" },
-  { code: "ru", label: "Русский" },
-  { code: "de", label: "Deutsch" },
-  { code: "fr", label: "Français" },
-  { code: "es", label: "Español" },
-  { code: "zh", label: "中文" },
-  { code: "tr", label: "Türkçe" },
+  { code: "en", label: "English", flag: "🇬🇧" },
+  { code: "ru", label: "Русский", flag: "🇷🇺" },
+  { code: "de", label: "Deutsch", flag: "🇩🇪" },
+  { code: "fr", label: "Français", flag: "🇫🇷" },
+  { code: "es", label: "Español", flag: "🇪🇸" },
+  { code: "zh", label: "中文", flag: "🇨🇳" },
+  { code: "tr", label: "Türkçe", flag: "🇹🇷" },
 ];
 
 const listeners = new Set();
@@ -48,6 +48,11 @@ export function onLangChange(fn) {
   return () => listeners.delete(fn);
 }
 
+// Human name for a complexity tier; custom tier names pass through as-is.
+export function trTier(tier) {
+  return ["low", "medium", "high"].includes(tier) ? t("tier." + tier) : tier;
+}
+
 export function t(key, vars) {
   const d = DICTS[lang] || en;
   let s = d[key] ?? en[key] ?? key;

web/js/i18n/de.js

@@ -30,7 +30,7 @@ export default {
   "nav.routing": "Routing",
   "nav.protocols": "Protokolle",
   "nav.keys": "API-Schlüssel",
-  "nav.playground": "Playground",
+  "nav.playground": "Testbereich",
   "nav.settings": "Einstellungen",
   "nav.foot": "Gateway · v{v}",
   "nav.billing": "Router-Key & Abrechnung",
@@ -76,7 +76,7 @@ export default {
   "dash.groupby.label": "nach Aufgabe",
   "dash.groupby.account": "nach Account",
   "dash.recent.title": "Letzte Anfragen",
-  "dash.recent.empty": "Noch keine Anfragen aufgezeichnet. Playground ausprobieren.",
+  "dash.recent.empty": "Noch keine Anfragen aufgezeichnet. Testbereich ausprobieren.",
   "dash.col.time": "Zeit",
   "dash.col.model": "Modell",
   "dash.col.tier": "Tier",
@@ -189,7 +189,7 @@ export default {
   "keys.allowAll": "alle",
 
   // playground
-  "pg.title": "Playground",
+  "pg.title": "Testbereich",
   "pg.subtitle": "Prompt durch die Live-Pipeline senden und Routing-Entscheidung prüfen.",
   "pg.system": "System-Prompt",
   "pg.systemPlaceholder": "optionale Systemnachricht",
@@ -280,4 +280,358 @@ export default {
   "settings.cache.ttl": "Eintrags-TTL",
   "settings.cache.embed": "Embedding-Modell",
   "settings.cache.note": "Cache-Einstellungen werden nach einem Neustart wirksam.",
+
+  // ── translated from en.js (previously falling back to English) ──
+  // nav
+  "nav.import": "Modell importieren",
+
+  // dash
+  "dash.clear": "Logs leeren",
+  "dash.clearConfirm": "Alle erfassten Statistiken und Logs löschen? Das lässt sich nicht rückgängig machen.",
+  "dash.cleared": "Logs geleert",
+
+  // models
+  "models.form.idOrModel": "Gib eine ID oder einen Modellnamen ein",
+  "models.form.apiKey": "API-Schlüssel",
+  "models.form.apiKeyPlaceholder": "API-Schlüssel einfügen",
+  "models.form.apiKeyNotNeeded": "nicht erforderlich (lokaler Server)",
+  "models.form.apiKeyHint": "Wird sicher im Gateway gespeichert und nicht erneut angezeigt.",
+  "models.form.keyStored": "Ein Schlüssel ist gespeichert — leer lassen, um ihn zu behalten, oder einen neuen einfügen.",
+  "models.form.keyFromEnv": "Es wird ein Schlüssel aus einer Umgebungsvariable verwendet.",
+  "models.form.paramsTitle": "Generierungs- und Denkparameter (O(1), MTP, Temperatur)",
+  "models.form.temperature": "Temperatur",
+  "models.form.temperatureHint": "Generierungstemperatur (0.0 = deterministisch, 1.0+ = kreativ).",
+  "models.form.topP": "Top-P (Nucleus Sampling)",
+  "models.form.topPHint": "Sampling-Schwelle (0.0 .. 1.0).",
+  "models.form.maxTokens": "Max. Tokens",
+  "models.form.maxTokensHint": "Maximale Anzahl generierter Tokens.",
+  "models.form.thinkBudget": "Denkmodus / Think Budget",
+  "models.form.thinkBudgetHint": "Token-Budget fürs Nachdenken (0 = aus, N > 0 = max. Reasoning-Tokens).",
+  "models.form.systemPrompt": "Standard-System-Prompt",
+  "models.form.systemPromptHint": "Wird automatisch vorangestellt, wenn die Anfrage keinen System-Prompt enthält.",
+  "models.form.systemPromptPlaceholder": "Du bist ein hilfreicher Assistent…",
+  "models.form.testKey": "Testen & Modelle laden",
+  "models.form.testing": "wird geprüft…",
+  "models.form.foundModels": "{n} Modelle geladen",
+  "models.form.modelPlaceholder": "tippen zum Suchen…",
+  "models.form.modelHint": "Klicke „Testen & Modelle laden“, um die Liste mit deinem Schlüssel abzurufen, und wähle dann eines aus.",
+  "models.managed": "verwaltet",
+  "models.managedHint": "Wird vom verwalteten CMF-Server bereitgestellt (Einstellungen → Lokale Modelle). Dort konfigurieren.",
+
+  // settings
+  "settings.router.enabled": "Router verwenden (aus = nur lokale Modelle)",
+  "settings.cmf": "Lokale Modelle (CMF)",
+  "settings.cmf.localOnly": "Nur lokale Modelle verwenden",
+  "settings.cmf.manage": "Lokalen Modellserver starten",
+  "settings.cmf.autoInstall": "cortiq automatisch installieren (crates.io)",
+  "settings.cmf.autoUpdate": "cortiq automatisch aktualisieren",
+  "settings.cmf.model": "Pfad zum lokalen .cmf-Modell",
+  "settings.cmf.port": "Port des lokalen Servers",
+  "settings.cmf.modelId": "Modell-ID im Pool",
+  "settings.cmf.note": "Stellt ein lokales .cmf über cortiq bereit (github.com/infosave2007/cmf). Funktioniert auch, wenn der Router nicht erreichbar ist.",
+  "settings.cmf.threads": "Worker-Threads",
+  "settings.cmf.gpu": "GPU verwenden (Metal / wgpu)",
+  "settings.cmf.speedNote": "Threads parallelisieren die Decode-Matvecs (~3× schneller; 0 = Standard der Runtime). GPU-Offload hilft vor allem beim Prefill langer Prompts — das Decoding ist speicherbandbreitenbegrenzt und daher auf Apple Silicon ungefähr neutral.",
+  "settings.cmf.pick": "Modell auswählen",
+  "settings.cmf.models": "Lokale Modelle",
+  "settings.cmf.modelsHelp": "Jede Zeile ist ein Modell, das das Gateway ausführt (eigenes cortiq serve auf eigenem Port) und im Pool registriert. Füge so viele hinzu, wie du .cmf-Dateien und freie Ports hast.",
+  "settings.cmf.rowHint": "ID · .cmf-Datei · Port · Threads · GPU. Änderungen greifen nach einem Neustart; das Löschen einer Zeile stoppt diesen Server.",
+  "settings.cmf.addServer": "+ Lokales Modell hinzufügen",
+  "settings.cmf.checkPort": "Port prüfen",
+  "settings.cmf.portFree": "Port ist frei",
+  "settings.cmf.portBusy": "Port ist belegt",
+  "settings.cmf.useSuggested": "{port} verwenden",
+  "settings.cmf.serving": "{model} läuft auf :{port}",
+  "settings.cmf.intro": "Modelle lokal mit der cortiq-Engine ausführen — funktioniert auch offline oder wenn der Router ausfällt.",
+  "settings.cmf.runtime": "cortiq-Runtime",
+  "settings.cmf.runtimeHelp": "Das Kommandozeilenwerkzeug `cortiq`, das .cmf-Modelle lädt und ausführt. Einmal installieren, bevor du einen lokalen Server startest.",
+  "settings.cmf.install": "cortiq installieren",
+  "settings.cmf.reinstall": "Neu installieren / aktualisieren",
+  "settings.cmf.installing": "wird installiert… (kompiliert, einige Minuten)",
+  "settings.cmf.installedOk": "cortiq installiert",
+  "settings.cmf.notInstalled": "nicht installiert",
+  "settings.cmf.addModel": "Modell hinzufügen",
+  "settings.cmf.addModelHelp": "Modelle werden im Tab „Modell importieren“ heruntergeladen und konvertiert (HuggingFace → .cmf). Richte den lokalen Server danach unten auf die .cmf-Datei aus.",
+  "settings.cmf.importNote": "Noch kein Modell? Importiere eines:",
+  "settings.cmf.importLink": "Import öffnen",
+  "settings.cmf.modelHelp": "Pfad zur .cmf-Datei, die bereitgestellt werden soll (z. B. models/qwen.cmf), erzeugt im Import-Tab. Mehrere Modelle für verschiedene Aufgaben? Importiere sie und wechsle diesen Pfad.",
+  "settings.cmf.portHelp": "TCP-Port, auf dem der lokale Modellserver lauscht (Standard 8081). Nur ändern, wenn er mit einem anderen Dienst kollidiert.",
+  "settings.cmf.threadsHelp": "Wie viele CPU-Kerne für die Generierung genutzt werden. Mehr = schneller (~3× gegenüber einem Kern); 0 überlässt die Wahl der Runtime.",
+  "settings.cmf.gpuHelp": "Matrixberechnungen auf die GPU auslagern (Metal/wgpu). Auf Apple Silicon beschleunigt das vor allem lange Prompts — das Decoding ist speicherbandbreitenbegrenzt.",
+  "settings.cmf.localOnlyHelp": "Jede Anfrage an das lokale Modell leiten und dabei Router sowie Cloud-Anbieter ignorieren.",
+  "settings.cmf.manageHelp": "Das Gateway startet beim Hochfahren `cortiq serve` für die untenstehende .cmf-Datei und routet dorthin. Erfordert ein installiertes cortiq (Schritt 1). Greift nach einem Neustart.",
+  "settings.cmf.autoInstallHelp": "Wenn cortiq beim Start fehlt, automatisch von crates.io installieren.",
+  "settings.cmf.autoUpdateHelp": "Beim Start cortiq auf die neueste Version aktualisieren, falls eine neuere existiert.",
+  "settings.router.enabledHelp": "Den cortiq-Router jede Anfrage klassifizieren lassen (Aufgabentyp + Komplexität) und ein Modell wählen. Aus = nur die lokale Routing-Tabelle verwenden.",
+  "settings.router.verifyTlsHelp": "Das TLS-Zertifikat des Routers prüfen. Nur bei einem selbstsignierten oder IP-gebundenen Zertifikat abschalten.",
+  "settings.telemetry.metricsHelp": "Prometheus-Metriken unter GET /metrics bereitstellen.",
+  "settings.cortiq.echoHelp": "Ein Feld `cortiq` (Aufgabe, Modell, Kosten) zu jedem Antwort-Body hinzufügen. Response-Header werden immer gesendet.",
+  "settings.stats.enabledHelp": "Aktuelle Anfragen aufzeichnen, um Dashboard und Diagramme zu speisen.",
+  "settings.cache.enabledHelp": "Semantischer Cache: eine gespeicherte Antwort zurückgeben, wenn ein neuer Prompt einem früheren sehr ähnlich ist, und den Modellaufruf überspringen. Erfordert ein Embedding-Modell im Pool.",
+  "settings.log.bodiesHelp": "Vollständige Nachrichteninhalte von Anfrage und Antwort loggen. Aus Datenschutzgründen standardmäßig aus.",
+  "settings.router.saveKey": "Schlüssel speichern",
+  "settings.router.keySaved": "Router-Schlüssel gespeichert",
+  "settings.router.keyEmpty": "Füge zuerst den Schlüssel ein",
+  "settings.router.secretHelp": "Füge den Schlüssel aus deiner E-Mail von api.allaigate.com ein und klicke auf „Schlüssel speichern“. Das ist KEIN Wert aus „API-Schlüssel“ — die sind für Clients, die dein Gateway aufrufen.",
+  "settings.router.keyStoredMask": "•••••••••••• — Schlüssel gespeichert (zum Ersetzen erneut einfügen)",
+  "settings.route.strategyHelp": "Welcher Text zur Klassifizierung an den Router geht: last_user = nur die letzte Nutzernachricht; last_user_plus_system = letzte Nutzernachricht + System-Prompt; concat_all = die gesamte Unterhaltung.",
+  "settings.route.maxCharsHelp": "Maximale Zeichenzahl dieses Textes, die an den Router gesendet wird (längerer Text wird gekürzt). Mehr = genauere Klassifizierung, aber langsamere und teurere Router-Aufrufe.",
+  "settings.route.cacheTtlHelp": "Wie lange eine Routing-Entscheidung für eine identische Anfrage zwischengespeichert wird, bevor der Router erneut gefragt wird (z. B. 60s, 5m).",
+  "settings.route.profileHelp": "Standard-Routing-Profil, wenn eine Anfrage keines angibt: cost-saver (am günstigsten), balanced oder quality-first (bestes Modell). Beeinflusst, welches Modell der Router wählt.",
+
+  // import
+  "import.subtitle": "Suche auf HuggingFace, konvertiere in ein lokales .cmf und stelle es bereit.",
+  "import.searchPlaceholder": "HuggingFace-Modelle suchen (z. B. qwen3, llama)…",
+  "import.searching": "Suche läuft…",
+  "import.noResults": "Keine Modelle gefunden.",
+  "import.configure": "Konvertierung einrichten",
+  "import.outName": "Ausgabename",
+  "import.outNameHint": "Name der .cmf-Datei (Buchstaben, Ziffern, - und _).",
+  "import.quant": "Quantisierung",
+  "import.convert": "Konvertieren & laden",
+  "import.converting": "Konvertierung",
+  "import.started": "Konvertierung gestartet",
+  "import.failed": "Konvertierung fehlgeschlagen — siehe Log.",
+  "import.register": "Als lokales Modell registrieren",
+  "import.registered": "Als '{id}' registriert. Starte cortiq-server, um es bereitzustellen.",
+  "import.jobs": "Downloads & Konvertierungen",
+  "import.cancel": "Abbrechen",
+  "import.cancelling": "Wird abgebrochen — unvollständige Ausgabe wird entfernt…",
+  "import.delete": "Löschen",
+  "import.deleteConfirm": "Dieses Modell und seine konvertierte .cmf-Datei von der Festplatte löschen?",
+  "import.deleted": "Mitsamt Dateien gelöscht",
+  "import.state.running": "läuft",
+  "import.state.done": "fertig",
+  "import.state.error": "Fehler",
+  "import.state.cancelled": "abgebrochen",
+  "import.featuredTitle": "Empfohlene fertige .cmf-Modelle",
+  "import.featuredSub": "Vorkonvertierte .cmf-Modelle vom infosave-Konto auf HuggingFace — die Liste wird live gelesen, neue Modelle erscheinen von selbst.",
+  "import.readyCmfBadge": "Fertiges .cmf",
+  "import.directDownload": "Herunterladen",
+  "import.q.q8_2f": "8-Bit Zwei-Feld (𝒲×θ) — empfohlen: bestes Verhältnis von Qualität und Größe.",
+  "import.q.q8_row": "8-Bit pro Zeile — einfach und robust.",
+  "import.q.q4": "4-Bit Block — am kleinsten, geringere Qualität.",
+  "import.q.q4_tiled": "4-Bit gekachelt (Q4_TILED) — 1,66× schneller auf der Metal-GPU.",
+  "import.q.vbit": "Variabel 3–8 Bit — Bit-Budget pro Experte.",
+  "import.q.q1t": "1,58-Bit ternär (Q1T) — BitNet b1.58 mit spärlichen Ausreißern.",
+  "import.q.q1s": "1-Bit spärlich (Q1S) — 1-Bit-Basis mit holografischen Ausreißern.",
+  "import.q.q1p": "1-Bit PTQ (Q1P) — 1 Bit mit Fehlerdiffusion.",
+  "import.q.q1": "1-Bit (Q1) — rein binäres Format.",
+  "import.q.f16": "16-Bit — keine Quantisierung.",
+  "import.q.f32": "32-Bit — volle Präzision (große Datei).",
+  "import.adv.title": "Erweiterte Einstellungen",
+  "import.adv.auto": "automatisch",
+  "import.adv.linearCore": "Linearer Kern",
+  "import.adv.linearHint": "Wie Layer mit linearer Attention übernommen bzw. gefaltet werden.",
+  "import.adv.nphase": "vmf_phase Phasen/Kopf",
+  "import.adv.vbitShape": "VBIT-Budgetform",
+  "import.adv.meanBits": "VBIT mittlere Bits",
+  "import.adv.shard": "Shard max. (GB)",
+  "import.adv.noShard": "kein Sharding",
+  "import.adv.skipMtp": "MTP-Kopf überspringen",
+  "import.adv.o1": "O(1)-Attention",
+  "import.adv.o1Hint": "Streaming-Attention mit konstantem Speicher: der KV-Cache wird nach dem Prefill freigegeben, lange Kontexte lassen den Speicher also nicht wachsen. Die Gewichte bleiben Byte-identisch — gespeichert wird nur ein Hinweis für die Ladezeit; du kannst jederzeit zurückwechseln (mit --o1 off starten). Auf Qwen3-0.6B validiert: alle Layer ≈ ×1,18 Perplexität.",
+  "import.adv.o1Off": "aus — exakte Attention (Standard)",
+  "import.adv.o1All": "alle — jeden Softmax-Layer konvertieren",
+  "import.adv.o1Deep": "deep N — nur die N tiefsten Layer",
+  "import.adv.o1Custom": "benutzerdefiniert — explizite Layer-Liste",
+  "import.adv.o1DeepN": "N tiefe Layer",
+  "import.adv.o1Layers": "Layer (kommagetrennt)",
+  "import.adv.o1mHint": "Landmark-Budget (Standard 32)",
+  "import.adv.o1windowHint": "Breite des exakten Fensters (Standard 128)",
+  "import.adv.o1sinkHint": "permanente exakte Sink-Keys (Standard 4)",
+
+  // onboarding
+  "onboarding.title": "Ersteinrichtung",
+  "onboarding.welcome": "Willkommen bei Cortiq Gateway",
+  "onboarding.welcomeSub": "Wähle deine Sprache — du kannst sie jederzeit in der Kopfzeile ändern.",
+  "onboarding.next": "Weiter",
+  "onboarding.back": "Zurück",
+  "onboarding.skip": "Vorerst überspringen",
+  "onboarding.skipSetup": "Überspringen",
+  "onboarding.finish": "Einrichtung abschließen",
+  "onboarding.featuredTitle": "Fertige Modelle (ein Klick)",
+  "onboarding.featuredSub": "Das sind bereits konvertierte .cmf-Modelle von infosave auf HuggingFace — einfach herunterladen, keine Konvertierung nötig. Wähle eines oder mehrere für den Sofortstart.",
+  "onboarding.download": "Herunterladen",
+  "onboarding.hfTitle": "Jedes HuggingFace-Modell — automatisch konvertiert",
+  "onboarding.hfSub": "Suche ein beliebiges Modell, wähle eine Quantisierung, und wir konvertieren es automatisch nach .cmf. Keine manuellen Config-Änderungen.",
+  "onboarding.noJobs": "Noch keine Downloads.",
+  "onboarding.doneTitle": "Alles bereit",
+  "onboarding.doneSub": "Heruntergeladene Modelle werden automatisch registriert. Weitere kannst du unter Import oder Modelle hinzufügen.",
+  "onboarding.doneHint": "„Einrichtung abschließen“ verbindet jeden fertigen Download als lokales Modell, startet dessen .cmf-Server und richtet das Routing darauf aus. Alles lässt sich später unter Modelle ändern.",
+  "onboarding.willRegister": "Werden als lokale Modelle verbunden",
+  "onboarding.nothingToRegister": "Noch keine abgeschlossenen Downloads — nichts zu verbinden. Geh einen Schritt zurück und wähle ein Modell.",
+  "onboarding.registeredN": "{n} Modell(e) verbunden: {ids}",
+  "onboarding.runtimeMissing": "Die cortiq-Runtime ist nicht installiert — installiere sie unter Einstellungen → Lokale Modelle, um diese Modelle bereitzustellen.",
+  "onboarding.downloaded": "heruntergeladen",
+  "onboarding.update": "Aktualisieren",
+  "onboarding.deleteFile": "Die .cmf-Datei von der Festplatte löschen",
+  "onboarding.confirmDelete": "„{id}“ löschen? Die .cmf-Datei wird von der Festplatte entfernt.",
+  "onboarding.unregistered": "Ebenfalls abgemeldet: {ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "Chat",
+  "pg.tab.image": "Bild",
+  "pg.tab.video": "Video",
+  "pg.generate": "Generieren",
+  "pg.generating": "Wird generiert…",
+  "pg.genFailed": "Generierung fehlgeschlagen — siehe Log.",
+  "pg.result": "Ergebnis",
+  "pg.genMetrics": "Generierungsmetriken",
+  "pg.imagePromptPlaceholder": "ein Rotfuchs im Schnee bei Sonnenuntergang, fotorealistisch, detailliertes Fell",
+  "pg.videoPromptPlaceholder": "ein Corgi mit Kochmütze wirft einen Pfannkuchen, Brutzeln und ein fröhliches Bellen",
+  "pg.imageEmpty": "Das generierte Bild erscheint hier.",
+  "pg.videoEmpty": "Der generierte Clip (mit Ton) erscheint hier.",
+  "pg.width": "Breite",
+  "pg.height": "Höhe",
+  "pg.steps": "Schritte",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "Zufälliger Seed",
+  "pg.cfgHint": "Guidance-Stärke; ≤ 1 schaltet CFG ab und halbiert die Arbeit.",
+  "pg.frames": "Frames",
+  "pg.framesHint": "Bei 24 fps; auf das Raster des Modells gerundet.",
+  "pg.quality": "JPEG-Qualität",
+  "pg.videoSizeHint": "Vielfache von 32; die trainierte kurze Kante ist 768.",
+  "pg.videoStepsHint": "Die Turbo-LoRA ist auf 4 Schritte trainiert.",
+  "pg.firstFrame": "Erstes Frame (optional)",
+  "pg.lastFrame": "Letztes Frame (optional)",
+  "pg.keyframeHint": "Macht den Lauf zu Keyframe-to-Video.",
+  "pg.resolution": "Auflösung",
+  "pg.genTime": "Generierungszeit",
+  "pg.timePerStep": "Pro Schritt",
+  "pg.timePerFrame": "Pro Frame",
+  "pg.fileSize": "Dateigröße",
+  "pg.duration": "Dauer",
+  "pg.play": "Abspielen",
+  "pg.noMediaModels": "Noch kein lokales {kind}-Modell. Lade eines (z. B. aus der infosave-Sammlung) unter Import herunter:",
+  "pg.tokSpeed": "Geschwindigkeit",
+  "pg.ttft": "Erstes Token",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "Logs",
+  "logs.subtitle": "Jüngstes Gateway-Log — das, was das Terminal zeigen würde.",
+  "logs.filterPlaceholder": "filtern…",
+  "logs.pause": "Pause",
+  "logs.resume": "Fortsetzen",
+  "logs.empty": "Nichts gefunden.",
+  "notice.openAdmin": "Die Konsole ist ohne Token offen und von anderen Rechnern erreichbar. Setze einen Token, wenn diese Maschine nicht privat ist.",
+  "notice.update": "Update verfügbar: v{v}.",
+  "dash.sys.title": "System",
+  "dash.sys.cores": "Kerne",
+  "dash.sys.disk": "Festplatte (Modelle)",
+  "dash.sys.free": "frei",
+  "dash.sys.gateway": "Gateway",
+  "fit.disk": "zu wenig Speicherplatz",
+  "fit.diskTitle": "Der Download ist größer als der freie Platz auf der Modell-Festplatte.",
+  "fit.ram": "passt evtl. nicht in den RAM",
+  "fit.ramTitle": "Das Modell ist nahe an oder größer als der RAM dieser Maschine — es läuft womöglich nicht.",
+  "pg.eta": "übrig",
+  "pg.min": "Min",
+  "pg.queued": "In der Warteschlange — Position {n}. Startet, sobald die aktuelle Generierung fertig ist.",
+  "pg.gallery": "Letzte Generierungen",
+  "pg.galDeleteConfirm": "Diese Generierung samt Dateien löschen?",
+  "pg.clearChat": "Leeren",
+  "keys.snip.title": "Deine App verbinden",
+  "keys.snip.hint": "Füge eines der Beispiele in dein Projekt ein — nur der Schlüssel-Platzhalter muss ersetzt werden.",
+  "keys.snip.withKey": "Die Beispiele unten enthalten bereits den gerade erstellten Schlüssel.",
+  "keys.snip.openMode": "Keine API-Schlüssel konfiguriert — das Gateway akzeptiert jeden Wert.",
+  "keys.snip.keyPh": "dein API-Schlüssel",
+  "settings.restart": "Gateway neu starten",
+  "settings.restartConfirm": "Gateway neu starten? Laufende Anfragen brechen ab; lokale Modellserver starten ebenfalls neu.",
+  "settings.restarting": "Neustart — die Seite lädt neu, sobald das Gateway wieder da ist…",
+  "bench.title": "Geschwindigkeit lokaler Modelle",
+  "bench.hint": "Führt `cortiq bench` auf dieser Maschine aus — echte tok/s, ein Modell nach dem anderen.",
+  "bench.run": "Messen",
+  "bench.running": "misst…",
+  "bench.failed": "fehlgeschlagen",
+  "bench.none": "Noch keine lokalen .cmf-Chat-Modelle.",
+
+  // task-based routing
+  "task.chitchat": "Smalltalk",
+  "task.code": "Code",
+  "task.creative-writing": "Kreatives Schreiben",
+  "task.extraction": "Datenextraktion",
+  "task.math": "Mathematik",
+  "task.qa": "Fragen & Antworten",
+  "task.summarization": "Zusammenfassung",
+  "task.translation": "Übersetzung",
+  "routing.tasks.title": "Aufgabenbasiertes Routing",
+  "routing.tasks.hint": "Die Modelle einer Regel kommen für ihre Aufgabe zuerst; die Komplexitätskette bleibt als Fallback. Leer = nur nach Komplexität.",
+  "routing.tasks.inherit": "nach Komplexität (keine Regel)",
+  "routing.tasks.share": "{p}% der Anfragen (7 T)",
+  "routing.tasks.fromRouter": "Labels live vom Router",
+  "routing.tasks.builtin": "Router nicht erreichbar — eingebauter Labelsatz",
+  "routing.tasks.addCustom": "Aufgabe hinzufügen",
+  "routing.tasks.addPlaceholder": "eigenes Label…",
+
+  // benchmark view
+  "nav.benchmark": "Benchmark",
+  "bm.title": "Benchmark",
+  "bm.subtitle": "Qualitäts- und Tempo-Proben durch die Live-Pipeline: Antworten per Schlüsselwort geprüft, Schleifen erkannt, tok/s und Zeit bis zum ersten Token je Modell.",
+  "bm.models": "Zu testende Modelle",
+  "bm.quickMode": "Schnelltest",
+  "bm.quickHint": "Die schnelle Teilmenge mit kurzen Antworten — etwa eine Minute pro lokalem Modell.",
+  "bm.suiteInfo": "Eingebaute Suite: {q} schnelle / {f} volle Tests, plus Ihre eigenen.",
+  "bm.run": "Starten",
+  "bm.pickModel": "Wählen Sie mindestens ein Modell.",
+  "bm.testOf": "Test {i} von {n}",
+  "bm.results": "Ergebnisse",
+  "bm.quick": "schnell",
+  "bm.test": "Test",
+  "bm.cellHint": "Klick auf eine Zelle zeigt die vollständige Antwort.",
+  "bm.history": "Frühere Läufe (in diesem Browser gespeichert)",
+  "bm.custom": "Eigene Tests",
+  "bm.customHint": "Prompt + kommagetrennte Schlüsselwörter, die die Antwort enthalten muss (| für Synonyme). Im Browser gespeichert.",
+  "bm.promptPh": "Prompt…",
+  "bm.checkPh": "Schlüsselwörter, kommagetrennt",
+  "bm.addTest": "Test hinzufügen",
+  "bm.emptyAnswer": "leere Antwort",
+  "bm.loopDetected": "Schleife erkannt",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "Smartes Routing",
+  "bm.mode.models": "Einzelne Modelle",
+  "bm.mode.routingDesc": "Das Kernfeature des Produkts im Test: jede Probe läuft über cortiq-auto — Sie sehen, welche Aufgabe der Router erkannt hat, welches Modell er wählte, ob das den Erwartungen entspricht und was es gekostet hat.",
+  "bm.mode.modelsDesc": "Dieselbe Suite, an gewählte Modelle gepinnt — Qualität, Tempo und Kosten im direkten Vergleich, am Router vorbei.",
+  "bm.answersOk": "Antworten korrekt",
+  "bm.classAcc": "Aufgaben-Klassifikation",
+  "bm.modelDist": "Anfragen gingen an",
+  "bm.expectedLbl": "erwartet:",
+  "bm.answer": "Antwort",
+  "bm.liveRunning": "läuft…",
+  "bm.spent": "ausgegeben",
+  "bm.verdict": "🏁 Fertig: Antworten {p}, ausgegeben {s}",
+  "bm.clearHistory": "Alle löschen",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — ins Terminal einfügen (das Gateway spricht das Anthropic-Protokoll nativ):",
+  "keys.h.codex": "Codex — hängt den Provider an ~/.codex/config.toml an und startet:",
+  "keys.h.opencode": "OpenCode — schreibt ~/.config/opencode/opencode.json (überschreibt!) und startet:",
+  "keys.h.continue": "Continue (VS Code / JetBrains) — hängt das Modell an ~/.continue/config.yaml an:",
+  "keys.h.cline1": "Cline (VS Code) — in den Erweiterungseinstellungen wählen:",
+  "keys.h.cline2": "Einstellungen → API Provider → OpenAI Compatible, dann die Werte oben einfügen.",
+  "keys.h.note": "cortiq-auto = smartes Routing: der Router wählt das Modell pro Anfrage. Für ein festes Modell den exakten Namen angeben. Unter Windows die Skripte in Git Bash / WSL ausführen oder dieselben Variablen über die Systemumgebung setzen.",
+  "keys.h.protoOff": "Das Anthropic-Protokoll (/v1/messages) ist deaktiviert — Claude Code kann sich nicht verbinden.",
+  "keys.h.enableProto": "Aktivieren",
+  "keys.h.st.installed": "Auf der Gateway-Maschine installiert",
+  "keys.h.st.configured": "Bereits für dieses Gateway konfiguriert",
+  "keys.h.st.notFound": "Auf der Gateway-Maschine nicht gefunden",
+  "bm.degraded": "Router degradiert",
+  "bm.routerDegraded": "Der Router hat nicht rechtzeitig geantwortet — die Anfrage nutzte die Fallback-Kette; die Klassifikation wird nicht gewertet.",
+  "bm.cutByCap": "Budget ging fürs Denken drauf — keine Antwort mehr",
+  "shell.uiStale": "Das Gateway wurde aktualisiert — diese Seite zeigt eine ältere Oberfläche.",
+  "shell.reload": "Neu laden",
+  "keys.col.requests": "Anfragen",
+  "keys.col.tokens": "Tokens ein/aus",
+  "keys.col.costAll": "$ gesamt",
+  "routing.tasks.tier": "Komplexität",
+  "routing.tasks.tierAuto": "Auto (Router)",
+  "routing.tasks.tierHint": "Welches Modell diese Aufgabe bei welcher Komplexität bedient; \"jede\" führt auf allen Stufen. Reihenfolge = Fallback-Reihenfolge. High eskaliert weiterhin über \"jede\"-Einträge.",
+  "routing.tasks.tierAny": "jede Komplexität",
+  "routing.tasks.addModel": "Modell",
+  "routing.bands.enable": "Eigene Komplexitätsgrenzen",
+  "routing.bands.hint": "Ziehen Sie die Griffe: wo low endet und high beginnt — die Griffe schieben einander, die Zahlen aktualisieren sich live. Der kontinuierliche Router-Score wird mit IHREN Grenzen neu eingeteilt; ohne Häkchen gelten die Grenzen des Routers.",
+  "tier.low": "leicht",
+  "tier.medium": "mittel",
+  "tier.high": "schwer",
 };

web/js/i18n/en.js

@@ -397,6 +397,7 @@ export default {
   "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.",
@@ -432,4 +433,198 @@ export default {
   "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 gateway",
+  "settings.restartConfirm": "Restart the gateway? Requests in flight will be dropped; local model servers restart too.",
+  "settings.restarting": "Restarting — the page reloads when the gateway is 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",
 };

web/js/i18n/es.js

@@ -30,7 +30,7 @@ export default {
   "nav.routing": "Enrutamiento",
   "nav.protocols": "Protocolos",
   "nav.keys": "Claves API",
-  "nav.playground": "Playground",
+  "nav.playground": "Zona de pruebas",
   "nav.settings": "Configuración",
   "nav.foot": "Gateway · v{v}",
   "nav.billing": "Clave del router y pagos",
@@ -76,7 +76,7 @@ export default {
   "dash.groupby.label": "por tarea",
   "dash.groupby.account": "por cuenta",
   "dash.recent.title": "Solicitudes recientes",
-  "dash.recent.empty": "Sin solicitudes registradas. Prueba el Playground.",
+  "dash.recent.empty": "Sin solicitudes registradas. Prueba la Zona de pruebas.",
   "dash.col.time": "Hora",
   "dash.col.model": "Modelo",
   "dash.col.tier": "Nivel",
@@ -189,7 +189,7 @@ export default {
   "keys.allowAll": "todos",
 
   // playground
-  "pg.title": "Playground",
+  "pg.title": "Zona de pruebas",
   "pg.subtitle": "Envía un prompt por el pipeline en vivo e inspecciona la decisión de enrutamiento.",
   "pg.system": "Prompt del sistema",
   "pg.systemPlaceholder": "mensaje de sistema opcional",
@@ -280,4 +280,358 @@ export default {
   "settings.cache.ttl": "TTL de entrada",
   "settings.cache.embed": "Modelo de embeddings",
   "settings.cache.note": "Los ajustes del caché se aplican tras reiniciar.",
+
+  // ── translated from en.js (previously falling back to English) ──
+  // nav
+  "nav.import": "Importar modelo",
+
+  // dash
+  "dash.clear": "Borrar registros",
+  "dash.clearConfirm": "¿Borrar todas las estadísticas y registros guardados? Esta acción no se puede deshacer.",
+  "dash.cleared": "Registros borrados",
+
+  // models
+  "models.form.idOrModel": "Introduce un id o un nombre de modelo",
+  "models.form.apiKey": "Clave API",
+  "models.form.apiKeyPlaceholder": "pega tu clave API",
+  "models.form.apiKeyNotNeeded": "no necesaria (servidor local)",
+  "models.form.apiKeyHint": "Se guarda de forma segura en la pasarela; no se vuelve a mostrar.",
+  "models.form.keyStored": "Hay una clave guardada — déjalo vacío para conservarla o pega una nueva.",
+  "models.form.keyFromEnv": "Se está usando una clave de una variable de entorno.",
+  "models.form.paramsTitle": "Parámetros de generación y razonamiento (O(1), MTP, temperatura)",
+  "models.form.temperature": "Temperatura",
+  "models.form.temperatureHint": "Temperatura de generación (0.0 = determinista, 1.0+ = creativa).",
+  "models.form.topP": "Top-P (muestreo nucleus)",
+  "models.form.topPHint": "Umbral de muestreo (0.0 .. 1.0).",
+  "models.form.maxTokens": "Tokens máx.",
+  "models.form.maxTokensHint": "Número máximo de tokens generados.",
+  "models.form.thinkBudget": "Modo razonamiento / presupuesto de pensamiento",
+  "models.form.thinkBudgetHint": "Presupuesto de tokens de razonamiento (0 = desactivado, N > 0 = máximo de tokens de razonamiento).",
+  "models.form.systemPrompt": "Prompt de sistema por defecto",
+  "models.form.systemPromptHint": "Se antepone automáticamente si la petición no trae prompt de sistema.",
+  "models.form.systemPromptPlaceholder": "Eres un asistente útil…",
+  "models.form.testKey": "Probar y cargar modelos",
+  "models.form.testing": "comprobando…",
+  "models.form.foundModels": "{n} modelos cargados",
+  "models.form.modelPlaceholder": "escribe para buscar…",
+  "models.form.modelHint": "Pulsa «Probar y cargar modelos» para traer la lista con tu clave y luego elige uno.",
+  "models.managed": "gestionado",
+  "models.managedHint": "Lo proporciona el servidor CMF gestionado (Ajustes → Modelos locales). Configúralo allí.",
+
+  // settings
+  "settings.router.enabled": "Usar el router (desactivado = solo modelos locales)",
+  "settings.cmf": "Modelos locales (CMF)",
+  "settings.cmf.localOnly": "Usar solo modelos locales",
+  "settings.cmf.manage": "Ejecutar un servidor de modelo local",
+  "settings.cmf.autoInstall": "Instalar cortiq automáticamente (crates.io)",
+  "settings.cmf.autoUpdate": "Actualizar cortiq automáticamente",
+  "settings.cmf.model": "Ruta del modelo .cmf local",
+  "settings.cmf.port": "Puerto del servidor local",
+  "settings.cmf.modelId": "Id del modelo en el pool",
+  "settings.cmf.note": "Sirve un .cmf local mediante cortiq (github.com/infosave2007/cmf). Funciona incluso cuando el router no está disponible.",
+  "settings.cmf.threads": "Hilos de trabajo",
+  "settings.cmf.gpu": "Usar GPU (Metal / wgpu)",
+  "settings.cmf.speedNote": "Los hilos paralelizan los matvec de decodificación (~3× más rápido; 0 = valor por defecto del runtime). Descargar en GPU ayuda sobre todo al prefill de prompts largos — la decodificación está limitada por el ancho de banda de memoria, así que en Apple Silicon es prácticamente neutro.",
+  "settings.cmf.pick": "selecciona un modelo",
+  "settings.cmf.models": "Modelos locales",
+  "settings.cmf.modelsHelp": "Cada fila es un modelo que la pasarela ejecuta (su propio cortiq serve en su propio puerto) y registra en el pool. Añade tantos como archivos .cmf y puertos libres tengas.",
+  "settings.cmf.rowHint": "id · archivo .cmf · puerto · hilos · GPU. Los cambios se aplican al reiniciar; borrar una fila detiene ese servidor.",
+  "settings.cmf.addServer": "+ Añadir modelo local",
+  "settings.cmf.checkPort": "Comprobar puerto",
+  "settings.cmf.portFree": "puerto libre",
+  "settings.cmf.portBusy": "puerto ocupado",
+  "settings.cmf.useSuggested": "usar {port}",
+  "settings.cmf.serving": "sirviendo {model} en :{port}",
+  "settings.cmf.intro": "Ejecuta modelos en local con el motor cortiq — funciona incluso sin conexión o cuando el router está caído.",
+  "settings.cmf.runtime": "Runtime cortiq",
+  "settings.cmf.runtimeHelp": "La herramienta de línea de comandos `cortiq` que carga y ejecuta modelos .cmf. Instálala una vez antes de arrancar un servidor local.",
+  "settings.cmf.install": "Instalar cortiq",
+  "settings.cmf.reinstall": "Reinstalar / actualizar",
+  "settings.cmf.installing": "instalando… (compila, unos minutos)",
+  "settings.cmf.installedOk": "cortiq instalado",
+  "settings.cmf.notInstalled": "no instalado",
+  "settings.cmf.addModel": "Añadir un modelo",
+  "settings.cmf.addModelHelp": "Los modelos se descargan y convierten en la pestaña Importar (HuggingFace → .cmf). Después apunta el servidor local al archivo .cmf de abajo.",
+  "settings.cmf.importNote": "¿Aún no tienes modelo? Importa uno:",
+  "settings.cmf.importLink": "Abrir Importar",
+  "settings.cmf.modelHelp": "Ruta del archivo .cmf que se va a servir (p. ej. models/qwen.cmf), generado en la pestaña Importar. ¿Varios modelos para distintas tareas? Impórtalos y cambia esta ruta.",
+  "settings.cmf.portHelp": "Puerto TCP en el que escucha el servidor de modelo local (8081 por defecto). Cámbialo solo si choca con otro servicio.",
+  "settings.cmf.threadsHelp": "Cuántos núcleos de CPU usar para la generación. Más = más rápido (~3× frente a un núcleo); 0 deja que decida el runtime.",
+  "settings.cmf.gpuHelp": "Descargar el cálculo matricial en la GPU (Metal/wgpu). En Apple Silicon acelera sobre todo los prompts largos — la decodificación está limitada por el ancho de banda de memoria.",
+  "settings.cmf.localOnlyHelp": "Enviar cada petición al modelo local, ignorando el router y cualquier proveedor en la nube.",
+  "settings.cmf.manageHelp": "La pasarela arranca `cortiq serve` para el .cmf de abajo al iniciarse y enruta hacia él. Requiere cortiq instalado (paso 1). Se aplica al reiniciar.",
+  "settings.cmf.autoInstallHelp": "Si cortiq falta al arrancar, instalarlo automáticamente desde crates.io.",
+  "settings.cmf.autoUpdateHelp": "Al arrancar, actualizar cortiq a la versión más reciente si existe una más nueva.",
+  "settings.router.enabledHelp": "Dejar que el router de cortiq clasifique cada petición (tipo de tarea + complejidad) y elija un modelo. Desactivado = usar solo la tabla de enrutado local.",
+  "settings.router.verifyTlsHelp": "Verificar el certificado TLS del router. Desactívalo solo con un certificado autofirmado o ligado a una IP.",
+  "settings.telemetry.metricsHelp": "Exponer métricas Prometheus en GET /metrics.",
+  "settings.cortiq.echoHelp": "Añadir un campo `cortiq` (tarea, modelo, coste) al cuerpo de cada respuesta. Las cabeceras de respuesta se envían siempre.",
+  "settings.stats.enabledHelp": "Registrar las peticiones recientes para alimentar el panel y las gráficas.",
+  "settings.cache.enabledHelp": "Caché semántica: devolver una respuesta guardada cuando un prompt nuevo se parece mucho a uno anterior, evitando la llamada al modelo. Requiere un modelo de embeddings en el pool.",
+  "settings.log.bodiesHelp": "Registrar el cuerpo completo de los mensajes de petición y respuesta. Desactivado por defecto por privacidad.",
+  "settings.router.saveKey": "Guardar clave",
+  "settings.router.keySaved": "Clave del router guardada",
+  "settings.router.keyEmpty": "Pega antes la clave",
+  "settings.router.secretHelp": "Pega la clave del correo de api.allaigate.com y pulsa Guardar clave. NO es un valor de «Claves API» — esas son para los clientes que llaman a tu pasarela.",
+  "settings.router.keyStoredMask": "•••••••••••• — clave guardada (pega otra para reemplazarla)",
+  "settings.route.strategyHelp": "Qué texto se envía al router para clasificar: last_user = solo el último mensaje del usuario; last_user_plus_system = último mensaje del usuario + prompt de sistema; concat_all = toda la conversación.",
+  "settings.route.maxCharsHelp": "Máximo de caracteres de ese texto enviados al router (lo que exceda se recorta). Más = clasificación más precisa, pero llamadas al router más lentas y caras.",
+  "settings.route.cacheTtlHelp": "Cuánto tiempo se cachea una decisión de enrutado para una petición idéntica antes de volver a preguntar al router (p. ej. 60s, 5m).",
+  "settings.route.profileHelp": "Perfil de enrutado por defecto cuando la petición no indica ninguno: cost-saver (el más barato), balanced o quality-first (el mejor modelo). Influye en qué modelo elige el router.",
+
+  // import
+  "import.subtitle": "Busca en HuggingFace, convierte a un .cmf local y sírvelo.",
+  "import.searchPlaceholder": "Buscar modelos en HuggingFace (p. ej. qwen3, llama)…",
+  "import.searching": "Buscando…",
+  "import.noResults": "No se encontraron modelos.",
+  "import.configure": "Configurar la conversión",
+  "import.outName": "Nombre de salida",
+  "import.outNameHint": "Nombre del archivo .cmf (letras, dígitos, - y _).",
+  "import.quant": "Cuantización",
+  "import.convert": "Convertir y cargar",
+  "import.converting": "Convirtiendo",
+  "import.started": "Conversión iniciada",
+  "import.failed": "La conversión falló — revisa el registro.",
+  "import.register": "Registrar como modelo local",
+  "import.registered": "Registrado como «{id}». Ejecuta cortiq-server para servirlo.",
+  "import.jobs": "Descargas y conversiones",
+  "import.cancel": "Cancelar",
+  "import.cancelling": "Cancelando — limpiando el archivo incompleto…",
+  "import.delete": "Eliminar",
+  "import.deleteConfirm": "¿Eliminar este modelo y su archivo .cmf convertido del disco?",
+  "import.deleted": "Eliminado junto con sus archivos",
+  "import.state.running": "en curso",
+  "import.state.done": "listo",
+  "import.state.error": "error",
+  "import.state.cancelled": "cancelado",
+  "import.featuredTitle": "Modelos .cmf listos para usar",
+  "import.featuredSub": "Modelos .cmf ya convertidos de la cuenta infosave en HuggingFace — la lista se lee en vivo, los modelos nuevos aparecen solos.",
+  "import.readyCmfBadge": ".cmf listo",
+  "import.directDownload": "Descargar",
+  "import.q.q8_2f": "8 bits de dos campos (𝒲×θ) — recomendado: mejor relación calidad/tamaño.",
+  "import.q.q8_row": "8 bits por fila — simple y robusto.",
+  "import.q.q4": "4 bits por bloque — el más pequeño, menor calidad.",
+  "import.q.q4_tiled": "4 bits en mosaico (Q4_TILED) — 1,66× más rápido en GPU Metal.",
+  "import.q.vbit": "Variable 3–8 bits — presupuesto de bits por experto.",
+  "import.q.q1t": "Ternario de 1,58 bits (Q1T) — BitNet b1.58 con valores atípicos dispersos.",
+  "import.q.q1s": "1 bit disperso (Q1S) — base de 1 bit con valores atípicos holográficos.",
+  "import.q.q1p": "1 bit PTQ (Q1P) — 1 bit con difusión de error.",
+  "import.q.q1": "1 bit (Q1) — formato puramente binario.",
+  "import.q.f16": "16 bits — sin cuantización.",
+  "import.q.f32": "32 bits — precisión completa (archivo grande).",
+  "import.adv.title": "Ajustes avanzados",
+  "import.adv.auto": "auto",
+  "import.adv.linearCore": "Núcleo lineal",
+  "import.adv.linearHint": "Cómo se trasladan o pliegan las capas de atención lineal.",
+  "import.adv.nphase": "vmf_phase fases/cabeza",
+  "import.adv.vbitShape": "Forma del presupuesto VBIT",
+  "import.adv.meanBits": "Bits medios VBIT",
+  "import.adv.shard": "Tamaño máx. de shard (GB)",
+  "import.adv.noShard": "sin fragmentar",
+  "import.adv.skipMtp": "omitir la cabeza MTP",
+  "import.adv.o1": "Atención O(1)",
+  "import.adv.o1Hint": "Atención en streaming con memoria constante: la caché KV se libera tras el prefill, así que los contextos largos no hacen crecer la memoria. Los pesos quedan idénticos byte a byte — solo se guarda una indicación para el momento de carga; puedes volver atrás cuando quieras (servir con --o1 off). Validado en Qwen3-0.6B: todas las capas ≈ ×1,18 de perplejidad.",
+  "import.adv.o1Off": "desactivada — atención exacta (por defecto)",
+  "import.adv.o1All": "all — convertir todas las capas softmax",
+  "import.adv.o1Deep": "deep N — solo las N capas más profundas",
+  "import.adv.o1Custom": "personalizado — lista explícita de capas",
+  "import.adv.o1DeepN": "N capas profundas",
+  "import.adv.o1Layers": "Capas (separadas por comas)",
+  "import.adv.o1mHint": "presupuesto de landmarks (32 por defecto)",
+  "import.adv.o1windowHint": "ancho de la ventana exacta (128 por defecto)",
+  "import.adv.o1sinkHint": "claves sink exactas permanentes (4 por defecto)",
+
+  // onboarding
+  "onboarding.title": "Configuración inicial",
+  "onboarding.welcome": "Bienvenido a Cortiq Gateway",
+  "onboarding.welcomeSub": "Elige tu idioma — puedes cambiarlo cuando quieras en la cabecera.",
+  "onboarding.next": "Siguiente",
+  "onboarding.back": "Atrás",
+  "onboarding.skip": "Omitir por ahora",
+  "onboarding.skipSetup": "Omitir",
+  "onboarding.finish": "Finalizar configuración",
+  "onboarding.featuredTitle": "Modelos listos para usar (un clic)",
+  "onboarding.featuredSub": "Son modelos .cmf ya convertidos de infosave en HuggingFace — basta con descargarlos, sin conversión. Elige uno o varios para empezar al instante.",
+  "onboarding.download": "Descargar",
+  "onboarding.hfTitle": "Cualquier modelo de HuggingFace — conversión automática",
+  "onboarding.hfSub": "Busca cualquier modelo, elige una cuantización y lo convertimos a .cmf automáticamente. Sin editar la configuración a mano.",
+  "onboarding.noJobs": "Todavía no hay descargas.",
+  "onboarding.doneTitle": "Todo listo",
+  "onboarding.doneSub": "Los modelos descargados se registrarán automáticamente. Puedes añadir más en Importar o Modelos.",
+  "onboarding.doneHint": "«Finalizar configuración» conecta cada descarga completada como modelo local, arranca su servidor .cmf y apunta el enrutado hacia él. Todo esto se puede cambiar luego en Modelos.",
+  "onboarding.willRegister": "Se conectarán como modelos locales",
+  "onboarding.nothingToRegister": "Aún no hay descargas terminadas — no hay nada que conectar. Vuelve un paso atrás y elige un modelo.",
+  "onboarding.registeredN": "{n} modelo(s) conectado(s): {ids}",
+  "onboarding.runtimeMissing": "El runtime cortiq no está instalado — instálalo en Ajustes → Modelos locales para poder servirlos.",
+  "onboarding.downloaded": "descargado",
+  "onboarding.update": "Actualizar",
+  "onboarding.deleteFile": "Eliminar el archivo .cmf del disco",
+  "onboarding.confirmDelete": "¿Eliminar «{id}»? El archivo .cmf se borrará del disco.",
+  "onboarding.unregistered": "También se dio de baja: {ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "Chat",
+  "pg.tab.image": "Imagen",
+  "pg.tab.video": "Vídeo",
+  "pg.generate": "Generar",
+  "pg.generating": "Generando…",
+  "pg.genFailed": "La generación falló — revisa el registro.",
+  "pg.result": "Resultado",
+  "pg.genMetrics": "Métricas de generación",
+  "pg.imagePromptPlaceholder": "un zorro rojo en la nieve al atardecer, fotorrealista, pelaje detallado",
+  "pg.videoPromptPlaceholder": "un corgi con gorro de chef voltea una tortita, chisporroteo y un ladrido alegre",
+  "pg.imageEmpty": "La imagen generada aparecerá aquí.",
+  "pg.videoEmpty": "El clip generado (con audio) aparecerá aquí.",
+  "pg.width": "Ancho",
+  "pg.height": "Alto",
+  "pg.steps": "Pasos",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "Seed aleatorio",
+  "pg.cfgHint": "Escala de guidance; ≤ 1 desactiva el CFG y reduce el trabajo a la mitad.",
+  "pg.frames": "Fotogramas",
+  "pg.framesHint": "A 24 fps; se ajusta a la rejilla del modelo.",
+  "pg.quality": "Calidad JPEG",
+  "pg.videoSizeHint": "Múltiplos de 32; el lado corto entrenado es 768.",
+  "pg.videoStepsHint": "La LoRA Turbo está entrenada para 4 pasos.",
+  "pg.firstFrame": "Primer fotograma (opcional)",
+  "pg.lastFrame": "Último fotograma (opcional)",
+  "pg.keyframeHint": "Convierte la ejecución en keyframe-to-video.",
+  "pg.resolution": "Resolución",
+  "pg.genTime": "Tiempo de generación",
+  "pg.timePerStep": "Por paso",
+  "pg.timePerFrame": "Por fotograma",
+  "pg.fileSize": "Tamaño del archivo",
+  "pg.duration": "Duración",
+  "pg.play": "Reproducir",
+  "pg.noMediaModels": "Aún no hay un modelo {kind} local. Descarga uno (p. ej. de la colección infosave) en Importar:",
+  "pg.tokSpeed": "Velocidad",
+  "pg.ttft": "Primer token",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "Registros",
+  "logs.subtitle": "Registro reciente de la pasarela — lo que mostraría la terminal.",
+  "logs.filterPlaceholder": "filtrar…",
+  "logs.pause": "Pausa",
+  "logs.resume": "Reanudar",
+  "logs.empty": "Nada coincide.",
+  "notice.openAdmin": "La consola está abierta sin token y accesible desde otras máquinas. Configura un token si esta máquina no es privada.",
+  "notice.update": "Actualización disponible: v{v}.",
+  "dash.sys.title": "Sistema",
+  "dash.sys.cores": "núcleos",
+  "dash.sys.disk": "Disco (modelos)",
+  "dash.sys.free": "libre",
+  "dash.sys.gateway": "pasarela",
+  "fit.disk": "no hay espacio suficiente",
+  "fit.diskTitle": "La descarga supera el espacio libre del disco de modelos.",
+  "fit.ram": "puede no caber en RAM",
+  "fit.ramTitle": "El modelo se acerca o supera la RAM de esta máquina — puede que no funcione.",
+  "pg.eta": "restante",
+  "pg.min": "min",
+  "pg.queued": "En cola — posición {n}. Arranca en cuanto termine la generación actual.",
+  "pg.gallery": "Generaciones recientes",
+  "pg.galDeleteConfirm": "¿Eliminar esta generación y sus archivos?",
+  "pg.clearChat": "Limpiar",
+  "keys.snip.title": "Conecta tu aplicación",
+  "keys.snip.hint": "Pega uno de estos ejemplos en tu proyecto — solo hay que sustituir el marcador de la clave.",
+  "keys.snip.withKey": "Los ejemplos de abajo ya incluyen la clave que acabas de crear.",
+  "keys.snip.openMode": "No hay claves API configuradas — la pasarela acepta cualquier valor.",
+  "keys.snip.keyPh": "tu clave API",
+  "settings.restart": "Reiniciar la pasarela",
+  "settings.restartConfirm": "¿Reiniciar la pasarela? Las peticiones en curso se cortarán; los servidores de modelos locales también se reinician.",
+  "settings.restarting": "Reiniciando — la página se recargará cuando la pasarela vuelva…",
+  "bench.title": "Velocidad de modelos locales",
+  "bench.hint": "Ejecuta `cortiq bench` en esta máquina — tok/s reales, un modelo a la vez.",
+  "bench.run": "Medir",
+  "bench.running": "midiendo…",
+  "bench.failed": "falló",
+  "bench.none": "Aún no hay modelos de chat .cmf locales.",
+
+  // task-based routing
+  "task.chitchat": "Charla",
+  "task.code": "Código",
+  "task.creative-writing": "Escritura creativa",
+  "task.extraction": "Extracción de datos",
+  "task.math": "Matemáticas",
+  "task.qa": "Preguntas y respuestas",
+  "task.summarization": "Resumen",
+  "task.translation": "Traducción",
+  "routing.tasks.title": "Enrutado por tarea",
+  "routing.tasks.hint": "Los modelos de una regla van primero para su tarea; la cadena por complejidad sigue como respaldo. Vacío = solo por complejidad.",
+  "routing.tasks.inherit": "por complejidad (sin regla)",
+  "routing.tasks.share": "{p}% de las peticiones (7 d)",
+  "routing.tasks.fromRouter": "etiquetas en vivo del router",
+  "routing.tasks.builtin": "router inaccesible — conjunto integrado",
+  "routing.tasks.addCustom": "Añadir tarea",
+  "routing.tasks.addPlaceholder": "etiqueta propia…",
+
+  // benchmark view
+  "nav.benchmark": "Benchmark",
+  "bm.title": "Benchmark",
+  "bm.subtitle": "Pruebas de calidad y velocidad a través del pipeline en vivo: respuestas verificadas por palabras clave, detección de bucles, tok/s y tiempo del primer token por modelo.",
+  "bm.models": "Modelos a probar",
+  "bm.quickMode": "Prueba rápida",
+  "bm.quickHint": "El subconjunto rápido con respuestas cortas — alrededor de un minuto por modelo local.",
+  "bm.suiteInfo": "Suite integrada: {q} pruebas rápidas / {f} completas, más las tuyas.",
+  "bm.run": "Ejecutar",
+  "bm.pickModel": "Elige al menos un modelo.",
+  "bm.testOf": "prueba {i} de {n}",
+  "bm.results": "Resultados",
+  "bm.quick": "rápida",
+  "bm.test": "Prueba",
+  "bm.cellHint": "Haz clic en una celda para ver la respuesta completa.",
+  "bm.history": "Ejecuciones anteriores (guardadas en este navegador)",
+  "bm.custom": "Pruebas propias",
+  "bm.customHint": "Prompt + palabras clave separadas por comas que la respuesta debe contener (| para sinónimos). Se guardan en este navegador.",
+  "bm.promptPh": "prompt…",
+  "bm.checkPh": "palabras clave, separadas por comas",
+  "bm.addTest": "Añadir prueba",
+  "bm.emptyAnswer": "respuesta vacía",
+  "bm.loopDetected": "bucle detectado",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "Enrutado inteligente",
+  "bm.mode.models": "Modelos individuales",
+  "bm.mode.routingDesc": "La función clave del producto a prueba: cada sonda pasa por cortiq-auto — ves qué tarea detectó el router, qué modelo eligió, si coincide con lo esperado y cuánto costó.",
+  "bm.mode.modelsDesc": "La misma suite fijada a los modelos elegidos — compara su calidad, velocidad y coste directamente, sin pasar por el router.",
+  "bm.answersOk": "respuestas correctas",
+  "bm.classAcc": "clasificación de tareas",
+  "bm.modelDist": "Las peticiones fueron a",
+  "bm.expectedLbl": "esperado:",
+  "bm.answer": "Respuesta",
+  "bm.liveRunning": "en curso…",
+  "bm.spent": "gastado",
+  "bm.verdict": "🏁 Listo: respuestas {p}, gastado {s}",
+  "bm.clearHistory": "Borrar todo",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — pega en la terminal (la pasarela habla el protocolo Anthropic de forma nativa):",
+  "keys.h.codex": "Codex — añade el proveedor a ~/.codex/config.toml y arranca:",
+  "keys.h.opencode": "OpenCode — escribe ~/.config/opencode/opencode.json (¡sobrescribe!) y arranca:",
+  "keys.h.continue": "Continue (VS Code / JetBrains) — añade el modelo a ~/.continue/config.yaml:",
+  "keys.h.cline1": "Cline (VS Code) — en los ajustes de la extensión elige:",
+  "keys.h.cline2": "Ajustes → API Provider → OpenAI Compatible, luego pega los valores de arriba.",
+  "keys.h.note": "cortiq-auto = enrutado inteligente: el router elige el modelo en cada petición. Para fijar uno, indica su nombre exacto. En Windows ejecuta los scripts en Git Bash / WSL o define las mismas variables en el entorno del sistema.",
+  "keys.h.protoOff": "El protocolo Anthropic (/v1/messages) está desactivado — Claude Code no podrá conectarse.",
+  "keys.h.enableProto": "Activar",
+  "keys.h.st.installed": "Instalado en la máquina de la pasarela",
+  "keys.h.st.configured": "Ya configurado para esta pasarela",
+  "keys.h.st.notFound": "No encontrado en la máquina de la pasarela",
+  "bm.degraded": "router degradado",
+  "bm.routerDegraded": "El router no respondió a tiempo — la petición usó la cadena de reserva; la clasificación no se cuenta.",
+  "bm.cutByCap": "presupuesto gastado en razonar — sin respuesta final",
+  "shell.uiStale": "La pasarela se actualizó — esta página usa una interfaz antigua.",
+  "shell.reload": "Recargar",
+  "keys.col.requests": "Peticiones",
+  "keys.col.tokens": "Tokens ent/sal",
+  "keys.col.costAll": "$ total",
+  "routing.tasks.tier": "Complejidad",
+  "routing.tasks.tierAuto": "Auto (router)",
+  "routing.tasks.tierHint": "Qué modelo atiende esta tarea en qué complejidad; «cualquiera» lidera en todos los niveles. El orden = orden de respaldo. Un veredicto high sigue escalando sobre las entradas «cualquiera».",
+  "routing.tasks.tierAny": "cualquier complejidad",
+  "routing.tasks.addModel": "modelo",
+  "routing.bands.enable": "Mis límites de complejidad",
+  "routing.bands.hint": "Arrastra los tiradores: dónde termina low y dónde empieza high — se empujan entre sí y las cifras se actualizan en vivo. La puntuación continua del router se re-mapea con TUS límites; sin marcar = las bandas del propio router.",
+  "tier.low": "fácil",
+  "tier.medium": "medio",
+  "tier.high": "difícil",
 };

web/js/i18n/fr.js

@@ -30,7 +30,7 @@ export default {
   "nav.routing": "Routage",
   "nav.protocols": "Protocoles",
   "nav.keys": "Clés API",
-  "nav.playground": "Playground",
+  "nav.playground": "Bac à sable",
   "nav.settings": "Paramètres",
   "nav.foot": "Gateway · v{v}",
   "nav.billing": "Clé routeur & facturation",
@@ -76,7 +76,7 @@ export default {
   "dash.groupby.label": "par tâche",
   "dash.groupby.account": "par compte",
   "dash.recent.title": "Requêtes récentes",
-  "dash.recent.empty": "Aucune requête enregistrée. Essayez le Playground.",
+  "dash.recent.empty": "Aucune requête enregistrée. Essayez le Bac à sable.",
   "dash.col.time": "Heure",
   "dash.col.model": "Modèle",
   "dash.col.tier": "Niveau",
@@ -189,7 +189,7 @@ export default {
   "keys.allowAll": "tous",
 
   // playground
-  "pg.title": "Playground",
+  "pg.title": "Bac à sable",
   "pg.subtitle": "Envoyez une invite via le pipeline en direct et inspectez la décision de routage.",
   "pg.system": "Invite système",
   "pg.systemPlaceholder": "message système optionnel",
@@ -280,4 +280,358 @@ export default {
   "settings.cache.ttl": "TTL d'entrée",
   "settings.cache.embed": "Modèle d'embeddings",
   "settings.cache.note": "Les paramètres du cache prennent effet après un redémarrage.",
+
+  // ── translated from en.js (previously falling back to English) ──
+  // nav
+  "nav.import": "Importer un modèle",
+
+  // dash
+  "dash.clear": "Effacer les journaux",
+  "dash.clearConfirm": "Effacer toutes les statistiques et les journaux enregistrés ? Action irréversible.",
+  "dash.cleared": "Journaux effacés",
+
+  // models
+  "models.form.idOrModel": "Saisissez un identifiant ou un nom de modèle",
+  "models.form.apiKey": "Clé API",
+  "models.form.apiKeyPlaceholder": "collez votre clé API",
+  "models.form.apiKeyNotNeeded": "non requise (serveur local)",
+  "models.form.apiKeyHint": "Stockée de façon sécurisée sur la passerelle ; elle n'est plus affichée ensuite.",
+  "models.form.keyStored": "Une clé est enregistrée — laissez vide pour la conserver, ou collez-en une nouvelle.",
+  "models.form.keyFromEnv": "Une clé issue d'une variable d'environnement est utilisée.",
+  "models.form.paramsTitle": "Paramètres de génération et de raisonnement (O(1), MTP, température)",
+  "models.form.temperature": "Température",
+  "models.form.temperatureHint": "Température de génération (0.0 = déterministe, 1.0+ = créatif).",
+  "models.form.topP": "Top-P (échantillonnage nucleus)",
+  "models.form.topPHint": "Seuil d'échantillonnage (0.0 .. 1.0).",
+  "models.form.maxTokens": "Tokens max.",
+  "models.form.maxTokensHint": "Nombre maximal de tokens générés.",
+  "models.form.thinkBudget": "Mode raisonnement / budget de réflexion",
+  "models.form.thinkBudgetHint": "Budget de tokens de raisonnement (0 = désactivé, N > 0 = maximum de tokens de raisonnement).",
+  "models.form.systemPrompt": "Prompt système par défaut",
+  "models.form.systemPromptHint": "Ajouté automatiquement si la requête ne contient pas de prompt système.",
+  "models.form.systemPromptPlaceholder": "Vous êtes un assistant utile…",
+  "models.form.testKey": "Tester et charger les modèles",
+  "models.form.testing": "vérification…",
+  "models.form.foundModels": "{n} modèles chargés",
+  "models.form.modelPlaceholder": "tapez pour rechercher…",
+  "models.form.modelHint": "Cliquez sur « Tester et charger les modèles » pour récupérer la liste liée à votre clé, puis choisissez-en un.",
+  "models.managed": "géré",
+  "models.managedHint": "Fourni par le serveur CMF géré (Paramètres → Modèles locaux). Configurez-le là-bas.",
+
+  // settings
+  "settings.router.enabled": "Utiliser le routeur (désactivé = modèles locaux uniquement)",
+  "settings.cmf": "Modèles locaux (CMF)",
+  "settings.cmf.localOnly": "Utiliser uniquement les modèles locaux",
+  "settings.cmf.manage": "Lancer un serveur de modèle local",
+  "settings.cmf.autoInstall": "Installer cortiq automatiquement (crates.io)",
+  "settings.cmf.autoUpdate": "Mettre cortiq à jour automatiquement",
+  "settings.cmf.model": "Chemin du modèle .cmf local",
+  "settings.cmf.port": "Port du serveur local",
+  "settings.cmf.modelId": "Identifiant du modèle dans le pool",
+  "settings.cmf.note": "Sert un .cmf local via cortiq (github.com/infosave2007/cmf). Fonctionne même quand le routeur est indisponible.",
+  "settings.cmf.threads": "Threads de travail",
+  "settings.cmf.gpu": "Utiliser le GPU (Metal / wgpu)",
+  "settings.cmf.speedNote": "Les threads parallélisent les matvecs de décodage (~3× plus rapide ; 0 = valeur par défaut du runtime). Le déport GPU aide surtout au prefill des longs prompts — le décodage est limité par la bande passante mémoire, donc sur Apple Silicon l'effet est à peu près neutre.",
+  "settings.cmf.pick": "choisir un modèle",
+  "settings.cmf.models": "Modèles locaux",
+  "settings.cmf.modelsHelp": "Chaque ligne est un modèle que la passerelle exécute (son propre cortiq serve sur son propre port) et enregistre dans le pool. Ajoutez-en autant que vous avez de fichiers .cmf et de ports libres.",
+  "settings.cmf.rowHint": "id · fichier .cmf · port · threads · GPU. Les changements prennent effet au redémarrage ; supprimer une ligne arrête ce serveur.",
+  "settings.cmf.addServer": "+ Ajouter un modèle local",
+  "settings.cmf.checkPort": "Vérifier le port",
+  "settings.cmf.portFree": "port libre",
+  "settings.cmf.portBusy": "port occupé",
+  "settings.cmf.useSuggested": "utiliser {port}",
+  "settings.cmf.serving": "{model} servi sur :{port}",
+  "settings.cmf.intro": "Exécutez des modèles en local avec le moteur cortiq — fonctionne même hors ligne ou quand le routeur est en panne.",
+  "settings.cmf.runtime": "Runtime cortiq",
+  "settings.cmf.runtimeHelp": "L'outil en ligne de commande `cortiq` qui charge et exécute les modèles .cmf. Installez-le une fois avant de démarrer un serveur local.",
+  "settings.cmf.install": "Installer cortiq",
+  "settings.cmf.reinstall": "Réinstaller / mettre à jour",
+  "settings.cmf.installing": "installation… (compilation, quelques minutes)",
+  "settings.cmf.installedOk": "cortiq installé",
+  "settings.cmf.notInstalled": "non installé",
+  "settings.cmf.addModel": "Ajouter un modèle",
+  "settings.cmf.addModelHelp": "Les modèles se téléchargent et se convertissent dans l'onglet Importer (HuggingFace → .cmf). Faites ensuite pointer le serveur local vers le fichier .cmf ci-dessous.",
+  "settings.cmf.importNote": "Pas encore de modèle ? Importez-en un :",
+  "settings.cmf.importLink": "Ouvrir Importer",
+  "settings.cmf.modelHelp": "Chemin du fichier .cmf à servir (par ex. models/qwen.cmf), produit par l'onglet Importer. Plusieurs modèles pour des tâches différentes ? Importez-les et changez ce chemin.",
+  "settings.cmf.portHelp": "Port TCP sur lequel écoute le serveur de modèle local (8081 par défaut). À changer seulement en cas de conflit avec un autre service.",
+  "settings.cmf.threadsHelp": "Nombre de cœurs CPU utilisés pour la génération. Plus = plus rapide (~3× par rapport à un seul cœur) ; 0 laisse le runtime décider.",
+  "settings.cmf.gpuHelp": "Déporter les calculs matriciels sur le GPU (Metal/wgpu). Sur Apple Silicon, cela accélère surtout les longs prompts — le décodage est limité par la bande passante mémoire.",
+  "settings.cmf.localOnlyHelp": "Router chaque requête vers le modèle local, en ignorant le routeur et tous les fournisseurs cloud.",
+  "settings.cmf.manageHelp": "Au démarrage, la passerelle lance `cortiq serve` pour le .cmf ci-dessous et y route les requêtes. Nécessite cortiq installé (étape 1). Prend effet au redémarrage.",
+  "settings.cmf.autoInstallHelp": "Si cortiq est absent au démarrage, l'installer automatiquement depuis crates.io.",
+  "settings.cmf.autoUpdateHelp": "Au démarrage, mettre cortiq à niveau vers la dernière version si elle est plus récente.",
+  "settings.router.enabledHelp": "Laisser le routeur cortiq classer chaque requête (type de tâche + complexité) et choisir un modèle. Désactivé = utiliser uniquement la table de routage locale.",
+  "settings.router.verifyTlsHelp": "Vérifier le certificat TLS du routeur. À désactiver uniquement pour un certificat auto-signé ou lié à une IP.",
+  "settings.telemetry.metricsHelp": "Exposer les métriques Prometheus sur GET /metrics.",
+  "settings.cortiq.echoHelp": "Ajouter un champ `cortiq` (tâche, modèle, coût) au corps de chaque réponse. Les en-têtes de réponse sont toujours envoyés.",
+  "settings.stats.enabledHelp": "Enregistrer les requêtes récentes pour alimenter le tableau de bord et les graphiques.",
+  "settings.cache.enabledHelp": "Cache sémantique : renvoyer une réponse enregistrée quand un nouveau prompt ressemble beaucoup à un précédent, en évitant l'appel au modèle. Nécessite un modèle d'embedding dans le pool.",
+  "settings.log.bodiesHelp": "Journaliser le corps complet des messages de requête et de réponse. Désactivé par défaut pour la confidentialité.",
+  "settings.router.saveKey": "Enregistrer la clé",
+  "settings.router.keySaved": "Clé du routeur enregistrée",
+  "settings.router.keyEmpty": "Collez d'abord la clé",
+  "settings.router.secretHelp": "Collez la clé reçue par e-mail depuis api.allaigate.com, puis cliquez sur Enregistrer la clé. Ce n'est PAS une valeur de « Clés API » — celles-ci servent aux clients qui appellent votre passerelle.",
+  "settings.router.keyStoredMask": "•••••••••••• — clé enregistrée (recollez-en une pour la remplacer)",
+  "settings.route.strategyHelp": "Texte envoyé au routeur pour la classification : last_user = uniquement le dernier message utilisateur ; last_user_plus_system = dernier message utilisateur + prompt système ; concat_all = toute la conversation.",
+  "settings.route.maxCharsHelp": "Nombre maximal de caractères de ce texte envoyés au routeur (au-delà, il est tronqué). Plus = classification plus précise, mais appels au routeur plus lents et plus coûteux.",
+  "settings.route.cacheTtlHelp": "Durée de mise en cache d'une décision de routage pour une requête identique avant de réinterroger le routeur (par ex. 60s, 5m).",
+  "settings.route.profileHelp": "Profil de routage par défaut quand la requête n'en précise aucun : cost-saver (le moins cher), balanced ou quality-first (meilleur modèle). Influence le modèle choisi par le routeur.",
+
+  // import
+  "import.subtitle": "Cherchez sur HuggingFace, convertissez en .cmf local et servez-le.",
+  "import.searchPlaceholder": "Rechercher des modèles HuggingFace (par ex. qwen3, llama)…",
+  "import.searching": "Recherche…",
+  "import.noResults": "Aucun modèle trouvé.",
+  "import.configure": "Configurer la conversion",
+  "import.outName": "Nom de sortie",
+  "import.outNameHint": "Nom du fichier .cmf (lettres, chiffres, - et _).",
+  "import.quant": "Quantification",
+  "import.convert": "Convertir et charger",
+  "import.converting": "Conversion",
+  "import.started": "Conversion lancée",
+  "import.failed": "Échec de la conversion — voir le journal.",
+  "import.register": "Enregistrer comme modèle local",
+  "import.registered": "Enregistré sous « {id} ». Lancez cortiq-server pour le servir.",
+  "import.jobs": "Téléchargements et conversions",
+  "import.cancel": "Annuler",
+  "import.cancelling": "Annulation — nettoyage du fichier incomplet…",
+  "import.delete": "Supprimer",
+  "import.deleteConfirm": "Supprimer ce modèle et son fichier .cmf converti du disque ?",
+  "import.deleted": "Supprimé avec ses fichiers",
+  "import.state.running": "en cours",
+  "import.state.done": "terminé",
+  "import.state.error": "erreur",
+  "import.state.cancelled": "annulé",
+  "import.featuredTitle": "Modèles .cmf prêts à l'emploi",
+  "import.featuredSub": "Modèles .cmf déjà convertis du compte infosave sur HuggingFace — la liste est lue en direct, les nouveaux modèles apparaissent d'eux-mêmes.",
+  "import.readyCmfBadge": ".cmf prêt",
+  "import.directDownload": "Télécharger",
+  "import.q.q8_2f": "8 bits à deux champs (𝒲×θ) — recommandé : meilleur rapport qualité/taille.",
+  "import.q.q8_row": "8 bits par ligne — simple et robuste.",
+  "import.q.q4": "4 bits par bloc — le plus compact, qualité moindre.",
+  "import.q.q4_tiled": "4 bits en tuiles (Q4_TILED) — 1,66× plus rapide sur GPU Metal.",
+  "import.q.vbit": "Variable 3–8 bits — budget de bits par expert.",
+  "import.q.q1t": "Ternaire 1,58 bit (Q1T) — BitNet b1.58 avec valeurs aberrantes éparses.",
+  "import.q.q1s": "1 bit épars (Q1S) — base 1 bit avec valeurs aberrantes holographiques.",
+  "import.q.q1p": "1 bit PTQ (Q1P) — 1 bit avec diffusion d'erreur.",
+  "import.q.q1": "1 bit (Q1) — format purement binaire.",
+  "import.q.f16": "16 bits — sans quantification.",
+  "import.q.f32": "32 bits — pleine précision (fichier volumineux).",
+  "import.adv.title": "Paramètres avancés",
+  "import.adv.auto": "auto",
+  "import.adv.linearCore": "Cœur linéaire",
+  "import.adv.linearHint": "Comment les couches d'attention linéaire sont reportées ou fusionnées.",
+  "import.adv.nphase": "vmf_phase phases/tête",
+  "import.adv.vbitShape": "Forme du budget VBIT",
+  "import.adv.meanBits": "Bits moyens VBIT",
+  "import.adv.shard": "Taille max. des shards (Go)",
+  "import.adv.noShard": "pas de découpage",
+  "import.adv.skipMtp": "ignorer la tête MTP",
+  "import.adv.o1": "Attention O(1)",
+  "import.adv.o1Hint": "Attention en flux à mémoire constante : le cache KV est libéré après le prefill, la mémoire ne croît donc pas avec de longs contextes. Les poids restent identiques octet pour octet — seule une indication de chargement est enregistrée ; vous pouvez revenir en arrière à tout moment (servir avec --o1 off). Validé sur Qwen3-0.6B : toutes couches ≈ ×1,18 de perplexité.",
+  "import.adv.o1Off": "désactivé — attention exacte (par défaut)",
+  "import.adv.o1All": "all — convertir chaque couche softmax",
+  "import.adv.o1Deep": "deep N — seulement les N couches les plus profondes",
+  "import.adv.o1Custom": "personnalisé — liste explicite de couches",
+  "import.adv.o1DeepN": "N couches profondes",
+  "import.adv.o1Layers": "Couches (séparées par des virgules)",
+  "import.adv.o1mHint": "budget de landmarks (32 par défaut)",
+  "import.adv.o1windowHint": "largeur de la fenêtre exacte (128 par défaut)",
+  "import.adv.o1sinkHint": "clés sink exactes permanentes (4 par défaut)",
+
+  // onboarding
+  "onboarding.title": "Configuration initiale",
+  "onboarding.welcome": "Bienvenue dans Cortiq Gateway",
+  "onboarding.welcomeSub": "Choisissez votre langue — vous pourrez la changer à tout moment dans l'en-tête.",
+  "onboarding.next": "Suivant",
+  "onboarding.back": "Retour",
+  "onboarding.skip": "Passer pour l'instant",
+  "onboarding.skipSetup": "Passer",
+  "onboarding.finish": "Terminer la configuration",
+  "onboarding.featuredTitle": "Modèles prêts à l'emploi (en un clic)",
+  "onboarding.featuredSub": "Ce sont des modèles .cmf déjà convertis, publiés par infosave sur HuggingFace — il suffit de les télécharger, aucune conversion nécessaire. Choisissez-en un ou plusieurs pour démarrer immédiatement.",
+  "onboarding.download": "Télécharger",
+  "onboarding.hfTitle": "N'importe quel modèle HuggingFace — conversion automatique",
+  "onboarding.hfSub": "Cherchez un modèle, choisissez une quantification, et nous le convertissons automatiquement en .cmf. Aucune modification manuelle de la configuration.",
+  "onboarding.noJobs": "Aucun téléchargement pour l'instant.",
+  "onboarding.doneTitle": "Tout est prêt",
+  "onboarding.doneSub": "Les modèles téléchargés seront enregistrés automatiquement. Vous pourrez en ajouter d'autres dans Importer ou Modèles.",
+  "onboarding.doneHint": "« Terminer la configuration » connecte chaque téléchargement achevé comme modèle local, démarre son serveur .cmf et y dirige le routage. Tout cela reste modifiable ensuite dans Modèles.",
+  "onboarding.willRegister": "Seront connectés comme modèles locaux",
+  "onboarding.nothingToRegister": "Aucun téléchargement terminé — rien à connecter. Revenez à l'étape précédente pour choisir un modèle.",
+  "onboarding.registeredN": "{n} modèle(s) connecté(s) : {ids}",
+  "onboarding.runtimeMissing": "Le runtime cortiq n'est pas installé — installez-le dans Paramètres → Modèles locaux pour les servir.",
+  "onboarding.downloaded": "téléchargé",
+  "onboarding.update": "Mettre à jour",
+  "onboarding.deleteFile": "Supprimer le fichier .cmf du disque",
+  "onboarding.confirmDelete": "Supprimer « {id} » ? Le fichier .cmf sera retiré du disque.",
+  "onboarding.unregistered": "Également désenregistré : {ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "Chat",
+  "pg.tab.image": "Image",
+  "pg.tab.video": "Vidéo",
+  "pg.generate": "Générer",
+  "pg.generating": "Génération…",
+  "pg.genFailed": "Échec de la génération — voir le journal.",
+  "pg.result": "Résultat",
+  "pg.genMetrics": "Métriques de génération",
+  "pg.imagePromptPlaceholder": "un renard roux dans la neige au coucher du soleil, photoréaliste, fourrure détaillée",
+  "pg.videoPromptPlaceholder": "un corgi en toque de chef fait sauter une crêpe, grésillements et aboiement joyeux",
+  "pg.imageEmpty": "L'image générée apparaîtra ici.",
+  "pg.videoEmpty": "Le clip généré (avec le son) apparaîtra ici.",
+  "pg.width": "Largeur",
+  "pg.height": "Hauteur",
+  "pg.steps": "Étapes",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "Seed aléatoire",
+  "pg.cfgHint": "Force du guidance ; ≤ 1 désactive le CFG et divise le travail par deux.",
+  "pg.frames": "Images",
+  "pg.framesHint": "À 24 fps ; arrondi à la grille du modèle.",
+  "pg.quality": "Qualité JPEG",
+  "pg.videoSizeHint": "Multiples de 32 ; le petit côté entraîné est 768.",
+  "pg.videoStepsHint": "La LoRA Turbo est entraînée pour 4 étapes.",
+  "pg.firstFrame": "Première image (optionnel)",
+  "pg.lastFrame": "Dernière image (optionnel)",
+  "pg.keyframeHint": "Transforme la génération en keyframe-to-video.",
+  "pg.resolution": "Résolution",
+  "pg.genTime": "Temps de génération",
+  "pg.timePerStep": "Par étape",
+  "pg.timePerFrame": "Par image",
+  "pg.fileSize": "Taille du fichier",
+  "pg.duration": "Durée",
+  "pg.play": "Lire",
+  "pg.noMediaModels": "Pas encore de modèle {kind} local. Téléchargez-en un (par ex. de la collection infosave) dans Importer :",
+  "pg.tokSpeed": "Vitesse",
+  "pg.ttft": "Premier token",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "Journaux",
+  "logs.subtitle": "Journal récent de la passerelle — ce que montrerait le terminal.",
+  "logs.filterPlaceholder": "filtrer…",
+  "logs.pause": "Pause",
+  "logs.resume": "Reprendre",
+  "logs.empty": "Rien ne correspond.",
+  "notice.openAdmin": "La console est ouverte sans jeton et accessible depuis d'autres machines. Définissez un jeton si cette machine n'est pas privée.",
+  "notice.update": "Mise à jour disponible : v{v}.",
+  "dash.sys.title": "Système",
+  "dash.sys.cores": "cœurs",
+  "dash.sys.disk": "Disque (modèles)",
+  "dash.sys.free": "libre",
+  "dash.sys.gateway": "passerelle",
+  "fit.disk": "espace disque insuffisant",
+  "fit.diskTitle": "Le téléchargement dépasse l'espace libre du disque des modèles.",
+  "fit.ram": "risque de ne pas tenir en RAM",
+  "fit.ramTitle": "Le modèle approche ou dépasse la RAM de cette machine — il pourrait ne pas tourner.",
+  "pg.eta": "restant",
+  "pg.min": "min",
+  "pg.queued": "En file d'attente — position {n}. Démarre dès la fin de la génération en cours.",
+  "pg.gallery": "Générations récentes",
+  "pg.galDeleteConfirm": "Supprimer cette génération et ses fichiers ?",
+  "pg.clearChat": "Effacer",
+  "keys.snip.title": "Connecter votre application",
+  "keys.snip.hint": "Collez un de ces exemples dans votre projet — seul le espace réservé de la clé est à remplacer.",
+  "keys.snip.withKey": "Les exemples ci-dessous incluent la clé que vous venez de créer.",
+  "keys.snip.openMode": "Aucune clé API configurée — la passerelle accepte n'importe quelle valeur.",
+  "keys.snip.keyPh": "votre clé API",
+  "settings.restart": "Redémarrer la passerelle",
+  "settings.restartConfirm": "Redémarrer la passerelle ? Les requêtes en cours seront coupées ; les serveurs de modèles locaux redémarrent aussi.",
+  "settings.restarting": "Redémarrage — la page se recharge dès que la passerelle revient…",
+  "bench.title": "Vitesse des modèles locaux",
+  "bench.hint": "Exécute `cortiq bench` sur cette machine — de vrais tok/s, un modèle à la fois.",
+  "bench.run": "Mesurer",
+  "bench.running": "mesure…",
+  "bench.failed": "échec",
+  "bench.none": "Pas encore de modèles de chat .cmf locaux.",
+
+  // task-based routing
+  "task.chitchat": "Bavardage",
+  "task.code": "Code",
+  "task.creative-writing": "Écriture créative",
+  "task.extraction": "Extraction de données",
+  "task.math": "Mathématiques",
+  "task.qa": "Questions-réponses",
+  "task.summarization": "Résumé",
+  "task.translation": "Traduction",
+  "routing.tasks.title": "Routage par tâche",
+  "routing.tasks.hint": "Les modèles d'une règle passent en premier pour leur tâche ; la chaîne par complexité reste en secours. Vide = complexité seule.",
+  "routing.tasks.inherit": "par complexité (aucune règle)",
+  "routing.tasks.share": "{p}% des requêtes (7 j)",
+  "routing.tasks.fromRouter": "étiquettes reçues du routeur",
+  "routing.tasks.builtin": "routeur injoignable — jeu d'étiquettes intégré",
+  "routing.tasks.addCustom": "Ajouter une tâche",
+  "routing.tasks.addPlaceholder": "étiquette personnalisée…",
+
+  // benchmark view
+  "nav.benchmark": "Benchmark",
+  "bm.title": "Benchmark",
+  "bm.subtitle": "Sondes de qualité et de vitesse via le pipeline en direct : réponses vérifiées par mots-clés, boucles détectées, tok/s et temps du premier token par modèle.",
+  "bm.models": "Modèles à tester",
+  "bm.quickMode": "Test rapide",
+  "bm.quickHint": "Le sous-ensemble rapide aux réponses courtes — environ une minute par modèle local.",
+  "bm.suiteInfo": "Suite intégrée : {q} tests rapides / {f} complets, plus les vôtres.",
+  "bm.run": "Lancer",
+  "bm.pickModel": "Choisissez au moins un modèle.",
+  "bm.testOf": "test {i} sur {n}",
+  "bm.results": "Résultats",
+  "bm.quick": "rapide",
+  "bm.test": "Test",
+  "bm.cellHint": "Cliquez sur une cellule pour voir la réponse complète.",
+  "bm.history": "Exécutions précédentes (stockées dans ce navigateur)",
+  "bm.custom": "Tests personnalisés",
+  "bm.customHint": "Prompt + mots-clés séparés par des virgules que la réponse doit contenir (| pour les synonymes). Stockés dans ce navigateur.",
+  "bm.promptPh": "prompt…",
+  "bm.checkPh": "mots-clés, séparés par des virgules",
+  "bm.addTest": "Ajouter un test",
+  "bm.emptyAnswer": "réponse vide",
+  "bm.loopDetected": "boucle détectée",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "Routage intelligent",
+  "bm.mode.models": "Modèles individuels",
+  "bm.mode.routingDesc": "La fonctionnalité clé du produit à l'épreuve : chaque sonde passe par cortiq-auto — vous voyez quelle tâche le routeur a détectée, quel modèle il a choisi, si cela correspond aux attentes et combien cela a coûté.",
+  "bm.mode.modelsDesc": "La même suite épinglée aux modèles choisis — comparez leur qualité, vitesse et coût en direct, sans passer par le routeur.",
+  "bm.answersOk": "réponses correctes",
+  "bm.classAcc": "classification des tâches",
+  "bm.modelDist": "Requêtes envoyées vers",
+  "bm.expectedLbl": "attendu :",
+  "bm.answer": "Réponse",
+  "bm.liveRunning": "en cours…",
+  "bm.spent": "dépensé",
+  "bm.verdict": "🏁 Terminé : réponses {p}, dépensé {s}",
+  "bm.clearHistory": "Tout effacer",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — collez dans le terminal (la passerelle parle nativement le protocole Anthropic) :",
+  "keys.h.codex": "Codex — ajoute le fournisseur à ~/.codex/config.toml et démarre :",
+  "keys.h.opencode": "OpenCode — écrit ~/.config/opencode/opencode.json (écrase !) et démarre :",
+  "keys.h.continue": "Continue (VS Code / JetBrains) — ajoute le modèle à ~/.continue/config.yaml :",
+  "keys.h.cline1": "Cline (VS Code) — dans les réglages de l'extension, choisissez :",
+  "keys.h.cline2": "Réglages → API Provider → OpenAI Compatible, puis collez les valeurs ci-dessus.",
+  "keys.h.note": "cortiq-auto = routage intelligent : le routeur choisit le modèle à chaque requête. Pour en fixer un, indiquez son nom exact. Sous Windows, lancez les scripts dans Git Bash / WSL ou définissez les mêmes variables via l'environnement système.",
+  "keys.h.protoOff": "Le protocole Anthropic (/v1/messages) est désactivé — Claude Code ne pourra pas se connecter.",
+  "keys.h.enableProto": "Activer",
+  "keys.h.st.installed": "Installé sur la machine de la passerelle",
+  "keys.h.st.configured": "Déjà configuré pour cette passerelle",
+  "keys.h.st.notFound": "Introuvable sur la machine de la passerelle",
+  "bm.degraded": "routeur dégradé",
+  "bm.routerDegraded": "Le routeur n'a pas répondu à temps — la requête a suivi la chaîne de secours ; la classification n'est pas comptée.",
+  "bm.cutByCap": "budget épuisé en raisonnement — pas de réponse",
+  "shell.uiStale": "La passerelle a été mise à jour — cette page utilise une ancienne interface.",
+  "shell.reload": "Recharger",
+  "keys.col.requests": "Requêtes",
+  "keys.col.tokens": "Tokens in/out",
+  "keys.col.costAll": "$ au total",
+  "routing.tasks.tier": "Complexité",
+  "routing.tasks.tierAuto": "Auto (routeur)",
+  "routing.tasks.tierHint": "Quel modèle sert cette tâche à quelle complexité ; « toute » mène à tous les niveaux. L'ordre = ordre de repli. Un verdict high escalade toujours au-dessus des entrées « toute ».",
+  "routing.tasks.tierAny": "toute complexité",
+  "routing.tasks.addModel": "modèle",
+  "routing.bands.enable": "Mes limites de complexité",
+  "routing.bands.hint": "Faites glisser les poignées : où finit low et où commence high — elles se poussent l'une l'autre, les chiffres se mettent à jour en direct. Le score continu du routeur est re-découpé avec VOS limites ; décoché = les bandes du routeur.",
+  "tier.low": "facile",
+  "tier.medium": "moyen",
+  "tier.high": "difficile",
 };

web/js/i18n/ru.js

@@ -31,7 +31,7 @@ export default {
   "nav.routing": "Роутинг",
   "nav.protocols": "Протоколы",
   "nav.keys": "API-ключи",
-  "nav.playground": "Playground",
+  "nav.playground": "Песочница",
   "nav.settings": "Настройки",
   "nav.foot": "Шлюз · v{v}",
   "nav.billing": "Ключ роутера и оплата",
@@ -80,7 +80,7 @@ export default {
   "dash.groupby.label": "по задаче",
   "dash.groupby.account": "по аккаунту",
   "dash.recent.title": "Последние запросы",
-  "dash.recent.empty": "Запросов ещё нет. Попробуйте Playground.",
+  "dash.recent.empty": "Запросов ещё нет. Попробуйте Песочницу.",
   "dash.col.time": "Время",
   "dash.col.model": "Модель",
   "dash.col.tier": "Уровень",
@@ -219,7 +219,7 @@ export default {
   "keys.allowAll": "все",
 
   // playground
-  "pg.title": "Playground",
+  "pg.title": "Песочница",
   "pg.subtitle": "Отправьте запрос через активный пайплайн и изучите решение роутера.",
   "pg.system": "Системный промпт",
   "pg.systemPlaceholder": "необязательное системное сообщение",
@@ -396,6 +396,7 @@ export default {
   "import.state.error": "ошибка",
   "import.state.cancelled": "отменено",
   "import.featuredTitle": "Рекомендуемые готовые .cmf модели",
+  "import.featuredSub": "Готовые .cmf модели из аккаунта infosave на HuggingFace — список читается вживую, новые модели появляются здесь сами.",
   "import.readyCmfBadge": "Готовая .cmf",
   "import.directDownload": "Скачать",
   "import.q.q8_2f": "8-бит двухполевой (𝒲×θ) — рекомендуется: лучшее качество/размер.",
@@ -431,4 +432,198 @@ export default {
   "import.adv.o1mHint": "число опорных точек (по умолчанию 32)",
   "import.adv.o1windowHint": "ширина точного окна (по умолчанию 128)",
   "import.adv.o1sinkHint": "постоянные точные sink-ключи (по умолчанию 4)",
+
+  // онбординг (первый запуск)
+  "onboarding.title": "Первоначальная настройка",
+  "onboarding.welcome": "Добро пожаловать в Cortiq Gateway",
+  "onboarding.welcomeSub": "Выберите язык — его можно сменить в шапке в любой момент.",
+  "onboarding.next": "Далее",
+  "onboarding.back": "Назад",
+  "onboarding.skip": "Пропустить",
+  "onboarding.skipSetup": "Пропустить",
+  "onboarding.finish": "Завершить",
+  "onboarding.featuredTitle": "Готовые модели в один клик",
+  "onboarding.featuredSub": "Это уже сконвертированные .cmf модели от infosave на HuggingFace — просто Скачать, без конвертации. Выберите одну или несколько для мгновенного старта.",
+  "onboarding.download": "Скачать",
+  "onboarding.hfTitle": "Любая модель с HuggingFace — автоконвертация",
+  "onboarding.hfSub": "Найдите любую модель, выберите квантизацию — мы автоматически сконвертируем её в .cmf. Никаких ручных правок конфига.",
+  "onboarding.noJobs": "Пока нет загрузок.",
+  "onboarding.doneTitle": "Готово",
+  "onboarding.doneSub": "Скачанные модели зарегистрируются автоматически. Добавить ещё можно во вкладке Импорт или Модели.",
+  "onboarding.doneHint": "Кнопка «Завершить» подключит все скачанные модели как локальные, поднимет для них .cmf сервер и настроит роутинг. Всё это потом можно изменить во вкладке Модели.",
+  "onboarding.willRegister": "Будут подключены как локальные модели",
+  "onboarding.nothingToRegister": "Завершённых загрузок пока нет — подключать нечего. Вернитесь на шаг назад и выберите модель.",
+  "onboarding.registeredN": "Подключено моделей: {n} — {ids}",
+  "onboarding.runtimeMissing": "Среда cortiq не установлена — установите её в Настройки → Локальные модели, чтобы запускать эти модели.",
+  "onboarding.downloaded": "скачана",
+  "onboarding.update": "Обновить",
+  "onboarding.deleteFile": "Удалить файл .cmf с диска",
+  "onboarding.confirmDelete": "Удалить «{id}»? Файл .cmf будет удалён с диска.",
+  "onboarding.unregistered": "Также отключено из моделей: {ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "Чат",
+  "pg.tab.image": "Изображение",
+  "pg.tab.video": "Видео",
+  "pg.generate": "Сгенерировать",
+  "pg.generating": "Генерация…",
+  "pg.genFailed": "Генерация не удалась — смотрите лог.",
+  "pg.result": "Результат",
+  "pg.genMetrics": "Метрики генерации",
+  "pg.imagePromptPlaceholder": "рыжая лиса в снегу на закате, фотореалистично, детальный мех",
+  "pg.videoPromptPlaceholder": "корги в поварском колпаке подбрасывает блин, шипение сковороды и весёлый лай",
+  "pg.imageEmpty": "Сгенерированное изображение появится здесь.",
+  "pg.videoEmpty": "Сгенерированный ролик (со звуком) появится здесь.",
+  "pg.width": "Ширина",
+  "pg.height": "Высота",
+  "pg.steps": "Шаги",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "Случайный seed",
+  "pg.cfgHint": "Сила guidance; ≤ 1 отключает CFG и вдвое ускоряет генерацию.",
+  "pg.frames": "Кадры",
+  "pg.framesHint": "При 24 fps; округляется до сетки модели.",
+  "pg.quality": "Качество JPEG",
+  "pg.videoSizeHint": "Кратно 32; обученная короткая сторона — 768.",
+  "pg.videoStepsHint": "Turbo LoRA обучена на 4 шага.",
+  "pg.firstFrame": "Первый кадр (необязательно)",
+  "pg.lastFrame": "Последний кадр (необязательно)",
+  "pg.keyframeHint": "Превращает запуск в keyframe-to-video.",
+  "pg.resolution": "Разрешение",
+  "pg.genTime": "Время генерации",
+  "pg.timePerStep": "На шаг",
+  "pg.timePerFrame": "На кадр",
+  "pg.fileSize": "Размер файла",
+  "pg.duration": "Длительность",
+  "pg.play": "Играть",
+  "pg.noMediaModels": "Локальной модели ({kind}) ещё нет. Скачайте её (например, из коллекции infosave) во вкладке Импорт:",
+  "pg.tokSpeed": "Скорость",
+  "pg.ttft": "Первый токен",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "Логи",
+  "logs.subtitle": "Последние записи журнала шлюза — то, что показал бы терминал.",
+  "logs.filterPlaceholder": "фильтр…",
+  "logs.pause": "Пауза",
+  "logs.resume": "Продолжить",
+  "logs.empty": "Ничего не найдено.",
+  "notice.openAdmin": "Панель управления открыта без токена и доступна с других машин. Задайте токен, если эта машина не приватная.",
+  "notice.update": "Доступно обновление: v{v}.",
+  "dash.sys.title": "Система",
+  "dash.sys.cores": "ядер",
+  "dash.sys.disk": "Диск (модели)",
+  "dash.sys.free": "свободно",
+  "dash.sys.gateway": "шлюз",
+  "fit.disk": "не хватит места",
+  "fit.diskTitle": "Загрузка больше свободного места на диске с моделями.",
+  "fit.ram": "может не влезть в RAM",
+  "fit.ramTitle": "Модель сравнима с объёмом RAM этой машины или больше — может не запуститься.",
+  "pg.eta": "осталось",
+  "pg.min": "мин",
+  "pg.queued": "В очереди — позиция {n}. Стартует, как только закончится текущая генерация.",
+  "pg.gallery": "Последние генерации",
+  "pg.galDeleteConfirm": "Удалить эту генерацию и её файлы?",
+  "pg.clearChat": "Очистить",
+  "keys.snip.title": "Подключите ваше приложение",
+  "keys.snip.hint": "Вставьте один из примеров в свой проект — заменить нужно только плейсхолдер ключа.",
+  "keys.snip.withKey": "В примерах ниже уже подставлен только что созданный ключ.",
+  "keys.snip.openMode": "API-ключи не настроены — шлюз принимает любое значение ключа.",
+  "keys.snip.keyPh": "ваш API-ключ",
+  "settings.restart": "Перезапустить шлюз",
+  "settings.restartConfirm": "Перезапустить шлюз? Текущие запросы оборвутся; серверы локальных моделей тоже перезапустятся.",
+  "settings.restarting": "Перезапуск — страница обновится, когда шлюз поднимется…",
+  "bench.title": "Скорость локальных моделей",
+  "bench.hint": "Запускает `cortiq bench` на этой машине — реальные tok/s, по одной модели за раз.",
+  "bench.run": "Замерить",
+  "bench.running": "замер…",
+  "bench.failed": "ошибка",
+  "bench.none": "Локальных чат-моделей .cmf пока нет.",
+
+  // task-based routing
+  "task.chitchat": "Светская беседа",
+  "task.code": "Код",
+  "task.creative-writing": "Творческие тексты",
+  "task.extraction": "Извлечение данных",
+  "task.math": "Математика",
+  "task.qa": "Вопросы и ответы",
+  "task.summarization": "Суммаризация",
+  "task.translation": "Перевод",
+  "routing.tasks.title": "Распределение по задачам",
+  "routing.tasks.hint": "Модели правила идут первыми для своей задачи; цепочка по сложности остаётся резервом. Пусто = только по сложности.",
+  "routing.tasks.inherit": "по сложности (без правила)",
+  "routing.tasks.share": "{p}% запросов (7д)",
+  "routing.tasks.fromRouter": "метки получены с роутера",
+  "routing.tasks.builtin": "роутер недоступен — встроенный набор меток",
+  "routing.tasks.addCustom": "Добавить задачу",
+  "routing.tasks.addPlaceholder": "своя метка…",
+
+  // benchmark view
+  "nav.benchmark": "Бенчмарк",
+  "bm.title": "Бенчмарк",
+  "bm.subtitle": "Проверки качества и скорости через живой пайплайн: ответы сверяются по ключевым словам, ловится зацикливание, замеряются tok/s и время первого токена.",
+  "bm.models": "Какие модели тестировать",
+  "bm.quickMode": "Быстрый тест",
+  "bm.quickHint": "Короткое подмножество с краткими ответами — около минуты на локальную модель.",
+  "bm.suiteInfo": "Встроенный набор: {q} быстрых / {f} полных тестов, плюс ваши собственные.",
+  "bm.run": "Запустить",
+  "bm.pickModel": "Выберите хотя бы одну модель.",
+  "bm.testOf": "тест {i} из {n}",
+  "bm.results": "Результаты",
+  "bm.quick": "быстрый",
+  "bm.test": "Тест",
+  "bm.cellHint": "Клик по ячейке — полный ответ модели.",
+  "bm.history": "Прошлые прогоны (хранятся в этом браузере)",
+  "bm.custom": "Свои тесты",
+  "bm.customHint": "Промпт + ключевые слова через запятую, которые должны быть в ответе (| — синонимы). Хранятся в этом браузере.",
+  "bm.promptPh": "промпт…",
+  "bm.checkPh": "ключевые слова через запятую",
+  "bm.addTest": "Добавить тест",
+  "bm.emptyAnswer": "пустой ответ",
+  "bm.loopDetected": "зацикливание",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "Умный роутинг",
+  "bm.mode.models": "Отдельные модели",
+  "bm.mode.routingDesc": "Проверка главной фишки продукта: каждый тест идёт через cortiq-auto — видно, какую задачу распознал роутер, какую модель выбрал, совпало ли это с ожиданием и сколько это стоило.",
+  "bm.mode.modelsDesc": "Тот же набор тестов, но закреплённый за выбранными моделями — сравнение их качества, скорости и стоимости напрямую, мимо роутера.",
+  "bm.answersOk": "ответы верны",
+  "bm.classAcc": "классификация задач",
+  "bm.modelDist": "Запросы ушли в",
+  "bm.expectedLbl": "ожидалось:",
+  "bm.answer": "Ответ",
+  "bm.liveRunning": "идёт…",
+  "bm.spent": "потрачено",
+  "bm.verdict": "🏁 Готово: ответы {p}, потрачено {s}",
+  "bm.clearHistory": "Очистить всё",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — вставьте в терминал (шлюз говорит на протоколе Anthropic нативно):",
+  "keys.h.codex": "Codex — добавит провайдера в ~/.codex/config.toml и запустит:",
+  "keys.h.opencode": "OpenCode — запишет ~/.config/opencode/opencode.json (перезапишет!) и запустит:",
+  "keys.h.continue": "Continue (VS Code / JetBrains) — добавит модель в ~/.continue/config.yaml:",
+  "keys.h.cline1": "Cline (VS Code) — в настройках расширения укажите:",
+  "keys.h.cline2": "Настройки → API Provider → OpenAI Compatible, затем вставьте значения выше.",
+  "keys.h.note": "cortiq-auto — умный роутинг: роутер сам выбирает модель под каждый запрос. Чтобы закрепить конкретную, укажите её точное имя. На Windows запускайте скрипты в Git Bash / WSL или задайте те же переменные через настройки окружения системы.",
+  "keys.h.protoOff": "Протокол Anthropic (/v1/messages) выключен — Claude Code не подключится.",
+  "keys.h.enableProto": "Включить",
+  "keys.h.st.installed": "Установлен на машине шлюза",
+  "keys.h.st.configured": "Уже настроен на этот шлюз",
+  "keys.h.st.notFound": "Не найден на машине шлюза",
+  "bm.degraded": "роутер деградировал",
+  "bm.routerDegraded": "Роутер не успел ответить — запрос ушёл по резервной цепочке; классификация не засчитывается.",
+  "bm.cutByCap": "бюджет ушёл на размышления — ответ не успел",
+  "shell.uiStale": "Шлюз обновился — на этой странице старый интерфейс.",
+  "shell.reload": "Перезагрузить",
+  "keys.col.requests": "Запросы",
+  "keys.col.tokens": "Токены вх/исх",
+  "keys.col.costAll": "$ за всё время",
+  "routing.tasks.tier": "Сложность",
+  "routing.tasks.tierAuto": "Авто (по роутеру)",
+  "routing.tasks.tierHint": "Какая модель обслуживает задачу на какой сложности; «любая» ведёт на всех уровнях. Порядок = порядок фолбэка. Вердикт high по-прежнему эскалирует поверх «любых».",
+  "routing.tasks.tierAny": "любая сложность",
+  "routing.tasks.addModel": "модель",
+  "routing.bands.enable": "Мои границы сложности",
+  "routing.bands.hint": "Тяните ручки: где кончается low и где начинается high — ручки толкают друг друга, цифры обновляются на лету. Непрерывный score роутера пересчитывается ВАШИМИ границами; галочка снята — действуют пороги самого роутера.",
+  "tier.low": "лёгкий",
+  "tier.medium": "средний",
+  "tier.high": "сложный",
 };

web/js/i18n/tr.js

@@ -280,4 +280,358 @@ export default {
   "settings.cache.ttl": "Giriş TTL",
   "settings.cache.embed": "Gömme modeli",
   "settings.cache.note": "Anlamsal önbellek ayarları yeniden başlatmadan sonra geçerli olur.",
+
+  // ── translated from en.js (previously falling back to English) ──
+  // nav
+  "nav.import": "Model içe aktar",
+
+  // dash
+  "dash.clear": "Günlükleri temizle",
+  "dash.clearConfirm": "Kaydedilmiş tüm istatistikler ve günlükler silinsin mi? Bu işlem geri alınamaz.",
+  "dash.cleared": "Günlükler temizlendi",
+
+  // models
+  "models.form.idOrModel": "Bir id ya da model adı girin",
+  "models.form.apiKey": "API anahtarı",
+  "models.form.apiKeyPlaceholder": "API anahtarınızı yapıştırın",
+  "models.form.apiKeyNotNeeded": "gerekmiyor (yerel sunucu)",
+  "models.form.apiKeyHint": "Ağ geçidinde güvenle saklanır; bir daha gösterilmez.",
+  "models.form.keyStored": "Kayıtlı bir anahtar var — korumak için boş bırakın ya da yenisini yapıştırın.",
+  "models.form.keyFromEnv": "Ortam değişkenindeki anahtar kullanılıyor.",
+  "models.form.paramsTitle": "Üretim ve düşünme parametreleri (O(1), MTP, sıcaklık)",
+  "models.form.temperature": "Sıcaklık",
+  "models.form.temperatureHint": "Üretim sıcaklığı (0.0 = belirlenimci, 1.0+ = yaratıcı).",
+  "models.form.topP": "Top-P (nucleus örnekleme)",
+  "models.form.topPHint": "Örnekleme eşiği (0.0 .. 1.0).",
+  "models.form.maxTokens": "Maks. token",
+  "models.form.maxTokensHint": "Üretilecek en fazla token sayısı.",
+  "models.form.thinkBudget": "Düşünme modu / düşünme bütçesi",
+  "models.form.thinkBudgetHint": "Akıl yürütme token bütçesi (0 = kapalı, N > 0 = en fazla akıl yürütme tokeni).",
+  "models.form.systemPrompt": "Varsayılan sistem istemi",
+  "models.form.systemPromptHint": "İstekte sistem istemi yoksa otomatik olarak başa eklenir.",
+  "models.form.systemPromptPlaceholder": "Yardımsever bir asistansın…",
+  "models.form.testKey": "Test et ve modelleri yükle",
+  "models.form.testing": "kontrol ediliyor…",
+  "models.form.foundModels": "{n} model yüklendi",
+  "models.form.modelPlaceholder": "aramak için yazın…",
+  "models.form.modelHint": "Anahtarınızla listeyi çekmek için “Test et ve modelleri yükle”ye tıklayın, sonra birini seçin.",
+  "models.managed": "yönetilen",
+  "models.managedHint": "Yönetilen CMF sunucusu tarafından sağlanır (Ayarlar → Yerel modeller). Yapılandırmayı orada yapın.",
+
+  // settings
+  "settings.router.enabled": "Yönlendiriciyi kullan (kapalı = yalnızca yerel modeller)",
+  "settings.cmf": "Yerel modeller (CMF)",
+  "settings.cmf.localOnly": "Yalnızca yerel modelleri kullan",
+  "settings.cmf.manage": "Yerel model sunucusu çalıştır",
+  "settings.cmf.autoInstall": "cortiq'i otomatik kur (crates.io)",
+  "settings.cmf.autoUpdate": "cortiq'i otomatik güncelle",
+  "settings.cmf.model": "Yerel .cmf model yolu",
+  "settings.cmf.port": "Yerel sunucu portu",
+  "settings.cmf.modelId": "Havuzdaki model id'si",
+  "settings.cmf.note": "Yerel bir .cmf dosyasını cortiq ile sunar (github.com/infosave2007/cmf). Yönlendirici erişilemez olsa bile çalışır.",
+  "settings.cmf.threads": "İş parçacıkları",
+  "settings.cmf.gpu": "GPU kullan (Metal / wgpu)",
+  "settings.cmf.speedNote": "İş parçacıkları çözme aşamasındaki matris-vektör çarpımlarını paralelleştirir (~3× hızlı; 0 = çalışma zamanı varsayılanı). GPU'ya aktarım daha çok uzun istemlerin prefill aşamasına yarar — çözme bellek bant genişliğine bağlı olduğundan Apple Silicon'da etkisi yaklaşık nötrdür.",
+  "settings.cmf.pick": "bir model seçin",
+  "settings.cmf.models": "Yerel modeller",
+  "settings.cmf.modelsHelp": "Her satır, ağ geçidinin çalıştırdığı (kendi portunda kendi cortiq serve süreci olan) ve havuza kaydettiği bir modeldir. Kaç .cmf dosyanız ve boş portunuz varsa o kadar ekleyebilirsiniz.",
+  "settings.cmf.rowHint": "id · .cmf dosyası · port · iş parçacığı · GPU. Değişiklikler yeniden başlatınca geçerli olur; satırı silmek o sunucuyu durdurur.",
+  "settings.cmf.addServer": "+ Yerel model ekle",
+  "settings.cmf.checkPort": "Portu kontrol et",
+  "settings.cmf.portFree": "port boş",
+  "settings.cmf.portBusy": "port kullanımda",
+  "settings.cmf.useSuggested": "{port} kullan",
+  "settings.cmf.serving": "{model} :{port} üzerinde sunuluyor",
+  "settings.cmf.intro": "Modelleri cortiq motoruyla yerelde çalıştırın — çevrimdışıyken ya da yönlendirici çöktüğünde bile çalışır.",
+  "settings.cmf.runtime": "cortiq çalışma zamanı",
+  "settings.cmf.runtimeHelp": ".cmf modellerini yükleyip çalıştıran `cortiq` komut satırı aracı. Yerel sunucuyu başlatmadan önce bir kez kurun.",
+  "settings.cmf.install": "cortiq'i kur",
+  "settings.cmf.reinstall": "Yeniden kur / güncelle",
+  "settings.cmf.installing": "kuruluyor… (derleniyor, birkaç dakika)",
+  "settings.cmf.installedOk": "cortiq kuruldu",
+  "settings.cmf.notInstalled": "kurulu değil",
+  "settings.cmf.addModel": "Model ekle",
+  "settings.cmf.addModelHelp": "Modeller “Model içe aktar” sekmesinde indirilip dönüştürülür (HuggingFace → .cmf). Sonra aşağıdaki yerel sunucuyu o .cmf dosyasına yönlendirin.",
+  "settings.cmf.importNote": "Henüz model yok mu? Bir tane içe aktarın:",
+  "settings.cmf.importLink": "İçe aktarmayı aç",
+  "settings.cmf.modelHelp": "Sunulacak .cmf dosyasının yolu (ör. models/qwen.cmf), içe aktarma sekmesinde üretilir. Farklı görevler için birden çok model mi? Hepsini içe aktarıp bu yolu değiştirin.",
+  "settings.cmf.portHelp": "Yerel model sunucusunun dinlediği TCP portu (varsayılan 8081). Yalnızca başka bir servisle çakışırsa değiştirin.",
+  "settings.cmf.threadsHelp": "Üretim için kaç CPU çekirdeği kullanılacağı. Daha fazlası = daha hızlı (tek çekirdeğe göre ~3×); 0 seçimi çalışma zamanına bırakır.",
+  "settings.cmf.gpuHelp": "Matris hesaplarını GPU'ya aktarır (Metal/wgpu). Apple Silicon'da çoğunlukla uzun istemleri hızlandırır — çözme bellek bant genişliğine bağlıdır.",
+  "settings.cmf.localOnlyHelp": "Her isteği yerel modele yönlendirir; yönlendiriciyi ve tüm bulut sağlayıcılarını yok sayar.",
+  "settings.cmf.manageHelp": "Ağ geçidi açılışta aşağıdaki .cmf için `cortiq serve` başlatır ve istekleri oraya yönlendirir. cortiq'in kurulu olması gerekir (adım 1). Yeniden başlatınca geçerli olur.",
+  "settings.cmf.autoInstallHelp": "Açılışta cortiq yoksa crates.io üzerinden otomatik kurar.",
+  "settings.cmf.autoUpdateHelp": "Açılışta daha yeni bir sürüm varsa cortiq'i en son sürüme yükseltir.",
+  "settings.router.enabledHelp": "Her isteği cortiq yönlendiricisi sınıflandırsın (görev türü + karmaşıklık) ve model seçsin. Kapalı = yalnızca yerel yönlendirme tablosunu kullan.",
+  "settings.router.verifyTlsHelp": "Yönlendiricinin TLS sertifikasını doğrula. Yalnızca kendinden imzalı ya da IP'ye bağlı sertifikada kapatın.",
+  "settings.telemetry.metricsHelp": "Prometheus metriklerini GET /metrics adresinde yayınla.",
+  "settings.cortiq.echoHelp": "Her yanıt gövdesine `cortiq` alanı ekle (görev, model, maliyet). Yanıt başlıkları her zaman gönderilir.",
+  "settings.stats.enabledHelp": "Panoyu ve grafikleri beslemek için son istekleri kaydet.",
+  "settings.cache.enabledHelp": "Anlamsal önbellek: yeni bir istem geçmiştekine çok benziyorsa kaydedilmiş yanıtı döndürür ve model çağrısını atlar. Havuzda bir gömme (embedding) modeli gerekir.",
+  "settings.log.bodiesHelp": "İstek/yanıt mesaj gövdelerinin tamamını günlüğe yaz. Gizlilik için varsayılan olarak kapalı.",
+  "settings.router.saveKey": "Anahtarı kaydet",
+  "settings.router.keySaved": "Yönlendirici anahtarı kaydedildi",
+  "settings.router.keyEmpty": "Önce anahtarı yapıştırın",
+  "settings.router.secretHelp": "api.allaigate.com e-postanızdaki anahtarı yapıştırıp Anahtarı kaydet'e basın. Bu bir “API anahtarları” değeri DEĞİLDİR — onlar ağ geçidinizi çağıran istemciler içindir.",
+  "settings.router.keyStoredMask": "•••••••••••• — anahtar kayıtlı (değiştirmek için yenisini yapıştırın)",
+  "settings.route.strategyHelp": "Sınıflandırma için yönlendiriciye gönderilen metin: last_user = yalnızca son kullanıcı mesajı; last_user_plus_system = son kullanıcı mesajı + sistem istemi; concat_all = tüm konuşma.",
+  "settings.route.maxCharsHelp": "Bu metnin yönlendiriciye gönderilen en fazla karakter sayısı (fazlası kırpılır). Daha fazlası = daha isabetli sınıflandırma, ama daha yavaş ve pahalı yönlendirici çağrıları.",
+  "settings.route.cacheTtlHelp": "Aynı istek için yönlendirme kararının, yönlendiriciye yeniden sorulmadan önce ne kadar önbellekte tutulacağı (ör. 60s, 5m).",
+  "settings.route.profileHelp": "İstek belirtmediğinde kullanılacak varsayılan yönlendirme profili: cost-saver (en ucuz), balanced ya da quality-first (en iyi model). Yönlendiricinin hangi modeli seçeceğini etkiler.",
+
+  // import
+  "import.subtitle": "HuggingFace'te arayın, yerel bir .cmf dosyasına dönüştürün ve sunun.",
+  "import.searchPlaceholder": "HuggingFace modellerinde ara (ör. qwen3, llama)…",
+  "import.searching": "Aranıyor…",
+  "import.noResults": "Model bulunamadı.",
+  "import.configure": "Dönüştürmeyi yapılandır",
+  "import.outName": "Çıktı adı",
+  "import.outNameHint": ".cmf dosya adı (harf, rakam, - ve _).",
+  "import.quant": "Niceleme",
+  "import.convert": "Dönüştür ve yükle",
+  "import.converting": "Dönüştürülüyor",
+  "import.started": "Dönüştürme başladı",
+  "import.failed": "Dönüştürme başarısız — günlüğe bakın.",
+  "import.register": "Yerel model olarak kaydet",
+  "import.registered": "“{id}” olarak kaydedildi. Sunmak için cortiq-server'ı çalıştırın.",
+  "import.jobs": "İndirmeler ve dönüştürmeler",
+  "import.cancel": "İptal",
+  "import.cancelling": "İptal ediliyor — yarım kalan dosya temizleniyor…",
+  "import.delete": "Sil",
+  "import.deleteConfirm": "Bu model ve dönüştürülmüş .cmf dosyası diskten silinsin mi?",
+  "import.deleted": "Dosyalarıyla birlikte silindi",
+  "import.state.running": "çalışıyor",
+  "import.state.done": "tamam",
+  "import.state.error": "hata",
+  "import.state.cancelled": "iptal edildi",
+  "import.featuredTitle": "Öne çıkan hazır .cmf modelleri",
+  "import.featuredSub": "HuggingFace'teki infosave hesabından hazır .cmf modelleri — liste canlı okunur, yeni modeller kendiliğinden görünür.",
+  "import.readyCmfBadge": "Hazır .cmf",
+  "import.directDownload": "İndir",
+  "import.q.q8_2f": "8 bit çift alan (𝒲×θ) — önerilen: en iyi kalite/boyut dengesi.",
+  "import.q.q8_row": "Satır başına 8 bit — basit ve sağlam.",
+  "import.q.q4": "4 bit blok — en küçük, kalite daha düşük.",
+  "import.q.q4_tiled": "4 bit döşeli (Q4_TILED) — Metal GPU'da 1,66× daha hızlı.",
+  "import.q.vbit": "Değişken 3–8 bit — uzman başına bit bütçesi.",
+  "import.q.q1t": "1,58 bit üçlü (Q1T) — seyrek aykırı değerlerle BitNet b1.58.",
+  "import.q.q1s": "1 bit seyrek (Q1S) — holografik aykırı değerlerle 1 bit taban.",
+  "import.q.q1p": "1 bit PTQ (Q1P) — hata yayılımlı 1 bit.",
+  "import.q.q1": "1 bit (Q1) — saf ikili biçim.",
+  "import.q.f16": "16 bit — niceleme yok.",
+  "import.q.f32": "32 bit — tam hassasiyet (büyük dosya).",
+  "import.adv.title": "Gelişmiş ayarlar",
+  "import.adv.auto": "otomatik",
+  "import.adv.linearCore": "Doğrusal çekirdek",
+  "import.adv.linearHint": "Doğrusal dikkat katmanlarının nasıl taşındığı/katlandığı.",
+  "import.adv.nphase": "vmf_phase faz/başlık",
+  "import.adv.vbitShape": "VBIT bütçe biçimi",
+  "import.adv.meanBits": "VBIT ortalama bit",
+  "import.adv.shard": "Parça üst sınırı (GB)",
+  "import.adv.noShard": "parçalama yok",
+  "import.adv.skipMtp": "MTP başlığını atla",
+  "import.adv.o1": "O(1) dikkat",
+  "import.adv.o1Hint": "Sabit bellekli akış dikkati: KV önbelleği prefill sonrası serbest bırakılır, böylece uzun bağlamlar belleği büyütmez. Ağırlıklar bayt bayt aynı kalır — yalnızca yükleme anına dair bir ipucu kaydedilir; istediğiniz zaman geri dönebilirsiniz (--o1 off ile sunun). Qwen3-0.6B üzerinde doğrulandı: tüm katmanlar ≈ ×1,18 şaşkınlık (perplexity).",
+  "import.adv.o1Off": "kapalı — tam dikkat (varsayılan)",
+  "import.adv.o1All": "all — her softmax katmanını dönüştür",
+  "import.adv.o1Deep": "deep N — yalnızca en derin N katman",
+  "import.adv.o1Custom": "özel — açık katman listesi",
+  "import.adv.o1DeepN": "N derin katman",
+  "import.adv.o1Layers": "Katmanlar (virgülle ayrılmış)",
+  "import.adv.o1mHint": "landmark bütçesi (varsayılan 32)",
+  "import.adv.o1windowHint": "tam pencere genişliği (varsayılan 128)",
+  "import.adv.o1sinkHint": "kalıcı tam sink anahtarları (varsayılan 4)",
+
+  // onboarding
+  "onboarding.title": "İlk kurulum",
+  "onboarding.welcome": "Cortiq Gateway'e hoş geldiniz",
+  "onboarding.welcomeSub": "Dilinizi seçin — üst çubuktan istediğiniz zaman değiştirebilirsiniz.",
+  "onboarding.next": "İleri",
+  "onboarding.back": "Geri",
+  "onboarding.skip": "Şimdilik atla",
+  "onboarding.skipSetup": "Atla",
+  "onboarding.finish": "Kurulumu tamamla",
+  "onboarding.featuredTitle": "Hazır modeller (tek tık)",
+  "onboarding.featuredSub": "Bunlar HuggingFace'te infosave tarafından yayınlanan, önceden dönüştürülmüş .cmf modelleridir — sadece indirin, dönüştürme gerekmez. Hemen başlamak için bir ya da birkaçını seçin.",
+  "onboarding.download": "İndir",
+  "onboarding.hfTitle": "Herhangi bir HuggingFace modeli — otomatik dönüştürme",
+  "onboarding.hfSub": "İstediğiniz modeli arayın, bir niceleme seçin; biz onu otomatik olarak .cmf biçimine dönüştürelim. Elle yapılandırma düzenlemesi yok.",
+  "onboarding.noJobs": "Henüz indirme yok.",
+  "onboarding.doneTitle": "Her şey hazır",
+  "onboarding.doneSub": "İndirdiğiniz modeller otomatik olarak kaydedilir. Daha fazlasını İçe aktar ya da Modeller sekmesinden ekleyebilirsiniz.",
+  "onboarding.doneHint": "“Kurulumu tamamla”, biten her indirmeyi yerel model olarak bağlar, .cmf sunucusunu başlatır ve yönlendirmeyi ona çevirir. Tümünü sonradan Modeller sekmesinden değiştirebilirsiniz.",
+  "onboarding.willRegister": "Yerel model olarak bağlanacak",
+  "onboarding.nothingToRegister": "Henüz tamamlanmış indirme yok — bağlanacak bir şey bulunmuyor. Bir adım geri dönüp model seçin.",
+  "onboarding.registeredN": "{n} model bağlandı: {ids}",
+  "onboarding.runtimeMissing": "cortiq çalışma zamanı kurulu değil — bunları sunabilmek için Ayarlar → Yerel modeller bölümünden kurun.",
+  "onboarding.downloaded": "indirildi",
+  "onboarding.update": "Güncelle",
+  "onboarding.deleteFile": ".cmf dosyasını diskten sil",
+  "onboarding.confirmDelete": "“{id}” silinsin mi? .cmf dosyası diskten kaldırılacak.",
+  "onboarding.unregistered": "Ayrıca kaydı kaldırıldı: {ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "Sohbet",
+  "pg.tab.image": "Görsel",
+  "pg.tab.video": "Video",
+  "pg.generate": "Oluştur",
+  "pg.generating": "Oluşturuluyor…",
+  "pg.genFailed": "Oluşturma başarısız — günlüğe bakın.",
+  "pg.result": "Sonuç",
+  "pg.genMetrics": "Oluşturma metrikleri",
+  "pg.imagePromptPlaceholder": "gün batımında karda oturan kızıl tilki, fotogerçekçi, ayrıntılı tüyler",
+  "pg.videoPromptPlaceholder": "aşçı şapkalı bir corgi krep çeviriyor, cızırtı sesleri ve neşeli bir havlama",
+  "pg.imageEmpty": "Oluşturulan görsel burada görünecek.",
+  "pg.videoEmpty": "Oluşturulan klip (sesiyle) burada görünecek.",
+  "pg.width": "Genişlik",
+  "pg.height": "Yükseklik",
+  "pg.steps": "Adım",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "Rastgele seed",
+  "pg.cfgHint": "Guidance gücü; ≤ 1 CFG'yi kapatır ve işi yarıya indirir.",
+  "pg.frames": "Kare",
+  "pg.framesHint": "24 fps'te; modelin ızgarasına yuvarlanır.",
+  "pg.quality": "JPEG kalitesi",
+  "pg.videoSizeHint": "32'nin katları; eğitilen kısa kenar 768.",
+  "pg.videoStepsHint": "Turbo LoRA 4 adım için eğitildi.",
+  "pg.firstFrame": "İlk kare (isteğe bağlı)",
+  "pg.lastFrame": "Son kare (isteğe bağlı)",
+  "pg.keyframeHint": "Çalışmayı keyframe-to-video'ya çevirir.",
+  "pg.resolution": "Çözünürlük",
+  "pg.genTime": "Oluşturma süresi",
+  "pg.timePerStep": "Adım başına",
+  "pg.timePerFrame": "Kare başına",
+  "pg.fileSize": "Dosya boyutu",
+  "pg.duration": "Süre",
+  "pg.play": "Oynat",
+  "pg.noMediaModels": "Henüz yerel bir {kind} modeli yok. İçe aktarma sekmesinden bir tane indirin (ör. infosave koleksiyonundan):",
+  "pg.tokSpeed": "Hız",
+  "pg.ttft": "İlk token",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "Günlükler",
+  "logs.subtitle": "Ağ geçidinin son günlüğü — terminalde görecekleriniz.",
+  "logs.filterPlaceholder": "filtrele…",
+  "logs.pause": "Duraklat",
+  "logs.resume": "Devam et",
+  "logs.empty": "Eşleşen yok.",
+  "notice.openAdmin": "Yönetim konsolu belirteçsiz açık ve diğer makinelerden erişilebilir. Bu makine özel değilse bir belirteç ayarlayın.",
+  "notice.update": "Güncelleme mevcut: v{v}.",
+  "dash.sys.title": "Sistem",
+  "dash.sys.cores": "çekirdek",
+  "dash.sys.disk": "Disk (modeller)",
+  "dash.sys.free": "boş",
+  "dash.sys.gateway": "ağ geçidi",
+  "fit.disk": "disk alanı yetmez",
+  "fit.diskTitle": "İndirme, model diskindeki boş alandan büyük.",
+  "fit.ram": "RAM'e sığmayabilir",
+  "fit.ramTitle": "Model bu makinenin RAM'ine yakın ya da ondan büyük — çalışmayabilir.",
+  "pg.eta": "kaldı",
+  "pg.min": "dk",
+  "pg.queued": "Kuyrukta — {n}. sırada. Mevcut üretim biter bitmez başlar.",
+  "pg.gallery": "Son üretimler",
+  "pg.galDeleteConfirm": "Bu üretim ve dosyaları silinsin mi?",
+  "pg.clearChat": "Temizle",
+  "keys.snip.title": "Uygulamanı bağla",
+  "keys.snip.hint": "Örneklerden birini projene yapıştır — yalnızca anahtar yer tutucusunu değiştirmen gerekir.",
+  "keys.snip.withKey": "Aşağıdaki örnekler az önce oluşturduğun anahtarı içeriyor.",
+  "keys.snip.openMode": "API anahtarı yapılandırılmadı — ağ geçidi her değeri kabul eder.",
+  "keys.snip.keyPh": "API anahtarın",
+  "settings.restart": "Ağ geçidini yeniden başlat",
+  "settings.restartConfirm": "Ağ geçidi yeniden başlatılsın mı? Devam eden istekler kesilir; yerel model sunucuları da yeniden başlar.",
+  "settings.restarting": "Yeniden başlatılıyor — ağ geçidi dönünce sayfa yenilenecek…",
+  "bench.title": "Yerel model hızı",
+  "bench.hint": "Bu makinede `cortiq bench` çalıştırır — gerçek tok/s, aynı anda tek model.",
+  "bench.run": "Ölç",
+  "bench.running": "ölçülüyor…",
+  "bench.failed": "başarısız",
+  "bench.none": "Henüz yerel .cmf sohbet modeli yok.",
+
+  // task-based routing
+  "task.chitchat": "Sohbet",
+  "task.code": "Kod",
+  "task.creative-writing": "Yaratıcı yazarlık",
+  "task.extraction": "Veri çıkarma",
+  "task.math": "Matematik",
+  "task.qa": "Soru-cevap",
+  "task.summarization": "Özetleme",
+  "task.translation": "Çeviri",
+  "routing.tasks.title": "Göreve göre yönlendirme",
+  "routing.tasks.hint": "Kuralın modelleri kendi görevi için önce gelir; karmaşıklık zinciri yedek olarak kalır. Boş = yalnızca karmaşıklığa göre.",
+  "routing.tasks.inherit": "karmaşıklığa göre (kural yok)",
+  "routing.tasks.share": "isteklerin %{p}'i (7 g)",
+  "routing.tasks.fromRouter": "etiketler yönlendiriciden canlı",
+  "routing.tasks.builtin": "yönlendiriciye ulaşılamıyor — yerleşik etiket seti",
+  "routing.tasks.addCustom": "Görev ekle",
+  "routing.tasks.addPlaceholder": "özel etiket…",
+
+  // benchmark view
+  "nav.benchmark": "Kıyaslama",
+  "bm.title": "Kıyaslama",
+  "bm.subtitle": "Canlı hat üzerinden kalite ve hız probları: yanıtlar anahtar kelimeyle doğrulanır, döngü tespit edilir, model başına tok/s ve ilk token süresi ölçülür.",
+  "bm.models": "Test edilecek modeller",
+  "bm.quickMode": "Hızlı test",
+  "bm.quickHint": "Kısa yanıtlı hızlı alt küme — yerel model başına yaklaşık bir dakika.",
+  "bm.suiteInfo": "Yerleşik küme: {q} hızlı / {f} tam test, artı kendi testleriniz.",
+  "bm.run": "Çalıştır",
+  "bm.pickModel": "En az bir model seçin.",
+  "bm.testOf": "{n} testten {i}.",
+  "bm.results": "Sonuçlar",
+  "bm.quick": "hızlı",
+  "bm.test": "Test",
+  "bm.cellHint": "Modelin tam yanıtı için hücreye tıklayın.",
+  "bm.history": "Önceki çalıştırmalar (bu tarayıcıda saklanır)",
+  "bm.custom": "Özel testler",
+  "bm.customHint": "İstem + yanıtın içermesi gereken virgülle ayrılmış anahtar kelimeler (| eşanlamlılar için). Bu tarayıcıda saklanır.",
+  "bm.promptPh": "istem…",
+  "bm.checkPh": "anahtar kelimeler, virgülle",
+  "bm.addTest": "Test ekle",
+  "bm.emptyAnswer": "boş yanıt",
+  "bm.loopDetected": "döngü tespit edildi",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "Akıllı yönlendirme",
+  "bm.mode.models": "Tek tek modeller",
+  "bm.mode.routingDesc": "Ürünün temel özelliği testte: her prob cortiq-auto üzerinden gider — yönlendiricinin hangi görevi algıladığını, hangi modeli seçtiğini, bunun beklentiyle örtüşüp örtüşmediğini ve maliyetini görürsünüz.",
+  "bm.mode.modelsDesc": "Aynı küme seçilen modellere sabitlenir — yönlendiriciyi atlayarak kalite, hız ve maliyeti doğrudan karşılaştırın.",
+  "bm.answersOk": "yanıtlar doğru",
+  "bm.classAcc": "görev sınıflandırması",
+  "bm.modelDist": "İstekler şuraya gitti",
+  "bm.expectedLbl": "beklenen:",
+  "bm.answer": "Yanıt",
+  "bm.liveRunning": "sürüyor…",
+  "bm.spent": "harcanan",
+  "bm.verdict": "🏁 Bitti: yanıtlar {p}, harcanan {s}",
+  "bm.clearHistory": "Tümünü temizle",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — terminale yapıştırın (ağ geçidi Anthropic protokolünü doğal olarak konuşur):",
+  "keys.h.codex": "Codex — sağlayıcıyı ~/.codex/config.toml dosyasına ekler ve başlatır:",
+  "keys.h.opencode": "OpenCode — ~/.config/opencode/opencode.json dosyasını yazar (üzerine yazar!) ve başlatır:",
+  "keys.h.continue": "Continue (VS Code / JetBrains) — modeli ~/.continue/config.yaml dosyasına ekler:",
+  "keys.h.cline1": "Cline (VS Code) — eklenti ayarlarında şunları seçin:",
+  "keys.h.cline2": "Ayarlar → API Provider → OpenAI Compatible, ardından yukarıdaki değerleri yapıştırın.",
+  "keys.h.note": "cortiq-auto = akıllı yönlendirme: yönlendirici her istek için modeli kendisi seçer. Belirli bir model için tam adını yazın. Windows'ta betikleri Git Bash / WSL içinde çalıştırın veya aynı değişkenleri sistem ortamından ayarlayın.",
+  "keys.h.protoOff": "Anthropic protokolü (/v1/messages) kapalı — Claude Code bağlanamaz.",
+  "keys.h.enableProto": "Etkinleştir",
+  "keys.h.st.installed": "Ağ geçidi makinesinde kurulu",
+  "keys.h.st.configured": "Bu ağ geçidi için zaten yapılandırılmış",
+  "keys.h.st.notFound": "Ağ geçidi makinesinde bulunamadı",
+  "bm.degraded": "yönlendirici yedeğe düştü",
+  "bm.routerDegraded": "Yönlendirici zamanında yanıt vermedi — istek yedek zincire gitti; sınıflandırma sayılmaz.",
+  "bm.cutByCap": "bütçe düşünmeye gitti — yanıt gelemedi",
+  "shell.uiStale": "Ağ geçidi güncellendi — bu sayfa eski arayüzü çalıştırıyor.",
+  "shell.reload": "Yeniden yükle",
+  "keys.col.requests": "İstekler",
+  "keys.col.tokens": "Token giriş/çıkış",
+  "keys.col.costAll": "$ toplam",
+  "routing.tasks.tier": "Karmaşıklık",
+  "routing.tasks.tierAuto": "Otomatik (yönlendirici)",
+  "routing.tasks.tierHint": "Bu görevi hangi karmaşıklıkta hangi model karşılar; \"her\" tüm katmanlarda önde gider. Sıra = yedekleme sırası. High kararı \"her\" girdilerinin üzerine yine tırmanır.",
+  "routing.tasks.tierAny": "her karmaşıklık",
+  "routing.tasks.addModel": "model",
+  "routing.bands.enable": "Kendi karmaşıklık sınırlarım",
+  "routing.bands.hint": "Tutamaçları sürükleyin: low nerede biter, high nerede başlar — tutamaçlar birbirini iter, sayılar anlık güncellenir. Yönlendiricinin sürekli puanı SİZİN sınırlarınızla yeniden bölümlenir; işaret kaldırılırsa yönlendiricinin kendi bantları geçerli.",
+  "tier.low": "kolay",
+  "tier.medium": "orta",
+  "tier.high": "zor",
 };

web/js/i18n/zh.js

@@ -280,4 +280,358 @@ export default {
   "settings.cache.ttl": "条目 TTL",
   "settings.cache.embed": "嵌入模型",
   "settings.cache.note": "缓存设置将在重启后生效。",
+
+  // ── translated from en.js (previously falling back to English) ──
+  // nav
+  "nav.import": "导入模型",
+
+  // dash
+  "dash.clear": "清空日志",
+  "dash.clearConfirm": "清空所有已记录的统计与日志？此操作无法撤销。",
+  "dash.cleared": "日志已清空",
+
+  // models
+  "models.form.idOrModel": "请输入 id 或模型名称",
+  "models.form.apiKey": "API 密钥",
+  "models.form.apiKeyPlaceholder": "粘贴你的 API 密钥",
+  "models.form.apiKeyNotNeeded": "无需密钥（本地服务器）",
+  "models.form.apiKeyHint": "安全保存在网关中，之后不会再次显示。",
+  "models.form.keyStored": "已保存一个密钥 — 留空表示保留，或粘贴新的密钥替换。",
+  "models.form.keyFromEnv": "正在使用环境变量中的密钥。",
+  "models.form.paramsTitle": "生成与思考参数（O(1)、MTP、温度）",
+  "models.form.temperature": "温度",
+  "models.form.temperatureHint": "生成温度（0.0 = 确定性，1.0+ = 更有创造性）。",
+  "models.form.topP": "Top-P（核采样）",
+  "models.form.topPHint": "采样阈值（0.0 .. 1.0）。",
+  "models.form.maxTokens": "最大 token 数",
+  "models.form.maxTokensHint": "生成内容的最大 token 数。",
+  "models.form.thinkBudget": "思考模式 / 思考预算",
+  "models.form.thinkBudgetHint": "推理 token 预算（0 = 关闭，N > 0 = 推理 token 上限）。",
+  "models.form.systemPrompt": "默认系统提示词",
+  "models.form.systemPromptHint": "当请求中没有系统提示词时自动添加到前面。",
+  "models.form.systemPromptPlaceholder": "你是一个乐于助人的助手……",
+  "models.form.testKey": "测试并加载模型",
+  "models.form.testing": "检查中……",
+  "models.form.foundModels": "已加载 {n} 个模型",
+  "models.form.modelPlaceholder": "输入以搜索……",
+  "models.form.modelHint": "点击“测试并加载模型”用你的密钥拉取列表，然后选择一个。",
+  "models.managed": "托管",
+  "models.managedHint": "由托管的 CMF 服务器提供（设置 → 本地模型）。请在那里配置。",
+
+  // settings
+  "settings.router.enabled": "使用路由器（关闭 = 仅本地模型）",
+  "settings.cmf": "本地模型（CMF）",
+  "settings.cmf.localOnly": "仅使用本地模型",
+  "settings.cmf.manage": "运行本地模型服务器",
+  "settings.cmf.autoInstall": "自动安装 cortiq（crates.io）",
+  "settings.cmf.autoUpdate": "自动更新 cortiq",
+  "settings.cmf.model": "本地 .cmf 模型路径",
+  "settings.cmf.port": "本地服务器端口",
+  "settings.cmf.modelId": "模型在池中的 id",
+  "settings.cmf.note": "通过 cortiq 提供本地 .cmf 服务（github.com/infosave2007/cmf）。即使路由器不可用也能工作。",
+  "settings.cmf.threads": "工作线程",
+  "settings.cmf.gpu": "使用 GPU（Metal / wgpu）",
+  "settings.cmf.speedNote": "线程会并行化解码阶段的矩阵向量乘法（约快 3 倍；0 = 运行时默认值）。GPU 卸载主要加速长提示词的 prefill — 解码受内存带宽限制，因此在 Apple Silicon 上基本持平。",
+  "settings.cmf.pick": "选择一个模型",
+  "settings.cmf.models": "本地模型",
+  "settings.cmf.modelsHelp": "每一行都是网关运行的一个模型（各自独立的 cortiq serve，各占一个端口）并注册到模型池。有多少 .cmf 文件和空闲端口就可以加多少行。",
+  "settings.cmf.rowHint": "id · .cmf 文件 · 端口 · 线程 · GPU。改动在重启后生效；删除一行会停止对应的服务器。",
+  "settings.cmf.addServer": "+ 添加本地模型",
+  "settings.cmf.checkPort": "检查端口",
+  "settings.cmf.portFree": "端口空闲",
+  "settings.cmf.portBusy": "端口被占用",
+  "settings.cmf.useSuggested": "使用 {port}",
+  "settings.cmf.serving": "{model} 正在 :{port} 提供服务",
+  "settings.cmf.intro": "用 cortiq 引擎在本地运行模型 — 即使离线或路由器故障也能工作。",
+  "settings.cmf.runtime": "cortiq 运行时",
+  "settings.cmf.runtimeHelp": "用于加载和运行 .cmf 模型的命令行工具 `cortiq`。启动本地服务器前先安装一次。",
+  "settings.cmf.install": "安装 cortiq",
+  "settings.cmf.reinstall": "重新安装 / 更新",
+  "settings.cmf.installing": "安装中……（需要编译，几分钟）",
+  "settings.cmf.installedOk": "cortiq 已安装",
+  "settings.cmf.notInstalled": "未安装",
+  "settings.cmf.addModel": "添加模型",
+  "settings.cmf.addModelHelp": "模型在“导入模型”标签页下载并转换（HuggingFace → .cmf）。然后把下面的本地服务器指向该 .cmf 文件。",
+  "settings.cmf.importNote": "还没有模型？去导入一个：",
+  "settings.cmf.importLink": "打开导入",
+  "settings.cmf.modelHelp": "要提供服务的 .cmf 文件路径（例如 models/qwen.cmf），由导入标签页生成。要为不同任务准备多个模型？导入它们并切换此路径。",
+  "settings.cmf.portHelp": "本地模型服务器监听的 TCP 端口（默认 8081）。仅在与其他服务冲突时修改。",
+  "settings.cmf.threadsHelp": "生成时使用多少个 CPU 核心。越多越快（相比单核约快 3 倍）；0 表示交给运行时决定。",
+  "settings.cmf.gpuHelp": "把矩阵运算卸载到 GPU（Metal/wgpu）。在 Apple Silicon 上主要加速长提示词 — 解码受内存带宽限制。",
+  "settings.cmf.localOnlyHelp": "把每个请求都发往本地模型，忽略路由器和所有云端供应商。",
+  "settings.cmf.manageHelp": "网关启动时会为下面的 .cmf 启动 `cortiq serve` 并把请求路由过去。需要已安装 cortiq（第 1 步）。重启后生效。",
+  "settings.cmf.autoInstallHelp": "如果启动时缺少 cortiq，自动从 crates.io 安装。",
+  "settings.cmf.autoUpdateHelp": "启动时如有更新版本，将 cortiq 升级到最新发布版。",
+  "settings.router.enabledHelp": "让 cortiq 路由器对每个请求分类（任务类型 + 复杂度）并挑选模型。关闭 = 仅使用本地路由表。",
+  "settings.router.verifyTlsHelp": "校验路由器的 TLS 证书。仅在使用自签名或绑定 IP 的证书时关闭。",
+  "settings.telemetry.metricsHelp": "在 GET /metrics 暴露 Prometheus 指标。",
+  "settings.cortiq.echoHelp": "在每个响应体中加入 `cortiq` 字段（任务、模型、成本）。响应头始终会发送。",
+  "settings.stats.enabledHelp": "记录最近的请求，为仪表盘和图表提供数据。",
+  "settings.cache.enabledHelp": "语义缓存：当新提示词与过去的某个非常相似时直接返回已保存的回答，跳过模型调用。需要池中有一个嵌入模型。",
+  "settings.log.bodiesHelp": "记录请求/响应的完整消息体。出于隐私考虑默认关闭。",
+  "settings.router.saveKey": "保存密钥",
+  "settings.router.keySaved": "路由器密钥已保存",
+  "settings.router.keyEmpty": "请先粘贴密钥",
+  "settings.router.secretHelp": "粘贴 api.allaigate.com 邮件中的密钥，然后点击“保存密钥”。这不是“API 密钥”页中的值 — 那些是给调用你网关的客户端用的。",
+  "settings.router.keyStoredMask": "•••••••••••• — 密钥已保存（再次粘贴可替换）",
+  "settings.route.strategyHelp": "发送给路由器用于分类的文本：last_user = 仅最后一条用户消息；last_user_plus_system = 最后一条用户消息 + 系统提示词；concat_all = 整段对话。",
+  "settings.route.maxCharsHelp": "发送给路由器的文本最大字符数（超出会截断）。越多分类越准，但路由器调用更慢也更贵。",
+  "settings.route.cacheTtlHelp": "相同请求的路由决策缓存多久后才再次询问路由器（例如 60s、5m）。",
+  "settings.route.profileHelp": "请求未指定时使用的默认路由档位：cost-saver（最省钱）、balanced 或 quality-first（最好的模型）。会影响路由器挑选哪个模型。",
+
+  // import
+  "import.subtitle": "在 HuggingFace 上搜索模型，转换为本地 .cmf 并提供服务。",
+  "import.searchPlaceholder": "搜索 HuggingFace 模型（例如 qwen3、llama）……",
+  "import.searching": "搜索中……",
+  "import.noResults": "未找到模型。",
+  "import.configure": "配置转换",
+  "import.outName": "输出名称",
+  "import.outNameHint": ".cmf 文件名（字母、数字、- 和 _）。",
+  "import.quant": "量化",
+  "import.convert": "转换并加载",
+  "import.converting": "转换中",
+  "import.started": "转换已开始",
+  "import.failed": "转换失败 — 请查看日志。",
+  "import.register": "注册为本地模型",
+  "import.registered": "已注册为 “{id}”。运行 cortiq-server 即可提供服务。",
+  "import.jobs": "下载与转换",
+  "import.cancel": "取消",
+  "import.cancelling": "正在取消 — 清理未完成的文件……",
+  "import.delete": "删除",
+  "import.deleteConfirm": "从磁盘删除该模型及其转换好的 .cmf 文件？",
+  "import.deleted": "已连同文件一起删除",
+  "import.state.running": "进行中",
+  "import.state.done": "完成",
+  "import.state.error": "错误",
+  "import.state.cancelled": "已取消",
+  "import.featuredTitle": "推荐的开箱即用 .cmf 模型",
+  "import.featuredSub": "来自 HuggingFace 上 infosave 账号的预转换 .cmf 模型 — 列表实时读取，新模型会自动出现。",
+  "import.readyCmfBadge": "现成 .cmf",
+  "import.directDownload": "下载",
+  "import.q.q8_2f": "8 位双场（𝒲×θ）— 推荐：质量与体积的最佳平衡。",
+  "import.q.q8_row": "8 位按行 — 简单稳健。",
+  "import.q.q4": "4 位分块 — 体积最小，质量较低。",
+  "import.q.q4_tiled": "4 位分块平铺（Q4_TILED）— 在 Metal GPU 上快 1.66 倍。",
+  "import.q.vbit": "可变 3–8 位 — 按专家分配位宽预算。",
+  "import.q.q1t": "1.58 位三值（Q1T）— BitNet b1.58，带稀疏离群值。",
+  "import.q.q1s": "1 位稀疏（Q1S）— 1 位基底，带全息离群值。",
+  "import.q.q1p": "1 位 PTQ（Q1P）— 1 位，带误差扩散。",
+  "import.q.q1": "1 位（Q1）— 纯二值格式。",
+  "import.q.f16": "16 位 — 不量化。",
+  "import.q.f32": "32 位 — 全精度（文件很大）。",
+  "import.adv.title": "高级设置",
+  "import.adv.auto": "自动",
+  "import.adv.linearCore": "线性核",
+  "import.adv.linearHint": "线性注意力层如何被保留或折叠。",
+  "import.adv.nphase": "vmf_phase 每头相位数",
+  "import.adv.vbitShape": "VBIT 预算形状",
+  "import.adv.meanBits": "VBIT 平均位宽",
+  "import.adv.shard": "分片上限（GB）",
+  "import.adv.noShard": "不分片",
+  "import.adv.skipMtp": "跳过 MTP 头",
+  "import.adv.o1": "O(1) 注意力",
+  "import.adv.o1Hint": "常量内存的流式注意力：prefill 之后释放 KV 缓存，因此长上下文不会持续增加内存。权重保持逐字节一致 — 只记录一个加载时的提示；随时可以切回（启动时加 --o1 off）。已在 Qwen3-0.6B 上验证：全部层约为 ×1.18 困惑度。",
+  "import.adv.o1Off": "关闭 — 精确注意力（默认）",
+  "import.adv.o1All": "all — 转换所有 softmax 层",
+  "import.adv.o1Deep": "deep N — 仅最深的 N 层",
+  "import.adv.o1Custom": "自定义 — 显式指定层列表",
+  "import.adv.o1DeepN": "最深的 N 层",
+  "import.adv.o1Layers": "层（用逗号分隔）",
+  "import.adv.o1mHint": "landmark 预算（默认 32）",
+  "import.adv.o1windowHint": "精确窗口宽度（默认 128）",
+  "import.adv.o1sinkHint": "常驻精确 sink key 数（默认 4）",
+
+  // onboarding
+  "onboarding.title": "初始设置",
+  "onboarding.welcome": "欢迎使用 Cortiq Gateway",
+  "onboarding.welcomeSub": "选择你的语言 — 随时可以在顶栏更改。",
+  "onboarding.next": "下一步",
+  "onboarding.back": "上一步",
+  "onboarding.skip": "暂时跳过",
+  "onboarding.skipSetup": "跳过",
+  "onboarding.finish": "完成设置",
+  "onboarding.featuredTitle": "开箱即用的模型（一键）",
+  "onboarding.featuredSub": "这些是 HuggingFace 上 infosave 发布的、已经转换好的 .cmf 模型 — 直接下载即可，无需转换。选择一个或多个即可立即开始。",
+  "onboarding.download": "下载",
+  "onboarding.hfTitle": "任意 HuggingFace 模型 — 自动转换",
+  "onboarding.hfSub": "搜索任意模型，选择量化方式，我们会自动把它转换为 .cmf。无需手动修改配置。",
+  "onboarding.noJobs": "还没有下载任务。",
+  "onboarding.doneTitle": "全部就绪",
+  "onboarding.doneSub": "下载好的模型会自动注册。之后可以在“导入模型”或“模型”中添加更多。",
+  "onboarding.doneHint": "“完成设置”会把每个下载完成的模型接入为本地模型，启动它的 .cmf 服务器并把路由指向它。这些之后都可以在“模型”中修改。",
+  "onboarding.willRegister": "将接入为本地模型",
+  "onboarding.nothingToRegister": "还没有下载完成的模型 — 没有可接入的内容。返回上一步选一个模型。",
+  "onboarding.registeredN": "已接入 {n} 个模型：{ids}",
+  "onboarding.runtimeMissing": "cortiq 运行时尚未安装 — 请在 设置 → 本地模型 中安装后才能运行这些模型。",
+  "onboarding.downloaded": "已下载",
+  "onboarding.update": "更新",
+  "onboarding.deleteFile": "从磁盘删除该 .cmf 文件",
+  "onboarding.confirmDelete": "删除 “{id}”？该 .cmf 文件将从磁盘移除。",
+  "onboarding.unregistered": "同时已取消注册：{ids}",
+
+  // playground: media generation + streaming metrics
+  "pg.tab.chat": "对话",
+  "pg.tab.image": "图像",
+  "pg.tab.video": "视频",
+  "pg.generate": "生成",
+  "pg.generating": "生成中……",
+  "pg.genFailed": "生成失败 — 请查看日志。",
+  "pg.result": "结果",
+  "pg.genMetrics": "生成指标",
+  "pg.imagePromptPlaceholder": "夕阳下雪地里的红狐狸，照片级真实感，毛发细节丰富",
+  "pg.videoPromptPlaceholder": "戴厨师帽的柯基翻煎饼，滋滋声和欢快的犬吠",
+  "pg.imageEmpty": "生成的图像将显示在这里。",
+  "pg.videoEmpty": "生成的短片（含音频）将显示在这里。",
+  "pg.width": "宽度",
+  "pg.height": "高度",
+  "pg.steps": "步数",
+  "pg.seed": "Seed",
+  "pg.randomSeed": "随机 seed",
+  "pg.cfgHint": "引导强度；≤ 1 关闭 CFG，工作量减半。",
+  "pg.frames": "帧数",
+  "pg.framesHint": "24 fps；按模型网格取整。",
+  "pg.quality": "JPEG 质量",
+  "pg.videoSizeHint": "32 的倍数；训练短边为 768。",
+  "pg.videoStepsHint": "Turbo LoRA 按 4 步训练。",
+  "pg.firstFrame": "首帧（可选）",
+  "pg.lastFrame": "末帧（可选）",
+  "pg.keyframeHint": "使运行变为关键帧生视频。",
+  "pg.resolution": "分辨率",
+  "pg.genTime": "生成耗时",
+  "pg.timePerStep": "每步",
+  "pg.timePerFrame": "每帧",
+  "pg.fileSize": "文件大小",
+  "pg.duration": "时长",
+  "pg.play": "播放",
+  "pg.noMediaModels": "还没有本地{kind}模型。请在“导入模型”中下载一个（例如 infosave 合集）：",
+  "pg.tokSpeed": "速度",
+  "pg.ttft": "首个 token",
+
+  // ops: logs, system, notices, gallery, chat, snippets, bench
+  "nav.logs": "日志",
+  "logs.subtitle": "网关最近的日志 — 终端里会看到的内容。",
+  "logs.filterPlaceholder": "过滤……",
+  "logs.pause": "暂停",
+  "logs.resume": "继续",
+  "logs.empty": "没有匹配内容。",
+  "notice.openAdmin": "管理控制台未设置令牌即可从其他机器访问。若这台机器不是私有的，请设置令牌。",
+  "notice.update": "有可用更新：v{v}。",
+  "dash.sys.title": "系统",
+  "dash.sys.cores": "核",
+  "dash.sys.disk": "磁盘（模型）",
+  "dash.sys.free": "可用",
+  "dash.sys.gateway": "网关",
+  "fit.disk": "磁盘空间不足",
+  "fit.diskTitle": "下载大小超过模型磁盘的可用空间。",
+  "fit.ram": "可能超出内存",
+  "fit.ramTitle": "模型接近或超过本机内存 — 可能无法运行。",
+  "pg.eta": "剩余",
+  "pg.min": "分钟",
+  "pg.queued": "排队中 — 第 {n} 位。当前生成结束后立即开始。",
+  "pg.gallery": "最近的生成",
+  "pg.galDeleteConfirm": "删除这次生成及其文件？",
+  "pg.clearChat": "清空",
+  "keys.snip.title": "接入你的应用",
+  "keys.snip.hint": "把示例粘贴到你的项目里 — 只需替换密钥占位符。",
+  "keys.snip.withKey": "下面的示例已包含你刚创建的密钥。",
+  "keys.snip.openMode": "未配置 API 密钥 — 网关接受任意密钥值。",
+  "keys.snip.keyPh": "你的 API 密钥",
+  "settings.restart": "重启网关",
+  "settings.restartConfirm": "重启网关？进行中的请求会中断；本地模型服务器也会重启。",
+  "settings.restarting": "正在重启 — 网关恢复后页面会自动刷新……",
+  "bench.title": "本地模型速度",
+  "bench.hint": "在本机运行 `cortiq bench` — 真实 tok/s，一次一个模型。",
+  "bench.run": "测速",
+  "bench.running": "测速中……",
+  "bench.failed": "失败",
+  "bench.none": "还没有本地 .cmf 聊天模型。",
+
+  // task-based routing
+  "task.chitchat": "闲聊",
+  "task.code": "代码",
+  "task.creative-writing": "创意写作",
+  "task.extraction": "数据提取",
+  "task.math": "数学",
+  "task.qa": "问答",
+  "task.summarization": "摘要",
+  "task.translation": "翻译",
+  "routing.tasks.title": "按任务路由",
+  "routing.tasks.hint": "规则中的模型对该任务优先；下方的复杂度链仍作为回退。留空 = 仅按复杂度。",
+  "routing.tasks.inherit": "按复杂度（无规则）",
+  "routing.tasks.share": "{p}% 的请求（7 天）",
+  "routing.tasks.fromRouter": "标签实时来自路由器",
+  "routing.tasks.builtin": "路由器不可达 — 使用内置标签集",
+  "routing.tasks.addCustom": "添加任务",
+  "routing.tasks.addPlaceholder": "自定义标签……",
+
+  // benchmark view
+  "nav.benchmark": "基准测试",
+  "bm.title": "基准测试",
+  "bm.subtitle": "通过实时管线做质量与速度探测：按关键词核对答案、检测循环输出，并按模型测量 tok/s 与首个 token 时间。",
+  "bm.models": "要测试的模型",
+  "bm.quickMode": "快速测试",
+  "bm.quickHint": "答案简短的快速子集 — 每个本地模型约一分钟。",
+  "bm.suiteInfo": "内置套件：{q} 个快速 / {f} 个完整测试，另加你自己的。",
+  "bm.run": "运行",
+  "bm.pickModel": "请至少选择一个模型。",
+  "bm.testOf": "第 {i}/{n} 个测试",
+  "bm.results": "结果",
+  "bm.quick": "快速",
+  "bm.test": "测试",
+  "bm.cellHint": "点击单元格查看模型的完整回答。",
+  "bm.history": "历史运行（保存在本浏览器）",
+  "bm.custom": "自定义测试",
+  "bm.customHint": "提示词 + 逗号分隔的关键词，回答必须包含它们（| 表示同义词）。保存在本浏览器。",
+  "bm.promptPh": "提示词……",
+  "bm.checkPh": "关键词，逗号分隔",
+  "bm.addTest": "添加测试",
+  "bm.emptyAnswer": "回答为空",
+  "bm.loopDetected": "检测到循环",
+
+  // benchmark: routing mode, cost, live
+  "bm.mode.routing": "智能路由",
+  "bm.mode.models": "单独模型",
+  "bm.mode.routingDesc": "测试产品核心能力：每个探测都经过 cortiq-auto — 可以看到路由器识别的任务、选中的模型、是否符合预期，以及花费了多少。",
+  "bm.mode.modelsDesc": "同一套测试固定在所选模型上 — 绕过路由器，直接对比它们的质量、速度与成本。",
+  "bm.answersOk": "回答正确",
+  "bm.classAcc": "任务分类",
+  "bm.modelDist": "请求流向",
+  "bm.expectedLbl": "预期：",
+  "bm.answer": "回答",
+  "bm.liveRunning": "进行中……",
+  "bm.spent": "花费",
+  "bm.verdict": "🏁 完成：回答 {p}，花费 {s}",
+  "bm.clearHistory": "全部清除",
+
+  // harness auto-setup (API keys view)
+  "keys.h.claude": "Claude Code — 粘贴到终端（网关原生支持 Anthropic 协议）：",
+  "keys.h.codex": "Codex — 将提供商追加到 ~/.codex/config.toml 并启动：",
+  "keys.h.opencode": "OpenCode — 写入 ~/.config/opencode/opencode.json（会覆盖！）并启动：",
+  "keys.h.continue": "Continue（VS Code / JetBrains）— 将模型追加到 ~/.continue/config.yaml：",
+  "keys.h.cline1": "Cline（VS Code）— 在扩展设置中选择：",
+  "keys.h.cline2": "设置 → API Provider → OpenAI Compatible，然后粘贴上面的值。",
+  "keys.h.note": "cortiq-auto = 智能路由：路由器为每个请求选择模型。要固定某个模型，请填写其精确名称。Windows 上请在 Git Bash / WSL 中运行脚本，或通过系统环境变量设置相同的值。",
+  "keys.h.protoOff": "Anthropic 协议（/v1/messages）已关闭 — Claude Code 无法连接。",
+  "keys.h.enableProto": "启用",
+  "keys.h.st.installed": "已安装在网关所在机器上",
+  "keys.h.st.configured": "已配置为使用此网关",
+  "keys.h.st.notFound": "网关所在机器上未找到",
+  "bm.degraded": "路由器降级",
+  "bm.routerDegraded": "路由器未及时响应 — 请求走了备用链路；分类不计入统计。",
+  "bm.cutByCap": "预算全用于思考——未能给出答案",
+  "shell.uiStale": "网关已更新 — 此页面运行的是旧界面。",
+  "shell.reload": "重新加载",
+  "keys.col.requests": "请求数",
+  "keys.col.tokens": "Token 入/出",
+  "keys.col.costAll": "$ 累计",
+  "routing.tasks.tier": "复杂度",
+  "routing.tasks.tierAuto": "自动（路由器）",
+  "routing.tasks.tierHint": "哪个模型在哪个复杂度上处理该任务；「任意」在所有层级领先。顺序即回退顺序。high 判定仍会越过「任意」条目升级。",
+  "routing.tasks.tierAny": "任意复杂度",
+  "routing.tasks.addModel": "模型",
+  "routing.bands.enable": "自定义复杂度边界",
+  "routing.bands.hint": "拖动手柄设定 low 到哪里结束、high 从哪里开始 — 手柄会相互推动，数字实时更新。路由器的连续得分将按你的边界重新划分；取消勾选则使用路由器自身的边界。",
+  "tier.low": "简单",
+  "tier.medium": "中等",
+  "tier.high": "困难",
 };

web/js/media-utils.js

@@ -0,0 +1,167 @@
+// Browser-side codecs for cortiq's dependency-free media outputs:
+//  - P6 PPM  → canvas (cortiq imagine links no image library)
+//  - MJPEG+PCM AVI → frame list + canvas player synced to the .wav
+//    (cortiq animate never touches ffmpeg; neither do we)
+
+/// Parse binary P6 PPM into {width, height, rgb: Uint8Array}.
+export function parsePpm(buf) {
+  const b = new Uint8Array(buf);
+  // header: "P6" <ws> width <ws> height <ws> maxval <single ws> raster
+  let pos = 0;
+  const isWs = (c) => c === 32 || c === 9 || c === 10 || c === 13;
+  function token() {
+    while (pos < b.length && (isWs(b[pos]) || b[pos] === 35 /* # comment */)) {
+      if (b[pos] === 35) while (pos < b.length && b[pos] !== 10) pos++;
+      else pos++;
+    }
+    let start = pos;
+    while (pos < b.length && !isWs(b[pos])) pos++;
+    return String.fromCharCode(...b.slice(start, pos));
+  }
+  if (token() !== "P6") throw new Error("not a P6 PPM");
+  const width = parseInt(token());
+  const height = parseInt(token());
+  const maxval = parseInt(token());
+  pos++; // single whitespace after maxval
+  if (!width || !height || !maxval) throw new Error("bad PPM header");
+  return { width, height, rgb: b.subarray(pos, pos + width * height * 3) };
+}
+
+/// Draw a parsed PPM onto a (new or given) canvas. Returns the canvas.
+export function ppmToCanvas(buf, canvas) {
+  const { width, height, rgb } = parsePpm(buf);
+  const c = canvas || document.createElement("canvas");
+  c.width = width;
+  c.height = height;
+  const ctx = c.getContext("2d");
+  const img = ctx.createImageData(width, height);
+  for (let i = 0, j = 0; i < width * height; i++, j += 3) {
+    img.data[i * 4] = rgb[j];
+    img.data[i * 4 + 1] = rgb[j + 1];
+    img.data[i * 4 + 2] = rgb[j + 2];
+    img.data[i * 4 + 3] = 255;
+  }
+  ctx.putImageData(img, 0, 0);
+  return c;
+}
+
+/// Rasterize an uploaded image file to WxH (stretched, as the engine does with
+/// the first frame) and return it as base64-encoded binary P6 PPM.
+export async function fileToPpmB64(file, width, height) {
+  const bmp = await createImageBitmap(file);
+  const c = document.createElement("canvas");
+  c.width = width;
+  c.height = height;
+  const ctx = c.getContext("2d");
+  ctx.drawImage(bmp, 0, 0, width, height);
+  const img = ctx.getImageData(0, 0, width, height).data;
+  const header = `P6\n${width} ${height}\n255\n`;
+  const out = new Uint8Array(header.length + width * height * 3);
+  for (let i = 0; i < header.length; i++) out[i] = header.charCodeAt(i);
+  let p = header.length;
+  for (let i = 0; i < width * height; i++) {
+    out[p++] = img[i * 4];
+    out[p++] = img[i * 4 + 1];
+    out[p++] = img[i * 4 + 2];
+  }
+  // chunked btoa — the frame can be a few MB
+  let bin = "";
+  for (let i = 0; i < out.length; i += 0x8000)
+    bin += String.fromCharCode.apply(null, out.subarray(i, i + 0x8000));
+  return btoa(bin);
+}
+
+/// Extract JPEG frames from an MJPEG AVI (RIFF): walk chunks from 'movi',
+/// collect '00dc'/'00dj' payloads as Blobs.
+export function aviJpegFrames(buf) {
+  const b = new Uint8Array(buf);
+  const dv = new DataView(buf);
+  const fourcc = (o) => String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]);
+  if (fourcc(0) !== "RIFF" || fourcc(8) !== "AVI ") throw new Error("not an AVI");
+  // find the 'movi' LIST
+  let movi = -1;
+  for (let o = 12; o + 12 <= b.length; ) {
+    const id = fourcc(o);
+    const size = dv.getUint32(o + 4, true);
+    if (id === "LIST" && fourcc(o + 8) === "movi") {
+      movi = o + 12;
+      break;
+    }
+    o += 8 + size + (size & 1);
+  }
+  if (movi < 0) throw new Error("no movi list");
+  const frames = [];
+  for (let o = movi; o + 8 <= b.length; ) {
+    const id = fourcc(o);
+    const size = dv.getUint32(o + 4, true);
+    if (id === "00dc" || id === "00dj") {
+      if (size > 0) frames.push(new Blob([b.subarray(o + 8, o + 8 + size)], { type: "image/jpeg" }));
+    } else if (id === "LIST") {
+      o += 12; // descend (rec lists)
+      continue;
+    } else if (id === "idx1") {
+      break;
+    }
+    o += 8 + size + (size & 1);
+  }
+  return frames;
+}
+
+/// Canvas player for extracted MJPEG frames at a fixed fps, synced to an
+/// optional <audio> element (the .wav). Returns {canvas, play, pause, seek0, playing}.
+export function mjpegPlayer(frames, fps, audio) {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  let bitmaps = null; // decoded lazily on first play
+  let raf = null;
+  let t0 = 0;
+  let startFrame = 0;
+  const state = { playing: false };
+
+  async function decodeAll() {
+    if (bitmaps) return;
+    bitmaps = await Promise.all(frames.map((f) => createImageBitmap(f)));
+    if (bitmaps.length) {
+      canvas.width = bitmaps[0].width;
+      canvas.height = bitmaps[0].height;
+      ctx.drawImage(bitmaps[0], 0, 0);
+    }
+  }
+  function drawAt(i) {
+    if (bitmaps && bitmaps[i]) ctx.drawImage(bitmaps[i], 0, 0);
+  }
+  function tick() {
+    // audio clock when available (keeps A/V in sync), wall clock otherwise
+    const t = audio && !audio.paused ? audio.currentTime : (performance.now() - t0) / 1000;
+    const i = Math.min(frames.length - 1, startFrame + Math.floor(t * fps));
+    drawAt(i);
+    if (i >= frames.length - 1) {
+      pause();
+      return;
+    }
+    raf = requestAnimationFrame(tick);
+  }
+  async function play() {
+    await decodeAll();
+    state.playing = true;
+    startFrame = 0;
+    t0 = performance.now();
+    if (audio) {
+      audio.currentTime = 0;
+      audio.play().catch(() => {});
+    }
+    raf = requestAnimationFrame(tick);
+  }
+  function pause() {
+    state.playing = false;
+    if (raf) cancelAnimationFrame(raf);
+    raf = null;
+    if (audio) audio.pause();
+  }
+  async function seek0() {
+    pause();
+    await decodeAll();
+    drawAt(0);
+  }
+  return { canvas, play, pause, seek0, state, decodeAll };
+}

web/js/ui.js

@@ -95,11 +95,25 @@ export function confirmDialog(message) {
 }
 
 // number formatting
+// Money as a DOM node: 4 decimals, the last two rendered smaller — tiny
+// per-request prices stay readable without shouting six zeros.
+export function moneyEl(n) {
+  if (n == null) return document.createTextNode("—");
+  if (n === 0) return document.createTextNode("$0");
+  // sub-0.0001 costs (cheap flash models) would collapse to $0.0000 — grow
+  // precision until two significant digits survive
+  const s = Math.abs(n) >= 0.0001 ? n.toFixed(4) : n.toFixed(Math.min(8, 1 - Math.floor(Math.log10(Math.abs(n)))));
+  return h("span", { class: "money" }, "$" + s.slice(0, -2), h("small", { class: "money-tail" }, s.slice(-2)));
+}
+
 export function money(n) {
   if (n == null) return "—";
   if (n === 0) return "$0";
-  if (Math.abs(n) < 0.01) return "$" + n.toFixed(6);
-  return "$" + n.toFixed(4);
+  if (Math.abs(n) > 0 && Math.abs(n) < 0.0001) return "$" + n.toFixed(Math.min(8, 1 - Math.floor(Math.log10(Math.abs(n)))));
+  // up to 4 decimals, trailing zeros trimmed (but keep money-like 2 minimum)
+  let s = n.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+  if (/\.\d$/.test(s)) s += "0";
+  return "$" + s;
 }
 export function ms(n) {
   return n == null ? "—" : `${Math.round(Number(n))} ms`;

web/js/views/benchmark.js

@@ -0,0 +1,525 @@
+// Benchmark — two modes over the live pipeline:
+//   🧭 Smart routing (default): the product's core promise under test — every
+//      probe goes through cortiq-auto and the router's task/tier decision and
+//      chosen model are judged alongside the answer itself.
+//   🎯 Individual models: the same suite pinned to selected models — compare
+//      quality and speed head-to-head.
+// A redesign of the old standalone benchmark.html: same scoring ideas
+// (keyword checks with | synonyms, think-tag stripping, anti-loop detection,
+// pass/partial/fail), now embedded, localized and CDN-free.
+import { h, mount, toast, ms, money, moneyEl } from "../ui.js";
+import { t, trTier } from "../i18n.js";
+import { api, testStream } from "../api.js";
+
+// ── built-in suite ──────────────────────────────────────────────────────────
+// Checks are language-neutral where possible (digits, identifiers, emails);
+// `check` entries may hold |-separated synonyms — one hit per entry counts.
+// `quick: true` marks the fast subset.
+// `label`: router task labels accepted as a correct classification (null = not
+// judged — the prompt has no natural label in the taxonomy).
+const SUITE = [
+  { id: "math-mult", cat: "math", label: ["math"], quick: true, max: 96, prompt: "What is 17 * 23? Answer with the number only.", check: ["391"] },
+  { id: "math-eq", cat: "math", label: ["math"], max: 128, prompt: "Solve 2x + 6 = 14. Answer with the value of x only.", check: ["4"] },
+  { id: "logic-syll", cat: "logic", label: ["qa", "math"], max: 96, prompt: "If all bloops are razzies and all razzies are lazzies, are all bloops lazzies? Answer yes or no.", check: ["yes|да|oui|ja|sí|si|evet|是"] },
+  { id: "count-letters", cat: "logic", label: ["qa", "math"], quick: true, max: 64, prompt: "How many letters are in the word 'cat'? Answer with a digit.", check: ["3"] },
+  { id: "apples", cat: "logic", label: ["math", "qa"], quick: true, max: 96, prompt: "John has 3 apples, buys 2 more, then eats 1. How many apples does he have? Answer with a digit.", check: ["4"] },
+  { id: "code-fact", cat: "code", label: ["code"], max: 256, prompt: "Write a Python function factorial(n) that returns n!.", check: ["def", "factorial", "return"] },
+  { id: "qa-capital", cat: "qa", label: ["qa"], quick: true, max: 48, prompt: "What is the capital of France? One word.", check: ["paris|париж"] },
+  { id: "primes", cat: "qa", label: ["math", "qa"], max: 96, prompt: "List the first five prime numbers, comma-separated.", check: ["2", "3", "5", "7", "11"] },
+  { id: "instr-ok", cat: "instruction", label: null, quick: true, max: 32, prompt: "Reply with exactly the word OK and nothing else.", check: ["ok"] },
+  { id: "extract-email", cat: "extraction", label: ["extraction"], quick: true, max: 64, prompt: "Extract the email address from: 'Contact us at info@example.com today.' Reply with the address only.", check: ["info@example.com"] },
+  { id: "translate", cat: "translation", label: ["translation"], max: 64, prompt: "Translate to English: «Доброе утро». Reply with the translation only.", check: ["good morning"] },
+  { id: "format-json", cat: "instruction", label: null, max: 96, prompt: 'Return a JSON object with a single key "n" whose value is 7. JSON only.', check: ['"n"', "7"] },
+  { id: "summarize", cat: "summarization", label: ["summarization"], max: 96, prompt: "Summarize in one short sentence: 'The cat sat on the warm mat by the window. After a while it curled up and fell asleep in the sun.'", check: ["cat|кот|кошк"] },
+  { id: "creative", cat: "creative-writing", label: ["creative-writing"], max: 512, prompt: "Write a two-line poem about the sea.", check: ["sea|море|ocean"] },
+  { id: "chitchat", cat: "chitchat", label: ["chitchat"], quick: true, max: 48, prompt: "Hi! How are you today?", check: [] },
+  // hard probes: dense enough that the router's complexity model rates them
+  // high tier — this is where tier-based routing actually earns its keep.
+  // Prompts are GENERATED fresh each run (domain + numbers rotate): the
+  // router deliberately scores familiar text as less novel, so any fixed
+  // wording would decay to medium/low over repeated runs.
+  // label: null — ambiguity between task labels is exactly what makes these high
+  { id: "hard-science", cat: "hard", label: null, judge: "route", max: 8, check: [], gen: "science" },
+  { id: "hard-ops", cat: "hard", label: null, judge: "route", max: 8, check: [], gen: "ops" },
+];
+
+// Fresh hard prompts per run. Two findings drive the design (measured against
+// the live router): ambiguity carries the biggest weight in the complexity
+// score, so INTERDISCIPLINARY prompts (science + engineering + planning) rate
+// high reliably, while single-domain ones classify too confidently and drop
+// to medium; and familiar text loses novelty on every repeat, so domains and
+// numbers rotate to keep each run lexically fresh.
+function hardPrompt(kind) {
+  const pick = (a) => a[(Math.random() * a.length) | 0];
+  const n = (lo, hi) => lo + ((Math.random() * (hi - lo)) | 0);
+  const science = [
+    () => `Architect a protein-folding inference pipeline for a wet lab: ensemble MSA generation with taxonomy-aware subsampling, template selection under a ${n(30, 60)} percent identity ceiling, distributed attention across ${n(4, 16)} GPUs with activation checkpointing, confidence calibration against experimental B-factors, and an active-learning loop that decides which of ${n(300, 2000)} candidate mutants to synthesize next week.`,
+    () => `Schedule observations for a network of ${n(8, 30)} robotic telescopes chasing gravitational-wave counterparts: probability skymaps updated every ${n(5, 20)} minutes, slew-time-aware target assignment with decaying rewards, cloud-cover forecasts folded in as stochastic availability, spectroscopy triggered only above a ${n(40, 85)} percent kilonova likelihood, and a plan to validate the scheduler against the one historical multi-messenger event.`,
+    () => `Run a closed-loop materials-discovery campaign for solid-state electrolytes: DFT screening of ${n(2000, 9000)} candidates, Bayesian optimization driving ${n(3, 12)} parallel synthesis robots, CNN-based XRD phase identification, an ionic-conductivity target of ${n(2, 25)} mS/cm, and an explicit decision policy for when simulation is trusted over synthesis.`,
+    () => `Design a surface-code error-correction pipeline for a ${n(400, 3000)}-qubit superconducting processor: choose a code distance for a logical error target of 1e-${n(9, 14)} at physical error rate 1e-3, syndrome extraction avoiding hook errors, a real-time decoder under a ${n(1, 4)} microsecond budget, and the classical co-processor layout with feedback for lattice surgery.`,
+    () => `Design a monitoring-reporting-verification pipeline for soil-carbon credits across ${n(500, 5000)} farms: satellite spectral indices calibrated against ${n(800, 4000)} physical core samples, hierarchical Bayesian estimation with shrinkage, additionality argued against county-level counterfactuals, uncertainty discounts priced into issuance, and an audit sampling plan catching over-reporting with ${n(90, 99)} percent power.`,
+    () => `Plan a cryo-EM structure-determination campaign for a ${n(300, 900)} kDa membrane complex: grid-screening strategy across ${n(4, 12)} detergent conditions, particle picking with a distilled transformer at ${n(2, 9)} million particles, ab-initio reconstruction ambiguity resolved by tilt-pair validation, local-resolution-aware model building, and a decision rule for when to stop collecting and publish.`,
+  ];
+  const ops = [
+    () => `Model a dengue outbreak across ${n(20, 90)} districts by coupling an SEIR compartment model to vaccine cold-chain optimization: transmission parameters estimated from noisy case counts with a particle filter, uncertainty propagated into weekly demand forecasts, refrigerated routing under a ${n(120, 400)}-dose-per-crate constraint, and a defended ethical weighting for which ${n(3, 12)} districts get priority when supply covers ${n(20, 60)} percent of demand.`,
+    () => `Co-optimize a regional power grid's day-ahead market with a fleet of ${n(200, 2000)} grid-scale batteries: bid curves learned from ${n(2, 6)} years of price data, unit commitment as mixed-integer programming with ramp constraints, degradation amortized into marginal costs, N-1 contingency screening after every dispatch, and a mechanism-design argument that the bidding rules cannot be gamed by a coalition controlling ${n(10, 30)} percent of storage.`,
+    () => `Couple regional climate downscaling at ${n(2, 12)} km resolution to catastrophe-bond pricing: bias-correct ${n(10, 40)} CMIP ensemble members, generate stochastic hurricane tracks, propagate landfall distributions into a portfolio of ${n(30, 200)} bonds, price the attachment probabilities, and defend the discount rate applied to century-scale tail risk.`,
+    () => `Co-design a hospital emergency department's triage policy with its nurse staffing schedule: arrivals as a time-varying Poisson process fitted to ${n(2, 6)} years of data, acuity drift as a hidden Markov chain, staffing as integer programming over ${n(8, 12)}-hour shifts, a queueing bound on door-to-doctor time at the ${n(90, 99)}th percentile, and a fairness constraint preventing systematic delays for low-acuity elderly patients.`,
+    () => `Optimize a container port's berth allocation jointly with tidal windows and rail departures: vessel ETAs with heavy-tailed uncertainty, berth-crane assignment as a mixed-integer program re-solved hourly, tide-constrained draft limits for the ${n(3, 8)} deepest berths, a queueing model of the truck gate coupled to city traffic, and a robustness argument for surviving a ${n(24, 72)}-hour crane outage.`,
+    () => `Schedule observations for a fleet of ${n(6, 40)} agricultural drones across ${n(200, 2000)} fields: multispectral revisit deadlines driven by crop growth-stage models, battery-swap logistics as a vehicle-routing problem with time windows, rain forecasts as stochastic field availability, disease-outbreak alerts pre-empting the plan, and a proof the replanner never starves a field past its agronomic deadline.`,
+  ];
+  return pick(kind === "science" ? science : ops)();
+}
+
+const LS_CUSTOM = "allaigate_bench_custom";
+const LS_HISTORY = "allaigate_bench_history";
+
+function customTests() {
+  try {
+    return JSON.parse(localStorage.getItem(LS_CUSTOM) || "[]");
+  } catch {
+    return [];
+  }
+}
+function saveCustom(list) {
+  localStorage.setItem(LS_CUSTOM, JSON.stringify(list));
+}
+function history() {
+  try {
+    return JSON.parse(localStorage.getItem(LS_HISTORY) || "[]");
+  } catch {
+    return [];
+  }
+}
+function pushHistory(run) {
+  const l = history();
+  l.unshift(run);
+  localStorage.setItem(LS_HISTORY, JSON.stringify(l.slice(0, 12)));
+}
+function saveHistory(l) {
+  localStorage.setItem(LS_HISTORY, JSON.stringify(l));
+}
+
+// ── evaluation (ported from the old benchmark, trimmed) ─────────────────────
+function stripThink(text) {
+  return text.replace(/<(?:\|)?(?:think|thought)(?:\|)?>[\s\S]*?(?:<\/(?:\|)?(?:think|thought)(?:\|)?>|$)/gi, "").trim();
+}
+// tail loop: the same 12+ char chunk repeated 3+ times back to back
+function looksLooped(text) {
+  const tail = text.slice(-360);
+  for (let len = 12; len <= 60; len += 8) {
+    const probe = tail.slice(-len);
+    if (probe && tail.split(probe).length - 1 >= 3) return true;
+  }
+  return false;
+}
+function evaluate(raw, test) {
+  let text = stripThink(raw);
+  if (!text && raw) text = raw; // max_tokens cut inside <think> — judge the raw
+  const resp = text.toLowerCase();
+  if (!resp.trim()) return { status: "fail", score: 0, note: t("bm.emptyAnswer") };
+  if (looksLooped(resp)) return { status: "fail", score: 0, note: t("bm.loopDetected") };
+  if (!test.check.length) return { status: "pass", score: 1, note: "✓" };
+  let hit = 0;
+  for (const cond of test.check) {
+    const opts = cond.toLowerCase().split("|").map((s) => s.trim());
+    if (opts.some((o) => o && resp.includes(o))) hit++;
+  }
+  const frac = hit / test.check.length;
+  const status = frac >= 1 ? "pass" : frac >= 0.5 ? "partial" : "fail";
+  return { status, score: frac, note: `${hit}/${test.check.length}` };
+}
+
+export async function renderBenchmark() {
+  const modelsData = await api.listModels();
+  const ids = (modelsData.models || []).map((m) => m.id);
+  const root = h("div");
+  let running = false;
+  let stopFlag = false;
+
+  let mode = "routing"; // routing (cortiq-auto, the product's feature) | models
+  const modelCbs = ids.map((id) => ({ id, cb: h("input", { type: "checkbox", checked: ids.length === 1 ? true : null }) }));
+  const quickCb = h("input", { type: "checkbox", checked: true });
+  const resultsHost = h("div", {});
+  const progressHost = h("div", {});
+  const historyHost = h("div", {});
+
+  const modeDesc = h("p", { class: "muted", style: "margin:8px 0 0" }, t("bm.mode.routingDesc"));
+  const modelsPick = h("div", { class: "flex wrap", style: "gap:10px; margin-top:12px; display:none" },
+    ...modelCbs.map(({ id, cb }) => h("label", { class: "check" }, cb, h("span", { class: "mono" }, id))));
+  const modeSeg = h("div", { class: "seg" },
+    h("button", { class: "active" }, "🧭 " + t("bm.mode.routing")),
+    h("button", {}, "🎯 " + t("bm.mode.models")));
+  modeSeg.querySelectorAll("button").forEach((b, i) =>
+    b.addEventListener("click", () => {
+      mode = i === 0 ? "routing" : "models";
+      modeSeg.querySelectorAll("button").forEach((x, j) => x.classList.toggle("active", j === i));
+      modelsPick.style.display = mode === "models" ? "" : "none";
+      modeDesc.textContent = t(mode === "routing" ? "bm.mode.routingDesc" : "bm.mode.modelsDesc");
+    }));
+
+  function suite() {
+    const base = SUITE.concat(customTests());
+    return quickCb.checked ? base.filter((x) => x.quick || x.custom) : base;
+  }
+
+  const runBtn = h("button", { class: "btn primary" }, "▶ " + t("bm.run"));
+  const stopBtn = h("button", { class: "btn ghost", style: "display:none" }, "✕ " + t("import.cancel"));
+  stopBtn.addEventListener("click", () => {
+    stopFlag = true;
+    stopBtn.disabled = true;
+  });
+
+  runBtn.addEventListener("click", async () => {
+    const models = mode === "routing" ? ["cortiq-auto"] : modelCbs.filter((m) => m.cb.checked).map((m) => m.id);
+    if (!models.length) {
+      toast(t("bm.pickModel"), "warn");
+      return;
+    }
+    running = true;
+    stopFlag = false;
+    runBtn.disabled = true;
+    stopBtn.style.display = "";
+    stopBtn.disabled = false;
+    const tests = suite().filter((x) => mode === "routing" || x.judge !== "route");
+    const run = { ts: Date.now(), mode, quick: quickCb.checked, models: {}, nTests: tests.length };
+
+    for (const model of models) {
+      const rec = { results: [], score: 0, tokS: [], ttft: [], failed: false };
+      run.models[model] = rec;
+      for (let i = 0; i < tests.length; i++) {
+        if (stopFlag) break;
+        const test = tests[i];
+        const prompt = test.gen ? hardPrompt(test.gen) : test.prompt;
+        mount(
+          progressHost,
+          h("div", { class: "card" },
+            h("div", { class: "flex" },
+              h("span", { class: "spinner" }), " ",
+              h("b", { class: "mono" }, mode === "routing" ? t("bm.mode.routing") : model), " · ",
+              t("bm.testOf", { i: i + 1, n: tests.length }), " · ",
+              h("span", { class: "muted" }, test.id)),
+            h("div", { class: "muted small", style: "margin-top:6px; font-style:italic" }, "«" + prompt.slice(0, 110) + (prompt.length > 110 ? "…»" : "»")),
+            h("div", { class: "pbar", style: "margin-top:8px" },
+              h("div", { class: "pbar-fill det", style: `width:${Math.round((i / tests.length) * 100)}%` })))
+        );
+        const started = performance.now();
+        let text = "";
+        try {
+          const info = await testStream(
+            // +256: headroom for reasoning models — a tight cap cuts them
+            // mid-<think> and turns a correct model into a false ❌
+            { model, messages: [{ role: "user", content: prompt }], temperature: 0, max_tokens: (test.max || 128) + 256 },
+            (d) => (text += d)
+          );
+          const latency = performance.now() - started;
+          let ev;
+          if (test.judge === "route") {
+            // the test asserts the ROUTER's decision: did it rate this high?
+            // Two honest retries. (1) The SAME prompt after a pause: the
+            // router judges difficulty in the background — the first-ever
+            // occurrence routes by prior, the judgement lands in the cache a
+            // couple of seconds later, so the second occurrence is the real
+            // steady-state answer. (2) A fresh template, in case this one's
+            // wording clustered into a burnt region.
+            if (info.tier !== "high" && test.gen) {
+              const attempts = [
+                { prompt, delayMs: 4000 },
+                { prompt: hardPrompt(test.gen), delayMs: 0 },
+              ];
+              for (const a of attempts) {
+                if (info.tier === "high") break;
+                if (a.delayMs) await new Promise((r) => setTimeout(r, a.delayMs));
+                try {
+                  const again = await testStream(
+                    { model, messages: [{ role: "user", content: a.prompt }], temperature: 0, max_tokens: (test.max || 128) + 256 },
+                    () => {}
+                  );
+                  info.cost_usd = (info.cost_usd || 0) + (again.cost_usd || 0);
+                  if (again.tier === "high") {
+                    info.tier = again.tier;
+                    info.selected_model = again.selected_model;
+                    info.task_label = again.task_label;
+                    info.route_source = again.route_source;
+                  }
+                } catch { /* keep previous attempt */ }
+              }
+            }
+            ev = info.tier === "high"
+              ? { status: "pass", score: 1, note: "high ✓" }
+              : { status: "fail", score: 0, note: (info.tier || "—") + " ≠ high" };
+          } else {
+            ev = evaluate(text, test);
+          }
+          const compl = info.usage?.completion_tokens;
+          if (test.judge !== "route" && ev.status === "fail" && !stripThink(text).trim() && compl >= (test.max || 128) + 250) {
+            ev.note = t("bm.cutByCap"); // the whole budget went into <think>
+          }
+          if (compl && latency > 0) {
+            const gen = info.ttft_ms != null ? Math.max(1, latency - info.ttft_ms) : latency;
+            rec.tokS.push(compl / (gen / 1000));
+          }
+          if (info.ttft_ms != null) rec.ttft.push(info.ttft_ms);
+          const row = { id: test.id, cat: test.cat, ...ev, latency: Math.round(latency), cost: info.cost_usd || 0, answer: stripThink(text).slice(0, 300) };
+          if (mode === "routing") {
+            // router timed out / fell back — there was no classification to
+            // judge, so it must not count against accuracy
+            row.degraded = !info.task_label
+              || info.task_label === "degraded"
+              || String(info.route_source || "").includes("degraded");
+            row.task = info.task_label || "—";
+            row.tier = info.tier || "—";
+            row.chosen = info.selected_model || "—";
+            row.source = info.route_source || "—";
+            row.expected = test.label; // null = classification not judged
+            row.taskOk = test.label && !row.degraded ? test.label.includes(info.task_label) : null;
+          }
+          rec.results.push(row);
+        } catch (e) {
+          rec.results.push({ id: test.id, cat: test.cat, status: "fail", score: 0, note: String(e.message || e).slice(0, 80), latency: 0, answer: "" });
+          rec.failed = true;
+        }
+        renderResults(run, true); // live: строка появляется сразу после теста
+      }
+      if (stopFlag) break;
+    }
+
+    mount(progressHost);
+    running = false;
+    runBtn.disabled = false;
+    stopBtn.style.display = "none";
+    if (!stopFlag) {
+      pushHistory(run);
+      // финальный аккорд: короткий вердикт с процентами и деньгами
+      const first = run.models[Object.keys(run.models)[0]];
+      if (first) {
+        const st = stats(first);
+        const judged = first.results.filter((r) => r.taskOk != null);
+        const cls = judged.length ? ` · ${judged.filter((r) => r.taskOk).length}/${judged.length}` : "";
+        const total = Object.values(run.models).reduce((a, rec) => a + stats(rec).cost, 0);
+        toast(t("bm.verdict", { p: Math.round(st.score * 100) + "%" + cls, s: money(total) }), "ok", 6000);
+      }
+    }
+    renderResults(run);
+    renderHistory();
+  });
+
+  function statusIcon(s) {
+    return s === "pass" ? "✅" : s === "partial" ? "◐" : "❌";
+  }
+
+  function stats(rec) {
+    const n = rec.results.length || 1;
+    return {
+      score: rec.results.reduce((a, r) => a + r.score, 0) / n,
+      tokS: rec.tokS.length ? rec.tokS.reduce((a, b) => a + b, 0) / rec.tokS.length : null,
+      ttft: rec.ttft.length ? rec.ttft.reduce((a, b) => a + b, 0) / rec.ttft.length : null,
+      cost: rec.results.reduce((a, r) => a + (r.cost || 0), 0),
+    };
+  }
+
+  function renderResults(run, live) {
+    const models = Object.keys(run.models);
+    if (!models.length) {
+      mount(resultsHost);
+      return;
+    }
+    const routing = run.mode === "routing";
+    const detail = h("div", {});
+
+    let summary;
+    if (routing) {
+      const rec = run.models[models[0]];
+      const st = stats(rec);
+      const judged = rec.results.filter((r) => r.taskOk != null);
+      const okCount = judged.filter((r) => r.taskOk).length;
+      // какие модели реально выбирал роутер
+      const dist = {};
+      for (const r of rec.results) {
+        if (!r.chosen) continue;
+        dist[r.chosen] = dist[r.chosen] || { n: 0, cost: 0 };
+        dist[r.chosen].n++;
+        dist[r.chosen].cost += r.cost || 0;
+      }
+      const pct = Math.round(st.score * 100);
+      summary = h("div", {},
+        h("div", { class: "kpis", style: "grid-template-columns: repeat(auto-fit, minmax(150px, 1fr))" },
+          h("div", { class: "kpi" }, h("div", { class: "big" }, pct + "%"), h("div", { class: "lbl" }, t("bm.answersOk"))),
+          h("div", { class: "kpi" }, h("div", { class: "big" }, judged.length ? `${okCount}/${judged.length}` : "—"), h("div", { class: "lbl" }, t("bm.classAcc"))),
+          h("div", { class: "kpi" }, h("div", { class: "big" }, st.ttft != null ? ms(Math.round(st.ttft)) : "—"), h("div", { class: "lbl" }, t("pg.ttft"))),
+          h("div", { class: "kpi" }, h("div", { class: "big" }, st.tokS != null ? st.tokS.toFixed(1) : "—"), h("div", { class: "lbl" }, "tok/s")),
+          h("div", { class: "kpi" }, h("div", { class: "big" }, moneyEl(st.cost)), h("div", { class: "lbl" }, t("bm.spent")))),
+        h("div", { class: "flex wrap", style: "gap:6px; margin-top:4px" },
+          h("span", { class: "muted small" }, t("bm.modelDist") + ":"),
+          ...Object.entries(dist).map(([m, d]) =>
+            h("span", { class: "badge" }, `${m} × ${d.n}`, d.cost > 0 ? " · " : "", d.cost > 0 ? moneyEl(d.cost) : ""))));
+    } else {
+      const sorted = models.slice().sort((a, b) => stats(run.models[b]).score - stats(run.models[a]).score);
+      summary = h("div", {},
+        ...sorted.map((m) => {
+          const st = stats(run.models[m]);
+          const pct = Math.round(st.score * 100);
+          return h("div", { class: "bm-sum" },
+            h("div", { class: "flex" },
+              h("b", { class: "mono grow" }, m),
+              h("span", { class: "badge " + (pct >= 80 ? "ok" : pct >= 50 ? "" : "bad") }, pct + "%"),
+              st.tokS != null ? h("span", { class: "muted small", style: "margin-left:8px" }, st.tokS.toFixed(1) + " tok/s") : null,
+              st.ttft != null ? h("span", { class: "muted small", style: "margin-left:8px" }, "TTFT " + ms(Math.round(st.ttft))) : null,
+              st.cost > 0 ? h("span", { class: "muted small", style: "margin-left:8px" }, t("bm.spent") + " ", moneyEl(st.cost)) : null),
+            h("div", { class: "sysbar" }, h("i", { class: pct < 50 ? "bad" : "", style: `width:${pct}%` })));
+        }));
+    }
+
+    function answerCell(r, m) {
+      const cell = h("td", { class: "bm-cell", title: r.answer || r.note },
+        statusIcon(r.status) + " ",
+        h("span", { class: "muted small" }, r.note + (r.latency ? ` · ${(r.latency / 1000).toFixed(1)}s` : "")));
+      cell.addEventListener("click", () => {
+        mount(detail, h("div", { class: "card" },
+          h("div", { class: "card-title" }, `${r.id} · ${m} · ${statusIcon(r.status)}`),
+          h("pre", { class: "conv-log", style: "max-height:200px" }, r.answer || "—")));
+      });
+      return cell;
+    }
+
+    let header, rows;
+    if (routing) {
+      const rec = run.models[models[0]];
+      header = h("tr", {},
+        h("th", {}, t("bm.test")),
+        h("th", {}, t("pg.task")),
+        h("th", {}, t("pg.tier")),
+        h("th", {}, t("pg.model")),
+        h("th", {}, t("bm.answer")));
+      rows = rec.results.map((r) =>
+        h("tr", {},
+          h("td", {}, h("div", {}, r.id), h("div", { class: "muted small" }, r.cat)),
+          h("td", {},
+            r.degraded
+              ? h("span", { class: "muted", title: t("bm.routerDegraded") }, "⚠ " + t("bm.degraded"))
+              : r.taskOk == null
+                ? h("span", { class: "muted" }, r.task || "—")
+                : h("span", { class: r.taskOk ? "" : "err" },
+                    (r.taskOk ? "✓ " : "✗ ") + r.task,
+                    r.taskOk ? "" : h("div", { class: "muted small" }, t("bm.expectedLbl") + " " + (r.expected || []).join("/")))),
+          h("td", {}, r.tier ? h("span", { class: "badge tier-" + r.tier }, trTier(r.tier)) : "—"),
+          h("td", {},
+            h("span", { class: "mono small" }, r.chosen || "—"),
+            r.cost > 0 ? h("div", { class: "muted small" }, moneyEl(r.cost)) : null,
+            r.source && r.source.includes("task-rule") ? h("div", { class: "badge", style: "margin-top:2px" }, "task-rule") : null),
+          answerCell(r, r.chosen || "cortiq-auto")));
+    } else {
+      header = h("tr", {}, h("th", {}, t("bm.test")), ...models.map((m) => h("th", { class: "mono" }, m)));
+      rows = (run.models[models[0]].results || []).map((_, i) =>
+        h("tr", {},
+          h("td", {},
+            h("div", {}, run.models[models[0]].results[i].id),
+            h("div", { class: "muted small" }, run.models[models[0]].results[i].cat)),
+          ...models.map((m) => {
+            const r = run.models[m].results[i];
+            return r ? answerCell(r, m) : h("td", {}, "—");
+          })));
+    }
+
+    mount(resultsHost,
+      h("div", { class: "card" },
+        h("div", { class: "card-head" },
+          h("h3", {}, (routing ? "🧭 " : "🎯 ") + t("bm.results")),
+          h("span", { class: "card-head sub" },
+            (live ? t("bm.liveRunning") + " · " : "") + new Date(run.ts).toLocaleString() + (run.quick ? " · " + t("bm.quick") : ""))),
+        summary,
+        h("div", { class: "table-wrap", style: "margin-top:14px" }, h("table", {}, h("thead", {}, header), h("tbody", {}, ...rows))),
+        h("div", { class: "muted small", style: "margin-top:6px" }, t("bm.cellHint"))),
+      detail);
+  }
+
+  function renderHistory() {
+    const l = history();
+    if (!l.length) {
+      mount(historyHost);
+      return;
+    }
+    const clearAll = h("button", { class: "btn ghost sm danger" }, "🗑 " + t("bm.clearHistory"));
+    clearAll.addEventListener("click", () => {
+      saveHistory([]);
+      renderHistory();
+    });
+    mount(historyHost, h("div", { class: "card" },
+      h("div", { class: "card-head" },
+        h("h3", {}, t("bm.history")),
+        h("div", { class: "right" }, clearAll)),
+      ...l.map((run, idx) => {
+        const models = Object.keys(run.models);
+        const scoreOf = (m) => {
+          const rs = run.models[m].results || [];
+          return rs.length ? rs.reduce((a, r) => a + r.score, 0) / rs.length : 0;
+        };
+        const best = models.slice().sort((a, b) => scoreOf(b) - scoreOf(a))[0];
+        const row = h("div", { class: "flex bench-row", style: "cursor:pointer" },
+          h("span", {}, run.mode === "routing" ? "🧭" : "🎯"),
+          h("span", { class: "muted small" }, new Date(run.ts).toLocaleString()),
+          h("span", { class: "grow mono small" }, run.mode === "routing" ? t("bm.mode.routing") : models.join(", ")),
+          run.quick ? h("span", { class: "badge" }, t("bm.quick")) : null,
+          best ? h("b", {}, Math.round(scoreOf(best) * 100) + "%") : null,
+          h("button", { class: "btn sm ghost danger", title: t("common.delete"), onClick: (e) => {
+            e.stopPropagation();
+            l.splice(idx, 1);
+            saveHistory(l);
+            renderHistory();
+          } }, "×"));
+        row.addEventListener("click", () => renderResults(run));
+        return row;
+      })));
+  }
+
+  // ── custom tests (stored in the browser) ──
+  function customCard() {
+    const host = h("div", { class: "card" });
+    function paint() {
+      const list = customTests();
+      const promptIn = h("input", { placeholder: t("bm.promptPh") });
+      const checkIn = h("input", { placeholder: t("bm.checkPh") });
+      const addBtn = h("button", { class: "btn ghost sm" }, "+ " + t("bm.addTest"));
+      addBtn.addEventListener("click", () => {
+        const prompt = promptIn.value.trim();
+        const check = checkIn.value.split(",").map((s) => s.trim()).filter(Boolean);
+        if (!prompt || !check.length) return;
+        list.push({ id: "custom-" + (list.length + 1), cat: "custom", custom: true, max: 128, prompt, check });
+        saveCustom(list);
+        paint();
+      });
+      mount(host,
+        h("div", { class: "card-title" }, t("bm.custom")),
+        h("div", { class: "muted small", style: "margin-bottom:8px" }, t("bm.customHint")),
+        ...list.map((tst, i) =>
+          h("div", { class: "flex bench-row" },
+            h("span", { class: "grow small" }, tst.prompt.slice(0, 90)),
+            h("span", { class: "muted small mono" }, tst.check.join(", ").slice(0, 40)),
+            h("button", { class: "btn sm ghost danger", onClick: () => { list.splice(i, 1); saveCustom(list); paint(); } }, "×"))),
+        h("div", { class: "flex", style: "gap:8px; margin-top:8px" }, promptIn, checkIn, addBtn));
+    }
+    paint();
+    return host;
+  }
+
+  mount(root,
+    h("div", { class: "page-head" },
+      h("h2", {}, t("bm.title")),
+      h("p", {}, t("bm.subtitle"))),
+    ids.length === 0 ? h("div", { class: "callout" }, t("routing.empty")) : null,
+    h("div", { class: "card" },
+      modeSeg,
+      modeDesc,
+      modelsPick,
+      h("div", { class: "flex", style: "justify-content:space-between; margin-top:14px" },
+        h("label", { class: "check", style: "margin:0", title: t("bm.quickHint") }, quickCb, "⚡ " + t("bm.quickMode")),
+        h("div", { class: "flex", style: "gap:8px" }, stopBtn, runBtn)),
+      h("div", { class: "muted small", style: "margin-top:6px" },
+        t("bm.suiteInfo", { q: SUITE.filter((x) => x.quick).length, f: SUITE.length }))),
+    progressHost,
+    resultsHost,
+    customCard(),
+    historyHost);
+  renderHistory();
+  return root;
+}

web/js/views/dashboard.js

@@ -1,5 +1,5 @@
 // Dashboard — KPIs, time-series charts, breakdown, recent requests, health.
-import { h, mount, money, num, ms, pct, timeAgo, toast, confirmDialog } from "../ui.js";
+import { h, mount, money, moneyEl, num, ms, pct, timeAgo, toast, confirmDialog } from "../ui.js";
 import { t } from "../i18n.js";
 import { api } from "../api.js";
 import { lineChart, barList } from "../charts.js";
@@ -27,6 +27,87 @@ export async function renderDashboard() {
   let groupby = "model";
   const root = h("div");
 
+  // ── host metrics: CPU sparkline + RAM / disk bars, refreshed every 2 s ──
+  const sysHost = h("div", {});
+  const cpuHistory = []; // last ~60 samples (2 min)
+  function fmtG(n) {
+    return (n / 1e9).toFixed(1) + " GB";
+  }
+  function bar(frac, cls) {
+    return h("div", { class: "sysbar" }, h("i", { class: cls || "", style: `width:${Math.min(100, frac * 100)}%` }));
+  }
+  function sparkline(values, w, hgt) {
+    const c = document.createElement("canvas");
+    c.width = w;
+    c.height = hgt;
+    const ctx = c.getContext("2d");
+    const accent = getComputedStyle(document.documentElement).getPropertyValue("--accent").trim() || "#5b8def";
+    ctx.strokeStyle = accent;
+    ctx.lineWidth = 1.5;
+    ctx.beginPath();
+    const n = Math.max(values.length, 2);
+    values.forEach((v, i) => {
+      const x = (i / (n - 1)) * (w - 2) + 1;
+      const y = hgt - 2 - (Math.min(v, 100) / 100) * (hgt - 4);
+      if (i === 0) ctx.moveTo(x, y);
+      else ctx.lineTo(x, y);
+    });
+    ctx.stroke();
+    return c;
+  }
+  async function refreshSystem() {
+    let sys;
+    try {
+      sys = await api.system();
+    } catch {
+      return;
+    }
+    if (!sys.ts) return;
+    cpuHistory.push(sys.cpu_percent || 0);
+    if (cpuHistory.length > 60) cpuHistory.shift();
+    const ramFrac = sys.ram_total ? sys.ram_used / sys.ram_total : 0;
+    const diskFrac = sys.disk_total ? (sys.disk_total - sys.disk_free) / sys.disk_total : 0;
+    mount(
+      sysHost,
+      h(
+        "div",
+        { class: "card" },
+        h("div", { class: "card-title" }, t("dash.sys.title")),
+        h(
+          "div",
+          { class: "sysgrid" },
+          h("div", { class: "sysitem" },
+            h("div", { class: "flex" },
+              h("span", { class: "k grow" }, `CPU · ${sys.cores} ${t("dash.sys.cores")}`),
+              h("span", { class: "v mono" }, (sys.cpu_percent || 0).toFixed(0) + "%")),
+            sparkline(cpuHistory, 220, 36),
+            h("div", { class: "muted small" }, `load ${Number(sys.load1 || 0).toFixed(1)}`)),
+          h("div", { class: "sysitem" },
+            h("div", { class: "flex" },
+              h("span", { class: "k grow" }, "RAM"),
+              h("span", { class: "v mono" }, `${fmtG(sys.ram_used)} / ${fmtG(sys.ram_total)}`)),
+            bar(ramFrac, ramFrac > 0.9 ? "bad" : ""),
+            h("div", { class: "muted small" }, t("dash.sys.gateway") + " " + (sys.process_rss / 1e6).toFixed(0) + " MB")),
+          h("div", { class: "sysitem" },
+            h("div", { class: "flex" },
+              h("span", { class: "k grow" }, t("dash.sys.disk")),
+              h("span", { class: "v mono" }, t("dash.sys.free") + " " + fmtG(sys.disk_free)),
+            ),
+            bar(diskFrac, diskFrac > 0.92 ? "bad" : ""),
+            h("div", { class: "muted small" }, `${fmtG(sys.disk_total - sys.disk_free)} / ${fmtG(sys.disk_total)}`))
+        )
+      )
+    );
+  }
+  const sysTimer = setInterval(() => {
+    if (!root.isConnected) {
+      clearInterval(sysTimer);
+      return;
+    }
+    refreshSystem();
+  }, 2000);
+  refreshSystem();
+
   async function load() {
     const rangeSecs = range;
     let stats, recent, health;
@@ -80,12 +161,14 @@ export async function renderDashboard() {
         { class: "kpis" },
         kpi(num(tot.requests), t("dash.kpi.requests")),
         kpi(num(tot.total_tokens), t("dash.kpi.tokens")),
-        kpi(money(tot.cost_usd), t("dash.kpi.cost")),
+        kpi(moneyEl(tot.cost_usd), t("dash.kpi.cost")),
         kpi(ms(tot.avg_latency_ms), t("dash.kpi.latency")),
         kpi(pct(tot.success_rate), t("dash.kpi.success")),
         kpi(num(tot.failovers), t("dash.kpi.failovers"))
       ),
 
+      sysHost,
+
       h(
         "div",
         { class: "grid cols-2" },

web/js/views/featured.js

@@ -0,0 +1,205 @@
+// Ready-to-run .cmf models, read live from the infosave HuggingFace account via
+// /setup/featured — so a newly published model shows up without a code change.
+// Shared by the first-run wizard and the Import view: same cards, same download
+// / progress / delete behaviour in both places.
+import { h, mount, toast } from "../ui.js";
+import { t } from "../i18n.js";
+import { api } from "../api.js";
+
+export async function loadFeatured() {
+  try {
+    const r = await api.setupFeatured();
+    return r.models || [];
+  } catch {
+    return [];
+  }
+}
+
+export function quantFromVariant(name) {
+  const s = (name || "").toLowerCase();
+  if (s.includes("q1t")) return "Q1T";
+  if (s.includes("q2tp")) return "Q2TP";
+  if (s.includes("q4tp")) return "Q4TP";
+  if (s.includes("q4t")) return "Q4T";
+  if (s.includes("q1")) return "Q1";
+  if (s.includes("q4")) return "Q4";
+  if (s.includes("q8")) return "Q8";
+  return "";
+}
+
+// Same thresholds as the backend's format_bytes, so card and job agree.
+export function fmtBytes(n) {
+  if (!n && n !== 0) return "";
+  if (n >= 1e9) return (n / 1e9).toFixed(1) + " GB";
+  if (n >= 1e6) return Math.round(n / 1e6) + " MB";
+  if (n >= 1e3) return Math.round(n / 1e3) + " KB";
+  return n + " B";
+}
+
+export function jobPct(j) {
+  if (j.progress == null) return null;
+  return Math.max(0, Math.min(100, Math.round(j.progress * 100)));
+}
+
+/// "downloading · 42% · 1.4 / 3.2 GB" — whatever of it the job actually knows.
+/// A settled job shows its result, not the phase it stopped in.
+export function jobStatusText(j) {
+  const parts = [];
+  if (j.state === "running") {
+    if (j.phase) parts.push(j.phase);
+    const pct = jobPct(j);
+    if (pct != null) parts.push(pct + "%");
+    if (j.total_bytes) parts.push(`${fmtBytes(j.done_bytes || 0)} / ${fmtBytes(j.total_bytes)}`);
+  } else if (j.state === "done" && j.size_bytes) {
+    parts.push(fmtBytes(j.size_bytes));
+  }
+  return parts.join(" · ");
+}
+
+export function jobBar(j) {
+  const pct = jobPct(j);
+  if (j.state === "done") return h("div", { class: "pbar" }, h("div", { class: "pbar-fill ok", style: "width:100%" }));
+  if (j.state !== "running") return h("div", { class: "pbar" }, h("div", { class: "pbar-fill err", style: "width:100%" }));
+  // known percentage → determinate fill; unknown (listing files) → animated slider
+  return h("div", { class: "pbar" },
+    pct != null
+      ? h("div", { class: "pbar-fill det", style: `width:${Math.max(pct, 1)}%` })
+      : h("div", { class: "pbar-fill run" })
+  );
+}
+
+/// HF gives `desc` as a bare pipeline tag ("text-generation") for live entries and
+/// a real sentence for curated ones. A one-word tag belongs in the badge row, not
+/// on a line of its own under every card.
+function descBadge(desc) {
+  return desc && !desc.includes(" ") ? h("span", { class: "badge" }, desc) : null;
+}
+function descLine(desc) {
+  return desc && desc.includes(" ") ? h("div", { class: "muted small", style: "margin:6px 0" }, desc) : null;
+}
+
+/// Disk/RAM sanity for a model of `bytes` size against the live system
+/// snapshot (ctx.sys): running a model needs it in RAM; downloading needs disk.
+function fitWarnings(bytes, sys) {
+  const out = [];
+  if (!bytes || !sys) return out;
+  if (sys.disk_free && bytes > sys.disk_free)
+    out.push(h("span", { class: "badge bad", title: t("fit.diskTitle") }, "⚠ " + t("fit.disk")));
+  else if (sys.ram_total && bytes > sys.ram_total * 0.75)
+    out.push(h("span", { class: "badge warn", title: t("fit.ramTitle") }, "⚠ " + t("fit.ram")));
+  return out;
+}
+
+/// One model. `ctx` = { hosts: Map(jobId → element), onDownload(m, v), onDelete(m, v), sys? }.
+/// Live progress lands in the per-variant host so a poll can repaint it in place,
+/// without re-rendering the grid under the user's cursor.
+export function featuredCard(m, ctx) {
+  const badge = m.badge || "CMF";
+  const label = m.label || m.id;
+  const desc = m.desc || "";
+  const variants = m.variants && m.variants.length ? m.variants : null;
+  const size = m.size || (m.size_bytes ? fmtBytes(m.size_bytes) : "");
+  const isDownloaded = !!m.downloaded;
+  const progressHost = (v) => {
+    const host = h("div", { class: "card-prog" });
+    const jid = (v && v.job) || m.job;
+    if (jid) ctx.hosts.set(jid, host);
+    return host;
+  };
+  // multi-variant (e.g. DeepSeek with parts-q2tp / parts-q4tp) → separate buttons per variant
+  if (variants && variants.length > 1) {
+    return h("div", { class: "hf-card featured-card" + (isDownloaded ? " sel" : "") },
+      h("div", { class: "hf-id" }, label, isDownloaded ? h("span", { class: "badge ok", style: "margin-left:6px" }, "✓") : null),
+      h("div", { class: "hf-meta" },
+        h("span", { class: "badge" }, badge),
+        descBadge(desc),
+        ...fitWarnings(m.size_bytes, ctx.sys),
+        isDownloaded ? h("span", { class: "badge ok" }, "✓ " + t("onboarding.downloaded")) : null),
+      descLine(desc),
+      h("div", { class: "muted small" }, m.id),
+      h("div", { style: "display:flex; flex-direction:column; gap:6px; margin-top:8px" },
+        ...variants.map((v) => {
+          const q = quantFromVariant(v.name) || badge;
+          const done = !!v.downloaded;
+          const upd = !!v.update_available;
+          const lab = done
+            ? (upd ? `↻ ${t("onboarding.update")} ${q} · ${v.size}` : `✓ ${q} · ${v.size}`)
+            : `⬇ ${q} · ${v.size}`;
+          const btn = h("button", {
+            class: "btn sm " + (done && !upd ? "ghost" : "primary"),
+            disabled: done && !upd ? true : null,
+            onClick: () => ctx.onDownload(m, v),
+            title: v.name + (done ? " — " + t("onboarding.downloaded") : ""),
+          }, lab);
+          const row = h("div", { style: "display:flex; gap:6px; align-items:center; flex-wrap:wrap" }, btn);
+          if (done) {
+            const del = h("button", { class: "btn sm ghost danger", title: t("onboarding.deleteFile") }, "🗑");
+            del.addEventListener("click", () => ctx.onDelete(m, v));
+            row.appendChild(del);
+          }
+          return h("div", {}, row, progressHost(v));
+        })
+      )
+    );
+  }
+  const v0 = variants && variants[0];
+  const done0 = !!(v0 && v0.downloaded) || isDownloaded;
+  const upd0 = !!(v0 && v0.update_available) || !!m.update_available;
+  const q0 = quantFromVariant((v0 && v0.name) || "") || badge;
+  const size0 = (v0 && v0.size) || size;
+  const btn0 = h("button", {
+    class: "btn sm " + (done0 && !upd0 ? "ghost" : "primary"),
+    disabled: done0 && !upd0 ? true : null,
+    onClick: () => ctx.onDownload(m, v0),
+    title: done0 && !upd0 ? t("onboarding.downloaded") : ""
+  }, done0
+    ? (upd0 ? `↻ ${t("onboarding.update")} ${q0} · ${size0}` : `✓ ${q0} · ${size0}`)
+    : `⬇ ${q0}${size0 ? " · " + size0 : ""}`);
+  const del0 = done0 ? h("button", { class: "btn sm ghost danger", title: t("onboarding.deleteFile") }, "🗑 " + t("import.delete")) : null;
+  if (del0) del0.addEventListener("click", () => ctx.onDelete(m, v0));
+  return h("div", { class: "hf-card featured-card" + (done0 ? " sel" : "") },
+    h("div", { class: "hf-id" }, label, done0 ? h("span", { class: "badge ok", style: "margin-left:6px" }, "✓") : null),
+    h("div", { class: "hf-meta" },
+      h("span", { class: "badge" }, badge),
+      size0 ? h("span", { class: "badge", style: "background:var(--bg); border-style:dashed" + (done0 ? "; opacity:.7" : "") }, (done0 ? "✓ " : "⬇ ") + size0) : null,
+      descBadge(desc),
+      ...(done0 ? [] : fitWarnings((v0 && v0.size_bytes) || m.size_bytes, ctx.sys))
+    ),
+    descLine(desc),
+    h("div", { class: "muted small" }, m.id),
+    h("div", { style: "display:flex; gap:6px; margin-top:8px; align-items:center; flex-wrap:wrap" }, btn0, del0),
+    progressHost(v0)
+  );
+}
+
+/// Repaint the per-variant progress hosts from the current job list.
+export function paintFeaturedHosts(hosts, jobs, onCancel) {
+  const byId = new Map(jobs.map((j) => [j.id, j]));
+  for (const [id, host] of hosts) {
+    const j = byId.get(id);
+    if (!j || j.state !== "running") { mount(host); continue; }
+    const cancel = h("button", { class: "btn sm ghost", style: "margin-left:auto", title: t("import.cancel") }, "✕");
+    cancel.addEventListener("click", async () => {
+      cancel.disabled = true;
+      try { await onCancel(j); } catch (e) { toast(e.message, "err"); cancel.disabled = false; }
+    });
+    mount(host,
+      jobBar(j),
+      h("div", { style: "display:flex; align-items:center; gap:8px" },
+        h("span", { class: "muted small" }, jobStatusText(j)),
+        cancel
+      )
+    );
+  }
+}
+
+/// Start the download for a featured variant. `local_name` is the stem the
+/// gateway itself derived, sent back verbatim so download / progress / delete
+/// can never disagree about which file this is.
+export async function startFeaturedDownload(m, v) {
+  const fallbackBase = m.id.split("/").pop().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  const name = (v && v.local_name) || m.local_name || fallbackBase;
+  const variant = v && v.name ? v.name : undefined;
+  await api.startImport({ repo: m.id, quant: "Q1", name, variant });
+  return variant;
+}

web/js/views/import.js

@@ -5,6 +5,13 @@
 import { h, mount, toast, opt } from "../ui.js";
 import { t } from "../i18n.js";
 import { api } from "../api.js";
+import {
+  loadFeatured,
+  featuredCard,
+  paintFeaturedHosts,
+  startFeaturedDownload,
+  jobStatusText,
+} from "./featured.js";
 
 const QUANTS = [
   ["Q8_2F", "import.q.q8_2f"],
@@ -20,12 +27,6 @@ const QUANTS = [
   ["F32", "import.q.f32"],
 ];
 
-const FEATURED_REPOS = [
-  { id: "infosave/Bonsai-1.7Bcmf", label: "Bonsai 1.7B CMF", badge: "1.7B · Q1", quant: "Q1" },
-  { id: "infosave/Bonsai-8B_2bit_cmf", label: "Bonsai 8B 2-bit CMF", badge: "8B · Q1T", quant: "Q1T" },
-  { id: "infosave/Bonsai-27Bcmf", label: "Bonsai 27B CMF", badge: "27B · Q1", quant: "Q1" },
-];
-
 
 function field(label, control, hint) {
   return h("label", { class: "field" }, h("span", {}, label), control,
@@ -53,6 +54,10 @@ export function renderImport() {
   let selected = null;
   let lastModels = []; // cache of the last search, so re-highlighting needs no refetch
   let jobsTimer = null;
+  let featured = []; // ready-made .cmf models from the infosave HF account
+  let featuredHosts = new Map(); // job id → live progress slot inside a featured card
+  let lastJobs = [];
+  let jobStates = new Map(); // job id → last seen state, to spot completions
 
   const searchIn = h("input", {
     class: "hf-search",
@@ -254,6 +259,12 @@ export function renderImport() {
   }
   // Load + render all jobs. Runs on mount (before `root` is attached — so no
   // isConnected guard here) and on each poll tick.
+  async function cancelJob(j) {
+    await api.cancelImport(j.id);
+    toast(t("import.cancelling"), "warn");
+    await refreshJobs();
+  }
+
   async function refreshJobs() {
     let jobs = [];
     try {
@@ -262,7 +273,14 @@ export function renderImport() {
       return;
     }
     jobs = jobs.filter((j) => j.state !== "cancelled"); // hide user-cancelled jobs
+    lastJobs = jobs;
     renderJobs(jobs);
+    // A settled download changes what the featured cards offer (✓ + delete), so
+    // re-read the list on that transition — not on every poll tick.
+    const settled = jobs.some((j) => jobStates.get(j.id) === "running" && j.state !== "running");
+    jobStates = new Map(jobs.map((j) => [j.id, j.state]));
+    if (settled) await renderFeatured();
+    else paintFeaturedHosts(featuredHosts, jobs, cancelJob);
     if (jobs.some((j) => j.state === "running")) ensurePolling();
     else stopPolling();
   }
@@ -289,7 +307,7 @@ export function renderImport() {
         (running && pct != null ? " · " + pct + "%" : "") +
         (j.size_bytes ? " · " + fmtBytes(j.size_bytes) : "")
     );
-    const phase = h("div", { class: "muted small" }, j.phase || "");
+    const phase = h("div", { class: "muted small" }, jobStatusText(j));
     const logEl = h("pre", { class: "conv-log" }, (j.log || []).slice(-10).join("\n"));
 
     const actions = [];
@@ -367,46 +385,61 @@ export function renderImport() {
     );
   }
 
-  function featuredCard(item) {
-    const card = h(
-      "div",
-      { class: "hf-card featured-card" },
-      h("div", { class: "row", style: "align-items:center; justify-content:space-between;" },
-        h("div", {},
-          h("div", { class: "hf-id" }, item.label),
-          h("div", { class: "hf-meta" },
-            h("span", { class: "badge" }, item.badge),
-            h("span", { class: "muted" }, item.id)
-          )
-        ),
-        h("button", { class: "btn primary sm" }, "⬇ " + t("import.directDownload"))
-      )
-    );
-    card.querySelector("button").addEventListener("click", async (e) => {
-      e.stopPropagation();
-      try {
-        await api.startImport({
-          repo: item.id,
-          quant: item.quant || "READY_CMF",
-          name: item.id.split("/").pop().toLowerCase(),
-        });
-        toast(t("import.started"), "ok");
-        refreshJobs();
-        jobsHost.scrollIntoView({ behavior: "smooth", block: "nearest" });
-      } catch (err) {
-        toast(err.message, "err");
-      }
-    });
-    return card;
-  }
-
+  // ── featured: the infosave account, read live so new releases just show up ──
+  const featuredGrid = h("div", { class: "hf-grid" }, h("div", { class: "muted pad" }, t("import.searching")));
+  const reloadBtn = h("button", { class: "btn ghost sm" }, "↻ " + t("common.refresh"));
   const featuredHost = h(
     "div",
     { class: "card featured-section" },
-    h("div", { class: "card-title" }, "⚡ " + t("import.featuredTitle")),
-    h("div", { class: "hf-grid" }, ...FEATURED_REPOS.map(featuredCard))
+    h("div", { class: "card-head", style: "display:flex; align-items:center; gap:10px" },
+      h("div", { class: "card-title", style: "margin:0" }, "⚡ " + t("import.featuredTitle")),
+      h("div", { style: "flex:1" }),
+      reloadBtn),
+    h("div", { class: "muted small", style: "margin:2px 0 10px" }, t("import.featuredSub")),
+    featuredGrid
   );
 
+  async function startFeatured(m, v) {
+    try {
+      const variant = await startFeaturedDownload(m, v);
+      toast(t("import.started") + (variant ? ` · ${variant}` : ""), "ok");
+      await refreshJobs();
+      jobsHost.scrollIntoView({ behavior: "smooth", block: "nearest" });
+    } catch (e) { toast(e.message, "err"); }
+  }
+
+  async function deleteFeatured(m, v) {
+    const name = (v && v.local_name) || m.local_name || m.id;
+    if (!window.confirm(t("onboarding.confirmDelete", { id: name }))) return;
+    try {
+      const r = await api.deleteSetupFile(m.id, v && v.name, (v && v.local_name) || m.local_name);
+      toast(t("import.deleted"), "ok");
+      if (r && r.unregistered && r.unregistered.length) {
+        toast(t("onboarding.unregistered", { ids: r.unregistered.join(", ") }), "ok");
+      }
+      await renderFeatured();
+      await refreshJobs();
+    } catch (e) { toast(e.message, "err"); }
+  }
+
+  async function renderFeatured(reload = true) {
+    if (reload) featured = await loadFeatured();
+    let sys = null;
+    try { sys = await api.system(); } catch { /* metrics optional */ }
+    featuredHosts = new Map();
+    const ctx = { hosts: featuredHosts, onDownload: startFeatured, onDelete: deleteFeatured, sys };
+    mount(featuredGrid, ...(featured.length
+      ? featured.map((m) => featuredCard(m, ctx))
+      : [h("div", { class: "muted pad" }, t("import.noResults"))]));
+    paintFeaturedHosts(featuredHosts, lastJobs, cancelJob);
+  }
+  reloadBtn.addEventListener("click", async () => {
+    reloadBtn.disabled = true;
+    mount(featuredGrid, h("div", { class: "muted pad" }, t("import.searching")));
+    await renderFeatured();
+    reloadBtn.disabled = false;
+  });
+
   const root = h(
     "div",
     {},
@@ -419,6 +452,7 @@ export function renderImport() {
     formHost
   );
   doSearch(); // initial trending list (mounts into `results`)
+  renderFeatured(); // ready-made .cmf models, fetched live
   refreshJobs(); // resume: show any running/recent conversions immediately
   return root;
 }

web/js/views/keys.js

@@ -1,30 +1,21 @@
 // API keys — list, create (with copy-once), revoke.
-import { h, mount, modal, toast, confirmDialog } from "../ui.js";
+import { h, mount, modal, toast, confirmDialog, moneyEl, num } from "../ui.js";
 import { t } from "../i18n.js";
 import { api } from "../api.js";
 
 export async function renderKeys() {
-  const modelsData = await api.listModels();
-  const ids = (modelsData.models || []).map((m) => m.id);
   const root = h("div");
+  let usageRange = "7d";
 
   function openCreate(reload) {
     const accountIn = h("input", { placeholder: "team-a" });
     const rateIn = h("input", { type: "number", value: 600 });
     const customIn = h("input", { placeholder: "sk-gw-…" });
-    const allowInputs = ids.map((id) => ({ id, cb: h("input", { type: "checkbox" }) }));
     const body = h(
       "div",
       {},
       h("label", { class: "field" }, h("span", {}, t("keys.form.account")), accountIn),
       h("label", { class: "field" }, h("span", {}, t("keys.form.rate")), rateIn),
-      h(
-        "label",
-        { class: "field" },
-        h("span", {}, t("keys.form.allow")),
-        h("div", { class: "flex wrap" }, ...allowInputs.map(({ id, cb }) => h("label", { class: "check" }, cb, id))),
-        h("div", { class: "hint" }, t("keys.form.allowHint"))
-      ),
       h("label", { class: "field" }, h("span", {}, t("keys.form.custom")), customIn, h("div", { class: "hint" }, t("keys.form.customHint")))
     );
     modal(t("keys.form.title"), body, async () => {
@@ -33,7 +24,7 @@ export async function renderKeys() {
           key: customIn.value.trim(),
           account: accountIn.value.trim() || "default",
           rate_per_min: parseInt(rateIn.value) || 0,
-          allow_models: allowInputs.filter(({ cb }) => cb.checked).map(({ id }) => id),
+          allow_models: [],
         });
         reload();
         showCreated(r.key);
@@ -48,11 +39,185 @@ export async function renderKeys() {
     const input = h("input", { value: key, readonly: true, class: "mono" });
     const copyBtn = h("button", { class: "btn", onClick: () => { input.select(); navigator.clipboard?.writeText(key); toast(t("common.copied"), "good"); } }, t("common.copy"));
     modal(t("common.ok"), h("div", {}, h("p", {}, t("keys.created")), h("div", { class: "flex" }, input, copyBtn)), null);
+    lastCreatedKey = key;
+    reload();
+  }
+
+  let lastCreatedKey = null;
+
+  // "Connect your app" — copy-paste snippets with this gateway's real URL.
+  // Keys are stored hashed-masked in the list, so the key itself is a
+  // placeholder unless one was just created on this page.
+  function snippetsCard(openMode) {
+    const origin = location.origin;
+    const base = origin + "/v1";
+    const key = lastCreatedKey || (openMode ? "sk-anything" : "<" + t("keys.snip.keyPh") + ">");
+    // Harness auto-setup scripts first (the gateway speaks OpenAI at /v1/* and
+    // Anthropic at /v1/messages, so Claude Code connects natively), SDKs after.
+    const snips = {
+      "Claude Code": `# ${t("keys.h.claude")}
+export ANTHROPIC_BASE_URL="${origin}"
+export ANTHROPIC_AUTH_TOKEN="${key}"
+export ANTHROPIC_MODEL="cortiq-auto"
+
+claude`,
+      Codex: `# ${t("keys.h.codex")}
+mkdir -p ~/.codex && cat >> ~/.codex/config.toml <<'EOF'
+model = "cortiq-auto"
+model_provider = "cortiq"
+
+[model_providers.cortiq]
+name = "Cortiq Gateway"
+base_url = "${base}"
+env_key = "CORTIQ_API_KEY"
+wire_api = "chat"
+EOF
+export CORTIQ_API_KEY="${key}"
+
+codex`,
+      OpenCode: `# ${t("keys.h.opencode")}
+mkdir -p ~/.config/opencode && cat > ~/.config/opencode/opencode.json <<'EOF'
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "cortiq": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Cortiq Gateway",
+      "options": { "baseURL": "${base}", "apiKey": "${key}" },
+      "models": { "cortiq-auto": { "name": "Cortiq Auto (smart routing)" } }
+    }
+  }
+}
+EOF
+
+opencode`,
+      Continue: `# ${t("keys.h.continue")}
+mkdir -p ~/.continue && cat >> ~/.continue/config.yaml <<'EOF'
+models:
+  - name: Cortiq Auto
+    provider: openai
+    model: cortiq-auto
+    apiBase: ${base}
+    apiKey: ${key}
+EOF`,
+      Cline: `${t("keys.h.cline1")}
+  API Provider:  OpenAI Compatible
+  Base URL:      ${base}
+  API Key:       ${key}
+  Model ID:      cortiq-auto
+
+${t("keys.h.cline2")}`,
+      curl: `curl ${base}/chat/completions \\
+  -H "Authorization: Bearer ${key}" \\
+  -H "Content-Type: application/json" \\
+  -d '{"model":"cortiq-auto","messages":[{"role":"user","content":"Привет!"}]}'`,
+      python: `from openai import OpenAI
+
+client = OpenAI(base_url="${base}", api_key="${key}")
+resp = client.chat.completions.create(
+    model="cortiq-auto",   # авто-роутинг; или точное имя модели
+    messages=[{"role": "user", "content": "Привет!"}],
+)
+print(resp.choices[0].message.content)`,
+      javascript: `import OpenAI from "openai";
+
+const client = new OpenAI({ baseURL: "${base}", apiKey: "${key}" });
+const resp = await client.chat.completions.create({
+  model: "cortiq-auto",
+  messages: [{ role: "user", content: "Привет!" }],
+});
+console.log(resp.choices[0].message.content);`,
+    };
+    let cur = "Claude Code";
+    const pre = h("pre", { class: "conv-log snippet" }, snips[cur]);
+    const seg = h(
+      "div",
+      { class: "seg" },
+      ...Object.keys(snips).map((k, i) =>
+        h("button", { class: (i === 0 ? "active" : "") + (["curl", "python", "javascript"].includes(k) ? " sdk" : ""), "data-snip": k, onClick: (e) => {
+          cur = k;
+          pre.textContent = snips[k];
+          protoWarn.style.display = k === "Claude Code" && protoWarn.childNodes.length ? "" : "none";
+          paintStatus();
+          seg.querySelectorAll("button").forEach((b) => b.classList.remove("active"));
+          e.currentTarget.classList.add("active");
+        } }, k)
+      )
+    );
+    // Claude Code needs the anthropic_messages protocol — offer a one-click
+    // enable when it is off, right where the user will hit the problem.
+    const protoWarn = h("div", { style: "display:none; margin-top:8px" });
+    api.getProtocols().then((prot) => {
+      if (prot.anthropic_messages) return;
+      const fixBtn = h("button", { class: "btn sm primary" }, t("keys.h.enableProto"));
+      fixBtn.addEventListener("click", async () => {
+        try {
+          await api.putProtocols({ ...prot, anthropic_messages: true });
+          protoWarn.style.display = "none";
+          toast(t("common.saved"), "ok");
+        } catch (e) {
+          toast(String(e.message || e), "err");
+        }
+      });
+      mount(protoWarn, h("div", { class: "callout warn" }, h("span", {}, "⚠ " + t("keys.h.protoOff")), " ", fixBtn));
+      if (cur === "Claude Code") protoWarn.style.display = "";
+    }).catch(() => {});
+
+    // Detected harnesses: ✓ on the tab when installed on the gateway machine,
+    // status line under the snippet ("installed" / "already configured").
+    let detected = {};
+    const statusHost = h("div", { class: "small", style: "margin-top:6px" });
+    function paintStatus() {
+      const d = detected[cur];
+      if (!d) {
+        statusHost.textContent = "";
+        return;
+      }
+      statusHost.innerHTML = "";
+      if (d.configured) mount(statusHost, h("span", { class: "ok" }, "✓ " + t("keys.h.st.configured")));
+      else if (d.installed) mount(statusHost, h("span", { class: "ok" }, "✓ " + t("keys.h.st.installed")));
+      else mount(statusHost, h("span", { class: "muted" }, "○ " + t("keys.h.st.notFound")));
+    }
+    api.harnesses().then((d) => {
+      detected = d || {};
+      seg.querySelectorAll("button").forEach((b) => {
+        const st = detected[b.dataset.snip];
+        if (st && st.installed) b.append(" ✓");
+      });
+      paintStatus();
+    }).catch(() => {});
+
+    const copy = h("button", { class: "btn ghost sm" }, "⧉ " + t("common.copy"));
+    copy.addEventListener("click", async () => {
+      await navigator.clipboard.writeText(pre.textContent);
+      toast(t("common.copied"), "ok");
+    });
+    return h(
+      "div",
+      { class: "card" },
+      h("div", { class: "card-title" }, "🔌 " + t("keys.snip.title")),
+      h("div", { class: "muted small", style: "margin-bottom:8px" },
+        lastCreatedKey ? t("keys.snip.withKey") : openMode ? t("keys.snip.openMode") : t("keys.snip.hint")),
+      h("div", { class: "flex", style: "gap:8px; margin-bottom:8px; flex-wrap:wrap" }, seg, h("div", { class: "grow" }), copy),
+      pre,
+      statusHost,
+      protoWarn,
+      h("div", { class: "muted small", style: "margin-top:6px" }, t("keys.h.note"))
+    );
   }
 
   async function reload() {
     const data = await api.listKeys();
     const keys = data.keys || [];
+    // per-account usage: window breakdown + cumulative-forever totals — the
+    // "who spends what" view for departments/developers sharing one gateway
+    let usage = {};
+    let alltime = {};
+    try {
+      const st = await api.stats(usageRange, "account");
+      for (const b of st.breakdown || []) usage[b.key] = b;
+      alltime = st.alltime_by_account || {};
+    } catch { /* stats disabled — columns show dashes */ }
     mount(
       root,
       h(
@@ -62,6 +227,9 @@ export async function renderKeys() {
           "div",
           { class: "flex" },
           h("div", { class: "grow" }, h("h2", {}, t("keys.title")), h("p", {}, t("keys.subtitle"))),
+          h("div", { class: "seg", style: "margin-right:10px" },
+            ...["24h", "7d", "30d"].map((r) =>
+              h("button", { class: r === usageRange ? "active" : "", onClick: () => { usageRange = r; reload(); } }, r))),
           h("button", { class: "btn primary", onClick: () => openCreate(reload) }, "+ " + t("keys.add"))
         )
       ),
@@ -80,7 +248,16 @@ export async function renderKeys() {
                 h(
                   "thead",
                   {},
-                  h("tr", {}, h("th", {}, t("keys.col.key")), h("th", {}, t("keys.col.account")), h("th", {}, t("keys.col.rate")), h("th", {}, t("keys.col.models")), h("th", { class: "right-align" }, t("common.actions")))
+                  h("tr", {},
+                    h("th", {}, t("keys.col.key")),
+                    h("th", {}, t("keys.col.account")),
+                    h("th", {}, t("keys.col.rate")),
+                    h("th", {}, t("keys.col.models")),
+                    h("th", { class: "right-align" }, t("keys.col.requests") + " (" + usageRange + ")"),
+                    h("th", { class: "right-align" }, t("keys.col.tokens") + " (" + usageRange + ")"),
+                    h("th", { class: "right-align" }, "$ (" + usageRange + ")"),
+                    h("th", { class: "right-align" }, t("keys.col.costAll")),
+                    h("th", { class: "right-align" }, t("common.actions")))
                 ),
                 h(
                   "tbody",
@@ -93,6 +270,10 @@ export async function renderKeys() {
                       h("td", {}, k.account),
                       h("td", { class: "mono" }, k.rate_per_min || "—"),
                       h("td", {}, (k.allow_models && k.allow_models.length) ? k.allow_models.join(", ") : h("span", { class: "muted" }, t("keys.allowAll"))),
+                      h("td", { class: "right-align mono" }, String((usage[k.account] || {}).requests ?? "—")),
+                      h("td", { class: "right-align mono small" }, usage[k.account] ? num(usage[k.account].prompt_tokens) + " / " + num(usage[k.account].completion_tokens) : "—"),
+                      h("td", { class: "right-align" }, usage[k.account] ? moneyEl(usage[k.account].cost_usd) : "—"),
+                      h("td", { class: "right-align" }, alltime[k.account] ? moneyEl(alltime[k.account].cost_usd) : "—"),
                       h(
                         "td",
                         { class: "right-align" },
@@ -119,7 +300,8 @@ export async function renderKeys() {
                 )
               )
             )
-          )
+          ),
+      snippetsCard(!!data.open_mode)
     );
   }
 

web/js/views/logs.js

@@ -0,0 +1,95 @@
+// Gateway log viewer — the in-memory ring served by /admin/api/logs, for
+// everyone who never sees the terminal (Docker, autostart, double-clicked exe).
+import { h, mount, toast } from "../ui.js";
+import { t } from "../i18n.js";
+import { api } from "../api.js";
+
+export function renderLogs() {
+  const root = h("div");
+  let timer = null;
+  let paused = false;
+  let filter = "";
+  let level = "";
+
+  const pre = h("pre", { class: "conv-log logs-view" }, t("common.loading"));
+  const filterIn = h("input", { placeholder: t("logs.filterPlaceholder"), style: "max-width:260px" });
+  const levelSel = h(
+    "select",
+    { style: "max-width:130px" },
+    h("option", { value: "" }, t("common.all")),
+    ...["ERROR", "WARN", "INFO", "DEBUG"].map((l) => h("option", { value: l }, l))
+  );
+  const pauseBtn = h("button", { class: "btn ghost sm" }, "⏸ " + t("logs.pause"));
+  const copyBtn = h("button", { class: "btn ghost sm" }, "⧉ " + t("common.copy"));
+  const clearBtn = h("button", { class: "btn ghost sm danger" }, "🗑 " + t("dash.clear"));
+  clearBtn.addEventListener("click", async () => {
+    try {
+      await api.clearLogs();
+      lines = [];
+      paint();
+      toast(t("dash.cleared"), "ok");
+    } catch (e) {
+      toast(String(e.message || e), "err");
+    }
+  });
+
+  let lines = [];
+  function paint() {
+    let shown = lines;
+    if (level) shown = shown.filter((l) => l.includes(` ${level} `) || l.includes(`${level} `));
+    if (filter) shown = shown.filter((l) => l.toLowerCase().includes(filter));
+    pre.textContent = shown.length ? shown.join("\n") : t("logs.empty");
+    if (!paused) pre.scrollTop = pre.scrollHeight;
+  }
+  async function refresh() {
+    if (paused) return;
+    try {
+      lines = (await api.logs(500)).lines || [];
+      paint();
+    } catch {
+      /* transient */
+    }
+  }
+  filterIn.addEventListener("input", () => {
+    filter = filterIn.value.trim().toLowerCase();
+    paint();
+  });
+  levelSel.addEventListener("change", () => {
+    level = levelSel.value;
+    paint();
+  });
+  pauseBtn.addEventListener("click", () => {
+    paused = !paused;
+    pauseBtn.textContent = (paused ? "▶ " : "⏸ ") + t(paused ? "logs.resume" : "logs.pause");
+    if (!paused) refresh();
+  });
+  copyBtn.addEventListener("click", async () => {
+    try {
+      await navigator.clipboard.writeText(pre.textContent);
+      toast(t("common.copied"), "ok");
+    } catch (e) {
+      toast(String(e.message || e), "err");
+    }
+  });
+
+  timer = setInterval(() => {
+    if (!root.isConnected) {
+      clearInterval(timer);
+      return;
+    }
+    refresh();
+  }, 2000);
+  refresh();
+
+  mount(
+    root,
+    h("div", { class: "view-head" }, h("h2", {}, t("nav.logs")), h("div", { class: "muted" }, t("logs.subtitle"))),
+    h(
+      "div",
+      { class: "card" },
+      h("div", { class: "flex", style: "gap:8px; flex-wrap:wrap; margin-bottom:10px" }, filterIn, levelSel, pauseBtn, copyBtn, clearBtn),
+      pre
+    )
+  );
+  return root;
+}

web/js/views/models.js

@@ -315,10 +315,63 @@ export async function renderModels() {
                 )
               )
             )
-          )
+          ),
+      benchCard()
     );
   }
 
+  // ── one-click benchmark of local .cmf files (cortiq bench --json) ──
+  function benchCard() {
+    const host = h("div", { class: "card" }, h("div", { class: "card-title" }, "⏱ " + t("bench.title")),
+      h("div", { class: "muted small", style: "margin-bottom:8px" }, t("bench.hint")),
+      h("div", { class: "empty" }, t("common.loading")));
+    let timer = null;
+    async function paint() {
+      let files = [];
+      let runs = {};
+      try {
+        files = (await api.mediaModels()).models || [];
+        for (const r of (await api.benchList()).runs || []) runs[r.model] = r;
+      } catch {
+        return;
+      }
+      const chat = files.filter((m) => m.modality === "chat");
+      const anyRunning = Object.values(runs).some((r) => r.state === "running");
+      const rows = chat.map((m) => {
+        const r = runs[m.name];
+        const go = h("button", { class: "btn sm ghost", disabled: anyRunning ? true : null }, "⏱ " + t("bench.run"));
+        go.addEventListener("click", async () => {
+          try {
+            await api.benchStart(m.name);
+            paint();
+            if (!timer) timer = setInterval(() => {
+              if (!host.isConnected) { clearInterval(timer); return; }
+              paint();
+            }, 3000);
+          } catch (e) {
+            toast(String(e.message || e), "bad");
+          }
+        });
+        let result = h("span", { class: "muted" }, "—");
+        if (r?.state === "running") result = h("span", { class: "flex" }, h("span", { class: "spinner" }), " ", t("bench.running"));
+        else if (r?.state === "done") result = h("b", { class: "mono" }, (r.tok_s != null ? r.tok_s.toFixed(1) : "?") + " tok/s");
+        else if (r?.state === "error") result = h("span", { class: "err", title: (r.log || []).slice(-2).join(" · ") }, t("bench.failed"));
+        return h("div", { class: "flex bench-row" },
+          h("span", { class: "mono grow" }, m.name),
+          h("span", { class: "muted small" }, (m.size_bytes / 1e9).toFixed(2) + " GB"),
+          result,
+          go);
+      });
+      mount(host,
+        h("div", { class: "card-title" }, "⏱ " + t("bench.title")),
+        h("div", { class: "muted small", style: "margin-bottom:8px" }, t("bench.hint")),
+        ...(rows.length ? rows : [h("div", { class: "empty" }, t("bench.none"))]));
+      if (!anyRunning && timer) { clearInterval(timer); timer = null; }
+    }
+    paint();
+    return host;
+  }
+
   await reload();
   return root;
 }

web/js/views/onboarding.js

@@ -0,0 +1,335 @@
+// First-run onboarding wizard: language → featured .cmf models (infosave) → HF search+convert → done.
+// No manual TOML edits: every action goes through the admin API.
+import { h, mount, toast } from "../ui.js";
+import { t, getLang, setLang, LANGS } from "../i18n.js";
+import { api } from "../api.js";
+import {
+  loadFeatured as fetchFeatured,
+  featuredCard,
+  paintFeaturedHosts,
+  startFeaturedDownload,
+  jobBar,
+  jobStatusText,
+  fmtBytes,
+} from "./featured.js";
+
+let step = 0; // 0 lang, 1 featured, 2 hf convert, 3 done
+let featured = [];
+let featuredLoaded = false;
+
+function langStep(onNext) {
+  const cards = LANGS.map((l) =>
+    h("button", {
+      class: "onb-lang" + (getLang() === l.code ? " sel" : ""),
+      onClick: () => {
+        setLang(l.code);
+        cards.forEach((c) => c.classList.toggle("sel", c.dataset.code === l.code));
+        toast(l.flag + " " + l.label, "ok");
+      },
+      "data-code": l.code,
+      title: l.label,
+      "aria-label": l.label,
+    }, h("span", { class: "flag" }, l.flag), h("b", {}, l.label))
+  );
+  return h("div", { class: "onb-step" },
+    h("h2", {}, t("onboarding.welcome")),
+    h("p", { class: "muted" }, t("onboarding.welcomeSub")),
+    h("div", { class: "onb-langs" }, ...cards),
+    h("div", { class: "actions" },
+      h("button", { class: "btn primary", onClick: onNext }, t("onboarding.next") + " →")
+    )
+  );
+}
+
+export function renderOnboarding() {
+  const root = h("div", { class: "onb-wrap" });
+  let jobsPoll = null;
+  let jobs = [];
+  let sysSnapshot = null; // disk/RAM для плашек "не влезет" на карточках
+  let jobStates = new Map(); // job id → last seen state, to spot completions
+  let hosts = new Map(); // job id → card progress host (rebuilt on every render)
+  let jobsHost = h("div", {});
+
+  // Job rows: bar, live status, and the actions that finish or undo a download.
+  function jobsMini(list) {
+    if (!list.length) return h("div", { class: "muted small" }, t("onboarding.noJobs"));
+    return h("div", {},
+      ...list.map((j) => {
+        const act = [];
+        if (j.state === "done") {
+          const btn = h("button", { class: "btn primary sm" }, "✓ " + t("import.register"));
+          btn.addEventListener("click", async () => {
+            btn.disabled = true;
+            try {
+              const r = await api.registerImport(j.id);
+              toast(t("import.registered", { id: r.model_id }), "ok");
+            } catch (e) { toast(e.message, "err"); btn.disabled = false; }
+          });
+          act.push(btn);
+        }
+        if (j.state === "running") {
+          const cancel = h("button", { class: "btn ghost sm" }, "✕ " + t("import.cancel"));
+          cancel.addEventListener("click", async () => {
+            cancel.disabled = true;
+            try { await api.cancelImport(j.id); toast(t("import.cancelling"), "ok"); await refreshJobs(); }
+            catch (e) { toast(e.message, "err"); cancel.disabled = false; }
+          });
+          act.push(cancel);
+        } else {
+          // done / error / cancelled — remove the .cmf from disk and redo the step
+          const del = h("button", { class: "btn ghost sm danger", title: t("onboarding.deleteFile") }, "🗑 " + t("import.delete"));
+          del.addEventListener("click", () => deleteJob(j));
+          act.push(del);
+        }
+        const known = ["running", "done", "error", "cancelled"].includes(j.state);
+        return h("div", { class: "job", style: "margin:8px 0" },
+          h("div", { class: "job-head" },
+            h("b", {}, j.name || j.repo || j.id),
+            h("span", { class: "badge" + (j.state === "done" ? " ok" : j.state === "running" ? "" : " bad") }, known ? t("import.state." + j.state) : j.state)
+          ),
+          jobBar(j),
+          h("div", { class: "muted small" }, jobStatusText(j)),
+          h("pre", { class: "conv-log", style: "max-height:80px" }, (j.log || []).slice(-6).join("\n")),
+          act.length ? h("div", { class: "actions" }, ...act) : null
+        );
+      })
+    );
+  }
+
+  // Repaint only the live bits (card hosts + job list) — cheap enough for 1.5s.
+  function paintJobs() {
+    mount(jobsHost, jobs.length
+      ? h("div", { class: "card" }, h("div", { class: "card-title" }, t("import.jobs")), jobsMini(jobs))
+      : h("div", {}));
+    paintFeaturedHosts(hosts, jobs, async (j) => {
+      await api.cancelImport(j.id);
+      toast(t("import.cancelling"), "ok");
+      await refreshJobs();
+    });
+  }
+
+  async function refreshJobs() {
+    try { jobs = (await api.listImports()).jobs || []; } catch { jobs = []; }
+    // A job that just settled changes what the cards offer (✓ + delete), so the
+    // featured list has to be re-read — but only on the transition, not per poll.
+    const settled = jobs.some((j) => {
+      const prev = jobStates.get(j.id);
+      return prev === "running" && j.state !== "running";
+    });
+    jobStates = new Map(jobs.map((j) => [j.id, j.state]));
+    if (settled) {
+      await loadFeatured();
+      render(); // rebuilds the cards (✓ + delete) and repaints the job rows
+    } else {
+      paintJobs();
+    }
+    if (jobs.some((j) => j.state === "running")) {
+      if (!jobsPoll) jobsPoll = setInterval(refreshJobs, 1500);
+    } else {
+      if (jobsPoll) { clearInterval(jobsPoll); jobsPoll = null; }
+    }
+  }
+
+  async function loadFeatured() {
+    featured = await fetchFeatured();
+    try { sysSnapshot = await api.system(); } catch { /* optional */ }
+    featuredLoaded = true;
+  }
+
+  function topNav(prev, next, extra) {
+    return h("div", { class: "actions", style: "margin-bottom:12px; position:sticky; top:0; background:var(--bg); z-index:2; padding:8px 0; border-bottom:1px solid var(--border-soft); backdrop-filter:blur(4px)" },
+      h("button", { class: "btn ghost", onClick: prev }, "← " + t("onboarding.back")),
+      extra ? extra : h("div", { style: "flex:1" }),
+      h("button", { class: "btn primary", onClick: next }, t("onboarding.next") + " →")
+    );
+  }
+
+  async function startDownload(m, v) {
+    try {
+      const variant = await startFeaturedDownload(m, v);
+      toast(t("import.started") + (variant ? ` · ${variant}` : ""), "ok");
+      await refreshJobs();
+    } catch (e) { toast(e.message, "err"); }
+  }
+
+  async function handleDelete(m, v) {
+    const name = (v && v.local_name) || m.local_name || m.id;
+    if (!confirm(t("onboarding.confirmDelete", { id: name }))) return;
+    try {
+      const r = await api.deleteSetupFile(m.id, v && v.name, (v && v.local_name) || m.local_name);
+      toast(t("import.deleted"), "ok");
+      if (r && r.unregistered && r.unregistered.length) {
+        toast(t("onboarding.unregistered", { ids: r.unregistered.join(", ") }), "ok");
+      }
+      await loadFeatured();
+      render();
+      await refreshJobs();
+    } catch (e) { toast(e.message, "err"); }
+  }
+
+  // Delete straight from a job row: the gateway knows that job's output path.
+  async function deleteJob(j) {
+    if (!confirm(t("onboarding.confirmDelete", { id: j.name || j.repo }))) return;
+    try {
+      await api.deleteImport(j.id);
+      toast(t("import.deleted"), "ok");
+      await loadFeatured();
+      render();
+      await refreshJobs();
+    } catch (e) { toast(e.message, "err"); }
+  }
+
+  function render() {
+    const dots = [0, 1, 2, 3].map((i) => h("span", { class: "dot" + (i === step ? " on" : i < step ? " done" : "") }));
+    const header = h("div", { class: "onb-header" },
+      h("div", { class: "onb-dots" }, ...dots),
+      h("div", { class: "onb-title" }, t("onboarding.title") + ` — ${step + 1}/4`)
+    );
+
+    let body;
+    const next = () => { step = Math.min(3, step + 1); render(); };
+    const prev = () => { step = Math.max(0, step - 1); render(); };
+    hosts = new Map(); // rebuilt by featuredCard below
+
+    if (step === 0) {
+      const top = h("div", { class: "actions", style: "margin-bottom:12px; justify-content:flex-end" },
+        h("button", { class: "btn primary", onClick: next }, t("onboarding.next") + " →")
+      );
+      body = h("div", {},
+        top,
+        langStep(next)
+      );
+    } else if (step === 1) {
+      const top = topNav(prev, next, h("button", { class: "btn ghost", onClick: () => { step = 3; render(); } }, t("onboarding.skip")));
+      const ctx = { hosts, onDownload: startDownload, onDelete: handleDelete, sys: sysSnapshot };
+      // the list is fetched from HuggingFace — say so instead of showing a blank grid
+      const grid = featured.length
+        ? h("div", { class: "hf-grid" }, ...featured.map((m) => featuredCard(m, ctx)))
+        : h("div", { class: "muted pad" }, featuredLoaded ? t("import.noResults") : t("import.searching"));
+      body = h("div", { class: "onb-step" },
+        top,
+        h("h2", {}, "📦 " + t("onboarding.featuredTitle")),
+        h("p", { class: "muted" }, t("onboarding.featuredSub")),
+        grid,
+        jobsHost,
+        h("div", { class: "actions" },
+          h("button", { class: "btn ghost", onClick: prev }, "← " + t("onboarding.back")),
+          h("button", { class: "btn", onClick: async () => { await loadFeatured(); render(); await refreshJobs(); } }, t("common.refresh")),
+          h("button", { class: "btn primary", onClick: next }, t("onboarding.next") + " →"),
+          h("button", { class: "btn ghost", onClick: () => { step = 3; render(); } }, t("onboarding.skip"))
+        )
+      );
+    } else if (step === 2) {
+      const top2 = topNav(prev, next);
+      // lightweight HF search inline
+      const inp = h("input", { placeholder: t("import.searchPlaceholder"), style: "width:100%" });
+      const res = h("div", { class: "hf-grid" });
+      const quantSel = h("select", {},
+        h("option", { value: "Q8_2F" }, "Q8_2F — " + t("import.q.q8_2f")),
+        h("option", { value: "Q4_BLOCK" }, "Q4 — " + t("import.q.q4")),
+        h("option", { value: "Q1T" }, "Q1T — " + t("import.q.q1t")),
+        h("option", { value: "Q1" }, "Q1 — " + t("import.q.q1")),
+      );
+      let selected = null;
+      let debounce = null;
+      async function doSearch() {
+        const q = inp.value.trim();
+        mount(res, h("div", { class: "muted pad" }, t("import.searching")));
+        try {
+          const r = await api.hfSearch(q, 16);
+          const models = r.models || [];
+          if (!models.length) { mount(res, h("div", { class: "muted pad" }, t("import.noResults"))); return; }
+          mount(res, ...models.map((m) => {
+            const card = h("div", { class: "hf-card" + (selected && selected.id === m.id ? " sel" : "") },
+              h("div", { class: "hf-id" }, m.id),
+              h("div", { class: "hf-meta" }, h("span", { class: "badge" }, m.pipeline_tag || "model"), h("span", { class: "muted" }, "♥ " + (m.likes ?? 0)))
+            );
+            card.addEventListener("click", () => { selected = m; doSearch(); });
+            return card;
+          }));
+        } catch (e) { mount(res, h("div", { class: "err" }, String(e.message))); }
+      }
+      inp.addEventListener("input", () => { clearTimeout(debounce); debounce = setTimeout(doSearch, 300); });
+      const go = h("button", { class: "btn primary" }, "⬇ " + t("import.convert"));
+      go.addEventListener("click", async () => {
+        if (!selected) { toast(t("import.noResults"), "warn"); return; }
+        go.disabled = true;
+        try {
+          await api.startImport({ repo: selected.id, quant: quantSel.value, name: selected.id.split("/").pop().toLowerCase() });
+          toast(t("import.started"), "ok");
+          await refreshJobs();
+        } catch (e) { toast(e.message, "err"); }
+        go.disabled = false;
+      });
+      // auto initial search
+      setTimeout(doSearch, 100);
+      body = h("div", { class: "onb-step" },
+        top2,
+        h("h2", {}, "🔍 " + t("onboarding.hfTitle")),
+        h("p", { class: "muted" }, t("onboarding.hfSub")),
+        h("div", { class: "card" }, inp, res),
+        h("div", { class: "card", style: "margin-top:12px" },
+          h("div", { class: "row" }, h("label", { class: "field" }, h("span", {}, t("import.quant")), quantSel)),
+          h("div", { class: "actions" }, go)
+        ),
+        jobsHost,
+        h("div", { class: "actions" },
+          h("button", { class: "btn ghost", onClick: prev }, "← " + t("onboarding.back")),
+          h("button", { class: "btn primary", onClick: next }, t("onboarding.next") + " →")
+        )
+      );
+    } else {
+      // done — finishing connects every completed download as a local model
+      const ready = jobs.filter((j) => j.state === "done");
+      const doneBtn = h("button", { class: "btn primary" }, t("onboarding.finish"));
+      doneBtn.addEventListener("click", async () => {
+        doneBtn.disabled = true;
+        let r = null;
+        try { r = await api.setupComplete(getLang(), true); } catch (e) { toast(e.message, "err"); }
+        if (r && r.registered && r.registered.length) {
+          toast(t("onboarding.registeredN", { n: r.registered.length, ids: r.registered.join(", ") }), "ok");
+          if (!r.runtime_installed) toast(t("onboarding.runtimeMissing"), "warn");
+          // let the toast be readable before the reload swaps the page
+          await new Promise((res) => setTimeout(res, 900));
+        }
+        // land where the reward is: try the model right away
+        location.hash = "#/playground";
+        location.reload();
+      });
+      const skipBtn = h("button", { class: "btn ghost", onClick: async () => {
+        try { await api.setupComplete(getLang(), false); } catch {}
+        location.hash = "#/dashboard";
+      } }, t("onboarding.skipSetup"));
+      body = h("div", { class: "onb-step" },
+        h("h2", {}, "✅ " + t("onboarding.doneTitle")),
+        h("p", { class: "muted" }, t("onboarding.doneSub")),
+        ready.length
+          ? h("div", { class: "card" },
+              h("div", { class: "card-title" }, t("onboarding.willRegister")),
+              ...ready.map((j) => h("div", { class: "muted small" }, "• cmf-" + (j.name || j.repo) + (j.size_bytes ? ` · ${fmtBytes(j.size_bytes)}` : "")))
+            )
+          : h("div", { class: "muted small" }, t("onboarding.nothingToRegister")),
+        jobsHost,
+        h("div", { class: "callout" }, t("onboarding.doneHint")),
+        h("div", { class: "actions" },
+          h("button", { class: "btn ghost", onClick: prev }, "← " + t("onboarding.back")),
+          skipBtn,
+          doneBtn
+        )
+      );
+    }
+
+    mount(root, h("div", { class: "onb" }, header, body));
+    paintJobs(); // fill the freshly built hosts with whatever we already know
+    if (jobs.some((j) => j.state === "running") && !jobsPoll) {
+      jobsPoll = setInterval(refreshJobs, 1500);
+    }
+  }
+
+  loadFeatured().then(() => { render(); refreshJobs(); });
+  render();
+  // cleanup poll on detach
+  const obs = new MutationObserver(() => { if (!root.isConnected && jobsPoll) { clearInterval(jobsPoll); jobsPoll = null; obs.disconnect(); } });
+  obs.observe(document.body, { childList: true, subtree: true });
+  return root;
+}

web/js/views/playground.js

@@ -1,17 +1,64 @@
-// Playground — send a prompt through the live pipeline, inspect routing decision.
-import { h, mount, money, ms } from "../ui.js";
-import { t } from "../i18n.js";
-import { api, testStream } from "../api.js";
+// Playground — three tabs over the live gateway:
+//   chat  → the routing pipeline (with streaming, token counts, tok/s, TTFT)
+//   image → `cortiq imagine` over a local text-to-image .cmf (Lumina)
+//   video → `cortiq animate` over a local text-to-video .cmf (MiniMax-H3)
+// Media results are decoded in the browser (PPM → canvas, MJPEG AVI → canvas
+// player synced to the wav) — the same no-ffmpeg stance as the engine itself.
+import { h, mount, toast, money, moneyEl, ms } from "../ui.js";
+import { t, trTier } from "../i18n.js";
+import { api, testStream, mediaFileUrl, mediaFileBytes } from "../api.js";
 import { appState } from "../app.js";
+import { ppmToCanvas, fileToPpmB64, aviJpegFrames, mjpegPlayer } from "../media-utils.js";
+
+function fmtBytes(n) {
+  if (!n && n !== 0) return "—";
+  if (n >= 1e9) return (n / 1e9).toFixed(2) + " GB";
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + " MB";
+  if (n >= 1e3) return Math.round(n / 1e3) + " KB";
+  return n + " B";
+}
+function kv(k, v) {
+  return h("div", { class: "kv" }, h("span", { class: "k" }, k), h("span", { class: "v" }, v));
+}
+function field(label, control, hint) {
+  return h("label", { class: "field" }, h("span", {}, label), control, hint ? h("div", { class: "hint" }, hint) : null);
+}
 
 export async function renderPlayground() {
   const meta = appState.meta || (await api.meta());
   const modelsData = await api.listModels();
   const ids = (modelsData.models || []).map((m) => m.id);
+  let mediaModels = [];
+  try {
+    mediaModels = (await api.mediaModels()).models || [];
+  } catch {
+    /* media API unavailable — tabs will show the hint */
+  }
+  const imageModels = mediaModels.filter((m) => m.modality === "image");
+  const videoModels = mediaModels.filter((m) => m.modality === "video");
 
-  let mode = "auto";
   const root = h("div");
+  let tab = "chat";
 
+  // ── tabs ──
+  const tabsSeg = h(
+    "div",
+    { class: "seg" },
+    h("button", { class: "active", "data-tab": "chat" }, "💬 " + t("pg.tab.chat")),
+    h("button", { "data-tab": "image" }, "🖼 " + t("pg.tab.image")),
+    h("button", { "data-tab": "video" }, "🎬 " + t("pg.tab.video"))
+  );
+  const panelHost = h("div", {});
+  tabsSeg.querySelectorAll("button").forEach((b) =>
+    b.addEventListener("click", () => {
+      tab = b.dataset.tab;
+      tabsSeg.querySelectorAll("button").forEach((x) => x.classList.toggle("active", x === b));
+      mount(panelHost, panels[tab]);
+    })
+  );
+
+  // ════════════════════════════ chat panel ════════════════════════════
+  let mode = "auto";
   const sysIn = h("textarea", { placeholder: t("pg.systemPlaceholder"), rows: 2 });
   const promptIn = h("textarea", { placeholder: t("pg.promptPlaceholder"), rows: 5 });
   const tempIn = h("input", { type: "number", step: "0.1", value: 0.7 });
@@ -44,16 +91,33 @@ export async function renderPlayground() {
     modeExtra = next;
   }
 
-  const out = h("div", { class: "answer" }, h("div", { class: "empty" }, t("pg.empty")));
+  const chatLog = []; // the running conversation: {role, content}
+  const out = h("div", { class: "answer chat-log" }, h("div", { class: "empty" }, t("pg.empty")));
   const decision = h("div", { class: "card routecard" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.decision"))), h("div", { class: "empty" }, "—"));
 
+  function bubble(role, text) {
+    return h("div", { class: "chat-msg " + role }, h("div", { class: "chat-bubble" }, text));
+  }
+  function renderChat(liveText) {
+    const items = chatLog.map((m) => bubble(m.role, m.content));
+    if (liveText != null) items.push(bubble("assistant", liveText || "…"));
+    mount(out, ...(items.length ? items : [h("div", { class: "empty" }, t("pg.empty"))]));
+    out.scrollTop = out.scrollHeight;
+  }
+  const clearBtn = h("button", { class: "btn ghost sm" }, "🧹 " + t("pg.clearChat"));
+  clearBtn.addEventListener("click", () => {
+    chatLog.length = 0;
+    renderChat();
+    mount(decision, h("div", { class: "card-head" }, h("h3", {}, t("pg.decision"))), h("div", { class: "empty" }, "—"));
+  });
+
   const sendBtn = h("button", { class: "btn primary" }, t("pg.send"));
   sendBtn.addEventListener("click", async () => {
     const prompt = promptIn.value.trim();
     if (!prompt) return;
     const messages = [];
     if (sysIn.value.trim()) messages.push({ role: "system", content: sysIn.value.trim() });
-    messages.push({ role: "user", content: prompt });
+    messages.push(...chatLog, { role: "user", content: prompt });
     let model = "cortiq-auto";
     if (mode === "auto") {
       if (profileSel.value) model = "cortiq-auto:" + profileSel.value;
@@ -62,7 +126,9 @@ export async function renderPlayground() {
     }
     sendBtn.disabled = true;
     sendBtn.textContent = t("pg.sending");
-    mount(out, h("div", { class: "flex" }, h("span", { class: "spinner" }), " ", t("pg.sending")));
+    chatLog.push({ role: "user", content: prompt });
+    promptIn.value = "";
+    renderChat("");
     const body = {
       model,
       messages,
@@ -73,12 +139,13 @@ export async function renderPlayground() {
       if (streamCb.checked) {
         const started = performance.now();
         let acc = "";
-        out.textContent = "";
         const info = await testStream(body, (d) => {
           acc += d;
-          out.textContent = acc;
+          renderChat(acc);
         });
-        out.textContent = acc || "—";
+        chatLog.push({ role: "assistant", content: acc || "—" });
+        renderChat();
+        const latency = Math.round(performance.now() - started);
         renderDecision({
           cortiq: {
             task_label: info.task_label,
@@ -88,37 +155,58 @@ export async function renderPlayground() {
             cost_usd: info.cost_usd,
             failover: false,
           },
-          usage: {},
-          latency_ms: Math.round(performance.now() - started),
+          usage: info.usage || {},
+          usage_estimated: info.usage_estimated,
+          latency_ms: latency,
+          ttft_ms: info.ttft_ms,
         });
       } else {
         const r = await api.test(body);
         if (r.ok) {
-          mount(out, r.answer || h("span", { class: "muted" }, "—"));
+          chatLog.push({ role: "assistant", content: r.answer || "—" });
+          renderChat();
           renderDecision(r);
         } else {
-          mount(out, h("div", { class: "callout" }, h("b", {}, t("pg.error") + ": "), r.error || ""));
+          chatLog.pop(); // the user turn failed — let them retry it
+          renderChat();
+          promptIn.value = prompt;
+          mount(out, out.firstChild || "", h("div", { class: "callout" }, h("b", {}, t("pg.error") + ": "), r.error || ""));
           mount(decision, h("div", { class: "card-head" }, h("h3", {}, t("pg.decision"))), h("div", { class: "empty" }, "—"));
         }
       }
     } catch (e) {
-      mount(out, h("div", { class: "callout" }, String(e.message || e)));
+      chatLog.pop();
+      renderChat();
+      promptIn.value = prompt;
+      toast(String(e.message || e), "err");
     }
     sendBtn.disabled = false;
     sendBtn.textContent = t("pg.send");
   });
+  // Cmd/Ctrl+Enter sends
+  promptIn.addEventListener("keydown", (e) => {
+    if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+      e.preventDefault();
+      sendBtn.click();
+    }
+  });
 
-  function kv(k, v) {
-    return h("div", { class: "kv" }, h("span", { class: "k" }, k), h("span", { class: "v" }, v));
-  }
   function renderDecision(r) {
     const c = r.cortiq || {};
     const score = c.complexity?.score ?? 0;
+    const u = r.usage || {};
+    const haveUsage = u.completion_tokens != null;
+    // generation speed over the produce phase (after first token when known)
+    let tokS = null;
+    if (haveUsage && r.latency_ms) {
+      const genMs = r.ttft_ms != null ? Math.max(1, r.latency_ms - r.ttft_ms) : r.latency_ms;
+      tokS = (u.completion_tokens / (genMs / 1000)).toFixed(1);
+    }
     mount(
       decision,
       h("div", { class: "card-head" }, h("h3", {}, t("pg.decision"))),
       kv(t("pg.task"), c.task_label || "—"),
-      kv(t("pg.tier"), c.complexity?.tier ? h("span", { class: "badge tier-" + c.complexity.tier }, c.complexity.tier) : "—"),
+      kv(t("pg.tier"), c.complexity?.tier ? h("span", { class: "badge tier-" + c.complexity.tier }, trTier(c.complexity.tier)) : "—"),
       h(
         "div",
         { class: "kv", style: "display:block" },
@@ -127,17 +215,278 @@ export async function renderPlayground() {
       ),
       kv(t("pg.selected"), h("span", { class: "mono" }, c.selected_model || "—")),
       kv(t("pg.source"), c.route_source || "—"),
-      kv(t("pg.tokens"), `${r.usage?.prompt_tokens ?? 0}/${r.usage?.completion_tokens ?? 0}`),
-      kv(t("pg.cost"), money(c.cost_usd)),
+      kv(t("pg.tokens"), haveUsage ? `${r.usage_estimated ? "≈ " : ""}${u.prompt_tokens ?? 0} / ${u.completion_tokens ?? 0}` : "—"),
+      kv(t("pg.tokSpeed"), tokS != null ? tokS + " tok/s" : "—"),
+      kv(t("pg.ttft"), r.ttft_ms != null ? ms(r.ttft_ms) : "—"),
+      kv(t("pg.cost"), moneyEl(c.cost_usd)),
       kv(t("pg.latency"), ms(r.latency_ms)),
       kv(t("pg.failover"), c.failover ? "yes" : "no")
     );
   }
 
-  mount(
-    root,
-    h("div", { class: "page-head" }, h("h2", {}, t("pg.title")), h("p", {}, t("pg.subtitle"))),
+  const chatPanel = h(
+    "div",
+    { class: "pg" },
     h(
+      "div",
+      {},
+      h(
+        "div",
+        { class: "card" },
+        field(t("pg.system"), sysIn),
+        field(t("pg.prompt"), promptIn),
+        field(t("pg.mode"), modeSeg),
+        modeExtra,
+        h("div", { class: "row" }, field(t("pg.temp"), tempIn), field(t("pg.maxTokens"), maxTokIn)),
+        h(
+          "div",
+          { class: "flex", style: "justify-content:space-between; gap:8px" },
+          h("label", { class: "check", style: "margin:0" }, streamCb, t("pg.stream")),
+          h("div", { class: "flex", style: "gap:8px" }, clearBtn, sendBtn)
+        )
+      ),
+      h("div", { class: "card" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.answer"))), out)
+    ),
+    decision
+  );
+
+  // ═══════════════════════ shared media machinery ═══════════════════════
+  let mediaPoll = null;
+  function stopMediaPoll() {
+    if (mediaPoll) clearInterval(mediaPoll);
+    mediaPoll = null;
+  }
+  // one generation at a time server-side → one active job client-side
+  function watchJob(id, ui, onDone) {
+    stopMediaPoll();
+    const started = performance.now();
+    mediaPoll = setInterval(async () => {
+      if (!root.isConnected) return stopMediaPoll();
+      let j;
+      try {
+        j = await api.mediaJob(id);
+      } catch {
+        return;
+      }
+      const elapsed = (performance.now() - started) / 1000;
+      const pct = j.progress != null ? Math.round(j.progress * 100) : null;
+      // honest ETA once there is enough signal: total ≈ elapsed / progress
+      let eta = "";
+      if (j.state === "running" && j.progress > 0.03) {
+        const left = elapsed / j.progress - elapsed;
+        if (left > 1) eta = ` · ${t("pg.eta")} ~${left > 90 ? Math.round(left / 60) + " " + t("pg.min") : Math.round(left) + " s"}`;
+      }
+      let statusLine;
+      if (j.state === "queued") {
+        const pos = (j.queue_position ?? 0) + 1;
+        statusLine = t("pg.queued", { n: pos });
+      } else {
+        statusLine =
+          (j.phase || j.state) +
+          (pct != null && j.state === "running" ? ` · ${pct}%` : "") +
+          ` · ${elapsed.toFixed(0)}s` + eta;
+      }
+      mount(
+        ui.bar,
+        h("div", { class: "pbar" },
+          j.state === "running"
+            ? (pct != null
+                ? h("div", { class: "pbar-fill det", style: `width:${Math.max(pct, 1)}%` })
+                : h("div", { class: "pbar-fill run" }))
+            : j.state === "queued"
+              ? h("div", { class: "pbar-fill run" })
+              : h("div", { class: "pbar-fill " + (j.state === "done" ? "ok" : "err"), style: "width:100%" })
+        ),
+        h("div", { class: "muted small" }, statusLine),
+        (j.log || []).length && j.state === "running" ? h("pre", { class: "conv-log", style: "max-height:90px" }, j.log.slice(-5).join("\n")) : null
+      );
+      if (j.state !== "running" && j.state !== "queued") {
+        stopMediaPoll();
+        ui.goBtn.disabled = false;
+        ui.cancelBtn.style.display = "none";
+        if (j.state === "done") onDone(j);
+        else if (j.state === "error") toast(t("pg.genFailed"), "err");
+      }
+    }, 1000);
+  }
+  function mediaControls(goBtn, onCancelId) {
+    const cancelBtn = h("button", { class: "btn ghost", style: "display:none" }, "✕ " + t("import.cancel"));
+    cancelBtn.addEventListener("click", async () => {
+      try {
+        await api.mediaCancel(onCancelId.id);
+      } catch (e) {
+        toast(e.message, "err");
+      }
+    });
+    return cancelBtn;
+  }
+  function noModelsHint(kindLabel) {
+    return h(
+      "div",
+      { class: "card" },
+      h("div", { class: "callout" },
+        t("pg.noMediaModels", { kind: kindLabel }),
+        " ",
+        h("a", { href: "#/import" }, t("settings.cmf.importLink") + " ↗"))
+    );
+  }
+  function dice(seedIn) {
+    const b = h("button", { class: "btn ghost sm", title: t("pg.randomSeed") }, "🎲");
+    b.addEventListener("click", () => (seedIn.value = Math.floor(Math.random() * 1e9)));
+    return b;
+  }
+
+  // ── gallery: past generations of one kind, loaded lazily ──
+  function buildGallery(kind, onOpen) {
+    const host = h("div", {});
+    async function refresh() {
+      let jobs = [];
+      try {
+        jobs = ((await api.mediaJobs()).jobs || []).filter((j) => j.kind === kind && j.state === "done");
+      } catch {
+        return;
+      }
+      if (!jobs.length) {
+        mount(host);
+        return;
+      }
+      const grid = h("div", { class: "gal-grid" });
+      for (const j of jobs.slice(0, 12)) {
+        const del = h("button", { class: "gal-del", title: t("import.delete") }, "×");
+        del.addEventListener("click", async (e) => {
+          e.stopPropagation();
+          if (!window.confirm(t("pg.galDeleteConfirm"))) return;
+          try {
+            await api.mediaDelete(j.id);
+            refresh();
+          } catch (err) {
+            toast(err.message, "err");
+          }
+        });
+        const cap = h("div", { class: "gal-cap" }, `${j.width}×${j.height} · seed ${j.seed}`);
+        const item = h("div", { class: "gal-item", title: j.prompt }, del, cap);
+        if (kind === "image") {
+          // lazy thumbnail: decode the PPM only when the item scrolls into view
+          const thumb = h("canvas", { class: "gal-thumb" });
+          item.prepend(thumb);
+          const io = new IntersectionObserver(async (entries) => {
+            if (!entries.some((x) => x.isIntersecting)) return;
+            io.disconnect();
+            try {
+              const buf = await mediaFileBytes(j.id, "image");
+              const full = ppmToCanvas(buf);
+              thumb.width = 128;
+              thumb.height = Math.round((128 * full.height) / full.width) || 128;
+              thumb.getContext("2d").drawImage(full, 0, 0, thumb.width, thumb.height);
+            } catch {
+              /* file gone */
+            }
+          });
+          io.observe(item);
+        } else {
+          item.prepend(h("div", { class: "gal-thumb gal-video" }, "🎬"));
+        }
+        item.addEventListener("click", () => onOpen(j));
+        grid.appendChild(item);
+      }
+      mount(host, h("div", { class: "card-title", style: "margin-top:14px" }, t("pg.gallery")), grid);
+    }
+    refresh();
+    return { host, refresh };
+  }
+
+  // ════════════════════════════ image panel ════════════════════════════
+  let imagePanel;
+  if (!imageModels.length) {
+    imagePanel = noModelsHint(t("pg.tab.image"));
+  } else {
+    const imModel = h("select", {}, ...imageModels.map((m) => h("option", { value: m.name }, `${m.name} · ${fmtBytes(m.size_bytes)}`)));
+    const imPrompt = h("textarea", { placeholder: t("pg.imagePromptPlaceholder"), rows: 3 });
+    const imW = h("select", {}, ...[256, 384, 512, 640, 768, 1024].map((v) => h("option", { value: v, selected: v === 512 ? true : null }, v)));
+    const imH = h("select", {}, ...[256, 384, 512, 640, 768, 1024].map((v) => h("option", { value: v, selected: v === 512 ? true : null }, v)));
+    const imSteps = h("input", { type: "number", min: 1, max: 100, value: 30 });
+    const imCfg = h("input", { type: "number", step: "0.5", value: 4 });
+    const imSeed = h("input", { type: "number", value: 42 });
+    const imBar = h("div", {});
+    const imOut = h("div", { class: "media-out" }, h("div", { class: "empty" }, t("pg.imageEmpty")));
+    const imMetrics = h("div", { class: "card routecard" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.genMetrics"))), h("div", { class: "empty" }, "—"));
+    const imGo = h("button", { class: "btn primary" }, "🖼 " + t("pg.generate"));
+    const imCancelRef = { id: null };
+    const imCancel = mediaControls(imGo, imCancelRef);
+
+    imGo.addEventListener("click", async () => {
+      const prompt = imPrompt.value.trim();
+      if (!prompt) return;
+      imGo.disabled = true;
+      imCancel.style.display = "";
+      mount(imOut, h("div", { class: "flex" }, h("span", { class: "spinner" }), " ", t("pg.generating")));
+      const params = {
+        kind: "image",
+        model: imModel.value,
+        prompt,
+        width: +imW.value,
+        height: +imH.value,
+        steps: +imSteps.value || 30,
+        cfg: parseFloat(imCfg.value) || 4,
+        seed: +imSeed.value || 42,
+      };
+      try {
+        const r = await api.mediaGenerate(params);
+        imCancelRef.id = r.job;
+        const t0 = performance.now();
+        watchJob(r.job, { bar: imBar, goBtn: imGo, cancelBtn: imCancel }, async (j) => {
+          mount(imBar);
+          const secs = (performance.now() - t0) / 1000;
+          await showImageResult(j, secs);
+          imGallery.refresh();
+        });
+      } catch (e) {
+        imGo.disabled = false;
+        imCancel.style.display = "none";
+        mount(imOut, h("div", { class: "callout" }, String(e.message || e)));
+      }
+    });
+
+    async function showImageResult(j, secs) {
+      try {
+        const buf = await mediaFileBytes(j.id, "image");
+        const canvas = ppmToCanvas(buf);
+        canvas.className = "media-canvas";
+        const dl = h("button", { class: "btn sm" }, "⬇ PNG");
+        dl.addEventListener("click", () =>
+          canvas.toBlob((b) => {
+            const a = h("a", { href: URL.createObjectURL(b), download: `cortiq-${j.id}.png` });
+            a.click();
+          }, "image/png")
+        );
+        mount(imOut, canvas, h("div", { class: "actions" }, dl));
+        const rows = [
+          kv(t("pg.model"), h("span", { class: "mono" }, j.model)),
+          kv(t("pg.resolution"), `${j.width}×${j.height}`),
+          kv(t("pg.steps"), String(j.steps)),
+          kv(t("pg.seed"), String(j.seed)),
+          kv(t("pg.fileSize"), fmtBytes(j.out_bytes)),
+        ];
+        if (secs != null) {
+          rows.push(kv(t("pg.genTime"), secs.toFixed(1) + " s"));
+          rows.push(kv(t("pg.timePerStep"), (secs / j.steps).toFixed(2) + " s"));
+        } else if (j.finished && j.started) {
+          const dur = j.finished - j.started;
+          rows.push(kv(t("pg.genTime"), dur + " s"));
+          rows.push(kv(t("pg.timePerStep"), (dur / j.steps).toFixed(2) + " s"));
+        }
+        mount(imMetrics, h("div", { class: "card-head" }, h("h3", {}, t("pg.genMetrics"))), ...rows);
+      } catch (e) {
+        mount(imOut, h("div", { class: "callout" }, String(e.message || e)));
+      }
+    }
+    const imGallery = buildGallery("image", (j) => {
+      imSeed.value = j.seed;
+      imSteps.value = j.steps;
+      showImageResult(j, null);
+    });
+
+    imagePanel = h(
       "div",
       { class: "pg" },
       h(
@@ -146,22 +495,178 @@ export async function renderPlayground() {
         h(
           "div",
           { class: "card" },
-          h("label", { class: "field" }, h("span", {}, t("pg.system")), sysIn),
-          h("label", { class: "field" }, h("span", {}, t("pg.prompt")), promptIn),
-          h("label", { class: "field" }, h("span", {}, t("pg.mode")), modeSeg),
-          modeExtra,
-          h("div", { class: "row" }, h("label", { class: "field" }, h("span", {}, t("pg.temp")), tempIn), h("label", { class: "field" }, h("span", {}, t("pg.maxTokens")), maxTokIn)),
-          h(
-            "div",
-            { class: "flex", style: "justify-content:space-between" },
-            h("label", { class: "check", style: "margin:0" }, streamCb, t("pg.stream")),
-            sendBtn
-          )
+          field(t("pg.model"), imModel),
+          field(t("pg.prompt"), imPrompt),
+          h("div", { class: "row" }, field(t("pg.width"), imW), field(t("pg.height"), imH)),
+          h("div", { class: "row" },
+            field(t("pg.steps"), imSteps),
+            field("CFG", imCfg, t("pg.cfgHint"))),
+          h("div", { class: "row" },
+            field(t("pg.seed"), h("div", { class: "flex", style: "gap:6px" }, imSeed, dice(imSeed)))),
+          h("div", { class: "actions" }, imCancel, imGo),
+          imBar
         ),
-        h("div", { class: "card" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.answer"))), out)
+        h("div", { class: "card" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.result"))), imOut, imGallery.host)
       ),
-      decision
-    )
+      imMetrics
+    );
+  }
+
+  // ════════════════════════════ video panel ════════════════════════════
+  let videoPanel;
+  if (!videoModels.length) {
+    videoPanel = noModelsHint(t("pg.tab.video"));
+  } else {
+    const vModel = h("select", {}, ...videoModels.map((m) => h("option", { value: m.name }, `${m.name} · ${fmtBytes(m.size_bytes)}`)));
+    const vPrompt = h("textarea", { placeholder: t("pg.videoPromptPlaceholder"), rows: 3 });
+    const vW = h("input", { type: "number", step: 32, value: 512 });
+    const vH = h("input", { type: "number", step: 32, value: 288 });
+    const vFrames = h("input", { type: "number", value: 39 });
+    const vSteps = h("input", { type: "number", value: 4 });
+    const vSeed = h("input", { type: "number", value: 42 });
+    const vQuality = h("input", { type: "number", min: 10, max: 100, value: 92 });
+    const vFirst = h("input", { type: "file", accept: "image/*" });
+    const vLast = h("input", { type: "file", accept: "image/*" });
+    const vBar = h("div", {});
+    const vOut = h("div", { class: "media-out" }, h("div", { class: "empty" }, t("pg.videoEmpty")));
+    const vMetrics = h("div", { class: "card routecard" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.genMetrics"))), h("div", { class: "empty" }, "—"));
+    const vGo = h("button", { class: "btn primary" }, "🎬 " + t("pg.generate"));
+    const vCancelRef = { id: null };
+    const vCancel = mediaControls(vGo, vCancelRef);
+
+    vGo.addEventListener("click", async () => {
+      const prompt = vPrompt.value.trim();
+      if (!prompt) return;
+      vGo.disabled = true;
+      vCancel.style.display = "";
+      mount(vOut, h("div", { class: "flex" }, h("span", { class: "spinner" }), " ", t("pg.generating")));
+      const params = {
+        kind: "video",
+        model: vModel.value,
+        prompt,
+        width: +vW.value || 512,
+        height: +vH.value || 288,
+        frames: +vFrames.value || 39,
+        steps: +vSteps.value || 4,
+        seed: +vSeed.value || 42,
+        quality: +vQuality.value || 92,
+      };
+      try {
+        if (vFirst.files[0]) params.first_frame_b64 = await fileToPpmB64(vFirst.files[0], params.width, params.height);
+        if (vLast.files[0]) params.last_frame_b64 = await fileToPpmB64(vLast.files[0], params.width, params.height);
+        const r = await api.mediaGenerate(params);
+        vCancelRef.id = r.job;
+        const t0 = performance.now();
+        watchJob(r.job, { bar: vBar, goBtn: vGo, cancelBtn: vCancel }, async (j) => {
+          mount(vBar);
+          vGallery.refresh();
+          const secs = (performance.now() - t0) / 1000;
+          try {
+            await showVideoResult(j, vOut);
+            const durS = (j.frames || 0) / 24;
+            mount(
+              vMetrics,
+              h("div", { class: "card-head" }, h("h3", {}, t("pg.genMetrics"))),
+              kv(t("pg.model"), h("span", { class: "mono" }, j.model)),
+              kv(t("pg.resolution"), `${j.width}×${j.height}`),
+              kv(t("pg.frames"), `${j.frames} @ 24 fps`),
+              kv(t("pg.duration"), durS.toFixed(1) + " s"),
+              kv(t("pg.steps"), String(j.steps)),
+              kv(t("pg.seed"), String(j.seed)),
+              kv(t("pg.genTime"), secs.toFixed(1) + " s"),
+              kv(t("pg.timePerFrame"), j.frames ? (secs / j.frames).toFixed(2) + " s" : "—"),
+              kv(t("pg.fileSize"), fmtBytes(j.out_bytes))
+            );
+          } catch (e) {
+            mount(vOut, h("div", { class: "callout" }, String(e.message || e)));
+          }
+        });
+      } catch (e) {
+        vGo.disabled = false;
+        vCancel.style.display = "none";
+        mount(vOut, h("div", { class: "callout" }, String(e.message || e)));
+      }
+    });
+
+    async function showVideoResult(j, host) {
+      const downloads = h("div", { class: "actions" });
+      for (const kind of j.outputs || []) {
+        const label = { video: "⬇ AVI", audio: "⬇ WAV", mp4: "⬇ MP4" }[kind];
+        if (!label) continue;
+        const b = h("button", { class: "btn sm" }, label);
+        b.addEventListener("click", async () => {
+          const { url } = await mediaFileUrl(j.id, kind);
+          const ext = kind === "video" ? "avi" : kind === "audio" ? "wav" : "mp4";
+          h("a", { href: url, download: `cortiq-${j.id}.${ext}` }).click();
+        });
+        downloads.appendChild(b);
+      }
+      if ((j.outputs || []).includes("mp4")) {
+        // ffmpeg was present server-side → native playback
+        const { url } = await mediaFileUrl(j.id, "mp4");
+        mount(host, h("video", { src: url, controls: true, class: "media-canvas" }), downloads);
+        return;
+      }
+      // no ffmpeg anywhere: decode the MJPEG AVI ourselves, sync to the wav
+      const buf = await mediaFileBytes(j.id, "video");
+      const frames = aviJpegFrames(buf);
+      let audio = null;
+      if ((j.outputs || []).includes("audio")) {
+        const { url } = await mediaFileUrl(j.id, "audio");
+        audio = h("audio", { src: url });
+      }
+      const player = mjpegPlayer(frames, 24, audio);
+      player.canvas.className = "media-canvas";
+      await player.seek0();
+      const playBtn = h("button", { class: "btn primary sm" }, "▶ " + t("pg.play"));
+      playBtn.addEventListener("click", async () => {
+        if (player.state.playing) {
+          player.pause();
+          playBtn.textContent = "▶ " + t("pg.play");
+        } else {
+          playBtn.textContent = "⏸";
+          await player.play();
+        }
+      });
+      mount(host, player.canvas, h("div", { class: "actions" }, playBtn, ...downloads.childNodes ? [downloads] : []));
+    }
+
+    const vGallery = buildGallery("video", (j) => showVideoResult(j, vOut));
+
+    videoPanel = h(
+      "div",
+      { class: "pg" },
+      h(
+        "div",
+        {},
+        h(
+          "div",
+          { class: "card" },
+          field(t("pg.model"), vModel),
+          field(t("pg.prompt"), vPrompt),
+          h("div", { class: "row" }, field(t("pg.width"), vW, t("pg.videoSizeHint")), field(t("pg.height"), vH)),
+          h("div", { class: "row" }, field(t("pg.frames"), vFrames, t("pg.framesHint")), field(t("pg.steps"), vSteps, t("pg.videoStepsHint"))),
+          h("div", { class: "row" },
+            field(t("pg.seed"), h("div", { class: "flex", style: "gap:6px" }, vSeed, dice(vSeed))),
+            field(t("pg.quality"), vQuality)),
+          h("div", { class: "row" }, field(t("pg.firstFrame"), vFirst, t("pg.keyframeHint")), field(t("pg.lastFrame"), vLast)),
+          h("div", { class: "actions" }, vCancel, vGo),
+          vBar
+        ),
+        h("div", { class: "card" }, h("div", { class: "card-head" }, h("h3", {}, t("pg.result"))), vOut, vGallery.host)
+      ),
+      vMetrics
+    );
+  }
+
+  const panels = { chat: chatPanel, image: imagePanel, video: videoPanel };
+
+  mount(
+    root,
+    h("div", { class: "page-head" }, h("h2", {}, t("pg.title")), h("p", {}, t("pg.subtitle"))),
+    tabsSeg,
+    panelHost
   );
+  mount(panelHost, panels.chat);
   return root;
 }

web/js/views/routing.js

@@ -1,74 +1,293 @@
 // Routing — tier editor (ordered model chips), default model, and policy.
 import { h, mount, toast } from "../ui.js";
-import { t } from "../i18n.js";
+import { t, trTier } from "../i18n.js";
 import { api } from "../api.js";
 import { appState } from "../app.js";
 
+// Known labels of the hosted taxonomy — used for localized names/descriptions
+// and as the offline fallback; the live list comes from /routing/labels.
+const TASK_META = {
+  chitchat: { icon: "💬" },
+  code: { icon: "⌨" },
+  "creative-writing": { icon: "✍" },
+  extraction: { icon: "📑" },
+  math: { icon: "∑" },
+  qa: { icon: "❓" },
+  summarization: { icon: "📋" },
+  translation: { icon: "🌍" },
+};
+
 export async function renderRouting() {
   const meta = appState.meta || (await api.meta());
   const [routing, modelsData] = await Promise.all([api.getRouting(), api.listModels()]);
   const ids = (modelsData.models || []).map((m) => m.id);
 
+  // Task labels: live from the router when reachable, built-in set otherwise;
+  // labels that already have a rule are always shown (custom taxonomies).
+  let taskLabels = Object.keys(TASK_META);
+  let labelsSource = "builtin";
+  try {
+    const r = await api.routingLabels();
+    if (r.labels && r.labels.length) {
+      taskLabels = r.labels;
+      labelsSource = "router";
+    }
+  } catch {
+    /* offline — builtin list */
+  }
+  for (const k of Object.keys(routing.tasks || {})) {
+    if (!taskLabels.includes(k)) taskLabels.push(k);
+  }
+
+  // Share of recent traffic per task — shows which rules actually matter.
+  let taskShare = {};
+  try {
+    const stat = await api.stats("7d", "label");
+    const total = (stat.breakdown || []).reduce((a, b) => a + (b.requests || 0), 0);
+    if (total > 0) {
+      for (const b of stat.breakdown || []) taskShare[b.key] = (b.requests || 0) / total;
+    }
+  } catch {
+    /* no stats yet */
+  }
+
   // local editable state — ensure standard tiers exist for a friendly editor
   const tiers = Object.assign({ low: [], medium: [], high: [] }, routing.tiers || {});
+  const tasks = {};
+  // A task rule is edited as ordered PAIRS (model, tier): "this model serves
+  // this task at this complexity" (tier "any" = at every complexity).
+  // GET returns {any:[], low:[], medium:[], high:[]}; legacy arrays = any.
+  const taskPairs = {};
+  for (const l of taskLabels) {
+    const v = (routing.tasks || {})[l];
+    const pairs = [];
+    if (Array.isArray(v)) for (const m of v) pairs.push({ model: m, tier: "any" });
+    else if (v && typeof v === "object") {
+      for (const tier of ["low", "medium", "high", "any"])
+        for (const m of v[tier] || []) pairs.push({ model: m, tier });
+    }
+    taskPairs[l] = pairs;
+  }
   const st = {
     tiers,
+    taskPairs,
+    bands: routing.bands || null, // null = пороги роутера как есть
     default: routing.default || ids[0] || "",
     policy: routing.policy || { mode: "fixed_table", min_class: {} },
   };
 
   const root = h("div");
 
-  function moveChip(tier, i, dir) {
-    const arr = st.tiers[tier];
+  function moveChip(map, key, i, dir) {
+    const arr = map[key];
     const ni = i + dir;
     if (ni < 0 || ni >= arr.length) return;
     [arr[i], arr[ni]] = [arr[ni], arr[i]];
     render();
   }
-  function removeChip(tier, i) {
-    st.tiers[tier].splice(i, 1);
+  function removeChip(map, key, i) {
+    map[key].splice(i, 1);
     render();
   }
-  function addChip(tier, id) {
-    if (id && !st.tiers[tier].includes(id)) st.tiers[tier].push(id);
+  function addChip(map, key, id) {
+    if (id && !map[key].includes(id)) map[key].push(id);
     render();
   }
-
-  function tierRow(tier) {
-    const arr = st.tiers[tier];
+  function chipEditor(map, key, emptyLabel) {
+    const arr = map[key];
     const avail = ids.filter((id) => !arr.includes(id));
     const addSel = h(
       "select",
-      {
-        style: "width:auto",
-        onChange: (e) => {
-          addChip(tier, e.target.value);
-        },
-      },
+      { style: "width:auto", onChange: (e) => addChip(map, key, e.target.value) },
       h("option", { value: "" }, t("routing.addModel")),
       ...avail.map((id) => h("option", { value: id }, id))
     );
+    return h(
+      "div",
+      { class: "chips" },
+      arr.length === 0 && emptyLabel ? h("span", { class: "muted small chips-empty" }, emptyLabel) : null,
+      ...arr.map((id, i) =>
+        h(
+          "div",
+          { class: "chip" },
+          h("span", { class: "ord" }, i + 1),
+          id,
+          h("span", { class: "arrow", title: "←", onClick: () => moveChip(map, key, i, -1) }, "◄"),
+          h("span", { class: "arrow", title: "→", onClick: () => moveChip(map, key, i, 1) }, "►"),
+          h("span", { class: "x", onClick: () => removeChip(map, key, i) }, "×")
+        )
+      ),
+      avail.length ? addSel : null
+    );
+  }
+
+  // Linked boundary sliders: one track, two handles (low|medium boundaries),
+  // three colored zones. Handles push each other, numbers update live —
+  // nobody types score ranges by hand.
+  function bandsCard() {
+    const DEF = { low: 0.33, medium: 0.48 };
+    const enabled = !!st.bands;
+    const b = st.bands || { ...DEF };
+    const MIN_GAP = 0.02;
+
+    const track = h("div", { class: "bands-track" });
+    const zoneLow = h("div", { class: "bands-zone z-low" });
+    const zoneMed = h("div", { class: "bands-zone z-med" });
+    const zoneHigh = h("div", { class: "bands-zone z-high" });
+    const hLow = h("div", { class: "bands-handle", tabindex: "0" }, h("span", { class: "bands-val" }));
+    const hMed = h("div", { class: "bands-handle", tabindex: "0" }, h("span", { class: "bands-val" }));
+    const legend = h("div", { class: "bands-legend" });
+    track.append(zoneLow, zoneMed, zoneHigh, hLow, hMed);
+
+    function paint() {
+      const lo = b.low, me = b.medium;
+      zoneLow.style.width = lo * 100 + "%";
+      zoneMed.style.left = lo * 100 + "%";
+      zoneMed.style.width = (me - lo) * 100 + "%";
+      zoneHigh.style.left = me * 100 + "%";
+      zoneHigh.style.width = (1 - me) * 100 + "%";
+      hLow.style.left = lo * 100 + "%";
+      hMed.style.left = me * 100 + "%";
+      hLow.querySelector(".bands-val").textContent = lo.toFixed(2);
+      hMed.querySelector(".bands-val").textContent = me.toFixed(2);
+      // подписи не наезжают, когда ручки рядом
+      hMed.querySelector(".bands-val").classList.toggle("raised", me - lo < 0.09);
+      mount(legend,
+        h("span", { class: "badge tier-low" }, `${trTier("low")} ≤ ${lo.toFixed(2)}`),
+        h("span", { class: "badge tier-medium" }, `${trTier("medium")} ≤ ${me.toFixed(2)}`),
+        h("span", { class: "badge tier-high" }, `${trTier("high")} > ${me.toFixed(2)}`));
+      track.classList.toggle("disabled", !st.bands);
+    }
+
+    function drag(handle, which) {
+      handle.addEventListener("pointerdown", (e) => {
+        if (!st.bands) return;
+        handle.setPointerCapture(e.pointerId);
+        const rect = track.getBoundingClientRect();
+        const move = (ev) => {
+          let v = (ev.clientX - rect.left) / rect.width;
+          v = Math.min(0.98, Math.max(0.02, Math.round(v * 100) / 100));
+          if (which === "low") {
+            b.low = v;
+            // связанность: low толкает medium перед собой
+            if (b.medium < b.low + MIN_GAP) b.medium = Math.min(0.99, b.low + MIN_GAP);
+          } else {
+            b.medium = v;
+            // и medium толкает low назад
+            if (b.low > b.medium - MIN_GAP) b.low = Math.max(0.01, b.medium - MIN_GAP);
+          }
+          st.bands = { low: b.low, medium: b.medium };
+          paint();
+        };
+        const up = () => {
+          handle.removeEventListener("pointermove", move);
+          handle.removeEventListener("pointerup", up);
+        };
+        handle.addEventListener("pointermove", move);
+        handle.addEventListener("pointerup", up);
+      });
+    }
+    drag(hLow, "low");
+    drag(hMed, "medium");
+
+    const toggle = h("input", { type: "checkbox", checked: enabled ? "" : null });
+    toggle.checked = enabled;
+    toggle.addEventListener("change", () => {
+      st.bands = toggle.checked ? { low: b.low, medium: b.medium } : null;
+      paint();
+    });
+    paint();
+    return h(
+      "div",
+      { class: "bands-wrap" },
+      h("label", { class: "check", style: "margin-bottom:8px" }, toggle, t("routing.bands.enable")),
+      h("div", { class: "muted small", style: "margin-bottom:10px" }, t("routing.bands.hint")),
+      track,
+      legend
+    );
+  }
+
+  function tierRow(tier) {
     return h(
       "div",
       { class: "tierrow" },
-      h("div", { class: "tname" }, h("span", { class: "badge tier-" + tier }, tier)),
+      h("div", { class: "tname" }, h("span", { class: "badge tier-" + tier }, trTier(tier))),
+      chipEditor(st.tiers, tier)
+    );
+  }
+
+  function taskRow(label) {
+    const known = TASK_META[label];
+    const name = known ? t("task." + label) : label;
+    const share = taskShare[label];
+    return h(
+      "div",
+      { class: "tierrow taskrow" },
       h(
         "div",
-        { class: "chips" },
-        ...arr.map((id, i) =>
-          h(
-            "div",
-            { class: "chip" },
-            h("span", { class: "ord" }, i + 1),
-            id,
-            h("span", { class: "arrow", title: "←", onClick: () => moveChip(tier, i, -1) }, "◄"),
-            h("span", { class: "arrow", title: "→", onClick: () => moveChip(tier, i, 1) }, "►"),
-            h("span", { class: "x", onClick: () => removeChip(tier, i) }, "×")
-          )
-        ),
-        avail.length ? addSel : null
-      )
+        { class: "tname taskname" },
+        h("div", {}, (known ? known.icon + " " : "") + name),
+        h("div", { class: "muted small mono" }, label),
+        share != null ? h("div", { class: "muted small" }, t("routing.tasks.share", { p: Math.round(share * 100) })) : null
+      ),
+      pairsEditor(label)
+    );
+  }
+
+  // Pairs editor: each row is [model ▾][complexity ▾][×]; "any" serves every
+  // tier. Order matters — it is the fallback order inside the tier.
+  function pairsEditor(label) {
+    const pairs = st.taskPairs[label];
+    const wrap = h("div", { class: "pairs grow" });
+    function paint() {
+      mount(
+        wrap,
+        ...pairs.map((p, i) => {
+          const modelSel = h(
+            "select",
+            { class: "pair-model" },
+            ...ids.map((id) => h("option", { value: id }, id))
+          );
+          modelSel.value = p.model;
+          modelSel.addEventListener("change", () => { p.model = modelSel.value; });
+          const tierSel = h(
+            "select",
+            { class: "pair-tier", title: t("routing.tasks.tierHint") },
+            h("option", { value: "any" }, t("routing.tasks.tierAny")),
+            ...Object.keys(st.tiers).map((tr) => h("option", { value: tr }, trTier(tr)))
+          );
+          tierSel.value = p.tier;
+          tierSel.addEventListener("change", () => { p.tier = tierSel.value; });
+          const del = h("button", { class: "btn sm ghost danger", onClick: () => { pairs.splice(i, 1); paint(); } }, "×");
+          return h("div", { class: "pair-row" }, modelSel, tierSel, del);
+        }),
+        pairs.length === 0 ? h("div", { class: "muted small", style: "align-self:center" }, t("routing.tasks.inherit")) : null,
+        h("button", { class: "btn ghost sm", onClick: () => { pairs.push({ model: ids[0] || "", tier: "any" }); paint(); } }, "+ " + t("routing.tasks.addModel"))
+      );
+    }
+    paint();
+    return wrap;
+  }
+
+  function tasksCard() {
+    const addIn = h("input", { placeholder: t("routing.tasks.addPlaceholder"), style: "max-width:220px" });
+    const addBtn = h("button", { class: "btn ghost sm" }, "+ " + t("routing.tasks.addCustom"));
+    addBtn.addEventListener("click", () => {
+      const v = addIn.value.trim().toLowerCase();
+      if (!v || st.taskPairs[v]) return;
+      st.taskPairs[v] = [];
+      render();
+    });
+    return h(
+      "div",
+      { class: "card" },
+      h("div", { class: "card-head" },
+        h("h3", {}, "🎯 " + t("routing.tasks.title")),
+        h("span", { class: "card-head sub" },
+          labelsSource === "router" ? t("routing.tasks.fromRouter") : t("routing.tasks.builtin"))),
+      h("div", { class: "muted small", style: "margin-bottom:10px" }, t("routing.tasks.hint")),
+      ...Object.keys(st.taskPairs).map(taskRow),
+      h("div", { class: "flex", style: "gap:8px; margin-top:10px" }, addIn, addBtn)
     );
   }
 
@@ -116,7 +335,16 @@ export async function renderRouting() {
     saveBtn.addEventListener("click", async () => {
       saveBtn.disabled = true;
       try {
-        await api.putRouting({ tiers: st.tiers, default: st.default, policy: st.policy });
+        const tasks = {};
+        for (const [k, pairs] of Object.entries(st.taskPairs)) {
+          const rule = {};
+          for (const p of pairs) {
+            if (!p.model) continue;
+            (rule[p.tier] = rule[p.tier] || []).push(p.model);
+          }
+          if (Object.keys(rule).length) tasks[k] = rule;
+        }
+        await api.putRouting({ tiers: st.tiers, tasks, bands: st.bands, default: st.default, policy: st.policy });
         toast(t("toast.saved"), "good");
       } catch (e) {
         toast(String(e.message || e), "bad");
@@ -141,8 +369,10 @@ export async function renderRouting() {
         "div",
         { class: "card" },
         h("div", { class: "card-head" }, h("h3", {}, t("routing.tiers")), h("span", { class: "card-head sub" }, t("routing.tierHint"))),
+        bandsCard(),
         ...Object.keys(st.tiers).map(tierRow)
       ),
+      tasksCard(),
       h(
         "div",
         { class: "card" },

web/js/views/settings.js

@@ -1,7 +1,7 @@
 // Settings — router/route/breaker/log/telemetry/stats + export/import config.
-import { h, mount, toast } from "../ui.js";
+import { h, mount, toast, confirmDialog } from "../ui.js";
 import { t } from "../i18n.js";
-import { api } from "../api.js";
+import { api, getToken, postRaw } from "../api.js";
 import { appState, SITE_URL } from "../app.js";
 
 // A small "?" badge with a hover/focus tooltip explaining a setting.
@@ -480,22 +480,33 @@ export async function renderSettings() {
   });
 
   async function exportConfig() {
-    const cfg = await api.getConfig();
-    const blob = new Blob([JSON.stringify(cfg, null, 2)], { type: "application/json" });
-    const url = URL.createObjectURL(blob);
-    const a = h("a", { href: url, download: "gateway-config.json" });
+    // the real gateway.toml from disk — comments and all
+    const tok = getToken();
+    const headers = {};
+    if (tok) headers["Authorization"] = "Bearer " + tok;
+    const r = await fetch("/admin/api/config/export", { headers });
+    if (!r.ok) {
+      toast(await r.text(), "bad");
+      return;
+    }
+    const url = URL.createObjectURL(await r.blob());
+    const a = h("a", { href: url, download: "gateway.toml" });
     document.body.appendChild(a);
     a.click();
     a.remove();
     URL.revokeObjectURL(url);
   }
-  const fileIn = h("input", { type: "file", accept: ".json,application/json", style: "display:none" });
+  const fileIn = h("input", { type: "file", accept: ".toml,.json,application/json", style: "display:none" });
   fileIn.addEventListener("change", async () => {
     const f = fileIn.files[0];
     if (!f) return;
     try {
-      const cfg = JSON.parse(await f.text());
-      await api.putConfig(cfg);
+      const text = await f.text();
+      if (f.name.endsWith(".json")) {
+        await api.putConfig(JSON.parse(text)); // legacy JSON export
+      } else {
+        await postRaw("/config/import", text); // gateway.toml — validated + hot-reloaded
+      }
       toast(t("toast.imported"), "good");
     } catch (e) {
       toast(String(e.message || e), "bad");
@@ -503,6 +514,29 @@ export async function renderSettings() {
     fileIn.value = "";
   });
 
+  const restartBtn = h("button", { class: "btn danger" }, "⟳ " + t("settings.restart"));
+  restartBtn.addEventListener("click", async () => {
+    if (!(await confirmDialog(t("settings.restartConfirm")))) return;
+    restartBtn.disabled = true;
+    try {
+      await api.restart();
+      toast(t("settings.restarting"), "good");
+      // the gateway comes back on the same port — reload once it answers
+      const poll = setInterval(async () => {
+        try {
+          await api.health();
+          clearInterval(poll);
+          location.reload();
+        } catch {
+          /* still restarting */
+        }
+      }, 1000);
+    } catch (e) {
+      toast(String(e.message || e), "bad");
+      restartBtn.disabled = false;
+    }
+  });
+
   mount(
     root,
     h(
@@ -623,7 +657,9 @@ export async function renderSettings() {
         { class: "flex wrap" },
         h("button", { class: "btn", onClick: exportConfig }, t("settings.export")),
         h("button", { class: "btn", onClick: () => fileIn.click() }, t("settings.import")),
-        fileIn
+        fileIn,
+        h("div", { class: "grow" }),
+        restartBtn
       )
     )
   );