@rt-tools/agent-kit 0.23.0 → 0.24.0

package/assets/hooks/git-guard-delivery-draft.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# Снятие черновика для гарда поставки: есть ли у заявки разбор, не конфликтует ли она и той ли
+# записью открыта.
+#
+# Строки `# rt-hook:` здесь нет намеренно: событие и образец вызова объявляет сам гард, а
+# помощник рядом хуком не регистрируется и в одиночку ничего не решает. Он зовётся из гарда и
+# пользуется его же переменными — командой, корнем дерева, машинной записью — и его отказом.
+#
+# Вынесен он отсюда потому, что гард дорос до предела длины: снятие черновика среди его
+# предметов самое отдельное — своя точка проверки, свой сетевой ярус, свои три отказа.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
+
+rt_delivery_draft_ready() {
+    # --- снятие черновика --------------------------------------------------------------------
+    #
+    # Ревьювера до этой правки не спрашивал никто. Он стоял прозой в правиле, а хостинг запрос
+    # разбора на самого себя принимает молча и не создаёт: разбор при этом выглядит запрошенным.
+    # Раньше снятия черновика спросить негде — до открытия заявки ревьювера нет вовсе, — а само
+    # снятие и есть тот ход, которым работа объявляется готовой.
+    #
+    # Ярус сетевой, и молчит он так же, как ярус состояния задачи: нет ответа — нет требования.
+    #
+    # Возврат заявки в черновик под требование не подпадает: он делает ровно то, чего гард и
+    # добивается, — снимает с работы вид готовой.
+    if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+ready|glab[[:space:]]+mr[[:space:]]+update[^|;&]*--ready)([[:space:]]|\$)" \
+        && ! printf '%s' "$cmd" | grep -q -- '--undo'; then
+        # Ссылка на заявку необязательна: без неё клиент берёт заявку текущей ветки, и это самая
+        # короткая форма вызова. Требовать номер значило бы снимать всё требование одним пробелом.
+        # Поэтому берётся первый довод, каким бы он ни был — номер, адрес или имя ветки, — а его
+        # отсутствие означает «спроси про текущую ветку».
+        pull_ref="$(printf '%s' "$cmd" | sed -nE 's/.*(gh[[:space:]]+pr[[:space:]]+ready|glab[[:space:]]+mr[[:space:]]+update)[[:space:]]+([^[:space:];&|-][^[:space:];&|]*).*/\2/p' | head -1)"
+        if rt_needs rt_pull_state git-guard-delivery; then
+            pull="$(cd "$root" && rt_pull_state "$pull_ref" 2>/dev/null)" || pull=''
+            if [ -n "$pull" ] && printf '%s' "$pull" | jq -e '.exists' >/dev/null 2>&1; then
+                # Номер берётся из ответа, а если его там нет — из самой команды: заявка,
+                # названная адресом или именем ветки, в отказе должна остаться узнаваемой.
+                pull_name="$(printf '%s' "$pull" | jq -r '.number // empty' 2>/dev/null)"
+                # Номер пишется с решёткой, а имя ветки или адрес — в кавычках: решётка перед
+                # адресом читается как опечатка, а не как ссылка на заявку.
+                [ -z "$pull_name" ] && pull_name="$pull_ref"
+                case "$pull_name" in
+                    '') ;;
+                    *[!0-9]*) pull_name=" «${pull_name}»" ;;
+                    *) pull_name=" #${pull_name}" ;;
+                esac
+                printf '%s' "$pull" | jq -e '.reviewed' >/dev/null 2>&1 \
+                    || fault "у заявки${pull_name} нет разбора: ревьювер не запрошен и отзыва никто не оставлял. Снятый черновик читается как «можно вливать», а вливать некому — назначь ревьювера и повтори."
+
+                # Конфликт приезжает в отданную заявку чужим слиянием, без единого действия её
+                # автора: основание, проверенное на открытии, к моменту снятия черновика уже
+                # вчерашнее. Снятый черновик читается как «можно вливать», а вливать нечего —
+                # владелец открывает заявку и находит там конфликт. Молчание при неизвестной
+                # сливаемости остаётся: хостинг считает её заново после каждой правки главной ветки,
+                # и «ещё не посчитано» — не «конфликтует».
+                printf '%s' "$pull" | jq -e '.conflicting' >/dev/null 2>&1 \
+                    && fault "заявка${pull_name} конфликтует с главной веткой. Влей её в свою ветку, разбери конфликт и повтори: снятый черновик читается как «можно вливать», а слить эту заявку нельзя."
+
+                # Автор заявки. На открытии судить было нечем, кроме текста команды: личность вызова
+                # приходит окружением. Здесь она уже названа хостингом, и это последний ход, где
+                # промах ещё исправим — после снятия черновика заявку вливают, а переоткрыть влитую
+                # нельзя. Дерево, не назвавшее машинной записи, автора не судит.
+                if [ -n "$task_bot" ]; then
+                    pull_author="$(printf '%s' "$pull" | jq -r '.author // empty' 2>/dev/null)"
+                    [ -n "$pull_author" ] && [ "$pull_author" != "$task_bot" ] \
+                        && fault "заявку${pull_name} открыла запись «${pull_author}», а не машинная «${task_bot}». Автор заявки её ревьювером не бывает, и разбор ей назначить нечем. Автора не сменить — закрой заявку и открой заново${pull_token_hint:+, подставив токен: ${pull_token_hint} …}."
+                fi
+            fi
+        fi
+
+        # Папка задачи: тот же предмет, что на открытии и на слиянии, третьим рубежом. Условие
+        # местное — оно читает ветку, а не хостинг, — и потому стоит вне сетевого яруса выше.
+        command -v rt_delivery_ready_folder >/dev/null 2>&1 && rt_delivery_ready_folder
+
+        deny_faults
+    fi
+}

