@rt-tools/agent-kit 0.10.0 → 0.12.0

package/assets/hooks/sql-guard-parse.sh

@@ -13,6 +13,8 @@
 # команда становилась одним сегментом, доказательство чтения из первой строки покрывало
 # неразобранный вызов из второй, и запись на боевую базу проходила молча — тот же обход,
 # что чинили для `&&`, только набранный с новой строки.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 normalize() {
     perl -0ne '
         # Продолжение длинной команды обратным слешем — это одна строка, а не две: без

package/assets/hooks/sql-guard-request.sh

@@ -10,6 +10,9 @@
 
 # Три вида ввода: запрос через подключение редактора, команда оболочки и та же команда,
 # завёрнутая в универсальный исполнитель. Инструмент, не названный здесь, гарда не касается.
+. "$(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
+
 sql_read_request() {
     sql=""
     context=""
@@ -23,7 +26,7 @@ sql_read_request() {
         # Терминал IDE исполняет ту же командную строку и кладёт её в то же поле, что и Bash:
         # без этой ветки весь гард обходился сменой инструмента.
         Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
-            cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+            cmd="$(rt_hook_cmd)"
             [ -z "$cmd" ] && exit 0
 
             # Универсальный исполнитель зовёт ЛЮБОЙ инструмент редактора по имени, в том числе

package/assets/hooks/sql-guard-target.sh

@@ -18,6 +18,8 @@
 # подключения, и по одному SQL отличить прод от локальной копии невозможно. Поэтому
 # подключения опознаются в лицо. Список сверяется вызовом list_database_connections;
 # добавили новое — допишите сюда, иначе оно попадёт в «неизвестные» ниже.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 sql_resolve_target() {
     is_prod=""
     PROD_CONNECTIONS="${RT_PROD_CONNECTIONS:-}"

package/assets/hooks/sql-guard-write.sh

@@ -7,6 +7,8 @@
 
 # Глаголы ищутся в сегментах ВЫЗОВА, а не по всей строке: иначе слово из шаблона поиска в
 # соседнем звене цепочки объявляло записью читающую команду.
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 sql_detect_write() {
     is_write=""
     write_scope="$segments"

package/assets/hooks/sql-guard.sh

@@ -40,11 +40,15 @@
 # пропускаются целиком — иначе слова «drop» и «update» в описании коммита читались бы как
 # запрос. Доставки запроса внутри такой команды не бывает, так что цена послабления нулевая.
 
-input="$(cat 2>/dev/null)"
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
-tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
+tool="$(rt_hook_tool)"
 
 # Рабочий каталог нужен одному правилу — разрешению адреса миграции: `DATABASE_URL`
 # обычно не назван в команде и лежит в `.env` рядом с проектом.

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

@@ -14,6 +14,8 @@
 # FAIL-OPEN: нет `jq`, не git-репозиторий, нет папки задачи — выходим молча. Сессия важнее
 # контекста.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 ROOT="${CLAUDE_PROJECT_DIR:-.}"
 command -v jq >/dev/null 2>&1 || exit 0
 cd "$ROOT" 2>/dev/null || exit 0

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

@@ -25,7 +25,11 @@
 # FAIL-OPEN: нет jq, не git-репозиторий, битый ввод, чужой инструмент → пропуск. Сломанный
 # гард не должен мешать работать.
 
-input="$(cat 2>/dev/null)"
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
@@ -43,7 +47,7 @@ done
 [ -f "$rt_hooks_dir/profile-check.sh" ] && . "$rt_hooks_dir/profile-check.sh"
 command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2>&1; }
 
-tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
+tool="$(rt_hook_tool)"
 candidates=""
 case "$tool" in
     # Инструмент редактора заводит файл теми же двумя данными, только называет их иначе —
@@ -59,7 +63,7 @@ case "$tool" in
     # имён гард стоял бы объявленным на них и молча пропускал — состояние хуже необъявленного,
     # потому что снаружи выглядит закрытым.
     Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool)
-        cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+        cmd="$(rt_hook_cmd)"
         [ -z "$cmd" ] && exit 0
         # Универсальный исполнитель прячет настоящую команду во вложенной строке: без её разбора
         # путь стоит за кавычкой, и до него не дотягивается ни один образец.
@@ -125,7 +129,7 @@ deny() {
 }
 
 # Ветку смотрим там же, где пойдёт правка: у worktree она своя.
-workdir="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
+workdir="$(rt_hook_cwd)"
 [ -z "$workdir" ] && workdir="${CLAUDE_PROJECT_DIR:-.}"
 cd "$workdir" 2>/dev/null || exit 0
 git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0

package/assets/hooks/turn-entry-load.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# rt-hook: SessionStart startup|resume|compact|clear
+# Требует: hooks/handoff-write.sh
+# SessionStart: передача прошлого захода и карта хода уезжают в контекст на каждом запуске.
+#
+# Передачу пишет хук перед сжатием — и на этом её путь кончался: читать её не умел никто, и
+# в новый заход её клал человек. Написанная и не прочитанная, она равна ненаписанной.
+#
+# Второе, чего заход после сжатия не знает, — как здесь ведут работу. Перечень состояний с
+# обязательными действиями лежит в правиле, а правило после сжатия не загружено: заход первым
+# движением идёт читать его целиком, то есть тратит на восстановление порядка ту часть окна,
+# ради которой сжатие и случилось. Карта отвечает на этот вопрос до того, как он задан.
+#
+# Подаётся это на всех четырёх запусках, а не только после сжатия: заход после обрыва и заход
+# после очистки начинают с того же пустого места, и разница между ними исполнителю не видна.
+#
+# FAIL-OPEN: не git-репозиторий, нет ветки, нет каталога передач, нет карты, нечитаемый файл —
+# хук выходит нулём и молчит о той части, которой нет. Запуск он не отбивает никогда: сессия
+# важнее контекста.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
+ROOT="${CLAUDE_PROJECT_DIR:-.}"
+cd "$ROOT" 2>/dev/null || exit 0
+git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
+
+branch="$(git branch --show-current 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" \
+    "$ROOT/.claude/rt-kit/defaults/project.sh" "$ROOT/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+handoff_dir="${RT_HANDOFF_DIR:-.claude/handoff}"
+map="$rt_hooks_dir/../rt-kit/defaults/turn-map.md"
+[ -f "$map" ] || map="$ROOT/.claude/rt-kit/defaults/turn-map.md"
+
+# Передача берётся по имени текущей ветки. Чужая, поданная как своя, описывает работу, которой
+# в этом дереве нет, — поэтому имя файла собирается из ветки, а не выбирается из каталога.
+handoff=''
+[ -n "$branch" ] && handoff="$ROOT/$handoff_dir/$branch.md"
+
+if [ -n "$handoff" ] && [ -r "$handoff" ]; then
+    printf 'ПЕРЕДАЧА ПРОШЛОГО ЗАХОДА — `%s/%s.md`, ниже целиком.\n\n' "$handoff_dir" "$branch"
+    printf 'Она написана прошлым заходом и описывает минуту, когда её собрали. Всё, что в ней\n'
+    printf 'стоит о дереве, проверяется деревом: команда этого хода главнее записанной вчера.\n\n'
+    cat "$handoff" 2>/dev/null
+    printf '\n\n'
+fi
+
+if [ -r "$map" ]; then
+    printf 'КАРТА ХОДА — состояния работы и то, чем ход кончается. Ниже целиком.\n\n'
+    printf 'Это выжимка правила ведения работы, а не оно само: правило объясняет, карта\n'
+    printf 'называет. Своё состояние заход читает в разделе «Где стоим» хода работы.\n\n'
+    cat "$map" 2>/dev/null
+    printf '\n'
+fi
+
+exit 0

package/assets/hooks/turn-exit-guard.sh

@@ -22,14 +22,21 @@
 #   5. Передача захода написана — окно кончилось.
 #   6. Владелец сказал остановиться.
 #
-# Чего страж не судит. Заход вне ветки задачи и работу без папки: состояние там объявлять
-# негде, и отбивать было бы не за что. Это его известная граница.
+# Работа без ветки и без папки задачи судится вторым признаком. Состояния у неё нет, и первый
+# признак взять неоткуда, — но ход, в котором не было ни одной правки дерева, не кончается и
+# здесь: просьба владельца «разложи», «обнови», «посмотри» живёт без задачи и без ветки, и
+# защищена она была меньше всего. Отпускают такой ход те же четыре вещи: вопрос, отказ гарда,
+# написанная передача и слово владельца об остановке.
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода, папки задачи
 # или строки состояния ход РАЗРЕШАЕТСЯ (exit 0). Сломанный страж не имеет права заклинить
 # разговор.
 
-input="$(cat 2>/dev/null)"
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
@@ -41,22 +48,25 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 [ -z "$transcript" ] && exit 0
 [ -f "$transcript" ] || exit 0
 
-workdir="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
+workdir="$(rt_hook_cwd)"
 [ -z "$workdir" ] && workdir="${CLAUDE_PROJECT_DIR:-.}"
 cd "$workdir" 2>/dev/null || exit 0
 git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
 
-branch="$(git branch --show-current 2>/dev/null)"
-[ -z "$branch" ] && exit 0
-
 root="$(git rev-parse --show-toplevel 2>/dev/null)"
 [ -z "$root" ] && exit 0
-tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
-progress="$root/$tasks_dir/$branch/progress.md"
-[ -f "$progress" ] || exit 0
 
-state="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Состояние:\*\*[[:space:]]*`\([^`]*\)`.*/\1/p' "$progress" 2>/dev/null | head -1)"
-[ -z "$state" ] && exit 0
+# Ветка, папка задачи и строка состояния берутся, пока они есть. Пусто — ход судится вторым
+# признаком, а не отпускается: отсюда раньше уходили нулём, и работа по слову владельца
+# кончалась объявлением намерения молча.
+branch="$(git branch --show-current 2>/dev/null)"
+tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
+progress=""
+state=""
+if [ -n "$branch" ] && [ -f "$root/$tasks_dir/$branch/progress.md" ]; then
+    progress="$root/$tasks_dir/$branch/progress.md"
+    state="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Состояние:\*\*[[:space:]]*`\([^`]*\)`.*/\1/p' "$progress" 2>/dev/null | head -1)"
+fi
 
 # Работа, дошедшая до этих двух состояний, чужого шага уже дождалась: дальше её двигает
 # владелец, и ход, закрытый здесь, ничего не роняет.
@@ -66,7 +76,8 @@ esac
 
 # Следующий шаг из хода работы — его страж и называет в отказе: исполнитель, которому сказано
 # только «работа не кончена», перечитывает ту же строку сам.
-next_step="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Следующий шаг:\*\*[[:space:]]*\(.*\)/\1/p' "$progress" 2>/dev/null | head -1)"
+next_step=""
+[ -n "$progress" ] && next_step="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Следующий шаг:\*\*[[:space:]]*\(.*\)/\1/p' "$progress" 2>/dev/null | head -1)"
 [ -z "$next_step" ] && next_step="что стоит в разделе «Где стоим» хода работы"
 
 # Команда, меняющая дерево или его состояние. Чтение и поиск сюда не входят намеренно: ими и
@@ -117,10 +128,14 @@ commands="$(printf '%s' "$verdict" | jq -r '.ran // ""' 2>/dev/null)"
 # Страж сравнивает номер этапа с тем, что лежит в истории ветки, и на выросшем номере требует
 # команды из строки «Чем проверяется» — она стоит в замысле обратными кавычками. Приём, записанный
 # прозой, страж не читает: подтвердить его выводом нечем, и это его известная граница.
-stage_now="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$progress" 2>/dev/null | head -1)"
-stage_was="$(git -C "$root" show "HEAD:$tasks_dir/$branch/progress.md" 2>/dev/null | sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -1)"
+stage_now=""
+stage_was=""
+if [ -n "$progress" ]; then
+    stage_now="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$progress" 2>/dev/null | head -1)"
+    stage_was="$(git -C "$root" show "HEAD:$tasks_dir/$branch/progress.md" 2>/dev/null | sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -1)"
+fi
 
