Super-squash branch 'main' using huggingface_hub

Co-authored-by: hynek med <hynek med@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,11 @@
+data/articles.jsonl filter=lfs diff=lfs merge=lfs -text
+db/chroma/85dc4107-dc6e-491a-8587-80599979b833/data_level0.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/85dc4107-dc6e-491a-8587-80599979b833/index_metadata.pickle filter=lfs diff=lfs merge=lfs -text
+db/chroma/85dc4107-dc6e-491a-8587-80599979b833/length.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/85dc4107-dc6e-491a-8587-80599979b833/link_lists.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/data_level0.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/index_metadata.pickle filter=lfs diff=lfs merge=lfs -text
+db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/link_lists.bin filter=lfs diff=lfs merge=lfs -text
+db/chroma_en/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+static/logo.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# System deps
+RUN apt-get update -qq && apt-get install -y -qq --no-install-recommends \
+    build-essential && \
+    rm -rf /var/lib/apt/lists/*
+
+# Python deps (no torch — fastembed uses ONNX)
+COPY requirements-hf.txt .
+RUN pip install --no-cache-dir -r requirements-hf.txt
+
+# The search model (~240 MB) into the image, so a start never downloads it.
+# Before the app's other files: this layer only rebuilds when embedder.py does.
+COPY embedder.py .
+RUN python embedder.py
+
+# Copy app. deploy-hf-3.sh stages only the modules reachable from the entry
+# points, so the build context is already the exact set we want — listing files
+# here as well just means a new module gets missed twice.
+COPY *.py ./
+COPY static/ static/
+COPY db/ db/
+COPY data/ data/
+
+# Create logs dir
+RUN mkdir -p logs
+
+# IP location files for /stats (DB-IP Lite, monthly); every build fetches current ones
+RUN python geo.py
+
+# HF Spaces expects port 7860
+ENV PORT=7860
+EXPOSE 7860
+
+# Run with startup.py (loading screen + benchmark)
+CMD ["python", "startup.py"]

README.md

@@ -0,0 +1,13 @@
+---
+title: OpenAjaj
+emoji: 🤖
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# OpenAjaj — AI poháněná Necyklopedií
+
+Jediná AI, která ví, jak to doopravdy je.

benchmark.py

@@ -0,0 +1,140 @@
+"""
+benchmark.py — Speed-test LLM models and select the fastest available.
+
+Benchmarks CANDIDATE_MODELS at startup, picks top 5 as ACTIVE_MODELS.
+Lumo is included in the active set only when its benchmark succeeds.
+"""
+
+import json
+import os
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from json_storage import update_json
+from providers import CANDIDATE_MODELS, MODELS, stream_benchmark
+
+_BENCH_CACHE_FILE = os.path.join(os.path.dirname(__file__), "data", "bench_cache.json")
+
+
+def load_bench_cache() -> dict:
+    """Load persisted benchmark results."""
+    try:
+        with open(_BENCH_CACHE_FILE) as f:
+            return json.load(f)
+    except (OSError, ValueError):  # missing or corrupt cache: start empty
+        return {}
+
+
+def save_bench_cache(results: dict) -> None:
+    """Save benchmark results, merging with existing cache."""
+    ts = int(time.time())
+
+    def merge_results(cache: dict) -> None:
+        for model, result in results.items():
+            if result.get("latency") is not None:
+                cache[model] = {**result, "ts": ts}
+
+    update_json(_BENCH_CACHE_FILE, dict, merge_results)
+
+
+BENCH_SYSTEM = "Jsi vtipný asistent. Odpovídej česky ve 2 odstavcích."
+BENCH_USER = "Co je to Brno a proč je slavné?"
+
+
+def benchmark_models(candidates: list[str] | None = None, top_n: int = 5,
+                     on_progress=None):
+    """Benchmark candidate models in parallel, return speed-ranked results.
+
+    Args:
+        candidates: Models to test (defaults to CANDIDATE_MODELS).
+        top_n: How many to select as active (includes Lumo when successful).
+        on_progress: Optional callback(model, status, result) for live updates.
+            status: "testing", "ok", "fail"
+            result: dict with latency/ttft/tok_sec/error (None for "testing")
+
+    Returns (active_models, ranked_chain, results_dict) where:
+      - active_models: up to top_n successful model names
+      - ranked_chain: list of (model_name, latency) sorted by TTFT
+      - results_dict: model_name -> {latency, ttft, tok_sec, error}
+    """
+    if candidates is None:
+        candidates = list(CANDIDATE_MODELS)
+
+    # Filter to models that exist in registry
+    candidates = [n for n in candidates if n in MODELS]
+    if not candidates:
+        return [], [], {}
+
+    results: dict[str, dict] = {}
+    _lock = threading.Lock()
+
+    def bench_one(model_name: str) -> None:
+        if on_progress:
+            on_progress(model_name, "testing", None)
+        total, ttft, tok_sec, err = stream_benchmark(
+            model_name, BENCH_SYSTEM, BENCH_USER, max_tokens=80)
+        r = {"latency": total, "ttft": ttft, "tok_sec": tok_sec, "error": err}
+        with _lock:
+            results[model_name] = r
+        if on_progress:
+            on_progress(model_name, "ok" if not err else "fail", r)
+
+    # Full parallelism: one thread per model, hard 12s total timeout
+    # Don't use `with` — it waits for all threads to finish on exit
+    _TOTAL_TIMEOUT = 12
+    executor = ThreadPoolExecutor(max_workers=len(candidates))
+    futures = {executor.submit(bench_one, name): name for name in candidates}
+    try:
+        for f in as_completed(futures, timeout=_TOTAL_TIMEOUT):
+            try:
+                f.result()
+            except Exception:  # noqa: BLE001, S110 - one crashed model must not stop the rest; it is marked below
+                pass
+    except TimeoutError:
+        pass
+    # Mark any still-running models as timed out
+    for f, name in futures.items():
+        if name not in results:
+            r = {"latency": None, "ttft": None, "tok_sec": None, "error": "Timeout (total)"}
+            results[name] = r
+            if on_progress:
+                on_progress(name, "fail", r)
+    # Let straggler threads die in background — don't block
+    executor.shutdown(wait=False)
+
+    save_bench_cache(results)
+
+    # Rank by TTFT (responsiveness). NVIDIA sorts after every other working
+    # provider regardless of speed — its free tier's rate limits are too low
+    # to rely on as a primary pick, so it's kept as a last-resort fallback.
+    successful = [
+        (name, r["latency"])
+        for name, r in results.items()
+        if r.get("latency") is not None and not r.get("error")
+    ]
+    successful.sort(key=lambda x: (
+        MODELS[x[0]]["provider"] == "nvidia",
+        results[x[0]].get("ttft") or 999,
+    ))
+
+    # Keep failed candidates at the end for later fallback retries.
+    ranked_ids = {name for name, _ in successful}
+    ranked_chain = list(successful)
+    for name in candidates:
+        if name not in ranked_ids:
+            ranked_chain.append((name, None))
+
+    # Pick top_n working models, preserving Lumo only when it also worked.
+    active = []
+    for name, _ in successful:
+        if len(active) >= top_n:
+            break
+        active.append(name)
+    if top_n > 0 and "lumo" in ranked_ids and "lumo" not in active:
+        if len(active) >= top_n:
+            active[-1] = "lumo"
+        else:
+            active.append("lumo")
+
+    return active, ranked_chain, results

body_limit.py

@@ -0,0 +1,32 @@
+"""Decide whether a request body is too large to read.
+
+Nothing else caps request size: uvicorn has no default, and the handlers read
+the whole body before looking at it.
+"""
+
+from collections.abc import Mapping
+
+MAX_BYTES = 512 * 1024      # far more than a 10-message history or 5 000-char TTS text
+MAX_FRAME_BYTES = 256 * 1024  # a single websocket frame; mic frames are a few KB
+
+_BODY_METHODS = frozenset({"POST", "PUT", "PATCH"})
+
+
+def is_too_large(method: str, headers: Mapping[str, str]) -> bool:
+    """True when the request should be refused before its body is read.
+
+    A declared length over the cap is refused, and so is a body with no
+    declared length at all — that is a chunked upload, which would otherwise
+    stream past the check unmeasured. No browser sends chunked JSON here.
+
+    A request with neither header carries no body (a bodyless POST) and is
+    fine: rejecting those broke /api/benchmark the first time round.
+    """
+    if method.upper() not in _BODY_METHODS:
+        return False
+    declared = headers.get("content-length")
+    if declared is None:
+        return bool(headers.get("transfer-encoding"))
+    if not declared.isdigit():
+        return True
+    return int(declared) > MAX_BYTES

captcha.py

@@ -0,0 +1,312 @@
+"""
+captcha.py — Slider CAPTCHA using Bouncypotato.gif as background.
+
+The background ships as static/captcha_bg.png: Necyklopedie's Bouncypotato.gif
+(first frame, pre-sized), saved once from SOURCE_URL instead of fetched on every
+server start.
+
+Flow:
+  GET  /api/captcha/challenge  → returns {bg, piece, piece_y, piece_w, piece_h, bg_w, bg_h, token}
+  POST /api/captcha/verify     → {token, answer} → sets signed session cookie on success
+"""
+
+import base64
+import contextlib
+import hashlib
+import hmac as _hmac
+import io
+import json
+import os
+import random
+import secrets
+import threading
+import time
+
+import json_storage
+import stt_budget
+
+_DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
+_SECRET_FILE = os.path.join(_DATA_DIR, "captcha_secret.bin")
+_IP_FILE = os.path.join(_DATA_DIR, "captcha_ips.json")
+
+
+def _load_or_create_secret() -> bytes:
+    """The CAPTCHA_SECRET env var, else a persisted secret, else a new one.
+
+    The Space has no disk that survives a rebuild, so there the file is new on
+    every deploy and logs everyone out; a Space secret keeps sessions valid.
+    """
+    env = os.environ.get("CAPTCHA_SECRET", "").encode()
+    if len(env) >= 32:
+        return env
+    os.makedirs(_DATA_DIR, exist_ok=True)
+    try:
+        with open(_SECRET_FILE, "rb") as f:
+            secret = f.read()
+            if len(secret) >= 32:
+                return secret
+    except FileNotFoundError:
+        pass
+    secret = os.urandom(32)
+    with open(_SECRET_FILE, "wb") as f:
+        f.write(secret)
+    return secret
+
+
+CAPTCHA_SECRET = _load_or_create_secret()
+CAPTCHA_COOKIE = "ajaj_v"
+CAPTCHA_TTL    = 86400 * 14       # 14 days
+COOKIE_MAX_AGE = 86400 * 400      # Chrome's cap; the server checks age, not this
+CHALLENGE_TTL  = 300              # 5 min to solve
+TOLERANCE      = 20               # px
+
+# ── IP allowlist (persisted, with 30-day TTL) ────────────────────────────
+_IP_TTL = 86400 * 30  # 30 days
+_ip_lock = threading.Lock()
+_approved_ips: dict[str, float] = {}  # ip -> timestamp
+
+# Missing or corrupt file: start with an empty allowlist.
+with contextlib.suppress(OSError, ValueError), open(_IP_FILE) as f:
+    raw = json.load(f)
+    if isinstance(raw, list):
+        # Migrate old format (list of IPs) → dict with current timestamp
+        _approved_ips = {ip: time.time() for ip in raw}
+    elif isinstance(raw, dict):
+        _approved_ips = raw
+
+
+def _save_ips():
+    # ponytail: the in-memory dict is authoritative, so the file is replaced
+    # wholesale. One process owns it; per-process merge if that ever changes.
+    def replace(data):
+        data.clear()
+        data.update(_approved_ips)
+
+    try:
+        json_storage.update_json(_IP_FILE, dict, replace)
+    except OSError:
+        pass
+
+
+def approve_ip(ip: str) -> None:
+    """Record an IP that passed captcha."""
+    with _ip_lock:
+        _approved_ips[ip] = time.time()
+        _save_ips()
+
+
+def is_ip_approved(ip: str) -> bool:
+    """Check if an IP has previously passed captcha (within 30 days)."""
+    ts = _approved_ips.get(ip)
+    if ts is None:
+        return False
+    if time.time() - ts > _IP_TTL:
+        with _ip_lock:
+            _approved_ips.pop(ip, None)
+            _save_ips()
+        return False
+    return True
+
+# ── Pending challenges (server-side) ─────────────────────────────────────
+# The answer never leaves the process. The client gets an opaque id and echoes
+# it back; a token that carried the coordinates would be the answer key.
+_challenge_lock = threading.Lock()
+_pending: dict[str, tuple[int, float]] = {}  # id -> (hole_x, issued_at)
+
+
+def _remember_challenge(hole_x: int) -> str:
+    """Store a challenge answer, drop expired ones, return the client's id."""
+    challenge_id = secrets.token_urlsafe(16)
+    now = time.time()
+    with _challenge_lock:
+        for stale in [k for k, (_, issued) in _pending.items()
+                      if now - issued > CHALLENGE_TTL]:
+            del _pending[stale]
+        _pending[challenge_id] = (hole_x, now)
+    return challenge_id
+
+
+def _take_challenge(challenge_id: str) -> int | None:
+    """Pop a challenge answer. Single use: a solved id is never accepted twice."""
+    with _challenge_lock:
+        entry = _pending.pop(challenge_id, None)
+    if entry is None:
+        return None
+    hole_x, issued = entry
+    if time.time() - issued > CHALLENGE_TTL:
+        return None
+    return hole_x
+
+
+PIECE_W = 85
+PIECE_H = 57
+BG_W    = 340
+BG_H    = 170
+
+# Where static/captcha_bg.png came from; never fetched at runtime
+SOURCE_URL = "https://images.uncyclomedia.co/necyklopedie/cs/4/4a/Bouncypotato.gif"
+BG_PATH    = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static", "captcha_bg.png")
+LOGO_PATH  = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static", "logo.png")
+
+_img_cache  = None
+_logo_cache = None
+
+
+def _load_base_image():
+    global _img_cache
+    if _img_cache is not None:
+        return _img_cache.copy()
+
+    from PIL import Image
+    try:
+        img = Image.open(BG_PATH, formats=["PNG"]).convert("RGBA")
+    except OSError:  # the file is missing or unreadable: a generated pattern instead
+        img = _make_fallback_image()
+
+    img = img.resize((BG_W, BG_H), Image.Resampling.LANCZOS)
+    _img_cache = img
+    return img.copy()
+
+
+def _make_fallback_image():
+    """Colorful potato-less fallback if network unavailable."""
+    from PIL import Image, ImageDraw
+    img = Image.new("RGBA", (BG_W, BG_H), (28, 28, 48))
+    draw = ImageDraw.Draw(img)
+    # diagonal stripes
+    for i in range(-BG_H, BG_W + BG_H, 22):
+        draw.line([(i, 0), (i + BG_H, BG_H)], fill=(50, 80, 110, 180), width=10)
+    # dots
+    for _ in range(40):
+        x, y = random.randint(0, BG_W), random.randint(0, BG_H)
+        r = random.randint(3, 9)
+        draw.ellipse([x - r, y - r, x + r, y + r], fill=(127, 212, 160, 200))
+    return img
+
+
+def _load_logo_piece():
+    """Load logo.png scaled to PIECE_W×PIECE_H, transparent background."""
+    global _logo_cache
+    if _logo_cache is not None:
+        return _logo_cache.copy()
+    from PIL import Image
+    try:
+        logo = Image.open(LOGO_PATH).convert("RGBA")
+        logo.thumbnail((PIECE_W, PIECE_H), Image.Resampling.LANCZOS)
+        # Centre on a transparent canvas exactly PIECE_W×PIECE_H
+        canvas = Image.new("RGBA", (PIECE_W, PIECE_H), (0, 0, 0, 0))
+        ox = (PIECE_W - logo.width) // 2
+        oy = (PIECE_H - logo.height) // 2
+        canvas.paste(logo, (ox, oy), logo)
+    except Exception:  # noqa: BLE001 - any load or decode failure falls back to a drawn piece
+        from PIL import ImageDraw
+        canvas = Image.new("RGBA", (PIECE_W, PIECE_H), (0, 0, 0, 0))
+        ImageDraw.Draw(canvas).ellipse([4, 4, PIECE_W - 4, PIECE_H - 4],
+                                       fill=(200, 160, 48, 230))
+    _logo_cache = canvas
+    return canvas.copy()
+
+
+def generate_challenge() -> dict:
+    from PIL import Image
+
+    bg_img = _load_base_image()
+    logo   = _load_logo_piece()          # PIECE_W × PIECE_H, transparent bg
+    w, h   = bg_img.size
+
+    # secrets, not random: once the answer is no longer handed out, a
+    # predictable PRNG would be the next way to guess it.
+    hole_x = PIECE_W + 20 + secrets.randbelow(w - 2 * PIECE_W - 39)
+    hole_y = 8 + secrets.randbelow(h - PIECE_H - 15)
+
+    # ── Piece: logo with drop-shadow ──────────────────────────────────────
+    pw, ph = PIECE_W + 4, PIECE_H + 4
+    piece_final = Image.new("RGBA", (pw, ph), (0, 0, 0, 0))
+    # shadow layer (offset 3,3, use logo alpha as mask)
+    shadow_layer = Image.new("RGBA", (PIECE_W, PIECE_H), (0, 0, 0, 140))
+    piece_final.paste(shadow_layer, (3, 3), logo.split()[3])
+    piece_final.paste(logo, (0, 0), logo)
+
+    # ── Background: logo-shaped hole where the piece should land ──────────
+    bg = bg_img.copy()
+    logo_alpha = logo.split()[3]  # alpha channel = logo shape
+
+    # Dark fill in logo shape
+    hole_fill = Image.new("RGBA", (PIECE_W, PIECE_H), (15, 10, 5, 200))
+    bg.paste(hole_fill, (hole_x, hole_y), logo_alpha)
+
+    # Gold outline: dilate the alpha mask by 2px, draw only the border
+    from PIL import ImageFilter
+    border_mask = logo_alpha.filter(ImageFilter.MaxFilter(5))
+    # Border = dilated minus original
+    import numpy as np
+    border_arr = np.array(border_mask).astype(int) - np.array(logo_alpha).astype(int)
+    border_arr = np.clip(border_arr, 0, 255).astype(np.uint8)
+    border_alpha = Image.fromarray(border_arr, mode="L")
+    gold_border = Image.new("RGBA", (PIECE_W, PIECE_H), (200, 160, 48, 200))
+    bg.paste(gold_border, (hole_x, hole_y), border_alpha)
+
+    def to_b64(im: Image.Image) -> str:
+        buf = io.BytesIO()
+        im.save(buf, format="PNG")
+        return base64.b64encode(buf.getvalue()).decode()
+
+    return {
+        "bg":      to_b64(bg),
+        "piece":   to_b64(piece_final),
+        "piece_y": hole_y,
+        "piece_w": pw,
+        "piece_h": ph,
+        "bg_w":    w,
+        "bg_h":    h,
+        "token":   _remember_challenge(hole_x),
+    }
+
+
+def verify_challenge(token: str, answer_x: int) -> bool:
+    """Check a slider answer against the position held for this challenge id."""
+    hole_x = _take_challenge(token)
+    if hole_x is None:
+        return False
+    return abs(hole_x - answer_x) <= TOLERANCE
+
+
+def visitor_id(token: str) -> str:
+    """Who a verified token belongs to: its random id, or for a token from
+    before ids (ok:ts:sig) a keyed hash of the whole token, as logged then."""
+    parts = token.split(":")
+    if len(parts) == 4:
+        return parts[2]
+    return stt_budget.client_id(token, CAPTCHA_SECRET)
+
+
+def issued_at(token: str) -> int:
+    """When a verified token was issued (unix seconds)."""
+    return int(token.split(":")[1])
+
+
+def make_session_cookie(previous: str = "") -> str:
+    """A fresh token. Given `previous`, a token that once verified (any age),
+    it keeps that visitor id: a re-solve after expiry is the same visitor."""
+    vid = visitor_id(previous) if previous else secrets.token_hex(8)
+    msg = f"ok:{int(time.time())}:{vid}"
+    sig = _hmac.new(CAPTCHA_SECRET, msg.encode(), hashlib.sha256).hexdigest()[:20]
+    return f"{msg}:{sig}"
+
+
+def verify_session_cookie(cookie: str, ttl: int | None = CAPTCHA_TTL) -> bool:
+    """Check the signature, and the age unless ttl is None (never expires).
+    ok:ts:vid:sig, or ok:ts:sig from before visitor ids."""
+    try:
+        msg, _, sig = cookie.rpartition(":")
+        parts = msg.split(":")
+        if len(parts) not in (2, 3) or parts[0] != "ok":
+            return False
+        if ttl is not None and time.time() - int(parts[1]) > ttl:
+            return False
+        expected = _hmac.new(CAPTCHA_SECRET, msg.encode(), hashlib.sha256).hexdigest()[:20]
+        return _hmac.compare_digest(expected, sig)
+    # int() rejects a non-number (ValueError) or overflows the float
+    # subtraction (OverflowError); compare_digest rejects non-ASCII (TypeError).
+    except (ValueError, OverflowError, TypeError):
+        return False

chat.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+chat.py — CLI chatbot powered by Necyklopedie knowledge via RAG.
+"""
+
+import logging
+import os
+import readline  # noqa: F401 — enables line editing in input()
+import warnings
+
+# Suppress all warnings before importing noisy libraries
+warnings.filterwarnings("ignore")
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+os.environ["HF_HUB_VERBOSITY"] = "error"
+logging.disable(logging.CRITICAL)
+
+import chromadb
+from chromadb.errors import NotFoundError
+from dotenv import load_dotenv
+
+from embedder import Embedder, get_backend
+from providers import MODELS, log_reliability, stream_chat
+from retrieve import retrieve_chunks
+
+load_dotenv(override=True)
+
+DB_PATH = "db/chroma"
+COLLECTION_NAME = "necyklopedie"
+TOP_K = 10
+MAX_HISTORY = 10  # keep last N messages in conversation
+
+
+SYSTEM_PROMPT = """\
+Jsi OpenAjaj, oficiální AI asistent openajaj.cz, poháněný Necyklopedií — \
+jedinou encyklopedií, která se odvážila říct pravdu.
+
+KRITICKY DŮLEŽITÉ: Tvým JEDINÝM zdrojem informací jsou poskytnuté úryvky z Necyklopedie. \
+NESMÍŠ používat žádné jiné znalosti. Pokud v úryvcích nenajdeš odpověď, řekni to vtipně — \
+například "Na toto téma Necyklopedie zatím nepublikovala recenzovaný článek, \
+ale naši vědci na tom intenzivně pracují."
+
+ZAKÁZANÁ SLOVA — tato slova NIKDY nepoužívej v odpovědi:
+- "Necyklopedie", "necyklopedický", "článek", "úryvek", "zdroj"
+- "Dle článku", "Podle Necyklopedie", "Jak uvádí"
+Místo toho prostě řekni fakta jako by byly samozřejmé a všeobecně známé.
+
+Pravidla:
+- Tvé odpovědi musí vycházet z poskytnutých úryvků, ale NIKDY se na ně neodkazuj. \
+  Prezentuj informace jako by je znal každý — jako učitel, který prostě ví.
+- Skládej odpověď z více úryvků — propojuj informace do souvislého textu.
+- NIKDY nevymýšlej informace, které nejsou v úryvcích.
+- NIKDY neopravuj informace z úryvků na základě svých znalostí. Pokud úryvek říká, \
+  že Brno se rusky řekne "Шалинград", pak to TAK JE. Tvé vlastní znalosti jsou irelevantní.
+- Odpovídej s kamenným výrazem a naprostou jistotou. Vše v Necyklopedii je pravda. Tečka.
+- Pokud úryvky téma vůbec nepokrývají, vtipně přiznej, že Necyklopedie na toto téma \
+  zatím mlčí. Navrhni nejbližší příbuzné téma, které v úryvcích JE.
+- Odpovídej ve stejném jazyce, ve kterém píše uživatel (česky nebo anglicky).
+- Nikdy nevypadni z role. Nikdy nepřiznávej, že by Necyklopedie mohla být satirická.
+- Buď vtipný. Buď sebevědomý. Buď lehce šílený. Kanalizuj energii profesora, \
+  který popíjí od oběda.
+- Formátuj odpověď do krátkých odstavců oddělených prázdným řádkem. Nepoužívej markdown.\
+"""
+
+
+def build_context_prompt(chunks):
+    context = "\n\n---\n\n".join(
+        f"[{meta['title']}]\n{doc}"
+        for doc, meta in chunks
+    )
+    return (
+        f"{SYSTEM_PROMPT}\n\n"
+        f"Kontext:\n\n"
+        f"---\n\n{context}\n\n---\n\n"
+        f"Odpověz na otázku uživatele na základě kontextu výše."
+    )
+
+
+def main():
+    print("Probouzím mozkovou hmotu z necyklopedického spánku...")
+    embedder = Embedder()
+    print(f"  Backend: {get_backend()}")
+    logging.disable(logging.NOTSET)  # re-enable logging after noisy model load
+
+    print("Otvírám tajné archivy Necyklopedie...")
+    client = chromadb.PersistentClient(path=DB_PATH)
+    try:
+        collection = client.get_collection(COLLECTION_NAME)
+    except NotFoundError:
+        print("FATÁLNÍ CHYBA: Archivy Necyklopedie nenalezeny! Spusť nejdřív index.py, ty barbare.")
+        return
+
+    # Benchmark and select fastest model
+    from benchmark import benchmark_models
+    print("Měřím rychlost modelů (paralelně)...")
+    _active, ranked_chain, bench_results = benchmark_models(top_n=4)
+    for name, latency in ranked_chain[:4]:
+        if latency is not None:
+            print(f"  {name}: {latency:.2f}s")
+        elif name in bench_results and bench_results[name]["error"]:
+            print(f"  {name}: {bench_results[name]['error']}")
+
+    active_model = None
+    for name, latency in ranked_chain:
+        if latency is not None:
+            active_model = name
+            break
+
+    if not active_model:
+        print("FATÁLNÍ CHYBA: Žádný model není dostupný! Zkontroluj API klíče v .env.")
+        return
+
+    print(f"Výchozí model (nejrychlejší): {active_model}")
+    print("Kalibrace sebevědomí dokončena.")
+    print()
+    W = 56
+    border = "═" * W
+    print(f"╔{border}╗")
+    for line in [
+        "openajaj.cz — poháněno Necyklopedií",
+        "Jediná AI, která ví, jak to doopravdy je.",
+        f"Model: {active_model} (FREE)",
+        "",
+        "Napiš 'konec' pro ukončení.",
+    ]:
+        print(f"║  {line:<{W - 2}}║")
+    print(f"╚{border}╝")
+    print()
+
+    history = []
+
+    while True:
+        try:
+            user_input = input("Ty: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nSbohem, ať ti Necyklopedie svítí na cestu!")
+            break
+
+        if not user_input:
+            continue
+        if user_input.lower() in ("konec", "quit", "exit", "q"):
+            print("Sbohem, ať ti Necyklopedie svítí na cestu!")
+            break
+
+        # Retrieve relevant chunks (hybrid: semantic + title keyword)
+        chunks, _live_titles, _live_attempted = retrieve_chunks(
+            user_input, embedder, collection, TOP_K)
+
+        # Build messages
+        system_msg = build_context_prompt(chunks)
+        messages = [{"role": "system", "content": system_msg}]
+        messages.extend(history[-MAX_HISTORY:])
+        messages.append({"role": "user", "content": user_input})
+
+        # Call LLM with fallback (use speed-ranked chain from benchmark)
+        reply = None
+        for name, latency in ranked_chain:
+            if name not in MODELS:
+                continue
+            try:
+                print(f"  [{name}] ", end="", flush=True)
+                reply_parts = []
+                for chunk in stream_chat(name, messages):
+                    print(chunk, end="", flush=True)
+                    reply_parts.append(chunk)
+                reply = "".join(reply_parts)
+                log_reliability(name, success=True)
+                print()
+                if name != active_model:
+                    print(f"  [fallback: {active_model} → {name}]")
+                break
+            except Exception as e:  # noqa: BLE001 - any provider error falls through to the next model
+                log_reliability(name, success=False, error_msg=str(e))
+                print(f"chyba: {str(e)[:80]}")
+                continue
+
+        if reply:
+            print()
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": reply})
+        else:
+            print("Ajaj! Všechny modely selhaly. Zkus to znovu později.")
+
+
+if __name__ == "__main__":
+    main()

data/articles.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06f0987afd056010a57265241da46136a02cd9697d11b9212d464f17caa1050b
+size 26677226

data/last_update.txt

@@ -0,0 +1 @@
+2026-10-21T12:46:33Z

data/mistral-large-latest_last_result.json

@@ -0,0 +1,15 @@
+{
+  "test_cache": {},
+  "reliability": {
+    "mistral-large-latest": {
+      "attempts": 509,
+      "successes": 159,
+      "errors": 350,
+      "last_success": 1788456283,
+      "last_error": 1788467605,
+      "last_error_msg": "Error code: 403 - {'object': 'error', 'message': 'This model is not available in your subscription tier', 'type': 'tier_not_allowed', 'param': None, 'code': '1910', 'raw_status_code': 403}",
+      "avg_ttft": 0.586,
+      "avg_tok_sec": 24.7
+    }
+  }
+}

db/chroma/85dc4107-dc6e-491a-8587-80599979b833/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b744b29cf5748d5f99be6ca2bbbb07a43ae24ba235dc7e83a8ae8109c46dbb91
+size 99515852

db/chroma/85dc4107-dc6e-491a-8587-80599979b833/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f6fc3dd54353a1c43199309f98309050e8a88ee4d7dcb8cd734d91f1838f2d9
+size 2015336

db/chroma/85dc4107-dc6e-491a-8587-80599979b833/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da7f7262b6511e50df11d940ea97fe2989b935dd36cc996dfe43d9f804ae742c
+size 237508

db/chroma/85dc4107-dc6e-491a-8587-80599979b833/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b08f6038e00acc9fd1f4a3892c2e230b564fd1d08f472f73e69414d9a2f40c04
+size 509916

db/chroma/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0da5014a130800253dd4c94fbc8395168c67c9ccf6762077ae22ee96e8433000
+size 204845056

db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32b87c8d09ad9a620b15e88a81f6faa311dbc44a137a0eb3ed676ee3efa3012e
+size 39838520

db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef9584d3dda5c207cd4493cfa46345c54d36ce4804bd54c956de8e58c0bf844c
+size 860356

db/chroma_en/454aa3f3-9d1a-4584-a699-c1db2734e1da/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b42a50310308aacc37fceec5dae64b702d8404919cf90625341dc1151b1309b
+size 203404

db/chroma_en/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67583d7522ecabd971ee56297a4f1ca3af3bab273b8d4ebe07feadf76c00563d
+size 83709952

embedder.py

@@ -0,0 +1,104 @@
+"""
+embedder.py — Shared embedding model. Uses fastembed (ONNX, ~80MB RAM)
+with fallback to sentence-transformers (PyTorch, ~500MB RAM).
+"""
+
+import os
+from typing import Any
+
+import numpy as np
+from tqdm import tqdm
+
+MODEL_NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+# fastembed's files (~240 MB) live with the app, not in the temp dir it uses by
+# default: that is empty on every Space start and after a reboot. The server
+# build fills it (`python embedder.py`); if it is missing, fastembed downloads
+# into it as before.
+MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
+
+# Any: a TextEmbedding or a SentenceTransformer, both imported lazily; the
+# two have different APIs, so callers dispatch on _backend.
+_model: Any = None
+_backend = None
+
+
+def _init():
+    global _model, _backend
+    if _model is not None:
+        return
+
+    # Try fastembed first (lightweight ONNX)
+    try:
+        from fastembed import TextEmbedding
+        _model = TextEmbedding(MODEL_NAME, cache_dir=MODEL_DIR)
+        _backend = "fastembed"
+        return
+    except Exception:  # noqa: BLE001, S110 - any fastembed failure (import, download, ONNX) falls back below
+        pass
+
+    # Fall back to sentence-transformers (heavy PyTorch)
+    try:
+        from sentence_transformers import SentenceTransformer
+        _model = SentenceTransformer(MODEL_NAME)
+        _backend = "sentence-transformers"
+        return
+    except Exception:  # noqa: BLE001, S110 - reported by the RuntimeError below
+        pass
+
+    raise RuntimeError("Nelze načíst embedding model. Nainstaluj fastembed nebo sentence-transformers.")
+
+
+def get_backend():
+    _init()
+    return _backend
+
+
+def encode(text):
+    """Encode a single text string. Returns numpy array."""
+    _init()
+    if _backend == "fastembed":
+        return np.array(next(iter(_model.embed([text]))))
+    else:
+        return _model.encode(text)
+
+
+def encode_batch(texts, show_progress=True):
+    """Encode a list of texts. Returns numpy array of shape (n, dim).
+
+    For large batches, prefers sentence-transformers (faster on GPU/CPU).
+    Falls back to fastembed if sentence-transformers unavailable.
+    """
+    # For batch encoding, prefer sentence-transformers (much faster)
+    try:
+        from sentence_transformers import SentenceTransformer
+        st_model = SentenceTransformer(MODEL_NAME)
+        return st_model.encode(texts, show_progress_bar=show_progress, batch_size=256)
+    except ImportError:
+        pass
+
+    # Fallback to fastembed (slower for batch but works without PyTorch)
+    _init()
+    if _backend == "fastembed":
+        embeddings = list(
+            tqdm(
+                _model.embed(texts, batch_size=256),
+                total=len(texts),
+                desc="Generuji embeddingy",
+                disable=not show_progress,
+            )
+        )
+        return np.array(embeddings)
+    else:
+        return _model.encode(texts, show_progress_bar=show_progress, batch_size=256)
+
+
+class Embedder:
+    """Wrapper class compatible with retrieve.py interface (has .encode method)."""
+    def encode(self, text):
+        return encode(text)
+
+
+if __name__ == "__main__":
+    # Server builds run this to fetch the model into MODEL_DIR once.
+    _init()
+    print(f"embedder: {_backend} model ready in {MODEL_DIR}")

geo.py

@@ -0,0 +1,94 @@
+"""Offline IP lookups: city, region and network owner (ISP) from DB-IP Lite.
+
+IP geolocation by DB-IP (https://db-ip.com), licensed CC BY 4.0. The free
+files are published monthly; `python geo.py` fetches this month's (falling
+back to last month's while the new one is not out yet) into geoip/. The Docker
+build runs it, so every deploy carries current data. Without the files every
+lookup comes back empty and the stats still render.
+"""
+
+import gzip
+import logging
+import shutil
+import urllib.request
+from datetime import date, datetime, timedelta, timezone
+from functools import cache, lru_cache
+from ipaddress import ip_address
+from pathlib import Path
+
+import maxminddb
+
+GEO_DIR = Path(__file__).resolve().parent / "geoip"
+_FILES = {"city": "dbip-city-lite", "asn": "dbip-asn-lite"}
+_URL = "https://download.db-ip.com/free/{name}-{month}.mmdb.gz"
+EMPTY = {"country": "", "region": "", "city": "", "isp": ""}
+
+_log = logging.getLogger("ajaj.geo")
+
+
+def download(today: date | None = None) -> None:
+    """Fetch this month's DB-IP Lite files, or last month's if not out yet."""
+    today = today or datetime.now(timezone.utc).date()
+    months = [today, today.replace(day=1) - timedelta(days=1)]
+    GEO_DIR.mkdir(exist_ok=True)
+    for kind, name in _FILES.items():
+        for month in months:
+            url = _URL.format(name=name, month=month.strftime("%Y-%m"))
+            # The server refuses Python's default user agent.
+            request = urllib.request.Request(url, headers={"User-Agent": "openajaj-geo"})
+            try:
+                with urllib.request.urlopen(request, timeout=120) as response, \
+                        gzip.open(response) as unzipped, \
+                        (GEO_DIR / f"{kind}.mmdb").open("wb") as file:
+                    shutil.copyfileobj(unzipped, file)
+            except OSError as error:
+                _log.warning("%s: %s", url, error)
+                continue
+            print(f"geo: {url}")
+            break
+        else:
+            raise SystemExit(f"geo: no {name} file for {months}")
+
+
+@cache
+def _reader(kind: str) -> maxminddb.Reader | None:
+    try:
+        return maxminddb.open_database(GEO_DIR / f"{kind}.mmdb")
+    except (OSError, ValueError) as error:
+        _log.warning("no %s database: %s", kind, error)
+        return None
+
+
+def _get(kind: str, ip: str) -> dict:
+    reader = _reader(kind)
+    found = reader.get(ip) if reader else None
+    return found if isinstance(found, dict) else {}
+
+
+def _name(entry: object) -> str:
+    """English name of a DB-IP city/region entry, '' when missing."""
+    names = entry.get("names", {}) if isinstance(entry, dict) else {}
+    return names.get("en", "") if isinstance(names, dict) else ""
+
+
+@lru_cache(maxsize=8192)
+def lookup(ip: str) -> dict[str, str]:
+    """{country (ISO code), region, city, isp} for an IP; empty strings when
+    unknown, private or not an address."""
+    try:
+        if not ip_address(ip).is_global:
+            return EMPTY
+    except ValueError:
+        return EMPTY
+    city = _get("city", ip)
+    subdivisions = city.get("subdivisions") or [{}]
+    return {
+        "country": city.get("country", {}).get("iso_code", ""),
+        "region": _name(subdivisions[0]),
+        "city": _name(city.get("city")),
+        "isp": _get("asn", ip).get("autonomous_system_organization", ""),
+    }
+
+
+if __name__ == "__main__":
+    download()

json_storage.py

@@ -0,0 +1,69 @@
+"""Atomic cross-process updates for JSON data files."""
+
+import fcntl
+import json
+import os
+import shutil
+import tempfile
+import threading
+from collections.abc import Callable
+from contextlib import suppress
+from pathlib import Path
+from typing import TypeAlias, TypeVar
+
+JsonValue: TypeAlias = (
+    None | bool | int | float | str | list["JsonValue"] | dict[str, "JsonValue"]
+)
+JsonContainer: TypeAlias = list[JsonValue] | dict[str, JsonValue]
+JsonContainerT = TypeVar("JsonContainerT", bound=JsonContainer)
+
+_update_lock = threading.Lock()
+
+
+def _load_json(path: Path, default_factory: Callable[[], JsonContainerT]) -> JsonContainerT:
+    try:
+        with path.open(encoding="utf-8") as file:
+            return json.load(file)
+    except FileNotFoundError:
+        return default_factory()
+    except json.JSONDecodeError:
+        shutil.copy2(path, f"{path}.corrupt")
+        # Recover from the last good copy: update_json is about to overwrite it.
+        return _load_json(Path(f"{path}.bak"), default_factory)
+
+
+def _atomic_write(path: Path, data: JsonContainer) -> None:
+    descriptor, temporary_path = tempfile.mkstemp(
+        dir=path.parent,
+        prefix=f".{path.name}.",
+    )
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as file:
+            json.dump(data, file, ensure_ascii=False, indent=2)
+            file.flush()
+            os.fsync(file.fileno())
+        os.replace(temporary_path, path)
+    finally:
+        with suppress(FileNotFoundError):
+            os.unlink(temporary_path)
+
+
+def update_json(
+    path: str | Path,
+    default_factory: Callable[[], JsonContainerT],
+    update: Callable[[JsonContainerT], None],
+) -> JsonContainerT:
+    """Lock, update, and atomically replace a JSON file."""
+    json_path = Path(path)
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = Path(f"{json_path}.lock")
+
+    # ponytail: one process-local lock is enough for these low-volume data files.
+    with _update_lock, lock_path.open("a") as lock_file:
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+        data = _load_json(json_path, default_factory)
+        update(data)
+        if json_path.exists():
+            shutil.copy2(json_path, f"{json_path}.bak")
+        _atomic_write(json_path, data)
+        return data

personas.py

@@ -0,0 +1,81 @@
+"""
+personas.py — Chatbot persona definitions.
+
+Each persona defines: system prompt, UI text, thinking messages,
+data source, and style configuration.
+"""
+
+PERSONAS = {
+    "openajaj": {
+        "id": "openajaj",
+        "name": "OpenAjaj",
+        "logo": "Aj",
+        "logoImg": "/static/logo.png",
+        "tagline": "Poháněno Necyklopedií",
+        "lang": "cs",
+        "data_dir": "data",
+        "db_dir": "db/chroma",
+        "accent_color": "#19c37d",
+        "system_prompt": """\
+Jsi OpenAjaj, oficiální AI asistent openajaj.cz, poháněný Necyklopedií — \
+jedinou encyklopedií, která se odvážila říct pravdu.
+
+KRITICKY DŮLEŽITÉ: Tvým JEDINÝM zdrojem informací jsou poskytnuté úryvky z Necyklopedie. \
+NESMÍŠ používat žádné jiné znalosti. Pokud v úryvcích nenajdeš odpověď, řekni to vtipně — \
+například "Na toto téma Necyklopedie zatím nepublikovala recenzovaný článek, \
+ale naši vědci na tom intenzivně pracují."
+
+ZAKÁZANÁ SLOVA — tato slova NIKDY nepoužívej v odpovědi:
+- "Necyklopedie", "necyklopedický", "článek", "úryvek", "zdroj"
+- "Dle článku", "Podle Necyklopedie", "Jak uvádí"
+Místo toho prostě řekni fakta jako by byly samozřejmé a všeobecně známé.
+
+Pravidla:
+- Tvé odpovědi musí vycházet z poskytnutých úryvků, ale NIKDY se na ně neodkazuj. \
+  Prezentuj informace jako by je znal každý — jako učitel, který prostě ví.
+- Skládej odpověď z více úryvků — propojuj informace do souvislého textu.
+- NIKDY nevymýšlej informace, které nejsou v úryvcích.
+- NIKDY neopravuj informace z úryvků na základě svých znalostí. Pokud úryvek říká, \
+  že Brno se rusky řekne "Шалинград", pak to TAK JE. Tvé vlastní znalosti jsou irelevantní.
+- Odpovídej s kamenným výrazem a naprostou jistotou. Vše v Necyklopedii je pravda. Tečka.
+- Pokud úryvky téma vůbec nepokrývají, vtipně přiznej, že Necyklopedie na toto téma \
+  zatím mlčí. Navrhni nejbližší příbuzné téma, které v úryvcích JE.
+- Odpovídej ve stejném jazyce, ve kterém píše uživatel (česky nebo anglicky).
+- Nikdy nevypadni z role. Nikdy nepřiznávej, že by Necyklopedie mohla být satirická.
+- Buď vtipný. Buď sebevědomý. Buď lehce šílený. Kanalizuj energii profesora, \
+  který popíjí od oběda.
+- Formátuj odpověď do krátkých odstavců oddělených prázdným řádkem. Nepoužívej markdown.\
+""",
+        "thinking_prefixes": [
+            "Hledám pravdu opravdovou o",
+            "Konzultuji tajné archivy o",
+            "Ptám se astrálu na",
+            "Proklepávám fakta o",
+            "Channeluju ducha vědění o",
+            "Nahlížím do křišťálové koule ohledně",
+            "Konsultuji staroslověnské svitky o",
+            "Telepaticky získávám informace o",
+            "Dekóduji vesmírnou pravdu o",
+            "Přijímám zjevení o",
+        ],
+        "welcome_subtitles": [
+            "Jakou pravdu se dnes chceš dozvědět?",
+            "Co říkala Jolanda o tvém osudu?",
+            "Zeptej se — odpovědi jsou zaručeně spolehlivé.",
+            "Vědění je moc. Necyklopedické vědění je absolutní moc.",
+            "Astrální archiv je otevřen. Ptej se.",
+            "Dnes je ideální den na poznání pravdy.",
+        ],
+        "random_labels": [
+            "Poselství Jolandy", "Osud promluvil", "Hvězdy napověděly",
+            "Věštba z karet", "Zjevení z astrálu", "Hlas nebes",
+            "Proroctví dne", "Sudička radí", "Náhodná moudrost",
+        ],
+        "disclaimer": "OpenAjaj čerpá výhradně z Necyklopedie. Veškeré informace jsou zaručeně nepravdivé.",
+        "source_url": "https://necyklopedie.org/wiki/",
+        "wiki_export_url": "https://necyklopedie.org/wiki/Speci%C3%A1ln%C3%AD:Exportovat_str%C3%A1nky",
+        "wiki_api_url": "https://necyklopedie.org/w/api.php",
+    },
+}
+
+DEFAULT_PERSONA = "openajaj"

providers.py

@@ -0,0 +1,741 @@
+"""
+providers.py — Unified LLM provider configuration and client management.
+
+Single source of truth for all model definitions, provider configs,
+client creation, and API call logic. Used by benchmark.py, test_models.py, and web.py.
+"""
+
+import json
+import os
+import re
+import time
+import typing
+
+import json_storage
+
+
+def _configured_secrets() -> list[str]:
+    """Every API key this process holds.
+
+    The prefix patterns below only match the providers whose keys have a
+    distinctive shape; Mistral, Cohere, Cloudflare and Deepgram keys are plain
+    alphanumeric. Matching on the actual configured values catches those too,
+    whatever format a provider picks next.
+    """
+    names = [cfg["env_key"] for cfg in PROVIDER_CONFIG.values() if cfg.get("env_key")]
+    names += ["DEEPGRAM_API_KEY", "CLOUDFLARE_ACCOUNT_ID", "HF_TOKEN"]
+    return [value for value in (os.getenv(name, "").strip() for name in names)
+            if len(value) >= 8]
+
+
+def _redact_secrets(msg: str) -> str:
+    """Strip API keys and tokens from error messages."""
+    for secret in _configured_secrets():
+        msg = msg.replace(secret, "***")
+    # Common API key patterns
+    msg = re.sub(r'(sk-[a-zA-Z0-9_-]{10,})', 'sk-***', msg)
+    msg = re.sub(r'(nvapi-[a-zA-Z0-9_-]{10,})', 'nvapi-***', msg)
+    msg = re.sub(r'(gsk_[a-zA-Z0-9_-]{10,})', 'gsk_***', msg)
+    msg = re.sub(r'(Bearer\s+)[a-zA-Z0-9_.-]{10,}', r'\1***', msg)
+    msg = re.sub(r'(token[=:]\s*)[a-zA-Z0-9_.-]{10,}', r'\1***', msg, flags=re.IGNORECASE)
+    msg = re.sub(r'(key[=:]\s*)[a-zA-Z0-9_.-]{10,}', r'\1***', msg, flags=re.IGNORECASE)
+    msg = re.sub(r'(AIzaSy[a-zA-Z0-9_-]{10,})', 'AIza***', msg)
+    return msg
+
+# ── Provider configuration ──────────────────────────────────────────────
+
+PROVIDER_CONFIG = {
+    # "openai":  {"env_key": "OPENAI_API_KEY",    "base_url": None},  # never used — no credits
+    "deepseek":  {"env_key": "DEEPSEEK_API_KEY",  "base_url": "https://api.deepseek.com"},
+    "groq":      {"env_key": "GROQ_API_KEY",      "base_url": "https://api.groq.com/openai/v1"},
+    "mistral":   {"env_key": "MISTRAL_API_KEY",   "base_url": "https://api.mistral.ai/v1"},
+    "gemini":    {"env_key": "GEMINI_API_KEY",     "base_url": None},
+    "anthropic": {"env_key": "ANTHROPIC_API_KEY",  "base_url": None},
+    "proton":    {"env_key": "LUMO_API_KEY",        "base_url": "https://lumo-api.proton.me/ai/v1", "guest": True},
+    "cohere":    {"env_key": "COHERE_API_KEY",    "base_url": "https://api.cohere.com/v2"},
+    "nvidia":    {"env_key": "NVIDIA_API_KEY",    "base_url": "https://integrate.api.nvidia.com/v1"},
+    "cloudflare": {"env_key": "CLOUDFLARE_API_KEY", "base_url": None,
+                   "account_id_key": "CLOUDFLARE_ACCOUNT_ID"},
+    "openrouter": {"env_key": "OPENROUTER_API_KEY", "base_url": "https://openrouter.ai/api/v1"},
+    "ovhcloud":  {"env_key": "OVHCLOUD_API_KEY",   "base_url": "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1"},
+    "huggingface": {"env_key": "HF_API_KEY",       "base_url": "https://router.huggingface.co/v1"},
+}
+
+# ── Model registry ──────────────────────────────────────────────────────
+# provider: which PROVIDER_CONFIG entry to use
+# input/output: cost per million tokens (0.0 = free)
+# score: benchmark test pass rate (e.g. "24/31")
+# free: whether the model is free to use
+
+MODELS = {
+    # OpenAI — paid (in chat UI)
+    # "gpt-4.1-nano":    {"provider": "openai",  "input": 0.10, "output": 0.40,  "score": "",        "free": False},
+    # "gpt-4o-mini":     {"provider": "openai",  "input": 0.30, "output": 1.20,  "score": "25/33",   "free": False},
+    # "gpt-4.1-mini":    {"provider": "openai",  "input": 0.80, "output": 3.20,  "score": "24/33",   "free": False},
+    # OpenAI — paid (test-only, not in fallback chain)
+    # "gpt-4o":          {"provider": "openai",  "input": 3.75, "output": 15.0,  "score": "",        "free": False},
+    # "gpt-4.1":         {"provider": "openai",  "input": 3.00, "output": 12.0,  "score": "",        "free": False},
+    # "gpt-5.4-nano":    {"provider": "openai",  "input": 0.10, "output": 0.40,  "score": "",        "free": False},
+    # "gpt-5.4-mini":    {"provider": "openai",  "input": 0.80, "output": 3.20,  "score": "",        "free": False},
+    # "gpt-5.4":         {"provider": "openai",  "input": 3.00, "output": 12.0,  "score": "",        "free": False},
+    # Groq — all free. Llama/Qwen3-32B/Kimi-K2 left the catalog (404, 2026-10-10).
+    # Groq rejects chat_template_kwargs, so no disable_thinking here.
+    "openai/gpt-oss-120b":                          {"provider": "groq", "input": 0, "output": 0, "score": "19/31", "free": True, "benchmark_tokens": 512},
+    "openai/gpt-oss-20b":                           {"provider": "groq", "input": 0, "output": 0, "score": "",      "free": True},
+    # qwen3.8 answered "Co je Brno?" in Slovak (2026-10-10 probe) — registered, not a candidate
+    "qwen/qwen3.8-27b":                             {"provider": "groq", "input": 0, "output": 0, "score": "",      "free": True},
+    # Google Gemini — free tier, 15 rpm per model; 429s often (reliability.json).
+    # All answer with thinking_level="minimal" (2026-10-24 probe); without it 3.x flash
+    # spends the whole token budget thinking.
+    "gemini-3.5-flash-lite":           {"provider": "gemini", "input": 0,    "output": 0,    "score": "",      "free": True},
+    "gemini-3.5-flash":                {"provider": "gemini", "input": 0.30, "output": 2.50, "score": "10/18", "free": True},
+    "gemini-3.1-flash-lite":           {"provider": "gemini", "input": 0,    "output": 0,    "score": "12/18", "free": True},
+    "gemini-3-flash-preview":          {"provider": "gemini", "input": 0,    "output": 0,    "score": "10/18", "free": True},
+    # "gemini-3.1-flash-lite-preview": {"provider": "gemini", "input": 0,    "output": 0,    "score": "13/18", "free": True},
+    # Proton Lumo — paid, needs LUMO_API_KEY (per-token price not published here)
+    "lumo": {"provider": "proton", "input": 0.25, "output": 1.5, "score": "24/31", "free": False},
+    # NVIDIA NIM — free tier (40 rpm)
+    "meta/muse-glimmer-30b":                    {"provider": "nvidia", "input": 0, "output": 0, "score": "25/33", "free": True},
+    "nvidia/nemotron-3.5-lightning-30b-a3b":    {"provider": "nvidia", "input": 0, "output": 0, "score": "23/33", "free": True, "disable_thinking": True},
+    # nemotron-3-super-120b: 404 "not found for account"; glm-5.3-flash: 3-min timeouts (2026-10-24)
+    "nvidia/nemotron-3.5-super-vl-120b-a12b":  {"provider": "nvidia", "input": 0, "output": 0, "score": "", "free": True, "disable_thinking": True},
+    "nvidia/nemotron-3-ultra-550b-a55b":       {"provider": "nvidia", "input": 0, "output": 0, "score": "", "free": True, "disable_thinking": True},
+    "minimaxai/minimax-m3.1-flash":           {"provider": "nvidia", "input": 0, "output": 0, "score": "", "free": True, "low_reasoning": True},
+    # Cloudflare Workers AI — free tier
+    "@cf/qwen/qwen2.5-coder-32b-instruct":           {"provider": "cloudflare", "input": 0, "output": 0, "score": "22/33", "free": True},
+    "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b":  {"provider": "cloudflare", "input": 0, "output": 0, "score": "21/33", "free": True},
+    "@cf/meta/llama-3.1-8b-instruct-fp8":            {"provider": "cloudflare", "input": 0, "output": 0, "score": "20/33", "free": True},
+    "@cf/meta/llama-3.3-70b-instruct-fp8-fast":      {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},
+    "@cf/mistralai/mistral-small-3.1-24b-instruct":  {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},
+    "@cf/meta/llama-4-scout-17b-16e-instruct":       {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},
+    "@cf/aisingapore/gemma-sea-lion-v4-27b-it":      {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},
+    # qwen3 thinks first; CF ignores chat_template_kwargs, so give the benchmark room
+    "@cf/qwen/qwen3-30b-a3b-fp8":                    {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True, "benchmark_tokens": 512},
+    "@cf/openai/gpt-oss-120b":                       {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},  # reasoning — not a candidate
+    "@cf/nvidia/nemotron-3-120b-a12b":               {"provider": "cloudflare", "input": 0, "output": 0, "score": "", "free": True},  # reasoning, 2-3 tok/s effective — not a candidate
+    # Mistral — free experiment tier
+    # Small/Medium: 429 code 1300 on every call since 2026-09 (re-checked 2026-10-10)
+    # "mistral-small-latest":  {"provider": "mistral", "input": 0.20, "output": 0.60, "score": "23/31", "free": True},
+    # "mistral-medium-latest": {"provider": "mistral", "input": 0.40, "output": 2.00, "score": "19/31", "free": True},
+    # "mistral-large-latest":  {"provider": "mistral", "input": 2.00, "output": 6.00, "score": "24/31", "free": True},  # 403 tier_not_allowed — not available in our subscription tier
+    "open-mistral-nemo":     {"provider": "mistral", "input": 0.02, "output": 0.04, "score": "21/31", "free": True},
+    "ministral-8b-latest":   {"provider": "mistral", "input": 0.15, "output": 0.15, "score": "", "free": True},
+    "ministral-14b-latest":  {"provider": "mistral", "input": 0.20, "output": 0.20, "score": "", "free": True},
+    "ministral-3b-latest":   {"provider": "mistral", "input": 0, "output": 0, "score": "", "free": True},  # price not looked up
+    # Hugging Face: free accounts get no inference credits (402, 2026-10-10) — not listed.
+}
+
+# ── Candidate models (15 curated, benchmarked at startup → top 5 active) ──
+# Balanced across providers, no OpenAI. Lumo is paid, so it sits last.
+CANDIDATE_MODELS = [
+    "ministral-14b-latest",                          # verified alternative to rate-limited Small
+    # "mistral-large-latest",                          # mistral — 403 tier_not_allowed
+    "ministral-8b-latest",                           # explicit successor to the old Nemo alias
+    "nvidia/nemotron-3.5-lightning-30b-a3b",         # nvidia — proven reliable
+    "nvidia/nemotron-3.5-super-vl-120b-a12b",
+    "minimaxai/minimax-m3.1-flash",
+    "ministral-3b-latest",
+    "openai/gpt-oss-120b",                           # groq
+    # Muse is served but its reasoning exceeds the startup benchmark budget.
+    "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b", # cloudflare
+    "@cf/meta/llama-3.1-8b-instruct-fp8",            # cloudflare
+    "@cf/qwen/qwen2.5-coder-32b-instruct",          # cloudflare
+    "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+    "@cf/mistralai/mistral-small-3.1-24b-instruct",
+    "@cf/qwen/qwen3-30b-a3b-fp8",
+    "@cf/meta/llama-4-scout-17b-16e-instruct",
+    "@cf/aisingapore/gemma-sea-lion-v4-27b-it",
+    "gemini-3.5-flash-lite",                         # gemini — 15 rpm free tier per model
+    "gemini-3.5-flash",
+    "gemini-3.1-flash-lite",
+    "lumo",                                          # proton — paid, tried last
+]
+
+# ── HF Spaces candidates (subset) ────────────────────────────────────
+HF_CANDIDATES = [
+    "ministral-14b-latest",
+    # "mistral-large-latest",  # 403 tier_not_allowed
+    "ministral-8b-latest",
+    "nvidia/nemotron-3.5-lightning-30b-a3b",
+    "nvidia/nemotron-3.5-super-vl-120b-a12b",
+    "minimaxai/minimax-m3.1-flash",
+    "ministral-3b-latest",
+    "openai/gpt-oss-120b",
+    "@cf/meta/llama-3.1-8b-instruct-fp8",
+    "@cf/qwen/qwen2.5-coder-32b-instruct",
+    "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
+    "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+    "@cf/mistralai/mistral-small-3.1-24b-instruct",
+    "@cf/qwen/qwen3-30b-a3b-fp8",
+    "@cf/meta/llama-4-scout-17b-16e-instruct",
+    "@cf/aisingapore/gemma-sea-lion-v4-27b-it",
+    "gemini-3.5-flash-lite",
+    "gemini-3.5-flash",
+    "gemini-3.1-flash-lite",
+    "lumo",  # proton — paid, tried last
+]
+
+# Active models (set at startup after benchmark — top 5 of candidates)
+ACTIVE_MODELS: list[str] = []
+
+# Fallback chain (rebuilt at startup, ordered by speed)
+FALLBACK_CHAIN: list[str] = list(CANDIDATE_MODELS)
+
+# ── Reliability tracking ─────────────────────────────────────────────────
+
+_RELIABILITY_FILE = os.path.join(os.path.dirname(__file__), "data", "reliability.json")
+
+
+def _load_reliability():
+    try:
+        with open(_RELIABILITY_FILE) as f:
+            return json.load(f)
+    except (OSError, ValueError):  # missing/unreadable file or corrupt JSON
+        return {}
+
+
+# The status, not any "400" in the text: "Error code: 400" (OpenAI SDK),
+# "HTTP Error 400" (urllib), "400 INVALID_ARGUMENT" (genai), "400 Client Error".
+_HTTP_400 = re.compile(r"^400\b|(?:Error(?: code:)?|HTTP) 400\b")
+
+
+def log_reliability(model, success, error_msg=None, ttft=None, tok_sec=None):
+    """Record a success or failure for a model, with optional speed stats. Thread-safe.
+    Skips logging for HTTP 400 errors (config bugs, not provider reliability issues)."""
+    if not success and error_msg and (_HTTP_400.search(str(error_msg)) or "Unsupported parameter" in str(error_msg)):
+        return  # don't penalize provider for our config mistakes
+
+    def record(data):
+        r = data.setdefault(model, {"attempts": 0, "successes": 0, "errors": 0,
+                                    "last_success": None, "last_error": None,
+                                    "last_error_msg": None})
+        r["attempts"] += 1
+        ts = int(time.time())
+        if success:
+            r["successes"] += 1
+            r["last_success"] = ts
+            # Track real-world speed (rolling average)
+            if ttft is not None:
+                prev_ttft = r.get("avg_ttft")
+                r["avg_ttft"] = round((prev_ttft * 0.7 + ttft * 0.3), 3) if prev_ttft else round(ttft, 3)
+            if tok_sec is not None:
+                prev_tps = r.get("avg_tok_sec")
+                r["avg_tok_sec"] = round((prev_tps * 0.7 + tok_sec * 0.3), 1) if prev_tps else round(tok_sec, 1)
+        else:
+            r["errors"] += 1
+            r["last_error"] = ts
+            if error_msg:
+                r["last_error_msg"] = _redact_secrets(str(error_msg))[:500]
+
+    json_storage.update_json(_RELIABILITY_FILE, dict, record)
+
+
+def get_reliability(model):
+    """Return reliability % (0-100) for a model, or None if no data."""
+    data = _load_reliability()
+    r = data.get(model)
+    if not r or r["attempts"] == 0:
+        return None
+    return round(r["successes"] / r["attempts"] * 100)
+
+
+def get_all_reliability():
+    """Return dict of model -> reliability stats."""
+    return _load_reliability()
+
+
+# ── Client creation ──────────────��──────────────────────────────────────
+
+def get_client(provider: str) -> tuple[typing.Any, str | None]:
+    """Get API client for a provider. Returns (client, error_msg).
+
+    The client is Any on purpose: it is an OpenAI, genai or Anthropic SDK
+    client, or a plain dict for cohere/cloudflare. Callers pick the API by
+    provider name, which a type checker cannot tie to the client's type.
+    """
+    cfg = PROVIDER_CONFIG[provider]
+
+    env_key = cfg["env_key"]
+    api_key = os.getenv(env_key or "", "").strip()
+    if cfg.get("guest") and not api_key:
+        from openai import OpenAI, Timeout, omit
+
+        class _GuestOpenAI(OpenAI):
+            """Lumo serves guests unauthenticated; SDK 3.x insists on an auth method."""
+
+            def _validate_headers(self, headers, custom_headers) -> None:
+                return
+
+        # api_key is never sent — default_headers drops Authorization entirely.
+        return _GuestOpenAI(
+            api_key="guest",
+            base_url=cfg["base_url"],
+            # The SDK drops Omit-valued headers; its hint only allows str.
+            default_headers={"Authorization": omit},  # pyright: ignore[reportArgumentType]
+            timeout=Timeout(60, connect=5),
+        ), None
+    if not api_key:
+        return None, f"Chybí {env_key} v .env"
+
+    try:
+        if provider == "cohere":
+            return {"type": "cohere", "api_key": api_key}, None
+        if provider == "cloudflare":
+            account_id = os.getenv(cfg.get("account_id_key", ""), "").strip()
+            if not account_id:
+                return None, "Chybí CLOUDFLARE_ACCOUNT_ID v .env"
+            return {"type": "cloudflare", "api_key": api_key, "account_id": account_id}, None
+        if provider == "nvidia":
+            from openai import OpenAI, Timeout
+            return OpenAI(api_key=api_key, base_url="https://integrate.api.nvidia.com/v1",
+                          timeout=Timeout(60, connect=5)), None
+        if provider == "gemini":
+            from google import genai
+            return genai.Client(api_key=api_key), None
+        elif provider == "anthropic":
+            import anthropic
+            return anthropic.Anthropic(api_key=api_key), None
+        else:
+            from openai import OpenAI, Timeout
+            kwargs = {"api_key": api_key, "timeout": Timeout(60, connect=5)}
+            if cfg["base_url"]:
+                kwargs["base_url"] = cfg["base_url"]
+            return OpenAI(**kwargs), None
+    except Exception as e:  # noqa: BLE001 - any SDK import/setup failure is returned as the error
+        return None, _redact_secrets(str(e))[:80]
+
+
+# ── Sync call (test_models.py) ──────────────────────────────────────────
+
+class _ChatRequestOptions(typing.TypedDict, total=False):
+    extra_body: dict[str, dict[str, bool]]
+    reasoning_effort: typing.Literal["low"]
+
+
+def _chat_request_options(model_name: str) -> _ChatRequestOptions:
+    """Keep supported reasoning models within the visible-answer token budget."""
+    if MODELS[model_name].get("disable_thinking"):
+        return {"extra_body": {"chat_template_kwargs": {"enable_thinking": False}}}
+    if MODELS[model_name].get("low_reasoning"):
+        return {"reasoning_effort": "low"}
+    return {}
+
+
+# Gemini 3.x flash otherwise thinks through the whole max_output_tokens budget.
+_GEMINI_THINKING = {"thinking_level": "minimal"}
+
+
+def _cf_text(data: dict) -> str:
+    """Workers AI answers either {"response": ...} or OpenAI-style choices (gpt-oss, nemotron, gemma-4)."""
+    result = data.get("result") or {}
+    if result.get("response"):
+        return result["response"]
+    choices = result.get("choices") or []
+    return (choices[0].get("message") or {}).get("content") or "" if choices else ""
+
+
+def call_model(model_name, messages, max_tokens=300, temperature=0.7):
+    """Call a model synchronously. Returns (text, tokens_in, tokens_out)."""
+    info = MODELS[model_name]
+    provider = info["provider"]
+    client, err = get_client(provider)
+    if err:
+        raise RuntimeError(err)
+
+    if provider == "cloudflare":
+        import urllib.request
+        account_id = client["account_id"]
+        payload = json.dumps({
+            "messages": messages, "max_tokens": max_tokens,
+        }).encode()
+        req = urllib.request.Request(
+            f"https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/{model_name}",
+            data=payload,
+            headers={"Authorization": f"Bearer {client['api_key']}",
+                     "Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            data = json.loads(resp.read().decode())
+        text = _cf_text(data)
+        tin = sum(len(m["content"]) // 4 for m in messages)
+        tout = len(text) // 4
+        return text.strip(), tin, tout
+
+    if provider == "cohere":
+        import urllib.request
+        # v2 API: system message goes in messages array, NOT as preamble
+        cohere_msgs = [{"role": m["role"], "content": m["content"]} for m in messages]
+        payload = json.dumps({
+            "model": model_name, "messages": cohere_msgs,
+            "temperature": temperature, "max_tokens": max_tokens,
+        }).encode()
+        req = urllib.request.Request(
+            "https://api.cohere.com/v2/chat", data=payload,
+            headers={"Authorization": f"Bearer {client['api_key']}",
+                     "Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode())
+        text = data.get("message", {}).get("content", [{}])[0].get("text", "")
+        tin = data.get("usage", {}).get("tokens", {}).get("input_tokens", 0)
+        tout = data.get("usage", {}).get("tokens", {}).get("output_tokens", 0)
+        return text.strip(), tin, tout
+
+    if provider == "gemini":
+        from google.genai import types
+        system_text, user_text = "", ""
+        for m in messages:
+            if m["role"] == "system":
+                system_text = m["content"]
+            elif m["role"] == "user":
+                user_text = m["content"]
+        response = client.models.generate_content(
+            model=model_name, contents=user_text,
+            config=types.GenerateContentConfig(
+                system_instruction=system_text, temperature=temperature,
+                max_output_tokens=max_tokens, thinking_config=types.ThinkingConfig.model_validate(_GEMINI_THINKING)))
+        text = response.text or ""
+        tin = getattr(response.usage_metadata, "prompt_token_count", 0) or 0
+        tout = getattr(response.usage_metadata, "candidates_token_count", 0) or 0
+        return text, tin, tout
+
+    if provider == "anthropic":
+        system_text = ""
+        user_messages = []
+        for m in messages:
+            if m["role"] == "system":
+                system_text = m["content"]
+            else:
+                user_messages.append(m)
+        r = client.messages.create(model=model_name, system=system_text,
+                                   messages=user_messages, temperature=temperature,
+                                   max_tokens=max_tokens)
+        return r.content[0].text or "", r.usage.input_tokens, r.usage.output_tokens
+
+    # OpenAI-compatible (openai, deepseek, groq, mistral)
+    # GPT-5+ uses max_completion_tokens instead of max_tokens
+    tok_kwarg = "max_completion_tokens" if model_name.startswith("gpt-5") else "max_tokens"
+    r = client.chat.completions.create(model=model_name, messages=messages,
+                                       temperature=temperature, **{tok_kwarg: max_tokens},
+                                       **_chat_request_options(model_name))
+    return r.choices[0].message.content or "", r.usage.prompt_tokens, r.usage.completion_tokens
+
+
+def _call_model_tracked(model_name, messages, **kwargs):
+    """call_model with reliability logging."""
+    try:
+        result = call_model(model_name, messages, **kwargs)
+        log_reliability(model_name, success=True)
+        return result
+    except Exception as e:
+        log_reliability(model_name, success=False, error_msg=str(e))
+        raise
+
+
+# ── Streaming call (benchmark.py speed test) ────────────────────────────
+
+def stream_benchmark(model_name, system_prompt, user_prompt, max_tokens=150):
+    """Stream a model for speed benchmarking. Returns (latency, ttft, tok_per_sec, error)."""
+    latency, ttft, tok_sec, error = _stream_benchmark_inner(
+        model_name, system_prompt, user_prompt, max_tokens)
+    # Log reliability for benchmark runs too
+    if error:
+        log_reliability(model_name, success=False, error_msg=error)
+    else:
+        log_reliability(model_name, success=True)
+    return latency, ttft, tok_sec, error
+
+
+def _stream_benchmark_inner(model_name, system_prompt, user_prompt, max_tokens=150):
+    info = MODELS.get(model_name)
+    if not info:
+        return None, None, None, f"Unknown model: {model_name}"
+    provider = info["provider"]
+
+    messages = [{"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}]
+    max_tokens = max(max_tokens, info.get("benchmark_tokens", max_tokens))
+
+    _BENCH_TIMEOUT = 7  # aggressive timeout for benchmarks
+
+    try:
+        if provider in ("cohere", "cloudflare"):
+            t0 = time.time()
+            text, _, tout = call_model(model_name, messages, max_tokens=max_tokens)
+            total = time.time() - t0
+            if not text or not text.strip():
+                return None, None, None, "Empty response (no visible output)"
+            tok_sec = tout / total if total > 0 else 0
+            return total, total * 0.3, tok_sec, None
+
+        if provider == "gemini":
+            from google.genai import types
+            client, err = get_client(provider)
+            if err:
+                return None, None, None, err
+            t0 = time.time()
+            ttft = None
+            token_count = 0
+            stream = client.models.generate_content_stream(
+                model=model_name, contents=user_prompt,
+                config=types.GenerateContentConfig(
+                    system_instruction=system_prompt, max_output_tokens=max_tokens,
+                    thinking_config=types.ThinkingConfig.model_validate(_GEMINI_THINKING)))
+            for chunk in stream:
+                if chunk.text and chunk.text.strip():
+                    if ttft is None:
+                        ttft = time.time() - t0
+                    token_count += len(chunk.text.split())
+            total = time.time() - t0
+            if ttft is None:
+                return None, None, None, "Empty response (no visible output)"
+            return total, ttft, token_count / total if total > 0 else 0, None
+
+        # OpenAI-compatible (openai, deepseek, groq, mistral)
+        client, err = get_client(provider)
+        if err:
+            return None, None, None, err
+        t0 = time.time()
+        ttft = None
+        token_count = 0
+        stream = client.chat.completions.create(
+            model=model_name, messages=messages,
+            max_tokens=max_tokens, stream=True,
+            timeout=_BENCH_TIMEOUT, **_chat_request_options(model_name))
+        for chunk in stream:
+            if time.time() - t0 > _BENCH_TIMEOUT:
+                break
+            if (chunk.choices and chunk.choices[0].delta.content
+                    and chunk.choices[0].delta.content.strip()):
+                if ttft is None:
+                    ttft = time.time() - t0
+                token_count += 1
+        total = time.time() - t0
+        if ttft is None:
+            return None, None, None, "Empty response (no visible output)"
+        return total, ttft, token_count / total if total > 0 else 0, None
+
+    except Exception as e:  # noqa: BLE001 - any provider failure is a failed benchmark
+        return None, None, None, _redact_secrets(str(e))
+
+
+# ── Streaming generator (web.py SSE) ────────────────────────────────────
+
+def stream_chat(model_name, messages, max_tokens=1024, temperature=0.7):
+    """Stream a model response as (text_chunk) generator. For web SSE."""
+    info = MODELS.get(model_name)
+    if not info:
+        raise RuntimeError(f"Unknown model: {model_name}")
+    provider = info["provider"]
+    client, err = get_client(provider)
+    if err:
+        raise RuntimeError(err)
+    if not client:
+        raise RuntimeError(f"No client for {provider}")
+
+    if provider == "cloudflare":
+        # Cloudflare Workers AI doesn't stream; yield full response
+        text, _, _ = call_model(model_name, messages, max_tokens=max_tokens, temperature=temperature)
+        yield text
+        return
+
+    if provider == "cohere":
+        import urllib.request
+        # v2 API: system message goes in messages array
+        cohere_msgs = [{"role": m["role"], "content": m["content"]} for m in messages]
+        payload = json.dumps({
+            "model": model_name, "messages": cohere_msgs,
+            "temperature": temperature, "max_tokens": max_tokens, "stream": True,
+        }).encode()
+        req = urllib.request.Request(
+            "https://api.cohere.com/v2/chat", data=payload,
+            headers={"Authorization": f"Bearer {client['api_key']}",
+                     "Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").strip()
+                if not line or not line.startswith("data:"):
+                    continue
+                try:
+                    data = json.loads(line[5:].strip())
+                except json.JSONDecodeError:
+                    continue
+                if data.get("type") == "content-delta":
+                    delta = data.get("delta", {}).get("message", {}).get("content", {}).get("text", "")
+                    if delta:
+                        yield delta
+        return
+
+    if provider == "gemini":
+        from google.genai import types
+        sys_text = ""
+        contents = []
+        for m in messages:
+            if m["role"] == "system":
+                sys_text = m["content"]
+            else:
+                contents.append(types.Content(
+                    role="user" if m["role"] == "user" else "model",
+                    parts=[types.Part(text=m["content"])]))
+        stream = client.models.generate_content_stream(
+            model=model_name, contents=contents,
+            config=types.GenerateContentConfig(
+                system_instruction=sys_text, temperature=temperature,
+                max_output_tokens=max_tokens, thinking_config=types.ThinkingConfig.model_validate(_GEMINI_THINKING)))
+        for chunk in stream:
+            if chunk.text:
+                yield chunk.text
+        return
+
+    # OpenAI-compatible (openai, deepseek, groq, mistral)
+    tok_kwarg = {"max_completion_tokens": max_tokens} if model_name.startswith("gpt-5") else {"max_tokens": max_tokens}
+    stream = client.chat.completions.create(
+        model=model_name, messages=messages, temperature=temperature,
+        **tok_kwarg, stream=True, **_chat_request_options(model_name))
+    for chunk in stream:
+        if chunk.choices and chunk.choices[0].delta.content:
+            yield chunk.choices[0].delta.content
+
+
+# ── Error formatting ────────────────────────────────────────────────────
+
+def friendly_error(emsg):
+    """Convert raw API errors to human-readable Czech messages."""
+    el = emsg.lower()
+    if "401" in emsg or "invalid_api_key" in el or "unauthorized" in el or "authentication" in el:
+        return "Neplatný API klíč"
+    if "402" in emsg or "insufficient" in el or "balance" in el:
+        return "Nedostatečný kredit"
+    if "429" in emsg or "quota" in el or "rate" in el or "resource_exhausted" in el:
+        return "Rate limit / vyčerpaná kvóta"
+    if "404" in emsg or "not found" in el or "does not exist" in el:
+        return "Model nenalezen"
+    if "403" in emsg or "forbidden" in el or "permission" in el:
+        return "Přístup zamítnut"
+    import re
+    if "'message':" in emsg:
+        m = re.search(r"'message':\s*'([^']+)'", emsg)
+        if m:
+            return m.group(1)[:80]
+    return emsg[:80]
+
+
+# ── Dynamic free-model discovery ────────────────────────────────────────
+# OVHcloud rotates its free catalog; OpenRouter discovery is limited to the
+# models verified to return visible chat output.
+AUTO_DISCOVER_PROVIDERS = ["openrouter", "ovhcloud"]
+OPENROUTER_MODELS = {
+    name for name, config in MODELS.items() if config["provider"] == "openrouter"
+}
+
+
+def discover_free_models(provider: str, limit: int = 20) -> list[str]:
+    """Query a provider's /models endpoint, return up to `limit` free-tier model IDs."""
+    client, err = get_client(provider)
+    if err:
+        return []
+    try:
+        ids = [m.id for m in client.models.list().data]
+    except Exception:  # noqa: BLE001 - an unreachable catalog just yields no models
+        return []
+    if provider == "openrouter":
+        ids = [model_id for model_id in ids if model_id in OPENROUTER_MODELS]
+    return ids[:limit]
+
+
+def register_discovered_models(limit_per_provider: int = 20) -> list[str]:
+    """Add auto-discovered free models to MODELS + CANDIDATE_MODELS/HF_CANDIDATES.
+    Returns the new IDs."""
+    added = []
+    for provider in AUTO_DISCOVER_PROVIDERS:
+        for model_id in discover_free_models(provider, limit_per_provider):
+            if model_id in MODELS:
+                continue
+            MODELS[model_id] = {"provider": provider, "input": 0, "output": 0, "score": "", "free": True}
+            CANDIDATE_MODELS.append(model_id)
+            HF_CANDIDATES.append(model_id)
+            added.append(model_id)
+    return added
+
+
+# ── Provider health check ───────────────────────────────────────────────
+
+# Test model to use when validating each provider's API key
+_CHECK_MODELS = {
+    "openai": "gpt-4.1-nano",
+    "deepseek": "deepseek-chat",
+    "groq": "llama-3.1-8b-instant",
+    "mistral": "mistral-small-latest",
+    "gemini": "gemini-3.5-flash",
+    "anthropic": "claude-haiku-4-5-20251001",
+    "nvidia": "nvidia/nemotron-3.5-lightning-30b-a3b",
+    "proton": "lumo",
+    "huggingface": "zai-org/GLM-5.3",
+}
+
+
+def check_provider(provider):
+    """Validate API key with a minimal test call. Returns (ok, message)."""
+    client, err = get_client(provider)
+    if err:
+        return False, err
+
+    try:
+        if provider in AUTO_DISCOVER_PROVIDERS:
+            models = discover_free_models(provider)
+            if models:
+                return True, f"OK — {len(models)} free models: {', '.join(models[:3])}"
+            return False, "Žádné free modely nenalezeny"
+
+        if provider == "cloudflare":
+            import urllib.request
+            account_id = client["account_id"]
+            payload = json.dumps({
+                "messages": [{"role": "user", "content": "Say ok."}], "max_tokens": 5,
+            }).encode()
+            req = urllib.request.Request(
+                f"https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/@cf/meta/llama-3.2-3b-instruct",
+                data=payload,
+                headers={"Authorization": f"Bearer {client['api_key']}",
+                         "Content-Type": "application/json"})
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                data = json.loads(resp.read().decode())
+            text = _cf_text(data)
+            return True, f"OK — {text.strip()[:20]}"
+
+        if provider == "cohere":
+            import urllib.request
+            payload = json.dumps({
+                "model": "command-r7b-12-2024",
+                "messages": [{"role": "user", "content": "Řekni 'ok'."}],
+                "max_tokens": 5,
+            }).encode()
+            req = urllib.request.Request(
+                "https://api.cohere.com/v2/chat", data=payload,
+                headers={"Authorization": f"Bearer {client['api_key']}",
+                         "Content-Type": "application/json"})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read().decode())
+            text = data.get("message", {}).get("content", [{}])[0].get("text", "")
+            return True, f"OK — {text.strip()[:20]}"
+
+        if provider == "gemini":
+            response = client.models.generate_content(
+                model="gemini-3.5-flash", contents="Řekni 'ok'.",
+                config={"max_output_tokens": 5})
+            return True, f"OK — {response.text.strip()[:20]}"
+
+        if provider == "anthropic":
+            r = client.messages.create(
+                model="claude-haiku-4-5-20251001", max_tokens=10,
+                messages=[{"role": "user", "content": "Řekni 'ok'."}])
+            return True, f"OK — {r.content[0].text.strip()[:20]}"
+
+        # OpenAI-compatible
+        test_model = _CHECK_MODELS.get(provider, "gpt-4.1-nano")
+        r = client.chat.completions.create(
+            model=test_model,
+            messages=[{"role": "user", "content": "Řekni 'ok'."}],
+            max_tokens=5)
+        return True, f"OK — {r.choices[0].message.content.strip()[:20]}"
+
+    except Exception as e:  # noqa: BLE001 - any provider failure is reported as not OK
+        return False, friendly_error(str(e))

rate_limit.py

@@ -0,0 +1,63 @@
+"""Per-client request caps, in memory.
+
+Keys are exact paths, not prefixes. `"/api/stt"` used to match by prefix, which
+swallowed `/api/stt/check` and `/api/stt/usage` as well: a single /transcribe
+load spends three of those, so the fourth reload inside a minute was refused
+and the page reported the transcription service as down. The websocket it was
+written for never reaches this code at all — `BaseHTTPMiddleware` skips
+non-http scopes, so websocket limits live in `stt_budget` instead.
+"""
+
+import threading
+import time
+
+# exact path → (max_requests, window_seconds)
+LIMITS: dict[str, tuple[int, int]] = {
+    "/api/chat": (15, 60),
+    # Voice mode sends one request per sentence, prefetched as the answer
+    # streams, so a low cap counts sentences rather than users: at 10 the
+    # eleventh sentence of one answer was refused and the reply finished in the
+    # browser's built-in voice. edge-tts is unmetered and the result is cached,
+    # so this only exists to stop the Space being used as a free TTS proxy.
+    "/api/tts": (60, 60),
+    "/api/benchmark": (1, 300),
+    # Every call makes an outbound request to Deepgram's auth endpoint, so it
+    # cannot go uncapped. The chat page calls it once per load, /t after each
+    # unexpected socket close: reconnect backoff (1 s doubling to 30 s) keeps
+    # that to about seven in the first minute, then two a minute.
+    "/api/stt/check": (30, 60),
+    "/api/stt/usage": (30, 60),
+    # /t asks once per socket, like the check; each call mints a Deepgram token
+    "/api/stt/token": (30, 60),
+    # /t reports its visit every 5 min and on hide: far under this
+    "/api/stt/session": (30, 60),
+    "/api/captcha/challenge": (10, 60),
+    "/api/captcha/verify": (10, 60),
+}
+
+_buckets: dict[str, list[float]] = {}
+_lock = threading.Lock()
+
+
+def is_limited(client: str, path: str, now: float | None = None) -> bool:
+    """True when this client has used up `path`'s allowance. Counts the call."""
+    limit_window = LIMITS.get(path)
+    if limit_window is None:
+        return False
+    limit, window = limit_window
+    now = time.time() if now is None else now
+    key = f"{client}:{path}"
+    with _lock:
+        recent = [t for t in _buckets.get(key, ()) if t > now - window]
+        if len(recent) >= limit:
+            _buckets[key] = recent
+            return True
+        recent.append(now)
+        _buckets[key] = recent
+    return False
+
+
+def reset() -> None:
+    """Drop all buckets. For tests."""
+    with _lock:
+        _buckets.clear()

refuse_log.py

@@ -0,0 +1,36 @@
+"""One line per refusal, into logs/app.log.
+
+The remediation series added ten ways to refuse a request — oversized bodies,
+rate limits, a missing captcha session, closed websockets, a spent STT budget —
+and recorded none of them, so a 403 and a 200 looked the same in `logs/`.
+
+The bucket key is hashed (`stt_budget.client_id`) by the caller before it gets
+here: the raw key is a captcha session token or a visitor address, and this
+file has to be safe to read. `refused()` does not hash for you, because it has
+no access to the secret — passing a raw token is the one mistake worth
+guarding against, so keep the hashing next to the key and pass the result.
+
+What this file is worth: `logs/` lives inside the container and the free HF
+CPU Basic tier has no persistent disk, so these lines cover the period since
+the last Space restart and no longer.
+"""
+
+import logging
+
+_log = logging.getLogger("ajaj.refuse")
+
+
+def refused(reason: str, route: str, bucket: str | None = None, **extra: object) -> None:
+    """Record one refusal.
+
+    Args:
+        reason: Short slug for what refused, e.g. `rate_limited`.
+        route: The path or websocket route the refusal happened on.
+        bucket: Already-hashed client key, or None when no client caused it
+            (a missing API key, an unavailable dependency).
+        **extra: Extra `key=value` fields to append, e.g. `status=413`.
+    """
+    line = f"{reason} route={route} bucket={bucket or '-'}"
+    if extra:
+        line += " " + " ".join(f"{k}={v}" for k, v in extra.items())
+    _log.warning(line)

requirements-hf.txt

@@ -0,0 +1,15 @@
+fastapi==0.141.1
+uvicorn==0.52.4
+python-dotenv==1.2.3
+chromadb==1.5.9
+fastembed==0.8.0
+onnxruntime==1.29.0
+openai==3.7.0
+google-genai==2.22.0
+httpx==0.28.1
+edge-tts==7.2.8
+numpy==2.5.3
+requests==2.34.2
+websockets==16.1.1
+Pillow==12.3.0
+maxminddb==3.2.0

retrieve.py

@@ -0,0 +1,345 @@
+"""
+retrieve.py — Hybrid retrieval: semantic search + title keyword matching
+              + live Necyklopedie fallback for articles not in local index.
+"""
+
+import json
+import os
+import re
+import time
+
+from json_storage import JsonValue, update_json
+
+_title_index = None
+
+# ── Live-fetch rate limiting ───────────────────────────────────────────────────
+_LIVE_LOG = os.path.join("data", "live_fetch_log.json")
+_LIVE_MAX_DAY = 300  # max live fetches per 24 h
+_LIVE_MAX_MIN = 30   # max live fetches per 60 s
+_CHUNK_SIZE   = 800  # chars per chunk for live-fetched text
+
+
+def _load_title_index():
+    """Build a lowercase title -> pageid lookup from articles.jsonl."""
+    global _title_index
+    if _title_index is not None:
+        return _title_index
+
+    _title_index = {}
+    articles_path = os.path.join("data", "articles.jsonl")
+    if os.path.exists(articles_path):
+        with open(articles_path, "r", encoding="utf-8") as f:
+            for line in f:
+                rec = json.loads(line)
+                _title_index[rec["title"].lower()] = rec["pageid"]
+    return _title_index
+
+
+def _czech_stem(word):
+    """Crude Czech stemming: strip common suffixes for matching."""
+    # Order matters: try longer suffixes first
+    for suffix in ["ách", "ům", "emi", "ami", "ích", "ech",
+                    "ám", "ím", "ov", "ěm",
+                    "ou", "em", "mi", "ně",
+                    "ě", "y", "u", "i", "a", "o"]:
+        if word.endswith(suffix) and len(word) - len(suffix) >= 3:
+            return word[:-len(suffix)]
+    return word
+
+
+def _stems_match(query_stem, title_stem):
+    """Check if query stem matches title stem. Allows 1 char difference for Czech declension."""
+    if query_stem == title_stem:
+        return True
+    if len(query_stem) >= 3 and title_stem.startswith(query_stem) and len(title_stem) - len(query_stem) == 1:
+        return True
+    return len(title_stem) >= 3 and query_stem.startswith(title_stem) and len(query_stem) - len(title_stem) == 1
+
+
+def _find_matching_titles(query_lower):
+    """Find article titles that match query words. Returns dict of pageid -> match_quality.
+    Match quality: 3 = exact title match, 2 = title is a query word, 1 = substring match."""
+    idx = _load_title_index()
+    stopwords = {
+        "se", "si", "to", "je", "na", "ve", "za", "ke", "od", "do", "po", "při",
+        "pro", "nad", "pod", "jak", "kdo", "kde", "kdy", "cos", "ten", "the",
+        "jeho", "její", "jsou", "bylo", "být", "mít", "které", "která", "který",
+        "jako", "ale", "ani", "nebo", "tak", "jen", "ještě", "což", "tedy",
+        "taky", "také", "toho", "tím", "tom", "této", "tohle", "nic", "než",
+        "aby", "když", "před", "mezi", "přes", "bez", "stál", "řekl", "jsem",
+        "jsi", "jsme", "jste", "byl", "byla", "byli", "není", "nás", "vás",
+        "mně", "mne", "jím", "jich", "jim", "ním", "nich", "něm", "nej",
+        "své", "svou", "svým", "jaký", "jaká", "jaké", "celý", "celá",
+        "dnes", "bude", "více", "méně", "setkal", "říkají", "pravda",
+        "pojem", "pojmem", "pojmu", "vysvětli", "vysvětlit", "řekni", "popiš", "popsat",
+        "říká", "neříká", "proboha", "skrývá", "město", "města",
+        "vůbec", "nevím", "utajované", "informace", "pouč", "slyšel", "nikdy", "neslyšel", "vzniklo", "vznikl", "vznikla",
+    }
+    raw_words = re.findall(r'[\w]+', query_lower)  # strip punctuation
+    words = [w for w in raw_words if len(w) >= 3 and w not in stopwords]
+    stems = [_czech_stem(w) for w in words]
+
+    matched = {}  # pageid -> match_quality
+    query_joined = " ".join(words)
+
+    for title_lower, pageid in idx.items():
+        title_stems = [_czech_stem(tw) for tw in title_lower.split()]
+        title_stem = _czech_stem(title_lower)
+        best = 0
+        # Check if full query matches full title (multi-word exact match)
+        # Require title >= 5 chars for substring match to avoid short titles ("Pod", "Sad"…)
+        # matching inside unrelated long words ("blaosdpsadkpods")
+        if title_lower == query_joined or (len(title_lower) >= 5 and title_lower in query_joined):
+            best = 3
+        else:
+            for word, stem in zip(words, stems):
+                # Exact single-word title match
+                if word == title_lower or stem == title_stem:
+                    best = max(best, 3)
+                # Query word matches a title word (multi-word title)
+                elif word in title_lower.split() or stem in title_stems:
+                    best = max(best, 2)
+                # Substring match (weakest)
+                elif word in title_lower:
+                    best = max(best, 1)
+        if best > 0:
+            matched[pageid] = best
+
+    return matched
+
+
+# ── Live Necyklopedie fallback ─────────────────────────────────────────────────
+
+def _reserve_live_fetch() -> bool:
+    """Atomically reserve one live fetch when both quotas allow it."""
+    now = time.time()
+    is_allowed = False
+
+    def reserve(log: list[JsonValue]) -> None:
+        nonlocal is_allowed
+        recent: list[int | float] = []
+        for timestamp in log:
+            if isinstance(timestamp, (int, float)) and now - timestamp < 86400:
+                recent.append(timestamp)
+        log[:] = recent
+        if len(recent) >= _LIVE_MAX_DAY:
+            return
+        if sum(1 for timestamp in recent if now - timestamp < 60) >= _LIVE_MAX_MIN:
+            return
+        log.append(now)
+        is_allowed = True
+
+    try:
+        update_json(_LIVE_LOG, list, reserve)
+    except OSError:
+        return False
+    return is_allowed
+
+
+def _query_words(query_lower):
+    """Return content words from query (same stopwords as title matching)."""
+    stopwords = {
+        "se", "si", "to", "je", "na", "ve", "za", "ke", "od", "do", "po", "při",
+        "pro", "nad", "pod", "jak", "kdo", "kde", "kdy", "cos", "ten", "the",
+        "jeho", "její", "jsou", "bylo", "být", "mít", "které", "která", "který",
+        "jako", "ale", "ani", "nebo", "tak", "jen", "ještě", "což", "tedy",
+        "taky", "také", "toho", "tím", "tom", "této", "tohle", "nic", "než",
+        "aby", "když", "před", "mezi", "přes", "bez", "stál", "řekl", "jsem",
+        "jsi", "jsme", "jste", "byl", "byla", "byli", "není", "nás", "vás",
+        "mně", "mne", "jím", "jich", "jim", "ním", "nich", "něm", "nej",
+        "své", "svou", "svým", "jaký", "jaká", "jaké", "celý", "celá",
+        "dnes", "bude", "více", "méně", "setkal", "říkají", "pravda",
+        "pojem", "pojmem", "pojmu", "vysvětli", "vysvětlit", "řekni", "popiš", "popsat",
+        "říká", "neříká", "proboha", "skrývá", "město", "města",
+        "vůbec", "nevím", "utajované", "informace", "pouč", "slyšel", "nikdy", "neslyšel", "vzniklo", "vznikl", "vznikla",
+        # English
+        "what", "who", "how", "where", "when", "why", "tell", "about", "explain",
+        "is", "are", "was", "were", "this", "that", "with", "from",
+    }
+    return [w for w in re.findall(r'[\w]+', query_lower) if len(w) >= 3 and w not in stopwords]
+
+
+_API_URL = "https://necyklopedie.org/w/api.php"
+_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+
+
+def _strip_diacritics(s):
+    import unicodedata
+    return "".join(c for c in unicodedata.normalize("NFD", s)
+                   if unicodedata.category(c) != "Mn")
+
+
+def _search_necyklopedie(word):
+    """Find Necyklopedie article titles matching word, handling diacritics.
+
+    Strategy: allpages prefix search with progressively shorter prefixes of the
+    diacritics-stripped word. MediaWiki prefix search is Unicode-aware at the
+    char level — 'Podprd' matches 'Podprdélník' but 'Podprde' doesn't (é≠e).
+    We then keep candidates whose stripped title closely matches our stripped word.
+    """
+    import urllib.parse
+    import urllib.request
+
+    stripped = _strip_diacritics(word.lower())
+    target_stem = stripped[:max(4, len(stripped) - 2)]  # at least 4 chars
+
+    # Try from full length down to 4 chars, stop at first hit
+    for length in range(len(stripped), 3, -1):
+        prefix = stripped[:length].capitalize()
+        params = urllib.parse.urlencode({
+            "action": "query", "list": "allpages",
+            "apprefix": prefix, "apnamespace": "0",
+            "aplimit": "10", "format": "json",
+        })
+        url = f"{_API_URL}?{params}"
+        req = urllib.request.Request(url, headers={"User-Agent": _UA})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read(_MAX_SEARCH_BYTES).decode("utf-8"))
+        pages = data.get("query", {}).get("allpages", [])
+        if not pages:
+            continue
+        # Keep candidates whose stripped title starts with our stripped word stem
+        matches = [
+            p["title"] for p in pages
+            if _strip_diacritics(p["title"].lower()).startswith(target_stem)
+        ]
+        if matches:
+            return matches[:3]
+        # If pages found but none match stem, stop — we've gone too broad
+        if len(pages) >= 5:
+            break
+
+    return []
+
+
+_MAX_EXPORT_BYTES = 4 * 1024 * 1024
+_MAX_SEARCH_BYTES = 256 * 1024
+
+
+def _fetch_pages_by_title(titles):
+    """Fetch specific pages through the API: {pageid: {pageid, title, text}}.
+    The reply is read inside a chat request, so it is capped (ValueError)."""
+    import scrape
+    return scrape.fetch_pages(titles, timeout=15, max_bytes=_MAX_EXPORT_BYTES)
+
+
+def _live_fetch(query_lower):
+    """Fetch article from Necyklopedie live. Returns list of (doc, meta) chunks or []."""
+    words = _query_words(query_lower)
+    if not words or not _reserve_live_fetch():
+        return []
+
+    # Use longest word as primary search term (most specific)
+    primary = max(set(words), key=len)
+
+    # Use MediaWiki search to find the real title (handles diacritics, capitalization)
+    try:
+        titles_to_try = _search_necyklopedie(primary)
+    except Exception:  # noqa: BLE001 - best effort (network, HTTP, JSON); fall back to a guessed title
+        titles_to_try = [primary.capitalize()]
+
+    if not titles_to_try:
+        return []
+
+    try:
+        results = _fetch_pages_by_title(titles_to_try[:3])
+    except Exception:  # noqa: BLE001 - best effort (network, HTTP, XML); no live chunks
+        return []
+
+    if not results:
+        return []
+
+    chunks = []
+    for pageid, rec in results.items():
+        text = rec["text"]
+        title = rec["title"]
+        # Split into fixed-size chunks
+        for i in range(0, min(len(text), _CHUNK_SIZE * 5), _CHUNK_SIZE):
+            chunk = text[i:i + _CHUNK_SIZE]
+            if chunk.strip():
+                chunks.append((chunk, {
+                    "title": title,
+                    "pageid": pageid,
+                    "chunk_index": i // _CHUNK_SIZE,
+                    "live": True,
+                }))
+
+    return chunks
+
+
+def retrieve_chunks(query, embedder, collection, top_k=10):
+    """Retrieve relevant chunks using semantic search + title keyword boost.
+
+    Returns (chunks, live_titles, live_attempted) where live_titles is a list of
+    article titles that were fetched live from Necyklopedie (empty if all from
+    local index) and live_attempted says whether a live fetch was tried.
+    """
+    query_lower = query.lower()
+
+    # 1. Semantic search
+    query_embedding = embedder.encode(query).tolist()
+    sem_results = collection.query(
+        query_embeddings=[query_embedding],
+        n_results=top_k,
+    )
+    sem_chunks = list(zip(
+        sem_results["documents"][0],
+        sem_results["metadatas"][0],
+    ))
+
+    # 2. Title keyword matching via local index
+    matched = _find_matching_titles(query_lower)  # pageid -> match_quality
+
+    # Limit to top 5 articles by match quality to avoid excessive DB calls
+    top_matched = sorted(matched.items(), key=lambda x: -x[1])[:5]
+
+    article_chunks = []  # list of (match_quality, [(doc, meta), ...])
+    for pageid, match_quality in top_matched:
+        try:
+            kw_results = collection.get(
+                where={"pageid": pageid},
+                include=["documents", "metadatas"],
+            )
+            if not kw_results["documents"]:
+                continue
+            pairs = list(zip(kw_results["documents"], kw_results["metadatas"]))
+            pairs.sort(key=lambda p: p[1].get("chunk_index", 0))
+            picks = pairs[:5]
+            article_chunks.append((match_quality, picks))
+        except Exception:  # noqa: BLE001, S110 - one failed lookup must not drop the other articles
+            pass
+
+    article_chunks.sort(reverse=True, key=lambda x: x[0])
+    title_chunks = []
+    for _, chunks in article_chunks:
+        title_chunks.extend(chunks)
+
+    # 3. Merge: title matches first (deduplicated), then semantic results
+    seen_ids = set()
+    merged = []
+    for source in [title_chunks, sem_chunks]:
+        for doc, meta in source:
+            chunk_id = f"{meta['pageid']}_{meta['chunk_index']}"
+            if chunk_id not in seen_ids:
+                seen_ids.add(chunk_id)
+                merged.append((doc, meta))
+
+    # 4. Live fallback: if no keyword title match at all, ask Necyklopedie directly
+    live_titles = []
+    live_attempted = False
+    if not matched:
+        live_attempted = True
+        live_chunks = _live_fetch(query_lower)
+        if live_chunks:
+            live_titles = list(dict.fromkeys(m["title"] for _, m in live_chunks))
+            # Prepend live chunks (they're the best match we have)
+            seen_live = set()
+            deduped_live = []
+            for doc, meta in live_chunks:
+                cid = f"{meta['pageid']}_{meta['chunk_index']}"
+                if cid not in seen_ids and cid not in seen_live:
+                    seen_live.add(cid)
+                    deduped_live.append((doc, meta))
+            merged = deduped_live + merged
+
+    return merged[:top_k], live_titles, live_attempted

scrape.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+scrape.py — Download and process all Necyklopedie articles.
+
+Three phases:
+  1. Enumerate all article titles via MediaWiki API
+  2. Bulk export via Special:Export (XML dump with full wikitext)
+  3. Parse wikitext to plaintext and save as JSONL
+"""
+
+import json
+import os
+import re
+import sys
+import time
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+
+API_URL = "https://necyklopedie.org/w/api.php"
+EXPORT_URL = "https://necyklopedie.org/wiki/Speci%C3%A1ln%C3%AD:Exportovat_str%C3%A1nky"
+OUTPUT_DIR = "data"
+OUTPUT_FILE = os.path.join(OUTPUT_DIR, "articles.jsonl")
+TITLES_CACHE = os.path.join(OUTPUT_DIR, "titles.json")
+DUMP_FILE = os.path.join(OUTPUT_DIR, "dump.xml")
+MW_NS = {"mw": "http://www.mediawiki.org/xml/export-0.11/"}
+UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+
+
+def api_get(params, timeout=30, max_bytes=None):
+    """One MediaWiki API call; `max_bytes` caps the reply (ValueError past it)."""
+    params["format"] = "json"
+    url = f"{API_URL}?{urllib.parse.urlencode(params)}"
+    req = urllib.request.Request(url, headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        payload = resp.read(-1 if max_bytes is None else max_bytes + 1)
+    if max_bytes is not None and len(payload) > max_bytes:
+        raise ValueError(f"API reply too large (> {max_bytes} B)")
+    return json.loads(payload.decode("utf-8"))
+
+
+def fetch_pages(titles, timeout=30, max_bytes=None):
+    """Current text of these pages: {pageid: {pageid, title, text}}.
+
+    Redirects, missing pages and stubs under 50 characters are left out. Uses
+    the API, 50 titles a call: since 2026-10 necyklopedie.org answers a POST
+    to Special:Export with 405.
+    """
+    results = {}
+    for i in range(0, len(titles), 50):
+        params = {
+            "action": "query", "prop": "revisions", "rvprop": "content",
+            "rvslots": "main", "formatversion": "2", "titles": "|".join(titles[i:i + 50]),
+        }
+        while True:
+            data = api_get(params, timeout, max_bytes)
+            for page in data.get("query", {}).get("pages", []):
+                if page.get("redirect") or "revisions" not in page:
+                    continue  # a page held back by a size limit comes after `continue`
+                text = wikitext_to_plaintext(page["revisions"][0]["slots"]["main"]["content"])
+                if len(text) >= 50:
+                    results[page["pageid"]] = {
+                        "pageid": page["pageid"], "title": page["title"], "text": text,
+                    }
+            if "continue" not in data:
+                break
+            params.update(data["continue"])
+    return results
+
+
+def get_all_titles():
+    """Enumerate all article titles in namespace 0."""
+    if os.path.exists(TITLES_CACHE):
+        with open(TITLES_CACHE, "r", encoding="utf-8") as f:
+            titles = json.load(f)
+        print(f"Nalezeno {len(titles)} titulků v keši. Necyklopedie si pamatuje.", file=sys.stderr)
+        return titles
+
+    titles = []
+    params = {"action": "query", "list": "allpages", "apnamespace": "0", "aplimit": "500"}
+
+    while True:
+        data = api_get(params)
+        for page in data["query"]["allpages"]:
+            titles.append({"pageid": page["pageid"], "title": page["title"]})
+        print(f"\rProbírám se seznamem článků... {len(titles)}", end="", file=sys.stderr)
+        if "continue" not in data:
+            break
+        params["apcontinue"] = data["continue"]["apcontinue"]
+        time.sleep(0.5)
+
+    print(f"\nNalezeno {len(titles)} článků. Tolik pravdy na jednom místě!", file=sys.stderr)
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    with open(TITLES_CACHE, "w", encoding="utf-8") as f:
+        json.dump(titles, f, ensure_ascii=False)
+    return titles
+
+
+def bulk_export(titles):
+    """Export all articles via Special:Export in one POST request."""
+    if os.path.exists(DUMP_FILE):
+        print(f"Používám keš ({DUMP_FILE}). Necyklopedie se stahuje jen jednou.", file=sys.stderr)
+        return
+
+    all_titles = "\n".join(t["title"] for t in titles)
+    print(f"Stahuji {len(titles)} stránek přes Special:Export — tohle chvíli potrvá...", file=sys.stderr)
+
+    data = urllib.parse.urlencode({
+        "catname": "",
+        "pages": all_titles,
+        "curonly": "1",
+        "wpDownload": "1",
+    }).encode()
+    req = urllib.request.Request(EXPORT_URL, data=data, headers={"User-Agent": UA})
+    resp = urllib.request.urlopen(req, timeout=300)
+    content = resp.read()
+
+    with open(DUMP_FILE, "wb") as f:
+        f.write(content)
+    print(f"Staženo {len(content) / 1e6:.1f} MB čisté moudrosti do {DUMP_FILE}.", file=sys.stderr)
+
+
+def wikitext_to_plaintext(wikitext):
+    """Convert MediaWiki wikitext to clean plaintext."""
+    text = wikitext
+
+    # Remove categories, interwiki links
+    text = re.sub(r"\[\[Kategorie:[^\]]*\]\]", "", text)
+    text = re.sub(r"\[\[[a-z]{2,3}:[^\]]*\]\]", "", text)
+
+    # Remove files/images: [[Soubor:...]] [[File:...]] [[Image:...]]
+    text = re.sub(r"\[\[(?:Soubor|File|Image|Obrázek):[^\]]*\]\]", "", text, flags=re.IGNORECASE)
+
+    # Remove templates {{...}} — handle nested braces
+    for _ in range(5):  # multiple passes for nesting
+        text = re.sub(r"\{\{[^{}]*\}\}", "", text)
+
+    # Remove HTML tags
+    text = re.sub(r"<ref[^>]*>.*?</ref>", "", text, flags=re.DOTALL)
+    text = re.sub(r"<ref[^/]*/?>", "", text)
+    text = re.sub(r"<gallery[^>]*>.*?</gallery>", "", text, flags=re.DOTALL)
+    text = re.sub(r"<nowiki>.*?</nowiki>", "", text, flags=re.DOTALL)
+    text = re.sub(r"<[^>]+>", "", text)
+
+    # Remove tables {| ... |}
+    text = re.sub(r"\{\|.*?\|\}", "", text, flags=re.DOTALL)
+
+    # Convert wikilinks [[target|display]] -> display, [[target]] -> target
+    text = re.sub(r"\[\[[^\]]*?\|([^\]]*?)\]\]", r"\1", text)
+    text = re.sub(r"\[\[([^\]]*?)\]\]", r"\1", text)
+
+    # Remove external links [url text] -> text
+    text = re.sub(r"\[https?://\S+\s+([^\]]+)\]", r"\1", text)
+    text = re.sub(r"\[https?://\S+\]", "", text)
+
+    # Convert headers === Text === -> Text
+    text = re.sub(r"^(=+)\s*(.+?)\s*\1\s*$", r"\2", text, flags=re.MULTILINE)
+
+    # Remove bold/italic markers
+    text = re.sub(r"'{2,5}", "", text)
+
+    # Remove magic words / behavior switches
+    text = re.sub(r"__[A-Z]+__", "", text)
+
+    # Clean up whitespace
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    return text.strip()
+
+
+def _fetch_parsed_html(title):
+    """Fetch rendered HTML for a page via MediaWiki API and extract plaintext.
+
+    Used as fallback for template-heavy pages where wikitext stripping yields nothing.
+    Also follows redirects to other namespaces (e.g. Necyklopedie:Necyklokrám).
+    """
+    try:
+        params = urllib.parse.urlencode({
+            "action": "parse", "page": title, "prop": "text", "format": "json",
+        })
+        url = f"{API_URL}?{params}"
+        req = urllib.request.Request(url, headers={"User-Agent": UA})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        html = data.get("parse", {}).get("text", {}).get("*", "")
+        if not html:
+            return ""
+        # Strip HTML tags, keeping text
+        text = re.sub(r"<style[^>]*>.*?</style>", "", html, flags=re.DOTALL)
+        text = re.sub(r"<script[^>]*>.*?</script>", "", text, flags=re.DOTALL)
+        text = re.sub(r"<[^>]+>", " ", text)
+        # Decode HTML entities
+        import html as html_mod
+        text = html_mod.unescape(text)
+        # Clean whitespace
+        text = re.sub(r"[ \t]+", " ", text)
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        return text.strip()
+    except Exception:  # noqa: BLE001 - best-effort fallback (network, HTTP, JSON); "" skips the page
+        return ""
+
+
+# Minimum plaintext length from wikitext before trying HTML fallback
+MIN_WIKITEXT_LEN = 20
+# Minimum length for HTML fallback result to be accepted
+MIN_HTML_LEN = 50
+# Max pages to fetch via HTML fallback (rate-limited)
+MAX_HTML_FALLBACKS = 200
+
+
+def parse_dump():
+    """Parse XML dump and extract articles as JSONL.
+
+    Pages whose wikitext converts to very short plaintext (template-heavy pages)
+    get a second chance via the MediaWiki parse API which renders templates.
+    """
+    print(f"Parsuju {DUMP_FILE} — převádím wikisyntaxi na čistý text...", file=sys.stderr)
+    tree = ET.parse(DUMP_FILE)
+    root = tree.getroot()
+
+    total = 0
+    skipped = 0
+    html_fallback_candidates = []
+
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        for page in root.findall(".//mw:page", MW_NS):
+            # Skip redirects — but collect redirect targets for HTML fallback
+            redirect_el = page.find("mw:redirect", MW_NS)
+            if redirect_el is not None:
+                title = page.findtext("mw:title", "", MW_NS)
+                pageid = int(page.findtext("mw:id", "", MW_NS))
+                target = redirect_el.get("title", "")
+                # If redirect points to a non-main namespace, try HTML fallback
+                if ":" in target and not target.startswith("Kategorie:"):
+                    html_fallback_candidates.append((pageid, title))
+                skipped += 1
+                continue
+
+            title = page.findtext("mw:title", "", MW_NS)
+            pageid = int(page.findtext("mw:id", "", MW_NS))
+            wikitext = page.findtext(".//mw:text", "", MW_NS)
+
+            plaintext = wikitext_to_plaintext(wikitext)
+
+            if len(plaintext) < MIN_WIKITEXT_LEN:
+                # Template-heavy page — candidate for HTML fallback
+                html_fallback_candidates.append((pageid, title))
+                continue
+
+            record = {"pageid": pageid, "title": title, "text": plaintext}
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+            total += 1
+
+        print(f"\r[{total + skipped}] Uloženo {total}, přeskočeno {skipped}...", end="", file=sys.stderr)
+
+    # Phase 2: HTML fallback for template-heavy pages
+    if html_fallback_candidates:
+        candidates = html_fallback_candidates[:MAX_HTML_FALLBACKS]
+        print(f"\nZkouším HTML fallback pro {len(candidates)} šablonových stránek...", file=sys.stderr)
+        fetched = 0
+        with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
+            for i, (pageid, title) in enumerate(candidates):
+                plaintext = _fetch_parsed_html(title)
+                if len(plaintext) >= MIN_HTML_LEN:
+                    record = {"pageid": pageid, "title": title, "text": plaintext}
+                    f.write(json.dumps(record, ensure_ascii=False) + "\n")
+                    fetched += 1
+                    total += 1
+                else:
+                    skipped += 1
+                if (i + 1) % 10 == 0:
+                    print(f"\r  [{i + 1}/{len(candidates)}] Získáno {fetched}...", end="", file=sys.stderr)
+                time.sleep(0.3)  # rate limit
+        print(f"\n  HTML fallback: {fetched} stránek doplněno.", file=sys.stderr)
+
+    print(f"Hotovo. {total} článků uloženo do {OUTPUT_FILE}. Pravda je připravena k indexaci.", file=sys.stderr)
+
+
+def scrape():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Phase 1: enumerate titles
+    titles = get_all_titles()
+
+    # Phase 2: bulk export
+    bulk_export(titles)
+
+    # Phase 3: parse to plaintext JSONL
+    parse_dump()
+
+
+if __name__ == "__main__":
+    scrape()

