@rt-tools/agent-kit 0.8.2 → 0.9.0

package/assets/hooks/reuse-first-guard.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|mcp__webstorm__create_new_file
+# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/profile-check.sh
 # Гард «ничего не пишется с нуля». PreToolUse на правке кода и разметки.
 #
@@ -47,9 +47,23 @@ case "$tool" in
     # сменой не инструмента, а способа записи; текстом правки тогда служит сама команда, и
     # заведённое ею в heredoc читается наравне с телом правки. Разбор —
     # `2026-08-15-guard-denied-shell-wrote-anyway.md`.
-    Bash)
+    #
+    # Терминал среды исполняет ту же командную строку и кладёт её в то же поле: без этих двух
+    # имён гард стоял бы объявленным на них и молча пропускал — состояние хуже необъявленного,
+    # потому что снаружи выглядит закрытым.
+    Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
         shell_cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
         [ -z "$shell_cmd" ] && exit 0
+        # Универсальный исполнитель прячет настоящую команду во вложенной строке: без её разбора
+        # путь стоит за кавычкой, и до него не дотягивается ни один образец.
+        if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
+            inner="$(printf '%s' "$shell_cmd" | perl -0ne '
+                if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+                    print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                }
+            ' 2>/dev/null)"
+            [ -n "$inner" ] && shell_cmd="$inner"
+        fi
         ;;
     *) exit 0 ;;
 esac

package/assets/hooks/skill-gate.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash
+# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool|mcp__claude-in-chrome__.*
 # Гейт правил: не даёт править файл, пока не загружено правило, под которое он подпадает.
 #
 # Закон и правило, которых никто не открывает, не действуют. Напоминание в подсказке помогает

