@rt-tools/agent-kit 0.14.0 → 0.15.0

package/assets/docs/GLOSSARY.md

@@ -13,70 +13,64 @@
 
 ## Слой правил
 
-| Термин                    | Что это                                                                                                                                                          |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Закон                     | Файл в каталоге конституции. Говорит, что должно быть верно, и не знает ни путей, ни имён файлов. Верен для любого приложения этого класса                       |
-| Законы приложения         | Слой законов, верных только для этого приложения: деньги, локали, доступ. Предметность в них законна — она их предмет                                            |
-| Правило                   | Скил с `kind: rule`. Привязывает закон к этому дереву: чем это здесь названо и где лежит                                                                         |
-| Паттерн                   | Скил с `kind: pattern`. Готовый код и порядок действий; стоит при правиле                                                                                        |
-| Компаньон                 | Файл `implementation.md` рядом с правилом: имена и пути этого дерева. Пакет знает приём, но не знает имён — их пишет проект                                      |
-| Спек                      | Описание домена: как он работает. Говорит об установившемся, а не о предстоящем                                                                                  |
-| Домен                     | Предмет, у которого свой спек. Выросший домен делится на поддомены, а не на соседние домены                                                                      |
-| Сценарий                  | Наблюдаемое поведение под номером `SC-<ПРЕФИКС>-<НОМЕР>`. Номер стоит в заголовке теста                                                                          |
-| Привязка                  | Строка `` `файл:символ` `` в компаньоне или в спутнике спека — место, где утверждение исполняется                                                                |
-| Спутник                   | Файл рядом со спеком или правилом: компаньон, перечень сценариев                                                                                                 |
-| Договорённость о продукте | Как продукт себя поведёт, записанное до кода. Единственное место, где спек говорит о будущем; после выкатки вливается в спек домена, а директория удаляется      |
-| Ресурс                    | Единица того, что везёт пакет правил: закон, правило, паттерн, гард, проверка, роль, команда, конвейер, шаблон, умолчание, документ                              |
-| Раскладка                 | Перенос ресурса из пакета в дерево по его роду и настройке слоя                                                                                                  |
-| Разложенный файл          | Файл в дереве с шапкой пакета. Правится не на месте, а надстройкой: правка на месте теряется на следующей раскладке                                              |
-| Надстройка                | Файл дерева, который сливается с разложенным по заголовкам разделов                                                                                              |
-| Выключенная роль          | Роль, вызов которой дерево перестало считать обязательным: гард при ней молчит. Названа списком в настройке дерева, из раскладки не убирается и зовётся руками   |
-| Наблюдение                | Строка о событии слоя правил: правило загружено, гейт отбил, гард отказал. Пишет гард, живёт в дереве, наружу уезжает счётчиками. Журналом не называется         |
-| Сводка                    | Что наблюдения говорят за отрезок дней: чем пользовались, чем ни разу, обо что спотыкались                                                                       |
-| Предложение               | Готовая формулировка правки правил с адресом: пакет, компаньон или дерево. Приносит разбор закрытой задачи или слово посреди работы, отправляет человек командой |
-| Слово                     | Реплика человека посреди работы о слое правил: что мешает, чего не хватило, что сработало не так. Ложится блоком в файл предложений, а не живёт до конца захода  |
+- **Закон** — файл в каталоге конституции: что должно быть верно, без путей и имён файлов. Верен для любого приложения этого класса
+- **Законы приложения** — слой законов, верных только для этого приложения: деньги, локали, доступ. Предметность в них законна — она их предмет
+- **Правило** — скил с `kind: rule`. Привязывает закон к этому дереву: чем это здесь названо и где лежит
+- **Паттерн** — скил с `kind: pattern`. Готовый код и порядок действий; стоит при правиле
+- **Компаньон** — файл `implementation.md` рядом с правилом: имена и пути этого дерева. Пакет знает приём, но не знает имён — их пишет проект
+- **Спек** — описание домена: как он работает. Говорит об установившемся, а не о предстоящем
+- **Домен** — предмет, у которого свой спек. Выросший домен делится на поддомены, а не на соседние домены
+- **Сценарий** — наблюдаемое поведение под номером `SC-<ПРЕФИКС>-<НОМЕР>`. Номер стоит в заголовке теста
+- **Привязка** — строка `` `файл:символ` `` в компаньоне или в спутнике спека — место, где утверждение исполняется
+- **Спутник** — файл рядом со спеком или правилом: компаньон, перечень сценариев
+- **Договорённость о продукте** — как продукт себя поведёт, записанное до кода: единственное место, где спек говорит о будущем. После выкатки вливается в спек домена
+- **Ресурс** — единица того, что везёт пакет правил: закон, правило, паттерн, гард, проверка, роль, команда, конвейер, шаблон, умолчание, документ
+- **Раскладка** — перенос ресурса из пакета в дерево по его роду и настройке слоя
+- **Разложенный файл** — файл в дереве с шапкой пакета. Правится не на месте, а надстройкой: правка на месте теряется на следующей раскладке
+- **Надстройка** — файл дерева, который сливается с разложенным по заголовкам разделов
+- **Выключенная роль** — роль, вызов которой дерево перестало считать обязательным: гард при ней молчит. Названа списком в настройке дерева, из раскладки не убирается и зовётся руками
+- **Наблюдение** — строка о событии слоя правил: правило загружено, гейт отбил, гард отказал. Пишет гард, живёт в дереве, наружу уезжает счётчиками. Журналом не называется
+- **Сводка** — что наблюдения говорят за отрезок дней: чем пользовались, чем ни разу, обо что спотыкались
+- **Предложение** — готовая формулировка правки правил с адресом: пакет, компаньон или дерево. Отправляет её человек командой
+- **Слово** — реплика человека посреди работы о слое правил: что мешает, чего не хватило, что сработало не так. Ложится блоком в файл предложений, а не живёт до конца захода
 
 ## Работа
 
