@rt-tools/agent-kit 0.10.0 → 0.11.0

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

@@ -30,6 +30,8 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
 # заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 

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

@@ -16,12 +16,21 @@
 # Место между порогами и есть то, на что закрывается заход: дописать ход работы, написать
 # передачу, закоммитить проверенное.
 #
+# Там, где дерево объявило порог сжатия ниже порога остановки, напоминание говорит обратное:
+# точку остановки выбирать не надо, потому что заход через порог пройдёт сам — сжатие придёт
+# первым, передачу к тому времени напишет свой хук, и работа продолжится тем же заходом. Отбой
+# при этом остаётся: он превращается из конца захода в страховку на случай, когда сжатие не
+# пришло. Напоминание, зовущее закрывать заход там, где закрывать его не надо, — это остановка
+# работы без причины, и стоит она ровно того же, что и отбой.
+#
 # Размер окна берётся из настройки дерева. Из записи захода он не выводится: модель записана
 # там без пометки о расширенном окне, и заход на широкое окно от захода на узкое неотличим.
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет размера окна, нет записи захода, нет разборщика, битый разбор —
 # работа РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 
@@ -49,6 +58,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 +123,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

package/assets/laws/work-conduct.md

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

package/assets/patterns/cargo-triage-mark.md

@@ -0,0 +1,119 @@
+---
+name: cargo-triage-mark
+kind: pattern
+rule: cargo-triage
+description: Паттерн правила cargo-triage. Брать при разборе приехавшего груза — готовые вызовы отметки: сухой прогон, пачка записей за вызов, приём починки при переходе в готово, версия выпуска при выпуске, разбор отбитой строки. Не брать для сведения предложений в правки пакета — это своя команда.
+---
+
+# Отметка записей груза
+
+Паттерн правила `cargo-triage`. Что при этом должно быть верно — закон
+`docs/constitution/work-conduct.md`.
+
+Вызовы ниже идут строкой запуска самого пакета и токеном дерева: токен лежит вне дерева, и без
+него команда отбивает вызов, не ходя в сеть.
+
+## Когда брать
+
+- Разбирается приехавший груз, и по записи принято решение.
+- Правка по записи влита в главную ветку.
+- Опубликована редакция, увёзшая починку к потребителю.
+- Вызов отметки вернул отбитую строку.
+
+## Что читается раньше вызова
+
+Список неразобранного — в админке приёма, отбором по состоянию «новое» и порядком приезда.
+Пока список не сужен, разобранное и нетронутое стоят вперемешку, и разбор идёт по второму
+кругу.
+
+Имя команды, адрес приёма и слова состояний у каждого дерева свои — они названы в
+`implementation.md` правила. Ниже они стоят так, как их зовёт пакет.
+
+## Взятие в работу: задача и отметка одним ходом
+
+Сначала задача — иначе отметка говорит, что запись взяли, и молчит о том, где идёт работа:
+
+```bash
+npm run task:new -- --title '<что не так>' --slug <короткое-имя> --label bug < тело.md
+```
+
+Отметка идёт следом, тем же ходом, и несёт все записи, которые эта задача закрывает:
+
+```bash
+npx agent-kit mark --state in_work \
+    --postmortem 2026-08-14-structure-invented-beside-the-sample.md \
+    --postmortem 2026-08-15-guard-denied-shell-wrote-anyway.md \
+    --proposal <признак предложения>
+```
+
+Род записи называется своим доводом: разбор происшествия — именем файла, предложение —
+признаком текста. Записи обоих родов едут одним вызовом.
+
+Сухим прогоном смотрят, что уехало бы, — он ничего не отправляет и следа наружу не оставляет:
+
+```bash
+npx agent-kit mark --state in_work --postmortem <файл> --dry-run
+```
+
+Сухой прогон вместо настоящего вызова оставляет запись в прежнем состоянии. Отметкой он не
+считается.
+
+## Починка: переход вместе с ответом на «чем»
+
+Ставится после того, как правка влита в главную ветку, — не по открытой заявке:
+
+```bash
+npx agent-kit mark --state fixed \
+    --postmortem <файл> \
+    --fix 'заведена статья правила о разборе груза и паттерн с готовыми вызовами'
+```
+
+Текст отвечает на «чем», а не на «где»: статья правила, гард, проверка, правка кода. Без него
+строка отбивается — переход в починку без ответа на «чем» приёмник не принимает.
+
+## Выпуск: версия называется тем, кто публикует
+
+Идёт тем же движением, что и публикация редакции:
+
+```bash
+npx agent-kit mark --state released --postmortem <файл> --release 'rt-agent-kit@0.10.1'
+```
+
+Версия — та, которой назван выпуск, увёзший починку. Не номер редакции приёмника и не время
+выкатки.
+
+## Ответ читается
+
+Вызов отвечает тремя числами и списком:
+
+```
+переведено 2, уже стояло 1, отбито 1
+  строка 3: <ключ> — записи у дерева нет
+```
+
+- **Переведено 0, уже стояло N** — этот разбор не двинул ничего: записи отмечены раньше либо
+  ключи названы не те.
+- **Отбито N** — эти записи остались там, где были. Причина названа при строке, и повтор того
+  же вызова отбивается ровно так же.
+
+Причины отбоя и что делать с каждой:
+
+| Что сказано            | Что это значит                                 | Что делать                           |
+| ---------------------- | ---------------------------------------------- | ------------------------------------ |
+| записи у дерева нет    | ключ назван не тот либо запись прислало не оно | сверить ключ со списком в админке    |
+| переход не разрешён    | шаг через состояние либо ход назад             | пройти состояние, которое пропустили |
+| перехода без текста    | починка без ответа на «чем»                    | добавить довод с текстом починки     |
+| текста не при том шаге | текст приехал с переходом, который не починка  | убрать довод либо сменить состояние  |
+| перехода без версии    | выпуск без ответа на «где искать фикс»         | добавить довод с версией выпуска     |
+| версии не при том шаге | версия приехала с переходом, который не выпуск | убрать довод либо сменить состояние  |
+
+## Ловушки
+
+- **Вызов без токена отбивается без сети.** Токен лежит вне дерева, и на свежей рабочей копии
+  его нет: команда называет это прямо, а не молчит.
+- **Своё дерево называется признаком из токена, а не доводом.** Приём сверяет его сам, и
+  назваться чужим деревом вызов не может.
+- **Записи, отмеченные в одной ветке, в соседней выглядят неотмеченными только в файлах.**
+  Состояние лежит в приёме, а не в дереве: смотрят его в админке, а не в рабочей копии.
+- **Повторная отметка тем же состоянием промахом не считается.** Рабочий порядок повторяют, и
+  вторая та же отметка отбивается ответом «уже стояло», а не отказом.