package/assets/hooks/sql-guard-parse.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+# Разбор команды для гарда хранилища: приведение к одному виду, нарезка на сегменты и ответ
+# на вопрос, доставляет ли сегмент SQL до сервера.
+#
+# Строки `# rt-hook:` здесь нет намеренно: событие и образец вызова объявляет сам гард, а
+# помощник рядом хуком не регистрируется и в одиночку ничего не решает.
+
+# Дальше разбираем без учёта регистра и переводов строк: `delete\n  from bookings`
+# — тот же запрос, что и в одну строку.
+#
+# Перевод строки при этом превращается в `;`, а не в пробел: в командной строке он РАЗДЕЛЯЕТ
+# вызовы ровно как `;`, и склейка его в пробел стирала границу между ними. Многострочная
+# команда становилась одним сегментом, доказательство чтения из первой строки покрывало
+# неразобранный вызов из второй, и запись на боевую базу проходила молча — тот же обход,
+# что чинили для `&&`, только набранный с новой строки.
+normalize() {
+    perl -0ne '
+        # Продолжение длинной команды обратным слешем — это одна строка, а не две: без
+        # склейки адрес из первой уезжал в соседний сегмент, где клиента уже нет.
+        s/\\\n/ /g;
+        # Перевод строки заменяется на `;` ТОЛЬКО вне кавычек. Внутри `-c "…"` он часть
+        # запроса: многострочный SELECT резался на сегменты, и штатное чтение боевой базы
+        # переставало быть доказанным.
+        my ($out, $quote, $esc) = ("", "", 0);
+        for my $ch (split //, $_) {
+            if ($esc) { $out .= $ch; $esc = 0; next; }
+            if ($ch eq "\\") { $out .= $ch; $esc = 1; next; }
+            if ($quote ne "") {
+                $out .= ($ch eq "\n" ? " " : $ch);
+                $quote = "" if $ch eq $quote;
+            } elsif ($ch eq q{"} || $ch eq q{'"'"'}) {
+                $quote = $ch; $out .= $ch;
+            } elsif ($ch eq "\n" || $ch eq ";") {
+                $out .= "\x01";              # граница независимых команд
+            } elsif ($ch eq "|") {
+                $out .= "\x02";              # граница звена конвейера
+            } elsif ($ch eq "&") {
+                $out .= "\x01";
+            } else {
+                $out .= $ch;
+            }
+        }
+        # Соседние маркеры схлопываются: `&&` и `||` дают по два подряд.
+        $out =~ s/\x01+/\x01/g;
+        $out =~ s/\x02\x01/\x01/g;
+        $out =~ s/\x01\x02/\x01/g;
+        # Незакрытая кавычка означает, что автомат разъехался: апостроф в комментарии
+        # (`# don'"'"'t forget`) оставлял состояние «внутри строки» до конца ввода, и все
+        # последующие переводы строк переставали разделять вызовы — сегментация выключалась
+        # одним символом. В таком случае честнее ничего не печатать: вызывающий разделит
+        # строки грубым способом, и лишнее дробление сыграет в пользу строгости.
+        print $out if $quote eq "";
+    ' 2>/dev/null
+}
+
+# Грубое разделение — запасной путь: все переводы строк становятся разделителями. Оно строже
+# точного (может разрезать многострочный запрос), поэтому годится и как фолбэк без perl,
+# и как ответ на неразобранную команду.
+sql_flatten() {
+    flat_rough="$(printf '%s' "$sql" | perl -0pe 's/\\\n/ /g' 2>/dev/null | tr '\n;&' '\001\001\001' | tr '|' '\002' | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
+    [ -z "$flat_rough" ] && flat_rough="$(printf '%s' "$sql" | tr '\n;&' '\001\001\001' | tr '|' '\002' | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
+
+    if command -v perl >/dev/null 2>&1; then
+        flat="$(printf '%s' "$sql" | normalize | tr '\t' ' ' | tr '[:upper:]' '[:lower:]')"
+        [ -z "$flat" ] && flat="$flat_rough"
+    else
+        flat="$flat_rough"
+    fi
+}
+
+# Разбор идёт по сегментам, а не по всей строке: `ls -l /opt && … psql -c "\copy …"` целиком
+# выглядел как чтение, потому что `-l` от `ls` засчитывался за `psql -l`.
+#
+# Нарезка живёт в ЕДИНСТВЕННОМ месте. Пока наборов разделителей было два — один в раннем слое,
+# другой здесь, — расхождение само по себе оказалось дырой: одиночный `|` считался границей
+# тут и не считался там, и доставка файла конвейером в клиент проходила как чтение.
+# Команда — то, что стоит между `;`, `&&`, `||` и переводами строк. Конвейер границей НЕ
+# является: `cat fix.sql | psql …` — не две независимые команды, а одна доставка SQL, где
+# левое звено питает правое. Пока `|` резал команды, глагол из `echo "drop table …"` терялся
+# вместе с отброшенным звеном, и запись проходила молча.
+split_segments() {
+    # Перевод строки в конце обязателен: без него `read` не отдаёт последнюю строку в тело
+    # цикла, и команда из одного сегмента молча выпадала из разбора целиком.
+    printf '%s\n' "$1" | tr '\001' '\n'
+}
+
+# Звенья конвейера внутри одной команды.
+split_pipeline() {
+    printf '%s' "$1" | tr '\002' '\n'
+}
+
+# Команда считается вызовом клиента, только если клиент стоит ГОЛОВОЙ хотя бы одного звена.
+# Имя в аргументе (`grep -rn "prisma db push" docs/`) вызовом не является.
+calls_client() {
+    _found=""
+    _links="$(printf '%s' "$1" | tr '\002' '\n')"
+    while IFS= read -r link; do
+        [ -z "$link" ] && continue
+        # Голова звена: пропускаем присваивания окружения и обёртки вроде sudo/time/xargs.
+        head="$(printf '%s' "$link" | sed -E 's/^[[:space:]]*//; s/^([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*//; s/^(sudo|time|env|nice|xargs)[[:space:]]+//')"
+        case "$head" in
+            psql*|pg_restore*|pg_dump*|pg_dumpall*|prisma*|*/psql*|*/pg_restore*|*/pg_dump*)
+                _found="yes"; break ;;
+        esac
+        # Транспорт до машины: сам вызов стоит внутри строки, которую он исполняет.
+        case "$head" in
+            ssh\ *|scp\ *|docker\ *|*/ssh\ *|*/docker\ *)
+                printf '%s' "$link" | grep -qE '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
+                    && { _found="yes"; break; } ;;
+        esac
+        # Раннер пакетов перед клиентом: `npx prisma migrate deploy`.
+        case "$head" in
+            npx\ *|pnpm\ *|yarn\ *|bun\ *|npm\ *)
+                printf '%s' "$head" | grep -qE '^(npx|pnpm|yarn|bun|npm)([[:space:]]+(exec|run|dlx))?[[:space:]]+(psql|pg_restore|pg_dump|prisma)([[:space:]]|$)' \
+                    && { _found="yes"; break; } ;;
+        esac
+    done <<CALLS_EOF
+$_links
+CALLS_EOF
+    [ -n "$_found" ]
+}
+
+# Голова сегмента — читающий инструмент: имя клиента стоит в его аргументе, то есть это поиск
+# или просмотр файла, а не доставка SQL. `grep -rn "prisma db push" docs/` читает документацию.
+# Решает именно ГОЛОВА: тот же приём применён в dev-server-guard якорем BOUND.
+is_reader() {
+    printf '%s' "$1" | grep -qE '^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*((sudo|time|env|nice|xargs)[[:space:]]+)*([^[:space:]]*/)?(grep|rg|ag|ack|find|awk|sed|cat|less|more|head|tail|wc|echo|printf|jq|diff|comm|sort|uniq|column)([[:space:]]|$)'
+}
+
+# Сегменты с настоящим вызовом клиента: читающие головы отсеиваются здесь же, а не отдельным
+# слоем с собственным выходом.
+client_segments() {
+    split_segments "$flat" | while IFS= read -r seg; do
+        [ -z "$seg" ] && continue
+        calls_client "$seg" || continue
+        # Маркер звена больше не нужен: дальше команда разбирается как одна строка.
+        printf '%s\n' "$(printf '%s' "$seg" | tr '\002' ' ')"
+    done
+}
+
+# Адресат берётся ТОЛЬКО из сегментов вызова клиента и только из аргументов, а не из данных.
+# Домен сайта живёт в самих строках — в почте владельца, в canonical и og:url объекта, — а
+# рядом в цепочке его дёргают по HTTP. Пока признак искался по всей команде, `curl
+# https://<домен приложения>/... && psql -p 5432 -c "update …"` отклонялся как запись в
+# боевую базу, и опт-аута у этой ветки нет по замыслу: команда становилась неисполнимой.
+# Текст запроса вырезается ДО нарезки на сегменты. Внутри `-c "…"` свободно живут `;` и `||`
+# — по ним сегменты и режутся, поэтому кусок запроса с доменом в данных становился отдельным
+# сегментом, и почта на домене приложения снова читалась как адрес боевой базы.
+sql_addr_flatten() {
+    addr_flat="$flat"
+    if command -v perl >/dev/null 2>&1; then
+        addr_flat="$(printf '%s' "$flat" | perl -0pe '
+            s/(^|[^[:alnum:]])--?(c|command|querytext)(=|\s+)("([^"\\]|\\.)*"|\x27[^\x27]*\x27)/$1/gs
+        ' 2>/dev/null || printf '%s' "$flat")"
+    fi
+}
+
+addr_segments() {
+    split_segments "$addr_flat" | while IFS= read -r seg; do
+        [ -z "$seg" ] && continue
+        flat_seg="$(printf '%s' "$seg" | tr '\002' ' ')"
+        # Адрес берётся из команд с вызовом клиента и из транспорта до машины: `ssh root@…`
+        # называет боевой хост, а сам вызов стоит дальше по цепочке.
+        if calls_client "$seg"; then
+            printf '%s\n' "$flat_seg"
+        elif printf '%s' "$flat_seg" | grep -qE '(^|[^[:alnum:]_.-])(ssh|scp|docker)([^[:alnum:]_.-]|$)|(pghost|pgport|pgdatabase|pguser|database_url|postgres_url)='; then
+            is_reader "$flat_seg" && continue
+            printf '%s\n' "$flat_seg"
+        fi
+    done
+}
+
+# Сегменты вызова клиента для дальнейшего разбора. У запроса из редактора сегментов нет вовсе
+# — там весь текст и есть запрос.
+sql_collect_segments() {
+    segments="$(client_segments)"
+    if [ -z "$segments" ]; then
+        if [ -n "$conn" ] || [ "$context" != "команда psql/prisma" ]; then
+            segments="$flat"
+        else
+            # Команда, где имя клиента встретилось только в аргументах читающих инструментов,
+            # ничего никуда не доставляет. Выход здесь безопасен: он стоит ПОСЛЕ разбора, а не
+            # вместо него, и срабатывает лишь когда настоящего вызова в команде нет.
+            exit 0
+        fi
+    fi
+}

