@rt-tools/agent-kit 0.12.0 → 0.14.0

package/assets/hooks/claim-guard.sh

@@ -41,6 +41,36 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 [ -z "$transcript" ] && exit 0
 [ -f "$transcript" ] || exit 0
 
+# Текст ответа ложится в запись хода не раньше, чем хост позовёт хук: гард, прочитавший файл
+# первым, судит ход, у которого сказанного нет вовсе, — и молчит, будучи неотличим от гарда,
+# который посмотрел и пропустил. Ждём его появления, и не дождавшись — возвращаем ход: пустая
+# запись означает не «владельцу ничего не сказано», а «прочитать нечего».
+#
+# Отказ этот принадлежит одному гарду нарочно. Текст судят трое, и печатай они свои объекты
+# подряд, вывод перестал бы разбираться целиком — то есть отбой пропал бы весь.
+if ! rt_turn_has_text "$transcript"; then
+    reason="BLOCKED by claim-guard: запись хода не отдала ни одного текста ответа, и судить сказанное владельцу нечем.
+
+Текст ложится в запись не раньше, чем хост зовёт хук. Прочитанная слишком рано запись выглядит ходом, в котором владельцу ничего не сказано, — и все гарды, судящие сказанное, проходят мимо молча.
+
+Повтори завершение хода: к этой минуте текст в записи уже есть. Ход при этом ничего не теряет — сказанное владельцу остаётся тем же.
+
+Гард судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/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" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"claim-guard: запись хода не отдала текста ответа — повтори завершение хода."}\n'
+    exit 0
+fi
+
 # Ход — всё, что записано после последней настоящей реплики владельца: ответ инструмента
 # приходит той же ролью и репликой не считается.
 turn="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r '
@@ -76,6 +106,10 @@ claims=(
     '(ветки|ветка|файлы|файл|папка|каталог)[^.]{0,40}(снят|удал|почищ|вычищ)|снят[оыа] с§git branch|git push .*--delete|git rm|gh api|rm §команду удаления — `git branch -d`, `git push --delete` или `git rm`'
     'прогон (зелёный|прошёл|кончился)|конвейер зелёный|проверки на PR зелёные§gh run§`gh run list` или `gh run view`'
     '(работа|правка|задача) готова|можно вливать|PR открыт|черновик снят§gh pr §`gh pr create`, `gh pr view` или `gh pr ready`'
+    # Ожидание чужого шага — тоже утверждение о состоянии, и врать ему есть чем: прогон бывает
+    # зелёным час, бывает не встав вовсе. Сказанное без команды оставляет готовую работу
+    # черновиком, и владелец узнаёт об этом последним — дважды за сутки так и вышло.
+    'жд[уёя][^.]{0,20}прогон|дожида[ею][^.]{0,20}прогон|прогон[^.]{0,20}(ещё идёт|не встал|не кончился|не дошёл)|черновик[^.]{0,30}(не снимаю|сниму|снимется)§gh run|gh pr checks|check-runs|check:board|board\.mjs§команду о прогоне — `gh run list`, `gh pr checks` или сверку очереди работ'
     'задача заведена|задача (в|переведена в) колонк|колонка переведена§gh issue|gh api|task:new|task:move|board\.mjs§команду очереди работ — заведение задачи или перевод колонки'
     '(в дереве|в репозитории|здесь|такого файла|такой команды)[^.]{0,30}(нет|не бывает)|не заводили|нигде не встречается§grep|rg |ls |find |git ls-files|git grep|git log|cat §команду поиска — `grep`, `git ls-files` или обход каталога'
 )

package/assets/hooks/dev-server-guard.sh

@@ -100,7 +100,7 @@ RUNNER='((npx|pnpm|yarn|bun|npm)([[:space:]]+(exec|run|dlx))?[[:space:]]+)?'
 
 # Начало вызова: начало строки или разделитель команд. Кавычку в границы вносить нельзя — тогда
 # поиск по тексту и снятие процесса по шаблону читаются как запуск.
-BOUND='(^|[;&|(]|&&|\|\|)[[:space:]]*'
+BOUND="$RT_CMD_BOUND"
 
 printf '%s' "$cmd" | grep -qE "${BOUND}${RUNNER}(nx|ng)[[:space:]]+(run[[:space:]]+[^[:space:]]*:)?(serve|dev)" \
     && deny "Запуск ещё одного сервера разработки через каркас."

package/assets/hooks/dispatch.sh

@@ -46,24 +46,57 @@ export RT_HOOK_INPUT="$input"
 branches="$(grep -l '^# rt-hook:' "$here"/*.sh 2>/dev/null | sort)"
 [ -z "$branches" ] && exit 0
 