package/assets/hooks/git-guard-delivery.sh

@@ -122,15 +122,12 @@ tasks_dir="${RT_TASKS_DIR:-}"
 archive_dir="${RT_ARCHIVE_DIR:-}"
 main_branch="${RT_MAIN_BRANCH:-main}"
 
-# Обход требования: строка с причиной. Причина видна тому, кто вливает, поэтому обход законен.
-# Без причины это просто молчаливый пропуск, поэтому она обязательна. Порог в три знака — тот
-# же, что у гарда документа: если сделать по-разному, две формы одного обхода разойдутся.
+# Обход требования: строка с причиной. Причину видит тот, кто вливает, поэтому обход разрешён;
+# без причины это молчаливый пропуск. Порог в три знака — тот же, что у гарда документа.
 #
-# Строка обхода начинает строку — свою в теле PR или комментарий в конце команды — и
-# подстановки не принимает. Без этих двух условий текст, который ОБЪЯСНЯЕТ, что обход называется
-# так-то, от самого обхода неотличим: тело PR со строкой-примером снимало требование само
-# собой, и тот же пример гард печатает в своём отказе ниже. Нашлось это приёмкой такого же
-# признака — прогон обязан был покраснеть на настоящем нарушении и остался зелёным.
+# Строка обхода стоит в начале строки — своей в теле PR или комментария в конце команды — и
+# подстановки не принимает. Иначе текст, который объясняет, как называется обход, неотличим от
+# самого обхода: тело PR со строкой-примером снимало требование само.
 folder_skip_re='(^|#)[[:space:]]*Task-folder-skip:[[:space:]]*[^[:space:]<"'"'"'][^[:space:]"'"'"']{2,}'
 
 deny() {
@@ -234,18 +231,13 @@ if [ -n "$branch_arg" ]; then
             || deny "BLOCKED: имя ветки «${branch_arg}» не той формы, что принята здесь. Номер у ветки тот же, что у задачи и у заголовка заявки на слияние."
         check_task "$number_arg" "ветка «${branch_arg}»"
 
-        # Условия поставки, известные уже здесь, спрашиваются здесь. Прежде их спрашивали на
-        # пуше и на открытии PR — то есть после того, как работа сделана: основание чинится
-        # мержем с разбором конфликта, а подпись коммитов — переписыванием всей ветки. В
-        # начале работы обе стоят одну команду.
+        # Условия поставки, известные уже здесь, проверяются здесь. После того как работа
+        # сделана, основание чинится слиянием с разбором конфликта, а подпись коммитов —
+        # переписыванием ветки; в начале работы обе стоят одну команду.
         #
         # Основание: вершина главной ветки обязана лежать в том, от чего растёт новая ветка.
-        # Ветка, заведённая от вчерашнего основания, узнаёт об этом на открытии PR — и узнаёт
-        # так, что владелец видит её конфликтующей.
-        #
-        # Судится названное основание, а не вершина рабочей копии: команда, которой основание
-        # как раз и берут свежим — `git checkout -b <ветка> origin/<главная>`, — иначе
-        # отбивалась бы наравне с той, у которой основание вчерашнее.
+        # Проверяется названное основание, а не вершина рабочей копии: иначе команда, которой
+        # основание берут свежим — `git checkout -b <ветка> origin/<главная>`, — запрещалась бы.
         base_arg="$(printf '%s' "$cmd" | sed -nE 's/.*git[[:space:]]+(checkout[[:space:]]+-b|switch[[:space:]]+-c)[[:space:]]+[^[:space:];&|]+[[:space:]]+([^[:space:];&|-][^[:space:];&|]*).*/\2/p' | head -1)"
         base_ref="${base_arg:-HEAD}"
         if git rev-parse --verify --quiet "refs/remotes/origin/${main_branch}" >/dev/null 2>&1 \
@@ -289,68 +281,13 @@ fi
     && . "$rt_hooks_dir/git-guard-delivery-signature.sh" 2>/dev/null
 command -v rt_delivery_signature >/dev/null 2>&1 && rt_delivery_signature
 
-# --- снятие черновика --------------------------------------------------------------------
-#
-# Ревьювера до этой правки не спрашивал никто. Он стоял прозой в правиле, а хостинг запрос
-# разбора на самого себя принимает молча и не создаёт: разбор при этом выглядит запрошенным.
-# Раньше снятия черновика спросить негде — до открытия заявки ревьювера нет вовсе, — а само
-# снятие и есть тот ход, которым работа объявляется готовой.
-#
-# Ярус сетевой, и молчит он так же, как ярус состояния задачи: нет ответа — нет требования.
-#
-# Возврат заявки в черновик под требование не подпадает: он делает ровно то, чего гард и
-# добивается, — снимает с работы вид готовой.
-if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+ready|glab[[:space:]]+mr[[:space:]]+update[^|;&]*--ready)([[:space:]]|\$)" \
-    && ! printf '%s' "$cmd" | grep -q -- '--undo'; then
-    # Ссылка на заявку необязательна: без неё клиент берёт заявку текущей ветки, и это самая
-    # короткая форма вызова. Требовать номер значило бы снимать всё требование одним пробелом.
-    # Поэтому берётся первый довод, каким бы он ни был — номер, адрес или имя ветки, — а его
-    # отсутствие означает «спроси про текущую ветку».
-    pull_ref="$(printf '%s' "$cmd" | sed -nE 's/.*(gh[[:space:]]+pr[[:space:]]+ready|glab[[:space:]]+mr[[:space:]]+update)[[:space:]]+([^[:space:];&|-][^[:space:];&|]*).*/\2/p' | head -1)"
-    if rt_needs rt_pull_state git-guard-delivery; then
-        pull="$(cd "$root" && rt_pull_state "$pull_ref" 2>/dev/null)" || pull=''
-        if [ -n "$pull" ] && printf '%s' "$pull" | jq -e '.exists' >/dev/null 2>&1; then
-            # Номер берётся из ответа, а если его там нет — из самой команды: заявка,
-            # названная адресом или именем ветки, в отказе должна остаться узнаваемой.
-            pull_name="$(printf '%s' "$pull" | jq -r '.number // empty' 2>/dev/null)"
-            # Номер пишется с решёткой, а имя ветки или адрес — в кавычках: решётка перед
-            # адресом читается как опечатка, а не как ссылка на заявку.
-            [ -z "$pull_name" ] && pull_name="$pull_ref"
-            case "$pull_name" in
-                '') ;;
-                *[!0-9]*) pull_name=" «${pull_name}»" ;;
-                *) pull_name=" #${pull_name}" ;;
-            esac
-            printf '%s' "$pull" | jq -e '.reviewed' >/dev/null 2>&1 \
-                || fault "у заявки${pull_name} нет разбора: ревьювер не запрошен и отзыва никто не оставлял. Снятый черновик читается как «можно вливать», а вливать некому — назначь ревьювера и повтори."
-
-            # Конфликт приезжает в отданную заявку чужим слиянием, без единого действия её
-            # автора: основание, проверенное на открытии, к моменту снятия черновика уже
-            # вчерашнее. Снятый черновик читается как «можно вливать», а вливать нечего —
-            # владелец открывает заявку и находит там конфликт. Молчание при неизвестной
-            # сливаемости остаётся: хостинг считает её заново после каждой правки главной ветки,
-            # и «ещё не посчитано» — не «конфликтует».
-            printf '%s' "$pull" | jq -e '.conflicting' >/dev/null 2>&1 \
-                && fault "заявка${pull_name} конфликтует с главной веткой. Влей её в свою ветку, разбери конфликт и повтори: снятый черновик читается как «можно вливать», а слить эту заявку нельзя."
-
-            # Автор заявки. На открытии судить было нечем, кроме текста команды: личность вызова
-            # приходит окружением. Здесь она уже названа хостингом, и это последний ход, где
-            # промах ещё исправим — после снятия черновика заявку вливают, а переоткрыть влитую
-            # нельзя. Дерево, не назвавшее машинной записи, автора не судит.
-            if [ -n "$task_bot" ]; then
-                pull_author="$(printf '%s' "$pull" | jq -r '.author // empty' 2>/dev/null)"
-                [ -n "$pull_author" ] && [ "$pull_author" != "$task_bot" ] \
-                    && fault "заявку${pull_name} открыла запись «${pull_author}», а не машинная «${task_bot}». Автор заявки её ревьювером не бывает, и разбор ей назначить нечем. Автора не сменить — закрой заявку и открой заново${pull_token_hint:+, подставив токен: ${pull_token_hint} …}."
-            fi
-        fi
-    fi
-
-    # Папка задачи: тот же предмет, что на открытии и на слиянии, третьим рубежом. Условие
-    # местное — оно читает ветку, а не хостинг, — и потому стоит вне сетевого яруса выше.
-    command -v rt_delivery_ready_folder >/dev/null 2>&1 && rt_delivery_ready_folder
-
-    deny_faults
-fi
+# --- снятие черновика ----------------------------------------------------------------------
+# Предмет живёт помощником рядом — `git-guard-delivery-draft.sh`, тем же приёмом, что и подпись.
+# Нет помощника — снятие черновика не судится, а работа идёт дальше.
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/git-guard-delivery-draft.sh" ] \
+    && . "$rt_hooks_dir/git-guard-delivery-draft.sh" 2>/dev/null
+command -v rt_delivery_draft_ready >/dev/null 2>&1 && rt_delivery_draft_ready
 
 # --- слияние заявки ----------------------------------------------------------------------
 #
