@rt-tools/agent-kit 0.9.1 → 0.11.0

package/assets/rules/task-flow.md

@@ -11,7 +11,7 @@ description: Правило под «Закон о ведении работы»
 про ход работы; здесь — чем это названо в этом дереве, где лежит и что из закона у нас не
 проверяется.
 
-**Требует:** `hooks/task-flow-guard.sh`, `hooks/task-context-load.sh`, `hooks/grill-gate.sh`, `hooks/window-fill-guard.sh`
+**Требует:** `hooks/task-flow-guard.sh`, `hooks/task-context-load.sh`, `hooks/grill-gate.sh`, `hooks/window-fill-guard.sh`, `hooks/turn-exit-guard.sh`
 
 ## Как это называется здесь
 
@@ -34,50 +34,71 @@ description: Правило под «Закон о ведении работы»
 переносится между репозиториями, раскладка — нет, и путь, названный в правиле, врёт в первом
 же дереве, которое держит код иначе.
 
-## Шаги работы
-
-Счёт сплошной: номер шага один на весь путь и не начинается заново в каждом паттерне. Шаг
-называют номером вслух, и два разных первых шага мешают разговору; а пропущенный шаг виден
-только по списку, из которого он выпал.
-
-| Шаг | Что происходит                                           | Ведёт паттерн       |
-| --- | -------------------------------------------------------- | ------------------- |
-| 1   | Разведка по дереву — до первого вопроса владельцу        | `task-flow-start`   |
-| 2   | Разбор просьбы с владельцем, шесть обязательных вопросов | `task-flow-start`   |
-| 3   | Конвейер ролей после разбора                             | `task-flow-start`   |
-| 4   | Серия задач объявляется эпиком — карточкой и замыслом    | `task-flow-start`   |
-| 5   | Задача, ветка, папка задачи                              | `task-flow-start`   |
-| 6   | Шапка замысла и сам замысел                              | `task-flow-start`   |
-| 7   | Возвращение к работе новым заходом                       | `task-flow-resume`  |
-| 8   | Этап замысла делается и отмечается в ходе работы         | `task-flow-resume`  |
-| 9   | Заход закрывается передачей                              | `task-flow-handoff` |
-| 10  | Работа отдаётся на разбор: PR открыт, ожидание названо   | `task-flow-close`   |
-| 11  | Следующая задача эпика берётся тем же движением          | `task-flow-resume`  |
-| 12  | Договорённость вливается в спек домена                   | `task-flow-close`   |
-| 13  | Тексты домена приводятся к сделанному                    | `task-flow-close`   |
-| 14  | Папка задачи разбирается                                 | `task-flow-close`   |
-| 15  | Сверка очереди работ                                     | `task-flow-close`   |
-| 16  | Работа разбирается правилами — фоном, следом за PR       | `task-flow-close`   |
-| 17  | Находки разбора принимаются одним ходом и ждут владельца | `task-flow-close`   |
-
-Шаги 7–9 повторяются, пока этапы замысла не кончатся: первый заход входит в работу шагом 1 и
-доходит до 8, дальше каждый следующий начинается шагом 7. Шаг 4 идёт только у работы, из которой
-видно серию задач. Шаги 10–17 идут один раз, когда работа кончена.
-
-Порядок в таблице — тот, в каком шаги случаются, а не тот, в каком о них удобно рассказывать.
-Следующая задача берётся раньше уборки за предыдущей: работа, отданная на разбор, ждёт владельца,
-и заход этим ожиданием не занимают. Список, в котором уборка стоит раньше, читается как
-разрешение сидеть над зелёным PR до ответа.
-
-Три шага идут не в очередь, а рядом с работой: прогон конвейера, разбор владельцем и разбор
-закрытой работы правилами. Ни один из них не спрашивает исполнителя, пока идёт, и ни один не
-ускоряется от того, что его ждут, — поэтому шаг 11 случается раньше, чем кончатся 10 и 16, а
-шаг 17 вклинивается в работу следующей задачи ровно на один ход. Порядок номеров говорит, что
-за чем следует, а не что чего дожидается.
-
-Список показывается владельцу в начале работы, и на нём же отмечается, где стоим: иначе после
+## Состояния работы
+
+Единица работы — состояние, а не шаг. У состояния есть вход, обязательное действие и выход, и
+пока действие не сделано, работа стоит в том же состоянии. Список шагов этого не давал: шаг
+кончался, а что делать дальше, выводилось из соседних строк.
+
+Состояние объявляется машиночитаемой строкой в разделе «Где стоим» хода работы и
+перезаписывается вместе с ним:
+
+```markdown
+- **Состояние:** `этап-идёт`
+```
+
+| Состояние                 | Вход в него                                     | Обязательное действие                                  | Ведёт паттерн      |
+| ------------------------- | ----------------------------------------------- | ------------------------------------------------------ | ------------------ |
+| `просьба-не-разобрана`    | реплика владельца о новой работе                | разведка по дереву, затем вопросы                      | `task-flow-start`  |
+| `разбор-закрыт`           | ответы владельца лежат на диске                 | договорённость о продукте либо причина её отсутствия   | `task-flow-start`  |
+| `договорённость-записана` | драфт лежит или причина названа                 | завести задачу, ветку и папку                          | `task-flow-start`  |
+| `задача-взята`            | задача в колонке работы, ветка по номеру, папка | написать замысел                                       | `task-flow-start`  |
+| `замысел-записан`         | замысел лежит и после записи не правится        | делать первый этап                                     | `task-flow-start`  |
+| `этап-идёт`               | этап начат                                      | доделать этап и отметить в ходе работы                 | `task-flow-resume` |
+| `этапы-кончились`         | все этапы отмечены                              | прогнать набор и открыть PR черновиком                 | `task-flow-close`  |
+| `работа-отдана`           | PR открыт черновиком                            | взять следующую задачу                                 | `task-flow-resume` |
+| `разбор-кончился`         | прогон зелёный, замечаний нет                   | влить договорённость, привести тексты, разобрать папку | `task-flow-close`  |
+| `папка-разобрана`         | папки в ветке нет, запись в архиве есть         | снять черновик и попросить влить                       | `task-flow-close`  |
+| `влито`                   | PR слит человеком                               | разбор работы правилами и сверка очереди               | `task-flow-close`  |
+
+Ни у одного состояния обязательное действие не звучит как «ждать»: ожидание чужого шага
+состоянием работы не является. Прогон, разбор владельцем и слияние идут без исполнителя, и от
+взгляда быстрее не становятся — поэтому в `работа-отдана` обязательное действие смотрит на
+следующую задачу, а не на открытый PR.
+
+Заполнение окна захода состоянием работы тоже не бывает: заход кончается передачей, работа
+остаётся в том состоянии, в каком стояла, а следующий заход читает строку и продолжает с неё.
+Ведёт закрытие захода паттерн `task-flow-handoff`.
+
+Перечень показывается владельцу в начале работы, и на нём же отмечается, где стоим: иначе после
 шести вопросов не видно ни того, что будет дальше, ни сколько всего впереди.
 