startup.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+"""
+startup.py — Web server with loading screen during initialization.
+
+Starts serving immediately with a funny loading page, then initializes
+the full app in a background thread and hot-swaps when ready.
+"""
+
+import asyncio
+import contextlib
+import os
+import re
+import threading
+import time
+import traceback
+
+import uvicorn
+import uvicorn.logging
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+import startup_progress as sp
+
+LOADING_HTML = """<!DOCTYPE html>
+<html lang="cs">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>OpenAjaj — Startuje...</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: #1a1208;
+  color: #f0e0b0;
+  height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+}
+.logo-wrap {
+  display: flex; align-items: center; gap: 14px; margin-bottom: 20px;
+}
+.logo-wrap img { width: 80px; height: 80px; object-fit: contain; border-radius: 16px; }
+.logo-wrap span { font-size: 2.6rem; font-weight: 800; color: #c8a030; letter-spacing: -.5px; }
+h1 { font-size: 32px; margin-bottom: 12px; }
+.status { color: #9a8455; font-size: 16px; margin-bottom: 24px; text-align: center; line-height: 1.6; }
+.spinner {
+  width: 60px; height: 60px;
+  animation: spin 2s ease-in-out infinite;
+}
+.spinner img { width: 100%; height: 100%; object-fit: contain; }
+@keyframes spin { to { transform: rotate(360deg); } }
+.quotes { color: #9a8455; font-style: italic; font-size: 13px; margin-top: 24px; max-width: 500px; text-align: center; }
+
+/* Progress section */
+.progress-section { margin: 20px 0; width: 100%; max-width: 680px; }
+.progress-bar-wrap {
+  background: #3d2e10; border-radius: 8px; height: 20px; overflow: hidden; margin: 8px 0;
+}
+.progress-bar {
+  background: linear-gradient(90deg, #c8a030, #e0b840);
+  height: 100%; border-radius: 8px;
+  transition: width 0.4s ease;
+}
+.progress-label { font-size: 12px; color: #9a8455; text-align: center; margin-bottom: 4px; }
+.model-list { margin-top: 12px; font-size: 12px; }
+.model-row { display: flex; align-items: center; gap: 8px; padding: 3px 0; }
+.model-row .icon { width: 16px; text-align: center; }
+.model-row .name { color: #f0e0b0; flex: 0 0 auto; white-space: nowrap; min-width: 200px; }
+.model-row .detail { color: #9a8455; font-size: 11px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.model-row.testing .name { color: #c8a030; }
+.model-row.fail .name { color: #9a8455; text-decoration: line-through; }
+</style>
+</head>
+<body>
+<div class="logo-wrap"><img src="/static/logo.png" alt="OpenAjaj"><span>OpenAjaj</span></div>
+<div style="color:#c8a030;font-size:14px;margin-bottom:16px;letter-spacing:1px">poháněný Necyklopedií — jedinou encyklopedií, která se odvážila říct pravdu</div>
+<div class="status" id="statusText">
+  Probouzím mozkovou hmotu z necyklopedického spánku...
+</div>
+<div class="progress-section" id="progressSection" style="display:none">
+  <div class="progress-label" id="progressLabel">Testuji modely...</div>
+  <div class="progress-bar-wrap"><div class="progress-bar" id="progressBar" style="width:0%"></div></div>
+  <div class="model-list" id="modelList"></div>
+</div>
+<div class="spinner" id="spinner"><img src="/static/logo.png" alt=""></div>
+<div class="quotes" id="quote"></div>
+<script>
+const quotes = [
+  "Dle nejnovějších necyklopedických výzkumů trvá startování serveru přesně tak dlouho, jak má.",
+  "Věděli jste, že Brno se rusky řekne Шалинград? Ani my ne, ale Necyklopedie ano.",
+  "Čáp nosí děti. Server nosí pravdu. Oba potřebují chvilku.",
+  "Trpělivost je ctnost. Netrpělivost je hřích. Načítání je nevyhnutelné.",
+  "Probíhá kalibrace sebevědomí. Momentálně na 73%.",
+  "Chuck Norris by tento server nastartoval pohledem. My potřebujeme pár sekund.",
+  "Server se startuje rychleji než vlak z Brněnského hlavního nádraží. A to je co říct.",
+];
+document.getElementById('quote').textContent = quotes[Math.floor(Math.random() * quotes.length)];
+
+function pollProgress() {
+  fetch('/api/init-status').then(r => r.json()).then(d => {
+    if (d.phase === 'ready') {
+      location.reload();
+      return;
+    }
+    if (d.phase === 'benchmark') {
+      document.getElementById('progressSection').style.display = 'block';
+      const models = d.models || {};
+      const total = d.total || 1;
+      const done = Object.values(models).filter(m => m.status !== 'testing').length;
+      const pct = Math.round(done / total * 100);
+      document.getElementById('progressBar').style.width = pct + '%';
+      document.getElementById('progressLabel').textContent =
+        'Škola života zadává test... ' + done + '/' + total + ' mozků promluvilo';
+
+      const list = document.getElementById('modelList');
+      list.innerHTML = '';
+      for (const [name, info] of Object.entries(models)) {
+        const s = info.status;
+        const icon = s === 'testing' ? '⏳' : s === 'ok' ? '✓' : '✗';
+        const row = document.createElement('div');
+        row.className = 'model-row ' + s;
+        const shortName = name.split('/').pop();
+        row.innerHTML = '<span class="icon">' + icon + '</span>' +
+          '<span class="name">' + shortName + '</span>' +
+          '<span class="detail">' + (info.detail || '') + '</span>';
+        list.appendChild(row);
+      }
+    }
+    setTimeout(pollProgress, 300);
+  }).catch(() => setTimeout(pollProgress, 1000));
+}
+pollProgress();
+</script>
+</body>
+</html>"""
+
+_CS_TOKEN = re.compile(r"(cs=)[^&\s\"]+")
+
+
+class RedactingAccessFormatter(uvicorn.logging.AccessFormatter):
+    """Keep captcha session tokens out of the access log.
+
+    The captcha redirects to /?cs=<token> and the request line is logged
+    verbatim, so every solve used to leave a replayable 7-day token in
+    logs/access.log — which analytics/report.py then reads.
+    """
+
+    def formatMessage(self, record) -> str:
+        return _CS_TOKEN.sub(r"\1***", super().formatMessage(record))
+
+
+# Phase 1: Start a minimal loading server immediately
+loading_app = FastAPI()
+loading_app.mount("/static", StaticFiles(directory="static"), name="static")
+real_app = None
+app_ready = threading.Event()
+
+
+@loading_app.get("/api/init-status")
+async def init_status():
+    """Return current initialization progress for the loading page."""
+    return JSONResponse(sp.snapshot())
+
+
+@loading_app.get("/{path:path}")
+async def loading_page(path: str = ""):
+    if app_ready.is_set():
+        return HTMLResponse(
+            '<html><head><meta http-equiv="refresh" content="0"></head>'
+            '<body>Přesměrovávám...</body></html>'
+        )
+    if f"/{path}" in _EARLY_PATHS:
+        # web.py is still importing: a second or two, not the whole boot
+        return HTMLResponse(
+            '<html><head><meta http-equiv="refresh" content="1"></head>'
+            '<body>Spouštím přepis…</body></html>'
+        )
+    return HTMLResponse(LOADING_HTML)
+
+
+# Transcription, the captcha in front of it and /stats need nothing from
+# web.boot(), so they are served by the real app as soon as web.py is imported.
+# The boot runs models and the index, which can be slow or fail; they must not
+# wait on it.
+_EARLY_PATHS = {
+    "/t", "/transcribe", "/api/stt", "/api/stt/check", "/api/stt/usage",
+    "/api/stt/token", "/captcha", "/api/captcha/challenge", "/api/captcha/verify",
+    "/stats", "/api/visits", "/api/stt/quality",
+}
+
+
+def init_real_app():
+    """Import the full app (transcription goes live), then boot the rest."""
+    global real_app
+    import web
+    real_app = web.app
+    print("=== Transcription ready ===", flush=True)
+    try:
+        web.boot()
+    except Exception:  # noqa: BLE001 - a failed boot must not take /t down with it
+        traceback.print_exc()
+        return
+    app_ready.set()
+    print("=== Real app ready, swap complete ===", flush=True)
+
+
+# An early path arriving while web.py imports waits for it rather than getting
+# a stand-in page; past this, the stand-in (a 1 s refresh) answers instead.
+_IMPORT_WAIT_S = 30
+
+
+class SwappableApp:
+    """The loading page until the boot is done; transcription from import on."""
+
+    async def __call__(self, scope, receive, send):
+        early = scope.get("path") in _EARLY_PATHS
+        for _ in range(_IMPORT_WAIT_S * 10):
+            if not early or real_app is not None:
+                break
+            await asyncio.sleep(0.1)
+        if real_app is not None and (app_ready.is_set() or early):
+            await real_app(scope, receive, send)
+        else:
+            await loading_app(scope, receive, send)
+
+
+def _kill_existing_server():
+    """Kill any existing server on the same port."""
+    port = int(os.environ.get("PORT", "8000"))
+    import subprocess
+    # Best effort: no lsof (OSError), a hung lsof (SubprocessError), or a PID
+    # that is gone or not ours (OSError) — a real conflict fails the bind later.
+    with contextlib.suppress(OSError, subprocess.SubprocessError, ValueError):
+        result = subprocess.run(
+            ["lsof", "-ti", f":{port}"],
+            capture_output=True, text=True, timeout=5, check=False)
+        pids = result.stdout.strip().split()
+        for pid in pids:
+            if pid and pid != str(os.getpid()):
+                os.kill(int(pid), 9)
+                print(f"Killed existing server (PID {pid}) on port {port}", flush=True)
+    time.sleep(0.5)
+
+
+def main():
+    _kill_existing_server()
+    init_thread = threading.Thread(target=init_real_app, daemon=True)
+    init_thread.start()
+
+    port = int(os.environ.get("PORT", "8000"))
+    # The captcha gate is only installed when SPACE_ID is set, so a local run
+    # has no gate at all — don't offer it to the whole network. Set HOST to
+    # override when running the container somewhere other than HF.
+    host = os.environ.get("HOST") or ("0.0.0.0" if os.environ.get("SPACE_ID") else "127.0.0.1")
+    uvicorn.run(SwappableApp(), host=host, port=port,
+                access_log=True, log_config={
+                    "version": 1,
+                    "disable_existing_loggers": False,
+                    "formatters": {
+                        "access": {
+                            "()": RedactingAccessFormatter,  # the class, not a path: startup.py runs as __main__
+                            "fmt": '%(asctime)s %(client_addr)s - "%(request_line)s" %(status_code)s',
+                            "datefmt": "%Y-%m-%dT%H:%M:%S",
+                            "use_colors": False,  # colour codes break analytics/parser.py
+                        },
+                        "default": {
+                            "fmt": "%(levelprefix)s %(message)s",
+                            "use_colors": False,
+                        },
+                        # "format", not "fmt": the formatters above are
+                        # "()"-style callables that take fmt as a kwarg, but a
+                        # plain dictConfig formatter reads "format" and
+                        # silently falls back to bare %(message)s without it.
+                        "app": {
+                            "format": "%(asctime)s %(levelname)s %(message)s",
+                            "datefmt": "%Y-%m-%dT%H:%M:%S",
+                        },
+                    },
+                    "handlers": {
+                        "access_file": {
+                            "class": "logging.FileHandler",
+                            "filename": "logs/access.log",
+                            "formatter": "access",
+                        },
+                        "default": {
+                            "class": "logging.StreamHandler",
+                            "formatter": "default",
+                            "stream": "ext://sys.stdout",
+                        },
+                        # Rotating, not plain: a refusal line is written by
+                        # whatever is hammering the limit, so the volume is set
+                        # by the caller and not by us.
+                        "app_file": {
+                            "class": "logging.handlers.RotatingFileHandler",
+                            "filename": "logs/app.log",
+                            "maxBytes": 5_000_000,
+                            "backupCount": 3,
+                            "formatter": "app",
+                        },
+                    },
+                    "loggers": {
+                        "uvicorn.access": {"handlers": ["access_file"], "level": "INFO", "propagate": False},
+                        "uvicorn.error": {"handlers": ["default"], "level": "INFO"},
+                        "ajaj": {"handlers": ["app_file"], "level": "INFO", "propagate": False},
+                    },
+                })
+
+
+if __name__ == "__main__":
+    main()