@@ -404,17 +341,13 @@ if [ -n "$title" ]; then
     fi
 fi
 
-# Главная ветка влита до открытия PR. PR от разошедшейся ветки показывает ревьюверу свою
-# правку вперемешку с чужой, а проверки на нём гоняются от устаревшего основания.
-#
-# Ярусов два, и порядок между ними такой же, как у проверки задачи. Первый читает локальную
-# вершину и работает без сети. Второй спрашивает удалённую ссылку — без него молчание гарда
-# значит лишь «твоя ссылка не старше твоей ветки», а читается как «главная ветка влита»: ровно
-# так открытый PR и оказался конфликтующим, и узнал об этом владелец.
+# Главная ветка влита до открытия PR: иначе ревьювер видит чужую правку вперемешку со своей, а
+# проверки идут от устаревшего основания.
 #
-# Сеть здесь допустима по той же причине, по которой её зовёт проверка очереди работ ниже:
-# отсутствие ответа пропускается молча, и проверка, падающая в самолёте, не отбивает работу.
-# Предел ожидания задаётся переменными самого git — внешний `timeout` есть не на всякой машине.
+# Ярусов два. Первый читает локальную вершину и работает без сети. Второй спрашивает удалённую
+# ссылку: без него молчание значит лишь «локальная ссылка не старше ветки», а читается как
+# «главная влита». Нет ответа сети — пропуск молча; предел ожидания задаётся переменными git,
+# внешний `timeout` есть не на всякой машине.
 if git rev-parse --verify --quiet "refs/remotes/origin/${main_branch}" >/dev/null 2>&1 \
     && ! git merge-base --is-ancestor "origin/${main_branch}" HEAD 2>/dev/null; then
     behind="$(git rev-list --count "HEAD..origin/${main_branch}" 2>/dev/null)"