+## Выходы хода
+
+Ход кончается четырьмя способами, и других нет:
+
+| Выход                                              | Чем подтверждается                                              |
+| -------------------------------------------------- | --------------------------------------------------------------- |
+| вопрос владельцу, ответа на который в правилах нет | вопрос задан, и за тот же ход правила читались                  |
+| отказ гарда                                        | отказ назван владельцу, обход не искался                        |
+| заполненное окно там, где сжатия нет               | ход работы дописан, передача написана                           |
+| работа отдана, и следующая начата                  | PR открыт, и по следующей задаче сделано действие, а не сказано |
+
+Всё остальное — продолжение хода, а не его конец. Веха ходом не кончается: ни коммит, ни
+прочитанная договорённость, ни граница «прочитал — сейчас правлю», ни зелёная проверка. Слова
+«иду дальше» и «работаю дальше» владелец читает как совершающееся действие, и писать их вместо
+результата нельзя.
+
+Переход из состояния в состояние ходом не кончается тем более: обязательное
+действие сделано, и следующее делается тем же ходом. Граница состояния выглядит законченным
+куском лучше всякой другой вехи — сделанное названо, отчитаться есть чем, — и отчёт встаёт
+ровно туда, где должно было стоять следующее действие. Что делается сразу за обязательным
+действием, называет сам раздел состояния строкой следующего движения.
+
+Три способа кончить ход выглядят работой и ею не являются: сводка о чужом шаге, меню при
+назначенном порядке и объявление намерения. Что при этом должно быть верно — ниже, в статьях
+о применении закона.
+
 ## Ход
 
 Ход работы от просьбы владельца до закрытия: где стоит разбор, что требует гард и куда девается
@@ -113,8 +134,21 @@ flowchart TD
 
 ## Как закон применяется здесь
 
