@rt-tools/agent-kit 0.16.1 → 0.18.0

package/assets/hooks/browser-guard-device-id.sh

@@ -17,13 +17,16 @@
 rt_hook_read
 input="$RT_HOOK_INPUT"
 
-device_id="$("${CLAUDE_PROJECT_DIR:-.}/.claude/hooks/browser-device-id.sh" 2>/dev/null)"
+# Признак сессии помощнику передаётся: без него слово о ненастроенном дереве метится днём и
+# приходит один раз в сутки, а не один раз за заход.
+sid="$(printf '%s' "$input" | jq -r '.session_id // "nosession"' 2>/dev/null)"
+
+device_id="$("${CLAUDE_PROJECT_DIR:-.}/.claude/hooks/browser-device-id.sh" "$sid")"
 [ -z "$device_id" ] && exit 0
 
 requested="$(printf '%s' "$input" | jq -r '.tool_input.deviceId // empty' 2>/dev/null)"
 
 if [ "$requested" = "$device_id" ]; then
-    sid="$(printf '%s' "$input" | jq -r '.session_id // "nosession"' 2>/dev/null)"
     marker_dir="${TMPDIR:-/tmp}/claude-browser-guard"
     mkdir -p "$marker_dir" 2>/dev/null && : >"$marker_dir/${sid}" 2>/dev/null
     exit 0

package/assets/hooks/browser-guard-no-other-drivers.sh

@@ -1,12 +1,18 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse mcp__playwright__.*|mcp__chrome-devtools__.*|Bash
+# rt-hook: PreToolUse mcp__playwright__.*|mcp__chrome-devtools__.*|Bash|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/deny-tail.sh
 # Гард обходных путей к браузеру. PreToolUse.
 #
 # Закрепление профиля чего-то стоит только тогда, когда дверь одна. Здесь перечислены двери,
 # которые обходят её целиком и закреплённый профиль не спрашивают вовсе: второй драйвер,
 # третий драйвер, открытие ссылки средствами системы, управление браузером через сценарий
-# автоматизации, отдельная утилита и прямой запуск бинарника.
+# автоматизации, отдельная утилита, прямой запуск бинарника и браузер, поднятый библиотекой
+# изнутри скрипта.
+#
+# Последняя дверь в строке команды не видна вовсе: там стоят имя интерпретатора и путь файла, а
+# вождение лежит внутри самого файла. Поэтому судится и содержимое запускаемого файла, и код,
+# переданный доводом вместо файла, — на известные точки входа браузерных библиотек. Так
+# закреплённый профиль обошли дважды за один заход, и не остановило ничто.
 #
 # Написание сквозных спек при этом остаётся законным: прогон спеки не выдаёт агенту
 # интерактивный браузер. Отбиваются только глаголы вождения.