@@ -438,27 +371,36 @@ if [ -n "$remote_main" ] && [ -n "$local_main" ] && [ "$remote_main" != "$local_
     fault "твоя ссылка origin/${main_branch} отстала от удалённой — ${local_main:0:8} против ${remote_main:0:8}.${age} Гард сравнивает ветку с тем, что лежит в дереве, поэтому молчание первого яруса значит «ссылка не старше ветки», а не «главная ветка влита». Влей и повтори: git fetch origin && git merge origin/${main_branch}."
 fi
 
-# Личность вызова. Клиент хостинга держит две записи сразу — залогиненную и ту, чей токен стоит
-# в окружении вызова, — и какая из них откроет заявку, из текста команды не видно ничем, кроме
-# явной подстановки. Читающие вызовы идут от залогиненной и работают, поэтому пишущий выглядит
-# таким же обычным; промах всплывает шагом позже, на назначении ревьювера: автор заявки её
-# ревьювером не бывает. Чинится это только переоткрытием — автора у заявки не сменить.
+# Личность вызова. Клиент хостинга держит две записи — залогиненную и ту, чей токен стоит в
+# окружении вызова; какая откроет заявку, из команды видно только по явной подстановке. Промах
+# всплывает на назначении ревьювера: автор заявки её ревьювером не бывает, а автора не сменить.
 #
-# Судится текст команды, а не ответ хостинга: спросить, чьим токеном пойдёт вызов, до его
-# исполнения нельзя. Дерево, не назвавшее переменной токена, требования не получает.
+# Проверяется текст команды. Дерево, не назвавшее переменной токена, требования не получает.
 if [ -n "$pull_token_var" ] \
     && ! printf '%s' "$cmd" | grep -qE "(^|[;&|(]|&&|\|\||[[:space:]])${pull_token_var}="; then
     fault "заявка открывается без токена машинной записи: в команде нет подстановки «${pull_token_var}». Открытая залогиненной записью, она выйдет от владельца — ревьювером его тогда не назначить, и чинится это только переоткрытием.${pull_token_hint:+ Подставь токен: ${pull_token_hint} …}"
 fi
 
-# Тело заявки несёт раздел об оставшемся шаге, и несёт его с минуты открытия. Требование
-# записано было и прежде — прозой в паттерне закрытия работы, ниже того места, где описано само
-# открытие: читающий доходил до открытия, открывал и раздела ещё не прочитал. Так заявка и
-# уехала без него, а владелец влил её кнопкой, пока шёл прогон.
+# Второй ярус той же личности: кто на самом деле придёт по этому токену. Подстановка говорит
+# о намерении, а не о результате: она читала файл, которого на машине нет, пустую строку клиент
+# принял за незаданный токен, и заявка вышла от владельца при верной с виду команде.
 #
-# Судится текст команды: тело приходит доводом либо файлом, и оба вида читаются здесь же. Файл
-# читается с диска — к моменту разбора он уже написан. Ни того ни другого в команде нет —
-# требования нет: заявка без тела вовсе судится строкой выше, а не этой.
+# У хостинга спрашивает дерево, а не пакет: хостинг, клиент и путь к токену у каждого свои.
+# Пустой ответ означает «спросить не удалось»: вызов пропускается, и об этом сообщается —
+# молчаливый пропуск неотличим от сошедшейся сверки.
+if [ -n "$task_bot" ] && command -v rt_pull_token_login >/dev/null 2>&1; then
+    token_login="$(rt_pull_token_login 2>/dev/null)"
+    if [ -z "$token_login" ]; then
+        printf 'гард поставки: кто придёт по токену, спросить не удалось — сверка по ответу хостинга пропущена.\n' >&2
+    elif [ "$token_login" != "$task_bot" ]; then
+        fault "по токену вызова хостинг отвечает записью «${token_login}», а не машинной «${task_bot}»: подстановка в команде есть, но значение пустое или чужое — так заявка выходит от владельца. Проверь, что файл токена на месте и читается${pull_token_hint:+: ${pull_token_hint}}."
+    fi
+fi
+
+# Тело заявки несёт раздел об оставшемся шаге с минуты открытия: без него владелец вливает
+# заявку кнопкой, пока идёт прогон. Тело приходит доводом либо файлом, оба читаются здесь; файл
+# к моменту разбора уже написан. Нет ни того ни другого — требования нет: заявка без тела
+# проверяется строкой выше.
 if [ -n "$pull_body_section" ]; then
     body=''
     if command -v perl >/dev/null 2>&1; then
@@ -482,13 +424,9 @@ fi
 
 check_task "$number" "заявка с ветки «${branch}»" да
 
-# Папка задачи разбирается до открытия заявки, а не после одобрения. Прежде здесь стояло
-# напоминание, а требование — на слиянии: считалось, что папка нужна на диске всё время
-# разбора, потому что правку по замечаниям без замысла отбивает гард хода работы. Владелец же
-# вливает, как только видит зелёное, и закрывающему коммиту места не остаётся — трижды подряд
-# папка уехала в главную неразобранной, а гард слияния этого не видел вовсе: кнопку нажимает
-# человек на хостинге, и до него гард не достаёт. Разбор переехал сюда, а замысел после уборки
-# гард хода работы берёт из истории ветки, а не с диска.
+# Папка задачи разбирается до открытия заявки, а не после одобрения: владелец вливает, как
+# только видит зелёное, и закрывающему коммиту места не остаётся — трижды подряд папка уехала в
+# главную неразобранной. Замысел после уборки гард хода работы берёт из истории ветки.
 rt_delivery_open_folder
 
 # Всё несошедшееся названо здесь, разом: до этой строки собирались условия, каждое из которых

package/assets/hooks/git-guard-main.sh

@@ -44,10 +44,45 @@ if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&
     ' 2>/dev/null)"
     [ -n "$inner" ] && cmd="$inner"
 fi
-case "$cmd" in
-    *git\ commit*) ;;
-    *) exit 0 ;;
-esac
+# Глагол ищется в позиции команды, а не подстрокой в строке.
+#
+# Голый поиск «git commit» промахивается в обе стороны. Мимо него уходит вызов, у которого между
+# `git` и глаголом стоит ключ — `git -c user.name=… commit`, `git -C <дерево> commit`, — и ровно
+# так коммитят машинной учётной записью. В него же попадает строка, где эти два слова стоят
+# рядом по другому поводу: `git log --grep 'git commit'`, разбор чужого вывода, текст сообщения.
+# Отбой на чтении истории стоит дороже пропуска: гард, мешающий читать, выключают в первый день.
+#
+# Разбор простой: у каждого слова `git` в строке пропускаются ключи — сами по себе и вместе со
+# значением, если ключ его берёт, — и первое слово без дефиса и есть глагол. Слов `git` в строке
+# бывает несколько (`git add . && git commit`), поэтому печатаются глаголы всех, а судится
+# список целиком.
+if command -v awk >/dev/null 2>&1; then
+    verbs="$(printf '%s\n' "$cmd" | awk '
+        {
+            for (i = 1; i <= NF; i++) {
+                word = $i
+                sub(/^.*\//, "", word)
+                if (word != "git") continue
+                for (j = i + 1; j <= NF; j++) {
+                    arg = $j
+                    if (arg == "-c" || arg == "-C" || arg == "--git-dir" || arg == "--work-tree" \
+                        || arg == "--namespace" || arg == "--exec-path") { j++; continue }
+                    if (substr(arg, 1, 1) == "-") continue
+                    print arg
+                    break
+                }
+            }
+        }
+    ' 2>/dev/null)"
+    printf '%s\n' "$verbs" | grep -qx 'commit' || exit 0
+else
+    # Разборщика нет — остаётся прежний признак: он врёт в обе стороны, но гард без него не
+    # судит вовсе.
+    case "$cmd" in
+        *git\ commit*) ;;
+        *) exit 0 ;;
+    esac
+fi
 
 # Коммит выполнится в рабочем каталоге вызова, поэтому и ветку смотрим там же; корень проекта
 # — запасной вариант, и он важен для отдельного рабочего дерева, где ветка своя.

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

