diff --git a/docs/api.md b/docs/api.md
index b09127c..64ec911 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -114,7 +114,8 @@
   "birth_date": "1990-01-01",
   "country": "US",
   "city": "New York",
-  "locale": "en-US",
+  "locale": null,
+  "locale_effective": "en-US",
   "avatar_url": "https://...",
   "profile_url": "https://...",
   "role": "admin",
@@ -122,11 +123,39 @@
 }
 ```
 
+`locale` is the interface language chosen in Settings — `null` (or `"auto"`) means
+"follow the account". `locale_effective` is the language the interface actually uses:
+that choice, else the gnexus-auth account locale, else `en`. The account's own tag is
+not part of this payload.
+
 **Errors**
 - `401` — not authenticated
 
 ---
 
+#### `PATCH /auth/me`
+
+Choose the interface language for the current user.
+
+**Request**
+```json
+{ "locale": "ru" }
+```
+
+`en`, `uk`, `ru` (or a regional tag like `en-US`, which normalizes to `en`) set the
+choice; `""` or `"auto"` clear it, so the account language applies again. The choice
+lives in `navi_users.locale_override` and is untouched by the `user.profile_updated`
+webhook, which only mirrors the account locale.
+
+**Response `200`** — the same body as `GET /auth/me`
+
+**Errors**
+- `401` — not authenticated
+- `422` — a language Navi does not ship
+- `503` — the choice could not be stored
+
+---
+
 #### `GET /auth/status`
 
 Return whether auth is enabled on the backend and whether OAuth is configured.
diff --git a/docs/i18n.md b/docs/i18n.md
new file mode 100644
index 0000000..6a308d8
--- /dev/null
+++ b/docs/i18n.md
@@ -0,0 +1,70 @@
+# Interface language (i18n)
+
+Navi's web client speaks **en / uk / ru**. The rules themselves live in the
+platform handbook ([handbook.gnexus](https://handbook.gnexus) → `10-platform/i18n`);
+this file only records how navi follows them and what is still untranslated.
+
+## Where the language comes from
+
+`locale_effective` from `GET /auth/me` — the choice made in Settings
+(`navi_users.locale_override`) → the gnexus-auth account locale
+(`navi_users.locale`, a straight mirror kept by the `user.profile_updated`
+webhook) → `en`.
+
+The picker is the first block of **Settings → Account**
+(`webclient/src/components/settings/AccountPanel.vue`) and offers
+Auto / English / Українська / Русский — each language named in its own language.
+A choice is written with `PATCH /auth/me`, so it follows the account to other
+devices and survives logout.
+
+With `NAVI_AUTH_ENABLED=false` there is no account to follow: the picker drops
+Auto, the choice is kept in `localStorage` under `navi.locale`, and the same key
+is used when the visitor is not signed in.
+
+## The module
+
+`webclient/src/i18n/` — vue-i18n is deliberately not pulled in:
+
+| File | Role |
+|---|---|
+| `index.js` | `locale` ref, `t(slug, params)`, `setLocale`, `normalizeTag`, `pluralCategory`, and the `navi.locale` storage helpers |
+| `messages/en.js`, `uk.js`, `ru.js` | flat dictionaries, the same slugs in all three |
+
+- `t()` interpolates `{param}` and falls back to the **English** string when the
+  chosen language has no slug yet (or to the slug itself when nobody has it).
+- Plurals are dictionaries (`{ one, few, many, other }`) driven only by
+  `params.n`; ru/uk use one/few/many, en uses one/other.
+- A slug is `<area>.<name>` and an area is a screen or a component group —
+  `settings.*`, `sidebar.*`, `messages.*`, `chat.*`, `artifacts.*`, `ui.*`,
+  `profile.*`, `app.*`, `common.*`. Slugs are shared with the other gnexus
+  services where they mean the same thing.
+- `SUPPORTED_LOCALES` is the single list: adding a language means adding
+  `messages/<code>.js` there, plus `navi/locales.py` on the backend (and the
+  same slug in `navi_users.locale_override` constraints on the client side).
+- Lists of options or nav items must be **computed**, not module-level
+  constants, or their labels freeze in the language that was active at import.
+
+The backend side is `navi/locales.py` (`normalize_locale`, `effective_locale`),
+mirroring the frontend's normalisation: `en-US`/`en_US` → `en`, anything not
+shipped → `None`.
+
+## Translation status
+
+Phase 1 shipped the framework and the language block only. Everything else is
+still hard-coded English and is translated area by area, biggest first:
+
+| Area | Strings | Status |
+|---|---|---|
+| `settings.*` | ~118 | language block only |
+| `artifacts.*` | ~45 | pending |
+| `sidebar.*` | ~29 | pending |
+| `messages.*` | ~27 | pending |
+| `chat.*` | ~21 | pending |
+| `ui.*` | ~20 | pending |
+
+The remaining strings are counted in templates (text nodes, `placeholder`,
+`title`, `aria-label`, `label`, `alt`) plus keyed strings in `<script setup>`.
+
+Backend-generated text (tool results, system prompts, WS event payloads) is
+still English and is out of scope for now — the interface language does not
+change what the agent answers.
diff --git a/docs/index.md b/docs/index.md
index d79e21e..da4aa8c 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -44,6 +44,7 @@
 | [`android-client.md`](android-client.md) | Android WebView client — architecture, build/deploy |
 | [`permissions.md`](permissions.md) | Permission gate — authoritative backend confirmation for destructive tool calls (**design only, not yet implemented**) |
 | [`auth.md`](auth.md) | Auth: multi-user OAuth via gnexus-auth, or disable with `NAVI_AUTH_ENABLED=false` |
+| [`i18n.md`](i18n.md) | Interface language — en/uk/ru, the picker, translation status per area |
 | [`../deploy/README.md`](../deploy/README.md) | Server deployment — one command: dockerized postgres + systemd + navi-code, web UI off |
 | [`../hive/README.md`](../hive/README.md) | hive — the swarm address book: machines announce themselves, agents ask who is alive |
 | [`config.md`](config.md) | All environment variables with types and defaults |
diff --git a/navi/api/routes/auth.py b/navi/api/routes/auth.py
index eb1709b..4c63db1 100644
--- a/navi/api/routes/auth.py
+++ b/navi/api/routes/auth.py
@@ -15,11 +15,18 @@
     StateValidationException,
     TokenExchangeException,
 )
+from pydantic import BaseModel
 
 from navi.auth.client import get_gauth_client
-from navi.auth.deps import get_current_user, require_user
+from navi.auth.deps import (
+    get_current_user,
+    get_locale_override,
+    require_user,
+    set_locale_override,
+)
 from navi.auth.encrypt import get_encryptor
 from navi.auth import User
+from navi.locales import effective_locale, normalize_locale
 from datetime import datetime, timedelta, timezone
 
 from navi.config import settings
@@ -389,9 +396,14 @@
     return {"ok": True}
 
 
-@router.get("/me")
-async def auth_me(user: Annotated[User, Depends(require_user)]) -> dict:
-    """Return current authenticated user."""
+def _me_payload(user: User, override: str | None) -> dict:
+    """The user, plus the interface language and what that language resolves to.
+
+    ``locale`` is the choice made in Navi's settings (None = follow the account),
+    ``locale_effective`` is what the interface actually uses. The account's own
+    tag is not exposed here — it lives in ``navi_users.locale``, where the
+    gnexus-auth webhook keeps mirroring it.
+    """
     profile_url = f"{settings.gnauth_base_url.rstrip('/')}{settings.gnauth_profile_path}"
     return {
         "id": user.id,
@@ -404,7 +416,8 @@
         "birth_date": user.birth_date,
         "country": user.country,
         "city": user.city,
-        "locale": user.locale,
+        "locale": override,
+        "locale_effective": effective_locale(override, user.locale),
         "avatar_url": user.avatar_url,
         "role": user.role,
         "permissions": user.permissions,
@@ -412,6 +425,43 @@
     }
 
 
+@router.get("/me")
+async def auth_me(user: Annotated[User, Depends(require_user)]) -> dict:
+    """Return current authenticated user."""
+    return _me_payload(user, await get_locale_override(user.id))
+
+
+class LocaleUpdate(BaseModel):
+    locale: str = ""
+
+
+@router.patch("/me")
+async def auth_me_update(
+    payload: LocaleUpdate,
+    user: Annotated[User, Depends(require_user)],
+) -> dict:
+    """Choose the interface language for this user.
+
+    An empty string or "auto" clears the override, so the account's language
+    applies again. Returns the same body as GET /auth/me.
+    """
+    value = (payload.locale or "").strip().lower()
+    follow_account = value in ("", "auto")
+    override = None if follow_account else normalize_locale(value)
+    if override is None and not follow_account:
+        raise HTTPException(status_code=422, detail=f"Unsupported locale: {payload.locale}")
+
+    try:
+        await set_locale_override(user.id, override)
+    except Exception:
+        # Say so instead of letting the picker show a language that will be
+        # gone on the next load.
+        log.warning("auth.locale_override_write_failed", user_id=user.id, exc_info=True)
+        raise HTTPException(status_code=503, detail="The language could not be saved")
+    log.info("auth.locale_override_set", user_id=user.id, locale=override)
+    return _me_payload(user, override)
+
+
 @router.get("/status")
 async def auth_status() -> dict:
     """Return whether auth is enabled and OAuth is configured on the backend."""
diff --git a/navi/api/routes/webhooks.py b/navi/api/routes/webhooks.py
index 1269dbb..d6a785a 100644
--- a/navi/api/routes/webhooks.py
+++ b/navi/api/routes/webhooks.py
@@ -24,8 +24,9 @@
     - client.roles_changed / client.permissions_changed → update user role/permissions
     - user.profile_updated → update the mirrored navi_users profile
       (handbook: profile.update; role/permissions have their own events, and a
-      local locale override must survive this hook — navi has none yet, the
-      locale column is a straight mirror, so it is updated together)
+      local locale override must survive this hook: navi keeps the account's own
+      tag in navi_users.locale and the choice made in Settings in
+      navi_users.locale_override, and this hook writes only the former)
 """
     if not settings.gnauth_client_id or not settings.gnauth_client_secret:
         raise HTTPException(status_code=503, detail="OAuth is not configured")
@@ -102,7 +103,12 @@
 
 
 async def _update_user_profile(user_id: str, profile: dict) -> None:
-    """Mirror a gnexus-auth profile change into navi_users (role/permissions aside)."""
+    """Mirror a gnexus-auth profile change into navi_users (role/permissions aside).
+
+    The ``locale`` written here is the account's own language; the override
+    picked in Navi's settings sits in its own column and is deliberately not
+    part of this mirror.
+    """
     try:
         from navi.api.deps import get_session_store
         store = get_session_store()
diff --git a/navi/auth/_ddl.py b/navi/auth/_ddl.py
index 0b75c10..c95813c 100644
--- a/navi/auth/_ddl.py
+++ b/navi/auth/_ddl.py
@@ -18,6 +18,7 @@
     country      TEXT,
     city         TEXT,
     locale       TEXT,
+    locale_override TEXT,
     role         TEXT NOT NULL DEFAULT 'user',
     permissions  TEXT NOT NULL DEFAULT '[]',
     created_at   TIMESTAMPTZ NOT NULL,
@@ -51,6 +52,10 @@
 """
 
 # Columns added after initial table creation — boot-time migration.
+# Keep in sync with the navi_users column list in _DDL above: an existing
+# database only ever sees a new column through this list (there
+# `CREATE TABLE IF NOT EXISTS` is a no-op). tests/unit/auth/test_ddl.py
+# guards that parity.
 _NAVI_USERS_MIGRATION_COLUMNS = [
     ("avatar_url", "TEXT"),
     ("username", "TEXT"),
@@ -61,6 +66,9 @@
     ("country", "TEXT"),
     ("city", "TEXT"),
     ("locale", "TEXT"),
+    # The language picked in Navi's settings; NULL means "follow the account".
+    # `locale` above stays a straight mirror of the gnexus-auth profile.
+    ("locale_override", "TEXT"),
 ]
 
 
diff --git a/navi/auth/deps.py b/navi/auth/deps.py
index 24b50e1..4135b14 100644
--- a/navi/auth/deps.py
+++ b/navi/auth/deps.py
@@ -458,6 +458,46 @@
         )
 
 
+# ── Interface language ──────────────────────────────────────────────────────
+
+async def get_locale_override(user_id: str) -> str | None:
+    """The language picked in Navi's settings, or None when the user follows the account.
+
+    Read per request instead of carried on User: the User handed around is built
+    from the gnexus-auth profile (and cached for 30s), and it knows nothing about
+    a choice made locally in Navi.
+    """
+    try:
+        from navi.api.deps import get_session_store
+        store = get_session_store()
+        pool = await store._get_pool()
+        async with pool.acquire() as conn:
+            return await conn.fetchval(
+                "SELECT locale_override FROM navi_users WHERE id = $1", user_id
+            )
+    except Exception:
+        # A missing store or an unmigrated column must not break sign-in — the
+        # account's own language is a sane answer.
+        log.warning("auth.locale_override_read_failed", user_id=user_id, exc_info=True)
+        return None
+
+
+async def set_locale_override(user_id: str, locale: str | None) -> None:
+    """Store the language picked in Navi's settings (None = follow the account).
+
+    Deliberately raises: the caller has to be able to tell the user the choice
+    was not saved, rather than let it silently revert on the next load.
+    """
+    from navi.api.deps import get_session_store
+    store = get_session_store()
+    pool = await store._get_pool()
+    async with pool.acquire() as conn:
+        await conn.execute(
+            "UPDATE navi_users SET locale_override = $2, updated_at = $3 WHERE id = $1",
+            user_id, locale, datetime.now(timezone.utc),
+        )
+
+
 # ── FastAPI Depends helpers ─────────────────────────────────────────────────
 
 async def require_user(user: Annotated[User | None, Depends(get_current_user)]) -> User:
diff --git a/navi/locales.py b/navi/locales.py
new file mode 100644
index 0000000..6224f5e
--- /dev/null
+++ b/navi/locales.py
@@ -0,0 +1,21 @@
+"""Interface language tags: normalisation and the effective locale.
+
+Mirror of the frontend i18n slugs: the override picked in Navi's settings →
+the language of the gnexus-auth account (mirrored into ``navi_users.locale``)
+→ ``en``. Tag normalisation is the same on both sides: ``en-US``/``en_US`` →
+``en``, anything outside :data:`SUPPORTED_LOCALES` → ``None``.
+"""
+
+SUPPORTED_LOCALES = ("en", "uk", "ru")
+
+
+def normalize_locale(tag) -> str | None:
+    """``en-US`` → ``en``; anything outside SUPPORTED_LOCALES → None."""
+    text = str(tag or "").strip().lower()
+    prefix = text.split("-", 1)[0].split("_", 1)[0]
+    return prefix if prefix in SUPPORTED_LOCALES else None
+
+
+def effective_locale(override, account) -> str:
+    """override → account language → ``en`` (same fallback as the frontend)."""
+    return normalize_locale(override) or normalize_locale(account) or "en"
diff --git a/tests/unit/api/test_auth_locale.py b/tests/unit/api/test_auth_locale.py
new file mode 100644
index 0000000..4aeeba3
--- /dev/null
+++ b/tests/unit/api/test_auth_locale.py
@@ -0,0 +1,136 @@
+"""GET/PATCH /auth/me — the interface language choice and what it resolves to.
+
+The override lives in its own column, so a user who never touched the picker
+must still get a usable language (the account's), and "auto" must put them back
+there. The endpoint pair is stubbed at the DB boundary — the SQL itself is
+covered by tests/unit/auth/test_deps.py.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+
+import navi.api.routes.auth as auth_routes
+from navi.auth import User
+from navi.auth.deps import require_user
+
+
+@pytest.fixture
+def api(monkeypatch):
+    """TestClient over a signed-in user (account language: uk) with a stubbed store."""
+    from navi.main import app
+
+    user = User(id="u1", email="u1@navi.test", display_name="U", locale="uk")
+    app.dependency_overrides[require_user] = lambda: user
+
+    stored: dict[str, str | None] = {"value": None}
+    written: list[tuple[str, str | None]] = []
+
+    async def _get(_user_id):
+        return stored["value"]
+
+    async def _set(user_id, value):
+        written.append((user_id, value))
+        stored["value"] = value
+
+    monkeypatch.setattr(auth_routes, "get_locale_override", _get)
+    monkeypatch.setattr(auth_routes, "set_locale_override", _set)
+    try:
+        yield TestClient(app), stored, written
+    finally:
+        app.dependency_overrides.pop(require_user, None)
+
+
+def test_me_follows_the_account_language_when_nothing_was_chosen(api):
+    client, _stored, _written = api
+
+    body = client.get("/auth/me").json()
+
+    assert body["locale"] is None
+    assert body["locale_effective"] == "uk"
+    # The rest of the profile is unchanged by the new fields.
+    assert body["id"] == "u1"
+    assert body["email"] == "u1@navi.test"
+    assert "profile_url" in body
+
+
+def test_me_reports_the_chosen_language(api):
+    client, stored, _written = api
+    stored["value"] = "ru"
+
+    body = client.get("/auth/me").json()
+
+    assert body["locale"] == "ru"
+    assert body["locale_effective"] == "ru"
+
+
+def test_me_falls_back_to_english_for_an_unknown_account_tag(monkeypatch):
+    """Accounts can carry tags Navi has no dictionary for — the interface must
+    still come up in a language it can speak."""
+    from navi.main import app
+
+    app.dependency_overrides[require_user] = lambda: User(id="u2", email="u2@navi.test", locale="de")
+
+    async def _no_override(_user_id):
+        return None
+
+    monkeypatch.setattr(auth_routes, "get_locale_override", _no_override)
+    try:
+        body = TestClient(app).get("/auth/me").json()
+    finally:
+        app.dependency_overrides.pop(require_user, None)
+
+    assert body["locale_effective"] == "en"
+
+
+def test_patch_stores_the_choice_and_answers_like_me(api):
+    client, _stored, written = api
+
+    resp = client.patch("/auth/me", json={"locale": "ru"})
+
+    assert resp.status_code == 200
+    assert written == [("u1", "ru")]
+    assert resp.json()["locale"] == "ru"
+    assert resp.json()["locale_effective"] == "ru"
+
+
+@pytest.mark.parametrize("payload", [{"locale": "auto"}, {"locale": ""}, {}])
+def test_patch_clears_the_choice_back_to_the_account(api, payload):
+    """Empty and "auto" are the same value: follow the account again."""
+    client, stored, written = api
+    stored["value"] = "ru"
+
+    resp = client.patch("/auth/me", json=payload)
+
+    assert resp.status_code == 200
+    assert written == [("u1", None)]
+    assert resp.json()["locale"] is None
+    assert resp.json()["locale_effective"] == "uk"
+
+
+def test_patch_normalizes_a_regional_tag(api):
+    client, _stored, written = api
+
+    client.patch("/auth/me", json={"locale": "en-US"})
+
+    assert written == [("u1", "en")]
+
+
+def test_patch_refuses_a_language_we_do_not_ship(api):
+    client, _stored, written = api
+
+    resp = client.patch("/auth/me", json={"locale": "de"})
+
+    assert resp.status_code == 422
+    assert written == []
+
+
+def test_patch_reports_a_failed_write(api, monkeypatch):
+    """A choice that cannot be stored must not be reported as saved."""
+    client, _stored, _written = api
+
+    async def _boom(_user_id, _value):
+        raise RuntimeError("column is gone")
+
+    monkeypatch.setattr(auth_routes, "set_locale_override", _boom)
+
+    assert client.patch("/auth/me", json={"locale": "ru"}).status_code == 503
diff --git a/tests/unit/auth/test_ddl.py b/tests/unit/auth/test_ddl.py
new file mode 100644
index 0000000..946380c
--- /dev/null
+++ b/tests/unit/auth/test_ddl.py
@@ -0,0 +1,33 @@
+"""navi_users gains columns only through the boot-time migration list.
+
+An existing database never re-runs CREATE TABLE (IF NOT EXISTS is a no-op
+there), so a column added to the DDL but forgotten in
+_NAVI_USERS_MIGRATION_COLUMNS is silently absent on every deployed instance
+while working fine on a fresh one.
+"""
+
+import re
+
+from navi.auth._ddl import _DDL, _NAVI_USERS_MIGRATION_COLUMNS
+
+# The columns navi_users was created with; everything else has to be migratable.
+_ORIGINAL_COLUMNS = {
+    "id", "email", "display_name", "role", "permissions", "created_at", "updated_at",
+}
+
+
+def _declared_columns() -> set[str]:
+    block = re.search(r"CREATE TABLE IF NOT EXISTS navi_users \((.*?)\n\);", _DDL, re.S)
+    assert block, "navi_users is no longer declared in _DDL — update this test"
+    return {line.split()[0] for line in block.group(1).splitlines() if line.strip()}
+
+
+def test_every_migrated_column_exists_in_the_ddl():
+    declared = _declared_columns()
+    for name, _type in _NAVI_USERS_MIGRATION_COLUMNS:
+        assert name in declared, f"{name} is migrated but never declared"
+
+
+def test_every_added_column_is_migratable():
+    migrated = {name for name, _type in _NAVI_USERS_MIGRATION_COLUMNS}
+    assert _declared_columns() - _ORIGINAL_COLUMNS <= migrated
diff --git a/tests/unit/auth/test_deps.py b/tests/unit/auth/test_deps.py
index a8229f6..3838822 100644
--- a/tests/unit/auth/test_deps.py
+++ b/tests/unit/auth/test_deps.py
@@ -13,9 +13,11 @@
     _user_cache,
     check_session_access,
     get_current_user,
+    get_locale_override,
     require_admin,
     require_permission,
     require_user,
+    set_locale_override,
 )
 from navi.auth.encrypt import TokenEncryptor
 from tests.conftest_factory import FakeConnection, FakePool
@@ -527,3 +529,52 @@
     _cleanup_refresh_locks()
 
     assert "s-old" not in _refresh_locks
+
+
+# ── interface language ──────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_locale_override_reads_the_column(_auth_env):
+    conn = FakeConnection()
+    conn.enqueue("ru")
+    _auth_env["get_store"].return_value = FakeSessionStore(conn)
+
+    assert await get_locale_override("u1") == "ru"
+    kind, sql, args = conn.calls[0]
+    assert kind == "fetchval"
+    assert "locale_override" in sql
+    assert args == ("u1",)
+
+
+@pytest.mark.asyncio
+async def test_locale_override_read_degrades_to_following_the_account(_auth_env):
+    """A missing store (or an unmigrated column) must never break sign-in."""
+    _auth_env["get_store"].side_effect = RuntimeError("no store")
+
+    assert await get_locale_override("u1") is None
+
+
+@pytest.mark.asyncio
+async def test_locale_override_write(_auth_env):
+    conn = FakeConnection()
+    _auth_env["get_store"].return_value = FakeSessionStore(conn)
+
+    await set_locale_override("u1", "uk")
+
+    kind, sql, args = conn.calls[0]
+    assert kind == "execute"
+    assert sql.startswith("UPDATE navi_users SET locale_override")
+    assert args[0] == "u1"
+    assert args[1] == "uk"
+
+
+@pytest.mark.asyncio
+async def test_locale_override_write_can_clear_the_choice(_auth_env):
+    """No override on the row = follow the account language again."""
+    conn = FakeConnection()
+    _auth_env["get_store"].return_value = FakeSessionStore(conn)
+
+    await set_locale_override("u1", None)
+
+    assert conn.calls[0][2][1] is None
diff --git a/tests/unit/test_locales.py b/tests/unit/test_locales.py
new file mode 100644
index 0000000..03ebe09
--- /dev/null
+++ b/tests/unit/test_locales.py
@@ -0,0 +1,45 @@
+"""Interface language tags: normalisation, and what a user's language resolves to."""
+
+import pytest
+
+from navi.locales import SUPPORTED_LOCALES, effective_locale, normalize_locale
+
+
+@pytest.mark.parametrize("tag,expected", [
+    ("en", "en"),
+    ("en-US", "en"),
+    ("en_US", "en"),
+    ("UK", "uk"),
+    ("ru-RU", "ru"),
+    ("  uk  ", "uk"),
+    # A tag's subtags are irrelevant here — only the language prefix matters.
+    ("en-GB-oed", "en"),
+])
+def test_normalize_locale_reads_the_language_prefix(tag, expected):
+    assert normalize_locale(tag) == expected
+
+
+@pytest.mark.parametrize("tag", ["de", "zh-Hans", "", None, "russian", "e"])
+def test_normalize_locale_rejects_what_we_do_not_ship(tag):
+    assert normalize_locale(tag) is None
+
+
+def test_every_supported_locale_normalizes_to_itself():
+    for code in SUPPORTED_LOCALES:
+        assert normalize_locale(code) == code
+
+
+def test_override_wins_over_the_account():
+    assert effective_locale("ru", "uk") == "ru"
+
+
+def test_account_language_is_used_when_there_is_no_override():
+    assert effective_locale(None, "uk") == "uk"
+    assert effective_locale("", "ru") == "ru"
+
+
+def test_english_when_neither_is_known():
+    """An unsupported account tag must not leak into the interface — the
+    dictionaries only ship en/uk/ru, and English is the fallback everywhere."""
+    assert effective_locale(None, None) == "en"
+    assert effective_locale("de", "zh") == "en"
diff --git a/webclient/CLAUDE.md b/webclient/CLAUDE.md
index 13ce91d..33ad76e 100644
--- a/webclient/CLAUDE.md
+++ b/webclient/CLAUDE.md
@@ -91,3 +91,18 @@
 - Surfaces intentionally NOT kit components (documented escape hatches):
   LoginScreen (SSO redirect, GnLoginCard doesn't fit), chat domain cards,
   MessageList, ImageLightbox.
+
+## Interface language
+
+The client speaks en/uk/ru through `src/i18n/` (no vue-i18n — a `t()` with
+`{param}` interpolation, Slavic plurals and flat per-area dictionaries in
+`src/i18n/messages/`). Rules come from the platform handbook
+(`10-platform/i18n`); [`../docs/i18n.md`](../docs/i18n.md) records navi's
+specifics, the slug areas, and which areas are still hard-coded English.
+
+- New UI text goes through `t('<area>.<name>')`, with the slug added to all
+  three dictionaries; a slug a language does not carry yet falls back to English.
+- Lists of options or nav items must be **computed** — a module-level array
+  freezes the labels in the language active at import.
+- The language is `locale_effective` from `/auth/me` (Settings choice → account
+  locale → en), or `navi.locale` in localStorage when there is no account.
diff --git a/webclient/src/App.vue b/webclient/src/App.vue
index 7a45c43..76921a7 100644
--- a/webclient/src/App.vue
+++ b/webclient/src/App.vue
@@ -78,6 +78,7 @@
 import { useChatStore } from '@/stores/chat'
 import { useAuthStore } from '@/stores/auth'
 import { isSettingsHash } from '@/utils/hash.js'
+import { setLocale, storedLocale, t } from '@/i18n/index.js'
 import AppSidebar from '@/components/sidebar/AppSidebar.vue'
 import ConfirmDialog from '@/components/ui/ConfirmDialog.vue'
 import ImageLightbox from '@/components/ui/ImageLightbox.vue'
@@ -108,7 +109,7 @@
 const showWelcome = computed(() => route.value === 'chat' && !chatStore.currentId && !chatStore.loading)
 
 const documentTitle = computed(() => {
-  if (route.value === 'settings') return 'Navi — Settings'
+  if (route.value === 'settings') return t('app.titleSettings')
   if (!chatStore.currentId) return 'Navi'
   const id = chatStore.currentId
   // nameById persists beyond the loaded list page (the list holds only ~30)
@@ -170,6 +171,10 @@
     }
   }
 
+  // Interface language: the account's own, with whatever was chosen in
+  // Settings, as soon as there is an account — this browser's choice otherwise.
+  setLocale(authStore.user ? authStore.user.locale_effective : storedLocale())
+
   // Load app data only if authenticated or auth is not configured
   if (!authStore.authConfigured || authStore.isAuthenticated) {
     try {
diff --git a/webclient/src/api/index.js b/webclient/src/api/index.js
index a1057b2..4c1732f 100644
--- a/webclient/src/api/index.js
+++ b/webclient/src/api/index.js
@@ -43,6 +43,12 @@
   return request('GET', '/auth/me')
 }
 
+// `{ locale }` — an empty string or "auto" follows the account language again.
+// Answers with the same body as getMe().
+export function updateMe(payload) {
+  return request('PATCH', '/auth/me', payload)
+}
+
 export function logout() {
   return request('POST', '/auth/logout')
 }
diff --git a/webclient/src/components/settings/AccountPanel.vue b/webclient/src/components/settings/AccountPanel.vue
new file mode 100644
index 0000000..1bd1dc6
--- /dev/null
+++ b/webclient/src/components/settings/AccountPanel.vue
@@ -0,0 +1,112 @@
+<template>
+  <div class="account-panel">
+    <!-- First block of the Account tab: the language of the interface itself. -->
+    <div class="account-language">
+      <div class="account-language-header">
+        <h2 class="account-language-title">{{ t('settings.languageToolbar') }}</h2>
+      </div>
+
+      <p class="account-language-description">{{ languageDescription }}</p>
+
+      <GnSelect
+        class="language-select"
+        :aria-label="t('settings.languageToolbar')"
+        :model-value="currentLocale"
+        :options="localeOptions"
+        :disabled="saving"
+        @update:model-value="changeLanguage"
+      />
+    </div>
+
+    <ApiKeysPanel />
+  </div>
+</template>
+
+<script setup>
+import { computed, ref } from 'vue'
+import { GnSelect, useToast } from 'gnexus-ui-kit/vue'
+import { updateMe } from '@/api'
+import { useAuthStore } from '@/stores/auth.js'
+import { SUPPORTED_LOCALES, locale, rememberLocale, setLocale, t } from '@/i18n/index.js'
+import ApiKeysPanel from './ApiKeysPanel.vue'
+
+const authStore = useAuthStore()
+const toast = useToast()
+
+const saving = ref(false)
+
+// Signed in, the language is a property of the account and follows it to other
+// devices. Without an account there is nothing to follow: sign-in may be off
+// altogether, and a visitor who is not signed in has no account either.
+const signedIn = computed(() => !authStore.isNoAuthMode && authStore.user !== null)
+
+const LANG_SLUGS = { en: 'profile.langEn', uk: 'profile.langUk', ru: 'profile.langRu' }
+
+// Computed, not a module-level constant: the labels go through t() and have to
+// be rebuilt whenever the language changes.
+const localeOptions = computed(() => {
+  const languages = SUPPORTED_LOCALES.map(code => ({ value: code, label: t(LANG_SLUGS[code]) }))
+  return signedIn.value
+    ? [{ value: '', label: t('profile.languageAuto') }, ...languages]
+    : languages
+})
+
+// '' is the Auto option — a value GnSelect can hold, unlike null.
+const currentLocale = computed(() => (signedIn.value ? authStore.user.locale ?? '' : locale.value))
+
+const languageDescription = computed(() =>
+  t(signedIn.value ? 'settings.languageDescription' : 'settings.languageDescriptionOpen')
+)
+
+async function changeLanguage(value) {
+  if (!signedIn.value) {
+    // No account to write to: the choice stays in this browser.
+    rememberLocale(value)
+    setLocale(value)
+    toast.success({ title: t('toast.languageSaved') })
+    return
+  }
+
+  saving.value = true
+  try {
+    // '' is Auto; the backend reads both it and 'auto' as "follow the account".
+    const updated = await updateMe({ locale: value || 'auto' })
+    authStore.user = updated
+    setLocale(updated.locale_effective)
+    toast.success({ title: t('toast.languageSaved') })
+  } catch (err) {
+    // The stored language is unchanged, so the picker still shows the truth.
+    toast.error({ title: t('common.error'), text: err.message })
+  } finally {
+    saving.value = false
+  }
+}
+</script>
+
+<style scoped lang="scss">
+@use 'kit-deps' as *;
+
+.account-language {
+  margin-bottom: 24px;
+}
+
+.account-language-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 12px;
+}
+
+.account-language-title {
+  font-size: 1.1rem;
+  font-weight: 600;
+  margin: 0;
+  color: var(--gn-color-text-medium);
+}
+
+.account-language-description {
+  margin: 0 0 16px;
+  font-size: 0.875rem;
+  color: var(--gn-color-text-medium);
+}
+</style>
diff --git a/webclient/src/components/ui/LoginScreen.vue b/webclient/src/components/ui/LoginScreen.vue
index 5ef0943..9a25f4e 100644
--- a/webclient/src/components/ui/LoginScreen.vue
+++ b/webclient/src/components/ui/LoginScreen.vue
@@ -4,7 +4,7 @@
       <img src="/images/logo.svg" alt="Navi" class="login-logo" />
       <h1 class="login-title">Welcome to Navi</h1>
       <p class="login-subtitle">Your personal AI assistant</p>
-      <GnButton variant="primary" class="login-btn" icon="ph ph-sign-in" @click="login">
+      <GnButton variant="primary" class="login-btn" icon="ph ph-sign-in" @click="authStore.login">
         Login with GNEXUS
       </GnButton>
     </div>
@@ -12,9 +12,12 @@
 </template>
 
 <script setup>
-function login() {
-  window.location.href = '/auth/login'
-}
+import { useAuthStore } from '@/stores/auth.js'
+
+// One implementation of the redirect: the sidebar's sign-in button goes
+// through the same store method, and that one carries the current hash back
+// across the SSO round trip.
+const authStore = useAuthStore()
 </script>
 
 <style scoped>
diff --git a/webclient/src/i18n/index.js b/webclient/src/i18n/index.js
new file mode 100644
index 0000000..e941e9f
--- /dev/null
+++ b/webclient/src/i18n/index.js
@@ -0,0 +1,84 @@
+// Tiny reactive i18n for the SPA (vue-i18n is deliberately not pulled in, per
+// the gnexus handbook): a locale ref, a t() with {param} interpolation and
+// Slavic plural forms, and flat per-area message dictionaries. The language is
+// the backend's `locale_effective` (settings override → auth account → en)
+// whenever there is an account, and this browser's own choice otherwise.
+import { ref, watch } from 'vue'
+
+import en from './messages/en.js'
+import uk from './messages/uk.js'
+import ru from './messages/ru.js'
+
+const messages = { en, uk, ru }
+
+export const SUPPORTED_LOCALES = Object.keys(messages)
+
+// With sign-in switched off there is no account to follow, so the choice
+// belongs to this browser and is kept here.
+export const LOCALE_STORAGE_KEY = 'navi.locale'
+
+export const locale = ref('en')
+
+// Language tags normalize to their 2-letter prefix ("en-US" → "en"); anything
+// the dictionaries do not ship falls back to English.
+export function normalizeTag(tag) {
+  const prefix = String(tag || '').trim().toLowerCase().split(/[-_]/)[0]
+  return messages[prefix] ? prefix : null
+}
+
+export function setLocale(tag) {
+  locale.value = normalizeTag(tag) || 'en'
+}
+
+export function storedLocale() {
+  try {
+    return normalizeTag(localStorage.getItem(LOCALE_STORAGE_KEY))
+  } catch {
+    // Storage blocked (private window) — English is a working answer.
+    return null
+  }
+}
+
+export function rememberLocale(tag) {
+  try {
+    localStorage.setItem(LOCALE_STORAGE_KEY, tag)
+  } catch {
+    // Nothing to do: the choice then lasts for this page view only.
+  }
+}
+
+watch(locale, (lang) => {
+  if (typeof document !== 'undefined') document.documentElement.lang = lang
+})
+
+export function pluralCategory(lang, n) {
+  // ru/uk: n%10==1 (except 11) → one; 2-4 (except 12-14) → few; else many
+  const mod10 = n % 10
+  const mod100 = n % 100
+  if (lang === 'ru' || lang === 'uk') {
+    if (mod10 === 1 && mod100 !== 11) return 'one'
+    if (mod10 >= 2 && mod10 <= 4 && !(mod100 >= 12 && mod100 <= 14)) return 'few'
+    return 'many'
+  }
+  return n === 1 ? 'one' : 'other'
+}
+
+function interpolate(text, params) {
+  return text.replace(/\{(\w+)\}/g, (match, key) =>
+    params && key in params ? String(params[key]) : match
+  )
+}
+
+function lookup(slug) {
+  return messages[locale.value]?.[slug] ?? messages.en[slug]
+}
+
+export function t(slug, params) {
+  let text = lookup(slug)
+  if (text != null && typeof text === 'object') {
+    // Plural dictionary {one, few, many, other}; a missing form falls to other.
+    const n = Number(params?.n ?? 0)
+    text = text[pluralCategory(locale.value, n)] ?? text.other
+  }
+  return text != null ? interpolate(String(text), params) : slug
+}
diff --git a/webclient/src/i18n/messages/en.js b/webclient/src/i18n/messages/en.js
new file mode 100644
index 0000000..6625b1a
--- /dev/null
+++ b/webclient/src/i18n/messages/en.js
@@ -0,0 +1,35 @@
+// Navi's interface strings: flat slugs grouped by area, one dictionary per
+// language, the same slugs in all of them. A slug a dictionary does not carry
+// yet falls back to English, and the English string is the literal the code
+// used to hard-code — so a language that is still being filled in changes
+// nothing a test or a reader of the English interface can see.
+//
+// Product names (Navi, Synapse, MCP, Ollama, GitHub…) are never translated.
+// Strings with markup in them are split around it: the markup stays in the
+// template, the words live here.
+export default {
+  // app shell — document titles and other chrome outside the chat itself
+  'app.titleSettings': 'Navi — Settings',
+
+  // shared vocabulary, reused wherever the meaning is the same
+  'common.error': 'Something went wrong',
+
+  // the account itself
+  'profile.languageAuto': 'Auto (from account)',
+  // A language is always written in its own language, so these three are
+  // identical in every dictionary and must not be translated.
+  'profile.langEn': 'English',
+  'profile.langUk': 'Українська',
+  'profile.langRu': 'Русский',
+
+  // toasts — a title, sometimes a line of text under it
+  'toast.languageSaved': 'Language saved',
+
+  // settings — the language row of the Account tab, the first area to be moved
+  // off hard-coded English
+  'settings.languageToolbar': 'Interface language',
+  'settings.languageDescription':
+    'Navi follows the language of your gnexus-auth account by default; a choice here overrides it for Navi only. Auto goes back to the account language.',
+  'settings.languageDescriptionOpen':
+    'Sign-in is switched off on this Navi, so the language is kept in this browser only.',
+}
diff --git a/webclient/src/i18n/messages/ru.js b/webclient/src/i18n/messages/ru.js
new file mode 100644
index 0000000..6416c98
--- /dev/null
+++ b/webclient/src/i18n/messages/ru.js
@@ -0,0 +1,30 @@
+// Русский интерфейс Navi. Слаги те же, что в en.js, — словарь читается по ним,
+// а не по порядку строк. Имена продуктов (Navi, Synapse, MCP, Ollama, GitHub…)
+// не переводятся: они и есть название. Формы множественного числа выбираются
+// по params.n, поэтому у числовых строк здесь четыре ключа вместо двух.
+export default {
+  // оболочка приложения — заголовки документа и прочее вне самого чата
+  'app.titleSettings': 'Navi — Настройки',
+
+  // общая лексика, повторяется везде, где смысл тот же
+  'common.error': 'Что-то пошло не так',
+
+  // сам аккаунт
+  'profile.languageAuto': 'Авто (из аккаунта)',
+  // Язык всегда пишется на самом себе, поэтому эти три строки одинаковы во всех
+  // словарях и переводу не подлежат.
+  'profile.langEn': 'English',
+  'profile.langUk': 'Українська',
+  'profile.langRu': 'Русский',
+
+  // всплывающие сообщения — заголовок, иногда строка текста под ним
+  'toast.languageSaved': 'Язык сохранён',
+
+  // настройки — строка языка на вкладке «Аккаунт», первая область, ушедшая с
+  // жёстко прописанного английского
+  'settings.languageToolbar': 'Язык интерфейса',
+  'settings.languageDescription':
+    'По умолчанию Navi следует языку вашего аккаунта gnexus-auth; выбор здесь перекрывает его только для Navi. «Авто» возвращает язык аккаунта.',
+  'settings.languageDescriptionOpen':
+    'Вход в этот Navi отключён, поэтому язык сохраняется только в этом браузере.',
+}
diff --git a/webclient/src/i18n/messages/uk.js b/webclient/src/i18n/messages/uk.js
new file mode 100644
index 0000000..e94e021
--- /dev/null
+++ b/webclient/src/i18n/messages/uk.js
@@ -0,0 +1,30 @@
+// Український інтерфейс Navi. Слаги ті самі, що в en.js, — словник читається за
+// ними, а не за порядком рядків. Назви продуктів (Navi, Synapse, MCP, Ollama,
+// GitHub…) не перекладаються: це і є назва. Форми множини вибираються за
+// params.n, тому в числових рядків тут чотири ключі замість двох.
+export default {
+  // оболонка застосунку — заголовки документа та інше поза самим чатом
+  'app.titleSettings': 'Navi — Налаштування',
+
+  // спільна лексика, повторюється всюди, де сенс той самий
+  'common.error': 'Щось пішло не так',
+
+  // сам акаунт
+  'profile.languageAuto': 'Авто (з акаунта)',
+  // Мова завжди пишеться сама собою, тому ці три рядки однакові в усіх
+  // словниках і перекладу не підлягають.
+  'profile.langEn': 'English',
+  'profile.langUk': 'Українська',
+  'profile.langRu': 'Русский',
+
+  // сповіщення-тости — заголовок, іноді рядок тексту під ним
+  'toast.languageSaved': 'Мову збережено',
+
+  // налаштування — рядок мови на вкладці «Акаунт», перша область, що пішла з
+  // жорстко прописаної англійської
+  'settings.languageToolbar': 'Мова інтерфейсу',
+  'settings.languageDescription':
+    'Стандартно Navi наслідує мову вашого акаунта gnexus-auth; вибір тут перекриває її лише для Navi. «Авто» повертає мову акаунта.',
+  'settings.languageDescriptionOpen':
+    'Вхід у цей Navi вимкнено, тому мова зберігається лише в цьому браузері.',
+}
diff --git a/webclient/src/stores/auth.js b/webclient/src/stores/auth.js
index 8c7f7ee..6c62312 100644
--- a/webclient/src/stores/auth.js
+++ b/webclient/src/stores/auth.js
@@ -67,8 +67,10 @@
     if (isAndroid) {
       params.set('platform', 'android')
     }
-    const qs = params.toString()
-    window.location.href = '/auth/login' + (qs ? '?' + qs : '')
+    // Come back to where the reader was: the hash names the open session or a
+    // settings section, and the SSO round trip would otherwise drop it.
+    params.set('return_to', location.pathname + location.search + location.hash)
+    window.location.href = '/auth/login?' + params.toString()
   }
 
   async function logout() {
diff --git a/webclient/tests/unit/components/settings/accountPanel.test.js b/webclient/tests/unit/components/settings/accountPanel.test.js
new file mode 100644
index 0000000..9efd100
--- /dev/null
+++ b/webclient/tests/unit/components/settings/accountPanel.test.js
@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+import { nextTick } from 'vue'
+import { createPinia, setActivePinia } from 'pinia'
+import { useAuthStore } from '@/stores/auth.js'
+import { LOCALE_STORAGE_KEY, locale, setLocale } from '@/i18n/index.js'
+import AccountPanel from '@/components/settings/AccountPanel.vue'
+
+vi.mock('@/api', () => ({ updateMe: vi.fn() }))
+vi.mock('@/components/settings/ApiKeysPanel.vue', () => ({
+  default: { name: 'ApiKeysPanel', template: '<div data-test="keys-stub" />' },
+}))
+
+// No GnToastProvider in tests — swallow toast calls.
+vi.mock('gnexus-ui-kit/vue', async (importOriginal) => {
+  const mod = await importOriginal()
+  const toast = {
+    show: () => {}, info: () => {}, success: () => {},
+    warning: () => {}, danger: () => {}, error: () => {}, close: () => {},
+  }
+  return { ...mod, useToast: () => toast }
+})
+
+import { updateMe } from '@/api'
+
+/** The language picker of a signed-in user whose account speaks uk. */
+function signedIn({ stored = null, effective = 'uk' } = {}) {
+  const auth = useAuthStore()
+  auth.authEnabled = true
+  auth.user = { id: 'u1', locale: stored, locale_effective: effective }
+  return auth
+}
+
+function options(wrapper) {
+  return wrapper.findAll('option').map(option => option.text())
+}
+
+async function select(wrapper, value) {
+  const el = wrapper.find('.language-select')
+  await el.setValue(value)
+  await flushPromises()
+}
+
+describe('Account — interface language', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    setLocale('en')
+    document.documentElement.lang = 'en'
+    updateMe.mockReset()
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  // The label of a language is written in that language, so the same three
+  // strings appear in every dictionary and are never translated.
+  it('lists the account option first, then every language in its own name', () => {
+    signedIn()
+    const wrapper = mount(AccountPanel)
+
+    expect(options(wrapper)).toEqual(['Auto (from account)', 'English', 'Українська', 'Русский'])
+    expect(wrapper.find('[data-test="keys-stub"]').exists()).toBe(true)
+  })
+
+  it('shows what the interface actually uses right now', () => {
+    signedIn({ stored: 'ru', effective: 'ru' })
+
+    expect(mount(AccountPanel).find('.language-select').element.value).toBe('ru')
+  })
+
+  it('shows Auto when the account language is what is used', () => {
+    signedIn({ stored: null, effective: 'uk' })
+
+    expect(mount(AccountPanel).find('.language-select').element.value).toBe('')
+  })
+
+  it('stores a chosen language on the account and switches to it', async () => {
+    const auth = signedIn()
+    updateMe.mockResolvedValue({ id: 'u1', locale: 'ru', locale_effective: 'ru' })
+    const wrapper = mount(AccountPanel)
+
+    await select(wrapper, 'ru')
+
+    expect(updateMe).toHaveBeenCalledWith({ locale: 'ru' })
+    expect(auth.user.locale).toBe('ru')
+    expect(locale.value).toBe('ru')
+    await nextTick()
+    expect(document.documentElement.lang).toBe('ru')
+  })
+
+  it('sends Auto as "auto" and goes back to the account language', async () => {
+    const auth = signedIn({ stored: 'ru', effective: 'ru' })
+    updateMe.mockResolvedValue({ id: 'u1', locale: null, locale_effective: 'uk' })
+    const wrapper = mount(AccountPanel)
+
+    await select(wrapper, '')
+
+    expect(updateMe).toHaveBeenCalledWith({ locale: 'auto' })
+    expect(auth.user.locale).toBeNull()
+    expect(locale.value).toBe('uk')
+  })
+
+  // A save that failed must not look saved: the picker keeps naming the
+  // language the backend actually holds.
+  it('keeps the current language when the choice cannot be stored', async () => {
+    signedIn({ stored: 'ru', effective: 'ru' })
+    setLocale('ru') // what boot did with locale_effective
+    updateMe.mockRejectedValue(new Error('PATCH /auth/me → 503'))
+    const wrapper = mount(AccountPanel)
+
+    await select(wrapper, 'en')
+
+    expect(locale.value).toBe('ru')
+    expect(wrapper.find('.language-select').element.value).toBe('ru')
+  })
+
+  // Sign-in switched off: there is no account to follow, so Auto is not
+  // offered and the choice is this browser's.
+  it('offers an explicit choice only when there is no account', async () => {
+    const auth = useAuthStore()
+    auth.authEnabled = false
+    auth.user = null
+    const storage = { entries: {}, getItem(k) { return this.entries[k] ?? null }, setItem(k, v) { this.entries[k] = v } }
+    vi.stubGlobal('localStorage', storage)
+    const wrapper = mount(AccountPanel)
+
+    expect(options(wrapper)).toEqual(['English', 'Українська', 'Русский'])
+
+    await select(wrapper, 'ru')
+
+    expect(updateMe).not.toHaveBeenCalled()
+    expect(storage.entries[LOCALE_STORAGE_KEY]).toBe('ru')
+    expect(locale.value).toBe('ru')
+  })
+})
diff --git a/webclient/tests/unit/i18n/index.test.js b/webclient/tests/unit/i18n/index.test.js
new file mode 100644
index 0000000..e4280e7
--- /dev/null
+++ b/webclient/tests/unit/i18n/index.test.js
@@ -0,0 +1,175 @@
+import { describe, it, expect, afterEach, beforeEach, vi } from 'vitest'
+import { nextTick } from 'vue'
+
+import {
+  LOCALE_STORAGE_KEY,
+  SUPPORTED_LOCALES,
+  locale,
+  normalizeTag,
+  pluralCategory,
+  rememberLocale,
+  setLocale,
+  storedLocale,
+  t,
+} from '@/i18n/index.js'
+import en from '@/i18n/messages/en.js'
+import ru from '@/i18n/messages/ru.js'
+
+describe('language tags', () => {
+  it('ships exactly the three languages of the handbook', () => {
+    expect(SUPPORTED_LOCALES).toEqual(['en', 'uk', 'ru'])
+  })
+
+  it('reads the language prefix out of a tag', () => {
+    expect(normalizeTag('en-US')).toBe('en')
+    expect(normalizeTag('uk_UA')).toBe('uk')
+    expect(normalizeTag(' RU ')).toBe('ru')
+  })
+
+  it('refuses a language it has no dictionary for', () => {
+    expect(normalizeTag('de')).toBeNull()
+    expect(normalizeTag('')).toBeNull()
+    expect(normalizeTag(null)).toBeNull()
+  })
+
+  it('falls back to English for a tag it cannot use', () => {
+    setLocale('de')
+    expect(locale.value).toBe('en')
+  })
+
+  it('follows the chosen language into the document', async () => {
+    setLocale('uk')
+    await nextTick()
+    expect(document.documentElement.lang).toBe('uk')
+
+    setLocale('en')
+    await nextTick()
+    expect(document.documentElement.lang).toBe('en')
+  })
+})
+
+describe('translating', () => {
+  beforeEach(() => setLocale('en'))
+
+  it('answers in the chosen language', () => {
+    setLocale('uk')
+    expect(t('toast.languageSaved')).toBe('Мову збережено')
+
+    setLocale('ru')
+    expect(t('toast.languageSaved')).toBe('Язык сохранён')
+  })
+
+  // The dictionaries are filled in area by area, so a language is expected to
+  // be missing slugs for a while — the interface must still be readable.
+  describe('when a dictionary is not complete yet', () => {
+    afterEach(() => {
+      ru['toast.languageSaved'] = 'Язык сохранён'
+    })
+
+    it('falls back to English for a slug the language does not carry', () => {
+      delete ru['toast.languageSaved']
+      setLocale('ru')
+
+      expect(t('toast.languageSaved')).toBe('Language saved')
+    })
+
+    it('shows the slug itself rather than nothing when nobody has it', () => {
+      expect(t('nope.not.a.slug')).toBe('nope.not.a.slug')
+    })
+  })
+
+  it('interpolates parameters', () => {
+    en['test.greeting'] = 'Hello {name}, {n} new'
+    try {
+      expect(t('test.greeting', { name: 'Ada', n: 3 })).toBe('Hello Ada, 3 new')
+      // A parameter nobody passed stays visible instead of turning into "undefined"
+      expect(t('test.greeting', { name: 'Ada' })).toBe('Hello Ada, {n} new')
+    } finally {
+      delete en['test.greeting']
+    }
+  })
+
+  it('picks the plural form from n', () => {
+    en['test.items'] = { one: '{n} item', other: '{n} items' }
+    ru['test.items'] = { one: '{n} вещь', few: '{n} вещи', many: '{n} вещей' }
+    try {
+      setLocale('en')
+      expect(t('test.items', { n: 1 })).toBe('1 item')
+      expect(t('test.items', { n: 2 })).toBe('2 items')
+
+      setLocale('ru')
+      expect(t('test.items', { n: 1 })).toBe('1 вещь')
+      expect(t('test.items', { n: 3 })).toBe('3 вещи')
+      expect(t('test.items', { n: 5 })).toBe('5 вещей')
+      expect(t('test.items', { n: 21 })).toBe('21 вещь')
+      expect(t('test.items', { n: 12 })).toBe('12 вещей')
+    } finally {
+      delete en['test.items']
+      delete ru['test.items']
+    }
+  })
+})
+
+// The Slavic categories are the part of pluralisation that is easy to get
+// subtly wrong, so they are checked on their own.
+describe('plural categories', () => {
+  it('uses one/few/many for ru and uk', () => {
+    for (const lang of ['ru', 'uk']) {
+      expect([1, 21, 101].map(n => pluralCategory(lang, n))).toEqual(['one', 'one', 'one'])
+      expect([2, 3, 4, 22].map(n => pluralCategory(lang, n))).toEqual(['few', 'few', 'few', 'few'])
+      expect([0, 5, 11, 12, 14, 25].map(n => pluralCategory(lang, n)))
+        .toEqual(['many', 'many', 'many', 'many', 'many', 'many'])
+    }
+  })
+
+  it('uses one/other for English', () => {
+    expect(pluralCategory('en', 1)).toBe('one')
+    expect(pluralCategory('en', 0)).toBe('other')
+    expect(pluralCategory('en', 7)).toBe('other')
+  })
+})
+
+// With sign-in switched off there is no account to follow, and the choice has
+// to survive a reload in this browser.
+describe('the language of a browser without an account', () => {
+  function fakeStorage(initial = {}) {
+    const entries = { ...initial }
+    return {
+      getItem: key => (key in entries ? entries[key] : null),
+      setItem: (key, value) => { entries[key] = String(value) },
+    }
+  }
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    setLocale('en')
+  })
+
+  it('keeps the choice for the next visit', () => {
+    const storage = fakeStorage()
+    vi.stubGlobal('localStorage', storage)
+
+    rememberLocale('ru')
+
+    expect(storage.getItem(LOCALE_STORAGE_KEY)).toBe('ru')
+    expect(storedLocale()).toBe('ru')
+  })
+
+  it('reads nothing out of storage that it cannot speak', () => {
+    vi.stubGlobal('localStorage', fakeStorage({ [LOCALE_STORAGE_KEY]: 'kl-GL' }))
+
+    expect(storedLocale()).toBeNull()
+  })
+
+  it('survives storage being unavailable', () => {
+    // A private window: every access throws, and neither reading nor writing
+    // may take the interface down with it.
+    vi.stubGlobal('localStorage', {
+      getItem: () => { throw new Error('blocked') },
+      setItem: () => { throw new Error('blocked') },
+    })
+
+    expect(storedLocale()).toBeNull()
+    expect(() => rememberLocale('uk')).not.toThrow()
+  })
+})