@rt-tools/agent-kit 0.16.0 → 0.17.0

package/assets/defaults/project.sh

@@ -87,7 +87,7 @@ rt_push_checks_default() {
     [ -x "$root/$RT_HOOKS_TESTS" ] && printf '%s\n' "bash $RT_HOOKS_TESTS"
 
     for check in check-doc-paths check-specs check-file-size check-dupes check-styles \
-        check-lib-layers check-reuse check-schema-drift check-states check-state-next \
+        check-glossary check-lib-layers check-reuse check-schema-drift check-states check-state-next \
         check-turn-map check-archive-age check-push-gate; do
         [ -f "$root/$RT_CHECKS_DIR/$check.mjs" ] && printf '%s\n' "node $RT_CHECKS_DIR/$check.mjs"
     done
@@ -183,6 +183,9 @@ RT_LAWS_DIR="${RT_LAWS_DIR:-docs/constitution}"
 RT_RULES_DIR="${RT_RULES_DIR:-.claude/skills}"
 RT_SPECS_DIR="${RT_SPECS_DIR:-docs/specs}"
 
+# Каталог замыслов, переживающих одну задачу: порядок задач эпика лежит там, а не в правилах.
+RT_PLANS_DIR="${RT_PLANS_DIR:-docs/plans}"
+
 # Главная ветка. Гарду она нужна, чтобы найти общего предка и понять, что ветка сделала с
 # папкой задачи и с архивом. Если общего предка нет, сравнивать не с чем — проверка молчит.
 RT_MAIN_BRANCH="${RT_MAIN_BRANCH:-main}"
@@ -239,11 +242,21 @@ rt_is_app_code_default() {
 # `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' \
+        | sed -E 's#(&|[0-9]*)>>?[[:space:]]*/dev/(null|stderr)##g; s#[0-9]*>&[0-9-]##g; s#[-=]+>##g' \
         | grep -Eq \
-            '>>?[[:space:]]*[^|&>[:space:]]|\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'
+            '>>?[[: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'
 }
 
 # Пути, названные командой оболочки. Печатает по одному в строке; судит их зовущий.
@@ -372,6 +385,12 @@ RT_TASK_BOT="${RT_TASK_BOT:-}"
 RT_PULL_TOKEN_VAR="${RT_PULL_TOKEN_VAR:-}"
 RT_PULL_TOKEN_HINT="${RT_PULL_TOKEN_HINT:-}"
 
+# Раздел, который тело заявки обязано нести с минуты открытия: решение о слиянии принимается на
+# её странице, где переписки нет вовсе, и сказанного вслух там не остаётся. Умолчание молчит —
+# заголовок пишется языком заявки, а чужих слов пакет не знает: не названный деревом, раздел не
+# судится вовсе.
+RT_PULL_BODY_SECTION="${RT_PULL_BODY_SECTION:-}"
+
 # Команда перевода задачи между колонками очереди работ и имя первой колонки — той, из которой
 # задача уходит, когда её берут в работу. Имя без умолчания: колонки дерево называет своими
 # словами, а выдуманное не совпало бы ни с чем и молча выключило бы проверку колонки.

package/assets/docs/GLOSSARY.md

@@ -73,4 +73,4 @@
 - **бэклог** — очередь работ
 - **линия работ** — эпик
 - **контекст-виндоу** — окно захода, а его доля — заполнение окна
-- **скилл, скилы** — правило, паттерн или скил без закона — по тому, что это на самом деле
+- **скилл, скиллы** — правило, паттерн или скил без закона — по тому, что это на самом деле

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

@@ -1,10 +1,16 @@
 #!/usr/bin/env bash
+# Местное значение: .claude/rt-kit/browser-device-id — без него браузерные гарды пропускают любой профиль
 # Общий помощник: печатает идентификатор закреплённого профиля браузера.
 #
 # Идентификатор локален для машины и в пакет не едет вовсе. Он берётся из переменной окружения,
-# а если её нет — из файла рядом с конфигом раскладки. Ни там ни там ничего нет — помощник
-# молчит, и все браузерные гарды пропускают: гард, который не может назвать нужный профиль,
-# ничего не предлагает взамен, и слепой отказ только заводил бы работу в тупик.
+# а если её нет — из файла рядом с конфигом раскладки. Ни там ни там ничего нет — все браузерные
+# гарды пропускают: гард, который не может назвать нужный профиль, ничего не предлагает взамен,
+# и слепой отказ только заводил бы работу в тупик.
+#
+# Пропуск при этом не молчит. Ненастроенное дерево получает строку в поток ошибок — один раз на
+# признак, чтобы она не тонула в каждом вызове: молчание тут неотличимо от «всё в порядке», и
+# читается оно как разрешение водить браузер каким угодно профилем. Признак приходит первым
+# доводом от того, кто зовёт; довода нет — метка дневная.
 #
 # Файл с идентификатором в репозиторий не коммитится: у каждой машины он свой.
 
@@ -16,7 +22,17 @@ if [ -n "${RT_BROWSER_DEVICE_ID:-}" ]; then
 fi
 
 file="${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/browser-device-id"
-[ -f "$file" ] || exit 0
+
+if [ ! -f "$file" ]; then
+    key="${1:-$(date +%Y%m%d 2>/dev/null || printf 'nokey')}"
+    marker_dir="${TMPDIR:-/tmp}/claude-browser-guard"
+    marker="$marker_dir/silent-$key"
+    if [ ! -f "$marker" ]; then
+        mkdir -p "$marker_dir" 2>/dev/null && : >"$marker" 2>/dev/null
+        echo "Профиль браузера этому дереву не назван: нет ни RT_BROWSER_DEVICE_ID, ни .claude/rt-kit/browser-device-id. Браузерные гарды поэтому пропускают всё подряд — это не разрешение ехать, а повод остановиться и сказать владельцу." >&2
+    fi
+    exit 0
+fi
 
 tr -d '[:space:]' <"$file"
 printf '\n'

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/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.sh

@@ -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:-}"
@@ -327,6 +332,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
 