-- **Правка кода приложения отбивается, пока на диске нет замысла.** Гард требует папку задачи
-  по имени ветки, `plan.md` в ней и названную в его шапке договорённость о продукте.
+- **Правка кода приложения отбивается, пока работа не дошла до состояния, в котором код
+  правится.** Гард требует четыре вещи: папку задачи по имени ветки, замысел в ней, объявленное
+  в ходе работы состояние и названную в замысле договорённость о продукте.
+- **Гард судит объявленный переход, а не наличие файлов.** Артефакт на диске не говорит, дошла
+  ли работа до правки кода: пустой замысел, положенный ради снятия отказа, лежит так же, как
+  написанный. Отказ снимает объявленное состояние, и снимают его четыре — `этап-идёт`,
+  `этапы-кончились`, `работа-отдана` и `разбор-кончился`: прогон бывает красным, а разбор — с
+  замечаниями, и починка идёт в ту же ветку.
+- **Отказ по состоянию называет обязательное действие того состояния, которое объявлено.**
+  Исполнитель, которому сказано только «не в том состоянии», перепишет строку состояния вместо
+  того, чтобы сделать шаг.
+- **Именем состояния считается только слово из перечня.** Своё слово не говорит ни о входе, ни
+  о выходе, ни об обязательном действии, а перечень называет все три.
+- **Состояние судится раньше договорённости и её обхода.** Строка о неизменном поведении
+  снимает требование договорённости о продукте, а не требование дойти до правки кода.
 - **Влитая договорённость ветку не запирает.** После вливания директории «предложено» на диске
   нет, а замысел на неё ссылается до конца работы: гард отличает влитое от незаведённого по
   истории ветки и пропускает первое. Иначе последний коммит PR закрывал бы дорогу правкам
@@ -143,29 +177,50 @@ flowchart TD
   Открытый PR при этом читается как приглашение влить — поэтому незаконченная работа идёт
   черновиком, и владельцу не приходится спрашивать, кончилась ли она. Черновик снимается тем
   ходом, которым исполнитель говорит, что решение готово.
-- **Открытый PR остановкой не является.** Отданное на разбор ждёт владельца, а не исполнителя:
-  следующая задача берётся тем же движением, которым предыдущая ушла на разбор. Заход,
-  закрытый на готовой задаче, стоил владельцу целого захода на то, чтобы вернуть работу в
-  движение, — при том что порядок был назначен и лежал записанным в замысле эпика.
-- **Владельцу не предлагается выбор, чем заняться дальше, пока эпик не кончился.** Меню при
-  назначенном порядке — это просьба назначить его заново. Если работы в эпике не осталось, так
-  и говорится: эпик кончился, — а не «чем займёмся».
 - **Гард замысла — нижняя граница требования, а не его предел.** Он требует папку только под
   правку кода приложения, и работа, которая туда не доходит, проходит мимо него — но папку
   заводит всё равно: статья правила говорит «под любую работу, без исключений». Прочитанный
   как признак, гард становится разрешением работать без замысла везде, куда он не смотрит.
