@rt-tools/agent-kit 0.3.0 → 0.4.0

package/assets/hooks/sql-guard.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# rt-hook: PreToolUse Bash|mcp__webstorm__execute_sql_query|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Гард пишущих запросов к хранилищу. PreToolUse.
 #
 # Правка данных — единственное действие, которое нельзя откатить правкой кода. Удаление по
@@ -6,8 +7,8 @@
 # автор запроса, и узнаётся это уже по восстановлению из копии.
 #
 # Отсюда правило: строки адресуются по первичному ключу. Перечисление идентификаторов
-# затрагивает ровно столько строк, сколько их перечислено, и промах виден до выполнения;
-# отбор по подстроке не виден никогда.
+# затрагивает ровно столько строк, сколько их перечислено, и промах виден до выполнения; отбор
+# по подстроке не виден никогда.
 #
 # Три уровня:
 #   отказ    — снос, очистка, правка схемы, удаление и обновление без условия или с условием
@@ -15,15 +16,23 @@
 #   вопрос   — остальная запись: адресная правка и вставка, решение за владельцем;
 #   пропуск  — чтение.
 #
-# Боевое хранилище отдельно: его адреса перечисляет профиль проекта ({{projectProfile}},
-# переменная RT_PROD_DSN) — там любая запись отказывается без опт-аута. Бой правится миграцией
-# через выкатку, а не запросом из редактора.
+# Боевое хранилище отдельно: его адреса и подключения перечисляет профиль дерева —
+#   RT_PROD_DSN          — образец адреса боевой базы: порт туннеля, хост, домен;
+#   RT_PROD_CONNECTIONS  — идентификаторы боевых подключений среды разработки;
+#   RT_LOCAL_CONNECTIONS — они же у локальных: опознанное локальное подключение сильнее любой
+#                          текстовой догадки;
+#   RT_SCRATCH_PORT_RE   — порты одноразовых баз, по которым вопрос не задаётся.
+# По боевому адресу любая запись отказывается без опт-аута: бой правится миграцией через
+# выкатку, а не запросом из редактора.
 #
 # Опт-аут для остальных случаев: маркер `destructive-ok` в тексте запроса вместе с объяснением,
 # почему адресация по идентификатору не подходит, понижает отказ до вопроса. Последнее слово
 # остаётся за владельцем — гард лишь не пропускает такое молча.
 #
-# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет разборщика, битый ввод, чужой инструмент — пропуск.
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет разборщика, битый ввод, чужой инструмент — пропуск. Без `perl`
+# вырезать текст сообщений коммитов нечем, поэтому команды работы с историей в этом случае
+# пропускаются целиком — иначе слова «drop» и «update» в описании коммита читались бы как
+# запрос. Доставки запроса внутри такой команды не бывает, так что цена послабления нулевая.
 
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
@@ -31,99 +40,640 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
 
+# Рабочий каталог нужен одному правилу — разрешению адреса миграции: `DATABASE_URL`
+# обычно не назван в команде и лежит в `.env` рядом с проектом.
+hook_cwd="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
+[ -z "$hook_cwd" ] && hook_cwd="${CLAUDE_PROJECT_DIR:-.}"
+
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+# Умолчание ищется и рядом с самим хуком: уезжают они вместе.
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+PROD_DSN="${RT_PROD_DSN:-}"
+
 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 '…'"` — при проверке одного
+        # лишь начала строки оно проходило мимо гарда целиком.
         #
-        # Порядок принципиален. Отсечка «команда начинается с гита», снимающая ложные
-        # срабатывания на тексте коммита, открывает обход: в составной команде первое звено
-        # уносит с собой весь остальной запрос. Поэтому сперва ищется клиент.
-        printf '%s\n' "$cmd" | grep -qE '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' || exit 0
-
-        # Ложные срабатывания на описаниях снимаются вырезанием текстов сообщений, а не отказом
-        # от проверки всей команды: в самом сообщении запрос не исполняется, но слова «удалить»
-        # и «обновить» в нём обычны.
+        # Порядок здесь принципиален. Раньше выше стояла отсечка «команда начинается с 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")"
-            printf '%s\n' "$cmd" | grep -qE '(^|[^[:alnum:]_.-])(psql|pg_restore|pg_dump|prisma)([^[:alnum:]_.-]|$)' || exit 0
+            # После вырезания сообщения клиента может уже не остаться — тогда это была
+            # 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
 
 [ -z "$sql" ] && exit 0
 