@@ -424,6 +434,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"

package/assets/hooks/grill-gate.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse AskUserQuestion
 # Требует: hooks/deny-tail.sh
 # rt-hook: Stop
 # Гард разговора: вопрос владельцу не задаётся, пока за этот же ход не читались законы и
-# правила. Стоит на двух событиях, и это не дублирование.
+# правила. Судит два события, и это не дублирование; второе объявлено соседним ресурсом
+# `hooks/grill-gate-ask.sh`, который отдаёт вызов сюда.
 #
 # Зачем именно так. Требование «правила читаются до разговора» исполнимо ровно до отправки
 # вопроса. Проверка на завершении хода отбивает задним числом: к моменту отказа вопрос уже у
@@ -13,7 +13,9 @@
 # Одним этим перехватом дыра не закрывается: вопрос чаще задаётся прозой, и ровно так был задан
 # тот, из-за которого гард заведён. Прозаический вопрос инструментом не является, и поймать его
 # можно только на завершении хода — событие получает путь к записи хода и видит его целиком.
-# Отсюда два события: меню ловится до отправки, проза — после.
+# Отсюда два события: меню ловится до отправки, проза — после. Объявлены они разными ресурсами
+# затем, чтобы дерево, у которого инструмент вопроса занят своим гардом, могло взять половину, а
+# не отказаться от требования целиком.
 #
 # Чтением правил считается любой из трёх путей: загрузка правила, чтение файла законов или
 # правил, поиск по ним. Требовать именно загрузку значило бы гнать на неё там, где хватило
@@ -57,13 +59,18 @@ done
 laws_dir="${RT_LAWS_DIR-docs/constitution}"
 rules_dir="${RT_RULES_DIR-.claude/skills}"
 specs_dir="${RT_SPECS_DIR-docs/specs}"
+# Замысел эпика и описание прошлого читаются наравне с законами: решение, связывающее задачи
+# эпика, лежит именно там. Прочитавший замысел получал отказ наравне с не читавшим ничего, и
+# снимался тот отказ поиском по трём каталогам, среди которых нужного не было.
+plans_dir="${RT_PLANS_DIR-docs/plans}"
+archive_dir="${RT_ARCHIVE_DIR-docs/archive}"
 
 # Дерево, у которого нет ни законов, ни правил, требования не получает: читать нечего.
 [ -z "$laws_dir" ] && [ -z "$rules_dir" ] && exit 0
 
 # Образец, по которому вызов инструмента считается чтением правил. Каталоги идут в него как
 # есть: точка в `.claude` совпадает с любым знаком и лишнего сюда не приводит.