package/assets/hooks/sql-guard-request.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# Запрос из ввода гарда хранилища: что именно поедет к серверу и через что.
+#
+# Строки `# rt-hook:` здесь нет намеренно: событие и образец вызова объявляет сам гард, а
+# помощник рядом хуком не регистрируется и в одиночку ничего не решает.
+#
+# Отсюда выходят четыре значения: `sql` — текст запроса или команда целиком, `conn` —
+# идентификатор подключения редактора, `context` — чем это доставляется, и `cmd` — исходная
+# командная строка, нужная разбору адреса миграции в исходном регистре.
+
+# Три вида ввода: запрос через подключение редактора, команда оболочки и та же команда,
+# завёрнутая в универсальный исполнитель. Инструмент, не названный здесь, гарда не касается.
+sql_read_request() {
+    sql=""
+    context=""
+    conn=""
+    case "$tool" in
+        mcp__webstorm__execute_sql_query)
+            sql="$(printf '%s' "$input" | jq -r '.tool_input.queryText // empty' 2>/dev/null)"
+            conn="$(printf '%s' "$input" | jq -r '.tool_input.connectionId // empty' 2>/dev/null)"
+            context="запрос через подключение редактора"
+            ;;
+        # Терминал IDE исполняет ту же командную строку и кладёт её в то же поле, что и Bash:
+        # без этой ветки весь гард обходился сменой инструмента.
+        Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
+            cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+            [ -z "$cmd" ] && exit 0
+
+            # Универсальный исполнитель зовёт ЛЮБОЙ инструмент редактора по имени, в том числе
+            # `execute_sql_query`, — и тогда в строке нет ни одного имени клиента, по которому
+            # гард себя включает. Сам инструмент закрыт в permissions.deny, но полагаться только
+            # на настройку нельзя: её снимут, а гард останется.
+            if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
+                case "$cmd" in
+                    *execute_sql_query*)
+                        inner_sql="$(printf '%s' "$cmd" | perl -0ne '
+                            if (/--queryText(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+                                print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                            }
+                        ' 2>/dev/null)"
+                        inner_conn="$(printf '%s' "$cmd" | perl -0ne '
+                            if (/--connectionId(?:=|\s+)(?:"([^"]*)"|\x27([^\x27]*)\x27|(\S+))/) {
+                                print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                            }
+                        ' 2>/dev/null)"
+                        ;;
+                esac
+                # Терминал, завёрнутый в тот же исполнитель: разбираем настоящую команду.
+                if [ -z "$inner_sql" ]; then
+                    inner_cmd="$(printf '%s' "$cmd" | perl -0ne '
+                        if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+                            print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                        }
+                    ' 2>/dev/null)"
+                    [ -n "$inner_cmd" ] && cmd="$inner_cmd"
+                fi
+            fi
+
+            # Завёрнутый запрос разбирается как запрос из редактора, а не как команда оболочки:
+            # имени клиента в нём нет, зато есть подключение и текст SQL.
+            if [ -n "$inner_sql" ]; then
+                sql="$inner_sql"
+                conn="$inner_conn"
+                context="запрос через подключение редактора (обёртка исполнителя)"
+            else
+
+            # Команда, которая ничего никуда не доставляет, разбору не подлежит — даже если имя
+            # клиента стоит в её аргументах. `grep -rn "prisma db push" docs/` читает файлы, а не
+            # базу; раньше он получал deny, и обойти это можно было только испортив сам шаблон
+            # поиска. Тот же приём уже применён в dev-server-guard: решает ГОЛОВА команды, а не
+            # упоминание имени где-то внутри.
+            # Интересуют команды, которые доносят SQL до сервера. Клиент ищется КАК СЛОВО в любом
+            # месте команды, а не только в начале: удаление на бою выглядит как
+            # `ssh root@host "docker compose exec postgres psql -c '…'"` — при проверке одного
+            # лишь начала строки оно проходило мимо гарда целиком.
+            #
+            # Порядок здесь принципиален. Раньше выше стояла отсечка «команда начинается с git/gh»,
+            # снимавшая ложные срабатывания на тексте коммита, — и она же открывала обход: в
+            # `git log && psql … -c "DELETE …"` первое звено уносило с собой весь остальной SQL.
+            # Теперь сперва ищется клиент, и только его отсутствие завершает проверку.
+            printf '%s\n' "$cmd" | grep -qE \
+                '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
+                || exit 0
+
+            # Ложные срабатывания на описаниях снимаются иначе — вырезанием текста сообщений
+            # (`-m '…'`, `-am "…"`, `--message="…"`, `-F file`), а не отказом от проверки всей
+            # команды. В самом сообщении SQL не исполняется, но слова «delete» и «drop» в нём
+            # обычны: `git commit -am "chore(api): update prisma schema"` разбирался как
+            # UPDATE без WHERE, потому что шаблон требовал `-m` вплотную к дефису.
+            if command -v perl >/dev/null 2>&1; then
+                # `file` в альтернации быть не должно: под него попадал `--file=cleanup.sql`
+                # у psql, и признак «SQL приехал файлом» умирал раньше, чем его проверяли.
+                # Здесь только флаги, которые несут ТЕКСТ сообщения.
+                cmd="$(printf '%s' "$cmd" | perl -0pe '
+                    s/(^|[^[:alnum:]])--?[a-zA-Z]*(m|message|body|title|body-file|F)(=|\s+)("([^"\\]|\\.)*"|\x27[^\x27]*\x27|[^\s;&|]+)/$1/gs
+                ' 2>/dev/null || printf '%s' "$cmd")"
+                # После вырезания сообщения клиента может уже не остаться — тогда это была
+                # git-команда, лишь упоминавшая psql в тексте.
+                printf '%s\n' "$cmd" | grep -qE \
+                    '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' \
+                    || exit 0
+            else
+                # Без perl вырезать текст сообщения нечем, и разбирать его как SQL нельзя:
+                # штатный коммит упирался бы в отказ. Доставки SQL в git-команде не бывает,
+                # поэтому здесь дешевле пропустить, чем ломать работу.
+                case "$cmd" in
+                    git\ *|*/git\ *|gh\ *|*/gh\ *) exit 0 ;;
+                esac
+            fi
+
+            sql="$cmd"
+            context="команда psql/prisma"
+            fi
+            ;;
+        *) exit 0 ;;
+    esac
+}

