@rt-tools/agent-kit 0.17.0 → 0.19.0

package/assets/defaults/shell.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# Разбор команды оболочки: пишет ли она и какие пути называет.
+#
+# Умолчание пакета, часть профиля дерева — грузится из `project.sh`, рядом с которым лежит.
+# Отдельным файлом потому, что вдвоём они перерастают предел длины, а читают их порознь: одному
+# нужен признак записи, другому — цель.
+
+# Пишет ли команда оболочки файл. Успех — да, и тогда пути из неё судятся тем же признаком,
+# что и путь из вызова инструмента правки.
+#
+# Гарды подписаны на инструменты правки файла, и этого мало: ту же правку кладут командой —
+# перенаправлением, `tee`, `sed -i`, интерпретатором с heredoc. Отбитая правка дважды за один
+# заход легла именно так, и не увидел этого никто: в дереве она неотличима от положенной
+# инструментом. Разбор — `2026-08-15-guard-denied-shell-wrote-anyway.md`.
+#
+# Список намеренно широк, и цена этого названа: команда чтения, в которой стоит имя
+# интерпретатора, будет отбита наравне с командой правки. Узкий список стоил бы дороже —
+# пропущенная форма записи возвращает обход целиком, а найти её можно только промахом.
+#
+# Перенаправление в пустое устройство и в поток ошибок снимается до разбора: файла оно не
+# пишет, а выглядит как перенаправление в файл. Так глушат вывод команды чтения, и без этого
+# `grep -rn x libs/ 2>/dev/null` судится наравне с записью — правило требуется на чтение, а
+# отбитий, пришедшихся не на правку файла, набирается большинство. Настоящая запись рядом с
+# заглушённым потоком остаётся видной: снимается перенаправление, а не команда целиком.
+#
+# Стрелка снимается там же и по той же причине. `->` и `=>` в оболочке не значат ничего, а знак
+# в них тот же: команда, печатавшая таблицу «путь -> правило», объявлялась пишущей и отдавала
+# все свои пути под суд. Туда же закрывающая скобка комментария разметки.
+#
+# Цель перенаправления сужена до знаков, из которых собирают пути. Строка цитаты разметки —
+# знак и слово через пробел — от записи в файл одним знаком неотличима, и различает их только
+# цель: за настоящим знаком стоит путь, а не слово словами. Цена названа прямо: путь, набранный
+# не латиницей, записью больше не считается — в дереве таких нет ни одного, а появятся, признак
+# придётся расширить.
+rt_shell_writes_default() {
+    printf '%s' "$1" \
+        | sed -E 's#(&|[0-9]*)>>?[[:space:]]*/dev/(null|stderr)##g; s#[0-9]*>&[0-9-]##g; s#[-=]+>##g' \
+        | grep -Eq \
+            '>>?[[:space:]]*[A-Za-z0-9_./~$"'"'"'-]|\btee\b|\bsed\b[^|]*-i|\bperl\b[^|]*-i|\bpython3?\b|\bnode\b|\bruby\b|\bdd\b[^|]*of=|\bcp\b|\bmv\b|\brm\b|\btouch\b|\btruncate\b|\binstall\b|\bpatch\b|\bgit[[:space:]]+(checkout|restore|apply|stash)\b'
+}
+
+# Пути, названные командой оболочки. Печатает по одному в строке; судит их зовущий.
+#
+# Разбирать оболочку по-настоящему нечем — здесь и не разбирают: из текста вынимается всё, что
+# похоже на путь, и каждое отдаётся признаку. Лишнее он отсеет сам, а пропущенное вернуло бы
+# обход. Кавычки снимаются заменой на пробел: путь внутри них тот же самый.
+#
+# Тело документа на месте путей не даёт: там лежит текст, который команда кладёт в файл, а
+# чужой путь, названный в нём словами, требовал бы правила под запись, которой нет. Запись
+# замысла так отбивалась трижды подряд, пока пути под каталогом кода не были названы иначе.
+# Судится заголовок команды — именно в нём стоит тот путь, куда команда пишет.
+#
+# Исключение — интерпретатор: ему код приходит телом, и путь записи стоит именно там. Признак
+# читается у той строки, которая тело открыла, а не у всей команды: тело принадлежит команде
+# своего заголовка. Прежде он читался у всего текста разом, и слово из документа отключало
+# вырезание целиком — строка «**Чем проверяется:** `bash projects/…`» в замысле делала запись
+# `plan.md` правкой кода приложения. Гард отбивал тем самым запись того файла, отсутствием
+# которого он же и отказывает.
+rt_shell_paths_default() {
+    text="$(printf '%s' "$1" | tr "\"'\`" '   ')"
+    text="$(printf '%s' "$text" | awk '
+        function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
+        tag != "" {
+            if (keep) { print }
+            if (trim($0) == tag) { tag = ""; keep = 0 }
+            next
+        }
+        {
+            print
+            if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
+                t = substr($0, RSTART, RLENGTH)
+                sub(/^<<-?[ \t]*/, "", t)
+                tag = t
+                keep = ($0 ~ /(^|[|;&(]|[ \t])(python3?|node|ruby|perl|php|deno|bun|bash|sh|zsh)([ \t]|$)/)
+            }
+        }')"
+
+    # Пути берутся только у тех кусков команды, которые пишут. Прежде брались у всей строки
+    # целиком, и команда чтения, сцепленная с записью, отдавала свои пути как цели записи:
+    # `python3 <<PY … PY` рядом с `grep -n … projects/…` отбивался за правку кода, которой в нём
+    # не было. Отбитий, пришедшихся не на правку файла, набиралось большинство, и цену платил
+    # тот, кто просто читал соседний файл в той же строке.
+    #
+    # Кусок — строка верхнего уровня, а внутри неё `;`, `&&` и `||`. Тело heredoc от своей
+    # команды не отрывается: оно едет вместе с ней одним куском, потому что путь записи
+    # интерпретатора стоит именно там.
+    printf '%s' "$text" | awk '
+        function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
+        function flush(  n, i, part) {
+            if (chunk == "") { return }
+            if (tag != "") { part = chunk; gsub(/\n/, " ", part); print part; chunk = ""; return }
+            n = split(chunk, parts, /;|&&|\|\|/)
+            for (i = 1; i <= n; i++) { print parts[i] }
+            chunk = ""
+        }
+        tag != "" {
+            chunk = chunk "\n" $0
+            if (trim($0) == tag) { flush(); tag = "" }
+            next
+        }
+        {
+            chunk = $0
+            if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
+                t = substr($0, RSTART, RLENGTH)
+                sub(/^<<-?[ \t]*/, "", t)
+                tag = t
+                next
+            }
+            flush()
+        }
+        END { if (chunk != "") { part = chunk; gsub(/\n/, " ", part); print part } }
+    ' \
+        | while IFS= read -r piece; do
+            [ -z "$piece" ] && continue
+            rt_shell_writes "$piece" || continue
+            # Кусок, который пишет одним лишь перенаправлением, отдаёт цель записи, а не всякое
+            # похожее на путь слово из своего текста. Имя файла, названное в аргументе или в
+            # содержимом, правкой этого файла не является: команда чтения, сцепленная с записью
+            # в свой файл, требовала правила по чужому имени и кончала ход — цена такого отказа
+            # равна цене настоящего срабатывания, потому что обойти его нечем.
+            #
+            # Прочие виды записи разбираются по-прежнему: у правки по месту, копирования,
+            # переноса и интерпретатора путь стоит в самой команде и не в одном месте.
+            if ! printf '%s' "$piece" | grep -Eq '\bsed\b[^|]*-i|\bperl\b[^|]*-i|\bpython3?\b|\bnode\b|\bruby\b|\bdd\b[^|]*of=|\bcp\b|\bmv\b|\brm\b|\btouch\b|\btruncate\b|\binstall\b|\bpatch\b|\bgit[[:space:]]+(checkout|restore|apply|stash)\b'; then
+                printf '%s' "$piece" \
+                    | grep -oE '(>>?[[:space:]]*|\btee\b([[:space:]]+-a)?[[:space:]]+)[A-Za-z0-9_@.~/-]+' \
+                    | sed -E 's/^(>>?|tee([[:space:]]+-a)?)[[:space:]]*//' \
+                    | grep -E '^[A-Za-z0-9_@.-]*/[A-Za-z0-9_@./-]+$' \
+                    | sed 's|^\./||'
+                continue
+            fi
+            printf '%s' "$piece" \
+                | tr "(),;=" '     ' \
+                | tr '[:space:]' '\n' \
+                | grep -E '^[A-Za-z0-9_@.-]*/[A-Za-z0-9_@./-]+$' \
+                | sed 's|^\./||'
+        done \
+        | sort -u
+}

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-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 на заведении ветки, пуше и открытии заявки на слияние.
 #
 # Закон о поставке требует трёх вещей, которых обычно не проверяет ничто: правка начинается с
@@ -163,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
@@ -380,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 несут один и тот же номер."