-if [ -n "$stage_now" ] && [ -n "$stage_was" ] && [ "$stage_now" -gt "$stage_was" ] 2>/dev/null; then
+if [ -n "$progress" ] && [ -n "$stage_now" ] && [ -n "$stage_was" ] && [ "$stage_now" -gt "$stage_was" ] 2>/dev/null; then
     plan="$root/$tasks_dir/$branch/plan.md"
     # Контракт закрытого этапа, а не начатого: подтверждается то, что объявлено сделанным.
     contract="$(awk -v n="$stage_was" '
@@ -162,7 +177,18 @@ fi
 
 [ "$worked" = "true" ] && exit 0
 
-reason="BLOCKED by turn-exit-guard: работа в состоянии '${state}', а за этот ход по ней не сделано ничего — ни правки, ни команды, меняющей дерево.
+if [ -z "$state" ]; then
+    reason="BLOCKED by turn-exit-guard: за этот ход не сделано ничего — ни правки, ни команды, меняющей дерево. Папки задачи у этой работы нет, и состояние взять неоткуда, но ход это не кончает.
+
+Ход кончается четырьмя способами, и других нет: вопрос владельцу, ответа на который в правилах нет; отказ гарда; заполненное окно захода; отданная работа с начатой следующей. Названная и не запущенная команда выходом не является: строка «сейчас запущу» — объявление намерения, а оно прямо названо ложным концом хода.
+
+Работа по слову владельца — «разложи», «обнови», «посмотри» — идёт без задачи и без ветки, и остановить её нечем, кроме этого признака.
+
+Запусти названное этим же ходом. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+else
+    reason="BLOCKED by turn-exit-guard: работа в состоянии '${state}', а за этот ход по ней не сделано ничего — ни правки, ни команды, меняющей дерево.
 
 Ход кончается четырьмя способами, и других нет: вопрос владельцу, ответа на который в правилах нет; отказ гарда; заполненное окно захода; отданная работа с начатой следующей. Отчёт о сделанном выходом не является — он выглядит работой лучше всякой другой, и пустоты за ним не видно.
 