-| Термин           | Что это                                                                                                                                                                                                                                                                       |
-| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Задача           | Единица работы в очереди работ. Заводится до ветки, и номер её стоит в имени ветки и в заголовке PR                                                                                                                                                                           |
-| PR               | Заявка на слияние: то же название, что у задачи, переведённое в сделанное. Отчётом, пул-реквестом и мёрдж-реквестом не называется — ни в файлах, ни в разговоре                                                                                                               |
-| Очередь работ    | Доска, на которой видно состояние каждой задачи. Ветки она не видит                                                                                                                                                                                                           |
-| Папка задачи     | Одна работа от разбора до слияния: разбор просьбы, замысел, ход работы. Умирает со слиянием — разбирается, и объясняющее решение уезжает в архив                                                                                                                              |
-| Разбор           | Расспрос владельца до первой правки. Записывается его словами и задним числом не переписывается                                                                                                                                                                               |
-| Замысел          | Файл папки задачи: след задачи и этапы с признаками готовности. После написания не правится — с ним сверяют результат при приёмке                                                                                                                                             |
-| Ход работы       | Файл папки задачи: «Где стоим», решения по ходу с причинами, записи заходов. Единственное место, где отмечается сделанное. Журналом не называется                                                                                                                             |
-| Состояние работы | Единица, которой работа ведётся: у каждого состояния названы вход, обязательное действие и выход. Объявляется машиночитаемой строкой в разделе «Где стоим» хода работы — гард судит объявленный переход, а не наличие файлов                                                  |
-| След задачи      | Раздел замысла: какие спеки, законы, правила и части кода работа задевает                                                                                                                                                                                                     |
-| Заход            | Одна сессия работы над задачей. Работа живёт дольше одного захода, и между ними её состояние держит только ход работы                                                                                                                                                         |
-| Заполнение окна  | Доля места захода, которую он уже занял: вход, запись в кэш, прочитанное из кэша и вывод последнего ответа, делённые на размер окна. Не «расход» и не «бюджет»: речь о месте, а не о деньгах                                                                                  |
-| Передача         | Текст, которым заход закрывается: рабочее дерево, ветка, задача, где лежит ход работы, что сделано, следующий шаг, особенности захода. Кладётся вне дерева и не коммитится                                                                                                    |
-| Эпик             | Серия задач одной темы, выполняемых в назначенном порядке. Живёт в двух местах сразу: карточка в очереди работ с меткой эпика и замысел рядом с ней — что за возможность разрабатывается, какие задачи входят и в каком порядке. Шире одной ветки. Линией работ не называется |
-| Архив            | Записи о состоявшемся: что объясняет закрытое решение. После выкатки не правится                                                                                                                                                                                              |
+- **Задача** — единица работы в очереди работ. Заводится до ветки, и номер её стоит в имени ветки и в заголовке PR
+- **PR** — заявка на слияние: то же название, что у задачи, переведённое в сделанное. Отчётом, пул-реквестом и мёрдж-реквестом не называется — ни в файлах, ни в разговоре
+- **Очередь работ** — доска, на которой видно состояние каждой задачи. Ветки она не видит
+- **Папка задачи** — одна работа от разбора до слияния: разбор просьбы, замысел, ход работы. Умирает со слиянием — разбирается, и объясняющее решение уезжает в архив
+- **Разбор** — расспрос владельца до первой правки. Записывается его словами и задним числом не переписывается
+- **Замысел** — файл папки задачи: след задачи и этапы с признаками готовности. После написания не правится — с ним сверяют результат при приёмке
+- **Ход работы** — файл папки задачи: «Где стоим», решения по ходу с причинами, записи заходов. Единственное место, где отмечается сделанное. Журналом не называется
+- **Состояние работы** — единица, которой работа ведётся: у каждого названы вход, обязательное действие и выход. Объявляется строкой в разделе «Где стоим» хода работы, и гард судит её, а не наличие файлов
+- **След задачи** — раздел замысла: какие спеки, законы, правила и части кода работа задевает
+- **Заход** — одна сессия работы над задачей. Работа живёт дольше захода, и между ними её состояние держит ход работы
+- **Заполнение окна** — доля места захода, которую он уже занял: вход, запись в кэш, прочитанное из кэша и вывод последнего ответа, делённые на размер окна. Не «расход» и не «бюджет»: речь о месте, а не о деньгах
+- **Передача** — текст, которым заход закрывается: рабочее дерево, ветка, задача, где лежит ход работы, что сделано, следующий шаг, особенности захода. Кладётся вне дерева и не коммитится
+- **Эпик** — серия задач одной темы в назначенном порядке, шире одной ветки. Живёт в двух местах: карточка с меткой эпика и замысел рядом с ней. Линией работ не называется
+- **Архив** — записи о состоявшемся: что объясняет закрытое решение. После выкатки не правится
 
 ## Проверки
 