-read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
+read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir|$plans_dir|$archive_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
 [ -z "$read_re" ] && exit 0
 
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
@@ -106,7 +113,7 @@ fi
 
 reason="$head Вопрос, ответ на который уже записан, владельцу не задаётся — правило ведения работы. Прогони поиск по словам темы и ответь по найденному; спрашивай только то, что документацией не покрыто:
 
-    grep -rn -i \"<слово темы>\" $laws_dir $rules_dir $specs_dir
+    grep -rn -i \"<слово темы>\" $laws_dir $rules_dir $specs_dir $plans_dir $archive_dir
 
 Гард судит один ход: следующий заход не отбивается."
 

package/assets/hooks/lint-after-edit.sh

@@ -3,11 +3,15 @@
 # Требует: hooks/profile-check.sh
 # Линтер по следам правки. PostToolUse.
 #
-# Два входа. Правка файла — линтуется один изменённый файл. Перенос файла командой — линтуются
-# файлы по адресу назначения: перенос меняет либу, а вместе с ней и границы, и импорт, законный
-# на прежнем месте, на новом уже запрещён. Ровно так запрещённый импорт уезжает в общую либу
-# молча: файлы перекладываются командой, хук на неё не смотрит, и правило границ сработало бы —
-# но его никто не запустил.
+# Два входа. Правка файла — линтуется один изменённый файл. Команда оболочки — линтуется то,
+# что она записала: перенос меняет либу, а вместе с ней и границы, и импорт, законный на прежнем
+# месте, на новом уже запрещён; запись перенаправлением, дозаписью или интерпретатором меняет
+# сам файл, и линтера он прежде не получал вовсе. Ровно так запрещённый импорт уезжает в общую
+# либу молча, а правленая проверка выходит из-под форматтера: правило сработало бы — но его
+# никто не запустил.
+#
+# Что команда пишет и куда, знает профиль дерева, и знает он это одним способом для всех: тот
+# же признак читает гейт правил.
 #
 # Полный набор гоняет гард на пуше, но это конец работы: к моменту, когда правило срабатывает,
 # поверх нарушения лежит десяток правок, и разбор превращается в археологию. Здесь тот же
@@ -19,6 +23,8 @@
 #
 # Что здесь чем зовётся, знает профиль дерева:
 #   rt_lint_for      — чем линтуется этот файл;
+#   rt_shell_writes  — пишет ли эта команда;
+#   rt_shell_paths   — какие пути она записала;
 #   rt_is_app_code   — где лежит код, к которому линтеры вообще относятся;
 #   RT_LINT_SKIP_RE  — что из него исключено;
 #   rt_push_checks   — что гоняет гейт пуша. По нему же решается, догонит ли замечание позже:
@@ -46,14 +52,12 @@ case "$tool" in
     *) exit 0 ;;
 esac
 
-# Отсев до всякой работы: хук висит на каждой команде оболочки, а перенос среди них — редкость.
+# Отсев до всякой работы: хук висит на каждой команде оболочки, а пишет из них меньшинство.
+# Пустая команда отсеивается здесь же — признак записи у неё спрашивать не о чем.
 command_text=""
 if [ "$mode" = "move" ]; then
     command_text="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
-    case "$command_text" in
-        *"git mv "*) ;;
-        *) exit 0 ;;
-    esac
+    [ -z "$command_text" ] && exit 0
 fi
 
 workdir="$(rt_hook_cwd)"
@@ -75,6 +79,15 @@ done
 command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2>&1; }
 rt_needs rt_lint_for lint-after-edit || exit 0
 
+# Признак записи спрашивается после профиля: до него функций ещё нет. Дерево, которое признака
+# не объявило, остаётся при прежнем поведении — разбирается один перенос.
+if [ "$mode" = "move" ] && rt_needs rt_shell_writes lint-after-edit; then
+    case "$command_text" in
+        *"git mv "*) ;;
+        *) rt_shell_writes "$command_text" || exit 0 ;;
+    esac
+fi
+
 # --- какие файлы проверяем -------------------------------------------------------------
 
 # Пути назначения всех переносов в команде. Команда бывает составной, поэтому режется по