+# Объявлений у файла бывает несколько: гард, стоящий и на вызове инструмента, и на завершении
+# хода, называет оба события своими строками. Читалось прежде только первое — и вторая ветка не
+# звалась ни разу, молча: снаружи это неотличимо от гарда, который посмотрел и пропустил.
+collected=""
 for branch in $branches; do
-    declaration="$(sed -n 's/^# rt-hook:[[:space:]]*//p' "$branch" 2>/dev/null | head -1)"
-    [ -z "$declaration" ] && continue
-
-    branch_event="${declaration%% *}"
-    [ "$branch_event" = "$event" ] || continue
-
-    # Образец вызова: его нет вовсе — гард зовётся на любом; есть — сверяется с именем
-    # инструмента целиком, а не куском. Звёздочка и точка со звёздочкой значат одно: любой вызов.
-    matcher="${declaration#"$branch_event"}"
-    matcher="${matcher#"${matcher%%[![:space:]]*}"}"
-    if [ -n "$matcher" ] && [ "$matcher" != '*' ] && [ "$matcher" != '.*' ]; then
-        [[ "${RT_HOOK_TOOL:-}" =~ ^(${matcher})$ ]] || continue
-    fi
+    matched=0
+    while IFS= read -r declaration; do
+        [ -z "$declaration" ] && continue
+
+        branch_event="${declaration%% *}"
+        [ "$branch_event" = "$event" ] || continue
+
+        # Образец вызова: его нет вовсе — гард зовётся на любом; есть — сверяется с именем
+        # инструмента целиком, а не куском. Звёздочка и точка со звёздочкой значат одно: любой
+        # вызов.
+        matcher="${declaration#"$branch_event"}"
+        matcher="${matcher#"${matcher%%[![:space:]]*}"}"
+        if [ -n "$matcher" ] && [ "$matcher" != '*' ] && [ "$matcher" != '.*' ]; then
+            [[ "${RT_HOOK_TOOL:-}" =~ ^(${matcher})$ ]] || continue
+        fi
+
+        matched=1
+        break
+    done <<EOF
+$(sed -n 's/^# rt-hook:[[:space:]]*//p' "$branch" 2>/dev/null)
+EOF
+
+    # Совпало хоть одно объявление — ветка зовётся один раз. Два объявления одного события в
+    # одном файле звали бы гард дважды на один ввод, и второй вызов судил бы то же самое.
+    [ "$matched" = 1 ] || continue
 
-    printf '%s' "$input" | bash "$branch"
+    branch_out="$(printf '%s' "$input" | bash "$branch" 2>/dev/null)"
     code=$?
-    [ "$code" -ne 0 ] && exit "$code"
+    if [ "$code" -ne 0 ]; then
+        [ -n "$branch_out" ] && printf '%s\n' "$branch_out"
+        exit "$code"
+    fi
+
+    # Отбой ветки приходит не кодом возврата, а решением в выводе: гарды завершения хода
+    # печатают его и выходят нулём. Не остановившись здесь, диспетчер склеил бы этот объект с
+    # выводом следующей ветки — а склеенное не разбирается, и отбой пропадает целиком.
+    if [ -n "$branch_out" ] && printf '%s' "$branch_out" | jq -e '.decision == "block"' >/dev/null 2>&1; then
+        printf '%s\n' "$branch_out"
+        exit 0
+    fi
+
+    [ -n "$branch_out" ] && collected="${collected}${branch_out}
+"
 done
 