@@ -114,7 +114,30 @@ done
 # shellcheck disable=SC1090
 [ -f "$rt_hooks_dir/profile-check.sh" ] && . "$rt_hooks_dir/profile-check.sh"
 command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2>&1; }
-rt_needs rt_push_checks git-guard-push-tests || exit 0
+
+# Строка наблюдения на каждый исход. Гард, пишущий только отбои, отвечает на один вопрос из
+# трёх: сколько пушей он остановил. «Набор прогнан и зелёный» и «набора не нашлось» выглядят в
+# записи одинаково — молчанием, — и гейт, не гонявший ни одной проверки за неделю, неотличим от
+# гейта, у которого всё зелено. Пишется это той же записью наблюдений, что и отбои гардов, и
+# гаснет тем же выключателем дерева.
+rt_push_gate_note() {
+    local outcome="$1" sid
+    # shellcheck disable=SC1090
+    [ -f "$rt_hooks_dir/observe.sh" ] && . "$rt_hooks_dir/observe.sh" 2>/dev/null
+    command -v rt_note >/dev/null 2>&1 || return 0
+    sid="$(printf '%s' "$input" | jq -r '.session_id // empty' 2>/dev/null)"
+    if [ -n "$sid" ]; then
+        rt_note push-gate "res=$outcome" "sid=$sid"
+    else
+        rt_note push-gate "res=$outcome"
+    fi
+    return 0
+}
+
+if ! rt_needs rt_push_checks git-guard-push-tests; then
+    rt_push_gate_note no-checks
+    exit 0
+fi
 
 main_branch="${RT_MAIN_BRANCH:-main}"
 base=''