-# Дальше разбираем без учёта регистра: запрос, разбитый на строки, — тот же запрос.
-flat="$(printf '%s' "$sql" | tr '\n' ' ' | tr '[:upper:]' '[:lower:]')"
+# Дальше разбираем без учёта регистра и переводов строк: `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,
+# и как ответ на неразобранную команду.
+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
 
 deny() {
-    echo "$1 Адресуй строки по первичному ключу: перечисление идентификаторов затрагивает ровно столько строк, сколько их названо, и промах виден до выполнения. Если адресация по идентификатору здесь не подходит, поставь маркер destructive-ok в текст запроса с объяснением — решение тогда примет владелец." >&2
-    exit 2
+    jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
+        || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"Destructive SQL blocked. Address rows by id."}}\n'
+    exit 0
 }
 
 ask() {
-    jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"ask",permissionDecisionReason:$r}}' 2>/dev/null
+    jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"ask",permissionDecisionReason:$r}}' 2>/dev/null \
+        || exit 0
     exit 0
 }
 
-# Бой: адреса знает профиль. Там любая запись отказывается, и опт-аут не действует.
-profile="${CLAUDE_PROJECT_DIR:-.}/{{projectProfile}}"
-if [ -f "$profile" ]; then
-    # shellcheck disable=SC1090
-    . "$profile" 2>/dev/null
-    if [ -n "${RT_PROD_DSN:-}" ] && printf '%s' "$flat" | grep -qF "$RT_PROD_DSN"; then
-        case "$flat" in
-            *insert\ *|*update\ *|*delete\ *|*drop\ *|*truncate\ *|*alter\ *)
-                echo "Запись в боевое хранилище запрещена совсем: схема меняется миграцией через выкатку, данные — через интерфейс." >&2
-                exit 2 ;;
+# --- прод: запись запрещена в любом виде ------------------------------------------------
+# Признак берётся из профиля: порт туннеля, хост, домен — у каждого дерева свои.
+#
+# Ищем его в АДРЕСЕ, а не в данных: домен приложения живёт и в самих строках — в почте
+# владельца, в канонической ссылке объекта. Пока признак брался по всей команде, вставка
+# строки с таким адресом в локальную базу отклонялась как запись в бой, а опт-аута у этой
+# ветки нет по замыслу — команда становилась неисполнимой.
+# Поэтому текст запроса (то, что стоит после `-c`/`--command`) из проверки вырезается.
+is_prod=""
+
+# Запрос из редактора адресата в тексте не называет: база выбирается идентификатором
+# подключения, и по одному SQL отличить прод от локальной копии невозможно. Поэтому
+# подключения опознаются в лицо. Список сверяется вызовом list_database_connections;
+# добавили новое — допишите сюда, иначе оно попадёт в «неизвестные» ниже.
+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
+
+# Разбор идёт по сегментам, а не по всей строке: `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
+}
+
+
+segments="$(client_segments)"
+if [ -z "$segments" ]; then
+    # У запроса из редактора сегментов нет вовсе — там весь текст и есть запрос.
+    if [ -n "$conn" ] || [ "$context" != "команда psql/prisma" ]; then
+        segments="$flat"
+    else
+        # Команда, где имя клиента встретилось только в аргументах читающих инструментов,
+        # ничего никуда не доставляет. Выход здесь безопасен: он стоит ПОСЛЕ разбора, а не
+        # вместо него, и срабатывает лишь когда настоящего вызова в команде нет.
+        exit 0
     fi
 fi
 
-opt_out=0
-case "$flat" in *destructive-ok*) opt_out=1 ;; esac
+# Адресат берётся ТОЛЬКО из сегментов вызова клиента и только из аргументов, а не из данных.
+# Домен сайта живёт в самих строках — в почте владельца, в canonical и og:url объекта, — а
+# рядом в цепочке его дёргают по HTTP. Пока признак искался по всей команде, `curl
+# https://<домен приложения>/... && psql -p 5432 -c "update …"` отклонялся как запись в
+# боевую базу, и опт-аута у этой ветки нет по замыслу: команда становилась неисполнимой.
+# Текст запроса вырезается ДО нарезки на сегменты. Внутри `-c "…"` свободно живут `;` и `||`
+# — по ним сегменты и режутся, поэтому кусок запроса с доменом в данных становился отдельным
+# сегментом, и почта на домене приложения снова читалась как адрес боевой базы.
+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
+}
 