+# Ни одна ветка не отбила: отдаётся то, что они напечатали, — подсказки и сводки.
+[ -n "${collected:-}" ] && printf '%s' "$collected"
+
 exit 0

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

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Условия поставки о папке задачи. НЕ гард: объявления `rt-hook:` у него нет, к событиям агента
+# он не подключается. Его источает гард поставки — тем же приёмом, каким источает хвост отказа и
+# запись наблюдений.
+#
+# Зачем он отдельным файлом. Условий о папке два, и живут они в разных местах вызова: одно на
+# открытии заявки, другое на слиянии. Вместе с разбором команды, подписью, основанием и очередью
+# работ они переросли предел длины файла, а делить гард по событиям нельзя — он одно целое,
+# и разбор команды у него общий. Делится он по предмету: папка задачи — свой предмет, у неё свой
+# обход и своя запись в архиве.
+#
+# ЧТО ЗДЕСЬ. Три вызова, и все три зовутся из гарда поставки, где уже объявлены `deny`, `fault`
+# и переменные профиля: `tasks_dir`, `archive_dir`, `main_branch`, `folder_skip_re`, `root`.
+# Своих у помощника нет — он не читает ни ввода, ни настроек.
+
+# Есть ли папка задачи в ветке. Смотрим содержимое ветки, а не рабочее дерево: если папку
+# удалили, но не закоммитили, проверка прошла бы, а папка всё равно уехала бы в главную. Имя
+# ветки подставляем целиком, вместе с косой: у ветки вида `chore/312-slug` папка лежит во
+# вложенном каталоге.
+rt_folder_in_branch() {
+    git ls-tree -d --name-only HEAD -- "$1" 2>/dev/null | head -1
+}
+
+# Была ли папка задачи в этой ветке вообще. Спрашивается у ветки, которая её удалила: иначе
+# требование записи в архиве цеплялось бы к работе, у которой папки и не было.
+rt_folder_was_in_branch() {
+    _base="$1"
+    _folder="$2"
+    _had="$(git ls-tree -d --name-only "$_base" -- "$_folder" 2>/dev/null | head -1)"
+    [ -z "$_had" ] && _had="$(git log "$_base..HEAD" --diff-filter=A --name-only --pretty=format: -- "$_folder" 2>/dev/null | head -1)"
+    [ -n "$_had" ]
+}
+
+# Условие открытия заявки: папка разобрана, и запись в архиве от ветки прибыла. Отказ копится
+# вместе с прочими условиями поставки и печатается разом.
+#
+# Разбор стоит здесь, а не на слиянии. Прежде было наоборот: считалось, что папка нужна на диске
+# всё время разбора, потому что правку по замечаниям без замысла отбивает гард хода работы.
+# Владелец же вливает, как только видит зелёное, и закрывающему коммиту места не остаётся —
+# трижды подряд папка уехала в главную неразобранной, а гард слияния этого не видел вовсе:
+# кнопку нажимает человек на хостинге, и до него гард не достаёт. Замысел после уборки гард хода
+# работы берёт из истории ветки, а не с диска.
+rt_delivery_open_folder() {
+    [ -n "$tasks_dir" ] || return 0
+    printf '%s' "$cmd" | grep -qiE "$folder_skip_re" && return 0
+
+    _folder="$tasks_dir/$branch"
+    _lying="$(rt_folder_in_branch "$_folder")"
+    if [ -n "$_lying" ]; then
+        fault "в ветке лежит папка задачи «${_lying}» — заявка открывается после уборки, а не до неё. Перенеси в «${archive_dir:-архив}» то, что объясняет принятые решения, остальное удали, закоммить последним коммитом и повтори. Если работа вливается частями, поставь в команду комментарий «# Task-folder-skip: <причина>»."
+        return 0
+    fi
+
+    [ -n "$archive_dir" ] || return 0
+    _base="$(git merge-base "$main_branch" HEAD 2>/dev/null)"
+    [ -z "$_base" ] && return 0
+    rt_folder_was_in_branch "$_base" "$_folder" || return 0
+
+    _gained="$(git diff --name-only --diff-filter=A "$_base" HEAD -- "$archive_dir" 2>/dev/null | head -1)"
+    [ -z "$_gained" ] \
+        && fault "папку задачи удалили, но в «${archive_dir}» ветка ничего не добавила. Удалить проще, чем разобрать, — и вместе с папкой пропадает разбор просьбы, единственная запись слов владельца. Перенеси то, что объясняет принятые решения, одним файлом с понятным именем и повтори."
+}
+
+# Условие слияния: тот же предмет вторым рубежом. Он ловит слияние, идущее командой, — то, до
+# которого гард достаёт. Отсюда выходят только отказом или молчанием: слияние решается целиком.
+rt_delivery_merge_folder() {
+    [ -n "$tasks_dir" ] || exit 0   # ведения работы папкой в дереве нет
+
+    _branch="$(git branch --show-current 2>/dev/null)"
+    [ -z "$_branch" ] && exit 0
+    rt_task_branch_ok "$_branch" || exit 0   # за беззадачной веткой папки не стоит
+
+    _folder="$tasks_dir/$_branch"
+
+    # Сначала ищем обход в самой команде — это работает и без сети. Если читать только
+    # тело заявки, то без сети гард отбил бы слияние, причина которого в этом теле и написана.
+    printf '%s' "$cmd" | grep -qiE "$folder_skip_re" && exit 0
+
+    _number="$(printf '%s' "$cmd" | sed -nE 's/.*(pr|mr)[[:space:]]+(merge|update)[[:space:]]+([0-9]+).*/\3/p' | head -1)"
+    if [ -n "$_number" ] && rt_needs rt_report_body git-guard-delivery; then
+        _body="$(cd "$root" && rt_report_body "$_number" 2>/dev/null)"
+        [ -n "$_body" ] && printf '%s' "$_body" | grep -qiE "$folder_skip_re" && exit 0
+    fi
+
+    _lying="$(rt_folder_in_branch "$_folder")"
+    [ -n "$_lying" ] \
+        && deny "BLOCKED: в ветке осталась папка задачи «${_lying}» — она уедет в главную. Разобрать её потом будет некому: работа перейдёт к следующей задаче, а эта заявка закроется. Перенеси в «${archive_dir:-архив}» то, что объясняет принятые решения, остальное удали и повтори. Если работа вливается частями, поставь в тело заявки строку «Task-folder-skip: <причина>»."
+
+    [ -n "$archive_dir" ] || exit 0
+    _base="$(git merge-base "$main_branch" HEAD 2>/dev/null)"
+    [ -z "$_base" ] && exit 0
+    rt_folder_was_in_branch "$_base" "$_folder" || exit 0
+
+    _gained="$(git diff --name-only --diff-filter=A "$_base" HEAD -- "$archive_dir" 2>/dev/null | head -1)"
+    [ -z "$_gained" ] \
+        && deny "BLOCKED: папку задачи удалили, но в «${archive_dir}» ветка ничего не добавила. Удалить проще, чем разобрать, — и вместе с папкой пропадает разбор просьбы, единственная запись слов владельца. Перенеси то, что объясняет принятые решения, одним файлом с понятным именем и повтори."
+
+    exit 0
+}

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

