@rt-tools/agent-kit 0.8.3 → 0.9.1

package/assets/checks/spec-scenarios.mjs

@@ -0,0 +1,201 @@
+/**
+ * Сценарии домена и уровень их привязки: что сценарий обещает, каким тестом это покрыто и не
+ * выключен ли тест переменной окружения.
+ */
+import {
+    ACTOR,
+    E2E_ROOTS,
+    PARTIAL,
+    PERCEIVES,
+    PROMISE,
+    SCENARIO_HEADING,
+    SCENARIO_REFERENCE,
+    TEST_ROOTS,
+    UNCOVERED,
+    read,
+    walk,
+} from './spec-common.mjs';
+
+// ── 4. Сценарии и уровень привязки ────────────────────────────────────────────
+
+function parseScenarios(file) {
+    const lines = read(file).split('\n');
+    const scenarios = [];
+    let current = null;
+    let inPromise = false;
+
+    lines.forEach((line, index) => {
+        const heading = SCENARIO_HEADING.exec(line);
+        if (heading) {
+            current = {
+                id: heading[1],
+                prefix: heading[2],
+                title: heading[4],
+                file,
+                line: index + 1,
+                uncovered: false,
+                partial: false,
+                promise: '',
+            };
+            inPromise = false;
+            scenarios.push(current);
+
+            return;
+        }
+        if (/^#{1,6}\s/.test(line)) {
+            current = null;
+
+            return;
+        }
+        if (!current) {
+            return;
+        }
+        if (UNCOVERED.test(line)) {
+            current.uncovered = true;
+        }
+        if (PARTIAL.test(line)) {
+            current.partial = true;
+        }
+        // «Тогда» и его продолжения с отступом — то, что сценарий обещает
+        if (PROMISE.test(line)) {
+            inPromise = true;
+            current.promise += ` ${line.trim()}`;
+
+            return;
+        }
+        if (inPromise && /^\s+\S/.test(line)) {
+            current.promise += ` ${line.trim()}`;
+
+            return;
+        }
+        inPromise = false;
+    });
+
+    return scenarios;
+}
+
+/**
+ * Обещан ли сценарием экран. Признак читается только из «Тогда»: «Дано» описывает
+ * обстановку, «Когда» — повод, а обещание пользователю стоит именно здесь.
+ *
+ * Человек и глагол восприятия требуются вместе, потому что порознь оба ошибаются.
+ * «Показывается» без человека стоит и там, где показывается запись в базе, а человек без
+ * восприятия — в каждом втором сценарии приёма заявки. Признак нарочно молчалив: сценарий,
+ * чьё «Тогда» человека не называет, под него не подпадает вовсе.
+ */
+function promisesScreen(promise) {
+    return ACTOR.test(promise) && PERCEIVES.test(promise);
+}
+
+/**
+ * Константы, собранные из окружения, вместе с теми, что собраны из них. Ими выключают
+ * сквозной тест целиком: без `BASE_URL` или пары входа он не исполняется ни разу.
+ * Цепочка раскрывается, пока есть что раскрывать: `HAS_ADMIN_SESSION` собран из двух
+ * других констант, а не из `process.env` напрямую.
+ */
+function environmentSwitches(root) {
+    // Объявление верхнего уровня: с отступом стоят локальные, и они гасят не тест, а случай
+    const declaration = /^const\s+([A-Za-z_]\w*)\s*(?::[^=]+)?=\s*([^;]+);/gm;
+    const assignments = [];
+    for (const file of walk(root, (name) => name.endsWith('.ts'))) {
+        for (const [, name, value] of read(file).matchAll(declaration)) {
+            assignments.push({ name, value });
+        }
+    }
+
+    const switches = new Set();
+    for (let pass = 0; pass <= assignments.length; pass += 1) {
+        const before = switches.size;
+        for (const { name, value } of assignments) {
+            if (value.includes('process.env') || [...switches].some((known) => new RegExp(`\\b${known}\\b`).test(value))) {
+                switches.add(name);
+            }
+        }
+        if (switches.size === before) {
+            break;
+        }
+    }
+
+    return switches;
+}
+
+/**
+ * Упоминания сценария в тестах: где стоит, идёт ли тест путём пользователя и не выключен ли
+ * он переменной окружения.
+ *
+ * Выключатель по состоянию стенда («у объекта меньше двух помещений») — это пропуск случая,
+ * и покрытие он не отменяет. Выключатель по переменной отменяет: тест с ним в обычном
+ * прогоне значится пропущенным, а сводка без этого читала бы его покрытием.
+ */
+function collectReferences() {
+    const references = new Map();
+    const remember = (id, place) => {
+        if (!references.has(id)) {
+            references.set(id, []);
+        }
+        references.get(id).push(place);
+    };
+    const switchesByRoot = new Map();
+
+    for (const root of TEST_ROOTS) {
+        for (const file of walk(root, (name) => name.endsWith('.spec.ts'))) {
+            const e2eRoot = E2E_ROOTS.find((dir) => file.startsWith(`${dir}/`));
+            if (e2eRoot && !switchesByRoot.has(e2eRoot)) {
+                switchesByRoot.set(e2eRoot, environmentSwitches(e2eRoot));
+            }
+            const switches = switchesByRoot.get(e2eRoot) ?? new Set();
+            const switched = (line) =>
+                [...line.matchAll(/test\.skip\(([^,]*)/g)].some(
+                    ([, condition]) =>
+                        condition.includes('process.env') || [...switches].some((name) => new RegExp(`\\b${name}\\b`).test(condition))
+                );
+
+            const found = [];
+            let test = null;
+            let describeSwitched = false;
+
+            read(file)
+                .split('\n')
+                .forEach((line, index) => {
+                    if (/^\s*test\.describe[.(]/.test(line)) {
+                        describeSwitched = false;
+                        test = null;
+                    } else if (/^\s*test\s*\(/.test(line)) {
+                        test = { off: describeSwitched };
+                    } else if (/test\.skip\(/.test(line)) {
+                        if (test) {
+                            test.off = test.off || switched(line);
+                        } else {
+                            describeSwitched = describeSwitched || switched(line);
+                        }
+                    }
+
+                    for (const [id] of line.matchAll(SCENARIO_REFERENCE)) {
+                        found.push({ id, test, place: `${file}:${index + 1}` });
+                    }
+                });
+
+            // Выключатель стоит первой строкой тела, то есть ниже заголовка теста с
+            // идентификатором: состояние теста читается, когда файл разобран целиком
+            found.forEach(({ id, test: own, place }) => remember(id, { place, screen: Boolean(e2eRoot), off: Boolean(own?.off) }));
+        }
+
+        // Наборы сценариев на shell. Так проверяются исполняемые файлы — гарды, проверки,
+        // умолчания: они не на TypeScript, и набор к ним пишут на том же языке, что и их
+        // самих. Выключателей здесь нет: пропустить сценарий в таком наборе нечем, поэтому
+        // достаточно найти идентификатор.
+        for (const file of walk(root, (name) => name.endsWith('.test.sh'))) {
+            read(file)
+                .split('\n')
+                .forEach((line, index) => {
+                    for (const [id] of line.matchAll(SCENARIO_REFERENCE)) {
+                        remember(id, { place: `${file}:${index + 1}`, screen: false, off: false });
+                    }
+                });
+        }
+    }
+
+    return references;
+}
+
+export { collectReferences, parseScenarios, promisesScreen };

package/assets/defaults/project.sh

@@ -43,9 +43,17 @@ RT_HOOKS_TESTS="${RT_HOOKS_TESTS:-.claude/hooks/tests/run.sh}"
 # Заведённая проверка встаёт сюда, а не только в общий прогон, который никто не зовёт сам:
 # новая строка в её списке известного уезжает в главную ветку молча, а список при этом читается
 # как действующая охрана.
+#
+# Сверка раскладки идёт первой строкой и по двум причинам. Она стоит секунды, поэтому отбивает
+# раньше, чем начнётся долгий прогон. И до неё расхождение разложенного с пакетом не отбивало
+# ничего: правка, положенная в разложенную копию мимо источника, ничего не ломает в день, когда
+# её делают, а всплывает на чужой работе — раскладка отказывает по правленому файлу целиком и не
+# кладёт ни одного другого. Признак — сама настройка раскладки: дерево без неё пакета не ставит,
+# и звать в нём нечего.
 rt_push_checks_default() {
     runner="$(rt_runner)"
     root="${CLAUDE_PROJECT_DIR:-.}"
+    [ -f "$root/.claude/rt-kit.json" ] && printf '%s\n' "$runner agent-kit sync --check"
     if [ -n "$1" ]; then
         printf '%s\n' "$runner nx affected -t lint test build --base=$1"
     else

package/assets/hooks/git-guard-push-tests.sh

@@ -36,10 +36,14 @@ case "$tool" in
 esac
 
 cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
-case "$cmd" in
-    *git\ push*) ;;
-    *) exit 0 ;;
-esac
+
+# Вызов пуша узнаётся по двум признакам сразу — команда `git` в начале строки или за
+# разделителем и слово `push` отдельным словом. Тем же приёмом, что у гарда поставки: одной
+# подстрокой «git push» пуш не поймать — помощник учётных данных и заголовок запроса ставятся
+# ключами `-c` между ними, и ровно этой формой здесь и пушат. Пока признаком была подстрока,
+# весь набор гейта на таком пуше не гонялся вовсе, а молчание гарда читалось как «зелено».
+printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git([[:space:]]|$)' || exit 0
+printf '%s' "$cmd" | grep -qE '(^|[[:space:]])push([[:space:]]|$)' || exit 0
 
 # Пробный пуш ничего не отправляет: гонять ради него весь набор незачем.
 case "$cmd" in

package/assets/hooks/skill-gate.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
+# 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
+}