@@ -171,6 +197,7 @@ reason="BLOCKED by turn-exit-guard: работа в состоянии '${state}
 Сделай его этим же ходом. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
 
 Страж судит один ход: следующий заход не отбивается."
+fi
 
 # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
 # а причина отказа остаётся прежней.

package/assets/hooks/utf8.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Локаль исполнения гарда. Подключается первой строкой тела: `. "<каталог гардов>/utf8.sh"`.
+#
+# Образцы гардов написаны словами того языка, на котором говорит дерево, и совпадение с ними
+# зависит от локали процесса. В локали C складывание регистра работает только для латиницы:
+# «В дереве этого нет» под образцом `(в дереве|здесь)…` не находится вовсе, гард выходит нулём
+# и пропускает ход, который обязан был вернуть. Счёт `{0,30}` там же считает байты, а не буквы,
+# и буква вне латиницы весит два.
+#
+# Заметить это на своей машине нечем: терминал разработчика идёт в UTF-8, а служба, запускающая
+# ту же работу, наследует пустую локаль. Три сценария так и падали в конвейере, проходя на
+# машине, где их писали.
+#
+# FAIL-OPEN: локали UTF-8 в системе не нашлось — ничего не объявляется, и гард работает как
+# прежде. Отобрать у него работу из-за отсутствия локали хуже, чем оставить прежнее поведение.
+
+rt_use_utf8_locale() {
+    case "${LC_ALL:-${LC_CTYPE:-${LANG:-}}}" in
+        *UTF-8* | *utf-8* | *UTF8* | *utf8*) return 0 ;;
+    esac
+
+    local available candidate
+    available="$(locale -a 2>/dev/null)" || return 0
+
+    for candidate in C.UTF-8 en_US.UTF-8 ru_RU.UTF-8; do
+        if printf '%s\n' "$available" | grep -qx -- "$candidate"; then
+            export LC_ALL="$candidate"
+            return 0
+        fi
+    done
+
+    return 0
+}
+
+rt_use_utf8_locale