@@ -11,6 +11,10 @@
 # среди них самая отдельная — своя точка проверки, свои условия молчания, свой отказ.
 
 . "$(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_signature() {
 # --- подпись машинного коммита ------------------------------------------------------------
@@ -33,13 +37,15 @@ rt_delivery_signature() {
 # логина разошлись бы молча. Исполнителем задачи он тоже не бывает — в дереве, где хостинг
 # ограничил машинную запись, исполнителем ставят человека, а коммит остаётся машинным.
 #
-# Вызов пуша узнаётся по двум признакам сразу — команда `git` в начале строки или за
-# разделителем и слово `push` отдельным словом. Одной подстрокой «git push» его не поймать:
-# помощник учётных данных и заголовок запроса ставятся ключами `-c` между ними.
+# Вызов пуша узнаётся по двум признакам сразу — начало вызова перед словом `git` и слово `push`
+# отдельным словом. Одной подстрокой «git push» его не поймать: помощник учётных данных и
+# заголовок запроса ставятся ключами `-c` между ними. Начало вызова считает присваивания
+# переменных частью команды: пуш подписанного коммита набирают с подстановкой токена, и признак
+# без них пропускал ровно тот вызов, ради которого этот помощник и заведён.
 # Пробный пуш не отправляет ничего, и подпись у него не спрашивают. Отложенная правка — тоже:
 # `git stash push` кладёт правку в тайник этой же машины, поэтому тайник вырезается из строки, а
 # признак считается по остатку.
-if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git([[:space:]]|$)' \
+if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}git([[:space:]]|\$)" \
     && printf '%s' "$cmd" | sed -E 's/git[[:space:]]+stash[[:space:]]+push/git stash/g' | grep -qE '(^|[[:space:]])push([[:space:]]|$)' \
     && ! printf '%s' "$cmd" | grep -q -- '--dry-run'; then
     # Два условия молчания. Дерево, не назвавшее почты машинной записи, требования не получает:

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: PreToolUse Bash|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
-# Требует: hooks/profile-check.sh, hooks/deny-tail.sh
+# Требует: hooks/git-guard-delivery-folder.sh, hooks/profile-check.sh, hooks/deny-tail.sh
 # Гард поставки. PreToolUse на заведении ветки, пуше и открытии заявки на слияние.
 #
 # Закон о поставке требует трёх вещей, которых обычно не проверяет ничто: правка начинается с
@@ -152,6 +152,12 @@ fault() {
 }— $1"
 }
 