-case "$flat" in
-    *drop\ *|*truncate\ *|*alter\ table*)
-        [ "$opt_out" = 1 ] && ask "Схемная команда с маркером destructive-ok. Решение за тобой."
-        deny "Снос, очистка или правка схемы запросом." ;;
-esac
+# Для запроса из редактора адрес в тексте не назван вовсе: там решает опознанное подключение,
+# а если оно неизвестно — ветка ниже спросит пользователя.
+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
 
-case "$flat" in
-    *delete\ from*|*update\ *set\ *)
-        # Условие по идентификатору — единственная форма, где число задетых строк известно
-        # заранее. Отбор по подстроке им не является, даже когда сегодня совпадает точно.
-        if printf '%s' "$flat" | grep -qE 'where[^;]*\b(id|uuid)\b[[:space:]]*(=|in[[:space:]]*\()'; then
-            ask "Адресная правка данных. Решение за тобой."
+is_write=""
+# Глаголы ищутся в сегментах ВЫЗОВА, а не по всей строке: иначе слово из шаблона поиска в
+# соседнем звене цепочки объявляло записью читающую команду.
+write_scope="$segments"
+# `copy … from` и `select … into` — запись, не называющая ни одного привычного глагола.
+printf '%s' "$write_scope" | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|create|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
+    && is_write="yes"
+# Конвейер из источника в клиент — та же доставка файла, только без флага: содержимое
+# `cat fix.sql | psql …` гарду не видно, значит это запись по определению.
+while IFS= read -r seg; do
+    [ -z "$seg" ] && continue
+    printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])(cat|head|tail|gzcat|zcat|gunzip|echo|printf|curl|wget)([[:space:]]|$)' \
+        && is_write="yes" && break
+done <<PIPE_EOF
+$(client_segments)
+PIPE_EOF
+
+# Команды prisma меняют базу, не называя ни одного SQL-глагола: `migrate reset` пересоздаёт
+# её целиком, `db push` подгоняет схему под модель, `db execute` льёт произвольный файл.
+printf '%s' "$write_scope" | grep -qE 'prisma[[:space:]]+(migrate[[:space:]]+(reset|deploy|dev)|db[[:space:]]+(push|execute))' \
+    && is_write="yes"
+
+# Глагол в командной строке — не единственный способ довезти SQL до сервера. Файл (`-f`,
+# `--file`, `< dump.sql`) и `pg_restore` не называют ни одного, поэтому раньше проходили
+# мимо всех трёх уровней: доставка файла в клиент на боевой базе завершалась нулём
+# без единого вопроса, а `pg_restore` не мог сработать в принципе, хотя `--clean` сносит
+# содержимое. Содержимое файла гарду недоступно — значит это запись по определению.
+printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_.-])pg_restore([^[:alnum:]_.-]|$)' \
+    && is_write="yes"
+# У `pg_dump` тот же `-f` означает файл ВЫВОДА: это чтение, и записью его считать нельзя —
+# иначе штатное снятие дампа с боевой базы отклонялось, хотя текст отказа сам его советует.
+#
+# Исключение действует ПОСЕГМЕНТНО. Пока оно проверялось по всей команде, одного упоминания
+# `pg_dump` где угодно в цепочке хватало, чтобы `-f` перестал считаться записью во всех
+# остальных вызовах: `pg_dump … > /dev/null && psql -d app -f /tmp/x.sql` проходил молча.
+while IFS= read -r seg; do
+    [ -z "$seg" ] && continue
+    # Граница слова обязательна: `-f /tmp/pg_dump-restore.sql` — это заливка дампа, а не
+    # его снятие, и подстрочное совпадение снимало с неё обе защиты разом.
+    if printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])pg_dump(all)?([^[:alnum:]_.-]|$)'; then
+        continue
+    fi
+    # Хвост сегмента после имени клиента: `-f` у `docker compose` (боевой compose-файл
+    # называется нестандартно, без флага не поднимается) стоит ДО `psql` и к запросу
+    # отношения не имеет.
+    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_tail" | grep -qE '(^|[[:space:]])(-f|--file)([[:space:]]|=)|<[[:space:]]*[^[:space:]|<]+\.(sql|dump)'; then
+        is_write="yes"
+        break
+    fi
+done <<EOF
+$segments
+EOF
+
+# Исключение стоит ПОСЛЕ разбора адреса и ПЕРЕД правилами записи, но строго после того, как
+# признак боевой базы уже выставлен: прод перекрывает исключение при любом совпадении, а не
+# наоборот. Условие тройное — одноразовый адрес найден, боевого нет, и других адресованных
+# вызовов в команде нет вовсе.
+if [ -n "$is_scratch" ] && [ -z "$is_prod" ] && [ -z "$addr_other" ]; then
+    exit 0
+fi
+
+if [ -n "$is_prod" ] && [ -n "$is_write" ]; then
+    deny "BLOCKED: запись в БОЕВОЕ хранилище (${context}). Адрес ведёт на бой — оттуда данные не восстанавливаются ничем, кроме копии. Схема на бою меняется миграцией через выкатку, данные — через панель владельца. Если правка данных на бою действительно нужна, её делает владелец руками, предварительно сняв копию; гард обойти нельзя."
+fi
+
+# На боевой базе разрешено только то, что гард опознал как чтение — БЕЛЫМ списком, а не
+# перечислением запретов. Чёрный список здесь принципиально не работает: SQL доезжает до
+# сервера файлом, редиректом, `\copy`, `SELECT … INTO`, и каждая заделанная форма оставляет
+# соседнюю. Поэтому вопрос перевёрнут: не «есть ли здесь запись», а «доказано ли чтение».
+#
+# Чтением считаются три формы, и каждая проверяется в СЕГМЕНТЕ своего вызова:
+#   pg_dump без --clean/--create   — снятие дампа
+#   psql -c "<один SELECT>"        — запрос без второго стейтмента
+#   psql -l / --version / --help   — проверка соединения без запроса
+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
-        [ "$opt_out" = 1 ] && ask "Правка без адресации по идентификатору, с маркером destructive-ok. Решение за тобой."
-        deny "Удаление или обновление без условия по идентификатору." ;;
-esac
 