@@ -131,8 +154,10 @@ rt_skip_code="${RT_SKIP_CODE:-7}"
 failed=""
 output=""
 skipped=""
+ran=0
 while IFS= read -r check; do
     [ -z "$check" ] && continue
+    ran=$((ran + 1))
     out="$(eval "$check" 2>&1)"
     status=$?
     [ "$status" -eq 0 ] && continue
@@ -150,6 +175,13 @@ EOF
 
 # Пропущенное называется вслух и тогда, когда набор прошёл: молчание о нём и есть та самая
 # неотличимость, ради которой код заведён. Пуш при этом идёт — отказа здесь нет.
+# Функция профиля есть, а печатать ей в этом дереве нечего: исход тот же, что и без неё, —
+# набора не нашлось, и молчание о нём читалось бы как зелёный прогон.
+if [ "$ran" -eq 0 ]; then
+    rt_push_gate_note no-checks
+    exit 0
+fi
+
 if [ -z "$failed" ] && [ -n "$skipped" ]; then
     printf 'гейт пуша: набор прошёл, но эти проверки смотреть было не на что:\n%s\n' "$skipped" >&2
 fi
@@ -176,11 +208,25 @@ if [ ! -f "$gap_mark" ]; then
     : >"$gap_mark" 2>/dev/null || true
 fi
 