+# Условия о папке задачи вынесены соседним файлом: у папки свой предмет, свой обход и своя
+# запись в архиве, а вместе с разбором команды и очередью работ они переросли предел длины.
+# Подключается он после `deny` и `fault` — обе зовутся изнутри.
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/git-guard-delivery-folder.sh" ] && . "$rt_hooks_dir/git-guard-delivery-folder.sh" 2>/dev/null
+
 # Отказ по накопленному. Пусто — вызывающая сторона идёт дальше.
 deny_faults() {
     [ -z "$faults" ] && return 0
@@ -161,21 +167,6 @@ deny_faults() {
 ${faults}"
 }
 
-# Подсказка вместо отказа: на открытии PR папка ещё нужна. Решения подсказка не несёт,
-# команда идёт дальше своим ходом.
-hint() {
-    jq -n --arg c "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:$c}}' 2>/dev/null
-    exit 0
-}
-
-# Есть ли папка задачи в ветке. Смотрим содержимое ветки, а не рабочее дерево: если папку
-# удалили, но не закоммитили, проверка прошла бы, а папка всё равно уехала бы в main. Имя
-# ветки подставляем целиком, вместе с косой: у ветки вида `chore/312-slug` папка лежит во
-# вложенном каталоге.
-folder_in_branch() {
-    git ls-tree -d --name-only HEAD -- "$1" 2>/dev/null | head -1
-}
-
 check_task() {
     number="$1"
     where="$2"
@@ -292,7 +283,7 @@ command -v rt_delivery_signature >/dev/null 2>&1 && rt_delivery_signature
 #
 # Возврат заявки в черновик под требование не подпадает: он делает ровно то, чего гард и
 # добивается, — снимает с работы вид готовой.
-if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*(gh[[:space:]]+pr[[:space:]]+ready|glab[[:space:]]+mr[[:space:]]+update[^|;&]*--ready)([[:space:]]|$)' \
+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
     # Ссылка на заявку необязательна: без неё клиент берёт заявку текущей ветки, и это самая
     # короткая форма вызова. Требовать номер значило бы снимать всё требование одним пробелом.
@@ -341,59 +332,20 @@ fi
 
 # --- слияние заявки ----------------------------------------------------------------------
 #
-# Папку задачи разбирают тем же PR, что и работу. После слияния этого уже никто не сделает:
-# работа перешла к следующей задаче, а PR закрыт. Раньше слияния требовать нельзя — пока идёт
-# ревью, plan.md нужен на диске, иначе гард хода работы не даст править код.
+# Второй рубеж того же условия, что стоит на открытии заявки: он ловит слияние, идущее командой.
 # Команду ищем от начала строки или после разделителя, а не где угодно в тексте. Иначе гард
 # отбивает сообщение, где `gh pr merge` просто упомянут в кавычках, — так он и сработал на
 # правке этого же текста. Полностью подстроку в кавычках так не отсечь, но случайное упоминание
 # внутри слова или пути мимо уже не пройдёт.
-if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*(gh[[:space:]]+pr[[:space:]]+merge|glab[[:space:]]+mr[[:space:]]+merge|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+update)([[:space:]]|$)'; then
-    [ -n "$tasks_dir" ] || exit 0   # ведения работы папкой в дереве нет
-
-    merge_branch="$(git branch --show-current 2>/dev/null)"
-    [ -z "$merge_branch" ] && exit 0
-    rt_task_branch_ok "$merge_branch" || exit 0   # за беззадачной веткой папки не стоит
-
-    folder="$tasks_dir/$merge_branch"
-
-    # Сначала ищем обход в самой команде — это работает и без сети. Если читать только
-    # тело PR, то без сети гард отбил бы слияние, причина которого в этом теле и написана.
-    printf '%s' "$cmd" | grep -qiE "$folder_skip_re" && exit 0
-
-    merge_number="$(printf '%s' "$cmd" | sed -nE 's/.*(pr|mr)[[:space:]]+(merge|update)[[:space:]]+([0-9]+).*/\3/p' | head -1)"
-    if [ -n "$merge_number" ] && rt_needs rt_report_body git-guard-delivery; then
-        body="$(cd "$root" && rt_report_body "$merge_number" 2>/dev/null)"
-        [ -n "$body" ] && printf '%s' "$body" | grep -qiE "$folder_skip_re" && exit 0
-    fi
-
-    lying="$(folder_in_branch "$folder")"
-    [ -n "$lying" ] \
-        && deny "BLOCKED: в ветке осталась папка задачи «${lying}» — она уедет в главную. Разобрать её потом будет некому: работа перейдёт к следующей задаче, а этот PR закроется. Перенеси в «${archive_dir:-архив}» то, что объясняет принятые решения, остальное удали и повтори. Если работа вливается частями, поставь в тело PR строку «Task-folder-skip: <причина>»."
-
-    # Запись в архиве спрашиваем только у ветки, которая папку удалила. Иначе проверка
-    # цеплялась бы к работе, у которой папки и не было. Без общего предка с главной веткой
-    # сравнивать не с чем — тогда молчим.
-    [ -n "$archive_dir" ] || exit 0
-    base="$(git merge-base "$main_branch" HEAD 2>/dev/null)"
-    [ -z "$base" ] && exit 0
-
-    had="$(git ls-tree -d --name-only "$base" -- "$folder" 2>/dev/null | head -1)"
-    [ -z "$had" ] && had="$(git log "$base..HEAD" --diff-filter=A --name-only --pretty=format: -- "$folder" 2>/dev/null | head -1)"
-    [ -z "$had" ] && exit 0
-
-    gained="$(git diff --name-only --diff-filter=A "$base" HEAD -- "$archive_dir" 2>/dev/null | head -1)"
-    [ -z "$gained" ] \
-        && deny "BLOCKED: папку задачи удалили, но в «${archive_dir}» ветка ничего не добавила. Удалить проще, чем разобрать, — и вместе с папкой пропадает разбор просьбы, единственная запись слов владельца. Перенеси то, что объясняет принятые решения, одним файлом с понятным именем и повтори."
-
-    exit 0
+if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+merge|glab[[:space:]]+mr[[:space:]]+merge|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+update)([[:space:]]|\$)"; then
+    rt_delivery_merge_folder
 fi
 
 # --- открытие заявки на слияние ----------------------------------------------------------
 # Команду ищем от начала строки или после разделителя — по той же причине, что и слияние:
 # упоминание в кавычках командой не является.
 printf '%s' "$cmd" \
-    | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*(gh[[:space:]]+pr[[:space:]]+create|glab[[:space:]]+mr[[:space:]]+create|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+create)([[:space:]]|$)' \
+    | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+create|glab[[:space:]]+mr[[:space:]]+create|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+create)([[:space:]]|\$)" \
     || exit 0
 
 branch="$(git branch --show-current 2>/dev/null)"
@@ -474,17 +426,17 @@ fi
 
 check_task "$number" "заявка с ветки «${branch}»" да
 
+# Папка задачи разбирается до открытия заявки, а не после одобрения. Прежде здесь стояло
+# напоминание, а требование — на слиянии: считалось, что папка нужна на диске всё время
+# разбора, потому что правку по замечаниям без замысла отбивает гард хода работы. Владелец же
+# вливает, как только видит зелёное, и закрывающему коммиту места не остаётся — трижды подряд
+# папка уехала в главную неразобранной, а гард слияния этого не видел вовсе: кнопку нажимает
+# человек на хостинге, и до него гард не достаёт. Разбор переехал сюда, а замысел после уборки
+# гард хода работы берёт из истории ветки, а не с диска.
+rt_delivery_open_folder
+
 # Всё несошедшееся названо здесь, разом: до этой строки собирались условия, каждое из которых
 # прежде отбивало вызов в одиночку.
 deny_faults
 
-# Сейчас папка ещё нужна: правки по замечаниям ревью идут в эту же ветку, а без plan.md их не
-# пропустит гард хода работы. Поэтому здесь только напоминание. Требование стоит на слиянии —
-# там папка уже не нужна, а вред от неё как раз и наступает.
-if [ -n "$tasks_dir" ]; then
-    lying="$(folder_in_branch "$tasks_dir/$branch")"
-    [ -n "$lying" ] \
-        && hint "В ветке лежит папка задачи «${lying}». Разбери её до слияния, этим же PR: потом за неё уже никто не возьмётся. На слиянии это будет отказ, а не напоминание."
-fi
-
 exit 0

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

@@ -46,7 +46,7 @@ cmd="$(rt_hook_cmd)"
 # подстрокой «git push» пуш не поймать — помощник учётных данных и заголовок запроса ставятся
 # ключами `-c` между ними, и ровно этой формой здесь и пушат. Пока признаком была подстрока,
 # весь набор гейта на таком пуше не гонялся вовсе, а молчание гарда читалось как «зелено».
-printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git([[:space:]]|$)' || exit 0
+printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}git([[:space:]]|\$)" || exit 0
 
 # Отложенная правка пушем не бывает: `git stash push` кладёт правку в тайник этой же машины и
 # наружу не отправляет ничего. Слово `push` в ней стоит отдельным, и без этой строки гард гонял
