Merge pull request 'fix(mera): витрина сделок лэндинга — в расписание, дата прогона на страницу, монитор свежести (#3469)' (#3509) from fix/3469-showcase-schedule into main

Тест применял 015/051/052 безусловно, и на базе, прошедшей всю цепочку
миграций (CI и прод), повтор 015 падал:

  psycopg.errors.UndefinedColumn: column "returning_count" of relation
  "scrape_runs" does not exist

Файл 015 идемпотентен относительно себя, но не относительно схемы,
прошедшей 214 (DROP COLUMN IF EXISTS returning_count): CREATE TABLE IF
NOT EXISTS — no-op, а COMMENT ON COLUMN в конце того же файла обращается
к снесённой колонке. На чистой базе, где 015 ложится с нуля, этого не
видно по построению — потому прогон и был зелёным там, где его гонял я,
и красным там, где его гоняет CI.

Зависимости теперь применяются только когда scrape_schedules ещё нет; в
докстроке — рецепт прогона на ПОЛНОЙ схеме, тем же путём, что у CI.

Заодно закрыты три дыры, которые находились мутациями:

- окно расписания и повторное применение проверяются на живой БД (до
  этого 6,7 → 6,23 и DELETE+INSERT вместо ON CONFLICT проходили насквозь);
  идемпотентность меряется created_at строки, а не числом строк — замена
  «удалить и вставить» тоже оставляет ровно одну строку, но стирает
  last_run_at/next_run_at на каждом деплое;
- next_run_at в будущем — утверждение стояло в приёмке и ничем не
  проверялось;
- handler сравнивается по САМОМУ job'у, а не по log_name: имя — второй
  литерал конструктора Handler, и чужое тело под верным ключом
  (_job_landing_stats) проходило проверку по имени.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.forgejo/workflows/ci.yml

@@ -219,6 +219,30 @@ jobs:
               - '.forgejo/workflows/deploy.yml'
               - '.forgejo/workflows/deploy-tradein.yml'
               - '.forgejo/workflows/ci.yml'
+              # #3448: тот же класс, ещё раз. Гейт про исключающие `!`-шаблоны
+              # в paths-filter проверяет ВСЕ воркфлоу, а paths-filter живёт и
+              # здесь — без этой строки правка ci-tradein.yml с таким шаблоном
+              # не запустила бы backend-tests, то есть гейт не побежал бы ровно
+              # на той правке, от которой стережёт.
+              - '.forgejo/workflows/ci-tradein.yml'
+              # #3467/#3475: гейт backend/tests/ops/test_3467_prometheus_reload.py
+              # читает оба файла ниже. Без них правка, трогающая ТОЛЬКО
+              # deploy-metrics.yml (скажем, дописывающая `|| true` к шагу
+              # перезагрузки Prometheus), даёт backend=false — джоба
+              # backend-tests пропускается, гейт не исполняется, регрессия
+              # уезжает в main зелёной. Ровно то, что осуждает комментарий выше.
+              - '.forgejo/workflows/deploy-metrics.yml'
+              - 'docker-compose.metrics.yml'
+              # #3443: тот же класс, третий раз. Гейт
+              # backend/tests/ops/test_3443_caddy_reload_not_recreate.py не читает
+              # ops/caddy-apply.sh, а ИСПОЛНЯЕТ его с подставным `docker` — то есть
+              # все содержательные регрессии живут в самом скрипте, а не в
+              # deploy.yml. PR, правящий только ops/**, без этой строки давал бы
+              # backend=false: джоба пропускается, гейт не исполняется, и
+              # «пересоздавать всегда» (окно 67 с на всех доменах) или
+              # «не пересоздавать никогда» (правка конфига беззвучно не доезжает)
+              # уезжает в main зелёным.
+              - 'ops/**'
             frontend:
               - 'frontend/**'
               - '.forgejo/workflows/ci.yml'

.forgejo/workflows/deploy-metrics.yml

@@ -90,8 +90,13 @@ jobs:
           METRICS_TELEGRAM_TOPIC_ID: ${{ secrets.METRICS_TELEGRAM_TOPIC_ID }}
           METRICS_TELEGRAM_INFRA_TOPIC_ID: ${{ secrets.METRICS_TELEGRAM_INFRA_TOPIC_ID }}
           METRICS_TELEGRAM_ONCALL: ${{ secrets.METRICS_TELEGRAM_ONCALL }}
+          ALERT_ACK_GLITCHTIP_SECRET: ${{ secrets.ALERT_ACK_GLITCHTIP_SECRET }}
+          # #3471: секрет ретранслятора Telegram Bot API (tg-relay). Пусто —
+          # профиль relay не включаем (см. PROFILES ниже), а не падаем в
+          # рестарт-луп: контейнер сам делает SystemExit на пустом секрете.
+          TG_RELAY_SECRET: ${{ secrets.TG_RELAY_SECRET }}
         with:
-          envs: METRICS_TELEGRAM_BOT_TOKEN,METRICS_TELEGRAM_CHAT_ID,METRICS_TELEGRAM_TOPIC_ID,METRICS_TELEGRAM_INFRA_TOPIC_ID,METRICS_TELEGRAM_ONCALL
+          envs: METRICS_TELEGRAM_BOT_TOKEN,METRICS_TELEGRAM_CHAT_ID,METRICS_TELEGRAM_TOPIC_ID,METRICS_TELEGRAM_INFRA_TOPIC_ID,METRICS_TELEGRAM_ONCALL,ALERT_ACK_GLITCHTIP_SECRET,TG_RELAY_SECRET
           host: ${{ secrets.INFRA_DEPLOY_HOST || secrets.DEPLOY_HOST }}
           username: ${{ secrets.INFRA_DEPLOY_USER || secrets.DEPLOY_USER }}
           key: ${{ secrets.INFRA_DEPLOY_SSH_KEY || secrets.DEPLOY_SSH_KEY }}
@@ -188,6 +193,14 @@ jobs:
                     echo "Инфраструктура: тема ${INFRA_TOPIC_ID} по умолчанию (METRICS_TELEGRAM_INFRA_TOPIC_ID не задана)."
                 fi
 
+                # Резервный приёмник GlitchTip (#3471) отвечает 503 на любой
+                # запрос, пока секрет пуст: тихо принимать чужие алерты настежь
+                # хуже, чем не принимать вовсе. Молчаливого отказа тут быть не
+                # должно — деплой обязан сказать, что канал не поднялся.
+                if [ -z "${ALERT_ACK_GLITCHTIP_SECRET:-}" ]; then
+                    echo "::warning title=Резервный канал GlitchTip выключен::ALERT_ACK_GLITCHTIP_SECRET пуст — alert-ack отвечает 503 на /glitchtip, и при падении продуктового бэкенда его ошибки доставлять будет нечем."
+                fi
+
                 if [ -n "${METRICS_TELEGRAM_ONCALL:-}" ]; then
                     echo "Клиентские инциденты: зовём ${METRICS_TELEGRAM_ONCALL} поимённо."
                 else
@@ -250,6 +263,19 @@ jobs:
                 echo "::warning title=Алерты выключены::METRICS_TELEGRAM_BOT_TOKEN/CHAT_ID не заданы. Метрики и логи собираются, но при срабатывании правила НИКТО не будет уведомлён. Канал доставки — открытый вопрос #3078."
             fi
 
+            # Ретранслятор Telegram Bot API (#3471, PR #3487 сломал прод: сервис
+            # без profiles уходил в SystemExit на пустом секрете и висел в
+            # Restarting). Профиль relay включаем НЕЗАВИСИМО от alerts — это
+            # разные каналы (один шлёт алерты боту, другой ретранслирует
+            # продуктовый Bot API трафик с Selectel). PROFILES — список через
+            # запятую, как того требует COMPOSE_PROFILES.
+            if [ -n "${TG_RELAY_SECRET:-}" ]; then
+                PROFILES="${PROFILES:+$PROFILES,}relay"
+                echo "Ретранслятор Telegram: секрет задан, профиль relay включён."
+            else
+                echo "::warning title=Резервный ретранслятор Telegram выключен::TG_RELAY_SECRET пуст — tg-relay не поднимается (профиль relay выключен). Продуктовый Telegram-трафик пойдёт напрямую с Selectel, где теряется примерно каждый четвёртый короткий запрос."
+            fi
+
             # ── Цели file_sd для Prometheus (#3155) ────────────────────────
             # Включатель профиля и цель для Prometheus обязаны стоять в ОДНОМ
             # условии. Пока они жили порознь, вышло так: 27.08 профиль alerts
@@ -268,67 +294,75 @@ jobs:
             AM_TARGETS_FILE=ops/metrics/prometheus/alertmanager_targets.gen.yml
             : > "$AM_TARGETS_FILE"
             echo "# Файл рендерится деплоем (deploy-metrics.yml), правки руками затрутся." >> "$AM_TARGETS_FILE"
-            if [ "$PROFILES" = "alerts" ]; then
+            # Сравнение через case, а не "=": PROFILES теперь может быть
+            # комбинацией через запятую ("alerts,relay") с тех пор, как #3471
+            # завёл независимый профиль relay — точное равенство строке
+            # "alerts" сломалось бы молча в тот момент, когда оба профиля
+            # включены разом.
+            case ",$PROFILES," in
+            *,alerts,*)
                 echo '- targets: ["alertmanager:9093"]' >> "$AM_TARGETS_FILE"
                 echo "  labels:" >> "$AM_TARGETS_FILE"
                 echo "    host: infra" >> "$AM_TARGETS_FILE"
                 echo "Prometheus: приёмник alertmanager:9093 прописан в целях."
-            else
+                ;;
+            *)
                 # Пустой список, а НЕ отсутствующий файл: одиночный бинд-маунт
                 # несуществующего пути docker подменяет каталогом, и Prometheus
                 # не стартует вовсе.
                 echo "# Профиль alerts выключен — приёмников нет." >> "$AM_TARGETS_FILE"
                 echo "[]" >> "$AM_TARGETS_FILE"
                 echo "Prometheus: профиль alerts выключен — целей нет, это штатно."
-            fi
+                ;;
+            esac
 
             # ── read-only роль для датасорса GlitchTip ─────────────────────
             # Идемпотентно. Прав на запись не выдаём вовсе: датасорс Grafana
             # обязан быть безопасен даже при полном доступе к дашбордам.
             bash scripts/setup-metrics-grafana-role.sh
 
-            # ── Prometheus: проверить конфигурацию ДО ЛЮБОГО применения ─────
-            # Тот же порядок, что у Caddy ниже: проверка — здесь, применение —
-            # только после неё. Стоит ВЫШЕ `up -d` намеренно: `up -d`
-            # пересоздаёт контейнер при смене образа, и тогда битый конфиг
-            # положил бы Prometheus раньше, чем деплой успел бы покраснеть.
-            # Сама перезагрузка — в конце, после приёмки: дёргать ручку
-            # раньше, чем процесс отвечает, нечем.
-            #
-            # ЗАЧЕМ ЭТО ВООБЩЕ. Правила подключены КАТАЛОГОМ, поэтому новый
-            # текст контейнер видит сразу — но Prometheus читает правила только
-            # при старте либо по явной перезагрузке, а деплой не делал ни того,
-            # ни другого. 12.09: контейнер работал с 27.08, на диске (и внутри
-            # контейнера) лежали правила из #3464, а /api/v1/rules отдавал
-            # прежние. Зелёный деплой, новый файл на диске, старое поведение —
-            # отказ без единого отрицательного признака. Значит и все прежние
-            # правки ops/metrics/prometheus/** вступали в силу лишь тогда, когда
-            # контейнер пересоздавался по какой-то посторонней причине.
-            #
-            # Проверяем ОДНОРАЗОВЫМ контейнером того же образа по файлам С
-            # ДИСКА, а не `docker exec` в работающий: prometheus.yml подключён
-            # бинд-маунтом ОДНОГО файла, и работающий контейнер после `git
-            # reset` читает СТАРЫЙ инод — exec проверял бы не тот текст,
-            # который применится.
-            #
-            # Нужны ОБЕ команды: при пустом (или не смонтированном) каталоге
-            # правил `check config` печатает «0 rule files found» и проходит, а
-            # `check rules` по явному шаблону в этом случае падает — проверено
-            # на стенде prom/prometheus:v3.1.0.
-            PROM_IMAGE=$(grep -oE 'prom/prometheus:[^ ]+' docker-compose.metrics.yml | head -1)
-            if ! docker run --rm -v "$PWD/ops/metrics/prometheus:/etc/prometheus:ro" \
-                    --entrypoint sh "$PROM_IMAGE" -c \
-                    'promtool check config /etc/prometheus/prometheus.yml && promtool check rules /etc/prometheus/rules/*.yml'; then
-                echo "ОШИБКА: конфиг или правила Prometheus не проходят проверку — ничего не применяем."
-                echo "Работающий Prometheus не тронут и остаётся на прежней конфигурации. Чинить и повторять."
-                exit 1
-            fi
-
             COMPOSE_PROFILES="$PROFILES" \
                 docker compose -p gendesign-metrics -f docker-compose.metrics.yml pull --quiet
             COMPOSE_PROFILES="$PROFILES" \
                 docker compose -p gendesign-metrics -f docker-compose.metrics.yml up -d --remove-orphans
 
+            # ── alert-ack / tg-relay: код монтируется с хоста ────────────────
+            # Тот же класс бага, что у Alertmanager (см. ниже) и Caddyfile:
+            # `up -d` сравнивает ОПИСАНИЕ сервиса, а не содержимое бинд-маунта.
+            # alert-ack и tg-relay получают код именно бинд-маунтом файла
+            # (./ops/metrics/{alert-ack,tg-relay}/app.py:/app/app.py:ro), а не
+            # сборкой образа — правка app.py оставляет уже запущенный
+            # контейнер работать на СТАРОМ коде в памяти интерпретатора сколько
+            # угодно, и `up -d` этого не видит вовсе.
+            #
+            # Пойман на проде 12.09.2026: PR #3490 (фикс alert-ack) слился,
+            # `git reset --hard` обновил файл на диске (grep по новому
+            # комментарию находил его), а gendesign-alert-ack, запущенный за
+            # 25 минут до этого, продолжал отвечать по старой логике —
+            # зелёный деплой, тихо неверное поведение. Починил только ручной
+            # `docker restart gendesign-alert-ack`. force-recreate здесь —
+            # замена этому ручному шагу.
+            #
+            # case ",$PROFILES," — пересоздаём только если профиль сервиса
+            # реально включён в ЭТОМ прогоне, иначе force-recreate ругается на
+            # несуществующий контейнер (сервис не создан вовсе).
+            case ",$PROFILES," in
+            *,alerts,*)
+                COMPOSE_PROFILES="$PROFILES" \
+                    docker compose -p gendesign-metrics -f docker-compose.metrics.yml \
+                    up -d --force-recreate alert-ack
+                echo "alert-ack: контейнер пересоздан — код монтируется с хоста, up -d его не подхватывает (#3490)."
+                ;;
+            esac
+            case ",$PROFILES," in
+            *,relay,*)
+                COMPOSE_PROFILES="$PROFILES" \
+                    docker compose -p gendesign-metrics -f docker-compose.metrics.yml \
+                    up -d --force-recreate tg-relay
+                echo "tg-relay: контейнер пересоздан — код монтируется с хоста, up -d его не подхватывает (#3490)."
+                ;;
+            esac
+
             # ── Alertmanager: пересоздать, если конфиг перерисовали ─────────
             # `up -d` выше СЧИТАЕТ alertmanager неизменившимся: он сравнивает
             # описание сервиса, а содержимое бинд-маунта в это сравнение не
@@ -354,34 +388,6 @@ jobs:
                 echo "Alertmanager: контейнер пересоздан — иначе читал бы конфиг по старому иноду."
             fi
 
-            # ── Бинд-маунт ОДНОГО файла держит инод ────────────────────────
-            # Та же ловушка, что у Alertmanager выше и у Alloy в джобах агентов:
-            # `git reset --hard` пишет изменившийся файл НОВЫМ инодом, а
-            # работающий контейнер продолжает читать прежний, уже удалённый.
-            # `up -d` этого не видит (сравнивается описание сервиса, не
-            # содержимое маунта), перезагрузка по API — тоже (перечитывается тот
-            # же открытый инод). Лечит только пересоздание контейнера.
-            #
-            # Список обязан совпадать с одиночными файловыми маунтами
-            # docker-compose.metrics.yml; сторожит соответствие
-            # backend/tests/ops/test_3467_prometheus_reload.py. Производные
-            # файлы (alertmanager.yml, alertmanager_targets.gen.yml) сюда не
-            # входят: их рендерит сам деплой и уже разбирается с инодом.
-            for entry in \
-                "prometheus gendesign-prometheus ops/metrics/prometheus/prometheus.yml /etc/prometheus/prometheus.yml" \
-                "loki gendesign-loki ops/metrics/loki/loki-config.yml /etc/loki/loki-config.yml" \
-                "alert-ack gendesign-alert-ack ops/metrics/alert-ack/app.py /app/app.py"; do
-                set -- $entry
-                docker ps -q -f "name=^$2\$" | grep -q . || continue
-                if [ "$(stat -c %i "$3")" = "$(docker exec "$2" stat -c %i "$4")" ]; then
-                    continue
-                fi
-                COMPOSE_PROFILES="$PROFILES" \
-                    docker compose -p gendesign-metrics -f docker-compose.metrics.yml \
-                    up -d --force-recreate "$1"
-                echo "$1: $3 переписан новым инодом — контейнер пересоздан."
-            done
-
             # ── Caddy: СНАЧАЛА проверить, потом применять ──────────────────
             # На этом хосте тот же Caddy обслуживает git., errors. и obsidian.
             # Синтаксическая ошибка в infra.caddy положила бы их все, включая
@@ -402,42 +408,55 @@ jobs:
 
             # ── Приёмка ────────────────────────────────────────────────────
             for i in $(seq 1 30); do
-                if docker exec gendesign-prometheus wget -q --spider http://localhost:9090/-/healthy 2>/dev/null \
-                   && docker exec gendesign-grafana wget -q --spider http://localhost:3000/api/health 2>/dev/null; then
+                if docker exec gendesign-prometheus wget -q --spider http://localhost:9090/-/healthy 2>/dev/null; then
                     break
                 fi
                 sleep 3
             done
             docker compose -p gendesign-metrics -f docker-compose.metrics.yml ps
 
-            # ── Применение: перечитать конфигурацию работающими сервисами ───
-            # Конфиг проверен выше, контейнеры отвечают — только теперь.
+            # ── Prometheus: конфиг/правила лежат на диске, `up -d` их не
+            # перечитывает ────────────────────────────────────────────────
+            # Тот же класс бага, что у Caddyfile и alertmanager.yml выше:
+            # docker compose сравнивает описание сервиса, а НЕ содержимое
+            # бинд-маунта, поэтому уже работающий контейнер продолжает жить
+            # со старым конфигом сколько угодно — на проде дошло до 16 суток
+            # незамеченными (#3467): lastConfigTime совпадал со startTime
+            # контейнера при каждом зелёном деплое, менявшем ops/metrics/prometheus/**.
             #
-            # Prometheus перечитывает и prometheus.yml, и правила по POST
-            # /-/reload (флаг --web.enable-lifecycle стоит в
-            # docker-compose.metrics.yml). Без флага ручка отвечает 405 и шаг
-            # краснеет — это и нужно: молча оставаться на старых правилах
-            # деплой больше не должен.
-            docker exec gendesign-prometheus wget -q -O- --post-data='' \
-                http://localhost:9090/-/reload
-            echo "Prometheus: конфигурация перечитана, правила вступили в силу."
+            # У Prometheus, в отличие от Alertmanager (см. комментарий выше),
+            # /-/reload переоткрывает файлы ПО ПУТИ заново, поэтому новый инод
+            # после `git reset --hard` подхватывается без пересоздания
+            # контейнера. --web.enable-lifecycle уже включён в compose ради
+            # этого шага (см. docker-compose.metrics.yml) — просто раньше
+            # никто не звал сам reload.
+            #
+            # promtool проверяет ОБА файла ДО reload: битый конфиг не должен
+            # положить работающий Prometheus молчаливым откатом на дефолты.
+            if docker exec gendesign-prometheus promtool check config /etc/prometheus/prometheus.yml \
+                    && docker exec gendesign-prometheus sh -c 'promtool check rules /etc/prometheus/rules/*.yml'; then
+                LAST_CONFIG_BEFORE="$(docker exec gendesign-prometheus wget -qO- http://localhost:9090/api/v1/status/runtimeinfo | grep -oE '"lastConfigTime":"[^"]*"')"
 
-            # Grafana. Дашборды провайдер пересканирует сам раз в 30 с
-            # (updateIntervalSeconds в provisioning/dashboards/dashboards.yml —
-            # проверено на стенде grafana:11.5.1: новый файл появился без
-            # рестарта), а ДАТАСОРСЫ применяются только при старте: правка
-            # provisioning/datasources лежала бы на диске без эффекта — ровно
-            # тот же разрыв, что и у правил Prometheus. Штатная ручка
-            # перезагрузки дешевле рестарта и не роняет открытые дашборды.
-            #
-            # Пароль берётся из окружения САМОГО контейнера: в аргументы команд
-            # на хосте и в лог деплоя он так не попадает.
-            if docker exec gendesign-grafana sh -c \
-                    'wget -q -O- --post-data="" --header="Authorization: Basic $(printf "%s:%s" "${GF_SECURITY_ADMIN_USER:-admin}" "${GF_SECURITY_ADMIN_PASSWORD}" | base64 -w0)" http://localhost:3000/api/admin/provisioning/datasources/reload'; then
-                echo
-                echo "Grafana: датасорсы перечитаны."
+                docker exec gendesign-prometheus wget -q -O /dev/null --post-data='' http://localhost:9090/-/reload
+
+                # lastConfigTime обновляется на КАЖДЫЙ успешный reload, даже
+                # если содержимое конфига не поменялось — значит сравнение
+                # "было/стало" надёжно ловит и несостоявшийся reload, и
+                # изменившиеся правила.
+                LAST_CONFIG_AFTER=""
+                for i in $(seq 1 10); do
+                    LAST_CONFIG_AFTER="$(docker exec gendesign-prometheus wget -qO- http://localhost:9090/api/v1/status/runtimeinfo | grep -oE '"lastConfigTime":"[^"]*"')"
+                    [ -n "$LAST_CONFIG_AFTER" ] && [ "$LAST_CONFIG_AFTER" != "$LAST_CONFIG_BEFORE" ] && break
+                    sleep 1
+                done
+
+                if [ -z "$LAST_CONFIG_AFTER" ] || [ "$LAST_CONFIG_AFTER" = "$LAST_CONFIG_BEFORE" ]; then
+                    echo "ОШИБКА: reload Prometheus не подтверждён — lastConfigTime не изменился ($LAST_CONFIG_BEFORE)."
+                    exit 1
+                fi
+                echo "Prometheus: конфиг и правила проверены, reload подтверждён ($LAST_CONFIG_BEFORE -> $LAST_CONFIG_AFTER)."
             else
-                echo "ОШИБКА: Grafana не перечитала датасорсы — правка provisioning/datasources осталась бы без эффекта."
+                echo "ОШИБКА: конфиг/правила Prometheus не проходят promtool — reload НЕ выполнен, работающий Prometheus остаётся на прежнем конфиге."
                 exit 1
             fi
 

.forgejo/workflows/deploy.yml

@@ -121,37 +121,98 @@ jobs:
       infra: ${{ steps.filter.outputs.infra }}
       # #2916: правка ТОЛЬКО конфига прокси. `infra` для этого не годится — он
       # включает и compose, и сам workflow, где полный деплой обязателен.
-      # `github.event_name == 'push'` первым множителем НАМЕРЕННО: на
-      # workflow_dispatch у paths-filter нет диффа, и любой его ответ не должен
-      # уметь отключить сборку — ручной прогон обязан оставаться полным.
-      caddy_only: ${{ github.event_name == 'push' && steps.filter.outputs.caddy == 'true' && steps.filter.outputs.non_caddy == 'false' }}
+      caddy_only: ${{ steps.filter.outputs.caddy_only }}
     steps:
       - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
+
+      # ── #3448: список изменённых файлов считаем САМИ ─────────────────────────
+      #
+      # ЧТО БЫЛО. Быстрый путь «правка только прокси» (#2916) не отработал НИ
+      # РАЗУ. Причина — НЕ пустой `event.before`: эта гипотеза опровергнута
+      # логом задачи 29244 (run 10881, мерж 84920e6c) — `before` там валиден,
+      # 204e2e09…, и `git diff` вернул ровно один файл. Причина в семантике
+      # самого фильтра: dorny/paths-filter склеивает шаблоны ОДНОГО фильтра
+      # через `some`, то есть ИЛИ (src/filter.ts: `patterns.some(aPredicate)`,
+      # predicate-quantifier по умолчанию `some`). Список
+      #     non_caddy: ['**', '!Caddyfile', '!caddy/**']
+      # читается не как «всё, КРОМЕ caddy», а как «подходит под `**` ИЛИ не
+      # Caddyfile ИЛИ не caddy/**». `**` матчит всё, поэтому non_caddy был true
+      # ВСЕГДА и caddy_only — false всегда. В логе это видно дословно:
+      #     ##[group]Filter non_caddy = true
+      #     Matching files:
+      #     caddy/sites/apps.caddy [modified]
+      # Исключённый файл сам себя и «исключил». deploy-caddy при этом
+      # пропускался, а Forgejo рисует пропущенную джобу зелёной — сигнала не
+      # было ни одного.
+      #
+      # ПОЧЕМУ ШЕЛЛ, А НЕ ЗАПЛАТКА К ФИЛЬТРАМ. Разность множеств тут нужна одна
+      # («все изменения лежат под caddy»), и выражать её действием, у которого
+      # ИЛИ по умолчанию, — значит снова повесить решение на незаметное
+      # умолчание: `predicate-quantifier: every` действует на ВЕСЬ блок и
+      # сломал бы backend/frontend/infra. Плюс два требования #3448: решение
+      # обязано быть ВИДНО в логе (иначе «сработало» и «просто не совпало»
+      # неотличимы), и оно не должно молча зависеть от того, что платформа
+      # кладёт в `before`.
+      #
+      # FAIL-SAFE. База не разрешилась (ручной запуск, пустой/нулевой `before`,
+      # коммита нет на сервере) → считаем изменённым ВЕСЬ репозиторий: лишний
+      # полный деплой безопаснее пропущенного. Фолбэка на `HEAD^..HEAD` тут
+      # намеренно нет: у мерж-коммита он дал бы верный ответ, а у push'а из
+      # нескольких коммитов — молча урезанный, и быстрый путь включился бы
+      # там, где приехал бэкенд.
+      - name: Определить изменённые файлы (#3448)
         id: filter
-        with:
-          filters: |
-            backend:
-              - 'backend/**'
-              - 'data/sql/**'
-            frontend:
-              - 'frontend/**'
-            infra:
-              - 'docker-compose.prod.yml'
-              - 'Caddyfile'
-              - 'caddy/**'
-              - '.forgejo/workflows/deploy.yml'
-            # Пара фильтров для «правка ТОЛЬКО прокси» (#2916). Одного `caddy`
-            # мало: он true и когда вместе с конфигом приехал бэкенд — тогда
-            # нужен обычный полный деплой. `non_caddy` матчит ВСЁ остальное,
-            # и быстрый путь включается лишь когда он false.
-            caddy:
-              - 'Caddyfile'
-              - 'caddy/**'
-            non_caddy:
-              - '**'
-              - '!Caddyfile'
-              - '!caddy/**'
+        env:
+          BEFORE: ${{ github.event.before }}
+          EVENT: ${{ github.event_name }}
+        run: |
+          set -eu
+          NULL_SHA=0000000000000000000000000000000000000000
+          BASE=""
+          if [ "$EVENT" = "push" ] && [ -n "${BEFORE:-}" ] && [ "$BEFORE" != "$NULL_SHA" ]; then
+            git cat-file -e "${BEFORE}^{commit}" 2>/dev/null \
+              || git fetch --depth=1 --no-tags origin "$BEFORE" >/dev/null 2>&1 \
+              || true
+            if git cat-file -e "${BEFORE}^{commit}" 2>/dev/null; then
+              BASE="$BEFORE"
+            else
+              echo "::warning::коммит $BEFORE недоступен в клоне — деплой будет полным"
+            fi
+          fi
+
+          if [ -n "$BASE" ]; then
+            FILES=$(git -c core.quotePath=false diff --no-renames --name-only "$BASE" HEAD)
+            N=$(printf '%s\n' "$FILES" | grep -c . || true)
+            echo "База: $BASE → $(git rev-parse HEAD); изменённых файлов: $N"
+            printf '%s\n' "$FILES" | sed 's/^/  /'
+          else
+            FILES=$(git -c core.quotePath=false ls-files)
+            N=$(printf '%s\n' "$FILES" | grep -c . || true)
+            echo "База не определена (event=$EVENT, before='${BEFORE:-}') — считаем изменённым весь репозиторий ($N файлов), деплой полный"
+          fi
+
+          # Те же наборы путей, что были в фильтрах до #3448.
+          CADDY_RE='^(Caddyfile$|caddy/)'
+          has() { printf '%s\n' "$FILES" | grep -qE "$1"; }
+
+          backend=false; frontend=false; infra=false; caddy_only=false
+          has '^(backend/|data/sql/)' && backend=true
+          has '^frontend/' && frontend=true
+          has '^(docker-compose\.prod\.yml$|Caddyfile$|caddy/|\.forgejo/workflows/deploy\.yml$)' && infra=true
+          # Быстрый путь: изменения ЕСТЬ и НИ ОДНО из них не лежит вне caddy.
+          # Проверка `N -gt 0` обязательна: пустой список иначе прошёл бы как
+          # «всё под caddy» и отключил бы сборку на ровном месте.
+          if [ "$N" -gt 0 ] && ! printf '%s\n' "$FILES" | grep -vE "$CADDY_RE" | grep -q .; then
+            caddy_only=true
+          fi
+
+          echo "Флаги: backend=$backend frontend=$frontend infra=$infra caddy_only=$caddy_only"
+          {
+            echo "backend=$backend"
+            echo "frontend=$frontend"
+            echo "infra=$infra"
+            echo "caddy_only=$caddy_only"
+          } >> "$GITHUB_OUTPUT"
 
   build-backend:
     runs-on: ubuntu-latest
@@ -997,12 +1058,17 @@ jobs:
             docker compose -p gendesign -f docker-compose.prod.yml up -d \
               --force-recreate --no-deps $WORKER_SERVICES
 
-            # Caddy: force-recreate чтобы подхватить изменения в Caddyfile
-            # И в особенности новые volume mounts из docker-compose.prod.yml
-            # (`reload` не пересоздаёт container, поэтому новые binds не появляются —
-            # был случай 2026-05-17 с PR #268 preview/ — потребовался manual SSH fix).
-            docker compose -p gendesign -f docker-compose.prod.yml up -d \
-              --force-recreate --no-deps caddy
+            # Caddy: пересоздание ТОЛЬКО когда без него правка не доедет (#3443).
+            # Здесь стоял безусловный `up -d --force-recreate --no-deps caddy` —
+            # то есть КАЖДЫЙ полный деплой сносил единственный процесс, слушающий
+            # 80/443, и все домены хоста отдавали `code=000` (замер 05.09: 67 с).
+            # Довод той правки (17.05, 11e78d73 — «иначе новые volume mounts не
+            # появляются») не подтвердился: `up -d` БЕЗ флага пересоздаёт
+            # контейнер сам, как только меняется описание сервиса или образ.
+            # Разбор и проверки — в шапке ops/caddy-apply.sh; там же сверка
+            # пофайловых bind-маунтов (Caddyfile + 4 сниппета держат инод) и
+            # `caddy validate` до применения.
+            sh ops/caddy-apply.sh
 
             # Forwarder: force-recreate чтобы новый image / новые env подхватывались.
             # Без --force-recreate обычный `up -d` НЕ recreate'ит при image rebuild
@@ -1229,14 +1295,13 @@ jobs:
   # Публичный периметр МЕРЫ живёт в этом файле и будет меняться часто: новая
   # страница = новая строка allowlist'а.
   #
-  # ПОЧЕМУ `reload`, А НЕ `up -d --force-recreate caddy`. Полный деплой
-  # осознанно пересоздаёт контейнер (комментарий в ci.yml: `reload` отказался бы
-  # принять битый конфиг и оставил бы работать старый — на общем деплое это
-  # скрыло бы поломку). Здесь наоборот: правится ТОЛЬКО конфиг, и отказ
-  # применить битый — ровно то, что нужно. `caddy reload` возвращает ненулевой
-  # код → job краснеет, а домены продолжают обслуживаться старым конфигом.
-  # Альтернатива (`--force-recreate`) на опечатке уводит контейнер в crash-loop
-  # и роняет ВСЕ домены сразу.
+  # ПОЧЕМУ `reload`, А НЕ `up -d --force-recreate caddy`. Опечатка в конфиге на
+  # пересоздании уводит контейнер в crash-loop и роняет ВСЕ домены сразу, а
+  # `caddy reload` её просто не принимает: job краснеет, домены продолжают
+  # обслуживаться прежним конфигом. С #3443 ровно тот же порядок действует и на
+  # полном деплое — оба пути зовут ops/caddy-apply.sh, который сперва проверяет
+  # конфиг одноразовым контейнером и пересоздаёт Caddy, только если правка иначе
+  # не доедет (пофайловый bind-маунт держит инод).
   #
   # Гейт `caddy validate` на PR (#2913) остаётся первой линией; этот шаг —
   # вторая, уже против боевого файла после `git reset`.
@@ -1282,14 +1347,73 @@ jobs:
           fingerprint: ${{ secrets.DEPLOY_SSH_FINGERPRINT }}
           script: |
             set -euo pipefail
+            # #3448: ТОТ ЖЕ ЛОК, что берёт полный деплой (см. job `deploy` выше).
+            # Эта джоба делает `git reset --hard` в /opt/gendesign, то есть правит
+            # прод-дерево — ровно то, что полный деплой сериализует локом. Пока
+            # быстрый путь был мёртв, столкнуться было нечему; теперь есть.
+            exec 9>/var/lock/gendesign-docker-deploy.lock
+            if flock -n 9; then
+              echo "→ докер-лок свободен, взят сразу"
+            else
+              echo "→ докер-лок занят соседним деплоем, жду (до 900с)…"
+              lock_wait_started=$(date +%s)
+              if ! flock -w 900 9; then
+                echo "ERROR: не дождался лока докер-деплоя за 900с."
+                echo "       Кто держит: ssh на хост, затем fuser -v /var/lock/gendesign-docker-deploy.lock"
+                exit 1
+              fi
+              echo "→ докер-лок получен через $(( $(date +%s) - lock_wait_started ))с ожидания"
+            fi
             cd /opt/gendesign
             git fetch origin main
+
+            # ── #3448: быстрый путь законен, только если прод отстаёт РОВНО на
+            # конфиг прокси ────────────────────────────────────────────────────
+            #
+            # Джоба `changes` считает дифф between-push (before→HEAD) и не знает,
+            # что доехало до прода. Пока caddy_only был мёртв, любой push шёл
+            # полным деплоем и гард свежести :latest (#2950, job `deploy`)
+            # прикрывал прод по умолчанию. Оживший быстрый путь этот гард
+            # обходит: при caddy_only=true джоба `deploy` пропускается целиком.
+            #
+            # Сценарий отказа: push A правит бэкенд, билды ~6 мин, `deploy` в
+            # очереди; через 2 мин push B правит только caddy/. Forgejo на
+            # 10.0.3 отменяет ещё не стартовавший `deploy` предыдущего прогона
+            # ДАЖЕ при cancel-in-progress: false (наблюдение 21.08.2026 10:35:13,
+            # см. шапку scripts/check-latest-image-revision.sh). Дифф A..B — один
+            # caddy-файл, быстрый путь включается, `compose pull` + `up -d` не
+            # делает никто: прод крутит старый образ при зелёной голове main.
+            #
+            # Единственный источник правды о том, что реально на проде, — HEAD
+            # прод-дерева (у Trade-In для этого заведён отдельный маркер
+            # /opt/gendesign/.tradein-deployed-sha, см. deploy-tradein.yml:150;
+            # у ПТИЦЫ маркера нет, но git reset ниже делает HEAD эквивалентом).
+            # Проверка стоит ДО reset намеренно: при отказе прод-HEAD остаётся
+            # честным для следующего прогона.
+            #
+            # ЧЕГО ЭТА ПРОВЕРКА НЕ ЛОВИТ: `deploy` прогона A, упавшую ПОСЛЕ
+            # `git reset --hard` (например на миграции). Тогда прод-HEAD уже
+            # равен A, а контейнеры старые, и caddy-only push пройдёт быстрым
+            # путём. Это остаётся за настоящим маркером «что задеплоено».
+            PROD_HEAD=$(git rev-parse HEAD)
+            OUTSIDE=$(git -c core.quotePath=false diff --name-only "$PROD_HEAD" origin/main | grep -vE '^(Caddyfile$|caddy/)' || true)
+            if [ -n "$OUTSIDE" ]; then
+              echo "::error::прод отстаёт не только по конфигу прокси — быстрый путь запрещён:"
+              printf '%s\n' "$OUTSIDE" | sed 's/^/  /'
+              echo "Запусти полный деплой через workflow_dispatch."
+              exit 1
+            fi
             git reset --hard origin/main
-            # Конфиг примонтирован read-only с хоста, пересборка не нужна —
-            # контейнер читает тот же файл, что только что обновил git.
-            docker compose -p gendesign -f docker-compose.prod.yml exec -T caddy \
-              caddy reload --config /etc/caddy/Caddyfile --adapter caddyfile
-            echo "✓ конфиг прокси перезагружен без пересборки и без миграций"
+            # #3443: тот же скрипт, что и в полном деплое. Голый `exec caddy
+            # reload` здесь был ВЕРЕН только для каталогов (caddy/sites/**,
+            # caddy/local/**). Caddyfile и четыре сниппета смонтированы
+            # ПОФАЙЛОВО, а `git reset --hard` выше пишет новый инод — контейнер
+            # остаётся на прежнем, и reload перечитывает СТАРЫЙ текст. Отказ
+            # беззвучный: джоба зелёная, конфиг на диске новый, прокси работает
+            # по старому. Скрипт сверяет, что именно видит контейнер, и
+            # пересоздаёт его только в этом случае.
+            sh ops/caddy-apply.sh
+            echo "✓ быстрый путь завершён: без пересборки образов и без миграций"
 
   # ── Смоук публичного периметра МЕРЫ после выкатки (#2917) ──────────────────
   #

backend/app/api/v1/parcels.py

@@ -17,6 +17,7 @@ from sqlalchemy.orm import Session
 
 from app.core.config import settings
 from app.core.db import get_db
+from app.observability.metrics import REPORTS_EXPORTED
 from app.schemas.parcel import (
     AnalysisRunDetail,
     AnalysisRunListResponse,
@@ -1612,6 +1613,11 @@ def export_parcel_forecast(
     if run is None:
         raise HTTPException(status_code=404, detail="прогноз ещё не посчитан")
 
+    # #3471: считаем выгрузку здесь, а не в каждой format-ветке ниже — рано
+    # (до самого рендера), зато один раз на весь запрос и без риска разъехаться
+    # с новой веткой формата, если её когда-нибудь добавят.
+    REPORTS_EXPORTED.labels(format=format).inc()
+
     # tg — INLINE сниппет (не файл): краткая сводка для копипаста в Telegram, без attachment.
     if format == "tg":
         return Response(
@@ -4911,6 +4917,7 @@ async def get_parcel_best_layouts_pdf(
         today = _dt.date.today().strftime("%Y-%m-%d")
         cad_safe = cad_num.replace(":", "-")
         filename = f"tz-layout-{cad_safe}-{today}.pdf"
+        REPORTS_EXPORTED.labels(format="best_layouts_pdf").inc()
         return Response(
             content=pdf_bytes,
             media_type="application/pdf",

backend/app/observability/metrics.py

@@ -100,6 +100,19 @@ BUILD_INFO.labels(
     release=os.getenv("SENTRY_RELEASE") or os.getenv("IMAGE_TAG") or "unknown",
 ).set(1)
 
+# ═══ ПРОДУКТОВЫЕ СЧЁТЧИКИ (#3471) ═══════════════════════════════════════════
+#
+# `format` — фиксированный литерал из сигнатуры эндпоинта (Literal["md", "json",
+# "tg", "docx", "pptx", "pdf"] в `export_parcel_forecast` + одно статичное
+# значение "best_layouts_pdf" из ТЗ-на-проектирование), НЕ произвольная строка —
+# кардинальность ограничена набором форматов экспорта, а не количеством
+# участков/пользователей.
+REPORTS_EXPORTED = Counter(
+    "sitefinder_reports_exported_total",
+    "Экспортов отчётов по участку (§22-форсайт, ТЗ на проектирование), по формату",
+    labelnames=("format",),
+)
+
 
 def route_label(scope: Scope) -> str:
     """Шаблон маршрута из ASGI-scope, либо ``__unmatched__``.

backend/tests/api/v1/conftest.py

@@ -17,12 +17,22 @@ Analyze-тесты с ПОЗИЦИОННЫМ DB-моком (``_make_db_for_analy
 (``test_analyze_zoning_regulation.py``), переопределяют этот же target своим
 per-test ``patch`` — он применяется ПОВЕРХ авто-фикстуры (вложенный mock-scope), так
 что их ожидаемые значения резолвера сохраняются.
+
+Perf-fix (2026-09-12): в конце ``analyze_parcel`` — безусловный best-effort
+``forecast_site_finder_report.delay(...)`` (§22-форсайт enqueue, см. app/api/v1/parcels.py).
+В песочнице тестов Celery-брокер (Redis) недоступен → ``.delay()`` синхронно ждёт
+kombu-реконнект с растущим backoff (~69с) ДО того как try/except его проглотит —
+эта пауза оказалась внутри КАЖДОГО теста, который дергает ``POST /analyze`` и не
+мокал форсайт-таску. Авто-фикстура ниже глушит ``.delay`` в no-op-мок для ВСЕХ
+тестов каталога (как и с резолвером выше) — тесты самого enqueue
+(``test_parcels_forecast.py``, ``test_run_history_and_response_contract.py``)
+переопределяют тот же target своим per-test ``patch`` поверх авто-фикстуры.
 """
 
 from __future__ import annotations
 
 from collections.abc import Iterator
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -37,3 +47,34 @@ def _stub_zone_regulation_resolver() -> Iterator[None]:
     """
     with patch("app.api.v1.parcels.get_or_fetch_zone_regulation", return_value=None):
         yield
+
+
+@pytest.fixture(autouse=True)
+def _stub_forecast_enqueue() -> Iterator[None]:
+    """No-op форсайт-enqueue по умолчанию (без реального Celery/Redis round-trip).
+
+    ``.delay(...)`` в проде — fire-and-forget (best-effort, обёрнут в try/except в
+    ``analyze_parcel``), тестам сам форсайт не нужен, а живой брокер в CI/локальной
+    песочнице недоступен и держит запрос ~69с на реконнект-backoff.
+    """
+    with patch("app.workers.tasks.forecast.forecast_site_finder_report.delay", MagicMock()):
+        yield
+
+
+@pytest.fixture(autouse=True)
+def _fast_inline_fetch_wait(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Схлопнуть inline-ожидание NSPD-фетча (#93 graceful fallback) до миллисекунд.
+
+    В ``analyze_parcel`` ветка «участка нет в БД» ждёт появления геометрии циклом
+    ``sleep(_INLINE_FETCH_POLL_INTERVAL_S)`` до ``_INLINE_FETCH_WAIT_S`` (15с прод-
+    значение). В тестах фетч замокан и геометрия не появится никогда → каждый такой
+    тест честно спал 16с (``test_market_price_invalid_cad_returns_404``,
+    ``test_recent_permits_invalid_cad_no_regression``).
+
+    Оставляем цикл РАБОЧИМ (несколько итераций по 10мс), а не выключаем его нулём:
+    тесты, проверяющие сам fast-path «строка появилась на N-м опросе», продолжают
+    видеть опросы. Тесты с собственным ``patch`` того же имени (напр.
+    ``test_run_history_and_response_contract.py``) переопределяют это поверх.
+    """
+    monkeypatch.setattr("app.api.v1.parcels._INLINE_FETCH_WAIT_S", 0.05)
+    monkeypatch.setattr("app.api.v1.parcels._INLINE_FETCH_POLL_INTERVAL_S", 0.01)

backend/tests/ops/test_3443_caddy_reload_not_recreate.py

@@ -0,0 +1,463 @@
+"""Полный деплой не пересоздаёт Caddy без нужды (#3443).
+
+ЧТО СЛУЧИЛОСЬ. Каждый полный деплой ПТИЦЫ делал `up -d --force-recreate
+--no-deps caddy`, то есть сносил единственный процесс, слушающий 80/443.
+Замер 05.09 (#3274): 67 с `code=000` на ВСЕХ доменах хоста — gendsgn.ru,
+meraocenka.ru и зеркала. Не 502/503: принимающего процесса нет вовсе, поэтому
+заглушка окна деплоя бессильна по построению — её отдаёт тот же Caddy.
+
+ЧТО УСТАНОВЛЕНО. Безусловный флаг появился 17.05 (11e78d73) ради нового
+bind-маунта `./preview`, который «не появлялся в running container». Довод
+неверен: `docker compose up -d` БЕЗ `--force-recreate` пересоздаёт контейнер
+сам, как только меняется описание сервиса или образ (проверено на живом демоне
+docker 28.4). Единственное, чего compose не видит, — СОДЕРЖИМОЕ пофайлового
+bind-маунта: `git reset --hard` пишет новый инод, контейнер держит прежний, и
+`caddy reload` перечитывает старый текст. У Caddy так смонтированы Caddyfile и
+четыре сниппета; каталоги (caddy/sites, caddy/local, preview) этим не страдают.
+
+ЗАЧЕМ ЭТОТ ФАЙЛ. У правки нет отрицательного признака: вернуть `--force-recreate`
+«на всякий случай» — одна строка, все деплои останутся зелёными, а окно в минуту
+увидит только тот, кто в этот момент держал непрерывную пробу. Проверки ниже
+ИСПОЛНЯЮТ ops/caddy-apply.sh с подставным `docker` и смотрят на СОВЕРШЁННЫЕ
+действия (пересоздал / перезагрузил / не тронул), а не на текст скрипта.
+Отдельно проверяется проводка в deploy.yml — что оба пути деплоя зовут именно
+его.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import stat
+import subprocess
+from pathlib import Path
+
+import pytest
+import yaml
+
+# backend/tests/ops/<этот файл> → корень репозитория
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SCRIPT = REPO_ROOT / "ops" / "caddy-apply.sh"
+WORKFLOWS = REPO_ROOT / ".forgejo" / "workflows"
+DEPLOY = WORKFLOWS / "deploy.yml"
+
+CID = "caddy-cid-0001"
+
+# Маунты Caddy ровно как на проде (`docker inspect gendesign-caddy-1`, 12.09):
+# пять ПОФАЙЛОВЫХ bind-маунтов и три каталога. Тома (caddy_data и соседи) в
+# сверку не входят — их фильтрует `{{if eq .Type "bind"}}`.
+FILE_MOUNTS = {
+    "Caddyfile": "/etc/caddy/Caddyfile",
+    "caddy/users.caddy.snippet": "/etc/caddy/caddy/users.caddy.snippet",
+    "caddy/metrics-ui.caddy.snippet": "/etc/caddy/caddy/metrics-ui.caddy.snippet",
+    "caddy/metrics-ingest.caddy.snippet": "/etc/caddy/caddy/metrics-ingest.caddy.snippet",
+    "caddy/deploy-window.caddy.snippet": "/etc/caddy/caddy/deploy-window.caddy.snippet",
+}
+DIR_MOUNTS = {
+    "caddy/sites": "/etc/caddy/caddy/sites",
+    "caddy/local": "/etc/caddy/caddy/local",
+    "preview": "/srv/preview",
+}
+
+# Подставной `docker`. Пишет каждый вызов в $FAKE_LOG и отвечает по сценарию:
+#   run          — одноразовый `caddy validate`, код из $FAKE_VALIDATE_RC;
+#   inspect      — список маунтов из $FAKE_MOUNTS, код из $FAKE_INSPECT_RC;
+#   exec         — sha256sum ФАЙЛА, КОТОРЫЙ ВИДИТ КОНТЕЙНЕР ($FAKE_VIEW/<slug>);
+#   compose … ps — текущий id контейнера из $FAKE_CID_FILE;
+#   compose … up — при $FAKE_UP_RECREATES=1 подменяет id (compose пересоздал сам).
+FAKE_DOCKER = r"""#!/bin/bash
+printf '%s\n' "$*" >> "$FAKE_LOG"
+cmd="$1"; shift
+case "$cmd" in
+  run)     exit "${FAKE_VALIDATE_RC:-0}" ;;
+  inspect)
+      if [ "${FAKE_INSPECT_RC:-0}" != "0" ]; then
+        echo "Error: No such object" >&2
+        exit "$FAKE_INSPECT_RC"
+      fi
+      cat "$FAKE_MOUNTS"
+      ;;
+  exec)
+      dst="$3"
+      view="$FAKE_VIEW/$(printf '%s' "$dst" | tr '/' '_')"
+      [ -f "$view" ] || exit 1
+      sha256sum "$view"
+      ;;
+  compose)
+      case " $* " in
+        *" ps "*)              cat "$FAKE_CID_FILE" ;;
+        *--force-recreate*)    echo "recreated caddy (forced)" ;;
+        *" up "*)
+            if [ "${FAKE_UP_RECREATES:-0}" = "1" ]; then
+              printf 'caddy-cid-NEW\n' > "$FAKE_CID_FILE"
+              echo "Container gendesign-caddy-1  Started"
+            else
+              echo "Container gendesign-caddy-1  Running"
+            fi
+            ;;
+        *) echo "(compose $*)" ;;
+      esac
+      ;;
+esac
+exit 0
+"""
+
+# macOS несёт shasum вместо sha256sum; на раннере (ubuntu) и на проде утилита
+# настоящая. Шим ставится только при её отсутствии — иначе гейт не запускался бы
+# локально вовсе.
+SHA_SHIM = '#!/bin/sh\nexec shasum -a 256 "$@"\n'
+
+
+def _write_exec(path: Path, text: str) -> None:
+    path.write_text(text, encoding="utf-8")
+    path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+@pytest.fixture
+def prod_tree(tmp_path: Path) -> Path:
+    """Копия боевого дерева: скрипт + конфиги + «взгляд контейнера»."""
+    tree = tmp_path / "opt" / "gendesign"
+    (tree / "ops").mkdir(parents=True)
+    shutil.copy(SCRIPT, tree / "ops" / SCRIPT.name)
+    for rel in [*FILE_MOUNTS, "caddy/sites/apps.caddy", "caddy/local/.gitignore"]:
+        path = tree / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(f"# {rel} версия НОВАЯ\n", encoding="utf-8")
+    (tree / "preview").mkdir()
+
+    view = tmp_path / "view"
+    view.mkdir()
+    # По умолчанию контейнер видит ровно то же, что лежит на диске.
+    for rel, dst in FILE_MOUNTS.items():
+        (view / dst.replace("/", "_")).write_text(
+            (tree / rel).read_text(encoding="utf-8"), encoding="utf-8"
+        )
+
+    mounts = tmp_path / "mounts"
+    mounts.write_text(
+        "".join(f"{tree / rel}|{dst}\n" for rel, dst in {**FILE_MOUNTS, **DIR_MOUNTS}.items()),
+        encoding="utf-8",
+    )
+
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    _write_exec(bin_dir / "docker", FAKE_DOCKER)
+    if shutil.which("sha256sum") is None:
+        _write_exec(bin_dir / "sha256sum", SHA_SHIM)
+    (tmp_path / "cid").write_text(CID + "\n", encoding="utf-8")
+    (tmp_path / "log").write_text("", encoding="utf-8")
+    return tree
+
+
+def _run(tree: Path, **env_extra: str) -> tuple[int, str, list[str]]:
+    root = tree.parent.parent
+    env = {
+        "PATH": f"{root / 'bin'}:/usr/bin:/bin:/usr/sbin:/sbin",
+        "FAKE_LOG": str(root / "log"),
+        "FAKE_CID_FILE": str(root / "cid"),
+        "FAKE_MOUNTS": str(root / "mounts"),
+        "FAKE_VIEW": str(root / "view"),
+        **env_extra,
+    }
+    proc = subprocess.run(
+        ["sh", str(tree / "ops" / "caddy-apply.sh")],
+        cwd=str(tree),
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    calls = [c for c in (root / "log").read_text(encoding="utf-8").splitlines() if c]
+    return proc.returncode, proc.stdout + proc.stderr, calls
+
+
+def _stale(tree: Path, dst: str) -> None:
+    """Контейнер остался на старом иноде этого маунта."""
+    view = tree.parent.parent / "view" / dst.replace("/", "_")
+    view.write_text("# версия СТАРАЯ\n", encoding="utf-8")
+
+
+def _recreated(calls: list[str]) -> bool:
+    return any("--force-recreate" in c for c in calls)
+
+
+def _reloaded(calls: list[str]) -> bool:
+    return any("caddy reload" in c for c in calls)
+
+
+# ── Что скрипт делает на самом деле ──────────────────────────────────────────
+
+
+def test_nothing_changed_reloads_without_recreate(prod_tree: Path) -> None:
+    """Обычный полный деплой (конфиг прокси не трогали): reload, без окна."""
+    rc, out, calls = _run(prod_tree)
+    assert rc == 0, out
+    assert not _recreated(calls), (
+        f"Caddy пересоздан, хотя ничего не изменилось: {calls}. "
+        "Это и есть #3443: 67 с code=000 на всех доменах при каждом деплое."
+    )
+    assert _reloaded(calls), f"конфиг не применён вовсе: {calls}"
+
+
+def test_changed_file_mount_forces_recreate(prod_tree: Path) -> None:
+    """Caddyfile правлен: reload перечитал бы старый инод — нужен recreate."""
+    _stale(prod_tree, "/etc/caddy/Caddyfile")
+    rc, out, calls = _run(prod_tree)
+    assert rc == 0, out
+    assert _recreated(calls), (
+        f"пересоздания нет: {calls}. Пофайловый bind-маунт держит инод — правка "
+        "Caddyfile не доехала бы до контейнера, а деплой ушёл бы зелёным."
+    )
+    assert "/etc/caddy/Caddyfile" in out, f"решение не названо в логе:\n{out}"
+
+
+@pytest.mark.parametrize("dst", sorted(set(FILE_MOUNTS.values()) - {"/etc/caddy/Caddyfile"}))
+def test_changed_snippet_forces_recreate(prod_tree: Path, dst: str) -> None:
+    """Каждый из четырёх сниппетов — тот же класс, не только Caddyfile."""
+    _stale(prod_tree, dst)
+    _, _out, calls = _run(prod_tree)
+    assert _recreated(calls), f"{dst}: правка сниппета не доехала бы: {calls}"
+
+
+def test_directory_mount_change_does_not_recreate(prod_tree: Path) -> None:
+    """caddy/sites/apps.caddy — самый частый случай; каталог инод не держит.
+
+    Если сюда приползёт пересоздание «за компанию», окно недоступности вернётся
+    ровно на тех правках, ради которых заведён быстрый путь #2916.
+    """
+    (prod_tree / "caddy" / "sites" / "apps.caddy").write_text("# новый блок\n", encoding="utf-8")
+    rc, out, calls = _run(prod_tree)
+    assert rc == 0, out
+    assert not _recreated(calls), f"правка в КАТАЛОГЕ вызвала пересоздание: {calls}"
+    assert _reloaded(calls), f"правка в каталоге не применена: {calls}"
+
+
+def test_broken_config_touches_nothing(prod_tree: Path) -> None:
+    """Битый конфиг: ни up, ни reload, ни пересоздания — прокси не тронут.
+
+    Иначе опечатка в Caddyfile уводит контейнер в crash-loop и роняет все
+    домены сразу (ровно то, чем опасен `--force-recreate` вслепую).
+    """
+    rc, out, calls = _run(prod_tree, FAKE_VALIDATE_RC="1")
+    assert rc != 0, f"скрипт не упал на битом конфиге:\n{out}"
+    assert not _recreated(calls), f"битый конфиг поехал в пересоздание: {calls}"
+    assert not _reloaded(calls), f"битый конфиг поехал в reload: {calls}"
+    assert not any(" up " in f" {c} " for c in calls), f"был `up` при битом конфиге: {calls}"
+
+
+def test_compose_recreate_is_not_doubled(prod_tree: Path) -> None:
+    """compose пересоздал сам (сменилось описание сервиса/образ) — хватит.
+
+    Второй `--force-recreate` поверх — ещё одно окно недоступности на ровном
+    месте, а новый контейнер и так читает свежие файлы.
+    """
+    rc, out, calls = _run(prod_tree, FAKE_UP_RECREATES="1")
+    assert rc == 0, out
+    assert not _recreated(calls), f"пересоздание сделано дважды: {calls}"
+    assert not _reloaded(calls), f"reload поверх свежего контейнера: {calls}"
+
+
+def test_unreadable_container_view_falls_back_to_recreate(prod_tree: Path) -> None:
+    """Сверка не отработала (контейнер не отвечает) → прежнее поведение.
+
+    Fail-safe направлен в сторону пересоздания: лучше окно в секунды, чем
+    беззвучно не применённая правка конфига прокси.
+    """
+    (prod_tree.parent.parent / "view" / "_etc_caddy_Caddyfile").unlink()
+    _, out, calls = _run(prod_tree)
+    assert _recreated(calls), f"непрочитанный маунт сочли доехавшим: {calls}\n{out}"
+
+
+def test_unreadable_mount_list_falls_back_to_recreate(prod_tree: Path) -> None:
+    """`docker inspect` не ответил → пересоздать, а не «расхождений нет».
+
+    Статус `$(docker inspect … | while …)` — это статус `while`, то есть всегда
+    0, а `pipefail` в POSIX-sh не существует. Провал команды давал бы пустой
+    список маунтов, ветку «всё доехало» и зелёную строку «окна недоступности
+    нет» при прокси, работающем по СТАРОМУ конфигу — тот самый беззвучный отказ,
+    ради которого написан скрипт.
+    """
+    rc, out, calls = _run(prod_tree, FAKE_INSPECT_RC="1")
+    assert rc == 0, out
+    assert _recreated(calls), f"непрочитанный список маунтов сочли «всё доехало»: {calls}\n{out}"
+    assert not _reloaded(calls), f"reload вместо пересоздания: {calls}"
+
+
+def test_no_file_mounts_is_not_silence(prod_tree: Path) -> None:
+    """Ноль пофайловых маунтов — не «сверка прошла», а «сверять было нечем».
+
+    Так выглядит, например, перевод Caddyfile на именованный том: фильтр
+    `{{if eq .Type "bind"}}` перестаёт что-либо отбирать, и сверка становится
+    тавтологически успешной.
+    """
+    root = prod_tree.parent.parent
+    (root / "mounts").write_text(
+        "".join(f"{prod_tree / rel}|{dst}\n" for rel, dst in DIR_MOUNTS.items()), encoding="utf-8"
+    )
+    rc, out, calls = _run(prod_tree)
+    assert rc == 0, out
+    assert _recreated(calls), f"пустая сверка сочтена успешной: {calls}\n{out}"
+
+
+def test_missing_host_file_is_not_skipped_as_a_directory(prod_tree: Path) -> None:
+    """Файла на хосте нет — это расхождение, а не «нечего сверять».
+
+    Пропуск по `[ -f "$src" ] || continue` склеивает два разных случая: каталог
+    (пропустить верно — инод он не держит) и исчезнувший/нечитаемый файл, для
+    которого в контейнере как раз живёт старый инод со старым текстом. Файл
+    удаляется после проверки конфига (в тесте она подставная) — проверяется
+    именно ветка сверки.
+    """
+    (prod_tree / "Caddyfile").unlink()
+    _, out, calls = _run(prod_tree)
+    assert _recreated(calls), f"исчезнувший файл сочли доехавшим: {calls}\n{out}"
+
+
+def test_log_says_how_many_mounts_were_compared(prod_tree: Path) -> None:
+    """В логе должно быть ЧИСЛО сверенных файлов, а не только вердикт.
+
+    «Сверили пять» и «сверили ноль» обязаны различаться: иначе строка
+    «перезагружен без пересоздания» одинаково означает и проверку, и её
+    отсутствие.
+    """
+    _, out, _ = _run(prod_tree)
+    assert re.search(r"сверено пофайловых маунтов[^\n]*: 5", out), (
+        f"скрипт не печатает число сверенных маунтов (их пять):\n{out}"
+    )
+
+
+def test_validation_precedes_any_action(prod_tree: Path) -> None:
+    """Проверка конфига идёт ПЕРВЫМ вызовом, до любого изменения состояния."""
+    _, out, calls = _run(prod_tree)
+    assert calls, f"скрипт не сделал ни одного вызова docker:\n{out}"
+    assert calls[0].startswith("run "), f"первым идёт не проверка конфига: {calls}"
+    assert "caddy validate" in calls[0], f"первый вызов — не validate: {calls[0]}"
+
+
+# ── Проводка: оба пути деплоя зовут именно этот скрипт ───────────────────────
+
+
+def _ssh_script(job: str) -> str:
+    spec = yaml.safe_load(DEPLOY.read_text(encoding="utf-8"))
+    steps = [s for s in spec["jobs"][job]["steps"] if "ssh-action" in str(s.get("uses"))]
+    assert len(steps) == 1, f"в job `{job}` нет ровно одного ssh-шага — гейт #3443 ослеп"
+    script = steps[0]["with"]["script"]
+    assert script.strip(), f"ssh-скрипт job `{job}` пуст"
+    return script
+
+
+def _commands(script: str) -> str:
+    """Только команды: комментарии выкинуты, продолжения строк склеены.
+
+    Комментарии — потому что разбор дефекта живёт в тех же файлах и содержит
+    его формулировку дословно: гейт по голому тексту краснел бы от объяснения,
+    а не от кода. Склейка `\\` — потому что `--force-recreate` и имя сервиса
+    легко оказываются на РАЗНЫХ физических строках, и построчный поиск такую
+    запись не увидел бы (зелено по построению).
+    """
+    kept = [ln for ln in script.splitlines() if not ln.lstrip().startswith("#")]
+    return re.sub(r"\\\n\s*", " ", "\n".join(kept))
+
+
+def _forced_caddy_recreates(commands: str) -> list[str]:
+    """Строки, которые пересоздают именно сервис caddy."""
+    return [
+        ln
+        for ln in commands.splitlines()
+        if "--force-recreate" in ln and re.search(r"\bcaddy\b", ln)
+    ]
+
+
+def test_script_exists_and_is_the_one_under_test() -> None:
+    """Признак непустоты: без скрипта проверки выше проходили бы вхолостую."""
+    assert SCRIPT.is_file(), f"нет {SCRIPT} — проводка ниже проверяла бы пустоту"
+
+
+@pytest.mark.parametrize("job", ["deploy", "deploy-caddy"])
+def test_deploy_applies_caddy_config_through_the_script(job: str) -> None:
+    assert "ops/caddy-apply.sh" in _commands(_ssh_script(job)), (
+        f"job `{job}` не зовёт ops/caddy-apply.sh — конфиг прокси применяется "
+        "мимо разбора #3443 (или безусловным пересозданием, или reload'ом, "
+        "который на пофайловом маунте читает старый инод)"
+    )
+
+
+def test_full_deploy_has_no_unconditional_caddy_recreate() -> None:
+    """Главный инвариант: в полном деплое нет безусловного пересоздания Caddy.
+
+    Возврат одной строки `up -d --force-recreate --no-deps caddy` в job `deploy`
+    возвращает 67-секундное окно `code=000` на всех доменах — и не краснит
+    ничего: деплой остаётся зелёным, а увидеть отказ может только непрерывная
+    проба, запущенная ровно в эту минуту.
+    """
+    bad = _forced_caddy_recreates(_commands(_ssh_script("deploy")))
+    assert not bad, (
+        "в полный деплой вернулось безусловное пересоздание Caddy:\n  "
+        + "\n  ".join(bad)
+        + "\nПересоздание обязано быть УСЛОВНЫМ — см. ops/caddy-apply.sh: compose "
+        "сам пересоздаёт контейнер при смене описания сервиса или образа, а "
+        "вручную это нужно только когда до контейнера не доехал пофайловый "
+        "bind-маунт (#3443)."
+    )
+
+
+def test_failures_are_not_swallowed() -> None:
+    """Ни применение конфига, ни сам reload не гасятся `|| true`.
+
+    Строка `caddy reload … || true` в репозитории уже живёт
+    (deploy-tradein.yml), то есть это не гипотеза: с ней отказ применения
+    перестаёт краснеть, и «конфиг доехал» становится неотличимо от «команда
+    упала, а мы продолжили». Проверяется и вызов скрипта из обеих джоб, и
+    строка reload внутри самого скрипта.
+    """
+    swallow = re.compile(r"\|\|\s*(true|:)\s*$")
+    offenders = []
+    for where, text in [
+        ("deploy", _commands(_ssh_script("deploy"))),
+        ("deploy-caddy", _commands(_ssh_script("deploy-caddy"))),
+        (SCRIPT.name, SCRIPT.read_text(encoding="utf-8")),
+    ]:
+        for line in text.splitlines():
+            code = line.split("#", 1)[0] if not line.lstrip().startswith("#") else ""
+            if ("caddy-apply.sh" in code or "caddy reload" in code) and swallow.search(code):
+                offenders.append(f"{where}: {line.strip()}")
+    assert not offenders, "отказ применения конфига проглочен:\n  " + "\n  ".join(offenders)
+
+
+def test_gate_runs_on_changes_to_the_script_itself() -> None:
+    """CI-фильтр обязан пускать backend-тесты на правку ops/**.
+
+    Все содержательные регрессии живут в ops/caddy-apply.sh: проверки выше его
+    ИСПОЛНЯЮТ. Без `ops/**` в фильтре PR, правящий только скрипт, даёт
+    backend=false — джоба пропускается, гейт не исполняется, и «пересоздавать
+    всегда» уезжает в main зелёным. Тот же класс, что #2950/#3448/#3467.
+    """
+    spec = yaml.safe_load((WORKFLOWS / "ci.yml").read_text(encoding="utf-8"))
+    steps = [
+        s
+        for job in spec["jobs"].values()
+        for s in job.get("steps") or []
+        if str(s.get("uses", "")).startswith("dorny/paths-filter")
+    ]
+    assert steps, "в ci.yml не найден paths-filter — проверка прошла бы вхолостую"
+    patterns = [p for s in steps for p in yaml.safe_load(s["with"]["filters"]).get("backend") or []]
+    assert "ops/**" in patterns, (
+        f"фильтр backend не покрывает ops/** (сейчас: {patterns}) — гейт #3443 не "
+        "побежит на правке ops/caddy-apply.sh, то есть ровно на той правке, от "
+        "которой стережёт"
+    )
+
+
+def test_gate_would_notice_the_regression() -> None:
+    """Сам гейт обязан краснеть на возвращённом дефекте — проверка на себя.
+
+    Без этого «не нашли force-recreate» неотличимо от «искали не там»: маска
+    поиска, промахнувшаяся мимо строки, выглядит зелёной ровно так же.
+    """
+    regressed = _commands(
+        "            # безусловное пересоздание caddy вернулось сюда\n"
+        "            docker compose -p gendesign -f docker-compose.prod.yml up -d \\\n"
+        "              --force-recreate --no-deps caddy\n"
+    )
+    assert _forced_caddy_recreates(regressed), (
+        "маска поиска не видит дословно ту строку, ради которой заведён гейт"
+    )

backend/tests/ops/test_3448_caddy_only_detection.py

@@ -0,0 +1,438 @@
+"""Гейт: быстрый путь «правка только прокси» действительно включается (#3448).
+
+ЧТО СЛУЧИЛОСЬ. Быстрый путь #2916 (`caddy_only` → джоба `deploy-caddy` с
+`caddy reload` вместо пересоздания контейнеров) не отработал ни разу за всё
+время жизни. Проверено на мерже 84920e6c, где в диффе ровно один файл
+`caddy/sites/apps.caddy`: контейнеры пересозданы, в логе Caddy
+`serving initial configuration` — холодный старт, а не reload.
+
+ПРИЧИНА — НЕ пустой `github.event.before` (рабочая гипотеза #3448 опровергнута
+логом задачи 29244: `before` = 204e2e09…, `git diff` вернул ровно один файл).
+Причина в том, что dorny/paths-filter склеивает шаблоны одного фильтра через
+`some`, то есть ИЛИ (src/filter.ts: `patterns.some(aPredicate)`; параметр
+`predicate-quantifier` по умолчанию `some`). Список
+
+    non_caddy: ['**', '!Caddyfile', '!caddy/**']
+
+значит «подходит под `**` ИЛИ не Caddyfile ИЛИ не caddy/**», а `**` матчит всё —
+non_caddy был true ВСЕГДА. В логе это видно дословно:
+
+    ##[group]Filter non_caddy = true
+    Matching files:
+    caddy/sites/apps.caddy [modified]
+
+исключённый файл сам себя и «исключил».
+
+ЗАЧЕМ ЭТОТ ФАЙЛ. У самой правки нет отрицательного признака: пропущенную джобу
+Forgejo рисует зелёной, поэтому «зелёный deploy-caddy» одинаково выглядит и
+когда быстрый путь сработал, и когда его вообще не было. Проверки ниже
+ИСПОЛНЯЮТ шаг определения файлов из deploy.yml на настоящем временном
+репозитории (включая мерж-коммит — ровно случай #3448) и смотрят на значения
+флагов, а не на текст воркфлоу. Так же исполняется и прод-сторож из джобы
+`deploy-caddy`: быстрый путь пропускает джобу `deploy` целиком, а вместе с ней
+и гард свежести :latest (#2950), поэтому перезагружать прокси можно, только
+если прод отстаёт РОВНО на конфиг прокси. Регресс к исключающим шаблонам
+paths-filter ловит отдельная проверка в конце.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+import pytest
+import yaml
+
+# backend/tests/ops/<этот файл> → корень репозитория
+REPO_ROOT = Path(__file__).resolve().parents[3]
+WORKFLOWS = REPO_ROOT / ".forgejo" / "workflows"
+DEPLOY = WORKFLOWS / "deploy.yml"
+
+NULL_SHA = "0" * 40
+
+# Файлы, которые лежат в тестовом репозитории до правки. Набор подобран так,
+# чтобы фолбэк «база не определена» мог отличить полный деплой от пустого.
+BASE_FILES = (
+    "caddy/sites/apps.caddy",
+    "Caddyfile",
+    "backend/app/main.py",
+    "frontend/src/page.tsx",
+    "data/sql/001.sql",
+    "docker-compose.prod.yml",
+    "README.md",
+)
+
+GIT_ENV = {
+    "GIT_AUTHOR_NAME": "t",
+    "GIT_AUTHOR_EMAIL": "t@example.com",
+    "GIT_COMMITTER_NAME": "t",
+    "GIT_COMMITTER_EMAIL": "t@example.com",
+    "GIT_CONFIG_GLOBAL": "/dev/null",
+    "GIT_CONFIG_SYSTEM": "/dev/null",
+}
+
+
+def _detect_script() -> str:
+    """Тело шага, который считает изменённые файлы в job `changes`."""
+    spec = yaml.safe_load(DEPLOY.read_text(encoding="utf-8"))
+    job = spec["jobs"]["changes"]
+    steps = [s for s in job["steps"] if s.get("id") == "filter"]
+    assert len(steps) == 1, (
+        "в job `changes` нет ровно одного шага с `id: filter` — определение "
+        "изменённых файлов переехало, гейт #3448 ослеп"
+    )
+    step = steps[0]
+    assert "run" in step, (
+        f"шаг `filter` не считает файлы сам, а делегирует их {step.get('uses')!r}. "
+        "Именно так и возник #3448: у dorny/paths-filter шаблоны одного фильтра "
+        "склеиваются через ИЛИ, поэтому `non_caddy: ['**', '!caddy/**']` был true "
+        "ВСЕГДА и быстрый путь не включался ни разу."
+    )
+    assert step["run"].strip(), "шаг `filter` пуст"
+    return step["run"]
+
+
+def _git(repo: Path, *args: str) -> None:
+    subprocess.run(
+        ["git", "-C", str(repo), *args], check=True, env=dict(GIT_ENV), capture_output=True
+    )
+
+
+def _sha(repo: Path) -> str:
+    return subprocess.run(
+        ["git", "-C", str(repo), "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=dict(GIT_ENV),
+    ).stdout.strip()
+
+
+def _commit(repo: Path, files: tuple[str, ...], msg: str = "c") -> None:
+    for name in files:
+        path = repo / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("changed\n", encoding="utf-8")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", msg, *([] if files else ["--allow-empty"]))
+
+
+def _base_repo(tmp_path: Path) -> tuple[Path, str]:
+    """Репозиторий с одним базовым коммитом; возвращает его sha — это `before`."""
+    repo = tmp_path / "repo"
+    repo.mkdir(parents=True)
+    _git(repo, "init", "-q", "-b", "main")
+    for name in BASE_FILES:
+        path = repo / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("base\n", encoding="utf-8")
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", "base")
+    return repo, _sha(repo)
+
+
+def _merge_commit(repo: Path, changed: tuple[str, ...]) -> None:
+    """Ветка с правкой и мерж `--no-ff` обратно в main.
+
+    Мерж, а не обычный коммит, — потому что #3448 наблюдался именно на мерже
+    PR'а: у мерж-коммита две родительские линии, и любой разбор диффа обязан
+    работать на этой форме. Что `before` нельзя заменить на `HEAD^`, стережёт
+    отдельная проверка — test_multi_commit_push_is_not_truncated: на ОДНОМ
+    мерж-коммите `HEAD^..HEAD` даёт верный ответ и такую подмену не ловит.
+    """
+    _git(repo, "checkout", "-q", "-b", "feature")
+    _commit(repo, changed, "feature")
+    _git(repo, "checkout", "-q", "main")
+    _git(repo, "merge", "-q", "--no-ff", "-m", "merge feature", "feature")
+
+
+def _exec(repo: Path, before: str, event: str = "push") -> tuple[dict[str, str], str]:
+    out_file = repo.parent / "outputs"
+    out_file.touch()
+    env = {
+        "PATH": "/usr/bin:/bin:/usr/local/bin",
+        "BEFORE": before,
+        "EVENT": event,
+        "GITHUB_OUTPUT": str(out_file),
+        **GIT_ENV,
+    }
+    proc = subprocess.run(
+        ["bash", "-c", _detect_script()],
+        cwd=repo,
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    assert proc.returncode == 0, f"шаг упал:\n{proc.stdout}\n{proc.stderr}"
+    outputs = dict(
+        line.split("=", 1)
+        for line in out_file.read_text(encoding="utf-8").splitlines()
+        if "=" in line
+    )
+    return outputs, proc.stdout
+
+
+def _run(
+    tmp_path: Path, changed: tuple[str, ...], *, before: str | None = None, event: str = "push"
+) -> tuple[dict[str, str], str]:
+    repo, base_sha = _base_repo(tmp_path)
+    _merge_commit(repo, changed)
+    return _exec(repo, base_sha if before is None else before, event)
+
+
+def test_merge_with_only_caddy_file_takes_the_fast_path(tmp_path: Path) -> None:
+    """Случай #3448 дословно: мерж, в диффе один файл под caddy/."""
+    outputs, _ = _run(tmp_path, ("caddy/sites/apps.caddy",))
+    assert outputs["caddy_only"] == "true", (
+        f"быстрый путь не включился на правке ТОЛЬКО прокси: {outputs}. "
+        "Ровно это и есть #3448: deploy-caddy пропускается, идёт полный деплой "
+        "с пересозданием контейнеров, а Forgejo рисует пропуск зелёным."
+    )
+    assert outputs["backend"] == "false"
+    assert outputs["frontend"] == "false"
+
+
+def test_caddy_plus_backend_is_a_full_deploy(tmp_path: Path) -> None:
+    """Обратное направление: быстрый путь НЕ должен красть обычный деплой."""
+    outputs, _ = _run(tmp_path, ("caddy/sites/apps.caddy", "backend/app/main.py"))
+    assert outputs["caddy_only"] == "false", (
+        f"быстрый путь включился, хотя вместе с конфигом приехал бэкенд: {outputs}. "
+        "Так прод остался бы на старом образе при зелёном деплое."
+    )
+    assert outputs["backend"] == "true"
+
+
+def test_missing_base_falls_back_to_full_deploy(tmp_path: Path) -> None:
+    """База не разрешилась → полный деплой, а не пустой список.
+
+    Пустой список изменений — это `caddy_only` без единого caddy-файла и
+    отключённая сборка: отказ, который выглядит как успешный быстрый путь.
+    """
+    for before, event in ((NULL_SHA, "push"), ("", "push"), (None, "workflow_dispatch")):
+        outputs, log = _run(
+            tmp_path / f"case-{event}-{before!r}",
+            ("caddy/sites/apps.caddy",),
+            before=before,
+            event=event,
+        )
+        assert outputs["caddy_only"] == "false", f"before={before!r} event={event}: {outputs}"
+        assert outputs["backend"] == "true", f"before={before!r} event={event}: {outputs}"
+        assert outputs["frontend"] == "true", f"before={before!r} event={event}: {outputs}"
+        assert outputs["infra"] == "true", f"before={before!r} event={event}: {outputs}"
+        assert "деплой полный" in log
+
+
+def test_decision_is_visible_in_the_log(tmp_path: Path) -> None:
+    """Решение печатается: и список файлов, и итоговые флаги.
+
+    Без этого «сработало» и «просто не совпало» неотличимы — единственным
+    свидетелем остаётся метка Created у контейнера на проде.
+    """
+    _, log = _run(tmp_path, ("caddy/sites/apps.caddy",))
+    assert "caddy/sites/apps.caddy" in log, f"шаг не печатает список файлов:\n{log}"
+    assert "caddy_only=true" in log and "backend=false" in log, (
+        f"шаг не печатает итоговые флаги:\n{log}"
+    )
+
+
+# ── Быстрый путь на самом проде: джоба deploy-caddy ──────────────────────────
+#
+# Пока caddy_only был мёртв, каждый push шёл полным деплоем, и гард свежести
+# :latest (#2950, job `deploy`) прикрывал прод по умолчанию. Оживший быстрый
+# путь его обходит: при caddy_only=true джоба `deploy` пропускается целиком.
+# Дифф between-push (before→HEAD) не знает, что реально доехало до прода:
+# отменённая очередью `deploy` предыдущего прогона оставляет прод на старом
+# образе, а следующий caddy-only push честно видит «изменился один caddy-файл».
+
+
+def _caddy_deploy_script() -> str:
+    spec = yaml.safe_load(DEPLOY.read_text(encoding="utf-8"))
+    steps = [s for s in spec["jobs"]["deploy-caddy"]["steps"] if "ssh-action" in str(s.get("uses"))]
+    assert len(steps) == 1, "в deploy-caddy нет ровно одного ssh-шага — гейт #3448 ослеп"
+    return steps[0]["with"]["script"]
+
+
+def _prod_lag_guard() -> str:
+    """Кусок ssh-скрипта от вычисления PROD_HEAD до `git reset --hard`."""
+    script = _caddy_deploy_script()
+    assert "PROD_HEAD=" in script, (
+        "джоба deploy-caddy не сверяет отставание прода: быстрый путь перезагрузит "
+        "прокси и уйдёт зелёным, оставив прод на старом образе (#3448)"
+    )
+    # Ищем КОМАНДУ, а не подстроку: `git reset --hard` упоминается выше в
+    # комментариях, и поиск по тексту нашёл бы объяснение вместо кода.
+    reset_cmd = re.search(r"(?m)^\s*git reset --hard", script)
+    assert reset_cmd, "в deploy-caddy пропал `git reset --hard` — гейт опирается на него"
+    start, reset = script.index("PROD_HEAD="), reset_cmd.start()
+    assert start < reset, (
+        "проверка отставания прода стоит ПОСЛЕ `git reset --hard` — при отказе "
+        "прод-HEAD уже переписан, и следующий прогон снова уйдёт быстрым путём"
+    )
+    return "set -euo pipefail\n" + script[start:reset]
+
+
+def _prod_repo(tmp_path: Path, ahead: tuple[str, ...]) -> Path:
+    """Прод-дерево на базовом коммите, origin/main — на `ahead` впереди."""
+    repo, base_sha = _base_repo(tmp_path)
+    _commit(repo, ahead, "ahead")
+    _git(repo, "update-ref", "refs/remotes/origin/main", "HEAD")
+    _git(repo, "reset", "--hard", "-q", base_sha)
+    return repo
+
+
+def _run_guard(repo: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["bash", "-c", _prod_lag_guard()],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+        env={"PATH": "/usr/bin:/bin:/usr/local/bin", **GIT_ENV},
+    )
+
+
+def test_fast_path_allowed_when_prod_lags_only_by_proxy_config(tmp_path: Path) -> None:
+    proc = _run_guard(_prod_repo(tmp_path, ("caddy/sites/apps.caddy",)))
+    assert proc.returncode == 0, f"законный быстрый путь заблокирован:\n{proc.stdout}{proc.stderr}"
+
+
+def test_fast_path_refuses_when_prod_lags_by_code(tmp_path: Path) -> None:
+    """Прод отстаёт не только по конфигу прокси → перезагрузка прокси запрещена."""
+    proc = _run_guard(_prod_repo(tmp_path, ("backend/app/main.py", "caddy/sites/apps.caddy")))
+    assert proc.returncode != 0, (
+        "быстрый путь разрешён, хотя прод отстаёт по коду бэкенда: перезагрузка "
+        f"прокси подменила бы выкатку, деплой ушёл бы зелёным.\n{proc.stdout}"
+    )
+    assert "backend/app/main.py" in proc.stdout, (
+        f"отказ не называет файлы, из-за которых он произошёл:\n{proc.stdout}"
+    )
+
+
+def test_fast_path_takes_the_same_host_lock() -> None:
+    """deploy-caddy правит прод-дерево — значит берёт тот же лок, что `deploy`.
+
+    Проверка текстовая, как в test_2950: исполнить flock-секцию в тесте нельзя,
+    а её пропажа не даёт ни одного сигнала до совпадения окон двух деплоев.
+    """
+    script = _caddy_deploy_script()
+    assert "exec 9>/var/lock/gendesign-docker-deploy.lock" in script, (
+        "deploy-caddy делает `git reset --hard` в /opt/gendesign в обход лока, "
+        "которым полный деплой сериализует работу с прод-деревом (#2950)"
+    )
+    assert "flock -w 900 9" in script, "лок открывается, но не захватывается"
+
+
+@pytest.mark.parametrize(
+    "changed", [("caddy-extra/x.txt",), ("Caddyfile.bak",), ("docs/caddy.md",)]
+)
+def test_paths_that_merely_start_with_caddy_are_not_the_fast_path(
+    tmp_path: Path, changed: tuple[str, ...]
+) -> None:
+    """`caddy-extra/…` и `Caddyfile.bak` — НЕ конфиг прокси.
+
+    Граница шаблона — единственное, что отделяет быстрый путь от тихого
+    пропуска полного деплоя: `^(Caddyfile|caddy)` вместо `^(Caddyfile$|caddy/)`
+    отправил бы эти правки перезагружать прокси вместо выкатки.
+    """
+    outputs, _ = _run(tmp_path, changed)
+    assert outputs["caddy_only"] == "false", f"{changed}: {outputs}"
+
+
+def test_empty_diff_is_not_the_fast_path(tmp_path: Path) -> None:
+    """Пустой дифф (`before` == HEAD, пустой мерж) — не «всё под caddy».
+
+    Без проверки «файлов больше нуля» пустой список формально удовлетворяет
+    «ни один файл не лежит вне caddy»: сборка отключается, деплой подменяется
+    перезагрузкой прокси — отказ, выглядящий как успешный быстрый путь.
+    """
+    outputs, log = _run(tmp_path, ())
+    assert outputs["caddy_only"] == "false", f"пустой дифф ушёл в быстрый путь: {outputs}"
+    assert "изменённых файлов: 0" in log
+
+
+def test_data_sql_counts_as_backend(tmp_path: Path) -> None:
+    """`data/sql/**` собирает backend-образ: миграции едут в нём."""
+    outputs, _ = _run(tmp_path, ("data/sql/002.sql",))
+    assert outputs["backend"] == "true", outputs
+    assert outputs["caddy_only"] == "false", outputs
+
+
+def test_non_ascii_path_is_classified(tmp_path: Path) -> None:
+    """Кириллица в пути не должна прятать файл от классификации.
+
+    `git diff --name-only` при `core.quotePath=true` (умолчание) отдаёт
+    не-ASCII пути закавыченными и с \\NNN-экранированием — `^backend/`
+    такую строку не матчит. Старый paths-filter брал `--name-status -z`, где
+    квотирования нет; при переходе на свой diff это единственное место, где
+    поведение могло разойтись. В дереве такие пути уже живут (docs/).
+    """
+    outputs, log = _run(tmp_path, ("backend/модуль.py",))
+    assert outputs["backend"] == "true", f"кириллический путь потерян: {outputs}\n{log}"
+
+
+def test_multi_commit_push_is_not_truncated(tmp_path: Path) -> None:
+    """Push из нескольких коммитов разбирается целиком, а не по последнему.
+
+    Ровно та подмена, которую соблазнительно сделать «чтобы не зависеть от
+    before»: `HEAD^..HEAD`. На одном мерж-коммите она даёт верный ответ и
+    выглядит рабочей, а здесь — молча теряет бэкенд из первого коммита и
+    включает быстрый путь, то есть пропускает выкатку кода.
+    """
+    repo, base_sha = _base_repo(tmp_path)
+    _commit(repo, ("backend/app/main.py",), "backend")
+    _commit(repo, ("caddy/sites/apps.caddy",), "caddy")
+    outputs, log = _exec(repo, base_sha)
+    assert outputs["backend"] == "true", f"первый коммит push'а потерян: {outputs}\n{log}"
+    assert outputs["caddy_only"] == "false", outputs
+
+
+def _paths_filter_steps() -> list[tuple[Path, str, dict]]:
+    """Все шаги dorny/paths-filter во всех воркфлоу (включая .yaml)."""
+    found = []
+    for path in sorted(WORKFLOWS.glob("*.y*ml")):
+        spec = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        for job_name, job in (spec.get("jobs") or {}).items():
+            for step in job.get("steps") or []:
+                if str(step.get("uses", "")).startswith("dorny/paths-filter"):
+                    found.append((path, job_name, step))
+    return found
+
+
+def test_exclusion_gate_has_something_to_check() -> None:
+    """Признак непустоты: проверка ниже обязана что-то находить.
+
+    Переименуют действие, разнесут воркфлоу по .yaml, уедут шаги — и гейт
+    пройдёт при нулевом охвате, молча (ровно то, от чего страхуется ci.yml:190).
+    """
+    steps = _paths_filter_steps()
+    assert steps, (
+        "не найдено ни одного шага dorny/paths-filter — проверка исключающих "
+        "шаблонов прошла бы впустую, перепроверь маску поиска"
+    )
+
+
+@pytest.mark.parametrize(
+    "path,job_name,step",
+    _paths_filter_steps(),
+    ids=[f"{p.name}:{j}" for p, j, _ in _paths_filter_steps()],
+)
+def test_no_paths_filter_relies_on_exclusion_patterns(
+    path: Path, job_name: str, step: dict
+) -> None:
+    """Ни один paths-filter в репозитории не вычитает пути через `!`.
+
+    Класс бага, а не единственный его случай: при `predicate-quantifier: some`
+    (умолчание) шаблоны фильтра склеиваются через ИЛИ, и `!` ничего не вычитает.
+    """
+    with_ = step.get("with") or {}
+    if with_.get("predicate-quantifier") == "every":
+        pytest.skip("predicate-quantifier: every — шаблоны склеиваются через И")
+    filters = yaml.safe_load(with_.get("filters") or "") or {}
+    assert filters, f"{path.name}: job {job_name} — у paths-filter пустой блок filters"
+    for filter_name, patterns in filters.items():
+        bad = [p for p in (patterns or []) if isinstance(p, str) and p.startswith("!")]
+        assert not bad, (
+            f"{path.name}: job {job_name}, фильтр {filter_name!r} вычитает пути "
+            f"шаблонами {bad} — при `some` (умолчание) они склеиваются через ИЛИ "
+            "и фильтр становится true ВСЕГДА. Так #2916 не сработал ни разу (#3448)."
+        )

backend/tests/ops/test_3467_prometheus_reload.py

@@ -1,213 +1,112 @@
-"""Деплой метрик обязан не только положить конфигурацию на диск, но и применить её.
+"""Правки Prometheus-конфига/правил обязаны доезжать до работающего процесса.
 
-ЧТО СЛУЧИЛОСЬ НА ПРОДЕ 12.09 (#3467). #3464 поправил два правила в
-`ops/metrics/prometheus/rules/infra.yml`, «Deploy Metrics / server» на этом
-коммите — success, новый текст лежал и на диске инфраструктурного хоста, и
-ВНУТРИ контейнера:
+ЧТО СЛУЧИЛОСЬ НА ПРОДЕ. `GET /api/v1/status/runtimeinfo` внутри
+`gendesign-prometheus` 12.09 отдавал `lastConfigTime`, совпадающий со
+`startTime` контейнера, — конфиг и правила не перечитывались 16 суток.
+Деплой при этом был зелёный: `docker compose up -d` не пересоздаёт
+контейнер из-за изменения содержимого бинд-маунта (он сравнивает только
+описание сервиса), а `--web.enable-lifecycle` был включён в
+docker-compose.metrics.yml, но эндпоинт `/-/reload` никто не вызывал.
 
-    docker exec gendesign-prometheus grep -n container_memory_working_set_bytes \
-        /etc/prometheus/rules/infra.yml        → строка 139, новая формулировка
+Тот же класс бага, что уже пойман и починен для Caddy (`caddy reload`)
+и для Alertmanager (`--force-recreate`, см. test_3xxx_alertmanager_inode.py)
+в этом же workflow — только для Prometheus починка не пересоздание
+контейнера, а именно `POST /-/reload`: он переоткрывает файлы конфига по
+пути заново, так что новый инод после `git reset --hard` подхватывается
+без даунтайма.
 
-а API отдавал прежнее правило:
-
-    GET /api/v1/rules → ContainerNearMemoryLimit:
-        container_spec_memory_limit_bytes{name!=""} > 0 and ...
-
-ПОЧЕМУ. Правила подключены КАТАЛОГОМ, поэтому новый текст контейнер видит сразу,
-но Prometheus читает правила только при старте или по явной перезагрузке.
-Контейнер не перезапускался с 2026-08-27T18:12:24Z (16 суток), а деплой
-перезагружал один Caddy. То есть ЛЮБАЯ правка ops/metrics/prometheus/** с
-момента появления стека доезжала до диска и не вступала в силу до случайного
-пересоздания контейнера — при зелёном деплое и без единого отрицательного
-признака. Тот же класс, что #3448: объявлено ≠ исполняется.
-
-ЧТО ПРОВЕРЕНО НА СТЕНДЕ, а не взято из документации (prom/prometheus:v3.1.0,
-те же файлы, что на проде):
-
-    правило переписано на диске, контейнер не тронут → API отдаёт СТАРОЕ
-    promtool check config && check rules → rc=0, затем POST /-/reload → rc=0
-    после reload                                     → API отдаёт НОВОЕ
-    битое правило   → проверка rc=1 (reload не делается)
-    пустой каталог правил → `check config` ПРОХОДИТ («0 rule files found»),
-                            падает только `check rules` — потому в деплое стоят
-                            обе команды, а не одна
-
-Тест сторожит связку целиком: правки правил приезжают этим воркфлоу (триггер),
-перезагрузка в нём есть, она стоит ПОСЛЕ проверки конфигурации, а провалившаяся
-проверка обрывает деплой и не доходит до перезагрузки. Отдельно проверяется, что
-у каждого одиночного файлового маунта есть путь доезда: такой маунт держит инод,
-и перезагрузка по API его не лечит (см. test_3xxx_alertmanager_inode.py).
+Проверяется здесь: (1) валидация promtool ЕСТЬ, (2) reload вызывается
+ТОЛЬКО после успешной валидации, (3) шаг обязан упасть, если reload не
+подтверждён сменой lastConfigTime.
 """
 
 from __future__ import annotations
 
-import re
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[3]
 WORKFLOW = REPO_ROOT / ".forgejo" / "workflows" / "deploy-metrics.yml"
-COMPOSE = REPO_ROOT / "docker-compose.metrics.yml"
-
-# Перезагрузка Prometheus: POST на ручку lifecycle из работающего контейнера.
-#
-# Хвост строки смотрим НАРОЧНО: `|| true` после команды глушит её отказ, и шаг
-# остаётся зелёным с неперечитанной конфигурацией — то есть ровно тот разрыв,
-# который тут и чинится, только теперь ещё и с «зелёной сводкой». Ревьюер
-# #3475 этой мутацией прошёл гейт насквозь.
-RELOAD = re.compile(
-    r"docker exec gendesign-prometheus wget[^\n]*--post-data[^\n]*"
-    r"http://localhost:9090/-/reload(?![^\n]*\|\|)"
-)
-# Проверка конфигурации: обе команды promtool по файлам с диска.
-CHECK = re.compile(
-    r"promtool check config \S*prometheus\.yml"
-    r" && promtool check rules \S*rules/\*\.yml"
-)
-# Ветка «проверка не прошла» — от `if ! ... promtool ...` до её `fi`.
-CHECK_FAILED_BRANCH = re.compile(r"if ! docker run[^\n]*promtool[^\n]*; then(.+?)\n\s*fi\n", re.S)
-# Одиночный файловый маунт в серверном стеке: ./ops/metrics/... : /путь/в/контейнере.
-# Суффикс прав (`:ro`) НЕ требуется: инод маунт держит одинаково что на чтение,
-# что на запись, а требование `:ro` делало гейт слепым к маунту без него.
-MOUNT = re.compile(r"-\s+\./(ops/metrics/[^\s:]+):(/[^\s:]+)")
 
 
-def _server_script() -> str:
-    """Скрипт серверной джобы с ЗАКЛЕЕННЫМИ переносами строк.
+def _text() -> str:
+    return WORKFLOW.read_text(encoding="utf-8")
 
-    Команды в воркфлоу разбиты `\\` по ширине, и без склейки любой поиск
-    «команда целиком» ловил бы только первую строку.
+
+def test_promtool_checks_config_and_rules() -> None:
+    """promtool обязан проверять и конфиг, и правила — не только один файл."""
+    text = _text()
+    assert "promtool check config /etc/prometheus/prometheus.yml" in text, (
+        "нет проверки конфига promtool'ом — битый prometheus.yml долетит до reload"
+    )
+    assert "promtool check rules" in text, (
+        "нет проверки правил promtool'ом — битое правило долетит до reload"
+    )
+
+
+def test_reload_endpoint_is_called() -> None:
+    """Сам reload обязан вызываться — иначе валидация ничего не решает."""
+    text = _text()
+    assert "localhost:9090/-/reload" in text, (
+        "нет вызова POST /-/reload — конфиг/правила проверяются, но в силу не вступают "
+        "(#3467: lastConfigTime не менялся 16 суток при зелёном деплое)"
+    )
+
+
+def test_reload_happens_after_validation_not_before() -> None:
+    """Reload обязан идти ПОСЛЕ promtool, а не до/вместо него."""
+    text = _text()
+    check_pos = text.index("promtool check config /etc/prometheus/prometheus.yml")
+    reload_pos = text.index("localhost:9090/-/reload")
+    assert check_pos < reload_pos, (
+        "reload стоит раньше проверки конфига — битый конфиг мог бы применяться вслепую"
+    )
+
+
+def test_reload_is_guarded_by_the_promtool_check() -> None:
+    """Reload обязан быть ВНУТРИ `if promtool ...; then`, а не безусловным."""
+    text = _text()
+    guard_start = text.index("if docker exec gendesign-prometheus promtool check config")
+    else_pos = text.index("else", guard_start)
+    reload_pos = text.index("localhost:9090/-/reload")
+    assert guard_start < reload_pos < else_pos, (
+        "вызов reload лежит вне ветки успешной проверки promtool — "
+        "битый конфиг всё равно приведёт к reload, либо reload вообще не защищён проверкой"
+    )
+
+
+def test_failed_validation_skips_reload_and_fails_the_step() -> None:
+    """При провале promtool — reload НЕ вызывается, и шаг падает (exit 1)."""
+    text = _text()
+    guard_start = text.index("if docker exec gendesign-prometheus promtool check config")
+    else_pos = text.index("else", guard_start)
+    fi_pos = text.index("fi", else_pos)
+    else_branch = text[else_pos:fi_pos]
+    assert "localhost:9090/-/reload" not in else_branch, (
+        "reload вызывается даже в ветке провалившейся проверки"
+    )
+    assert "exit 1" in else_branch, (
+        "провал promtool не роняет шаг — деплой останется зелёным при битом конфиге"
+    )
+
+
+def test_acceptance_checks_last_config_time_actually_changed() -> None:
+    """Приёмка обязана сверять `lastConfigTime` до/после, а не доверять коду ответа reload.
+
+    `wget` на POST /-/reload может отрапортовать успех, даже если Prometheus
+    молча остался на старом конфиге (например, если бинарь внутри образа не
+    поддерживает --post-data так, как ожидалось) — единственное надёжное
+    подтверждение реального перечитывания конфига это смена таймстемпа.
     """
-    text = WORKFLOW.read_text(encoding="utf-8")
-    start = text.find("Поднять серверный стек")
-    end = text.find("# ═══ АГЕНТЫ")
-    assert start != -1 and end != -1, (
-        "в deploy-metrics.yml не найдены границы серверной джобы: шаг «Поднять "
-        "серверный стек» или заголовок «АГЕНТЫ» переименовали — гейт смотрел бы "
-        "не туда, поправь якоря здесь"
+    text = _text()
+    assert text.count("lastConfigTime") >= 2, (
+        "нет сравнения lastConfigTime до/после — reload не проверяется по факту"
     )
-    return re.sub(r"\s*\\\n\s*", " ", text[start:end])
-
-
-def test_rules_are_delivered_by_this_workflow() -> None:
-    """Правки правил приезжают на хост именно этим деплоем.
-
-    Без этого остальные проверки сторожили бы механизм, который никто не
-    запускает: «объявлено» и «исполняется» разошлись бы уже на триггере.
-    """
-    text = WORKFLOW.read_text(encoding="utf-8")
-    start, end = text.find("paths:"), text.find("workflow_dispatch")
-    assert start != -1 and end != -1, "в deploy-metrics.yml не найден блок триггеров paths:"
-    assert '"ops/metrics/**"' in text[start:end], (
-        "деплой не запускается на правку ops/metrics/** — правила меняются мимо него"
+    assert "LAST_CONFIG_BEFORE" in text and "LAST_CONFIG_AFTER" in text, (
+        "нет явного до/после сравнения таймстемпа последней перезагрузки конфига"
     )
-
-
-def test_deploy_reloads_prometheus() -> None:
-    """Перезагрузка Prometheus в деплое есть.
-
-    Её отсутствие и есть #3467: конфигурация на диске новая, работающий процесс
-    на старой, деплой зелёный.
-    """
-    assert RELOAD.search(_server_script()), (
-        "в серверной джобе нет POST /-/reload для Prometheus — правки правил "
-        "лягут на диск и не вступят в силу, как это и было с #3464"
-    )
-
-
-def test_reload_comes_after_config_check() -> None:
-    """Перезагрузка — только после проверки конфигурации, как у Caddy.
-
-    Порядок здесь несущий: перезагрузка битого конфига оставляет Prometheus на
-    прежнем — то есть ровно тот же тихий отказ, который чинится.
-    """
-    script = _server_script()
-    check = CHECK.search(script)
-    reload_ = RELOAD.search(script)
-    assert check, "в деплое нет проверки promtool (check config + check rules)"
-    assert reload_, "в деплое нет перезагрузки Prometheus"
-    assert check.start() < reload_.start(), (
-        "перезагрузка стоит РАНЬШЕ проверки конфигурации — битый конфиг молча "
-        "оставит Prometheus на старой конфигурации при зелёном деплое"
-    )
-
-
-def test_config_check_precedes_any_application() -> None:
-    """Проверка стоит ВЫШЕ `up -d`, а не между подъёмом и перезагрузкой.
-
-    `up -d` пересоздаёт контейнер при смене образа: проверка ниже него не
-    успевает спасти — битый конфиг уже применён стартом нового контейнера, и
-    Prometheus не поднимется вовсе.
-    """
-    script = _server_script()
-    check = CHECK.search(script)
-    assert check, "в деплое нет проверки promtool (check config + check rules)"
-    assert check.start() < script.index("up -d --remove-orphans"), (
-        "проверка конфигурации стоит после `up -d` — контейнер успеет "
-        "пересоздаться с битым конфигом раньше, чем деплой покраснеет"
-    )
-
-
-def test_failed_check_stops_deploy_without_reload() -> None:
-    """Провалившаяся проверка обрывает деплой и НЕ перезагружает Prometheus."""
-    branch = CHECK_FAILED_BRANCH.search(_server_script())
-    assert branch, "проверка promtool не закрыта веткой обработки отказа"
-    body = branch.group(1)
-    assert "exit 1" in body, "при провале проверки деплой продолжается — отказ выглядел бы успехом"
-    assert "/-/reload" not in body, "в ветке отказа делается перезагрузка"
-
-
-def test_lifecycle_flag_makes_reload_possible() -> None:
-    """Ручка /-/reload работает только с --web.enable-lifecycle.
-
-    Флаг и перезагрузка — одно целое: снимут флаг, и POST начнёт отвечать 405.
-    """
-    assert "--web.enable-lifecycle" in COMPOSE.read_text(encoding="utf-8"), (
-        "у Prometheus снят --web.enable-lifecycle — перезагрузка из деплоя невозможна"
-    )
-
-
-def test_every_single_file_mount_has_a_way_to_arrive() -> None:
-    """У каждого одиночного файлового маунта есть путь доезда до контейнера.
-
-    Бинд-маунт ОДНОГО файла держит инод: `git reset --hard` пишет новый файл, а
-    контейнер продолжает читать прежний — `up -d` этого не видит, перезагрузка
-    по API тоже (перечитывается тот же инод). Лечит только пересоздание, и
-    деплой обязан сверять инод по каждому такому файлу.
-
-    Список берётся ИЗ compose, а не из воркфлоу: добавят новый файловый маунт —
-    тест покраснеет, пока для него не появится сверка. Производные файлы
-    (alertmanager.yml, alertmanager_targets.gen.yml) в git не лежат и потому
-    сюда не попадают: их рендерит сам деплой и сам разбирается с инодом.
-    """
-    script = _server_script()
-    mounts = [
-        (host, container)
-        for host, container in MOUNT.findall(COMPOSE.read_text(encoding="utf-8"))
-        if (REPO_ROOT / host).is_file()
-    ]
-    assert len(mounts) == 3, (
-        f"ожидались три одиночных файловых маунта (prometheus.yml, loki-config.yml, "
-        f"alert-ack/app.py), найдено: {mounts}"
-    )
-    assert "stat -c %i" in script and '--force-recreate "$1"' in script, (
-        "в деплое нет сверки инода с пересозданием контейнера"
-    )
-    for host, container in mounts:
-        assert re.search(rf'"[^"\n]*{re.escape(host)} {re.escape(container)}[^"\n]*"', script), (
-            f"{host} не сверяется с {container}: правка этого файла ляжет на диск, "
-            f"а контейнер останется на старом иноде — молча"
-        )
-
-
-def test_grafana_datasources_are_reloaded() -> None:
-    """Датасорсы Grafana применяются ТОЛЬКО при старте — их надо перечитать явно.
-
-    Замер на стенде (grafana/grafana:11.5.1, provisioning из этого репозитория):
-    новый дашборд появился сам за 30 с (updateIntervalSeconds), а изменённый url
-    датасорса не применился и через 75 с; POST на
-    /api/admin/provisioning/datasources/reload применил его сразу.
-    """
-    assert "/api/admin/provisioning/datasources/reload" in _server_script(), (
-        "деплой не перечитывает датасорсы Grafana — правка "
-        "provisioning/datasources останется без эффекта при зелёном деплое"
+    verify_start = text.index("LAST_CONFIG_AFTER")
+    verify_block_end = text.index("Prometheus: конфиг и правила проверены", verify_start)
+    verify_block = text[verify_start:verify_block_end]
+    assert "exit 1" in verify_block, (
+        "если lastConfigTime не изменился, шаг обязан падать, а не считаться успешным"
     )

backend/tests/test_3471_product_metrics.py

@@ -0,0 +1,36 @@
+"""Продуктовый счётчик экспорта отчётов (#3471): выгрузок §22-форсайта / ТЗ.
+
+Мера кардинальности та же, что в `test_metrics.py`: единственный лейбл —
+`format`, фиксированный литерал из `Literal[...]` сигнатуры эндпоинта
+(`export_parcel_forecast`) плюс одно статичное значение `best_layouts_pdf`
+(ТЗ на проектирование) — не кадастровый номер и не идентификатор пользователя.
+"""
+
+from __future__ import annotations
+
+from prometheus_client import REGISTRY, generate_latest
+
+from app.observability import metrics as m
+
+
+def test_reports_exported_counter_has_bounded_format_label() -> None:
+    assert tuple(m.REPORTS_EXPORTED._labelnames) == ("format",)  # type: ignore[attr-defined]
+
+
+def test_reports_exported_counter_increments_per_format() -> None:
+    def _value(fmt: str) -> float:
+        return (
+            REGISTRY.get_sample_value("sitefinder_reports_exported_total", {"format": fmt}) or 0.0
+        )
+
+    before_pdf = _value("pdf")
+    before_layouts = _value("best_layouts_pdf")
+
+    m.REPORTS_EXPORTED.labels(format="pdf").inc()
+    m.REPORTS_EXPORTED.labels(format="best_layouts_pdf").inc()
+
+    assert _value("pdf") - before_pdf == 1.0
+    assert _value("best_layouts_pdf") - before_layouts == 1.0
+
+    body = generate_latest(REGISTRY).decode()
+    assert "sitefinder_reports_exported_total" in body

caddy/sites/apps.caddy

@@ -133,6 +133,35 @@ gendsgn.ru {
         format json
     }
 
+    # #3471: копия access-лога на stdout. За 3 часа наблюдения в
+    # gendesign-caddy-1 не было НИ ОДНОЙ строки http.log.access — только ACME/
+    # TLS/warn от reverse_proxy, статусы/латентность/RPS прокси не видны в
+    # Loki вообще. Alloy на этом хосте уже собирает stdout контейнеров через
+    # journald (`loki.source.journal "host"`,
+    # ops/metrics/alloy/alloy-apps.alloy) — второй bind-монт не нужен.
+    #
+    # Секреты в query (`?secret=`, `?token=` и т.п., см. инцидент #3154) режет
+    # УЖЕ РАБОТАЮЩИЙ `loki.process.scrub_credentials` (#3354, тот же список
+    # имён параметров, что в app/core/log_scrub.py) — он стоит на пути ЛЮБОГО
+    # journal-лога, включая этот, поэтому второй слой скраба здесь не заводим.
+    #
+    # `log_skip` — общий для ВСЕХ логгеров сайта флаг на запрос (Caddy не даёт
+    # скипать выборочно по конкретному логгеру), поэтому /health и статика
+    # Next пропадают заодно и из файлового gendsgn.ru.log выше, не только из
+    # копии на stdout. Это осознанный побочный эффект, не только экономия:
+    # /health — 32% строк gendsgn.ru.log в измеренном сегменте (12.09.2026,
+    # 240 из 742 строк за ~4ч, аптайм-монитор раз в минуту) без диагностической
+    # ценности, и именно он гонит файловый лог через 50MiB roll_size так часто.
+    log access_stdout {
+        output stdout
+        format json
+    }
+
+    @noisy_access_log {
+        path /health /_next/static/*
+    }
+    log_skip @noisy_access_log
+
     route {
         # `/metrics` наружу не отдаётся — ни бэкендом, ни фронтом (#3078).
         # Сегодня он и так недостижим: бэкенду «Птицы» ниже уходят только
@@ -375,6 +404,24 @@ meraocenka.ru {
         output file /var/log/caddy/meraocenka.ru.log
     }
 
+    # #3471: та же копия access-лога на stdout, что у gendsgn.ru — см.
+    # развёрнутый комментарий там (Alloy/journald, scrub_credentials #3354,
+    # log_skip общий на все логгеры сайта). `/trade-in/_next/static/*` — 5.1%
+    # строк meraocenka.ru.log в измерении 12.09.2026 (3782 из 73810 за
+    # ~17.6 суток без ротации, roll_size здесь вообще не настроен) — статика
+    # Next не может быть источником 5xx бэкенда. `/health` на этом домене не
+    # проксируется (allowlist ниже отдаёт по нему 404), но матчер добавлен для
+    # единообразия с gendsgn.ru — вреда от него ноль.
+    log access_stdout {
+        output stdout
+        format json
+    }
+
+    @noisy_access_log {
+        path /health /trade-in/_next/static/*
+    }
+    log_skip @noisy_access_log
+
     # `/metrics` наружу не отдаётся (#3078). Здесь действует белый список и
     # финальный `handle { respond 404 }`, так что путь и без этой строки не
     # проходит, — но у бэкенда «Меры» он ОТКРЫТ без авторизации ради агента

caddy/sites/infra.caddy

@@ -105,11 +105,44 @@ metrics.gendsgn.ru {
     # угадавший, — ложная отметка «принято» в чате, где сразу видно, что её
     # поставил не человек. Прав в системе токен не даёт никаких.
     #
-    # Сервис отвечает только на /ack/* и /healthz; всё прочее — 404.
+    # Сервис отвечает только на /ack/*, /glitchtip и /healthz; всё прочее — 404.
     handle /ack/* {
         reverse_proxy alert-ack:8080
     }
 
+    # Резервный приёмник алертов GlitchTip (#3471). Основной получатель —
+    # продуктовый бэкенд на Selectel, то есть тот самый сервис, за которым эти
+    # алерты и следят: пока он лежит, его собственные ошибки доставлять некому.
+    # Этот путь живёт у другого провайдера и с чистой сетью до Telegram, поэтому
+    # переживает падение Selectel целиком.
+    #
+    # Секрет — в значении query-параметра, а не в пути: путь сам по себе не
+    # секрет, и его попадание в access-лог безопасно. Само значение вырезает
+    # scrub_credentials в Alloy до записи в Loki (#3154).
+    handle /glitchtip* {
+        reverse_proxy alert-ack:8080
+    }
+
+    # Ретранслятор Bot API продукта (#3471). Путь от Selectel до
+    # api.telegram.org теряет примерно каждый четвёртый короткий запрос, тот же
+    # замер с Beget в те же минуты — чистый. Поэтому продуктовый бот ходит в
+    # Telegram отсюда, а не напрямую.
+    #
+    # Путь содержит токен бота (/tg-relay/bot<TOKEN>/<method>) — он не должен
+    # осесть ни в файловом логе сайта, ни в stdout-копии (#3154), поэтому
+    # запрос помечен log_skip.
+    @tg_relay path /tg-relay/*
+    log_skip @tg_relay
+
+    handle_path /tg-relay/* {
+        reverse_proxy tg-relay:8080 {
+            # getUpdates — long-poll до ~40с, дефолтный таймаут ответа короче.
+            transport http {
+                response_header_timeout 80s
+            }
+        }
+    }
+
     # Вход ОДИН — собственный вход Grafana (#3078). Внешний basic_auth снят по
     # решению владельца: два запроса пароля подряд мешали работе, а Grafana имеет
     # собственную аутентификацию с ролями и `GF_USERS_ALLOW_SIGN_UP=false`.

docker-compose.metrics-agent.yml

@@ -231,6 +231,71 @@ services:
     mem_limit: 128m
     logging: *default-logging
 
+  # ── redis-exporter: здоровье общего Redis (только на Poincare) ───────────────
+  # #3471. Redis — один инстанс на три потребителя: db0 celery-брокер Site
+  # Finder, db1 SearchCache trade-in, db2 glitchtip (см. комментарий у сервиса
+  # `redis` в docker-compose.prod.yml). Один `redis_up` покрывает риск для всех
+  # трёх разом — до этой правки Redis не измерялся вообще, переполнение
+  # брокера и обычная недоступность снаружи выглядели одинаково — тишиной.
+  #
+  # Адрес — через alias `gendesign-redis`, который `redis` регистрирует на
+  # сети `shared` (см. #2709 в docker-compose.prod.yml) — джойнить ещё и
+  # `product` не нужно, тем же путём уже идёт postgres-exporter-tradein.
+  #
+  # Пароль — из окружения, не хардкод: сегодня на Redis нет requirepass (нет
+  # переменной ни в docker-compose.prod.yml, ни здесь), но если он появится,
+  # значение подставляется через METRICS_REDIS_PASSWORD в /opt/gendesign/.env
+  # на хосте, а не в этот файл.
+  redis-exporter:
+    image: oliver006/redis_exporter:v1.65.0
+    container_name: gendesign-redis-exporter
+    restart: unless-stopped
+    profiles: ["apps"]
+    environment:
+      REDIS_ADDR: ${METRICS_REDIS_ADDR:-redis://gendesign-redis:6379}
+      REDIS_PASSWORD: ${METRICS_REDIS_PASSWORD:-}
+    expose:
+      - "9121"
+    networks:
+      - shared
+    mem_limit: 64m
+    logging: *default-logging
+
+  # ── celery-exporter: очередь Site Finder (только на Poincare) ────────────────
+  # #3471. Слепая зона: глубина очереди, число живых воркеров и счётчик
+  # неуспешных задач нигде не измерялись — залипший воркер и переполненная
+  # очередь снаружи неотличимы от тишины.
+  #
+  # ПОЧЕМУ ОТДЕЛЬНЫЙ ОБРАЗ, А НЕ redis-exporter --check-keys. check-keys дал
+  # бы LLEN дефолтной очереди "celery" (в backend/app/workers/celery_app.py
+  # НЕТ task_routes — все таски идут в один дефолтный queue, имя буквально
+  # "celery") без нового образа вообще. Но он НЕ умеет считать живых
+  # воркеров и неуспешные таски — то есть закрыл бы только треть минимума
+  # из задачи. celery-exporter слушает событийную шину Celery через тот же
+  # брокер и даёт все три метрики разом, поэтому выбран он, а не комбинация
+  # check-keys + что-то ещё для остальных двух чисел.
+  #
+  # ⚠️ ИМЕНА МЕТРИК НИЖЕ (celery_queue_length, celery_worker_up,
+  # celery_task_failed_total) — по документации проекта на момент правки, БЕЗ
+  # прогона на реальном брокере (агент писал этот файл без доступа к проду).
+  # Сверить с `curl http://gendesign-celery-exporter:9808/metrics` на хосте
+  # после первого деплоя и поправить `ops/metrics/prometheus/rules/infra.yml`
+  # при расхождении — иначе алерты будут молча ничего не ловить.
+  celery-exporter:
+    image: danihodovic/celery-exporter:0.13.0
+    container_name: gendesign-celery-exporter
+    restart: unless-stopped
+    profiles: ["apps"]
+    command:
+      - "--broker-url=${METRICS_CELERY_BROKER_URL:-redis://gendesign-redis:6379/0}"
+      - "--queue=celery"
+    expose:
+      - "9808"
+    networks:
+      - shared
+    mem_limit: 128m
+    logging: *default-logging
+
   # ── postgres-exporter: инфраструктурная БД (только на Beget) ─────────────────
   # forgejo + glitchtip. Нужен и сам по себе, и как страховка: рост базы glitchtip
   # ничем не ограничен — политики ретенции у GlitchTip нет вообще.

docker-compose.metrics.yml

@@ -196,6 +196,12 @@ services:
       # Внешний адрес попадает в кнопку. Пустой — сообщение уйдёт без кнопки,
       # но уйдёт: алерт важнее подтверждения.
       ALERT_ACK_PUBLIC_URL: ${ALERT_ACK_PUBLIC_URL:-https://metrics.gendsgn.ru}
+      # Резервный получатель GlitchTip-алертов (#3471, POST /glitchtip) — второй
+      # получатель наряду с основным вебхуком в продуктовый бэкенд на Selectel.
+      # Секрет СВОЙ, не общий с продуктовым TRADEIN_INTERNAL_AUTH_SECRET: разные
+      # хосты/домены безопасности. Пусто — эндпоинт отвечает 503, остальной
+      # функционал сервиса не затронут.
+      ALERT_ACK_GLITCHTIP_SECRET: ${ALERT_ACK_GLITCHTIP_SECRET:-}
     volumes:
       - ./ops/metrics/alert-ack/app.py:/app/app.py:ro
     expose:
@@ -210,7 +216,74 @@ services:
       timeout: 10s
       retries: 5
 
+  # ── Ретранслятор Bot API продукта через Beget (#3471) ───────────────────────
+  #
+  # Замер 12.09.2026, оба хоста в одни и те же минуты: `getMe` из контейнера
+  # `tradein-tgbot` на Selectel — 9 успешных из 12, три ConnectTimeout. TCP-443
+  # до адреса, резолвящегося на Selectel — 5/6. Тот же TCP-443 до адреса,
+  # резолвящегося на Beget — 8/8. За сутки 508 строк `network error` в логе
+  # бота, за 30 дней 92 обрыва итерации poll loop. Путь до Telegram с Selectel
+  # лоссовый, с Beget чистый — Alertmanager (тот же чат, живёт рядом) шлёт без
+  # проблем. Продуктовые sendMessage/copyMessage/getUpdates идут сюда вместо
+  # прямого пути; выключается пустым TELEGRAM_RELAY_BASE_URL на стороне
+  # продукта — это и есть откат.
+  #
+  # НЕ рядом с продуктом: смысл ретранслятора именно в том, что он живёт там,
+  # откуда путь до Telegram чистый, а не там, откуда он лоссовый.
+  #
+  # Образ без сборки и без зависимостей (только stdlib) — тот же принцип, что у
+  # alert-ack: сервис обязан подниматься даже когда сломано всё остальное.
+  tg-relay:
+    image: python:3.12-slim
+    container_name: gendesign-tg-relay
+    # #3471 (PR #3487 инцидент): без profiles сервис поднимался ВСЕГДА, а при
+    # пустом TG_RELAY_SECRET делает SystemExit — то есть уходит в бесконечный
+    # Restarting сразу после деплоя. Профиль включает deploy-metrics.yml, и
+    # только когда секрет реально задан (см. PROFILES там).
+    profiles: ["relay"]
+    restart: unless-stopped
+    user: "65534:65534"
+    command: ["python", "-u", "/app/app.py"]
+    env_file:
+      - path: ./backend/.env.runtime
+        required: false
+      - path: ./backend/.env
+        required: false
+    environment:
+      # Общий секрет с продуктовым клиентом (TELEGRAM_RELAY_SECRET на стороне
+      # tradein-backend/tradein-tgbot) — домен публичный, без секрета отказ.
+      TG_RELAY_SECRET: ${TG_RELAY_SECRET:-}
+    volumes:
+      - ./ops/metrics/tg-relay/app.py:/app/app.py:ro
+    expose:
+      - "8080"
+    networks:
+      - shared
+    mem_limit: 128m
+    logging: *default-logging
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request;urllib.request.urlopen('http://localhost:8080/healthz',timeout=5)"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+
   # ── Grafana: витрина ─────────────────────────────────────────────────────────
+  # Grafana здесь ТОЛЬКО рисует — не решает, что считать инцидентом и куда его
+  # слать. Тревоги живут в Prometheus (правила) и Alertmanager (маршрутизация,
+  # Telegram); это единственный путь доставки (#3158).
+  #
+  # Встроенный Alerting выключен ЯВНО, а не просто «не настроен». Проверка на
+  # живом API 12.09.2026 нашла: 0 правил, единственный контакт-поинт —
+  # стоковый grafana-default-email на example@email.com, GF_SMTP_* не заданы.
+  # То есть кнопка «New alert rule» в интерфейсе есть и работает, а результат
+  # молча уходит в никуда — ровно та ситуация, из-за которой никто не проверяет
+  # второй, настоящий путь. Дублирующий движок на том же датасорсе Prometheus
+  # надёжности всё равно не прибавляет (общая точка отказа), только даёт второе
+  # место, где правило может быть заведено и забыто.
+  #
+  # Если это когда-нибудь понадобится включить обратно — сначала подключить
+  # реальный SMTP или другой contact point и завести хотя бы одно тестовое
+  # правило руками, иначе вернётся тот же капкан.
   grafana:
     image: grafana/grafana:11.5.1
     container_name: gendesign-grafana
@@ -230,6 +303,12 @@ services:
       GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:-}
       GF_SERVER_ROOT_URL: https://metrics.gendsgn.ru/
       GF_SERVER_SERVE_FROM_SUB_PATH: "false"
+      # Единственный официальный переключатель Grafana Alerting в 11.x — секция
+      # [unified_alerting], легаси-[alerting] удалён из Grafana ещё в 9.0 и в
+      # 11.5 в конфиге отсутствует (сверено с grafana.com/docs/grafana/v11.5/
+      # setup-grafana/configure-grafana/#unified_alerting). false здесь убирает
+      # раздел Alerting из UI и глушит движок правил целиком — см. #3158 выше.
+      GF_UNIFIED_ALERTING_ENABLED: "false"
       # Телеметрия наружу — выключена. Отдельный хост, отдельный провайдер, и не
       # хочется, чтобы наблюдатель сам ходил в интернет без нужды.
       GF_ANALYTICS_REPORTING_ENABLED: "false"

ops/caddy-apply.sh

@@ -0,0 +1,138 @@
+#!/bin/sh
+# Применить текущий конфиг прокси к работающему Caddy (#3443).
+#
+# ЗАЧЕМ. Полный деплой ПТИЦЫ пересоздавал сам Caddy БЕЗУСЛОВНО
+# (`up -d --force-recreate --no-deps caddy`), а вместе с контейнером исчезал
+# единственный процесс, слушающий 80/443. Замер 05.09 (#3274): 67 с `code=000`
+# на ВСЕХ доменах хоста — gendsgn.ru, meraocenka.ru и зеркала, включая
+# публичный лендинг МЕРЫ. Это не 502/503: принимающего процесса нет вовсе,
+# поэтому заглушка окна деплоя (caddy/sites/deploy-window.caddy.snippet) здесь
+# бессильна по построению — её отдаёт тот же Caddy.
+#
+# ЧТО НА САМОМ ДЕЛЕ ТРЕБУЕТ ПЕРЕСОЗДАНИЯ. Безусловный флаг появился 17.05
+# (11e78d73) ради нового bind-маунта `./preview` из docker-compose.prod.yml,
+# который «не появлялся в running container». Довод неверен: `docker compose
+# up -d` БЕЗ `--force-recreate` пересоздаёт контейнер сам, как только меняется
+# описание сервиса или образ. Проверено на живом демоне (docker 28.4):
+#   добавлен volume        → `Container … Starting/Started`, id контейнера новый;
+#   тег указан на др. образ → id новый;
+#   не менялось ничего     → `Container … Running`, id тот же.
+#
+# Остаётся ровно один класс изменений, которого compose не видит: СОДЕРЖИМОЕ
+# пофайлового bind-маунта. `git reset --hard` не правит файл на месте, а пишет
+# новый инод; контейнер держит примонтированным прежний и продолжает читать
+# его — `caddy reload` перечитает ровно тот же старый инод. Тот же механизм уже
+# ловили на Alertmanager (27.08, deploy-metrics.yml) и на Alloy (#3380). У Caddy
+# так смонтированы пять путей: Caddyfile и четыре сниппета. Каталоги
+# (caddy/sites, caddy/local, preview) этим не страдают — правка внутри каталога
+# видна контейнеру сразу, поэтому самый частый случай (caddy/sites/apps.caddy)
+# пересоздания НЕ требует.
+#
+# ОТСЮДА ПОРЯДОК: проверить конфиг → `up -d` без `--force-recreate` → если
+# контейнер остался тем же, сверить, видит ли он текущее содержимое пофайловых
+# маунтов → пересоздать ТОЛЬКО при расхождении, иначе `caddy reload`, который
+# не рвёт соединения.
+#
+# ГРАНИЦА. Сверка по СОДЕРЖИМОМУ, а не по иноду: файл, переписанный тем же
+# текстом, пересоздания не требует. Не прочиталось (контейнер не запущен, в
+# образе нет sha256sum) — считаем расхождением: fail-safe в сторону прежнего
+# поведения, то есть пересоздания.
+set -eu
+
+# Оба вызывающих (job `deploy` и job `deploy-caddy` в .forgejo/workflows/deploy.yml)
+# работают в /opt/gendesign, но не зависеть от cwd дешевле, чем это помнить.
+cd "$(dirname "$0")/.."
+
+COMPOSE="docker compose -p gendesign -f docker-compose.prod.yml"
+
+caddy_cid() { $COMPOSE ps -aq caddy 2>/dev/null | tail -n1; }
+
+# ── 1. Проверка ДО применения ────────────────────────────────────────────────
+# Одноразовый контейнер читает файлы С ХОСТА — то есть ровно то, что поедет в
+# работающий Caddy. `exec caddy validate` здесь не годится: он проверил бы
+# старый инод, то есть предыдущую версию конфига. Образ и парсер те же, что на
+# PR-гейте (ci.yml «Guard: Caddyfile синтаксически валиден»).
+#
+# ГРАНИЦА ЭТОЙ ПРОВЕРКИ. Она обрывает применение до того, как конфиг попадёт в
+# работающий Caddy, — но только на быстром пути. В полном деплое ВЫШЕ по
+# скрипту (deploy.yml, `up -d $UP_SERVICES`) уже прошёл общий подъём всех
+# сервисов, и если правка одновременно ломает Caddyfile И меняет блок caddy в
+# docker-compose.prod.yml, контейнер пересоздастся там — с непроверенным
+# конфигом и раньше этой строки. Первая линия против этого — гейт на PR (#2913).
+echo "→ проверяю конфиг прокси одноразовым контейнером…"
+if ! docker run --rm -v "$PWD:/work:ro" -w /work caddy:2 \
+        caddy validate --config /work/Caddyfile --adapter caddyfile; then
+  echo "ОШИБКА: конфиг прокси не применён — проверка не пройдена ЛИБО не удалось"
+  echo "        запустить проверочный контейнер (нет образа caddy:2, занят демон,"
+  echo "        недоступен реестр). Причина — в выводе выше, не гадать по этой строке."
+  echo "        Работающий Caddy не тронут, домены живы."
+  exit 1
+fi
+
+# ── 2. Описание сервиса и образ ──────────────────────────────────────────────
+before=$(caddy_cid)
+$COMPOSE up -d --no-deps caddy
+after=$(caddy_cid)
+if [ -z "$after" ]; then
+  echo 'ОШИБКА: после `up -d` контейнера caddy нет — смотри вывод compose выше.'
+  exit 1
+fi
+if [ "$before" != "$after" ]; then
+  echo "✓ Caddy пересоздан compose'ом: изменилось описание сервиса или образ (${before:-нет}→${after})."
+  exit 0
+fi
+
+# ── 3. Доехало ли содержимое пофайловых маунтов ──────────────────────────────
+# Список маунтов читается ОТДЕЛЬНОЙ командой, а не в конвейере с циклом: в
+# `$(docker inspect … | while …)` статус подстановки — это статус `while`, то
+# есть всегда 0 (`pipefail` в POSIX-sh нет вовсе). Провал `docker inspect`
+# давал бы пустой список → «расхождений нет» → `caddy reload` → зелёная джоба с
+# надписью «окна недоступности нет», а прокси работал бы по СТАРОМУ конфигу.
+# Это ровно тот беззвучный отказ, ради которого написан весь скрипт.
+mounts=$(docker inspect "$after" \
+           --format '{{range .Mounts}}{{if eq .Type "bind"}}{{.Source}}|{{.Destination}}{{println}}{{end}}{{end}}') \
+  || mounts=''
+
+if [ -z "$mounts" ]; then
+  echo "WARNING: список маунтов Caddy не прочитан (docker inspect молчит или упал) —"
+  echo "         сверить нечем, считаю расхождением: fail-safe в прежнее поведение."
+  verdicts=""
+  stale="(маунты не прочитаны)"
+else
+  verdicts=$(printf '%s\n' "$mounts" | while IFS='|' read -r src dst; do
+               [ -n "${dst:-}" ] || continue
+               # Каталог инод не держит — пропускаем. Именно `-d`, а не `-f`:
+               # отсутствующий/нечитаемый ФАЙЛ — не повод молча пропустить, в
+               # контейнере в этот момент живёт старый инод со старым текстом.
+               if [ -d "$src" ]; then continue; fi
+               host_sum=$(sha256sum "$src" 2>/dev/null | cut -d' ' -f1)
+               seen_sum=$(docker exec "$after" sha256sum "$dst" 2>/dev/null | cut -d' ' -f1)
+               if [ -n "$host_sum" ] && [ "$host_sum" = "${seen_sum:-НЕ_ПРОЧИТАНО}" ]; then
+                 echo "OK $dst"
+               else
+                 echo "STALE $dst"
+               fi
+             done)
+  # «Сверили пять файлов» и «сверили ноль» обязаны различаться в логе — иначе
+  # зелёная строка ниже одинаково означает и проверку, и её отсутствие.
+  checked=$(printf '%s\n' "$verdicts" | grep -c . || true)
+  echo "→ сверено пофайловых маунтов с тем, что видит контейнер: $checked"
+  stale=$(printf '%s\n' "$verdicts" | sed -n 's/^STALE //p' | tr '\n' ' ')
+  if [ "$checked" -eq 0 ]; then
+    echo "WARNING: ни одного пофайлового bind-маунта не найдено — у Caddy их пять"
+    echo "         (Caddyfile + 4 сниппета). Считаю расхождением: fail-safe."
+    stale="(пофайловых маунтов не найдено)"
+  fi
+fi
+
+if [ -n "$stale" ]; then
+  echo "→ до контейнера НЕ доехали пофайловые маунты: $stale"
+  echo "  (bind-маунт файла держит инод: reload перечитал бы старую версию — нужен recreate)"
+  $COMPOSE up -d --force-recreate --no-deps caddy
+  echo "✓ Caddy пересоздан — иначе правка осталась бы неприменённой."
+  exit 0
+fi
+
+# ── 4. Всё доехало — перезагрузка без разрыва соединений ─────────────────────
+$COMPOSE exec -T caddy caddy reload --config /etc/caddy/Caddyfile --adapter caddyfile
+echo "✓ конфиг прокси перезагружен без пересоздания контейнера — окна недоступности нет."

ops/metrics/alert-ack/app.py

@@ -27,6 +27,28 @@
     METRICS_TELEGRAM_ONCALL      кого звать поимённо (необязательна)
     ALERT_ACK_PUBLIC_URL         внешний адрес сервиса, попадает в кнопку
     ALERT_ACK_TTL_MIN            сколько минут живёт токен (по умолчанию 1440)
+    ALERT_ACK_GLITCHTIP_SECRET   секрет резервного вебхука GlitchTip (#3471,
+                                 см. POST /glitchtip ниже); пусто — 503
+
+РЕЗЕРВНЫЙ КАНАЛ GLITCHTIP (#3471). Все три alert-правила GlitchTip (backend,
+frontend, Trade-In) шлют основной вебхук в продуктовый бэкенд на Selectel —
+тот самый хост, за которым они следят. Если там упал сам бэкенд или Caddy,
+алерт об этом теряется именно тогда, когда нужнее всего. `POST /glitchtip`
+— второй получатель того же алерта, зарегистрированный в GlitchTip отдельной
+строкой; живёт на ЭТОМ (инфраструктурном, Beget) хосте и не зависит от
+здоровья продукта. Формат тела — тот же Slack-совместимый payload, что и у
+продуктового приёмника (`tradein-mvp/backend/app/api/v1/glitchtip.py`):
+``{"text": str, "attachments": [{"title","title_link","text","color",
+"fields":[{"title","value"}]}]}``, GlitchTip заголовков не шлёт вовсе —
+аутентификация только через секрет в query (``?secret=``) или в заголовке
+``X-GlitchTip-Secret`` (тот же выбор, что там же и по той же причине: заголовок
+не течёт в access-log, query остаётся, т.к. сам GlitchTip 6.1.6 заголовков не
+добавляет). Секрет намеренно СВОЙ (``ALERT_ACK_GLITCHTIP_SECRET``), а не общий
+с продуктовым ``TRADEIN_INTERNAL_AUTH_SECRET`` — секреты разных хостов/доменов
+безопасности компрометировать вместе незачем. Сообщение уходит в ту же тему
+клиентских инцидентов (``METRICS_TELEGRAM_CHAT_ID``/``_TOPIC_ID``), что и
+Alertmanager-алерты через alert-ack, с явной пометкой «резервный канал», чтобы
+не спутать с основным путём.
 """
 
 from __future__ import annotations
@@ -51,6 +73,7 @@ TOPIC_ID = os.environ.get("METRICS_TELEGRAM_TOPIC_ID", "")
 ONCALL = os.environ.get("METRICS_TELEGRAM_ONCALL", "")
 PUBLIC_URL = os.environ.get("ALERT_ACK_PUBLIC_URL", "").rstrip("/")
 TTL_SEC = int(os.environ.get("ALERT_ACK_TTL_MIN", "1440")) * 60
+GLITCHTIP_SECRET = os.environ.get("ALERT_ACK_GLITCHTIP_SECRET", "")
 API = "https://api.telegram.org/bot{}/{}"
 
 # token -> {"message_id": int, "title": str, "created": float, "acked_by": str|None}
@@ -153,6 +176,79 @@ def _send_alert(payload: dict) -> None:
         _tg("sendMessage", msg)
 
 
+_GLITCHTIP_TEXT_LIMIT = 3500  # запас под баннер+имя проекта до лимита Telegram 4096
+
+
+def _verify_glitchtip_secret(provided: str) -> bool:
+    """Constant-time сравнение — длина/префикс секрета не утекают через время
+    ответа (тот же приём, что у продуктового приёмника, см. docstring модуля)."""
+    return bool(GLITCHTIP_SECRET) and secrets.compare_digest(provided or "", GLITCHTIP_SECRET)
+
+
+def _glitchtip_field(attachment: dict, label: str) -> str | None:
+    for field in attachment.get("fields") or []:
+        if not isinstance(field, dict):
+            continue
+        if str(field.get("title", "")).strip().lower() == label.lower():
+            value = field.get("value")
+            return str(value) if value is not None else None
+    return None
+
+
+def _render_glitchtip(payload: dict) -> str:
+    """Собрать текст сообщения из Slack-совместимого payload GlitchTip.
+
+    Максимально терпимо к форме тела: GlitchTip шлёт ОДИНАКОВУЮ структуру для
+    issue- и uptime-алертов, но поля внутри attachments опциональны, а тестовое
+    сообщение из UI GlitchTip может не иметь attachments вовсе. Ничего в теле
+    не считаем обязательным — падать сервису на резервном канале нельзя.
+    """
+    lines = ["⚠️ РЕЗЕРВНЫЙ КАНАЛ (GlitchTip → alert-ack)"]
+    lines.append("Основной путь через продуктовый бэкенд мог быть недоступен.")
+    lines.append("")
+    text = payload.get("text")
+    lines.append(html.escape(str(text)) if text else "GlitchTip alert")
+
+    attachments = payload.get("attachments")
+    for attachment in attachments if isinstance(attachments, list) else []:
+        if not isinstance(attachment, dict):
+            continue
+        block: list[str] = []
+        project = _glitchtip_field(attachment, "Project")
+        if project:
+            block.append(f"Проект: {html.escape(project)}")
+        if attachment.get("title"):
+            block.append(html.escape(str(attachment["title"])))
+        if attachment.get("text"):
+            block.append(html.escape(str(attachment["text"])))
+        if attachment.get("title_link"):
+            block.append(f"Ссылка: {html.escape(str(attachment['title_link']))}")
+        if block:
+            lines.append("")
+            lines.extend(block)
+
+    out = "\n".join(lines)
+    if len(out) > _GLITCHTIP_TEXT_LIMIT:
+        out = out[:_GLITCHTIP_TEXT_LIMIT] + "\n… (обрезано)"
+    return out
+
+
+def _send_glitchtip_alert(payload: dict) -> None:
+    """Переслать вебхук GlitchTip в ту же тему клиентских инцидентов, что и
+    Alertmanager через этот сервис. Без кнопки подтверждения — это не
+    firing/resolved инцидент с состоянием, а разовое уведомление резервного
+    канала."""
+    msg = {
+        "chat_id": CHAT_ID,
+        "text": _render_glitchtip(payload),
+        "parse_mode": "HTML",
+        "disable_web_page_preview": "true",
+    }
+    if TOPIC_ID:
+        msg["message_thread_id"] = TOPIC_ID
+    _tg("sendMessage", msg)
+
+
 _PAGE = (
     "<!doctype html><meta charset=utf-8>"
     "<title>{t}</title>"
@@ -243,11 +339,24 @@ class Handler(BaseHTTPRequestHandler):
         self._reply(code, page.encode())
 
     def do_POST(self) -> None:  # noqa: N802 — имя из stdlib
-        if self.path != "/alertmanager":
-            self._reply(404, b"not found", "text/plain; charset=utf-8")
-            return
+        # Тело читается ДО любой развилки и ветки отказа. protocol_version =
+        # HTTP/1.1, то есть соединение переиспользуется, а Caddy перед нами
+        # держит пул к апстриму. Ответить 401/404/503, не вычитав тело, значит
+        # оставить его в сокете — и следующий запрос по тому же соединению
+        # начнётся с чужих байт. Проверено на проде 12.09.2026: неавторизованный
+        # зонд на /glitchtip, а следом законный алерт получил
+        # 501 Unsupported method ('{"text":"probe"}POST'). То есть один
+        # отказ ронял следующий НАСТОЯЩИЙ алерт — ровно то, ради чего этот
+        # резервный канал и заводился.
+        parsed = urllib.parse.urlsplit(self.path)
         length = int(self.headers.get("Content-Length") or 0)
         raw = self.rfile.read(length) if length else b"{}"
+        if parsed.path == "/glitchtip":
+            self._handle_glitchtip(parsed, raw)
+            return
+        if parsed.path != "/alertmanager":
+            self._reply(404, b"not found", "text/plain; charset=utf-8")
+            return
         try:
             payload = json.loads(raw.decode() or "{}")
         except Exception:  # noqa: BLE001
@@ -261,6 +370,36 @@ class Handler(BaseHTTPRequestHandler):
         self._reply(200, b"accepted", "text/plain; charset=utf-8")
         threading.Thread(target=_send_alert, args=(payload,), daemon=True).start()
 
+    def _handle_glitchtip(self, parsed: urllib.parse.SplitResult, raw: bytes) -> None:
+        """POST /glitchtip — резервный получатель GlitchTip-алертов (#3471).
+
+        Секрет — из заголовка ``X-GlitchTip-Secret`` (предпочтительно, не течёт
+        в access-log) либо из query ``?secret=`` (fallback: GlitchTip 6.1.6
+        заголовков не шлёт вовсе). Несконфигурированный секрет → 503, а не
+        тихий приём без проверки. Неразобранное/нестандартное тело НЕ роняет
+        запрос — это резервный канал, теряться на кривом JSON ему нельзя.
+        """
+        if not GLITCHTIP_SECRET:
+            self._reply(503, b"glitchtip webhook not configured", "text/plain; charset=utf-8")
+            return
+
+        header_secret = self.headers.get("X-GlitchTip-Secret", "")
+        query_secret = urllib.parse.parse_qs(parsed.query).get("secret", [""])[0]
+        if not _verify_glitchtip_secret(header_secret or query_secret):
+            log.warning("glitchtip webhook: invalid or missing secret")
+            self._reply(401, b"invalid or missing secret", "text/plain; charset=utf-8")
+            return
+
+        try:
+            payload = json.loads(raw.decode() or "{}")
+            if not isinstance(payload, dict):
+                payload = {"text": raw.decode(errors="replace")}
+        except Exception:  # noqa: BLE001 — резервный канал не роняем на кривом теле
+            payload = {"text": raw.decode(errors="replace")}
+
+        self._reply(200, b"accepted", "text/plain; charset=utf-8")
+        threading.Thread(target=_send_glitchtip_alert, args=(payload,), daemon=True).start()
+
 
 def main() -> None:
     missing = [n for n, v in (("BOT_TOKEN", BOT_TOKEN), ("CHAT_ID", CHAT_ID)) if not v]
@@ -268,6 +407,11 @@ def main() -> None:
         raise SystemExit(f"не заданы обязательные переменные: {', '.join(missing)}")
     if not PUBLIC_URL:
         log.warning("ALERT_ACK_PUBLIC_URL пуст — сообщения уйдут БЕЗ кнопки подтверждения")
+    if not GLITCHTIP_SECRET:
+        log.warning(
+            "ALERT_ACK_GLITCHTIP_SECRET пуст — резервный канал GlitchTip (#3471) "
+            "отключён, POST /glitchtip будет отвечать 503"
+        )
     port = int(os.environ.get("ALERT_ACK_PORT", "8080"))
     log.info("alert-ack слушает :%d, тема=%s, дежурный=%s", port, TOPIC_ID or "—", ONCALL or "—")
     ThreadingHTTPServer(("", port), Handler).serve_forever()

ops/metrics/alert-ack/test_app.py

@@ -0,0 +1,256 @@
+"""Тесты для резервного канала GlitchTip → alert-ack (#3471).
+
+Продукт (tradein-backend на Selectel) — САМ объект наблюдения GlitchTip. Если
+он лежит, основной вебхук-получатель лежит вместе с ним, и алерт об этом не
+доходит именно тогда, когда нужнее всего. `POST /glitchtip` — второй
+получатель на ДРУГОМ хосте (Beget, рядом с этим сервисом), не зависящий от
+здоровья продукта.
+
+Проверяем на уровне функций, а не полного HTTP-транспорта (тот же приём, что
+`ops/glitchtip-auth-forwarder/test_forwarder.py`): `BaseHTTPRequestHandler`
+неудобно поднимать без реального сокета, а бизнес-логика — секрет, рендер,
+отправка — целиком вынесена в чистые функции модуля.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Env — ДО импорта app.py: BOT_TOKEN/CHAT_ID читаются на уровне модуля.
+os.environ.setdefault("METRICS_TELEGRAM_BOT_TOKEN", "test-bot-token")
+os.environ.setdefault("METRICS_TELEGRAM_CHAT_ID", "-1001234567890")
+os.environ.setdefault("METRICS_TELEGRAM_TOPIC_ID", "158")
+os.environ["ALERT_ACK_GLITCHTIP_SECRET"] = "correct-secret"
+
+import app as alert_ack  # noqa: E402
+
+
+def test_verify_glitchtip_secret_accepts_correct_value() -> None:
+    assert alert_ack._verify_glitchtip_secret("correct-secret") is True
+
+
+def test_verify_glitchtip_secret_rejects_wrong_value() -> None:
+    """Неверный секрет — отказ."""
+    assert alert_ack._verify_glitchtip_secret("wrong-secret") is False
+
+
+def test_verify_glitchtip_secret_rejects_empty_value() -> None:
+    assert alert_ack._verify_glitchtip_secret("") is False
+
+
+def test_verify_glitchtip_secret_fails_closed_when_unconfigured(monkeypatch) -> None:
+    """Пустой ALERT_ACK_GLITCHTIP_SECRET — отказ всем, а не тихий fail-open."""
+    monkeypatch.setattr(alert_ack, "GLITCHTIP_SECRET", "")
+    assert alert_ack._verify_glitchtip_secret("correct-secret") is False
+    assert alert_ack._verify_glitchtip_secret("") is False
+
+
+def test_render_glitchtip_full_payload_marks_fallback_channel() -> None:
+    payload = {
+        "text": "GlitchTip Alert: Something broke",
+        "attachments": [
+            {
+                "title": "TypeError: boom",
+                "title_link": "https://errors.gendsgn.ru/issue/1",
+                "text": "подробности ошибки",
+                "color": "#ff0000",
+                "fields": [{"title": "Project", "value": "tradein-backend"}],
+            }
+        ],
+    }
+    text = alert_ack._render_glitchtip(payload)
+    assert "РЕЗЕРВНЫЙ КАНАЛ" in text
+    assert "Проект: tradein-backend" in text
+    assert "TypeError: boom" in text
+    assert "https://errors.gendsgn.ru/issue/1" in text
+
+
+def test_render_glitchtip_survives_payload_without_attachments() -> None:
+    """Тело без attachments не роняет сервис — только текст."""
+    text = alert_ack._render_glitchtip({"text": "просто текст без вложений"})
+    assert "РЕЗЕРВНЫЙ КАНАЛ" in text
+    assert "просто текст без вложений" in text
+
+
+def test_render_glitchtip_survives_empty_payload() -> None:
+    """Пустой словарь (нет ни text, ни attachments) — тоже не должен падать."""
+    text = alert_ack._render_glitchtip({})
+    assert "РЕЗЕРВНЫЙ КАНАЛ" in text
+    assert "GlitchTip alert" in text
+
+
+def test_render_glitchtip_survives_malformed_attachments() -> None:
+    """attachments/fields неожиданной формы (не список, не словарь, битые
+    типы) — резервный канал не должен падать на кривом теле."""
+    payload = {
+        "text": "test",
+        "attachments": [
+            "not-a-dict",
+            {"fields": "not-a-list"},
+            {"fields": [{"title": "Project"}]},  # value отсутствует
+            None,
+        ],
+    }
+    text = alert_ack._render_glitchtip(payload)
+    assert "РЕЗЕРВНЫЙ КАНАЛ" in text
+
+
+def test_send_glitchtip_alert_forwards_via_tg(monkeypatch) -> None:
+    """Верный секрет уже проверен вызывающей стороной (do_POST) — здесь
+    проверяем, что отрендеренное сообщение реально уходит в тот же chat/topic,
+    что и Alertmanager-алерты этого сервиса, без кнопки подтверждения."""
+    calls = []
+    monkeypatch.setattr(alert_ack, "_tg", lambda method, payload: calls.append((method, payload)))
+
+    alert_ack._send_glitchtip_alert({"text": "boom", "attachments": []})
+
+    assert len(calls) == 1
+    method, sent = calls[0]
+    assert method == "sendMessage"
+    assert sent["chat_id"] == alert_ack.CHAT_ID
+    assert sent["message_thread_id"] == alert_ack.TOPIC_ID
+    assert "reply_markup" not in sent
+    assert "boom" in sent["text"]
+
+
+# ── Keep-alive: отказ не должен ронять СЛЕДУЮЩИЙ запрос ──────────────────────
+# Эти четыре теста — единственные, что поднимают настоящий сокет. Дефект,
+# который они стерегут, живёт именно в транспорте и на уровне функций невидим:
+# ветка отказа отвечала, не вычитав тело запроса, а `protocol_version` здесь
+# HTTP/1.1, то есть соединение переиспользуется (и Caddy перед сервисом держит
+# пул к апстриму). Непрочитанное тело оставалось в сокете, и следующий запрос
+# по тому же соединению начинался с чужих байт.
+#
+# Поймано на проде 12.09.2026: зонд без секрета получил 401, а следующий —
+# уже с верным секретом — вернул 501 Unsupported method ('{"text":"probe"}POST').
+# То есть один отказ съедал следующий НАСТОЯЩИЙ алерт.
+
+
+def _serve_in_background(monkeypatch):
+    """Поднимает Handler на эфемерном порту, глушит отправку в Telegram."""
+    import threading as _threading
+    from http.server import ThreadingHTTPServer
+
+    sent: list[dict] = []
+    monkeypatch.setattr(alert_ack, "_send_glitchtip_alert", sent.append)
+    monkeypatch.setattr(alert_ack, "_send_alert", sent.append)
+
+    srv = ThreadingHTTPServer(("127.0.0.1", 0), alert_ack.Handler)
+    thread = _threading.Thread(target=srv.serve_forever, daemon=True)
+    thread.start()
+    return srv, sent
+
+
+def _raw_post(sock, path: str, body: bytes, headers: str = "") -> str:
+    """Шлёт POST по уже открытому сокету и возвращает статусную строку."""
+    req = (
+        f"POST {path} HTTP/1.1\r\n"
+        f"Host: localhost\r\n"
+        f"Content-Type: application/json\r\n"
+        f"Content-Length: {len(body)}\r\n"
+        f"{headers}"
+        f"\r\n"
+    ).encode() + body
+    sock.sendall(req)
+    # Читаем ровно заголовки: тела короткие, Content-Length всегда проставлен.
+    buf = b""
+    while b"\r\n\r\n" not in buf:
+        chunk = sock.recv(4096)
+        if not chunk:
+            break
+        buf += chunk
+    head, _, rest = buf.partition(b"\r\n\r\n")
+    length = 0
+    for line in head.split(b"\r\n")[1:]:
+        if line.lower().startswith(b"content-length:"):
+            length = int(line.split(b":")[1])
+    while len(rest) < length:
+        rest += sock.recv(4096)
+    return head.split(b"\r\n")[0].decode()
+
+
+def _pair_on_one_connection(monkeypatch, first_headers: str, first_path: str = "/glitchtip"):
+    import socket
+
+    srv, sent = _serve_in_background(monkeypatch)
+    try:
+        sock = socket.create_connection(srv.server_address, timeout=5)
+        try:
+            first = _raw_post(sock, first_path, b'{"text":"probe"}', first_headers)
+            second = _raw_post(
+                sock,
+                "/glitchtip",
+                b'{"text":"real alert"}',
+                "X-GlitchTip-Secret: correct-secret\r\n",
+            )
+        finally:
+            sock.close()
+    finally:
+        srv.shutdown()
+        srv.server_close()
+    return first, second, sent
+
+
+def test_rejected_request_does_not_break_next_one_on_same_connection(monkeypatch) -> None:
+    """401 без секрета, следом законный алерт по ТОМУ ЖЕ соединению — 200."""
+    first, second, sent = _pair_on_one_connection(monkeypatch, "")
+    assert "401" in first
+    assert "200" in second, f"второй запрос испорчен первым: {second}"
+    assert sent == [{"text": "real alert"}]
+
+
+def test_unconfigured_secret_does_not_break_next_request(monkeypatch) -> None:
+    """503 при пустом секрете тоже обязан вычитать тело."""
+    import socket
+
+    monkeypatch.setattr(alert_ack, "GLITCHTIP_SECRET", "")
+    srv, _sent = _serve_in_background(monkeypatch)
+    try:
+        sock = socket.create_connection(srv.server_address, timeout=5)
+        try:
+            first = _raw_post(sock, "/glitchtip", b'{"text":"probe"}')
+            second = _raw_post(sock, "/glitchtip", b'{"text":"again"}')
+        finally:
+            sock.close()
+    finally:
+        srv.shutdown()
+        srv.server_close()
+    assert "503" in first
+    assert "503" in second, f"второй запрос испорчен первым: {second}"
+
+
+def test_unknown_path_does_not_break_next_request(monkeypatch) -> None:
+    """404 на чужом пути — та же ветка раннего ответа, то же требование."""
+    first, second, sent = _pair_on_one_connection(monkeypatch, "", first_path="/nope")
+    assert "404" in first
+    assert "200" in second, f"второй запрос испорчен первым: {second}"
+    assert sent == [{"text": "real alert"}]
+
+
+def test_bad_json_on_alertmanager_does_not_break_next_request(monkeypatch) -> None:
+    """400 на неразобранном теле /alertmanager — тело уже вычитано, связь цела."""
+    import socket
+
+    srv, sent = _serve_in_background(monkeypatch)
+    try:
+        sock = socket.create_connection(srv.server_address, timeout=5)
+        try:
+            first = _raw_post(sock, "/alertmanager", b"{not json")
+            second = _raw_post(
+                sock,
+                "/glitchtip",
+                b'{"text":"real alert"}',
+                "X-GlitchTip-Secret: correct-secret\r\n",
+            )
+        finally:
+            sock.close()
+    finally:
+        srv.shutdown()
+        srv.server_close()
+    assert "400" in first
+    assert "200" in second, f"второй запрос испорчен первым: {second}"
+    assert sent == [{"text": "real alert"}]

ops/metrics/alertmanager/alertmanager.yml.tmpl

@@ -71,9 +71,16 @@ route:
       repeat_interval: 3h
 
 inhibit_rules:
-  # Если хост целиком недоступен, не сыпать отдельно про каждый его сервис.
+  # Если хост целиком недоступен, не сыпать отдельно про каждый его
+  # warning-сервис. `target_matchers` НАМЕРЕННО ограничен одним warning
+  # (#3471): раньше сюда попадал и critical, и падение node-exporter молча
+  # гасило заодно PostgresLongTransactionCritical и все critical cAdvisor-
+  # алерты того же хоста — самое важное сообщение исчезало вместе с шумом,
+  # который оно должно было подавить. Warning того же хоста подавлять по-
+  # прежнему стоит (диск/память/своп неотличимы от «нет данных»), а critical
+  # обязан пережить это подавление и дойти до дежурного отдельно.
   - source_matchers: [alertname = "HostAgentDown"]
-    target_matchers: [severity =~ "warning|critical"]
+    target_matchers: [severity = "warning"]
     equal: ["host"]
 
 receivers:

ops/metrics/alloy/alloy-apps.alloy

@@ -119,6 +119,27 @@ prometheus.scrape "postgres" {
   scrape_interval = "60s"
 }
 
+// ═══ REDIS И ОЧЕРЕДЬ CELERY (#3471) ═════════════════════════════════════════════
+// До этой правки ни одной серии redis_* / celery_* в Prometheus не было: глубина
+// очереди, число живых воркеров и потеря соединения с брокером были невидимы —
+// переполнение очереди и залипший воркер снаружи выглядели одинаково, тишиной.
+
+prometheus.scrape "redis" {
+  targets = [
+    { __address__ = "gendesign-redis-exporter:9121", job = "redis" },
+  ]
+  forward_to      = [prometheus.remote_write.central.receiver]
+  scrape_interval = "30s"
+}
+
+prometheus.scrape "celery" {
+  targets = [
+    { __address__ = "gendesign-celery-exporter:9808", job = "celery" },
+  ]
+  forward_to      = [prometheus.remote_write.central.receiver]
+  scrape_interval = "30s"
+}
+
 // ═══ МЕТРИКИ ПРИЛОЖЕНИЙ ════════════════════════════════════════════════════════
 // Эндпоинты появляются в части 3. До этого скрейп просто отдаёт `up 0` — и это
 // правильно: цель видна как недоступная, а не отсутствует молча.

ops/metrics/alloy/alloy-infra.alloy

@@ -57,9 +57,13 @@ prometheus.scrape "cadvisor" {
 prometheus.relabel "cadvisor_trim" {
   forward_to = [prometheus.remote_write.central.receiver]
 
+  // `up`/`scrape_samples_scraped` — служебные ряды самого скрейпа, не
+  // container_*-метрики. Без явного допуска этот keep-фильтр резал их вместе
+  // с прочим шумом, и у cAdvisor как job'а не было своей серии `up` вообще —
+  // его смерть выглядела так же, как «ничего не изменилось» (#3471).
   rule {
     source_labels = ["__name__"]
-    regex         = "container_(memory_(usage_bytes|working_set_bytes|rss)|cpu_(usage_seconds_total|cfs_throttled_seconds_total)|network_(receive|transmit)_bytes_total|fs_(usage|limit)_bytes|last_seen|spec_memory_limit_bytes|start_time_seconds|processes)"
+    regex         = "up|scrape_samples_scraped|container_(memory_(usage_bytes|working_set_bytes|rss)|cpu_(usage_seconds_total|cfs_throttled_seconds_total)|network_(receive|transmit)_bytes_total|fs_(usage|limit)_bytes|last_seen|spec_memory_limit_bytes|start_time_seconds|processes)"
     action        = "keep"
   }
 
@@ -70,9 +74,15 @@ prometheus.relabel "cadvisor_trim" {
   //
   // NB: на пустые панели это правило НЕ влияло. Причина была в cAdvisor 0.52 на
   // Docker 29 — до сюда доезжал ровно один ряд, корневой. Лечится версией 0.55.1.
+  //
+  // `up`/`scrape_samples_scraped` лейбла `name` не несут вовсе (они не про
+  // конкретный контейнер, а про сам скрейп) — фильтр по нему вырезал бы и их.
+  // Поэтому здесь смотрим на пару (__name__, name): для служебных рядов
+  // достаточно самого __name__, для контейнерных метрик по-прежнему обязателен
+  // непустой name.
   rule {
-    source_labels = ["name"]
-    regex         = ".+"
+    source_labels = ["__name__", "name"]
+    regex         = "up;.*|scrape_samples_scraped;.*|container_[^;]*;.+"
     action        = "keep"
   }
 }

ops/metrics/grafana/dashboards/apps.json

@@ -107,7 +107,7 @@
     {
       "type": "timeseries",
       "title": "Запросы по классам ответов",
-      "description": "Классы, а не отдельные коды: форма графика важнее точного номера. Всплеск 4xx без 5xx — обычно сканер или сломанный клиент; всплеск 5xx — наша ошибка.",
+      "description": "Классы, а не отдельные коды: форма графика важнее точного номера. Всплеск 4xx без 5xx — обычно сканер или сломанный клиент; всплеск 5xx — наша ошибка. Линии НЕ стекируются: высота красной линии — это и есть число пятисоток, а не сумма со всем, что под ней.",
       "datasource": { "type": "prometheus", "uid": "prometheus" },
       "gridPos": { "h": 8, "w": 12, "x": 0, "y": 7 },
       "targets": [
@@ -117,7 +117,7 @@
         { "refId": "D", "expr": "sum by (app) (rate(http_requests_total{app=~\"$app\", status=~\"5..\"}[5m]))", "legendFormat": "{{app}} · 5xx" }
       ],
       "fieldConfig": {
-        "defaults": { "unit": "reqps", "min": 0, "custom": { "fillOpacity": 25, "stacking": { "mode": "normal" }, "showPoints": "never", "lineWidth": 1 } },
+        "defaults": { "unit": "reqps", "min": 0, "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 } },
         "overrides": [
           { "matcher": { "id": "byRegexp", "options": ".*2xx.*" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "green" } } ] },
           { "matcher": { "id": "byRegexp", "options": ".*3xx.*" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "blue" } } ] },

ops/metrics/grafana/dashboards/product.json

@@ -0,0 +1,161 @@
+{
+  "uid": "gendesign-product",
+  "title": "Продуктовые метрики",
+  "description": "Числа бизнеса, а не процесса: сколько людей реально что-то сделали в «Мере» и «Птице» (#3471). Источник — те же счётчики Prometheus, что и на дашборде «Приложения», только считают не HTTP-статусы, а продуктовые события (оценка, лид, отчёт, вход, обращение в поддержку). Часовое окно нарочно грубое: при текущем трафике (сотни событий в сутки) минутные всплески — шум, а не сигнал.",
+  "tags": ["gendesign", "product"],
+  "timezone": "browser",
+  "editable": false,
+  "schemaVersion": 39,
+  "refresh": "5m",
+  "time": { "from": "now-24h", "to": "now" },
+  "panels": [
+    { "type": "row", "title": "Мера — воронка продукта", "gridPos": { "h": 1, "w": 24, "x": 0, "y": 0 } },
+
+    {
+      "type": "timeseries",
+      "title": "Оценок в час, по исходу",
+      "description": "insufficient_data — не ошибка: аналогов рядом с адресом не нашлось, расчёт прошёл штатно. Тревожиться стоит, если эта линия начинает расти быстрее ok — значит покрытие рынка проседает, а не то, что сломался расчёт.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 1 },
+      "targets": [
+        {
+          "refId": "A",
+          "expr": "sum by (outcome) (increase(mera_estimates_total[1h]))",
+          "legendFormat": "{{outcome}}"
+        }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": [
+          { "matcher": { "id": "byName", "options": "insufficient_data" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "orange" } } ] },
+          { "matcher": { "id": "byName", "options": "ok" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "green" } } ] }
+        ]
+      }
+    },
+
+    {
+      "type": "timeseries",
+      "title": "Подсказки адреса в час, нашёлся ли результат",
+      "description": "found=no — человек напечатал адрес, а автокомплит ничего не предложил: либо адреса нет в базе, либо он вне зоны покрытия. Устойчивый рост этой линии — повод расширять покрытие, а не баг одного запроса.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 1 },
+      "targets": [
+        {
+          "refId": "A",
+          "expr": "sum by (found) (increase(mera_address_suggestions_total[1h]))",
+          "legendFormat": "найден: {{found}}"
+        }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": [
+          { "matcher": { "id": "byRegexp", "options": ".*no.*" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "orange" } } ] }
+        ]
+      }
+    },
+
+    {
+      "type": "timeseries",
+      "title": "Лиды и скачанные отчёты в час",
+      "description": "Лид — заявка с телефоном после оценки, отчёт — скачанный PDF по оценке. Оба редкие: сверяйте с недельным окном (кнопка времени вверху), часовой провал сам по себе ни о чём не говорит при таком трафике.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 9 },
+      "targets": [
+        { "refId": "A", "expr": "increase(mera_leads_total[1h])", "legendFormat": "лиды" },
+        { "refId": "B", "expr": "increase(mera_reports_exported_total[1h])", "legendFormat": "отчёты" }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": []
+      }
+    },
+
+    {
+      "type": "timeseries",
+      "title": "Входы в час, по исходу",
+      "description": "Устойчивый рост failed при ровном success — либо перебор паролей, либо сломался клиент (истёкшая сессия, старый билд фронта). При подозрении на перебор смотрите заодно панель «Отказы авторизации и лимитера» на дашборде «Приложения» — там 401/429 по HTTP.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 9 },
+      "targets": [
+        {
+          "refId": "A",
+          "expr": "sum by (result) (increase(mera_logins_total[1h]))",
+          "legendFormat": "{{result}}"
+        }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": [
+          { "matcher": { "id": "byName", "options": "failed" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "red" } } ] },
+          { "matcher": { "id": "byName", "options": "success" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "green" } } ] }
+        ]
+      }
+    },
+
+    {
+      "type": "timeseries",
+      "title": "Обращения в поддержку в час, по каналу",
+      "description": "anon — обращения с экрана входа, без логина (типично «не могу войти»), web — уже залогиненные пользователи. Всплеск anon без роста web — обычно означает баг именно в форме/процессе входа, а не общий рост нагрузки на поддержку.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 17 },
+      "targets": [
+        {
+          "refId": "A",
+          "expr": "sum by (channel) (increase(mera_support_messages_total[1h]))",
+          "legendFormat": "{{channel}}"
+        }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": [
+          { "matcher": { "id": "byName", "options": "anon" }, "properties": [ { "id": "color", "value": { "mode": "fixed", "fixedColor": "orange" } } ] }
+        ]
+      }
+    },
+
+    { "type": "row", "title": "Птица — экспорт отчётов", "gridPos": { "h": 1, "w": 24, "x": 0, "y": 25 } },
+
+    {
+      "type": "timeseries",
+      "title": "Экспортов отчётов по участку в час, по формату",
+      "description": "Формат — то, что реально скачали: md/json/docx/pptx/pdf/tg-сводка §22-форсайта плюс best_layouts_pdf (ТЗ на проектирование). Провал всех форматов разом при живом трафике на дашборде «Приложения» значит, что сломан сам экспорт, а не рендер одного конкретного формата.",
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "gridPos": { "h": 8, "w": 24, "x": 0, "y": 26 },
+      "targets": [
+        {
+          "refId": "A",
+          "expr": "sum by (format) (increase(sitefinder_reports_exported_total[1h]))",
+          "legendFormat": "{{format}}"
+        }
+      ],
+      "fieldConfig": {
+        "defaults": {
+          "unit": "short",
+          "min": 0,
+          "custom": { "fillOpacity": 8, "stacking": { "mode": "none" }, "showPoints": "never", "lineWidth": 2 }
+        },
+        "overrides": []
+      }
+    }
+  ]
+}

ops/metrics/grafana/provisioning/alerting/README.md

@@ -0,0 +1,16 @@
+# Эта папка сознательно пустая
+
+Grafana умеет провижинить contact points, notification policies и alert rules
+файлами отсюда (`/etc/grafana/provisioning/alerting`). Не клади их сюда.
+
+Решение (#3158, 12.09.2026): единственный путь доставки тревог — Prometheus
+(правила) + Alertmanager (маршрутизация, Telegram). Grafana только рисует.
+Встроенный Alerting выключен явно (`GF_UNIFIED_ALERTING_ENABLED: "false"` в
+`docker-compose.metrics.yml`, секция `grafana`) — при живом API 12.09.2026
+единственным контакт-поинтом был стоковый `grafana-default-email` на
+`example@email.com`, `GF_SMTP_*` не задан, правил ноль. Файл сюда работать не
+заставит: движок alerting выключен на уровне сервиса, провижининг в эту папку
+Grafana просто не читает.
+
+Если понадобится включить обратно — сначала пересмотреть само решение в
+`docker-compose.metrics.yml`, а не просто добавить файл в эту папку.

ops/metrics/prometheus/rules/infra.yml

@@ -44,6 +44,21 @@ groups:
           summary: "С продуктового хоста 15 минут не приходят метрики"
           description: "Либо лёг агент на Poincare, либо оборван канал до metrics.gendsgn.ru, либо приёмник не принимает remote-write."
 
+      # cAdvisor как job не публикует `up` естественным образом — до фикса
+      # keep-фильтра в alloy-infra.alloy/alloy-apps.alloy (#3471) эта серия
+      # вырезалась тем же правилом, что чистит container_* от мусорных
+      # лейблов. Итог — смерть cAdvisor молча гасила ContainerRestartLoop и
+      # ContainerNearMemoryLimit: обе метрики просто переставали поступать, а
+      # выглядело это как «событий не было».
+      - alert: CadvisorDown
+        expr: up{job="cadvisor"} == 0 or absent(up{job="cadvisor"})
+        for: 5m
+        labels:
+          severity: critical
+        annotations:
+          summary: "cAdvisor не отвечает"
+          description: "{{ if $labels.host }}{{ $labels.host }}: {{ end }}job=\"cadvisor\" вернул up=0 либо серия пропала целиком. Без неё контейнерные алерты этого хоста молчат вне зависимости от реального состояния контейнеров."
+
   # ── Хост ────────────────────────────────────────────────────────────────────
   - name: host
     interval: 60s
@@ -145,6 +160,135 @@ groups:
           summary: "Контейнер у своего потолка памяти"
           description: "{{ $labels.host }} / {{ $labels.name }}: {{ $value | humanizePercentage }} от mem_limit. Дальше OOM-kill."
 
+      # tradein-tgbot и tradein-scraper не HTTP-сервисы — у них нет `up{}`
+      # вообще, поэтому крэш-без-рестарта или удаление контейнера иначе не
+      # поймать. `absent()` на каждое имя отдельно (не одним regex-селектором):
+      # regex-селектор с несколькими сериями считается «пустым» только когда
+      # ПРОПАЛИ ОБЕ — если жив хотя бы один из двух контейнеров, absent() по
+      # общему selector'у молчит и не заметит пропажу второго.
+      #
+      # ВАЖНО, чего это правило НЕ ловит: container_last_seen обновляется, пока
+      # Docker видит контейнер живым, — зависший, но не упавший процесс
+      # (внутренний цикл встал, контейнер по-прежнему числится running) эту
+      # метрику не тронет. Слепая зона «живой процесс с застрявшим циклом»
+      # остаётся открытой: подходящей метрики для неё сейчас нет.
+      - alert: TradeInBackgroundContainerMissing
+        expr: |
+          absent(container_last_seen{name="tradein-tgbot"})
+            or absent(container_last_seen{name="tradein-scraper"})
+        for: 5m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Фоновый контейнер Меры пропал из cAdvisor"
+          description: "{{ $labels.name }}: серия container_last_seen исчезла — контейнер, судя по всему, не работает и не перезапускается."
+
+  # ── Приложение ──────────────────────────────────────────────────────────────
+  # `job="app"` — job из alloy-apps.alloy, лейбл `app` различает продукты
+  # (sitefinder / mera). Метрики отдаёт `MetricsMiddleware`
+  # (`backend/app/observability/metrics.py` у «Птицы»,
+  # `tradein-mvp/backend/app/observability/metrics.py` у «Меры») — счётчик
+  # `http_requests_total{method,route,status}` и гистограмма
+  # `http_request_duration_seconds{method,route}`. До этой группы доля 5xx и
+  # задержка были видны только постфактум в GlitchTip, без порога срабатывания
+  # (#3471).
+  #
+  # severity: critical + host: apps здесь ОБЯЗАТЕЛЬНЫ содержательно, не для
+  # красоты: именно эта пара матчится маршрутом telegram-clients в
+  # alertmanager.yml.tmpl — тот зовёт дежурного и напоминает каждые 30 минут.
+  # `host` выставлен статически: `sum by (app)` вырезает его из результата
+  # запроса, а job="app" в принципе существует только на продуктовом хосте.
+  - name: app
+    interval: 60s
+    rules:
+      # Гейт по RPS внутри знаменателя — тот же приём, что у
+      # PostgresLowHotUpdateRatio: делит только там, где трафик уже есть,
+      # иначе один упавший запрос при нулевой нагрузке даёт 100% и будит
+      # дежурного зря.
+      - alert: AppHighErrorRate
+        expr: |
+          sum by (app) (rate(http_requests_total{job="app", status=~"5.."}[5m]))
+            / (sum by (app) (rate(http_requests_total{job="app"}[5m])) > 0.1) > 0.05
+        for: 5m
+        labels:
+          severity: critical
+          host: apps
+        annotations:
+          summary: "Доля 5xx выше 5%"
+          description: "{{ $labels.app }}: {{ $value | humanizePercentage }} ответов 5xx за последние 5 минут при RPS выше 0.1."
+
+      # Порог 5s — заведомо выше рабочего профиля обоих продуктов (у «Меры»
+      # типичный расчёт 90мс, у «Птицы» верхняя граница гистограммы — 60с под
+      # тяжёлую геометрию, но это единичные хвостовые запросы, не p95).
+      # Калибровка по реальному трафику — отдельная задача, не эта.
+      - alert: AppHighLatencyP95
+        expr: |
+          histogram_quantile(0.95, sum by (le, app) (rate(http_request_duration_seconds_bucket{job="app"}[10m]))) > 5
+        for: 10m
+        labels:
+          severity: critical
+          host: apps
+        annotations:
+          summary: "p95 задержки ответа выше 5 секунд"
+          description: "{{ $labels.app }}: p95 за 10 минут — {{ $value | humanizeDuration }}."
+
+  # ── Redis и очередь Celery (#3471) ───────────────────────────────────────────
+  # Слепая зона: до этих правил ни redis_*, ни celery_* не собирались вовсе.
+  # Redis — общий инстанс на три потребителя (celery-брокер Site Finder, кэш
+  # trade-in, glitchtip — см. docker-compose.prod.yml), поэтому его смерть
+  # клиентская, отсюда severity: critical без явного host: apps — серия
+  # приходит только с продуктового alloy (alloy-apps.alloy), host в неё
+  # проставляется через external_labels уже на месте.
+  #
+  # ⚠️ Имена метрик celery_queue_length / celery_worker_up /
+  # celery_task_failed_total — по документации celery-exporter на момент
+  # написания правил, без проверки на реальном брокере (см. комментарий у
+  # сервиса celery-exporter в docker-compose.metrics-agent.yml). Сверить после
+  # первого деплоя.
+  - name: redis-celery
+    interval: 60s
+    rules:
+      - alert: RedisDown
+        expr: up{job="redis"} == 0 or redis_up == 0
+        for: 5m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Redis недоступен"
+          description: "redis_exporter не может достучаться до Redis (или сам процесс лёг). Разом теряют связь celery-брокер Site Finder, SearchCache trade-in и glitchtip."
+
+      # `absent()` — как у CadvisorDown: если сам celery-exporter не поднялся,
+      # серии celery_worker_up не будет вообще, а не будет со значением 0.
+      - alert: NoActiveCeleryWorkers
+        expr: count(celery_worker_up == 1) == 0 or absent(celery_worker_up)
+        for: 5m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Ни одного живого воркера Celery"
+          description: "celery-exporter не видит ни одного heartbeat от воркера Site Finder. Все periodic-таски (парсинг, аналитика, синк слоёв) встали."
+
+      # Порог 150 ПРЕДВАРИТЕЛЬНЫЙ: реальных данных по глубине очереди нет (до
+      # этой правки метрика не собиралась). beat_schedule.py на момент правки
+      # содержит 44 periodic-задачи с разным временем срабатывания — даже
+      # маловероятный залп всех разом даёт кратно меньше 150. Порог взят с
+      # запасом сознательно и требует пересмотра через неделю наблюдений по
+      # факту `celery_queue_length`.
+      #
+      # `delta(...) >= 0` — очередь не УМЕНЬШАЕТСЯ за 15 минут (тот же приём,
+      # что и "растёт и не разгребается" в тексте задачи): просто высокое
+      # значение без этого условия поймало бы и здоровый кратковременный всплеск.
+      - alert: CeleryQueueGrowing
+        expr: |
+          celery_queue_length{queue_name="celery"} > 150
+            and delta(celery_queue_length{queue_name="celery"}[15m]) >= 0
+        for: 15m
+        labels:
+          severity: warning
+        annotations:
+          summary: "Очередь Celery растёт и не разгребается"
+          description: "В очереди {{ $value }} задач, за 15 минут меньше не стало. Похоже на залипший воркер или устойчивый рост нагрузки."
+
   # ── Postgres ────────────────────────────────────────────────────────────────
   - name: postgres
     interval: 60s

ops/metrics/tg-relay/app.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Ретранслятор Bot API продукта через инфраструктурный хост Beget (#3471).
+
+ЗАЧЕМ. Замер 12.09.2026, оба хоста в одни и те же минуты: `getMe` из контейнера
+`tradein-tgbot` на Selectel — 9 успешных из 12, три `ConnectTimeout`. TCP на 443
+до адреса, резолвящегося на Selectel (149.154.167.220) — 5 из 6. Тот же TCP до
+адреса, резолвящегося на Beget (149.154.166.110) — 8 из 8. За сутки в логе бота
+508 строк `network error`, за 30 дней 92 обрыва итерации poll loop. Путь до
+Telegram с Selectel лоссовый, с Beget чистый: Alertmanager (живёт на Beget)
+пишет в тот же чат без проблем, а бот поддержки на Selectel часть отправок
+теряет. Решение — не чинить сеть Selectel (вне контроля), а дать продуктовым
+сервисам обходной путь через хост, с которого Telegram отвечает надёжно.
+
+ЧТО ПРОКСИРУЕТСЯ. Метод Bot API целиком — путь `/bot<TOKEN>/<method>`, тело,
+query. Не только отправка: `getUpdates` (long-poll) страдает от потерь ровно
+так же, как `sendMessage`, и это тот же HTTP-путь через тот же испорченный
+транзит.
+
+ТОКЕН НЕ ЛОГИРУЕТСЯ. Он приходит в пути запроса. `log_request` переопределён
+ПОЛНОСТЬЮ (не вызывает `super()`): дефолт stdlib кладёт в лог `requestline`
+целиком, включая токен. Здесь путь редактируется до записи в лог.
+
+АУТЕНТИФИКАЦИЯ. Общий секрет в заголовке `X-Relay-Secret`, по образцу общего
+секрета `X-Internal-Auth-Secret` в этом же стеке (`app/core/config.py`,
+`tradein_internal_auth_secret`) — сравнение строкой (не сравнение таймингов:
+секрет не является паролем пользователя, ценность атаки по времени здесь
+исчезающе мала при секрете длиной от 32 байт, а stdlib `hmac` — лишняя
+зависимость ради stdlib-only сервиса). Домен публичный, без секрета — отказ,
+а не тихий приём.
+
+БЕЗ ЗАВИСИМОСТЕЙ. Только стандартная библиотека — тот же принцип, что у
+`ops/metrics/alert-ack/app.py`: сервис обязан подниматься, даже когда всё
+остальное сломано, и не тащить установку пакетов.
+
+ОТКАЗ РЕТРАНСЛЯТОРА НЕ ДОЛЖЕН РОНЯТЬ БОТА. Это реализовано НЕ здесь, а на
+стороне клиента (`tradein-mvp/backend/app/services/tgbot/client.py`): при
+транспортном отказе похода на ретранслятор клиент делает одну попытку
+напрямую к `api.telegram.org`. Здесь достаточно не быть точкой отказа хуже
+прямого пути: таймаут до апстрима подобран так, чтобы не обрубать long-poll
+`getUpdates` раньше, чем это сделал бы сам Telegram.
+
+Переменные окружения:
+    TG_RELAY_SECRET               обязательна — общий секрет, сверяется с
+                                   заголовком X-Relay-Secret
+    TG_RELAY_PORT                 порт (по умолчанию 8080)
+    TG_RELAY_UPSTREAM_TIMEOUT_S   таймаут запроса к api.telegram.org в секундах
+                                   (по умолчанию 75 — с запасом над самым долгим
+                                   long-poll getUpdates, который шлёт клиент:
+                                   timeout=30 + 10с запаса на стороне httpx = 40с)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import urllib.error
+import urllib.request
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+log = logging.getLogger("tg-relay")
+
+RELAY_SECRET = os.environ.get("TG_RELAY_SECRET", "")
+UPSTREAM = "https://api.telegram.org"
+UPSTREAM_TIMEOUT_S = float(os.environ.get("TG_RELAY_UPSTREAM_TIMEOUT_S", "75"))
+SECRET_HEADER = "X-Relay-Secret"
+
+
+def redact_path(path: str) -> str:
+    """Прячет токен из `/bot<TOKEN>/method[?query]` для логов и ошибок.
+
+    Вынесена в модульную функцию (не метод), чтобы быть проверяемой напрямую
+    без поднятия HTTP-сервера.
+    """
+    if not path.startswith("/bot"):
+        return path
+    rest = path[len("/bot") :]
+    _token_part, sep, tail = rest.partition("/")
+    if not sep:
+        # Ни `/method`, ни query — токен без хвоста (или токен+query без slash).
+        return "/bot<REDACTED>"
+    tail = tail.split("?", 1)[0]
+    return f"/bot<REDACTED>/{tail}" if tail else "/bot<REDACTED>"
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, fmt: str, *args) -> None:  # noqa: A003 — сигнатура из stdlib
+        log.info("%s", fmt % args)
+
+    def log_request(self, code="-", size="-") -> None:  # noqa: A003 — сигнатура из stdlib
+        # ПОЛНОСТЬЮ заменяет реализацию BaseHTTPRequestHandler (не вызывает
+        # super()): та кладёт в лог self.requestline целиком, а он для Bot API
+        # содержит токен в пути.
+        log.info('%s "%s %s" %s', self.address_string(), self.command, redact_path(self.path), code)
+
+    def _reply(self, code: int, body: bytes, ctype: str = "application/json") -> None:
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        if body:
+            self.wfile.write(body)
+
+    def _authorized(self) -> bool:
+        return bool(RELAY_SECRET) and self.headers.get(SECRET_HEADER) == RELAY_SECRET
+
+    def _proxy(self) -> None:
+        if self.path == "/healthz":
+            self._reply(200, b"ok", "text/plain; charset=utf-8")
+            return
+        if not self._authorized():
+            self._reply(401, b'{"ok":false,"description":"unauthorized"}')
+            return
+        if not self.path.startswith("/bot"):
+            self._reply(404, b'{"ok":false,"description":"not found"}')
+            return
+
+        length = int(self.headers.get("Content-Length") or 0)
+        body = self.rfile.read(length) if length else None
+        req = urllib.request.Request(
+            UPSTREAM + self.path,
+            data=body,
+            method=self.command,
+            headers={"Content-Type": self.headers.get("Content-Type") or "application/json"},
+        )
+        try:
+            # Таймаут ЯВНО шире любого long-poll getUpdates клиента — иначе
+            # ретранслятор обрубит соединение раньше площадки и превратит
+            # штатный long-poll в вечный network error, то есть станет хуже
+            # прямого пути, а не лучше.
+            with urllib.request.urlopen(req, timeout=UPSTREAM_TIMEOUT_S) as resp:
+                out = resp.read()
+                self._reply(resp.status, out, resp.headers.get("Content-Type") or "application/json")
+        except urllib.error.HTTPError as exc:
+            # Telegram ответил ошибкой (4xx/5xx) — это НЕ отказ ретранслятора,
+            # передаём как есть, клиент сам решает, ретраить или нет.
+            out = exc.read()
+            ctype = exc.headers.get("Content-Type") if exc.headers else None
+            self._reply(exc.code, out, ctype or "application/json")
+        except Exception as exc:  # noqa: BLE001 — любой отказ апстрима не должен уронить сервис
+            log.warning("upstream недоступен (%s): %s", redact_path(self.path), type(exc).__name__)
+            self._reply(502, b'{"ok":false,"description":"relay upstream unreachable"}')
+
+    def do_GET(self) -> None:  # noqa: N802 — имя из stdlib
+        self._proxy()
+
+    def do_POST(self) -> None:  # noqa: N802 — имя из stdlib
+        self._proxy()
+
+
+def main() -> None:
+    if not RELAY_SECRET:
+        raise SystemExit("не задан TG_RELAY_SECRET — домен публичный, отказ на старте")
+    port = int(os.environ.get("TG_RELAY_PORT", "8080"))
+    log.info("tg-relay слушает :%d, upstream_timeout=%.0fs", port, UPSTREAM_TIMEOUT_S)
+    ThreadingHTTPServer(("", port), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

ops/metrics/tg-relay/test_app.py

@@ -0,0 +1,144 @@
+"""Тесты для tg-relay — ретранслятора Bot API продукта через Beget (#3471).
+
+Гоняют реальный `ThreadingHTTPServer` на localhost (эфемерный порт), апстрим
+`urllib.request.urlopen` подменяется моком — реальный api.telegram.org НЕ
+дёргаем никогда.
+"""
+
+from __future__ import annotations
+
+import http.client
+import json
+import logging
+import threading
+from unittest import mock
+
+import pytest
+
+import app as relay
+
+
+def _fake_upstream_response(status: int = 200, body: bytes = b'{"ok": true, "result": []}'):
+    resp = mock.MagicMock()
+    resp.status = status
+    resp.read.return_value = body
+    resp.headers.get.return_value = "application/json"
+    resp.__enter__.return_value = resp
+    resp.__exit__.return_value = False
+    return resp
+
+
+@pytest.fixture()
+def secret(monkeypatch):
+    monkeypatch.setattr(relay, "RELAY_SECRET", "test-secret-value")
+    return "test-secret-value"
+
+
+@pytest.fixture()
+def server(secret):
+    httpd = relay.ThreadingHTTPServer(("127.0.0.1", 0), relay.Handler)
+    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield httpd
+    finally:
+        httpd.shutdown()
+        thread.join(timeout=5)
+
+
+def _request(server, path, headers=None, method="GET", body=None):
+    conn = http.client.HTTPConnection(*server.server_address, timeout=5)
+    try:
+        conn.request(method, path, body=body, headers=headers or {})
+        resp = conn.getresponse()
+        return resp.status, resp.read()
+    finally:
+        conn.close()
+
+
+def test_redact_path_hides_token_from_method_path():
+    assert relay.redact_path("/bot123456:ABC-DEF/sendMessage") == "/bot<REDACTED>/sendMessage"
+
+
+def test_redact_path_hides_bare_token():
+    assert relay.redact_path("/bot123456:ABC-DEF/") == "/bot<REDACTED>"
+    assert relay.redact_path("/bot123456:ABC-DEF") == "/bot<REDACTED>"
+
+
+def test_redact_path_leaves_non_bot_paths_untouched():
+    assert relay.redact_path("/healthz") == "/healthz"
+
+
+def test_missing_secret_rejected_without_touching_upstream(server):
+    with mock.patch.object(relay.urllib.request, "urlopen") as mocked:
+        status, _body = _request(server, "/bot123:TOK/getMe")
+    assert status == 401
+    mocked.assert_not_called()
+
+
+def test_wrong_secret_rejected_without_touching_upstream(server):
+    with mock.patch.object(relay.urllib.request, "urlopen") as mocked:
+        status, _body = _request(server, "/bot123:TOK/getMe", headers={"X-Relay-Secret": "wrong"})
+    assert status == 401
+    mocked.assert_not_called()
+
+
+def test_valid_secret_passes_method_path_and_body_unmodified(server, secret):
+    with mock.patch.object(
+        relay.urllib.request, "urlopen", return_value=_fake_upstream_response()
+    ) as mocked:
+        status, body = _request(
+            server,
+            "/bot123:TOK/sendMessage",
+            headers={"X-Relay-Secret": secret, "Content-Type": "application/json"},
+            method="POST",
+            body=b'{"chat_id": 1, "text": "hi"}',
+        )
+
+    assert status == 200
+    assert json.loads(body) == {"ok": True, "result": []}
+
+    sent_request = mocked.call_args[0][0]
+    assert sent_request.full_url == "https://api.telegram.org/bot123:TOK/sendMessage"
+    assert sent_request.data == b'{"chat_id": 1, "text": "hi"}'
+    assert sent_request.get_method() == "POST"
+
+
+def test_get_updates_uses_upstream_timeout_wider_than_longest_client_poll(server, secret):
+    """Клиент шлёт getUpdates(timeout=30) → httpx ждёт ответ 40с (30 + запас
+    10с). Апстрим-таймаут ретранслятора обязан быть шире, иначе он обрубит
+    long-poll раньше площадки и превратит штатный цикл в вечный network error."""
+    with mock.patch.object(
+        relay.urllib.request, "urlopen", return_value=_fake_upstream_response()
+    ) as mocked:
+        _request(
+            server,
+            "/bot123:TOK/getUpdates",
+            headers={"X-Relay-Secret": secret},
+            method="POST",
+            body=b'{"offset": 1, "timeout": 30}',
+        )
+
+    _req, kwargs = mocked.call_args
+    assert kwargs["timeout"] >= 40
+
+
+def test_token_never_appears_in_logs(server, secret, caplog):
+    token = "999888777:VerySecretTokenValue"
+    with caplog.at_level(logging.INFO, logger="tg-relay"):
+        with mock.patch.object(
+            relay.urllib.request, "urlopen", return_value=_fake_upstream_response()
+        ):
+            _request(server, f"/bot{token}/getMe", headers={"X-Relay-Secret": secret})
+
+    for record in caplog.records:
+        assert token not in record.getMessage()
+
+
+def test_unauthorized_attempt_does_not_leak_token_either(server, caplog):
+    token = "999888777:VerySecretTokenValue"
+    with caplog.at_level(logging.INFO, logger="tg-relay"):
+        _request(server, f"/bot{token}/getMe")
+
+    for record in caplog.records:
+        assert token not in record.getMessage()

tradein-mvp/backend/app/api/public/mera.py

@@ -79,7 +79,7 @@ from pydantic import BaseModel, Field
 from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from app.api.v1.geocode import SuggestResponse, suggest_addresses
+from app.api.v1.geocode import SuggestResponse, effective_region_code, suggest_addresses
 from app.api.v1.trade_in import coverage_probe, estimate
 from app.core.config import settings
 from app.core.db import get_db
@@ -222,6 +222,9 @@ class PublicSuggestInput(BaseModel):
     q: str = Field(min_length=2, max_length=200)
     limit: int = Field(default=8, ge=1, le=10)
     city_hint: str | None = Field(default=None, max_length=100)
+    # #3051: явный регион с фронта (если он его когда-нибудь пришлёт) —
+    # приоритетнее вывода из city_hint, см. effective_region_code.
+    region_code: int | None = Field(default=None)
 
 
 def _fold(text: str) -> str:
@@ -326,6 +329,7 @@ async def public_suggest(
                 limit=payload.limit,
                 db=db,
                 city_hint=payload.city_hint,
+                region_code=effective_region_code(payload.region_code, payload.city_hint),
             )
     finally:
         _suggest_slots.release()
@@ -479,9 +483,15 @@ class ShowcaseStats(BaseModel):
 
     Без этих чисел «20 отличных строк» неотличимо от «столько и было»:
     посетитель не может отличить выборку из работы оценщика от её лучшего
-    хвоста. `eligible` минус `written` — сколько годных строк не поместилось
-    в витрину; `rejection_rule` — по какому правилу отсеяно остальное,
-    записанное ТЕМ прогоном, который эти строки посчитал.
+    хвоста. `eligible` — сколько строк прогон СОБРАЛ (данных хватило),
+    `written` — сколько из них показано; `rejection_rule` — по какому правилу
+    отобраны показанные, записанное ТЕМ прогоном, который их посчитал.
+
+    `eligible` минус `written` — НЕ «столько не поместилось»: с 2026-09-12
+    витрина показывает полосу расхождения −5 %..+20 %, и в разницу входят
+    строки, отсеянные полосой. Что это именно отбор, а не вся сверка, говорит
+    `rejection_rule` — поэтому счётчики и правило показываются вместе, одной
+    подписью, а не порознь.
     """
 
     considered: int
@@ -550,7 +560,7 @@ def public_showcase(
     нечего, и это ровно то, что фронт должен увидеть вместо выдуманных строк.
 
     Вместе со строками едет `stats` — сколько сделок рассмотрено, сколько
-    годных строк не поместилось и по какому правилу отсеяно остальное. Числа
+    строк прогон собрал и по какому правилу из них отобраны показанные. Числа
     считает пересчёт; без них витрина не имеет права подписаться честно.
     """
     run = db.execute(_SHOWCASE_RUN_SQL).mappings().first()

tradein-mvp/backend/app/api/v1/auth.py

@@ -73,6 +73,7 @@ from app.core.password import (
     verify_slots_saturated,
 )
 from app.core.ratelimit import SlidingWindowLimiter, _client_ip
+from app.observability.metrics import LOGINS
 from app.services.auth_session import create_session, get_user_by_username, revoke_session
 from app.services.identity_store import AccessState, get_identity_db
 from app.services.user_events import schedule_event
@@ -324,6 +325,7 @@ async def _reject_invalid_credentials(
     fails = _USERNAME_FAIL_LIMITER.record(username)
     delay_s = _throttle_delay_s(fails)
 
+    LOGINS.labels(result="failed").inc()
     schedule_event(
         event_type="login_failed",
         username=username,
@@ -452,6 +454,7 @@ async def login(
         path="/",
     )
 
+    LOGINS.labels(result="success").inc()
     schedule_event(
         event_type="login_success",
         username=user["username"],

tradein-mvp/backend/app/api/v1/geocode.py

@@ -11,14 +11,33 @@ from sqlalchemy import text
 from sqlalchemy.orm import Session
 
 from app.core.db import get_db, run_db_thread
+from app.observability.metrics import ADDRESS_SUGGESTIONS
 from app.services.estimator import _lookup_house_facts
 from app.services.geocoder import GeocodeResult, geocode, reverse_geocode, suggest
+from app.services.regions import DEFAULT_REGION_CODE, region_by_city
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
 
+def effective_region_code(region_code: int | None, city_hint: str | None) -> int:
+    """Регион для геокодера (#3051): явный `region_code` > вывод из `city_hint` > 66.
+
+    До этого хелпера `/suggest` всегда уходил в геокодер с регионом 66
+    по умолчанию — московский `city_hint` («Москва») молча получал
+    свердловский bbox-констрейнт и терял подсказки. Реестр `app.services.regions`
+    уже знает, каким городам какой регион соответствует (REGIONS[77].cities
+    содержит «москва») — используем его вместо повторного захардкоженного списка.
+    """
+    if region_code is not None:
+        return region_code
+    region = region_by_city(city_hint)
+    if region is not None:
+        return region.code
+    return DEFAULT_REGION_CODE
+
+
 @router.get("/lookup", response_model=GeocodeResult)
 async def lookup(
     address: Annotated[str, Query(min_length=3, max_length=500)],
@@ -81,16 +100,17 @@ async def suggest_addresses(
         ),
     ] = None,
     region_code: Annotated[
-        int,
+        int | None,
         Query(
             description=(
-                "Регион покрытия (#3051). Дефолт 66 — Свердловская область, прежнее "
-                "поведение для существующих клиентов. 77 — Москва: без него DaData "
-                "и Nominatim получают свердловский hard-констрейнт и молча "
-                "возвращают ПУСТО на московском адресе."
+                "Регион покрытия (#3051). None (дефолт) — выводится из `city_hint` "
+                "через реестр регионов, иначе 66 (Свердловская область, прежнее "
+                "поведение). 77 — Москва: без него DaData и Nominatim получают "
+                "свердловский hard-констрейнт и молча возвращают ПУСТО на "
+                "московском адресе."
             ),
         ),
-    ] = 66,
+    ] = None,
 ) -> SuggestResponse:
     """Автокомплит адресов в регионе `region_code` (дефолт 66 — Свердловская область;
     ЕКБ — основной трафик, остаётся быстрым fast-path).
@@ -105,11 +125,15 @@ async def suggest_addresses(
       /api/v1/geocode/suggest?q=Ленина+1&city_hint=Нижний+Тагил
       /api/v1/geocode/suggest?q=Тверская+6&region_code=77  # Москва
     """
+    resolved_region_code = effective_region_code(region_code, city_hint)
     try:
-        items = await suggest(q, db=db, limit=limit, city_hint=city_hint, region_code=region_code)
+        items = await suggest(
+            q, db=db, limit=limit, city_hint=city_hint, region_code=resolved_region_code
+        )
     except ValueError as exc:
         # Регион вне реестра покрытия — 422, а не 500: это ошибка ввода клиента.
         raise HTTPException(status_code=422, detail=str(exc)) from exc
+    ADDRESS_SUGGESTIONS.labels(found="yes" if items else "no").inc()
     return SuggestResponse(
         items=[
             SuggestItem(

tradein-mvp/backend/app/api/v1/glitchtip.py

@@ -50,11 +50,14 @@ from datetime import UTC, datetime
 from typing import Annotated, Any
 
 from fastapi import APIRouter, Header, HTTPException, Query, Request
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel, ConfigDict, ValidationError
+from starlette.background import BackgroundTask
 
 from app.core.config import settings
 from app.services.tgbot.client import TelegramError
 from app.services.tgbot.shared import get_telegram_client
+from app.tasks.glitchtip_alert_retry import retry_forward_alert
 
 logger = logging.getLogger(__name__)
 
@@ -184,16 +187,28 @@ def _verify_secret(provided: str) -> None:
         raise HTTPException(status_code=401, detail="invalid or missing secret")
 
 
-@router.post("/ops/glitchtip-webhook")
+@router.post("/ops/glitchtip-webhook", response_model=None)
 async def glitchtip_webhook(
     request: Request,
     secret: Annotated[str, Query()] = "",
     header_secret: Annotated[str, Header(alias="X-GlitchTip-Secret")] = "",
-) -> dict[str, str]:
+) -> dict[str, str] | JSONResponse:
     """Приёмник GlitchTip webhook-алертов (issue + uptime) → пересылка в
     Telegram-тему алертов (``TELEGRAM_ALERTS_CHAT_ID``/``TELEGRAM_ALERTS_TOPIC_ID``
     — ОТДЕЛЬНАЯ тема от support-топика, см. docstring модуля).
 
+    Отказ синхронной попытки (#3471) отвечает 502 как и раньше (#3456 — честный
+    сигнал отправителю), но ставит доставку в фон
+    (``app.tasks.glitchtip_alert_retry.retry_forward_alert`` через
+    ``starlette.background.BackgroundTask`` на самом ответе) — GlitchTip вебхуки
+    не ретраит (#3157), без этого текст алерта терялся бы безвозвратно.
+    ``BackgroundTask`` привязан НАПРЯМУЮ к возвращаемому ``JSONResponse``, а не
+    к ``BackgroundTasks``-зависимости: FastAPI прикрепляет задачи из
+    ``BackgroundTasks`` только к ответу, который вернул сам хендлер, а `raise
+    HTTPException` строит ОТДЕЛЬНЫЙ ответ в exception-мидлваре — задачи,
+    поставленные до `raise`, в реальности молча терялись бы вместе с ним (это
+    воспроизведено тестом, не гипотеза).
+
     Путь публичный в ``rbac_guard`` (``app.core.rbac._PUBLIC_PATHS``) — этот
     хендлер сам делает единственную проверку секрета.
 
@@ -231,8 +246,27 @@ async def glitchtip_webhook(
     except TelegramError:
         # Ловим общий предок, а не `TelegramApiError`: недоступность Telegram —
         # тоже «переслать не смогли», и отвечать на неё надо задуманным 502, а не
-        # 500 из необработанного исключения (#3456).
+        # 500 из необработанного исключения (#3456). 502 ОСТАЁТСЯ — это честный
+        # сигнал отправителю. Но GlitchTip вебхуки не ретраит (#3157) — без этого
+        # текст алерта пропал бы бесследно, поэтому доставку ставим в фон
+        # (#3471, см. app.tasks.glitchtip_alert_retry).
+        #
+        # `raise HTTPException` здесь НЕ подходит: FastAPI прикрепляет
+        # background-задачи только к ответу, который вернул сам хендлер, а
+        # исключение строит СВОЙ отдельный JSONResponse в exception-мидлваре —
+        # задача, поставленная до `raise`, никогда бы не выполнилась. Поэтому
+        # 502 собран и возвращён вручную, с задачей на этом же объекте ответа.
         logger.exception("glitchtip webhook: не удалось переслать алерт в Telegram")
-        raise HTTPException(status_code=502, detail="failed to forward alert to telegram") from None
+        return JSONResponse(
+            status_code=502,
+            content={"detail": "failed to forward alert to telegram"},
+            background=BackgroundTask(
+                retry_forward_alert,
+                client,
+                chat_id=settings.telegram_alerts_chat_id,
+                text=text,
+                message_thread_id=settings.telegram_alerts_topic_id or None,
+            ),
+        )
 
     return {"status": "ok"}

tradein-mvp/backend/app/api/v1/lead.py

@@ -33,6 +33,7 @@ from sqlalchemy.orm import Session
 from app.api.v1.trade_in import _assert_estimate_access
 from app.core.config import settings
 from app.core.db import get_db
+from app.observability.metrics import LEADS
 
 logger = logging.getLogger(__name__)
 
@@ -173,6 +174,7 @@ async def create_trade_in_lead(
     )
 
     db.commit()
+    LEADS.inc()
 
     logger.info(
         "trade_in_lead saved id=%s estimate_id=%s source=%s ip=%s policy=%s",

tradein-mvp/backend/app/api/v1/support.py

@@ -62,6 +62,7 @@ import hashlib
 import logging
 import re
 import secrets
+import time
 from datetime import UTC, datetime
 from typing import Annotated, Literal
 
@@ -73,6 +74,7 @@ from sqlalchemy.orm import Session
 from app.core.config import settings
 from app.core.db import get_db
 from app.core.ratelimit import SlidingWindowLimiter, _client_ip
+from app.observability.metrics import SUPPORT_MESSAGES
 from app.services.tgbot import web_support_storage as storage
 from app.services.tgbot.bridge import SERVICE_UNAVAILABLE_TEXT
 from app.services.tgbot.client import TelegramError
@@ -169,6 +171,14 @@ _SEND_UNAVAILABLE_DETAIL = "Telegram сейчас недоступен. Попр
 # треде отдавало бы ВЕСЬ лог переписки. См. `web_support_storage.list_messages`.
 _LIST_MESSAGES_LIMIT = 200
 
+# Идемпотентность отправки (#3471 retry-storm) — см. `_resolve_idempotency_key`.
+_IDEMPOTENCY_HEADER = "idempotency-key"
+# Форма клиентского ключа — как у anon-токена (`_ANON_TOKEN_RE`): произвольная
+# opaque-строка клиента, без пробелов/спецсимволов, которые попали бы в SQL-параметр
+# как есть. Не матчится — считаем заголовок отсутствующим и уходим на fallback,
+# а не пытаемся его "починить" (тот же принцип, что у `_read_anon_token`).
+_CLIENT_IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9_.-]{8,128}\Z")
+
 
 def _require_username(request: Request) -> str:
     """Достаёт X-Authenticated-User. rbac_guard (app/main.py) уже гарантирует его
@@ -344,8 +354,51 @@ def _rollback_quietly(db: Session) -> None:
         logger.warning("web support: rollback после сбоя БД тоже не удался", exc_info=True)
 
 
+def _resolve_idempotency_key(request: Request, *, identity_key: str, text: str) -> str:
+    """Ключ идемпотентности inbound-отправки (#3471, миграция 301).
+
+    Почему заголовок + fallback, а не что-то одно. Явный `Idempotency-Key` —
+    ЕДИНСТВЕННЫЙ надёжный путь: клиент генерирует ключ ОДИН раз на "намерение
+    отправить" и переиспользует его на любом ретрае (fetch retry / переотправка
+    после таймаута) независимо от того, что именно менялось в UI между
+    попытками (см. `useSendSupportMessage` во фронтенде — реальный трафик
+    обязан идти этим путём). Fallback без заголовка — детерминированный
+    отпечаток sha256(identity, текст, минутное окно) — существует ТОЛЬКО для
+    клиентов, которые заголовок не прислали (п.5 требования — старое поведение
+    не должно сломаться), и у него два честных изъяна, оба снимаются самим
+    фактом использования заголовка:
+      1. два РАЗНЫХ по смыслу сообщения с одинаковым текстом от одного и того
+         же человека в течение одной минуты ("да" и ещё раз "да", "+", "ок")
+         СХЛОПНУТСЯ в одно — второе будет молча проглочено, клиент получит id
+         первого, оператор не увидит второе сообщение вообще;
+      2. окно — не скользящие 60 секунд, а округление `time.time() // 60` вниз:
+         фактический срок дедупликации случаен от 0 до 60с в зависимости от
+         момента внутри минуты, и часть настоящих повторов (ретрай ровно на
+         границе окна) эту защиту не получит.
+    Оба пункта перестают быть важны, когда клиент реально шлёт заголовок
+    (см. `useSendSupportMessage`).
+
+    Хранит и потенциально логирует (см. вызовы в этом файле) только САМ ключ —
+    он либо непрозрачный клиентский токен, либо хэш. Текст сообщения сюда
+    попадает ТОЛЬКО как вход в sha256, в открытом виде не сохраняется и не
+    возвращается — жёсткое правило проекта "текст не в логах" (ПДн) при этом
+    не нарушается, даже если бы этот ключ где-то залогировали.
+
+    Префиксы `client:`/`auto:` разводят два namespace'а ключей (защита от
+    случайного совпадения клиентского токена с fallback-хэшем) — дёшево и не
+    требует отдельной колонки.
+    """
+    header = (request.headers.get(_IDEMPOTENCY_HEADER) or "").strip()
+    if header and _CLIENT_IDEMPOTENCY_KEY_RE.match(header):
+        return f"client:{header}"
+    window = int(time.time() // 60)
+    fingerprint = f"{identity_key}|{text}|{window}"
+    return "auto:" + hashlib.sha256(fingerprint.encode("utf-8")).hexdigest()
+
+
 @router.post("/support/messages", response_model=SupportMessageOut)
 async def send_support_message(
+    request: Request,
     payload: SupportMessageInput,
     username: Annotated[str, Depends(_require_username)],
     db: Annotated[Session, Depends(get_db)],
@@ -379,6 +432,37 @@ async def send_support_message(
     if cooldown is not None:
         raise _too_many_failures_error(cooldown)
 
+    # Идемпотентность (#3471). Что именно закрывает этот pre-check — важно не
+    # переоценить: строка в БД (и её idempotency_key) появляется ТОЛЬКО ПОСЛЕ
+    # успешной доставки в Telegram (H1 ниже), поэтому потерю самого запроса на
+    # плече Selectel -> api.telegram.org этот механизм НЕ дедуплицирует — если
+    # `send_message` не удался, ключ нигде не записан, и повтор клиента после
+    # неудачи это законная первая попытка. Реально закрывается другой, тоже
+    # частый случай: доставка УЖЕ состоялась (Telegram принял, строка
+    # закоммичена), но ответ до клиента не дошёл (обрыв на обратном пути,
+    # клиентский таймаут) или пользователь кликнул "отправить" второй раз по
+    # той же ещё не отрисовавшейся отправке — тогда pre-check находит уже
+    # записанное сообщение по ключу и отдаёт его же, не уходя в Telegram снова.
+    # Тред может ещё не существовать (это первая попытка этого ключа) — тогда
+    # сравнивать не с чем, идём в Telegram как обычно; сам факт "нет треда"
+    # здесь безопасен, т.к. тред создаётся ТОЛЬКО в этой же ручке (см. H1) —
+    # если бы сообщение под этим ключом уже было записано, тред уже был бы.
+    idempotency_key = _resolve_idempotency_key(request, identity_key=username, text=payload.text)
+    existing_thread_id = storage.find_thread_id(db, username)
+    if existing_thread_id is not None:
+        existing = storage.find_inbound_by_idempotency_key(
+            db, thread_id=existing_thread_id, idempotency_key=idempotency_key
+        )
+        if existing is not None:
+            logger.info(
+                "web support: repeat send (idempotency key already recorded) "
+                "username=%s thread_id=%d message_id=%s",
+                username,
+                existing_thread_id,
+                existing["id"],
+            )
+            return SupportMessageOut(**existing)
+
     # Общий клиент приложения (#tg-connection-resilience): на каждый запрос
     # свой создавать нельзя — это ноль keep-alive и полный TCP+TLS-хендшейк
     # до api.telegram.org перед каждой отправкой. Живёт в lifespan.
@@ -406,6 +490,7 @@ async def send_support_message(
 
     # Отправка удалась — теперь и только теперь расходуем rate-limit бюджет.
     _send_limiter.record(username)
+    SUPPORT_MESSAGES.labels(channel="web").inc()
     # Канал жив — счётчик отказов считает именно ПОДРЯД идущие отказы.
     _send_failure_limiter.reset(username)
 
@@ -436,6 +521,7 @@ async def send_support_message(
             text_body=payload.text,
             topic_message_id=topic_message_id,
             support_chat_id=settings.telegram_support_chat_id,
+            idempotency_key=idempotency_key,
         )
         db.commit()
     except SQLAlchemyError:
@@ -606,6 +692,31 @@ async def send_anon_support_message(
             raise _too_many_failures_error(cooldown)
 
     display_id = _anon_display_id(token)
+
+    # Идемпотентность (#3471) — см. развёрнутый комментарий в авторизованной
+    # ветке. Ограничение специфично для анонимной ветки: если предыдущая
+    # попытка сама провалилась ДО выдачи куки (`is_new_token=True` тогда и
+    # сейчас), identity_key каждый раз новый (случайный токен) и pre-check
+    # структурно не может найти прошлую попытку — это тот же класс проблемы,
+    # что и потеря куки в сети, вне scope этой правки.
+    idempotency_key = _resolve_idempotency_key(request, identity_key=thread_key, text=payload.text)
+    existing_thread_id = storage.find_thread_id(db, thread_key)
+    if existing_thread_id is not None:
+        existing = storage.find_inbound_by_idempotency_key(
+            db, thread_id=existing_thread_id, idempotency_key=idempotency_key
+        )
+        if existing is not None:
+            logger.info(
+                "web support (anon): repeat send (idempotency key already recorded) "
+                "%s thread_id=%d message_id=%s",
+                display_id,
+                existing_thread_id,
+                existing["id"],
+            )
+            if is_new_token:
+                _set_anon_cookie(response, token)
+            return SupportMessageOut(**existing)
+
     # Общий клиент приложения (#tg-connection-resilience): на каждый запрос
     # свой создавать нельзя — это ноль keep-alive и полный TCP+TLS-хендшейк
     # до api.telegram.org перед каждой отправкой. Живёт в lifespan.
@@ -631,6 +742,7 @@ async def send_anon_support_message(
 
     _send_limiter.record(thread_key)
     _anon_ip_limiter.record(ip)
+    SUPPORT_MESSAGES.labels(channel="anon").inc()
     # Канал жив — счётчики отказов считают именно ПОДРЯД идущие отказы.
     _send_failure_limiter.reset(thread_key)
     _anon_ip_failure_limiter.reset(ip)
@@ -654,6 +766,7 @@ async def send_anon_support_message(
             text_body=payload.text,
             topic_message_id=topic_message_id,
             support_chat_id=settings.telegram_support_chat_id,
+            idempotency_key=idempotency_key,
         )
         db.commit()
     except SQLAlchemyError:

tradein-mvp/backend/app/api/v1/trade_in.py

@@ -22,6 +22,7 @@ from app.core.anon_session import get_or_create_anon_session_id
 from app.core.config import settings
 from app.core.db import get_db
 from app.core.ratelimit import SlidingWindowLimiter, _client_ip
+from app.observability.metrics import ESTIMATES, REPORTS_EXPORTED
 from app.schemas.trade_in import (
     AggregatedEstimate,
     AnalogLot,
@@ -560,6 +561,13 @@ async def estimate(
         # #3082: слот возвращаем сразу после дорогой части — инкремент квоты и
         # сериализация ответа ниже дёшевы и слот держать не должны.
         _estimate_slots.release()
+
+    # #3471: считаем оценку "успешно посчитанной" здесь — до квоты и до 429
+    # ниже, потому что расчёт (дорогая часть) уже прошёл. insufficient_data —
+    # тоже успех расчёта: медиана не нашлась не потому что что-то сломалось, а
+    # потому что аналогов не было, это отдельный, а не ошибочный исход.
+    ESTIMATES.labels(outcome="insufficient_data" if result.insufficient_data else "ok").inc()
+
     # #747: атомарно-условный инкремент — источник истины по лимиту. check_and_raise
     # выше остаётся быстрым pre-check (429 до дорогой оценки), но финальное решение
     # тут: при гонке двух /estimate на used=lim-1 второй получит False.
@@ -1013,6 +1021,7 @@ def estimate_pdf(
     brand_obj = _resolve_brand(owner_brand_slug, db)
     pdf_bytes = generate_trade_in_pdf(estimate, input_snapshot, brand=brand_obj)
     filename = f"trade-in-{brand_obj.slug}-{estimate_id}.pdf"
+    REPORTS_EXPORTED.inc()
     logger.info(
         "PDF generated estimate_id=%s brand=%s size=%d",
         estimate_id,
@@ -2201,6 +2210,7 @@ def get_street_deals(
         _percentile,
         _resolve_target_city,
         extract_street_name,
+        region_code_for_address,
     )
 
     now = datetime.now(tz=UTC)
@@ -2244,6 +2254,17 @@ def get_street_deals(
     target_city = _resolve_target_city(address)
     city_filter = "AND LOWER(city) = CAST(:target_city AS text)" if target_city else ""
 
+    # #dkp-corridor-scope (2026-09-12): region_code — обязательный фильтр, в отличие
+    # от city_filter выше (который применяется, только если _resolve_target_city
+    # узнал город обл.66). extract_street_name после фикса московского порядка
+    # ("Название улица") стал возвращать имя улицы и для Москвы, а
+    # _resolve_target_city знает ТОЛЬКО города обл.66 → для Москвы target_city=None,
+    # city_filter пуст, и без region_code одноимённая улица другого региона
+    # подмешалась бы в выборку (прод-замер: "Ясная" — 168 сделок в 66 и 80 в 77,
+    # "Советская" — 1202 и 17). region_code заполнен у всех deals (66→108 623,
+    # 77→212 937, NULL нет) — фильтр не отрезает ни одной существующей строки.
+    region_code = region_code_for_address(address)
+
     rows = (
         db.execute(
             text(
@@ -2255,6 +2276,7 @@ def get_street_deals(
               AND address ILIKE :street_pattern
               AND address ~* :street_regex
               {city_filter}
+              AND region_code = CAST(:region_code AS integer)
               -- #3256: фильтра по rooms нет — deals.rooms синтезирована из площади
               -- (тот же CASE 30/44/62/85, что area_bucket), т.е. это был второй
               -- ступенчатый фильтр по площади поверх полосы ±15% ниже. Развёрнуто —
@@ -2269,6 +2291,7 @@ def get_street_deals(
                 "street_pattern": "%" + street_name + "%",
                 "street_regex": r"\m" + street_name + r"\M",
                 "target_city": target_city.lower() if target_city else None,
+                "region_code": region_code,
                 "area_min": area_min,
                 "area_max": area_max,
                 "period_months": period_months,
@@ -2503,7 +2526,12 @@ def get_sales_vs_listings(
 
     Per-street view: Росреестр open dataset агрегирует адреса до улицы.
     """
-    from app.services.estimator import _percentile, _resolve_target_city, extract_street_name
+    from app.services.estimator import (
+        _percentile,
+        _resolve_target_city,
+        extract_street_name,
+        region_code_for_address,
+    )
 
     def _empty(reason_street: str | None = None) -> SalesVsListingsResponse:
         return SalesVsListingsResponse(
@@ -2533,16 +2561,36 @@ def get_sales_vs_listings(
     # известная H1) → фильтр не применяется на TVF-стороне (см. миграцию 205).
     target_city = _resolve_target_city(address)
 
+    # #dkp-corridor-scope (2026-09-12): region_code — фильтр ДОПОЛНИТЕЛЬНО к
+    # target_city выше, нужен по той же причине, что и в /street-deals: для
+    # Москвы _resolve_target_city (словарь городов ТОЛЬКО обл.66) возвращает
+    # None → target_city-фильтр внутри TVF (миграция 205) не срабатывает ни
+    # для deals, ни для listings, и одноимённая улица другого региона
+    # подмешивается в пары (см. estimator.region_code_for_address).
+    #
+    # TVF street_sales_vs_listings() (миграция 205) параметра региона не
+    # знает — сама TVF не трогается (это отдельная миграция, вне текущего
+    # фикса), фильтр применён СНАРУЖИ: оборачиваем вызов в JOIN на deals по
+    # deal_id и фильтруем region_code ТОЛЬКО на стороне сделок. Сторона
+    # listings внутри TVF остаётся НЕ отфильтрованной по региону — это
+    # известный узкий компромисс, не побочный эффект: у listings нет
+    # общего для всех источников поля региона (city заполнен частично, см.
+    # комментарий 205 выше), а сам JOIN внутри TVF уже требует совпадения
+    # street_pattern + rooms + area + date proximity, что резко сужает шанс
+    # чужого региона на listing-стороне. Полный фикс (передать region_code
+    # внутрь TVF седьмым/восьмым параметром) — отдельная миграция.
+    region_code = region_code_for_address(address)
+
     rows = (
         db.execute(
             text(
                 """
             SELECT
-                deal_id, deal_date, deal_price_rub, deal_price_per_m2,
-                deal_area_m2, deal_rooms, deal_floor, deal_address,
-                listing_id, listing_source, listing_source_url,
-                listing_date, listing_price_rub, listing_price_per_m2,
-                listing_area_m2, days_listing_to_deal, discount_pct
+                sv.deal_id, sv.deal_date, sv.deal_price_rub, sv.deal_price_per_m2,
+                sv.deal_area_m2, sv.deal_rooms, sv.deal_floor, sv.deal_address,
+                sv.listing_id, sv.listing_source, sv.listing_source_url,
+                sv.listing_date, sv.listing_price_rub, sv.listing_price_per_m2,
+                sv.listing_area_m2, sv.days_listing_to_deal, sv.discount_pct
             FROM street_sales_vs_listings(
                 CAST(:street_pattern AS text),
                 CAST(:area_m2 AS numeric),
@@ -2551,7 +2599,9 @@ def get_sales_vs_listings(
                 CAST(:area_tolerance AS numeric),
                 CAST(:period_months AS integer),
                 CAST(:target_city AS text)
-            )
+            ) sv
+            JOIN deals d ON d.id = sv.deal_id
+            WHERE d.region_code = CAST(:region_code AS integer)
             """
             ),
             {
@@ -2562,6 +2612,7 @@ def get_sales_vs_listings(
                 "area_tolerance": area_tolerance,
                 "period_months": period_months,
                 "target_city": target_city,
+                "region_code": region_code,
             },
         )
         .mappings()

tradein-mvp/backend/app/core/auth_db.py

@@ -47,6 +47,7 @@ from sqlalchemy.exc import ArgumentError
 from sqlalchemy.orm import Session, sessionmaker
 
 from app.core.config import settings
+from app.core.db import DB_CONNECT_ARGS
 
 
 class AuthDatabaseNotConfiguredError(RuntimeError):
@@ -101,6 +102,18 @@ def _build() -> tuple[Engine, sessionmaker[Session]]:
             # НЕ закрывает: текст ошибки самого драйвера (Postgres DETAIL со значением)
             # и сырые psycopg-подключения мимо движков — это отдельный класс.
             hide_parameters=True,
+            # #3463. Те же потолки, что у продуктового движка, — ОДНОЙ константой на оба:
+            # потолок на одном движке и мина на втором это не починка, а половина.
+            # Этот движок живёт на ГОРЯЧЕМ пути: `core/rbac.py` резолвит session-cookie
+            # в middleware, синхронно на event loop'е, на КАЖДОМ запросе с cookie
+            # (на проде IDENTITY_STORE=auth во всех трёх сервисах образа — сверено 12.09,
+            # `printenv` в контейнерах). Без потолка `ACCESS EXCLUSIVE` на `auth.sessions`
+            # вешает не четыре слота `/estimate`, а весь uvicorn-воркер (он один, без
+            # --workers) — включая `/health`.
+            # Срабатывание потолка безопасно: вызов в rbac.py уже под `except Exception`
+            # с фолбэком на заголовочную аутентификацию, то есть отмена запроса даёт тот
+            # же путь, что и любой другой сбой реестра, а не 500.
+            connect_args=DB_CONNECT_ARGS,
         )
     except (ArgumentError, ValueError):
         # ValueError — не паранойя: на «почти URL» разбор SQLAlchemy доходит до

tradein-mvp/backend/app/core/config.py

@@ -1287,6 +1287,69 @@ class Settings(BaseSettings):
     telegram_alerts_chat_id: int = Field(default=0, validation_alias="TELEGRAM_ALERTS_CHAT_ID")
     telegram_alerts_topic_id: int = Field(default=0, validation_alias="TELEGRAM_ALERTS_TOPIC_ID")
 
+    # Общий (не per-тему) лимит частоты отправки в ОДНУ группу — Telegram
+    # считает ~20 сообщений/минуту на группу суммарно по всем её темам (#3471:
+    # всплеск GlitchTip-алертов + поток поддержки в ту же группу давали 429 и
+    # потерю сообщений). `TELEGRAM_SUPPORT_CHAT_ID`/`TELEGRAM_ALERTS_CHAT_ID` на
+    # проде равны (одна группа, темы разные) — обе половины делят один
+    # площадочный бюджет.
+    #
+    # РАЗДЕЛЕНО ПО РОЛЯМ (review H2, #3471), а не одна общая константа: лимитер
+    # живёт in-memory В ЭКЗЕМПЛЯРЕ `TelegramClient`, а в эту группу пишут ДВА
+    # независимых процесса — API под uvicorn (`app/services/tgbot/shared.py`,
+    # интерактивные ручки + GlitchTip-вебхук) и контейнер бота (`app/tgbot_main.py`,
+    # long-polling воркер). У них НЕТ общего счётчика (это отдельная задача —
+    # Redis-based распределённый лимитер), поэтому если каждому дать по 18,
+    # сумма (2×18=36) УДВОИТ площадочный лимit и 429 вернётся ровно там же.
+    # Бюджет делится статически так, чтобы СУММА была заметно НИЖЕ ~20: у API
+    # больше — там же интерактивные ответы клиентам, у бота меньше — там же
+    # обычно только зеркалирование/уведомления, которые могут подождать дольше
+    # (см. `TelegramGroupRateLimiter.acquire` про `max_wait=None` для фона).
+    # 0/отрицательное значение выключает лимитер для соответствующего процесса.
+    #
+    # ЧЕСТНО ПРО ОГРАНИЧЕНИЕ ЭТОГО ДИЗАЙНА (review, #3471):
+    # `telegram_group_rate_limit_api_per_minute` — ОДИН общий бюджет на ВСЕ
+    # отправки процесса API в эту группу, а туда
+    # пишут И зеркала веб-чата поддержки (`app/api/v1/support.py`), И
+    # GlitchTip-алерты (`app/api/v1/glitchtip.py`) — обе ручки идут через один
+    # и тот же `get_telegram_client()` (см. `app/services/tgbot/shared.py`).
+    # Приоритета между ними НЕТ: кто первый встал в очередь `TelegramGroupRateLimiter`,
+    # тот и получил слот. Оба пути передают узкий `timeout` (5с у support, 8с у
+    # glitchtip) — он же становится потолком ожидания слота (см.
+    # `TelegramClient._request`, review H1). Значит при всплеске алертов (пачка
+    # ошибок прода бьёт в вебхук залпом) реально возможен сценарий: бюджет
+    # 12/мин исчерпан алертами → следующая отправка живого клиента в веб-чате
+    # ждёт до 5с и получает `TelegramRateLimitedError` → 502 клиенту поддержки.
+    # То есть при достаточно большом всплеске алертов веб-чат ДЕЙСТВИТЕЛЬНО
+    # может временно вставать. Разделить бюджет по ИСТОЧНИКУ (не по процессу) —
+    # отдельная задача: нужен свой `TelegramGroupRateLimiter` на алерты с явно
+    # малой квотой и/или приоритет для support-трафика; здесь НЕ сделано
+    # (вне бюджета этой правки).
+    telegram_group_rate_limit_api_per_minute: int = Field(
+        default=12, validation_alias="TELEGRAM_GROUP_RATE_LIMIT_API_PER_MINUTE"
+    )
+    telegram_group_rate_limit_bot_per_minute: int = Field(
+        default=6, validation_alias="TELEGRAM_GROUP_RATE_LIMIT_BOT_PER_MINUTE"
+    )
+
+    # ── Ретранслятор Bot API через Beget (#3471) ─────────────────────────────
+    # Замер 12.09.2026, оба хоста в одни и те же минуты: `getMe` с Selectel — 9
+    # успешных из 12 (три ConnectTimeout), TCP-443 до адреса Selectel — 5/6, TCP-443
+    # до адреса Beget — 8/8; за сутки 508 строк `network error` в логе бота, за 30
+    # дней 92 обрыва итерации poll loop. Путь до Telegram с Selectel лоссовый, с
+    # Beget чистый (Alertmanager там же шлёт без проблем) — поэтому продуктовый
+    # трафик Bot API идёт через маленький HTTP-ретранслятор на Beget
+    # (`ops/metrics/tg-relay`), а не напрямую.
+    #
+    # Пусто (дефолт) = прежнее поведение, прямой путь к api.telegram.org — это и
+    # есть механизм отката, если ретранслятор сам подведёт. При заданном адресе
+    # клиент (`app/services/tgbot/client.py`) всё равно делает одну попытку
+    # напрямую при транспортном отказе похода на ретранслятор — хуже прямого
+    # пути быть не должно ни при каких условиях.
+    # ENV: TELEGRAM_RELAY_BASE_URL, TELEGRAM_RELAY_SECRET.
+    telegram_relay_base_url: str = Field(default="", validation_alias="TELEGRAM_RELAY_BASE_URL")
+    telegram_relay_secret: str = Field(default="", validation_alias="TELEGRAM_RELAY_SECRET")
+
     # ── Платёжный контур МЕРЫ (Т-Банк эквайринг) — схема-only PR-B ──────────
     # См. `mera-tbank-acquiring-recon.md` в корне репо. Этот PR НЕ содержит
     # роутеров/httpx-клиента/подписи Token — только поля конфига и kill-switch.

tradein-mvp/backend/app/core/db.py

@@ -10,10 +10,59 @@ from app.core.config import settings
 
 logger = logging.getLogger(__name__)
 
+# #3463. Потолок ОДНОГО statement'а, секунды·1000. Ставится на КОННЕКТЕ (libpq
+# `options`), а не в питоновской обёртке: обёртка (`run_db_thread` ниже) при
+# отмене обязана ДОЖДАТЬСЯ потока, иначе поток остаётся сиротой в общей
+# `Session` — ровно то, ради чего писался #3449. Значит верхняя граница ожидания
+# = длительность самого запроса, и задать её может только сервер.
+#
+# 30 с выбраны так, чтобы потолок НИКОГДА не стал биндящим ограничением для
+# честной работы, но остался конечным:
+#   * самый длинный ОБЪЯВЛЕННЫЙ бюджет на `/estimate` — 20 с (`estimate_avito_imv_timeout_s`,
+#     config.py:852); дальше 12 с геокод, 8 с Yandex/Cian/house_meta. 30 с = 1.5× от максимума;
+#   * ОСНОВНАЯ опора по планировщику — `scrape_runs` (длительности целых прогонов, они
+#     не вытесняются): самая долгая ЧИСТО-БД задача за 14 суток — listing_source_snapshot,
+#     9.7 с ЦЕЛИКОМ (и у неё сверх того свой `SET LOCAL statement_timeout = 900000`,
+#     который перекрывает это значение — гейт tests/test_3463_db_timeouts.py);
+#   * самый длинный set-based statement ЧЕРЕЗ движок из замеренных — матч ГАР→houses
+#     (`services/gar_flats_loader._MATCH_SQL`): 2.07 с с городским фильтром и 6.46 с без
+#     него (`city_filter=None`, флаг CLI). Запас ~3×, и это СЧИТАЮЩИЙ запрос, а не ждущий.
+#
+# `pg_stat_statements` опорой по планировщику НЕ является: при `max = 5000` он вытесняет
+# редкие записи (проверено 12.09 — `dealloc` вырос на единицу за десять минут, и из топа
+# пропали ВСЕ записи с `calls = 1`, включая `REFRESH MATERIALIZED VIEW` 30.85 с и KNN
+# `cadastral_geo_match` 2.45 с). Суточная задача до следующих суток там не доживает, так
+# что «самый долгий запрос 4.27 с» верно только для ВЫСОКОЧАСТОТНЫХ запросов.
+_STATEMENT_TIMEOUT_MS = 30_000
+
+# Ожидание БЛОКИРОВКИ — заведомо меньше: ждать лок дольше секунд смысла нет, лучше
+# деградировать. 5 с — та же величина, что у миграций проекта
+# (`SET LOCAL lock_timeout = '5s'` в data/sql/250,251,260,272,277…), снизу ограничена
+# deadlock_timeout (на проде 1 с — сверено 12.09). Именно этот потолок закрывает
+# сценарий #3463: под `ACCESS EXCLUSIVE` на `geocode_cache` запрос ЖДЁТ лок, а не
+# считает, — statement_timeout тут только страховка от «считает вечно».
+_LOCK_TIMEOUT_MS = 5_000
+
+# idle_in_transaction_session_timeout НАМЕРЕННО не трогаем: тем же движком живёт tgbot,
+# и `services/tgbot/bridge.py` держит транзакцию открытой ПОВЕРХ long-poll Telegram
+# (замер на проде 12.09, 3 пробы с шагом 7 с: одна и та же сессия, запрос
+# `SELECT value FROM tg_support_state …`, возраст транзакции циклически растёт до ~29 с).
+# Сессионный потолок на простой в транзакции ронял бы long-poll КАЖДЫЙ цикл —
+# гарантированно, а не в редком случае.
+DB_CONNECT_ARGS = {
+    "options": f"-c statement_timeout={_STATEMENT_TIMEOUT_MS} -c lock_timeout={_LOCK_TIMEOUT_MS}"
+}
+
 engine = create_engine(
     settings.database_url,
     pool_pre_ping=True,
     future=True,
+    # #3463. Накрывает ВСЕ три сервиса образа (backend / scraper / tgbot — один и тот
+    # же `app.core.db`, см. docker-compose.prod.yml) и обе стороны: продуктовый путь
+    # `/estimate` и задачи планировщика. Миграции идут мимо (psql из
+    # .forgejo/workflows/deploy-tradein.yml, не этот движок) — их DDL под своим
+    # `SET LOCAL lock_timeout` и потолком не ограничен.
+    connect_args=DB_CONNECT_ARGS,
     # #3194: SQLAlchemy печатает ВСЕ bind-параметры в тексте StatementError —
     # через них в GlitchTip уезжали ключ шифрования кук и сами куки
     # (pgp_sym_encrypt(:cookies_json, :key)). Флаг на УРОВНЕ ДВИЖКА кроет все

tradein-mvp/backend/app/main.py

@@ -19,6 +19,7 @@ from sentry_sdk.integrations.httpx import HttpxIntegration
 from sentry_sdk.integrations.logging import LoggingIntegration
 from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
 from sentry_sdk.integrations.starlette import StarletteIntegration
+from sentry_sdk.types import Event, Hint
 
 from app.api.public import mera as public_mera
 from app.api.v1 import (
@@ -79,31 +80,43 @@ install_query_secret_filter()
 # frontend), отдельного broker нет → мониторить нечего.
 if settings.glitchtip_dsn:
     from app.observability.sentry_scrub import (
+        drop_payments_disabled_event,
         redact_telegram_bot_token,
         scrub_payment_request_body,
         scrub_public_address,
         stabilize_retry_error_fingerprint,
     )
 
-    def _before_send(event: dict[str, object], hint: dict[str, object]) -> dict[str, object] | None:
-        """Композиция платёжный body-wipe + PII-scrub + Telegram bot-токен redaction +
-        RetryError fingerprint-стабилизация (#tgsupport-web, PR-D2, glitchtip-noise) —
-        см. app/tgbot_main.py._before_send (идентичная композиция без последнего шага,
-        тот бот geocoder не зовёт). Тот же риск: теперь этот процесс тоже держит
-        TelegramClient в стек-фреймах при ошибке sendMessage, а
+    def _before_send(event: Event, hint: Hint) -> Event | None:
+        """Композиция payments-disabled drop + платёжный body-wipe + PII-scrub +
+        Telegram bot-токен redaction + RetryError fingerprint-стабилизация
+        (#tgsupport-web, PR-D2, glitchtip-noise, #3471) — см.
+        app/tgbot_main.py._before_send (идентичная композиция без последнего
+        шага, тот бот geocoder не зовёт). Тот же риск: теперь этот процесс тоже
+        держит TelegramClient в стек-фреймах при ошибке sendMessage, а
         include_local_variables=False ниже — первый рубеж защиты.
 
-        PR-D2: платёжный body-wipe идёт ПЕРВЫМ шагом, а не заменяет остальные —
-        режет `request.data` целиком только для `/payments/*`, остальные пути
-        (extra/contexts/traceback) по-прежнему проходят ключ-based scrub и
-        token-redaction. Тот же обработчик передан ОБОИМ каналам ниже
-        (before_send и before_send_transaction) — вчерашний баг в Птице закрыл
-        только error-канал, transaction-канал остался вообще без обработчика.
+        #3471: payments-disabled drop идёт ПЕРВЫМ шагом — это единственный
+        процесс из трёх entrypoint'ов, который реально держит ASGI-роут
+        `/api/v1/payments/*`, поэтому именно здесь события возникают; ранний
+        return None экономит остальную композицию на заведомо отбрасываемом
+        событии.
+
+        PR-D2: платёжный body-wipe идёт следующим шагом, а не заменяет
+        остальные — режет `request.data` целиком только для `/payments/*`,
+        остальные пути (extra/contexts/traceback) по-прежнему проходят
+        ключ-based scrub и token-redaction. Тот же обработчик передан ОБОИМ
+        каналам ниже (before_send и before_send_transaction) — вчерашний баг в
+        Птице закрыл только error-канал, transaction-канал остался вообще без
+        обработчика.
 
         RetryError-стабилизация — этот процесс обслуживает /api/v1/geocode/*
         (suggest/lookup/reverse), которые ретраят Nominatim через tenacity; см.
         sentry_scrub.stabilize_retry_error_fingerprint."""
-        scrubbed = scrub_payment_request_body(event, hint)  # type: ignore[arg-type]
+        dropped = drop_payments_disabled_event(event, hint)  # type: ignore[arg-type]
+        if dropped is None:
+            return None
+        scrubbed = scrub_payment_request_body(dropped, hint)  # type: ignore[arg-type]
         if scrubbed is None:
             return None
         # Публичный периметр МЕРЫ: тело запроса — это ровно введённый адрес, а

tradein-mvp/backend/app/observability/metrics.py

@@ -99,6 +99,47 @@ BUILD_INFO = Gauge(
 # смысл метки в том, чтобы «что было задеплоено в 03:14» отвечалось однозначно.
 BUILD_INFO.labels(app="mera", release=f"{APP_VERSION}+{BUILD_SHA}").set(1)
 
+# ═══ ПРОДУКТОВЫЕ СЧЁТЧИКИ (#3471) ═══════════════════════════════════════════
+#
+# Источник списка — реальные `event_type` из `user_events` (миграция 184) плюс
+# ручки, которые сами в этот аудит-лог не пишут (suggest, PDF-экспорт). Метки
+# везде — фиксированный литерал из кода вызова (outcome/found/channel/result),
+# НЕ значение из запроса: username, адрес, estimate_id в метку не идут —
+# это ровно то, что взрывает кардинальность ряда у Prometheus.
+ESTIMATES = Counter(
+    "mera_estimates_total",
+    "Запрошенных оценок trade-in, по исходу расчёта",
+    labelnames=("outcome",),  # ok | insufficient_data
+)
+
+ADDRESS_SUGGESTIONS = Counter(
+    "mera_address_suggestions_total",
+    "Запросов автокомплита адреса (/geocode/suggest), нашёлся ли результат",
+    labelnames=("found",),  # yes | no
+)
+
+REPORTS_EXPORTED = Counter(
+    "mera_reports_exported_total",
+    "Скачанных PDF-отчётов по оценке trade-in",
+)
+
+LEADS = Counter(
+    "mera_leads_total",
+    "Сохранённых контактных заявок (телефон + согласие) с результата оценки",
+)
+
+SUPPORT_MESSAGES = Counter(
+    "mera_support_messages_total",
+    "Сообщений в поддержку, дошедших до Telegram-топика, по каналу",
+    labelnames=("channel",),  # web | anon
+)
+
+LOGINS = Counter(
+    "mera_logins_total",
+    "Попыток входа в личный кабинет, по исходу",
+    labelnames=("result",),  # success | failed
+)
+
 
 def route_label(scope: Scope) -> str:
     """Шаблон маршрута из ASGI-scope, либо ``__unmatched__``.

tradein-mvp/backend/app/observability/sentry_scrub.py

@@ -25,6 +25,7 @@ import re
 from typing import Any
 
 from sentry_sdk.types import Event
+from starlette.exceptions import HTTPException as _StarletteHTTPException
 from tenacity import RetryError
 
 _REDACTED = "[REDACTED]"
@@ -256,6 +257,41 @@ def scrub_payment_request_body(event: Event, _hint: dict[str, Any]) -> Event | N
     return event
 
 
+_PAYMENTS_DISABLED_DETAIL = "payments are disabled"
+
+
+def drop_payments_disabled_event(event: Event, hint: dict[str, Any]) -> Event | None:
+    """before_send-хук: роняет 503 "payments are disabled" из
+    `payments.py._require_enabled` (issue #3471, GlitchTip-группа TRADE-IN-3GG).
+
+    Источник — внутренний IP смоук-проверки: кнопки оплаты во фронте нет,
+    клиентского трафика на эти пути нет вообще, а выключенный платёжный контур
+    (`settings.payments_enabled=False`) штатно отвечает 503 на каждый такой
+    запрос — 167 событий за 29.08-12.09 размывали ленту, на этом фоне терялась
+    настоящая ошибка. Само поведение ручки НЕ меняется (503 остаётся) —
+    фильтруется только репортинг в трекер: sentry_sdk `StarletteIntegration`
+    репортит любой `HTTPException` с кодом из `failed_request_status_codes`
+    (по умолчанию весь диапазон 5xx) как error-событие, даже когда исключение
+    штатно обработано FastAPI и превращено в корректный HTTP-ответ.
+
+    Матчим `isinstance` реального объекта исключения из `hint["exc_info"]` (тот
+    же контракт, что `stabilize_retry_error_fingerprint` ниже) + точный текст
+    `detail` — НЕ код 503 сам по себе, чтобы не проглотить другие 503 (напр.
+    будущий maintenance-режим другого роутера).
+    """
+    if not isinstance(event, dict):
+        return event
+    exc_info = hint.get("exc_info") if isinstance(hint, dict) else None
+    exc_value = exc_info[1] if exc_info and len(exc_info) > 1 else None
+    if (
+        isinstance(exc_value, _StarletteHTTPException)
+        and exc_value.status_code == 503
+        and exc_value.detail == _PAYMENTS_DISABLED_DETAIL
+    ):
+        return None
+    return event
+
+
 _PUBLIC_API_URL_SEGMENT = "/api/public/"
 
 #: Хосты геокодеров: их URL несёт введённый адрес прямо в query.

tradein-mvp/backend/app/scheduler_main.py

@@ -43,14 +43,16 @@ if settings.glitchtip_dsn:
     from sentry_sdk.integrations.httpx import HttpxIntegration
     from sentry_sdk.integrations.logging import LoggingIntegration
     from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
+    from sentry_sdk.types import Event, Hint
 
     from app.observability.sentry_scrub import (
+        drop_payments_disabled_event,
         scrub_payment_request_body,
         scrub_pii_event,
         stabilize_retry_error_fingerprint,
     )
 
-    def _before_send(event: dict, hint: dict) -> dict | None:  # type: ignore[type-arg]
+    def _before_send(event: Event, hint: Hint) -> Event | None:
         """PR-D2: этот процесс не держит ASGI-приложения (нет `request` в event
         сегодня), но payments_confirm/payments_reconcile (PR-E, тот же
         `tradein-scraper` контейнер) будут звать Т-Банк API отсюда — belt-and-
@@ -58,6 +60,13 @@ if settings.glitchtip_dsn:
         `request`/`extra`. Тот же обработчик на оба канала ниже — см.
         app/main.py._before_send (идентичный мотив, не дублировать без причины).
 
+        #3471: payments-disabled drop — тот же belt-and-suspenders мотив, что и
+        payment body-wipe выше по докстрингу: этот процесс сегодня не отвечает
+        503 из `_require_enabled` (нет ASGI/роутов), реальный источник шума —
+        `app/main.py`, но фильтр держим одинаковым во всех трёх entrypoint'ах,
+        чтобы поведение не разошлось, если payments-код когда-нибудь переедет
+        сюда же.
+
         PII-scrub + RetryError fingerprint-стабилизация (glitchtip-noise) идут
         следом за платёжным body-wipe: этот процесс гоняет
         `geocode_missing_listings` (ночной batch, сотни адресов за прогон) —
@@ -66,13 +75,16 @@ if settings.glitchtip_dsn:
         на КАЖДЫЙ адрес (RetryError.__str__() тащит нестабильный repr() Future).
         См. sentry_scrub docstring.
         """
-        scrubbed = scrub_payment_request_body(event, hint)  # type: ignore[arg-type]
+        dropped = drop_payments_disabled_event(event, hint)  # type: ignore[arg-type]
+        if dropped is None:
+            return None
+        scrubbed = scrub_payment_request_body(dropped, hint)  # type: ignore[arg-type]
         if scrubbed is None:
             return None
-        scrubbed = scrub_pii_event(scrubbed, hint)
+        scrubbed = scrub_pii_event(scrubbed, hint)  # type: ignore[arg-type]
         if scrubbed is None:
             return None
-        return stabilize_retry_error_fingerprint(scrubbed, hint)
+        return stabilize_retry_error_fingerprint(scrubbed, hint)  # type: ignore[arg-type,return-value]
 
     sentry_sdk.init(
         dsn=settings.glitchtip_dsn,

tradein-mvp/backend/app/services/cian_price_history.py

@@ -131,7 +131,7 @@ async def backfill_cian_price_history(
             # Fail-closed (#2616): пул пуст/недоступен в проде. Остальные листинги
             # упрутся в то же самое — рвём батч сразу, а не 50 раз по 5 секунд с
             # логом, который читается как «Циан нас блокирует».
-            logger.error(
+            logger.warning(
                 "cian_price_history: нет доступного прокси в пуле (%s) — батч прерван "
                 "на listing_id=%s (обработано %d из %d)",
                 exc,

tradein-mvp/backend/app/services/cian_session.py

@@ -201,7 +201,7 @@ async def verify_session(cookies: dict[str, str]) -> dict[str, Any] | None:
         # ИМЕННО для cian/нездоровы — НЕ уходим на settings.cian_proxy_url (тот самый
         # статичный узел мог быть источником бана, см. proxy_egress module docstring).
         # Явный отказ вместо слепого прохода через заведомо подозрительный egress.
-        logger.error(
+        logger.warning(
             "Cian cookies verify: пул прокси исчерпан для cian (%s) — verify пропущен, "
             "cookies НЕ помечены протухшими, retry на следующем такте",
             exc,

tradein-mvp/backend/app/services/estimator.py

@@ -328,6 +328,13 @@ SBER_TIME_ADJUST_REGION = "Свердловская область"  # ряд р
 _SBER_REGION_SERIES: dict[int, str] = {
     66: SBER_TIME_ADJUST_REGION,
     77: "Москва",
+    # Московская область — свой ряд, а не фолбэк на «Россию». Загрузчик научился
+    # тянуть REF_AREA=50 (services/sber_index), и 12.09.2026 ряд приехал на прод:
+    # real_estate_deals/«Вторичный», 116 месяцев 2017-01..2026-08 — та же глубина,
+    # что у Москвы и обл.66. До этой строки область считалась по общероссийскому
+    # ряду, то есть коридор ошибался на расхождение области со страной; теперь
+    # ошибка только внутрирегиональная.
+    50: "Московская область",
 }
 
 # Ряд для региона ВНЕ карты. Выбран общероссийский, а не отказ от поправки (1.0):
@@ -1991,6 +1998,38 @@ def _resolve_target_city(address_text: str | None) -> str | None:
     return None
 
 
+def region_code_for_address(address: str | None) -> int:
+    """Код региона покрытия (regions.REGIONS) по городу в адресе.
+
+    Режет адрес по запятым, каждый сегмент — strip+lower, ищет ТОЧНОЕ
+    совпадение с одним из городов региона (regions.region_by_city). Точное
+    равенство сегмента, а НЕ подстрока: подстрочный поиск "москва" в адресе
+    поймал бы екатеринбургскую "Московская улица" и увёл её в регион 77 —
+    сегмент "московская улица" целиком ≠ "москва".
+
+    #dkp-corridor-scope (2026-09-12): нужен для WHERE region_code = ... в
+    get_street_deals/get_sales_vs_listings — extract_street_name после фикса
+    московского порядка ("Название улица") стал возвращать имя улицы и для
+    Москвы, и без явного region-скоупа одноимённая улица из другого региона
+    (66 vs 77) подмешивалась бы в медиану (напр. "Ясная": 168 сделок в 66 и
+    80 в 77, "Советская": 1202 и 17).
+
+    Returns regions.DEFAULT_REGION_CODE (66), если ни один сегмент не
+    распознан как город ни одного региона — байт-в-байт прежнее поведение
+    (все ЕКБ/безымянные адреса и раньше трактовались как регион 66).
+    """
+    if not address:
+        return regions_mod.DEFAULT_REGION_CODE
+    for raw_segment in address.split(","):
+        segment = raw_segment.strip()
+        if not segment:
+            continue
+        region = regions_mod.region_by_city(segment)
+        if region:
+            return region.code
+    return regions_mod.DEFAULT_REGION_CODE
+
+
 def _fetch_dkp_corridor(
     db: Session,
     *,
@@ -5987,12 +6026,34 @@ def _extract_short_addr(full_address: str | None) -> str | None:
 # идентичный результат (см. test_street_deals_endpoint.py). Бывшая отдельная
 # bare-альтернатива "мкр" убрана как ставшая избыточной — "мкр\.?" уже
 # покрывает оба варианта (с точкой и без).
-_STREET_KW_RE = re.compile(
-    r"(?<![А-Яа-яёЁa-zA-Z])"
+# Общий список street-keyword альтернатив — единственное место, где он
+# перечислен. И _STREET_KW_RE (forward, требует \s+ после), и
+# _STREET_KW_SUFFIX_RE (moscow-reverse, без \s+) собираются из этой же
+# константы, чтобы при добавлении нового типа улицы (аллея/линия/...) их
+# списки не разъехались независимой правкой одного из двух regex.
+_STREET_KW_ALTERNATION = (
     r"(?:ул\.?|улица|пр\.?|пр-т|проспект|пер\.?|переулок|"
     r"б-р|бульвар|ш\.?|шоссе|наб\.?|набережная|проезд|тракт|"
     r"пл\.?|площадь|мкр\.?|микрорайон)"
-    r"\s+",
+)
+
+_STREET_KW_RE = re.compile(
+    r"(?<![А-Яа-яёЁa-zA-Z])" + _STREET_KW_ALTERNATION + r"\s+",
+    flags=re.IGNORECASE | re.UNICODE,
+)
+
+# Тот же список keyword'ов (_STREET_KW_ALTERNATION), но БЕЗ обязательного
+# \s+ после них — вместо этого lookahead на запятую/пробел/конец строки.
+# Нужен для московского формата "Название улица, 6" (Тверская улица,
+# Ленинский проспект, Брюсов переулок): там сразу после keyword идёт запятая,
+# и _STREET_KW_RE (требующий \s+) вообще не матчит эту позицию — ни keyword,
+# ни имя после него найти нельзя. Используется ТОЛЬКО как fallback ниже,
+# после того как forward-путь через _STREET_KW_RE не дал результата — может
+# дать результат там, где раньше был None (напр. keyword найден, но имя
+# после него не распарсилось: "Тверская ул. 6"); непустые результаты
+# форматов, которые уже что-то возвращали, не меняются.
+_STREET_KW_SUFFIX_RE = re.compile(
+    r"(?<![А-Яа-яёЁa-zA-Z])" + _STREET_KW_ALTERNATION + r"(?=[,\s]|$)",
     flags=re.IGNORECASE | re.UNICODE,
 )
 
@@ -6017,10 +6078,29 @@ def extract_street_name(full_address: str | None) -> str | None:
       "ул. Большая Конюшенная, 25"                              → "Большая Конюшенная"
       ""                                                        → None
 
+    Московский формат — keyword стоит ПОСЛЕ имени улицы ("Название улица, N"),
+    а не перед ним:
+      "Москва, Тверская улица, 6"                               → "Тверская"
+      "Москва, 1-я Тверская-Ямская улица, 12"                   → "1-я Тверская-Ямская"
+      "Москва, Брюсов переулок, 8"                               → "Брюсов"
+      "Москва, Ленинский проспект, 30"                           → "Ленинский"
+      "Театр имени М. Н. Ермоловой, 5/6, Тверская улица, 58,
+       Тверской район, Москва, Центральный федеральный округ,
+       125009, Россия" (reverse-формат Nominatim)                → "Тверская"
+      "Москва, Проектируемый проезд № 4062, 5"                  → None (безымянный
+                                                                     нумерованный проезд)
+
     Алгоритм:
-    1. Ищем street-keyword (ул/улица/пр/проспект/...) — case-insensitive.
-    2. После keyword берём 1-3 слова до запятой или номера дома.
-    3. Если keyword не нашёлся — пытаемся первый capitalized токен с
+    1. Ищем street-keyword (ул/улица/пр/проспект/...) — case-insensitive,
+       берём 1-3 слова ПОСЛЕ него до запятой или номера дома (forward-формат).
+    2. Московский формат: сразу после keyword — запятая/конец строки (имени
+       после него нет, т.к. keyword в этом формате идёт ПОСЛЕ названия).
+       Ищем keyword ещё раз без требования пробела после него и берём 1-3
+       слова ДО keyword внутри той же запятой-секции ("Тверская улица, 6" →
+       "Тверская"). Не срабатывает, если сразу после keyword — "№"
+       (нумерованный проезд без имени, напр. "Проектируемый проезд №
+       4062" — извлекать нечего, "Проектируемый" НЕ street name).
+    3. Если keyword не нашёлся вовсе — пытаемся первый capitalized токен с
        поиском до запятой или номера (fallback для адресов без keyword'а).
 
     Returns None если ничего не извлеклось.
@@ -6038,7 +6118,27 @@ def extract_street_name(full_address: str | None) -> str | None:
         if nm:
             return nm.group(1).strip()
 
-    # 2. Fallback: нет keyword — пробуем первый capitalized токен
+    # 2. Московский формат "Название улица, N": keyword идёт ПОСЛЕ имени, и
+    # сразу за ним запятая/конец строки — _STREET_KW_RE (шаг 1) такую позицию
+    # вообще не матчит, т.к. требует \s+ сразу после keyword. Берём keyword
+    # отдельно (без требования пробела) и смотрим на слова ДО него в пределах
+    # той же запятой-секции.
+    km = _STREET_KW_SUFFIX_RE.search(s)
+    if km:
+        # Исключение: "Проектируемый проезд № 4062" — keyword с числовым
+        # индексом БЕЗ имени (forward-паттерн "keyword № N", не moscow-
+        # reverse). Слово перед keyword ("Проектируемый") здесь — прилагательное
+        # к самому "проезду", а не имя улицы; сотни таких проездов имеют один
+        # и тот же "Проектируемый" — коридор по нему смешал бы все их сделки.
+        after = s[km.end() :].lstrip()
+        if not after.startswith("№"):
+            segment_start = s.rfind(",", 0, km.start()) + 1
+            before = s[segment_start : km.start()].strip()
+            words = before.split()
+            if words:
+                return " ".join(words[-3:])
+
+    # 3. Fallback: нет keyword — пробуем первый capitalized токен
     # Используется для "Большая Конюшенная, 25" без "ул."
     nm = _STREET_NAME_RE.match(s)
     if nm:

tradein-mvp/backend/app/services/product_handlers.py

@@ -325,6 +325,34 @@ async def _job_landing_stats(
     await loop.run_in_executor(None, refresh_landing_stats, db, run_id, params)
 
 
+# ── landing_showcase_deals — sync пересчёт витрины сделок в executor ─────────
+async def _job_landing_showcase_deals(
+    db: Session, run_id: int, params: dict[str, Any], ctx: SchedulerContext
+) -> None:
+    """Пересчёт витрины сделок публичного лэндинга (#3469).
+
+    ЛАЙФСАЙКЛ ПРОГОНА ВЕДЁТ HANDLER, а не задача. `refresh_landing_showcase_deals`
+    писалась под ручной запуск (`python -m app.tasks.landing_showcase_deals`) и про
+    `run_id` ничего не знает — тот же случай, что у `_job_refresh_search_matview`,
+    и решается так же: done/failed ставим здесь.
+
+    Параметры берём ИЗ РАСПИСАНИЯ только те, что в нём есть: дефолты живут в
+    сигнатуре задачи, и повтор их здесь дал бы два места, которые разъедутся.
+    """
+    from app.tasks.landing_showcase_deals import refresh_landing_showcase_deals
+
+    kwargs = {k: params[k] for k in ("sample", "since", "limit", "city") if k in params}
+    loop = asyncio.get_event_loop()
+    try:
+        counters = await loop.run_in_executor(
+            None, lambda: refresh_landing_showcase_deals(db, **kwargs)
+        )
+        ctx.runs.mark_done(db, run_id, counters)
+    except Exception:
+        logger.exception("scheduler: landing_showcase_deals crashed run_id=%d", run_id)
+        ctx.runs.mark_failed(db, run_id, "landing_showcase_deals failed", {})
+
+
 # ── sber_freshness_monitor — sync DB-only freshness check в executor ──────────
 async def _job_sber_freshness_monitor(
     db: Session, run_id: int, params: dict[str, Any], ctx: SchedulerContext
@@ -911,6 +939,7 @@ def build_product_handlers(ctx: SchedulerContext) -> dict[str, Handler]:
         "deals_freshness_monitor": Handler(_job_deals_freshness_monitor, "deals_freshness_monitor"),
         "sber_freshness_monitor": Handler(_job_sber_freshness_monitor, "sber_freshness_monitor"),
         "landing_stats_refresh": Handler(_job_landing_stats, "landing_stats_refresh"),
+        "landing_showcase_deals": Handler(_job_landing_showcase_deals, "landing_showcase_deals"),
         "newbuilding_enrich": Handler(_job_newbuilding_enrich, "newbuilding_enrich"),
         "yandex_newbuilding_sweep": Handler(
             _job_yandex_newbuilding_sweep, "yandex_newbuilding_sweep"

tradein-mvp/backend/app/services/proxy_egress.py

@@ -302,7 +302,7 @@ def resolve_proxy_url(db: Session, source: str) -> str | None:
 
     # Сценарий 2: пул РЕАЛЬНО не пуст, но для source не осталось ни одного
     # здорового/небаненного узла -- fail-closed (#2616), НЕ fallback на env.
-    logger.error(
+    logger.warning(
         "proxy_egress: source=%s -- пул scrape_proxies НЕ пуст (%d узлов), но НИ ОДИН "
         "не прошёл фильтр для этого источника (banned_for_source=%d, "
         "unhealthy_or_disabled=%d) -- FAIL-CLOSED (#2616): отказ, БЕЗ обхода через "

tradein-mvp/backend/app/services/proxy_pool.py

@@ -1309,6 +1309,8 @@ async def _probe_proxy(url: str) -> tuple[bool, str | None, int | None, str | No
     транзиентный сбой узла ≠ перманентный бан, используется пока только для логов):
       - "timeout"       — сеть недоступна/медленная (httpx.TimeoutException)
       - "connect_error" — прокси не поднят/не слушает/DNS (httpx.ConnectError)
+      - "proxy_error"   — сам прокси отверг соединение (httpx.ProxyError, напр. 407 от
+                          провайдера — это состояние пула, а не инцидент; #3471)
       - "http_error"    — ipify ответил ошибкой через прокси (auth/upstream)
       - "other"         — прочее
 
@@ -1328,6 +1330,14 @@ async def _probe_proxy(url: str) -> tuple[bool, str | None, int | None, str | No
     except httpx.ConnectError:
         logger.warning("proxy_pool: health probe connect_error proxy=%s", _mask(url))
         return False, None, None, "connect_error"
+    except httpx.ProxyError as exc:
+        # #3471: сам прокси-провайдер отверг соединение (чаще всего 407 —
+        # исчерпан лимит/просрочен пакет) — штатный исход health-пробы, не
+        # инцидент приложения. Одна строка без трейса: узел + причина текстом
+        # исключения, полный traceback здесь не несёт новой информации и только
+        # засорял логи (184 строки/сутки, #3471).
+        logger.warning("proxy_pool: health probe proxy_error proxy=%s reason=%s", _mask(url), exc)
+        return False, None, None, "proxy_error"
     except httpx.HTTPStatusError as exc:
         logger.warning(
             "proxy_pool: health probe http_error proxy=%s status=%s",

tradein-mvp/backend/app/services/regions.py

@@ -28,9 +28,18 @@ class Region:
     """Один регион покрытия продукта.
 
     bbox_tight  — ядро города: geocoder-фильтрация фуззи-матчей провайдеров
-                  (не принять соседний город за совпадение по опечатке).
+                  (не принять соседний город за совпадение по опечатке). У
+                  региона БЕЗ одного центрального города (50 — область, много
+                  сопоставимых по объёму городов, ни один не «ядро») — равен
+                  bbox_product_core: эмпирический пояс, где данные РЕАЛЬНО
+                  наблюдались (перцентили 0.5..99.5 координат сырья), а не
+                  административная граница — см. REGIONS[50] и обоснование там.
     bbox_wide   — город + легитимное приграничье: ingest-guard координат,
                   ПРИШЕДШИХ ИЗВНЕ (detail-страницы площадок). Содержит tight.
+                  У 50 — полный наблюдённый диапазон координат (min..max, без
+                  перцентильной обрезки) вместо «город + отступ»: без своего
+                  города отступать не от чего, поэтому граница «легитимности»
+                  здесь тоже эмпирическая, просто менее обрезанная, чем tight.
     bbox_region — генеральный bbox региона: fallback-accept для провайдеров без
                   структурного region-поля. Содержит wide.
     bbox_product_core — гео-охват ПРОДУКТА в этом регионе: location_index
@@ -38,9 +47,14 @@ class Region:
                   out_of_coverage. У 66 УЖЕ (не равен) tight: исторический bbox
                   location_index (56.70..56.95/60.50..60.75), синхронизирован с
                   EKB_BBOX Overpass-загрузчика POI основного gendesign-бэкенда
-                  (комментарий в обе стороны, см. site_finder/poi_loader.py).
+                  (комментарий в обе стороны, см. site_finder/poi_loader.py). У
+                  50 — намеренно НЕ административный bbox (обещать охват там,
+                  где нет ни одного объявления, нельзя) — эмпирический пояс
+                  фактических данных, см. REGIONS[50].
     city_token  — нормализованный токен главного города (нижний регистр, е==ё
-                  нормализует потребитель — matching.normalize).
+                  нормализует потребитель — matching.normalize). У региона без
+                  единого центра (50) — самый объёмный по данным город, который
+                  ОДНОВРЕМЕННО де-факто административный: см. REGIONS[50].
     cities      — узнаваемые города региона (для city_hint / prefix-логики
                   геокодера). НЕ исчерпывающий список — основные центры.
     enrichment_tiers — какие тиры обогащения РЕАЛЬНО доступны региону.
@@ -159,19 +173,122 @@ REGIONS: dict[int, Region] = {
         # import_rosreestr_dkp подставляет каноничное имя вместо city источника.
         canonical_city="Москва",
     ),
+    50: Region(
+        code=50,
+        name="Московская область",
+        # У области НЕТ города-ядра (в отличие от 66/77) — 20 сопоставимых по
+        # объёму городов-спутников. Поэтому tight/wide/product_core здесь не
+        # «город + отступ», а ЭМПИРИЧЕСКИЙ пояс данных: разброс координат
+        # подмосковного сырья Циан (45 294 строки, отбор по городскому
+        # поддомену ссылки ≠ www, замер на дату добавления региона):
+        #   полный диапазон:      lat 54.673..56.762, lon 35.920..39.888
+        #   перцентили 0.5..99.5: lat 54.834..56.728, lon 36.193..39.545
+        # tight = product_core = перцентильный пояс (без выбросов из хвоста
+        # распределения — то немногое, что уверенно наблюдали). wide = полный
+        # диапазон (min..max) — легитимное приграничье для ingest-guard шире
+        # tight, но всё ещё эмпирическое, не административное.
+        bbox_tight=(54.834, 56.728, 36.193, 39.545),
+        bbox_wide=(54.673, 56.762, 35.920, 39.888),
+        # region — административный bbox МО целиком (fallback-accept должен
+        # покрывать всю область, а не только пояс, где уже есть данные):
+        # lat 54.20..56.96, lon 35.14..40.21.
+        bbox_region=(54.20, 56.96, 35.14, 40.21),
+        # product_core НЕ равен bbox_region: location_index не должен обещать
+        # медианы там, где по факту нет ни одного объявления (deals=0,
+        # listings=0 на дату добавления — импорт 411 056 сделок Росреестра из
+        # FDW идёт отдельным PR). Равен tight — см. выше.
+        bbox_product_core=(54.834, 56.728, 36.193, 39.545),
+        # Красногорск: и самый объёмный город по факту сырья (см. cities ниже,
+        # по убыванию объёма), и де-факто административный центр региона —
+        # Правительство Московской области физически размещается в Красногорске
+        # с 2013 г. (Москва как формальный административный центр — экстра-
+        # территориальна и уже занята регионом 77). Единственный кандидат,
+        # обоснованный ОБОИМИ критериями сразу.
+        city_token="красногорск",
+        cities=frozenset(
+            {
+                "красногорск",
+                "балашиха",
+                "видное",
+                "люберцы",
+                "звенигород",
+                "химки",
+                "мытищи",
+                "подольск",
+                "одинцово",
+                "солнечногорск",
+                "домодедово",
+                "королёв",
+                "королев",
+                "котельники",
+                "дмитров",
+                "электросталь",
+                "реутов",
+                "щёлково",
+                "щелково",
+                "серпухов",
+                "ногинск",
+                "железнодорожный",
+            }
+        ),
+        # Тиров обогащения у области пока НЕТ ни одного: IMV/квартальный
+        # индекс/кадастр/POI не заведены (проверено — frozenset() пуст
+        # намеренно, не заглушка). Ряд Сбериндекса по области с 12.09.2026 в
+        # карте _SBER_REGION_SERIES эстиматора есть, но тиром он от этого не
+        # становится: у Москвы набор тиров тоже пуст, а свой ряд она читает —
+        # поправка по времени идёт мимо enrichment_tiers (TIER_SBER_INDEX нигде
+        # за пределами этого реестра не спрашивают).
+        enrichment_tiers=frozenset(),
+        # Источники по области несут настоящий city (Химки, Балашиха — не
+        # муниципальный округ/поселение, в отличие от Москвы) — перезаписывать
+        # нечего и незачем, в отличие от 77.
+        canonical_city=None,
+    ),
 }
 
 DEFAULT_REGION_CODE = 66
 
 
+def _bbox_area(bbox: BBox) -> float:
+    """Грубая «площадь» bbox в кв. градусах (lat_range * lon_range).
+
+    Не учитывает сжатие долготы на широте (cos(lat)) — не нужно: значение
+    используется ТОЛЬКО чтобы сравнить специфичность bbox'ов разного порядка
+    (город vs область), не как настоящая площадь в км²."""
+    lat_min, lat_max, lon_min, lon_max = bbox
+    return (lat_max - lat_min) * (lon_max - lon_min)
+
+
+# Порядок обхода для region_for_point: от САМОГО специфичного (маленький
+# bbox_region) к самому общему — НЕ sorted(REGIONS) по числовому коду.
+#
+# Почему код региона как ключ порядка сломался: bbox_region(50) (Московская
+# область целиком, lat 54.20..56.96/lon 35.14..40.21) геометрически СОДЕРЖИТ
+# bbox_region(77) (Москва, 55.10..56.10/36.80..38.10) как прямоугольники — а
+# 50 < 66 < 77 по числу. При обходе `sorted(REGIONS)` регион 50 проверялся бы
+# ПЕРВЫМ (50 < 77) и забирал бы себе ВСЕ точки Москвы, включая центр
+# (55.75, 37.62) — она лежит в bbox_region обоих регионов одновременно. Старый
+# докстринг называл это «на случай, если когда-нибудь пересекутся» — случай
+# наступил прямо при добавлении региона 50, не гипотетически.
+#
+# Площадь bbox_region (см. `_bbox_area`) как ключ сортировки решает это БЕЗ
+# ручного списка: чем компактнее регион, тем раньше его проверяют, поэтому
+# вложенный регион (77 внутри 50) всегда выигрывает у объемлющего, а будущий
+# новый регион сам встанет в верную позицию по своей площади — правку этого
+# места повторять не придётся.
+_POINT_LOOKUP_ORDER: tuple[int, ...] = tuple(
+    sorted(REGIONS, key=lambda code: (_bbox_area(REGIONS[code].bbox_region), code))
+)
+
+
 def region_for_point(lat: float, lon: float) -> Region | None:
     """Регион покрытия, которому принадлежит точка (по bbox_region), или None.
 
-    Регионы географически не пересекаются; порядок обхода детерминирован кодом
-    региона на случай, если когда-нибудь пересекутся (первый по коду выигрывает
-    — и это станет видно в тестах реестра, а не в проде).
+    Обход — `_POINT_LOOKUP_ORDER` (компактный bbox_region раньше обширного), а
+    не числовой код региона: код как ключ порядка ломается ровно на паре
+    50/77, см. комментарий у `_POINT_LOOKUP_ORDER`.
     """
-    for code in sorted(REGIONS):
+    for code in _POINT_LOOKUP_ORDER:
         if is_within_bbox(lat, lon, REGIONS[code].bbox_region):
             return REGIONS[code]
     return None
@@ -179,7 +296,16 @@ def region_for_point(lat: float, lon: float) -> Region | None:
 
 def region_by_city(city: str | None) -> Region | None:
     """Регион, в чьём списке городов есть `city` (нормализованный нижний
-    регистр, е/ё не различаются). None — город не узнан ни одним регионом."""
+    регистр, е/ё не различаются). None — город не узнан ни одним регионом.
+
+    В отличие от `region_for_point`, здесь нет геометрической вложенности —
+    сравнение точное (токен строки), не bbox-containment, поэтому порядок по
+    коду региона не создаёт баг ordering'а САМ ПО СЕБЕ. Он МОГ бы сломаться,
+    если бы одно имя города оказалось в `cities` двух регионов (тогда побеждал
+    бы меньший код) — список городов 50 сверен вручную с `cities` регионов 66
+    и 77, пересечений нет (закреплено test_no_city_name_duplicated_across_regions
+    в tests/test_3051_region_registry_moscow_oblast.py).
+    """
     if not city:
         return None
     token = " ".join(city.lower().replace("ё", "е").split())

tradein-mvp/backend/app/services/sber_index.py

@@ -40,6 +40,18 @@ REF_AREA codes (sberindex internal region IDs, not ОКАТО/ISO):
   77  = Москва               — verified 2026-05-31 brute-force against /api/sowa
         (region name from ref_area field of response);
         real_estate_deals: 2017-01 148 471 → 2026-04 309 510 руб/м².
+  50  = Московская область   — verified live 2026-09-12 (все три дашборда, ref_area
+        в ответе = «Московская область»); real_estate_deals 116 месячных точек
+        2017-01..2026-08, residential_real_estate_prices 47 (2022-10..2026-08),
+        dinamika-tsen-obyavlenii 56 (2021-12..2026-07) — та же глубина и свежесть,
+        что у Москвы.
+
+Область заведена ЗАРАНЕЕ, до появления региона 50 в реестре regions.REGIONS. Ряд
+источника наполняется месяцами и задним числом не восстанавливается, поэтому
+загружать его надо начинать раньше, чем он понадобится оценщику. На саму оценку
+это не влияет: estimator берёт ряды через _SBER_REGION_SERIES, кода 50 там нет, и
+до его появления область в расчёт не попадает. Мониторинг свежести тоже не
+затронут — SBER_REQUIRED_REGIONS считается от карты ЭСТИМАТОРА, а не отсюда.
 """
 
 from __future__ import annotations
@@ -71,6 +83,7 @@ SBER_REF_AREAS: dict[str, str] = {
     "643": "Россия",
     "66": "Свердловская область",
     "77": "Москва",
+    "50": "Московская область",
 }
 
 

tradein-mvp/backend/app/services/tgbot/bridge.py

@@ -147,6 +147,21 @@ _NOTIFY_SEND_TIMEOUT_S = 5.0
 _NOTIFY_SEND_MAX_RETRIES = 3
 _NOTIFY_SEND_MAX_BACKOFF_S = 1.0
 
+# Потолок ожидания в TelegramGroupRateLimiter для отправок ИЗ ЭТОГО модуля,
+# которые не проходят через _notify_topic (review M1, #3471). Без него
+# `client.send_message`/`copy_message` без явного `timeout` наследуют
+# лимитер-политику "без потолка" (см. TelegramClient._request) — приемлемую
+# ДЛЯ ФОНОВОЙ отправки как таковой, но НЕ здесь: эти вызовы идут внутри
+# `run_poll_loop`, который на каждый апдейт держит ОТКРЫТУЮ сессию БД
+# (SessionLocal, см. вызывающих) и однопоточно блокирует опрос СЛЕДУЮЩИХ
+# апдейтов — минутный сон здесь стопорит и БД-соединение, и весь мост, а не
+# только одно сообщение. Второй повод — SIGTERM drain: `tgbot_main._DRAIN_TIMEOUT_S`
+# даёт 100с на завершение текущей итерации; ожидание слота дольше этого
+# бюджета уже не успевает подчиниться cooperative drain. 20с — заметно больше,
+# чем разумная очередь при исчерпанном лимите (окно 60с, обычно секунды), но
+# заметно МЕНЬШЕ минуты и вписывается в drain-бюджет с запасом.
+_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S = 20.0
+
 # Потолок переигрываний ОДНОГО update_id на транзиентных сетевых отказах
 # (#tg-connection-resilience).
 #
@@ -223,7 +238,13 @@ class BridgeStorage(Protocol):
     ) -> int | None: ...
 
     def record_web_out_message(
-        self, *, thread_id: int, text_body: str, operator_tg_id: int | None
+        self,
+        *,
+        thread_id: int,
+        text_body: str,
+        operator_tg_id: int | None,
+        topic_message_id: int | None = None,
+        support_chat_id: int | None = None,
     ) -> None: ...
 
 
@@ -376,14 +397,20 @@ class SqlBridgeStorage:
         со ЧУЖИМ (не NULL, не текущим) support_chat_id — исторический артефакт
         ротации support-группы, не валидный маршрут сегодня. NULL (строки до
         миграции 188, если есть) — лениентный wildcard-матч (единственный
-        действовавший чат на тот момент)."""
+        действовавший чат на тот момент).
+
+        БЕЗ фильтра по direction (#3471 P0, было `AND direction = 'in'`): с тех
+        пор как `record_message` на исходящем ответе тоже сохраняет
+        `topic_message_id` (id сообщения оператора В ТОПИКЕ), реплай оператора
+        на СВОЙ предыдущий ответ обязан резолвиться так же, как реплай на
+        зеркало клиента — иначе продолжение диалога без повторного цитирования
+        клиента тихо проваливалось в orphan-check."""
         row = self._db.execute(
             text(
                 """
                 SELECT chat_id
                 FROM tg_support_messages
                 WHERE topic_message_id = CAST(:topic_message_id AS bigint)
-                  AND direction = 'in'
                   AND (support_chat_id = CAST(:support_chat_id AS bigint)
                        OR support_chat_id IS NULL)
                 ORDER BY created_at DESC
@@ -413,13 +440,21 @@ class SqlBridgeStorage:
         )
 
     def record_web_out_message(
-        self, *, thread_id: int, text_body: str, operator_tg_id: int | None
+        self,
+        *,
+        thread_id: int,
+        text_body: str,
+        operator_tg_id: int | None,
+        topic_message_id: int | None = None,
+        support_chat_id: int | None = None,
     ) -> None:
         web_support_storage.record_outbound(
             self._db,
             thread_id=thread_id,
             text_body=text_body,
             operator_tg_id=operator_tg_id,
+            topic_message_id=topic_message_id,
+            support_chat_id=support_chat_id,
         )
 
 
@@ -448,7 +483,7 @@ async def _notify_topic(
     text: str,
     reply_to_message_id: int | None,
     context: str,
-) -> None:
+) -> bool:
     """Служебное уведомление оператору в support-топик (вторичное действие).
 
     Два свойства, которых не было у прямых `client.send_message` вызовов:
@@ -459,6 +494,12 @@ async def _notify_topic(
        и не решает судьбу апдейта.
     `context` — только технические идентификаторы (chat_id/thread_id), НЕ текст
     переписки: логи моста принципиально не содержат ПДн.
+
+    Возвращает True, если уведомление реально ушло, False — если само
+    уведомление тоже упало (напр. Telegram недоступен). Вызывающий, для
+    которого проваленное уведомление означает ПОЛНУЮ тишину (ни клиенту, ни
+    оператору), обязан на False залогировать `logger.error` с идентификаторами
+    (#3471 P0) — иначе единственный след остаётся только в этом WARNING.
     """
     try:
         await client.send_message(
@@ -470,6 +511,7 @@ async def _notify_topic(
             max_retries=_NOTIFY_SEND_MAX_RETRIES,
             max_backoff=_NOTIFY_SEND_MAX_BACKOFF_S,
         )
+        return True
     except Exception:
         logger.warning(
             "tgbot bridge: не удалось отправить уведомление оператору в топик (%s) — "
@@ -477,6 +519,7 @@ async def _notify_topic(
             context,
             exc_info=True,
         )
+        return False
 
 
 # ── Update routing ────────────────────────────────────────────────────────────
@@ -507,7 +550,11 @@ async def _handle_private_message(
     text_body = message.get("text")
     if text_body == "/start":
         # E) команда — не содержательное обращение, топик не засоряем.
-        await client.send_message(chat_id=chat_id, text=GREETING_TEXT)
+        await client.send_message(
+            chat_id=chat_id,
+            text=GREETING_TEXT,
+            rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
+        )
         return
 
     if not settings.telegram_support_chat_id:
@@ -517,7 +564,11 @@ async def _handle_private_message(
             chat_id,
         )
         # Не молчим клиенту (#5 review) — иначе он ждёт ответа, которого никогда не будет.
-        await client.send_message(chat_id=chat_id, text=SERVICE_UNAVAILABLE_TEXT)
+        await client.send_message(
+            chat_id=chat_id,
+            text=SERVICE_UNAVAILABLE_TEXT,
+            rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
+        )
         return
 
     message_id = message.get("message_id")
@@ -545,7 +596,11 @@ async def _handle_private_message(
         # за окно — `_flood_notify_limiter.check()` возвращает None (и сам
         # фиксирует попытку) ровно один раз за окно.
         if _flood_notify_limiter.check(flood_key) is None:
-            await client.send_message(chat_id=chat_id, text=FLOOD_LIMITED_TEXT)
+            await client.send_message(
+                chat_id=chat_id,
+                text=FLOOD_LIMITED_TEXT,
+                rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
+            )
         return
     _flood_limiter.record(flood_key)
 
@@ -556,6 +611,7 @@ async def _handle_private_message(
             chat_id=settings.telegram_support_chat_id,
             text=header,
             message_thread_id=settings.telegram_support_topic_id or None,
+            rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
         )
 
     mirrored = await client.copy_message(
@@ -563,6 +619,7 @@ async def _handle_private_message(
         from_chat_id=chat_id,
         message_id=message_id,
         message_thread_id=settings.telegram_support_topic_id or None,
+        rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
     )
     topic_message_id = mirrored.get("message_id") if isinstance(mirrored, dict) else None
 
@@ -627,6 +684,7 @@ async def _handle_group_reply(
                 chat_id=target_chat_id,
                 from_chat_id=settings.telegram_support_chat_id,
                 message_id=message_id,
+                rate_limit_max_wait=_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S,
             )
         except TelegramApiError as exc:
             if exc.error_code == 403:
@@ -649,10 +707,22 @@ async def _handle_group_reply(
             chat_id=target_chat_id,
             direction="out",
             tg_message_id=tg_message_id,
-            topic_message_id=None,
+            # #3471 P0: id ЭТОГО сообщения оператора В ТОПИКЕ (было безусловно
+            # None) — без него реплай оператора на СВОЙ предыдущий ответ не
+            # резолвился (искать было нечего), маршрут держался только на
+            # зеркале клиента. Совпадение с `in`-записью структурно исключено:
+            # `message_id` — id реплая оператора, а зеркало клиента уже занимает
+            # другой message_id в том же чате.
+            topic_message_id=message_id,
             kind=_infer_kind(message),
             text_body=message.get("text") or message.get("caption"),
             operator_tg_id=operator_id,
+            # Deep review PR #3479: без этого out-строка была бы вечным
+            # wildcard для `find_chat_by_topic_message` (матчит support_chat_id
+            # IS NULL под ЛЮБЫМ текущим чатом) — при ротации support-группы
+            # (188) новый message_id мог бы совпасть со старой out-строкой и
+            # увести ответ ЧУЖОМУ клиенту. Симметрично in-ветке выше (строка ~601).
+            support_chat_id=settings.telegram_support_chat_id,
         )
         return
 
@@ -686,11 +756,64 @@ async def _handle_group_reply(
 
         operator = message.get("from") or {}
         operator_id = operator.get("id")
-        storage.record_web_out_message(
-            thread_id=web_thread_id,
-            text_body=text_body,
-            operator_tg_id=operator_id,
-        )
+        try:
+            storage.record_web_out_message(
+                thread_id=web_thread_id,
+                text_body=text_body,
+                operator_tg_id=operator_id,
+                # #3471 P0: id ЭТОГО сообщения оператора в топике — без него
+                # реплай оператора на СВОЙ предыдущий веб-ответ не резолвится
+                # (см. `find_thread_by_topic_message`, direction-фильтр снят).
+                topic_message_id=message_id if isinstance(message_id, int) else None,
+                # Deep review PR #3479: БЕЗ этого out-строка писалась бы с
+                # support_chat_id=NULL — `find_thread_by_topic_message` матчит
+                # NULL под ЛЮБЫМ текущим чатом (лениентный wildcard для легаси
+                # строк до 187/188), т.е. каждая out-строка стала бы вечным
+                # wildcard. При ротации support-группы новый message_id мог бы
+                # совпасть со старой out-строкой и увести ответ в ЧУЖОЙ тред —
+                # ровно то, от чего защищала скоупинг-миграция 187/188.
+                support_chat_id=settings.telegram_support_chat_id,
+            )
+        except SQLAlchemyError:
+            # #3471 P0: для веб-треда ЭТА запись — и есть доставка клиенту (веб-
+            # фронт вычитывает ответ обычным polling'ом web_support_messages).
+            # Откат без уведомления означал бы: оператор уверен, что ответил,
+            # клиент ждёт молча. Offset ниже всё равно сдвигается — НЕ потому,
+            # что апдейт "частично применён в Telegram" (в этой ветке до сбоя в
+            # Telegram ничего не уходило вообще: сам реплай оператора Telegram
+            # уже полностью доставил ДО того, как мы начали его разбирать,
+            # ретраить на стороне площадки нечего), а потому что действует общая
+            # политика `process_update` для `SQLAlchemyError` — сбой БД не
+            # переигрывается (в отличие от `TelegramNetworkError`), а
+            # сигнализируется громко; здесь это explicit-просьба оператору
+            # прислать ответ заново — human-in-the-loop retry вместо
+            # технического. rollback() ОБЯЗАН отработать ДО уведомления —
+            # сессия в failed-transaction state, а `_notify_topic` шлёт через
+            # `client`, не через `storage`, поэтому сам rollback тут не нужен для
+            # отправки, но нужен, чтобы process_update дальше не упал на
+            # save_offset/commit тем же PendingRollbackError (см. #3 review).
+            storage.rollback()
+            notified = await _notify_topic(
+                client,
+                text=(
+                    "Не удалось сохранить ваш ответ из-за сбоя базы данных — клиенту "
+                    "он НЕ доставлен. Пожалуйста, отправьте ответ ещё раз."
+                ),
+                reply_to_message_id=message_id if isinstance(message_id, int) else None,
+                context=f"сбой БД на доставке веб-ответа thread_id={web_thread_id}",
+            )
+            if not notified:
+                # Оба канала молчат (БД и уведомление) — единственный след,
+                # который останется, это эта строка. Идентификаторы, НЕ текст
+                # (ПДн в лог не идёт) — по ним человек найдёт ответ оператора в
+                # топике и перешлёт его руками (#3471 P0).
+                logger.error(
+                    "tgbot bridge: сбой БД на веб-ответе И не удалось уведомить "
+                    "оператора (thread_id=%d, message_id=%s) — ответ клиенту "
+                    "потерян молча, требуется ручной разбор support-топика",
+                    web_thread_id,
+                    message_id,
+                )
         return
 
     # Обычная болтовня в топике (реплай на чьё-то ещё сообщение) — не логируем,
@@ -741,7 +864,12 @@ async def process_update(
         `PendingRollbackError`, `process_update` вылетит без сохранения offset'а,
         следующая итерация получит СТАРЫЙ offset от `get_offset()` и переиграет
         тот же апдейт — copyMessage задублирует зеркало клиента в топике на
-        каждый повтор поллинга (#3 review, воспроизведено).
+        каждый повтор поллинга (#3 review, воспроизведено). Для веб-ветки
+        (`_handle_group_reply` → `record_web_out_message`) этот `SQLAlchemyError`
+        перехватывается ЛОКАЛЬНО, до этого места: там запись в БД И ЕСТЬ
+        доставка клиенту, поэтому rollback сопровождается уведомлением оператору
+        в топике, что ответ НЕ доставлен (#3471 P0) — сюда, на верхний уровень,
+        это исключение уже не долетает.
       - любое прочее исключение (в т.ч. `TelegramApiError` — площадка ОТВЕТИЛА
         отказом, повтор ничего не изменит) — offset двигаем, «ядовитый» апдейт
         не блокирует поток.

tradein-mvp/backend/app/services/tgbot/client.py

@@ -43,6 +43,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from typing import Any
 
 import httpx
@@ -54,6 +55,150 @@ _DEFAULT_RETRY_AFTER_S = 5.0
 _MAX_BACKOFF_S = 30.0
 _DEFAULT_MAX_RETRIES = 5
 
+# Telegram документирует ~20 сообщений/минуту на ОДНУ группу (общий лимит на
+# все темы супергруппы разом, не на тему по отдельности — превышение даёт 429
+# на ЛЮБОЕ следующее сообщение в группу, кто бы его ни отправлял). До #3471
+# лимита на нашей стороне не было вовсе: всплеск GlitchTip-алертов + поток
+# сообщений поддержки в ту же группу (разные темы, общий чат) укладывались в
+# 429 и теряли сообщения — retry в `_request` уважает `retry_after`, но не
+# предотвращает сам всплеск. `_DEFAULT_GROUP_RATE_LIMIT_PER_MINUTE` — чуть
+# ниже площадочного потолка, с запасом на неточность скользящего окна и на то,
+# что сама площадка не обязана быть педантичной ровно к 20-й отправке.
+_DEFAULT_GROUP_RATE_LIMIT_PER_MINUTE = 18
+_RATE_LIMIT_WINDOW_S = 60.0
+
+
+class TelegramGroupRateLimiter:
+    """Общий (per-`chat_id`, НЕ per-теме) ограничитель частоты отправки в группу.
+
+    Зачем ключ — `chat_id`, а не `(chat_id, message_thread_id)`: лимит Telegram
+    считается на группу целиком, все темы супергруппы делят один бюджет.
+    Ограничитель с ключом по теме позволил бы двум темам суммарно превысить
+    лимит группы и всё равно поймать 429 — ровно баг, который здесь чинится.
+
+    Реализация — скользящее окно (список меток времени последних отправок за
+    `_RATE_LIMIT_WINDOW_S`), а не токен-бакет с фиксированным пополнением:
+    окно точнее соответствует тому, как Telegram считает лимит («N сообщений
+    за последние 60 секунд», а не «N сообщений в календарную минуту»).
+
+    Конкурентность (asyncio, один процесс, несколько отправителей): на каждый
+    `chat_id` — свой `asyncio.Lock`. Лок держится ВКЛЮЧАЯ время ожидания
+    (`asyncio.sleep`), а не только на чтение/запись счётчика — это осознанно:
+    цель не просто «не гонять счётчик без гонки», а ФАКТИЧЕСКИ сериализовать
+    отправителей в этот чат, чтобы они не просыпались все разом по истечении
+    окна и не били по лимиту повторно.
+
+    ВАЖНО про ключ (проверено на проде, review 2026-09-12): `TELEGRAM_SUPPORT_CHAT_ID`
+    и `TELEGRAM_ALERTS_CHAT_ID` — это ОДНА И ТА ЖЕ группа, различаются только
+    темы (`*_TOPIC_ID`). Именно поэтому ключ лимитера — `chat_id`, а НЕ
+    `(chat_id, message_thread_id)`: поток алертов и поток поддержки сегодня
+    физически делят один Telegram-бюджет группы, и лимитер обязан это
+    отражать. Ключ по `chat_id` при этом остаётся корректным и в гипотезе, что
+    когда-нибудь эти два потока разведут по разным группам, — тогда у каждой
+    просто появится свой независимый лок/бюджет автоматически, без правки кода.
+
+    Регистр локов защищён отдельным `asyncio.Lock` только на момент
+    создания записи — сам подсчёт/сон идёт уже под персональным локом чата.
+    """
+
+    def __init__(
+        self,
+        max_per_window: int = _DEFAULT_GROUP_RATE_LIMIT_PER_MINUTE,
+        window_s: float = _RATE_LIMIT_WINDOW_S,
+    ) -> None:
+        self._max_per_window = max_per_window
+        self._window_s = window_s
+        self._registry_lock = asyncio.Lock()
+        self._locks: dict[int, asyncio.Lock] = {}
+        self._sent_at: dict[int, list[float]] = {}
+
+    async def _lock_for(self, chat_id: int) -> asyncio.Lock:
+        async with self._registry_lock:
+            lock = self._locks.get(chat_id)
+            if lock is None:
+                lock = asyncio.Lock()
+                self._locks[chat_id] = lock
+            return lock
+
+    async def acquire(self, chat_id: int, max_wait: float | None = None) -> None:
+        """Блокируется, пока в окне `_window_s` для `chat_id` есть свободный слот.
+
+        `max_wait` (review H1, #3471): потолок ожидания очереди. `None` (дефолт)
+        — без потолка, ждать сколько нужно; это ПРАВИЛЬНОЕ поведение для
+        фоновых отправок бота, где потерять сообщение хуже, чем подождать.
+        Если задан и слот не появился вовремя — бросает `TelegramRateLimitedError`
+        (честный отказ), а НЕ продолжает ждать: интерактивная HTTP-ручка не
+        может легально держать открытый запрос браузера дольше своего
+        собственного таймаута. Вызывающая сторона — `TelegramClient._request`,
+        см. её докстринг про то, откуда берётся конкретное значение.
+
+        Логирование (review L1): предупреждение об ожидании пишется РОВНО ОДИН
+        раз за вызов `acquire` (флаг `warned`), а не на каждой итерации сна —
+        при реальной перегрузке группы это иначе валит лог сотнями одинаковых
+        строк вместо одного сигнала «была очередь».
+
+        Побочный эффект (review M2): перед постановкой в очередь чистит ЧУЖИЕ
+        полностью просроченные записи в `_sent_at`/`_locks` — см. `_cleanup_stale`.
+        """
+        if self._max_per_window <= 0:
+            return  # 0/отрицательное значение конфига = лимитер выключен
+        now0 = time.monotonic()
+        await self._cleanup_stale(now0)
+        deadline = None if max_wait is None else now0 + max_wait
+        lock = await self._lock_for(chat_id)
+        async with lock:
+            warned = False
+            while True:
+                now = time.monotonic()
+                if deadline is not None and now >= deadline:
+                    raise TelegramRateLimitedError(chat_id, max_wait or 0.0)
+                history = self._sent_at.setdefault(chat_id, [])
+                cutoff = now - self._window_s
+                while history and history[0] <= cutoff:
+                    history.pop(0)
+                if len(history) < self._max_per_window:
+                    history.append(now)
+                    return
+                wait_s = history[0] + self._window_s - now
+                if deadline is not None:
+                    wait_s = min(wait_s, max(deadline - now, 0.0))
+                if not warned:
+                    logger.warning(
+                        "tg group rate limit: chat_id=%s — лимит %d/%.0fs исчерпан, "
+                        "отправки встают в очередь (одно предупреждение на серию)",
+                        chat_id,
+                        self._max_per_window,
+                        self._window_s,
+                    )
+                    warned = True
+                await asyncio.sleep(max(wait_s, 0.01))
+
+    async def _cleanup_stale(self, now: float) -> None:
+        """Чистит ЧУЖИЕ (не текущий вызов `acquire`) записи с полностью
+        просроченной историей (review M2, #3471).
+
+        Зачем: `_locks`/`_sent_at` ключуются по ЛЮБОМУ `chat_id`, включая
+        личные чаты каждого клиента бота (`bridge.py` зеркалит их 1:1 через тот
+        же `TelegramClient`) — большинство из них шлют боту одно сообщение и
+        больше никогда не возвращаются. Без чистки оба словаря растут
+        монотонно на всё время жизни долгоживущего процесса (медленная утечка).
+
+        Безопасность удаления: лок пропускаем, если `lock.locked()` — значит
+        кто-то ИМЕННО СЕЙЧАС работает с этим `chat_id`, трогать нельзя. Если
+        лок свободен и вся история старше окна — запись безвредно удалить:
+        следующий `acquire` для того же `chat_id` просто создаст её заново
+        пустой (`setdefault`), с тем же результатом, что и не удаляй мы её.
+        """
+        cutoff = now - self._window_s
+        async with self._registry_lock:
+            stale = [cid for cid, ts in self._sent_at.items() if not ts or ts[-1] <= cutoff]
+            for cid in stale:
+                lock = self._locks.get(cid)
+                if lock is not None and lock.locked():
+                    continue
+                self._sent_at.pop(cid, None)
+                self._locks.pop(cid, None)
+
 # Раздельные таймауты вместо скаляра. httpx разворачивает скаляр в
 # connect=read=write=pool, поэтому long-poll `getUpdates` (read = 30с, которые
 # Telegram держит запрос, + 10с запаса = 40с) ставил 40 секунд и на УСТАНОВКУ
@@ -126,6 +271,25 @@ class TelegramNetworkError(TelegramError):
         super().__init__(f"Telegram {method} unreachable after {attempts} attempts: {reason}")
 
 
+class TelegramRateLimitedError(TelegramError):
+    """Слот в `TelegramGroupRateLimiter` не появился за `max_wait` секунд (review H1).
+
+    Бросается ТОЛЬКО когда вызывающий явно (или неявно, через `timeout`)
+    попросил ограниченное ожидание — фоновые вызовы без такого ограничения
+    ждут очередь сколько нужно и этого исключения никогда не увидят. Общий
+    предок `TelegramError` — существующие `except TelegramError` в
+    `app.api.v1.support`/`glitchtip` подхватывают этот отказ автоматически, без
+    правки самих ручек, и отвечают своим честным 502 вместо зависшего запроса.
+    """
+
+    def __init__(self, chat_id: int, max_wait: float) -> None:
+        self.chat_id = chat_id
+        self.max_wait = max_wait
+        super().__init__(
+            f"Telegram group rate limit: no slot for chat_id={chat_id} within {max_wait:.1f}s"
+        )
+
+
 def _request_timeout(read: float) -> httpx.Timeout:
     """Разворачивает «сколько ждать ответа» (скаляр вызывающего) в таймауты httpx.
 
@@ -198,10 +362,26 @@ class TelegramClient:
         token: str,
         base_url: str = "https://api.telegram.org",
         timeout: float = _DEFAULT_TIMEOUT_S,
+        relay_base_url: str = "",
+        relay_secret: str = "",
+        group_rate_limit_per_minute: int = _DEFAULT_GROUP_RATE_LIMIT_PER_MINUTE,
     ) -> None:
-        self._base = f"{base_url}/bot{token}"
+        # ── Ретранслятор через Beget (#3471) ────────────────────────────────
+        # `relay_base_url` пуст по умолчанию → `_relay_base is _direct_base`,
+        # и `_post` ниже не делает второй попытки (фолбэчить с прямого пути
+        # НА прямой же путь бессмысленно). Заданный адрес переключает основной
+        # путь на ретранслятор, прямой остаётся ЗАПАСНЫМ на случай его отказа.
+        self._direct_base = f"{base_url}/bot{token}"
+        self._relay_base = f"{relay_base_url}/bot{token}" if relay_base_url else self._direct_base
+        self._relay_secret = relay_secret
+        self._base = self._relay_base
         self._timeout = timeout
         self._http: httpx.AsyncClient | None = None
+        # Один лимитер на экземпляр клиента — см. `TelegramGroupRateLimiter`.
+        # Ретранслятор здесь ни при чём: лимитер стоит ДО `_post`, то есть
+        # считает отправку независимо от того, уйдёт она через relay или
+        # напрямую (#3471) — оба пути ниже по стеку от этой точки.
+        self._rate_limiter = TelegramGroupRateLimiter(group_rate_limit_per_minute)
 
     def _http_client(self) -> httpx.AsyncClient:
         """Ленивое создание переиспользуемого AsyncClient (вне цикла ретраев)."""
@@ -228,6 +408,42 @@ class TelegramClient:
     async def __aexit__(self, *_exc: object) -> None:
         await self.aclose()
 
+    async def _post(
+        self,
+        client: httpx.AsyncClient,
+        url: str,
+        payload: dict[str, Any],
+        timeout: httpx.Timeout,
+    ) -> httpx.Response:
+        """POST с фолбэком на прямой путь при отказе РЕТРАНСЛЯТОРА (#3471).
+
+        Когда ретранслятор не настроен, `_relay_base is _direct_base`, `via_relay`
+        ниже всегда `False`, и метод ведёт себя как простой `client.post` — этот
+        путь ничем не отличается от поведения до #3471 (механизм отката).
+
+        Когда настроен: `url` бьёт в `self._relay_base`. Транспортный отказ (не
+        ответ Telegram ЧЕРЕЗ ретранслятор, а отказ ДО него — TCP/TLS до самого
+        relay-хоста) даёт РОВНО ОДНУ попытку напрямую к api.telegram.org — не
+        рекурсивно: если недоступен и прямой путь, исключение поднимается как
+        обычно и подхватывается retry-циклом `_request` на общих основаниях (со
+        следующей попытки цикл снова пробует ретранслятор first — временный
+        сбой relay не должен постоянно понижать клиента до прямого пути).
+        """
+        via_relay = self._relay_base != self._direct_base and url.startswith(self._relay_base)
+        headers = (
+            {"X-Relay-Secret": self._relay_secret} if via_relay and self._relay_secret else None
+        )
+        try:
+            return await client.post(url, json=payload, timeout=timeout, headers=headers)
+        except httpx.TransportError:
+            if not via_relay:
+                raise
+            direct_url = self._direct_base + url[len(self._relay_base) :]
+            logger.warning(
+                "tg client: ретранслятор недоступен, одна попытка напрямую к Telegram"
+            )
+            return await client.post(direct_url, json=payload, timeout=timeout)
+
     async def _request(
         self,
         method: str,
@@ -236,9 +452,24 @@ class TelegramClient:
         timeout: float | None = None,
         max_retries: int = _DEFAULT_MAX_RETRIES,
         max_backoff: float | None = None,
+        rate_limit_max_wait: float | None = None,
     ) -> Any:
         """POST `method` с JSON-телом `payload`. Ретраит 429/5xx/network, иначе raise сразу.
 
+        `rate_limit_max_wait` (review H1/M1, #3471) — потолок ожидания слота в
+        `TelegramGroupRateLimiter.acquire`. Приоритет:
+          1. Явный `rate_limit_max_wait` — используется как есть (bridge.py
+             передаёт его точечно для конкретных мест, см. `_BRIDGE_SEND_RATE_LIMIT_MAX_WAIT_S`).
+          2. Иначе, если вызывающий передал явный `timeout` — используем
+             `effective_timeout` КАК ЕСТЬ. Интерактивные ручки (`app.api.v1.support`,
+             `app.api.v1.glitchtip`) и так ОБЯЗАНЫ передавать узкий `timeout`
+             (5-8с, см. их собственные докстринги) — этого достаточно, чтобы
+             очередь лимитера не держала открытый HTTP-запрос браузера дольше
+             его же собственного бюджета, БЕЗ дополнительной правки этих ручек.
+          3. Иначе `None` — без потолка. Это дефолт для фоновых отправок бота
+             (`app.tgbot_main`/`bridge.py` без явного `timeout`), где потерять
+             сообщение хуже, чем подождать дольше.
+
         `max_backoff` (#tgsupport-retry) — потолок паузы МЕЖДУ попытками. По
         умолчанию `_MAX_BACKOFF_S` (30с) и полный `retry_after` из тела 429 — это
         воркерная политика, она НЕ меняется. Интерактивный вызывающий передаёт узкий
@@ -252,8 +483,23 @@ class TelegramClient:
         это штатные 30-60с) на число попыток и подвесил бы синхронный HTTP-запрос на
         минуты — ровно то, от чего предостерегает докстринг `send_message`.
         """
-        url = f"{self._base}/{method}"
         effective_timeout = timeout if timeout is not None else self._timeout
+
+        # Лимитер применяется ТОЛЬКО к методам с `chat_id` в payload (отправка
+        # в конкретный чат) — `getUpdates` его не несёт и лимиту не подлежит.
+        # Списывается ОДИН слот на логический вызов `_request` (то есть на
+        # одну попытку отправки конкретного сообщения), а не на каждую HTTP
+        # попытку внутри ретрай-цикла ниже: ретраи по 429/5xx лечат один и тот
+        # же send, а не порождают новые отправки. Приоритет `wait_cap` — см.
+        # докстринг параметра `rate_limit_max_wait` выше.
+        chat_id = payload.get("chat_id")
+        if isinstance(chat_id, int):
+            wait_cap = rate_limit_max_wait
+            if wait_cap is None and timeout is not None:
+                wait_cap = effective_timeout
+            await self._rate_limiter.acquire(chat_id, max_wait=wait_cap)
+
+        url = f"{self._base}/{method}"
         # Раздельные таймауты считаем ОДИН раз и передаём per-request: у общего
         # AsyncClient свой дефолт, а бюджет ответа у каждого вызова свой.
         request_timeout = _request_timeout(effective_timeout)
@@ -266,7 +512,7 @@ class TelegramClient:
         while True:
             attempt += 1
             try:
-                response = await client.post(url, json=payload, timeout=request_timeout)
+                response = await self._post(client, url, payload, request_timeout)
             except httpx.TransportError as exc:
                 # Ловим ВЕСЬ `TransportError`, а не узкий кортеж
                 # `(TimeoutException, NetworkError)`: `RemoteProtocolError`
@@ -423,8 +669,12 @@ class TelegramClient:
         message_id: int,
         message_thread_id: int | None = None,
         reply_to_message_id: int | None = None,
+        rate_limit_max_wait: float | None = None,
     ) -> dict[str, Any]:
-        """copyMessage — зеркалит ЛЮБОЙ тип контента без ре-аплоада файла."""
+        """copyMessage — зеркалит ЛЮБОЙ тип контента без ре-аплоада файла.
+
+        `rate_limit_max_wait` — см. `TelegramClient._request`; используется
+        `bridge.py` для точечного потолка ожидания на конкретных местах (review M1)."""
         payload: dict[str, Any] = {
             "chat_id": chat_id,
             "from_chat_id": from_chat_id,
@@ -434,7 +684,9 @@ class TelegramClient:
             payload["message_thread_id"] = message_thread_id
         if reply_to_message_id:
             payload["reply_to_message_id"] = reply_to_message_id
-        result = await self._request("copyMessage", payload)
+        result = await self._request(
+            "copyMessage", payload, rate_limit_max_wait=rate_limit_max_wait
+        )
         return result if isinstance(result, dict) else {}
 
     async def send_message(
@@ -447,6 +699,7 @@ class TelegramClient:
         timeout: float | None = None,
         max_retries: int | None = None,
         max_backoff: float | None = None,
+        rate_limit_max_wait: float | None = None,
     ) -> dict[str, Any]:
         """sendMessage — текстовое сообщение (заголовки, приветствия, уведомления об ошибке).
 
@@ -470,5 +723,103 @@ class TelegramClient:
             kwargs["max_retries"] = max_retries
         if max_backoff is not None:
             kwargs["max_backoff"] = max_backoff
+        if rate_limit_max_wait is not None:
+            kwargs["rate_limit_max_wait"] = rate_limit_max_wait
         result = await self._request("sendMessage", payload, **kwargs)
         return result if isinstance(result, dict) else {}
+
+    async def get_chat(self, chat_id: int) -> dict[str, Any]:
+        """getChat — метаданные чата. Единственная цель здесь — startup-проверка
+        (см. `verify_chat_and_topic`): подтвердить, что `chat_id` валиден и бот
+        не выгнан/не заблокирован, без единого видимого сообщения."""
+        result = await self._request("getChat", {"chat_id": chat_id}, max_retries=1)
+        return result if isinstance(result, dict) else {}
+
+    async def send_chat_action(
+        self,
+        *,
+        chat_id: int,
+        action: str = "typing",
+        message_thread_id: int | None = None,
+    ) -> bool:
+        """sendChatAction — статус набора текста. Возвращает `True`/`False`, JSON-объекта нет.
+
+        Используется НЕ по прямому назначению (индикация набора), а как способ
+        проверить существование `message_thread_id` (темы форума) — см.
+        `verify_chat_and_topic`. Это единственный метод Bot API, который
+        принимает `message_thread_id` и не создаёт message-объект: если тема
+        удалена/переименована в другую с иным id, Telegram отвечает `Bad
+        Request: message thread not found` мгновенно, а в истории чата не
+        остаётся ни строки (индикатор эфемерный и не персистится)."""
+        payload: dict[str, Any] = {"chat_id": chat_id, "action": action}
+        if message_thread_id:
+            payload["message_thread_id"] = message_thread_id
+        result = await self._request(
+            "sendChatAction", payload, max_retries=1, max_backoff=5.0
+        )
+        return bool(result)
+
+
+async def verify_chat_and_topic(
+    client: TelegramClient,
+    *,
+    chat_id: int,
+    topic_id: int,
+    label: str,
+) -> bool:
+    """Разовая startup-проверка: чат существует, бот в нём не забанен, тема жива.
+
+    Зачем нужна: бот пишет в тему форума по числовому id из настроек. Если
+    тему удалили, переименовали в другую (новый id) или id в конфиге просто
+    неверный — отправка начинает падать НА КАЖДОМ сообщении, а узнаём мы об
+    этом только по молчанию у людей (симметрично истории #tgsupport с сетевыми
+    отказами: тихий отказ хуже шума). Эта проверка переносит обнаружение с
+    «через сутки тишины» на «в первую секунду после старта/рестарта».
+
+    Способ намеренно НЕ `sendMessage`+`deleteMessage`:
+      - `getChat(chat_id)` подтверждает валидность чата и то, что бот не
+        выгнан/не заблокирован — чистый read, нулевой видимый след.
+      - `send_chat_action` (typing-индикатор с `message_thread_id`) —
+        единственный способ провалидировать САМУ тему без создания
+        message-объекта: Telegram обязан знать про `message_thread_id`, чтобы
+        показать «печатает...» именно в нужном треде, и явно отказывает, если
+        такой темы нет. `sendMessage`+`deleteMessage` тоже сработал бы, но
+        оставлял бы видимый (пусть на секунды) артефакт в истории треда при
+        КАЖДОМ рестарте контейнера — на rolling-деплое это многократно в
+        сутки; typing-индикатор того же результата достигает без единого
+        сообщения.
+
+    НЕ роняет процесс: любой `TelegramError` ловится здесь же и уходит в лог
+    уровня error — задача явно требует шума в логе, а не падения воркера
+    (тема пуста/невалидна — это деградация уведомлений, а не фатальный сбой
+    самого бота, который всё ещё должен принимать входящие).
+
+    `chat_id == 0` (не настроено) — считается успехом без обращения к API:
+    это штатный kill-switch (см. `app.core.config`), а не ошибка конфигурации.
+    """
+    if not chat_id:
+        return True
+    try:
+        await client.get_chat(chat_id)
+        if topic_id:
+            await client.send_chat_action(
+                chat_id=chat_id, action="typing", message_thread_id=topic_id
+            )
+    except TelegramError as exc:
+        logger.error(
+            "tg topic check [%s]: чат/тема недоступны для отправки "
+            "(chat_id=%s, topic_id=%s) — %s. Сообщения в эту тему БУДУТ "
+            "падать, пока конфигурация не исправлена.",
+            label,
+            chat_id,
+            topic_id,
+            exc,
+        )
+        return False
+    logger.info(
+        "tg topic check [%s]: чат и тема доступны для отправки (chat_id=%s, topic_id=%s)",
+        label,
+        chat_id,
+        topic_id,
+    )
+    return True

tradein-mvp/backend/app/services/tgbot/shared.py

@@ -32,7 +32,15 @@ def get_telegram_client() -> TelegramClient:
     """
     global _client
     if _client is None:
-        _client = TelegramClient(settings.telegram_bot_token)
+        _client = TelegramClient(
+            settings.telegram_bot_token,
+            relay_base_url=settings.telegram_relay_base_url,
+            relay_secret=settings.telegram_relay_secret,
+            # API-роль (review H2, #3471) — см. докстринг настройки в
+            # app.core.config: бюджет группы разделён статически между этим
+            # процессом и app.tgbot_main, суммарно ниже площадочного лимита.
+            group_rate_limit_per_minute=settings.telegram_group_rate_limit_api_per_minute,
+        )
     return _client
 
 

tradein-mvp/backend/app/services/tgbot/web_support_storage.py

@@ -61,6 +61,36 @@ def get_or_create_thread(db: Session, username: str) -> int:
     return int(row[0])
 
 
+def find_inbound_by_idempotency_key(
+    db: Session, *, thread_id: int, idempotency_key: str
+) -> dict[str, Any] | None:
+    """Уже записанное inbound-сообщение с этим ключом идемпотентности в треде,
+    если есть (#3471). Вызывается ИЗ `app.api.v1.support` ДО похода в Telegram
+    (`send_support_message` / `send_anon_support_message`) — повтор с тем же
+    ключом не должен создавать второе зеркало в топике, а не только вторую
+    строку в БД. `thread_id`, а не username/anon-token: таблица не хранит
+    identity напрямую, а тред уже гарантированно существует к моменту, когда
+    этот ключ мог быть записан (тред создаётся ДО `record_inbound`, см. H1 в
+    докстринге `app.api.v1.support`)."""
+    row = (
+        db.execute(
+            text(
+                """
+                SELECT id, direction, text_body, operator_tg_id, created_at
+                FROM web_support_messages
+                WHERE thread_id = CAST(:thread_id AS bigint)
+                  AND direction = 'in'
+                  AND idempotency_key = :idempotency_key
+                """
+            ),
+            {"thread_id": thread_id, "idempotency_key": idempotency_key},
+        )
+        .mappings()
+        .one_or_none()
+    )
+    return dict(row) if row is not None else None
+
+
 def record_inbound(
     db: Session,
     *,
@@ -68,6 +98,7 @@ def record_inbound(
     text_body: str,
     topic_message_id: int | None,
     support_chat_id: int | None,
+    idempotency_key: str | None = None,
 ) -> dict[str, Any]:
     """Записывает сообщение пользователя сайта (direction='in'). `topic_message_id` —
     id зеркала (sendMessage) в support-топике, ключ маршрутизации ответа оператора.
@@ -75,18 +106,103 @@ def record_inbound(
     review M1): скоупит будущий резолв `find_thread_by_topic_message` к ТЕКУЩЕЙ
     support-группе — если группу когда-нибудь сменят/пересоздадут, Telegram
     message_id стартует заново с 1 в новом чате и может совпасть с числом из
-    старого — без этого поля коллизия была бы ТИХОЙ (см. миграцию 187/188)."""
+    старого — без этого поля коллизия была бы ТИХОЙ (см. миграцию 187/188).
+
+    `idempotency_key` (#3471, миграция 301) — вызывающая сторона (`app.api.v1.support`)
+    делает SELECT-затем-действие pre-check ДО Telegram-похода (см.
+    `find_inbound_by_idempotency_key`), но этот pre-check САМ ПО СЕБЕ гонку не
+    закрывает (TOCTOU): два запроса с одним ключом могут пройти его одновременно
+    и оба уйти в Telegram. Последняя линия защиты — здесь: `INSERT ... ON
+    CONFLICT (thread_id, idempotency_key) DO NOTHING` на partial unique индексе
+    (мигр. 301, тот же predicate). Если конфликт всё же случился, проигравший
+    НЕ создаёт вторую строку — читает уже вставленную и возвращает её, так что
+    оба запроса-конкурента получают ОДИН и тот же id. `idempotency_key=None`
+    (дефолт) ведёт себя как раньше: NULL никогда не конфликтует сам с собой в
+    partial-индексе (WHERE idempotency_key IS NOT NULL), INSERT всегда проходит."""
     row = (
         db.execute(
             text(
                 """
                 INSERT INTO web_support_messages
                     (thread_id, direction, text_body, topic_message_id,
-                     support_chat_id, operator_tg_id, created_at)
+                     support_chat_id, operator_tg_id, idempotency_key, created_at)
                 VALUES
                     (CAST(:thread_id AS bigint), 'in', :text_body,
                      CAST(:topic_message_id AS bigint),
-                     CAST(:support_chat_id AS bigint), NULL, NOW())
+                     CAST(:support_chat_id AS bigint), NULL, :idempotency_key, NOW())
+                ON CONFLICT (thread_id, idempotency_key)
+                    WHERE idempotency_key IS NOT NULL AND direction = 'in'
+                    DO NOTHING
+                RETURNING id, direction, text_body, operator_tg_id, created_at
+                """
+            ),
+            {
+                "thread_id": thread_id,
+                "text_body": text_body,
+                "topic_message_id": topic_message_id,
+                "support_chat_id": support_chat_id,
+                "idempotency_key": idempotency_key,
+            },
+        )
+        .mappings()
+        .one_or_none()
+    )
+    if row is not None:
+        return dict(row)
+
+    # Конфликт пойман индексом — idempotency_key почти наверняка не NULL здесь
+    # (при NULL partial-индекс в конфликт не участвует), но НЕ `assert`: это
+    # прод-путь ПОСЛЕ уже доставленного в Telegram сообщения (см. H1 в
+    # app.api.v1.support), а `except SQLAlchemyError` в вызывающей стороне
+    # `AssertionError` не ловит — под `python -O` assert вдобавок исчезает
+    # молча и `existing` осталось бы `None`, что развалилось бы чуть ниже при
+    # сборке ответа. Вместо падения — явная ветка с логом и WORKING откатом.
+    existing = (
+        find_inbound_by_idempotency_key(db, thread_id=thread_id, idempotency_key=idempotency_key)
+        if idempotency_key is not None
+        else None
+    )
+    if existing is not None:
+        # Ожидаемый случай гонки (#3471): проигравший запрос уже отправил своё
+        # СОБСТВЕННОЕ зеркало в Telegram (свой topic_message_id) до того, как
+        # обнаружил конфликт здесь — эта копия зеркала теперь осиротела
+        # (реплай оператора на неё никуда не смаршрутизируется, т.к. строки
+        # для неё в БД нет). Осознанно не чиним это в этом PR (см. коммент
+        # выше по коду), но фиксируем в логе, а не молчим — ровно то же самое,
+        # для чего уже есть `_warn_operator_message_not_recorded` в другом месте.
+        logger.warning(
+            "web support: гонка по idempotency_key — зеркало topic_message_id=%s "
+            "(thread_id=%d) отправлено, но НЕ записано, победила строка id=%d",
+            topic_message_id,
+            thread_id,
+            existing["id"],
+        )
+        return existing
+
+    # Крайний случай (в норме недостижим при READ COMMITTED, которую использует
+    # этот сервис): индекс сообщил о конфликте, но повторное чтение строку не
+    # нашло. Логируем и пишем БЕЗ идемпотентности — NULL-ключ никогда не
+    # конфликтует сам с собой (partial-индекс его не видит), INSERT гарантированно
+    # пройдёт; для этого одного сообщения дедупликация отключается, но клиент
+    # получает корректный ответ вместо 500 после уже состоявшейся доставки.
+    logger.warning(
+        "web support: ON CONFLICT сообщил о конфликте (thread_id=%d, "
+        "idempotency_key=%s), но повторное чтение строки её не нашло — "
+        "записываем без идемпотентности",
+        thread_id,
+        "<set>" if idempotency_key is not None else None,
+    )
+    row = (
+        db.execute(
+            text(
+                """
+                INSERT INTO web_support_messages
+                    (thread_id, direction, text_body, topic_message_id,
+                     support_chat_id, operator_tg_id, idempotency_key, created_at)
+                VALUES
+                    (CAST(:thread_id AS bigint), 'in', :text_body,
+                     CAST(:topic_message_id AS bigint),
+                     CAST(:support_chat_id AS bigint), NULL, NULL, NOW())
                 RETURNING id, direction, text_body, operator_tg_id, created_at
                 """
             ),
@@ -106,8 +222,17 @@ def record_inbound(
 def find_thread_by_topic_message(
     db: Session, topic_message_id: int, support_chat_id: int
 ) -> int | None:
-    """Резолвит id зеркала (сообщения оператора reply_to) в thread_id — только
-    среди direction='in' записей, зеркало-конвенция как в tg_support_messages (186).
+    """Резолвит id зеркала/ответа (reply_to) в thread_id.
+
+    БЕЗ фильтра по direction (#3471 P0, было `AND direction = 'in'`): с тех пор
+    как `record_outbound` тоже сохраняет `topic_message_id` (id ответа оператора
+    В ТОПИКЕ), реплай оператора на СВОЙ предыдущий ответ обязан резолвиться так
+    же, как реплай на inbound-зеркало клиента — иначе продолжение диалога без
+    повторного цитирования клиента тихо проваливалось в orphan-check
+    (`_handle_group_reply` в bridge.py). Коллизий topic_message_id между
+    inbound- и outbound-строками одного треда быть не может: Telegram выдаёт
+    каждому сообщению в чате свой возрастающий id, `web_support_messages_topic_message_id_uq`
+    (partial unique, 187) это же и гарантирует на уровне БД.
 
     Скоупим к ТЕКУЩЕМУ `support_chat_id` (#tgsupport-web review M1): строка со
     ЧУЖИМ (не NULL и не текущим) support_chat_id — это исторический артефакт
@@ -120,7 +245,6 @@ def find_thread_by_topic_message(
             SELECT thread_id
             FROM web_support_messages
             WHERE topic_message_id = CAST(:topic_message_id AS bigint)
-              AND direction = 'in'
               AND (support_chat_id = CAST(:support_chat_id AS bigint) OR support_chat_id IS NULL)
             ORDER BY created_at DESC
             LIMIT 1
@@ -132,18 +256,40 @@ def find_thread_by_topic_message(
 
 
 def record_outbound(
-    db: Session, *, thread_id: int, text_body: str, operator_tg_id: int | None
+    db: Session,
+    *,
+    thread_id: int,
+    text_body: str,
+    operator_tg_id: int | None,
+    topic_message_id: int | None = None,
+    support_chat_id: int | None = None,
 ) -> int | None:
     """Записывает ответ оператора (реплай на веб-зеркало) как direction='out'.
-    `topic_message_id` всегда NULL — маршрутизирующий ключ живёт только на
-    inbound-записи (см. tg_support_messages-конвенцию, 186)."""
+
+    `topic_message_id` (#3471 P0, раньше был безусловно NULL) — id ЭТОГО
+    сообщения оператора в топике. Раньше маршрутизирующий ключ жил только на
+    inbound-записи (конвенция 186/187), из-за чего реплай оператора на СВОЙ
+    предыдущий ответ был нерезолвим — искать было нечего, а `reply_to_message_id`
+    указывал на строку без ключа. `find_thread_by_topic_message` теперь матчит
+    обе стороны (direction-фильтр там снят).
+
+    `support_chat_id` (deep review PR #3479) — ОБЯЗАТЕЛЕН при заполненном
+    `topic_message_id`: `find_thread_by_topic_message` матчит `support_chat_id
+    IS NULL` как лениентный wildcard "под любым текущим чатом" (легаси-строки
+    до 187/188). Без этого поля КАЖДАЯ out-строка была бы таким wildcard — при
+    ротации support-группы новый message_id мог бы совпасть со старой
+    out-строкой и увести ответ в ЧУЖОЙ тред (ровно то, от чего защищала
+    скоупинг-миграция 187/188, см. review M1 там же)."""
     row = db.execute(
         text(
             """
             INSERT INTO web_support_messages
-                (thread_id, direction, text_body, topic_message_id, operator_tg_id, created_at)
+                (thread_id, direction, text_body, topic_message_id,
+                 support_chat_id, operator_tg_id, created_at)
             VALUES
-                (CAST(:thread_id AS bigint), 'out', :text_body, NULL,
+                (CAST(:thread_id AS bigint), 'out', :text_body,
+                 CAST(:topic_message_id AS bigint),
+                 CAST(:support_chat_id AS bigint),
                  CAST(:operator_tg_id AS bigint), NOW())
             RETURNING id
             """
@@ -151,6 +297,8 @@ def record_outbound(
         {
             "thread_id": thread_id,
             "text_body": text_body,
+            "topic_message_id": topic_message_id,
+            "support_chat_id": support_chat_id,
             "operator_tg_id": operator_tg_id,
         },
     ).fetchone()

tradein-mvp/backend/app/services/yandex_address_backfill.py

@@ -141,7 +141,7 @@ async def backfill_yandex_addresses(
         # нездоровы — НЕ уходим на settings.scraper_proxy_url (см. proxy_egress module
         # docstring). Явный пропуск run'а вместо слепого прохода через egress, который
         # мог быть источником текущего инцидента.
-        logger.error(
+        logger.warning(
             "yandex_address_backfill: пул прокси исчерпан для yandex (%s) — run "
             "пропущен, ни один листинг не обработан",
             exc,

tradein-mvp/backend/app/tasks/avito_detail_backfill.py

@@ -806,7 +806,7 @@ async def run_avito_detail_backfill(
                 # и mark_failed с текстом про пул, как у домклика после #3283.
                 if _caused_by_empty_pool(e):
                     counters.failed += 1
-                    logger.error(
+                    logger.warning(
                         "avito_detail_backfill: run_id=%d СТОП — пул прокси пуст, "
                         "к площадке не ходили. enriched=%d attempted=%d",
                         run_id,
@@ -913,7 +913,7 @@ async def run_avito_detail_backfill(
                     # ratio: прогон 5210 (14 блоков из 20, ровно порог) отпечатал
                     # "ABORT -- 1 consecutive blocks" -- текущая серия в тот момент
                     # действительно равнялась единице, но обрыв был не по ней.
-                    logger.error(
+                    logger.warning(
                         "avito_detail_backfill: run_id=%d ABORT -- %s, "
                         "частая причина: %s. enriched=%d attempted=%d",
                         run_id,

tradein-mvp/backend/app/tasks/cian_history_backfill.py

@@ -256,7 +256,7 @@ async def backfill_cian_history(
                         if caused_by_no_proxy(exc):
                             result.no_proxy_stop = True
                             result.listings_failed_fetch += 1
-                            logger.error(
+                            logger.warning(
                                 "cian_history_backfill: СТОП — пул прокси пуст, к площадке "
                                 "не ходили. listing_id=%s processed=%d succeeded=%d",
                                 listing_id,

tradein-mvp/backend/app/tasks/domclick_detail_backfill.py

@@ -493,7 +493,7 @@ async def run_domclick_detail_backfill(
                         # ниже. Причина не теряется: в записи прогона стоит
                         # no_proxy_stop=1 и mark_failed с текстом про пул.
                         counters.failed += 1
-                        logger.error(
+                        logger.warning(
                             "domclick_detail_backfill: run_id=%d СТОП — пул прокси пуст, "
                             "к площадке не ходили. enriched=%d attempted=%d",
                             run_id,
@@ -572,7 +572,7 @@ async def run_domclick_detail_backfill(
                     if consecutive_blocks >= max_consecutive_blocks:
                         # #3196: причину больше не выдумываем и не молчим — печатаем
                         # перепись диагнозов по HTTP-статусам этого прогона.
-                        logger.error(
+                        logger.warning(
                             "domclick_detail_backfill: run_id=%d ABORT -- %d consecutive "
                             "blocks, диагнозы: %s. enriched=%d attempted=%d",
                             run_id,

tradein-mvp/backend/app/tasks/glitchtip_alert_retry.py

@@ -0,0 +1,105 @@
+"""Фоновая пересылка GlitchTip-алерта в Telegram после отказа синхронной попытки.
+
+Контекст (#3471, #3157, #3456). GlitchTip-вебхуки НЕ ретраятся — сам GlitchTip
+безусловно помечает уведомление ``is_sent`` сразу после HTTP-ответа приёмника
+(upstream-поведение, см. #3157), поэтому если синхронная пересылка в Telegram
+(``app.api.v1.glitchtip``) не удалась, повторной доставки от GlitchTip не будет
+никогда — текст алерта исчезает бесследно. Ответ 502 на отказ Telegram остаётся
+как есть (задуман осознанно, #3456: честный сигнал отправителю, а не тихий
+проглот) — меняется то, что происходит С ТЕКСТОМ алерта после этого отказа.
+
+Почему не Celery. В tradein-mvp нет очереди с воркером: ни ``app/celery_app.py``,
+ни зависимости ``celery`` в ``backend/pyproject.toml`` не существует (проверено
+при работе над #3471) — попытка ``from celery import ...`` здесь упала бы
+``ModuleNotFoundError``. Бутстрап полноценного Celery-воркера — новый контейнер и
+брокер, инфраструктурное решение вне границ этой задачи. Единственный доступный
+внутри границ задачи (``app/api/v1/glitchtip.py`` + ``app/tasks/**``) механизм
+«не блокировать интерактивный ответ, но не потерять текст» — Starlette
+``BackgroundTasks``: выполняется ПОСЛЕ отправки HTTP-ответа тем же процессом, вне
+узкого интерактивного бюджета (``_INTERACTIVE_SEND_TIMEOUT_S=8s`` в glitchtip.py),
+поэтому здесь можно позволить себе штатную "воркерную" ретрай-политику клиента
+(``TelegramClient.send_message`` без явных ``timeout``/``max_retries`` — 5 попыток,
+backoff до 30s, см. ``app.services.tgbot.client``), плюс собственный внешний
+потолок ниже.
+
+Компромисс, честно: BackgroundTasks не переживает рестарт процесса (это не
+персистентная очередь) — если tradein-backend упадёт ровно между отказом
+синхронной попытки и завершением фоновой, текст всё-таки потеряется. Событие
+редкое (одно с начала эксплуатации, TRADE-IN-3F7, 28.08.2026), а сеть до Telegram
+теряет отдельные запросы, а не рвётся на минуты (замер 12.09: 9/12 успешных
+``getMe``) — штатной ретрай-политики клиента обычно достаточно без внешнего
+потолка вовсе. Персистентная очередь (переживающая рестарт) требует
+Celery/Redis-воркера — отдельное инфраструктурное решение.
+
+Идемпотентность настолько, насколько дёшево. Текст между попытками не
+пересобирается (переиспользуется уже отформатированный ``text`` из
+``glitchtip.py`` — никакого дублирования форматирования). Полной идемпотентности
+нет и быть не может дёшево: Telegram ``sendMessage`` не идемпотентен сам по себе
+(повтор создаёт НОВОЕ сообщение, не апдейтит старое) — именно поэтому внешний
+потолок попыток мал (``_MAX_ATTEMPTS``), а не «ретраить пока не получится».
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from app.services.tgbot.client import TelegramClient, TelegramError
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["retry_forward_alert"]
+
+# Внешний потолок ПОВЕРХ штатной ретрай-политики клиента (5 попыток внутри одного
+# send_message с backoff до 30s) — защита от «недоставляемый алерт крутится в фоне
+# вечно»: если сеть до Telegram не восстановилась за это время, сдаёмся и логируем
+# ERROR с текстом, а не повторяем бесконечно.
+_MAX_ATTEMPTS = 3
+_RETRY_DELAY_S = 30.0
+
+
+async def retry_forward_alert(
+    client: TelegramClient,
+    *,
+    chat_id: int,
+    text: str,
+    message_thread_id: int | None,
+) -> None:
+    """Досылает уже отформатированный текст алерта после отказа синхронной попытки.
+
+    ``client`` — ТОТ ЖЕ общий клиент приложения, что и в синхронном пути
+    (``get_telegram_client()`` в ``glitchtip.py``), а не новый инстанс: он живёт в
+    lifespan ради keep-alive-соединения (см. docstring ``glitchtip.py``).
+    """
+    for attempt in range(1, _MAX_ATTEMPTS + 1):
+        try:
+            await client.send_message(
+                chat_id=chat_id,
+                text=text,
+                message_thread_id=message_thread_id,
+                # Без явных timeout/max_retries — штатная "воркерная" политика
+                # клиента (см. докстринг модуля).
+            )
+        except TelegramError:
+            if attempt == _MAX_ATTEMPTS:
+                logger.error(
+                    "glitchtip alert retry: не удалось доставить алерт в Telegram "
+                    "после %d попыток — текст потерян: %r",
+                    _MAX_ATTEMPTS,
+                    text[:200],
+                    exc_info=True,
+                )
+                return
+            logger.warning(
+                "glitchtip alert retry: попытка %d/%d не удалась, повтор через %.0fs",
+                attempt,
+                _MAX_ATTEMPTS,
+                _RETRY_DELAY_S,
+                exc_info=True,
+            )
+            await asyncio.sleep(_RETRY_DELAY_S)
+        else:
+            logger.info(
+                "glitchtip alert retry: доставлено фоном с попытки %d/%d", attempt, _MAX_ATTEMPTS
+            )
+            return

tradein-mvp/backend/app/tasks/landing_showcase_deals.py

@@ -9,26 +9,36 @@
 
 ПРАВИЛО ОТБОРА — ЯВНО И БЕЗ ПОДГОНКИ
 ------------------------------------
-Отбираем N строк ключом::
+Витрина показывает ПОЛОСУ РАСХОЖДЕНИЯ, а не всю сверку. С 2026-09-12 решением
+владельца продукта на витрину попадают только сделки, у которых расхождение
+прогноза с ценой ДКП лежит в пределах `BAND_MIN_ERR_PCT`..`BAND_MAX_ERR_PCT`
+(−5 %..+20 % включительно). Оставшиеся `limit` строк ранжируются ключом::
 
     (полнота данных ↓, свежесть квартала ↓, id сделки ↓)
 
-Величина ошибки в ключе НЕ УЧАСТВУЕТ и участвовать не должна. Отбор по малой
-ошибке превращает витрину в рекламу: показанные 20 строк перестают быть
-выборкой из работы оценщика и становятся её лучшим хвостом, а посетитель
-читает их как «вот так МЕРА обычно и попадает». Это тот самый случай, когда
-код формально работает, а продукт врёт. Проверяется тестом
-`test_landing_showcase_deals.py::test_selection_ignores_error_magnitude`.
+ЭТО ОТБОР ПОКАЗАТЕЛЬНЫХ СТРОК, И НАЗЫВАТЬ ЕГО НАДО ТАК. До 2026-09-12 здесь
+не было ни фильтра, ни слагаемого ошибки в ключе, и подпись витрины это прямо
+утверждала. Теперь утверждать это нельзя: строки с промахом крупнее полосы в
+данных есть (на проде 30.08.2026 из показанных двадцати вне полосы было
+двенадцать — от −27,9 % до +75,7 %), и они не показываются. Поэтому полоса
+названа в `REJECTION_RULE`, которое едет на фронт вместе со счётчиками
+прогона, и в подписи под таблицей рядом с медианой расхождения ПО ВСЕЙ
+СВЕРКЕ: два числа рядом не дают прочитать двадцать отобранных строк как
+«вот так МЕРА обычно и попадает».
 
-ФИЛЬТРА ПО ОШИБКЕ ТОЖЕ НЕТ — И ЭТО ТО ЖЕ САМОЕ ПРАВИЛО. До 2026-08-29 здесь
-жил порог `MAX_ABS_ERR_PCT = 40`, выбрасывавший кандидата ПО ВЕЛИЧИНЕ ОШИБКИ
-до ранжирования. Запрет выше он обходил ступенькой раньше: отбор по ошибке в
-ключе и отбор по ошибке в фильтре — одно и то же действие, и второе даже
-злее, потому что не оставляет строку в кандидатах. Обоснование «отклонение
-больше 40% — это почти всегда занижение ДКП ради налога» не держится: см.
-следующий раздел, грубые занижения вырезаны выше по потоку и по свойству
-самой сделки. Отбраковываем только то, чего в данных НЕТ (нет прогноза, нет
-квартала, нет площади) — «число некрасивое» причиной не является.
+ЧТО ЭТО НЕ ОТМЕНЯЕТ. Внутри полосы отбор по величине ошибки по-прежнему
+запрещён — иначе витрина показывала бы лучший хвост уже самой полосы
+(`test_selection_ignores_error_magnitude`). Счётчики прогона считаются ДО
+полосы: `eligible` — сколько строк прогон вообще собрал, `written` — сколько
+из них прошло полосу и поместилось в `limit`. Разница между ними видна
+посетителю, и она честная ровно потому, что рядом сказано, чем именно
+отобраны показанные. Если в полосу попало меньше `limit` строк — показываем
+сколько есть; добирать соседями по ошибке нельзя, это вернуло бы отбор по
+величине ошибки в обход полосы.
+
+Отбраковка по «данных нет» (нет прогноза, нет квартала, нет площади) осталась
+прежней и живёт в `build_row`: строка вне полосы ОСТАЁТСЯ кандидатом и
+попадает в счётчик `eligible`, её снимает отбор, а не отбраковка.
 
 Полнота — сколько из полей, которые видит посетитель (район, этаж, этажность,
 схема улицы), у строки заполнено. Свежесть — порядок квартала сделки.
@@ -57,8 +67,10 @@
     `PPM2_MIN = 30 000` / `PPM2_MAX = 600 000` (город намеренно не заведён в
     `deal_city_price_bands`, там же и комментарий об этом). Значит грубые
     занижения из выборки уже вырезаны ДО того, как сюда приходит кандидат, а
-    всё, что после этого дало большую ошибку, — работа оценщика, и витрина
-    обязана её показать. Своей копии диапазона здесь нет намеренно: прежние
+    всё, что после этого дало большую ошибку, — работа оценщика. С 2026-09-12
+    такая строка на витрину не выходит (полоса), но остаётся в `eligible` и
+    в подписи названа отобранной, а не несуществующей. Своей копии диапазона
+    здесь нет намеренно: прежние
     `MIN_FACT_PPM2 = 30k` дублировал уже применённый фильтр, а
     `MAX_FACT_PPM2 = 1.2M` был недостижим при потолке выборки 600k — из трёх
     отбраковок в проде срабатывала РОВНО ОДНА, та самая, что льстила витрине.
@@ -75,7 +87,10 @@
     ошибки, — правило отбора выше не нарушено.
   * СЧЁТЧИКИ ЕДУТ НА ФРОНТ, А НЕ ТОЛЬКО В ЛОГ. «Мы показываем 20 отличных
     строк» неотличимо от «столько и было», пока рядом не написано, сколько
-    сделок рассмотрено и сколько годных строк не поместилось. Поэтому итог
+    сделок рассмотрено, сколько строк прогон собрал и по какому правилу из
+    них отобраны показанные. С появлением полосы это перестало быть
+    страховкой и стало обязательным: без счётчиков и правила отобранная
+    двадцатка читается как вся сверка. Поэтому итог
     прогона пишется в `landing_showcase_runs` (миграция 277) и отдаётся
     ручкой `/api/public/mera/showcase` вместе со строками.
 
@@ -104,18 +119,47 @@ from app.services.street_scheme import StreetIndex, build_street_scheme, load_st
 
 logger = logging.getLogger(__name__)
 
-# ── Правило отбраковки: одна формулировка, она же едет на фронт ──────────────
+# ── Полоса расхождения: что показываем и что об этом сказано ─────────────────
 #
-# Порогов на величину ошибки здесь НЕТ (разбор — в докстринге модуля). Санитарный
-# диапазон ₽/м² применён выше по потоку, в `_load_sample`; дублировать его тут
-# значило бы завести проверку, которая в проде не срабатывает никогда.
+# Границы ВКЛЮЧИТЕЛЬНЫЕ. Полоса несимметрична намеренно: решение владельца от
+# 2026-09-12 — показывать сделки, где МЕРА не занизила больше чем на 5 % и не
+# завысила больше чем на 20 %.
+BAND_MIN_ERR_PCT = -5.0
+BAND_MAX_ERR_PCT = 20.0
+
+# Подпись полосы ВЫВОДИТСЯ из границ, а не вписывается рядом: «−5 %…+20 %» в
+# тексте и `>= -5.0` в коде — две независимые величины, и разъедутся они
+# ровно тогда, когда порог однажды подвинут.
+BAND_LABEL = f"от {BAND_MIN_ERR_PCT:+.0f} % до {BAND_MAX_ERR_PCT:+.0f} % включительно"
+
+
+def in_band(err_pct: float) -> bool:
+    """Попадает ли расхождение в показываемую полосу (границы включительно)."""
+    return BAND_MIN_ERR_PCT <= err_pct <= BAND_MAX_ERR_PCT
+
+
+# ── Правило отбора и отбраковки: одна формулировка, она же едет на фронт ──────
+#
+# Санитарный диапазон ₽/м² применён выше по потоку, в `_load_sample`;
+# дублировать его тут значило бы завести проверку, которая в проде не
+# срабатывает никогда.
+#
+# ТЕКСТ ОБЯЗАН НАЗЫВАТЬ ПОЛОСУ. Пока фильтра не было, здесь стояло «величина
+# отклонения на отбор и отбраковку не влияет — иначе витрина показывала бы
+# лучший хвост, а не работу расчёта». С фильтром эта фраза стала ложью ровно
+# про то, чего опасалась, поэтому она снята, а не смягчена.
 REJECTION_RULE = (
-    "Строка не попадает на витрину, только если данных нет: расчёт МЕРЫ не дал "
-    "ожидаемой цены продажи (мало аналогов), неизвестен квартал сделки или "
-    "площадь. Величина отклонения на отбор и отбраковку не влияет — иначе "
-    "витрина показывала бы лучший хвост, а не работу расчёта. Санитарный "
-    "диапазон цены сделки (30 000–600 000 ₽/м² для Екатеринбурга) применён "
-    "к выборке до расчёта, по цене самой сделки."
+    f"На витрине — ОТОБРАННАЯ полоса расхождения, а не вся сверка: показаны "
+    f"только сделки, у которых расхождение прогноза с ценой ДКП лежит {BAND_LABEL}. "
+    "Промахи крупнее полосы в данных есть, и здесь их не видно — судить по этим "
+    "строкам о точности расчёта нельзя, для этого есть медиана расхождения по "
+    "всей сверке. Внутри полосы порядок задают полнота данных и свежесть "
+    "квартала: величина отклонения на него не влияет, лучший хвост самой полосы "
+    "витрина тоже не показывает. Кроме полосы строку снимает только отсутствие "
+    "данных: расчёт МЕРЫ не дал ожидаемой цены продажи (мало аналогов), "
+    "неизвестен квартал сделки или площадь. Санитарный диапазон цены сделки "
+    "(30 000–600 000 ₽/м² для Екатеринбурга) применён к выборке до расчёта, по "
+    "цене самой сделки."
 )
 
 NOTE = (
@@ -184,7 +228,7 @@ def completeness(row: ShowcaseRow) -> int:
 
 
 def _sort_key(row: ShowcaseRow) -> tuple[int, date, int]:
-    """Ключ отбора. Ошибки здесь нет — см. «ПРАВИЛО ОТБОРА» в докстринге модуля."""
+    """Ключ ранжирования. Ошибки здесь нет — см. «ПРАВИЛО ОТБОРА» в докстринге."""
     return (
         -completeness(row),
         -(row.deal_date or date.min).toordinal(),
@@ -193,8 +237,25 @@ def _sort_key(row: ShowcaseRow) -> tuple[int, date, int]:
 
 
 def select_rows(rows: list[ShowcaseRow], limit: int) -> list[ShowcaseRow]:
-    """Отобрать `limit` строк по полноте и свежести (НЕ по величине ошибки)."""
-    return sorted(rows, key=_sort_key)[:limit]
+    """Строки полосы −5 %..+20 %, до `limit` штук, по полноте и свежести.
+
+    ДВА ДЕЙСТВИЯ, И ОНИ РАЗНЫЕ. Сначала ФИЛЬТР по величине расхождения
+    (`in_band`) — это и есть «витрина показывает отобранную полосу, а не всю
+    сверку», названное так же в `REJECTION_RULE` и в подписи под таблицей.
+    Потом РАНЖИРОВАНИЕ уцелевших по полноте данных и свежести квартала —
+    внутри полосы величина ошибки на порядок не влияет, иначе показывался бы
+    лучший хвост уже самой полосы.
+
+    Фильтр стоит ЗДЕСЬ, а не в `build_row`, намеренно: строка вне полосы
+    обязана остаться кандидатом и попасть в счётчик `eligible`. Отбраковав её
+    раньше, мы получили бы «показано 20 из 20 годных» — счётчик, из которого
+    отбор не виден вообще.
+
+    В полосе меньше `limit` строк — возвращаем сколько есть. Добирать
+    ближайшими по ошибке нельзя: это тот же отбор по величине ошибки, просто
+    с другой стороны.
+    """
+    return sorted((r for r in rows if in_band(r.err_pct)), key=_sort_key)[:limit]
 
 
 def build_row(
@@ -217,8 +278,11 @@ def build_row(
 
     Причины отказа ИСЧЕРПЫВАЮЩИЕ и все — «данных нет»: спайн не дал ожидаемой
     цены продажи; квартал сделки неизвестен; нет площади или цены сделки
-    (делить не на что). Величина отклонения причиной НЕ является ни при каких
-    значениях — см. «ФИЛЬТРА ПО ОШИБКЕ ТОЖЕ НЕТ» в докстринге модуля.
+    (делить не на что). Величина отклонения причиной отказа НЕ является ни при
+    каких значениях: строка с любым промахом становится кандидатом и попадает
+    в счётчик `eligible`. Полоса, по которой из кандидатов отбираются
+    показанные, применяется позже и в другом месте — `select_rows`; здесь её
+    нет намеренно, иначе отбор перестал бы быть виден в счётчиках.
 
     ФАКТ — ЭТО `deals.price_rub`, ЦЕНА ИЗ ДОГОВОРА, А НЕ ПРОИЗВЕДЕНИЕ. Колонка на
     витрине называется «Цена ДКП», и подпись обязана называть ту величину, которая
@@ -384,9 +448,14 @@ def refresh_landing_showcase_deals(
       priced        из них оценщик дал ожидаемую цену продажи
       no_prediction не дал (мало аналогов / спайн упал)
       incomplete    цена есть, но нет квартала/площади — строку не собрать
-      eligible      годных строк ВСЕГО (никакого отсева по ошибке нет)
-      written       из них показано (обрезано по `limit`)
+      eligible      строк СОБРАНО всего, ДО полосы (данных хватило)
+      written       из них показано: прошли полосу и поместились в `limit`
       with_district у скольких показанных удалось определить район
+
+    `eligible` минус `written` — это НЕ «столько не поместилось»: с 2026-09-12
+    в разницу входят и строки вне полосы −5 %..+20 %. Поэтому подпись под
+    таблицей называет `eligible` собранными строками, а чем отобраны
+    показанные — говорит `REJECTION_RULE`, который едет тем же ответом.
     """
     # Импорт внутри функции: `scripts.backtest_estimator` тянет оценщик со всеми
     # его зависимостями, а web-процессу это на импорте приложения не нужно.
@@ -444,6 +513,16 @@ def refresh_landing_showcase_deals(
         candidates.append(row)
 
     chosen = select_rows(candidates, limit)
+    # Сколько собранных строк вообще попало в полосу — в лог, а не в счётчики:
+    # колонки под него в `landing_showcase_runs` нет, а без него по `written`
+    # не отличить «полоса оставила мало» от «упёрлись в limit».
+    logger.info(
+        "в полосе %s: %d из %d собранных, показано %d",
+        BAND_LABEL,
+        sum(1 for r in candidates if in_band(r.err_pct)),
+        len(candidates),
+        len(chosen),
+    )
     schemes = _schemes_for(db, street_index, chosen, {d.id: d.address for d in deals})
 
     db.execute(_DELETE_SQL)
@@ -488,7 +567,7 @@ def refresh_landing_showcase_deals(
 
     logger.info(
         "витрина обновлена: рассмотрено=%d оценено=%d без_прогноза=%d неполных=%d "
-        "годных=%d записано=%d с_районом=%d",
+        "собрано=%d записано=%d с_районом=%d",
         counters["considered"],
         counters["priced"],
         counters["no_prediction"],

tradein-mvp/backend/app/tasks/msk_raw_import.py

@@ -1,22 +1,34 @@
-"""Импорт московского сырья (`msk_raw.*_latest`) в `listings`.
+"""Импорт сырья `msk_raw.*_latest` в `listings` — Москва (77) и область (50).
 
 Сырьё собрано отдельным коллектором и лежит в прод-схеме `msk_raw`: каждая строка
 несёт `payload` — сериализованный `ScrapedLot` один в один (те же 54 ключа, что и
 поля модели, см. `scraper_kit/base.py`). Свой писатель поэтому не нужен: собираем
-`ScrapedLot(**payload)` и отдаём в штатный `save_listings(..., region_code=77)`.
+`ScrapedLot(**payload)` и отдаём в штатный `save_listings(..., region_code=region)`.
 
-Отбор Москвы (source=cian). Адрес карточки Циана города НЕ содержит, зато
-начинается с округа: «ЦАО, ...», «СВАО, ...». По этому префиксу Москва и
-опознаётся. Замер по проду (60 464 карточки): с округом — 35 551, ВСЕ внутри
-bbox региона 77; без округа внутри bbox — 17 576 (это Московская область, регион
-50, которого в реестре ещё нет, в этот импорт не берём); без округа вне bbox —
-7 337. Отдельно 212 карточек с адресом вида «Екатеринбург (Cian)» — артефакт
-парсера, считаются своим счётчиком, чтобы не растворяться в «не Москва».
+Отбор региона (source=cian). Адрес карточки Циана города НЕ содержит, зато для
+Москвы начинается с округа: «ЦАО, ...», «СВАО, ...». По этому префиксу Москва и
+опознаётся — байт-в-байт как раньше. Замер по проду (60 464 карточки): с округом
+— 35 551, ВСЕ внутри bbox региона 77; без округа внутри bbox — 17 576 (это
+Московская область, регион 50); без округа вне bbox — 7 337. Отдельно 212
+карточек с адресом вида «Екатеринбург (Cian)» — артефакт парсера, считаются
+своим счётчиком, чтобы не растворяться в «не целевой регион».
+
+Область (регион 50) у Циана в адресе НЕ видна вовсе — берём по ПОДДОМЕНУ
+`source_url` (`https://<sub>.cian.ru/...`): `sub != "www"` ⇒ область. Замер по
+`msk_raw.cian_latest` 12.09.2026: `www` — 38 030 карточек, из них 36 569 с
+префиксом округа (это Москва); все прочие поддомены (krasnogorsk 2065,
+balashikha 1828, vidnoye 1802, lyubertsy 1498, zvenigorod 1420, khimki 1306,
+mytishchi 1288, podolsk 756, odintsovo 738, …) — 0 карточек с префиксом округа,
+итого не-www ≈ 24 784. Поддомен и префикс округа нигде не противоречат друг
+другу, поэтому Москва остаётся на префиксе округа (не трогаем), а область —
+на поддомене. Поддомен не распознался (нет source_url / хост не `*.cian.ru`) →
+карточка НЕ область (консервативно, счётчик «не целевой регион»).
 
 Отбор Москвы (source=avito) по адресу НЕВОЗМОЖЕН: у Авито адрес — голая улица с
 домом («Варшавское ш.,62к1»), ни города, ни округа, и координат нет НИ У ОДНОЙ
 карточки (замер: lat/lon/cadastral_number/geo_precision пусты у всех 50 335).
-Поэтому для Авито работает ПРЕД-ГЕОКОД (`--geocode`), а не префиксный фильтр.
+Поэтому для Авито работает ПРЕД-ГЕОКОД (`--geocode`), а не префиксный фильтр —
+для ЛЮБОГО целевого региона.
 
 Два сигнала, и оба нужны — ни один по отдельности не годится.
 
@@ -42,16 +54,16 @@ bbox региона 77; без округа внутри bbox — 17 576 (это
 qc_geo=0 у 97% найденных.
 
 Что куда едет:
-  * регион 77 → в `listings`, С координатами (geom есть сразу, radius-подбор
-    аналогов работает без ожидания `geocode_missing`);
-  * регион 50 → НЕ пишется, ждёт появления региона 50 в реестре; лежит не в
-    воздухе, а строкой в `msk_raw.avito_geocode` (region_code=50) — когда
-    регион появится, прогон по этой полке уже не потребует внешних вызовов;
+  * регион == `--region` → в `listings`, С координатами (geom есть сразу,
+    radius-подбор аналогов работает без ожидания `geocode_missing`);
+  * адрес разрешился, но регион ответа не совпал с `--region` → не пишется,
+    лежит не в воздухе, а строкой в `msk_raw.avito_geocode` — прогон с другим
+    `--region` подхватит её из кэша без единого внешнего вызова;
   * адрес не разрешился (ЖК без улицы, «Мкр-н имени В.Н. Махалина, 33») →
     свой счётчик, карточка не пишется.
 
 `--allow-unfiltered` (без `--geocode`) остаётся прежним аварийным режимом: пишет
-Москву вперемешку с областью и БЕЗ geom. Молча он по-прежнему не срабатывает.
+целевой регион вперемешку с прочими и БЕЗ geom. Молча он по-прежнему не срабатывает.
 
 Пересчёт `listing_segment` (пункт, ради которого нельзя копировать payload как
 есть). Кит ставит 'novostroyki' по одному лишь наличию `offer.newbuilding.id`,
@@ -71,17 +83,43 @@ source_id) считает сам кит (`ScrapedLot.compute_dedup_hash`), це
 курсор идёт по `id` вью, так что порядок и полнота обхода от прогона к прогону
 одинаковы.
 
-Отбор Москвы (source=yandex) стоит ноль вызовов: адрес приходит полным и
+Отбор региона (source=yandex) стоит ноль вызовов: адрес приходит полным и
 нормализованным («Россия, Москва, Коробейников переулок, 1»), регион читается
 вторым компонентом. Замер по 21 393 карточкам первого прохода — ровно два
 значения, «Москва» 10 610 и «Московская область» 10 783. Координаты у Яндекса
 заполнены у 100% карточек, поэтому ни геокод, ни `geocode_missing` ему не нужны.
 
+Отбор региона (source=domclick) стоит ноль вызовов, но таблица одна на ДВА
+РАЗНЫХ прогона сборщика с разными GUID: московский (батч
+`msk-serp-domclick-20260912`) и областной (отдельный запуск, батч
+`mo-serp-domclick-20260912`) — оба пишут в один и тот же
+`msk_raw.domclick_cards`. Колонки региона в таблице НЕТ, а вью
+`msk_raw.domclick_latest` отдаёт обе партии вперемешку — курсор по `id` не
+различает, из какого прогона строка. Поэтому фильтр по адресу здесь не
+опциональная вторая линия, а единственный способ развести регионы.
+
+Регион читается ПЕРВЫМ компонентом адреса. Замер живьём на API ДомКлика
+12.09.2026: московские карточки — «Москва, Генерала Дорохова проспект, 49» и
+подобные, первый компонент «Москва» у всех 22 836 карточек прод-корпуса;
+областные карточки — «Московская область, Химки, 7-й м-н, проспект
+Мельникова, 33», «Московская область, Одинцовский городской округ,
+Звенигород, 3-й м-н, 28» и подобные, первый компонент «Московская область» у
+всех 140 карточек выборки с семи разных смещений выдачи. Разделение полное и
+симметричное `is_moscow_yandex_address`/`is_oblast_yandex_address`. Новая
+Москва приходит как «Москва, пос. Птичное, …» — посёлок стоит вторым
+компонентом, первый по-прежнему «Москва», регион 77 не ломается. Координаты
+заполнены у 100% карточек в обоих прогонах.
+
 Запуск:
     python -m app.tasks.msk_raw_import --dry-run
     python -m app.tasks.msk_raw_import --limit 500
     python -m app.tasks.msk_raw_import --source yandex
+    python -m app.tasks.msk_raw_import --source yandex --region 50
+    python -m app.tasks.msk_raw_import --source cian --region 50
+    python -m app.tasks.msk_raw_import --source domclick
+    python -m app.tasks.msk_raw_import --source domclick --region 50
     python -m app.tasks.msk_raw_import --source avito --geocode --geocode-limit 9000
+    python -m app.tasks.msk_raw_import --source avito --geocode --region 50
     python -m app.tasks.msk_raw_import --source avito --allow-unfiltered  # аварийный
 """
 
@@ -91,6 +129,7 @@ import argparse
 import asyncio
 import logging
 import re
+from collections.abc import Callable
 from dataclasses import dataclass
 from urllib.parse import urlsplit
 
@@ -102,15 +141,18 @@ from sqlalchemy.orm import Session
 from app.core.db import SessionLocal
 from app.services import dadata
 from app.services.geocoder import normalize_address
+from app.services.regions import REGIONS, is_within_bbox
 from app.services.scraper_adapters import RealMatcherAdapter
 
 logger = logging.getLogger(__name__)
 
 MOSCOW_REGION_CODE = 77
 MOSCOW_CITY = "Москва"
-# Регион 50 (Московская область) в реестре `app.services.regions` ещё не заведён —
-# карточки области не пишутся, а откладываются (см. докстринг модуля).
+# Московская область в реестре `app.services.regions` заведена, но своего
+# единого города у неё нет (`canonical_city is None`) — в listings.city для
+# неё пишем None (см. `import_msk_raw`, `save_listings` его COALESCE'ит).
 OBLAST_REGION_CODE = 50
+SUPPORTED_REGIONS = (MOSCOW_REGION_CODE, OBLAST_REGION_CODE)
 DEFAULT_BATCH_SIZE = 500
 
 # Слаг города в `source_url` Авито: `https://www.avito.ru/<slug>/kvartiry/...`.
@@ -160,6 +202,7 @@ SOURCE_VIEWS = {
     "cian": "msk_raw.cian_latest",
     "avito": "msk_raw.avito_latest",
     "yandex": "msk_raw.yandex_latest",
+    "domclick": "msk_raw.domclick_latest",
 }
 
 _PAGE_SQL = """
@@ -415,14 +458,16 @@ class ImportCounters:
 
     read: int = 0
     skipped_artifact: int = 0
-    skipped_not_moscow: int = 0
+    # Карточка сама говорит про другой регион (префикс округа / поддомен
+    # Циана / компонент адреса не совпал с целевым `--region`).
+    skipped_not_target_region: int = 0
     skipped_invalid: int = 0
-    # Пред-геокод Авито: два РАЗНЫХ исхода, и смешивать их нельзя. Область —
-    # адрес разрешён, дом реальный, просто регион 50 (ждёт реестра). Не
-    # разрешён — DaData дома не нашла ИЛИ кончился бюджет вызовов; всплеск
-    # этого счётчика читается как «проверь квоту», а не «в Москве стало меньше
-    # домов».
-    skipped_oblast: int = 0
+    # Пред-геокод Авито: два РАЗНЫХ исхода, и смешивать их нельзя. Другой
+    # регион — адрес разрешён, дом реальный, просто регион в ответе DaData не
+    # совпал с целевым. Не разрешён — DaData дома не нашла ИЛИ кончился
+    # бюджет вызовов; всплеск этого счётчика читается как «проверь квоту», а
+    # не «в целевом регионе стало меньше домов».
+    skipped_geo_other_region: int = 0
     skipped_ungeocoded: int = 0
     selected: int = 0
     inserted: int = 0
@@ -449,8 +494,8 @@ class ImportCounters:
             self.read
             == self.selected
             + self.skipped_artifact
-            + self.skipped_not_moscow
-            + self.skipped_oblast
+            + self.skipped_not_target_region
+            + self.skipped_geo_other_region
             + self.skipped_ungeocoded
             + self.skipped_invalid
         )
@@ -468,6 +513,37 @@ def is_moscow_address(address: str | None) -> bool:
     return _MOSCOW_OKRUG_RE.match(address.strip()) is not None
 
 
+def cian_subdomain(payload: dict) -> str | None:
+    """Поддомен `source_url` Циана: `https://<sub>.cian.ru/...` → `<sub>`.
+
+    Адрес карточки регион 50 не выдаёт вовсе (см. докстринг модуля), поэтому
+    область читается из URL. Поддомен и префикс округа не противоречат друг
+    другу ни в одной карточке (замер по `msk_raw.cian_latest`, 12.09.2026):
+    `www` — 38 030 карточек (36 569 с префиксом округа, это Москва); все
+    прочие поддомены (krasnogorsk, balashikha, vidnoye, lyubertsy, zvenigorod,
+    khimki, mytishchi, podolsk, odintsovo, …) — 0 карточек с префиксом округа.
+    Хост не `*.cian.ru` или `source_url` отсутствует → None (консервативно:
+    региону не сопоставляем).
+    """
+    url = payload.get("source_url")
+    if not isinstance(url, str) or not url:
+        return None
+    # `hostname`, а не `netloc`: он уже без порта и userinfo и в нижнем
+    # регистре — иначе гипотетический `www.cian.ru:443` промахнулся бы мимо
+    # суффикса и уехал в «не целевой регион».
+    host = urlsplit(url).hostname or ""
+    if not host.endswith(".cian.ru"):
+        return None
+    sub = host[: -len(".cian.ru")]
+    return sub or None
+
+
+def is_cian_oblast_payload(payload: dict) -> bool:
+    """Регион 50 у Циана: любой поддомен, кроме `www` (см. `cian_subdomain`)."""
+    sub = cian_subdomain(payload)
+    return sub is not None and sub != "www"
+
+
 def is_moscow_yandex_address(address: str | None) -> bool:
     """У Яндекса регион — второй компонент полного адреса.
 
@@ -485,11 +561,99 @@ def is_moscow_yandex_address(address: str | None) -> bool:
     return len(parts) > 1 and parts[1] == "Москва"
 
 
-# Источники, у которых город виден в самой карточке. Ключ отсутствует —
-# источник про город молчит, и без пред-геокода писать его нельзя (avito).
-CITY_FILTERS = {
-    "cian": is_moscow_address,
-    "yandex": is_moscow_yandex_address,
+def is_oblast_yandex_address(address: str | None) -> bool:
+    """Регион 50 у Яндекса: второй компонент адреса — «Московская область».
+
+    Симметрично `is_moscow_yandex_address`: во втором компоненте встречаются
+    ровно два значения (см. докстринг модуля), третьего нет — среди карточек
+    Яндекса «не Москва» и означает «область».
+    """
+    parts = [part.strip() for part in (address or "").split(",")]
+    return len(parts) > 1 and parts[1] == "Московская область"
+
+
+def is_moscow_domclick_address(address: str | None) -> bool:
+    """У ДомКлика регион — ПЕРВЫЙ компонент адреса: «Москва, улица …».
+
+    Источник собран запросом с GUID-ом Москвы в параметре address и дополнительно
+    отфильтрован по bbox на стороне сборщика, так что областных карточек в сырье
+    и не должно быть. Фильтр здесь — вторая линия: сменится GUID в сборщике или
+    появится второй город в той же таблице — импорт не потащит его в Москву
+    молча. Замер по 5 024 карточкам первого прохода: первый компонент имеет ровно
+    одно значение, «Москва», областных нет ни одной.
+
+    Новая Москва отдельным значением НЕ приходит: «Москва, x. Ильичевка, …»,
+    «Москва, пос. Птичное, …» — посёлок стоит ВТОРЫМ компонентом, первый всегда
+    город, что совпадает с кодом региона 77.
+    """
+    parts = [part.strip() for part in (address or "").split(",")]
+    return bool(parts) and parts[0] == "Москва"
+
+
+def is_oblast_domclick_address(address: str | None) -> bool:
+    """Регион 50 у ДомКлика: первый компонент адреса — «Московская область».
+
+    Симметрично `is_moscow_domclick_address`. Таблица `msk_raw.domclick_cards`
+    копит ДВА разных прогона сборщика (московский батч
+    `msk-serp-domclick-20260912`, областной `mo-serp-domclick-20260912`) без
+    своей колонки региона, а вью `msk_raw.domclick_latest` отдаёт обе партии
+    вперемешку — фильтр по адресу обязателен, не опционален. Замер живьём на
+    API ДомКлика 12.09.2026: «Московская область, Химки, 7-й м-н, проспект
+    Мельникова, 33», «Московская область, Одинцовский городской округ,
+    Звенигород, 3-й м-н, 28» и подобные — первый компонент «Московская
+    область» у всех 140 карточек выборки с семи разных смещений выдачи.
+    """
+    parts = [part.strip() for part in (address or "").split(",")]
+    return bool(parts) and parts[0] == "Московская область"
+
+
+def _payload_point(payload: dict) -> tuple[float, float] | None:
+    """(lat, lon) из сырья ДомКлика, если сборщик их положил и они читаются."""
+    try:
+        return float(payload["lat"]), float(payload["lon"])
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def is_oblast_domclick_payload(payload: dict) -> bool:
+    """Область у ДомКлика: префикс адреса ИЛИ координата внутри bbox области.
+
+    Одного префикса мало. Замер на собранном корпусе 12.09.2026 (2 961 карточка
+    областного батча): «Московская область» стоит первым компонентом у 2 960, а
+    у одной — «Можайский муниципальный округ, д. Семёновское, 1», 55.5116/35.8293.
+    Это настоящая область (Можайск), и строгий префикс выбросил бы её молча.
+    Московский батч тем же замером даёт «Москва» первым компонентом у ВСЕХ
+    22 836 карточек, поэтому явный отказ Москве идёт раньше гео-ветки и bbox
+    Москвы (вложенный в областной) не может протащить столичную карточку в 50.
+    """
+    address = payload.get("address")
+    if is_oblast_domclick_address(address):
+        return True
+    if is_moscow_domclick_address(address):
+        return False
+    point = _payload_point(payload)
+    if point is None:
+        return False
+    return is_within_bbox(point[0], point[1], REGIONS[OBLAST_REGION_CODE].bbox_region)
+
+
+def _by_address(fn: Callable[[str | None], bool]) -> Callable[[dict], bool]:
+    """Адаптер: фильтр по адресу → фильтр по всему payload'у (для реестра)."""
+    return lambda payload: fn(payload.get("address"))
+
+
+# Реестр (source, целевой регион) → фильтр по ВСЕМУ payload'у, не только
+# адресу: у Циана признак региона 50 лежит в `source_url`, адрес про него
+# молчит. Ключа нет только для источника, который вообще не умеет отличать
+# регион без пред-геокода (avito, для ЛЮБОГО региона) — для всех прочих пар
+# фильтр обязан быть в реестре явно.
+REGION_FILTERS: dict[tuple[str, int], Callable[[dict], bool]] = {
+    ("cian", MOSCOW_REGION_CODE): _by_address(is_moscow_address),
+    ("cian", OBLAST_REGION_CODE): is_cian_oblast_payload,
+    ("yandex", MOSCOW_REGION_CODE): _by_address(is_moscow_yandex_address),
+    ("yandex", OBLAST_REGION_CODE): _by_address(is_oblast_yandex_address),
+    ("domclick", MOSCOW_REGION_CODE): _by_address(is_moscow_domclick_address),
+    ("domclick", OBLAST_REGION_CODE): is_oblast_domclick_payload,
 }
 
 
@@ -538,6 +702,7 @@ def import_msk_raw(
     db: Session,
     *,
     source: str = "cian",
+    region: int = MOSCOW_REGION_CODE,
     batch_size: int = DEFAULT_BATCH_SIZE,
     limit: int | None = None,
     dry_run: bool = False,
@@ -546,32 +711,38 @@ def import_msk_raw(
     geocode_limit: int = DEFAULT_GEOCODE_LIMIT,
 ) -> ImportCounters:
     """Переливает сырьё `msk_raw` в `listings`. Коммит — на каждом батче."""
+    if region not in SUPPORTED_REGIONS:
+        raise SystemExit(f"region={region}: регион не поддержан, доступны {SUPPORTED_REGIONS}")
+
     view = SOURCE_VIEWS[source]
     counters = ImportCounters()
     matcher = RealMatcherAdapter()
     budget = GeocodeBudget(remaining=max(0, geocode_limit))
 
-    # Источник, который сам говорит про город: у Циана это префикс округа, у
-    # Яндекса — второй компонент полного адреса. Авито не говорит ничего, ему
-    # нужен пред-геокод, поэтому его в словаре нет.
-    city_filter = CITY_FILTERS.get(source)
+    # Источник, который сам говорит про целевой регион: у Циана это префикс
+    # округа/поддомен, у Яндекса — второй компонент адреса, у ДомКлика —
+    # первый. Авито не говорит ничего ни для какого региона, ему нужен
+    # пред-геокод, поэтому в реестре его нет вовсе.
+    city_filter = REGION_FILTERS.get((source, region))
     if geocode and city_filter is not None:
-        # Город опознаётся даром и без ошибок — тратить на него внешнюю квоту
+        # Регион опознаётся даром и без ошибок — тратить на него внешнюю квоту
         # незачем.
         raise SystemExit(f"source={source}: --geocode нужен только для avito")
     if city_filter is None and not geocode:
-        # Без пред-геокода у Авито по-прежнему нечем отделить Москву от области:
-        # ни города в адресе, ни координат. Пишем только по явному разрешению.
+        # Без пред-геокода у Авито по-прежнему нечем отделить целевой регион от
+        # прочих: ни города в адресе, ни координат. Пишем только по явному
+        # разрешению.
         if not (dry_run or allow_unfiltered):
             raise SystemExit(
-                f"source={source}: адрес не содержит признака города, Москву от "
-                "области не отличить. Нужен --geocode (штатный путь), "
+                f"source={source}: адрес не содержит признака города, регион "
+                f"{region} от прочих не отличить. Нужен --geocode (штатный путь), "
                 "--allow-unfiltered (аварийный) или --dry-run."
             )
         logger.warning(
-            "source=%s: пред-геокод ВЫКЛЮЧЕН — фильтра по городу нет вовсе; "
-            "строки лягут без geom и вперемешку с областью",
+            "source=%s region=%d: пред-геокод ВЫКЛЮЧЕН — фильтра по региону нет "
+            "вовсе; строки лягут без geom и вперемешку с прочими регионами",
             source,
+            region,
         )
     if geocode and not dry_run:
         db.execute(text(_GEO_CACHE_DDL))
@@ -587,16 +758,16 @@ def import_msk_raw(
             if is_artifact_address(address):
                 counters.skipped_artifact += 1
                 continue
-            if city_filter is not None and not city_filter(address):
-                counters.skipped_not_moscow += 1
+            if city_filter is not None and not city_filter(payload):
+                counters.skipped_not_target_region += 1
                 continue
             if geocode:
                 point = points.get(geo_cache_key(address or "", avito_city_slug(payload)))
                 if point is None:
                     counters.skipped_ungeocoded += 1
                     continue
-                if point.region_code != MOSCOW_REGION_CODE:
-                    counters.skipped_oblast += 1
+                if point.region_code != region:
+                    counters.skipped_geo_other_region += 1
                     continue
                 # Координаты кладём в КОПИЮ payload'а: исходную строку сырья не
                 # трогаем, пересбор корпуса от этого не зависит. geom появляется
@@ -618,19 +789,26 @@ def import_msk_raw(
         if dry_run or not lots:
             continue
 
+        # У региона 50 своего единого города нет (`canonical_city is None` в
+        # реестре regions) — пишем city=None, `save_listings` его COALESCE'ит
+        # и существующее значение не затирает. Подбор аналогов не страдает:
+        # он радиусный (ST_DWithin), а не по городу; ценовая полоса ДКП
+        # ключуется на `deals.city`, а не на `listings.city`.
+        city = MOSCOW_CITY if region == MOSCOW_REGION_CODE else None
         inserted, updated = save_listings(
             db,
             lots,
             matcher=matcher,
-            region_code=MOSCOW_REGION_CODE,
-            city=MOSCOW_CITY,
+            region_code=region,
+            city=city,
         )
         counters.inserted += inserted
         counters.updated += updated
         db.commit()  # батч зафиксирован — обрыв не отматывает всю работу
         logger.info(
-            "msk_raw %s: прочитано=%d отобрано=%d записано=%d (new=%d upd=%d)",
+            "msk_raw %s region=%d: прочитано=%d отобрано=%d записано=%d (new=%d upd=%d)",
             source,
+            region,
             counters.read,
             counters.selected,
             counters.written,
@@ -648,11 +826,12 @@ def import_msk_raw(
             geocode_limit,
         )
     logger.info(
-        "msk_raw %s ИТОГ%s: прочитано=%d отобрано=%d записано=%d "
-        "(new=%d upd=%d, писатель пропустил=%d) | пропущено: не Москва=%d "
-        "область(50)=%d не разрешён=%d артефакт=%d невалидный payload=%d | "
+        "msk_raw %s region=%d ИТОГ%s: прочитано=%d отобрано=%d записано=%d "
+        "(new=%d upd=%d, писатель пропустил=%d) | пропущено: не целевой регион=%d "
+        "геокод-другой-регион=%d не разрешён=%d артефакт=%d невалидный payload=%d | "
         "геокод-вызовов=%d | сходится=%s",
         source,
+        region,
         " (dry-run)" if dry_run else "",
         counters.read,
         counters.selected,
@@ -660,8 +839,8 @@ def import_msk_raw(
         counters.inserted,
         counters.updated,
         counters.writer_skipped if not dry_run else 0,
-        counters.skipped_not_moscow,
-        counters.skipped_oblast,
+        counters.skipped_not_target_region,
+        counters.skipped_geo_other_region,
         counters.skipped_ungeocoded,
         counters.skipped_artifact,
         counters.skipped_invalid,
@@ -676,21 +855,30 @@ def main() -> None:
         level=logging.INFO,
         format="%(asctime)s %(levelname)s %(name)s: %(message)s",
     )
-    parser = argparse.ArgumentParser(description="Импорт сырья msk_raw в listings (регион 77)")
+    parser = argparse.ArgumentParser(
+        description="Импорт сырья msk_raw в listings (регион задаётся --region, по умолчанию 77)"
+    )
     parser.add_argument("--source", choices=sorted(SOURCE_VIEWS), default="cian")
+    parser.add_argument(
+        "--region",
+        type=int,
+        choices=SUPPORTED_REGIONS,
+        default=MOSCOW_REGION_CODE,
+        help=f"целевой регион: {MOSCOW_REGION_CODE} — Москва, {OBLAST_REGION_CODE} — область",
+    )
     parser.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE)
     parser.add_argument("--limit", type=int, default=None, help="обработать не больше N карточек")
     parser.add_argument("--dry-run", action="store_true", help="ничего не пишет, только счётчики")
     parser.add_argument(
         "--allow-unfiltered",
         action="store_true",
-        help="АВАРИЙНЫЙ режим: писать avito без фильтра по городу и без geom",
+        help="АВАРИЙНЫЙ режим: писать avito без фильтра по региону и без geom",
     )
     parser.add_argument(
         "--geocode",
         action="store_true",
         help="штатный путь для avito: пред-геокод адреса (слаг + DaData), "
-        "в listings уходит только регион 77, область откладывается",
+        "в listings уходит только целевой регион (--region), прочее пропускается",
     )
     parser.add_argument(
         "--geocode-limit",
@@ -706,6 +894,7 @@ def main() -> None:
         import_msk_raw(
             db,
             source=args.source,
+            region=args.region,
             batch_size=args.batch_size,
             limit=args.limit,
             dry_run=args.dry_run,

tradein-mvp/backend/app/tasks/yandex_detail_backfill.py

@@ -427,7 +427,7 @@ async def run_yandex_detail_backfill(
                         )
                         if consecutive_blocks >= max_consecutive_blocks:
                             aborted_by_blocks = True
-                            logger.error(
+                            logger.warning(
                                 "yandex_detail_backfill: run_id=%d ABORT -- %d consecutive "
                                 "non-200 responses. enriched=%d attempted=%d",
                                 run_id,

tradein-mvp/backend/app/tasks/yandex_newbuilding_sweep.py

@@ -354,7 +354,7 @@ async def enrich_yandex_newbuilding_sweep(
                 if caused_by_no_proxy(exc):
                     result.no_proxy_stop = True
                     result.failed_resolve += 1
-                    logger.error(
+                    logger.warning(
                         "yandex-nb-sweep: СТОП — пул прокси пуст, к площадке не ходили. "
                         "house_id=%s processed=%d succeeded=%d",
                         house_id,
@@ -419,7 +419,7 @@ async def enrich_yandex_newbuilding_sweep(
             if caused_by_no_proxy(exc):  # #3197 — см. блок resolve выше
                 result.no_proxy_stop = True
                 result.failed_fetch += 1
-                logger.error(
+                logger.warning(
                     "yandex-nb-sweep: СТОП — пул прокси пуст, к площадке не ходили. "
                     "house_id=%s processed=%d succeeded=%d",
                     house_id,

tradein-mvp/backend/app/tgbot_main.py

@@ -26,13 +26,12 @@ import logging
 import os
 import signal
 from contextlib import suppress
-from typing import Any
 
 from app.core.config import settings
 from app.core.db import SessionLocal
 from app.core.shutdown import request_shutdown, shutdown_requested, wait_for_shutdown
 from app.services.tgbot.bridge import run_poll_loop
-from app.services.tgbot.client import TelegramClient
+from app.services.tgbot.client import TelegramClient, verify_chat_and_topic
 
 logging.basicConfig(
     level=logging.INFO,
@@ -57,18 +56,20 @@ if settings.glitchtip_dsn:
     import sentry_sdk
     from sentry_sdk.integrations.httpx import HttpxIntegration
     from sentry_sdk.integrations.logging import LoggingIntegration
+    from sentry_sdk.types import Event, Hint
 
     from app.observability.sentry_scrub import (
+        drop_payments_disabled_event,
         redact_telegram_bot_token,
         scrub_payment_request_body,
         scrub_pii_event,
     )
 
-    def _before_send(event: Any, hint: dict[str, Any]) -> Any:
-        """Композиция платёжный body-wipe (PR-D2) + PII-scrub (form-данные) +
-        Telegram bot-токен redaction (#tgsupport review). Токен утекает ДВУМЯ
-        независимыми векторами, которые `include_local_variables=False` ниже и
-        этот хук закрывают вместе:
+    def _before_send(event: Event, hint: Hint) -> Event | None:
+        """Композиция payments-disabled drop (#3471) + платёжный body-wipe (PR-D2) +
+        PII-scrub (form-данные) + Telegram bot-токен redaction (#tgsupport review).
+        Токен утекает ДВУМЯ независимыми векторами, которые
+        `include_local_variables=False` ниже и этот хук закрывают вместе:
           1. `include_local_variables=True` (sentry_sdk default) кладёт stack-frame
              locals (`self._base`/`url` в `TelegramClient._request`) в traceback —
              закрыто через `include_local_variables=False` в `sentry_sdk.init`.
@@ -78,18 +79,22 @@ if settings.glitchtip_dsn:
              — belt-and-suspenders на случай #1 (если include_local_variables
              случайно вернут) И на span data.
 
-        Платёжный body-wipe — belt-and-suspenders: этот процесс не держит ASGI-
-        приложения (нет `request` в event сегодня), но тот же обработчик передан
-        ОБОИМ каналам ниже (before_send/before_send_transaction) ради единообразия
-        со всеми точками инициализации sentry_sdk в проекте (см. app/main.py).
+        Payments-disabled drop и платёжный body-wipe — belt-and-suspenders: этот
+        процесс не держит ASGI-приложения (нет `request`/HTTPException в event
+        сегодня, реальный источник 503 — app/main.py), но тот же обработчик
+        передан ОБОИМ каналам ниже (before_send/before_send_transaction) ради
+        единообразия со всеми точками инициализации sentry_sdk в проекте.
         """
-        scrubbed = scrub_payment_request_body(event, hint)
+        dropped = drop_payments_disabled_event(event, hint)  # type: ignore[arg-type]
+        if dropped is None:
+            return None
+        scrubbed = scrub_payment_request_body(dropped, hint)  # type: ignore[arg-type]
         if scrubbed is None:
             return None
-        scrubbed = scrub_pii_event(scrubbed, hint)
+        scrubbed = scrub_pii_event(scrubbed, hint)  # type: ignore[arg-type]
         if scrubbed is None:
             return None
-        return redact_telegram_bot_token(scrubbed, hint)
+        return redact_telegram_bot_token(scrubbed, hint)  # type: ignore[arg-type,return-value]
 
     sentry_sdk.init(
         dsn=settings.glitchtip_dsn,
@@ -118,7 +123,29 @@ async def _run_bridge() -> None:
     # из поллинга (кооперативный drain по SIGTERM, hard-cancel, исключение).
     # Клиент один на весь процесс: пересоздание на запрос убивало keep-alive и
     # заставляло каждый long-poll начинаться с TCP+TLS-хендшейка.
-    async with TelegramClient(settings.telegram_bot_token) as client:
+    async with TelegramClient(
+        settings.telegram_bot_token,
+        relay_base_url=settings.telegram_relay_base_url,
+        relay_secret=settings.telegram_relay_secret,
+        # Бот-роль (review H2, #3471) — своя, меньшая доля общего бюджета
+        # группы; см. докстринг настройки в app.core.config.
+        group_rate_limit_per_minute=settings.telegram_group_rate_limit_bot_per_minute,
+    ) as client:
+        # Startup-проверка (#3471): убеждаемся ОДИН раз, что чат/тема живы,
+        # прежде чем уходить в бесконечный poll loop. Не блокирует и не роняет
+        # запуск при неудаче — см. докстринг `verify_chat_and_topic`.
+        await verify_chat_and_topic(
+            client,
+            chat_id=settings.telegram_support_chat_id,
+            topic_id=settings.telegram_support_topic_id,
+            label="support",
+        )
+        await verify_chat_and_topic(
+            client,
+            chat_id=settings.telegram_alerts_chat_id,
+            topic_id=settings.telegram_alerts_topic_id,
+            label="alerts",
+        )
         await run_poll_loop(client, SessionLocal)
 
 

tradein-mvp/backend/data/sql/301_web_support_message_idempotency_key.sql

@@ -0,0 +1,59 @@
+-- 301_web_support_message_idempotency_key.sql
+-- Идемпотентность отправки веб-сообщения в поддержку (#3471 retry-storm):
+-- канал Selectel -> api.telegram.org теряет заметную долю коротких запросов
+-- (см. app/api/v1/support.py, _INTERACTIVE_SEND_TIMEOUT_S), поэтому повтор
+-- клиента (fetch-ретрай/двойной клик/переотправка по таймауту) — обычное
+-- дело. Раньше повтор создавал ВТОРУЮ строку в web_support_messages и ВТОРОЕ
+-- зеркало в support-топике.
+--
+-- idempotency_key — client-provided (заголовок Idempotency-Key) ИЛИ
+-- детерминированный fallback-отпечаток sha256(identity|текст|минутное окно)
+-- для клиентов без заголовка (app/api/v1/support.py::_resolve_idempotency_key).
+-- Всегда opaque-строка (клиентский токен или hex-хэш) — ТЕЛО СООБЩЕНИЯ сюда
+-- никогда не попадает в открытом виде, только его отпечаток.
+--
+-- Scoped к (thread_id, direction='in'): идемпотентность осмысленна только для
+-- inbound (клиентских) сообщений — direction='out' (ответ оператора) её не
+-- требует, там уже есть своя partial-уникальность на topic_message_id (187).
+-- thread_id, а не username/anon-token: таблица не хранит identity напрямую,
+-- а тред уже гарантированно создан (`get_or_create_thread`) к моменту INSERT
+-- (см. H1 в app/api/v1/support.py — тред создаётся ДО record_inbound).
+--
+-- Гонку двух одновременных запросов с одним ключом закрывает САМ уникальный
+-- индекс + `INSERT ... ON CONFLICT DO NOTHING` в
+-- web_support_storage.record_inbound (не read-then-write) — на конфликте
+-- вызывающая сторона дочитывает уже вставленную строку и возвращает её тем
+-- же ответом (тот же id), а не создаёт вторую строку.
+--
+-- IDEMPOTENCY: ADD COLUMN/CREATE INDEX IF NOT EXISTS — безопасный re-run.
+-- Зависимости: 187_web_support_chat.sql (таблица web_support_messages).
+
+BEGIN;
+
+-- Блокирующий DDL не должен ждать чужую сессию бесконечно: без этого
+-- ALTER встаёт в очередь за долгим запросом и уводит за собой ВСЕ
+-- последующие обращения к таблице (#2752). Пять секунд — не успел взять
+-- лок, деплой падает честно, а прод продолжает работать.
+SET LOCAL lock_timeout = '5s';
+
+ALTER TABLE web_support_messages
+    ADD COLUMN IF NOT EXISTS idempotency_key text;
+
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_constraint WHERE conname = 'web_support_messages_idempotency_key_len_chk'
+    ) THEN
+        ALTER TABLE web_support_messages
+            ADD CONSTRAINT web_support_messages_idempotency_key_len_chk
+            CHECK (idempotency_key IS NULL OR char_length(idempotency_key) BETWEEN 1 AND 160);
+    END IF;
+END $$;
+
+COMMENT ON COLUMN web_support_messages.idempotency_key IS 'Ключ идемпотентности inbound-отправки (#3471) — client-provided заголовок Idempotency-Key ("client:...") ИЛИ sha256-отпечаток thread+текст+минутное окно ("auto:...") для клиентов без заголовка. NULL для direction=''out'' и для строк до этой миграции.';
+
+CREATE UNIQUE INDEX IF NOT EXISTS web_support_messages_thread_idempotency_uq
+    ON web_support_messages (thread_id, idempotency_key)
+    WHERE idempotency_key IS NOT NULL AND direction = 'in';
+
+COMMIT;

tradein-mvp/backend/data/sql/302_scrape_schedules_seed_rosreestr_dkp_50.sql

@@ -0,0 +1,52 @@
+-- 302_scrape_schedules_seed_rosreestr_dkp_50.sql
+-- Seed-строка scrape_schedules для региона 50 (Московская область) — #3051, трек МО.
+--
+-- Dependencies: 289_rosreestr_fdw_msk_columns_seed77.sql (та же таблица, тот же
+--               формат source/default_params).
+-- Apply after: 301_web_support_message_idempotency_key.sql
+--
+-- WHY:
+--   Код-часть импорта уже параметризована регионом (`scheduler.py::_job_rosreestr_dkp`
+--   читает `region_code` из default_params и валидирует его по `app.services.regions`),
+--   а wildcard-хендлер `rosreestr_dkp_import_*` резолвит любое имя с суффиксом кода.
+--   Регион 50 заведён в реестре и уже на проде, поэтому включение области стоит ровно
+--   одной строки расписания — новой логики не требуется.
+--
+--   У региона 50 `canonical_city IS NULL`, то есть он идёт по ветке региона 66:
+--   `deals.city` берётся из источника (муниципалитет — Балашиха, Химки, Подольск),
+--   `raw_payload` не заполняется, строки с пустым city отбрасываются. Для области это
+--   и есть верное поведение: единого города у региона нет, подставлять нечего.
+--
+--   Замер по FDW (2026-09-12, прод): под полным WHERE импорта регион 50 даёт
+--   113 351 сделку ДКП с 2024-01-01 — корпус того же порядка, что московский.
+--
+--   Строка ВЫКЛЮЧЕНА (enabled=false) — ровно как seed 77 в миграции 289: миграция
+--   заводит расписание, включение и первый прогон остаются отдельным решением
+--   main-сессии. Окно 4-6 UTC совпадает с окнами регионов 66 и 77; прогоны
+--   сериализуются планировщиком, а первая полная заливка 77 заняла 3 минуты на
+--   212 937 строк, так что третий регион в то же окно помещается с запасом.
+--
+-- ИДЕМПОТЕНТНОСТЬ: ON CONFLICT (source) DO NOTHING — повторный прогон no-op и,
+--   что важнее, НЕ сбрасывает enabled обратно в false после ручного включения.
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+
+INSERT INTO scrape_schedules (
+    source,
+    enabled,
+    window_start_hour,
+    window_end_hour,
+    default_params
+)
+VALUES (
+    'rosreestr_dkp_import_50',
+    false,
+    4,
+    6,
+    '{"region_code": 50, "since": "2024-01-01", "batch_size": 2000}'::jsonb
+)
+ON CONFLICT (source) DO NOTHING;
+
+COMMIT;

tradein-mvp/backend/data/sql/303_scrape_schedules_seed_landing_showcase_deals.sql

@@ -0,0 +1,79 @@
+-- 303_scrape_schedules_seed_landing_showcase_deals.sql
+-- Расписание для пересчёта витрины сделок публичного лэндинга (issue #3469).
+--
+-- ЧТО БЫЛО. Задача `landing_showcase_deals` (миграции 276/277, таблицы
+-- landing_showcase_deals + landing_showcase_runs) в scrape_schedules НЕ СТОЯЛА:
+-- `SELECT * FROM scrape_schedules WHERE source LIKE '%showcase%'` — 0 строк
+-- (замер на проде 12.09.2026). Пересчёт был ручным шагом, и за всё время его
+-- запускали четырежды; на 12.09 лэндинг показывал прогон от 30.08 — тринадцать
+-- суток. Handler в реестре тоже отсутствовал, то есть строка расписания без
+-- него не помогла бы: обе половины регистрации задачи (Handler в
+-- app/services/product_handlers.py + вот эта строка) едут одним PR.
+--
+-- ТАКТ — СУТКИ, И СЧИТАЕТСЯ ОН НЕ ОТ ДАННЫХ, А ОТ КОДА.
+-- Вход витрины — ДКП-сделки Росреестра, они приезжают ПОКВАРТАЛЬНО, и по
+-- входу хватило бы такта в квартал. Но витрина показывает не сделки, а
+-- РАСХОЖДЕНИЕ прогноза МЕРЫ с ценой сделки, а прогноз пересчитывается тем же
+-- спайном оценщика, что и боевой расчёт: любая правка оценщика, коэффициентов
+-- СберИндекса, набора активных объявлений или правила отбора (миграция 276,
+-- полоса −5..+20 % от 12.09.2026) меняет ЧИСЛА на странице, не трогая ни одной
+-- сделки. Деплой у продукта чаще, чем квартал, — поэтому такт суточный: столько
+-- живёт окно «код уже другой, а витрина ещё прежняя». Прогон дешёвый и без
+-- внешних вызовов (200 сделок через спайн + запись 20 строк, ~минуты CPU
+-- ночью), так что цена суточного такта — та же, что у соседнего
+-- landing_stats_refresh (миграция 275).
+--
+-- ЭТА ЖЕ СТРОКА ЗАВОДИТ ВИТРИНУ В МОНИТОР СВЕЖЕСТИ. Сводка просроченных
+-- источников (`emit_stale_digest`, scraper_kit/orchestration/scheduler.py,
+-- #2670) ходит по ВКЛЮЧЁННЫМ расписаниям и бьёт тревогу (logger.error →
+-- GlitchTip), когда источник не приносил данных дольше
+-- STALE_DIGEST_INTERVAL_FACTOR × его такта — то есть здесь дольше ТРЁХ СУТОК.
+-- Отдельного монитора для витрины не заводится намеренно: её молчание было
+-- невидимо ровно потому, что источника не существовало для сводки, а не потому,
+-- что сводка не умеет про него говорить (живой пример с прода 12.09.2026:
+-- «1 источников не собирают дольше 3× своего такта — avito_newbuilding_sweep
+-- 3.5d/1d»). interval_days в default_params стоит ЯВНО — им же сводка считает
+-- порог (`_schedule_interval_days`), и умолчание «1» лучше не подразумевать.
+--
+-- ОКНО 06:00–07:00 UTC (11:00–12:00 по Екатеринбургу): после импорта сделок
+-- Росреестра (rosreestr_dkp_import, окно 04–06) и после landing_stats_refresh
+-- (05–06) — витрина считается по уже обновлённым за ночь данным; и за два часа
+-- до deals_freshness_monitor (08–09), так что утренний пересчёт успевает
+-- сняться с просрочки до утренней же проверки.
+--
+-- enabled=true — как у landing_stats_refresh: задача только читает базу и
+-- перезаписывает две свои маленькие таблицы, внешних вызовов нет, цена ошибки —
+-- минуты CPU. Дожидаться ручного включения тут значило бы оставить дефект
+-- #3469 на месте, просто под другой причиной.
+--
+-- next_run_at на завтра 06:00 UTC — прогон не выстреливает в момент деплоя
+-- (образец: 162_seed_deals_freshness_monitor.sql, 275_landing_stats.sql).
+--
+-- ЗАВИСИМОСТИ: 052_scrape_schedules.sql (таблица + UNIQUE(source)), 276/277
+-- (таблицы витрины), Handler 'landing_showcase_deals' в product_handlers.py.
+-- Идемпотентно: ON CONFLICT (source) DO NOTHING.
+
+BEGIN;
+-- Конвенция проекта (#2752): блокирующий DDL/DML под lock_timeout.
+SET LOCAL lock_timeout = '5s';
+
+INSERT INTO scrape_schedules (
+    source,
+    enabled,
+    window_start_hour,
+    window_end_hour,
+    next_run_at,
+    default_params
+)
+VALUES
+(
+    'landing_showcase_deals',
+    true,
+    6,
+    7,
+    ((CURRENT_DATE + INTERVAL '1 day') + make_interval(hours => 6)) AT TIME ZONE 'UTC',
+    '{"interval_days": 1, "sample": 200, "limit": 20}'::jsonb
+)
+ON CONFLICT (source) DO NOTHING;
+
+COMMIT;

tradein-mvp/backend/tests/conftest.py

@@ -4,8 +4,10 @@
 `--strict-markers` в pyproject.toml не включён, так что незарегистрированный
 маркер только предупреждал бы) и сторожит глобальное состояние, которое
 переживает отдельный тест: общий rate-limiter POST /estimate (см.
-`_reset_estimate_rate_limiter`) и слоты проверки пароля (см.
-`_no_leaked_password_verify_slots`).
+`_reset_estimate_rate_limiter`), слоты проверки пароля (см.
+`_no_leaked_password_verify_slots`) и синглтон Telegram-клиента (см.
+`_reset_telegram_shared_client`, #3471 — иначе его rate limiter копит
+реальное время между тестами и вешает прогон).
 """
 
 from __future__ import annotations
@@ -48,6 +50,35 @@ def _reset_estimate_rate_limiter() -> None:
     )
 
 
+@pytest.fixture(autouse=True)
+def _reset_telegram_shared_client():
+    """`app.services.tgbot.shared._client` — модульный синглтон `TelegramClient`
+    (#3471). Его `TelegramGroupRateLimiter` копит РЕАЛЬНЫЕ метки времени
+    (`time.monotonic()`, ничем не замоканные) по `chat_id` за весь pytest-процесс,
+    а не по тесту — а тестовые настройки `telegram_alerts_chat_id`/
+    `telegram_support_chat_id` дефолтятся в 0, так что ЛЮБЫЕ тесты, бьющие в
+    `app.api.v1.support`/`glitchtip` через реальный (не замоканный) shared-клиент,
+    делят ОДИН и тот же ключ бакета. После N-й (лимит роли, по умолчанию 12)
+    такой отправки в пределах 60 реальных секунд следующая уходит в настоящий
+    `asyncio.sleep` до 60с — тест не падает, а зависает, и именно так выглядела
+    смерть CI-джобы на #3494 (обрыв на ~9%, 75с жизни, ни строки об ошибке;
+    `pytest-timeout` затем добивает зависший тест снаружи).
+
+    Фикстура не выключает и не завышает лимит (в проде он ДОЛЖЕН оставаться
+    ниже площадочного потолка) — она просто гарантирует каждому тесту СВЕЖИЙ
+    клиент (и тем самым свежий, пустой `TelegramGroupRateLimiter`), так же как
+    `_reset_estimate_rate_limiter` выше делает для `_estimate_limiter`. Сброс
+    и ДО, и ПОСЛЕ теста — тест мог создать клиент через `get_telegram_client()`,
+    не пройдя явный локальный `_reset_singleton` (см. `test_shared.py`), и не
+    должен оставить накопленное состояние следующему тесту.
+    """
+    from app.services.tgbot import shared
+
+    shared._client = None
+    yield
+    shared._client = None
+
+
 @pytest.fixture(autouse=True)
 def _no_leaked_password_verify_slots():
     """Тест не оставляет за собой занятых слотов проверки пароля (#2665, #2714).
@@ -150,3 +181,20 @@ def pytest_sessionfinish(session, exitstatus) -> None:
     )
     if exitstatus == 0:
         session.exitstatus = 1
+
+
+# ── Никакого НАСТОЯЩЕГО сна в тестах ─────────────────────────────────────────
+# Фоновый дослальщик алертов GlitchTip (#3471) спит между попытками по
+# настоящим часам: три попытки по 30 секунд. `TestClient` из Starlette ждёт
+# завершения background-задачи, привязанной к ответу, поэтому один-единственный
+# тест на отказ доставки держал весь прогон около минуты, а в CI прогон просто
+# умирал по таймауту без единой строки об ошибке.
+#
+# Ставим паузу в ноль для ВСЕХ тестов: проверять надо, что дослальщик вызван и
+# сколько раз, а не то, что интерпретатор умеет спать. Тест, которому нужна
+# настоящая пауза, переопределяет значение сам.
+@pytest.fixture(autouse=True)
+def _no_real_retry_sleep(monkeypatch: pytest.MonkeyPatch) -> None:
+    from app.tasks import glitchtip_alert_retry
+
+    monkeypatch.setattr(glitchtip_alert_retry, "_RETRY_DELAY_S", 0.0)

tradein-mvp/backend/tests/services/test_proxy_egress.py

@@ -420,8 +420,10 @@ def test_all_candidates_banned_raises_pool_exhausted_not_env_fallback(
     assert exc_info.value.pool_total == 2
     assert exc_info.value.banned_for_source == 2
     assert exc_info.value.unhealthy_or_disabled == 0
-    errors = [rec for rec in caplog.records if rec.levelname == "ERROR"]
-    assert any("fail-closed" in rec.message.lower() for rec in errors)
+    # fail-closed без здорового узла — штатный исход скрапинга, а не инцидент;
+    # понижено до warning, чтобы не шуметь в GlitchTip (было logger.error).
+    warnings = [rec for rec in caplog.records if rec.levelname == "WARNING"]
+    assert any("fail-closed" in rec.message.lower() for rec in warnings)
     # НЕ должно быть "обход пула" / "static-fallback" в логах — env не тронут.
     assert not any("static-fallback" in rec.message for rec in caplog.records)
 
@@ -429,8 +431,10 @@ def test_all_candidates_banned_raises_pool_exhausted_not_env_fallback(
 def test_exhausted_and_empty_pool_log_texts_are_distinct(
     monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
 ) -> None:
-    """Регрессия на замечание ревью: "пуст" и "все отсеяны" — РАЗНЫЕ формулировки И
-    разные уровни (WARNING vs ERROR), иначе их нельзя различить в логах/алертах."""
+    """Регрессия на замечание ревью: "пуст" и "все отсеяны" — РАЗНЫЕ формулировки,
+    иначе их нельзя различить в логах/алертах. Оба сценария — штатный исход
+    скрапинга, поэтому оба теперь warning (было WARNING vs ERROR), различимость
+    держится на тексте, не на уровне."""
     now = datetime.now(UTC)
 
     with caplog.at_level("WARNING"):
@@ -452,8 +456,8 @@ def test_exhausted_and_empty_pool_log_texts_are_distinct(
     exhausted_messages = {rec.levelname: rec.message for rec in caplog.records}
 
     assert "ERROR" not in empty_pool_messages
-    assert "ERROR" in exhausted_messages
-    assert empty_pool_messages.get("WARNING") != exhausted_messages.get("ERROR")
+    assert "ERROR" not in exhausted_messages
+    assert empty_pool_messages.get("WARNING") != exhausted_messages.get("WARNING")
 
 
 def test_disabled_proxy_raises_pool_exhausted() -> None:

tradein-mvp/backend/tests/services/test_proxy_pool.py

@@ -50,6 +50,7 @@ os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:
 from datetime import UTC, datetime, timedelta
 from typing import Any
 
+import httpx
 import pytest
 
 from app.services import proxy_pool
@@ -1527,3 +1528,74 @@ def test_clear_source_bans_resets_escalation() -> None:
     assert ban["ban_count"] == 1
     expected = datetime.now(UTC) + timedelta(hours=SOURCE_BAN_BASE_HOURS)
     assert abs((ban["banned_until"] - expected).total_seconds()) < 60
+
+
+# ── health-probe failure logging (#3471 — GlitchTip/log noise) ──────────────
+# httpx.ProxyError (типично 407 от провайдера) раньше падал в generic
+# `except Exception: ... exc_info=True` внутри `_probe_proxy` — полный traceback
+# на КАЖДЫЙ провал, хотя это штатное состояние пула (184 строки/сутки на
+# проде), а не инцидент приложения. Тесты ниже бьют по РЕАЛЬНОМУ `_probe_proxy`
+# (не монки-заглушке, как в тестах `run_proxy_healthcheck` выше) — только так
+# видно, что осталось от логирования при живом httpx-исключении.
+
+
+async def test_probe_proxy_proxy_error_logs_single_line_without_traceback(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    async def _broken_get(self: httpx.AsyncClient, *args: Any, **kwargs: Any) -> httpx.Response:
+        raise httpx.ProxyError("407 Proxy Authentication Required")
+
+    monkeypatch.setattr(httpx.AsyncClient, "get", _broken_get)
+
+    with caplog.at_level("WARNING", logger="app.services.proxy_pool"):
+        ok, exit_ip, latency_ms, fail_kind = await proxy_pool._probe_proxy(
+            "http://u:p@h1:8080"
+        )
+
+    assert ok is False
+    assert exit_ip is None
+    assert latency_ms is None
+    assert fail_kind == "proxy_error"
+
+    records = [r for r in caplog.records if r.name == "app.services.proxy_pool"]
+    assert len(records) == 1, "провал ipify-пробы обязан лечь ОДНОЙ строкой, не пачкой"
+    record = records[0]
+    assert record.exc_info is None, "проба — штатная операция, полный traceback не нужен"
+    assert "proxy_error" in record.message
+    assert "407" in record.message  # причина (текст исключения) видна без трейса
+
+
+async def test_healthcheck_counts_proxy_error_as_failed_without_traceback(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Итоговая строка `checked=.../ok=.../failed=...` не ломается провалом
+    вида ProxyError, а сам провал не тащит traceback в лог прогона."""
+    db = FakeSession([_proxy(1, fails=0)])
+
+    async def _broken_get(self: httpx.AsyncClient, *args: Any, **kwargs: Any) -> httpx.Response:
+        raise httpx.ProxyError("407 Proxy Authentication Required")
+
+    monkeypatch.setattr(httpx.AsyncClient, "get", _broken_get)
+
+    # INFO (не WARNING): итоговая сводка `healthcheck done` логируется на INFO —
+    # порог ниже WARNING нужен, чтобы её тоже поймать в этом же прогоне.
+    with caplog.at_level("INFO", logger="app.services.proxy_pool"):
+        counters = await proxy_pool.run_proxy_healthcheck(db)  # type: ignore[arg-type]
+
+    assert counters["checked"] == 1
+    assert counters["ok"] == 0
+    assert counters["failed"] == 1
+    assert db._by_id(1)["consecutive_fails"] == 1
+
+    summary = [
+        r
+        for r in caplog.records
+        if r.name == "app.services.proxy_pool" and "healthcheck done" in r.message
+    ]
+    assert len(summary) == 1
+    assert "checked=1" in summary[0].message
+    assert "ok=0" in summary[0].message
+    assert "failed=1" in summary[0].message
+    assert not any(r.exc_info for r in caplog.records if r.name == "app.services.proxy_pool")

tradein-mvp/backend/tests/services/tgbot/test_bridge.py

@@ -80,6 +80,10 @@ class FakeBridgeStorage:
         self._next_id = 1
         self.clock_s: float = 0.0
         self.fail_next_record_message = False
+        # #3471 P0: следующий вызов record_web_out_message кидает SQLAlchemyError
+        # (симулирует обрыв коннекта к БД на веб-ветке — для веб-треда эта запись
+        # И ЕСТЬ доставка клиенту) и сбрасывается в False.
+        self.fail_next_record_web_out_message = False
         # #tgsupport-web: web_support_messages-эквивалент, topic_message_id ->
         # (thread_id, support_chat_id) — второй элемент моделирует колонку
         # web_support_messages.support_chat_id (review M1); None = легаси wildcard.
@@ -158,9 +162,11 @@ class FakeBridgeStorage:
 
     def find_chat_by_topic_message(self, topic_message_id: int, support_chat_id: int) -> int | None:
         """support_chat_id-скоуп (review M1): запись со ЧУЖИМ (не None, не текущим)
-        support_chat_id не матчится — None (легаси/дефолт) матчится всегда."""
+        support_chat_id не матчится — None (легаси/дефолт) матчится всегда.
+        БЕЗ фильтра по direction (#3471 P0) — реплай на СВОЙ предыдущий ответ
+        (direction='out') резолвится так же, как реплай на зеркало клиента."""
         for m in reversed(self.messages):
-            if m["direction"] != "in" or m["topic_message_id"] != topic_message_id:
+            if m["topic_message_id"] != topic_message_id:
                 continue
             entry_chat_id = m.get("support_chat_id")
             if entry_chat_id is not None and entry_chat_id != support_chat_id:
@@ -185,15 +191,32 @@ class FakeBridgeStorage:
         return thread_id
 
     def record_web_out_message(
-        self, *, thread_id: int, text_body: str, operator_tg_id: int | None
+        self,
+        *,
+        thread_id: int,
+        text_body: str,
+        operator_tg_id: int | None,
+        topic_message_id: int | None = None,
+        support_chat_id: int | None = None,
     ) -> None:
+        if self.fail_next_record_web_out_message:
+            self.fail_next_record_web_out_message = False
+            raise SQLAlchemyError("simulated DB failure (deploy connection reset)")
         self.web_out_messages.append(
             {
                 "thread_id": thread_id,
                 "text_body": text_body,
                 "operator_tg_id": operator_tg_id,
+                "topic_message_id": topic_message_id,
+                "support_chat_id": support_chat_id,
             }
         )
+        # Зеркалим в `web_topic_to_thread` (deep review PR #3479) — реальный
+        # `record_outbound` пишет ту же строку в web_support_messages, которую
+        # потом читает `find_thread_by_topic_message`; без этого фейк не мог бы
+        # поймать баг "out-строка с support_chat_id=NULL — вечный wildcard".
+        if topic_message_id is not None:
+            self.web_topic_to_thread[topic_message_id] = (thread_id, support_chat_id)
 
 
 # ── httpx mocking helpers (mirrors tests/services/test_dadata.py) ───────────
@@ -855,6 +878,146 @@ async def test_group_reply_refuses_delivery_when_both_tg_and_web_match(
     assert storage.get_offset() == 62
 
 
+async def test_group_reply_to_web_mirror_db_failure_notifies_operator_and_advances_offset() -> None:
+    """#3471 P0: сбой БД на `record_web_out_message` — для веб-треда эта запись И
+    ЕСТЬ доставка клиенту (веб-фронт читает её polling'ом), поэтому тихий откат
+    означал бы навсегда потерянный ответ оператора (воспроизведено на проде
+    31.08.2026 — клиент kopylov). Теперь: rollback → уведомление оператору
+    реплаем в топик, что ответ НЕ доставлен → offset всё равно сдвигается (та же
+    политика, что у любого другого `SQLAlchemyError` в `process_update` — сбой
+    БД не переигрывается, human-in-the-loop retry заменяет технический) →
+    исключение наружу НЕ улетает."""
+    calls: list[tuple[str, dict[str, Any]]] = []
+    client = _make_client({}, calls)
+    storage = FakeBridgeStorage()
+    storage.web_topic_to_thread[310] = (50, SUPPORT_CHAT_ID)
+    storage.fail_next_record_web_out_message = True
+
+    update = {
+        "update_id": 70,
+        "message": _group_reply_message(reply_to_message_id=310, message_id=210),
+    }
+    await bridge.process_update(update, client, storage)
+
+    # Ответ НЕ попал в web_out_messages (запись упала), но и не потерян молча.
+    assert storage.web_out_messages == []
+    assert storage.rollbacks == 1
+    methods = [m for m, _ in calls]
+    assert methods == ["sendMessage"]
+    notice = calls[0][1]
+    assert notice["chat_id"] == SUPPORT_CHAT_ID
+    assert notice["reply_to_message_id"] == 210
+    assert "НЕ доставлен" in notice["text"]
+    # Сбой БД не переигрывается (общая политика SQLAlchemyError) — offset сдвинут и закоммичен.
+    assert storage.get_offset() == 70
+    assert storage.commits == 1
+
+
+async def test_group_reply_to_web_mirror_db_failure_and_notify_failure_logs_error(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """#3471 P0: сбой БД НА веб-ответе, а следом ещё и уведомление оператору не
+    ушло (Telegram недоступен) — полная тишина по обоим каналам. `process_update`
+    всё равно не падает и offset сдвигает, но остаётся `logger.error` с
+    идентификаторами (thread_id/message_id), НЕ текстом — по нему человек найдёт
+    ответ оператора в топике вручную."""
+    calls: list[tuple[str, dict[str, Any]]] = []
+    # 403 (не 5xx) — не ретраится клиентом, `_notify_topic` падает быстро и
+    # детерминированно (без реальных retry-пауз).
+    client = _make_client({"sendMessage": 403}, calls)
+
+    storage = FakeBridgeStorage()
+    storage.web_topic_to_thread[311] = (51, SUPPORT_CHAT_ID)
+    storage.fail_next_record_web_out_message = True
+
+    update = {
+        "update_id": 71,
+        "message": _group_reply_message(reply_to_message_id=311, message_id=211),
+    }
+    with caplog.at_level(logging.ERROR, logger="app.services.tgbot.bridge"):
+        await bridge.process_update(update, client, storage)
+
+    assert storage.web_out_messages == []
+    assert "потерян молча" in caplog.text
+    assert "51" in caplog.text  # thread_id узнаваем в логе
+    assert storage.get_offset() == 71  # сбой БД не переигрывается — offset сдвинут
+    assert storage.commits == 1
+
+
+async def test_group_reply_to_own_previous_web_reply_resolves_thread() -> None:
+    """#3471 P0 (пункт 3): реплай оператора на СВОЙ предыдущий веб-ответ (не на
+    исходное зеркало клиента) теперь тоже резолвится — `record_outbound`
+    сохраняет topic_message_id исходящей записи, `find_thread_by_topic_message`
+    больше не фильтрует по direction.
+
+    Deep review PR #3479: новая out-строка ОБЯЗАНА писаться с ТЕКУЩИМ
+    `support_chat_id`, а не NULL — NULL матчится `find_thread_by_topic_message`
+    как лениентный wildcard "любой чат" (легаси до 187/188), т.е. NULL сделал бы
+    КАЖДУЮ out-строку вечным wildcard-совпадением при ротации support-группы.
+    Эта проверка падает на дефектной реализации (support_chat_id не передавался
+    в `record_web_out_message`), даже когда resolve выше внешне "работает"."""
+    calls: list[tuple[str, dict[str, Any]]] = []
+    client = _make_client({}, calls)
+    storage = FakeBridgeStorage()
+    # Симулируем уже сохранённый предыдущий ответ оператора (topic_message_id=320)
+    # так, как это сделал бы реальный record_outbound после фикса.
+    storage.web_topic_to_thread[320] = (52, SUPPORT_CHAT_ID)
+
+    update = {
+        "update_id": 72,
+        "message": _group_reply_message(
+            reply_to_message_id=320, message_id=220, text="Продолжение"
+        ),
+    }
+    await bridge.process_update(update, client, storage)
+
+    assert len(storage.web_out_messages) == 1
+    assert storage.web_out_messages[0]["thread_id"] == 52
+    assert storage.web_out_messages[0]["topic_message_id"] == 220
+    # Deep review PR #3479: НЕ NULL — иначе эта строка стала бы вечным wildcard.
+    assert storage.web_out_messages[0]["support_chat_id"] == SUPPORT_CHAT_ID
+
+
+async def test_group_reply_to_own_previous_tg_reply_resolves_target_chat() -> None:
+    """#3471 P0 (пункт 3): та же история для Telegram-пути — реплай оператора на
+    СВОЙ предыдущий ответ клиенту (direction='out', topic_message_id теперь
+    заполнен) резолвится в chat_id, а не проваливается в orphan-check.
+
+    Deep review PR #3479: новая out-строка ОБЯЗАНА писаться с ТЕКУЩИМ
+    `support_chat_id` (симметрично in-ветке) — иначе она стала бы вечным
+    wildcard в `find_chat_by_topic_message` при ротации support-группы, и
+    reply мог бы увести ответ ЧУЖОМУ клиенту."""
+    calls: list[tuple[str, dict[str, Any]]] = []
+    client = _make_client({"copyMessage": {"message_id": 601}}, calls)
+    storage = FakeBridgeStorage()
+    # Предыдущий ответ оператора клиенту, зафиксированный с topic_message_id
+    # (id этого ответа В ТОПИКЕ) — то, что теперь пишет TG-путь `_handle_group_reply`.
+    storage.record_message(
+        chat_id=555,
+        direction="out",
+        tg_message_id=500,
+        topic_message_id=330,
+        kind="text",
+        text_body="Первый ответ оператора",
+        operator_tg_id=777,
+        support_chat_id=SUPPORT_CHAT_ID,
+    )
+
+    update = {
+        "update_id": 73,
+        "message": _group_reply_message(reply_to_message_id=330, message_id=230, text="Уточнение"),
+    }
+    await bridge.process_update(update, client, storage)
+
+    methods = [m for m, _ in calls]
+    assert methods == ["copyMessage"]
+    assert calls[0][1]["chat_id"] == 555
+    assert len(storage.messages) == 2  # исходный 'out' + новый 'out'
+    assert storage.messages[-1]["topic_message_id"] == 230
+    # Deep review PR #3479: НЕ NULL — иначе эта строка стала бы вечным wildcard.
+    assert storage.messages[-1]["support_chat_id"] == SUPPORT_CHAT_ID
+
+
 # ── C) дедуп ──────────────────────────────────────────────────────────────────
 
 

tradein-mvp/backend/tests/services/tgbot/test_client.py

@@ -409,3 +409,78 @@ async def test_async_context_manager_closes_client_on_exit() -> None:
 
     assert len(created) == 1
     assert created[0].is_closed
+
+
+# ── Ретранслятор через Beget: фолбэк на прямой путь (#3471) ────────────────
+#
+# Единственный `httpx.AsyncClient` (общий для обоих адресов через тот же
+# MockTransport) позволяет различать «запрос на ретранслятор» от «запрос
+# напрямую» по хосту в `request.url.host` — так проверяется, что при отказе
+# ретранслятора клиент реально уходит на api.telegram.org, а не молчит.
+
+
+async def test_relay_transport_failure_falls_back_to_direct_once() -> None:
+    """Отказ ретранслятора не должен ронять бота: одна попытка напрямую."""
+    seen_hosts: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen_hosts.append(request.url.host)
+        if request.url.host == "relay.example.com":
+            raise httpx.ConnectError("connection refused", request=request)
+        return httpx.Response(200, json={"ok": True, "result": {}})
+
+    _install_transport(handler)
+    client = TelegramClient(
+        token="fake-token", relay_base_url="https://relay.example.com", relay_secret="shh"
+    )
+    result = await client.send_message(chat_id=1, text="hi")
+
+    assert result == {}
+    assert seen_hosts == ["relay.example.com", "api.telegram.org"]
+
+
+async def test_relay_secret_header_sent_only_to_relay_not_to_direct_fallback() -> None:
+    captured: list[str | None] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.append(request.headers.get("X-Relay-Secret"))
+        if request.url.host == "relay.example.com":
+            raise httpx.ConnectError("connection refused", request=request)
+        return httpx.Response(200, json={"ok": True, "result": {}})
+
+    _install_transport(handler)
+    client = TelegramClient(
+        token="fake-token", relay_base_url="https://relay.example.com", relay_secret="shh"
+    )
+    await client.send_message(chat_id=1, text="hi")
+
+    assert captured == ["shh", None], "секрет ретранслятора не должен уходить напрямую в Telegram"
+
+
+async def test_no_relay_configured_behaves_exactly_as_direct_path_before() -> None:
+    """Пустая настройка — это откат: поведение НЕ должно отличаться от прежнего."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.host == "api.telegram.org"
+        assert "X-Relay-Secret" not in request.headers
+        return httpx.Response(200, json={"ok": True, "result": {}})
+
+    _install_transport(handler)
+    result = await TelegramClient(token="fake-token").send_message(chat_id=1, text="hi")
+    assert result == {}
+
+
+async def test_relay_success_never_touches_direct_host() -> None:
+    seen_hosts: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen_hosts.append(request.url.host)
+        return httpx.Response(200, json={"ok": True, "result": {}})
+
+    _install_transport(handler)
+    client = TelegramClient(
+        token="fake-token", relay_base_url="https://relay.example.com", relay_secret="shh"
+    )
+    await client.send_message(chat_id=1, text="hi")
+
+    assert seen_hosts == ["relay.example.com"]

tradein-mvp/backend/tests/services/tgbot/test_topic_check_and_group_rate_limit.py

@@ -0,0 +1,377 @@
+"""Тесты для #3471: startup-проверка темы форума + общий (per-группа) rate limit.
+
+Оба сюжета выбраны так, чтобы падать на коде ДО правки:
+  - `TelegramGroupRateLimiter` и `verify_chat_and_topic` физически не существовали
+    в `app.services.tgbot.client` — импорт ниже сам по себе даёт `ImportError` на
+    старом коде (подтверждено откатом при разработке).
+  - `test_send_message_rate_limits_across_different_topics_same_chat` без лимитера
+    прошёл бы «слишком хорошо» (`sleep_calls == []` после 3 отправок) — это и есть
+    баг #3471 (нет лимита вовсе, всплеск бьёт по площадочному 429).
+
+NEVER calls real Telegram API — httpx.MockTransport only, тот же паттерн, что
+`test_client.py`.
+"""
+
+from __future__ import annotations
+
+import os
+from unittest import mock
+
+import httpx
+import pytest
+
+os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
+
+from app.services.tgbot.client import (
+    TelegramApiError,
+    TelegramClient,
+    TelegramGroupRateLimiter,
+    TelegramRateLimitedError,
+    verify_chat_and_topic,
+)
+
+_REAL_ASYNC_CLIENT = httpx.AsyncClient
+
+
+def _install_transport(handler) -> None:
+    transport = httpx.MockTransport(handler)
+
+    def factory(*_: object, **__: object) -> httpx.AsyncClient:
+        return _REAL_ASYNC_CLIENT(transport=transport)
+
+    mock.patch("app.services.tgbot.client.httpx.AsyncClient", factory).start()
+
+
+@pytest.fixture(autouse=True)
+def _stop_patches():
+    yield
+    mock.patch.stopall()
+
+
+# ── verify_chat_and_topic ────────────────────────────────────────────────────
+
+
+async def test_verify_chat_and_topic_success_calls_get_chat_and_send_chat_action() -> None:
+    """Happy path: getChat + typing-индикатор в тему, никакого видимого сообщения."""
+    calls: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls.append(request.url.path.rsplit("/", 1)[-1])
+        return httpx.Response(200, json={"ok": True, "result": True})
+
+    _install_transport(handler)
+    client = TelegramClient(token="fake-token")
+
+    ok = await verify_chat_and_topic(client, chat_id=-100123, topic_id=7, label="support")
+
+    assert ok is True
+    assert calls == ["getChat", "sendChatAction"]
+
+
+async def test_verify_chat_and_topic_no_visible_message_method_used() -> None:
+    """Ни один из вызовов не бьёт в sendMessage/copyMessage — не мусорим в чат."""
+    methods: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        methods.append(request.url.path.rsplit("/", 1)[-1])
+        return httpx.Response(200, json={"ok": True, "result": True})
+
+    _install_transport(handler)
+    client = TelegramClient(token="fake-token")
+
+    await verify_chat_and_topic(client, chat_id=-100123, topic_id=7, label="support")
+
+    assert "sendMessage" not in methods
+    assert "copyMessage" not in methods
+
+
+async def test_verify_chat_and_topic_logs_error_and_does_not_raise(caplog) -> None:
+    """Тема удалена/переименована → Telegram отвечает отказом. Лог error, процесс жив."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            400, json={"ok": False, "error_code": 400, "description": "message thread not found"}
+        )
+
+    _install_transport(handler)
+    client = TelegramClient(token="fake-token")
+
+    with caplog.at_level("ERROR", logger="app.services.tgbot.client"):
+        ok = await verify_chat_and_topic(client, chat_id=-100123, topic_id=999, label="support")
+
+    assert ok is False  # не бросает исключение наружу — сигнализирует возвратом
+    assert any(record.levelname == "ERROR" for record in caplog.records)
+    assert any("support" in record.message for record in caplog.records)
+
+
+async def test_verify_chat_and_topic_raises_nothing_even_on_network_error() -> None:
+    """Сетевой сбой при проверке (не 4xx, а обрыв) — тоже не должен ронять старт."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        raise httpx.ConnectError("boom", request=request)
+
+    _install_transport(handler)
+    with mock.patch("app.services.tgbot.client.asyncio.sleep", return_value=None):
+        client = TelegramClient(token="fake-token")
+        ok = await verify_chat_and_topic(client, chat_id=-100123, topic_id=7, label="alerts")
+
+    assert ok is False
+
+
+async def test_verify_chat_and_topic_skips_api_call_when_chat_id_is_zero() -> None:
+    """chat_id=0 — штатный kill-switch (не настроено), не ошибка. Нет вызовов к API."""
+    calls: list[str] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls.append(request.url.path)
+        return httpx.Response(200, json={"ok": True, "result": True})
+
+    _install_transport(handler)
+    client = TelegramClient(token="fake-token")
+
+    ok = await verify_chat_and_topic(client, chat_id=0, topic_id=0, label="alerts")
+
+    assert ok is True
+    assert calls == []
+
+
+# ── TelegramGroupRateLimiter ─────────────────────────────────────────────────
+
+
+async def test_rate_limiter_allows_calls_up_to_limit_without_waiting() -> None:
+    sleep_calls: list[float] = []
+
+    async def fake_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    with mock.patch("app.services.tgbot.client.asyncio.sleep", fake_sleep):
+        limiter = TelegramGroupRateLimiter(max_per_window=3, window_s=60.0)
+        await limiter.acquire(chat_id=555)
+        await limiter.acquire(chat_id=555)
+        await limiter.acquire(chat_id=555)
+
+    assert sleep_calls == []
+
+
+async def test_rate_limiter_waits_once_limit_exceeded_same_chat() -> None:
+    """4-я отправка в тот же chat_id за лимитом (2) — ждёт, а не теряется/падает."""
+    sleep_calls: list[float] = []
+    fake_now = [1_000.0]
+
+    def fake_monotonic() -> float:
+        return fake_now[0]
+
+    async def fake_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+        fake_now[0] += seconds
+
+    with (
+        mock.patch("app.services.tgbot.client.time.monotonic", fake_monotonic),
+        mock.patch("app.services.tgbot.client.asyncio.sleep", fake_sleep),
+    ):
+        limiter = TelegramGroupRateLimiter(max_per_window=2, window_s=60.0)
+        await limiter.acquire(chat_id=1)
+        await limiter.acquire(chat_id=1)
+        assert sleep_calls == []
+        await limiter.acquire(chat_id=1)  # третья — сверх лимита
+
+    assert sleep_calls  # ждала, а не пролетела/бросила исключение
+    assert sleep_calls[0] > 0
+
+
+async def test_rate_limiter_different_chats_do_not_block_each_other() -> None:
+    """Разные группы (chat_id) — независимые бюджеты, одна не душит другую."""
+    sleep_calls: list[float] = []
+
+    async def fake_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+
+    with mock.patch("app.services.tgbot.client.asyncio.sleep", fake_sleep):
+        limiter = TelegramGroupRateLimiter(max_per_window=1, window_s=60.0)
+        await limiter.acquire(chat_id=1)
+        await limiter.acquire(chat_id=2)  # другая группа — свой бюджет
+
+    assert sleep_calls == []
+
+
+async def test_rate_limiter_no_races_under_concurrent_senders() -> None:
+    """Несколько конкурентных asyncio-отправителей в ОДИН chat_id — без гонок:
+    итоговое число «пропущенных без ожидания» строго не больше лимита, и никто
+    не теряется/не падает — все 5 корутин успешно завершаются."""
+    import asyncio
+
+    limiter = TelegramGroupRateLimiter(max_per_window=2, window_s=0.15)
+
+    async def sender() -> None:
+        await limiter.acquire(chat_id=42)
+
+    # Реальное время, реальный event loop — единственный способ честно
+    # проверить отсутствие гонки на разделяемом `self._sent_at[chat_id]`.
+    results = await asyncio.gather(*(sender() for _ in range(5)), return_exceptions=True)
+
+    assert all(not isinstance(r, Exception) for r in results)
+    history = limiter._sent_at[42]
+    # После завершения всех 5 — в окне НЕ больше max_per_window меток (иначе
+    # гонка позволила бы двум конкурентным acquire() одновременно "проскочить").
+    assert len(history) <= 2
+
+
+# ── интеграция с TelegramClient.send_message ─────────────────────────────────
+
+
+async def test_send_message_rate_limits_across_different_topics_same_chat() -> None:
+    """Ключевой сценарий #3471: РАЗНЫЕ темы одной группы делят ОДИН бюджет.
+
+    Без правки лимитера нет вовсе — этот тест на старом коде проходил бы
+    "слишком хорошо" (sleep не звался никогда), что и есть баг.
+
+    ВАЖНО (post-merge review, #3494 CI hang): `fake_sleep` ОБЯЗАН двигать
+    подменённый `time.monotonic` вперёд, а не оставаться чистым no-op. Без
+    этого 3-я отправка (сверх лимита=2) уходит в `acquire()`, `wait_s`
+    пересчитывается из РЕАЛЬНОГО `time.monotonic()` (не замоканного здесь),
+    окно не истекает — и `while True` крутится настоящим busy-spin БЕЗ
+    единого реального ожидания, пока `pytest-timeout` не убьёт тест десятками
+    секунд спустя. Именно так этот тест сам стал причиной 75-секундного
+    зависания CI-джобы (обрыв на ~9%, ни строки об ошибке) — не сам лимитер и
+    не синглтон `shared.py` (гипотеза координатора была разумной, но к этому
+    конкретному зависанию отношения не имела).
+    """
+    sleep_calls: list[float] = []
+    fake_now = [0.0]
+
+    def fake_monotonic() -> float:
+        return fake_now[0]
+
+    async def fake_sleep(seconds: float) -> None:
+        sleep_calls.append(seconds)
+        fake_now[0] += seconds
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"ok": True, "result": {"message_id": 1}})
+
+    _install_transport(handler)
+    with (
+        mock.patch("app.services.tgbot.client.time.monotonic", fake_monotonic),
+        mock.patch("app.services.tgbot.client.asyncio.sleep", fake_sleep),
+    ):
+        client = TelegramClient(token="fake-token", group_rate_limit_per_minute=2)
+        await client.send_message(chat_id=42, text="a", message_thread_id=1)  # тема поддержки
+        await client.send_message(chat_id=42, text="b", message_thread_id=2)  # тема алертов
+        assert sleep_calls == []
+        await client.send_message(chat_id=42, text="c", message_thread_id=3)  # 3-я тема, тот же чат
+
+    assert sleep_calls  # общий бюджет группы исчерпан третьей отправкой
+
+
+async def test_send_message_does_not_rate_limit_missing_chat_id_payload() -> None:
+    """get_updates (нет chat_id в payload) не должен спотыкаться о лимитер вовсе."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"ok": True, "result": []})
+
+    _install_transport(handler)
+    client = TelegramClient(token="fake-token", group_rate_limit_per_minute=1)
+
+    # Не должно ни зависнуть, ни бросить — getUpdates не несёт chat_id.
+    result = await client.get_updates(offset=1)
+    assert result == []
+
+
+def test_telegram_api_error_importable_for_manual_inspection() -> None:
+    """Sanity: тестовый модуль не потерял импорт TelegramApiError (использовался
+    при отладке 400-ответа выше)."""
+    assert issubclass(TelegramApiError, Exception)
+
+
+# ── review H1: честный отказ вместо бесконечного ожидания на interactive-пути ─
+
+
+async def test_rate_limiter_raises_rate_limited_error_when_max_wait_exceeded() -> None:
+    """Слот не появился за `max_wait` — `TelegramRateLimitedError`, не вечный сон."""
+    fake_now = [0.0]
+
+    def fake_monotonic() -> float:
+        return fake_now[0]
+
+    async def fake_sleep(seconds: float) -> None:
+        fake_now[0] += seconds
+
+    with (
+        mock.patch("app.services.tgbot.client.time.monotonic", fake_monotonic),
+        mock.patch("app.services.tgbot.client.asyncio.sleep", fake_sleep),
+    ):
+        limiter = TelegramGroupRateLimiter(max_per_window=1, window_s=60.0)
+        await limiter.acquire(chat_id=9)  # занимает единственный слот
+        with pytest.raises(TelegramRateLimitedError):
+            await limiter.acquire(chat_id=9, max_wait=2.0)  # бюджет короче окна
+
+
+async def test_send_message_bounds_rate_limit_wait_by_explicit_timeout() -> None:
+    """Явный `timeout` (как у interactive-ручек support.py/glitchtip.py) сам по
+    себе ограничивает ожидание очереди — без правки самих ручек (review H1)."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"ok": True, "result": {"message_id": 1}})
+
+    _install_transport(handler)
+    with mock.patch(
+        "app.services.tgbot.client.TelegramGroupRateLimiter.acquire",
+        autospec=True,
+    ) as acquire_mock:
+        client = TelegramClient(token="fake-token")
+        await client.send_message(chat_id=1, text="hi", timeout=3.0)
+
+    _, kwargs = acquire_mock.call_args
+    assert kwargs.get("max_wait") == 3.0
+
+
+async def test_send_message_unbounded_wait_by_default_for_background_calls() -> None:
+    """Без явного `timeout` (типичный фоновый вызов) — `max_wait=None` (без потолка)."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"ok": True, "result": {"message_id": 1}})
+
+    _install_transport(handler)
+    with mock.patch(
+        "app.services.tgbot.client.TelegramGroupRateLimiter.acquire",
+        autospec=True,
+    ) as acquire_mock:
+        client = TelegramClient(token="fake-token")
+        await client.send_message(chat_id=1, text="hi")
+
+    _, kwargs = acquire_mock.call_args
+    assert kwargs.get("max_wait") is None
+
+
+# ── review H2: бюджет группы разделён по ролям (API-процесс / бот-процесс) ────
+
+
+def test_group_rate_limit_split_by_role_sums_below_platform_ceiling() -> None:
+    """API- и бот-роль вместе НЕ должны превышать площадочный лимит (~20/мин).
+
+    Регрессия ровно на баг из review H2: раньше оба процесса получали
+    ОДИНАКОВЫЙ дефолт (18+18=36) — сумма вдвое превышала лимит площадки.
+    """
+    from app.core.config import settings
+
+    api_limit = settings.telegram_group_rate_limit_api_per_minute
+    bot_limit = settings.telegram_group_rate_limit_bot_per_minute
+    assert api_limit > 0
+    assert bot_limit > 0
+    assert api_limit + bot_limit < 20
+
+
+def test_shared_client_uses_api_role_limit() -> None:
+    """`app.services.tgbot.shared` (процесс uvicorn) собирает клиент с API-долей."""
+    from app.core.config import settings
+    from app.services.tgbot import shared
+
+    shared._client = None
+    try:
+        client = shared.get_telegram_client()
+        assert (
+            client._rate_limiter._max_per_window
+            == settings.telegram_group_rate_limit_api_per_minute
+        )
+    finally:
+        shared._client = None

tradein-mvp/backend/tests/skip_allowlist.txt

@@ -38,6 +38,7 @@ tests/test_house_dedup_merge.py::test_real_fias_pass_ignores_geo_guard
 tests/test_house_dedup_merge.py::test_real_merge_is_reversible_via_journal
 tests/test_house_dedup_merge.py::test_real_merge_repoints_dedups_deletes_and_is_idempotent
 tests/test_user_events.py::test_real_record_event_inserts_row
+tests/test_3469_showcase_schedule.py::test_live_migration_puts_showcase_into_schedules_and_digest
 
 # Приватность/ретеншн (#2547) — тот же `_live_session()`. Приехали в main
 # параллельно с самим списком, поэтому первым же прогоном deploy-лэйна хук их и
@@ -129,3 +130,18 @@ tests/test_revisit_floor_lateral_lookup.py::test_missing_history_before_anchor_s
 # (postgres-сервис) — там прогон и был зелёным; в deploy-tradein.yml БД нет вовсе.
 tests/test_3063_seller_fields_not_eroded.py::test_poor_rescrape_does_not_erase_seller_fields
 tests/test_3063_seller_fields_not_eroded.py::test_real_change_still_overwrites
+
+# Потолки БД на движке (#3463) — поведенческая половина: проверяют, что запрос
+# длиннее потолка ОБРЫВАЕТСЯ (pg_sleep), что ожидание блокировки отваливается по
+# lock_timeout, и что `SET LOCAL` задачи планировщика перекрывает сессионный
+# потолок и не течёт за свою транзакцию. Всё это нельзя проверить без сервера:
+# потолок применяет Postgres, а не питон. Статическая половина того же файла
+# (test_engine_opens_connections_with_both_ceilings +
+# test_ceilings_are_coherent_with_declared_estimate_budgets) идёт на ОБОИХ лэйнах
+# и краснеет от снятия `connect_args` — проверено вручную 12.09. В ci-tradein.yml
+# эти пять бегут по-настоящему (postgres-сервис, #2745).
+tests/test_3463_db_timeouts.py::test_live_session_reports_both_ceilings
+tests/test_3463_db_timeouts.py::test_statement_over_ceiling_is_cancelled_not_hung
+tests/test_3463_db_timeouts.py::test_lock_wait_over_ceiling_is_aborted
+tests/test_3463_db_timeouts.py::test_set_local_statement_timeout_overrides_session_ceiling
+tests/test_3463_db_timeouts.py::test_set_local_is_scoped_to_its_transaction

tradein-mvp/backend/tests/tasks/test_avito_detail_backfill.py

@@ -348,7 +348,9 @@ async def test_backfill_abort_log_has_no_ip_rate_limited_literal(caplog: Any) ->
         patch(_RESOLVE_PROXY_URL, MagicMock(return_value="http://test-proxy.local:8080")),
         patch(_FETCH, mock_fetch),
         patch(_SLEEP, new_callable=AsyncMock),
-        caplog.at_level("ERROR"),
+        # серия подтверждённых блоков площадки -- штатный исход скрапинга, не
+        # инцидент; понижено до warning, чтобы не шуметь в GlitchTip.
+        caplog.at_level("WARNING"),
     ):
         await run_avito_detail_backfill(
             db, run_id=3, params={"batch_size": 10, "budget_sec": 3600, "max_consecutive_blocks": 5}
@@ -1354,7 +1356,9 @@ async def test_backfill_ratio_abort_log_names_the_ratio_not_the_streak(caplog: A
         patch(_FETCH, mock_fetch),
         patch(_SAVE, return_value=True),
         patch(_SLEEP, new_callable=AsyncMock),
-        caplog.at_level("ERROR"),
+        # ABORT по доле блоков -- штатный исход скрапинга, не инцидент; понижено
+        # до warning, чтобы не шуметь в GlitchTip.
+        caplog.at_level("WARNING"),
     ):
         result = await run_avito_detail_backfill(
             db, run_id=110, params={"batch_size": total, "budget_sec": 3600}
@@ -1396,7 +1400,9 @@ async def test_backfill_safety_net_abort_log_names_the_streak(caplog: Any) -> No
         patch(_FETCH, mock_fetch),
         patch(_SAVE, return_value=True),
         patch(_SLEEP, new_callable=AsyncMock),
-        caplog.at_level("ERROR"),
+        # ABORT по safety-net серии -- штатный исход скрапинга, не инцидент;
+        # понижено до warning, чтобы не шуметь в GlitchTip.
+        caplog.at_level("WARNING"),
     ):
         result = await run_avito_detail_backfill(
             db, run_id=111, params={"batch_size": total, "budget_sec": 3600}

tradein-mvp/backend/tests/tasks/test_domclick_detail_backfill.py

@@ -287,7 +287,9 @@ async def test_backfill_abort_log_has_no_qrator_literal(caplog: pytest.LogCaptur
         patch(_BROWSER_FETCHER, mock_bf_cls),
         patch(_FETCH, mock_fetch),
         patch(_SLEEP, new_callable=AsyncMock),
-        caplog.at_level("ERROR"),
+        # серия подтверждённых блоков площадки -- штатный исход скрапинга, не
+        # инцидент; понижено до warning, чтобы не шуметь в GlitchTip.
+        caplog.at_level("WARNING"),
     ):
         await run_domclick_detail_backfill(
             db,

tradein-mvp/backend/tests/test_2698_imv_sidecar_wiring.py

@@ -65,7 +65,9 @@ async def test_backfill_browser_fetcher_gets_proxy_pool_wiring(
     db.execute.return_value.mappings.return_value.all.return_value = [
         {"id": 1, "address": "ЕКБ, ул. X, 1", "full_address": None, "lat": 56.8, "lon": 60.6}
     ]
-    await hib.backfill_house_imv(db, batch_size=1)
+    # request_delay_sec=0: мок дублирует строку в retry+fresh (2 записи вместо 1) — реальный
+    # анти-бот sleep(5с) между ними тут не нужен.
+    await hib.backfill_house_imv(db, batch_size=1, request_delay_sec=0)
 
     captured = _CapturingFetcher.captured
     assert captured["source"] == "avito"

tradein-mvp/backend/tests/test_2924_yandex_resolve_tried_at.py

@@ -101,6 +101,12 @@ async def _run(pending: list[dict], *, force: bool = False, resolved: str | None
         ),
         patch.object(mod, "_sleep_with_jitter", AsyncMock(return_value=None)),
         patch("app.services.scraper_adapters.RealScraperConfig", MagicMock()),
+        # Удачный резолв доходит до fetch_jk — без мока это реальный BrowserFetcher/прокси-пул
+        # (26с на живом прогоне); тесту нужен только факт «маркер не выставлен», не сам fetch.
+        patch(
+            "scraper_kit.providers.yandex.newbuilding.YandexNewbuildingScraper.fetch_jk",
+            AsyncMock(return_value=None),
+        ),
     ):
         await mod.enrich_yandex_newbuilding_sweep(
             db, city="ekaterinburg", limit=5, force=force, request_delay_sec=0

tradein-mvp/backend/tests/test_3033_avito_native_secondary_filter.py

@@ -129,7 +129,11 @@ def _capture(method: str, **kw: object) -> list[str]:
 
 def test_anchor_sweep_uses_secondary_slug_by_default() -> None:
     """fetch_around по умолчанию — путь вторички, geoCoords/radius сохранены в query."""
-    urls = _capture("fetch_around", lat=56.84, lon=60.6, radius_m=1000, pages=1)
+    # delay_override_sec=0: сеть подменена, anti-ban sleep(5с*jitter) после единственной
+    # страницы тут не защищает ничего реального.
+    urls = _capture(
+        "fetch_around", lat=56.84, lon=60.6, radius_m=1000, pages=1, delay_override_sec=0
+    )
     assert urls, "fetch_around не сделал запроса"
     u = urlparse(urls[0])
     assert u.path == f"/ekaterinburg/kvartiry/prodam/{SECONDARY_SLUG}", u.path
@@ -139,8 +143,15 @@ def test_anchor_sweep_uses_secondary_slug_by_default() -> None:
 
 def test_anchor_sweep_secondary_only_false_keeps_general_path() -> None:
     """Контроль: secondary_only=False — прежняя общая выдача."""
+    # delay_override_sec=0: тот же anti-ban trailing sleep, что и в тесте выше.
     urls = _capture(
-        "fetch_around", lat=56.84, lon=60.6, radius_m=1000, pages=1, secondary_only=False
+        "fetch_around",
+        lat=56.84,
+        lon=60.6,
+        radius_m=1000,
+        pages=1,
+        secondary_only=False,
+        delay_override_sec=0,
     )
     assert urlparse(urls[0]).path == "/ekaterinburg/kvartiry/prodam-ASgBAgICAUSSA8YQ"
 

tradein-mvp/backend/tests/test_3051_region_registry.py

@@ -43,15 +43,41 @@ def test_bbox_nesting_invariants() -> None:
 
 
 def test_regions_do_not_overlap() -> None:
-    """Центры продукт-ядер каждого региона не попадают в чужой bbox_region."""
+    """Центры продукт-ядер каждого региона не попадают в чужой bbox_region —
+    ЗА ИСКЛЮЧЕНИЕМ пары (50, 77): регион 50 (Московская область) admin-bbox'ом
+    геометрически СОДЕРЖИТ регион 77 (Москва) целиком, это ожидаемая вложенность,
+    не баг (см. #3051 Moscow-oblast, tests/test_3051_region_registry_moscow_oblast.py
+    — там же настоящий инвариант для вложенной пары: `region_for_point` обязан
+    резолвить точку во ВЛАДЕЮЩИЙ, более специфичный регион по площади bbox, а не
+    по числовому коду). 66 (Урал) физически за тысячи км от 50/77 — для него
+    старый плоский инвариант «никто ни в кого не попадает» остаётся в силе."""
+    nested_pairs = {(50, 77), (77, 50)}
+    # Исключение из инварианта обязано опираться на ДОКАЗАННУЮ вложенность, а не
+    # на допущение в докстринге: сначала проверяем, что bbox_region(50)
+    # действительно содержит bbox_region(77) как множество, и только потом
+    # разрешаем этой паре не соблюдать «центры не пересекаются». Если 77 когда-
+    # нибудь выедет за границы области, тест упадёт ЗДЕСЬ — с понятной причиной,
+    # а не молча пропустит настоящее пересечение через список исключений.
+    oblast_lat_min, oblast_lat_max, oblast_lon_min, oblast_lon_max = regions.REGIONS[50].bbox_region
+    msk_lat_min, msk_lat_max, msk_lon_min, msk_lon_max = regions.REGIONS[77].bbox_region
+    assert oblast_lat_min <= msk_lat_min and msk_lat_max <= oblast_lat_max, (
+        "bbox_region(77) выехал за широты bbox_region(50) — исключение (50,77) больше "
+        "не обосновано вложенностью"
+    )
+    assert oblast_lon_min <= msk_lon_min and msk_lon_max <= oblast_lon_max, (
+        "bbox_region(77) выехал за долготы bbox_region(50) — исключение (50,77) больше "
+        "не обосновано вложенностью"
+    )
+
     for r in regions.REGIONS.values():
         core = r.bbox_product_core
         center = ((core[0] + core[1]) / 2, (core[2] + core[3]) / 2)
         for other in regions.REGIONS.values():
-            if other.code != r.code:
-                assert not regions.is_within_bbox(*center, other.bbox_region), (
-                    f"центр {r.code} внутри bbox_region {other.code}"
-                )
+            if other.code == r.code or (r.code, other.code) in nested_pairs:
+                continue
+            assert not regions.is_within_bbox(*center, other.bbox_region), (
+                f"центр {r.code} внутри bbox_region {other.code}"
+            )
 
 
 # ── 2. Поведение региона 66 закреплено байт-в-байт ───────────────────────────

tradein-mvp/backend/tests/test_3051_region_registry_moscow_oblast.py

@@ -0,0 +1,159 @@
+"""#3051, регион 50 (Московская область) + фикс порядка обхода реестра.
+
+`region_for_point`/`region_by_city` раньше обходили `sorted(REGIONS)` — «первый
+по коду выигрывает». Это работало, пока регионы физически не пересекались
+(66 Урал и 77 Москва — тысячи км друг от друга). Регион 50 ломает допущение:
+bbox_region(50) (Московская область целиком) геометрически СОДЕРЖИТ
+bbox_region(77) (Москва) как прямоугольники, а 50 < 77 по числовому коду —
+наивный код-порядок отправил бы ВСЕ точки Москвы (включая центр) в регион 50.
+
+Фикс — `_POINT_LOOKUP_ORDER`: обход по площади bbox_region по возрастанию
+(компактный регион проверяется раньше объемлющего), без ручного списка.
+
+Область на дату этого PR — тир обогащения пуст (frozenset()), в deals/listings
+0 строк (импорт Росреестра из FDW — отдельный PR). Тесты ниже проверяют РЕЕСТР
+(геометрию/классификацию), не данные.
+"""
+
+from __future__ import annotations
+
+import os
+
+os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
+
+from app.services import regions
+
+# ── 1. Регрессия на порядок обхода (главный тест) ───────────────────────────
+
+
+def test_lookup_order_is_by_bbox_area_not_by_code() -> None:
+    """77 (Москва, самый маленький bbox_region) проверяется первым, 66 (Урал,
+    самый большой) — последним. Порядок НЕ (50, 66, 77) — это был бы код."""
+    assert regions._POINT_LOOKUP_ORDER == (77, 50, 66)
+
+
+def test_moscow_center_resolves_to_77_not_50() -> None:
+    """Точка в центре Москвы лежит внутри bbox_region И 77, И 50 одновременно
+    — регрессия на сам баг: наивный код-порядок (50 < 77) увёл бы её в 50."""
+    res = regions.region_for_point(55.75, 37.62)
+    assert res is not None
+    assert res.code == 77
+    # Инвариант, который делает это регрессией, а не совпадением:
+    assert regions.is_within_bbox(55.75, 37.62, regions.REGIONS[50].bbox_region)
+    assert regions.is_within_bbox(55.75, 37.62, regions.REGIONS[77].bbox_region)
+
+
+def test_novaya_moskva_resolves_to_77() -> None:
+    """Посёлок Птичное (Новая Москва) — административно Москва, не область."""
+    res = regions.region_for_point(55.52, 37.21)
+    assert res is not None
+    assert res.code == 77
+
+
+def test_far_moscow_oblast_points_resolve_to_50() -> None:
+    """Точки вне генерального bbox 77 однозначно — дальнее Подмосковье."""
+    for lat, lon in [
+        (54.9152, 37.4166),  # Серпухов
+        (56.3430, 37.5228),  # Дмитров
+        (55.7889, 38.4458),  # Электросталь
+    ]:
+        res = regions.region_for_point(lat, lon)
+        assert res is not None and res.code == 50, (lat, lon, res)
+
+
+def test_ekb_point_still_resolves_to_66() -> None:
+    """Регион 66 не сломан добавлением 50/переходом на area-порядок."""
+    res = regions.region_for_point(56.8300, 60.6000)
+    assert res is not None
+    assert res.code == 66
+
+
+def test_point_outside_all_regions_is_none() -> None:
+    res = regions.region_for_point(58.01, 56.25)  # Пермь
+    assert res is None
+
+
+def test_known_limitation_khimki_balashikha_resolve_to_77_via_bbox() -> None:
+    """ИЗВЕСТНОЕ ОГРАНИЧЕНИЕ, не баг этого PR: bbox_region(77) — генеральный
+    fallback-net Москвы, по долготе тянется до 38.10 (~13 км восточнее МКАД).
+    Химки (55.91, 37.41) и Балашиха (55.7965, 37.9388) физически лежат внутри
+    ЭТОГО прямоугольника, хотя административно это область. region_for_point
+    (bbox-based) резолвит их в 77; region_by_city (точное имя) — правильно в
+    50 (см. test_region_by_city_resolves_moscow_oblast_cities). Сузить
+    bbox_region(77), чтобы это исправить, — отдельное решение вне скоупа
+    ordering-фикса (риск задеть geocoder/estimator-потребителей 77 без
+    возможности перепроверить их в этом PR)."""
+    khimki = regions.region_for_point(55.91, 37.41)
+    assert khimki is not None and khimki.code == 77
+    balashikha = regions.region_for_point(55.7965, 37.9388)
+    assert balashikha is not None and balashikha.code == 77
+
+
+# ── 2. region_by_city ─────────────────────────────────────────────────────
+
+
+def test_region_by_city_resolves_moscow_oblast_cities() -> None:
+    for city in ("Красногорск", "Балашиха", "химки", "Серпухов", "Ногинск"):
+        res = regions.region_by_city(city)
+        assert res is not None and res.code == 50, city
+
+
+def test_region_by_city_moscow_and_ekb_unaffected() -> None:
+    assert regions.region_by_city("Москва").code == 77
+    assert regions.region_by_city("Екатеринбург").code == 66
+    assert regions.region_by_city("Пермь") is None
+
+
+def test_no_city_name_duplicated_across_regions() -> None:
+    """Если бы Химки/Балашиха и т.п. попали в `cities` двух регионов —
+    region_by_city резолвил бы их по меньшему коду. Список 50 сверен вручную
+    с 66/77 — пересечений нет."""
+    seen: dict[str, int] = {}
+    for code, r in regions.REGIONS.items():
+        for city in r.cities:
+            key = city.replace("ё", "е")
+            assert key not in seen or seen[key] == code, (
+                f"'{city}' в cities и региона {seen.get(key)}, и региона {code}"
+            )
+            seen[key] = code
+
+
+# ── 3. Тиры обогащения и bbox-инварианты региона 50 ──────────────────────────
+
+
+def test_moscow_oblast_has_no_enrichment_tiers_and_degrades_loudly() -> None:
+    r50 = regions.REGIONS[50]
+    assert r50.enrichment_tiers == frozenset()
+    for tier in (
+        regions.TIER_AVITO_IMV,
+        regions.TIER_YANDEX_VALUATION,
+        regions.TIER_CIAN_VALUATION,
+        regions.TIER_QUARTER_INDEX,
+        regions.TIER_SBER_INDEX,
+    ):
+        reason = regions.unsupported_tier_reason(r50, tier)
+        assert reason is not None and "50" in reason and tier in reason
+
+
+def test_moscow_oblast_canonical_city_is_none() -> None:
+    """В отличие от 77 (Росреестр отдаёт округ/поселение) — источники по
+    области несут настоящий city (Химки, Балашиха), перезаписывать нечего."""
+    assert regions.REGIONS[50].canonical_city is None
+
+
+def test_moscow_oblast_bbox_nesting() -> None:
+    r50 = regions.REGIONS[50]
+
+    def _contains(outer: regions.BBox, inner: regions.BBox) -> bool:
+        return (
+            outer[0] <= inner[0]
+            and outer[1] >= inner[1]
+            and outer[2] <= inner[2]
+            and outer[3] >= inner[3]
+        )
+
+    assert _contains(r50.bbox_wide, r50.bbox_tight)
+    assert _contains(r50.bbox_region, r50.bbox_wide)
+    assert _contains(r50.bbox_region, r50.bbox_product_core)
+    # tight == product_core для 50 (нет отдельного «города-ядра» — см. docstring).
+    assert r50.bbox_tight == r50.bbox_product_core

tradein-mvp/backend/tests/test_3051_suggest_region_scope.py

@@ -23,6 +23,8 @@ os.environ.setdefault("DATABASE_URL", "postgresql://test:test@localhost/test_db"
 
 import pytest
 
+from app.api.v1 import geocode as geocode_module
+from app.api.v1.geocode import SuggestResponse, effective_region_code
 from app.services.geocoder import (
     OBLAST66_VIEWBOX,
     SVERDLOVSK_OBLAST_REGION,
@@ -179,3 +181,52 @@ async def test_suggest_unknown_region_raises() -> None:
     """Неизвестный регион — ValueError до похода к провайдерам."""
     with pytest.raises(ValueError, match="unknown region_code"):
         await suggest("Ленина 1", db=None, limit=5, region_code=99)
+
+
+# ── API-слой: effective_region_code и хендлер /suggest ──────────────────────
+#
+# Всё выше проверяет, что `suggest()` в geocoder.py УМЕЕТ регион. Ниже —
+# СЛЕДУЮЩИЙ слой той же истории #3051: сам HTTP-хендлер `/suggest` (и его
+# публичный прокси в mera.py) до сих пор звал `suggest()` с `region_code=66`
+# по умолчанию БЕЗУСЛОВНО, даже когда `city_hint='Москва'` уже прямо говорил,
+# какой регион нужен. Приоритет: явный `region_code` > вывод из `city_hint`
+# (реестр `app.services.regions`) > 66. Инварианты ниже — на хелпере
+# `effective_region_code`, который эту логику и вносит.
+
+
+def test_effective_region_no_hint_no_explicit_defaults_to_66() -> None:
+    assert effective_region_code(None, None) == 66
+
+
+def test_effective_region_sverdlovsk_city_hint_stays_66() -> None:
+    assert effective_region_code(None, "Серов") == 66
+
+
+def test_effective_region_moscow_city_hint_infers_77() -> None:
+    assert effective_region_code(None, "Москва") == 77
+
+
+def test_effective_region_explicit_wins_over_moscow_hint() -> None:
+    assert effective_region_code(66, "Москва") == 66
+
+
+async def test_suggest_handler_resolves_region_from_moscow_hint() -> None:
+    """`suggest_addresses` без явного `region_code` реально передаёт вниз 77,
+    а не только хелпер в изоляции."""
+    captured: dict[str, object] = {}
+
+    async def _fake_suggest(q, db=None, limit=8, city_hint=None, region_code=66):
+        captured["region_code"] = region_code
+        return []
+
+    with patch.object(geocode_module, "suggest", _fake_suggest):
+        result = await geocode_module.suggest_addresses(
+            q="Тверская 6",
+            limit=8,
+            db=MagicMock(),
+            city_hint="Москва",
+            region_code=None,
+        )
+
+    assert isinstance(result, SuggestResponse)
+    assert captured["region_code"] == 77

tradein-mvp/backend/tests/test_3398_estimator_valuations_proxy_pool.py

@@ -342,6 +342,9 @@ def _yandex_with_pool(monkeypatch: pytest.MonkeyPatch, *, get: Any) -> _Counting
         patch(
             "scraper_kit.providers.yandex.valuation._CurlCffiSession", _fake_curl_session(get=get)
         ),
+        # На успехе fetch_house_history зовёт настоящий anti-ban sleep_between_requests
+        # (5с jitter) — тесту нужен только факт release-lease, не сама пауза.
+        patch("scraper_kit.base.asyncio.sleep", new_callable=AsyncMock),
     ):
         _call_yandex(_db_cache_miss())
     return provider

tradein-mvp/backend/tests/test_3463_db_timeouts.py

@@ -0,0 +1,276 @@
+"""#3463 — у запросов к БД обязан быть потолок по времени и по ожиданию блокировки.
+
+Отказ, который тут закрывается (см. issue): под `ACCESS EXCLUSIVE` на таблице шаг БД
+на пути `/estimate` ЖДЁТ блокировку; бюджет источника истекает, обёртка `run_db_thread`
+уходит ждать свой поток (иначе он останется сиротой в общей `Session` — #3449), а
+верхняя граница этого ожидания = длительность самого запроса. Границы у запроса не
+было → слот `_estimate_slots` не возвращался → `_ESTIMATE_CONCURRENCY = 4` исчерпывался
+и `/estimate` отдавал 429 всем остальным.
+
+Потолок поэтому стоит на КОННЕКТЕ (libpq `options`), а не в питоновской обёртке:
+таймаут в обёртке вернул бы ровно ту сироту, ради которой писался #3449.
+
+Проверки по значению, а не по тексту:
+  * потолки реально доехали до параметров подключения движка и согласованы с
+    объявленными бюджетами `/estimate` (без БД — падают от снятия `connect_args`);
+  * живая сессия этого движка сообщает оба потолка (без БД пропускается);
+  * запрос длиннее потолка ОБРЫВАЕТСЯ за отведённое время, а не висит;
+  * ожидание блокировки длиннее потолка обрывается — это и есть сценарий #3463;
+  * задача со своим `SET LOCAL statement_timeout` (планировщик: 900 с в
+    `app/tasks/listing_source_snapshot.py`) новым сессионным потолком НЕ обрезается.
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+import time
+from collections.abc import Iterator
+
+import psycopg
+import pytest
+from sqlalchemy import Engine, create_engine, text
+from sqlalchemy.exc import OperationalError
+
+from app.core.db import _LOCK_TIMEOUT_MS, _STATEMENT_TIMEOUT_MS, DB_CONNECT_ARGS, engine
+
+# Потолки для ПОВЕДЕНЧЕСКИХ проверок — намеренно маленькие: проверяется механизм
+# (потолок из `options` реально обрывает запрос / ожидание лока), а прод-ВЕЛИЧИНЫ
+# проверяет `test_live_session_reports_both_ceilings` на самом прод-движке. Иначе
+# каждый прогон сьюта стоил бы 30 с ожидания pg_sleep.
+_PROBE_STATEMENT_TIMEOUT_MS = 1_000
+_PROBE_LOCK_TIMEOUT_MS = 500
+
+_LOCK_PROBE_TABLE = "t3463_lock_probe"
+
+
+def _engine_connect_options(eng: Engine) -> str:
+    """Строка libpq `options`, с которой движок РЕАЛЬНО открывает коннекты.
+
+    `connect_args` в движке не хранятся полем: `create_engine` вливает их в `cparams`
+    замыкания `pool._creator`. Читаем оттуда, а не из `DB_CONNECT_ARGS`, — иначе тест
+    остался бы зелёным после снятия `connect_args=` у `create_engine`.
+
+    Наружу отдаём ТОЛЬКО `options`: в `cparams` лежит пароль роли, и текст
+    провалившегося assert'а уехал бы с ним в лог CI.
+    """
+    creator = getattr(eng.pool, "_creator", None)
+    assert creator is not None, "у пула движка нет _creator — SQLAlchemy сменила устройство"
+    cparams = inspect.getclosurevars(creator).nonlocals.get("cparams")
+    assert cparams is not None, (
+        "в замыкании pool._creator нет cparams — SQLAlchemy сменила устройство, "
+        "проверку параметров подключения надо переписать, а не удалять"
+    )
+    return str(cparams.get("options", ""))
+
+
+def _live_engine(connect_args: dict[str, str]) -> Engine | None:
+    """Движок против живой Postgres с заданными `connect_args`, иначе None.
+
+    Тот же способ добыть DSN, что у `_live_session()` в tests/test_house_dedup_merge.py
+    и tests/test_purge_expired_trade_in_data.py: в CI Postgres есть (ci-tradein.yml),
+    на ноутбуке без БД тест пропускается (учтён в tests/skip_allowlist.txt).
+    """
+    dsn = os.environ.get("TEST_DATABASE_URL") or os.environ.get("DATABASE_URL", "")
+    if not dsn or "localhost:5432/test" in dsn:
+        return None
+
+    # Сначала проба БЕЗ connect_args: она отделяет «сервера нет» (честный пропуск)
+    # от «сервер есть, но наши `options` он не принял». Глушить второе нельзя —
+    # именно так испорченное значение (`statement_timeout=30000zz`) проходило
+    # зелёным: коннект падал, тест пропускался, запись в allowlist гасила сигнал,
+    # а на проде это FATAL на КАЖДОМ коннекте.
+    try:
+        probe = create_engine(dsn, future=True)
+    except Exception:
+        return None
+    try:
+        with probe.connect() as conn:
+            conn.execute(text("SELECT 1"))
+    except Exception:
+        return None
+    finally:
+        probe.dispose()
+
+    eng = create_engine(dsn, future=True, connect_args=connect_args)
+    with eng.connect() as conn:  # НЕ под except: сервер живой, виноваты connect_args
+        conn.execute(text("SELECT 1"))
+    return eng
+
+
+@pytest.fixture
+def probe_engine() -> Iterator[Engine]:
+    """Живой движок с МАЛЕНЬКИМИ потолками — проверка механизма, не прод-величин."""
+    eng = _live_engine(
+        {
+            "options": (
+                f"-c statement_timeout={_PROBE_STATEMENT_TIMEOUT_MS} "
+                f"-c lock_timeout={_PROBE_LOCK_TIMEOUT_MS}"
+            )
+        }
+    )
+    if eng is None:
+        pytest.skip("живой Postgres недоступен (DATABASE_URL-заглушка)")
+    try:
+        yield eng
+    finally:
+        eng.dispose()
+
+
+# ── Проводка и согласованность величин (без БД) ───────────────────────────────
+
+
+def test_engine_opens_connections_with_both_ceilings() -> None:
+    """Оба потолка доехали до параметров подключения ПРОД-движка.
+
+    Фальсификация: убрать `connect_args=DB_CONNECT_ARGS` из `create_engine` —
+    `options` станет пустой, тест краснеет.
+    """
+    expected = f"-c statement_timeout={_STATEMENT_TIMEOUT_MS} -c lock_timeout={_LOCK_TIMEOUT_MS}"
+    options = _engine_connect_options(engine)
+    # РАВЕНСТВО, а не `in`: подстрочная проверка пропускала испорченный хвост
+    # (`…=30000zz` содержит `…=30000`), а Postgres на такое значение отвечает
+    # `FATAL: invalid value for parameter "statement_timeout"` — ни одного коннекта
+    # ни в одном из трёх сервисов образа, полный отказ продукта.
+    assert options == expected, (
+        f"движок открывает коннекты с options={options!r}, ожидалось {expected!r}: "
+        "либо потолка нет вовсе (заблокированный запрос снова висит и жжёт слот "
+        "/estimate, #3463), либо значение испорчено — тогда libpq отвергнет КАЖДЫЙ коннект"
+    )
+    assert DB_CONNECT_ARGS["options"] == options
+
+
+def test_ceilings_are_coherent_with_declared_estimate_budgets() -> None:
+    """Потолок выше САМОГО ДЛИННОГО объявленного бюджета `/estimate`, но конечен."""
+    from app.core.config import settings
+
+    declared_budgets_s = (
+        settings.estimate_avito_imv_timeout_s,  # 20 с — самый длинный
+        settings.estimate_geocode_budget_s,  # 12 с
+        settings.estimate_house_meta_timeout_s,  # 8 с
+        settings.estimate_yandex_valuation_timeout_s,  # 8 с
+        settings.estimate_cian_valuation_timeout_s,  # 8 с
+    )
+    longest_ms = max(declared_budgets_s) * 1000
+    assert _STATEMENT_TIMEOUT_MS > longest_ms, (
+        f"потолок запроса {_STATEMENT_TIMEOUT_MS} мс не выше самого длинного объявленного "
+        f"бюджета {longest_ms:.0f} мс — потолок стал бы биндящим ограничением честной работы"
+    )
+    # Потолок сверху — иначе у проверки есть пол и нет крыши: `_STATEMENT_TIMEOUT_MS =
+    # 300_000` (пять минут) зеленел бы, а пять минут ожидания это тот же отказ, только
+    # медленнее: четыре таких запроса всё так же выедают `_ESTIMATE_CONCURRENCY`.
+    assert _STATEMENT_TIMEOUT_MS <= 2 * longest_ms, (
+        f"потолок запроса {_STATEMENT_TIMEOUT_MS} мс больше чем вдвое превышает самый "
+        f"длинный объявленный бюджет {longest_ms:.0f} мс — это уже не защита, а отсрочка: "
+        "слот /estimate держится всё это время"
+    )
+    assert 0 < _LOCK_TIMEOUT_MS < _STATEMENT_TIMEOUT_MS, (
+        "ожидание блокировки обязано обрываться РАНЬШЕ потолка на сам запрос: "
+        "деградировать лучше, чем держать слот"
+    )
+
+
+# ── Поведение против живой Postgres ──────────────────────────────────────────
+
+
+def test_live_session_reports_both_ceilings() -> None:
+    """Прод-ВЕЛИЧИНЫ на живой сессии ПРОД-движка: сервер их принял, а не проигнорировал.
+
+    Коннект берётся у самого `app.core.db.engine`, а не у собранного здесь двойника:
+    двойник остался бы зелёным после снятия `connect_args=` в `create_engine`.
+    """
+    if _live_engine(DB_CONNECT_ARGS) is None:
+        pytest.skip("живой Postgres недоступен (DATABASE_URL-заглушка)")
+    with engine.connect() as conn:
+        statement_timeout = conn.execute(
+            text("SELECT current_setting('statement_timeout')")
+        ).scalar_one()
+        lock_timeout = conn.execute(text("SELECT current_setting('lock_timeout')")).scalar_one()
+
+    assert statement_timeout == "30s", (
+        f"сессия сообщает statement_timeout={statement_timeout!r} — "
+        f"ожидалось 30s (_STATEMENT_TIMEOUT_MS={_STATEMENT_TIMEOUT_MS})"
+    )
+    assert lock_timeout == "5s", (
+        f"сессия сообщает lock_timeout={lock_timeout!r} — "
+        f"ожидалось 5s (_LOCK_TIMEOUT_MS={_LOCK_TIMEOUT_MS})"
+    )
+
+
+def test_statement_over_ceiling_is_cancelled_not_hung(probe_engine: Engine) -> None:
+    """`pg_sleep` длиннее потолка обрывается ОТМЕНОЙ за отведённое время."""
+    sleep_s = _PROBE_STATEMENT_TIMEOUT_MS / 1000 * 5
+    started = time.monotonic()
+    with probe_engine.connect() as conn, pytest.raises(OperationalError) as excinfo:
+        conn.execute(text(f"SELECT pg_sleep({sleep_s})"))
+    elapsed = time.monotonic() - started
+
+    assert isinstance(excinfo.value.orig, psycopg.errors.QueryCanceled), (
+        f"запрос упал не отменой по таймауту, а {type(excinfo.value.orig).__name__}"
+    )
+    assert elapsed < sleep_s, (
+        f"запрос шёл {elapsed:.1f} с при потолке {_PROBE_STATEMENT_TIMEOUT_MS} мс — "
+        "потолок не сработал, он висел до конца pg_sleep"
+    )
+
+
+def test_lock_wait_over_ceiling_is_aborted(probe_engine: Engine) -> None:
+    """Сценарий #3463: под ACCESS EXCLUSIVE читатель ОТВАЛИВАЕТСЯ, а не ждёт вечно."""
+    with probe_engine.connect() as blocker:
+        blocker.execute(text(f"CREATE TABLE IF NOT EXISTS {_LOCK_PROBE_TABLE} (id int)"))
+        blocker.commit()
+        try:
+            blocker.execute(text(f"LOCK TABLE {_LOCK_PROBE_TABLE} IN ACCESS EXCLUSIVE MODE"))
+            started = time.monotonic()
+            with probe_engine.connect() as victim, pytest.raises(OperationalError) as excinfo:
+                victim.execute(text(f"SELECT count(*) FROM {_LOCK_PROBE_TABLE}"))
+            elapsed = time.monotonic() - started
+        finally:
+            blocker.rollback()
+            blocker.execute(text(f"DROP TABLE IF EXISTS {_LOCK_PROBE_TABLE}"))
+            blocker.commit()
+
+    assert isinstance(excinfo.value.orig, psycopg.errors.LockNotAvailable), (
+        f"читатель упал не по ожиданию блокировки, а {type(excinfo.value.orig).__name__} — "
+        "сработал не тот потолок"
+    )
+    assert elapsed < _PROBE_STATEMENT_TIMEOUT_MS / 1000, (
+        f"ожидание блокировки длилось {elapsed:.2f} с при lock_timeout "
+        f"{_PROBE_LOCK_TIMEOUT_MS} мс — оборвал не lock_timeout"
+    )
+
+
+def test_set_local_statement_timeout_overrides_session_ceiling(probe_engine: Engine) -> None:
+    """Задача со своим `SET LOCAL` НЕ обрезается сессионным потолком.
+
+    Это и есть проверка обещания «задачи планировщика не пострадают»: у
+    `app/tasks/listing_source_snapshot.py:288` стоит `SET LOCAL statement_timeout = 900000`,
+    и он обязан ПЕРЕКРЫВАТЬ значение из `connect_args`, а не наоборот.
+    """
+    own_budget_ms = _PROBE_STATEMENT_TIMEOUT_MS * 10
+    sleep_s = _PROBE_STATEMENT_TIMEOUT_MS / 1000 * 2  # заведомо больше сессионного потолка
+
+    with probe_engine.connect() as conn:
+        conn.execute(text(f"SET LOCAL statement_timeout = {own_budget_ms}"))
+        effective = conn.execute(text("SELECT current_setting('statement_timeout')")).scalar_one()
+        assert effective == "10s", f"SET LOCAL не применился: current_setting={effective!r}"
+        # Не просто current_setting: запрос длиннее СЕССИОННОГО потолка обязан дойти до конца.
+        conn.execute(text(f"SELECT pg_sleep({sleep_s})"))
+        conn.rollback()
+
+
+def test_set_local_is_scoped_to_its_transaction(probe_engine: Engine) -> None:
+    """Обратная сторона: чужой `SET LOCAL` не снимает потолок со всей сессии.
+
+    Иначе одна задача с 900-секундным бюджетом отключала бы защиту у всех, кому
+    достанется тот же коннект из пула.
+    """
+    with probe_engine.connect() as conn:
+        conn.execute(text(f"SET LOCAL statement_timeout = {_PROBE_STATEMENT_TIMEOUT_MS * 10}"))
+        conn.rollback()
+        after = conn.execute(text("SELECT current_setting('statement_timeout')")).scalar_one()
+
+    assert after == "1s", (
+        f"после завершения транзакции statement_timeout={after!r} — "
+        "SET LOCAL протёк за пределы своей транзакции, коннект вернулся в пул без потолка"
+    )

tradein-mvp/backend/tests/test_3469_showcase_schedule.py

@@ -0,0 +1,324 @@
+"""Витрина сделок лэндинга попадает в расписание и в монитор свежести (#3469).
+
+ЧТО БЫЛО СЛОМАНО. `landing_showcase_deals` считает витрину публичного лэндинга
+(«МЕРА сказала X — продали за Y»), но в `scrape_schedules` строки для неё не было
+вовсе (`WHERE source LIKE '%showcase%'` — 0 строк на проде 12.09.2026), а в
+реестре `product_handlers` — обработчика. То есть планировщик про задачу не знал
+ни с какой стороны, пересчёт был ручным, и страница показывала прогон
+тринадцатисуточной давности. Заметить это было неоткуда: под таблицей печатались
+счётчики прогона, но не его дата, а сводка просроченных источников
+(`emit_stale_digest`, #2670) ходит по ВКЛЮЧЁННЫМ РАСПИСАНИЯМ — источника, которого
+в таблице нет, для неё не существует.
+
+ЧТО ПРОВЕРЯЕТСЯ ЗДЕСЬ, И ПОЧЕМУ ИМЕННО ЭТО.
+
+  1. Обработчик резолвится ТЕМ ЖЕ `resolve_handler`, которым его ищет боевой
+     `_dispatch`. Одной строки расписания мало: без обработчика планировщик
+     нашёл бы задачу и не смог её запустить.
+  2. Миграция 303 сеет строку, и сеет её ВКЛЮЧЁННОЙ с явным `interval_days` —
+     сводка считает порог просрочки из этого же числа.
+  3. Сводка краснеет, когда витрина не пересчитывалась дольше ТРЁХ тактов
+     (приёмка #3469), и молчит на двух. Число тактов здесь — литерал, а такт
+     читается из миграции: ожидание, взятое из той же настройки, которую
+     проверяешь, уезжает вместе с ней — см. комментарий при _ACCEPTANCE_CYCLES.
+  4. Живой Postgres (само-скип): миграция реально вставляет строку в таблицу,
+     повторное применение её не задваивает, и настоящий запрос сводки
+     `_STALE_SOURCES_SQL` видит эту строку и отдаёт витрину просроченной.
+
+ЖИВОЙ ТЕСТ НЕ УДАЛЯЕТ И НЕ ПРАВИТ НИЧЕГО ЧУЖОГО: он применяет ту же идемпотентную
+миграцию, что применяет деплой (ON CONFLICT DO NOTHING). В CI он ИДЁТ —
+ci-tradein.yml поднимает свой Postgres и кладёт DSN в DATABASE_URL; на машине без
+базы само-скипается (запись в tests/skip_allowlist.txt).
+
+ГОНЯТЬ ЕГО НАДО НА ПОЛНОЙ СХЕМЕ, А НЕ НА ПУСТОЙ БАЗЕ. На чистой базе он был
+зелёным и при этом падал в CI: повтор `015_scrape_runs.sql` (его комментарий к
+колонке, снесённой миграцией 214) на полной схеме валится, а на пустой — нет.
+Поэтому зависимости применяются только когда таблицы ещё нет, а проверять надо
+тем же путём, каким гоняет CI:
+
+    docker exec tradein-postgres psql -U tradein -d postgres -c 'CREATE DATABASE t3469full'
+    docker exec -i tradein-postgres psql -U tradein -d t3469full -c \\
+      'CREATE EXTENSION postgis; CREATE EXTENSION pg_trgm; CREATE ROLE gendesign_reader;'
+    for f in $(ls -1 data/sql/*.sql | sort); do docker exec -i tradein-postgres \\
+      psql -U tradein -d t3469full -v ON_ERROR_STOP=on -q < "$f"; done
+    DATABASE_URL="postgresql+psycopg://tradein:tradein@127.0.0.1:5433/t3469full" \\
+      uv run python -m pytest tests/test_3469_showcase_schedule.py -q
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
+
+from scraper_kit.orchestration import scheduler as sched
+
+from app.services.product_handlers import _job_landing_showcase_deals, build_product_handlers
+
+SOURCE = "landing_showcase_deals"
+
+_SQL_DIR = Path(__file__).resolve().parents[1] / "data" / "sql"
+_MIGRATION = _SQL_DIR / "303_scrape_schedules_seed_landing_showcase_deals.sql"
+# Таблицы, без которых строку расписания некуда класть (FK scrape_schedules →
+# scrape_runs), — живой тест применяет их в том же порядке, что и деплой.
+_DEPS = [
+    _SQL_DIR / "015_scrape_runs.sql",
+    # counters jsonb — по нему сводка судит, принёс ли прогон данные.
+    _SQL_DIR / "051_scrape_runs_extend.sql",
+    _SQL_DIR / "052_scrape_schedules.sql",
+]
+
+NOW = datetime(2026, 9, 12, 8, 0, tzinfo=UTC)
+
+
+def _migration_sql() -> str:
+    return _MIGRATION.read_text("utf-8")
+
+
+def _seeded_interval_days() -> int:
+    """Такт из САМОЙ миграции — порог сводки считается из него, не из литерала."""
+    m = re.search(r'"interval_days"\s*:\s*(\d+)', _migration_sql())
+    assert m is not None, "в default_params миграции 303 нет interval_days"
+    return int(m.group(1))
+
+
+# ── 1. Планировщик видит задачу ──────────────────────────────────────────────
+
+
+def test_handler_resolves_for_scheduler() -> None:
+    """`resolve_handler` находит витрину — тем же вызовом, что и боевой _dispatch.
+
+    Ломать так: убрать ключ из реестра в product_handlers — тест покраснеет, а
+    планировщик на проде заклеймил бы прогон и не нашёл, чем его выполнить.
+    """
+    registry = build_product_handlers(ctx=None)  # type: ignore[arg-type]
+    handler = sched.resolve_handler(SOURCE, registry)
+    assert handler is not None, f"{SOURCE} не резолвится реестром — задача невидима"
+    # СРАВНИВАЕМ САМ JOB, А НЕ `log_name`: имя — второй литерал конструктора
+    # Handler, и правильный ключ с чужим телом (`_job_landing_stats` под ключом
+    # витрины) проходил проверку по имени насквозь. Резолв ведёт к пересчёту
+    # витрины или не ведёт — это свойство функции, а не подписи в логе.
+    assert handler.job is _job_landing_showcase_deals, (
+        f"под ключом {SOURCE} стоит чужой job: {handler.job.__name__}"
+    )
+    assert handler.log_name == SOURCE
+
+
+# ── 2. Миграция сеет строку ──────────────────────────────────────────────────
+
+
+def test_migration_303_exists() -> None:
+    assert _MIGRATION.is_file(), f"missing migration: {_MIGRATION}"
+
+
+def test_migration_303_seeds_source_enabled() -> None:
+    sql = _migration_sql()
+    assert f"'{SOURCE}'" in sql
+    assert "INSERT INTO scrape_schedules" in sql
+    # enabled=true — иначе сводка просроченных источников строку не увидит
+    # (_STALE_SOURCES_SQL: WHERE sch.enabled), и монитор молчал бы как раньше.
+    assert re.search(rf"'{SOURCE}',\s*\n\s*true", sql), "расписание засеяно выключенным"
+
+
+def test_migration_303_is_idempotent_and_transactional() -> None:
+    sql = _migration_sql()
+    assert "ON CONFLICT (source) DO NOTHING" in sql
+    assert "BEGIN;" in sql
+    assert "COMMIT;" in sql
+
+
+def test_migration_303_no_psycopg_trap() -> None:
+    assert not re.search(r":\w+::", _migration_sql())
+
+
+def test_migration_303_interval_days_is_daily() -> None:
+    """Такт суточный: витрина устаревает от КОДА (деплой), а не от квартальных сделок."""
+    assert _seeded_interval_days() == 1
+
+
+# ── 3. Сводка свежести краснеет на молчащей витрине ──────────────────────────
+
+
+def _row(age_days: float, *, status: str | None = "done") -> Any:
+    """Строка `_STALE_SOURCES_SQL`: прогон витрины `age_days` суток назад.
+
+    `status=None` (LEFT JOIN не нашёл прогонов) — витрину не пересчитывали ни разу
+    с момента появления расписания; тогда возраст считается от created_at строки.
+    """
+    finished = None if status is None else NOW - timedelta(days=age_days)
+    return SimpleNamespace(
+        source=SOURCE,
+        interval_days=str(_seeded_interval_days()),
+        created_at=NOW - timedelta(days=age_days),
+        finished_at=finished,
+        status=status,
+        counters={"considered": 200, "eligible": 161, "written": 20},
+    )
+
+
+def _stale_now(rows: list[Any]) -> list[sched.StaleSource]:
+    return sched.stale_sources(sched.freshness_rows(rows), NOW)
+
+
+# Приёмка issue #3469 дословно: «отсутствие прогона дольше 3× такта даёт тревогу».
+# ЧИСЛО ЗДЕСЬ ЛИТЕРАЛ, А НЕ `sched.STALE_DIGEST_INTERVAL_FACTOR`. Взятое из той же
+# настройки, которую проверяем, ожидание уезжает вместе с ней: при факторе 3650
+# ЭТИ ЖЕ тесты оставались зелёными (проверено руками), то есть проверяли ровно
+# ничего. Такт (`interval_days`) при этом читается из миграции — правило «3×»
+# и задано в тактах, а не в сутках.
+_ACCEPTANCE_CYCLES = 3
+
+
+def test_digest_flags_showcase_after_three_cycles() -> None:
+    """Нет пересчёта дольше 3× такта → витрина в сводке просроченных."""
+    lag = _ACCEPTANCE_CYCLES * _seeded_interval_days() + 0.5
+    stale = _stale_now([_row(lag)])
+    assert [s.source for s in stale] == [SOURCE], (
+        f"витрина молчит {lag} суток при такте {_seeded_interval_days()} и не в тревоге"
+    )
+    assert stale[0].interval_days == _seeded_interval_days()
+
+
+def test_digest_silent_within_cycle() -> None:
+    """Контроль: два такта — ещё норма, иначе тревога кричала бы всегда."""
+    lag = 2 * _seeded_interval_days()
+    assert _stale_now([_row(lag)]) == []
+
+
+def test_digest_flags_showcase_that_never_ran() -> None:
+    """Расписание есть, прогонов нет — самый частый вид молчания (#3469 и был им)."""
+    lag = _ACCEPTANCE_CYCLES * _seeded_interval_days() + 1
+    stale = _stale_now([_row(lag, status=None)])
+    assert [s.source for s in stale] == [SOURCE]
+    assert stale[0].never_ok is True
+
+
+def test_showcase_counters_do_not_fake_freshness() -> None:
+    """Свежесть даёт ПРОГОН, а не его счётчики.
+
+    `run_brought_data` судит по результатным ключам kit'а, а у витрины их нет
+    (`considered`/`eligible`/`written` — свой словарь). Значит мерой остаётся
+    успешный статус: прогон, свалившийся в failed, свежести не даёт.
+    """
+    assert sched.run_brought_data("done", {"considered": 200, "written": 20}) is True
+    assert sched.run_brought_data("failed", {"considered": 200, "written": 0}) is False
+
+
+# ── 4. Живая БД: строка реально ложится в таблицу ────────────────────────────
+
+
+def _live_session() -> Any | None:
+    """Session на живой Postgres — та же проба, что у соседних живых тестов.
+
+    `TEST_DATABASE_URL` имеет приоритет; `localhost:5432/test` — заглушка модулей,
+    её не считаем базой. В CI сюда приезжает DSN поднятого в job'е контейнера
+    (ci-tradein.yml), поэтому проверка там ИДЁТ, а не тихо скипается.
+    """
+    try:
+        from sqlalchemy import create_engine, text
+        from sqlalchemy.orm import sessionmaker
+
+        dsn = os.environ.get("TEST_DATABASE_URL") or os.environ.get("DATABASE_URL", "")
+        if not dsn or "localhost:5432/test" in dsn:
+            return None
+        engine = create_engine(dsn, future=True)
+        with engine.connect() as conn:
+            conn.execute(text("SELECT 1"))
+        return sessionmaker(bind=engine, future=True)()
+    except Exception:
+        return None
+
+
+def _apply(db: Any, path: Path) -> None:
+    """Прогнать файл миграции целиком, одним куском — как `psql -f` на деплое.
+
+    Через ДРАЙВЕРНОЕ соединение, а не `exec_driver_sql`: последний отдаёт текст
+    psycopg вместе с пустым набором параметров, и тот начинает искать в нём
+    плейсхолдеры — любой процент в комментарии миграции («полоса −5..+20 %»)
+    роняет запуск ошибкой про `%`. psql такого разбора не делает, так что это
+    артефакт теста, а не свойство файла.
+    """
+    db.connection().connection.driver_connection.execute(path.read_text("utf-8"))
+    db.commit()
+
+
+@pytest.mark.skipif(_live_session() is None, reason="no reachable Postgres test DB")
+def test_live_migration_puts_showcase_into_schedules_and_digest() -> None:
+    """Миграция кладёт строку в scrape_schedules, и сводка видит витрину просроченной.
+
+    Значение, а не текст файла: применяем 303 на живой базе (дважды — дублей быть
+    не должно), читаем строку обратно и прогоняем настоящий `_STALE_SOURCES_SQL` —
+    тот же запрос, которым сводка судит на проде.
+
+    Ничего не удаляем: обе миграции идемпотентны (CREATE TABLE IF NOT EXISTS /
+    ON CONFLICT DO NOTHING), то есть повтор здесь — ровно то же действие, что и
+    повторный деплой.
+    """
+    from sqlalchemy import text
+
+    db = _live_session()
+    assert db is not None
+    try:
+        # Зависимости — ТОЛЬКО на пустой базе. На базе, прошедшей всю цепочку
+        # (CI и прод), повтор 015 падает: `CREATE TABLE IF NOT EXISTS` — no-op,
+        # а `COMMENT ON COLUMN scrape_runs.returning_count` внизу того же файла
+        # обращается к колонке, которую снесла 214. Файл идемпотентен
+        # относительно себя, но не относительно схемы, прошедшей 214, — и
+        # прогон на чистой базе этого не видит по построению.
+        if db.execute(text("SELECT to_regclass('public.scrape_schedules')")).scalar() is None:
+            for dep in _DEPS:
+                _apply(db, dep)
+        _apply(db, _MIGRATION)
+        # ИДЕМПОТЕНТНОСТЬ МЕРЯЕТСЯ ПО СОСТОЯНИЮ СТРОКИ, А НЕ ПО ЧИСЛУ СТРОК.
+        # «DELETE + INSERT» тоже оставляет ровно одну строку, но на КАЖДОМ
+        # деплое стирает last_run_at/next_run_at и взводит расписание заново —
+        # счёт строк такую замену не отличает, а created_at отличает.
+        first_created_at = db.execute(
+            text("SELECT created_at FROM scrape_schedules WHERE source = :s"), {"s": SOURCE}
+        ).scalar()
+        _apply(db, _MIGRATION)
+
+        rows = db.execute(
+            text(
+                "SELECT enabled, window_start_hour, window_end_hour, created_at, "
+                "       (next_run_at > now()) AS next_run_ahead, "
+                "       default_params->>'interval_days' AS interval_days "
+                "FROM scrape_schedules WHERE source = :s"
+            ),
+            {"s": SOURCE},
+        ).fetchall()
+        assert len(rows) == 1, f"ожидалась одна строка расписания, получено {len(rows)}"
+        row = rows[0]
+        assert row.created_at == first_created_at, (
+            "повторное применение пересоздало строку расписания — на каждом деплое "
+            "это стирало бы состояние прогонов (last_run_at/next_run_at)"
+        )
+        assert row.enabled is True
+        assert (row.window_start_hour, row.window_end_hour) == (6, 7)
+        assert int(row.interval_days) == _seeded_interval_days()
+        # next_run_at в БУДУЩЕМ: сев расписания не должен выстреливать прогоном
+        # в момент деплоя (образец — 162/275). Стоит в приёмке, значит и здесь.
+        assert row.next_run_ahead is True, "next_run_at в прошлом — прогон стартует на деплое"
+
+        # Сводка: прогонов у витрины нет, возраст считается от created_at строки.
+        digest_rows = list(db.execute(sched._STALE_SOURCES_SQL).fetchall())
+        assert SOURCE in {r.source for r in digest_rows}, "сводка не видит витрину"
+
+        overdue_at = row.created_at + timedelta(
+            days=_ACCEPTANCE_CYCLES * _seeded_interval_days() + 0.5
+        )
+        stale = sched.stale_sources(sched.freshness_rows(digest_rows), overdue_at)
+        assert SOURCE in {s.source for s in stale}, "витрина без прогонов не попала в тревогу"
+
+        fresh_at = row.created_at + timedelta(hours=1)
+        fresh = sched.stale_sources(sched.freshness_rows(digest_rows), fresh_at)
+        assert SOURCE not in {s.source for s in fresh}, "тревога сразу после сева — ложная"
+    finally:
+        db.close()

tradein-mvp/backend/tests/test_3471_product_metrics.py

@@ -0,0 +1,94 @@
+"""Продуктовые счётчики (#3471): числа бизнеса рядом с техническими метриками.
+
+Проверяется то же, ради чего вообще заведён `test_metrics.py` — не «метрика
+существует», а что она не может взорвать кардинальность. Источник счётчиков —
+реальные `event_type` из `user_events` (миграция 184) плюс две ручки без
+собственного audit-события (suggest, PDF). Метки везде — фиксированный литерал
+из места вызова (outcome/found/channel/result), никогда значение из запроса
+(username, адрес, estimate_id), поэтому тест фиксирует именно НАБОР меток, а не
+факт роста счётчика на единицу — рост уже проверен паттерном `test_metrics.py`.
+"""
+
+from __future__ import annotations
+
+from prometheus_client import REGISTRY, generate_latest
+
+from app.observability import metrics as m
+
+
+def _labelnames(counter: object) -> tuple[str, ...]:
+    return tuple(counter._labelnames)  # type: ignore[attr-defined]
+
+
+def test_estimates_counter_has_bounded_outcome_label() -> None:
+    """Только исход расчёта, никогда адрес/estimate_id — те дали бы ряд на заявку."""
+    assert _labelnames(m.ESTIMATES) == ("outcome",)
+
+
+def test_address_suggestions_counter_has_bounded_found_label() -> None:
+    """found — да/нет, не сам адрес и не количество результатов (unbounded)."""
+    assert _labelnames(m.ADDRESS_SUGGESTIONS) == ("found",)
+
+
+def test_reports_exported_counter_has_no_labels() -> None:
+    """У «Меры» один формат отчёта (PDF оценки) — без лейбла, дублировать нечего."""
+    assert _labelnames(m.REPORTS_EXPORTED) == ()
+
+
+def test_leads_counter_has_no_labels() -> None:
+    assert _labelnames(m.LEADS) == ()
+
+
+def test_support_messages_counter_has_bounded_channel_label() -> None:
+    """channel — ровно два значения (web/anon), не thread_id и не username."""
+    assert _labelnames(m.SUPPORT_MESSAGES) == ("channel",)
+
+
+def test_logins_counter_has_bounded_result_label() -> None:
+    """result — исход попытки, не username (иначе ряд на каждый аккаунт)."""
+    assert _labelnames(m.LOGINS) == ("result",)
+
+
+def test_product_counters_survive_a_realistic_sequence() -> None:
+    """Инкременты по реальным меткам видны в экспозиции и не мешают друг другу.
+
+    Значения сравниваются приращением: реестр `prometheus_client` глобален на
+    процесс, и абсолютное число зависит от порядка запуска тестов.
+    """
+
+    def _value(name: str, labels: dict[str, str]) -> float:
+        return REGISTRY.get_sample_value(name, labels) or 0.0
+
+    before_ok = _value("mera_estimates_total", {"outcome": "ok"})
+    before_insufficient = _value("mera_estimates_total", {"outcome": "insufficient_data"})
+    before_found = _value("mera_address_suggestions_total", {"found": "yes"})
+    before_web = _value("mera_support_messages_total", {"channel": "web"})
+    before_login_ok = _value("mera_logins_total", {"result": "success"})
+
+    m.ESTIMATES.labels(outcome="ok").inc()
+    m.ESTIMATES.labels(outcome="insufficient_data").inc()
+    m.ADDRESS_SUGGESTIONS.labels(found="yes").inc()
+    m.SUPPORT_MESSAGES.labels(channel="web").inc()
+    m.LOGINS.labels(result="success").inc()
+    m.LEADS.inc()
+    m.REPORTS_EXPORTED.inc()
+
+    assert _value("mera_estimates_total", {"outcome": "ok"}) - before_ok == 1.0
+    assert (
+        _value("mera_estimates_total", {"outcome": "insufficient_data"}) - before_insufficient
+        == 1.0
+    )
+    assert _value("mera_address_suggestions_total", {"found": "yes"}) - before_found == 1.0
+    assert _value("mera_support_messages_total", {"channel": "web"}) - before_web == 1.0
+    assert _value("mera_logins_total", {"result": "success"}) - before_login_ok == 1.0
+
+    body = generate_latest(REGISTRY).decode()
+    for metric in (
+        "mera_estimates_total",
+        "mera_address_suggestions_total",
+        "mera_reports_exported_total",
+        "mera_leads_total",
+        "mera_support_messages_total",
+        "mera_logins_total",
+    ):
+        assert metric in body

tradein-mvp/backend/tests/test_alerts_become_events.py

@@ -70,7 +70,7 @@ def glitchtip_events() -> Iterator[list[dict[str, Any]]]:
             yield events
         finally:
             # Иначе на каждый тест остаётся фоновый поток транспорта.
-            client.close()
+            client.close(timeout=0)
 
 
 def event_texts(events: list[dict[str, Any]]) -> list[str]:

tradein-mvp/backend/tests/test_backfill_wave2.py

@@ -215,7 +215,8 @@ async def test_backfill_yandex_addresses_error_on_non_200():
             return_value=mock_session,
         ),
     ):
-        result = await backfill_yandex_addresses(MagicMock(), limit=10)
+        # request_delay_sec=0: реальный анти-бот sleep(3с) тут не нужен, 1 item в батче.
+        result = await backfill_yandex_addresses(MagicMock(), limit=10, request_delay_sec=0)
 
     assert result.errors == 1
     assert result.saved == 0

tradein-mvp/backend/tests/test_cian_session.py

@@ -446,8 +446,9 @@ async def test_verify_session_pool_exhausted_returns_source_unavailable_with_err
 ) -> None:
     """#2825 fail-closed (#2616): пул scrape_proxies исчерпан для cian (все узлы
     забанены/нездоровы) — session.get НЕ вызывается (никуда не ходим без egress),
-    возвращается VERIFY_SOURCE_UNAVAILABLE_SENTINEL, но с ERROR-логом (не warning,
-    отдельным от обычного network-error пути) — явная деградация, а не проглатывание."""
+    возвращается VERIFY_SOURCE_UNAVAILABLE_SENTINEL, с явным логом (не тихое
+    проглатывание). Штатный исход скрапинга -- warning, не error (было error;
+    понижено, чтобы не шуметь в GlitchTip)."""
     from app.services.proxy_egress import ProxyPoolExhaustedError
 
     def _raise(source: str) -> str | None:
@@ -470,8 +471,8 @@ async def test_verify_session_pool_exhausted_returns_source_unavailable_with_err
 
     assert result is VERIFY_SOURCE_UNAVAILABLE_SENTINEL
     mock_session.get.assert_not_called()
-    errors = [rec for rec in caplog.records if rec.levelname == "ERROR"]
-    assert any("пул прокси исчерпан" in rec.message.lower() for rec in errors)
+    warnings = [rec for rec in caplog.records if rec.levelname == "WARNING"]
+    assert any("пул прокси исчерпан" in rec.message.lower() for rec in warnings)
 
 
 @pytest.mark.asyncio

tradein-mvp/backend/tests/test_glitchtip_alert_retry.py

@@ -0,0 +1,150 @@
+"""Тесты фоновой пересылки GlitchTip-алерта в Telegram после отказа синхронной
+попытки — app/api/v1/glitchtip.py (BackgroundTasks) + app/tasks/glitchtip_alert_retry.py.
+
+Контекст (#3471, #3157): GlitchTip вебхуки не ретраит, поэтому отказ синхронной
+попытки не должен терять текст алерта. 502 на отказ Telegram остаётся как есть
+(#3456) — проверяем, что он остаётся ОДНОВРЕМЕННО с постановкой фоновой доставки.
+
+NEVER touches real DB / real Telegram API.
+"""
+
+from __future__ import annotations
+
+import os
+
+os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
+
+import asyncio
+from typing import Any, ClassVar
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.api.v1 import glitchtip as glitchtip_module
+from app.services.tgbot.client import TelegramNetworkError
+from app.tasks import glitchtip_alert_retry as retry_module
+
+_SECRET = "test-shared-secret"
+_ENDPOINT = "/api/v1/trade-in/ops/glitchtip-webhook"
+
+_ISSUE_PAYLOAD = {
+    "text": "GlitchTip Alert",
+    "attachments": [{"title": "ValueError: something broke", "text": "app/services/foo.py"}],
+}
+
+
+@pytest.fixture(autouse=True)
+def _configured(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(glitchtip_module.settings, "tradein_internal_auth_secret", _SECRET)
+    monkeypatch.setattr(glitchtip_module.settings, "telegram_bot_token", "fake-token")
+    monkeypatch.setattr(glitchtip_module.settings, "telegram_alerts_chat_id", -1004443088679)
+    monkeypatch.setattr(glitchtip_module.settings, "telegram_alerts_topic_id", 158)
+
+
+class _FakeTelegramClient:
+    """Подменяет `TelegramClient` внутри модуля `glitchtip` — никакого httpx/сети.
+
+    `responses` — очередь: каждый вызов `send_message` берёт следующий элемент
+    (dict = успех, Exception = отказ), позволяя смоделировать «первая попытка не
+    удалась, повторная фоном прошла».
+    """
+
+    calls: ClassVar[list[dict[str, Any]]] = []
+    responses: ClassVar[list[dict[str, Any] | Exception]] = []
+
+    def __init__(self, _token: str = "fake-token") -> None:
+        pass
+
+    async def send_message(self, **kwargs: Any) -> dict[str, Any]:
+        _FakeTelegramClient.calls.append(kwargs)
+        outcome = _FakeTelegramClient.responses.pop(0)
+        if isinstance(outcome, Exception):
+            raise outcome
+        return outcome
+
+
+@pytest.fixture(autouse=True)
+def _fake_telegram_client(monkeypatch: pytest.MonkeyPatch) -> Any:
+    _FakeTelegramClient.calls = []
+    _FakeTelegramClient.responses = [{"message_id": 1}]
+    monkeypatch.setattr(glitchtip_module, "get_telegram_client", lambda: _FakeTelegramClient())
+    # Ретрай-модуль спит между попытками (_RETRY_DELAY_S=30s) — в тестах не ждём.
+    monkeypatch.setattr(retry_module, "_RETRY_DELAY_S", 0.0)
+    return _FakeTelegramClient
+
+
+@pytest.fixture
+def client() -> TestClient:
+    app = FastAPI()
+    app.include_router(glitchtip_module.router, prefix="/api/v1/trade-in")
+    return TestClient(app)
+
+
+def _network_error() -> TelegramNetworkError:
+    return TelegramNetworkError("sendMessage", "ConnectTimeout", 4)
+
+
+# ── отказ синхронной попытки → фон + 502 ────────────────────────────────────
+
+
+def test_sync_failure_queues_background_retry_and_still_returns_502(
+    client: TestClient, _fake_telegram_client: Any
+) -> None:
+    """Синхронная попытка не удалась → задача уходит в фон, ответ ОСТАЁТСЯ 502
+    (#3456 — 502 задуман осознанно, не подменяется молчаливым 200)."""
+    _fake_telegram_client.responses = [_network_error(), {"message_id": 2}]
+
+    r = client.post(f"{_ENDPOINT}?secret={_SECRET}", json=_ISSUE_PAYLOAD)
+
+    assert r.status_code == 502
+    # TestClient прогоняет BackgroundTasks синхронно перед возвратом ответа —
+    # к этому моменту фоновая попытка уже отработала: 2 вызова (sync + retry).
+    assert len(_fake_telegram_client.calls) == 2
+    for call in _fake_telegram_client.calls:
+        assert call["chat_id"] == -1004443088679
+        assert call["message_thread_id"] == 158
+        assert "ValueError: something broke" in call["text"]
+    # Переиспользован тот же уже отформатированный текст — не пересобран заново.
+    assert _fake_telegram_client.calls[0]["text"] == _fake_telegram_client.calls[1]["text"]
+
+
+def test_sync_success_does_not_queue_background_retry(
+    client: TestClient, _fake_telegram_client: Any
+) -> None:
+    """Успешная синхронная отправка НЕ ставит фоновую задачу — ровно один вызов."""
+    _fake_telegram_client.responses = [{"message_id": 1}]
+
+    r = client.post(f"{_ENDPOINT}?secret={_SECRET}", json=_ISSUE_PAYLOAD)
+
+    assert r.status_code == 200, r.text
+    assert len(_fake_telegram_client.calls) == 1
+
+
+# ── retry_forward_alert напрямую: потолок ретраев ───────────────────────────
+
+
+async def _run_retry(fake_client_cls: Any, responses: list[Any]) -> None:
+    fake_client_cls.responses = list(responses)
+    await retry_module.retry_forward_alert(
+        fake_client_cls(), chat_id=-1, text="алерт", message_thread_id=158
+    )
+
+
+def test_retry_succeeds_after_transient_failure(_fake_telegram_client: Any) -> None:
+    asyncio.run(_run_retry(_fake_telegram_client, [_network_error(), {"message_id": 9}]))
+
+    assert len(_fake_telegram_client.calls) == 2
+
+
+def test_retry_gives_up_after_max_attempts_and_logs(
+    _fake_telegram_client: Any, caplog: pytest.LogCaptureFixture
+) -> None:
+    """На потолке ретраев — сдаётся с ERROR-логом, а не молча и не бесконечно."""
+    responses = [_network_error() for _ in range(retry_module._MAX_ATTEMPTS)]
+
+    with caplog.at_level("ERROR", logger=retry_module.logger.name):
+        asyncio.run(_run_retry(_fake_telegram_client, responses))
+
+    assert len(_fake_telegram_client.calls) == retry_module._MAX_ATTEMPTS
+    assert any("не удалось доставить" in rec.message for rec in caplog.records)

tradein-mvp/backend/tests/test_house_imv_backfill_browser_flag.py

@@ -64,7 +64,9 @@ async def test_backfill_flag_on_constructs_browser_and_threads_it(
     monkeypatch.setattr(house_imv_backfill, "_process_one_house", _fake_process)
 
     db = _fake_db_with_one_row()
-    await house_imv_backfill.backfill_house_imv(db, batch_size=10)
+    # request_delay_sec=0: мок дублирует строку в retry+fresh (2 записи вместо 1) — реальный
+    # анти-бот sleep(5с) между ними тут не нужен.
+    await house_imv_backfill.backfill_house_imv(db, batch_size=10, request_delay_sec=0)
 
     # Ровно один BrowserFetcher(source="avito"), вошли в контекст.
     assert len(_FakeBrowserFetcher.instances) == 1
@@ -91,7 +93,8 @@ async def test_backfill_flag_off_no_browser_and_none_threaded(
     monkeypatch.setattr(house_imv_backfill, "_process_one_house", _fake_process)
 
     db = _fake_db_with_one_row()
-    await house_imv_backfill.backfill_house_imv(db, batch_size=10)
+    # request_delay_sec=0: та же дублирующая мок-строка retry+fresh, что и в тесте выше.
+    await house_imv_backfill.backfill_house_imv(db, batch_size=10, request_delay_sec=0)
 
     # Флаг OFF → BrowserFetcher не конструируется, browser_fetcher=None.
     assert _FakeBrowserFetcher.instances == []

tradein-mvp/backend/tests/test_landing_showcase_deals.py

@@ -1,11 +1,21 @@
 """Витрина лэндинга на реальных сделках — отбор и отбраковка (миграция 276).
 
-Главное, что здесь защищается, — НЕ формат строки, а свойство отбора: витрина
-показывает выборку из работы оценщика, а не её лучший хвост. Отбор по малой
-ошибке дал бы формально работающий код и врущий продукт, и заметить это на
-глаз в проде нельзя — числа будут красивые. Поэтому проверка двусторонняя:
-самая точная строка, у которой не хватает данных, обязана проиграть менее
-точной, но полной.
+Здесь защищаются ДВА разных свойства, и путать их нельзя.
+
+1. ПОЛОСА. С 2026-09-12 витрина показывает только расхождения −5 %..+20 %
+   включительно — решение владельца продукта. Это отбор показательных строк,
+   и проверяется он ПО ЗНАЧЕНИЮ, на реальных строках прода: +75,7 % и −27,9 %
+   на витрину не попадают, +9,9 % попадает.
+2. ВНУТРИ ПОЛОСЫ отбора по величине ошибки по-прежнему нет. Иначе витрина
+   показывала бы лучший хвост уже самой полосы, а числа при этом остались бы
+   красивыми — на глаз в проде такое не ловится. Поэтому проверка
+   двусторонняя: самая точная строка, у которой не хватает данных, обязана
+   проиграть менее точной, но полной.
+
+Отбраковка («данных нет») — третье свойство, и она живёт в `build_row`: строка
+вне полосы остаётся кандидатом и попадает в счётчик `eligible`, её снимает
+отбор, а не отбраковка. Ровно поэтому подпись под витриной может честно
+сказать, сколько строк прогон собрал.
 """
 
 from __future__ import annotations
@@ -16,6 +26,9 @@ from datetime import date
 os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
 
 from app.tasks.landing_showcase_deals import (
+    BAND_MAX_ERR_PCT,
+    BAND_MIN_ERR_PCT,
+    REJECTION_RULE,
     ShowcaseRow,
     build_row,
     quarter_label,
@@ -50,26 +63,102 @@ def _row(
     )
 
 
+# ── Полоса −5 %..+20 %: проверка ПО ЗНАЧЕНИЮ, на реальных строках прода ───────
+
+
+def test_band_drops_rows_outside_it_and_keeps_rows_inside() -> None:
+    """Три строки, которые сегодня лежат на витрине прода (прогон 30.08.2026).
+
+    id 41 — расхождение +75,71 %, id 43 — −27,87 %, id 44 — +9,85 %. Первые две
+    на витрину попадать больше не должны, третья должна.
+
+    Ломать так: снять фильтр в `select_rows` (вернуть
+    `sorted(rows, key=_sort_key)`) — тест покраснеет ПО ЗНАЧЕНИЮ, показав
+    [44, 41, 43] вместо [44], то есть ровно те два промаха, которых владелец
+    на витрине видеть не хочет.
+    """
+    far_over = _row(41, err_pct=75.71)
+    far_under = _row(43, err_pct=-27.87)
+    inside = _row(44, err_pct=9.85)
+
+    chosen = select_rows([far_over, far_under, inside], limit=20)
+
+    assert [r.deal_id for r in chosen] == [44], (
+        "на витрину прошла строка вне полосы −5 %..+20 %: подпись обещает "
+        "полосу, а показывает не её"
+    )
+
+
+def test_band_edges_are_inclusive_and_near_misses_are_not() -> None:
+    """Границы полосы включительные, а на волос за ними — уже нет.
+
+    Проверяется ПО ЗНАЧЕНИЮ у самой границы: `<` вместо `<=` в `in_band`
+    выбросит ровно строки 1 и 2 и покраснит тест.
+    """
+    rows = [
+        _row(1, err_pct=BAND_MIN_ERR_PCT),
+        _row(2, err_pct=BAND_MAX_ERR_PCT),
+        _row(3, err_pct=BAND_MIN_ERR_PCT - 0.01),
+        _row(4, err_pct=BAND_MAX_ERR_PCT + 0.01),
+    ]
+
+    assert sorted(r.deal_id for r in select_rows(rows, limit=20)) == [1, 2]
+
+
+def test_short_band_shows_what_there_is_and_does_not_top_up() -> None:
+    """В полосу попало меньше лимита — показываем сколько есть.
+
+    Добор ближайшими по ошибке был бы тем же отбором по величине ошибки, просто
+    с другой стороны. Ломать так: добавить в `select_rows` «добить до limit
+    остальными» — тест покраснеет тремя строками вместо одной.
+    """
+    rows = [_row(1, err_pct=3.0), _row(2, err_pct=44.0), _row(3, err_pct=-60.0)]
+
+    assert [r.deal_id for r in select_rows(rows, limit=20)] == [1]
+
+
+def test_rejection_rule_names_the_band_that_is_actually_applied() -> None:
+    """Подпись витрины называет ТУ полосу, которую применяет фильтр.
+
+    Текст едет на фронт и там читается как обещание. Вписанный руками «−5 %» в
+    тексте и `>= -5.0` в коде — две независимые величины; здесь проверяется,
+    что в тексте стоят именно границы фильтра.
+
+    Ломать так: подвинуть `BAND_MAX_ERR_PCT` на 30, не трогая текст, — тест
+    покраснеет на «+30 %», которого в подписи нет.
+    """
+    assert f"{BAND_MIN_ERR_PCT:+.0f} %" in REJECTION_RULE
+    assert f"{BAND_MAX_ERR_PCT:+.0f} %" in REJECTION_RULE
+    assert "не вся сверка" in REJECTION_RULE, "подпись не говорит, что это отбор"
+    # Снятая формулировка не должна вернуться: с фильтром она ложь.
+    assert "на отбор и отбраковку не влияет" not in REJECTION_RULE
+
+
+# ── Внутри полосы: порядок задают полнота и свежесть, не ошибка ───────────────
+
+
 def test_selection_ignores_error_magnitude() -> None:
     """Точнейшая строка с дырами в данных НЕ должна оказаться впереди полной.
 
+    Обе строки ВНУТРИ полосы — проверяется именно ранжирование, а не фильтр:
+    иначе тест зеленел бы по той же причине, по которой краснеет соседний.
+
     Ломать так: добавить в `_sort_key` слагаемое `abs(row.err_pct)` — тест
     покраснеет с id 1 на первом месте вместо id 2.
     """
     almost_perfect_but_thin = _row(1, district=None, floor=None, err_pct=0.1)
-    complete_but_worse = _row(2, err_pct=27.0)
+    complete_but_worse = _row(2, err_pct=19.0)
 
     chosen = select_rows([almost_perfect_but_thin, complete_but_worse], limit=1)
 
     assert [r.deal_id for r in chosen] == [2], (
-        "отбор поехал за величиной ошибки — витрина перестала быть выборкой "
-        "и стала рекламой лучшего хвоста"
+        "отбор поехал за величиной ошибки — витрина показывает лучший хвост уже самой полосы"
     )
 
 
 def test_selection_prefers_fresher_quarter_at_equal_completeness() -> None:
     older = _row(1, deal_date=date(2025, 1, 1), err_pct=1.0)
-    fresher = _row(2, deal_date=date(2026, 4, 1), err_pct=35.0)
+    fresher = _row(2, deal_date=date(2026, 4, 1), err_pct=18.0)
 
     assert [r.deal_id for r in select_rows([older, fresher], limit=1)] == [2]
 
@@ -86,9 +175,10 @@ def test_selection_prefers_row_with_street_scheme() -> None:
     `completeness` — тест покраснеет ПО ЗНАЧЕНИЮ, порядком [9, 8].
 
     Вторая сторона проверки — строка без улицы ОСТАЁТСЯ в витрине: она не
-    первая, но и не выброшена. Прятать промахи по-прежнему нельзя.
+    первая, но и не выброшена. Отсутствие поля — не причина отбраковки, и
+    полоса тут ни при чём: обе строки внутри неё.
     """
-    no_street = _row(9, has_street=False, err_pct=75.7)
+    no_street = _row(9, has_street=False, err_pct=19.0)
     with_street = _row(8, err_pct=3.0)
 
     chosen = select_rows([no_street, with_street], limit=2)
@@ -157,11 +247,12 @@ def test_fact_is_the_contract_price_not_the_reconstruction() -> None:
 
 
 def test_no_error_magnitude_is_ever_rejected() -> None:
-    """Промах оценщика ЛЮБОГО размера остаётся на витрине.
+    """Промах ЛЮБОГО размера остаётся кандидатом и попадает в счётчик.
 
-    Это второй половина запрета «не отбирать по ошибке»: фильтр по величине
-    ошибки — тот же отбор, просто ступенькой раньше, и он тем злее, что не
-    оставляет строку даже в кандидатах.
+    Отбраковка и отбор — разные шаги, и величина ошибки причиной ОТБРАКОВКИ не
+    является: вне полосы строка не показывается, но входит в `eligible`, и
+    подпись «показано N из M собранных» остаётся правдой. Отбракуй её здесь —
+    и отбор перестал бы быть виден в счётчиках вообще.
 
     Ломать так: вернуть в `build_row` любой порог вида
     `if abs(err_pct) > X: return None` — тест покраснеет на первом же
@@ -171,20 +262,20 @@ def test_no_error_magnitude_is_ever_rejected() -> None:
     for err_pct in (-95.0, -60.0, -41.0, -5.0, 0.0, 5.0, 41.0, 150.0, 900.0):
         row = _build(predicted_rub=fact_rub * (1 + err_pct / 100))
         assert row is not None, (
-            f"строка с отклонением {err_pct:+.0f}% выброшена: витрина снова "
-            "показывает лучший хвост, а не работу оценщика"
+            f"строка с отклонением {err_pct:+.0f}% выброшена из кандидатов: "
+            "счётчик собранных строк перестал считать работу оценщика"
         )
         assert row.err_pct == round(err_pct, 2)
 
 
-def test_underdeclared_dkp_is_shown_not_hidden() -> None:
-    """Занижение ДКП ради налога выглядит как промах — и всё равно показывается.
+def test_underdeclared_dkp_is_counted_not_dropped() -> None:
+    """Занижение ДКП ради налога выглядит как промах — и остаётся кандидатом.
 
-    Прятать такие строки нельзя: «отклонение больше 40% — это почти всегда
-    дефект ДКП» было догадкой, а санитарный диапазон ₽/м² уже применён к
-    выборке выше по потоку (`_load_sample`, для ЕКБ 30k..600k). Всё, что
-    прошло его и дало большую ошибку, — работа оценщика. Честность за счёт
-    строки в `note`, а не за счёт отсева.
+    Отбраковывать такие строки нельзя: «отклонение больше 40% — это почти
+    всегда дефект ДКП» было догадкой, а санитарный диапазон ₽/м² уже применён
+    к выборке выше по потоку (`_load_sample`, для ЕКБ 30k..600k). На витрину
+    такая строка не выйдет — её снимет полоса, — но в `eligible` она войдёт,
+    и счётчик под таблицей останется честным.
     """
     # Факт 2 000 000 ₽ против прогноза 5 000 000 — отклонение +150%.
     row = _build(fact_rub=2_000_000.0)
@@ -247,8 +338,8 @@ def test_row_without_coords_stays_on_showcase() -> None:
     """Нет точки — строка всё равно на витрине, с lat=lon=None.
 
     Выбрасывать сделку из-за отсутствия координаты — отбор по признаку, не
-    связанному с качеством оценки: та же порча витрины, что и отбор по
-    величине ошибки, просто по другому полю. Карта переживёт строку без точки.
+    связанному с качеством оценки, и в отличие от полосы он нигде не назван:
+    посетитель бы о нём не узнал. Карта переживёт строку без точки.
 
     Ломать так: добавить в `build_row` `if lat is None or lon is None: return
     None` — тест покраснеет на None вместо строки.

tradein-mvp/backend/tests/test_msk_raw_import.py

@@ -156,7 +156,7 @@ def test_only_moscow_rows_reach_the_writer(captured: list[dict[str, Any]]) -> No
     assert [lot.source_id for lot in captured[0]["lots"]] == ["1", "4"]
     assert counters.read == 5
     assert counters.selected == 2
-    assert counters.skipped_not_moscow == 1
+    assert counters.skipped_not_target_region == 1
     assert counters.skipped_artifact == 1
     assert counters.skipped_invalid == 1
     assert counters.check(), "счётчики обязаны сходиться с прочитанным"
@@ -331,7 +331,7 @@ def test_geocode_lets_avito_through_without_allow_unfiltered(
         _FakeSession(_geo_rows()), source="avito", batch_size=10, geocode=True
     )
     assert [lot.source_id for lot in captured[0]["lots"]] == ["1"]
-    assert counters.skipped_oblast == 1
+    assert counters.skipped_geo_other_region == 1
     assert counters.skipped_ungeocoded == 1
     assert counters.check(), "счётчики обязаны сходиться с прочитанным"
 
@@ -444,7 +444,7 @@ def test_yandex_oblast_rows_do_not_reach_the_writer(captured: list[dict[str, Any
     ]
     counters = mod.import_msk_raw(_FakeSession(rows), source="yandex", batch_size=10)
     assert [lot.source_id for lot in captured[0]["lots"]] == ["1"]
-    assert counters.skipped_not_moscow == 1
+    assert counters.skipped_not_target_region == 1
 
 
 def test_yandex_keeps_its_own_coordinates(captured: list[dict[str, Any]]) -> None:
@@ -461,3 +461,280 @@ def test_geocode_is_refused_for_yandex(captured: list[dict[str, Any]]) -> None:
         mod.import_msk_raw(
             _FakeSession([{"id": 1, "payload": _yandex()}]), source="yandex", geocode=True
         )
+
+
+def test_domclick_moscow_is_recognised_without_geocode() -> None:
+    """Регион ДомКлика — первый компонент адреса; Новая Москва тоже Москва."""
+    assert mod.is_moscow_domclick_address("Москва, улица Нижние Мнёвники, 16 к2")
+    assert mod.is_moscow_domclick_address("Москва, пос. Птичное, Лесная улица, 82")
+    assert mod.is_moscow_domclick_address("Москва, x. Ильичевка, хутор Ильичёвка, 1")
+
+
+def test_domclick_non_moscow_is_rejected() -> None:
+    """Вторая линия обороны: GUID в сборщике сменится — импорт не смолчит."""
+    assert not mod.is_moscow_domclick_address("Московская область, Химки, 9 Мая, 21к3")
+    assert not mod.is_moscow_domclick_address("Екатеринбург, улица Ясная, 2")
+    # «Москва» должна быть отдельным компонентом, а не префиксом другого слова.
+    assert not mod.is_moscow_domclick_address("Московский, 1-я улица, 5")
+    assert not mod.is_moscow_domclick_address("")
+    assert not mod.is_moscow_domclick_address(None)
+
+
+def test_domclick_oblast_is_recognised_without_geocode() -> None:
+    """Регион 50 у ДомКлика — первый компонент адреса «Московская область»."""
+    assert mod.is_oblast_domclick_address("Московская область, Химки, 9 Мая, 21к3")
+    assert mod.is_oblast_domclick_address(
+        "Московская область, Одинцовский городской округ, Звенигород, 3-й м-н, 28"
+    )
+    assert not mod.is_oblast_domclick_address("Москва, улица Нижние Мнёвники, 16 к2")
+    assert not mod.is_oblast_domclick_address("")
+    assert not mod.is_oblast_domclick_address(None)
+
+
+def test_domclick_oblast_without_prefix_is_saved_by_its_coordinates() -> None:
+    """Живой случай: областная карточка БЕЗ префикса «Московская область».
+
+    В собранном корпусе 12.09.2026 такая ровно одна на 2 961 — Можайск, и
+    строгий префикс выбросил бы её молча. Координата внутри bbox области —
+    вторая опора фильтра, а не замена первой.
+    """
+    mozhaysk = _payload(
+        source="domclick",
+        address="Можайский муниципальный округ, д. Семёновское, 1",
+        lat=55.511625,
+        lon=35.829308,
+    )
+    assert mod.is_oblast_domclick_payload(mozhaysk)
+
+    # Строки вместо чисел (JSON сырья бывает и таким) читаются так же.
+    assert mod.is_oblast_domclick_payload({**mozhaysk, "lat": "55.511625", "lon": "35.829308"})
+
+
+def test_domclick_oblast_geo_branch_cannot_swallow_moscow() -> None:
+    """bbox Москвы вложен в областной — отказ по адресу обязан идти РАНЬШЕ гео."""
+    moscow = _payload(
+        source="domclick",
+        address="Москва, улица Нижние Мнёвники, 16 к2",
+        lat=55.7558,
+        lon=37.6173,
+    )
+    assert not mod.is_oblast_domclick_payload(moscow)
+
+
+def test_domclick_oblast_geo_branch_needs_a_usable_point() -> None:
+    """Нет префикса и нечего проверить координатой → карточка НЕ область."""
+    bare = _payload(source="domclick", address="Можайский муниципальный округ, д. Семёновское, 1")
+    bare.pop("lat", None)
+    bare.pop("lon", None)
+    assert not mod.is_oblast_domclick_payload(bare)
+    assert not mod.is_oblast_domclick_payload({**bare, "lat": None, "lon": None})
+    assert not mod.is_oblast_domclick_payload({**bare, "lat": "н/д", "lon": "н/д"})
+    # Координата за пределами области (Екатеринбург) тоже не проходит.
+    assert not mod.is_oblast_domclick_payload({**bare, "lat": 56.8300, "lon": 60.6000})
+
+
+def test_domclick_view_is_wired_into_source_views() -> None:
+    assert mod.SOURCE_VIEWS["domclick"] == "msk_raw.domclick_latest"
+    filt77 = mod.REGION_FILTERS[("domclick", 77)]
+    assert filt77(_payload(source="domclick", address="Москва, улица Нижние Мнёвники, 16 к2"))
+    assert not filt77(_payload(source="domclick", address="Московская область, Химки, 9 Мая, 21к3"))
+
+    filt50 = mod.REGION_FILTERS[("domclick", 50)]
+    assert filt50 is mod.is_oblast_domclick_payload
+    assert filt50(_payload(source="domclick", address="Московская область, Химки, 9 Мая, 21к3"))
+    assert not filt50(_payload(source="domclick", address="Москва, улица Нижние Мнёвники, 16 к2"))
+
+
+# ── регион 50 (Московская область) ───────────────────────────────────────────
+
+
+def test_cian_subdomain_selects_oblast_regardless_of_okrug(
+    captured: list[dict[str, Any]],
+) -> None:
+    """khimki.cian.ru → область при --region 50, даже если адрес без округа."""
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source_id="khimki-1",
+                source_url="https://khimki.cian.ru/sale/flat/1/",
+                address="городской округ Химки, Олимпийский проспект, 29",
+            ),
+        }
+    ]
+    counters_50 = mod.import_msk_raw(_FakeSession(rows), source="cian", region=50, batch_size=10)
+    assert counters_50.selected == 1
+
+    counters_77 = mod.import_msk_raw(_FakeSession(rows), source="cian", region=77, batch_size=10)
+    assert counters_77.selected == 0
+
+
+def test_cian_www_with_okrug_stays_moscow_only(captured: list[dict[str, Any]]) -> None:
+    """www.cian.ru + префикс округа — Москва (77), не область (50)."""
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source_id="www-1",
+                source_url="https://www.cian.ru/sale/flat/330200428/",
+                address="ЦАО, р-н Арбат, улица Арбат, 10",
+            ),
+        }
+    ]
+    counters_77 = mod.import_msk_raw(_FakeSession(rows), source="cian", region=77, batch_size=10)
+    assert counters_77.selected == 1
+
+    counters_50 = mod.import_msk_raw(_FakeSession(rows), source="cian", region=50, batch_size=10)
+    assert counters_50.selected == 0
+
+
+def test_yandex_oblast_region_50_is_selected(captured: list[dict[str, Any]]) -> None:
+    rows = [
+        {
+            "id": 1,
+            "payload": _yandex(
+                source_id="oblast-1",
+                address="Россия, Московская область, Химки, Ивановская улица, 5",
+            ),
+        }
+    ]
+    counters_50 = mod.import_msk_raw(_FakeSession(rows), source="yandex", region=50, batch_size=10)
+    assert counters_50.selected == 1
+
+    counters_77 = mod.import_msk_raw(_FakeSession(rows), source="yandex", region=77, batch_size=10)
+    assert counters_77.selected == 0
+
+
+def test_domclick_oblast_region_50_is_selected(captured: list[dict[str, Any]]) -> None:
+    """Областной прогон сборщика (батч mo-serp-domclick-20260912) отбирается по region=50."""
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source="domclick",
+                source_id="oblast-1",
+                address="Московская область, Химки, проспект Мельникова, 33",
+            ),
+        }
+    ]
+    counters_50 = mod.import_msk_raw(
+        _FakeSession(rows), source="domclick", region=50, batch_size=10
+    )
+    assert counters_50.selected == 1
+
+    counters_77 = mod.import_msk_raw(
+        _FakeSession(rows), source="domclick", region=77, batch_size=10
+    )
+    assert counters_77.selected == 0
+
+
+def test_domclick_moscow_region_77_is_selected(captured: list[dict[str, Any]]) -> None:
+    """Московский прогон (батч msk-serp-domclick-20260912) отбирается по region=77."""
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source="domclick",
+                source_id="moscow-1",
+                address="Москва, Генерала Дорохова проспект, 49",
+            ),
+        }
+    ]
+    counters_77 = mod.import_msk_raw(
+        _FakeSession(rows), source="domclick", region=77, batch_size=10
+    )
+    assert counters_77.selected == 1
+
+    counters_50 = mod.import_msk_raw(
+        _FakeSession(rows), source="domclick", region=50, batch_size=10
+    )
+    assert counters_50.selected == 0
+
+
+def test_domclick_writer_gets_region_50_and_city_none(captured: list[dict[str, Any]]) -> None:
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source="domclick",
+                source_id="oblast-2",
+                address="Московская область, Химки, проспект Мельникова, 33",
+            ),
+        }
+    ]
+    mod.import_msk_raw(_FakeSession(rows), source="domclick", region=50, batch_size=10)
+    assert captured[0]["region_code"] == 50
+    assert captured[0]["city"] is None
+
+
+def test_domclick_mixed_batches_are_told_apart_by_address(captured: list[dict[str, Any]]) -> None:
+    """Вью отдаёт московский и областной прогоны вперемешку — региональный фильтр
+    обязан развести их сам, курсор по `id` тут не помощник."""
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source="domclick",
+                source_id="oblast-3",
+                address="Московская область, Одинцовский городской округ, Звенигород, 3-й м-н, 28",
+            ),
+        },
+        {
+            "id": 2,
+            "payload": _payload(
+                source="domclick",
+                source_id="moscow-2",
+                address="Москва, Генерала Дорохова проспект, 49",
+            ),
+        },
+    ]
+    counters = mod.import_msk_raw(_FakeSession(rows), source="domclick", region=50, batch_size=10)
+    assert [lot.source_id for lot in captured[0]["lots"]] == ["oblast-3"]
+    assert counters.selected == 1
+    assert counters.skipped_not_target_region == 1
+    assert counters.check(), "счётчики обязаны сходиться с прочитанным"
+
+
+def test_writer_gets_city_none_for_oblast(captured: list[dict[str, Any]]) -> None:
+    rows = [
+        {
+            "id": 1,
+            "payload": _payload(
+                source_id="khimki-1",
+                source_url="https://khimki.cian.ru/sale/flat/1/",
+                address="городской округ Химки, Олимпийский проспект, 29",
+            ),
+        }
+    ]
+    mod.import_msk_raw(_FakeSession(rows), source="cian", region=50, batch_size=10)
+    assert captured[0]["region_code"] == 50
+    assert captured[0]["city"] is None
+
+
+def test_moscow_region_77_numbers_unchanged(captured: list[dict[str, Any]]) -> None:
+    """Анти-регресс: те же фикстуры, тот же region=77 → те же прежние числа."""
+    counters = mod.import_msk_raw(_FakeSession(_rows()), batch_size=10, region=77)
+    assert [lot.source_id for lot in captured[0]["lots"]] == ["1", "4"]
+    assert counters.read == 5
+    assert counters.selected == 2
+    assert counters.skipped_not_target_region == 1
+    assert counters.skipped_artifact == 1
+    assert counters.skipped_invalid == 1
+    assert captured[0]["region_code"] == 77
+    assert captured[0]["city"] == "Москва"
+
+
+def test_cian_subdomain_ignores_port_and_case() -> None:
+    """Поддомен читается из `hostname`, а не из `netloc`: порт и регистр хоста
+    не должны превращать московскую карточку в «не целевой регион», а областную
+    — в московскую. Хост не `*.cian.ru` (включая голый `cian.ru` и похожий
+    `fake-cian.ru`) остаётся None — консервативно, ложной области не даёт."""
+    assert mod.cian_subdomain({"source_url": "https://WWW.CIAN.RU:443/sale/flat/1/"}) == "www"
+    assert (
+        mod.cian_subdomain({"source_url": "https://khimki.cian.ru:8443/sale/flat/1/"}) == "khimki"
+    )
+    assert mod.is_cian_oblast_payload({"source_url": "https://khimki.cian.ru:8443/x"}) is True
+    assert mod.is_cian_oblast_payload({"source_url": "https://WWW.CIAN.RU:443/x"}) is False
+    for bad in ("https://cian.ru/sale/flat/1/", "https://fake-cian.ru/x", "", None, 42):
+        assert mod.cian_subdomain({"source_url": bad}) is None
+    assert mod.cian_subdomain({}) is None

tradein-mvp/backend/tests/test_public_mera_api.py

@@ -559,7 +559,12 @@ def test_offered_cities_match_coverage_cities() -> None:
     import pathlib
     import re
 
-    from app.api.v1.trade_in import COVERAGE_GREEN_CITIES, COVERAGE_YELLOW_CITIES, _fold_city
+    from app.api.v1.trade_in import (
+        COVERAGE_GREEN_CITIES,
+        COVERAGE_MOSCOW_DISPLAY,
+        COVERAGE_YELLOW_CITIES,
+        _fold_city,
+    )
 
     registry = (
         pathlib.Path(__file__).resolve().parents[2]
@@ -573,7 +578,10 @@ def test_offered_cities_match_coverage_cities() -> None:
     assert block, "не нашли OBLAST_CITIES — проверка стала бы пустой"
 
     offered = {_fold_city(m) for m in re.findall(r'label:\s*"([^"]+)"', block.group(1))}
-    answerable = {_fold_city(c) for c in (*COVERAGE_GREEN_CITIES, *COVERAGE_YELLOW_CITIES)}
+    answerable = {
+        _fold_city(c)
+        for c in (*COVERAGE_GREEN_CITIES, *COVERAGE_YELLOW_CITIES, COVERAGE_MOSCOW_DISPLAY)
+    }
 
     assert offered == answerable, (
         "предлагаем выбрать и умеем отвечать — это должно быть одно множество.\n"
@@ -640,6 +648,25 @@ def test_suggest_passes_city_prefixed_query_downstream(client: TestClient) -> No
     assert captured["q"] == "Серов, Ленина 1"
     # Сам хинт продолжаем передавать: от него зависит гейт кадастрового тира.
     assert captured["city_hint"] == "Серов"
+    # Серов — регион 66, вывод из city_hint не меняет прежнее поведение.
+    assert captured["region_code"] == 66
+
+
+def test_suggest_infers_region_from_moscow_city_hint(client: TestClient) -> None:
+    """#3051: `city_hint='Москва'` без явного region_code должен уйти в 77,
+    а не молча получить свердловский region_code=66 по умолчанию.
+    """
+    captured: dict[str, object] = {}
+
+    async def _fake(**kwargs):
+        captured.update(kwargs)
+        return SuggestResponse(items=[])
+
+    with patch.object(public_mera, "suggest_addresses", _fake):
+        resp = client.post(f"{PREFIX}/suggest", json={"q": "Тверская 6", "city_hint": "Москва"})
+
+    assert resp.status_code == 200, resp.text
+    assert captured["region_code"] == 77
 
 
 # ── 9. Невалидный вход: 422 и всё тот же бюджет ──────────────────────────────

tradein-mvp/backend/tests/test_sales_vs_listings.py

@@ -419,6 +419,57 @@ def test_sales_vs_listings_target_city_none_when_city_unresolved(
     assert params["target_city"] is None
 
 
+# ── Test: region-scope (#dkp-corridor-scope 2026-09-12) ───────────────────────
+
+
+def test_sales_vs_listings_region_code_scoped_for_moscow(trade_in_app: FastAPI) -> None:
+    """Московский адрес: target_city остаётся None (словарь только обл.66), но
+    region_code=77 обязан уйти в SQL — иначе TVF смешивает московские сделки с
+    одноимённой улицей ЕКБ (region_code=66) на стороне deals."""
+    db_mock = _make_db_mock([])
+    _override_db(trade_in_app, db_mock)
+
+    client = TestClient(trade_in_app)
+    resp = client.get(
+        "/api/v1/trade-in/sales-vs-listings",
+        params={
+            "address": "Москва, Тверская улица, 6",
+            "area_m2": 44.3,
+            "rooms": 2,
+        },
+    )
+    assert resp.status_code == 200
+    assert db_mock.execute.called
+    args, kwargs = db_mock.execute.call_args
+    sql_text = str(args[0])
+    params = args[1] if len(args) > 1 else kwargs.get("parameters", {})
+    assert params["target_city"] is None
+    assert params["region_code"] == 77
+    assert "region_code" in sql_text and "deals" in sql_text, (
+        "SQL must JOIN deals and filter by region_code"
+    )
+
+
+def test_sales_vs_listings_region_code_unchanged_for_ekaterinburg(trade_in_app: FastAPI) -> None:
+    """Регресс-гейт: екатеринбургский адрес по-прежнему скоупится в регион 66."""
+    db_mock = _make_db_mock([])
+    _override_db(trade_in_app, db_mock)
+
+    client = TestClient(trade_in_app)
+    resp = client.get(
+        "/api/v1/trade-in/sales-vs-listings",
+        params={
+            "address": "г. Екатеринбург, ул. Малышева, 125",
+            "area_m2": 65.5,
+            "rooms": 3,
+        },
+    )
+    assert resp.status_code == 200
+    args, kwargs = db_mock.execute.call_args
+    params = args[1] if len(args) > 1 else kwargs.get("parameters", {})
+    assert params["region_code"] == 66
+
+
 # ── Test: response shape (Pydantic validation) ───────────────────────────────
 
 

tradein-mvp/backend/tests/test_sber_index.py

@@ -537,3 +537,26 @@ async def test_pull_sber_indices_asking_benchmark_logged(caplog: pytest.LogCaptu
     assert any("115000" in record.message for record in caplog.records), (
         "Benchmark log should include the latest asking index value"
     )
+
+
+def test_moscow_oblast_ref_area_feeds_the_estimator_under_the_same_name() -> None:
+    """Имя ряда у загрузчика и у эстиматора обязано совпадать буква в букву.
+
+    Загрузчик завёл REF_AREA=50 раньше (#3498), когда карта эстиматора кода 50
+    ещё не знала и область считалась по «России». 12.09.2026 ряд приехал на прод
+    (real_estate_deals/«Вторичный», 116 месяцев 2017-01..2026-08), и код 50 попал
+    в `_SBER_REGION_SERIES`. С этого момента расхождение имён перестаёт быть
+    безобидным: эстиматор молча читал бы пустой ряд, а монитор свежести требовал
+    бы ряд, которого загрузчик не пишет. Тест сцепляет обе стороны по имени.
+    """
+    from app.services.estimator import (
+        SBER_MONITORED_REGIONS,
+        SBER_REQUIRED_REGIONS,
+        sber_region_series_name,
+    )
+    from app.services.sber_index import SBER_REF_AREAS
+
+    assert SBER_REF_AREAS["50"] == "Московская область"
+    assert sber_region_series_name(50) == SBER_REF_AREAS["50"]
+    assert "Московская область" in SBER_REQUIRED_REGIONS
+    assert "Московская область" in SBER_MONITORED_REGIONS

tradein-mvp/backend/tests/test_sber_region_series_3051.py

@@ -88,6 +88,21 @@ def test_series_names_agree_with_region_registry() -> None:
         assert regions_mod.REGIONS[code].name == name
 
 
+def test_resolver_maps_50_to_moscow_oblast_not_russia() -> None:
+    """Область получает СВОЙ ряд, а не общероссийский фолбэк.
+
+    Загрузчик научился тянуть REF_AREA=50 (#3498), и 12.09.2026 ряд приехал на
+    прод: real_estate_deals/«Вторичный», 116 месяцев 2017-01..2026-08 — та же
+    глубина, что у Москвы и обл.66. Пока кода 50 в карте не было, коридор
+    области считался по «России», то есть ошибался на всё расхождение области
+    со страной. Тест красный на прежней карте ПО ЗНАЧЕНИЮ: там вернулась бы
+    «Россия».
+    """
+    assert est.sber_region_series_name(50) == "Московская область"
+    assert est.sber_region_series_name(50) != est.SBER_TIME_ADJUST_FALLBACK_REGION
+    assert "Московская область" in est.SBER_REQUIRED_REGIONS
+
+
 def test_monitored_regions_cover_every_series_the_estimator_can_read() -> None:
     assert set(est.SBER_MONITORED_REGIONS) == set(est._SBER_REGION_SERIES.values()) | {
         est.SBER_TIME_ADJUST_FALLBACK_REGION
@@ -275,8 +290,15 @@ def test_monitor_verdict_for_sverdlovsk_unchanged(monkeypatch: pytest.MonkeyPatc
 
 
 def _without_moscow() -> _MonDB:
-    """Источник переименовал «Москва» → ряда с прежним именем больше нет."""
-    return _MonDB({"Свердловская область": _JUN_2026, "Россия": _JUN_2026})
+    """Источник переименовал «Москва» → ряда с прежним именем больше нет.
+
+    Остальные обязательные ряды на месте — иначе тесты ниже считали бы пропажу
+    Москвы вместе с чужими пропажами. Строятся от карты эстиматора, чтобы новый
+    регион в ней не ронял эти тесты по счётчику (ровно так они и покраснели,
+    когда в карту приехала область).
+    """
+    present = {r: _JUN_2026 for r in est.SBER_MONITORED_REGIONS if r != "Москва"}
+    return _MonDB(present)
 
 
 def test_missing_moscow_does_not_suppress_the_sverdlovsk_verdict(
@@ -352,7 +374,7 @@ def test_missing_fallback_series_does_not_fail_the_monitor(
 ) -> None:
     """«Россия» — фолбэк: сегодня по нему не считается ни одна сделка → не сбой."""
     calls = _patch_runs(monkeypatch)
-    db = _MonDB({"Свердловская область": _JUN_2026, "Москва": _JUN_2026})
+    db = _MonDB({r: _JUN_2026 for r in est.SBER_REQUIRED_REGIONS})
     out = mon.check_sber_freshness(db, run_id=4, params={}, now=_NOW)  # type: ignore[arg-type]
     assert calls["failed"] is None
     assert out["regions_missing"] == 1
@@ -457,15 +479,17 @@ def test_duplicate_series_name_does_not_pin_regions_missing(
 def test_early_exit_fills_the_new_counters(monkeypatch: pytest.MonkeyPatch) -> None:
     """КРАСНЫЙ ДО ПРАВКИ: в раннем выходе новые ключи отдавали нули.
 
-    Пропажа ДВУХ обязательных рядов была неотличима от пропажи одного свердловского,
-    а найденный ряд не попадал в age_days_max вовсе.
+    Пропажа ВСЕХ обязательных рядов была неотличима от пропажи одного
+    свердловского, а найденный ряд не попадал в age_days_max вовсе. Счётчик
+    сверяем с длиной карты, а не с литералом: новый регион в ней — не повод
+    этому тесту краснеть.
     """
     calls = _patch_runs(monkeypatch)
     db = _MonDB({est.SBER_TIME_ADJUST_FALLBACK_REGION: _JUN_2026})
     out = mon.check_sber_freshness(db, run_id=11, params={}, now=_NOW)  # type: ignore[arg-type]
     assert calls["done"] is None
     assert calls["failed"] is not None
-    assert out["regions_missing"] == 2
+    assert out["regions_missing"] == len(est.SBER_REQUIRED_REGIONS)
     assert out["alert_regions_missing"] == 1  # ДО ПРАВКИ: 0
     assert out["age_days_max"] == 72  # ДО ПРАВКИ: 0 — найденный ряд был не виден
     # прежняя семантика раннего выхода не тронута
@@ -492,9 +516,7 @@ class _MonDBDriverFault(_MonDB):
 
     def execute(self, stmt: Any, params: dict[str, Any] | None = None) -> _Result:
         if self._deactivated:
-            raise PendingRollbackError(
-                "Can't reconnect until invalid transaction is rolled back"
-            )
+            raise PendingRollbackError("Can't reconnect until invalid transaction is rolled back")
         params = params or {}
         if params.get("city") == self._broken:
             self._deactivated = True

tradein-mvp/backend/tests/test_scraper_kit_group_c_backfill_kit_parity.py

@@ -186,7 +186,9 @@ async def test_house_imv_backfill_browser_fetcher_uses_settings_endpoint() -> No
         db.execute.return_value.mappings.return_value.all.return_value = [
             {"id": 1, "address": "ЕКБ, ул. X, 1", "full_address": None, "lat": 56.8, "lon": 60.6}
         ]
-        await house_imv_backfill.backfill_house_imv(db, batch_size=1)
+        # request_delay_sec=0: мок дублирует строку в retry+fresh (2 записи вместо 1) —
+        # реальный анти-бот sleep(5с) между ними тут не нужен.
+        await house_imv_backfill.backfill_house_imv(db, batch_size=1, request_delay_sec=0)
 
     # #2698: к endpoint= добавилась проводка пула — без неё сайдкар брал env-прокси
     # (узел с affinity='domclick'), и домовая оценка падала 34 дня подряд.

tradein-mvp/backend/tests/test_sentry_scrub.py

@@ -13,6 +13,7 @@ import pytest
 os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://test:test@localhost:5432/test")
 
 from app.observability.sentry_scrub import (
+    drop_payments_disabled_event,
     redact_telegram_bot_token,
     scrub_payment_request_body,
     scrub_pii_event,
@@ -627,3 +628,63 @@ def test_scrub_pii_event_httpx_url_query_stabilization_leaves_unrelated_text_unt
     out = scrub_pii_event(event, {})
     assert out is not None
     assert out["extra"]["note"] == benign
+
+
+# ── payments-disabled drop (issue #3471, GlitchTip-группа TRADE-IN-3GG) ─────
+# 503 из `payments.py._require_enabled` — штатный ответ выключенного
+# kill-switch'а, а не инцидент: sentry_sdk `StarletteIntegration` репортит его
+# как error-событие только потому, что 503 попадает в дефолтный диапазон
+# `failed_request_status_codes` (5xx), хотя FastAPI обработал исключение
+# штатно. 167 событий/2 недели от внутреннего IP смоук-проверки (кнопки оплаты
+# во фронте нет) размывали ленту. Фильтр не должен трогать поведение самой
+# ручки (503 остаётся) и не должен глотать другие ошибки — включая другие 503.
+
+from fastapi import HTTPException  # noqa: E402
+
+
+def _exc_info_hint(exc: BaseException) -> dict:
+    """Та же форма hint, что sentry_sdk реально передаёт в before_send —
+    `exc_info = (type, value, traceback)` (см. `_hint_for` выше по файлу)."""
+    return {"exc_info": (type(exc), exc, exc.__traceback__)}
+
+
+def test_drop_payments_disabled_event_drops_the_503() -> None:
+    exc = HTTPException(status_code=503, detail="payments are disabled")
+    event = {"level": "error", "exception": {"values": [{"type": "HTTPException"}]}}
+    assert drop_payments_disabled_event(event, _exc_info_hint(exc)) is None
+
+
+def test_drop_payments_disabled_event_leaves_other_errors_untouched() -> None:
+    """Обычная ошибка (не платёжный kill-switch) должна долетать до GlitchTip
+    без изменений — фильтр специфичен по (status_code, detail), а не по 5xx."""
+    exc = ValueError("boom")
+    event = {"level": "error"}
+    out = drop_payments_disabled_event(event, _exc_info_hint(exc))
+    assert out is event
+
+
+def test_drop_payments_disabled_event_leaves_other_503s_untouched() -> None:
+    """Другой 503 с другим текстом (напр. будущий maintenance-режим другого
+    роутера) не должен ложно схлопнуться с платёжным kill-switch'ем."""
+    exc = HTTPException(status_code=503, detail="service temporarily unavailable")
+    event = {"level": "error"}
+    out = drop_payments_disabled_event(event, _exc_info_hint(exc))
+    assert out is event
+
+
+def test_drop_payments_disabled_event_leaves_matching_detail_wrong_status_untouched() -> None:
+    """Тот же текст detail, но другой status_code — не платёжный kill-switch."""
+    exc = HTTPException(status_code=500, detail="payments are disabled")
+    event = {"level": "error"}
+    out = drop_payments_disabled_event(event, _exc_info_hint(exc))
+    assert out is event
+
+
+def test_drop_payments_disabled_event_no_exc_info_untouched() -> None:
+    event = {"level": "error"}
+    out = drop_payments_disabled_event(event, {})
+    assert out is event
+
+
+def test_drop_payments_disabled_event_handles_non_dict_event() -> None:
+    assert drop_payments_disabled_event(None, {}) is None  # type: ignore[arg-type]

tradein-mvp/backend/tests/test_street_deals_endpoint.py

@@ -107,6 +107,50 @@ def test_extract_street_name_parametrized(address: str | None, expected: str | N
     assert extract_street_name(address) == expected
 
 
+@pytest.mark.parametrize(
+    "address,expected",
+    [
+        # Live-prod repro (2026-09-12): московский формат — keyword стоит
+        # ПОСЛЕ имени улицы ("Название улица, N"), а не перед ним. Сразу
+        # после keyword идёт запятая — _STREET_KW_RE (форматы "ул. X")
+        # такую позицию вообще не матчит (требует \s+), из-за чего
+        # extract_street_name возвращал None для ВСЕХ московских адресов,
+        # и ДКП-коридор (_fetch_dkp_corridor) для Москвы никогда не строился
+        # (212 937 московских сделок в БД, dkp_corridor=null на проде).
+        ("Москва, Тверская улица, 6", "Тверская"),
+        ("Москва, 1-я Тверская-Ямская улица, 12", "1-я Тверская-Ямская"),
+        ("Москва, Брюсов переулок, 8", "Брюсов"),
+        ("Москва, Ленинский проспект, 30", "Ленинский"),
+        # Reverse-формат Nominatim с московским порядком keyword'а.
+        (
+            "Театр имени М. Н. Ермоловой, 5/6, Тверская улица, 58, Тверской"
+            " район, Москва, Центральный федеральный округ, 125009, Россия",
+            "Тверская",
+        ),
+        # Площадь — тот же реверс-порядок, keyword не только "улица"/"переулок".
+        ("Москва, Красная площадь, 1", "Красная"),
+        # Новая Москва — Coммунарка/поселения — тот же keyword-порядок работает
+        # без явного упоминания слова "Москва" в адресе.
+        ("поселение Сосенское, Коммунарка, Ясная улица, 5", "Ясная"),
+        # Голый keyword без имени перед ним (пустая запятая-секция) — извлекать
+        # нечего, а не "" или мусор из соседнего сегмента.
+        ("Москва, улица, 5", None),
+        # Нумерованный проезд БЕЗ имени: "Проектируемый" — прилагательное к
+        # самому "проезду" (сотни таких проездов в Москве имеют один и тот же
+        # префикс), keyword+"№" — НЕ moscow-reverse формат с именем.
+        ("Москва, Проектируемый проезд № 4062, 5", None),
+    ],
+)
+def test_extract_street_name_moscow_reverse_order(
+    address: str | None, expected: str | None
+) -> None:
+    """Московский формат "Название улица, N" — keyword после имени, не перед
+    ним (#dkp-corridor live-prod fix 2026-09-12)."""
+    from app.services.estimator import extract_street_name
+
+    assert extract_street_name(address) == expected
+
+
 @pytest.mark.parametrize(
     "address,expected",
     [
@@ -358,3 +402,87 @@ def test_street_regex_param_passed_to_db(trade_in_app: FastAPI) -> None:
     assert r"\m" in regex_val or r"\b" in regex_val or regex_val.startswith(r"\m"), (
         f"Expected word-boundary in regex, got: {regex_val!r}"
     )
+
+
+# ── Test: region-scope (#dkp-corridor-scope 2026-09-12) ───────────────────────
+
+
+@pytest.mark.parametrize(
+    "address,expected_region_code",
+    [
+        ("Москва, Тверская улица, 6", 77),
+        ("Екатеринбург, ул. Космонавтов, 50", 66),
+        # Точное совпадение сегмента, НЕ подстрока: "Московская улица" в ЕКБ
+        # содержит "москва" как подстроку, но сегмент целиком ≠ "москва" — не
+        # должна уехать в регион 77 (иначе одноимённая улица ЕКБ подмешалась
+        # бы в московскую выборку, и наоборот).
+        ("Екатеринбург, Московская улица, 12", 66),
+        (None, 66),
+        ("", 66),
+    ],
+)
+def test_region_code_for_address(address: str | None, expected_region_code: int) -> None:
+    from app.services.estimator import region_code_for_address
+
+    assert region_code_for_address(address) == expected_region_code
+
+
+def test_street_deals_region_code_scoped_for_moscow(trade_in_app: FastAPI) -> None:
+    """Московский адрес: extract_street_name теперь распознаёт улицу, но
+    _resolve_target_city знает только города обл.66 → без region_code фильтра
+    одноимённая улица ЕКБ (region_code=66) подмешалась бы в московскую выборку.
+    Ручка обязана передать region_code=77 в SQL-фильтр."""
+    db_mock = _make_db_mock([])
+
+    from app.core.db import get_db
+
+    def _override():
+        yield db_mock
+
+    trade_in_app.dependency_overrides[get_db] = _override
+
+    client = TestClient(trade_in_app)
+    client.get(
+        "/api/v1/trade-in/street-deals",
+        params={
+            "address": "Москва, Тверская улица, 6",
+            "area_m2": 50.0,
+            "rooms": 2,
+        },
+    )
+
+    assert db_mock.execute.called
+    call_args = db_mock.execute.call_args
+    sql_text = str(call_args[0][0])
+    params = call_args[0][1] if len(call_args[0]) > 1 else call_args[1].get("parameters", {})
+    assert "region_code" in params, f"region_code not passed to SQL: {params}"
+    assert params["region_code"] == 77
+    assert "region_code" in sql_text, "SQL must filter by region_code"
+
+
+def test_street_deals_region_code_unchanged_for_ekaterinburg(trade_in_app: FastAPI) -> None:
+    """Регресс-гейт: екатеринбургский адрес по-прежнему скоупится в регион 66
+    (DEFAULT_REGION_CODE) — фильтр не отрезает существующие ЕКБ-результаты."""
+    db_mock = _make_db_mock([])
+
+    from app.core.db import get_db
+
+    def _override():
+        yield db_mock
+
+    trade_in_app.dependency_overrides[get_db] = _override
+
+    client = TestClient(trade_in_app)
+    client.get(
+        "/api/v1/trade-in/street-deals",
+        params={
+            "address": "Екатеринбург, ул. Космонавтов, 50",
+            "area_m2": 50.0,
+            "rooms": 2,
+        },
+    )
+
+    assert db_mock.execute.called
+    call_args = db_mock.execute.call_args
+    params = call_args[0][1] if len(call_args[0]) > 1 else call_args[1].get("parameters", {})
+    assert params["region_code"] == 66

tradein-mvp/backend/tests/test_support.py

@@ -76,6 +76,20 @@ class _FakeTelegramClient:
         return _FakeTelegramClient._response
 
 
+@pytest.fixture(autouse=True)
+def _no_existing_idempotent_message(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Дефолт для тестов, которые не проверяют идемпотентность (#3471) напрямую:
+    без этого автостаба pre-check в `support.py` дёргал бы РЕАЛЬНУЮ
+    storage-функцию против MagicMock `db` в каждом тесте, где замокан
+    `find_thread_id` для своих целей (rate-limit / DB-failure / anon-сценарии
+    и т.д.) — падало бы на MagicMock-результате, никак не связанное с тем, что
+    тест на самом деле проверяет. Тесты идемпотентности переопределяют это
+    через `_install_fake_storage` ниже."""
+    monkeypatch.setattr(
+        support_module.storage, "find_inbound_by_idempotency_key", lambda *a, **kw: None
+    )
+
+
 @pytest.fixture(autouse=True)
 def _fake_telegram_client(monkeypatch: pytest.MonkeyPatch) -> Any:
     _FakeTelegramClient.calls = []
@@ -238,7 +252,9 @@ def test_send_message_happy_path_mirrors_with_website_marker(
     monkeypatch.setattr(support_module.storage, "get_or_create_thread", fake_get_or_create_thread)
     recorded = {}
 
-    def fake_record_inbound(db, *, thread_id, text_body, topic_message_id, support_chat_id):
+    def fake_record_inbound(
+        db, *, thread_id, text_body, topic_message_id, support_chat_id, idempotency_key=None
+    ):
         recorded.update(
             thread_id=thread_id,
             text_body=text_body,
@@ -1052,3 +1068,156 @@ def test_anon_send_failures_trigger_cooldown_per_ip(
     blocked = client.post("/api/v1/trade-in/support/anon/messages", json={"text": "2"})
     assert blocked.status_code == 429
     assert len(_fake_telegram_client.calls) == calls_before  # до Telegram не дошло
+# ── idempotency (#3471) ──────────────────────────────────────────────────────
+
+
+class _FakeIdempotentStorage:
+    """In-memory stand-in для `web_support_storage`, достаточный чтобы точно
+    воспроизвести идемпотентный контракт (thread_id, idempotency_key) БЕЗ
+    настоящей БД: unique-конфликт на повторном ключе внутри `record_inbound`
+    (см. миграцию 301 и storage.record_inbound docstring)."""
+
+    def __init__(self) -> None:
+        self.threads: dict[str, int] = {}
+        self.messages: list[dict[str, Any]] = []
+        self._next_id = 1
+
+    def find_thread_id(self, db: Any, username: str) -> int | None:
+        return self.threads.get(username)
+
+    def get_or_create_thread(self, db: Any, username: str) -> int:
+        if username not in self.threads:
+            self.threads[username] = len(self.threads) + 1
+        return self.threads[username]
+
+    def find_inbound_by_idempotency_key(
+        self, db: Any, *, thread_id: int, idempotency_key: str
+    ) -> dict[str, Any] | None:
+        for m in self.messages:
+            if m["_thread_id"] == thread_id and m["_idempotency_key"] == idempotency_key:
+                return {k: v for k, v in m.items() if not k.startswith("_")}
+        return None
+
+    def record_inbound(
+        self,
+        db: Any,
+        *,
+        thread_id: int,
+        text_body: str,
+        topic_message_id: int | None,
+        support_chat_id: int | None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        # Тот же контракт, что и настоящий `INSERT ... ON CONFLICT DO NOTHING`:
+        # конфликт по (thread_id, idempotency_key) отдаёт УЖЕ существующую строку.
+        if idempotency_key is not None:
+            existing = self.find_inbound_by_idempotency_key(
+                db, thread_id=thread_id, idempotency_key=idempotency_key
+            )
+            if existing is not None:
+                return existing
+        row = {
+            "id": self._next_id,
+            "direction": "in",
+            "text_body": text_body,
+            "operator_tg_id": None,
+            "created_at": "2026-09-12T00:00:00+00:00",
+            "_thread_id": thread_id,
+            "_idempotency_key": idempotency_key,
+        }
+        self._next_id += 1
+        self.messages.append(row)
+        return {k: v for k, v in row.items() if not k.startswith("_")}
+
+
+def _install_fake_storage(monkeypatch: pytest.MonkeyPatch) -> _FakeIdempotentStorage:
+    fake = _FakeIdempotentStorage()
+    monkeypatch.setattr(support_module.storage, "find_thread_id", fake.find_thread_id)
+    monkeypatch.setattr(support_module.storage, "get_or_create_thread", fake.get_or_create_thread)
+    monkeypatch.setattr(
+        support_module.storage,
+        "find_inbound_by_idempotency_key",
+        fake.find_inbound_by_idempotency_key,
+    )
+    monkeypatch.setattr(support_module.storage, "record_inbound", fake.record_inbound)
+    return fake
+
+
+def test_repeat_send_with_same_idempotency_header_returns_same_id_single_mirror(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch, _fake_telegram_client: Any
+) -> None:
+    """Повтор с тем же `Idempotency-Key` — тот же id, ОДНО зеркало в Telegram
+    (не только одна строка в БД, см. #3471 требование п.3)."""
+    _install_fake_storage(monkeypatch)
+    headers = {**_auth("kopylov"), "Idempotency-Key": "retry-abc123"}
+
+    r1 = client.post(
+        "/api/v1/trade-in/support/messages", json={"text": "первое сообщение"}, headers=headers
+    )
+    r2 = client.post(
+        "/api/v1/trade-in/support/messages", json={"text": "первое сообщение"}, headers=headers
+    )
+
+    assert r1.status_code == 200, r1.text
+    assert r2.status_code == 200, r2.text
+    assert r1.json()["id"] == r2.json()["id"]
+    # Ключевая проверка: повтор НЕ ушёл в Telegram второй раз.
+    assert len(_fake_telegram_client.calls) == 1
+
+
+def test_send_with_different_idempotency_keys_creates_different_messages(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch, _fake_telegram_client: Any
+) -> None:
+    _install_fake_storage(monkeypatch)
+    r1 = client.post(
+        "/api/v1/trade-in/support/messages",
+        json={"text": "вопрос один"},
+        headers={**_auth("kopylov"), "Idempotency-Key": "key-one-111"},
+    )
+    r2 = client.post(
+        "/api/v1/trade-in/support/messages",
+        json={"text": "вопрос два"},
+        headers={**_auth("kopylov"), "Idempotency-Key": "key-two-222"},
+    )
+
+    assert r1.status_code == 200, r1.text
+    assert r2.status_code == 200, r2.text
+    assert r1.json()["id"] != r2.json()["id"]
+    assert len(_fake_telegram_client.calls) == 2
+
+
+def test_repeat_send_without_idempotency_header_still_dedupes_via_fallback_window(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch, _fake_telegram_client: Any
+) -> None:
+    """Требование п.5: отсутствие явного ключа не должно ломать старых клиентов —
+    сервер сам считает детерминированный fallback-отпечаток (thread+текст+минутное
+    окно), так что тот же повтор ТЕМ ЖЕ клиентом без заголовка тоже не создаёт
+    дубль. Время фиксируем, чтобы не зависеть от границы минутного окна в CI."""
+    _install_fake_storage(monkeypatch)
+    monkeypatch.setattr(support_module.time, "time", lambda: 1_800_000_000.0)
+
+    r1 = client.post(
+        "/api/v1/trade-in/support/messages", json={"text": "не могу войти"}, headers=_auth("bob")
+    )
+    r2 = client.post(
+        "/api/v1/trade-in/support/messages", json={"text": "не могу войти"}, headers=_auth("bob")
+    )
+
+    assert r1.status_code == 200, r1.text
+    assert r2.status_code == 200, r2.text
+    assert r1.json()["id"] == r2.json()["id"]
+    assert len(_fake_telegram_client.calls) == 1
+
+
+def test_send_without_idempotency_header_first_call_still_succeeds(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch, _fake_telegram_client: Any
+) -> None:
+    """Требование п.5 (не ломает старых клиентов): один запрос без заголовка
+    отрабатывает как раньше — 200, тред создан, зеркало отправлено ровно раз."""
+    _install_fake_storage(monkeypatch)
+    r = client.post(
+        "/api/v1/trade-in/support/messages", json={"text": "просто вопрос"}, headers=_auth("carol")
+    )
+    assert r.status_code == 200, r.text
+    assert r.json()["persisted"] is True
+    assert len(_fake_telegram_client.calls) == 1

tradein-mvp/docker-compose.prod.yml

@@ -425,6 +425,13 @@ services:
   # (env_file ниже); пусто/нет токена = бот молча не стартует (см. tgbot_main.py).
   # ⚠️ НЕ дублировать TELEGRAM_* в блоке environment: (см. предупреждение у backend
   # выше про environment: перекрывающий env_file при пустой host-env).
+  # #3471: TELEGRAM_RELAY_BASE_URL/TELEGRAM_RELAY_SECRET (клиент резервного
+  # ретранслятора tg-relay на инфраструктурном хосте) заводятся тем же
+  # способом — строкой в backend/.env.runtime на ЭТОМ (продуктовом, Selectel)
+  # хосте. deploy-tradein.yml секреты приложения в CI не инжектит вовсе —
+  # только читает уже лежащий на хосте .env.runtime, поэтому Forgejo-секрет
+  # TELEGRAM_RELAY_SECRET сюда сам по себе не долетит: файл на хосте нужно
+  # дополнить вручную (см. README-АДМИНУ.md).
   tgbot:
     image: ghcr.io/lekss361/gendesign-tradein-backend:${IMAGE_TAG:-latest}
     container_name: tradein-tgbot