@@ -136,7 +149,17 @@ if [ "$mode" = "edit" ]; then
     esac
     candidates="$(expand "$path")"
 else
-    candidates="$(collect_moved "$command_text" | while IFS= read -r moved; do expand "$moved"; done)"
+    # Перенос разворачивает каталог: он двигает целые слои. Запись — нет: пишут всегда в файл,
+    # а каталог в команде записи — это рабочий каталог, и развёрнутый он отдаёт линтеру половину
+    # дерева. Поэтому у записанных путей берутся только существующие файлы.
+    written=""
+    if rt_needs rt_shell_paths lint-after-edit; then
+        written="$(rt_shell_paths "$command_text" 2>/dev/null | while IFS= read -r path; do
+            [ -f "$path" ] && printf '%s\n' "$path"
+        done)"
+    fi
+    candidates="$( { collect_moved "$command_text" | while IFS= read -r moved; do expand "$moved"; done
+        printf '%s\n' "$written"; } | sort -u)"
 fi
 
 [ -z "$candidates" ] && exit 0
@@ -214,11 +237,16 @@ else
     tail_line="Почини их сейчас: этот линтер в гейт пуша не входит, и отложенное замечание уедет в главную ветку молча."
 fi
 
-if [ "$mode" = "move" ]; then
-    head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ПЕРЕНОСА. Перенос меняет либу, а вместе с ней границы: импорт, законный на прежнем месте, на новом может быть запрещён."
-else
-    head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ:"
-fi
+case "$mode:$command_text" in
+    # Перенос назван отдельно: замечание после него объясняется не правкой файла, а сменой его
+    # места, и без этой строки читатель ищет промах в тексте, которого никто не менял.
+    move:*"git mv "*)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ПЕРЕНОСА. Перенос меняет либу, а вместе с ней границы: импорт, законный на прежнем месте, на новом может быть запрещён." ;;
+    move:*)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ЗАПИСИ КОМАНДОЙ:" ;;
+    *)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ:" ;;
+esac
 
 ctx="${head_line}
 ${report}

package/assets/hooks/proposal-guard.sh

@@ -82,11 +82,27 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg asked "$asked_
 
 [ "$verdict" = "owe" ] || exit 0
 