-[ -z "$failed" ] && exit 0
+if [ -z "$failed" ]; then
+    rt_push_gate_note green
+    exit 0
+fi
+
+rt_push_gate_note red
 
 # Хвост вывода, а не весь: у прогонщика он длинный, а нужна причина отказа.
 tail_out="$(printf '%s' "$output" | tail -n 40 | tr -d '\000')"
-reason="BLOCKED: пуш без зелёного локального прогона. «${failed}» упала — почини и пушь снова, обходить гард нельзя. Пуш — вход в конвейер, и красное отсюда проверяется уже на проде. Хвост вывода:
+# Красное бывает двух родов, и гард их не различает: он проверяет только код возврата. Когда
+# падает проверка кода, «почини и пушь снова» верно. Когда ошибается сама проверка, тот же текст
+# велит чинить код, которого никто не трогал: разобранный однажды отказ целиком лежал в
+# документах, не тронутых ни одним коммитом ветки. Закон о проверяемости говорит, что сломанная
+# проверка работу не останавливает, и до этой строки такого варианта в отказе не было.
+reason="BLOCKED: пуш без зелёного локального прогона. «${failed}» упала — почини и пушь снова, обходить гард нельзя. Пуш — вход в конвейер, и красное отсюда проверяется уже на проде.
+
+Ходов отсюда три: починить названное и повторить вызов; починить саму проверку, если ошибается она, — разобрать отказы поимённо, показать разбор владельцу и поправить проверку; либо принести владельцу цену обхода и ждать его слова. Спорное в список известного не вносится: он хранит принятое, а не результаты сломанной проверки.
+
+Хвост вывода:
 
 ${tail_out}"
 

package/assets/hooks/hook-input.sh