-- **Ход, сообщающий владельцу о чужом шаге, называет своё следующее действие и начинает его.**
-  Прогон, разбор владельцем и слияние идут без исполнителя и быстрее от взгляда не становятся,
-  поэтому сообщение о них — не работа, а сводка. Ход, кончившийся такой сводкой, владелец
-  читает как работу: она полна, в ней названы номера и состояния, и пустоты за ней не видно.
-  Открытый PR, красный прогон и ожидание слова владельца — случаи одного и того же, и правило
-  у них одно: о чужом шаге говорят вместе с начатым своим, а не вместо него. За один заход это
-  было нарушено четырежды, и готовая работа простояла в невлитом PR почти три часа, пока
-  исполнитель отвечал владельцу сводками о её состоянии.
-- **Пока PR ждёт разбора, исполнитель берёт следующую задачу.** Ожидание чужого шага заходом
-  не занимают: работа уходит на разбор, и тем же движением берётся следующая. Готовым к
-  слиянию прежний PR становится не сам — его доводит до готовности исполнитель, вернувшись к
-  нему тем же ходом, которым прочитал конец прогона.
+- **Сводка о чужом шаге.** Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда
+  быстрее не становятся. Ход, кончившийся такой сводкой, владелец читает как работу: она полна,
+  в ней названы номера и состояния, и пустоты за ней не видно. О чужом шаге говорят вместе с
+  начатым своим, а не вместо него. За один заход это было нарушено четырежды, и готовая работа
+  простояла в невлитом PR почти три часа.
+- **Меню при назначенном порядке.** Выбор, предложенный владельцу, пока эпик не кончился, — это
+  просьба назначить порядок заново. Работы в эпике не осталось — так и говорится: эпик
+  кончился, — а не «чем займёмся».
+- **Объявление намерения.** «Беру следующую задачу» — не то же самое, что взять её: фраза живёт
+  до конца хода, а работа не двигается. Названо может быть только сделанное: номер заведённой
+  задачи, имя заведённой ветки, переведённая колонка.
+
+- **Прерывание работы владельцем называется вслух.** Пришло задание, останавливающее начатое, —
+  исполнитель говорит, что стоит, на чём остановлено и что будет с прежней работой, и только
+  потом берётся за новое. Молчание об этом владелец читает как «прежнее кончилось».
+- **Остановка называется отдельной репликой.** Не строкой в конце отчёта: там она тонет —
+  владелец читает отчёт как рассказ о сделанном. Называются три вещи: что стоит, чего оно ждёт
+  и что владелец может решить.
+- **Выходы хода стережёт страж, а не память исполнителя.** Он читает объявленное состояние
+  работы и то, что за ход по ней сделано: правку файла или команду, меняющую дерево. Ход, в
+  котором не было ни того ни другого, возвращается исполнителю вместе со следующим шагом из
+  хода работы. Отданную и влитую работу страж не судит: она уже дождалась чужого шага.
+- **Этап замысла объявляется закрытым только после того, как его команда проверки прошла.**
+  Строка «Чем проверяется» несёт команду обратными кавычками и то, что в её выводе означает
+  «сошлось». Страж читает прежний номер этапа из истории ветки и не выпускает ход, в котором
+  номер вырос, а команда не запускалась: через заход отмеченное по памяти неотличимо от
+  проверенного.
+- **Слово об остановке страж читает у владельца, а не у исполнителя.** Иначе остановку
+  объявляет тот, кому она в эту минуту удобна, и запрет держится ровно до первого неудобства.
+- **Утверждение о состоянии дерева стережёт гард утверждения, а не память исполнителя.** Всё,
+  что ответ владельцу говорит о дереве, несёт команду и её вывод: сказанное без команды
+  утверждением не считается — ни «проверено», ни «снято», ни «готово». Гард читает текст,
+  сказанный владельцу за ход, и ищет команду того же хода; у каждого слова назван свой род
+  команды, потому что общий признак «команда была» подтверждал бы одно другим. Прошлый ход не
+  годится: состояние дерева меняется, и вчерашний вывод о нынешнем молчит. Восемь разборов
+  подряд пришлись на этот промах, и каждый раз в правило дописывалась ещё одна статья —
+  держит его теперь машина.
+- **Слово-утверждение гард ловит, неверный вывод — нет.** Об образце, судимом по одному его
+  файлу, и о пути, которым человек не пойдёт, судить нечем: там нет ни слова, ни команды, с
+  которой сверять. Это известная граница гарда, и держат её статьи ниже, а не он.
 - **Ход о чужом шаге стережёт гард ожидания, а не память исполнителя.** Он отбивает завершение
   хода, в котором о чужом шаге сказано, а по следующей задаче не сделано ни одного действия —
   ни заведения задачи, ни ветки, ни папки, ни перевода колонки. Чужой шаг он узнаёт по двум
@@ -207,15 +262,26 @@ flowchart TD
   случился, и ловить раньше нечего. Признание ловится набором образцов, а не пониманием смысла;
   промах, признанный словами вне набора, гард пропускает, и это его известная граница, а не
   обещание.
+- **Заход, начатый с передачи, входит в работу тем же правилом, что и всякий другой.** Передача
+  лежит вне дерева, её не читает ни одна проверка, и написана она вчера: всё, что в ней стоит,
+  проверяется деревом. Порядок входа — четыре шага в паттерне возвращения; стережёт его гард, а
+  не память: порядок, записанный только словами, исполняется, пока о нём помнят.
 - **Состояние незаконченной работы приходит в контекст на запуске сессии.** Замысел и ход
   работы отдаются целиком, разбор просьбы — путём. Ветка вида `<КЛЮЧ>-*` без папки даёт
   предупреждение с готовой командой, но сессию не рвёт.
 - **Сделанное отмечается только в ходе работы.** «Где стоим» перезаписывается каждым заходом,
   а не дописывается: это первое, что читает следующий заход.
+- **Заполненное окно кончает ход только там, где сжатия нет.** Где оно объявлено, окно —
+  продолжение хода: заход сжимается и работает дальше, а порог остановки срабатывает лишь тогда,
+  когда сжатие не пришло.
 - **Заполнение окна захода стережёт гард, а не память исполнителя.** На первом пороге он
   напоминает выбирать точку остановки, на втором отбивает всё, кроме записи хода работы,
   передачи и команд поставки. Размер окна и оба порога дерево задаёт само; не задавшее размера
   стража не получает.