package/assets/hooks/waiting-turn-guard.sh

@@ -30,7 +30,11 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
 # заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
-input="$(cat 2>/dev/null)"
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 
 command -v jq >/dev/null 2>&1 || exit 0

package/assets/hooks/window-fill-guard.sh

@@ -16,13 +16,24 @@
 # Место между порогами и есть то, на что закрывается заход: дописать ход работы, написать
 # передачу, закоммитить проверенное.
 #
+# Там, где дерево объявило порог сжатия ниже порога остановки, напоминание говорит обратное:
+# точку остановки выбирать не надо, потому что заход через порог пройдёт сам — сжатие придёт
+# первым, передачу к тому времени напишет свой хук, и работа продолжится тем же заходом. Отбой
+# при этом остаётся: он превращается из конца захода в страховку на случай, когда сжатие не
+# пришло. Напоминание, зовущее закрывать заход там, где закрывать его не надо, — это остановка
+# работы без причины, и стоит она ровно того же, что и отбой.
+#
 # Размер окна берётся из настройки дерева. Из записи захода он не выводится: модель записана
 # там без пометки о расширенном окне, и заход на широкое окно от захода на узкое неотличим.
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет размера окна, нет записи захода, нет разборщика, битый разбор —
 # работа РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
 
-input="$(cat 2>/dev/null)"
+. "$(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_hook_read
+input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 
 command -v jq >/dev/null 2>&1 || exit 0
