chore: release 0.2.39

fix(shell): stale tabs now know the gateway was updated
Recurring confusion all day: the SPA lives in an open tab until reload, so after a gateway rebuild/update users kept seeing (and benchmarking with!) an old interface — "where is the feature", "why are the test ids old". The meta endpoint now carries the process start timestamp; the existing 20s health poll compares it, and when the gateway has restarted the tab shows a fixed banner: "The gateway was updated — this page is running an older interface" with a one-click Reload. 2 strings in all 7 languages.
2026-08-07 22:25:52 +03:00 · 2026-08-07 22:14:08 +03:00 · 2026-08-07 21:34:24 +03:00 · 2026-08-07 20:15:46 +03:00 · 2026-08-07 19:48:03 +03:00 · 2026-08-07 19:41:56 +03:00
47 changed files with 5485 additions and 158 deletions
@@ -3,6 +3,89 @@
 All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/).

+## [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
@@ -285,7 +285,7 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"

 [[package]]
 name = "cortiq-gateway"
-version = "0.2.37"
+version = "0.2.39"
 dependencies = [
 "anyhow",
 "arc-swap",
@@ -302,6 +302,7 @@ dependencies = [
 "rust-embed",
 "serde",
 "serde_json",
+ "sysinfo",
 "thiserror 1.0.69",
 "tokio",
 "tokio-stream",
@@ -341,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"
@@ -873,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"
@@ -882,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"
@@ -1430,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"
@@ -1914,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"
@@ -1923,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"
@@ -1989,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"
@@ -1,6 +1,6 @@
 [package]
 name = "cortiq-gateway"
-version = "0.2.37"
+version = "0.2.39"
 edition = "2021"
 rust-version = "1.75"
 license = "Apache-2.0"
@@ -61,6 +61,9 @@ 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"
 anyhow = "1"
@@ -3,6 +3,10 @@
 # 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
@@ -11,13 +15,15 @@ RUN cargo build --release

 # ---- runtime stage ----------------------------------------------------------
 FROM debian:trixie-slim
-# curl is required at runtime — model imports download ready .cmf files with it
+# 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 curl \
+    && 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 /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
@@ -40,7 +40,8 @@ One OpenAI-compatible endpoint → automatic model selection from your pool
 - **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.
@@ -137,7 +138,7 @@ The wizard takes you from nothing to a working local model:
 | **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, and `routing.default` points at it |
+| **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 —
@@ -39,7 +39,8 @@
 - **Запуск без конфигурации.** `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.** Прогон промпта через живой пайплайн с разбором решения роутинга.
@@ -129,7 +130,7 @@ cortiq-gateway
 | **Язык** | 7 языков; потом меняется в шапке |
 | **Готовые модели** | `.cmf` модели [`infosave`](https://huggingface.co/infosave), список читается с HuggingFace вживую — выбираете квантизацию и видите реальный прогресс загрузки |
 | **Любая модель с HF** | поиск по HuggingFace и автоконвертация в `.cmf` |
-| **Завершить** | каждая скачанная модель подключается как локальная, поднимается её `cortiq serve`, `routing.default` указывает на неё |
+| **Завершить** | каждая скачанная модель подключается как локальная, поднимается её `cortiq serve`, `routing.default` указывает на неё — и вы попадаете в Песочницу |

 Никаких правок 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

@@ -162,3 +162,29 @@ 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.
+
+**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"`.
@@ -160,3 +160,28 @@ cooldown  = "30s"
 enabled = false
 # источник истины задаёт интегратор (например, заголовок X-Cortiq-Correct-Label)
 ```
+
+## Распределение по задачам
+
+Роутер классифицирует каждый запрос дважды: **тип задачи** (что это за работа)
+и **уровень сложности** (насколько она трудна). Уровни выбирают, *сколько
+модели* нужно; правила по задачам — *какая* модель лучше в этом деле:
+
+```toml
+[routing.tasks]
+translation = ["local-qwen"]           # переводы дёшевы — оставляем локально
+code        = ["claude-sonnet", "gpt"] # код — сильнейшему кодеру
+```
+
+Модели подходящего правила идут **первыми** в цепочке кандидатов; цепочка по
+сложности следует за ними как резерв — правило по задаче не ослабляет failover.
+Задачи без правила маршрутизируются только по сложности.
+
+**Исключение — высокая сложность эскалирует.** Когда роутер оценил запрос как
+`high` (и цепочка `high` настроена), цепочка уровня идёт первой, а правило
+задачи становится резервом. Иначе правило вида `code → дешёвая-модель`
+приковало бы к дешёвой модели даже самые сложные запросы, и система уровней
+не имела бы права голоса. Для low/medium правило задачи ведёт, как и раньше. Список меток приходит
+с роутера (`GET /v1/taxonomies`) — вкладка Роутинг строит редактор по живой
+таксономии аккаунта и показывает долю каждой задачи в трафике. Когда цепочку
+возглавило правило задачи, ответ сообщает `route_source: "router+task-rule"`.
@@ -155,10 +155,12 @@ pub fn api_routes(admin_token: String) -> Router<SharedState> {
        )
        .route("/admin/api/models/:id/probe", post(probe_model))
        .route("/admin/api/routing", get(get_routing).put(put_routing))
+        .route("/admin/api/routing/labels", get(get_routing_labels))
        .route(
            "/admin/api/protocols",
            get(get_protocols).put(put_protocols),
        )
+        .route("/admin/api/harnesses", get(get_harnesses))
        .route("/admin/api/settings", get(get_settings).put(put_settings))
        .route("/admin/api/keys", get(list_keys).post(create_key))
        .route("/admin/api/keys/:key", axum::routing::delete(delete_key))
@@ -184,6 +186,20 @@ pub fn api_routes(admin_token: String) -> Router<SharedState> {
        .route("/admin/api/requests", get(get_requests))
        .route("/admin/api/test", post(run_test))
        .route("/admin/api/test/stream", post(run_test_stream))
+        .route("/admin/api/logs", get(get_logs).delete(clear_logs))
+        .route("/admin/api/system", get(get_system))
+        .route("/admin/api/restart", post(restart_gateway))
+        .route("/admin/api/bench", get(bench_list).post(bench_start))
+        .route("/admin/api/config/export", get(config_export))
+        .route("/admin/api/config/import", post(config_import))
+        .route("/admin/api/media/models", get(media_models))
+        .route("/admin/api/media", get(media_jobs).post(media_generate))
+        .route(
+            "/admin/api/media/:job",
+            get(media_job_status).delete(media_delete),
+        )
+        .route("/admin/api/media/:job/cancel", post(media_cancel))
+        .route("/admin/api/media/:job/file/:kind", get(media_file))
        .route("/admin/api/setup/status", get(setup_status))
        .route("/admin/api/setup/complete", post(setup_complete))
        .route("/admin/api/setup/featured", get(setup_featured))
@@ -583,9 +599,23 @@ async fn provider_models(
    ok(resp)
 }

-async fn meta() -> ApiResult {
+async fn meta(State(state): State<SharedState>) -> ApiResult {
+    // process start marker: open tabs poll this and offer a reload when the
+    // gateway (and thus the embedded SPA) has been restarted/updated
+    static STARTED: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
+    let started = *STARTED.get_or_init(|| {
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs()
+    });
    ok(json!({
        "version": env!("CARGO_PKG_VERSION"),
+        "started": started,
+        "update_available": state.gateway_update.lock().unwrap().clone(),
+        "admin_open_public": state
+            .admin_open_public
+            .load(std::sync::atomic::Ordering::Relaxed),
        "providers": ["openai", "anthropic", "openrouter", "lmstudio", "ollama", "http"],
        "provider_impl": { "openai": true, "anthropic": true, "openrouter": true, "lmstudio": true, "ollama": true, "http": true },
        "cost_tiers": ["cheap", "mid", "expensive", "local"],
@@ -726,7 +756,7 @@ fn strip_id_from_routing(routing: &mut RoutingCfg, id: &str) {
    if routing.default == id {
        routing.default = String::new();
    }
-    for tt in routing.tiers.values_mut() {
+    for tt in routing.tiers.values_mut().chain(routing.tasks.values_mut()) {
        match tt {
            crate::config::TierTargets::List(v) => v.retain(|x| x != id),
            crate::config::TierTargets::One(s) if s == id => {
@@ -735,6 +765,11 @@ fn strip_id_from_routing(routing: &mut RoutingCfg, id: &str) {
            crate::config::TierTargets::One(_) => {}
        }
    }
+    // an emptied task rule means "no rule", not "no candidates"
+    routing.tasks.retain(|_, tt| match tt {
+        crate::config::TierTargets::List(v) => !v.is_empty(),
+        crate::config::TierTargets::One(s) => !s.is_empty(),
+    });
 }

 /// Whether any managed server or static model in `cfg` still uses `path` as its
@@ -875,17 +910,70 @@ async fn probe_model(State(state): State<SharedState>, Path(id): Path<String>) -

 async fn get_routing(State(state): State<SharedState>) -> ApiResult {
    let live = state.live();
+    let tasks: HashMap<String, Vec<String>> = live
+        .cfg
+        .routing
+        .tasks
+        .iter()
+        .map(|(k, v)| {
+            (
+                k.clone(),
+                match v {
+                    TierTargets::List(l) => l.clone(),
+                    TierTargets::One(s) => vec![s.clone()],
+                },
+            )
+        })
+        .collect();
    ok(json!({
        "tiers": tiers_to_map(&live.cfg.routing),
+        "tasks": tasks,
        "default": live.cfg.routing.default,
        "policy": live.cfg.routing.policy,
    }))
 }

+/// Task labels of the active taxonomy, straight from the router (`GET
+/// /v1/taxonomies`) — the UI builds the per-task rule editor from this, so a
+/// custom taxonomy shows its own labels without a gateway update.
+async fn get_routing_labels(State(state): State<SharedState>) -> ApiResult {
+    let live = state.live();
+    match live.router.taxonomies().await {
+        Ok(Some(v)) => {
+            let want = live.cfg.router.taxonomy_id.clone().unwrap_or_default();
+            let mut labels: Vec<String> = Vec::new();
+            if let Some(arr) = v["taxonomies"].as_array() {
+                for tx in arr {
+                    let id = tx["taxonomy_id"].as_str().unwrap_or("");
+                    if want.is_empty() || id == want || labels.is_empty() {
+                        if let Some(ls) = tx["labels"].as_array() {
+                            let this: Vec<String> = ls
+                                .iter()
+                                .filter_map(|l| l.as_str().map(String::from))
+                                .collect();
+                            if id == want || labels.is_empty() {
+                                labels = this;
+                            }
+                        }
+                    }
+                }
+            }
+            if labels.is_empty() {
+                ok(json!({ "labels": Value::Null, "source": "router-empty" }))
+            } else {
+                ok(json!({ "labels": labels, "source": "router" }))
+            }
+        }
+        _ => ok(json!({ "labels": Value::Null, "source": "unavailable" })),
+    }
+}
+
 #[derive(Deserialize)]
 struct RoutingBody {
    #[serde(default)]
    tiers: HashMap<String, Vec<String>>,
+    #[serde(default)]
+    tasks: HashMap<String, Vec<String>>,
    default: String,
    #[serde(default)]
    policy: RoutingPolicy,
@@ -899,6 +987,12 @@ async fn put_routing(State(state): State<SharedState>, Json(body): Json<RoutingB
            .into_iter()
            .map(|(k, v)| (k, TierTargets::List(v)))
            .collect(),
+        tasks: body
+            .tasks
+            .into_iter()
+            .filter(|(_, v)| !v.is_empty()) // empty rule = "по сложности", not a rule
+            .map(|(k, v)| (k, TierTargets::List(v)))
+            .collect(),
        default: body.default,
        policy: body.policy,
    };
@@ -906,6 +1000,84 @@ async fn put_routing(State(state): State<SharedState>, Json(body): Json<RoutingB
    ok(json!({ "ok": true }))
 }

+// ──────────────────────────── harness detection ────────────────────────────
+// Which coding harnesses are present on the machine the gateway runs on, so the
+// API-keys view can mark tabs "installed" / "already configured for cortiq".
+// Detection is best-effort: binaries in PATH + common install dirs, config
+// files under the user's home. Works on Linux/macOS/Windows.
+
+fn harness_home() -> Option<std::path::PathBuf> {
+    std::env::var_os("HOME")
+        .or_else(|| std::env::var_os("USERPROFILE"))
+        .map(std::path::PathBuf::from)
+}
+
+fn find_bin(name: &str) -> bool {
+    let exts: &[&str] = if cfg!(windows) {
+        &[".exe", ".cmd", ".bat", ""]
+    } else {
+        &[""]
+    };
+    let mut dirs: Vec<std::path::PathBuf> = std::env::var_os("PATH")
+        .map(|p| std::env::split_paths(&p).collect())
+        .unwrap_or_default();
+    if let Some(home) = harness_home() {
+        // GUI-launched processes often miss the shell PATH — add usual suspects
+        for extra in [
+            ".local/bin",
+            ".cargo/bin",
+            "bin",
+            ".bun/bin",
+            ".npm-global/bin",
+            "AppData/Roaming/npm",
+        ] {
+            dirs.push(home.join(extra));
+        }
+    }
+    dirs.extend(["/usr/local/bin", "/opt/homebrew/bin"].map(std::path::PathBuf::from));
+    dirs.iter()
+        .any(|d| exts.iter().any(|e| d.join(format!("{name}{e}")).is_file()))
+}
+
+/// Does the harness config mention cortiq (i.e. was it pointed at this gateway)?
+fn config_mentions_cortiq(rel: &str) -> bool {
+    harness_home()
+        .map(|h| h.join(rel))
+        .and_then(|p| std::fs::read_to_string(p).ok())
+        .map(|c| c.to_lowercase().contains("cortiq"))
+        .unwrap_or(false)
+}
+
+async fn get_harnesses() -> ApiResult {
+    let harnesses = tokio::task::spawn_blocking(|| {
+        let vscode_ext_glob = |marker: &str| -> bool {
+            let Some(home) = harness_home() else {
+                return false;
+            };
+            for extdir in [".vscode/extensions", ".vscode-server/extensions"] {
+                if let Ok(rd) = std::fs::read_dir(home.join(extdir)) {
+                    for e in rd.flatten() {
+                        if e.file_name().to_string_lossy().starts_with(marker) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            false
+        };
+        json!({
+            "Claude Code": { "installed": find_bin("claude"), "configured": serde_json::Value::Null },
+            "Codex": { "installed": find_bin("codex"), "configured": config_mentions_cortiq(".codex/config.toml") },
+            "OpenCode": { "installed": find_bin("opencode"), "configured": config_mentions_cortiq(".config/opencode/opencode.json") },
+            "Continue": { "installed": harness_home().map(|h| h.join(".continue").is_dir()).unwrap_or(false), "configured": config_mentions_cortiq(".continue/config.yaml") },
+            "Cline": { "installed": vscode_ext_glob("saoudrizwan.claude-dev"), "configured": serde_json::Value::Null },
+        })
+    })
+    .await
+    .unwrap_or_else(|_| json!({}));
+    ok(harnesses)
+}
+
 // ───────────────────────────── protocols ───────────────────────────────────

 async fn get_protocols(State(state): State<SharedState>) -> ApiResult {
@@ -1420,8 +1592,16 @@ async fn setup_complete(
            .map(|j| j.output)
            .collect();
        if !finished.is_empty() {
+            let cortiq_bin = state.live().cfg.cmf.cortiq_bin.clone();
            let mut cfg = current_cfg(&state);
            for output in &finished {
+                // media packs (image/video) are used by the media API directly,
+                // not served — connecting them as chat servers would only fail
+                let modality =
+                    crate::media::classify_file(std::path::Path::new(output), &cortiq_bin).await;
+                if modality != crate::media::Modality::Chat {
+                    continue;
+                }
                if let Some(id) = register_cmf_output(&mut cfg, output) {
                    registered.push(id);
                }
@@ -1972,6 +2152,15 @@ async fn register_import(State(state): State<SharedState>, Path(job): Path<Strin
    if j.state != "done" {
        return Err(ApiError::bad("conversion not finished"));
    }
+    let live = state.live();
+    // Image/video packs are not served by `cortiq serve` — they are used
+    // directly by the media API. Nothing to register; tell the UI what it is.
+    let modality =
+        crate::media::classify_file(std::path::Path::new(&j.output), &live.cfg.cmf.cortiq_bin)
+            .await;
+    if modality != crate::media::Modality::Chat {
+        return ok(json!({ "ok": true, "media_kind": modality, "model_id": null }));
+    }
    let mut cfg = current_cfg(&state);
    let id = register_cmf_output(&mut cfg, &j.output).ok_or_else(|| {
        ApiError::bad(format!(
@@ -2004,6 +2193,186 @@ async fn get_requests(State(state): State<SharedState>, Query(q): Query<RecentQu
    ok(json!({ "requests": items }))
 }

+// ───────────────────────── system / logs / lifecycle ─────────────────────────
+
+/// Recent gateway log lines (in-memory ring) — for users who never see the
+/// terminal: Docker, autostart, a double-clicked exe.
+async fn get_logs(Query(q): Query<RecentQuery>) -> ApiResult {
+    let limit = q.limit.unwrap_or(300).min(500);
+    ok(json!({ "lines": crate::logbuf::snapshot(limit) }))
+}
+
+async fn clear_logs() -> ApiResult {
+    crate::logbuf::clear();
+    ok(json!({ "ok": true }))
+}
+
+/// Host metrics snapshot: CPU, RAM, free disk at the models dir, gateway RSS.
+async fn get_system(State(state): State<SharedState>) -> ApiResult {
+    let snap = state.sysmon.snapshot();
+    ok(serde_json::to_value(snap).unwrap_or_else(|_| json!({})))
+}
+
+/// Restart the gateway in place: stop managed model servers, spawn a fresh
+/// copy of ourselves (it retries the bind while our port frees), then exit.
+/// In Docker we only exit — we are PID 1, a spawned child would die with the
+/// container anyway; the container's restart policy brings the gateway back.
+async fn restart_gateway(State(state): State<SharedState>) -> ApiResult {
+    state.cmf.stop().await;
+    let in_docker = std::path::Path::new("/.dockerenv").exists();
+    let exe = std::env::current_exe().map_err(|e| ApiError::bad(e.to_string()))?;
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    tokio::spawn(async move {
+        // let the 200 reach the browser first
+        tokio::time::sleep(std::time::Duration::from_millis(300)).await;
+        if !in_docker {
+            let _ = std::process::Command::new(exe)
+                .args(args)
+                .env("CORTIQ_BIND_RETRY", "1")
+                .spawn();
+            tokio::time::sleep(std::time::Duration::from_millis(200)).await;
+        }
+        std::process::exit(0);
+    });
+    ok(json!({ "ok": true }))
+}
+
+#[derive(Deserialize)]
+struct BenchBody {
+    model: String,
+}
+
+/// Benchmark a local .cmf with `cortiq bench --json` — real tok/s on this box.
+async fn bench_start(State(state): State<SharedState>, Json(b): Json<BenchBody>) -> ApiResult {
+    let live = state.live();
+    crate::bench::start(state.bench.clone(), &live.cfg.cmf, b.model).map_err(ApiError::bad)?;
+    ok(json!({ "ok": true }))
+}
+
+async fn bench_list(State(state): State<SharedState>) -> ApiResult {
+    ok(json!({ "runs": state.bench.list() }))
+}
+
+/// The config file as-is (comments included) for download. Secrets live in
+/// secrets.toml and are deliberately NOT part of the export.
+async fn config_export(State(state): State<SharedState>) -> Response {
+    match tokio::fs::read_to_string(&state.config_path).await {
+        Ok(text) => (
+            [
+                (header::CONTENT_TYPE, "application/toml".to_string()),
+                (
+                    header::CONTENT_DISPOSITION,
+                    "attachment; filename=\"gateway.toml\"".to_string(),
+                ),
+            ],
+            text,
+        )
+            .into_response(),
+        Err(e) => ApiError::bad(format!("cannot read config: {e}")).into_response(),
+    }
+}
+
+/// Replace the whole config from an uploaded TOML. Validated and hot-reloaded
+/// exactly like a panel edit; on any error the current config stays untouched.
+async fn config_import(State(state): State<SharedState>, body: String) -> ApiResult {
+    let cfg: crate::config::Config =
+        toml::from_str(&body).map_err(|e| ApiError::bad(format!("invalid TOML: {e}")))?;
+    state.reload(cfg)?;
+    ok(json!({ "ok": true }))
+}
+
+// ───────────────────────────── media generation ─────────────────────────────
+
+/// Local `.cmf` files with their modality (chat / image / video) — the
+/// playground's media tabs read this to know what can generate what.
+async fn media_models(State(state): State<SharedState>) -> ApiResult {
+    let live = state.live();
+    let models =
+        crate::media::list_media_models(&live.cfg.cmf.models_dir, &live.cfg.cmf.cortiq_bin).await;
+    ok(json!({ "models": models }))
+}
+
+async fn media_jobs(State(state): State<SharedState>) -> ApiResult {
+    ok(json!({ "jobs": state.media.list() }))
+}
+
+async fn media_generate(
+    State(state): State<SharedState>,
+    Json(p): Json<crate::media::MediaParams>,
+) -> ApiResult {
+    let live = state.live();
+    let id = crate::media::start_generation(state.media.clone(), &live.cfg.cmf, p)
+        .map_err(ApiError::bad)?;
+    ok(json!({ "job": id }))
+}
+
+async fn media_job_status(State(state): State<SharedState>, Path(job): Path<String>) -> ApiResult {
+    match state.media.get(&job) {
+        Some(j) => {
+            let mut v = serde_json::to_value(&j).unwrap_or_else(|_| json!({}));
+            if j.state == "queued" {
+                v["queue_position"] = json!(state.media.queue_position(&job));
+            }
+            ok(v)
+        }
+        None => Err(ApiError::not_found(format!("media job '{job}' not found"))),
+    }
+}
+
+async fn media_cancel(State(state): State<SharedState>, Path(job): Path<String>) -> ApiResult {
+    if state.media.get(&job).is_none() {
+        return Err(ApiError::not_found(format!("media job '{job}' not found")));
+    }
+    ok(json!({ "ok": state.media.cancel(&job, &crate::media::media_dir()) }))
+}
+
+async fn media_delete(State(state): State<SharedState>, Path(job): Path<String>) -> ApiResult {
+    if state.media.get(&job).is_none() {
+        return Err(ApiError::not_found(format!("media job '{job}' not found")));
+    }
+    let removed = state
+        .media
+        .delete(&job, &crate::media::media_dir())
+        .map_err(ApiError::bad)?;
+    ok(json!({ "ok": removed }))
+}
+
+/// Serve a finished job's output bytes (ppm / avi / wav / mp4). The job id is
+/// server-generated hex and the file name is fixed per kind, so no path from the
+/// client ever reaches the filesystem.
+async fn media_file(
+    State(state): State<SharedState>,
+    Path((job, kind)): Path<(String, String)>,
+) -> Response {
+    let Some(j) = state.media.get(&job) else {
+        return ApiError::not_found(format!("media job '{job}' not found")).into_response();
+    };
+    if j.state != "done" {
+        return ApiError::bad("generation not finished").into_response();
+    }
+    let Some((file, mime)) = crate::media::output_file(&kind) else {
+        return ApiError::bad(format!("unknown output kind '{kind}'")).into_response();
+    };
+    let path = crate::media::media_dir().join(&job).join(file);
+    match tokio::fs::read(&path).await {
+        Ok(bytes) => (
+            [
+                (header::CONTENT_TYPE, mime.to_string()),
+                (
+                    header::CONTENT_DISPOSITION,
+                    format!(
+                        "inline; filename=\"cortiq-{job}.{}\"",
+                        file.rsplit('.').next().unwrap_or("bin")
+                    ),
+                ),
+            ],
+            bytes,
+        )
+            .into_response(),
+        Err(_) => ApiError::not_found("output file missing on disk").into_response(),
+    }
+}
+
 // ───────────────────────────── playground (test) ───────────────────────────

 #[derive(Deserialize)]
@@ -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());
+    }
+}
@@ -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)
@@ -305,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
@@ -396,6 +398,12 @@ 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>,
 }

 /// A routing tier is either a list of model_ids or the string `default`.
@@ -724,13 +732,16 @@ 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: "http://localhost:8080".to_string(),
-                timeout_ms: default_router_timeout(),
-                verify_tls: 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("general.task-type".to_string()),
+                taxonomy_id: Some("data-assistant".to_string()),
            },
            route: RouteCfg::default(),
            models: Vec::new(),
@@ -738,6 +749,7 @@ impl Default for Config {
                tiers: HashMap::new(),
                default: String::new(),
                policy: RoutingPolicy::default(),
+                tasks: HashMap::new(),
            },
            breaker: BreakerCfg::default(),
            protocols: ProtocolsCfg {
@@ -745,7 +757,9 @@ impl Default for Config {
                openai_completions: true,
                openai_embeddings: true,
                openai_models: true,
-                anthropic_messages: false,
+                // 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,
            },
@@ -862,6 +876,21 @@ impl Config {
                }
            }
        }
+        for (task, targets) in &self.routing.tasks {
+            let list = match targets {
+                TierTargets::List(v) => v.clone(),
+                TierTargets::One(s) => vec![s.clone()],
+            };
+            for id in &list {
+                if !ids.contains(id.as_str()) {
+                    anyhow::bail!(
+                        "config: routing.tasks.{} references unknown model id '{}'",
+                        task,
+                        id
+                    );
+                }
+            }
+        }
        Ok(())
    }

@@ -132,7 +132,7 @@ 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,
@@ -162,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);
@@ -215,6 +261,7 @@ impl JobStore {
                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) {
@@ -263,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) {
@@ -280,6 +328,7 @@ impl JobStore {
                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()
@@ -295,6 +344,7 @@ 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> {
@@ -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());
+        }
+    }
+}
@@ -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;
@@ -203,12 +207,23 @@ async fn main() -> anyhow::Result<()> {
    if listen != original_listen {
        let _ = cfg.save(&config_path);
    }
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            tracing_subscriber::EnvFilter::try_from_default_env()
-                .unwrap_or_else(|_| cfg.log.level.clone().into()),
-        )
-        .init();
+    {
+        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 admin_enabled = cfg.admin.enabled;
    let admin_token = resolve_admin_token(&cfg, &args);
@@ -216,6 +231,18 @@ async fn main() -> anyhow::Result<()> {

    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
    // the background so startup is never blocked by a cargo install or a model
@@ -246,7 +273,25 @@ async fn main() -> anyhow::Result<()> {

    let app = app.with_state(state).layer(cors);

-    let listener = tokio::net::TcpListener::bind(&listen).await?;
+    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 {
        let host_for_url = if listen.starts_with("0.0.0.0:") {
@@ -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());
+    }
+}
@@ -232,8 +232,16 @@ impl Pipeline {
                        match live.router.route(&text, prof).await {
                            Ok(Some(dec)) => {
                                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!(
@@ -542,6 +550,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(),
@@ -551,6 +564,7 @@ impl Pipeline {
                        protocol,
                        directive,
                        started,
+                        prompt_chars,
                    );
                    return Ok((info, Box::pin(tapped)));
                }
@@ -722,6 +736,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! {
@@ -731,12 +746,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();
@@ -765,6 +783,7 @@ fn tap_stream(
                                            v["choices"][0]["delta"]["content"].as_str()
                                        {
                                            delta_chars += c.chars().count();
+                                            delta_chunks += 1;
                                        }
                                    }
                                }
@@ -774,12 +793,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 {
@@ -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()),
        })
    }

@@ -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()),
        })
    }

@@ -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 },
@@ -3,38 +3,85 @@

 use crate::config::{Config, TierTargets};

+fn to_list(t: &TierTargets) -> Vec<String> {
+    match t {
+        TierTargets::List(v) => v.clone(),
+        TierTargets::One(s) => vec![s.clone()],
+    }
+}
+
 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, Vec<String>>,
    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)| (task.clone(), to_list(targets)))