@@ -71,7 +71,7 @@ esac
 #
 # Судится переключение на существующую ветку. Заведение новой (`checkout -b`, `switch -c`)
 # сюда не попадает: у свежей ветки дерево то же самое, что и было.
-if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git[[:space:]]+(checkout|switch)[[:space:]]+' &&
+if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}git[[:space:]]+(checkout|switch)[[:space:]]+" &&
     ! printf '%s' "$cmd" | grep -qE 'git[[:space:]]+(checkout[[:space:]]+-b|switch[[:space:]]+-c)([[:space:]]|$)'; then
     reason="BLOCKED: переключение ветки и пуш одной командой. Набор гейта гоняется в том дереве, какое лежит на момент разбора команды, — то есть по ПРЕЖНЕЙ ветке, а не по той, что уходит на хостинг. Зелёный набор при этом читается как проверка ушедшего, хотя проверял он другое. Раздели вызовы: сперва переключись, затем отдельной командой пушь."
     # Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.

package/assets/hooks/hook-input.sh

@@ -47,8 +47,70 @@ rt_hook_field() {
     printf '%s' "$RT_HOOK_INPUT" | jq -r "${path} // empty" 2>/dev/null
 }
 
+# НАЧАЛО ВЫЗОВА В КОМАНДНОЙ СТРОКЕ. Приставка образца, которым гард узнаёт свой вызов: команда
+# стоит в начале строки, за разделителем — и после любого числа присваиваний переменных
+# окружения перед её именем.
+#
+# Присваивания входят сюда потому, что вызов с ними — обычная форма, и часть набора требует её
+# прямо: личность вызова, открывающего заявку, видна из команды только явной подстановкой
+# токена. Признак, не знавший о присваиваниях, на этой форме слепнул молча — он не отказывал и
+# не предупреждал, он не считал вызов вызовом, и весь предмет гарда оставался несудимым. Так
+# прошли мимо своих гардов пуш, открытие заявки, снятие черновика и слияние: коммит с чужой
+# подписью уехал в главную ветку, а запрет на слияние агентом снимался подстановкой токена.
+#
+# Значение присваивания берётся без пробелов: `ИМЯ="a b"` в кавычках сюда не подпадает, и вызов
+# за ним останется несудимым. Пробел внутри значения перед вызовом встречается редко, а
+# образец, разбирающий кавычки, ошибается в другую сторону — считает вызовом то, что им не
+# является. Признак обязан ошибаться в сторону лишнего срабатывания: гард, не узнавший вызов,
+# молчит и выглядит исправным, а сработавший на лишнем виден сразу и правится.
+#
+# Само по себе присваивание вызовом не считается: за ним обязано стоять имя команды.
+#
+# Объявлено это одним местом, а не литералом в каждом гарде: разойдясь, копии чинятся по одной
+# и молчат о том, что остальные остались слепыми.
+RT_CMD_BOUND='(^|[;&|(]|&&|\|\|)[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*'
+
 # Поля, которые спрашивают все гарды.
 rt_hook_tool() { rt_hook_field RT_HOOK_TOOL '.tool_name'; }
 rt_hook_cmd() { rt_hook_field RT_HOOK_CMD '.tool_input.command'; }
 rt_hook_file() { rt_hook_field RT_HOOK_FILE '.tool_input.file_path'; }
 rt_hook_cwd() { rt_hook_field RT_HOOK_CWD '.cwd'; }
