@rt-tools/agent-kit 0.8.1 → 0.8.3

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

@@ -1,19 +1,21 @@
 #!/usr/bin/env bash
 # rt-hook: PreToolUse Bash|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/profile-check.sh
-# Гард поставки. PreToolUse на заведении ветки и открытии заявки на слияние.
+# Гард поставки. PreToolUse на заведении ветки, пуше и открытии заявки на слияние.
 #
 # Закон о поставке требует трёх вещей, которых обычно не проверяет ничто: правка начинается с
-# задачи, видимой в очереди работ; задача, ветка и отчёт несут один номер; у задачи есть
+# задачи, видимой в очереди работ; задача, ветка и PR несут один номер; у задачи есть
 # исполнитель. Держатся они памятью — и не удерживаются: задачи стоят вне очереди, исполнитель
 # не проставлен, а большинство влитых заявок приходит с веток, за которыми задачи не стояло
 # вовсе.
 #
-# Гард стоит в двух точках, и в каждой требует того, что в этот момент исправимо:
+# Гард стоит в трёх точках, и в каждой требует того, что в этот момент исправимо:
 #
 #   заведение ветки — имя с номером разбирается на месте; имя без номера пропускается:
 #       локальная ветка под пробу законна, в главную она не поедет, потому что заявка с неё
 #       не откроется;
+#   пуш — подпись машинного коммита ещё переписывается на месте; после пуша её чинит только
+#       силовая отправка;
 #   открытие заявки — ветка обязана нести номер, заголовок обязан начинаться с того же номера,
 #       а задача — быть открытой, стоять в очереди работ и иметь исполнителя.
 #
@@ -28,7 +30,9 @@
 #                          numbered); молчание значит «спросить некого»;
 #   RT_TASK_NEW_CMD      — чем заводится задача;
 #   RT_BOARD_CHECK_CMD   — чем сверяется очередь работ;
-#   RT_TASK_BOT          — учётная запись, которую ставят исполнителем.
+#   RT_TASK_BOT          — учётная запись, которую ставят исполнителем;
+#   RT_COMMIT_EMAIL      — почта, которой подписан машинный коммит; её же левой частью он и
+#                          опознаётся.
 # Отказ называет и то, что не так, и чем это чинится: отказ без действия обходят, а не исполняют.
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: не репозиторий, нет разборщика, битый ввод, нет профиля — пропуск.
@@ -87,6 +91,7 @@ title_re="${RT_TASK_TITLE_RE:-^\[[A-Za-z]+-[0-9]+\][[:space:]]+[^[:space:]]}"
 task_new="${RT_TASK_NEW_CMD:-npm run task:new}"
 board_check="${RT_BOARD_CHECK_CMD:-npm run check:board}"
 task_bot="${RT_TASK_BOT:-}"
+commit_email="${RT_COMMIT_EMAIL:-}"
 tasks_dir="${RT_TASKS_DIR:-}"
 archive_dir="${RT_ARCHIVE_DIR:-}"
 main_branch="${RT_MAIN_BRANCH:-main}"
@@ -94,7 +99,13 @@ main_branch="${RT_MAIN_BRANCH:-main}"
 # Обход требования: строка с причиной. Причина видна тому, кто вливает, поэтому обход законен.
 # Без причины это просто молчаливый пропуск, поэтому она обязательна. Порог в три знака — тот
 # же, что у гарда документа: если сделать по-разному, две формы одного обхода разойдутся.