@@ -58,17 +58,28 @@ rt_hook_field() {
 # прошли мимо своих гардов пуш, открытие заявки, снятие черновика и слияние: коммит с чужой
 # подписью уехал в главную ветку, а запрет на слияние агентом снимался подстановкой токена.
 #
-# Значение присваивания берётся без пробелов: `ИМЯ="a b"` в кавычках сюда не подпадает, и вызов
-# за ним останется несудимым. Пробел внутри значения перед вызовом встречается редко, а
-# образец, разбирающий кавычки, ошибается в другую сторону — считает вызовом то, что им не
-# является. Признак обязан ошибаться в сторону лишнего срабатывания: гард, не узнавший вызов,
-# молчит и выглядит исправным, а сработавший на лишнем виден сразу и правится.
+# Значение присваивания бывает трёх видов: без пробелов, подстановкой `$( … )` и в кавычках.
+# Раньше принимался только первый, а заявки открывают командой `GH_TOKEN=$(cat <файл>) gh pr
+# create …` — путь в подстановке содержит пробел, и гард поставки такую команду не проверял:
+# ни номер ветки, ни тело заявки, ни разбор папки задачи. Молчание гарда неотличимо от
+# разрешения.
+#
+# Подстановка берётся до первой закрывающей скобки, строка в кавычках — до закрывающей кавычки
+# того же вида. Вложенные скобки и кавычки образец не разбирает: признак остаётся образцом, а не
+# разборщиком оболочки. Ошибаться признак должен в сторону лишнего срабатывания: гард, не
+# распознавший вызов, молчит и выглядит исправным; сработавший лишний раз виден сразу и правится.
 #
 # Само по себе присваивание вызовом не считается: за ним обязано стоять имя команды.
 #
+# Каталог перед именем — та же команда. Клиент, у которого своё имя занято псевдонимом оболочки,
+# зовут полным путём, и признак, знавший только голое имя, такой вызов не узнавал вовсе: гард
+# выходил нулём, а молчание его неотличимо от разрешения. Так заявки и уехали открытыми не
+# машинной записью. Часть пути не переходит через пробел, поэтому она остаётся внутри одного
+# слова и лишнего к вызову не приклеивает.
+#
 # Объявлено это одним местом, а не литералом в каждом гарде: разойдясь, копии чинятся по одной
 # и молчат о том, что остальные остались слепыми.
-RT_CMD_BOUND='(^|[;&|(]|&&|\|\|)[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*'
+RT_CMD_BOUND='(^|[;&|(]|&&|\|\|)[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=([^[:space:]]*|\$\([^)]*\)|"[^"]*"|'"'"'[^'"'"']*'"'"')[[:space:]]+)*([^[:space:]]*/)?'
 
 # Поля, которые спрашивают все гарды.
 rt_hook_tool() { rt_hook_field RT_HOOK_TOOL '.tool_name'; }

package/assets/hooks/rule-source-guard.sh

@@ -107,6 +107,17 @@ while IFS= read -r candidate; do
     resource="$(head -12 "$candidate" 2>/dev/null | sed -nE 's/.*rt-kit v[^ ]+ · ([^ ]+) · [0-9a-f]+.*/\1/p' | head -1)"
     [ -z "$resource" ] && continue
 
+    # Файл в конфликте пропускается наравне со снятым. Разрешение конфликта содержания копии не
+    # меняет — раскладка кладёт её заново, — а отбитый здесь исполнитель остаётся с наполовину
+    # слитой веткой и без законного хода: источник править нечего, надстройка конфликта не
+    # снимает. Признаков два, и хватает любого: запись индекса о неслитом файле и маркеры
+    # слияния в самом файле — второй нужен там, где слияние ведёт не git, а сторонний
+    # инструмент, оставляющий маркеры без записи в индексе.
+    if [ -n "$(git -C "$root" ls-files -u -- "$candidate" 2>/dev/null)" ] \
+        || grep -qE '^(<<<<<<< |>>>>>>> )' "$candidate" 2>/dev/null; then
+        continue
+    fi
+
     if [ -n "$sources" ] && [ -f "$root/$sources/$resource" ]; then
         deny "BLOCKED by rule-source-guard: «${candidate#"$root"/}» разложен пакетом, и правка на его месте теряется на следующей раскладке — а до тех пор раскладка отказывает по этому файлу целиком, и цену платит тот, кто в этот день правит соседний ресурс. Ресурс — «${resource}». Правь источник: ${sources}/${resource} — потом собери пакет и разложи." \
             "правка, верная только этому дереву, идёт в надстройку .claude/rt-kit/overrides/${resource} — она сливается по разделу «## » и раскладку переживает"