package/assets/patterns/task-flow-close.md

@@ -102,6 +102,9 @@ PR #<номер> готов к слиянию: прогон зелёный, па
 кто пишет тело. Разница между ними одна, и она вся: реплику владелец прочитает, только если
 вернётся в переписку, а раздел он видит там, куда смотрит, нажимая кнопку.
 
+**Следующее движение:** тем же ходом берётся следующая задача эпика, а разбор закрытой работы
+уходит в фон. Прогон и владелец идут без исполнителя, и ждать их состоянием работы не бывает.
+
 ## Состояние `разбор-кончился`: договорённость вливается в спек домена
 
 Последним коммитом PR, до слияния. Код к этому моменту написан, поэтому привязки
@@ -131,6 +134,9 @@ npm run check:specs   # раздел «Пора вливать» называе
 npm run check:specs   # после вливания: привязки на месте, сценарии не потерялись
 ```
 
+**Следующее движение:** за влитой договорённостью тем же ходом идут тексты домена — правила,
+паттерны и разделы, которые работа задела.
+
 ## Состояние `разбор-кончился`: тексты домена приводятся к сделанному
 
 В спек уезжает только то, что записали до кода. Остальные тексты — правила, паттерны, законы
@@ -172,6 +178,9 @@ grep -rn -A3 "Чего из закона здесь нет" <каталог пр
 Что сделали на этом шаге, пишется в тело PR: что перечитали, что изменили, а если ничего
 не изменили — почему. Форма раздела — паттерн `git-workflow-commit`.
 
+**Следующее движение:** приведённые тексты коммитятся, и тем же ходом разбирается папка
+задачи — последним коммитом ветки.
+
 ## Состояние `разбор-кончился`: папка задачи разбирается
 
 Разбор идёт по трём исходам, а не по двум.
@@ -229,6 +238,9 @@ rm -r docs/tasks/<своя>
 Две записи в архиве, а не одна: работы разные, и решения в них разные. Сверка очереди работ
 после этого не называет ни одной папки — этим и проверяется, что разобраны обе.
 
+**Следующее движение:** разобранная папка уезжает в ветку тем же коммитом, и следом за ним
+сверяется очередь работ.
+
 ## Состояние `папка-разобрана`: сверка очереди работ
 
 ```bash