+
+# ЖДЁТ ПОСЛЕДНИЙ ТЕКСТ ХОДА В ЗАПИСИ. Гарды завершения судят то, что сказано владельцу, а запись
+# хода на этот момент бывает неполна: текст ответа ложится в файл не раньше, чем хост позовёт
+# хук, и гард читает ход, у которого текста нет вовсе. Молчит он при этом честно — и снаружи
+# неотличим от гарда, который посмотрел и пропустил. Ровно так ход, поставивший работу в
+# зависимость от слова владельца, ушёл мимо трёх гардов сразу, а тот же ход, поданный им
+# повторно, был отбит.
+#
+# Ждём короткими попытками: файл дописывается за миллисекунды, а ход и без того кончается не
+# мгновенно. Дождались — ноль; текста так и нет — единица, и решает уже гард.
+rt_turn_has_text() {
+    local transcript="$1" tries="${2:-20}" got
+
+    [ -n "$transcript" ] && [ -f "$transcript" ] || return 1
+    command -v jq >/dev/null 2>&1 || return 1
+
+    while [ "$tries" -gt 0 ]; do
+        got="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r '
+            def is_input:
+                .type == "user"
+                and (((.message.content // []) | if type == "array"
+                        then ([.[] | select(.type == "tool_result")] | length)
+                        else 0 end) == 0);
+
+            (map(is_input) | rindex(true)) as $i
+            | (if $i == null then . else .[$i + 1:] end)
+            | [.[] | select(.type == "assistant") | (.message.content // [])[]
+                 | select(.type == "text") | .text]
+            | length
+        ' 2>/dev/null)"
+
+        [ -n "$got" ] && [ "$got" != '0' ] && return 0
+
+        tries=$((tries - 1))
+        [ "$tries" -gt 0 ] && sleep 0.05
+    done
+
+    return 1
+}

package/assets/hooks/override-write-guard.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# rt-hook: PreToolUse Write|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
+# Требует: hooks/deny-tail.sh
+# Гард затирания надстройки: запись поверх — не то же самое, что правка.
+#
+# Надстройка дерева сливается с ресурсом пакета по разделу «## »: раздел, который дерево
+# переписало, замещает пакетный, а остальные приходят из пакета. Файл надстройки поэтому
+# накапливается — разделы в него дописывают разные ветки и разные заходы, — и выглядит он как
+# обычный текст, который можно положить целиком.
+#
+# Положенный целиком, он уносит с собой все разделы, которых эта правка не касалась. Пропажу не
+# видно ничем: раскладка сходится, проверки зелёные, а пакетный раздел молча вернулся на место
+# того, что дерево о себе говорило. Заметит это тот, кто через месяц удивится, почему правило
+# снова требует чужих имён.
+#
+# ЧТО СУДИТСЯ. Запись файла целиком поверх существующей непустой надстройки: инструмент записи,
+# перенаправление `>`, `tee` без дописывания, копирование поверх. Дописывание в конец — `>>`,
+# `tee -a` — и правка по месту проходят: они ничего не уносят.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет `jq`, битый ввод, чужой инструмент, файла нет, файл пуст —
+# правка РАЗРЕШАЕТСЯ. Сломанный гард не имеет права заклинить работу.
+
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
+[ -z "$input" ] && exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# 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() { printf ''; }
+
+deny() {
+    # 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 && rt_note guard-deny res=override-write-guard
+
+    reason="$1 $(rt_deny_tail "$2")"
+    jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
+        || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"Гард затирания надстройки."}}\n'
+    exit 0
+}
+
+# Цели записи поверх, названные командой прямо. Дописывание сюда не входит: `>>` прячется до
+# разбора и обратно не разворачивается, `tee` берётся только без довода о дописывании.
+rt_overwrite_targets() {
+    tr "\"'\`" '   ' \
+        | sed -E 's/>>/\
+APPEND/g' \
+        | sed -E 's/>/\
+>/g' \
+        | sed -nE '
+            s/^>[[:space:]]*([^[:space:]|&;]+).*/\1/p
+            s/(^|.*[[:space:]])tee[[:space:]]+([^-[:space:]][^[:space:]|&;]*).*/\2/p
+            s/(^|.*[[:space:]])(cp|mv|install)[[:space:]]+([^[:space:]]+[[:space:]]+)+([^[:space:]|&;]+).*/\4/p
+        ' \
+        | sort -u
+}
+
+tool="$(rt_hook_tool)"
+candidates=""
+case "$tool" in
+    Write | mcp__webstorm__create_new_file)
+        candidates="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+        ;;
+    Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
+        cmd="$(rt_hook_cmd)"
+        [ -z "$cmd" ] && exit 0
+        candidates="$(printf '%s' "$cmd" | rt_overwrite_targets)"
+        ;;
+    *) exit 0 ;;
+esac
+[ -z "$candidates" ] && exit 0
+
+root="${CLAUDE_PROJECT_DIR:-.}"
+overrides_dir="${RT_OVERRIDES_DIR:-.claude/rt-kit/overrides}"
+
+while IFS= read -r candidate; do
+    [ -z "$candidate" ] && continue
+    case "$candidate" in
+        /*) relative="${candidate#"$root"/}" ;;
+        *)
+            relative="$candidate"
+            candidate="$root/$candidate"
+            ;;
+    esac
+    case "$relative" in "$overrides_dir"/*) ;; *) continue ;; esac
+    [ -f "$candidate" ] || continue
+
+    lines="$(wc -l <"$candidate" 2>/dev/null | tr -d ' ')"
+    [ -z "$lines" ] && continue
+    [ "$lines" -eq 0 ] && continue
+
+    sections="$(grep -c '^## ' "$candidate" 2>/dev/null || printf '0')"
+    resource="${relative#"$overrides_dir"/}"
+
+    deny "BLOCKED by override-write-guard: «${relative}» — надстройка этого дерева, и в ней уже лежит ${lines} строк, разделов «## » — ${sections}. Запись целиком уносит все разделы, которых эта правка не касалась, и на их место молча возвращается пакетный текст ресурса «${resource}»: раскладка после этого сходится, проверки зелёные, а сказанного деревом о себе больше нет. Правь по месту — правкой раздела, а не записью файла." \
+        "новый раздел дописывается в конец: надстройка сливается с пакетным ресурсом по заголовку «## », и пакетный текст замещается только теми разделами, которые дерево назвало"
+done <<EOF
+$candidates
+EOF
+
+exit 0