+- **Порог сжатия контекста дерево задаёт само, и стоит он НИЖЕ порога остановки.** Совпавшие
+  пороги согласием не бывают: это гонка, и выигрывает её страж — он стоит на вызове, а сжатие
+  приходит между ходами. Расстояние объявляется числом, а не выводится разницей; сведены пороги
+  или нет, говорит разбор состояния раскладки.
 - **Заход закрывается передачей, которая лежит вне дерева.** Состояние работы коммитится ходом
   работы, а передача его пересказывает для вставки в новый заход: рабочее дерево, ветка,
   сделанное, следующий шаг и особенности захода. В историю она не едет — иначе рядом с ходом
@@ -256,13 +322,6 @@ flowchart TD
   это заготовка правки чужого дерева, и часть заготовок отпадает при первом же чтении; уехавшая
   без разбора, она становится работой того, кто её не заказывал. Сводка наблюдений уезжает
   всегда: она говорит, чем пользовались и чем нет, и мнением не является.
-- **Ожидание прогона работой не занимают.** Прогон идёт на стороне и быстрее от взгляда на него
-  не становится. Пока он идёт, берётся следующая задача, а к прогону возвращаются тем ходом,
-  которым читают его конец. Это верно и для разбора владельцем: оба ожидания — не повод стоять.
-- **Остановка, если она всё-таки случилась, называется владельцу отдельной репликой.** Не
-  строкой в конце отчёта: там она тонет — владелец читает отчёт как рассказ о сделанном.
-  Называются три вещи: что стоит, чего оно ждёт и что владелец может решить — разобрать работу
-  первой или сказать, что прогона можно не ждать. Всё остальное идёт после.
 - **Договорённость вливается в спек домена последним коммитом PR.** К этому моменту код
   написан, привязки известны, и в главной ветке директория `proposed/` не появляется вовсе.
   Готовые к вливанию перечисляет `npm run check:specs`.
@@ -357,6 +416,12 @@ flowchart TD
   задаче так ушли две правки подряд: сначала подняли общее число у соседнего узла, потом
   перенесли узел в другое место разметки. Обе владелец отверг, а нужный способ назвал сам.
   Спрашивают до правки, а не показывают замер после.
+- **Путь, предложенный человеку, судится числом его шагов и тем, чем ему для этого надо
+  владеть.** Со стороны кода вариант выглядит дешёвым — «меньше путей», «строку запуска не
+  трогаем», — а человеку он стоит захода на сервер. Однажды рекомендуемым вариантом так стояла
+  выдача токена, за которой владельцу надо было идти по ssh в работающий контейнер; отбивал
+  этот вариант он сам. Цена называется со стороны того, кто пойдёт: сколько шагов и что ему для
+  них нужно. Пересказ действующего порядка без такой оценки владелец читает как одобрение.
 - **Эпик по теме читается до того, как решается раскладка.** Замысел эпика держит решения,
   которые пережили десяток задач, и разведка по коду их не находит: снятое решение следа в
   дереве не оставляет. Домен, заведённый генератором и снесённый через полчаса, стоял в замысле

package/assets/rules/testing.md

@@ -113,6 +113,20 @@ flowchart TD
   принятое остаётся навсегда, долг накоплен к заведению проверки и только сокращается, — либо
   столько ключей, сколько у записей родов. Причина обязательна: снятая проверка без причины
   через месяц неотличима от недосмотра.
+- **Запись принятого отличается от долга тем, заведена ли на неё работа.** Принятое — то, что
+  дерево делить не собирается; долг — то, на что заведена задача, и он только сокращается. Один
+  список на оба означал бы, что разбирать нечего: запись без задачи через месяц читается как
+  вечная, а запись с задачей — как недосмотр.
+- **У каждой записи стоят своя причина и номер задачи, которой она внесена.** Причина прозой на
+  весь список объясняет любую его строку и потому не объясняет ни одной, а запись без номера не
+  спросишь ни у кого: тот, кто её внёс, к этому дню не помнит ни повода, ни своего решения.
+  Запись без причины или без номера отбивает проверку — и заводится она словом владельца, а не
+  решением исполнителя, которому она в эту минуту мешает.
+- **У красного есть назначенное действие, и второй перезапуск в него не входит.** Красное бывает
+  двух родов, и в списке прогонов они выглядят одинаково: отказ хостинга на шаге подготовки
+  лечится перезапуском, дефект ветки — не лечится им вовсе. Назначенное действие одно: сперва
+  журнал этого задания, потом решение. Перезапуск, повторённый до чтения журнала, чинит не
+  причину, а её проявление, и в истории выглядит работой.
 - **Строка в список известного не заводится под красную проверку.** Список набран к дню
   заведения проверки и с тех пор только сокращается: дописанная строка гасит сигнал, а не
   причину, и в истории выглядит так же, как починка. Место, где проверка права по букве и не