@@ -49,6 +60,21 @@ esac
 
 warn_pct="${RT_WINDOW_WARN_PCT:-40}"
 stop_pct="${RT_WINDOW_STOP_PCT:-50}"
+
+# Доля, на которой контекст сжимает сам инструмент. Объявлена деревом — заход через порог
+# проходит сам: сжатие приходит первым, передачу к тому моменту уже написал свой хук, и работа
+# идёт дальше тем же заходом. Не объявлена — прежний порядок: заход кончается передачей.
+#
+# От этого зависит текст напоминания, а не отказ. Отбой на пороге остановки остаётся в обоих
+# случаях: он и есть страховка на случай, когда сжатие не пришло — настройка снята, версия
+# другая, сжатие отказало. Отобрав отбой у дерева, объявившего сжатие, страж пустил бы такой
+# заход до предела окна, где работа теряется целиком.
+compact_pct="${CLAUDE_AUTOCOMPACT_PCT_OVERRIDE:-}"
+case "$compact_pct" in
+    '' | *[!0-9]*) compact_pct='' ;;
+esac
+[ -n "$compact_pct" ] && [ "$compact_pct" -ge "$stop_pct" ] 2>/dev/null && compact_pct=''
+
 tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
 handoff_dir="${RT_HANDOFF_DIR:-.claude/handoff}"
 
@@ -99,7 +125,13 @@ if [ "$event" = "PostToolUse" ]; then
     printf '%s' "$step" > "$mark" 2>/dev/null
 
     if [ "$pct" -ge "$stop_pct" ]; then
-        text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается."
+        if [ -n "$compact_pct" ]; then
+            text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Сжатие объявлено на ${compact_pct}% и не пришло: порог остановки ${stop_pct}% пройден, а контекст прежний. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается — закрывай заход и скажи владельцу, что сжатие не сработало."
+        else
+            text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается."
+        fi
+    elif [ -n "$compact_pct" ]; then
+        text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k). Точку остановки выбирать не надо: на ${compact_pct}% инструмент сожмёт контекст сам, передачу к тому времени напишет хук, и работа пойдёт дальше этим же заходом. Порог остановки ${stop_pct}% — страховка на случай, если сжатие не придёт. Работай дальше."
     else
         text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k). Пора выбирать точку остановки: с ${stop_pct}% останется только закрыть заход. Доведи текущий шаг до состояния, с которого следующий заход продолжит, перепиши «Где стоим» в ходе работы, напиши передачу и отдай владельцу путь к ней — паттерн task-flow-handoff."
     fi