-| Термин                | Что это                                                                                                                     |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| Гард                  | Хук агента, который отбивает действие до того, как оно сделано, и говорит, чем отказ снимается                              |
-| Гейт                  | Требование, которое пропускает действие один раз за сессию после того, как выполнено: загружено правило, пройдены проверки  |
-| Отказ в пользу работы | Устройство гарда, при котором любая его поломка пропускает действие. Сломанный гард не имеет права остановить работу совсем |
-| Прогон                | Запуск набора сценариев. «Тесты гоняются», а не «запускаются в работу»                                                      |
-| Сверка                | Проверка, которая ничего не правит, а называет расхождения: раскладки с пакетом, спеков с кодом, очереди работ с ветками    |
-| Замер                 | Число, снятое с работающего приложения. Взгляд на экран замером не является                                                 |
+- **Гард** — хук агента, который отбивает действие до того, как оно сделано, и говорит, чем отказ снимается
+- **Гейт** — требование, которое пропускает действие один раз за сессию после того, как выполнено: загружено правило, пройдены проверки
+- **Отказ в пользу работы** — устройство гарда, при котором любая его поломка пропускает действие. Сломанный гард не имеет права остановить работу совсем
+- **Прогон** — запуск набора сценариев. «Тесты гоняются», а не «запускаются в работу»
+- **Сверка** — проверка, которая ничего не правит, а называет расхождения: раскладки с пакетом, спеков с кодом, очереди работ с ветками
+- **Замер** — число, снятое с работающего приложения. Взгляд на экран замером не является
 
 ## Так не пишем
 