@@ -187,7 +201,7 @@ flowchart TD
   чего в спеке домена нет и быть не должно: `qa-dataid` элементов, состояния разметки, ловушки
   стенда. Обещанное поведение остаётся сценарием в `scenarios.md`: если списать его во второе
   место, копии разойдутся молча — `npm run check:specs` этого не увидит.
-- `npx nx serve` проверкой не является: это шаг из правила `browser-verification`, а не тест.
+- `npx nx serve` проверкой не считается: это шаг из правила `browser-verification`, а не тест.
 - **Кадр, зависящий от загрузки машины, проверяет машину, а не вёрстку.** Ожидание отсчётом
   времени этим и кончается: на свободной машине набор зелен целиком, на занятой падает, и какой
   именно кадр не успел — дело случая. Лечится ожиданием события, а не удлинением отсчёта: шрифты

package/assets/rules/turn-entry.md

@@ -0,0 +1,93 @@
+---
+name: turn-entry
+kind: rule
+law: work-conduct
+description: Правило под «Закон о ведении работы». Брать при правке хука входа в заход, текста карты хода и проверки над ней, а также когда решается, что заход получает в контекст до первой реплики. Называет передачу прошлого захода, карту хода, четыре запуска и отказ в пользу работы. Не брать для самого хода работы — это правило task-flow.
+---
+
+# Вход в заход — как это устроено здесь
+
+Правило под закон `docs/constitution/work-conduct.md`. Закон говорит, что переданное прошлым
+заходом приходит в новый заход само и что порядок ведения работы приходит вместе с работой;
+здесь — чем это сделано в этом дереве. Сам ход работы — правило `task-flow` под тем же законом:
+там про состояния и их обязательные действия, здесь — про то, как они попадают в заход.
+
+## Как это называется здесь
+
+| В законе                   | Здесь                                                                         |
+| -------------------------- | ----------------------------------------------------------------------------- |
+| вход в заход               | то, что хук старта кладёт в контекст до первой реплики                        |
+| переданное прошлым заходом | файл по имени ветки в каталоге передач; пишет его хук перед сжатием контекста |
+| порядок ведения работы     | карта хода — состояния с обязательными действиями и четыре выхода хода        |
+| запуск                     | первый запуск, возобновление, сжатие контекста, очистка                       |
+
+## Где это лежит
+
+В этом дереве — таблица в `implementation.md` рядом. Пути живут там, а не здесь: правило
+переносится между репозиториями, раскладка — нет.
+
+## Ход
+
+Ход подачи: что кладётся в контекст, в каком порядке и что делается с недостающим.
+
+```mermaid
+flowchart TD
+    A[Запуск захода] --> B{Есть передача по имени текущей ветки}
+    B -->|Да| C[Передача кладётся в контекст целиком]
+    B -->|Нет| D[О передаче не говорится ничего]
+    C --> E{Разложен ресурс карты хода}
+    D --> E
+    E -->|Да| F[Карта кладётся следом: состояния, действия, четыре выхода]
+    E -->|Нет| G[О карте не говорится ничего]
+    F --> H[Хук выходит нулём: запуск не отбивается ни при каком исходе]
+    G --> H
+```
+
+## Как закон применяется здесь
+
+- **Передача прошлого захода приходит в контекст тем же запуском, что и состояние работы.**
+  Написанная и не прочитанная, она равна ненаписанной: следующий заход о ней не знает и
+  начинает с пустого места — с того самого, ради чего её и писали.
+- **Передача берётся по имени текущей ветки.** Передач в каталоге столько, сколько было веток;
+  чужая, поданная как своя, описывает работу, которой в этом дереве нет.
+- **Передачи нет — вход об этом молчит.** Ветка, по которой заход ещё не закрывался, это
+  обычное начало работы, а не поломка: отказ на ней превращал бы каждый первый заход в разбор
+  хука.
+- **Карта хода приходит тем же запуском и лежит своим файлом, а не вынимается из правила.**
+  Разобранная на месте из таблицы правила, она ломается молча при первой правке разметки;
+  зашитая в хук — расходится с правилом без единой правки.
+- **Карта короче правила, и предел ей назначает проверка дерева.** Этим она и полезна:
+  выросшая до правила, она съедает то самое окно, ради которого её кладут в контекст, — и
+  заметить это нечем, потому что она продолжает приходить и продолжает быть верной.
+- **Состояние, объявленное правилом и забытое в карте, — расхождение.** Заход получает карту,
+  не находит в ней своего состояния и идёт читать правило: карта работает ровно до первого
+  нового состояния.
+- **Вход подаётся на всех четырёх запусках, а не только после сжатия.** Заход после обрыва и
+  заход после очистки начинают с того же пустого места, и разница между ними исполнителю не
+  видна вовсе.
+- **Хук входа запуск не отбивает.** Отказ любой его части — нечитаемый файл, отсутствующий
+  ресурс, чужие права — оставляет заход без части входа, но не без захода.
+
+## Чего из закона здесь нет
+
+Полноту самой передачи не проверяет ничто: хук подаёт то, что лежит, и о том, дописал ли
+исполнитель к черновику своё, судить машине нечем. Держится это паттерном закрытия захода.
+
+Не проверяется и то, прочитал ли заход поданное. Вход кладётся в контекст, а что с ним делают
+дальше — свойство хода, а не файла.
+
+## Паттерны
+
+- `turn-entry-map` — что входит в карту, порядок подачи и живая проба хука.
+- `task-flow-handoff` — закрытие захода: точка остановки и форма передачи; паттерн соседнего
+  правила, но читается в паре с этим.
+
+## Ловушки
+
+- **Хук, подающий пустоту, неотличим от работающего.** Вход, у которого нет ни передачи, ни
+  карты, печатает ноль байт и возвращает ноль — ровно так же выглядит хук, который не запустился
+  вовсе. Проверяется это не глазами по контексту, а вызовом хука руками на дереве, где обе части
+  лежат.
+- **Передача пишется для машины, а не для владельца.** Обращение в ней — «спроси у него, чем
+  кончилась проба» — уходит в пустоту: к минуте, когда передачу читают, владельца в разговоре
+  ещё нет.