@@ -114,9 +146,9 @@ fi
 [ "$event" = "PreToolUse" ] || exit 0
 [ "$pct" -ge "$stop_pct" ] || exit 0
 
-tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
-path="$(printf '%s' "$input" | jq -r '.tool_input.file_path // empty' 2>/dev/null)"
-cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+tool="$(rt_hook_tool)"
+path="$(rt_hook_file)"
+cmd="$(rt_hook_cmd)"
 
 allowed=0
 case "$tool" in

package/assets/laws/work-conduct.md

@@ -1,9 +1,7 @@
 # Закон о ведении работы
 
-Что должно быть верно про то, как работа идёт от просьбы владельца до её закрытия. Работа
-длится дольше одного захода и переживает перерывы: между заходами исполнитель не помнит
-ничего, а владелец помнит и вынужден пересказывать. Пересказ каждый раз выходит короче
-предыдущего, и работа доделывается по обрывку исходной просьбы.
+Закон устанавливает как ведётся работа от момента постановки задачи до её закрытия. Работа
+длится дольше одной сессии и должна сохранять весь контекст и состояние при переходах из одной сессии в другую.
 
 ## Статьи
 
@@ -13,15 +11,13 @@
 - **Пробел закрывается вопросом владельцу, а не догадкой.** Догадка неотличима от знания:
   она попадает в работу молча и обнаруживается только при приёмке, когда переделывать дороже
   всего.
-- **Работа, объявленная сборкой по образцу, начинается с чтения самого образца.** Пересказ
+- **Работа, которая требует изменений по образцу, начинается с чтения самого образца.** Пересказ
   образца образцом не является: по нему собирается понимание того, кто пересказывал, и
   расхождение всплывает на приёмке целой работой, а не строкой. Читается та часть образца,
   которую работа повторяет, и читается целиком — об устройстве чужого дерева по одному его
   файлу не судят.
-- **Образец, названный однажды, доступен каждому заходу работы.** Где он лежит, записано
-  там, где заход найдёт это без владельца. Иначе второй заход собирает по памяти первого,
-  третий — по пересказу второго, и к четвёртому от образца не остаётся ничего, кроме слова
-  «образец».
+- **Образец, указанный в ходе работы должен быть доступен каждой сессии во время работы.**
+  Ссылка на образец нужно указывать непосредственно в файле с описанием прогресса работы.
 - **Вопрос, у которого есть очевидный ответ, работу не останавливает.** Исполнитель называет
   допущение, идёт дальше и записывает его туда же, где идёт работа. Останавливает только тот
   пробел, при котором любая догадка делает работу опасной или бесполезной. Вопрос, заданный
@@ -71,6 +67,15 @@
   владельца.** Владелец знает, что работа не кончена, но не знает, где именно она стоит;
   пересказ он даёт по своей памяти, а не по ходу работы, и следующий заход начинает с чужой
   картины.
+- **Переданное прошлым заходом приходит в новый заход само, а не кладётся рукой.** Передача,
+  написанная и не прочитанная, равна ненаписанной: следующий заход о ней не знает и начинает с
+  пустого места — то есть с того же, ради чего её и писали. Кладёт её человек ровно до тех пор,
+  пока это не поручено машине; поручённое машине не забывается ночью.
+- **Порядок ведения работы приходит в заход вместе с работой, а не разыскивается им.** Заход,
+  знающий задачу и не знающий, что с ней делают дальше, первым движением идёт читать правило
+  целиком — и тратит на это ту часть места, ради которой заход и начали заново. Приходит
+  короткая выжимка: состояния, обязательное действие каждого и то, чем ход кончается. Правило
+  она не заменяет и заменить не может — она отвечает на вопрос «что делать», а не «почему».
 - **Замысел и ход работы — разные записи.** Замысел — то, с чем сверяют результат при
   приёмке; правленный по ходу, он перестаёт отличаться от PR, и приёмке сверять нечего.
 - **Сделанное отмечается в одном месте.** Две записи об одном разъезжаются молча, и после
