@rt-tools/agent-kit 0.8.1 → 0.8.2

package/assets/docs/GLOSSARY.md

@@ -1,7 +1,7 @@
 # Словарь проекта
 
 Слова, которые в этом дереве значат что-то определённое. Читается перед тем, как написать спек,
-правило, комментарий, тело коммита или описание отчёта: слово отсюда употребляется в том
+правило, комментарий, тело коммита или описание PR: слово отсюда употребляется в том
 значении, что здесь, а слово не отсюда либо заводится здесь же, либо заменяется простым.
 
 Термины одного домена живут в разделе «Терминология» его спека — здесь только те, что проходят
@@ -36,21 +36,21 @@
 
 ## Работа
 
-| Термин          | Что это                                                                                                                                                                                      |
-| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Задача          | Единица работы в очереди работ. Заводится до ветки, и номер её стоит в имени ветки и в заголовке отчёта                                                                                      |
-| Отчёт           | Заявка на слияние: то же название, что у задачи, переведённое в сделанное                                                                                                                    |
-| Очередь работ   | Доска, на которой видно состояние каждой задачи. Ветки она не видит                                                                                                                          |
-| Папка задачи    | Одна работа от разбора до слияния: разбор просьбы, замысел, ход работы. Умирает со слиянием — разбирается, и объясняющее решение уезжает в архив                                             |
-| Разбор          | Расспрос владельца до первой правки. Записывается его словами и задним числом не переписывается                                                                                              |
-| Замысел         | Файл папки задачи: след задачи и этапы с признаками готовности. После написания не правится — с ним сверяют результат при приёмке                                                            |
-| Ход работы      | Файл папки задачи: «Где стоим», решения по ходу с причинами, записи заходов. Единственное место, где отмечается сделанное. Журналом не называется                                            |
-| След задачи     | Раздел замысла: какие спеки, законы, правила и части кода работа задевает                                                                                                                    |
-| Заход           | Одна сессия работы над задачей. Работа живёт дольше одного захода, и между ними её состояние держит только ход работы                                                                        |
-| Заполнение окна | Доля места захода, которую он уже занял: вход, запись в кэш, прочитанное из кэша и вывод последнего ответа, делённые на размер окна. Не «расход» и не «бюджет»: речь о месте, а не о деньгах |
-| Передача        | Текст, которым заход закрывается: рабочее дерево, ветка, задача, где лежит ход работы, что сделано, следующий шаг, особенности захода. Кладётся вне дерева и не коммитится                   |
-| Линия работ     | Файл с порядком задач и зависимостями между ними, когда из одного разбора вышло несколько задач. Шире одной ветки                                                                            |
-| Архив           | Записи о состоявшемся: что объясняет закрытое решение. После выкатки не правится                                                                                                             |
+| Термин          | Что это                                                                                                                                                                                                                                                                       |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Задача          | Единица работы в очереди работ. Заводится до ветки, и номер её стоит в имени ветки и в заголовке PR                                                                                                                                                                           |
+| PR              | Заявка на слияние: то же название, что у задачи, переведённое в сделанное. Отчётом, пул-реквестом и мёрдж-реквестом не называется — ни в файлах, ни в разговоре                                                                                                               |
+| Очередь работ   | Доска, на которой видно состояние каждой задачи. Ветки она не видит                                                                                                                                                                                                           |
+| Папка задачи    | Одна работа от разбора до слияния: разбор просьбы, замысел, ход работы. Умирает со слиянием — разбирается, и объясняющее решение уезжает в архив                                                                                                                              |
+| Разбор          | Расспрос владельца до первой правки. Записывается его словами и задним числом не переписывается                                                                                                                                                                               |
+| Замысел         | Файл папки задачи: след задачи и этапы с признаками готовности. После написания не правится — с ним сверяют результат при приёмке                                                                                                                                             |
+| Ход работы      | Файл папки задачи: «Где стоим», решения по ходу с причинами, записи заходов. Единственное место, где отмечается сделанное. Журналом не называется                                                                                                                             |
+| След задачи     | Раздел замысла: какие спеки, законы, правила и части кода работа задевает                                                                                                                                                                                                     |
+| Заход           | Одна сессия работы над задачей. Работа живёт дольше одного захода, и между ними её состояние держит только ход работы                                                                                                                                                         |
+| Заполнение окна | Доля места захода, которую он уже занял: вход, запись в кэш, прочитанное из кэша и вывод последнего ответа, делённые на размер окна. Не «расход» и не «бюджет»: речь о месте, а не о деньгах                                                                                  |
+| Передача        | Текст, которым заход закрывается: рабочее дерево, ветка, задача, где лежит ход работы, что сделано, следующий шаг, особенности захода. Кладётся вне дерева и не коммитится                                                                                                    |
+| Эпик            | Серия задач одной темы, выполняемых в назначенном порядке. Живёт в двух местах сразу: карточка в очереди работ с меткой эпика и замысел рядом с ней — что за возможность разрабатывается, какие задачи входят и в каком порядке. Шире одной ветки. Линией работ не называется |
+| Архив           | Записи о состоявшемся: что объясняет закрытое решение. После выкатки не правится                                                                                                                                                                                              |
 
 ## Проверки
 
@@ -65,13 +65,15 @@
 
 ## Так не пишем
 