-| Так не пишем                | Пишем так                                                                                      |
-| --------------------------- | ---------------------------------------------------------------------------------------------- |
-| спека (о тесте)             | тест — файл рядом с исходником; спек — документ. Одна буква разницы, а значения противоположны |
-| таска, тикет                | задача                                                                                         |
-| пул-реквест, мёрдж-реквест  | PR, а действие — слияние                                                                       |
-| отчёт (о заявке на слияние) | PR; отчёт — сводка данных, и слово занято ею                                                   |
-| джоба, пайплайн             | конвейер и его шаг                                                                             |
-| хендофф                     | передача                                                                                       |
-| бэклог                      | очередь работ                                                                                  |
-| линия работ                 | эпик                                                                                           |
-| контекст-виндоу             | окно захода, а его доля — заполнение окна                                                      |
-| скилл, скилы                | правило, паттерн или скил без закона — по тому, что это на самом деле                          |
+Слева — то, что не пишется и не произносится нигде; справа — чем это зовут здесь.
+
+- **спека (о тесте)** — тест — файл рядом с исходником; спек — документ. Одна буква разницы, а значения противоположны
+- **таска, тикет** — задача
+- **пул-реквест, мёрдж-реквест** — PR, а действие — слияние
+- **отчёт (о заявке на слияние)** — PR; отчёт — сводка данных, и слово занято ею
+- **джоба, пайплайн** — конвейер и его шаг
+- **хендофф** — передача
+- **бэклог** — очередь работ
+- **линия работ** — эпик
+- **контекст-виндоу** — окно захода, а его доля — заполнение окна
+- **скилл, скилы** — правило, паттерн или скил без закона — по тому, что это на самом деле

package/assets/hooks/rule-article.sh