-folder_skip_re='Task-folder-skip:[[:space:]]*[^[:space:]"'"'"']{3,}'
+#
+# Строка обхода начинает строку — свою в теле PR или комментарий в конце команды — и
+# подстановки не принимает. Без этих двух условий текст, который ОБЪЯСНЯЕТ, что обход называется
+# так-то, от самого обхода неотличим: тело PR со строкой-примером снимало требование само
+# собой, и тот же пример гард печатает в своём отказе ниже. Нашлось это приёмкой такого же
+# признака — прогон обязан был покраснеть на настоящем нарушении и остался зелёным.
+folder_skip_re='(^|#)[[:space:]]*Task-folder-skip:[[:space:]]*[^[:space:]<"'"'"'][^[:space:]"'"'"']{2,}'
 
 deny() {
     # Отказ гарда — наблюдение: гард, отбивающий чаще прочих, говорит, какое место поставки
@@ -109,7 +120,7 @@ deny() {
     exit 0
 }
 
-# Подсказка вместо отказа: на открытии отчёта папка ещё нужна. Решения подсказка не несёт,
+# Подсказка вместо отказа: на открытии PR папка ещё нужна. Решения подсказка не несёт,
 # команда идёт дальше своим ходом.
 hint() {
     jq -n --arg c "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:$c}}' 2>/dev/null
@@ -165,6 +176,66 @@ if [ -n "$branch_arg" ]; then
     exit 0
 fi
 
+# --- подпись машинного коммита ------------------------------------------------------------
+#
+# Служебный адрес хостинга состоит из числа, логина и домена, а сопоставляется по числу: логин
+# рядом с ним не сверяет никто. Коммит с чужим числом хостинг припишет постороннему человеку, и
+# изнутри это выглядит верным — имя учётной записи в истории то самое. Так одиннадцать коммитов
+# и уехали в главную ветку за чужой подписью; нашёл это владелец, читая историю глазами.
+#
+# Точка — пуш: до него подпись переписывается на месте всей веткой сразу, после — только силовой
+# отправкой. На коммите гард не стоит: почта задаётся переменными самой команды, и разбор её из
+# текста ловил бы ту же строку, которая и так перед глазами у набравшего её.
+#
+# Судится коммит, НАЗВАВШИЙСЯ машинной записью: её логин стоит именем автора либо левой частью
+# почты. Опознавать по самой почте нельзя — она в таком коммите как раз и неверна, а требовать
+# машинную подпись от каждого коммита значило бы отбивать работу, сделанную человеком своими
+# руками в том же дереве.
+#
+# Логин читается из объявленной почты, а не объявляется вторым свойством: два объявления одного
+# логина разошлись бы молча. Исполнителем задачи он тоже не бывает — в дереве, где хостинг
+# ограничил машинную запись, исполнителем ставят человека, а коммит остаётся машинным.
+#
+# Вызов пуша узнаётся по двум признакам сразу — команда `git` в начале строки или за
+# разделителем и слово `push` отдельным словом. Одной подстрокой «git push» его не поймать:
+# помощник учётных данных и заголовок запроса ставятся ключами `-c` между ними.
+# Пробный пуш не отправляет ничего, и подпись у него не спрашивают.
+if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git([[:space:]]|$)' \
+    && printf '%s' "$cmd" | grep -qE '(^|[[:space:]])push([[:space:]]|$)' \
+    && ! printf '%s' "$cmd" | grep -q -- '--dry-run'; then
+    # Два условия молчания. Дерево, не назвавшее почты машинной записи, требования не получает:
+    # своей машинной записи у пакета нет, а выдуманная отбивала бы работу в чужом дереве.
+    # Вершины главной ветки нет — вклад считать не от чего.
+    #
+    # Судится вклад ветки, а не вся история: влитое в главную этой веткой уже не чинится, и
+    # отказ за него отбивал бы работу вместо промаха.
+    if [ -n "$commit_email" ] \
+        && git rev-parse --verify --quiet "refs/remotes/origin/${main_branch}" >/dev/null 2>&1; then
+        # Левая часть служебного адреса: `<число>+<логин>` либо просто логин.
+        bot_login="${commit_email%%@*}"
+        bot_login="${bot_login##*+}"
+
+        strangers=''
+        while IFS="$(printf '\t')" read -r short author email; do
+            [ -z "$short" ] && continue
+            login="${email%%@*}"
+            login="${login##*+}"
+            [ "$author" = "$bot_login" ] || [ "$login" = "$bot_login" ] || continue
+            [ "$email" = "$commit_email" ] && continue
+            strangers="${strangers}${strangers:+, }${short} <${email}>"
+        done <<EOF
+$(git log --format='%h%x09%an%x09%ae' "origin/${main_branch}..HEAD" 2>/dev/null)
+EOF
+
+        [ -n "$strangers" ] \
+            && deny "BLOCKED: машинный коммит подписан не той почтой, что объявлена деревом. Хостинг сопоставляет служебный адрес по числу в нём, и коммит с чужим числом он припишет постороннему человеку — изнутри промах не виден, потому что имя учётной записи рядом верное. Расходятся: ${strangers}. Объявлено: ${commit_email} — почта берётся оттуда, а не набирается по памяти. Перепиши подпись до пуша, после него это чинит только силовая отправка:
+    последний коммит — GIT_AUTHOR_NAME=\"${bot_login}\" GIT_AUTHOR_EMAIL=\"${commit_email}\" GIT_COMMITTER_NAME=\"${bot_login}\" GIT_COMMITTER_EMAIL=\"${commit_email}\" git commit --amend --no-edit --reset-author
+    весь вклад ветки — git filter-branch -f --env-filter 'GIT_AUTHOR_EMAIL=\"${commit_email}\"; GIT_COMMITTER_EMAIL=\"${commit_email}\"' origin/${main_branch}..HEAD"
+    fi
+fi
+# Своего выхода у этой точки нет: пуш бывает и составной командой, а второе её звено судят
+# разделы ниже.
+
 # --- слияние заявки ----------------------------------------------------------------------
 #
 # Папку задачи разбирают тем же PR, что и работу. После слияния этого уже никто не сделает:
@@ -243,24 +314,46 @@ fi
 
 if [ -n "$title" ]; then
     printf '%s' "$title" | grep -qE "$title_re" \
-        || deny "BLOCKED: заголовок заявки не начинается с номера задачи. В списке заявок тела не видно, а строка связи живёт именно там — без номера в заголовке отчёт с задачей не сопоставить."
+        || deny "BLOCKED: заголовок заявки не начинается с номера задачи. В списке заявок тела не видно, а строка связи живёт именно там — без номера в заголовке PR с задачей не сопоставить."
     title_number="$(printf '%s' "$title" | sed -nE 's/^\[[A-Za-z]+-([0-9]+)\].*/\1/p')"
     if [ -n "$number" ] && [ -n "$title_number" ]; then
         [ "$title_number" = "$number" ] \
-            || deny "BLOCKED: в заголовке заявки номер ${title_number}, у ветки — ${number}. Задача, ветка и отчёт несут один и тот же номер."
+            || deny "BLOCKED: в заголовке заявки номер ${title_number}, у ветки — ${number}. Задача, ветка и PR несут один и тот же номер."
     fi
 fi
 
-# Главная ветка влита до открытия отчёта. Отчёт от разошедшейся ветки показывает ревьюверу свою
+# Главная ветка влита до открытия PR. PR от разошедшейся ветки показывает ревьюверу свою
 # правку вперемешку с чужой, а проверки на нём гоняются от устаревшего основания.
 #
-# Судится локальная вершина главной ветки, без сети: сетевой вызов в разборе команды падал бы
-# вместе со связью и отбивал бы работу вместо промаха. Отсюда и граница — гард ловит ветку,
-# отставшую заведомо; свежесть самой вершины держит `git fetch`, и требует его чеклист.
+# Ярусов два, и порядок между ними такой же, как у проверки задачи. Первый читает локальную
+# вершину и работает без сети. Второй спрашивает удалённую ссылку — без него молчание гарда
+# значит лишь «твоя ссылка не старше твоей ветки», а читается как «главная ветка влита»: ровно
+# так открытый PR и оказался конфликтующим, и узнал об этом владелец.
+#
+# Сеть здесь допустима по той же причине, по которой её зовёт проверка очереди работ ниже:
+# отсутствие ответа пропускается молча, и проверка, падающая в самолёте, не отбивает работу.
+# Предел ожидания задаётся переменными самого 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)"
-    deny "BLOCKED: «${main_branch}» ушла вперёд на ${behind:-несколько} коммитов, а в ветку не влита. Отчёт от разошедшейся ветки показывает ревьюверу правку вперемешку с чужой, а проверки на нём идут от устаревшего основания. Влей и повтори: git fetch origin && git merge origin/${main_branch} — порядок и разбор конфликта в паттерне git-workflow-merge."
+    deny "BLOCKED: «${main_branch}» ушла вперёд на ${behind:-несколько} коммитов, а в ветку не влита. PR от разошедшейся ветки показывает ревьюверу правку вперемешку с чужой, а проверки на нём идут от устаревшего основания. Влей и повтори: git fetch origin && git merge origin/${main_branch} — порядок и разбор конфликта в паттерне git-workflow-merge."
+fi
+
+# Второй ярус: локальная ссылка сама могла протухнуть. Ответа нет — ярус молчит.
+remote_main="$(GIT_HTTP_LOW_SPEED_LIMIT=1000 GIT_HTTP_LOW_SPEED_TIME=5 GIT_TERMINAL_PROMPT=0 \
+    git ls-remote origin "refs/heads/${main_branch}" 2>/dev/null | cut -f1)"
+local_main="$(git rev-parse --verify --quiet "refs/remotes/origin/${main_branch}" 2>/dev/null)"
+if [ -n "$remote_main" ] && [ -n "$local_main" ] && [ "$remote_main" != "$local_main" ]; then
+    # Возраст ссылки — то, чего исполнитель не видит вовсе, и именно он отличает «ветка
+    # отстала» от «я не знаю, отстала ли». Формат `stat` на BSD и на GNU разный, поэтому
+    # спрашиваются оба, а не угадывается система.
+    fetch_head="$(git rev-parse --git-dir 2>/dev/null)/FETCH_HEAD"
+    fetched_at="$(stat -f %m "$fetch_head" 2>/dev/null || stat -c %Y "$fetch_head" 2>/dev/null)"
+    age=''
+    if [ -n "$fetched_at" ]; then
+        age=" Последний git fetch — $(( ( $(date +%s) - fetched_at ) / 60 )) мин. назад."
+    fi
+    deny "BLOCKED: твоя ссылка origin/${main_branch} отстала от удалённой — ${local_main:0:8} против ${remote_main:0:8}.${age} Гард сравнивает ветку с тем, что лежит в дереве, поэтому молчание первого яруса значит «ссылка не старше ветки», а не «главная ветка влита». Влей и повтори: git fetch origin && git merge origin/${main_branch}."
 fi
 
 check_task "$number" "заявка с ветки «${branch}»"

package/assets/hooks/proposal-guard.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# rt-hook: Stop
+# Гард предложения: ход, в котором владелец сказал завести или отправить предложение слою правил,
+# не заканчивается, пока отправки не было. Stop.
+#
+# Зачем именно так. Написанное и не отправленное лежит в дереве неотличимо от отправленного:
+# своей записи в слое правил у него нет, и владелец читает работу сделанной, пока не спросит
+# прямо. Отправка при этом неудобна ровно в одном месте — она пишет отметки в файлы предложений и
+# делает дерево грязным, — и этим доводом исполнитель закрывает молчание правил.
+#
+# Ловится просьба образцами, а не пониманием смысла: оценку «владелец просил отправить» назначал
+# бы тот, кому она мешает. Глагол обязателен: «разбери пропозалы» — работа над уже приехавшими, и
+# отправкой она не кончается. Слово «предложение» само по себе не считается тоже — оно ходит в
+# каждом втором ходе о другом, и рядом с ним нужно слово о слое правил или о пакете.
+#
+# Отправкой считается вызов команды пакета без сухого прогона, сделанный в том же ходе: сухой
+# прогон показывает, что уехало бы, ничего не заводит и следа наружу не оставляет.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
+# заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
+
+input="$(cat 2>/dev/null)"
+[ -z "$input" ] && exit 0
+
+command -v jq >/dev/null 2>&1 || exit 0
+
+# Повторный заход по тому же ходу не судится: гард сказал своё один раз и отпускает.
+active="$(printf '%s' "$input" | jq -r '.stop_hook_active // false' 2>/dev/null)"
+[ "$active" = "true" ] && exit 0
+
+transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)"
+[ -z "$transcript" ] && exit 0
+[ -f "$transcript" ] || exit 0
+
+# Каталог предложений у дерева свой. Заданный пустым — отказ дерева от требования: дереву, не
+# берущему переносимый слой правил, гард не навязывается.
+proposals_dir="${RT_PROPOSALS_DIR-.claude/rt-kit/proposals}"
+[ -z "$proposals_dir" ] && exit 0
+
+# Просьба владельца. Набор открыт и пополняется правкой: полнота его — открытый вопрос
+# договорённости, а не обещание.
+asked_re='(завед|напиш|отправ|пошл|зашл|отошл|выгруз)[а-яё]*[^.!?]{0,40}(пропозал|предложени)|(пропозал|предложени)[а-яё]*[^.!?]{0,40}(завед|напиш|отправ|пошл|зашл|отошл|выгруз)'
+
+# Сосед, без которого слово «предложение» не считается просьбой о слое правил.
+context_re='пропозал|слою правил|слоя правил|слой правил|пакет|agent-kit|наверх'
+
+# Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
+# приходит той же ролью, поэтому строки с `tool_result` вводом не считаются.
+#
+# Хвост в 400 строк: запись хода растёт всю сессию, а судится только последний ход.
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg asked "$asked_re" --arg ctx "$context_re" '
+    def is_input:
+        .type == "user"
+        and (((.message.content // []) | if type == "array"
+                then ([.[] | select(.type == "tool_result")] | length)
+                else 0 end) == 0);
+
+    def text_of:
+        (.message.content // []) | if type == "array"
+            then ([.[] | select(.type == "text") | .text] | join("\n"))
+            else (. // "") end;
+
+    (map(is_input) | rindex(true)) as $i
+    | (if $i == null then [] else .[$i:] end) as $turn
+    | (if $i == null then "" else ($turn[0] | text_of) end) as $said
+    | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "tool_use")] as $uses
+    # Признак нечувствителен к регистру флагом, а не приведением: приведение знает только
+    # латиницу, и «Отправь Пропозал» с большой буквы проходило бы мимо набора образцов молча.
+    | (($said | test($asked; "i")) and ($said | test($ctx; "i"))) as $wanted
+    | ($uses | map(
+          ((.name // "") | test("^Bash$"))
+          and ((.input.command // "") | test("agent-kit[^|;&]*propose"))
+          and ((.input.command // "") | test("--dry-run") | not)
+      ) | any) as $sent
+    | if $wanted and ($sent | not) then "owe" else "pass" end
+' 2>/dev/null)"
+
+[ "$verdict" = "owe" ] || exit 0
+
+reason="BLOCKED by proposal-guard: владелец сказал завести или отправить предложение слою правил, а отправки в этом ходе не было. Написанное и не отправленное лежит в дереве неотличимо от отправленного: своей записи в слое правил у него нет, и владелец читает работу сделанной, пока не спросит прямо.
+
+Предложение пишется файлом в \`$proposals_dir/\` и уезжает в тот же ход:
+
+    npx agent-kit propose
+
+Сухой прогон отправкой не является: он показывает, что уехало бы, и следа наружу не оставляет. Отправка пишет отметки в файлы предложений и делает дерево грязным — при открытом PR они ложатся вторым коммитом в ту же ветку, и это их место, а не повод отложить.
+
+Гард судит один ход: следующий заход не отбивается."
+
+jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+    || printf '{"decision":"block","reason":"proposal-guard: владелец просил предложение — отправь его командой пакета."}\n'
+
+exit 0

package/assets/hooks/reuse-first-guard.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|mcp__webstorm__create_new_file
+# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/profile-check.sh
 # Гард «ничего не пишется с нуля». PreToolUse на правке кода и разметки.
 #
@@ -38,14 +38,60 @@ command -v jq >/dev/null 2>&1 || exit 0
 command -v perl >/dev/null 2>&1 || exit 0
 
 tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
+shell_cmd=""
 case "$tool" in
     # Инструмент среды заводит файл теми же двумя данными, только называет их иначе — без этой
     # ветки файл заводился мимо всех проверок.
     Edit | Write | MultiEdit | mcp__webstorm__create_new_file) ;;
+    # Команда оболочки, которая пишет файл, — та же правка. Без этой ветки гард обходится
+    # сменой не инструмента, а способа записи; текстом правки тогда служит сама команда, и
+    # заведённое ею в heredoc читается наравне с телом правки. Разбор —
+    # `2026-08-15-guard-denied-shell-wrote-anyway.md`.
+    #
+    # Терминал среды исполняет ту же командную строку и кладёт её в то же поле: без этих двух
+    # имён гард стоял бы объявленным на них и молча пропускал — состояние хуже необъявленного,
+    # потому что снаружи выглядит закрытым.
+    Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
+        shell_cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+        [ -z "$shell_cmd" ] && exit 0
+        # Универсальный исполнитель прячет настоящую команду во вложенной строке: без её разбора
+        # путь стоит за кавычкой, и до него не дотягивается ни один образец.
+        if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
+            inner="$(printf '%s' "$shell_cmd" | perl -0ne '
+                if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+                    print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                }
+            ' 2>/dev/null)"
+            [ -n "$inner" ] && shell_cmd="$inner"
+        fi
+        ;;
     *) exit 0 ;;
 esac
 
-path="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+# Читается до разбора пути: пути из команды оболочки вынимает как раз профиль.
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+if [ -n "$shell_cmd" ]; then
+    command -v rt_shell_writes >/dev/null 2>&1 && command -v rt_shell_paths >/dev/null 2>&1 || exit 0
+    rt_shell_writes "$shell_cmd" || exit 0
+    # Из команды берётся первый путь, чьё расширение гарду интересно: остальные ему безразличны.
+    path=""
+    while IFS= read -r candidate; do
+        case "$candidate" in
+            *.html | *.scss | *.ts) path="$candidate"; break ;;
+        esac
+    done <<EOF
+$(rt_shell_paths "$shell_cmd")
+EOF
+    [ -z "$path" ] && exit 0
+else
+    path="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+fi
 # Путь от корня дерева приводится к абсолютному один раз, чтобы образцы не двоились.
 case "$path" in
     /*) ;;
@@ -56,13 +102,6 @@ case "$path" in
     *) exit 0 ;;
 esac
 
-# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
-rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
-    # shellcheck disable=SC1090
-    [ -f "$profile" ] && . "$profile" 2>/dev/null
-done
-
 # Слово о нехватке функции профиля: хук, вышедший молча, неотличим от работающего. Файл может
 # быть не разложен — тогда остаётся прежнее поведение, молчаливое.
 # shellcheck disable=SC1090
@@ -82,11 +121,16 @@ if [ -n "${RT_REUSE_SKIP_RE:-}" ] && printf '%s' "$path" | grep -qE "$RT_REUSE_S
     exit 0
 fi
 
-# Только новый текст: строка, уже лежавшая в файле, этой правкой не заводилась.
-added="$(printf '%s' "$input" | jq -r '
-    [ .tool_input.content?, .tool_input.text?, .tool_input.new_string?, (.tool_input.edits[]?.new_string) ]
-    | map(select(. != null)) | join("\n")
-' 2>/dev/null)"
+# Только новый текст: строка, уже лежавшая в файле, этой правкой не заводилась. У команды
+# оболочки таким текстом служит она сама: что она кладёт в файл, лежит в ней же.
+if [ -n "$shell_cmd" ]; then
+    added="$shell_cmd"
+else
+    added="$(printf '%s' "$input" | jq -r '
+        [ .tool_input.content?, .tool_input.text?, .tool_input.new_string?, (.tool_input.edits[]?.new_string) ]
+        | map(select(. != null)) | join("\n")
+    ' 2>/dev/null)"
+fi
 [ -z "$added" ] && exit 0
 
 # Явный отказ от правила: готового такого нет, автор это осознал и пометил. Считается по
@@ -138,11 +182,19 @@ has_re() {
 rt_checks_json="${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/checks.json"
 rt_bundles=''
 rt_own_signals=''
+rt_backend_roots=''
 if [ -f "$rt_checks_json" ]; then
     rt_bundles="$(jq -r '.reuse.bundles[]? // empty' "$rt_checks_json" 2>/dev/null | tr '\n' ' ')"
     own="$(jq -r '.reuse.signals // empty' "$rt_checks_json" 2>/dev/null)"
     [ -n "$own" ] && rt_own_signals="${CLAUDE_PROJECT_DIR:-.}/$own"
+    # Тем же ключом, каким их читает сплошная проверка: второе объявление тех же корней
+    # разошлось бы с первым молча.
+    rt_backend_roots="$(jq -r '.backendRoots[]? // empty' "$rt_checks_json" 2>/dev/null | tr '\n' ' ')"
 fi
+
+# Путь от корня дерева: образец в признаке пишет дерево, и писать его от корня машины оно не
+# может. Абсолютный путь нужен только для чтения файла с диска.
+rel_path="${path#"${CLAUDE_PROJECT_DIR:-.}"/}"
 rt_signals_dir="${CLAUDE_PROJECT_DIR:-.}/${RT_REUSE_SIGNALS_DIR:-tools/signals}"
 
 # Признаки объявленных наборов: те же файлы читает сплошная проверка. Ключ признака совпал с
@@ -172,9 +224,25 @@ while IFS= read -r signal; do
         '') ;;
         *) case "$path" in *"$ext") ;; *) continue ;; esac ;;
     esac
+    # Пропуск корней бэкенда: признак, объявленный с ним, на бэкенде не действует вовсе — там
+    # принят другой способ, и базового класса, которого признак требует, у бэкенда нет. Поле
+    # читает и сплошная проверка; читать его одному из двоих значит отбивать гардом ту самую
+    # правку, которую проверка пропускает, — а провести её больше нечем: маркер отступления
+    # объявляет обход готового, а обхода тут не было.
+    if [ "$(field "$signal" '.skipBackendRoots')" = 'true' ] && [ -n "$rt_backend_roots" ]; then
+        skip_backend=''
+        for backend_root in $rt_backend_roots; do
+            case "$rel_path" in "$backend_root"*) skip_backend=1 ;; esac
+        done
+        [ -n "$skip_backend" ] && continue
+    fi
+
+    # Образец имени сверяется с путём от корня дерева, а не с именем файла: слои, которые
+    # признак и разделяет, зовут свои файлы одинаково, и по имени они неразличимы. Сплошная
+    # проверка сверяет с путём — расходиться им нельзя.
     only_named="$(field "$signal" '.onlyNamed')"
     if [ -n "$only_named" ]; then
-        printf '%s' "${path##*/}" | grep -qE "$only_named" || continue
+        printf '%s' "$rel_path" | grep -qE "$only_named" || continue
     fi
 
     case "$(field "$signal" '.scope')" in

package/assets/hooks/skill-gate-layers.sh

@@ -124,7 +124,7 @@ esac
 
 # --- слой по пути: ведение работы -------------------------------------------------------------
 #
-# Папка задачи, договорённость о продукте до кода и линия работ — первые файлы, которые
+# Папка задачи, договорённость о продукте до кода и замысел эпика — первые файлы, которые
 # заводятся в работе. Требование ловит на них того, кто пошёл мимо порядка: «пришла новая
 # задача» инструментом не является, и поймать это больше нечем.
 case "$target" in

package/assets/hooks/skill-gate.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash
+# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Гейт правил: не даёт править файл, пока не загружено правило, под которое он подпадает.
 #
 # Закон и правило, которых никто не открывает, не действуют. Напоминание в подсказке помогает
@@ -90,6 +90,32 @@ case "$tool" in
         fi
         req="$(skill_for bash "$target" "" 2>/dev/null)"
         kind="command"
+        # Команда оболочки, которая пишет файл, — та же правка, и правило ей нужно то же.
+        # Без этого яруса гейт обходится сменой не инструмента, а способа записи: отбитая
+        # правка легла командой дважды за один заход. Разбор —
+        # `2026-08-15-guard-denied-shell-wrote-anyway.md`.
+        for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
+            # shellcheck disable=SC1090
+            [ -f "$profile" ] && . "$profile" 2>/dev/null
+        done
+        if command -v rt_shell_writes >/dev/null 2>&1 && command -v rt_shell_paths >/dev/null 2>&1 \
+            && rt_shell_writes "$target"; then
+            while IFS= read -r written_path; do
+                [ -z "$written_path" ] && continue
+                case "$written_path" in
+                    /*) ;;
+                    *) written_path="${CLAUDE_PROJECT_DIR:-.}/$written_path" ;;
+                esac
+                case "$written_path" in
+                    "${CLAUDE_PROJECT_DIR:-.}"/*) ;;
+                    *) continue ;;
+                esac
+                more="$(skill_for edit "$written_path" "" 2>/dev/null)"
+                [ -n "$more" ] && req="$req $more"
+            done <<EOF
+$(rt_shell_paths "$target")
+EOF
+        fi
         ;;
     mcp__claude-in-chrome__*)
         req="$(skill_for browser "$tool" "" 2>/dev/null)"

package/assets/hooks/task-flow-guard.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit
+# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/profile-check.sh
 # PreToolUse guard for Edit|Write|MultiEdit: код не пишется раньше замысла.
 #
 # Работа идёт много заходов, и между ними исполнитель не помнит ничего. Замысел, лежащий на
 # диске, — единственное, что переживает перерыв: изменения к этому моменту бывают не
-# закоммичены, отчёт не открыт, а очередь работ показывает задачу начатой и молчит о том, что
+# закоммичены, PR не открыт, а очередь работ показывает задачу начатой и молчит о том, что
 # внутри неё сделано.
 #
 # Гард требует три вещи и ровно их: папку задачи по имени ветки, замысел в ней и названную в
@@ -24,22 +24,8 @@ input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
-tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
-case "$tool" in
-    # Инструмент редактора заводит файл теми же двумя данными, только называет их иначе —
-    # без этой ветки правка шла бы мимо гарда сменой инструмента.
-    Edit | Write | MultiEdit | mcp__webstorm__create_new_file) ;;
-    *) exit 0 ;;
-esac
-
-path="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
-[ -z "$path" ] && exit 0
-case "$path" in
-    /*) ;;
-    ?*) path="${CLAUDE_PROJECT_DIR:-.}/$path" ;;
-esac
-
 # Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+# Читается до разбора пути: пути из команды оболочки вынимает как раз профиль.
 rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
     # shellcheck disable=SC1090
@@ -52,12 +38,66 @@ 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; }
 
+tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
+candidates=""
+case "$tool" in
+    # Инструмент редактора заводит файл теми же двумя данными, только называет их иначе —
+    # без этой ветки правка шла бы мимо гарда сменой инструмента.
+    Edit | Write | MultiEdit | mcp__webstorm__create_new_file)
+        candidates="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+        ;;
+    # Второй ярус: та же правка, положенная командой оболочки. Без него отказ гарда обходится
+    # сменой не инструмента, а способа записи — перенаправлением, `sed -i`, интерпретатором с
+    # heredoc. Разбор — `2026-08-15-guard-denied-shell-wrote-anyway.md`.
+    #
+    # Терминал среды исполняет ту же командную строку и кладёт её в то же поле: без этих двух
+    # имён гард стоял бы объявленным на них и молча пропускал — состояние хуже необъявленного,
+    # потому что снаружи выглядит закрытым.
+    Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
+        cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+        [ -z "$cmd" ] && exit 0
+        # Универсальный исполнитель прячет настоящую команду во вложенной строке: без её разбора
+        # путь стоит за кавычкой, и до него не дотягивается ни один образец.
+        if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
+            inner="$(printf '%s' "$cmd" | perl -0ne '
+                if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+                    print defined $1 ? $1 : (defined $2 ? $2 : $3);
+                }
+            ' 2>/dev/null)"
+            [ -n "$inner" ] && cmd="$inner"
+        fi
+        rt_needs rt_shell_writes task-flow-guard || exit 0
+        rt_needs rt_shell_paths task-flow-guard || exit 0
+        rt_shell_writes "$cmd" || exit 0
+        candidates="$(rt_shell_paths "$cmd")"
+        ;;
+    *) exit 0 ;;
+esac
+[ -z "$candidates" ] && exit 0
+
 # Признак «правка меняет поведение» — путь, а не оценка на глаз: оценку назначает тот, кому
 # она мешает, и порог плывёт. Где живёт код приложения, знает профиль: правила, тексты, обвязка
 # и зависимости под требование не попадают — иначе разбор задачи нельзя было бы вести до
 # заведения ветки.
 rt_needs rt_is_app_code task-flow-guard || exit 0
-rt_is_app_code "$path" || exit 0
+
+# Судится каждый названный путь: команда пишет столько файлов, сколько в ней стоит, и одного
+# под требованием довольно, чтобы отбить её целиком.
+path=""
+while IFS= read -r candidate; do
+    [ -z "$candidate" ] && continue
+    case "$candidate" in
+        /*) ;;
+        *) candidate="${CLAUDE_PROJECT_DIR:-.}/$candidate" ;;
+    esac
+    if rt_is_app_code "$candidate"; then
+        path="$candidate"
+        break
+    fi
+done <<EOF
+$candidates
+EOF
+[ -z "$path" ] && exit 0
 
 # Каталог папок задач: у дерева он свой, но имя обычно общее.
 tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
@@ -113,7 +153,7 @@ fi
 
 # Договорённость, влитая в спек домена, с диска уходит — так и задумано: в главной ветке
 # директории «предложено» быть не должно. Но замысел на неё ссылается до конца работы, и без
-# этой развилки последний коммит отчёта запирал бы ветку: ни правки по замечаниям разбора, ни
+# этой развилки последний коммит PR запирал бы ветку: ни правки по замечаниям разбора, ни
 # записи в журнал изменений после вливания уже не сделать.
 #
 # Влитое от незаведённого отличает история ветки: путь, которого в ней никогда не было,