@@ -142,6 +147,26 @@
   остановиться позволяет только предел заполнения окна. Заход, закрытый на готовой задаче,
   оставляет владельцу пустое место и стоит целого захода на возвращение к тому, что и так было
   под рукой.
+- **Предел заполнения окна останавливает заход только там, где инструмент не сжимает контекст
+  сам.** Где сжатие объявлено и приходит раньше предела, окно — не конец захода, а его
+  продолжение: контекст сжимается, записанное состояние работы возвращается в него, и работа
+  идёт дальше тем же заходом. Останавливаться там незачем, а остановка стоит того же, что и
+  всякая другая: владелец возвращает исполнителя в работу руками.
+- **Порог, на котором заход останавливают, стоит позже порога, на котором его продолжают.**
+  Два порога на одном числе — это не согласие, а гонка, и выигрывает её тот, кто ближе к
+  действию: остановка приходит на вызове, а сжатие — между ходами. Расстояние между ними
+  объявляется, а не выводится разницей: сжатие идёт не мгновенно, и порог, отстоящий на волос,
+  требование «раньше» удовлетворяет, а работу не спасает.
+- **Переход из состояния в состояние исполнителя не останавливает.** Обязательное
+  действие сделано — следующее начинается тем же движением, без отчёта владельцу и без его
+  слова. Граница между состояниями выглядит законченным куском лучше всякой другой вехи:
+  сделанное названо, отчитаться есть чем, — и отчёт встаёт ровно на то место, где должно было
+  стоять следующее действие. Владелец читает такой отчёт как сделанную работу, а работа стоит.
+- **Текст, ведущий состояние работы, называет, что делается сразу за ним.** Дочитанный до
+  последнего приёма, он кончается ничем: следующего движения в нём нет, и исполнитель выводит
+  его из пустоты — то есть останавливается. Названное движение стоит там же, где приёмы, и
+  своими словами: одинаковая на все состояния строка перестаёт замечаться раньше, чем
+  понадобится.
 - **Работа, отданная на разбор, освобождает исполнителя, а не останавливает его.** Отданное на
   разбор ждёт владельца, а не машину: следующая задача эпика берётся тем же движением, которым
   предыдущая ушла на разбор.

package/assets/patterns/dependencies-upgrade.md

@@ -2,7 +2,7 @@
 name: dependencies-upgrade
 kind: pattern
 rule: dependencies
-description: Паттерн правила dependencies. Брать при подъёме версий пакетов — выбор верхней границы по peer-диапазонам, порядок проверок, граница переформатирования после обновления форматтера, разбор новых правил линтера. Не брать для ветки, коммита и PR — это паттерн git-workflow-commit.
+description: Паттерн правила dependencies. Брать при подъёме версий пакетов — выбор верхней границы по peer-диапазонам, порядок проверок, граница переформатирования после обновления форматтера, разбор новых правил линтера. Не брать для ветки и коммита — это паттерн git-workflow-commit, для PR — git-workflow-pr.
 ---
 
 # Подъём версий

package/assets/patterns/doc-style-write.md

@@ -19,7 +19,7 @@ description: Паттерн правила doc-style. Брать при напи
 
 Само правило укладывается в одно предложение. Следом — не больше двух предложений о том, что
 сломается иначе, и только если из самой фразы это не видно. Обоснование, у которого была
-альтернатива, идёт в «Ловушки» правила, а не в сам закон: разросшийся буллет читают по
+альтернатива, идёт в ловушки — холодную часть правила, — а не в сам закон: разросшийся буллет читают по
 диагонали, а закон говорит, что верно, — не почему когда-то выбрали так.
 
 ```
@@ -41,8 +41,8 @@ description: Паттерн правила doc-style. Брать при напи
 Место исполнения меняется при первом же рефакторинге, и документ, который его называет,
 устаревает молча. Для него заведён отдельный файл — `implementation.md` рядом.
 
-Исключение — «Ловушки» правила: там устройство кода называется прямо, потому что ловушка и
-есть место, где на него наступают.
+Исключение — ловушки в холодной части правила: там устройство кода называется прямо, потому
+что ловушка и есть место, где на него наступают.
 
 ## Без утверждений о будущем