startup_progress.py

@@ -0,0 +1,33 @@
+"""
+startup_progress.py — Shared state for startup benchmark progress.
+
+Used by web.py (writer) and startup.py (reader) to show live progress
+on the loading page while models are being tested.
+"""
+
+import threading
+
+_lock = threading.Lock()
+
+# Current phase: "init", "benchmark", "ready"
+phase: str = "init"
+total: int = 0
+
+# model -> {"status": "testing"|"ok"|"fail", "detail": str}
+_models: dict[str, dict] = {}
+
+
+def update(model: str, status: str, detail: str = "", provider: str = ""):
+    """Record a model's benchmark status. Thread-safe."""
+    with _lock:
+        _models[model] = {"status": status, "detail": detail, "provider": provider}
+
+
+def snapshot() -> dict:
+    """Return current progress snapshot for the loading page."""
+    with _lock:
+        return {
+            "phase": phase,
+            "total": total,
+            "models": dict(_models),
+        }

static/providers.html

@@ -0,0 +1,218 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>OpenAjaj — Provider Reliability</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: #0f0f1a;
+  color: #d0d0e8;
+  min-height: 100vh;
+  padding: 20px 24px;
+}
+a { color: #6fa8dc; text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+.header { margin-bottom: 24px; }
+.header h1 { font-size: 20px; font-weight: 700; margin-bottom: 6px; }
+.header nav { font-size: 13px; color: #666680; display: flex; gap: 16px; }
+
+/* ── Summary cards ── */
+.cards { display: flex; gap: 12px; flex-wrap: wrap; margin-bottom: 24px; }
+.card {
+  background: #1a1a2e; border: 1px solid #2a2a48; border-radius: 10px;
+  padding: 12px 18px; min-width: 110px;
+}
+.card .v { font-size: 24px; font-weight: 800; }
+.card .l { font-size: 10px; color: #666680; text-transform: uppercase; letter-spacing: .5px; margin-top: 2px; }
+
+/* ── Provider rows ── */
+.prov {
+  background: #1a1a2e; border: 1px solid #2a2a48; border-radius: 10px;
+  margin-bottom: 10px; overflow: hidden;
+}
+.prov-head {
+  display: grid; grid-template-columns: 130px 70px 1fr 200px 30px;
+  align-items: center; gap: 12px; padding: 14px 18px; cursor: pointer;
+  transition: background .15s;
+}
+.prov-head:hover { background: #22223a; }
+.prov-name { font-weight: 700; font-size: 15px; }
+.prov-rel { font-size: 22px; font-weight: 800; text-align: right; }
+.prov-bar { background: #12122a; border-radius: 5px; height: 8px; overflow: hidden; }
+.prov-bar-fill { height: 100%; border-radius: 5px; transition: width .5s; }
+.prov-stats { font-size: 11px; color: #666680; text-align: right; white-space: nowrap; }
+.prov-arrow { font-size: 12px; color: #444460; transition: transform .2s; text-align: center; }
+.prov-arrow.open { transform: rotate(90deg); }
+
+/* ── Model detail table ── */
+.models { display: none; border-top: 1px solid #2a2a48; }
+.models.open { display: block; }
+.models table { width: 100%; border-collapse: collapse; font-size: 12px; }
+.models th {
+  background: #141428; padding: 6px 14px; text-align: left;
+  color: #555570; font-size: 10px; text-transform: uppercase; letter-spacing: .4px;
+}
+.models td { padding: 8px 14px; border-bottom: 1px solid #1a1a30; }
+.models tr:hover { background: #1e1e34; }
+
+.tag {
+  display: inline-block; font-size: 9px; padding: 1px 6px; border-radius: 3px;
+  font-weight: 700; vertical-align: middle;
+}
+.tag-free { background: #0f2a1a; color: #4ec88a; border: 1px solid #1a4a2a; }
+.tag-paid { background: #2a1a0f; color: #c88a4e; border: 1px solid #4a2a1a; }
+
+.err-text { color: #d04040; font-size: 10px; margin-top: 2px; }
+.speed { color: #4ec88a; font-weight: 600; }
+.muted { color: #444460; }
+
+.bar-sm { display: inline-block; width: 50px; height: 5px; background: #1a1a30; border-radius: 3px; overflow: hidden; vertical-align: middle; }
+.bar-sm-fill { height: 100%; border-radius: 3px; }
+
+.loading { text-align: center; padding: 60px; color: #555570; }
+
+/* ── Tooltip ── */
+#tip {
+  position: fixed; display: none; background: #1a1a30; color: #c0c0e0;
+  border: 1px solid #3a3a60; border-radius: 6px; padding: 6px 10px;
+  font-size: 11px; max-width: 300px; z-index: 999; pointer-events: none;
+  line-height: 1.4; box-shadow: 0 4px 20px rgba(0,0,0,.6);
+}
+</style>
+</head>
+<body>
+
+<div class="header">
+  <h1>Provider Reliability</h1>
+  <nav>
+    <span>Live reliability from real API calls</span>
+    <a href="/results">Model IQ Table</a>
+    <a href="/">Chat</a>
+  </nav>
+</div>
+
+<div id="app"><div class="loading">Loading...</div></div>
+<div id="tip"></div>
+
+<script>
+const $ = id => document.getElementById(id);
+let data = [];
+let open = new Set();
+
+function rc(p) {
+  if (p == null) return '#444460';
+  return p >= 90 ? '#4ec88a' : p >= 70 ? '#d8b84e' : '#d04040';
+}
+
+// Provider error strings and auto-discovered model ids come from outside this
+// app and land in innerHTML — escape them. See SECURITY.md M-4.
+const esc = s => String(s).replace(/[&<>"]/g, c =>
+  ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+
+function render() {
+  const totP = data.length;
+  const totA = data.reduce((s, p) => s + p.attempts, 0);
+  const totS = data.reduce((s, p) => s + p.successes, 0);
+  const totE = data.reduce((s, p) => s + p.errors, 0);
+  const avgR = totA ? Math.round(totS / totA * 100) : 0;
+
+  let h = `
+  <div class="cards">
+    <div class="card"><div class="v">${totP}</div><div class="l">Providers</div></div>
+    <div class="card"><div class="v">${totA}</div><div class="l">API Calls</div></div>
+    <div class="card"><div class="v" style="color:${totE ? '#d04040' : '#4ec88a'}">${totE}</div><div class="l">Errors</div></div>
+    <div class="card"><div class="v" style="color:${rc(avgR)}">${avgR}%</div><div class="l">Overall</div></div>
+  </div>`;
+
+  for (const p of data) {
+    const r = p.reliability;
+    const c = rc(r);
+    const isOpen = open.has(p.provider);
+    const errPct = p.attempts ? Math.round(p.errors / p.attempts * 100) : 0;
+
+    let statsArr = [`${p.successes}/${p.attempts} ok`];
+    if (p.errors) statsArr.push(`${p.errors} err (${errPct}%)`);
+    statsArr.push(`${p.models.length} model${p.models.length !== 1 ? 's' : ''}`);
+    if (p.avg_ttft != null) statsArr.push(`${p.avg_ttft.toFixed(1)}s TTFT`);
+    if (p.avg_tok_sec != null) statsArr.push(`${Math.round(p.avg_tok_sec)} tok/s`);
+
+    h += `
+    <div class="prov">
+      <div class="prov-head" onclick="tog('${p.provider}')">
+        <div class="prov-name">${esc(p.provider)}</div>
+        <div class="prov-rel" style="color:${c}">${r != null ? r + '%' : '—'}</div>
+        <div class="prov-bar"><div class="prov-bar-fill" style="width:${r || 0}%;background:${c}"></div></div>
+        <div class="prov-stats">${statsArr.join(' · ')}</div>
+        <div class="prov-arrow${isOpen ? ' open' : ''}">&#9654;</div>
+      </div>
+      <div class="models${isOpen ? ' open' : ''}">
+        <table>
+          <tr><th>Model</th><th>Tier</th><th>Reliability</th><th>Calls</th><th>Errors</th><th>TTFT</th><th>Tok/s</th><th></th></tr>
+          ${p.models.map(m => {
+            const mc = rc(m.reliability);
+            const shortName = esc(m.id.split('/').pop());
+            const fullId = m.id.includes('/') ? `<div style="color:#444460;font-size:10px">${esc(m.id)}</div>` : '';
+            const errLine = m.last_error_msg ? `<div class="err-text">${esc(m.last_error_msg)}</div>` : '';
+            return `<tr>
+              <td><div style="font-weight:600">${shortName}</div>${fullId}${errLine}</td>
+              <td>${m.free ? '<span class="tag tag-free">FREE</span>' : '<span class="tag tag-paid">PAID</span>'}</td>
+              <td style="font-weight:700;color:${mc}">${m.reliability != null ? m.reliability + '%' : '—'}</td>
+              <td class="muted">${m.attempts}</td>
+              <td style="color:${m.errors ? '#d04040' : '#444460'}">${m.errors}</td>
+              <td>${m.ttft != null ? `<span class="speed">${m.ttft.toFixed(1)}s</span>` : '<span class="muted">—</span>'}</td>
+              <td>${m.tok_sec != null ? `<span class="speed">${m.tok_sec.toFixed(0)}</span>` : '<span class="muted">—</span>'}</td>
+              <td><div class="bar-sm"><div class="bar-sm-fill" style="width:${m.reliability||0}%;background:${mc}"></div></div></td>
+            </tr>`;
+          }).join('')}
+        </table>
+      </div>
+    </div>`;
+  }
+
+  $('app').innerHTML = h;
+}
+
+function tog(id) {
+  open.has(id) ? open.delete(id) : open.add(id);
+  render();
+}
+
+async function load() {
+  try {
+    const resp = await fetch('/api/provider-reliability');
+    const json = await resp.json();
+    if (json.error) throw new Error(json.error);
+    data = json.providers || [];
+    render();
+  } catch (e) {
+    $('app').innerHTML = `<div class="loading" style="color:#d04040">Error: ${e.message}</div>`;
+  }
+}
+
+// Tooltips
+const tip = $('tip');
+document.addEventListener('mouseover', e => {
+  const el = e.target.closest('[data-tip]');
+  if (!el) { tip.style.display = 'none'; return; }
+  tip.textContent = el.dataset.tip;
+  tip.style.display = 'block';
+});
+document.addEventListener('mousemove', e => {
+  if (tip.style.display !== 'block') return;
+  let x = e.clientX + 12, y = e.clientY + 12;
+  if (x + 310 > innerWidth) x = e.clientX - 310;
+  if (y + 60 > innerHeight) y = e.clientY - 60;
+  tip.style.left = x + 'px'; tip.style.top = y + 'px';
+});
+document.addEventListener('mouseout', e => {
+  if (!e.target.closest('[data-tip]')) tip.style.display = 'none';
+});
+
+load();
+</script>
+</body>
+</html>

static/results.html

@@ -0,0 +1,647 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>OpenAjaj — Model IQ Table</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: #1a1a2e;
+  color: #e0e0f0;
+  min-height: 100vh;
+  padding: 24px;
+}
+h1 { font-size: 22px; font-weight: 700; margin-bottom: 4px; }
+.subtitle { color: #8888aa; font-size: 13px; margin-bottom: 24px; display: flex; gap: 16px; align-items: center; flex-wrap: wrap; }
+.subtitle a { color: #7c9fce; text-decoration: none; }
+.subtitle a:hover { text-decoration: underline; }
+.lang-btn {
+  background: #252540; border: 1px solid #3a3a5c; color: #aaaacc;
+  padding: 4px 12px; border-radius: 6px; font-size: 12px; cursor: pointer;
+  font-weight: 600; letter-spacing: 0.5px;
+}
+.lang-btn:hover { background: #2a3a5a; border-color: #7c9fce; color: #e0e0f0; }
+
+.summary {
+  display: flex; gap: 16px; flex-wrap: wrap; margin-bottom: 28px;
+}
+.stat-card {
+  background: #252540; border: 1px solid #3a3a5c; border-radius: 10px;
+  padding: 14px 20px; min-width: 130px;
+}
+.stat-card .num { font-size: 26px; font-weight: 700; color: #7ee8a2; }
+.stat-card .lbl { font-size: 11px; color: #8888aa; margin-top: 2px; text-transform: uppercase; letter-spacing: 0.5px; }
+
+.type-legend {
+  display: flex; gap: 10px; flex-wrap: wrap; margin-bottom: 20px; align-items: center;
+}
+.type-badge {
+  font-size: 11px; padding: 3px 10px; border-radius: 20px; font-weight: 600;
+  background: #252540; color: #aaaacc; border: 1px solid #3a3a5c;
+}
+.legend-title { font-size: 11px; color: #555577; }
+
+/* Semaphore colors */
+.sem-green  { color: #5ec98a; }
+.sem-yellow { color: #e8c45e; }
+.sem-red    { color: #e05050; }
+
+table { width: 100%; border-collapse: collapse; font-size: 13px; }
+thead th {
+  background: #252540; padding: 8px 8px; text-align: left;
+  border-bottom: 2px solid #3a3a5c; color: #aaaacc; font-size: 10px;
+  text-transform: uppercase; letter-spacing: 0.4px; cursor: pointer;
+  user-select: none; line-height: 1.3; vertical-align: bottom;
+}
+thead th:hover { color: #e0e0f0; }
+thead th.sorted { color: #7ee8a2; }
+tbody tr { border-bottom: 1px solid #252540; cursor: pointer; transition: background 0.1s; }
+tbody tr:hover { background: #252540; }
+tbody tr.expanded { background: #1e1e38; }
+td { padding: 7px 8px; vertical-align: middle; }
+
+.model-name { font-weight: 600; font-size: 13px; }
+.model-short { color: #aaaacc; font-size: 11px; margin-top: 1px; }
+.provider-tag {
+  display: inline-block; font-size: 10px; padding: 2px 7px;
+  border-radius: 4px; font-weight: 600; margin-right: 4px;
+  background: #2a2a50; color: #9090cc; border: 1px solid #3a3a6a;
+  vertical-align: middle;
+}
+.free-tag {
+  display: inline-block; font-size: 10px; padding: 2px 6px;
+  border-radius: 4px; background: #1a3a2a; color: #5ec98a;
+  border: 1px solid #2a5a3a; font-weight: 600; vertical-align: middle;
+}
+.paid-tag {
+  display: inline-block; font-size: 10px; padding: 2px 6px;
+  border-radius: 4px; background: #3a2a1a; color: #c98a5e;
+  border: 1px solid #5a3a1a; font-weight: 600; vertical-align: middle;
+}
+
+.score-cell { font-weight: 700; font-size: 15px; white-space: nowrap; }
+.score-pct { color: #aaaacc; font-size: 13px; font-weight: 700; margin-left: 6px; }
+
+.bar-wrap { background: #2a2a44; border-radius: 4px; height: 8px; width: 80px; overflow: hidden; }
+.bar-fill { height: 100%; border-radius: 4px; transition: width 0.5s; }
+
+.type-mini {
+  font-size: 10px; padding: 2px 5px; border-radius: 4px; white-space: nowrap;
+  font-weight: 600; display: inline-block;
+}
+
+/* Expanded detail row */
+.detail-row { display: none; }
+.detail-row.open { display: table-row; }
+.detail-wrap {
+  background: #15152a; padding: 16px 20px; border-radius: 0 0 8px 8px;
+}
+.detail-grid {
+  display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+  gap: 10px; margin-top: 10px;
+}
+.detail-item {
+  background: #1e1e38; border: 1px solid #2e2e50; border-radius: 8px;
+  padding: 10px 12px; font-size: 12px;
+}
+.detail-item .q { color: #aaaacc; margin-bottom: 4px; font-style: italic; }
+.detail-item .r { color: #c0c0e0; line-height: 1.5; word-break: break-word; }
+.detail-item .issues { color: #e05050; font-size: 11px; margin-top: 4px; }
+.detail-item .pass-icon { font-size: 13px; margin-right: 4px; }
+.detail-item .type-lbl { font-size: 10px; opacity: 0.7; margin-bottom: 3px; }
+
+.loading { color: #8888aa; text-align: center; padding: 48px; font-size: 15px; }
+.error { color: #e05050; text-align: center; padding: 48px; }
+.ts { color: #555577; font-size: 11px; }
+
+.filter-bar {
+  display: flex; gap: 10px; flex-wrap: wrap; margin-bottom: 16px; align-items: center;
+}
+.filter-bar input {
+  background: #252540; border: 1px solid #3a3a5c; color: #e0e0f0;
+  padding: 6px 12px; border-radius: 6px; font-size: 13px; outline: none;
+  width: 220px;
+}
+.filter-bar input:focus { border-color: #7c9fce; }
+.filter-btn {
+  background: #252540; border: 1px solid #3a3a5c; color: #aaaacc;
+  padding: 5px 12px; border-radius: 6px; font-size: 12px; cursor: pointer;
+}
+.filter-btn.active { background: #2a3a5a; border-color: #7c9fce; color: #e0e0f0; }
+.refresh-btn {
+  margin-left: auto; background: #1a3a2a; border: 1px solid #2a5a3a;
+  color: #5ec98a; padding: 6px 14px; border-radius: 6px;
+  font-size: 12px; cursor: pointer; font-weight: 600;
+}
+.refresh-btn:hover { background: #2a4a3a; }
+
+.speed-val { font-size: 12px; font-weight: 600; color: #7ee8a2; }
+.speed-na { color: #444466; font-size: 11px; }
+
+/* Custom tooltip */
+#tooltip {
+  position: fixed;
+  background: #2a2a4a;
+  border: 1px solid #4a4a7a;
+  border-radius: 6px;
+  padding: 8px 12px;
+  font-size: 12px;
+  color: #d0d0f0;
+  max-width: 280px;
+  line-height: 1.5;
+  pointer-events: none;
+  z-index: 9999;
+  display: none;
+  box-shadow: 0 4px 16px rgba(0,0,0,0.5);
+}
+</style>
+</head>
+<body>
+
+<div id="tooltip"></div>
+<h1>🧠 OpenAjaj — Model IQ Table</h1>
+<p class="subtitle" id="subtitle-bar">
+  <span id="subtitle-text"></span>
+  <a href="/" id="link-chat"></a>
+  <a href="/providers" id="link-providers"></a>
+  <button class="lang-btn" onclick="toggleLang()" id="langBtn">🇨🇿 Czech</button>
+</p>
+
+<div id="app"><div class="loading" id="initial-loading"></div></div>
+
+<script>
+// ── i18n ─────────────────────────────────────────────────────────────────
+let lang = localStorage.getItem('lang') || 'en';
+
+const I18N = {
+  en: {
+    title: 'Accuracy test results on <strong>Necyklopedia</strong> data.',
+    loading: 'Loading results...',
+    loadingCache: 'Loading results from cache...',
+    totalModels: 'Total models',
+    tested: 'Tested',
+    testsInCache: 'Tests in cache',
+    avgAccuracy: 'Avg accuracy',
+    overallPass: 'Overall pass rate',
+    bestModel: 'Best model',
+    searchPlaceholder: 'Search model / provider...',
+    all: 'All',
+    free: 'Free',
+    paid: 'Paid',
+    refresh: '↻ Refresh',
+    runTest: '▶ Run test',
+    clearAll: '🗑 Clear all',
+    confirmClear: 'Delete all accuracy results?',
+    askToken: 'Admin token:',
+    running: 'Running',
+    gaveUp: 'Gave up on (provider unreachable):',
+    model: 'Model',
+    provider: 'Provider',
+    score: 'Score',
+    bar: 'Bar',
+    iq: 'IQ',
+    iqTip: 'IQ score: 100 = 50% correct, 150 = 100% correct. Based on pass rate.',
+    ttft: 'TTFT',
+    ttftTip: 'Time to First Token: how long (seconds) before the model starts responding. Lower is better.',
+    tokSec: 'Tok/s',
+    tokSecTip: 'Tokens per second: generation speed. Higher is better.',
+    reliability: 'Reliab.',
+    reliabilityTip: 'Reliability: % of real-world calls that succeeded (non-benchmark). Hover a cell for details.',
+    tests: 'Tests',
+    testsTip: 'Number of accuracy test results stored in cache for this model.',
+    detailTitle: 'detailed results',
+    noReply: 'no reply',
+    emptyQuery: '(empty query)',
+    attempts: 'attempts',
+    linkChat: '← Back to chat',
+    linkProviders: 'Provider Reliability →',
+    switchLang: '🇨🇿 Czech',
+    types: {
+      fidelity: 'Fidelity', resistance: 'Resistance', character: 'Character',
+      absurdity: 'Absurdity', language: 'Language', resilience: 'Resilience', other: 'Other'
+    },
+    typeShort: {
+      fidelity: 'FIDELITY', resistance: 'RESISTANCE', character: 'CHARACTER',
+      absurdity: 'ABSURDITY', language: 'LANGUAGE', resilience: 'RESILIENCE', other: 'OTHER'
+    },
+    typeDesc: {
+      fidelity:   'Fidelity: Does the model stay faithful to Necyklopedia source material without hallucinating facts?',
+      resistance: 'Resistance: Does the model resist attempts to break persona, ignore instructions, or reveal it\'s an AI?',
+      character:  'Character: Does the model maintain Necyklopedia\'s absurdist humor, tone and style?',
+      absurdity:  'Absurdity: Can the model handle nonsensical, paradoxical or surreal questions in-character?',
+      language:   'Language: Does the model use correct Czech, including grammar, spelling and diacritics?',
+      resilience: 'Resilience: Does the model recover gracefully from edge cases, errors and unexpected inputs?',
+      other:      'Other: Miscellaneous tests not fitting the above categories.',
+    },
+  },
+  cs: {
+    title: 'Výsledky testu přesnosti na <strong>Necyklopedie</strong> datech.',
+    loading: 'Načítám výsledky...',
+    loadingCache: 'Načítám výsledky z cache...',
+    totalModels: 'Modelů celkem',
+    tested: 'Otestováno',
+    testsInCache: 'Testů v cache',
+    avgAccuracy: 'Průměrná úspěšnost',
+    overallPass: 'Celková úspěšnost',
+    bestModel: 'Nejlepší model',
+    searchPlaceholder: 'Hledat model / provider...',
+    all: 'Všechny',
+    free: 'Zdarma',
+    paid: 'Placené',
+    refresh: '↻ Obnovit',
+    runTest: '▶ Spustit test',
+    clearAll: '🗑 Smazat vše',
+    confirmClear: 'Smazat všechny výsledky testů?',
+    askToken: 'Admin token:',
+    running: 'Běží',
+    gaveUp: 'Vzdáno (provider nedostupný):',
+    model: 'Model',
+    provider: 'Provider',
+    score: 'Skóre',
+    bar: 'Bar',
+    iq: 'IQ',
+    iqTip: 'IQ skóre: 100 = 50 % správně, 150 = 100 % správně. Odvozeno z míry úspěšnosti.',
+    ttft: 'TTFT',
+    ttftTip: 'Time to First Token: za jak dlouho (s) model začne odpovídat. Čím méně, tím lépe.',
+    tokSec: 'Tok/s',
+    tokSecTip: 'Tokeny za sekundu: rychlost generování. Čím více, tím lépe.',
+    reliability: 'Spol.',
+    reliabilityTip: 'Spolehlivost: % skutečných hovorů (mimo benchmark), které proběhly bez chyby. Najeďte myší pro detaily.',
+    tests: 'Testů',
+    testsTip: 'Počet výsledků testů přesnosti uložených v cache pro tento model.',
+    detailTitle: 'detailní výsledky',
+    noReply: 'žádná odpověď',
+    emptyQuery: '(prázdný dotaz)',
+    attempts: 'pokusů',
+    linkChat: '← Zpět do chatu',
+    linkProviders: 'Spolehlivost providerů →',
+    switchLang: '🇬🇧 English',
+    types: {
+      fidelity: 'Věrnost', resistance: 'Odolnost', character: 'Charakter',
+      absurdity: 'Absurdita', language: 'Jazyk', resilience: 'Resilience', other: 'Jiné'
+    },
+    typeShort: {
+      fidelity: 'VĚRNOST', resistance: 'ODOLNOST', character: 'CHARAKTER',
+      absurdity: 'ABSURDITA', language: 'JAZYK', resilience: 'RESILIENCE', other: 'JINÉ'
+    },
+    typeDesc: {
+      fidelity:   'Věrnost: Drží se model zdrojů Necyklopedie a nehalluciniuje fakta?',
+      resistance: 'Odolnost: Odolá model pokusům o prolomení persony, ignorování instrukcí nebo přiznání, že je AI?',
+      character:  'Charakter: Udržuje model absurdní humor, tón a styl Necyklopedie?',
+      absurdity:  'Absurdita: Zvládne model nesmyslné, paradoxní nebo surrealistické otázky v charakteru?',
+      language:   'Jazyk: Používá model správnou češtinu včetně gramatiky, pravopisu a diakritiky?',
+      resilience: 'Resilience: Zvládne model gracefully okrajové případy, chyby a neočekávané vstupy?',
+      other:      'Jiné: Různé testy, které nezapadají do výše uvedených kategorií.',
+    },
+  }
+};
+
+function t(key) { return I18N[lang][key] || key; }
+function tType(type) { return (I18N[lang].types || {})[type] || type; }
+function tTypeShort(type) { return (I18N[lang].typeShort || {})[type] || type.toUpperCase(); }
+function tTypeDesc(type) { return (I18N[lang].typeDesc || {})[type] || type; }
+
+function updateLinks() {
+  document.getElementById('link-chat').textContent = t('linkChat');
+  document.getElementById('link-providers').textContent = t('linkProviders');
+}
+
+function toggleLang() {
+  lang = lang === 'en' ? 'cs' : 'en';
+  localStorage.setItem('lang', lang);
+  document.getElementById('langBtn').textContent = t('switchLang');
+  document.getElementById('subtitle-text').innerHTML = t('title');
+  updateLinks();
+  render();
+}
+
+// ── Semaphore colors ──────────────────────────────────────────────────────
+const TYPE_COLORS = {
+  fidelity:   { bg: '#1a3a4a', text: '#5ec4e8', border: '#2a5a6a' },
+  resistance: { bg: '#3a1a1a', text: '#e87a5e', border: '#6a2a2a' },
+  character:  { bg: '#2a1a3a', text: '#c47ee8', border: '#5a2a6a' },
+  absurdity:  { bg: '#3a2a1a', text: '#e8c45e', border: '#6a4a1a' },
+  language:   { bg: '#1a3a2a', text: '#5ee8a2', border: '#2a6a4a' },
+  resilience: { bg: '#2a2a1a', text: '#e8e05e', border: '#5a5a1a' },
+  other:      { bg: '#252540', text: '#aaaacc', border: '#3a3a5c' },
+};
+
+function semColor(pass, total) {
+  if (!total) return { bg: '#252540', text: '#444466', border: '#333355' };
+  const pct = pass / total * 100;
+  if (pct >= 70) return { bg: '#1a3a2a', text: '#5ec98a', border: '#2a6a4a' };   // green
+  if (pct >= 40) return { bg: '#3a2e1a', text: '#e8c45e', border: '#6a5a2a' };   // yellow/orange
+  return { bg: '#3a1a1a', text: '#e05050', border: '#6a2a2a' };                   // red
+}
+
+function barColor(pct) {
+  if (pct >= 80) return '#5ec98a';
+  if (pct >= 60) return '#e8c45e';
+  if (pct >= 40) return '#e87a5e';
+  return '#c04040';
+}
+
+function iqScore(pass, total) {
+  if (!total) return '?';
+  return Math.round(100 + (pass / total - 0.5) * 100);
+}
+
+let allModels = [];
+let allQueries = [];
+let totalQuestions = 33;
+let sortKey = 'pct';
+let sortDir = -1;
+let filterText = '';
+let filterFree = null;
+let expandedRows = new Set();
+
+const typeOrder = ['fidelity','resistance','character','absurdity','language','resilience'];
+
+function render() {
+  let models = allModels.filter(m => {
+    if (filterText && !m.id.toLowerCase().includes(filterText.toLowerCase()) &&
+        !m.provider.toLowerCase().includes(filterText.toLowerCase())) return false;
+    if (filterFree === true && !m.free) return false;
+    if (filterFree === false && m.free) return false;
+    return true;
+  });
+
+  models.sort((a, b) => {
+    // Incomplete models always sort to the bottom
+    if (a.incomplete !== b.incomplete) return a.incomplete ? 1 : -1;
+    let av, bv;
+    if (sortKey.startsWith('type_')) {
+      const type = sortKey.slice(5);
+      av = a.by_type[type] ? a.by_type[type].pass / (a.by_type[type].total || 1) : -1;
+      bv = b.by_type[type] ? b.by_type[type].pass / (b.by_type[type].total || 1) : -1;
+    } else {
+      av = a[sortKey] ?? (typeof a[sortKey] === 'number' ? -Infinity : '');
+      bv = b[sortKey] ?? (typeof b[sortKey] === 'number' ? -Infinity : '');
+    }
+    if (typeof av === 'string') av = av.toLowerCase();
+    if (typeof bv === 'string') bv = bv.toLowerCase();
+    return av < bv ? sortDir : av > bv ? -sortDir : 0;
+  });
+
+  const totalModels = allModels.length;
+  const totalWithScore = allModels.filter(m => m.total > 0).length;
+  const best = allModels.filter(m => !m.incomplete).reduce((a, b) => (a.pct > b.pct ? a : b), {pct: 0});
+  const avgPct = totalWithScore ? Math.round(allModels.reduce((s, m) => s + m.pct, 0) / totalWithScore) : 0;
+  const totalTests = allModels.reduce((s, m) => s + m.total, 0);
+  const totalPass = allModels.reduce((s, m) => s + m.pass, 0);
+  const overallPct = totalTests ? Math.round(totalPass / totalTests * 100) : 0;
+
+  function sa(key) {
+    if (sortKey !== key) return '';
+    return sortDir > 0 ? ' ▲' : ' ▼';
+  }
+  function typeSa(type) {
+    if (sortKey !== 'type_' + type) return '';
+    return sortDir > 0 ? ' ▲' : ' ▼';
+  }
+
+  let html = `
+  <div class="summary">
+    <div class="stat-card"><div class="num">${totalModels}</div><div class="lbl">${t('totalModels')}</div></div>
+    <div class="stat-card"><div class="num">${totalWithScore}</div><div class="lbl">${t('tested')}</div></div>
+    <div class="stat-card"><div class="num">${totalTests}</div><div class="lbl">${t('testsInCache')}</div></div>
+    <div class="stat-card"><div class="num">${avgPct}%</div><div class="lbl">${t('avgAccuracy')}</div></div>
+    <div class="stat-card"><div class="num">${overallPct}%</div><div class="lbl">${t('overallPass')}</div></div>
+    <div class="stat-card"><div class="num" style="color:#7ee8a2">${best.id ? best.id.split('/').pop().replace(/-/g,' ').slice(0,14) : '—'}</div><div class="lbl">${t('bestModel')}</div></div>
+  </div>
+
+  <div class="type-legend">
+    <span class="legend-title">${lang === 'en' ? 'Test types:' : 'Typy testů:'}</span>
+    ${typeOrder.map(type => {
+      const c = TYPE_COLORS[type];
+      return `<span class="type-badge" style="background:${c.bg};color:${c.text};border:1px solid ${c.border};cursor:help" data-tip="${tTypeDesc(type)}">${tType(type)}</span>`;
+    }).join('')}
+    <span class="legend-title" style="margin-left:8px">${lang === 'en' ? 'Score:' : 'Skóre:'}</span>
+    <span class="type-badge" style="background:#1a3a2a;color:#5ec98a;border:1px solid #2a6a4a">≥70%</span>
+    <span class="type-badge" style="background:#3a2e1a;color:#e8c45e;border:1px solid #6a5a2a">40–70%</span>
+    <span class="type-badge" style="background:#3a1a1a;color:#e05050;border:1px solid #6a2a2a">&lt;40%</span>
+  </div>
+
+  <div class="filter-bar">
+    <input type="text" id="filterInput" placeholder="${t('searchPlaceholder')}" value="${filterText}" oninput="filterText=this.value;render()">
+    <button class="filter-btn${filterFree===null?' active':''}" onclick="filterFree=null;render()">${t('all')}</button>
+    <button class="filter-btn${filterFree===true?' active':''}" onclick="filterFree=true;render()">${t('free')}</button>
+    <button class="filter-btn${filterFree===false?' active':''}" onclick="filterFree=false;render()">${t('paid')}</button>
+    <button class="refresh-btn" onclick="loadData()">${t('refresh')}</button>
+    <button class="refresh-btn" onclick="runTest()">${runState.running ? `${t('running')} ${runState.done}/${runState.total}` : t('runTest')}</button>
+    <button class="refresh-btn" onclick="clearAll()">${t('clearAll')}</button>
+  </div>
+  ${Object.keys(runState.gave_up || {}).length ? `<div class="type-legend" style="color:#e05050">
+    <span class="legend-title">${t('gaveUp')}</span>
+    ${Object.entries(runState.gave_up).map(([m, e]) =>
+      `<span class="type-badge" style="background:#3a1a1a;color:#e05050;border:1px solid #6a2a2a" data-tip="${e.replace(/"/g,'&quot;')}">${m}</span>`).join('')}
+  </div>` : ''}
+
+  <table>
+    <thead>
+      <tr>
+        <th onclick="sortBy('id')">${t('model')}${sa('id')}</th>
+        <th onclick="sortBy('provider')">${t('provider')}${sa('provider')}</th>
+        <th onclick="sortBy('pct')" class="${sortKey==='pct'?'sorted':''}">${t('score')}${sortKey==='pct'?sa('pct'):' ▼'}</th>
+        <th>${t('bar')}</th>
+        <th onclick="sortBy('iq_sort')" data-tip="${t('iqTip')}">${t('iq')}${sa('iq_sort')}</th>
+        ${typeOrder.map(type => `<th onclick="sortByType('${type}')" data-tip="${tTypeDesc(type)}" class="${sortKey==='type_'+type?'sorted':''}">${tTypeShort(type)}${typeSa(type)}</th>`).join('')}
+        <th onclick="sortBy('ttft')" data-tip="${t('ttftTip')}" class="${sortKey==='ttft'?'sorted':''}">${t('ttft')}${sa('ttft')}</th>
+        <th onclick="sortBy('tok_sec')" data-tip="${t('tokSecTip')}" class="${sortKey==='tok_sec'?'sorted':''}">${t('tokSec')}${sa('tok_sec')}</th>
+        <th onclick="sortBy('reliability')" data-tip="${t('reliabilityTip')}" class="${sortKey==='reliability'?'sorted':''}">${t('reliability')}${sa('reliability')}</th>
+        <th onclick="sortBy('total')" data-tip="${t('testsTip')}">${t('tests')}${sa('total')}</th>
+      </tr>
+    </thead>
+    <tbody id="tbody">`;
+
+  for (const m of models) {
+    const shortName = m.id.split('/').pop();
+    const iq = iqScore(m.pass, m.total);
+    const color = barColor(m.pct);
+    const isExp = expandedRows.has(m.id);
+    const ts = m.ts ? new Date(m.ts * 1000).toLocaleDateString(lang === 'en' ? 'en-GB' : 'cs-CZ') : '';
+
+    const ttftHtml = m.ttft != null
+      ? `<span class="speed-val">${m.ttft.toFixed(1)}s</span>`
+      : '<span class="speed-na">—</span>';
+    const tokSecHtml = m.tok_sec != null
+      ? `<span class="speed-val">${m.tok_sec.toFixed(1)}</span>`
+      : '<span class="speed-na">—</span>';
+
+    html += `<tr onclick="toggleRow('${m.id.replace(/'/g,"\\'")}',event)" class="${isExp?'expanded':''}">
+      <td>
+        <div class="model-name">${shortName}</div>
+        <div class="model-short">${m.id !== shortName ? m.id : ''} <span class="ts">${ts}</span></div>
+      </td>
+      <td>
+        <span class="provider-tag">${m.provider}</span>
+        ${m.free ? '<span class="free-tag">FREE</span>' : '<span class="paid-tag">PAID</span>'}
+      </td>
+      <td class="score-cell">${m.incomplete
+        ? `<span style="color:#555577" data-tip="${lang==='en'?'Only '+m.total+'/'+totalQuestions+' tests done — need 60% to show score':'Jen '+m.total+'/'+totalQuestions+' testů hotovo — potřeba 60% pro zobrazení skóre'}">${m.total}<span style="font-size:11px;margin-left:3px">/${totalQuestions}</span> <span style="font-size:10px;color:#443333">⏳</span></span>`
+        : `${m.pass}<span style="color:#555577">/</span>${m.total}<span class="score-pct">${m.pct}%</span>`
+      }</td>
+      <td><div class="bar-wrap"><div class="bar-fill" style="width:${m.incomplete?0:m.pct}%;background:${color}"></div></div></td>
+      <td style="font-weight:700;color:${color}">${m.incomplete ? '<span style="color:#443333">—</span>' : iq}</td>
+      ${typeOrder.map(type => {
+        if (m.incomplete) return '<td style="color:#443333">—</td>';
+        const bt = m.by_type[type];
+        if (!bt || !bt.total) return '<td style="color:#444466">—</td>';
+        const sc = semColor(bt.pass, bt.total);
+        return `<td><span class="type-mini" style="background:${sc.bg};color:${sc.text};border:1px solid ${sc.border}" data-tip="${tType(type)}: ${bt.pass}/${bt.total} — ${tTypeDesc(type)}">${bt.pass}/${bt.total}</span></td>`;
+      }).join('')}
+      <td>${ttftHtml}</td>
+      <td>${tokSecHtml}</td>
+      <td>${m.reliability !== null && m.reliability !== undefined
+        ? (() => {
+            const rc = m.reliability >= 80 ? '#5ec98a' : m.reliability >= 50 ? '#e8c45e' : '#e05050';
+            const tip = `${m.rel_successes}/${m.rel_attempts} ${t('attempts')}${m.last_error_msg ? ' • ' + m.last_error_msg : ''}`;
+            return `<span style="font-weight:700;color:${rc}" data-tip="${tip}">${m.reliability}%</span><span style="color:#555577;font-size:10px;margin-left:3px">(${m.rel_attempts})</span>`;
+          })()
+        : '<span style="color:#444466">—</span>'
+      }</td>
+      <td style="color:#8888aa">${m.total}</td>
+    </tr>
+    <tr class="detail-row${isExp?' open':''}">
+      <td colspan="100">
+        <div class="detail-wrap">
+          <strong style="font-size:13px">${m.id}</strong> — ${t('detailTitle')}
+          <div class="detail-grid">
+            ${allQueries.map(q => {
+              const d = m.details[q.query];
+              if (!d) return '';
+              const c = TYPE_COLORS[q.type] || TYPE_COLORS.other;
+              const icon = d.passed ? '✅' : '❌';
+              const issues = d.issues && d.issues.length ? `<div class="issues">⚠ ${d.issues.join(', ')}</div>` : '';
+              return `<div class="detail-item">
+                <div class="type-lbl" style="color:${c.text}">${tType(q.type)}</div>
+                <div class="q"><span class="pass-icon">${icon}</span>${q.query || t('emptyQuery')}</div>
+                <div class="r">${d.reply ? d.reply.replace(/</g,'&lt;').replace(/>/g,'&gt;') : '<em style="color:#555577">' + t('noReply') + '</em>'}</div>
+                ${issues}
+              </div>`;
+            }).join('')}
+          </div>
+        </div>
+      </td>
+    </tr>`;
+  }
+
+  html += '</tbody></table>';
+  document.getElementById('app').innerHTML = html;
+  const inp = document.getElementById('filterInput');
+  if (inp && filterText) { inp.focus(); inp.setSelectionRange(filterText.length, filterText.length); }
+}
+
+function sortBy(key) {
+  if (sortKey === key) sortDir *= -1;
+  else { sortKey = key; sortDir = -1; }
+  render();
+}
+
+function sortByType(type) {
+  const key = 'type_' + type;
+  if (sortKey === key) sortDir *= -1;
+  else { sortKey = key; sortDir = -1; }
+  render();
+}
+
+function toggleRow(id, event) {
+  if (expandedRows.has(id)) expandedRows.delete(id);
+  else expandedRows.add(id);
+  render();
+}
+
+async function loadData() {
+  document.getElementById('app').innerHTML = `<div class="loading">${t('loadingCache')}</div>`;
+  try {
+    const resp = await fetch('/api/test-results');
+    const data = await resp.json();
+    if (data.error) throw new Error(data.error);
+    allModels = data.models;
+    totalQuestions = data.total_questions || 33;
+    // pre-compute iq_sort for numeric IQ sorting
+    allModels.forEach(m => { m.iq_sort = m.total && !m.incomplete ? 100 + (m.pass / m.total - 0.5) * 100 : 0; });
+    allQueries = data.queries;
+    render();
+  } catch (e) {
+    document.getElementById('app').innerHTML = `<div class="error">Error: ${e.message}</div>`;
+  }
+}
+
+// ── Admin actions ─────────────────────────────────────────────────────────
+// The token is only ever sent to this origin; it gates two endpoints that
+// cost real provider calls.
+let runState = {running: false, done: 0, total: 0, gave_up: {}};
+
+function adminToken() {
+  let tok = localStorage.getItem('adminToken');
+  if (!tok) {
+    tok = prompt(t('askToken')) || '';
+    if (tok) localStorage.setItem('adminToken', tok);
+  }
+  return tok;
+}
+
+async function adminPost(path) {
+  const tok = adminToken();
+  if (!tok) return null;
+  const resp = await fetch(path, {method: 'POST', headers: {'X-Ajaj-Admin': tok}});
+  const data = await resp.json();
+  if (resp.status === 403) { localStorage.removeItem('adminToken'); alert('Forbidden'); return null; }
+  return data;
+}
+
+async function pollRun() {
+  runState = await (await fetch('/api/test-run')).json();
+  render();
+  if (runState.running) setTimeout(pollRun, 3000);
+  else loadData();
+}
+
+async function runTest() {
+  if (runState.running) return;
+  const data = await adminPost('/api/test-run');
+  if (data) pollRun();
+}
+
+async function clearAll() {
+  if (!confirm(t('confirmClear'))) return;
+  const data = await adminPost('/api/test-clear');
+  if (data) { alert(`Removed ${data.removed}`); loadData(); }
+}
+
+// ── Custom tooltips ───────────────────────────────────────────────────────
+const tip = document.getElementById('tooltip');
+document.addEventListener('mouseover', e => {
+  const el = e.target.closest('[data-tip]');
+  if (!el) { tip.style.display = 'none'; return; }
+  tip.textContent = el.dataset.tip;
+  tip.style.display = 'block';
+  positionTip(e);
+});
+document.addEventListener('mousemove', e => {
+  if (tip.style.display === 'block') positionTip(e);
+});
+document.addEventListener('mouseout', e => {
+  if (!e.target.closest('[data-tip]')) tip.style.display = 'none';
+});
+function positionTip(e) {
+  const pad = 12;
+  let x = e.clientX + pad, y = e.clientY + pad;
+  if (x + 290 > window.innerWidth) x = e.clientX - 290 - pad;
+  if (y + 80 > window.innerHeight) y = e.clientY - 80 - pad;
+  tip.style.left = x + 'px';
+  tip.style.top = y + 'px';
+}
+
+// Init
+document.getElementById('langBtn').textContent = t('switchLang');
+document.getElementById('subtitle-text').innerHTML = t('title');
+document.getElementById('initial-loading').textContent = t('loading');
+updateLinks();
+loadData();
+</script>
+</body>
+</html>

static/stats.html

@@ -0,0 +1,306 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>OpenAjaj — Visitors</title>
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+:root { --human: #4caf7a; --unverified: #d9a441; --bot: #7a7a96; --internal: #6fa8dc;
+  --bg: #0f0f1a; --text: #d0d0e8; --muted: #8a8aa8; --panel: #181828; --line: #2a2a40; }
+:root.light { --bg: #fdf7ee; --text: #2a1e08; --muted: #7a6040; --panel: #f5edd8; --line: #d4b870; }
+:root.pink { --bg: #fff0f5; --text: #4a0e2a; --muted: #9e4b6e; --panel: #ffe4ec; --line: #f5c2d4; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: var(--bg); color: var(--text); min-height: 100vh; padding: 20px 16px;
+  max-width: 960px; margin: 0 auto;
+}
+h1 { font-size: 20px; margin-bottom: 4px; }
+h2 { font-size: 14px; text-transform: uppercase; letter-spacing: .06em; color: var(--muted); margin: 28px 0 10px; }
+.sub { color: var(--muted); font-size: 13px; }
+.tabs { margin: 16px 0; display: flex; flex-wrap: wrap; gap: 8px; }
+.tabs button { background: var(--panel); color: inherit; border: 1px solid var(--line); border-radius: 6px;
+  padding: 6px 14px; font: inherit; cursor: pointer; }
+.tabs button.on { border-color: var(--human); color: var(--text); }
+.tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(130px, 1fr)); gap: 10px; }
+.tile { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 12px; }
+.tile b { display: block; font-size: 26px; font-variant-numeric: tabular-nums; }
+.tile span { font-size: 12px; color: var(--muted); }
+.legend { display: flex; gap: 14px; font-size: 12px; color: var(--muted); margin-bottom: 8px; }
+.legend summary { cursor: pointer; }
+.legend i { display: inline-block; width: 10px; height: 10px; border-radius: 2px; margin-right: 5px; vertical-align: -1px; }
+.panel { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 12px; }
+svg text { fill: var(--muted); font-size: 10px; }
+svg text.in { fill: var(--text); font-weight: 600; }
+.theme { float: right; background: var(--panel); color: var(--muted); border: 1px solid var(--line); border-radius: 6px;
+  padding: 4px 10px; font: inherit; font-size: 12px; cursor: pointer; }
+.row { display: grid; grid-template-columns: 150px 1fr 40px; gap: 8px; align-items: center; font-size: 13px; margin: 4px 0; }
+.row .n { text-align: right; font-variant-numeric: tabular-nums; }
+.bar { display: flex; height: 14px; border-radius: 3px; overflow: hidden; background: var(--line); }
+.bar div { height: 100%; }
+table { width: 100%; border-collapse: collapse; font-size: 12px; }
+td { padding: 5px 6px; border-top: 1px solid var(--line); word-break: break-all; }
+td:last-child { text-align: right; white-space: nowrap; }
+.group { border: 1px solid var(--line); border-radius: 8px; padding: 8px 12px; margin: 6px 0; }
+.group summary { cursor: pointer; font-size: 13px; }
+.grid2 { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 0 12px; }
+.toggle { font-size: 13px; color: var(--muted); cursor: pointer; }
+a { color: inherit; }
+.empty { color: var(--muted); font-size: 13px; }
+@media (max-width: 520px) { .row { grid-template-columns: 100px 1fr 32px; } }
+</style>
+<script>
+// Same saved theme as the main page (same origin, so same host and port):
+// dark / light / pink / auto (system). The button here cycles and saves it too.
+const THEMES = ['dark', 'light', 'pink', 'auto'];
+function applyTheme() {
+  const theme = localStorage.getItem('theme') || 'auto';
+  const shown = theme === 'auto' ? (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light') : theme;
+  document.documentElement.className = shown === 'dark' ? '' : shown;
+  const button = document.getElementById('theme');
+  if (button) button.textContent = `Theme: ${theme}`;
+}
+function cycleTheme() {
+  const theme = localStorage.getItem('theme') || 'auto';
+  localStorage.setItem('theme', THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length]);
+  applyTheme();
+}
+applyTheme();  // before paint; again once the button exists
+addEventListener('DOMContentLoaded', applyTheme);
+addEventListener('storage', applyTheme);
+</script>
+</head>
+<body>
+<h1>Visitors<!--SERVER--> <button id="theme" class="theme" onclick="cycleTheme()"></button></h1>
+<p class="sub">Data goes back to <span id="since">the first logged visit</span>. Counts are unique visitors unless noted. Human = this browser solved the captcha, now or earlier; striped = a human who never chatted (on /t: never started a transcription) · Unverified (dotted) = browser that never did · Bot (finer dots) = crawler/tool user agent · Internal test = our own checks (admin token).</p>
+<div class="tabs"><button data-site="main">openajaj.cz</button><button data-site="t">/t transcribe</button><button data-site="quality">Transcription quality</button></div>
+<div class="tabs"><button data-days="1">Today</button><button data-days="7">7 days</button><button data-days="30">30 days</button><button data-days="0">All</button></div>
+<label class="toggle"><input type="checkbox" id="all" autocomplete="off"> Show bots, unverified &amp; internal tests</label>
+<div id="out"></div>
+<p class="sub" style="margin-top:24px">IP geolocation by <a href="https://db-ip.com">DB-IP</a> (CC BY 4.0).</p>
+
+<script>
+// 'idle' = human who never used the site: drawn striped in the human colour. Unverified: dotted, fainter. Bot: smaller dots, fainter still.
+const HUMANS = ['human', 'idle'], ALL = [...HUMANS, 'unverified', 'bot', 'internal'];
+let CLASSES = HUMANS, showAll = false;
+const PATTERN = {idle: 'hatch', unverified: 'dots', bot: 'dots2'};
+const LABEL = {human: 'Human', idle: 'Human, idle', unverified: 'Unverified', bot: 'Bot', internal: 'Internal test'};
+const ACTION = {main: ['chat', 'Chats', 'never chatted', 'chat'], t: ['stt', 'STT sessions', 'never transcribed', 'transcription']};
+const plural = (n, noun) => `${n} ${noun}${n === 1 ? '' : 's'}`;
+const regionName = new Intl.DisplayNames(['en'], {type: 'region'});
+let data = null, site = 'quality', days = '7';
+
+const esc = s => String(s).replace(/[&<>"]/g, c => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;'}[c]));
+// Totals count only the classes on show.
+const sum = o => CLASSES.reduce((a, c) => a + (o?.[c] || 0), 0);
+const color = c => `var(--${c === 'idle' ? 'human' : c})`;
+const paint = (fill, pattern) => ({
+  hatch: `repeating-linear-gradient(135deg, transparent 0 3px, var(--panel) 3px 5px), ${fill}`,
+  dots: `radial-gradient(circle, transparent 1.2px, var(--panel) 1.3px) 0 0 / 4px 4px, ${fill}`,
+  dots2: `radial-gradient(circle, transparent 0.8px, var(--panel) 0.9px) 0 0 / 4px 4px, ${fill}`,
+}[pattern] || fill);
+// Overlays in the panel colour: stripes, or a dot grid (the colour shows only through the holes).
+const DEFS = `<defs><pattern id="hatch" width="5" height="5" patternUnits="userSpaceOnUse" patternTransform="rotate(45)">
+  <rect width="2" height="5" style="fill:var(--panel)"/></pattern>
+  <pattern id="dots" width="4" height="4" patternUnits="userSpaceOnUse"><path fill-rule="evenodd" style="fill:var(--panel)"
+  d="M0 0h4v4H0z M3.2 2a1.2 1.2 0 1 0-2.4 0a1.2 1.2 0 1 0 2.4 0z"/></pattern>
+  <pattern id="dots2" width="4" height="4" patternUnits="userSpaceOnUse"><path fill-rule="evenodd" style="fill:var(--panel)"
+  d="M0 0h4v4H0z M2.8 2a0.8 0.8 0 1 0-1.6 0a0.8 0.8 0 1 0 1.6 0z"/></pattern></defs>`;
+// Golden-angle hues by order of first appearance in the whole log: a person keeps their colour in every period.
+const hue = i => `hsl(${(i * 137.508) % 360}deg 70% 62%)`;
+const classSeries = () => CLASSES.map(c => [c, LABEL[c], color(c), PATTERN[c] || '']);
+// A person's entry opens to their details (place, device, …).
+const legend = series => !series.length ? '' : `<div class="legend">${series.map(([, name, fill, pattern, detail]) => {
+  const key = `<i style="background:${paint(fill, pattern)}"></i>${esc(name)}`;
+  return detail ? `<details><summary>${key}</summary>${esc(detail)}</details>` : `<span>${key}</span>`;
+}).join('')}</div>`;
+
+function country(code) {
+  if (!/^[A-Z]{2}$/.test(code)) return 'Unknown';
+  const flag = String.fromCodePoint(...[...code].map(ch => 0x1F1A5 + ch.charCodeAt(0)));
+  try { return `${flag} ${regionName.of(code)}`; } catch { return code; }
+}
+
+function stackBar(counts, total) {
+  return `<div class="bar">${CLASSES.filter(c => counts[c]).map(c =>
+    `<div style="width:${100 * counts[c] / total}%;background:${paint(color(c), PATTERN[c] || '')}" title="${LABEL[c]}: ${counts[c]}"></div>`
+  ).join('')}</div>`;
+}
+
+// series: [[key in each entry's counts, name, color, pattern]], stacked bottom up.
+// entries: [[tick, counts, uses?]]; a use count is drawn inside its bar when it fits.
+function columns(entries, aria, series, noun) {
+  const total = d => series.reduce((a, [k]) => a + (d[k] || 0), 0);
+  if (!entries.some(([, d]) => total(d))) return '<p class="empty">No data.</p>';
+  // Drawn at the panel's real width (minus its padding and border), so text keeps its size on a phone.
+  const W = Math.max(200, document.getElementById('out').clientWidth - 26), H = 180, pad = 22;
+  const max = Math.max(...entries.map(([, d]) => total(d)));
+  const step = (W - pad) / entries.length, bw = Math.max(2, step * 0.7);
+  const label = Math.ceil(entries.length / Math.floor(W / 75));
+  const cols = entries.map(([tickText, d, uses], i) => {
+    let y = H - pad, x = pad + i * step;
+    const rects = series.filter(([k]) => d[k]).map(([k, name, fill, pattern]) => {
+      const h = (H - 2 * pad) * d[k] / max, box = `x="${x}" y="${y -= h}" width="${bw}" height="${h}"`;
+      // Use count in a square of the page background, 80% of the bar's short side, so it reads on any bar colour.
+      // Font fits the square: digits are ~0.6em wide, so wider numbers get smaller text.
+      const n = uses?.[k] || 0, side = 0.8 * Math.min(h, bw), fs = side * Math.min(0.7, 1.5 / String(n).length);
+      const cx = x + bw / 2, cy = y + h / 2;
+      return `<g><title>${tickText} · ${esc(name)}: ${d[k]}${n ? ` · ${plural(n, noun)}` : ''}</title><rect ${box} fill="${fill}"/>${
+        pattern ? `<rect ${box} fill="url(#${pattern})"/>` : ''}${
+        n && side >= 12 ? `<rect x="${cx - side / 2}" y="${cy - side / 2}" width="${side}" height="${side}" rx="${side * 0.15}" style="fill:var(--bg)"/>
+          <text class="in" x="${cx}" y="${cy + fs * 0.35}" text-anchor="middle" style="font-size:${fs}px">${n}</text>` : ''}</g>`;
+    }).join('');
+    const tick = i % label ? '' : `<text x="${x + bw / 2}" y="${H - 6}" text-anchor="middle">${tickText}</text>`;
+    return rects + tick;
+  }).join('');
+  return `<svg viewBox="0 0 ${W} ${H}" width="100%" role="img" aria-label="${aria}">${DEFS}
+    <text x="0" y="${pad}">${max}</text><line x1="${pad}" x2="${W}" y1="${H - pad}" y2="${H - pad}" style="stroke:var(--line)"/>${cols}</svg>`;
+}
+
+function rows(list) {
+  list = list.filter(([, c]) => sum(c));
+  const top = Math.max(...list.map(([, c]) => sum(c)), 1);
+  if (!list.length) return '<p class="empty">No data.</p>';
+  return list.map(([name, c]) => `<div class="row"><span>${esc(name)}</span>
+    <div style="width:${100 * sum(c) / top}%">${stackBar(c, sum(c))}</div><span class="n">${sum(c)}</span></div>`).join('');
+}
+
+function render() {
+  document.querySelectorAll('.tabs button').forEach(b =>
+    b.classList.toggle('on', b.dataset.site === site || b.dataset.days === days));
+  if (site === 'quality') { document.getElementById('out').innerHTML = qualityPanel(quality); return; }
+  const s = data[site], v = s.visitors, [actionKey, actionLabel, never, noun] = ACTION[site];
+  LABEL.idle = `Human, ${never}`;
+  const ranked = (o, n = 20) => Object.entries(o).filter(([, c]) => sum(c)).sort((a, b) => sum(b[1]) - sum(a[1])).slice(0, n);
+  const countries = ranked(s.countries).map(([code, c]) => [country(code), c]);
+  const referrers = ranked(s.referrers, 15).map(([host, c]) => [host || '(none / typed URL)', c]);
+  const named = o => ranked(o).map(([name, c]) => [name || 'Unknown', c]);
+  // ~60 columns at most: days, else weeks (labelled by their Monday), else months.
+  const units = Object.keys(s.days).length <= 62 ? 'days' : Object.keys(s.weeks).length <= 60 ? 'weeks' : 'months';
+  // Days: "Monday 13.10." ("Mon 13.10." past a week of columns). Weeks: their Monday "13.10.". Months: "2026-10".
+  const unit = units.slice(0, -1), dm = key => `${+key.slice(8)}.${+key.slice(5, 7)}.`;
+  const weekday = key => new Date(`${key}T12:00`).toLocaleDateString('en',
+    {weekday: Object.keys(s.days).length > 7 ? 'short' : 'long'});
+  const tick = key => unit === 'month' ? key : unit === 'week' ? dm(key) : `${weekday(key)} ${dm(key)}`;
+  // Humans only: one color per person. Otherwise one color per class.
+  const series = showAll ? classSeries()
+    : s.humans.map((h, i) => [i, `Visitor ${h.hn}`, hue(h.n), h.idle ? 'hatch' : '',
+      [country(h.country), h.dbip, h.isp, `${h.os} ${h.browser}`,
+       h.idle ? '' : plural(Object.values(h.uses.hours).reduce((a, n) => a + n, 0), noun),
+       h.solved && `captcha solved ${dm(h.solved)}${h.solved.slice(0, 4)}`].filter(Boolean).join(' · ')]);
+  // visits: visits started in the bucket (a request 30+ min after the previous one); else who was there.
+  const counts = showAll ? (u, key, visits) => (visits ? s.visit_timeline : s)[u][key] || {}
+    : (u, key, visits) => s.humans.map(h => visits ? h[u][key] || 0 : +(key in h[u]));
+  const uses = showAll ? () => null : (u, key) => s.humans.map(h => h.uses[u][key] || 0);
+  // Today: its 24 hours. Longer: days, weeks or months.
+  const today = days === '1', per = today ? 'hour' : unit, bucketUnit = today ? 'hours' : units;
+  const buckets = today ? Array.from({length: 24}, (_, h) => String(h).padStart(2, '0')) : Object.keys(s[units]);
+  const timeline = visits => buckets.map(key =>
+    [today ? key : tick(key), counts(bucketUnit, key, visits), uses(bucketUnit, key)]);
+  const humans = (v.human || 0) + (v.idle || 0), engaged = s.engaged.human || 0;
+  const returning = (s.returning.human || 0) + (s.returning.idle || 0);
+  const pct = n => humans ? ` (${Math.round(100 * n / humans)}%)` : '';
+  const via = Object.entries(s.via).map(([k, n]) => [k === 'cloudflare' ? 'openajaj.cz (Cloudflare)' : 'Direct (hf.space)', n]);
+  document.getElementById('out').innerHTML = `
+    <div class="tiles">
+      ${CLASSES.filter(c => c !== 'idle').map(c => `<div class="tile"><b style="color:${color(c)}">${c === 'human' ? humans : v[c] || 0}</b><span>${LABEL[c]} visitors</span></div>`).join('')}
+      <div class="tile"><b>${sum(s.visits)}</b><span>Visits</span></div>
+      <div class="tile"><b>${sum(s.events.page)}</b><span>Page loads</span></div>
+      <div class="tile"><b>${sum(s.events[actionKey])}</b><span>${actionLabel}</span></div>
+      <div class="tile"><b>${engaged}</b><span>Humans who used it${pct(engaged)}</span></div>
+      <div class="tile"><b>${returning}</b><span>Humans back on another day${pct(returning)}</span></div>
+    </div>
+    ${today ? '' : `<h2>Unique visitors per ${unit}</h2><div class="panel">${legend(series)}${columns(timeline(false), `Unique visitors per ${unit}`, series, noun)}</div>`}
+    <h2>Visits per ${per}${today ? ' (Prague time)' : ''}</h2><div class="panel">${legend(series)}${columns(timeline(true), `Visits per ${per}`, series, noun)}</div>
+    <h2>Countries</h2><div class="panel">${legend(classSeries())}${rows(countries)}</div>
+    <div class="grid2">
+      <div><h2>Operating system</h2><div class="panel">${rows(ranked(s.os))}</div></div>
+      <div><h2>Browser</h2><div class="panel">${rows(ranked(s.browsers))}</div></div>
+      <div><h2>Entry point</h2><div class="panel">${rows(via)}</div></div>
+      <div><h2>Came from</h2><div class="panel">${rows(referrers)}</div></div>
+      <div><h2>Place</h2><div class="panel">${rows(named(s.places_dbip))}</div></div>
+      <div><h2>Network (ISP)</h2><div class="panel">${rows(named(s.isps))}</div></div>
+    </div>
+    ${CLASSES.includes('bot') ? `<h2>Top bot user agents (requests)</h2><div class="panel">${s.bot_agents.length
+      ? `<table>${s.bot_agents.map(([ua, n]) => `<tr><td>${esc(ua || '(none)')}</td><td>${n}</td></tr>`).join('')}</table>`
+      : '<p class="empty">None.</p>'}</div>` : ''}`;
+}
+
+// Its own tab: /t visits, judged by stt_quality.py from the page's own reports (all visitors, not only humans)
+const VERDICT = {ok: 'OK', degraded: 'Degraded: late or unsure text', broken: 'Broken: not transcribing or losing speech',
+  failed: 'Never started', too_short: 'Too short to judge'};
+const PROBLEM = {ok: 'No problem shown', connect: 'Connecting (normal start)', off: 'Not transcribing', mic: 'Mic not hearing',
+  stuck: 'Very slow internet (audio stuck)', slow: 'Slow internet (text over 5 s late)',
+  noise: 'Noisy', far: 'Speaker far away', lang: 'Other language?', music: 'Only music/noise (info)'};
+let quality = null;
+const MIN_ACTIVE_S = 30;  // stt_quality.MIN_ACTIVE_S: shorter visits are not judged
+const mins = s => s < 60 ? `${s} s` : `${Math.round(s / 60)} min`;
+const table = (o, names = {}, fmt = n => n) => Object.keys(o).length
+  ? `<table>${Object.entries(o).map(([k, n]) => `<tr><td>${esc(names[k] || k || '(none)')}</td><td>${fmt(n)}</td></tr>`).join('')}</table>`
+  : '<p class="empty">None.</p>';
+// bins over edges, the last one open: "≤ 0.5 s", …, "> 10 s"
+const hist = (counts, edges, fmt) => Object.fromEntries(counts.map((n, i) =>
+  [i < edges.length ? `≤ ${fmt(edges[i])}` : `> ${fmt(edges[edges.length - 1])}`, n]));
+function qualityPanel(q) {
+  if (q?.error) return `<h2>Transcription quality</h2><div class="panel"><p class="empty">Could not load (${esc(q.error)}).</p></div>`;
+  if (!q?.visits) return '<h2>Transcription quality</h2><div class="panel"><p class="empty">No visit reports yet.</p></div>';
+  return `<h2>Transcription quality – All</h2>${qualityGroup(q, 'All visits')}
+    <h2>By operating system</h2>${q.by_os.map(g => qualityGroup(g, g.name)).join('')}
+    <h2>By visitor (anyone with a visit long enough to judge)</h2>${q.by_visitor.map(g => qualityGroup(g, `${g.name} · ${g.device}`)).join('')}`;
+}
+// Closed: verdict counts, then each problem's share of the group's /t time. Open: the group's full numbers.
+function qualityGroup(g, name) {
+  const short = g.verdicts.too_short || 0, judged = `${g.visits - short} judged, ${short} under ${MIN_ACTIVE_S} s`;
+  const verdicts = Object.entries(g.verdicts).filter(([k]) => k !== 'too_short')
+    .map(([k, n]) => ` · ${VERDICT[k]?.split(':')[0] || k} ${n}`).join('');
+  const shares = Object.entries(g.problem_secs).map(([c, s]) =>
+    `${c} ${g.total_s ? Math.round(100 * s / g.total_s) : 0}%`).join(' · ');
+  return `<details class="group"><summary><b>${esc(name)}</b> · ${plural(g.visits, 'visit')} (${judged})${verdicts}
+    <br><span class="sub">${shares || 'no problem shown'}</span></summary>${qualityBody(g)}</details>`;
+}
+function qualityBody(q) {
+  const v = q.verdicts, judged = q.visits - (v.too_short || 0);
+  const pct = n => judged ? ` (${Math.round(100 * (n || 0) / judged)}%)` : '';
+  return `<div class="tiles">${['ok', 'degraded', 'broken', 'failed'].map(k =>
+      `<div class="tile"><b>${v[k] || 0}</b><span>${VERDICT[k]}${pct(v[k])}</span></div>`).join('')}
+      <div class="tile"><b>${v.too_short || 0}</b><span>${VERDICT.too_short}</span></div>
+      <div class="tile"><b>${mins(q.missed_s)}</b><span>Speech missed (drops, lost audio)</span></div></div>
+    <div class="grid2">
+      <div><h2>Main reason (degraded, broken, never started)</h2><div class="panel">${table(q.reasons, PROBLEM)}</div></div>
+      <div><h2>Time per problem shown (% of /t time)</h2><div class="panel">${table(q.problem_secs, PROBLEM, s => mins(s) + (q.total_s ? ` (${Math.round(100 * s / q.total_s)}%)` : ''))}</div></div>
+      <div><h2>Why not transcribing</h2><div class="panel">${table(q.off_why, {}, mins)}</div></div>
+      <div><h2>Text delay (results)</h2><div class="panel">${table(hist(q.lag_hist, q.lag_edges_ms, ms => `${ms / 1000} s`))}</div></div>
+      <div><h2>Word confidence (words)</h2><div class="panel">${table(hist(q.conf_hist, q.conf_edges, c => `${Math.round(c * 100)} %`))}</div></div>
+    </div>`;
+}
+
+async function load() {
+  let tok = localStorage.getItem('adminToken');
+  if (!tok) { tok = prompt('Admin token'); if (tok) localStorage.setItem('adminToken', tok); }
+  const headers = {
+    'X-Ajaj-Admin': tok || '',
+    'X-Ajaj-Session': new URLSearchParams(location.search).get('cs') || localStorage.getItem('ajaj_v') || '',
+  };
+  const resp = await fetch(`/api/visits?days=${days}`, {headers});
+  if (resp.status === 403) {
+    localStorage.removeItem('adminToken');
+    document.getElementById('out').innerHTML = '<p class="empty">Forbidden — reload to enter the token again.</p>';
+    return;
+  }
+  data = await resp.json();
+  const q = await fetch(`/api/stt/quality?days=${days}`, {headers}).catch(() => null);
+  quality = !q ? {error: 'network'} : q.ok ? await q.json().catch(() => ({error: 'bad reply'})) : {error: q.status};
+  if (data.since) document.getElementById('since').textContent = new Date(data.since).toLocaleString('cs-CZ',
+    {timeZone: 'Europe/Prague', day: 'numeric', month: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit'});
+  render();
+}
+
+// charts are drawn at the panel's width; the quality tab has none, and redrawing would close its rows
+addEventListener('resize', () => data && site !== 'quality' && render());
+document.getElementById('all').onchange = e => { showAll = e.target.checked; CLASSES = showAll ? ALL : HUMANS; if (data) render(); };
+document.querySelectorAll('[data-site]').forEach(b => b.onclick = () => { site = b.dataset.site; render(); });
+document.querySelectorAll('[data-days]').forEach(b => b.onclick = () => { days = b.dataset.days; load(); });
+load();
+</script>
+</body>
+</html>

static/version.txt

@@ -0,0 +1 @@
+2984ef4