package/assets/samples/tasks/_template/plan.md

@@ -32,7 +32,10 @@
 
 - **Что делается:** <одной фразой>
 - **Признак готовности:** <что должно стать верным>
-- **Чем проверяется:** <команда или приём>
+- **Чем проверяется:** `<команда>` — <что в её выводе означает «сошлось»>
+
+Команда пишется обратными кавычками: страж выходов хода читает её и не выпускает ход, в котором
+этап объявлен закрытым, а команда не запускалась. Приём, записанный прозой, подтвердить нечем.
 
 ## Чего эта работа не делает
 

package/assets/samples/tasks/_template/progress.md

@@ -4,6 +4,7 @@
 
 Перезаписывается каждым заходом, а не дописывается.
 
+- **Состояние:** `<имя из перечня состояний правила task-flow>`
 - **Этап:** <номер> из <всего> — <название>
 - **Сделано:** <коротко>
 - **Следующий шаг:** <что делается первым в новом заходе>

package/assets/skills/agent-kit.md

@@ -27,6 +27,7 @@ description: Переносимый слой правил агента — за
 | какие признаки единообразия дерево берёт       | `checks.json`, ключи `reuse.bundles` и `reuse.signals` |
 | раздел разложенного текста                     | `.claude/rt-kit/overrides/<идентификатор ресурса>`     |
 | что брать, а от чего отказаться                | `.claude/rt-kit.json`, ключи `only` и `skip`           |
+| какие роли зовутся не обязательно, а руками    | `.claude/rt-kit.json`, ключ `rolesOff`                 |
 | что у дерева есть: хранилище, админка, пакеты  | `.claude/rt-kit.json`, ключ `has`                      |
 | сам механизм — гард, проверка, текст правила   | ресурс в пакете                                        |
 
@@ -156,8 +157,40 @@ npx agent-kit propose       # отправить груз в приём: сво
 - **Свойство, которого пакет не объявлял, роняет раскладку** — что в `has` дерева, что в имени
   ресурса. Объявлены свойства перечнем при пакете, рядом с осями различия.
 