+                .filter(|(_, v)| !v.is_empty())
+                .collect(),
            default: cfg.routing.default.clone(),
        }
    }

+    /// Candidates for `(task, tier)`, in preference order, deduplicated:
+    /// the task rule's models first (when one exists), then the tier chain —
+    /// so a task pin adds preference without ever weakening failover.
+    /// Returns `(candidates, task_rule_matched)`.
+    pub fn candidates_for(&self, task: &str, tier: &str) -> (Vec<String>, bool) {
+        let mut out: Vec<String> = Vec::new();
+        let tier_chain = self
+            .tiers
+            .get(tier)
+            .cloned()
+            .unwrap_or_else(|| vec![self.default.clone()]);
+        // Task rules steer everyday traffic — but a high-complexity verdict
+        // must escalate ABOVE them, or a "code → cheap-model" rule would pin
+        // the hardest prompts to the small model forever. At tier=high the
+        // tier chain leads and the task rule becomes the fallback; otherwise
+        // the task rule leads as before.
+        let escalate = tier == "high" && self.tiers.contains_key("high");
+        if escalate {
+            out.extend(tier_chain.iter().cloned());
+        }
+        let matched = if let Some(rule) = self.tasks.get(task) {
+            for id in rule {
+                if !out.contains(id) {
+                    out.push(id.clone());
+                }
+            }
+            true
+        } else {
+            false
+        };
+        if !escalate {
+            for id in tier_chain {
+                if !out.contains(&id) {
+                    out.push(id);
+                }
+            }
+        }
+        out.retain(|id| !id.is_empty());
+        (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 +93,61 @@ 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(), v.iter().map(|s| s.to_string()).collect()))
+                .collect(),
+            default: default.to_string(),
+        }
+    }
+
+    #[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");
+        assert!(m);
+        assert_eq!(c, vec!["big", "cheap-coder"]);
+    }
+
+    #[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"]);
+        let (c, matched) = t.candidates_for("qa", "unknown-tier");
+        assert!(!matched);
+        assert_eq!(c, vec!["d"]);
+    }
+}
@@ -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,
@@ -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
+}
@@ -585,6 +585,93 @@ body.modal-open { overflow: hidden; }
 /* 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); }
+
+/* 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; }
@@ -68,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
@@ -118,6 +120,22 @@ export const api = {
  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.
@@ -134,6 +152,21 @@ export const api = {
    ),
 };

+// 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) {
@@ -155,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;
@@ -167,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 */
      }
