@rt-tools/agent-kit 0.22.0 → 0.24.0

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

@@ -25,6 +25,7 @@
 #
 # Что здесь чем зовётся, знает профиль дерева:
 #   rt_task_branch_ok    — форма имени ветки под задачу;
+#   rt_task_branch_number — номер задачи из этого имени: приставкой бывает и род правки;
 #   RT_TASK_TITLE_RE     — форма номера в заголовке заявки;
 #   rt_task_state        — состояние задачи одним объектом (existsize, open, onBoard, assigned,
 #                          numbered); молчание значит «спросить некого»;
@@ -95,6 +96,7 @@ done
 [ -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_task_branch_ok git-guard-delivery || exit 0
+rt_needs rt_task_branch_number git-guard-delivery || exit 0
 
 title_re="${RT_TASK_TITLE_RE:-^\[[A-Za-z]+-[0-9]+\][[:space:]]+[^[:space:]]}"
 task_new="${RT_TASK_NEW_CMD:-npm run task:new}"
@@ -120,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() {
@@ -146,10 +145,9 @@ deny() {
     exit 0
 }
 
-# Несошедшиеся условия копятся и называются разом. Отказ по первому промаху заставляет чинить
-# их по одному: исполнитель правит основание, повторяет вызов, упирается в заголовок, правит
-# заголовок, упирается в задачу — и цена отказа растёт на каждом круге, хотя всё несошедшееся
-# было известно уже на первом. Готовность к поставке — одно состояние, и называется оно целиком.
+# Несошедшиеся условия копятся и называются разом: отказ по первому промаху заставляет чинить их
+# по одному — правка основания, повтор, заголовок, снова повтор, задача, — хотя всё несошедшееся
+# известно уже на первом круге. Готовность к поставке — одно состояние, и называется оно целиком.
 faults=''
 
 fault() {
@@ -163,10 +161,9 @@ fault() {
 # shellcheck disable=SC1090
 [ -f "$rt_hooks_dir/git-guard-delivery-folder.sh" ] && . "$rt_hooks_dir/git-guard-delivery-folder.sh" 2>/dev/null
 
-# Конфликтующая своя заявка: тот же приём, что у папки и подписи, — свой предмет живёт
-# помощником рядом. Зовётся он до всех ярусов ниже и судит не готовность этой работы, а право
-# брать следующую: пока отданное конфликтует, его чинят первым действием хода. Нет помощника —
-# ярус не судится, а работа идёт дальше.
+# Конфликтующая своя заявка: тот же приём, что у папки и подписи. Зовётся помощник до всех ярусов
+# ниже и судит не готовность этой работы, а право брать следующую: пока отданное конфликтует, его
+# чинят первым действием хода. Нет помощника — ярус не судится, а работа идёт дальше.
 # shellcheck disable=SC1090
 [ -f "$rt_hooks_dir/git-guard-delivery-conflict.sh" ] && . "$rt_hooks_dir/git-guard-delivery-conflict.sh" 2>/dev/null
 command -v rt_delivery_conflict >/dev/null 2>&1 && rt_delivery_conflict
@@ -225,23 +222,22 @@ fi
 if [ -n "$branch_arg" ]; then
     # Имя, притворяющееся веткой под задачу, но не совпадающее с формой, — это промах в имени,
     # а не осознанная беззадачная ветка. Ловится до первого коммита.
-    if printf '%s' "$branch_arg" | grep -qiE '^[A-Za-z]+-[0-9]+'; then
+    # Номер вынимает профиль: своя регулярка знала одну приставку — ключ задач, — и ветка вида
+    # `feat/88-slug`, законная по форме того же профиля, номера не давала вовсе. Проверка формы
+    # при заведении не срабатывала на ней ни разу, а сверка номеров пропускалась молча.
+    number_arg="$(rt_task_branch_number "$branch_arg")"
+    if [ -n "$number_arg" ]; then
         rt_task_branch_ok "$branch_arg" \
             || deny "BLOCKED: имя ветки «${branch_arg}» не той формы, что принята здесь. Номер у ветки тот же, что у задачи и у заголовка заявки на слияние."
-        check_task "$(printf '%s' "$branch_arg" | sed -nE 's/^[A-Za-z]+-([0-9]+).*/\1/p')" "ветка «${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 \
@@ -285,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
 
 # --- слияние заявки ----------------------------------------------------------------------
 #
@@ -374,7 +315,7 @@ branch="$(git branch --show-current 2>/dev/null)"
 rt_task_branch_ok "$branch" \
     || deny "BLOCKED: заявка с ветки «${branch}», за которой не стоит задачи. Правка начинается с задачи, видимой в очереди работ: заведи её — ${task_new} — и перенеси работу в ветку с её номером."
 
-number="$(printf '%s' "$branch" | sed -nE 's/^[A-Za-z]+-([0-9]+).*/\1/p')"
+number="$(rt_task_branch_number "$branch")"
 
 title=''
 if command -v perl >/dev/null 2>&1; then
@@ -400,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)"
@@ -434,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
@@ -478,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,15 +175,58 @@ 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
 
-[ -z "$failed" ] && exit 0
+# Чем набор гейта уже набора конвейера — сказанное один раз за сессию.
+#
+# Правило поставки требует, чтобы гейт не был уже конвейера, а собрать это требование нечем:
+# файл конвейера у каждого дерева свой, и вывести из него шаги набора пакет не может. Молчание
+# при этом читается как «проверено всё»: расхождение узнаётся из красного конвейера после
+# заявки, когда правка уже отдана человеку.
+#
+# Отметка живёт в каталоге временных файлов, как у слова о нехватке функции профиля: на каждый
+# пуш та же строка повторялась бы за заход десятки раз и перестала бы читаться.
+gap_key="$(printf '%s' "$input" | jq -r '.session_id // empty' 2>/dev/null)"
+[ -z "$gap_key" ] && gap_key="$(date +%Y%m%d 2>/dev/null || printf 'nosession')"
+gap_mark="${TMPDIR:-/tmp}/rt-kit-push-gate-gap-$gap_key"
+if [ ! -f "$gap_mark" ]; then
+    printf 'гейт пуша: набор гейта — не набор конвейера. Сборка образов, снимки показа и проверка
+' >&2
+    printf 'собранных пакетов в него не входят: что в нём стоит, показывает разбор состояния
+' >&2
+    printf '(agent-kit doctor, раздел «набор перед пушем»), — прогони недостающее до заявки.
+' >&2
+    : >"$gap_mark" 2>/dev/null || true
+fi
+
+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/glossary-load.sh

@@ -15,11 +15,32 @@ GLOSSARY="${CLAUDE_PROJECT_DIR:-.}/docs/GLOSSARY.md"
 [ -f "$GLOSSARY" ] || exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
+# Где слово заводят. Словарь бывает разложен пакетом — тогда правка на его месте теряется на
+# следующей раскладке, а до тех пор раскладка отказывает по нему целиком. Вводная, которую читает
+# каждая сессия, обязана вести в надстройку: она — единственный текст о словаре, доезжающий до
+# читателя гарантированно, и, ведя в собранный файл, она отменяет собой всё сказанное на других
+# слоях. Опровержение стоит строкой ниже, в шапке раскладки, но читается служебной строкой сборки:
+# начинается оно с версии и суммы, а не со слова.
+#
+# Адрес выводится из идентификатора ресурса в самой шапке, а не зашивается: каталог надстроек у
+# каждого дерева свой, и зашитый путь врал бы в первом же, которое держит их иначе. Шапки нет —
+# словарь принадлежит дереву целиком, и «заводится здесь же» верно как есть.
+header="$(head -1 "$GLOSSARY" 2>/dev/null)"
+resource="$(printf '%s' "$header" | sed -n 's/.*rt-kit v[^ ]* · \([^ ]*\) · .*/\1/p')"
+
+if [ -n "$resource" ]; then
+    where="$(printf 'Словарь разложен пакетом и на месте не правится: новое слово идёт в надстройку\n.claude/rt-kit/overrides/%s — она сливается по разделу «## » и раскладку переживает.\n' "$resource")"
+else
+    where='Словарь принадлежит дереву целиком: новое слово заводится в нём же той же правкой.
+'
+fi
+
 {
     printf 'СЛОВАРЬ ПРОЕКТА — `docs/GLOSSARY.md`, ниже целиком.\n\n'
     printf 'Слово отсюда употребляется в том значении, что здесь: и в файлах, и в ответах владельцу.\n'
     printf 'Раздел «Так не пишем» действует так же — левая колонка не пишется и не произносится нигде.\n'
-    printf 'Слова, которого здесь нет, у читателя нет тоже: оно либо заводится здесь же той же правкой,\n'
-    printf 'либо заменяется тем, что уже есть.\n\n'
+    printf 'Слова, которого здесь нет, у читателя нет тоже: оно вводится тем же изменением, которым\n'
+    printf 'впервые употреблено, либо заменяется тем, что уже есть.\n'
+    printf '%s\n' "$where"
     cat "$GLOSSARY"
 } | jq -Rs '{hookSpecificOutput:{hookEventName:"SessionStart",additionalContext:.}}'

package/assets/hooks/grill-gate.sh

@@ -165,6 +165,68 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re"
     | if ($asked_prose or $asking_now) and ($read | not) then "ask" else "pass" end
 ' 2>/dev/null)"
 
+# Второй признак того же гарда: на этот вопрос владелец уже отвечал.
+#
+# Первый признак судит, читались ли правила, и на разрешённой работе молчит. А промах бывает
+# другой: владелец дал указание прямой репликой, исполнитель нашёл факт, который меняет цену
+# указания, но не его смысл, — и вместо строки о цене задал меню, где два варианта из трёх
+# предлагали отменить решение владельца. Работа встала до ответа, разрешённая минутой раньше.
+#
+# Судится пересечение слов: вопрос, который сейчас уходит, против последней реплики владельца —
+# и только там, где в записи уже был вызов инструмента вопроса, то есть владелец на вопрос
+# отвечал. Понимания текста здесь нет и не нужно: три общих значимых слова означают тот же
+# предмет, а разбор из шести вопросов идёт по разным предметам и порога не набирает.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет вопроса в вызове, нет реплики владельца, нет прошлого вопроса —
+# признак молчит.
+if [ -n "$tool" ]; then
+    asked_json="$(printf '%s' "$input" | jq -r '(.tool_input.questions // []) | tostring' 2>/dev/null)"
+    seen="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg now "$asked_json" '
+        def is_input:
+            .type == "user"
+            and ((.isCompactSummary // false) | not)
+            and (((.message.content // []) | if type == "array"
+                    then ([.[] | select(.type == "tool_result")] | length)
+                    else 0 end) == 0);
+
+        def words: [splits("[^\\p{L}\\p{N}]+")] | map(select(length >= 5)) | unique;
+
+        (map(is_input) | rindex(true)) as $i
+        | if $i == null then "нет" else
+            (.[$i] | (.message.content // []) | if type == "array"
+                then ([.[] | select(.type == "text") | .text] | join(" "))
+                else (. // "") end) as $said
+            | ([.[:$i][] | select(.type == "assistant") | (.message.content // [])[]
+                 | select(.type == "tool_use") | select(.name == "AskUserQuestion")] | length) as $before
+            | if $before == 0 or ($said | length) == 0 then "нет" else
+                (($now | words) - (($now | words) - ($said | words))) as $common
+                | if ($common | length) >= 3 then "было" else "нет" end
+              end
+          end
+    ' 2>/dev/null)"
+
+    if [ "$seen" = "было" ]; then
+        reason="BLOCKED by grill-gate: на этот вопрос владелец уже отвечал в этом разговоре — продолжай работу, а не переспрашивай.
+
+Указание владельца действует до его отмены. Новый факт против действующего указания — это строка в ответе о цене, а не новый вопрос: переспрашивают только то, чего указание не покрывает. Промах здесь не в форме вопроса, а в остановке работы, которая уже разрешена.
+
+Вопрос всё-таки о другом предмете — назови в нём то, чего в прежнем ответе владельца нет: признак судит общие слова вопроса и последней реплики владельца, а не смысл."
+
+        # Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.
+        # shellcheck disable=SC1090
+        [ -f "$rt_hooks_dir/deny-tail.sh" ] && . "$rt_hooks_dir/deny-tail.sh" 2>/dev/null
+        command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+        deny_tail_text="$(rt_deny_tail "")"
+        [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+        jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
+            || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"grill-gate: на этот вопрос уже отвечали."}}\n'
+        exit 0
+    fi
+fi
+
 [ "$verdict" = "ask" ] || exit 0
 
 if [ -n "$tool" ]; then

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'; }