+## Выключенная роль
+
+Роль, при которой стоит гард, зовётся не по усмотрению исполнителя: гард держит работу, пока
+роль не сказала своё. Дерево, которому такая роль в эту минуту мешает, называет её ключом
+`rolesOff` — именем файла роли без расширения.
+
+```json
+{ "rolesOff": ["strict-teacher"] }
+```
+
+- **Выключается обязательность вызова, а не роль.** Файл роли остаётся разложенным, и позвать её
+  руками можно в любую минуту. Список читают сами гарды — помощником, который лежит с ними
+  рядом; собственного объявления события у него нет, к действиям агента он не подключается.
+- **От отказа ключом `skip` это отличается тем, что ничего не убирает.** Отказ не кладёт файл
+  роли вовсе: звать становится некого, а гард при ней остаётся лежать и продолжает отбивать.
+  Здесь наоборот — роль на месте, молчит гард.
+- **Настройка, которую не прочитать, роль не выключает.** Не нашлось `jq`, нет настройки, в
+  настройке сломан разбор — гард судит, как судил. Обратный выбор гасил бы слой правил молча, и
+  заметить это было бы нечем.
+- **Ключ, написанный не списком, ловит раскладка, а не гард.** Гарду виден только список имён:
+  строка вместо списка читается им как «роль включена», и роль работает, хотя дерево считает её
+  выключенной. Отказывает на этом разбор настройки — первой же раскладкой, называя ключ.
+- **Выключение живёт в настройке дерева, а не в настройке агента.** Строка, вырезанная из
+  настроек агента руками, теряется на первой же правке того файла, и вернуть роль будет нечем.
+  Здесь оно объявлено в одном месте и видно всякому, кто читает настройку дерева.
+
 ## Ловушки
 
+- **Набор, проверяющий гард, читает настройку того дерева, из которого его запустили.** Помощник
+  берёт настройку по каталогу проекта, а его агент выставляет своим — и `cd` в прогонщике этого
+  не перебивает. Набор, не заведший своего одноразового дерева, зеленеет от строки в чужой
+  настройке: шесть сценариев гарда экзамена прошли ровно так, потому что роль была выключена в
+  дереве, где их гоняли. Своё дерево объявляется на каждый сценарий, а не один раз на файл.
+
 - **Надстройка замещает раздел целиком, и пакетные пункты в нём приходится держать копией.**
   Дописать в раздел одну статью нечем: слияние идёт по заголовку `## `. Дерево, которому нужен
   один свой пункт, копирует к нему все пакетные — и с этого дня правка любого из них,

package/assets/templates/project.sh

@@ -19,10 +19,26 @@ RT_PROD_DSN='<хост боевого хранилища>'
 # Пути, у которых якорь для сквозных тестов не требуется.
 RT_QA_SKIP_RE='<выражение путей>'
 
+# Имя клиента хостинга в строке запуска: по нему гард перезапуска узнаёт вызов перезапуска
+# задания. Умолчание пакета — под самый распространённый вид хостинга.
+RT_HOST_CLI='<имя клиента хостинга>'
+
 # Команды, которые обязаны пройти перед пушем. По одной на строку; первая упавшая отбивает пуш.
+#
+# Тяжёлый шаг — стенд, снимки витрин, сборка образов — печатается только тогда, когда ветка
+# тронула не только тексты: иначе пуш коммита с одной правленой строкой markdown занимает
+# минуты, и владелец читает его как зависший. Признак даёт `rt_push_docs_only <база>`; при
+# пустой базе он молчит, и гоняется весь набор — той же пустой базой зовёт эту функцию сверка
+# полноты набора, и список она обязана видеть целиком.
 rt_push_checks() {
     rt_push_checks_default
     # printf '%s\n' '<своя проверка>'
+
+    # Тяжёлые шаги — по составу правки, а не подряд.
+    # if [ -n "$1" ] && rt_push_docs_only "$1"; then
+    #     return 0
+    # fi
+    # printf '%s\n' '<шаг, поднимающий стенд или собирающий образ>'
 }
 
 # Какой документ обязан ехать тем же коммитом, что и этот файл. Печатает образец пути или молчит.

package/bin/agent-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-kit.d.ts","sourceRoot":"","sources":["../../../projects/agent-kit/src/bin/agent-kit.ts"],"names":[],"mappings":";AAeA,OAAO,EAAqC,iBAAiB,EAAqB,MAAM,oBAAoB,CAAC;AA8S7G,wBAAsB,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAU9E"}
+{"version":3,"file":"agent-kit.d.ts","sourceRoot":"","sources":["../../../projects/agent-kit/src/bin/agent-kit.ts"],"names":[],"mappings":";AAeA,OAAO,EAAqC,iBAAiB,EAAqB,MAAM,oBAAoB,CAAC;AA4V7G,wBAAsB,IAAI,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAU9E"}