-| Так не пишем               | Пишем так                                                                                      |
-| -------------------------- | ---------------------------------------------------------------------------------------------- |
-| спека (о тесте)            | тест — файл рядом с исходником; спек — документ. Одна буква разницы, а значения противоположны |
-| таска, тикет               | задача                                                                                         |
-| пул-реквест, мёрдж-реквест | отчёт, а действие — слияние                                                                    |
-| джоба, пайплайн            | конвейер и его шаг                                                                             |
-| хендофф                    | передача                                                                                       |
-| бэклог                     | очередь работ                                                                                  |
-| контекст-виндоу            | окно захода, а его доля — заполнение окна                                                      |
-| скилл, скилы               | правило, паттерн или скил без закона — по тому, что это на самом деле                          |
+| Так не пишем                | Пишем так                                                                                      |
+| --------------------------- | ---------------------------------------------------------------------------------------------- |
+| спека (о тесте)             | тест — файл рядом с исходником; спек — документ. Одна буква разницы, а значения противоположны |
+| таска, тикет                | задача                                                                                         |
+| пул-реквест, мёрдж-реквест  | PR, а действие — слияние                                                                       |
+| отчёт (о заявке на слияние) | PR; отчёт — сводка данных, и слово занято ею                                                   |
+| джоба, пайплайн             | конвейер и его шаг                                                                             |
+| хендофф                     | передача                                                                                       |
+| бэклог                      | очередь работ                                                                                  |
+| линия работ                 | эпик                                                                                           |
+| контекст-виндоу             | окно захода, а его доля — заполнение окна                                                      |
+| скилл, скилы                | правило, паттерн или скил без закона — по тому, что это на самом деле                          |

package/assets/hooks/docs-guard.sh

@@ -17,8 +17,8 @@
 #
 # Отдельно — законы. Совпал ли код с законом, машина не знает: правка файла, на который закон
 # ссылается якорем, поэтому не отклоняется, а выносится вопросом владельцу. Тем же вопросом
-# встречается и правка самого закона: закон описывает договорённость о продукте, и менять её
-# молча гард не даёт.
+# встречается и правка самого закона — как на месте, так и надстройкой над ним: закон описывает
+# договорённость о продукте, и менять её молча гард не даёт.
 #
 # Обход — строка `Docs-skip: <причина>` в теле коммита. Причина остаётся в истории и видна при
 # разборе ветки; пустая не принимается.
@@ -66,11 +66,18 @@ command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2
 
 laws_dir="${RT_LAWS_DIR:-docs/constitution}"
 lib_marker="${RT_LIB_MARKER:-project.json}"
+overrides_dir="${RT_OVERRIDES_DIR:-.claude/rt-kit/overrides}"
 
 # ── Правка закона спрашивает владельца ────────────────────────────────────────
 #
 # Спутник рядом с законом — привязка статей к коду, она устаревает при каждом переименовании и
 # правится свободно. Спрашивается только сам текст закона.
+#
+# Путей к тексту закона два, и ходят чаще вторым. Разложенный закон на месте не правится вовсе:
+# правка теряется на следующей раскладке, а сама раскладка на неё отказывает, — поэтому правят
+# надстройку, и файл закона переписывает раскладка. Гард, знающий один каталог законов, сторожит
+# ровно тот путь, которым к закону и не ходят: чем сложнее надстройка дерева, тем реже закон
+# правят на месте. Спрашивается и надстройка — по содержанию это правка закона, а не обвязки.
 case "$tool" in
     Edit | Write | MultiEdit | NotebookEdit | mcp__webstorm__create_new_file)
         target="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.filePath // .tool_input.path // .tool_input.pathInProject // empty' 2>/dev/null)"
@@ -79,6 +86,10 @@ case "$tool" in
             */"$laws_dir"/*.md | "$laws_dir"/*.md)
                 decide ask "Правка закона: \`${target##*/}\`. Закон описывает договорённость о продукте, а не устройство кода, — назови владельцу, что и почему меняешь, и дождись ответа. Если правка уже согласована, подтверди вызов."
                 ;;
+            */"$overrides_dir"/laws/*.implementation.md | "$overrides_dir"/laws/*.implementation.md) exit 0 ;;
+            */"$overrides_dir"/laws/*.md | "$overrides_dir"/laws/*.md)
+                decide ask "Правка закона надстройкой: \`${target##*/}\`. Разложенный файл переписывает раскладка, поэтому правка надстройки — это правка самого закона: назови владельцу, что и почему меняешь, и дождись ответа. Если правка уже согласована, подтверди вызов."
+                ;;
         esac
         exit 0
         ;;
@@ -112,7 +123,12 @@ esac
 
 # Причина обхода остаётся в истории, поэтому обход законен. Пустая строка обходом не считается:
 # «Docs-skip:» без причины — это тот же молчаливый пропуск, только с двоеточием.
-if printf '%s' "$cmd" | grep -qiE 'Docs-skip:[[:space:]]*[^[:space:]"'"'"']{3,}'; then
+#
+# Строка начинает строку — свою в теле коммита или комментарий в конце команды — и подстановки
+# не принимает. То же условие, что у обхода при слиянии: иначе текст, который ОБЪЯСНЯЕТ обход,
+# снимает требование сам собой. Тело коммита о правке гарда как раз называет эту строку, и без
+# привязки к началу гард пропускал бы такой коммит молча.
+if printf '%s' "$cmd" | grep -qiE '(^|#)[[:space:]]*Docs-skip:[[:space:]]*[^[:space:]<"'"'"'][^[:space:]"'"'"']{2,}'; then
     exit 0
 fi
 

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

@@ -38,14 +38,46 @@ 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)
+        shell_cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+        [ -z "$shell_cmd" ] && exit 0
+        ;;
     *) 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 +88,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 +107,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 +168,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 +210,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