@@ -237,6 +249,9 @@ npm run check:specs   # договорённость влита, привязк
 npm run check:docs    # пути, названные в текстах, существуют
 ```
 
+**Следующее движение:** расхождения, названные сверками, чинятся тем же ходом; чинить нечего —
+тот же ход снимает черновик и просит владельца влить, называя номер.
+
 ## Состояние `влито`: работа разбирается правилами — фоном, следом за PR
 
 Шаг о слое правил, а не о продукте: что за эту работу грузилось, что помогло, чего не хватило и
@@ -261,6 +276,9 @@ npm run check:docs    # пути, названные в текстах, суще
 3. **Вернувшиеся находки принимают одним ходом** — записать и вернуться к прежнему. Разбор,
    отложенный «до удобного момента», не случается вовсе: заход кончается раньше.
 
+**Следующее движение:** пока роль разбирает, тот же ход занят следующей задачей; вернувшиеся
+находки принимаются одним ходом — записать и продолжить прежнее.
+
 ## Состояние `влито`: находки разбора ложатся в папку задачи и ждут владельца
 
 Ответ роли живёт в переписке и умирает вместе с ней, поэтому он сразу ложится на диск — в папку
@@ -296,6 +314,9 @@ npm run check:docs    # пути, названные в текстах, суще
 котором владелец сказал вслух, уходит наружу в тот же ход: написанное и не отправленное лежит в
 дереве неотличимо от отправленного.
 
+**Следующее движение:** записанные находки работу не держат — следующая задача уже идёт, а
+владельцу о них говорится, когда кончился эпик.
+
 ## Ловушки
 
 - **Папку разбирают до слияния — потом о ней уже никто не вспомнит.** Сверка очереди считает

package/assets/patterns/task-flow-handoff.md

@@ -66,6 +66,24 @@ mkdir -p <каталог передачи>
 # файл — <каталог передачи>/<ветка>.md
 ```
 
+**Черновик передачи пишет хук, а не рука.** Перед сжатием контекста он кладёт по тому же
+адресу то, что есть на диске: ветку, состояние работы, следующий шаг, незакоммиченное, коммиты
+сверх главной. Сжатие приходит и тогда, когда напомнить некому — ночью или посреди длинного
+хода, — и без хука заход в этот момент терял передачу целиком.
+
+**Читает передачу тоже хук, а не человек.** На запуске он кладёт её в контекст целиком — вместе
+с картой хода, — и вставлять её руками не приходится ни после сжатия, ни после обрыва, ни после
+очистки. Написанная и не прочитанная, передача равна ненаписанной: следующий заход о ней не
+знает и начинает с пустого места, то есть с того же, ради чего её и писали.
+
+Отсюда требование к тексту: передача пишется для машины, которая подаст её без разбора, и для
+захода, который прочтёт её первой строкой. Обращаться в ней к владельцу — «спроси у него, чем
+кончилась проба» — значит писать в пустоту: к моменту чтения владельца в разговоре ещё нет.
+
+Написанное хуком — нижняя граница, а не готовая передача. Исполнитель, закрывающий заход по
+правилу, пишет поверх: он знает то, чего на диске нет, — чем кончилась проба, почему выбран
+этот путь, что владелец сказал по дороге. Файл один, последняя запись побеждает.
+
 Внутри — готовый текст для вставки в новый заход, без обращения к владельцу за подробностями:
 
 ```markdown

package/assets/patterns/task-flow-resume.md

@@ -120,6 +120,9 @@ git log --oneline origin/main..HEAD
 - Доэтапное, не этой работы: сверка очереди перечисляет шесть закрытых задач вне борды.
 ```
 
+**Следующее движение:** отмеченный этап тем же ходом сменяется следующим. Этапы кончились —
+тот же ход гонит набор и открывает PR черновиком.
+
 ## Состояние `работа-отдана`: следующая задача берётся тем же движением
 
 Задача закрыта, PR открыт и ждёт владельца — заход на этом не кончается. Отданное на разбор
@@ -138,6 +141,9 @@ git log --oneline origin/main..HEAD
 `task-flow-handoff`. Эпик кончился — заход закрывается тем же порядком, и владельцу называется,
 что кончился именно эпик, а не одна его задача.
 
+**Следующее движение:** по следующей задаче делается действие — заведена задача, ветка или
+папка. Ход кончается после него, а не после слов о нём.
+
 ## Ловушки
 
 - **Заход, кончившийся ничем, тоже записывается.** Иначе следующий пойдёт той же дорогой:

package/assets/patterns/task-flow-start.md

@@ -40,6 +40,9 @@ Agent(subagent_type: "Explore", prompt: "<тема просьбы>: что по
 считается сделанным, разведка исполняется как настроение: прочитанный переданный текст сходит
 за неё, и по текущему дереву не запускается ни одной команды.
 
+**Следующее движение:** находки ложатся в разбор, и тем же ходом владельцу уходит первый из
+шести вопросов. Разведка кончилась — состояние осталось прежним, ход тоже.
+
 ### Состояние `просьба-не-разобрана`: разбор с владельцем
 
 Ведёт главный агент: субагент до владельца не достучится. Команда — `/grill-me`, один вопрос
@@ -89,6 +92,9 @@ mkdir -p docs/tasks/_draft-<slug>
 cp docs/tasks/_template/grill.md docs/tasks/_draft-<slug>/grill.md
 ```
 
+**Следующее движение:** ответ владельца дописывается в разбор, и следом уходит следующий
+вопрос. Ответы кончились — тем же ходом работа идёт в конвейер ролей.
+
 ### Состояние `разбор-закрыт`: конвейер после разбора
 
 Вопросов больше не будет — дальше роли:
@@ -107,6 +113,9 @@ Workflow(name: "plan", args: "docs/tasks/_draft-<slug>")
 «не входит». Находка критика, расходящаяся с ответом владельца, относится владельцу — она не
 исполняется молча и не считается закрытой правкой текста.
 
+**Следующее движение:** сверенная с разбором договорённость коммитится, и тем же ходом
+заводятся задача, ветка и папка — а вышла из разбора серия, сперва объявляется эпик.
+
 ### Состояние `договорённость-записана`: серия задач объявляется эпиком
 
 Разбор кончился одной задачей — шаг пропускается. Вышло несколько, и порядок между ними
@@ -134,6 +143,9 @@ Workflow(name: "plan", args: "docs/tasks/_draft-<slug>")
 Лежит замысел вне папки задачи: та умирает с мержем первой же задачи. Каталог для него называет
 компаньон правила — у пакета своего пути нет.
 
+**Следующее движение:** объявленный эпик коммитится, и тем же ходом берётся первая его
+задача — заведением задачи, ветки и папки.
+
 ### Состояние `договорённость-записана`: задача, ветка, папка
 
 ```bash
@@ -171,6 +183,9 @@ cp docs/tasks/_template/progress.md docs/tasks/<КЛЮЧ>-<номер>-<slug>/pr
 Пока не объявлено состояние, в котором код правится, гард отбивает правку и называет
 обязательное действие того состояния, которое стоит в строке.
 
+**Следующее движение:** объявив состояние, тот же ход берётся за замысел — начиная с его
+шапки. Заведённая папка ходом не кончается: в ней ещё нет ни одного написанного файла.
+
 ### Состояние `задача-взята`: шапка замысла
 
 Её читает гард:
@@ -189,6 +204,32 @@ cp docs/tasks/_template/progress.md docs/tasks/<КЛЮЧ>-<номер>-<slug>/pr
 
 Пустая причина не принимается.
 
+**Следующее движение:** под шапкой пишутся след задачи и этапы, замысел коммитится, и тем же
+ходом начинается первый этап.
+
+### Состояние `замысел-записан`: первый этап начинается тем же ходом
+
+Замысел закоммичен — работа переходит в первый этап сразу, не отдавая хода. Строка состояния
+перезаписывается на `этап-идёт`, и дальше работу ведёт паттерн возвращения.
+
+```markdown
+- **Состояние:** `этап-идёт`
+- **Этап:** 1 из 3 — <название первого этапа из замысла>
+```
+
+Ход на этой границе не кончается. Написанный замысел выглядит законченным куском: этапы
+разложены, файл закоммичен, отчитаться есть чем — и отчёт встаёт ровно на то место, которое
+должна была занять работа. Владелец читает такой отчёт как сделанное, а сделано ничего. Так
+и вышло 21 августа: заход кончился строкой «следующий шаг — такой-то» при заполнении окна около
+двух процентов.
+
+Кончают ход четыре вещи, и они те же, что у остальных состояний: предел заполнения окна, отказ
+гарда, вопрос владельцу и отданная работа, по которой начата следующая. Дочитанный до конца
+паттерн к ним не относится — текст кончился, работа нет.
+
+**Следующее движение:** первый этап делается тем же ходом, а закрытым он объявляется после
+того, как прошла его команда из строки «Чем проверяется».
+
 ## Ловушки
 
 - **Номер не бывает первым.** До конца разбора неизвестно даже, сколько задач из него выйдет:

package/assets/patterns/turn-entry-map.md

@@ -0,0 +1,81 @@
+---
+name: turn-entry-map
+kind: pattern
+rule: turn-entry
+description: Паттерн правила turn-entry. Брать при правке карты хода и хука, который её подаёт, — что в карту входит, чем она отличается от правила, как хук молчит о недостающем и как это проверяется. Не брать для формы самой передачи — это паттерн task-flow-handoff.
+---
+
+# Карта хода и её подача — готовый код
+
+Паттерн правила `turn-entry`. Что при этом должно быть верно — закон
+`docs/constitution/work-conduct.md`.
+
+## Когда брать
+
+- В правило ведения работы добавили состояние — карта отстала.
+- Правится хук входа или порядок, в котором части входа кладутся в контекст.
+- Проверка карты покраснела.
+
+## Что входит в карту, а что нет
+
+Карта отвечает на вопрос «что делать», правило — на вопрос «почему». Признак отбора один: строка,
+которую заход прочитает и после которой сделает следующий шаг, — в карту; строка, которая
+объясняет, откуда требование взялось, — в правило.
+
+| В карту                                        | В правило                                          |
+| ---------------------------------------------- | -------------------------------------------------- |
+| имя состояния и его обязательное действие      | почему это действие обязательно                    |
+| паттерн, который состояние ведёт               | разбор происшествия, из которого оно выросло       |
+| четыре выхода хода и чем каждый подтверждается | что бывает, когда ход кончают иначе                |
+| строка о том, что остальное — продолжение хода | перечень того, чем ход кончать нельзя, с примерами |
+
+Разбор происшествия в карту не переезжает никогда: он объясняет, а объяснение — это правило.
+
+## Подача: сперва передача, потом карта
+
+Порядок не безразличен. Передача говорит, где именно стоит эта работа, карта — что делают в
+таком месте вообще. Прочитанная первой, карта отвечает на вопрос, которого заход ещё не задал.
+
+```bash
+# передача — по имени текущей ветки, не выбором из каталога
+handoff="$ROOT/${RT_HANDOFF_DIR:-.claude/handoff}/$(git branch --show-current).md"
+[ -r "$handoff" ] && { printf 'ПЕРЕДАЧА ПРОШЛОГО ЗАХОДА\n\n'; cat "$handoff"; }
+
+# карта — своим файлом, а не разбором правила
+[ -r "$map" ] && { printf 'КАРТА ХОДА\n\n'; cat "$map"; }
+
+exit 0
+```
+
+Три вещи в этом куске обязательны и легко теряются:
+
+- **`-r`, а не `-f`.** Файл может существовать и не читаться; `-f` тогда пропускает `cat`
+  дальше, и хук печатает заголовок над пустотой.
+- **`exit 0` в конце и никаких других выходов.** Хук входа ничего не отбивает: заход без части
+  контекста лучше, чем отбитый запуск.
+- **Имя файла собирается из ветки.** Выбор «первого попавшегося» в каталоге подаёт чужую
+  передачу, и выглядит она как своя.
+
+## Чем это проверяется
+
+```bash
+node tools/check-turn-map.mjs   # размер, полнота состояний в обе стороны, четыре выхода
+```
+
+Проверка сверяет имена состояний карты с таблицей правила в обе стороны: состояние, заведённое
+правилом и забытое в карте, и состояние, оставшееся в карте после переименования, — оба
+расхождения.
+
+Живая проба хука делается на дереве, где обе части лежат, и повторяется четырежды: обе части,
+без передачи, без карты, без обеих. Последний случай обязан дать пустой вывод и нулевой код —
+хук, промолчавший с ненулевым кодом, читается как отбитый запуск.
+
+## Ловушки
+
+- **Предел размера назначается замером, а не на глаз.** Первое число выбрали «вдвое больше
+  нынешней карты» — и проверка покраснела на собственном тексте в первом же прогоне: карта в
+  кириллице весит вдвое больше, чем кажется по числу строк.
+- **Выход за предел означает деление карты, а не подъём предела.** Поднятый однажды, он
+  поднимается и во второй раз, и карта тихо становится вторым экземпляром правила.
+- **Карта, разобранная из правила на месте, ломается молча.** Правку разметки таблицы не видит
+  ни одна проверка, а карта после неё приходит пустой — и заход об этом не узнает.