@@ -86,4 +92,37 @@ printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(/[^[:space:]]*/)?(google-chrome|c
 printf '%s' "$cmd" | grep -qF 'Google Chrome.app/Contents/MacOS' \
     && deny "Прямой запуск бинарника браузера обходит закреплённый профиль."
 
+# Точки входа браузерных библиотек — то, чем браузер поднимают из кода. Перечислены и глагол
+# запуска, и глагол присоединения к уже поднятому: второй обходит профиль ровно так же.
+launch='(chromium|firefox|webkit|browserType|puppeteer|chromeLauncher)[[:space:]]*\.[[:space:]]*(launch|connect)|launchPersistentContext|webdriver\.(Chrome|Firefox)|chrome-launcher'
+
+# Код, переданный доводом вместо файла. Судится только вместе с именем интерпретатора и его
+# флагом кода: голый образец отбивал бы и поиск по дереву, в котором такое слово просто ищут.
+if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(node|bun|deno|python3?)([[:space:]]+-[^[:space:]]+)*[[:space:]]+(-e|--eval|-c|-p|--print)[[:space:]]" \
+    && printf '%s' "$cmd" | grep -qE "$launch"; then
+    deny "Браузер, поднятый библиотекой из кода довода, закреплённый профиль не спрашивает."
+fi
+
+# Файлы, которые команда запускает интерпретатором. Обёртки менеджеров пакетов снимаются: под
+# ними стоит тот же интерпретатор, а видеть его надо в позиции команды.
+launched="$(printf '%s' "$cmd" | sed -E '
+        s/(^|[[:space:]])(npx|bunx)[[:space:]]+/\1/g
+        s/(^|[[:space:]])(pnpm|npm|yarn)[[:space:]]+(exec|dlx)[[:space:]]+/\1/g
+        s/(^|[[:space:]])deno[[:space:]]+run[[:space:]]+/\1deno /g
+    ' | tr '|&;' '\n\n\n' | sed -nE '
+        s/.*(^|[[:space:]])(node|bun|deno|tsx|ts-node|python3?)[[:space:]]+((-[^[:space:]]+|[A-Za-z_][A-Za-z0-9_]*=[^[:space:]]+)[[:space:]]+)*([^[:space:]]+).*/\5/p
+    ' | tr -d "\"'\`")"
+
+cwd="$(rt_hook_cwd)"
+for file in $launched; do
+    for base in '' "${cwd:-.}/" "${CLAUDE_PROJECT_DIR:-.}/"; do
+        path="${base}${file}"
+        [ -f "$path" ] || continue
+        if head -c 200000 "$path" 2>/dev/null | grep -qE "$launch"; then
+            deny "Браузер, поднятый библиотекой изнутри ${file}, закреплённый профиль не спрашивает."
+        fi
+        break
+    done
+done
+
 exit 0

package/assets/hooks/claim-guard.sh

@@ -22,6 +22,12 @@
 # сверять. Эти случаи держит правило ведения работы, и это известная граница гарда, а не
 # обещание.
 #
+# Не судится и чужое слово: цитата в кавычках, вопрос экзаменатора, пересказ чужого текста,
+# строка кода и предложение в условном наклонении утверждением о дереве не являются. Отбитые
+# за них ходы обходятся дороже пропущенных: гард, отбивающий цитату, учит не проверять дерево,
+# а не писать кавычек. Поэтому перед разбором из сказанного вынимаются кавычки, код, строки
+# цитирования и предложения со словом условия.
+#
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода или пустом
 # тексте ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
@@ -95,6 +101,19 @@ said="$(printf '%s' "$turn" | jq -r '.said // ""' 2>/dev/null)"
 ran="$(printf '%s' "$turn" | jq -r '.ran // ""' 2>/dev/null)"
 [ -z "$said" ] && exit 0
 
+# Чужое слово вынимается до разбора. Строка цитирования и блок кода уходят целиком, кавычки и
+# код в строке гасятся пробелом, а предложения со словом условия отбрасываются: «прогнал бы» и
+# «если бы линт был зелёным» о состоянии дерева не говорят ничего.
+judged="$(printf '%s\n' "$said" \
+    | awk 'BEGIN { code = 0 }
+        /^[[:space:]]*```/ { code = !code; next }
+        !code && !/^[[:space:]]*>/' \
+    | sed -E 's/`[^`]*`/ /g; s/«[^»]*»/ /g; s/"[^"]*"/ /g' \
+    | sed -E 's/([.!?])[[:space:]]+/\1\'$'\n''/g' \
+    | grep -viE '(^|[[:space:]])(бы|если|разве|неужели|ли)([[:space:]]|[,.]|$)' 2>/dev/null)"
+[ -z "$judged" ] && exit 0
+said="$judged"
+
 # Карта утверждений: что сказано о дереве | чем это показывают | что назвать в отказе.
 #
 # Слово берётся в той форме, в какой его говорят владельцу. Будущее время сюда не идёт:
@@ -128,7 +147,9 @@ for row in "${claims[@]}"; do
 
 Утверждение о дереве стоит ровно столько, сколько команда, его показавшая: сказанное без команды владелец читает как проверенный факт и узнаёт о расхождении последним.
 
-Запусти ${name} этим же ходом и назови её вывод — либо убери утверждение из ответа.
+Первый выход — убрать утверждение из ответа и сказать о сделанном без него. Он же и верный там, где владелец команды не просил: запуск ради снятия отказа бывает опаснее того, что гард стережёт, — так ход, которому нечего было поставлять, дошёл до пуша.
+
+Второй — запустить ${name} этим же ходом и назвать её вывод.
 
 Гард судит один ход: следующий заход не отбивается."
 

package/assets/hooks/docs-guard.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
+# rt-hook: PreToolUse Edit|Write|MultiEdit|NotebookEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Требует: hooks/profile-check.sh, hooks/deny-tail.sh
 # Гард пары «правка и её документ». PreToolUse.
 #

package/assets/hooks/exam-guard.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse Edit|Write|MultiEdit|mcp__webstorm__create_new_file|Bash
-# Требует: agents/strict-teacher.md, hooks/roles.sh, hooks/deny-tail.sh
+# rt-hook: PreToolUse Edit|Write|MultiEdit|mcp__webstorm__create_new_file|Bash|mcp__webstorm__execute_terminal_command
+# Требует: agents/strict-teacher.md, hooks/roles.sh, hooks/deny-tail.sh, hooks/write-targets.sh
 # Гард экзамена: правка не идёт, пока за сессию не сдан экзамен по загруженным правилам.
 #
 # Зачем именно так. Гейт правил требует загрузить правило перед правкой и на этом кончается:
@@ -15,6 +15,21 @@
 # между вопросами и ответами не должно быть чтения тех же правил. Признак грубый и своей границы
 # не скрывает: чтение соседнего правила он засчитает списыванием тоже.
 #
+# Вердикт ищется во всех формах записи хода, а не в одной. Форму доставки выбирает хост: роль,
+# работающая фоном, отдаёт результат уведомлением о завершении, и записи вида «ответ инструмента»
+# у неё нет вовсе. Дерево, где роль так и работает, гард запер целиком — пять кругов экзамена с
+# полным вердиктом не отпустили ни одной правки; разбор — в описаниях происшествий.
+#
+# Отброшены при этом две формы, и обе намеренно. Свой текст помощника вердиктом не бывает:
+# написать нужную строку в ответе стоит одного движения. Ответы инструментов чтения и записи —
+# тоже: печать той же строки эхом или чтение файла с нею проходили бы гард, то есть единственным
+# достижимым способом стала бы подделка. Засчитывается ответ инструмента, который читать и
+# писать файлы не умеет, — им роль и запускают.
+#
+# Из-под гарда выведены настройка дерева, её надстройки и передача захода: настройка, которой
+# гард выключается, этим гардом не запирается — иначе выхода из отказа нет вовсе. Отправка груза
+# в приём заперта была той же дырой: адрес приёма живёт в той же настройке.
+#
 # FAIL-OPEN: нет jq, нет записи хода, чужой инструмент → пропуск. Сломанный гард не должен
 # мешать работать.
 
@@ -34,16 +49,46 @@ rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 [ -f "$rt_hooks_dir/roles.sh" ] && . "$rt_hooks_dir/roles.sh" 2>/dev/null
 command -v rt_role_off >/dev/null 2>&1 && rt_role_off strict-teacher && exit 0
 
+# Цели записи разбирает общий помощник — тот же, которым их разбирает гард места правки.
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/write-targets.sh" ] && . "$rt_hooks_dir/write-targets.sh" 2>/dev/null
+command -v rt_write_targets >/dev/null 2>&1 || rt_write_targets() { cat >/dev/null; }
+
+# Пути, которые гард не судит: настройка дерева, её надстройки и каталог передачи захода.
+# Печатает «да», если все названные цели выведены из-под гарда.
+rt_exam_free_paths() {
+    free=1
+    while IFS= read -r target; do
+        [ -z "$target" ] && continue
+        case "$target" in
+            *.claude/rt-kit.json | *.claude/rt-kit/* | *.claude/handoff/*) ;;
+            *) free=0 ;;
+        esac
+    done
+    [ "$free" = "1" ] && printf 'да'
+}
+
 tool="$(rt_hook_tool)"
 # Второй экзамен спрашивается на снятии черновика: работа кончилась, и правила поставки к этому
 # моменту читались давно — между их чтением и этой минутой прошёл весь заход.
 ready=0
 case "$tool" in
-    Edit | Write | MultiEdit | mcp__webstorm__create_new_file) ;;
-    Bash)
+    Edit | Write | MultiEdit | mcp__webstorm__create_new_file)
+        target="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+        [ -n "$target" ] && [ "$(printf '%s\n' "$target" | rt_exam_free_paths)" = "да" ] && exit 0
+        ;;
+    Bash | mcp__webstorm__execute_terminal_command)
         cmd="$(rt_hook_cmd)"
-        printf '%s' "$cmd" | grep -qE 'pr[[:space:]]+ready|mr[[:space:]]+update[^|;&]*--ready' || exit 0
-        ready=1
+        if printf '%s' "$cmd" | grep -qE 'pr[[:space:]]+ready|mr[[:space:]]+update[^|;&]*--ready'; then
+            ready=1
+        else
+            # Запись файла вызовом оболочки судится наравне с правкой: закрытый честный путь при
+            # открытом обходном означает, что гард держит того, кто правилам следует, и пропускает
+            # того, кто их обходит.
+            targets="$(printf '%s' "$cmd" | rt_write_targets)"
+            [ -z "$targets" ] && exit 0
+            [ "$(printf '%s\n' "$targets" | rt_exam_free_paths)" = "да" ] && exit 0
+        fi
         ;;
     *) exit 0 ;;
 esac
@@ -70,11 +115,39 @@ deny() {
 
 # Судится вся сессия, а не последний ход: экзамен сдаётся один раз на старте и держится до конца.
 verdict="$(jq -s -r '
-    [.[] | select(.type == "user") | .message.content // [] | select(type == "array") | .[]
-       | select(.type == "tool_result") | .content
-       | if type == "string" then .
-         elif type == "array" then (map(if type == "object" then (.text // "") else tostring end) | join("\n"))
-         else tostring end] | join("\n")
+    def textof:
+        if type == "string" then .
+        elif type == "array" then (map(if type == "object" then (.text // "") else tostring end) | join("\n"))
+        else tostring end;
+
+    # Инструменты, читающие и пишущие файлы: их ответ вердиктом не считается — иначе печать той
+    # же строки эхом и чтение файла с нею проходят гард, а настоящий вердикт не проходит.
+    ["Bash", "Read", "Grep", "Glob", "Edit", "Write", "MultiEdit", "NotebookEdit"] as $mute
+    | [.[] | select(.type == "assistant") | (.message.content // [])[]
+         | select(.type == "tool_use") | select(.name as $n | $mute | index($n) != null) | (.id // "")] as $muted
+
+    | [ .[]
+        # Свой текст помощника вердиктом не бывает: написать нужную строку в ответе стоит одного
+        # движения.
+        | if .type == "assistant" then ""
+          elif .type == "user" then
+              ([ ((.message.content // []) | if type == "array" then .[] else empty end
+                    | select(.type == "tool_result")
+                    | select(((.tool_use_id // "") as $i | $muted | index($i)) == null)
+                    | .content | textof),
+                 ((.message.content // "") | if type == "string" then . else "" end),
+                 # Поле результата вызова: та же запись, другая форма. Отбрасывается, только
+                 # если этот результат принадлежит инструменту чтения или записи.
+                 (. as $rec
+                  | if ($rec.toolUseResult // null) == null then ""
+                    elif ([($rec.message.content // []) | if type == "array" then .[] else empty end
+                            | select(.type == "tool_result") | (.tool_use_id // "")]
+                          | map($muted | index(.)) | any(. != null)) then ""
+                    else ($rec.toolUseResult | textof) end)
+               ] | join("\n"))
+          # Записи хоста — уведомление о завершении роли и вложение: форму их выбирает хост, и
+          # засчитываются они целиком.
+          else tostring end ] | join("\n")
     | [scan("ЭКЗАМЕН:[[:space:]]*сдано[[:space:]]*([0-9]+)[[:space:]]*из[[:space:]]*([0-9]+)")]
     | if length == 0 then "нет"
       else (.[-1] | if .[0] == .[1] then "сдан" else "провален" end)
@@ -120,6 +193,6 @@ case "$verdict" in
         deny "BLOCKED by exam-guard: экзамен по загруженным правилам провален. Перечитай правило целиком — не тот кусок, о котором спрашивали, — и позови роль strict-teacher снова. Показанный ответ даёт знание одной строки, а не правила."
         ;;
     *)
-        deny "BLOCKED by exam-guard: за эту сессию экзамена по загруженным правилам не было. Позови роль strict-teacher, передай ей список загруженных правил, ответь на её вопросы по памяти и верни ей ответы — вердикт она отдаёт строкой «ЭКЗАМЕН: сдано N из 5». Загруженное правило и прочитанное правило — разные вещи, и цену этой разницы платит владелец."
+        deny "BLOCKED by exam-guard: за эту сессию экзамена по загруженным правилам не было. Позови роль strict-teacher, передай ей список загруженных правил, ответь на её вопросы по памяти и верни ей ответы — вердикт она отдаёт строкой «ЭКЗАМЕН: сдано N из 5». Засчитывается он из ответа роли в любой форме, какой его доставил хост, но не из вывода оболочки и не из твоего же текста: печать этой строки эхом гард не отпускает. Роль уже звали и вердикт получен — значит, он пришёл формой, которой гард не видит: это дефект гарда, и правка `.claude/rt-kit.json` из-под него выведена. Загруженное правило и прочитанное правило — разные вещи, и цену этой разницы платит владелец."
         ;;
 esac

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

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# Конфликтующая своя заявка для гарда поставки: пока хоть одна отданная работа помечена
+# конфликтующей, новая не берётся.
+#
+# Строки `# rt-hook:` здесь нет намеренно: событие и образец вызова объявляет сам гард, а
+# помощник рядом хуком не регистрируется и в одиночку ничего не решает. Он зовётся из гарда,
+# пользуется его переменными и его отказом — тем же приёмом, что помощники папки и подписи.
+#
+# Зачем именно так. Гард поставки стоит в трёх точках и в каждой требует того, что в эту минуту
+# исправимо, а состояние уже отданного не спрашивает нигде. Конфликт приезжает в отданную заявку
+# чужим слиянием, без единого действия её автора: влить её человек больше не может, и заявка
+# стоит, пока автор не заметит. Заметить её нечем — требование перечитывать свои открытые заявки
+# записано текстом и держится памятью: две заявки простояли конфликтующими весь заход, и заметил
+# это владелец.
+#
+# Исправимо это ровно в минуту, когда берётся следующая работа: после неё конфликтов становится
+# больше, а не меньше — каждая новая заявка растёт из той же главной ветки и приезжает в ту же
+# очередь, которую придётся догонять.
+#
+# Работой здесь считаются четыре команды: заведение задачи, заведение ветки под задачу, перевод
+# колонки в работу и открытие заявки. Всё, чем конфликт чинится, — подтягивание, вливание,
+# коммит, отправка, переход между ветками — идёт как прежде: гард, отбивающий починку, запирал
+# бы дерево наглухо.
+#
+# Судится только прямое «конфликтует». Пока хостинг считает сливаемость, он отвечает
+# неопределённостью — и считает он её заново после каждой правки главной ветки, — а читать
+# неопределённость как конфликт значило бы отбивать работу на каждой свежей вершине.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет функции профиля, нет сети, нет машинной записи — ярус пропускается.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+# Начало вызова помощник берёт оттуда же, откуда все гарды. Источается он и здесь, хотя зовущий
+# гард это уже сделал: пустой образец превратил бы признак в поиск слова по всей строке.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
+
+rt_delivery_conflict() {
+    # Признак взятия работы читается из текста команды и стоит первым: опрос ходит в сеть, и
+    # платить за него на каждой команде оболочки нельзя.
+    taking=''
+    case "$cmd" in
+        *"${task_new}"*) taking='заведение задачи' ;;
+    esac
+    # Перевод колонки судится вместе с именем колонки работы: перевод в разбор и в закрытые —
+    # это конец работы, а не её начало.
+    if [ -z "$taking" ] && [ -n "$task_move" ]; then
+        case "$cmd" in
+            *"${task_move}"*)
+                case "$cmd" in
+                    *"${RT_BOARD_INPROGRESS_KEY:-in-progress}"*) taking='перевод колонки в работу' ;;
+                esac
+                ;;
+        esac
+    fi
+    if [ -z "$taking" ] \
+        && printf '%s' "$cmd" | grep -qE '(^|[;&|[:space:]])git[[:space:]]+(checkout[[:space:]]+-b|switch[[:space:]]+-c)[[:space:]]+[A-Za-z]+-[0-9]+'; then
+        taking='заведение ветки под задачу'
+    fi
+    if [ -z "$taking" ] \
+        && printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+create|glab[[:space:]]+mr[[:space:]]+create)([[:space:]]|\$)"; then
+        taking='открытие заявки'
+    fi
+    [ -z "$taking" ] && return 0
+
+    rt_needs rt_conflicting_pulls git-guard-delivery || return 0
+    stuck="$(cd "$root" && rt_conflicting_pulls 2>/dev/null)" || return 0
+    [ -z "$stuck" ] && return 0
+
+    listed=''
+    while IFS= read -r line; do
+        [ -z "$line" ] && continue
+        listed="${listed}${listed:+
+}— ${line}"
+    done <<EOF
+${stuck}
+EOF
+    [ -z "$listed" ] && return 0
+
+    deny "BLOCKED: ${taking} при своей конфликтующей заявке. Отданное конфликтует с главной веткой, и влить его человек не может:
+
+${listed}
+
+Конфликт приезжает чужим слиянием, без единого действия автора заявки: она стоит, пока её не догонят. Новая работа его не чинит — она прибавляет к очереди ещё одну ветку, которая растёт из той же главной и отстанет так же.
+
+Ход отсюда один: подтянуть главную, влить её в названную ветку, разобрать конфликт и отправить — и только потом брать новую работу. Что чем чинится — паттерн git-workflow-freshness."
+}

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