+# Команда отправки называется той, которая в этом дереве исполняется. Дерево, поставившее пакет
+# зависимостью, зовёт бинарь из зависимостей; дерево, где пакет живёт исходниками, бинаря не
+# имеет вовсе — там зовут собранный bin. Названная наугад команда стоит исполнителю хода: отказ
+# читается как указание, и вызов `npx agent-kit` отвечает в таком дереве отказом установки.
+root="${CLAUDE_PROJECT_DIR:-.}"
+if [ -x "$root/node_modules/.bin/agent-kit" ]; then
+    propose_cmd="npx agent-kit propose"
+else
+    built="$(ls "$root"/dist/*/bin/agent-kit.js 2>/dev/null | head -1)"
+    if [ -n "$built" ]; then
+        propose_cmd="node ${built#"$root"/} propose"
+    else
+        propose_cmd="npx agent-kit propose"
+    fi
+fi
+
 reason="BLOCKED by proposal-guard: владелец сказал завести или отправить предложение слою правил, а отправки в этом ходе не было. Написанное и не отправленное лежит в дереве неотличимо от отправленного: своей записи в слое правил у него нет, и владелец читает работу сделанной, пока не спросит прямо.
 
 Предложение пишется файлом в \`$proposals_dir/\` и уезжает в тот же ход:
 
-    npx agent-kit propose
+    $propose_cmd
 
 Сухой прогон отправкой не является: он показывает, что уехало бы, и следа наружу не оставляет. Отправка пишет отметки в файлы предложений и делает дерево грязным — при открытом PR они ложатся вторым коммитом в ту же ветку, и это их место, а не повод отложить.
 

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

@@ -22,6 +22,13 @@
 # как два разных требования.
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 
+# Собранное дерево кодом не бывает: путь к артефакту приходит из команды, которая его запускает.
+# Карта гейта такой путь уже пропускает, и слои обязаны молчать вместе с ней — иначе выход из
+# карты снимает одно требование и оставляет полтора десятка других.
+case "$target" in
+    */node_modules/* | */dist/* | */build/* | */.nx/* | */coverage/*) return 0 ;;
+esac
+
 rt_layer_add() {
     case " $req " in
         *" $1 "*) return 0 ;;

package/assets/hooks/skill-gate.sh

@@ -151,6 +151,20 @@ for name in $req; do
     break
 done
 [ -z "$want" ] && exit 0
+
+# Что потребуется дальше по этой же команде. Требуется по-прежнему одно правило за раз, но
+# длину пути заход видит с первого отказа: на сквозной правке отказы идут по одному на вызов и
+# читаются как разные требования — тринадцать подряд за одну задачу, и каждый стоил хода.
+ahead=""
+for name in $req; do
+    [ "$name" = "$want" ] && continue
+    [ -f "$root/$rules_dir/${name}/SKILL.md" ] || continue
+    if [ -f "$loaded" ] && grep -qE "^([^:]*:)?$(printf '%s' "$name" | sed 's/[][\.*^$/]/\\&/g')$" "$loaded" 2>/dev/null; then
+        continue
+    fi
+    ahead="${ahead}${ahead:+, }${name}"
+done
+
 req="$want"
 
 # Отбитие — наблюдение: правило, которое приходится требовать чаще прочего, и род правки, на
@@ -197,6 +211,21 @@ ${article}
     fi
 fi
 
+# Что потребуется дальше по этой же команде. Строка стоит после всех веток текста: их три, и
+# каждая переписывает причину целиком.
+[ -n "$ahead" ] && reason="${reason} Дальше по этой команде потребуются: ${ahead}."
+
+# Спутник зовётся отдельным предложением и ко всем видам отказа разом. Прежде он был назван
+# только запасным ходом — «если инструмент такого имени не знает», — и читатель, у которого имя
+# известно, до него не доходил вовсе. Цена этого: правило называет способ, а спутник рядом
+# объявляет его здесь невозможным; работа, сделанная способом из правила, кончилась результатом,
+# которого для её заказчика не существовало, а разделы спутника за тот заход не открывались ни
+# разу.
+companion="$rules_dir/${req}/implementation.md"
+[ -f "$root/$companion" ] && reason="${reason}
+
+Спутник правила — ${companion} — читается вместе с ним: правило говорит, что должно быть верно, а спутник — чем это верно здесь и что здесь названо невозможным. Инструментом он не грузится, его читают файлом."
+
 # Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.
 # Файл может быть не разложен — тогда хвоста нет, а причина отказа остаётся прежней.
 # shellcheck disable=SC1090

package/assets/hooks/task-context-load.sh

@@ -58,6 +58,16 @@ if [ ! -d "$DIR" ]; then
             printf 'Ветка `%s` названа задачей, а `%s/` нет: ход работы записывать некуда,\n' "$branch" "$DIR"
             printf 'и следующий заход начнёт с расспросов владельца.\n\n'
             printf 'Собрать с образца:\n\n    cp -r %s/_template %s\n\n' "$TASKS_DIR" "$DIR"
+            # Папка бывает названа не именем ветки: этапы одной большой задачи идут отдельными
+            # ветками при одной общей папке. Названная поимённо папка — единственное, по чему
+            # заход её найдёт; иначе он читает отказ как «записей нет» и отвечает владельцу из
+            # кода, минуя всё, что в этих записях решено.
+            others="$(find "$TASKS_DIR" -mindepth 1 -maxdepth 1 -type d ! -name '_template' 2>/dev/null | sort)"
+            if [ -n "$others" ]; then
+                printf 'В каталоге задач при этом лежит:\n\n%s\n\n' "$others"
+                printf 'Этапы одной задачи идут отдельными ветками при общей папке — прежде чем\n'
+                printf 'считать, что записей нет, смотрят в названные.\n\n'
+            fi
             # О соседнем ресурсе — условно и по имени: пакет не знает, разложен ли он здесь,
             # а сказанное безусловно приходит в контекст каждой сессии и врёт про дерево тем
             # увереннее, что печатает это сам инструмент.