chore(release): 2.0.0-beta.11 (#48 )

Co-authored-by: by-sonic <171230345+by-sonic@users.noreply.github.com>
fix(proxy): DC и маршрут в строке статуса были из разных соединений (#47 )
2026-09-05 18:16:09 +03:00 · 2026-08-19 15:04:34 +03:00 · 2026-08-19 14:59:34 +03:00 · 2026-08-19 14:37:05 +03:00 · 2026-08-19 14:32:34 +03:00 · 2026-08-19 09:12:23 +03:00
22 changed files with 2130 additions and 198 deletions
@@ -58,6 +58,40 @@ jobs:
      - name: Test
        run: cargo test --all-targets

+  bundle:
+    name: Bundled app must be the GUI binary
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-apple-darwin
+
+      # Явный --target обязателен: без него бандлер выбирал правильный бинарь, а
+      # с ним — нет, и именно так beta.2 и beta.3 уехали с headless CLI внутри.
+      - name: Bundle the app
+        run: npx tauri build --bundles app --target aarch64-apple-darwin
+
+      # Проверяется содержимое, а не имя файла. В beta.3 имя было уже
+      # правильным, потому что бандлер переименовал CLI, и проверка имени
+      # ничего не заметила.
+      - name: The bundled binary must actually be the GUI one
+        run: |
+          exe=$(find target -maxdepth 8 -path '*TGLock.app/Contents/MacOS/tglock' | head -1)
+          test -n "$exe" || { echo "исполняемый файл бандла не найден"; find target -maxdepth 6 -name 'TGLock.app'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
  headless:
    name: Headless CLI (no WebView, no Node)
    runs-on: ubuntu-22.04
@@ -73,13 +107,13 @@ jobs:
      # libwebkit2gtk. It fails the moment anything drags the GUI back into the
      # headless build, which is the whole point of issues #10 and #17.
      - name: Lint
-        run: cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
+        run: cargo clippy --no-default-features --features cli --all-targets -- -D warnings

      - name: Test
-        run: cargo test --no-default-features --lib --bins
+        run: cargo test --no-default-features --features cli --lib --bins

      - name: Build
-        run: cargo build --release --no-default-features --bin tglock-cli
+        run: cargo build --release --no-default-features --features cli --bin tglock-cli

      - name: Start, advertise a proxy link and stop on SIGTERM
        run: |
@@ -101,6 +135,43 @@ jobs:
            ./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > restart.log 2>&1
          test "$first" = "$(grep -o 'secret=[0-9a-f]*' restart.log)"

+      # Настройки из файла и приоритет флага над файлом.
+      - name: Read settings from a file
+        run: |
+          cat > tglock.toml <<'CONF'
+          port = 18090
+          secret = "dd00112233445566778899aabbccddeeff"
+          worker = ["example.workers.dev"]
+          CONF
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml > conf.log 2>&1
+          cat conf.log
+          grep -q '127.0.0.1:18090' conf.log
+          grep -q 'secret=dd00112233445566778899aabbccddeeff' conf.log
+          grep -q 'example.workers.dev' conf.log
+          # Флаг должен перекрывать файл.
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml --port 18091 > over.log 2>&1
+          grep -q '127.0.0.1:18091' over.log
+          # Опечатка в файле обязана быть ошибкой, а не молчаливым дефолтом.
+          echo 'porrt = 1443' > bad.toml
+          if ./target/release/tglock-cli --config bad.toml; then
+            echo "опечатка в конфиге прошла незамеченной"; exit 1
+          fi
+
+      # Закрытый stdout не должен ронять демон: println! при ошибке записи
+      # паникует, а канал закрывается штатно — `| head`, закрытый терминал,
+      # перезапуск сборщика логов.
+      - name: Survive a closed stdout
+        run: |
+          set +e
+          timeout --signal=TERM 5 ./target/release/tglock-cli --port 18092 2> pipe-err.log | head -2
+          set -e
+          cat pipe-err.log
+          if grep -qi 'panic' pipe-err.log; then
+            echo "демон упал из-за закрытого stdout"; exit 1
+          fi
+
  msrv:
    name: Rust 1.88 compatibility
    runs-on: macos-latest
@@ -123,7 +194,7 @@ jobs:
        run: cargo check --locked

      - name: Check the headless dependency graph too
-        run: cargo check --locked --no-default-features --lib --bins
+        run: cargo check --locked --no-default-features --features cli --lib --bins

  frontend:
    name: Frontend
@@ -9,7 +9,40 @@ permissions:
  contents: write

 jobs:
+  # Токен Actions умеет создавать релиз только на HEAD ветки по умолчанию. Если
+  # тег отстал хоть на один коммит, GitHub отвечает «Resource not accessible by
+  # integration» — сообщение про права, хотя права в порядке и дело в положении
+  # тега. Так утонул v2.0.0-beta.8: тег поставили, следом дописали коммит в main,
+  # и три сборки по восемь минут закончились загадочным 403.
+  #
+  # Проверка занимает секунды и идёт до сборок. Но она НЕ закрывает гонку: если
+  # запушить в main уже после её прохождения, публикация всё равно упадёт — как и
+  # случилось с beta.8. Единственная настоящая защита — порядок действий: тег
+  # ставится последним, и пока идёт релиз, в main не пушим.
+  guard:
+    name: Тег должен стоять на HEAD
+    runs-on: ubuntu-latest
+    steps:
+      - name: Сверить тег с веткой по умолчанию
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          branch=$(gh api "repos/$GITHUB_REPOSITORY" -q .default_branch)
+          head=$(gh api "repos/$GITHUB_REPOSITORY/commits/$branch" -q .sha)
+          if [ "$head" = "$GITHUB_SHA" ]; then
+            echo "$GITHUB_REF_NAME и $branch указывают на $head — собираем."
+            exit 0
+          fi
+          echo "::error::$GITHUB_REF_NAME стоит на $GITHUB_SHA, а $branch — на $head. Публикация упадёт с 403, потому что токен Actions создаёт релиз только на HEAD ветки по умолчанию."
+          echo "Переставьте тег и запушьте заново:"
+          echo "  git tag -d $GITHUB_REF_NAME"
+          echo "  git push origin :refs/tags/$GITHUB_REF_NAME"
+          echo "  git tag -a $GITHUB_REF_NAME $head -m 'TGLock ...'"
+          echo "  git push origin $GITHUB_REF_NAME"
+          exit 1
+
  publish:
+    needs: guard
    name: Build ${{ matrix.platform }}
    strategy:
      fail-fast: false
@@ -64,39 +97,52 @@ jobs:
        with:
          tagName: v__VERSION__
          releaseName: TGLock v__VERSION__
+          # Только инструкция по скачиванию: она одна и та же для любой версии.
+          # Список изменений дописывается в release notes при выпуске — иначе
+          # выходит как в бетах 1-7, где каждая несла один и тот же текст «новый
+          # TGLock, полностью обновлённый интерфейс» и понять, что поменялось,
+          # было невозможно.
          releaseBody: |
-            Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
+            ## Что скачивать

-            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
-            - Windows: скачайте `.exe` установщик
-            - Linux: скачайте `.AppImage` или `.deb`
-            - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
+            - **Windows** — `.exe`, установщик
+            - **macOS** — универсальный `.dmg` (или `.app.tar.gz`)
+            - **Linux** — `.AppImage` или `.deb`
+            - **Сервер, контейнер, машина без монитора** — `tglock-cli-*`: то же самое, но без графического интерфейса
+
+            Если Windows ругается на файл — [почему так и что с этим делать](https://github.com/by-sonic/tglock#-антивирус-ругается-smartscreen-предупреждает-virustotal-показывает-детекты).
          releaseDraft: false
          prerelease: false
          args: ${{ matrix.args }}

-      # Смотрит внутрь собранного бандла. v2.0.0-beta.2 опубликовался с зелёным
-      # CI, хотя .app и .deb содержали headless CLI вместо приложения: сборка
-      # была успешной, просто никто не проверял, что внутри.
-      - name: The bundle must contain the GUI binary
+      # Проверяет СОДЕРЖИМОЕ упакованного бинаря, а не его имя.
+      #
+      # v2.0.0-beta.2 и v2.0.0-beta.3 опубликовались с зелёным CI, хотя в бандле
+      # лежал headless CLI вместо приложения. В beta.3 имя файла было уже
+      # правильным — переименованным — поэтому проверка имени прошла. Отличить
+      # можно только по содержимому: `wry`/`ipc.localhost` есть исключительно в
+      # GUI, а `allow-direct` — исключительно в CLI.
+      - name: The bundled binary must actually be the GUI one
        if: runner.os == 'macOS'
        shell: bash
        run: |
          app=$(find target -maxdepth 6 -name 'TGLock.app' -type d | head -1)
          test -n "$app" || { echo "TGLock.app не найден"; exit 1; }
-          exe=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Contents/Info.plist")
-          echo "CFBundleExecutable = $exe"
-          test "$exe" = "tglock" || { echo "в бандле не GUI-бинарь"; exit 1; }
-          test -x "$app/Contents/MacOS/tglock" || { echo "исполняемый файл отсутствует"; exit 1; }
+          exe="$app/Contents/MacOS/tglock"
+          test -f "$exe" || { echo "нет $exe:"; ls -la "$app/Contents/MacOS/"; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"

-      - name: The bundle must contain the GUI binary
+      - name: The bundled binary must actually be the GUI one
        if: runner.os == 'Linux'
        shell: bash
        run: |
          deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
          test -n "$deb" || { echo ".deb не найден"; exit 1; }
-          dpkg-deb -c "$deb" | grep -E ' \./usr/bin/tglock$' \
-            || { echo "в .deb нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          root=$(mktemp -d)
+          dpkg-deb -x "$deb" "$root"
+          exe="$root/usr/bin/tglock"
+          test -f "$exe" || { echo "нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"

  cli:
    name: Headless CLI ${{ matrix.platform }}
@@ -136,7 +182,7 @@ jobs:
          IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
          binaries=()
          for target in "${targets[@]}"; do
-            cargo build --release --locked --no-default-features \
+            cargo build --release --locked --no-default-features --features cli \
              --bin tglock-cli --target "$target"
            binaries+=("target/$target/release/tglock-cli")
          done
@@ -152,7 +198,7 @@ jobs:
        if: runner.os == 'Windows'
        shell: bash
        run: |
-          cargo build --release --locked --no-default-features \
+          cargo build --release --locked --no-default-features --features cli \
            --bin tglock-cli --target ${{ matrix.rust-targets }}
          cp "target/${{ matrix.rust-targets }}/release/tglock-cli.exe" "${{ matrix.asset }}"
          ./"${{ matrix.asset }}" --version
@@ -3553,7 +3553,7 @@ dependencies = [

 [[package]]
 name = "tglock"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.11"
 dependencies = [
 "aes",
 "cipher",
@@ -3570,6 +3570,7 @@ dependencies = [
 "tauri-build",
 "tokio",
 "tokio-tungstenite",
+ "toml 0.8.2",
 ]

 [[package]]
@@ -1,6 +1,6 @@
 [package]
 name = "tglock"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.11"
 edition = "2021"
 rust-version = "1.88"
 description = "Telegram unblock via local WebSocket tunnel"
@@ -13,6 +13,14 @@ default = ["gui"]
 # frontend bundle from the build, which is what makes headless servers and
 # machines without a GPU or monitor able to build and run TGLock at all.
 gui = ["dep:tauri", "dep:tauri-build", "dep:open"]
+# The headless binary. Deliberately NOT in `default`.
+#
+# When both binaries exist in one build, the Tauri bundler picks the wrong one
+# as the application: `tauri build --target <triple>` packaged tglock-cli and
+# shipped it as the app in v2.0.0-beta.2 and v2.0.0-beta.3. Keeping the CLI
+# behind its own non-default feature means it simply does not exist during an
+# application build, so there is nothing to pick wrongly.
+cli = ["dep:clap", "dep:toml"]

 [lib]
 name = "tglock"
@@ -26,11 +34,15 @@ required-features = ["gui"]
 [[bin]]
 name = "tglock-cli"
 path = "src/bin/cli.rs"
+required-features = ["cli"]

 [dependencies]
 tauri = { version = "2", features = [], optional = true }
 open = { version = "5", optional = true }
-clap = { version = "4", features = ["derive"] }
+clap = { version = "4", features = ["derive"], optional = true }
+# Файл конфигурации CLI. TOML, а не JSON, потому что файл правят руками и в нём
+# нужны комментарии.
+toml = { version = "0.8", optional = true }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = [
@@ -122,7 +122,7 @@ TGLock — это **локальный прокси** на твоём компь
 3. **Собрать самому.** Для CLI это одна команда и никаких зависимостей кроме Rust:

   ```bash
-   cargo build --release --locked --no-default-features --bin tglock-cli
+   cargo build --release --locked --no-default-features --features cli --bin tglock-cli
   ```

   Полная сборка с интерфейсом — [ниже](#-сборка-из-исходников).
@@ -155,12 +155,23 @@ Telegram → Настройки → **Продвинутые** → Тип сое

 В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.

-Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
+Когда LAN-режим включён, TGLock показывает в окне **готовый адрес** вида `192.168.1.7:1080` — нажми на него, чтобы скопировать. Плюс он сам открывает ссылку `tg://proxy`, где уже подставлены адрес, порт и секрет: её достаточно переслать себе в Telegram и открыть на телефоне.
+
+> ⚠️ На другом устройстве **не вводи `127.0.0.1`** — для него это оно само, а не твой компьютер. Нужен именно тот адрес, который показан в окне TGLock. Это же касается телефона в эмуляторе (MuMuPlayer, BlueStacks и подобных): внутри эмулятора Android — отдельная машина со своей сетью.
+
+Если адрес нужен руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.

 Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».

 В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.

+> **📵 С телефона не подключается?** Открой **Диагностика** на компьютере и посмотри две цифры.
+>
+> - **Соединения `0` и Отклонено `0`** — телефон до компьютера не дошёл. Дело не в TGLock: проверь, что оба устройства в одной сети (телефон может сидеть на гостевом Wi-Fi или в мобильном интернете), что в роутере не включена изоляция клиентов, и что брандмауэр пускает входящие на порт TGLock.
+> - **Соединения растут, Отклонено растёт** — телефон дошёл, но просит адрес, который LAN-режим не пропускает. Конкретный адрес назван в журнале событий ниже — пришли эту строку в issue.
+> - **Не опознаны растёт** — телефон дошёл, но договориться не вышло. Почти всегда в Telegram на телефоне вписана ссылка от прошлого запуска, то есть другой секрет. Сверь её с той, что показана в окне сейчас.
+> - **Соединения растут, Туннели `0`** — до Telegram не доходит уже сам компьютер. Это [Cloudflare Worker](docs/CLOUDFLARE_WORKER.md), а не проблема LAN.
+
 ### 🖥 Без графического интерфейса: `tglock-cli`

 Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
@@ -173,7 +184,31 @@ tglock-cli --worker my-name.workers.dev    # резервный маршрут,
 tglock-cli --help                          # все флаги
 ```

-При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
+#### Файл настроек
+
+Чтобы не собирать батник с ключами при каждом запуске ([#32](https://github.com/by-sonic/tglock/issues/32)), положите рядом с бинарём `tglock.toml` — он подхватится сам. Или укажите путь: `tglock-cli --config /etc/tglock.toml`.
+
+```toml
+port = 1080
+lan = true
+
+# Секрет — вторая половина ссылки tg://proxy. Для сервиса его нужно закрепить,
+# иначе после перезапуска все настроенные клиенты отвалятся. Запустите один
+# раз, скопируйте из напечатанной ссылки и вставьте сюда.
+secret = "dd00112233445566778899aabbccddeeff"
+
+worker = ["my-name.workers.dev"]
+```
+
+Полный пример со всеми полями и пояснениями — [`tglock.example.toml`](tglock.example.toml).
+
+Приоритеты: значения по умолчанию → файл → флаги. Флаг всегда сильнее файла. Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только включать: их отсутствие означает «взять из файла», а не «выключить».
+
+Опечатка в файле — ошибка при старте с перечислением допустимых полей, а не молча проигнорированная строка. Сервис, который из-за `porrt = 1443` слушает 1080, хуже сервиса, который не запустился.
+
+Файл с секретом внутри держите с правами `600`: это доступ к вашему прокси.
+
+При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев, сколько запросов отклонено политикой «только Telegram» и сколько клиентов не опознано. Отдельными строками отмечаются подключившиеся устройства, адреса, из-за которых был отказ, и клиенты, с которыми не удалось договориться, — по ним видно, дошёл ли телефон до сервиса вообще и не вписан ли в нём устаревший секрет.

 Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.

@@ -189,7 +224,7 @@ Wants=network-online.target

 [Service]
 Type=exec
-ExecStart=/usr/local/bin/tglock-cli --lan --secret-file /var/lib/tglock/secret
+ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
 Restart=on-failure
 RestartSec=5s
 StateDirectory=tglock
@@ -206,11 +241,14 @@ WantedBy=multi-user.target

 ```bash
 sudo install -m755 tglock-cli-x86_64-unknown-linux-gnu /usr/local/bin/tglock-cli
+sudo install -m600 tglock.example.toml /etc/tglock.toml   # и отредактировать
 sudo systemctl enable --now tglock
 journalctl -u tglock -f
 ```

-`--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
+**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
+
+При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.

 Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.

@@ -220,7 +258,7 @@ journalctl -u tglock -f
 FROM rust:1.88 AS build
 WORKDIR /src
 COPY . .
-RUN cargo build --release --locked --no-default-features --bin tglock-cli
+RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli

 FROM debian:bookworm-slim
 RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
@@ -435,7 +473,7 @@ npm run tauri build
 ### Только CLI, без графики

 ```bash
-cargo build --release --locked --no-default-features --bin tglock-cli
+cargo build --release --locked --no-default-features --features cli --bin tglock-cli
 ```

 Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
@@ -445,9 +483,9 @@ cargo build --release --locked --no-default-features --bin tglock-cli
 ```bash
 cargo fmt --check
 cargo clippy --all-targets -- -D warnings
-cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
+cargo clippy --no-default-features --features cli --all-targets -- -D warnings
 cargo test --all-targets
-cargo test --no-default-features --lib --bins
+cargo test --no-default-features --features cli --lib --bins
 ```

 Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.
@@ -55,6 +55,67 @@ LAN-режим превращал бы машину в открытый прок
 `config::ListenConfig`, а не в условиях по месту вызова; переопределяется
 только явным `--allow-direct` в CLI.

+### Что считается адресом Telegram
+
+Список сетей — опубликованный самим Telegram
+(<https://core.telegram.org/resources/cidr.txt>), он лежит в `telegram_net` и
+проверяется по маске префикса. До 2.0.0-beta.9 сравнивались два первых октета,
+то есть «телеграмом» считались целиком `149.154.0.0/16`, `91.108.0.0/16`,
+`91.105.0.0/16` и `185.76.0.0/16`, а IPv6 не распознавался вовсе. Ошибка была в
+обе стороны:
+
+- чужие адреса внутри этих `/16` уходили в MTProto-туннель и умирали там;
+- настоящие адреса дата-центров по IPv6 отклонялись как посторонние.
+
+Второе и давало «на компьютере работает, с телефона нет» (#42): на loopback
+неопознанный адрес всё равно релеился напрямую, поэтому там дефект не
+проявлялся, а на сетевом слушателе тот же адрес получал отказ.
+
+Назначение делится на три вида:
+
+| Вид | Что это | Что делаем |
+|---|---|---|
+| Дата-центр | IP из опубликованных сетей, v4 или v6 | заворачиваем в WebSocket |
+| Веб Telegram | имя из `telegram.org`, `t.me`, `telegram.me`, `telesco.pe`, `cdn-telegram.org` | пропускаем как есть — это обычный HTTPS, а не MTProto |
+| Всё остальное | — | напрямую на loopback, отказ на сетевом адресе |
+
+Имена сопоставляются по границе метки, поэтому `telegram.org.example.com` —
+посторонний домен. В ограниченном режиме имя разрешается заранее, и адреса
+внутри локальной сети (`127.0.0.0/8`, `10/8`, `172.16/12`, `192.168/16`,
+`100.64/10`, `fc00::/7`, `fe80::/10`) отбрасываются: назначение выбирает чужое
+устройство, и DNS-ответ не должен превращать TGLock в дверь во внутреннюю сеть
+этой машины.
+
+### Отказ перестаёт быть молчаливым
+
+Отклонённый запрос увеличивает счётчик `blocked` и один раз называет адрес в
+журнале; повторы того же адреса склеиваются, чтобы не забить журнал одной
+строкой. Отдельно отмечается первое подключение с каждого сетевого адреса.
+
+Без этого «с телефона не работает» неразличимо распадалось на два случая:
+телефон не дошёл до машины (сеть, брандмауэр, изоляция клиентов на роутере) —
+и дошёл, но попросил адрес, который мы не пропускаем. Первый виден как ноль
+соединений и ноль отказов, второй — как соединения есть, отказы растут.
+
+Третий случай нашёлся, когда репортёр #42 прислал диагностику: у него было ноль
+отказов и работающие туннели, то есть оба счётчика говорили «всё хорошо».
+Клиент, который дошёл до прокси, но не сумел договориться, не попадал ни в
+один из них. Соединение просто закрывалось: `active` дёргался вверх и обратно.
+
+Теперь такие клиенты считает `unknown_clients`, и журнал называет адрес и
+причину. Их две:
+
+- MTProto-init не разбирается под текущим секретом. Почти всегда это ссылка
+  `tg://proxy` от прошлого запуска: секрет — её половина, и клиент со
+  сохранённой старой ссылкой попадает ровно сюда. Со стороны Telegram это и
+  есть «прокси настроен неверно и будет отключён» (#37).
+- SOCKS5-приветствие не разбирается. Сюда же попадает MTProto-соединение,
+  ушедшее в SOCKS5-ветку по неоднозначному первому байту, если полный init не
+  успел прийти за `PROTOCOL_PROBE_TIMEOUT`.
+
+Счётчик `ws_failures` от них отличается тем, что растёт после успешного
+рукопожатия с клиентом: там договорились с клиентом, но не смогли с Telegram.
+
 ## Учёт состояния

 `Stats::ws` считает **установленные** туннели: счётчик поднимается после
@@ -63,6 +124,14 @@ LAN-режим превращал бы машину в открытый прок
 несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
 «туннель установлен» различимы и в GUI, и в выводе CLI.

+Дата-центр и маршрут пишутся **одним значением**, в момент, когда туннель
+поднялся. Пока это были два независимых поля, номер писало соединение при
+разборе init, а маршрут — другое соединение после рукопожатия, и при десятках
+одновременных соединений в строку статуса попадала пара из разных из них.
+Читалась она как «до этого DC шли этим маршрутом», хотя означала другое: в
+диагностике #42 встречались строки `DC5 · Запасной Telegram IP`, а у DC5
+закреплённый адрес всего один и запасного у него не бывает вовсе.
+
 Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
 файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
 путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
@@ -41,6 +41,44 @@
 > кодом, LAN-режим ограничен адресами Telegram на уровне типа, Cloudflare Worker
 > остаётся исключительно пользовательской настройкой.

+> **Статус на 19 августа 2026.** С прошлой отметки вышли beta.6, beta.7,
+> beta.8 и beta.9. Что закрыто и что осталось:
+>
+> - **#32 (медиа).** Файл настроек `tglock.toml` сделан в beta.6 — это была
+>   отдельная просьба из того же issue. Заодно исправлена паника `println!` при
+>   закрытом stdout. Причина проблем с медиа не подтверждена: репортёр не
+>   прислал строку статуса в момент, когда фото не грузится. Слабое место
+>   названо в самом issue — у DC203 закреплён один IP, резерва по адресам для
+>   медиа нет.
+> - **#37 («прокси настроен неверно»).** В beta.7 перестала проглатываться
+>   ошибка записи секрета: раньше при неудачной записи в `%APPDATA%\TGLock`
+>   секрет молча генерировался заново при каждом запуске, и ссылка `tg://proxy`
+>   переставала совпадать с сохранённой в Telegram. Это гипотеза, а не
+>   подтверждённый диагноз — воспроизвести случай репортёра не удалось, но
+>   теперь видно, тот это случай или нет.
+> - **#39 (не работает).** По скриншоту: соединения есть, DC определяется,
+>   туннелей ноль, 678 падений маршрутов за пять минут. Наружу не отвечает ни
+>   один маршрут — у провайдера заблокирована веб-инфраструктура Telegram
+>   целиком. Кодом это не лечится, остаётся свой Cloudflare Worker. Счётчик
+>   падений маршрутов, по которому это стало видно, появился в beta.7.
+> - **#40, #41 (свои).** В LAN-режиме окно показывает готовый адрес для других
+>   устройств — люди искали его в интерфейсе и вписывали `127.0.0.1`. И страж
+>   тега в CI, который ловит тег, поставленный не на HEAD.
+> - **#42 (LAN не работает с телефона).** Нашлось в коде. Принадлежность адреса
+>   Telegram проверялась по двум первым октетам, то есть «телеграмом» считались
+>   целиком четыре `/16`, а IPv6 не распознавался вовсе. На loopback это не
+>   проявлялось: неопознанный адрес там всё равно релеится напрямую. На сетевом
+>   слушателе тот же адрес получал отказ — отсюда ровно то, что описал
+>   репортёр: на компьютере работает, с телефона нет. В beta.9 список сетей
+>   взят опубликованный Telegram, добавлены IPv6 и имена веб-инфраструктуры.
+>   Отказ перестал быть молчаливым: счётчик «Отклонено» и адрес в журнале.
+> - **#9 (Android)** остаётся открытым. PR #36 собирает APK, но приложение
+>   никто ни разу не запускал — нужен человек с телефоном.
+>
+> Общее по трём разобранным issue: во всех трёх диагноз упирался в то, что
+> программа не рассказывала о себе достаточно. Каждый выпуск с beta.7 добавлял
+> не функцию, а показание прибора.
+
 ## Выводы

 Главная причина жалоб «прокси подключён, но Telegram не работает» — приложение
@@ -0,0 +1,74 @@
+# Как выпускать релиз
+
+## Порядок важен
+
+Токен GitHub Actions создаёт релиз **только на HEAD ветки по умолчанию**. Если тег
+отстанет от `main` хотя бы на один коммит, публикация упадёт с ошибкой
+`Resource not accessible by integration` — сообщение про права, хотя права в
+порядке и дело в положении тега.
+
+Отсюда единственное жёсткое правило: **тег ставится последним, и пока идёт
+релиз, в `main` не пушим.**
+
+## Шаги
+
+1. Влить в `main` всё, что должно попасть в релиз, и дождаться зелёного CI.
+2. Поднять версию **в двух местах** — `Cargo.toml` и `tauri.conf.json`. Они
+   должны совпадать: имена файлов бандла берутся из `tauri.conf.json`.
+3. Закоммитить подъём версии и запушить в `main`.
+4. Убедиться, что больше ничего не уедет: `git ls-remote origin refs/heads/main`
+   должен совпасть с локальным `git rev-parse HEAD`.
+5. Поставить аннотированный тег на этот же коммит и запушить его:
+
+   ```bash
+   git tag -a v2.0.0-beta.N -m "TGLock 2.0.0-beta.N"
+   git push origin v2.0.0-beta.N
+   ```
+
+6. **Ничего не пушить в `main`, пока сборка не закончится.** Правки README,
+   документации, чего угодно — после публикации релиза.
+
+## Проверить, что выпустили
+
+Зелёный workflow — это ещё не доказательство. В бетах 2 и 3 сборка была зелёной,
+а в приложение попадал headless-бинарь вместо графического. Поэтому проверяем
+содержимое, а не имя файла:
+
+```bash
+gh release download vX.Y.Z --repo by-sonic/tglock -p 'TGLock_universal.app.tar.gz' -D /tmp/check
+tar -xzf /tmp/check/TGLock_universal.app.tar.gz -C /tmp/check
+python scripts/verify_bundle_binary.py /tmp/check/TGLock.app/Contents/MacOS/tglock
+```
+
+Скрипт ищет внутри бинаря маркеры GUI (`ipc.localhost`, `wry`) и маркеры CLI
+(`allow-direct`, `secret-file`) и ругается, если в бандле оказался не тот.
+
+## Если публикация всё-таки упала с `Resource not accessible by integration`
+
+Значит, тег разошёлся с `main`. Сверьте:
+
+```bash
+git ls-remote origin refs/heads/main 'refs/tags/vX.Y.Z^{}'
+```
+
+Если SHA разные — переставьте тег на HEAD и запушьте заново:
+
+```bash
+git tag -d vX.Y.Z
+git push origin :refs/tags/vX.Y.Z
+git tag -a vX.Y.Z <sha ветки main> -m "TGLock X.Y.Z"
+git push origin vX.Y.Z
+```
+
+Перезапускать упавший workflow бесполезно: он возьмёт тот же отставший тег и
+упадёт снова.
+
+## Что защищает автоматически
+
+Первым шагом релиза идёт задача `guard`: она сверяет тег с HEAD ветки по
+умолчанию и валится за секунды, не запуская сборки. Она ловит тег, поставленный
+на старый коммит.
+
+Она **не** ловит гонку: если запушить в `main` уже после её прохождения, но до
+конца сборки, публикация упадёт. Ровно так утонул первый заход v2.0.0-beta.8.
+От этого защищает только правило из первого раздела.
@@ -1,7 +1,7 @@
 {
  "name": "tglock-ui",
  "private": true,
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.11",
  "type": "module",
  "scripts": {
    "dev": "vite --port 1420",
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Проверяет, что в бандл приложения попал GUI-бинарь, а не headless CLI.
+
+Зачем это существует. В v2.0.0-beta.2 и v2.0.0-beta.3 бандлер Tauri упаковал
+`tglock-cli` как исполняемый файл приложения, и оно не запускалось ни на одной
+платформе. В beta.3 имя файла было уже правильным — бандлер переименовал CLI —
+поэтому проверка имени или `CFBundleExecutable` ничего не заметила. Отличить
+можно только по содержимому.
+
+Почему на Python, а не grep. BSD grep на macOS в UTF-8-локали молча не находит
+строки в бинарных данных там, где GNU grep находит: проверка проходила на
+Linux и давала ложное «не GUI» на macOS. Один скрипт для всех платформ и для
+всех трёх мест, где проверка вызывается, исключает подобные расхождения.
+
+Использование:
+    python3 scripts/verify_bundle_binary.py <путь-к-бинарю>
+"""
+
+import sys
+
+# Присутствуют только в GUI: строка CSP из tauri.conf.json и имя движка WebView.
+GUI_MARKERS = (b"ipc.localhost", b"wry")
+# Присутствуют только в CLI: имена флагов clap.
+CLI_MARKERS = (b"allow-direct", b"secret-file")
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print(f"использование: {argv[0]} <путь-к-бинарю>", file=sys.stderr)
+        return 2
+
+    path = argv[1]
+    try:
+        with open(path, "rb") as handle:
+            data = handle.read()
+    except OSError as error:
+        print(f"не удалось прочитать {path}: {error}", file=sys.stderr)
+        return 1
+
+    found_gui = [marker.decode() for marker in GUI_MARKERS if marker in data]
+    found_cli = [marker.decode() for marker in CLI_MARKERS if marker in data]
+
+    print(f"файл:     {path}")
+    print(f"размер:   {len(data) / 1048576:.1f} МБ")
+    print(f"GUI:      {found_gui or 'признаков нет'}")
+    print(f"CLI:      {found_cli or 'признаков нет'}")
+
+    if found_cli:
+        print("ОШИБКА: в бандле headless CLI вместо приложения", file=sys.stderr)
+        return 1
+    if not found_gui:
+        print("ОШИБКА: это не GUI-бинарь, признаков GUI нет", file=sys.stderr)
+        return 1
+
+    print("OK: в бандле GUI-бинарь")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
@@ -12,11 +12,22 @@ use std::process::ExitCode;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
-use tglock::config::ListenConfig;
-use tglock::{mtproto, proxy, transport};
+use tglock::cli_settings as config;
+use tglock::{proxy, transport};

 const STATUS_POLL: Duration = Duration::from_secs(1);

+/// Напечатать строку, вернув `false`, если stdout больше не принимает данные.
+///
+/// `println!` при ошибке записи паникует, а у демона stdout исчезает штатно: его
+/// пускают в `head`, закрывают терминал, перезапускают сборщик логов. Падать из
+/// за этого туннель не должен — он продолжает работать молча.
+fn say(text: &str) -> bool {
+    use std::io::Write;
+    let mut out = std::io::stdout().lock();
+    writeln!(out, "{text}").and_then(|()| out.flush()).is_ok()
+}
+
 #[derive(Debug, Parser)]
 #[command(
    name = "tglock-cli",
@@ -24,13 +35,17 @@ const STATUS_POLL: Duration = Duration::from_secs(1);
    about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
 )]
 struct Args {
-    /// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
-    #[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
-    bind: IpAddr,
+    /// Файл настроек. Если не задан, ищется tglock.toml рядом с бинарём
+    #[arg(short, long, value_name = "PATH")]
+    config: Option<PathBuf>,

-    /// Порт локального прокси
-    #[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
-    port: u16,
+    /// Адрес для прослушивания. По умолчанию 127.0.0.1 — только этот компьютер
+    #[arg(short, long, value_name = "IP")]
+    bind: Option<IpAddr>,
+
+    /// Порт локального прокси. По умолчанию 1080
+    #[arg(short, long, value_name = "PORT")]
+    port: Option<u16>,

    /// То же, что --bind 0.0.0.0: доступ с других устройств в локальной сети
    #[arg(long, conflicts_with = "bind")]
@@ -44,8 +59,8 @@ struct Args {
    #[arg(long)]
    allow_direct: bool,

-    /// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
-    /// секрет будет новым и уже настроенные клиенты перестанут подключаться
+    /// Файл с секретом прокси. Для сервиса нужен он или secret в настройках:
+    /// иначе после перезапуска секрет будет новым и настроенные клиенты отвалятся
    #[arg(long, value_name = "PATH")]
    secret_file: Option<PathBuf>,

@@ -55,28 +70,31 @@ struct Args {
 }

 impl Args {
-    fn stats(&self) -> Arc<proxy::Stats> {
-        match &self.secret_file {
-            Some(path) => proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path)),
-            None => proxy::Stats::new(),
+    fn overrides(&self) -> config::Overrides {
+        config::Overrides {
+            bind: self.bind,
+            port: self.port,
+            lan: self.lan,
+            allow_direct: self.allow_direct,
+            worker: self.worker.clone(),
+            secret_file: self.secret_file.clone(),
+            quiet: self.quiet,
        }
    }

-    fn listen(&self) -> ListenConfig {
-        let base = if self.lan {
-            ListenConfig::lan(self.port)
-        } else {
-            ListenConfig::new(self.bind, self.port)
-        };
-        if self.allow_direct {
-            base.with_allow_direct(true)
-        } else {
-            base
+    /// Файл настроек и путь, по которому он найден.
+    ///
+    /// Явный `--config` обязателен к существованию: если человек указал путь и
+    /// опечатался, молча стартовать с настройками по умолчанию — худшее из
+    /// возможных поведений.
+    fn load_file(&self) -> Result<(config::FileConfig, Option<PathBuf>), String> {
+        if let Some(path) = &self.config {
+            return Ok((config::FileConfig::load(path)?, Some(path.clone())));
+        }
+        match config::path_next_to_executable() {
+            Some(path) if path.is_file() => Ok((config::FileConfig::load(&path)?, Some(path))),
+            _ => Ok((config::FileConfig::default(), None)),
        }
-    }
-
-    fn worker_domains(&self) -> String {
-        self.worker.join(",")
    }
 }

@@ -100,30 +118,55 @@ fn main() -> ExitCode {
 }

 async fn serve(args: Args) -> Result<(), String> {
-    let listen = args.listen();
-    let stats = args.stats();
-    stats.set_worker_domain(&args.worker_domains());
+    let (file, file_path) = args.load_file()?;
+    let settings = config::resolve(file, args.overrides())?;
+    let listen = settings.listen;
+    let stats = settings.stats();
+    let quiet = settings.quiet;

    // Bind before printing anything: a busy port must be an error, not a
    // daemon that reports success and silently does nothing.
    let listener = proxy::bind(listen).await?;

-    if !args.quiet {
-        println!("Слушаю {}", listen.addr);
-        println!(
+    if !quiet {
+        let intro = match &file_path {
+            Some(path) => format!("Настройки: {}", path.display()),
+            None => format!(
+                "Настройки: только флаги ({} рядом с бинарём не найден)",
+                config::DEFAULT_FILE_NAME
+            ),
+        };
+        say(&intro);
+        say(&format!("Слушаю {}", listen.addr));
+        say(&format!(
            "Ссылка для Telegram: {}",
            listen.telegram_link(&stats.telegram_secret())
-        );
-        if listen.allow_direct && !listen.addr.ip().is_loopback() {
-            println!(
-                "Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
-                listen.addr.ip()
-            );
-        } else if !listen.allow_direct {
-            println!("Пропускаю только адреса Telegram");
+        ));
+        // Запись секрета могла провалиться — тогда после перезапуска ссылка
+        // изменится и Telegram скажет «прокси настроен неверно». Раньше это
+        // происходило молча (by-sonic/tglock#37).
+        if let Some(error) = stats.secret_write_error() {
+            say(&format!(
+                "Внимание: секрет НЕ сохранён ({error}). После перезапуска ссылка \
+                 изменится, и Telegram откажется подключаться к старой"
+            ));
        }
-        if !args.worker.is_empty() {
-            println!("Резервные Worker-домены: {}", args.worker_domains());
+        if matches!(settings.secret, config::SecretSource::Ephemeral) {
+            say(
+                "Внимание: секрет не закреплён и будет новым после перезапуска — \
+                 задайте secret в настройках или --secret-file",
+            );
+        }
+        if listen.allow_direct && !listen.addr.ip().is_loopback() {
+            say(&format!(
+                "Внимание: allow_direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
+                listen.addr.ip()
+            ));
+        } else if !listen.allow_direct {
+            say("Пропускаю только адреса Telegram");
+        }
+        if !settings.workers.is_empty() {
+            say(&format!("Резервные Worker-домены: {}", settings.workers));
        }
    }

@@ -132,14 +175,14 @@ async fn serve(args: Args) -> Result<(), String> {
        tokio::spawn(
            async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
        );
-    let watcher = (!args.quiet).then(|| tokio::spawn(watch_status(stats.clone())));
+    let watcher = (!quiet).then(|| tokio::spawn(watch_status(stats.clone())));

    let outcome = tokio::select! {
        joined = &mut server => joined.map_err(|error| format!("рабочая задача упала: {error}"))?,
        signal = shutdown_signal() => {
            signal.map_err(|error| format!("обработчик сигналов: {error}"))?;
-            if !args.quiet {
-                println!("Получен сигнал остановки, закрываю соединения…");
+            if !quiet {
+                say("Получен сигнал остановки, закрываю соединения…");
            }
            stats.stop();
            server
@@ -162,19 +205,33 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
    let mut previous = None;
    loop {
        tokio::time::sleep(STATUS_POLL).await;
+
+        // Отдельные события — кто подключился и какой адрес отклонён. Без них
+        // journalctl показывает только счётчики, по которым нельзя отличить
+        // «телефон не дошёл» от «дошёл и получил отказ» (by-sonic/tglock#42).
+        for event in stats.drain_events() {
+            if !say(&event) {
+                return;
+            }
+        }
+
        let current = (
            stats.active.load(Ordering::Relaxed),
            stats.ws.load(Ordering::Relaxed),
-            stats.last_dc.load(Ordering::Relaxed),
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_dc(),
+            stats.last_route(),
            stats.ws_failures.load(Ordering::Relaxed),
+            stats.route_failures(),
+            stats.blocked.load(Ordering::Relaxed),
+            stats.unknown_clients.load(Ordering::Relaxed),
        );
        if previous.as_ref() == Some(&current) {
            continue;
        }
-        let (active, tunnels, dc, route, failures) = current;
-        println!(
-            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
+        let (active, tunnels, dc, route, failures, route_failures, blocked, unknown) = current;
+        let line = format!(
+            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures} · \
+             падений маршрутов {route_failures} · отклонено {blocked} · не опознано {unknown}",
            if dc > 0 {
                format!("DC{dc}")
            } else {
@@ -182,6 +239,11 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
            },
            transport::route_label(route)
        );
+        // Закрытый stdout — не ошибка: печатать больше некому, туннель работает
+        // дальше без наблюдателя.
+        if !say(&line) {
+            return;
+        }
        previous = Some(current);
    }
 }
@@ -213,6 +275,11 @@ mod tests {
        Args::try_parse_from(std::iter::once("tglock-cli").chain(args.iter().copied())).unwrap()
    }

+    /// Итоговые настройки только из флагов, без файла.
+    fn from_flags(args: &[&str]) -> config::Resolved {
+        config::resolve(config::FileConfig::default(), parse(args).overrides()).unwrap()
+    }
+
    #[test]
    fn command_definition_is_valid() {
        Args::command().debug_assert();
@@ -220,7 +287,7 @@ mod tests {

    #[test]
    fn defaults_to_loopback_on_the_default_port() {
-        let listen = parse(&[]).listen();
+        let listen = from_flags(&[]).listen;
        assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
        assert!(listen.allow_direct);
    }
@@ -228,50 +295,50 @@ mod tests {
    #[test]
    fn lan_flag_matches_explicit_wildcard_bind() {
        assert_eq!(
-            parse(&["--lan"]).listen(),
-            parse(&["-b", "0.0.0.0"]).listen()
+            from_flags(&["--lan"]).listen,
+            from_flags(&["-b", "0.0.0.0"]).listen
        );
    }

    #[test]
    fn lan_does_not_relay_non_telegram_traffic() {
-        let listen = parse(&["--lan"]).listen();
+        let listen = from_flags(&["--lan"]).listen;
        assert_eq!(listen.addr.to_string(), "0.0.0.0:1080");
        assert!(!listen.allow_direct);
    }

    #[test]
    fn allow_direct_is_the_only_way_to_open_a_network_listener() {
-        assert!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
+        assert!(!from_flags(&["-b", "192.168.1.10"]).listen.allow_direct);
        assert!(
-            parse(&["-b", "192.168.1.10", "--allow-direct"])
-                .listen()
+            from_flags(&["-b", "192.168.1.10", "--allow-direct"])
+                .listen
                .allow_direct
        );
    }

    #[test]
    fn bind_and_port_are_honoured() {
-        let listen = parse(&["--bind", "10.0.0.7", "--port", "1443"]).listen();
+        let listen = from_flags(&["--bind", "10.0.0.7", "--port", "1443"]).listen;
        assert_eq!(listen.addr.to_string(), "10.0.0.7:1443");
    }

    #[test]
    fn ipv6_bind_is_accepted() {
-        let listen = parse(&["-b", "::1", "-p", "2080"]).listen();
+        let listen = from_flags(&["-b", "::1", "-p", "2080"]).listen;
        assert_eq!(listen.addr.to_string(), "[::1]:2080");
        assert!(listen.allow_direct);
    }

    #[test]
    fn repeated_worker_flags_collapse_into_one_list() {
-        let args = parse(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
-        assert_eq!(args.worker_domains(), "a.workers.dev,b.workers.dev");
+        let settings = from_flags(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
+        assert_eq!(settings.workers, "a.workers.dev,b.workers.dev");
    }

    #[test]
    fn no_worker_flag_means_no_domains() {
-        assert!(parse(&[]).worker_domains().is_empty());
+        assert!(from_flags(&[]).workers.is_empty());
    }

    #[test]
@@ -288,10 +355,10 @@ mod tests {
        ));
        let _ = std::fs::remove_file(&path);

-        let first = parse(&["--secret-file", path.to_str().unwrap()])
+        let first = from_flags(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();
-        let second = parse(&["--secret-file", path.to_str().unwrap()])
+        let second = from_flags(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();

@@ -303,11 +370,11 @@ mod tests {

        // A corrupted file must not wedge the daemon: it is replaced.
        std::fs::write(&path, "garbage").unwrap();
-        let third = parse(&["--secret-file", path.to_str().unwrap()])
+        let third = from_flags(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();
        assert_ne!(third, first);
-        let fourth = parse(&["--secret-file", path.to_str().unwrap()])
+        let fourth = from_flags(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();
        assert_eq!(third, fourth, "the replacement must be persisted in turn");
@@ -0,0 +1,360 @@
+//! Файл конфигурации для `tglock-cli`.
+//!
+//! Живёт в библиотеке, а не рядом с бинарём: каталожная форма `src/bin/cli/`
+//! ломает перечисление бинарей в Tauri — он выводит имя приложения из имени
+//! каталога и пытается упаковать несуществующий `cli`.
+//!
+//! Запрошен в by-sonic/tglock#32: держать все параметры и секрет в одном месте,
+//! чтобы не собирать батник с ключами при каждом запуске.
+//!
+//! Порядок приоритетов: значения по умолчанию → файл → флаги командной строки.
+//! Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только
+//! включать: их отсутствие означает «взять из файла», а не «выключить».
+
+use crate::config::ListenConfig;
+use crate::{mtproto, proxy};
+use serde::Deserialize;
+use std::net::IpAddr;
+use std::path::{Path, PathBuf};
+
+/// Имя файла, который ищется рядом с бинарём, если `--config` не задан.
+pub const DEFAULT_FILE_NAME: &str = "tglock.toml";
+
+/// Содержимое файла конфигурации.
+///
+/// `deny_unknown_fields` намеренно: опечатка вроде `porrt = 1080` должна быть
+/// ошибкой при старте, а не молча проигнорированной строкой, из-за которой
+/// сервис слушает не тот порт.
+#[derive(Debug, Default, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct FileConfig {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: Option<bool>,
+    pub allow_direct: Option<bool>,
+    pub worker: Option<Vec<String>>,
+    pub secret: Option<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: Option<bool>,
+}
+
+impl FileConfig {
+    pub fn parse(text: &str) -> Result<Self, String> {
+        toml::from_str(text).map_err(|error| format!("конфиг разобрать не удалось: {error}"))
+    }
+
+    pub fn load(path: &Path) -> Result<Self, String> {
+        let text = std::fs::read_to_string(path)
+            .map_err(|error| format!("не удалось прочитать {}: {error}", path.display()))?;
+        Self::parse(&text)
+    }
+}
+
+/// Значения, пришедшие из командной строки.
+#[derive(Debug, Default)]
+pub struct Overrides {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: bool,
+    pub allow_direct: bool,
+    pub worker: Vec<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: bool,
+}
+
+/// Откуда взять секрет прокси.
+#[derive(Debug, PartialEq)]
+pub enum SecretSource {
+    /// Записан прямо в конфиге.
+    Inline([u8; 16]),
+    /// Лежит в отдельном файле, создаётся при первом запуске.
+    File(PathBuf),
+    /// Ни того, ни другого: секрет будет новым при каждом старте.
+    Ephemeral,
+}
+
+/// Итоговые настройки запуска.
+#[derive(Debug, PartialEq)]
+pub struct Resolved {
+    pub listen: ListenConfig,
+    /// Домены Worker'ов в том виде, в каком их ждёт `Stats::set_worker_domain`.
+    pub workers: String,
+    pub secret: SecretSource,
+    pub quiet: bool,
+}
+
+impl Resolved {
+    pub fn stats(&self) -> std::sync::Arc<proxy::Stats> {
+        let stats = match &self.secret {
+            SecretSource::Inline(secret) => proxy::Stats::with_secret(*secret),
+            SecretSource::File(path) => {
+                proxy::Stats::with_stored_secret(mtproto::load_or_create_secret_at(path))
+            }
+            SecretSource::Ephemeral => proxy::Stats::new(),
+        };
+        stats.set_worker_domain(&self.workers);
+        stats
+    }
+}
+
+/// Свести файл и флаги в одни настройки.
+pub fn resolve(file: FileConfig, cli: Overrides) -> Result<Resolved, String> {
+    let port = cli.port.or(file.port).unwrap_or(proxy::DEFAULT_PORT);
+    if port == 0 {
+        return Err("порт должен быть от 1 до 65535".to_owned());
+    }
+
+    let lan = cli.lan || file.lan.unwrap_or(false);
+    let bind = cli.bind.or(file.bind);
+    if lan && bind.is_some() {
+        return Err("нельзя задать одновременно lan и bind: выберите одно".to_owned());
+    }
+
+    let listen = match (lan, bind) {
+        (true, _) => ListenConfig::lan(port),
+        (false, Some(ip)) => ListenConfig::new(ip, port),
+        (false, None) => ListenConfig::loopback(port),
+    };
+    let allow_direct = cli.allow_direct || file.allow_direct.unwrap_or(false);
+    let listen = if allow_direct {
+        listen.with_allow_direct(true)
+    } else {
+        listen
+    };
+
+    let workers = if cli.worker.is_empty() {
+        file.worker.unwrap_or_default()
+    } else {
+        cli.worker
+    };
+
+    // Секрет из файла конфигурации важнее отдельного файла: если человек вписал
+    // его сюда, значит хотел держать всё в одном месте.
+    let secret = match (&file.secret, cli.secret_file.or(file.secret_file)) {
+        (Some(value), _) => SecretSource::Inline(
+            mtproto::parse_secret(value)
+                .ok_or("секрет в конфиге неверный: нужны 32 hex-символа, можно с префиксом dd")?,
+        ),
+        (None, Some(path)) => SecretSource::File(path),
+        (None, None) => SecretSource::Ephemeral,
+    };
+
+    Ok(Resolved {
+        listen,
+        workers: workers.join(","),
+        secret,
+        quiet: cli.quiet || file.quiet.unwrap_or(false),
+    })
+}
+
+/// Путь к конфигу рядом с исполняемым файлом.
+///
+/// Именно этого просили в #32: «размещение рядом с бинарником частично решает
+/// вопрос». Текущий каталог не используется, чтобы сервис не зависел от того,
+/// откуда его запустили.
+pub fn path_next_to_executable() -> Option<PathBuf> {
+    let executable = std::env::current_exe().ok()?;
+    Some(executable.parent()?.join(DEFAULT_FILE_NAME))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SECRET: &str = "00112233445566778899aabbccddeeff";
+
+    fn cli() -> Overrides {
+        Overrides::default()
+    }
+
+    #[test]
+    fn empty_config_and_no_flags_give_the_documented_defaults() {
+        let resolved = resolve(FileConfig::default(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "127.0.0.1:1080");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "");
+        assert_eq!(resolved.secret, SecretSource::Ephemeral);
+        assert!(!resolved.quiet);
+    }
+
+    #[test]
+    fn file_values_are_used_when_no_flags_are_given() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            allow_direct = true
+            worker = ["a.workers.dev", "b.workers.dev"]
+            quiet = true
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "10.0.0.5:1443");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "a.workers.dev,b.workers.dev");
+        assert!(resolved.quiet);
+    }
+
+    #[test]
+    fn flags_win_over_the_file() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            worker = ["from-file.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                bind: Some("192.168.1.7".parse().unwrap()),
+                port: Some(2080),
+                worker: vec!["from-flag.workers.dev".to_owned()],
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "192.168.1.7:2080");
+        assert_eq!(resolved.workers, "from-flag.workers.dev");
+    }
+
+    #[test]
+    fn a_switch_flag_can_only_turn_things_on() {
+        // Отсутствие --quiet не должно отменять quiet = true из файла: иначе
+        // файл нельзя было бы использовать для включения ничего.
+        let file = FileConfig::parse("quiet = true\nallow_direct = true").unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(resolved.quiet);
+        assert!(resolved.listen.allow_direct);
+    }
+
+    #[test]
+    fn lan_from_the_file_restricts_to_telegram() {
+        let resolved = resolve(FileConfig::parse("lan = true").unwrap(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "0.0.0.0:1080");
+        assert!(
+            !resolved.listen.allow_direct,
+            "сетевой слушатель не должен релеить произвольные адреса без явного разрешения"
+        );
+    }
+
+    #[test]
+    fn lan_and_bind_together_are_rejected_wherever_they_come_from() {
+        let both_in_file = FileConfig::parse("lan = true\nbind = \"10.0.0.5\"").unwrap();
+        assert!(resolve(both_in_file, cli()).is_err());
+
+        let file = FileConfig::parse("bind = \"10.0.0.5\"").unwrap();
+        let flag_lan = Overrides {
+            lan: true,
+            ..Overrides::default()
+        };
+        assert!(
+            resolve(file, flag_lan).is_err(),
+            "конфликт должен ловиться и когда стороны пришли из разных мест"
+        );
+    }
+
+    #[test]
+    fn inline_secret_is_accepted_in_both_written_forms() {
+        for value in [SECRET.to_owned(), format!("dd{SECRET}")] {
+            let file = FileConfig::parse(&format!("secret = \"{value}\"")).unwrap();
+            let resolved = resolve(file, cli()).unwrap();
+            assert_eq!(
+                resolved.secret,
+                SecretSource::Inline([
+                    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
+                    0xdd, 0xee, 0xff,
+                ]),
+                "форма {value} должна приниматься"
+            );
+        }
+    }
+
+    #[test]
+    fn a_broken_inline_secret_stops_the_start() {
+        let file = FileConfig::parse("secret = \"явно не секрет\"").unwrap();
+        let error = resolve(file, cli()).unwrap_err();
+        assert!(
+            error.contains("32"),
+            "ошибка должна объяснять формат, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn inline_secret_wins_over_a_secret_file() {
+        let file =
+            FileConfig::parse(&format!("secret = \"{SECRET}\"\nsecret_file = \"s.bin\"")).unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(matches!(resolved.secret, SecretSource::Inline(_)));
+    }
+
+    #[test]
+    fn secret_file_from_the_flag_wins_over_the_file() {
+        let file = FileConfig::parse("secret_file = \"from-file.bin\"").unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                secret_file: Some(PathBuf::from("from-flag.bin")),
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(
+            resolved.secret,
+            SecretSource::File(PathBuf::from("from-flag.bin"))
+        );
+    }
+
+    #[test]
+    fn a_typo_in_the_config_is_an_error_not_a_silent_default() {
+        // Самая опасная поломка конфига — та, которую не видно. Сервис не должен
+        // слушать 1080, если человек написал porrt = 1443.
+        let error = FileConfig::parse("porrt = 1443").unwrap_err();
+        assert!(
+            error.contains("porrt"),
+            "ошибка должна называть неизвестное поле, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn malformed_values_are_rejected() {
+        for text in [
+            "bind = \"не адрес\"",
+            "port = \"1080\"",
+            "port = 70000",
+            "worker = \"строка вместо списка\"",
+            "lan = \"да\"",
+        ] {
+            assert!(
+                FileConfig::parse(text).is_err(),
+                "{text:?} должен быть отвергнут"
+            );
+        }
+    }
+
+    #[test]
+    fn zero_port_is_rejected() {
+        assert!(resolve(FileConfig::parse("port = 0").unwrap(), cli()).is_err());
+    }
+
+    #[test]
+    fn comments_and_blank_lines_are_fine() {
+        let file = FileConfig::parse(
+            r#"
+            # порт для второго экземпляра
+            port = 1081
+
+            # свой воркер как резерв
+            worker = ["backup.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        assert_eq!(file.port, Some(1081));
+        assert_eq!(
+            file.worker.as_deref(),
+            Some(&["backup.workers.dev".to_owned()][..])
+        );
+    }
+}
@@ -8,4 +8,9 @@
 pub mod config;
 pub mod mtproto;
 pub mod proxy;
+pub mod telegram_net;
 pub mod transport;
+
+/// Настройки headless-версии: файл конфигурации и сведение с флагами.
+#[cfg(feature = "cli")]
+pub mod cli_settings;
@@ -44,8 +44,27 @@ struct StatusSnapshot {
    data_center: Option<u16>,
    route: String,
    failures: u32,
+    /// Падения отдельных маршрутов. Растёт даже когда соединение в итоге
+    /// состоялось через запасной адрес (by-sonic/tglock#32).
+    route_failures: u32,
+    /// Запросы, отклонённые политикой «в LAN-режиме только Telegram».
+    ///
+    /// Ноль при неработающем телефоне означает, что он вообще не дотянулся до
+    /// этой машины; не ноль — что дотянулся, и разбираться надо с адресами
+    /// (by-sonic/tglock#42).
+    blocked: u32,
+    /// Клиенты, которые дошли, но не сумели договориться. Почти всегда это
+    /// ссылка `tg://proxy` от прошлого запуска, то есть другой секрет.
+    unknown_clients: u32,
    uptime_seconds: u64,
    port: u16,
+    /// Адрес, который нужно вписать в Telegram на другом устройстве.
+    ///
+    /// В LAN-режиме это адрес этого компьютера в локальной сети. Люди искали
+    /// его в интерфейсе и не находили: вписывали `127.0.0.1`, который на
+    /// телефоне или в эмуляторе означает само устройство, и подключение не
+    /// работало (by-sonic/tglock#36).
+    share_address: Option<String>,
    logs: Vec<LogLine>,
 }

@@ -53,6 +72,10 @@ struct AppState {
    stats: Arc<proxy::Stats>,
    settings: Mutex<Settings>,
    active_port: Mutex<u16>,
+    /// Слушатель работающего прокси. Нужен, чтобы показать адрес для других
+    /// устройств именно тот, на котором прокси реально поднят, а не тот, что
+    /// сейчас выбран в настройках.
+    active_listen: Mutex<Option<ListenConfig>>,
    started_at: Mutex<Option<Instant>>,
    logs: Arc<Mutex<Vec<LogLine>>>,
    settings_path: PathBuf,
@@ -68,6 +91,7 @@ impl AppState {
            stats: proxy::Stats::new(),
            settings: Mutex::new(settings),
            active_port: Mutex::new(proxy::DEFAULT_PORT),
+            active_listen: Mutex::new(None),
            started_at: Mutex::new(None),
            logs: Arc::new(Mutex::new(Vec::new())),
            settings_path,
@@ -87,8 +111,13 @@ impl AppState {
    }

    fn snapshot(&self) -> StatusSnapshot {
-        let data_center = self.stats.last_dc.load(Ordering::Relaxed);
-        let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
+        // События прокси доходят до журнала только здесь: у ядра нет своего
+        // способа что-то показать, а интерфейс и так опрашивает состояние.
+        for event in self.stats.drain_events() {
+            self.log(event, false);
+        }
+        let data_center = self.stats.last_dc();
+        let route = transport::route_label(self.stats.last_route());
        StatusSnapshot {
            running: self.stats.running.load(Ordering::SeqCst),
            active_connections: self.stats.active.load(Ordering::Relaxed),
@@ -96,12 +125,16 @@ impl AppState {
            data_center: (data_center > 0).then_some(data_center),
            route: route.to_owned(),
            failures: self.stats.ws_failures.load(Ordering::Relaxed),
+            route_failures: self.stats.route_failures(),
+            blocked: self.stats.blocked.load(Ordering::Relaxed),
+            unknown_clients: self.stats.unknown_clients.load(Ordering::Relaxed),
            uptime_seconds: self
                .started_at
                .lock()
                .unwrap()
                .map_or(0, |started| started.elapsed().as_secs()),
            port: *self.active_port.lock().unwrap(),
+            share_address: share_address(*self.active_listen.lock().unwrap()),
            logs: self.logs.lock().unwrap().clone(),
        }
    }
@@ -118,6 +151,18 @@ impl AppState {
    }
 }

+/// Адрес, который нужно вписать в Telegram на другом устройстве.
+///
+/// Только для слушателя на `0.0.0.0`: на loopback делиться нечем, туда никто
+/// извне не достучится. Возвращается адрес этой машины в сети, а не `0.0.0.0`
+/// и не `127.0.0.1` — последний на телефоне или в эмуляторе означает само
+/// устройство, и именно на этом спотыкались (by-sonic/tglock#36).
+fn share_address(listen: Option<ListenConfig>) -> Option<String> {
+    listen
+        .filter(|listen| listen.addr.ip().is_unspecified())
+        .map(|listen| format!("{}:{}", listen.advertised_host(), listen.addr.port()))
+}
+
 fn current_time() -> String {
    let seconds = SystemTime::now()
        .duration_since(UNIX_EPOCH)
@@ -173,6 +218,8 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
        ListenConfig::loopback(settings.port)
    };

+    *state.active_listen.lock().unwrap() = Some(listen);
+
    let stats = state.stats.clone();
    let logs = state.logs.clone();
    std::thread::spawn(move || {
@@ -190,6 +237,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {

    std::thread::sleep(std::time::Duration::from_millis(220));
    if !state.stats.running.load(Ordering::SeqCst) {
+        *state.active_listen.lock().unwrap() = None;
        *state.started_at.lock().unwrap() = None;
        return Err(state
            .logs
@@ -209,6 +257,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
 #[tauri::command]
 fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
    state.stats.stop();
+    *state.active_listen.lock().unwrap() = None;
    *state.started_at.lock().unwrap() = None;
    state.log("Защита выключена", false);
    state.snapshot()
@@ -279,7 +328,17 @@ fn main() {
                .app_config_dir()
                .map_err(|error| error.to_string())?
                .join("settings.json");
-            app.manage(AppState::new(settings_path));
+            let state = AppState::new(settings_path);
+            // Если секрет не удалось записать, ссылка tg://proxy изменится после
+            // перезапуска и Telegram откажется подключаться к сохранённой.
+            // Раньше это происходило молча (by-sonic/tglock#37).
+            if let Some(error) = state.stats.secret_write_error() {
+                state.log(
+                    format!("Секрет не сохранён ({error}). После перезапуска ссылка изменится"),
+                    true,
+                );
+            }
+            app.manage(state);
            Ok(())
        })
        .invoke_handler(tauri::generate_handler![
@@ -297,6 +356,34 @@ fn main() {
 mod tests {
    use super::*;

+    #[test]
+    fn nothing_to_share_when_the_proxy_is_off_or_local() {
+        assert_eq!(
+            share_address(None),
+            None,
+            "выключенный прокси нечего делить"
+        );
+        assert_eq!(
+            share_address(Some(ListenConfig::loopback(1080))),
+            None,
+            "на loopback снаружи никто не подключится"
+        );
+    }
+
+    #[test]
+    fn lan_mode_shares_a_reachable_address() {
+        let shown = share_address(Some(ListenConfig::lan(1443))).expect("в LAN-режиме адрес нужен");
+        assert!(shown.ends_with(":1443"), "порт должен быть виден: {shown}");
+        assert!(
+            !shown.starts_with("0.0.0.0"),
+            "0.0.0.0 нельзя вписать в Telegram: {shown}"
+        );
+        assert!(
+            !shown.starts_with("127.0.0.1"),
+            "127.0.0.1 на другом устройстве означает само устройство: {shown}"
+        );
+    }
+
    #[test]
    fn software_rendering_is_requested_by_default() {
        let vars = software_rendering_vars(false, |_| false);
@@ -51,31 +51,64 @@ pub fn generate_secret() -> [u8; 16] {
    secret
 }

-/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
+/// Секрет прокси и то, лежит ли он на диске.
+pub struct StoredSecret {
+    pub value: [u8; 16],
+    /// Ошибка, из-за которой секрет не удалось сохранить.
+    ///
+    /// Если она есть, при следующем запуске секрет будет другим, ссылка
+    /// `tg://proxy` перестанет совпадать с сохранённой в Telegram, и Telegram
+    /// скажет «прокси настроен неверно и будет отключён». Раньше запись
+    /// провалившись молчала, и понять причину было невозможно
+    /// (by-sonic/tglock#37).
+    pub write_error: Option<String>,
+}
+
+impl StoredSecret {
+    /// Секрет действительно переживёт перезапуск.
+    pub fn is_persistent(&self) -> bool {
+        self.write_error.is_none()
+    }
+}
+
+/// Взять секрет из файла, создав его, если файла нет или он испорчен.
 ///
-/// A daemon needs this: the secret is half of the `tg://proxy` link, so a
-/// service that invents a new one on every restart silently invalidates every
-/// client that was already configured.
-pub fn load_or_create_secret_at(path: &Path) -> [u8; 16] {
+/// Секрет — половина ссылки `tg://proxy`, поэтому сервис, придумывающий новый
+/// при каждом старте, отключает всех уже настроенных клиентов.
+pub fn load_or_create_secret_at(path: &Path) -> StoredSecret {
    if let Ok(value) = std::fs::read_to_string(path) {
-        if let Some(secret) = parse_secret_hex(value.trim()) {
-            return secret;
+        if let Some(value) = parse_secret_hex(value.trim()) {
+            return StoredSecret {
+                value,
+                write_error: None,
+            };
        }
    }

-    let secret = generate_secret();
+    let value = generate_secret();
+    let write_error = store_secret(path, &secret_hex(&value))
+        .err()
+        .map(|error| format!("{}: {error}", path.display()));
+    StoredSecret { value, write_error }
+}
+
+fn store_secret(path: &Path, value: &str) -> std::io::Result<()> {
    if let Some(parent) = path.parent() {
-        let _ = std::fs::create_dir_all(parent);
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent)?;
+        }
    }
-    write_secret_file(path, &secret_hex(&secret));
-    secret
+    write_secret_file(path, value)
 }

 #[cfg(not(test))]
-pub fn load_or_create_secret() -> [u8; 16] {
+pub fn load_or_create_secret() -> StoredSecret {
    match secret_path() {
        Some(path) => load_or_create_secret_at(&path),
-        None => generate_secret(),
+        None => StoredSecret {
+            value: generate_secret(),
+            write_error: Some("не удалось определить папку для секрета в этой системе".to_owned()),
+        },
    }
 }

@@ -105,23 +138,21 @@ fn secret_path() -> Option<PathBuf> {
 }

 #[cfg(unix)]
-fn write_secret_file(path: &Path, value: &str) {
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
    use std::io::Write;
    use std::os::unix::fs::OpenOptionsExt;
-    if let Ok(mut file) = std::fs::OpenOptions::new()
+    let mut file = std::fs::OpenOptions::new()
        .create(true)
        .truncate(true)
        .write(true)
        .mode(0o600)
-        .open(path)
-    {
-        let _ = file.write_all(value.as_bytes());
-    }
+        .open(path)?;
+    file.write_all(value.as_bytes())
 }

 #[cfg(not(unix))]
-fn write_secret_file(path: &Path, value: &str) {
-    let _ = std::fs::write(path, value);
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
+    std::fs::write(path, value)
 }

 pub fn secret_hex(secret: &[u8; 16]) -> String {
@@ -133,6 +164,19 @@ pub fn secret_hex(secret: &[u8; 16]) -> String {
    output
 }

+/// Разобрать секрет, записанный человеком.
+///
+/// Принимает и 32 hex-символа, и форму с префиксом `dd` — именно так секрет
+/// выглядит в ссылке `tg://proxy`, откуда его и копируют.
+pub fn parse_secret(value: &str) -> Option<[u8; 16]> {
+    let trimmed = value.trim();
+    let hex = trimmed
+        .strip_prefix("dd")
+        .filter(|rest| rest.len() == 32)
+        .unwrap_or(trimmed);
+    parse_secret_hex(hex)
+}
+
 fn parse_secret_hex(value: &str) -> Option<[u8; 16]> {
    if value.len() != 32 {
        return None;
@@ -501,6 +545,105 @@ mod tests {
        }
    }

+    #[test]
+    fn a_failed_write_is_reported_instead_of_swallowed() {
+        // Раньше ошибка записи выбрасывалась, секрет генерировался заново при
+        // каждом запуске, и Telegram говорил «прокси настроен неверно» без
+        // единой подсказки почему (by-sonic/tglock#37).
+        let blocker = std::env::temp_dir().join(format!(
+            "tglock-not-a-dir-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        std::fs::write(&blocker, "я файл, а не папка").unwrap();
+
+        // Родитель пути — обычный файл, поэтому создать каталог невозможно.
+        let stored = load_or_create_secret_at(&blocker.join("secret"));
+
+        assert!(
+            !stored.is_persistent(),
+            "неудачная запись обязана быть видна"
+        );
+        let error = stored.write_error.expect("должно быть сообщение об ошибке");
+        assert!(
+            error.contains("secret"),
+            "в сообщении должен быть путь, получено: {error}"
+        );
+        // Секрет всё равно выдан: прокси работает, просто до перезапуска.
+        assert_ne!(stored.value, [0; 16]);
+
+        let _ = std::fs::remove_file(&blocker);
+    }
+
+    #[test]
+    fn a_successful_write_reports_no_error() {
+        let path = std::env::temp_dir().join(format!(
+            "tglock-secret-ok-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        let _ = std::fs::remove_file(&path);
+
+        let first = load_or_create_secret_at(&path);
+        assert!(first.is_persistent(), "запись в temp должна удаваться");
+
+        // Второй запуск читает готовый файл и тоже не жалуется.
+        let second = load_or_create_secret_at(&path);
+        assert!(second.is_persistent());
+        assert_eq!(
+            first.value, second.value,
+            "секрет должен переживать перезапуск"
+        );
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn accepts_a_secret_copied_from_a_tg_link() {
+        let expected = [
+            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+            0xee, 0xff,
+        ];
+        // Обе формы: как в файле и как в ссылке tg://proxy.
+        assert_eq!(
+            parse_secret("00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        assert_eq!(
+            parse_secret("dd00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        // Пробелы по краям — обычное дело при копировании.
+        assert_eq!(
+            parse_secret("  dd00112233445566778899aabbccddeeff\n"),
+            Some(expected)
+        );
+        // Секрет, который сам начинается с dd и уже имеет полную длину, не
+        // должен потерять первый байт: префикс снимается только если после него
+        // остаётся ровно 32 символа.
+        assert_eq!(
+            parse_secret("dd112233445566778899aabbccddeeff"),
+            Some([
+                0xdd, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+                0xee, 0xff,
+            ])
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_secrets() {
+        for bad in [
+            "",
+            "dd",
+            "слишком коротко",
+            "00112233445566778899aabbccddee",     // 30 символов
+            "00112233445566778899aabbccddeeffff", // 34 символа
+            "zz112233445566778899aabbccddeeff",   // не hex
+        ] {
+            assert!(parse_secret(bad).is_none(), "{bad:?} должен быть отвергнут");
+        }
+    }
+
    #[test]
    fn parses_persisted_secret() {
        assert_eq!(
@@ -1,6 +1,7 @@
 use crate::config::ListenConfig;
-use std::net::Ipv4Addr;
-use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU8, Ordering};
+use std::collections::{HashSet, VecDeque};
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
@@ -21,18 +22,70 @@ pub struct Stats {
    pub active: AtomicU32,
    pub total: AtomicU32,
    pub ws: AtomicU32,
-    pub last_dc: AtomicU16,
+    /// DC последнего разобранного соединения. Показывается, пока туннеля ещё
+    /// нет: клиент уже понят, маршрут ещё не выбран.
+    seen_dc: AtomicU16,
    pub ws_failures: AtomicU32,
-    /// See `transport::RouteKind::ui_code`.
-    pub last_route: AtomicU8,
+    /// Сколько запросов отклонено политикой «только Telegram».
+    ///
+    /// В LAN-режиме это единственный признак, отличающий «телефон не дотянулся
+    /// до компьютера» от «дотянулся, но попросил адрес, который мы не пускаем».
+    /// Раньше отказ происходил молча, и снаружи оба случая выглядели одинаково
+    /// (by-sonic/tglock#42).
+    pub blocked: AtomicU32,
+    /// Сколько клиентов дошло до прокси, но не сумело договориться.
+    ///
+    /// Почти всегда это несовпадение секрета: в Telegram вписана ссылка от
+    /// прошлого запуска. Такое соединение закрывалось молча, и по диагностике
+    /// отличить его от рабочего было нельзя.
+    pub unknown_clients: AtomicU32,
+    /// DC и маршрут последнего поднятого туннеля, упакованные в одно значение.
+    ///
+    /// Раньше это были два независимых поля: номер писало соединение при
+    /// разборе init, маршрут — другое соединение после рукопожатия. При
+    /// нескольких десятках одновременных соединений пара в строке статуса
+    /// складывалась из разных из них, и читалась она как «до этого DC шли
+    /// этим маршрутом», хотя означала совсем не это. У DC1, DC3, DC5 и DC203
+    /// закреплённый адрес всего один, и «запасного» у них не бывает вовсе —
+    /// а строки `DC5 · Запасной Telegram IP` в диагностике встречались
+    /// (by-sonic/tglock#42).
+    ///
+    /// Формат: `dc << 8 | route`, где route — `transport::RouteKind::ui_code`.
+    last_tunnel: AtomicU32,
    transport: crate::transport::TransportEngine,
    secret: [u8; 16],
+    /// Почему секрет не удалось сохранить, если не удалось.
+    secret_write_error: Option<String>,
+    events: Mutex<Events>,
    shutdown: Mutex<Option<tokio::sync::watch::Sender<bool>>>,
 }

+/// Однократные сообщения о том, что происходит с подключениями.
+///
+/// Однократные намеренно: отклонённый адрес повторяется десятки раз в минуту,
+/// и без склейки журнал превратился бы в одну строку, повторённую сто раз.
+/// Число повторов при этом не теряется — оно в счётчике `blocked`.
+#[derive(Default)]
+struct Events {
+    pending: VecDeque<String>,
+    seen: HashSet<String>,
+}
+
+/// Сколько разных событий помним, чтобы буфер не рос без границы.
+const EVENT_LIMIT: usize = 64;
+
 impl Stats {
    pub fn new() -> Arc<Self> {
-        Self::with_secret(initial_secret())
+        Self::with_stored_secret(initial_secret())
+    }
+
+    /// Построить с секретом, про который известно, сохранился он на диск или нет.
+    ///
+    /// Если не сохранился, при следующем запуске ссылка `tg://proxy` изменится и
+    /// Telegram скажет «прокси настроен неверно и будет отключён». Раньше это
+    /// происходило молча (by-sonic/tglock#37).
+    pub fn with_stored_secret(stored: crate::mtproto::StoredSecret) -> Arc<Self> {
+        Self::build(stored.value, stored.write_error)
    }

    /// Build with an explicit proxy secret.
@@ -40,24 +93,122 @@ impl Stats {
    /// A daemon must pin this: the secret is half of the `tg://proxy` link, so
    /// generating a fresh one on restart breaks every configured client.
    pub fn with_secret(secret: [u8; 16]) -> Arc<Self> {
+        Self::build(secret, None)
+    }
+
+    /// Сообщение о том, почему секрет не сохранён, если он не сохранён.
+    pub fn secret_write_error(&self) -> Option<&str> {
+        self.secret_write_error.as_deref()
+    }
+
+    fn build(secret: [u8; 16], secret_write_error: Option<String>) -> Arc<Self> {
        Arc::new(Self {
            running: AtomicBool::new(false),
            active: AtomicU32::new(0),
            total: AtomicU32::new(0),
            ws: AtomicU32::new(0),
-            last_dc: AtomicU16::new(0),
+            seen_dc: AtomicU16::new(0),
            ws_failures: AtomicU32::new(0),
-            last_route: AtomicU8::new(0),
+            blocked: AtomicU32::new(0),
+            unknown_clients: AtomicU32::new(0),
+            last_tunnel: AtomicU32::new(0),
            transport: crate::transport::TransportEngine::new(),
            secret,
+            secret_write_error,
+            events: Mutex::new(Events::default()),
            shutdown: Mutex::new(None),
        })
    }

+    /// Запомнить событие, если такого ещё не было.
+    pub fn note(&self, message: impl Into<String>) {
+        let message = message.into();
+        let mut events = self.events.lock().unwrap();
+        if events.seen.len() >= EVENT_LIMIT || !events.seen.insert(message.clone()) {
+            return;
+        }
+        events.pending.push_back(message);
+    }
+
+    /// Забрать накопившиеся события. Показывает их GUI или CLI — тот, кто есть.
+    pub fn drain_events(&self) -> Vec<String> {
+        self.events.lock().unwrap().pending.drain(..).collect()
+    }
+
+    fn note_blocked(&self, destination: &str, port: u16) {
+        self.blocked.fetch_add(1, Ordering::Relaxed);
+        self.note(format!(
+            "Отклонено: {destination}:{port} — адрес не из сетей Telegram"
+        ));
+    }
+
+    /// Клиент дошёл, но договориться с ним не удалось.
+    ///
+    /// Раньше такое соединение закрывалось молча: `active` дёргался вверх и
+    /// обратно, и всё. По диагностике это неотличимо от «клиент подключился и
+    /// работает», хотя означает противоположное (by-sonic/tglock#42).
+    fn note_unknown_client(&self, peer: Option<SocketAddr>, reason: &str) {
+        self.unknown_clients.fetch_add(1, Ordering::Relaxed);
+        let who = match peer {
+            Some(peer) => peer.ip().to_string(),
+            None => "неизвестный адрес".to_owned(),
+        };
+        self.note(format!("Клиент {who}: {reason}"));
+    }
+
+    /// Отметить, что до прокси дотянулось устройство из сети, а не с этой машины.
+    ///
+    /// Это первое, что нужно знать при разборе LAN-режима: если строки нет,
+    /// телефон до компьютера не дошёл, и дело в сети, а не в TGLock.
+    fn note_peer(&self, peer: SocketAddr) {
+        if peer.ip().is_loopback() {
+            return;
+        }
+        self.note(format!("Подключилось устройство из сети: {}", peer.ip()));
+    }
+
+    /// Запомнить DC, с которым пришёл клиент. Туннеля может ещё не быть.
+    fn note_dc(&self, dc: u16) {
+        self.seen_dc.store(dc, Ordering::Relaxed);
+    }
+
+    /// Запомнить, каким маршрутом поднялся туннель и до какого DC.
+    ///
+    /// Пишется одним значением, чтобы пара в диагностике всегда была из
+    /// одного соединения.
+    fn note_tunnel(&self, dc: u16, route: u8) {
+        self.last_tunnel
+            .store(u32::from(dc) << 8 | u32::from(route), Ordering::Relaxed);
+    }
+
+    /// Номер дата-центра для показа: из последнего поднятого туннеля, а пока
+    /// туннеля не было — из последнего разобранного соединения.
+    pub fn last_dc(&self) -> u16 {
+        match self.last_tunnel.load(Ordering::Relaxed) {
+            0 => self.seen_dc.load(Ordering::Relaxed),
+            packed => (packed >> 8) as u16,
+        }
+    }
+
+    /// Маршрут последнего поднятого туннеля. См. `transport::RouteKind::ui_code`.
+    pub fn last_route(&self) -> u8 {
+        (self.last_tunnel.load(Ordering::Relaxed) & 0xff) as u8
+    }
+
    pub fn telegram_secret(&self) -> String {
        crate::mtproto::telegram_secret(&self.secret)
    }

+    /// Сколько отдельных маршрутов не ответило.
+    ///
+    /// Отличается от `ws_failures`: тот растёт только когда упали все маршруты
+    /// и соединение не состоялось. Этот показывает перебор, который прошёл
+    /// незаметно — например, когда закреплённый адрес мёртв, а запасной
+    /// работает (by-sonic/tglock#32).
+    pub fn route_failures(&self) -> u32 {
+        self.transport.route_failures()
+    }
+
    pub fn set_worker_domain(&self, domain: &str) {
        let domains = domain
            .split([',', ';', ' '])
@@ -75,13 +226,16 @@ impl Stats {
 }

 #[cfg(not(test))]
-fn initial_secret() -> [u8; 16] {
+fn initial_secret() -> crate::mtproto::StoredSecret {
    crate::mtproto::load_or_create_secret()
 }

 #[cfg(test)]
-fn initial_secret() -> [u8; 16] {
-    crate::mtproto::generate_secret()
+fn initial_secret() -> crate::mtproto::StoredSecret {
+    crate::mtproto::StoredSecret {
+        value: crate::mtproto::generate_secret(),
+        write_error: None,
+    }
 }

 /// Claim the local port.
@@ -115,8 +269,9 @@ pub async fn serve(
        tokio::select! {
            result = listener.accept() => {
                match result {
-                    Ok((stream, _)) => {
+                    Ok((stream, peer)) => {
                        let s = stats.clone();
+                        s.note_peer(peer);
                        s.active.fetch_add(1, Ordering::Relaxed);
                        s.total.fetch_add(1, Ordering::Relaxed);
                        tasks.spawn(async move {
@@ -209,18 +364,55 @@ async fn detect_protocol(
    }
 }

+/// Куда просится SOCKS5-клиент и что с этим делать.
+#[derive(Debug, Eq, PartialEq)]
+enum Destination {
+    /// Адрес дата-центра Telegram: дальше идёт MTProto, его заворачиваем в
+    /// WebSocket — ради этого TGLock и существует.
+    DataCentre(IpAddr),
+    /// Имя из веб-инфраструктуры Telegram. Это обычный HTTPS, а не MTProto:
+    /// клиент ходит сюда за конфигурацией, превью и файлами CDN. Заворачивать
+    /// такое соединение в MTProto-туннель нельзя, его нужно пропустить как есть.
+    ///
+    /// На телефоне эти запросы идут через тот же прокси, поэтому в LAN-режиме
+    /// они разрешены — иначе клиент не может даже дочитать свою конфигурацию.
+    TelegramWeb,
+    /// Всё остальное. На loopback пропускается напрямую, на сетевом адресе —
+    /// отклоняется, иначе LAN-режим стал бы открытым прокси.
+    Elsewhere,
+}
+
+fn classify(address: &str) -> Destination {
+    match address.parse::<IpAddr>() {
+        Ok(ip) if crate::telegram_net::is_telegram(ip) => Destination::DataCentre(ip),
+        Ok(_) => Destination::Elsewhere,
+        Err(_) if crate::telegram_net::is_telegram_host(address) => Destination::TelegramWeb,
+        Err(_) => Destination::Elsewhere,
+    }
+}
+
 async fn handle_socks5(
    mut s: TcpStream,
    stats: &Stats,
    allow_direct: bool,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    s.set_nodelay(true)?;
+    let peer = s.peer_addr().ok();

-    let (addr, port) = tokio::time::timeout(IO_TIMEOUT, read_socks5_request(&mut s))
+    let request = tokio::time::timeout(IO_TIMEOUT, read_socks5_request(&mut s))
        .await
-        .map_err(|_| "SOCKS5 handshake timeout")??;
-    let tg = addr.parse::<Ipv4Addr>().ok().and_then(dc_from_ip).is_some();
-    if !tg && !allow_direct {
+        .map_err(|_| "SOCKS5 handshake timeout".to_owned())
+        .and_then(|result| result.map_err(|error| error.to_string()));
+    let (addr, port) = match request {
+        Ok(request) => request,
+        Err(error) => {
+            stats.note_unknown_client(peer, &format!("SOCKS5-приветствие не разобрано ({error})"));
+            return Err(error.into());
+        }
+    };
+    let destination = classify(&addr);
+    if destination == Destination::Elsewhere && !allow_direct {
+        stats.note_blocked(&addr, port);
        write_socks_reply(&mut s, 0x02).await?;
        return Err("LAN mode only permits Telegram destinations".into());
    }
@@ -229,19 +421,15 @@ async fn handle_socks5(
    s.write_all(&[0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x04, 0x38])
        .await?;

-    if tg {
+    if let Destination::DataCentre(ip) = destination {
        // Read 64-byte obfuscated2 init → extract real DC
        let mut init = [0u8; 64];
        s.read_exact(&mut init).await?;

-        let (dc, media) = dc_from_init(&init).unwrap_or_else(|| {
-            addr.parse::<Ipv4Addr>()
-                .ok()
-                .and_then(dc_from_ip)
-                .map_or((2, false), |dc| (dc, false))
-        });
+        let (dc, media) = dc_from_init(&init)
+            .unwrap_or_else(|| (crate::telegram_net::dc_from_ip(ip).unwrap_or(2), false));

-        stats.last_dc.store(dc, Ordering::Relaxed);
+        stats.note_dc(dc);

        let r = ws_tunnel(s, dc, media, &init, None, stats).await;

@@ -250,7 +438,7 @@ async fn handle_socks5(
        }
        r?;
    } else {
-        let remote = tokio::time::timeout(IO_TIMEOUT, TcpStream::connect((addr.as_str(), port)))
+        let remote = tokio::time::timeout(IO_TIMEOUT, connect_direct(&addr, port, allow_direct))
            .await
            .map_err(|_| "direct connection timeout")??;
        let _ = remote.set_nodelay(true);
@@ -259,19 +447,87 @@ async fn handle_socks5(
    Ok(())
 }

+/// Открыть прямое соединение по адресу, который назвал клиент.
+///
+/// В ограниченном режиме имя разрешается заранее и проверяется, куда оно
+/// указывает: список доменов принадлежит Telegram, но DNS-ответ приходит извне,
+/// а адрес назначения выбирает чужое устройство. Без проверки ответ вида
+/// `127.0.0.1` или `192.168.0.1` сделал бы TGLock дверью во внутреннюю сеть
+/// этой машины.
+async fn connect_direct(
+    address: &str,
+    port: u16,
+    allow_direct: bool,
+) -> Result<TcpStream, Box<dyn std::error::Error + Send + Sync>> {
+    if allow_direct {
+        return Ok(TcpStream::connect((address, port)).await?);
+    }
+
+    let mut last = None;
+    for candidate in tokio::net::lookup_host((address, port)).await? {
+        if is_private(candidate.ip()) {
+            continue;
+        }
+        match TcpStream::connect(candidate).await {
+            Ok(stream) => return Ok(stream),
+            Err(error) => last = Some(error),
+        }
+    }
+    Err(match last {
+        Some(error) => Box::new(error) as Box<dyn std::error::Error + Send + Sync>,
+        None => format!("{address} resolves only to addresses inside this network").into(),
+    })
+}
+
+fn is_private(ip: IpAddr) -> bool {
+    match ip {
+        IpAddr::V4(ip) => {
+            ip.is_private()
+                || ip.is_loopback()
+                || ip.is_link_local()
+                || ip.is_broadcast()
+                || ip.is_unspecified()
+                || ip.octets()[0] == 0
+                // 100.64.0.0/10, операторский NAT
+                || (ip.octets()[0] == 100 && (64..128).contains(&ip.octets()[1]))
+        }
+        IpAddr::V6(ip) => {
+            ip.is_loopback()
+                || ip.is_unspecified()
+                // fc00::/7 — уникальные локальные, fe80::/10 — link-local
+                || (ip.segments()[0] & 0xfe00) == 0xfc00
+                || (ip.segments()[0] & 0xffc0) == 0xfe80
+                || ip.to_ipv4_mapped().is_some_and(|ip| is_private(IpAddr::V4(ip)))
+        }
+    }
+}
+
 async fn handle_mtproto(
    mut stream: TcpStream,
    stats: &Stats,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    stream.set_nodelay(true)?;
+    let peer = stream.peer_addr().ok();
    let mut init = [0; 64];
    tokio::time::timeout(IO_TIMEOUT, stream.read_exact(&mut init))
        .await
        .map_err(|_| "MTProto init timeout")??;
-    let parsed = crate::mtproto::parse_client_init(&init, &stats.secret)
-        .ok_or("invalid MTProto init or secret")?;
+    let parsed = match crate::mtproto::parse_client_init(&init, &stats.secret) {
+        Some(parsed) => parsed,
+        None => {
+            // Секрет — половина ссылки `tg://proxy`. Клиент с сохранённой
+            // ссылкой от прошлого запуска попадает ровно сюда, и Telegram
+            // показывает ему «прокси настроен неверно».
+            stats.note_unknown_client(
+                peer,
+                "MTProto-init не разобран. Скорее всего в Telegram вписан другой \
+                 секрет — сверьте ссылку tg://proxy с той, что показана сейчас",
+            );
+            return Err("invalid MTProto init or secret".into());
+        }
+    };

-    stats.last_dc.store(parsed.dc, Ordering::Relaxed);
+    stats.note_dc(parsed.dc);
    let result = ws_tunnel(
        stream,
        parsed.dc,
@@ -373,28 +629,6 @@ fn dc_from_init(init: &[u8; 64]) -> Option<(u16, bool)> {
    matches!(dc, 1..=5 | 203).then_some((dc, id < 0))
 }

-fn dc_from_ip(ip: Ipv4Addr) -> Option<u16> {
-    let o = ip.octets();
-    match (o[0], o[1]) {
-        (149, 154) => Some(match o[2] {
-            160..=163 => 1,
-            164..=167 => 2,
-            168..=171 => 3,
-            172..=175 => 1,
-            _ => 2,
-        }),
-        (91, 108) => Some(match o[2] {
-            56..=59 => 5,
-            8..=11 => 3,
-            12..=15 => 4,
-            _ => 2,
-        }),
-        (91, 105) if o[2] == 192 => Some(203),
-        (91, 105) | (185, 76) => Some(2),
-        _ => None,
-    }
-}
-
 // -- WebSocket tunnel -------------------------------------------------------

 /// Keeps `Stats::ws` equal to the number of *established* tunnels.
@@ -431,9 +665,7 @@ async fn ws_tunnel(

    let (mut ws, connected) = stats.transport.connect(dc, media).await?;
    let _tunnel = EstablishedTunnel::new(stats);
-    stats
-        .last_route
-        .store(connected.route.kind.ui_code(), Ordering::Relaxed);
+    stats.note_tunnel(dc, connected.route.kind.ui_code());

    let (mut tcp_r, mut tcp_w) = tokio::io::split(tcp);

@@ -662,12 +894,130 @@ mod tests {
        assert!(server_task.await.unwrap());
    }

+    /// Что именно решает судьбу соединения в LAN-режиме.
+    ///
+    /// Принадлежность адреса сетям Telegram проверяется в `telegram_net`;
+    /// здесь важно, что из неё следует для каждой из трёх веток.
    #[test]
-    fn maps_known_telegram_networks_to_dc() {
-        assert_eq!(dc_from_ip("149.154.160.1".parse().unwrap()), Some(1));
-        assert_eq!(dc_from_ip("149.154.167.255".parse().unwrap()), Some(2));
-        assert_eq!(dc_from_ip("91.108.58.1".parse().unwrap()), Some(5));
-        assert_eq!(dc_from_ip("1.1.1.1".parse().unwrap()), None);
+    fn destinations_are_sorted_into_three_kinds() {
+        assert_eq!(
+            classify("149.154.167.51"),
+            Destination::DataCentre("149.154.167.51".parse().unwrap())
+        );
+        assert_eq!(
+            classify("2001:67c:4e8:f002::a"),
+            Destination::DataCentre("2001:67c:4e8:f002::a".parse().unwrap()),
+            "IPv6-адрес дата-центра — такой же Telegram (by-sonic/tglock#42)"
+        );
+        assert_eq!(classify("web.telegram.org"), Destination::TelegramWeb);
+        assert_eq!(classify("1.1.1.1"), Destination::Elsewhere);
+        assert_eq!(
+            classify("185.76.150.1"),
+            Destination::Elsewhere,
+            "соседний адрес вне опубликованного блока Telegram"
+        );
+        assert_eq!(classify("telegram.org.example.com"), Destination::Elsewhere);
+    }
+
+    #[test]
+    fn a_refused_destination_is_counted_and_named_once() {
+        let stats = Stats::new();
+        for _ in 0..3 {
+            stats.note_blocked("1.1.1.1", 443);
+        }
+        stats.note_blocked("8.8.8.8", 443);
+
+        assert_eq!(
+            stats.blocked.load(Ordering::Relaxed),
+            4,
+            "счётчик считает все отказы"
+        );
+        let events = stats.drain_events();
+        assert_eq!(events.len(), 2, "а журнал называет каждый адрес один раз");
+        assert!(events[0].contains("1.1.1.1:443"), "{events:?}");
+        assert!(
+            stats.drain_events().is_empty(),
+            "забранное событие не приходит повторно"
+        );
+    }
+
+    /// Диагностика обязана показывать пару из одного соединения.
+    ///
+    /// Пока это были два независимых поля, при десятках одновременных
+    /// соединений в строку статуса попадали номер от одного и маршрут от
+    /// другого. Читалось это как «до DC5 шли запасным адресом», хотя у DC5
+    /// закреплённый адрес всего один и запасного не бывает вовсе
+    /// (by-sonic/tglock#42).
+    #[test]
+    fn the_reported_data_centre_and_route_come_from_the_same_tunnel() {
+        let stats = Stats::new();
+        assert_eq!(stats.last_dc(), 0, "до соединений показывать нечего");
+        assert_eq!(stats.last_route(), 0);
+
+        stats.note_dc(2);
+        assert_eq!(stats.last_dc(), 2, "клиент разобран, номер известен");
+        assert_eq!(stats.last_route(), 0, "а маршрут ещё не выбран");
+
+        stats.note_tunnel(4, 2);
+        assert_eq!((stats.last_dc(), stats.last_route()), (4, 2));
+
+        // Ещё одно соединение до другого DC, туннеля у него пока нет.
+        stats.note_dc(203);
+        assert_eq!(
+            (stats.last_dc(), stats.last_route()),
+            (4, 2),
+            "пара обязана остаться от соединения, у которого туннель был"
+        );
+    }
+
+    /// Клиент с сохранённой ссылкой от прошлого запуска. Раньше его соединение
+    /// закрывалось молча, и по диагностике это было неотличимо от рабочего.
+    #[tokio::test]
+    async fn a_client_with_the_wrong_secret_gets_named_instead_of_dropped_in_silence() {
+        let stats = Stats::new();
+        let (port, server) = start_proxy(stats.clone(), true).await;
+
+        let stranger = crate::mtproto::generate_secret();
+        let init = unambiguous_client_init(&stranger, 2);
+        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
+        client.write_all(&init).await.unwrap();
+
+        wait_until("отказ по секрету", || {
+            stats.unknown_clients.load(Ordering::Relaxed) > 0
+        })
+        .await;
+        let events = stats.drain_events();
+        assert!(
+            events
+                .iter()
+                .any(|event| event.contains("MTProto-init не разобран")),
+            "в журнале должно быть сказано, что init не разобран: {events:?}"
+        );
+
+        stats.stop();
+        let _ = server.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn a_client_that_speaks_neither_protocol_is_counted_too() {
+        let stats = Stats::new();
+        let (port, server) = start_proxy(stats.clone(), true).await;
+
+        // Приветствие SOCKS5 с нулём методов: разбор обязан провалиться.
+        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
+        client.write_all(&[0x05, 0x00]).await.unwrap();
+
+        wait_until("отказ по рукопожатию", || {
+            stats.unknown_clients.load(Ordering::Relaxed) > 0
+        })
+        .await;
+        assert!(stats
+            .drain_events()
+            .iter()
+            .any(|event| event.contains("SOCKS5-приветствие не разобрано")));
+
+        stats.stop();
+        let _ = server.await.unwrap();
    }

    #[tokio::test]
@@ -798,7 +1148,7 @@ mod tests {
        // Detection must land on MTProto, which records the data centre. The
        // SOCKS5 path would instead answer with a handshake reply.
        wait_until("the MTProto data centre to be recorded", || {
-            stats.last_dc.load(Ordering::Relaxed) == 2
+            stats.last_dc() == 2
        })
        .await;

@@ -839,6 +1189,42 @@ mod tests {
            reply[1], 0x02,
            "a shared listener must not relay arbitrary destinations"
        );
+        assert_eq!(
+            stats.blocked.load(Ordering::Relaxed),
+            1,
+            "отказ должен быть виден в диагностике, а не только клиенту"
+        );
+        assert!(
+            stats
+                .drain_events()
+                .iter()
+                .any(|event| event.contains("1.1.1.1:443")),
+            "в журнале должен быть назван адрес, из-за которого отказали"
+        );
+
+        stats.stop();
+        let _ = server.await.unwrap();
+    }
+
+    /// Ровно то, на чём ломался LAN-режим: телефон просит адрес дата-центра по
+    /// IPv6, а прокси отвечает «не Telegram» (by-sonic/tglock#42).
+    #[tokio::test]
+    async fn network_listener_accepts_a_telegram_ipv6_data_centre() {
+        let stats = Stats::new();
+        let (port, server) = start_proxy(stats.clone(), false).await;
+
+        let mut request = vec![0x05, 0x01, 0x00, 0x04];
+        request.extend_from_slice(
+            &"2001:67c:4e8:f002::a"
+                .parse::<std::net::Ipv6Addr>()
+                .unwrap()
+                .octets(),
+        );
+        request.extend_from_slice(&443_u16.to_be_bytes());
+
+        let (_client, reply) = socks5_exchange(port, &request).await;
+        assert_eq!(reply[1], 0x00, "адрес Telegram по IPv6 нельзя отклонять");
+        assert_eq!(stats.blocked.load(Ordering::Relaxed), 0);

        stats.stop();
        let _ = server.await.unwrap();
@@ -915,9 +1301,9 @@ mod tests {
            "Telegram must receive exactly the client's plaintext"
        );

-        assert_eq!(stats.last_dc.load(Ordering::Relaxed), 4);
+        assert_eq!(stats.last_dc(), 4);
        assert_eq!(
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_route(),
            crate::transport::RouteKind::TelegramIp.ui_code()
        );
        assert_eq!(stats.ws_failures.load(Ordering::Relaxed), 0);
@@ -972,7 +1358,7 @@ mod tests {
        );
        assert_eq!(relayed, request);
        assert_eq!(
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_route(),
            crate::transport::RouteKind::CloudflareWorker.ui_code()
        );

@@ -1000,10 +1386,7 @@ mod tests {
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();

-        wait_until("the init to be parsed", || {
-            stats.last_dc.load(Ordering::Relaxed) == 2
-        })
-        .await;
+        wait_until("the init to be parsed", || stats.last_dc() == 2).await;
        tokio::time::sleep(Duration::from_millis(300)).await;

        assert_eq!(
@@ -1012,7 +1395,7 @@ mod tests {
            "a handshake still in flight must not be reported as a working tunnel"
        );
        assert_eq!(
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_route(),
            0,
            "no route may be announced before a tunnel is established"
        );
@@ -1041,7 +1424,7 @@ mod tests {
        })
        .await;
        assert_eq!(
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_route(),
            0,
            "a route must not be reported as working when every attempt failed"
        );
@@ -1071,13 +1454,13 @@ mod tests {
        client.write_all(&init).await.unwrap();

        tokio::time::timeout(Duration::from_secs(10), async {
-            while stats.last_route.load(Ordering::Relaxed) == 0 {
+            while stats.last_route() == 0 {
                tokio::task::yield_now().await;
            }
        })
        .await
        .unwrap();
-        assert_eq!(stats.last_dc.load(Ordering::Relaxed), 4);
+        assert_eq!(stats.last_dc(), 4);
        assert_eq!(stats.ws_failures.load(Ordering::Relaxed), 0);

        stats.stop();
@@ -0,0 +1,271 @@
+//! Какие адреса и имена принадлежат Telegram.
+//!
+//! От этого ответа зависит поведение LAN-режима: слушатель на сетевом адресе
+//! пропускает только Telegram, всё остальное отклоняет. Значит ошибка в любую
+//! сторону видна пользователю.
+//!
+//! Раньше проверка сравнивала два первых октета, то есть считала «телеграмом»
+//! целиком `149.154.0.0/16`, `91.108.0.0/16`, `91.105.0.0/16` и `185.76.0.0/16`,
+//! а IPv6 не знала вовсе. Отсюда два разных дефекта: чужие адреса внутри этих
+//! сетей уходили в MTProto-туннель и умирали, а настоящие адреса Telegram по
+//! IPv6 отклонялись как посторонние. Второе и выглядит как «на компьютере
+//! работает, с телефона нет» (by-sonic/tglock#42): на loopback не-Telegram
+//! адреса всё равно релеятся напрямую, поэтому там ошибка не проявляется.
+//!
+//! Список сетей — официальный, <https://core.telegram.org/resources/cidr.txt>,
+//! сверен 19 августа 2026 года.
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+/// IPv4-сети Telegram: адрес сети и длина префикса.
+const V4: &[(Ipv4Addr, u32)] = &[
+    (Ipv4Addr::new(91, 105, 192, 0), 23),
+    (Ipv4Addr::new(91, 108, 4, 0), 22),
+    (Ipv4Addr::new(91, 108, 8, 0), 22),
+    (Ipv4Addr::new(91, 108, 12, 0), 22),
+    (Ipv4Addr::new(91, 108, 16, 0), 22),
+    (Ipv4Addr::new(91, 108, 20, 0), 22),
+    (Ipv4Addr::new(91, 108, 56, 0), 22),
+    (Ipv4Addr::new(149, 154, 160, 0), 20),
+    (Ipv4Addr::new(185, 76, 151, 0), 24),
+];
+
+/// IPv6-сети Telegram.
+const V6: &[(Ipv6Addr, u32)] = &[
+    (Ipv6Addr::new(0x2001, 0x67c, 0x4e8, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23c, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23d, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23f, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2a0a, 0xf280, 0, 0, 0, 0, 0, 0), 32),
+];
+
+/// Домены Telegram, к которым SOCKS5-клиент может попроситься по имени.
+///
+/// Это веб-инфраструктура, а не дата-центры: обычный HTTPS, MTProto в нём нет.
+/// Telegram ходит сюда за конфигурацией, превью ссылок и файлами CDN, и на
+/// телефоне такие запросы идут через тот же прокси.
+const HOSTS: &[&str] = &[
+    "telegram.org",
+    "t.me",
+    "telegram.me",
+    "telesco.pe",
+    "cdn-telegram.org",
+];
+
+/// Принадлежит ли адрес Telegram.
+pub fn is_telegram(ip: IpAddr) -> bool {
+    match ip {
+        IpAddr::V4(ip) => in_v4(ip),
+        // Клиент может прислать `::ffff:149.154.167.51` вместо IPv4-формы, и
+        // это тот же самый адрес.
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => in_v4(ip),
+            None => in_v6(ip),
+        },
+    }
+}
+
+/// Принадлежит ли имя Telegram.
+///
+/// Совпадение только по границе метки: `telegram.org.example.com` — чужой
+/// домен, и разрешать его нельзя.
+pub fn is_telegram_host(host: &str) -> bool {
+    let host = host.trim_end_matches('.').to_ascii_lowercase();
+    HOSTS.iter().any(|suffix| {
+        host == *suffix
+            || (host.len() > suffix.len()
+                && host.ends_with(suffix)
+                && host.as_bytes()[host.len() - suffix.len() - 1] == b'.')
+    })
+}
+
+/// Номер дата-центра по адресу — запасной вариант, когда его не удалось
+/// достать из init-пакета.
+///
+/// Это догадка, а не факт: одна и та же подсеть обслуживает несколько DC
+/// (`149.154.175.x` — и DC1, и DC3). Настоящий номер приходит из init, и сюда
+/// попадают только соединения, у которых init разобрать не вышло.
+pub fn dc_from_ip(ip: IpAddr) -> Option<u16> {
+    match ip {
+        IpAddr::V4(ip) => dc_from_ipv4(ip),
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => dc_from_ipv4(ip),
+            None => dc_from_ipv6(ip),
+        },
+    }
+}
+
+fn dc_from_ipv4(ip: Ipv4Addr) -> Option<u16> {
+    if !in_v4(ip) {
+        return None;
+    }
+    let octets = ip.octets();
+    Some(match (octets[0], octets[1], octets[2]) {
+        (149, 154, 160..=163) => 1,
+        (149, 154, 164..=167) => 2,
+        (149, 154, 168..=171) => 3,
+        (149, 154, 172..=175) => 1,
+        (91, 108, 56..=59) => 5,
+        (91, 108, 8..=11) => 3,
+        (91, 108, 12..=15) => 4,
+        (91, 105, 192..=193) => 203,
+        _ => 2,
+    })
+}
+
+/// Адреса дата-центров имеют вид `2001:b28:f23d:f002::a`, где `f00N` —
+/// номер DC. Для `2a0a:f280::/32` такого правила нет, и выдумывать его не
+/// нужно: номер придёт из init.
+fn dc_from_ipv6(ip: Ipv6Addr) -> Option<u16> {
+    if !in_v6(ip) {
+        return None;
+    }
+    let dc = ip.segments()[3].checked_sub(0xf000)?;
+    matches!(dc, 1..=5).then_some(dc)
+}
+
+fn in_v4(ip: Ipv4Addr) -> bool {
+    let value = u32::from(ip);
+    V4.iter().any(|&(network, prefix)| {
+        let mask = u32::MAX.checked_shl(32 - prefix).unwrap_or(0);
+        value & mask == u32::from(network) & mask
+    })
+}
+
+fn in_v6(ip: Ipv6Addr) -> bool {
+    let value = u128::from(ip);
+    V6.iter().any(|&(network, prefix)| {
+        let mask = u128::MAX.checked_shl(128 - prefix).unwrap_or(0);
+        value & mask == u128::from(network) & mask
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ip(value: &str) -> IpAddr {
+        value.parse().unwrap()
+    }
+
+    #[test]
+    fn known_data_centre_addresses_are_telegram() {
+        for address in [
+            "149.154.175.50", // DC1
+            "149.154.167.51", // DC2
+            "149.154.175.100",
+            "149.154.167.91",
+            "91.108.56.130", // DC5
+            "91.105.192.100",
+            "185.76.151.1",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+    }
+
+    /// Раньше сюда попадал весь `/16`, то есть десятки тысяч чужих адресов.
+    #[test]
+    fn neighbours_outside_the_published_blocks_are_not_telegram() {
+        for address in [
+            "149.154.159.255", // на один адрес ниже 149.154.160.0/20
+            "149.154.176.0",   // на один выше
+            "91.108.3.255",
+            "91.108.24.0",
+            "91.108.60.0",
+            "91.105.194.0",
+            "185.76.150.255",
+            "185.76.152.0",
+            "1.1.1.1",
+        ] {
+            assert!(!is_telegram(ip(address)), "{address} — не Telegram");
+        }
+    }
+
+    #[test]
+    fn block_edges_belong_to_the_block() {
+        for address in [
+            "149.154.160.0",
+            "149.154.175.255",
+            "91.108.4.0",
+            "91.108.7.255",
+            "185.76.151.0",
+            "185.76.151.255",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} — край блока Telegram");
+        }
+    }
+
+    /// Из-за этого LAN-режим отклонял живой Telegram (by-sonic/tglock#42).
+    #[test]
+    fn ipv6_data_centres_are_telegram_too() {
+        for address in [
+            "2001:b28:f23d:f001::a",
+            "2001:67c:4e8:f002::a",
+            "2001:b28:f23d:f003::a",
+            "2001:67c:4e8:f004::a",
+            "2001:b28:f23f:f005::a",
+            "2001:b28:f23c::1",
+            "2a0a:f280:203:a::b",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+        assert!(!is_telegram(ip("2606:4700:4700::1111")), "это Cloudflare");
+        assert!(!is_telegram(ip("2001:b28:f23e::1")), "соседний префикс");
+    }
+
+    #[test]
+    fn ipv4_mapped_form_is_the_same_address() {
+        assert!(is_telegram(ip("::ffff:149.154.167.51")));
+        assert!(!is_telegram(ip("::ffff:1.1.1.1")));
+    }
+
+    /// Поведение, на которое опирался предыдущий тест `dc_from_ip`.
+    #[test]
+    fn data_centre_guess_survives_the_stricter_membership_check() {
+        assert_eq!(dc_from_ip(ip("149.154.160.1")), Some(1));
+        assert_eq!(dc_from_ip(ip("149.154.167.255")), Some(2));
+        assert_eq!(dc_from_ip(ip("91.108.58.1")), Some(5));
+        assert_eq!(dc_from_ip(ip("1.1.1.1")), None);
+    }
+
+    #[test]
+    fn data_centre_guess_reads_the_number_out_of_an_ipv6_address() {
+        assert_eq!(dc_from_ip(ip("2001:67c:4e8:f002::a")), Some(2));
+        assert_eq!(dc_from_ip(ip("2001:b28:f23f:f005::a")), Some(5));
+        assert_eq!(
+            dc_from_ip(ip("2a0a:f280:203:a::b")),
+            None,
+            "для этого префикса правила нет — лучше признаться, чем выдумать"
+        );
+    }
+
+    #[test]
+    fn telegram_hosts_are_matched_on_label_boundaries() {
+        for host in [
+            "telegram.org",
+            "web.telegram.org",
+            "core.telegram.org",
+            "venus.web.telegram.org",
+            "t.me",
+            "TELEGRAM.ORG",
+            "telegram.org.", // корневая точка в имени законна
+            "cdn4.cdn-telegram.org",
+        ] {
+            assert!(is_telegram_host(host), "{host} — Telegram");
+        }
+    }
+
+    #[test]
+    fn lookalike_hosts_are_rejected() {
+        for host in [
+            "telegram.org.example.com",
+            "nottelegram.org",
+            "fakecdn-telegram.org",
+            "t.me.evil.net",
+            "example.com",
+            "",
+        ] {
+            assert!(!is_telegram_host(host), "{host} — не Telegram");
+        }
+    }
+}
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};

@@ -113,6 +114,14 @@ struct HealthState {
 pub struct TransportEngine {
    health: Mutex<HealthState>,
    worker_domains: Mutex<Vec<String>>,
+    /// Сколько раз отдельный маршрут не ответил.
+    ///
+    /// Считается отдельно от `Stats::ws_failures`, который растёт только когда
+    /// упали ВСЕ маршруты. Из-за этого диагностика показывала «сбоев 0», пока
+    /// закреплённый адрес был недоступен и каждое холодное соединение молча
+    /// откатывалось на следующий маршрут, тратя на это до восьми секунд
+    /// (by-sonic/tglock#32).
+    route_failures: AtomicU32,
    #[cfg(test)]
    forced_routes: Mutex<Vec<Route>>,
 }
@@ -258,7 +267,13 @@ impl TransportEngine {
        health.preferred.insert(key, route.clone());
    }

+    /// Сколько отдельных маршрутов не ответило за время работы.
+    pub fn route_failures(&self) -> u32 {
+        self.route_failures.load(Ordering::Relaxed)
+    }
+
    fn record_failure(&self, route: &Route) {
+        self.route_failures.fetch_add(1, Ordering::Relaxed);
        let mut health = self.health.lock().unwrap();
        let failures = health
            .routes
@@ -656,6 +671,38 @@ mod tests {
        );
    }

+    #[test]
+    fn every_route_failure_is_counted() {
+        // Диагностика показывала «сбоев 0», пока закреплённый адрес был мёртв и
+        // соединения молча откатывались на запасной. Счётчик маршрутов должен
+        // видеть каждое такое падение.
+        let engine = TransportEngine::new();
+        let routes = routes_for_dc(2, false);
+        assert_eq!(engine.route_failures(), 0);
+
+        engine.record_failure(&routes[0]);
+        assert_eq!(engine.route_failures(), 1);
+
+        engine.record_failure(&routes[0]);
+        engine.record_failure(&routes[1]);
+        assert_eq!(
+            engine.route_failures(),
+            3,
+            "считаются все падения, включая повторные по тому же маршруту"
+        );
+
+        // Успех не обнуляет историю: она нужна, чтобы понять, что маршруты
+        // перебирались, даже когда в итоге всё соединилось.
+        engine.record_success(
+            DcKey {
+                dc: 2,
+                media: false,
+            },
+            &routes[1],
+        );
+        assert_eq!(engine.route_failures(), 3);
+    }
+
    #[test]
    fn documented_worker_contract_matches_the_requested_path() {
        // docs/CLOUDFLARE_WORKER.md promises exactly this shape.
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "TGLock",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.11",
  "identifier": "com.bysonic.tglock",
  "mainBinaryName": "tglock",
  "build": {
@@ -0,0 +1,42 @@
+# Настройки tglock-cli.
+#
+# Положите этот файл рядом с бинарём под именем tglock.toml — он подхватится
+# сам. Либо укажите путь явно: tglock-cli --config /etc/tglock.toml
+#
+# Все поля необязательны. Флаги командной строки перекрывают то, что здесь.
+
+# Адрес и порт локального прокси.
+# По умолчанию 127.0.0.1:1080 — доступ только с этого компьютера.
+# bind = "127.0.0.1"
+# port = 1080
+
+# Слушать 0.0.0.0, чтобы подключались другие устройства в сети.
+# Нельзя задавать одновременно с bind.
+# lan = true
+
+# Секрет прокси — вторая половина ссылки tg://proxy.
+#
+# Для сервиса его нужно закрепить, иначе после перезапуска секрет будет новым и
+# все настроенные клиенты перестанут подключаться. Достаточно один раз
+# запустить tglock-cli, скопировать секрет из напечатанной ссылки и вписать
+# сюда. Принимается и с префиксом dd, и без него.
+#
+# Файл с секретом внутри держите с правами 600: это доступ к вашему прокси.
+# secret = "dd00112233445566778899aabbccddeeff"
+
+# Либо хранить секрет в отдельном файле — он создастся при первом запуске.
+# Игнорируется, если задан secret выше.
+# secret_file = "secret"
+
+# Свои Cloudflare Worker'ы как резервный маршрут — на случай, когда у
+# провайдера легли все обычные маршруты. Установка описана в
+# docs/CLOUDFLARE_WORKER.md
+# worker = ["my-name.workers.dev"]
+
+# Пропускать и не-Telegram адреса.
+# На loopback это включено само. На сетевом адресе означает открытый
+# SOCKS5-прокси для всего интернета — включайте осознанно.
+# allow_direct = false
+
+# Печатать только ошибки.
+# quiet = false
@@ -10,8 +10,15 @@ type Status = {
  dataCenter: number | null;
  route: string;
  failures: number;
+  routeFailures: number;
+  /// Отклонено политикой «в LAN-режиме только Telegram».
+  blocked: number;
+  /// Клиенты, которые дошли, но не сумели договориться о рукопожатии.
+  unknownClients: number;
  uptimeSeconds: number;
  port: number;
+  /// Адрес для других устройств. Приходит только в LAN-режиме.
+  shareAddress: string | null;
  logs: LogLine[];
 };

@@ -37,8 +44,12 @@ let status: Status = {
  dataCenter: null,
  route: "Маршрут ещё не выбран",
  failures: 0,
+  routeFailures: 0,
+  blocked: 0,
+  unknownClients: 0,
  uptimeSeconds: 0,
  port: 1080,
+  shareAddress: null,
  logs: [],
 };
 let settings: Settings = { lanMode: false, port: 1080, workerDomain: "" };
@@ -145,6 +156,18 @@ function renderHome(): void {
        <span>порт ${status.port}</span>
      </div>

+      ${status.shareAddress ? `
+      <div class="share-card">
+        <div class="share-label">Адрес для других устройств</div>
+        <button id="copy-address" class="share-address" title="Нажмите, чтобы скопировать">
+          ${escapeHtml(status.shareAddress)}
+        </button>
+        <div class="share-hint">
+          Впишите его в Telegram на телефоне. Не <code>127.0.0.1</code> — на другом
+          устройстве это означает само устройство.
+        </div>
+      </div>` : ""}
+
      <nav class="bottom-nav" aria-label="Разделы">
        <button id="settings-nav" class="nav-button">
          <span class="nav-icon">${icons.settings}</span>
@@ -160,6 +183,7 @@ function renderHome(): void {
  `, "home-page");

  document.querySelector("#power")?.addEventListener("click", toggleProtection);
+  document.querySelector("#copy-address")?.addEventListener("click", copyShareAddress);
  document.querySelector("#settings-nav")?.addEventListener("click", () => navigate("settings"));
  document.querySelector("#diagnostics-nav")?.addEventListener("click", () => navigate("diagnostics"));
 }
@@ -261,8 +285,40 @@ function renderDiagnostics(): void {
          <span>Время работы</span>
          <strong class="time">${formatUptime(status.uptimeSeconds)}</strong>
        </article>
+        <article class="metric-card">
+          <span>Падений маршрутов</span>
+          <strong>${status.routeFailures}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Отклонено</span>
+          <strong>${status.blocked}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Не опознаны</span>
+          <strong>${status.unknownClients}</strong>
+        </article>
      </div>

+      <p class="field-hint">
+        «Падений маршрутов» больше нуля при работающем Telegram — это норма:
+        значит закреплённый адрес недоступен и подключение идёт через запасной.
+        Число в багрепорте помогает понять, что именно перебиралось.
+      </p>
+
+      <p class="field-hint">
+        «Отклонено» — запросы, которые LAN-режим не пропустил: он ходит только
+        по адресам Telegram. Если с телефона ничего не работает, а здесь ноль и
+        соединений тоже ноль, значит телефон до этого компьютера не дошёл —
+        дело в сети или брандмауэре. Какие именно адреса отклонены, видно ниже.
+      </p>
+
+      <p class="field-hint">
+        «Не опознаны» — клиенты, которые дошли до прокси, но договориться с ними
+        не удалось. Почти всегда это старая ссылка: секрет в Telegram остался от
+        прошлого запуска и больше не совпадает. Тогда Telegram пишет «прокси
+        настроен неверно», а адрес такого клиента появится в журнале ниже.
+      </p>
+
      <div class="log-panel">
        <div class="log-heading">
          <span>Последние события</span>
@@ -356,6 +412,18 @@ async function saveSettings(event: Event): Promise<void> {
  }
 }

+async function copyShareAddress(): Promise<void> {
+  const address = status.shareAddress;
+  if (!address) return;
+  try {
+    await navigator.clipboard.writeText(address);
+    showToast("Адрес скопирован");
+  } catch {
+    // Буфер обмена может быть недоступен — адрес и так виден на экране.
+    showToast("Скопируйте адрес вручную", true);
+  }
+}
+
 function showToast(message: string, error = false): void {
  window.clearTimeout(toastTimer);
  window.requestAnimationFrame(() => {
@@ -847,3 +847,53 @@ input:disabled {
      0 19px 52px rgba(9, 182, 133, 0.4);
  }
 }
+
+/* Адрес для подключения других устройств. Показывается только в LAN-режиме:
+   люди искали его в интерфейсе, не находили и вписывали 127.0.0.1, который на
+   телефоне означает сам телефон (by-sonic/tglock#36). */
+.share-card {
+  margin-top: 14px;
+  padding: 14px 16px;
+  border-radius: 14px;
+  background: rgba(42, 171, 238, 0.08);
+  border: 1px solid rgba(42, 171, 238, 0.24);
+  text-align: center;
+}
+
+.share-label {
+  font-size: 12px;
+  letter-spacing: 0.02em;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-address {
+  display: block;
+  width: 100%;
+  margin: 6px 0 8px;
+  padding: 6px 8px;
+  border: 0;
+  border-radius: 10px;
+  background: transparent;
+  color: var(--accent, #2aabee);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 20px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background 150ms ease;
+}
+
+.share-address:hover,
+.share-address:focus-visible {
+  background: rgba(42, 171, 238, 0.14);
+}
+
+.share-hint {
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-hint code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 11px;
+}