@@ -75,6 +75,18 @@ rt_rule_article_marks() {
 # Текст статьи, внутри которой стоит строка с признаком. Статья начинается ближайшим сверху
 # пунктом списка верхнего уровня и кончается перед следующим таким пунктом или перед строкой без
 # отступа: продолжение статьи всегда идёт с отступом.
+# Заголовок статьи — её жирная первая фраза. Отказ гейта называет статьи ею, а не пересказывает
+# их телом: правило заход грузит следом, и тело придёт в контекст вторым разом. У правила текстов
+# отказ печатал 4 134 знака одиннадцатью статьями, их заголовки — 718.
+#
+# Заголовок при этом не украшение: по нему идёт привязка утверждения к коду, и он же называет
+# статью в отказе так, что её видно в правиле глазами.
+rt_rule_article_heads() {
+    rule_file="$1"
+    edited="$2"
+    rt_rule_articles "$rule_file" "$edited" 2>/dev/null | grep -o '^- \*\*[^*]*\*\*' 2>/dev/null
+}
+
 rt_rule_article_at() {
     awk -v mark="$2" '
         NR <= mark && /^- / { start = NR }

package/assets/hooks/skill-gate.sh

@@ -186,13 +186,14 @@ fi
 # Правило целиком остаётся вторым ходом — для того, кому статьи мало.
 # shellcheck disable=SC1090
 [ -f "$rt_hooks_dir/rule-article.sh" ] && . "$rt_hooks_dir/rule-article.sh" 2>/dev/null
-if [ "$kind" != "command" ] && [ "$kind" != "browser" ] && command -v rt_rule_articles >/dev/null 2>&1; then
-    article="$(rt_rule_articles "$root/$rules_dir/${req}/SKILL.md" "$target" 2>/dev/null)"
+if [ "$kind" != "command" ] && [ "$kind" != "browser" ] && command -v rt_rule_article_heads >/dev/null 2>&1; then
+    article="$(rt_rule_article_heads "$root/$rules_dir/${req}/SKILL.md" "$target" 2>/dev/null)"
     if [ -n "$article" ]; then
-        reason="Отбито гейтом правил. Под эту правку подпадает статья правила «${req}»:
+        reason="Отбито гейтом правил. Под эту правку подпадают статьи правила «${req}»:
 
 ${article}
-Статья снимает чтение правила целиком, а не отказ: загрузи правило «${req}» инструментом Skill и повтори действие. ${fallback} Для этой области это происходит один раз за сессию."
+
+Текст этих статей придёт в контекст вместе с правилом, и пересказывать его здесь значило бы платить за один текст дважды: загрузи правило «${req}» инструментом Skill и повтори действие. ${fallback} Для этой области это происходит один раз за сессию."
     fi
 fi
 

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

@@ -215,6 +215,26 @@ case "$state" in
         ;;
 esac
 
+# Папка задачи едет в ветку коммитом, а не живёт в одном рабочем дереве. Четыре требования выше
+# смотрят диск, и папка, ни разу не закоммиченная, проходит их все без единого отказа — а
+# признак отданной работы гард берёт из истории, и там её нет. Отказ приходит в последней точке,
+# на открытии заявки, когда папка уже разобрана своими руками: чинить нечего, замысел снят, и
+# собирать его приходится заново по памяти. За одну задачу это стоило восьми вызовов и двух
+# отказов подряд.
+#
+# Второе следствие тише: ход работы, живущий в рабочем дереве, не виден никому. Владелец видит
+# ветку без единого следа того, что в ней делается, а следующий заход — пустоту вместо «Где
+# стоим», если рабочее дерево между заходами сменилось.
+#
+# Спрашивается та же история, что и у признака отданной работы: папка стоит в `HEAD` либо её
+# добавлял коммит ветки. Нет git — требования нет: спросить историю нечем.
+if [ -n "$(git rev-parse --verify HEAD 2>/dev/null)" ]; then
+    in_tree="$(git ls-tree -d --name-only HEAD -- "$tasks_dir/$branch" 2>/dev/null | head -1)"
+    if [ -z "$in_tree" ]; then
+        deny "BLOCKED by task-flow: папка задачи '${tasks_dir}/${branch}' лежит в рабочем дереве, а в историю ветки не заведена. Заведи её коммитом (git add ${tasks_dir}/${branch} && git commit), затем повтори: признак отданной работы гард берёт из истории, и с некоммиченной папкой отказ придёт на открытии заявки — когда папка уже разобрана и чинить нечего. Правило — скил task-flow."
+    fi
+fi
+
 # Строка обхода: поведение не меняется, договорённость о продукте не нужна. Причина обязана
 # стоять — без неё обход становится умолчанием.
 if grep -qE '^\*\*Поведение:\*\*[[:space:]]*не меняется[[:space:]]*—[[:space:]]*\S' "$plan" 2>/dev/null; then

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

@@ -12,7 +12,9 @@
 # нельзя, и запрет должна держать машина.
 #
 # Что считается работой: правка файла и команда, меняющая дерево или его состояние. Чтение,
-# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал.
+# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал. Читающая
+# подкоманда `git` и клиента хостинга работой не считается тоже, и судится это по частям
+# составной команды: чтение, соединённое с правкой через `&&`, работой остаётся.
 #
 # Что отпускает ход:
 #   1. Работа отдана либо влита — состояние работы говорит об этом само.
@@ -74,6 +76,43 @@ case "$state" in
     работа-отдана | влито) exit 0 ;;
 esac
 
+# Записанный замысел концом хода не бывает вовсе. Обязательное действие этого состояния — делать
+# первый этап, а начавший его переводит состояние той же правкой: ход, оставшийся в прежнем
+# состоянии, первого этапа не начал по определению. Второй признак сюда не годится — заведение
+# задачи, ветки, колонки и папки он считает работой, и ход, где сделана одна подготовка,
+# проходит его насквозь. За один заход так вышло трижды; дважды это поймал соседний гард по
+# открытой заявке, третий раз не поймало ничто, а владельцу отчёт о взятой задаче неотличим от
+# остановки.
+if [ "$state" = "замысел-записан" ]; then
+    plan="$root/$tasks_dir/$branch/plan.md"
+    first_stage="$(grep -m1 '^### ' "$plan" 2>/dev/null | sed 's/^### //')"
+    [ -z "$first_stage" ] && first_stage="первый этап замысла"
+    reason="BLOCKED by turn-exit-guard: работа стоит в состоянии 'замысел-записан', а обязательное действие этого состояния — делать первый этап — за ход не начато.
+
+Заведение задачи, ветки, колонки и папки этим шагом не считается: всё это подготовка к работе, а не работа. Владельцу отчёт о взятой задаче неотличим от остановки — он видит исполнителя стоящим.
+
+Первый этап замысла: ${first_stage}
+
+Начни его этим же ходом и перепиши состояние на '- **Состояние:** \`этап-идёт\`'. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+    # а причина отказа остаётся прежней.
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: замысел записан, а первый этап не начат."}\n'
+    exit 0
+fi
+
 # То же самое, но объявить это на диске уже нечем: папка задачи разбирается до открытия заявки,
 # и ход работы уезжает вместе с ней. Признак берётся из истории ветки — папка, снятая её
 # коммитом.
@@ -108,7 +147,36 @@ next_step=""
 # заполняется ход, который встал.
 work_re='git (add|commit|push|checkout|merge|rm)|npm run|pnpm (run|exec)|nx (build|test|run)|gh (pr|issue|api|run)|task:(new|move)|mkdir|cp |mv |rm |sed -i|tee |>>?[[:space:]]*[^|&]'
 
-verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re" '
+# Разведка. Те же слова, что и в образце работы, но подкоманда читающая: переключение ветки,
+# подтягивание, просмотр истории, чтение заявок и прогонов. Образец работы называет их работой,
+# потому что знает только первое слово — `git` и `gh` стоят в нём целиком, — и ход, в котором
+# исполнитель перешёл на главную ветку, прочитал историю и написал владельцу отчёт, выходил
+# отсюда нулём. Разбор — `docs/postmortems/2026-08-25-read-only-turn-counted-as-work.md`.
+#
+# Разведка выглядит работой лучше всего остального: в ней команды, числа и точные ответы. Тем
+# она и опасна — ход, набитый ею, читается как полный и владельцем, и самим заходом.
+read_re='^[[:space:]]*(([^[:space:]]*/)?git[[:space:]]+(show|log|ls-tree|ls-files|ls-remote|diff|status|branch|tag|rev-parse|remote|describe|blame|fetch|pull|(checkout|switch)(?![[:space:]]+-[bc][[:space:]]))|([^[:space:]]*/)?gh[[:space:]]+(pr|issue|run|repo)[[:space:]]+(list|view|status|checks|diff|download|logs))([[:space:]]|$)'
+
+# Части составной команды судятся по одной: ход собирает чтение и работу в одну строку через
+# `&&`, и суждение целиком отпускало бы разведку по первой же меняющей части.
+part_re='&&|\|\||;|\n'
+
+# Ожидание чужого шага. Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда
+# быстрее не становятся — правило прямо говорит, что состоянием работы это не бывает. Судится
+# только ПОСЛЕДНЕЕ действие хода: ожидание в середине законно, а запуск работы в фоне работой
+# остаётся. Разбор — `docs/postmortems/2026-08-25-turn-ended-on-waiting.md`.
+#
+# Прежний признак спрашивал одно: была ли за ход работа. Ход, где разобран конфликт, сделаны
+# коммит и пуш, а последним действием стал цикл до готовности прогона, проходил его целиком —
+# работа была, и много. Именно эта полнота и обманывает: пустоты за таким ходом не видно.
+wait_re='gh[[:space:]]+(run[[:space:]]+watch|pr[[:space:]]+checks[^|]*--watch)|until[[:space:]].*sleep|while[[:space:]].*sleep|^[[:space:]]*sleep[[:space:]]'
+
+# Отдача работы и начало следующей. Правило зовёт законным концом хода отданную работу — но с
+# условием: следующая начата, и по ней сделано ДЕЙСТВИЕ, а не сказано.
+handover_re='gh[[:space:]]+pr[[:space:]]+create'
+started_re='task:new|task:move|board\.mjs[[:space:]]+move|git[[:space:]]+checkout[[:space:]]+-b|git[[:space:]]+switch[[:space:]]+-c'
+
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re" --arg read "$read_re" --arg part "$part_re" --arg wait "$wait_re" --arg handover "$handover_re" --arg started "$started_re" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -122,7 +190,29 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re
     | ($uses | map(.name // "") | any(test("^(Edit|Write|MultiEdit|NotebookEdit)$"))) as $edited
     | ($uses | map(.name // "") | any(test("AskUserQuestion"))) as $asked
     | ($uses | map((.input.command // "")) | join("\n")) as $ran
-    | ($ran | test($work)) as $ran_work
+    # Работой считается часть команды, совпавшая с образцом работы и не совпавшая с образцом
+    # разведки: переключение ветки и чтение истории тем же ходом работой не становятся.
+    | ([$ran | splits($part)] | map(test($work) and (test($read) | not)) | any) as $ran_work
+    # Последнее действие хода. Ожидание чужого шага концом хода не бывает, сколько бы работы ни
+    # было раньше: работа остаётся ровно там, где стояла.
+    | ([$uses[] | select((.name // "") == "Bash") | (.input.command // "")] | last // "") as $last
+    | ($last | test($wait)) as $waited
+    # Отдача работы: хвост хода после открытия заявки. Всё, что было до неё, сделано по сданной
+    # задаче и о следующей не говорит ничего.
+    | ([$uses[] | select((.name // "") == "Bash") | (.input.command // "")]) as $cmds
+    | (($cmds | map(test($handover)) | index(true))) as $handover_at
+    | ($handover_at != null) as $handed_over
+    | (if $handover_at == null then [] else $cmds[$handover_at:] end) as $tail
+    | (($tail | map(test($started)) | any)
+        or ($uses | map(.name // "") | any(test("^(Edit|Write|MultiEdit|NotebookEdit)$")))) as $started_next
+    # ПОСЛЕДНЕЕ ДЕЙСТВИЕ ХОДА — общий признак, из которого частные ярусы ниже только выводят
+    # понятный отказ. Девять разборов происшествий за сутки описывают девять разных остановок, и
+    # во всех девяти последним действием хода был текст владельцу: отчёт, сводка, объявление
+    # намерения. Ярус на каждый вид остановки — гонка без конца: видов столько, сколько бывает
+    # поводов заговорить. Признак поэтому один — работой должно быть ПОСЛЕДНЕЕ действие.
+    | ([$uses[] | (.name // "")] | last // "") as $last_tool
+    | (($last_tool | test("^(Edit|Write|MultiEdit|NotebookEdit)$"))
+        or ([$last | splits($part)] | map(test($work) and (test($read) | not)) | any)) as $ended_working
     # Отказ гарда и передача захода — оба кончают ход по правилу.
     | ([$turn[] | select(.type == "user") | .message.content // [] | select(type == "array") | .[]
           | select(.type == "tool_result") | .content
@@ -136,17 +226,65 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re
           | if type == "string" then . elif type == "array"
             then (map(if type == "object" then (.text // "") else "" end) | join("\n")) else "" end] | join("\n")) as $said
     | ($said | test("останов|стоп|хватит|подожди|не надо|прерв|отложи")) as $told_stop
-    | { worked: ($edited or $ran_work), released: ($asked or $denied or $handed or $told_stop), ran: $ran }
+    | { worked: ($edited or $ran_work), released: ($asked or $denied or $handed or $told_stop), waited: $waited, handed_over: $handed_over, started_next: $started_next, ended_working: $ended_working, ran: $ran }
 ' 2>/dev/null)"
 
 [ -z "$verdict" ] && exit 0
 
 worked="$(printf '%s' "$verdict" | jq -r '.worked // false' 2>/dev/null)"
+waited="$(printf '%s' "$verdict" | jq -r '.waited // false' 2>/dev/null)"
+handed_over="$(printf '%s' "$verdict" | jq -r '.handed_over // false' 2>/dev/null)"
+started_next="$(printf '%s' "$verdict" | jq -r '.started_next // false' 2>/dev/null)"
+ended_working="$(printf '%s' "$verdict" | jq -r '.ended_working // false' 2>/dev/null)"
 released="$(printf '%s' "$verdict" | jq -r '.released // false' 2>/dev/null)"
 commands="$(printf '%s' "$verdict" | jq -r '.ran // ""' 2>/dev/null)"
 
 [ "$released" = "true" ] && exit 0
 
+# Взятая, но не начатая работа. Ветка по номеру задачи заведена, а каталога задачи при ней нет
+# вовсе — значит работа объявлена взятой и не начата ни одной строкой. Ход здесь не кончается, сколько бы
+# работы в нём ни было: заведение ветки, перевод колонки и уборка соседних веток — всё это
+# команды, меняющие дерево, и второй признак отпускает такой ход целиком.
+#
+# Ровно так ход и вставал: задача взята, номер назван владельцу, отчёт написан — и следующее
+# действие состояния «задача-взята», написать замысел, не сделано. Отчёт выглядит работой лучше
+# всякой другой, а страж, знающий только «была ли за ход работа», подтверждает это: работа была.
+# Разбор — `docs/postmortems/2026-08-25-task-taken-and-turn-ended.md`.
+#
+# Папка, разобранная коммитом ветки, сюда не попадает: `archived` означает отданную работу, и её
+# судит прежний ярус. Ветка без номера задачи не судится вовсе — под пробу заводят и такие.
+if [ "$archived" != "true" ] && [ -z "$progress" ] && [ -n "$branch" ] && [ ! -d "$root/$tasks_dir/$branch" ]; then
+    task_key="${RT_TASK_KEY:-}"
+    if [ -z "$task_key" ] && [ -f "$root/.claude/rt-kit/checks.json" ]; then
+        task_key="$(jq -r '.board.taskKey // empty' "$root/.claude/rt-kit/checks.json" 2>/dev/null)"
+    fi
+    [ -z "$task_key" ] && task_key='[A-Za-z][A-Za-z0-9]*'
+    if printf '%s' "$branch" | grep -qE "^${task_key}-[0-9]+-" 2>/dev/null; then
+        reason="BLOCKED by turn-exit-guard: работа взята и не начата — ветка \`$branch\` заведена, а папки задачи при ней нет.
+
+Заведённая ветка означает состояние «задача-взята», и обязательное действие у него одно — написать замысел. Ход, кончившийся здесь, оставляет работу объявленной и не начатой: номер назван, колонка сдвинута, а на диске нет ни разбора просьбы, ни этапов. Команды заведения ветки и перевода колонки этого не заменяют — ими такой ход и заполняется.
+
+    npm run task:new -- <номер>   # если папки нет вовсе
+
+Собери \`$tasks_dir/$branch/\` и напиши замысел этим же ходом.
+
+Страж судит один ход: следующий заход не отбивается."
+
+        # shellcheck disable=SC1090
+        [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+            && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+        command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+        deny_tail_text="$(rt_deny_tail "")"
+        [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+        jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+            || printf '{"decision":"block","reason":"turn-exit-guard: работа взята и не начата — напиши замысел."}\n'
+        exit 0
+    fi
+fi
+
 # Контракт этапа. Отметка «этап сделан» — утверждение о дереве, и подтверждается оно выводом
 # команды, а не словами: этап, отмеченный по памяти, через заход неотличим от проверенного.
 # Страж сравнивает номер этапа с тем, что лежит в истории ветки, и на выросшем номере требует
@@ -199,6 +337,93 @@ ${deny_tail_text}"
     fi
 fi
 
+# Работа отдана, а следующая только названа. Работы в таком ходе больше, чем в любом другом, — и
+# вся она по сданной задаче: отдача завершает прошлую работу, а не ход. Девять разборов
+# происшествий за сутки описывают девять разных остановок, и во всех девяти последним действием
+# хода был текст владельцу: отчёт, сводка, объявление намерения.
+# Разбор — `docs/postmortems/2026-08-25-handover-turn-ends-on-intent.md`.
+if [ "$handed_over" = "true" ] && [ "$started_next" != "true" ]; then
+    reason="BLOCKED by turn-exit-guard: заявка открыта, а по следующей работе за этот ход не сделано ничего.
+
+Отданная работа кончает ход только вместе с начатой следующей — по ней должно быть сделано действие, а не сказано. «Беру такую-то» выходом не является: правило зовёт это объявлением намерения.
+
+Всё, что было до открытия заявки, сделано по сданной задаче и о следующей не говорит ничего.
+
+    npm run task:new -- <заголовок>            # завести следующую
+    git checkout -b <КЛЮЧ>-<номер>-<slug>      # взять её в работу
+
+Сделай первый шаг по следующей работе этим же ходом. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: работа отдана, а следующая не начата."}\n'
+    exit 0
+fi
+
+# Ход кончился ожиданием чужого шага. Работа в нём была — тем он и обманчив: полон, и пустоты за
+# ним не видно. Судится последнее действие, а не наличие работы.
+if [ "$waited" = "true" ]; then
+    reason="BLOCKED by turn-exit-guard: последним действием хода стало ожидание чужого шага, а оно состоянием работы не бывает.
+
+Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда быстрее не становятся. Работы за ход могло быть много — она остаётся ровно там, где стояла, и владелец видит исполнителя стоящим.
+
+Следующий шаг записан в ходе работы: ${next_step}
+
+Сделай его этим же ходом либо возьми следующую задачу. Ожидание в середине хода законно — отбит именно конец.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: ход кончился ожиданием чужого шага."}\n'
+    exit 0
+fi
+
+# Общий рубеж. Работа за ход была — но последним действием стал не она, а текст владельцу.
+# Частные ярусы выше называют вид остановки точнее; сюда доходит то, чего они не знают по имени.
+if [ "$worked" = "true" ] && [ "$ended_working" != "true" ]; then
+    reason="BLOCKED by turn-exit-guard: работа за ход была, но последним действием хода стала не она.
+
+Ход кончается работой, а не рассказом о ней. Отчёт, сводка и объявление намерения выходом не являются: они выглядят завершением тем убедительнее, чем больше сделано, — и ровно на это место встаёт следующее действие.
+
+Следующий шаг записан в ходе работы: ${next_step}
+
+Сделай его этим же ходом, а сказать о сделанном можно после. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: последним действием хода стала не работа."}\n'
+    exit 0
+fi
+
 [ "$worked" = "true" ] && exit 0
 
 if [ "$archived" = "true" ]; then