@@ -181,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();
+}
@@ -11,6 +11,8 @@ 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 = [
@@ -21,6 +23,8 @@ 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 },
 ];
@@ -52,6 +56,27 @@ 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(
@@ -221,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();
@@ -231,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");
@@ -468,4 +468,157 @@ export default {
  "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",
 };
@@ -461,4 +461,157 @@ export default {
  "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",
 };
@@ -468,4 +468,157 @@ export default {
  "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",
 };
@@ -468,4 +468,157 @@ export default {
  "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",
 };
@@ -460,4 +460,157 @@ export default {
  "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": "Перезагрузить",
 };
@@ -468,4 +468,157 @@ export default {
  "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",
 };
@@ -468,4 +468,157 @@ export default {
  "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": "重新加载",
 };
@@ -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 };
+}
@@ -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`;
@@ -0,0 +1,490 @@
+// 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 } 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.`,
+  ];
+  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.`,
+  ];
+  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?
+            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 }, 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;
+}
@@ -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" },
@@ -78,7 +78,19 @@ function descLine(desc) {
  return desc && desc.includes(" ") ? h("div", { class: "muted small", style: "margin:6px 0" }, desc) : null;
 }

-/// One model. `ctx` = { hosts: Map(jobId → element), onDownload(m, v), onDelete(m, v) }.
+/// 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) {
@@ -101,6 +113,7 @@ export function featuredCard(m, ctx) {
      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),
@@ -149,7 +162,8 @@ export function featuredCard(m, ctx) {
    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)
+      descBadge(desc),
+      ...(done0 ? [] : fitWarnings((v0 && v0.size_bytes) || m.size_bytes, ctx.sys))
    ),
    descLine(desc),
    h("div", { class: "muted small" }, m.id),
@@ -424,8 +424,10 @@ export function renderImport() {

  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 };
+    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"))]));
@@ -4,27 +4,17 @@ 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");

  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 +23,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,6 +38,171 @@ 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() {
@@ -119,7 +274,8 @@ export async function renderKeys() {
                )
              )
            )
-          )
+          ),
+      snippetsCard(!!data.open_mode)
    );
  }

@@ -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;
+}
@@ -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;
 }
@@ -45,6 +45,7 @@ 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", {});
@@ -131,6 +132,7 @@ export function renderOnboarding() {

  async function loadFeatured() {
    featured = await fetchFeatured();
+    try { sysSnapshot = await api.system(); } catch { /* optional */ }
    featuredLoaded = true;
  }

@@ -199,7 +201,7 @@ export function renderOnboarding() {
      );
    } 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 };
+      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)))
@@ -290,7 +292,8 @@ export function renderOnboarding() {
          // let the toast be readable before the reload swaps the page
          await new Promise((res) => setTimeout(res, 900));
        }
-        location.hash = "#/models";
+        // land where the reward is: try the model right away
+        location.hash = "#/playground";
        location.reload();
      });
      const skipBtn = h("button", { class: "btn ghost", onClick: async () => {
@@ -1,17 +1,64 @@
-// Playground — send a prompt through the live pipeline, inspect routing decision.
-import { h, mount, money, ms } from "../ui.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 } from "../i18n.js";
-import { api, testStream } from "../api.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,32 +155,53 @@ 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"))),
@@ -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;
 }
@@ -4,71 +4,155 @@ import { t } 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 = {};
+  for (const l of taskLabels) tasks[l] = (routing.tasks || {})[l] || [];
  const st = {
    tiers,
+    tasks,
    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
+    );
+  }
+
+  function tierRow(tier) {
    return h(
      "div",
      { class: "tierrow" },
      h("div", { class: "tname" }, h("span", { class: "badge tier-" + tier }, 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
+      ),
+      chipEditor(st.tasks, label, t("routing.tasks.inherit"))
+    );
+  }
+
+  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.tasks[v]) return;
+      st.tasks[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.tasks).map(taskRow),
+      h("div", { class: "flex", style: "gap:8px; margin-top:10px" }, addIn, addBtn)
    );
  }

@@ -116,7 +200,9 @@ 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, v] of Object.entries(st.tasks)) if (v.length) tasks[k] = v;
+        await api.putRouting({ tiers: st.tiers, tasks, default: st.default, policy: st.policy });
        toast(t("toast.saved"), "good");
      } catch (e) {
        toast(String(e.message || e), "bad");
@@ -143,6 +229,7 @@ export async function renderRouting() {
        h("div", { class: "card-head" }, h("h3", {}, t("routing.tiers")), h("span", { class: "card-head sub" }, t("routing.tierHint"))),
        ...Object.keys(st.tiers).map(tierRow)
      ),
+      tasksCard(),
      h(
        "div",
        { class: "card" },
@@ -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
      )
    )
  );
Author	SHA1	Message	Date
infosave2007	b4d36334bf	chore: release 0.2.39 Docker / publish (push) Canceled after 0s Details Release / crates-io (push) Canceled after 0s Details Release / release (macos-14, aarch64-apple-darwin) (push) Canceled after 0s Details Release / release (ubuntu-latest, x86_64-unknown-linux-gnu) (push) Canceled after 0s Details Release / release (windows-latest, x86_64-pc-windows-msvc) (push) Canceled after 0s Details	2026-08-07 22:25:52 +03:00
infosave2007	dd9ccaea94	fix(shell): stale tabs now know the gateway was updated Recurring confusion all day: the SPA lives in an open tab until reload, so after a gateway rebuild/update users kept seeing (and benchmarking with!) an old interface — "where is the feature", "why are the test ids old". The meta endpoint now carries the process start timestamp; the existing 20s health poll compares it, and when the gateway has restarted the tab shows a fixed banner: "The gateway was updated — this page is running an older interface" with a one-click Reload. 2 strings in all 7 languages.	2026-08-07 22:14:08 +03:00
infosave2007	ff8415d7d4	feat(routing): high tier escalates over task rules; benchmark generates hard prompts that stay hard Routing semantics fix observed live: a task rule ("code → cheap model") was pinning even high-complexity prompts to the cheap model — the tier system never got a say. At tier=high the tier chain now leads and the task rule demotes to fallback; low/medium keep task-rule-first. Unit-tested both ways. The benchmark's hard probes are now GENERATED per run from two pools (science: protein folding / telescope scheduling / materials discovery; ops: epidemic logistics / grid markets / climate risk) with rotating domains and numbers. Two findings against the live router drove this: ambiguity carries the biggest weight in the complexity score, so interdisciplinary prompts rate high reliably (0.52-0.66) while single-domain "hard" prompts classify too confidently and sink to medium; and any fixed wording loses novelty on every repeat. Their labels are null — straddling task labels is precisely what makes them high, so classification is not judged. Verified end-to-end: full run 100% answers, 13/13 classification, both hard probes high → routed to the expensive model (one of them over a code task rule), at $0.0018 each thanks to the tiny route-judge token budget.	2026-08-07 21:34:24 +03:00
infosave2007	7479cc51c2	feat(benchmark): hard tests that light up the high tier — judged on routing, not essays Two "hard" probes (full suite only): a compiler-backend design and a security protocol design, each dense enough for the router's complexity model to rate them high. They are judged on the ROUTER's decision (judge: "route") — pass means tier=high was reached and the request went to the big model; the answer itself is not scored (open-ended essays aren't keyword-judgeable, and reasoning models happily burn 3000+ thinking tokens on them — measured). With max_tokens kept tiny the probes cost cents even on the priciest model, while the cost column tells the whole story: $0.0148 for the high-tier request next to $0.00005 for the easy ones. Each run picks a random variant of the prompt: the router deliberately scores familiar text as less novel, so a fixed wording would decay to medium over repeated runs. In pinned-models mode route-judged tests are skipped. Also: creative-writing budget 96→512 (deepseek was spending the whole cap thinking and returning an empty poem), and when a model does burn its entire budget inside <think> the table now says so ("budget spent on reasoning") instead of the misleading "empty answer". Server-side (cortiq-router prod, both replicas rolling-restarted): the high band started at 0.66 while the complexity model tops out ~0.65 on the hardest single prompts — high was unreachable. Band boundary moved to 0.50 based on measured distribution (easy 0.25-0.36, medium 0.37-0.49, hard 0.50-0.65); config backed up as config.prod.toml.bak-tiers.	2026-08-07 20:15:46 +03:00
infosave2007	b1e0dc76ec	fix(benchmark): fair to reasoning models, fair to router degradation, real sub-cent costs Three false signals in benchmark results, all seen on a live run: - Reasoning models were scored ❌ because the per-test max_tokens cap cut them mid-<think> before the actual answer. Every run now gets +256 tokens of headroom; non-thinking models stop at EOS as before, thinking ones get to finish (math-mult on nanbeige: false 0/1 → honest 1/1). - When the router degraded (timeout → fallback chain) the table showed "✗ degraded" and counted it against classification accuracy. There was no classification to judge — such rows now show a muted "⚠ router degraded" with an explanatory tooltip and are excluded from the accuracy KPI. - Costs below $0.0001 (cheap flash models) collapsed to "$0.0000". money formatting now grows precision until two significant digits survive ($0.000035 instead of $0.0000). 2 new strings in all 7 languages.	2026-08-07 19:48:03 +03:00
infosave2007	c3dd251cce	fix(keys): drop the allowed-models picker from the new-key dialog Creating a key now asks only account, rate limit and optional custom value — allow_models is sent empty (= all models). Per-key model restrictions stay editable in Settings for whoever actually needs them.	2026-08-07 19:41:56 +03:00
infosave2007	9af51b679e	fix(bench): newer cortiq pretty-prints --json — parse it, and report honest tok/s The one-click model benchmark showed "error" even though cortiq bench ran fine: the parser expected the JSON result on a single line, while newer cortiq releases pretty-print it across many. Extraction now finds the last balanced JSON object anywhere in the mixed CLI output (both formats work). Also hardened tok/s selection: steady decode speed (decode_tok_s_steady) is preferred over incl-prefill, and the loose "contains tok+per" fallback — which would happily report allocs_per_token=769 as tok/s — now only matches tok_s / tokens_per fields.	2026-08-07 19:32:47 +03:00
infosave2007	1bba427042	feat(keys): one-paste harness setup — Claude Code, Codex, OpenCode, Continue, Cline The "connect your app" card in the API-keys view now leads with auto-setup scripts for popular coding harnesses, each pre-filled with this gateway's URL and the freshly created key: Claude Code — env exports (the gateway speaks Anthropic /v1/messages natively; the protocol is now ON by default, and when a config has it off the tab shows a warning with a one-click Enable button) Codex — appends a [model_providers.cortiq] block to ~/.codex/config.toml OpenCode — writes the provider into opencode.json Continue — appends the model to ~/.continue/config.yaml Cline — the exact values to paste into the extension settings The gateway also detects which harnesses are already present on its machine (binaries across PATH + common install dirs, config files under home) via GET /admin/api/harnesses: installed tabs get a ✓, and the status line under the snippet says "installed" or "already configured for this gateway" when the harness config mentions cortiq. Works on Linux/macOS/Windows. curl / python / javascript SDK snippets stay as before. 16 new strings in all 7 languages.	2026-08-07 19:26:54 +03:00
infosave2007	54b73f1365	fix: honest costs in streams, oracle-sized timeouts, history & log cleanup Cost showed $0 for every streamed request: the X-Cortiq-Cost-USD header is written before generation, when the cost cannot be known. The gateway now ships the final number in a closing SSE event (`cortiq_cost_usd`, alongside the token estimate when the provider sent no usage), and the console prefers it over the header. Money renders with 4 decimals, the last two in a smaller font — $0.0006 stays readable instead of collapsing to $0. Timeouts, both ends: the router default was 800 ms, silently degrading every prompt the hosted router escalates to its oracle (~10 s) — now 15 s. Provider clients had NO timeout at all (a dead OpenRouter host hung requests forever) — now a 10 s connect timeout, with no overall cap so long generations and streams are never cut. Benchmark history: per-run × and a Clear-all button. Logs view: a clear button backed by DELETE /admin/api/logs.	2026-08-07 19:15:27 +03:00
infosave2007	ec92bdddb7	feat(benchmark): smart-routing mode is the point — live results, per-model cost The benchmark now leads with the product's actual feature. Two explicit modes: 🧭 Smart routing (default) — every probe goes through cortiq-auto; each row shows the router's task label judged against the expected one (✓/✗ with "expected: …"), the complexity tier, the chosen model with what that request cost, and a task-rule badge when a routing rule fired. KPIs: answer quality, classification accuracy, TTFT, tok/s and money spent, plus a "requests went to" distribution with per-model cost. 🎯 Individual models — the old head-to-head comparison, now as the clearly separate option (model checkboxes appear only here). The suite covers all 8 taxonomy labels (added summarization, creative-writing and chitchat probes; expected labels annotated per test). Results are LIVE: the table grows a row after every test (with a small fade-in), the progress card shows the prompt being asked, and a 🏁 verdict toast lands at the end with the score and the total spend. 12 new strings in all 7 languages.	2026-08-07 19:04:41 +03:00
infosave2007	1120d8f11a	feat(benchmark): the built-in benchmark, redesigned into the console The old standalone benchmark.html (Russian-only, Tailwind+Chart.js from CDNs, never shipped in the crate) becomes a proper sidebar view. Same scoring ideas, reimplemented: keyword checks with \|-synonyms, think-tag stripping, tail-loop detection, pass/partial/fail — plus what the old page never had: runs go through the LIVE pipeline (pinned per model, streamed), so every test also measures tok/s and time-to-first-token with the gateway's real token counts. A built-in suite of 12 language-neutral probes (math, logic, code, QA, instruction-following, extraction, translation, JSON formatting); the ⚡ quick mode runs the 6 short ones — about a minute on a local model. Results: score bars per model sorted best-first, a per-test grid (click a cell for the full answer), previous runs and custom tests kept in the browser. 22 new strings in all 7 languages.	2026-08-07 18:56:47 +03:00
infosave2007	914ff42fc5	release: v0.2.38 — media generation, task-based routing, ops batch Docker / publish (push) Canceled after 0s Details Release / crates-io (push) Canceled after 0s Details Release / release (macos-14, aarch64-apple-darwin) (push) Canceled after 0s Details Release / release (ubuntu-latest, x86_64-unknown-linux-gnu) (push) Canceled after 0s Details Release / release (windows-latest, x86_64-pc-windows-msvc) (push) Canceled after 0s Details	2026-08-07 18:34:00 +03:00
infosave2007	2ede0ee452	feat(routing): per-task rules on top of complexity tiers; hosted router is the default The router has always returned two signals — task label and complexity tier — but only the tier picked models. [routing.tasks] adds `label → ordered models`: a matching rule's models lead the candidate chain and the tier chain follows as fallback, so pinning translations to a local model never weakens failover. Requests whose chain was headed by a task rule report route_source "router+task-rule". The Routing page grows a per-task editor built from the account's LIVE taxonomy (GET /v1/taxonomies via the new /admin/api/routing/labels proxy; built-in label set when the router is unreachable), with localized task names, each task's share of 7-day traffic, "by complexity (no rule)" as the explicit empty state, and custom labels for other taxonomies. Deleting a model scrubs it from task rules like it always did from tiers. Also fixes the default config pointing at a placeholder localhost:8080 router with a nonexistent taxonomy — a fresh install now targets the hosted allaigate router (IP endpoint, verify_tls off, data-assistant, 12 s oracle timeout) and degrades gracefully until a key is set. Verified end-to-end against the live router: translation → task-rule model, math → tier path. 16 new strings in all 7 languages.	2026-08-07 17:39:38 +03:00
infosave2007	15de36be3b	feat: ops & UX batch — jobs survive restarts, logs/system in the console, media queue, gallery, chat, exact stream tokens Fifteen changes aimed at the first day of real use: - Import and media jobs persist to <data>/jobs-*.json and reload on start (running ones settle as errors); the Register button no longer vanishes because the gateway restarted. - Docker ships the cortiq binary (built in the builder stage) — local .cmf chat models and image/video generation now work in containers, where auto-install never could (no cargo in the runtime image). libvulkan1 added for optional GPU offload. - Open admin console on 0.0.0.0 without a token now warns in the log and shows a dismissible banner — the VPS footgun is at least labeled. - "Restart gateway" button in Settings: stops managed model servers, spawns a fresh copy (bind retried while the port frees), Docker relies on the container restart policy instead. - Dashboard "System" panel: CPU sparkline + load, RAM (with the gateway's own RSS), free disk at the models dir — sampled by sysinfo every 2 s. - Featured model cards warn "not enough disk" / "may not fit in RAM" before the download, from the same live snapshot. - Log viewer in the sidebar: a 500-line in-memory ring fed by a second ANSI-free tracing layer; filter, level, pause, copy. - Update check: crates.io polled twice a day, the console shows an "update available" notice. - Media generations queue up (with position shown) instead of being rejected; progress gained an honest ETA from measured throughput. - Generation gallery under the image/video tabs: lazy PPM thumbnails, click to reopen with seed/steps, delete. - Playground chat is a real dialogue now: history is resent, bubbles, Clear, Cmd/Ctrl+Enter. - "Connect your app" snippets (curl / Python / JS) on the keys page, with the real key inlined right after creation. - One-click benchmark on the Models page via `cortiq bench --json`. - Config export now downloads the actual gateway.toml (comments intact); import accepts TOML (validated, hot-reloaded) and the legacy JSON. - Streaming token counts are exact when the model server provides usage (cortiq-server patch, shipped separately); the gateway fallback now counts content chunks (1/token on cortiq) instead of chars/4. Wizard's Finish lands on the Playground. 37 new strings in all 7 languages.	2026-08-07 17:07:48 +03:00
infosave2007	a77beeabab	feat(playground): image & video generation tabs + real chat metrics The infosave collection now ships media models (Lumina-Image-2.0, MiniMax-H3 Turbo) that cortiq runs via `imagine`/`animate` CLI, not `cortiq serve`. The gateway grows a media API: local .cmf files are classified by `cortiq info` (chat/image/video, cached), generations run as tracked jobs with step progress parsed from stdout, one at a time, cancellable, outputs under <data>/media. The playground becomes three tabs. Image: width/height/steps/CFG/seed, live progress, result rendered from P6 PPM to a canvas in the browser (PNG export via toBlob). Video: frames/steps/quality/seed plus 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 (mp4 remux happens opportunistically when ffmpeg exists). A metrics card shows resolution, steps, seed, total time, time per step/frame and file size. Chat metrics: the local cortiq server sends no usage chunk in streams, so token counts showed 0/0. tap_stream now injects one OpenAI-shaped usage event ahead of [DONE] with the gateway's ~4-chars/token estimate, flagged `cortiq_estimated`; the UI renders it as "≈ N / M" and adds tok/s and time-to-first-token. Registration skips media packs (a `cortiq serve` entry for a diffusion model would only fail) in both Register and the wizard's Finish. 36 new UI strings translated across all 7 languages.	2026-08-07 15:55:06 +03:00