package/assets/hooks/sql-guard-target.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+# Адресат запроса для гарда хранилища: боевая база, одноразовая база проверки или что-то
+# третье — и что на боевой разрешено.
+#
+# Строки `# rt-hook:` здесь нет намеренно: событие и образец вызова объявляет сам гард, а
+# помощник рядом хуком не регистрируется и в одиночку ничего не решает.
+
+# --- прод: запись запрещена в любом виде ------------------------------------------------
+# Признак берётся из профиля: порт туннеля, хост, домен — у каждого дерева свои.
+#
+# Ищем его в АДРЕСЕ, а не в данных: домен приложения живёт и в самих строках — в почте
+# владельца, в канонической ссылке объекта. Пока признак брался по всей команде, вставка
+# строки с таким адресом в локальную базу отклонялась как запись в бой, а опт-аута у этой
+# ветки нет по замыслу — команда становилась неисполнимой.
+# Поэтому текст запроса (то, что стоит после `-c`/`--command`) из проверки вырезается.
+#
+# Запрос из редактора адресата в тексте не называет: база выбирается идентификатором
+# подключения, и по одному SQL отличить прод от локальной копии невозможно. Поэтому
+# подключения опознаются в лицо. Список сверяется вызовом list_database_connections;
+# добавили новое — допишите сюда, иначе оно попадёт в «неизвестные» ниже.
+sql_resolve_target() {
+    is_prod=""
+    PROD_CONNECTIONS="${RT_PROD_CONNECTIONS:-}"
+    LOCAL_CONNECTIONS="${RT_LOCAL_CONNECTIONS:-}"
+
+    conn_known=""
+    if [ -n "$conn" ]; then
+        case " $PROD_CONNECTIONS " in *" $conn "*) is_prod="yes"; conn_known="prod" ;; esac
+        # Опознанное локальное подключение сильнее текстовой догадки: домен приложения живёт в
+        # самих данных — в почте владельца, в канонической ссылке объекта. Пока вывод не
+        # отменялся, обновление такой строки на локальной базе отклонялось как запись в бой, и
+        # обойти это было нечем.
+        case " $LOCAL_CONNECTIONS " in *" $conn "*) conn_known="local"; is_prod="" ;; esac
+    fi
+
+    # Для запроса из редактора адрес в тексте не назван вовсе: там решает опознанное
+    # подключение, а если оно неизвестно — ветка ниже спросит пользователя.
+    is_scratch=""
+    addr_other=""
+    if [ -z "$conn" ] && [ "$context" != "запрос через подключение редактора (обёртка исполнителя)" ]; then
+        while IFS= read -r seg; do
+            [ -z "$seg" ] && continue
+            if [ -n "$PROD_DSN" ] && printf '%s' "$seg" | grep -qE "$PROD_DSN"; then
+                is_prod="yes"
+                addr_other="yes"
+                continue
+            fi
+            # Одноразовая база проверки: петлевой адрес и порт из отведённого под них диапазона.
+            # Диапазон занимают контейнеры, которые поднимают на время одной проверки —
+            # восстановление копии, репетиция миграции на непустой базе — и сносят следом. Данных,
+            # которые стоило бы стеречь, там нет по построению, а вопрос на каждую строку такой
+            # проверки приучает отвечать «да» не читая и обесценивает тот вопрос, который был важен.
+            #
+            # Диапазон узкий и петлевой намеренно: под него не должны попадать ни рабочая база
+            # дерева, ни туннель к бою, ни базы соседних деревьев на этой машине. Какой он здесь,
+            # знает профиль; не назван — исключения нет вовсе, и вопрос задаётся всегда.
+            if [ -n "${RT_SCRATCH_PORT_RE:-}" ] \
+                && printf '%s' "$seg" | grep -qE "$RT_SCRATCH_PORT_RE" \
+                && printf '%s' "$seg" | grep -qE '127\.0\.0\.1|localhost|host\.docker\.internal'; then
+                is_scratch="yes"
+            else
+                # Любой другой адресованный вызов снимает исключение целиком: в цепочке
+                # `psql -p 19434 -f x.sql && psql -c "delete …"` ранний выход убрал бы проверку
+                # со второго звена, а это ровно тот обход, ради которого гард и написан.
+                addr_other="yes"
+            fi
+        done <<EOF
+$(addr_segments)
+EOF
+    fi
+}
+
+# Исключение стоит ПОСЛЕ разбора адреса и ПЕРЕД правилами записи, но строго после того, как
+# признак боевой базы уже выставлен: прод перекрывает исключение при любом совпадении, а не
+# наоборот. Условие тройное — одноразовый адрес найден, боевого нет, и других адресованных
+# вызовов в команде нет вовсе.
+sql_pass_scratch() {
+    if [ -n "$is_scratch" ] && [ -z "$is_prod" ] && [ -z "$addr_other" ]; then
+        exit 0
+    fi
+}
+
+# На боевой базе разрешено только то, что гард опознал как чтение — БЕЛЫМ списком, а не
+# перечислением запретов. Чёрный список здесь принципиально не работает: SQL доезжает до
+# сервера файлом, редиректом, `\copy`, `SELECT … INTO`, и каждая заделанная форма оставляет
+# соседнюю. Поэтому вопрос перевёрнут: не «есть ли здесь запись», а «доказано ли чтение».
+#
+# Чтением считаются три формы, и каждая проверяется в СЕГМЕНТЕ своего вызова:
+#   pg_dump без --clean/--create   — снятие дампа
+#   psql -c "<один SELECT>"        — запрос без второго стейтмента
+#   psql -l / --version / --help   — проверка соединения без запроса
+sql_check_prod() {
+    if [ -n "$is_prod" ] && [ -n "$is_write" ]; then
+        deny "BLOCKED: запись в БОЕВОЕ хранилище (${context}). Адрес ведёт на бой — оттуда данные не восстанавливаются ничем, кроме копии. Схема на бою меняется миграцией через выкатку, данные — через панель владельца. Если правка данных на бою действительно нужна, её делает владелец руками, предварительно сняв копию; гард обойти нельзя."
+    fi
+
+    if [ -n "$is_prod" ]; then
+        unproven=""
+        while IFS= read -r seg; do
+            [ -z "$seg" ] && continue
+            seg_read=""
+            # Аргументы клиента — всё, что стоит ПОСЛЕ его имени. До имени в том же сегменте
+            # свободно живут чужие флаги: `docker compose -f docker-compose.prod.yml … psql`,
+            # и `-f` от compose однажды отменял доказательство чтения.
+            seg_tail="$(printf '%s' "$seg" | perl -0pe 's{^.*?(?<![[:alnum:]_./-])(psql|pg_restore|prisma)(?=\s|$)}{$1}s' 2>/dev/null)"
+            [ -z "$seg_tail" ] && seg_tail="$seg"
+
+            if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])pg_dump(all)?([^[:alnum:]_.-]|$)'; then
+                case "$seg" in
+                    *--clean*|*--create*) ;;
+                    *) seg_read="yes" ;;
+                esac
+            fi
+
+            # Один SELECT и ничего кроме: второй стейтмент через `;` уже не чтение.
+            if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_])select([^[:alnum:]_]|$)' \
+                && ! printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
+                && ! printf '%s' "$seg_tail" | grep -qE '(^|[[:space:]])(-f|--file)([[:space:]]|=)'; then
+                seg_read="yes"
+            fi
+
+            printf '%s' "$seg_tail" | grep -qE '(^|[[:space:]])(-l|--list|--version|--help)([[:space:]]|$)' \
+                && seg_read="yes"
+
+            [ -z "$seg_read" ] && unproven="yes"
+        done <<EOF
+$segments
+EOF
+
+        if [ -n "$unproven" ]; then
+            deny "BLOCKED: вызов клиента БД против БОЕВОЙ базы (${context}). На проде разрешено только доказанное чтение — \`pg_dump\` без \`--clean\`, одиночный SELECT через \`-c\`, либо \`-l\`/\`--version\`. Всё остальное отклоняется, даже если гард просто не разобрал команду: содержимое файлов (\`-f\`, \`< dump.sql\`), \`\\copy\` и восстановление дампа ему не видны. Если нужен разбор данных боевой базы — снимай дамп и работай с локальной копией."
+        fi
+    fi
+}