+        # Один 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
+
+[ -z "$is_write" ] && exit 0
+
+# --- заведомо разрушительное ------------------------------------------------------------
+soft=""
 case "$flat" in
-    *insert\ into*) ask "Вставка данных. Решение за тобой." ;;
+    *destructive-ok*) soft="yes" ;;
 esac
 
-exit 0
+verdict() {
+    if [ -n "$soft" ]; then
+        ask "Запрос помечен маркером destructive-ok, но остаётся разрушительным: $1 Подтверди выполнение, если это осознанно."
+    fi
+    deny "BLOCKED: $1 Адресуй строки по первичному ключу — \`WHERE id IN ('…','…')\`: так затрагивается ровно столько строк, сколько перечислено, и промах виден до выполнения. Удаление по маске (email LIKE '%test%') однажды унесло вместе с тестовыми записями демонстрационные брони владельца. Если адресация по id действительно не подходит — сначала выполни SELECT с тем же условием, покажи пользователю, что попадает под удаление, и помечай запрос маркером destructive-ok с объяснением."
+}
+
+if printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_])(truncate|drop[[:space:]]+(table|database|schema|column|index)|alter[[:space:]]+table)([^[:alnum:]_]|$)'; then
+    verdict "запрос меняет саму схему или очищает таблицу целиком (${context})."
+fi
+
+if printf '%s' "$flat" | grep -qE 'prisma[[:space:]]+(migrate[[:space:]]+reset|db[[:space:]]+push)'; then
+    verdict "\`prisma migrate reset\` / \`db push\` пересоздаёт базу и теряет её содержимое (${context})."
+fi
+
+# `pg_restore --clean` перед загрузкой удаляет существующие объекты — то же очищение
+# таблиц, только чужими руками. Без `--clean` это обычная догрузка, она идёт общим путём.
+if printf '%s' "$flat" | grep -q 'pg_restore' && printf '%s' "$flat" | grep -qE '(^|[[:space:]])(--clean|-c|--create)([[:space:]]|=|$)'; then
+    verdict "\`pg_restore --clean\` удаляет объекты базы перед загрузкой дампа (${context})."
+fi
+
+# Штатное применение миграций разрушительным не считается. Раньше здесь стоял безусловный
+# `ask` со словами «убедись, что DATABASE_URL указывает на локальную базу» — гард
+# перекладывал на человека ровно ту работу, которую умеет сделать сам. На локальной базе
+# миграции гоняются постоянно, и вопрос на каждую не добавляет безопасности: гард, который
+# спрашивает по десятому разу, перестают читать вместе с тем единственным вопросом, который
+# был важен.
+#
+# Поэтому адрес РАЗРЕШАЕТСЯ, а не угадывается: сначала inline-префикс самой команды, затем
+# переменная окружения, затем `.env` рабочего каталога.
+unquote() {
+    sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e 's/^"//' -e 's/"$//' -e "s/^'//" -e "s/'$//"
+}
+
+resolve_database_url() {
+    # Искать по `$flat` нельзя: он приведён к нижнему регистру, и `DATABASE_URL=` в нём
+    # не встречается никогда — правило молча брало бы адрес из `.env`, игнорируя явно
+    # указанный в команде. Разбирается исходная строка, а `$flat` остаётся запасным
+    # вариантом с регистронезависимым поиском.
+    inline="$(printf '%s' "${cmd:-}" | grep -oE '[Dd][Aa][Tt][Aa][Bb][Aa][Ss][Ee]_[Uu][Rr][Ll]=[^[:space:]]+' | tail -n1)"
+    [ -z "$inline" ] && inline="$(printf '%s' "$flat" | grep -oiE 'database_url=[^[:space:]]+' | tail -n1)"
+    if [ -n "$inline" ]; then
+        printf '%s' "${inline#*=}" | unquote
+        return
+    fi
+    if [ -n "${DATABASE_URL:-}" ]; then
+        printf '%s' "$DATABASE_URL" | unquote
+        return
+    fi
+    # Подъём по дереву, а не только рабочий каталог: агент работает в git worktree под
+    # `.claude/worktrees/<ветка>/`, где своего `.env` нет, а у основного чекаута — есть,
+    # и он лежит ровно выше по пути. Без подъёма гард не разрешил бы адрес ни разу
+    # именно там, где миграции и гоняются.
+    dir="$hook_cwd"
+    depth=0
+    while [ -n "$dir" ] && [ "$dir" != '/' ] && [ "$depth" -lt 8 ]; do
+        for env_file in "$dir/.env" "$dir/.env.local"; do
+            [ -f "$env_file" ] || continue
+            value="$(grep -m1 -E '^[[:space:]]*DATABASE_URL=' "$env_file" 2>/dev/null | sed -e 's/^[[:space:]]*DATABASE_URL=//' | unquote)"
+            if [ -n "$value" ]; then
+                printf '%s' "$value"
+                return
+            fi
+        done
+        dir="$(dirname "$dir")"
+        depth=$((depth + 1))
+    done
+}
+
+if printf '%s' "$flat" | grep -qE 'prisma[[:space:]]+migrate[[:space:]]+(deploy|dev)'; then
+    migrate_target="$(resolve_database_url)"
+    # Боевой адрес проверяется ДО разбора по видам: туннель к бою тоже висит на петлевом
+    # адресе, только на своём порту, и общее правило «петлевой значит локальный» пропустило бы
+    # миграцию на бой.
+    if [ -n "$PROD_DSN" ] && printf '%s' "$migrate_target" | grep -qE "$PROD_DSN"; then
+        deny "BLOCKED: применение миграций к БОЕВОЙ базе (${context}). Адрес базы ведёт на бой. Схема на бою меняется выкаткой: она сама зовёт применение миграций одноразовым контейнером до старта приложения. Руками этого делать нельзя — гард обойти нельзя."
+    fi
+    case "$migrate_target" in
+        *@localhost:*|*@127.0.0.1:*|*@postgres:*|*@host.docker.internal:*)
+            # Локальная база — штатная работа. Разбор завершается здесь, иначе ниже
+            # сработает общее правило про запись в базу и вопрос всё равно будет задан:
+            # `migrate deploy` помечен записью выше по тексту.
+            #
+            # Но выйти можно, только если запись в команде ОДНА — сама миграция. В цепочке
+            # `prisma migrate deploy && psql -c "delete …"` ранний выход снял бы проверку со
+            # второго звена, а это ровно тот обход, ради которого гард и написан.
+            other_write=""
+            printf '%s' "$write_scope" \
+                | grep -qE '(^|[^[:alnum:]_])(delete|update|insert|truncate|drop|alter|create|grant|revoke|copy)([^[:alnum:]_]|$)|\\copy|into[[:space:]]+[a-z_"]' \
+                && other_write="yes"
+            while IFS= read -r seg; do
+                [ -z "$seg" ] && continue
+                printf '%s' "$seg" | grep -qE '(^|[^[:alnum:]_.-])(cat|head|tail|gzcat|zcat|gunzip|echo|printf|curl|wget)([[:space:]]|$)' \
+                    && other_write="yes" && break
+            done <<MIGRATE_PIPE_EOF
+$(client_segments)
+MIGRATE_PIPE_EOF
+            [ -z "$other_write" ] && exit 0
+            ;;
+        '')
+            ask "Применение миграций к базе (${context}), но адрес разрешить не удалось: DATABASE_URL нет ни в команде, ни в окружении, ни в \`.env\` рабочего каталога. Проверь, куда пойдёт миграция, и подтверди."
+            ;;
+        *)
+            ask "Применение миграций по адресу, НЕИЗВЕСТНОМУ ГАРДУ (${context}). Гард знает локальные адреса и боевые; этот — ни то, ни другое. Убедись, что это не прод, и подтверди."
+            ;;
+    esac
+fi
+
+# --- delete/update: смотрим на адресацию ------------------------------------------------
+if printf '%s' "$flat" | grep -qE '(^|[^[:alnum:]_])(delete[[:space:]]+from|update)([^[:alnum:]_]|$)'; then
+    if ! printf '%s' "$flat" | grep -q 'where'; then
+        verdict "DELETE/UPDATE без WHERE затрагивает всю таблицу (${context})."
+    fi
+
+    # Адресация ищется ТОЛЬКО в хвосте после последнего `where`. Пока смотрели на весь
+    # запрос, присваивание в SET засчитывалось за адресацию: `UPDATE bookings SET
+    # "propertyId" = 'p1' WHERE source = 'site'` выглядел адресным, хотя задевал все прямые
+    # заявки объекта — ровно то, от чего гард и защищает.
+    # Регистр здесь сохраняется, в отличие от `flat`: колонки Prisma пишутся в camelCase, и
+    # приведённый к нижнему регистру `bookingid` уже не отличить от слова `paid`.
+    where_tail="$(printf '%s' "$sql" | tr '\n\t' '  ' | sed -E 's/.*[Ww][Hh][Ee][Rr][Ee]/where/')"
+
+    # Имя колонки требуется целиком: `id`, `booking_id`, `"bookingId"`. Прежний шаблон
+    # `[a-z_]*id` принимал за идентификатор `paid` и `valid`.
+    if ! printf '%s' "$where_tail" | grep -qE '(^|[^[:alnum:]_"])"?(id|[A-Za-z_]+_id|[a-zA-Z]+Id)"?[[:space:]]*(=|[Ii][Nn][[:space:]]*\()'; then
+        verdict "DELETE/UPDATE адресует строки не по идентификатору (${context}) — условие может совпасть шире, чем задумано."
+    fi
+
+    # Гард видит имя колонки, но не схему: `propertyId` и `session_id` — внешние ключи, и
+    # запрос по ним адресный только на вид. `DELETE … WHERE "propertyId" = 'p1'` сносит все
+    # брони объекта. Отличить это от первичного ключа без схемы нельзя, поэтому решение
+    # остаётся за пользователем — но предупреждение должно быть прямым, а не общим.
+    if ! printf '%s' "$where_tail" | grep -qE '(^|[^[:alnum:]_"])"?id"?[[:space:]]*(=|[Ii][Nn][[:space:]]*\()'; then
+        ask "Условие адресует строки по ВНЕШНЕМУ ключу, а не по первичному (${context}): $(printf '%s' "$where_tail" | head -c 200). Под него попадут ВСЕ строки, связанные с этой сущностью, — например \`WHERE \"propertyId\" = …\` заденет все брони объекта, включая демонстрационные. Если нужны конкретные строки, сперва выбери их SELECT-ом и перечисли в \`WHERE id IN (…)\`."
+    fi
+fi
+
+# --- остальная запись: решает пользователь ----------------------------------------------
+# Неизвестное подключение — не повод пропустить молча: адресат запроса не опознан, и им
+# может оказаться боевая база под другим идентификатором.
+if [ "$conn_known" = "" ] && [ -n "$conn" ]; then
+    ask "Запись в базу через ПОДКЛЮЧЕНИЕ, НЕИЗВЕСТНОЕ ГАРДУ (id ${conn}). Гард знает локальное подключение и боевое; это — ни то, ни другое, поэтому убедись, что запрос уходит не на прод. Если подключение постоянное, впиши его id в PROD_CONNECTIONS или LOCAL_CONNECTIONS в .claude/hooks/sql-guard.sh."
+fi
+
+ask "Запись в базу (${context}). Проверь, что затронуты только ожидаемые строки, и подтверди."