@@ -61,6 +61,25 @@ rt_delivery_open_folder() {
         && fault "папку задачи удалили, но в «${archive_dir}» ветка ничего не добавила. Удалить проще, чем разобрать, — и вместе с папкой пропадает разбор просьбы, единственная запись слов владельца. Перенеси то, что объясняет принятые решения, одним файлом с понятным именем и повтори."
 }
 
+# Условие снятия черновика: тот же предмет между открытием и слиянием. Снятый черновик читается
+# владельцем как приглашение влить, и кнопку он нажимает, не дожидаясь коммита уборки: гард
+# слияния сюда не достаёт вовсе — нажимает человек на хостинге. Три работы подряд уехали в
+# главную ветку именно так, и в теле каждой заявки стояло обещание убрать папку после одобрения.
+#
+# Ветку функция спрашивает сама: на этом ходе гард её ещё не посчитал.
+rt_delivery_ready_folder() {
+    [ -n "$tasks_dir" ] || return 0
+    printf '%s' "$cmd" | grep -qiE "$folder_skip_re" && return 0
+
+    _branch="$(git branch --show-current 2>/dev/null)"
+    [ -z "$_branch" ] && return 0
+    rt_task_branch_ok "$_branch" || return 0   # за беззадачной веткой папки не стоит
+
+    _lying="$(rt_folder_in_branch "$tasks_dir/$_branch")"
+    [ -n "$_lying" ] \
+        && fault "в ветке лежит папка задачи «${_lying}» — снятый черновик читается как «можно вливать», а вливать её туда нельзя. Кнопку нажимает человек на хостинге, и до его руки папка уедет в главную. Перенеси в «${archive_dir:-архив}» то, что объясняет принятые решения, остальное удали, закоммить и повтори. Если работа вливается частями, поставь в команду комментарий «# Task-folder-skip: <причина>»."
+}
+
 # Условие слияния: тот же предмет вторым рубежом. Он ловит слияние, идущее командой, — то, до
 # которого гард достаёт. Отсюда выходят только отказом или молчанием: слияние решается целиком.
 rt_delivery_merge_folder() {

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

@@ -24,9 +24,15 @@ rt_delivery_signature() {
 # изнутри это выглядит верным — имя учётной записи в истории то самое. Так одиннадцать коммитов
 # и уехали в главную ветку за чужой подписью; нашёл это владелец, читая историю глазами.
 #
-# Точка — пуш: до него подпись переписывается на месте всей веткой сразу, после — только силовой
-# отправкой. На коммите гард не стоит: почта задаётся переменными самой команды, и разбор её из
-# текста ловил бы ту же строку, которая и так перед глазами у набравшего её.
+# Точек две — коммит и пуш, и судят они одно: подпись коммитов, уже лежащих во вкладе ветки.
+# Текст самой команды при этом не разбирается ни там, ни там: почта задаётся её переменными, и
+# разбор ловил бы ту же строку, которая и так перед глазами у набравшего её.
+#
+# Коммит добавлен потому, что промах делается на нём и до пуша успевает лечь в несколько коммитов
+# подряд: каждый следующий берёт адрес у предыдущего. Отбитый на коммите промах чинится
+# переписыванием последнего коммита тем же ходом; отбитый на пуше — переписыванием истории, а
+# права на него у исполнителя может не быть вовсе. Первый коммит ветки при этом проходит: судить
+# нечего, вклад пуст.
 #
 # Судится коммит, НАЗВАВШИЙСЯ машинной записью: её логин стоит именем автора либо левой частью
 # почты. Опознавать по самой почте нельзя — она в таком коммите как раз и неверна, а требовать
@@ -45,9 +51,12 @@ rt_delivery_signature() {
 # Пробный пуш не отправляет ничего, и подпись у него не спрашивают. Отложенная правка — тоже:
 # `git stash push` кладёт правку в тайник этой же машины, поэтому тайник вырезается из строки, а
 # признак считается по остатку.
+# Коммит узнаётся тем же приёмом: слово `commit` отдельным словом при вызове git. Пробный
+# коммит здесь не отличают — своего `--dry-run` он не знает.
 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
+    && { { 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'; } \
+        || printf '%s' "$cmd" | grep -qE '(^|[[:space:]])commit([[:space:]]|$)'; }; 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/git-guard-delivery-folder.sh, hooks/profile-check.sh, hooks/deny-tail.sh
+# Требует: hooks/git-guard-delivery-folder.sh, hooks/git-guard-delivery-conflict.sh, hooks/profile-check.sh, hooks/deny-tail.sh
 # Гард поставки. PreToolUse на заведении ветки, пуше и открытии заявки на слияние.
 #
 # Закон о поставке требует трёх вещей, которых обычно не проверяет ничто: правка начинается с
@@ -107,6 +107,11 @@ task_bot="${RT_TASK_BOT:-}"
 # у него может не быть отдельной машинной записи.
 pull_token_var="${RT_PULL_TOKEN_VAR:-}"
 pull_token_hint="${RT_PULL_TOKEN_HINT:-}"
+# Раздел, который тело заявки обязано нести с минуты открытия. Кнопку слияния нажимает человек
+# на хостинге, куда гард не достаёт: всё, чем требование там держится, — то, что владелец увидел
+# на странице. Заголовок раздела пишется языком заявки, поэтому образец называет дерево, а не
+# пакет: чужих слов пакет не знает, и выдуманное умолчание не совпало бы ни с чем.
+pull_body_section="${RT_PULL_BODY_SECTION:-}"
 commit_email="${RT_COMMIT_EMAIL:-}"
 tasks_dir="${RT_TASKS_DIR:-}"
 archive_dir="${RT_ARCHIVE_DIR:-}"
@@ -158,6 +163,14 @@ 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
+
 # Отказ по накопленному. Пусто — вызывающая сторона идёт дальше.
 deny_faults() {
     [ -z "$faults" ] && return 0
@@ -327,6 +340,11 @@ if printf '%s' "$cmd" | grep -qE "${RT_CMD_BOUND}(gh[[:space:]]+pr[[:space:]]+re
             fi
         fi
     fi
+
+    # Папка задачи: тот же предмет, что на открытии и на слиянии, третьим рубежом. Условие
+    # местное — оно читает ветку, а не хостинг, — и потому стоит вне сетевого яруса выше.
+    command -v rt_delivery_ready_folder >/dev/null 2>&1 && rt_delivery_ready_folder
+
     deny_faults
 fi
 
@@ -370,7 +388,12 @@ fi
 if [ -n "$title" ]; then
     printf '%s' "$title" | grep -qE "$title_re" \
         || fault "заголовок заявки не начинается с номера задачи. В списке заявок тела не видно, а строка связи живёт именно там — без номера в заголовке PR с задачей не сопоставить."
-    title_number="$(printf '%s' "$title" | sed -nE 's/^\[[A-Za-z]+-([0-9]+)\].*/\1/p')"
+    # Номер вынимается из той части заголовка, которую признала сама форма, а не второй
+    # регуляркой рядом. Своя регулярка знает только пакетную форму: дерево, замостившее форму
+    # своей, получало пустой номер — и сверка номера заголовка с номером ветки молча не
+    # выполнялась вовсе, выглядя при этом сошедшейся.
+    title_matched="$(printf '%s' "$title" | grep -oE "$title_re" | head -1)"
+    title_number="$(printf '%s' "$title_matched" | grep -oE '[A-Za-z]+-[0-9]+' | head -1 | sed -E 's/^[A-Za-z]+-//')"
     if [ -n "$number" ] && [ -n "$title_number" ]; then
         [ "$title_number" = "$number" ] \
             || fault "в заголовке заявки номер ${title_number}, у ветки — ${number}. Задача, ветка и PR несут один и тот же номер."
@@ -424,6 +447,35 @@ if [ -n "$pull_token_var" ] \
     fault "заявка открывается без токена машинной записи: в команде нет подстановки «${pull_token_var}». Открытая залогиненной записью, она выйдет от владельца — ревьювером его тогда не назначить, и чинится это только переоткрытием.${pull_token_hint:+ Подставь токен: ${pull_token_hint} …}"
 fi
 
+# Тело заявки несёт раздел об оставшемся шаге, и несёт его с минуты открытия. Требование
+# записано было и прежде — прозой в паттерне закрытия работы, ниже того места, где описано само
+# открытие: читающий доходил до открытия, открывал и раздела ещё не прочитал. Так заявка и
+# уехала без него, а владелец влил её кнопкой, пока шёл прогон.
+#
+# Судится текст команды: тело приходит доводом либо файлом, и оба вида читаются здесь же. Файл
+# читается с диска — к моменту разбора он уже написан. Ни того ни другого в команде нет —
+# требования нет: заявка без тела вовсе судится строкой выше, а не этой.
+if [ -n "$pull_body_section" ]; then
+    body=''
+    if command -v perl >/dev/null 2>&1; then
+        body="$(printf '%s' "$cmd" | perl -0ne '
+            if (/(?:--body|-b)(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(\S+))/s) {
+                print defined $1 ? $1 : (defined $2 ? $2 : $3);
+            }
+        ' 2>/dev/null)"
+        body_file="$(printf '%s' "$cmd" | perl -0ne '
+            if (/(?:--body-file|-F)(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(\S+))/s) {
+                print defined $1 ? $1 : (defined $2 ? $2 : $3);
+            }
+        ' 2>/dev/null)"
+        [ -z "$body" ] && [ -n "$body_file" ] && [ -f "$body_file" ] && body="$(cat "$body_file" 2>/dev/null)"
+    fi
+
+    if [ -n "$body" ] && ! printf '%s' "$body" | grep -qE "$pull_body_section"; then
+        fault "в теле заявки нет раздела об оставшемся шаге. Кнопку слияния нажимает человек на хостинге, где гардов нет, и вливает он, как только видит зелёное: всё, чем требование там держится, — то, что владелец прочитал на странице. Раздел стоит последним и говорит ровно одно — осталось ли что-то до слияния; переписывается он тем же вызовом, которым правится тело."
+    fi
+fi
+
 check_task "$number" "заявка с ветки «${branch}»" да
 
 # Папка задачи разбирается до открытия заявки, а не после одобрения. Прежде здесь стояло

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

@@ -119,11 +119,25 @@ if git fetch --quiet origin "$main_branch" 2>/dev/null && git rev-parse --verify
     base="origin/$main_branch"
 fi
 
+# Код, которым проверка объявляет, что смотреть было не на что: ни «сошлось», ни «расхождение».
+# Прежде такая проверка говорила о себе строкой вывода и выходила нулём — в наборе этот ноль
+# стоял рядом с пройденными и ничем от них не отличался, а сводка читалась как проверенная
+# целиком. Пуш он не отбивает: проверка, которой нечего смотреть, поломкой не является.
+rt_skip_code="${RT_SKIP_CODE:-7}"
+
 failed=""
 output=""
+skipped=""
 while IFS= read -r check; do
     [ -z "$check" ] && continue
-    out="$(eval "$check" 2>&1)" && continue
+    out="$(eval "$check" 2>&1)"
+    status=$?
+    [ "$status" -eq 0 ] && continue
+    if [ "$status" -eq "$rt_skip_code" ]; then
+        skipped="${skipped}${skipped:+
+}${check}"
+        continue
+    fi
     failed="$check"
     output="$out"
     break
@@ -131,6 +145,12 @@ done <<EOF
 $(rt_push_checks "$base")
 EOF
 
+# Пропущенное называется вслух и тогда, когда набор прошёл: молчание о нём и есть та самая
+# неотличимость, ради которой код заведён. Пуш при этом идёт — отказа здесь нет.
+if [ -z "$failed" ] && [ -n "$skipped" ]; then
+    printf 'гейт пуша: набор прошёл, но эти проверки смотреть было не на что:\n%s\n' "$skipped" >&2
+fi
+
 [ -z "$failed" ] && exit 0
 
 # Хвост вывода, а не весь: у прогонщика он длинный, а нужна причина отказа.

package/assets/hooks/grill-gate-ask.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# rt-hook: PreToolUse AskUserQuestion
+# Требует: hooks/grill-gate.sh
+# Половина гарда разговора, стоящая на инструменте вопроса: меню судится до отправки.
+#
+# Своим ресурсом, а не строкой в шапке соседа, потому что инструмент вопроса — единственный
+# способ спросить владельца, и у дерева на нём уже может стоять свой гард со своей причиной
+# отказа. Второй отказ на том же инструменте делает вопрос недоступным вовсе, и дерево
+# отказывается от гарда целиком вместо того, чтобы взять его половину. Разведённые по двум
+# ресурсам, половины отменяются порознь: строка отказа снимает одну и оставляет другую.
+#
+# Судит вызов то же тело, что и завершение хода: требование одно, и расходиться двум его
+# редакциям нельзя. Здесь только объявление события и передача ввода.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет соседнего файла — ход РАЗРЕШАЕТСЯ. Половина гарда, потерявшая
+# тело, не имеет права заклинить разговор.
+
+. "$(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_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+[ -f "$rt_hooks_dir/grill-gate.sh" ] || exit 0
+
+rt_hook_read
+printf '%s' "$RT_HOOK_INPUT" | "$rt_hooks_dir/grill-gate.sh"