@rt-tools/agent-kit 0.13.0 → 0.15.0

package/assets/checks/spec-common.mjs

@@ -66,8 +66,12 @@ const E2E_ROOTS = CONFIG.e2eRoots;
  * переписан целиком. Алфавит не перечисляется диапазонами: перечисленные молча не покрывают
  * соседнего, и промах выглядит отсутствием привязки. Путь при этом остаётся латинским — он
  * адрес в дереве, а не слово текста.
+ *
+ * Решётка перед именем законна: приватное поле класса объявлено с ней, и записанное без неё имя
+ * называет метод не тем именем, каким он объявлен. Проверка при этом остаётся зелёной — граница
+ * слова перед решёткой есть, — поэтому промах не краснеет ни разу и виден только чтением.
  */
-const ANCHOR = /`([\w./-]+\.[A-Za-z]{2,10}):(\p{L}[\p{L}\p{N}_-]*|_[\w-]*)`/gu;
+const ANCHOR = /`([\w./-]+\.[A-Za-z]{2,10}):(#?\p{L}[\p{L}\p{N}_-]*|#?_[\w-]*)`/gu;
 /**
  * Явный вердикт вместо якоря: статья, которой в дереве исполняться негде. Так бывает
  * законно — правило говорит о службе, которой дерево не держит, или о движении человека,

package/assets/checks/task-new.github.mjs

@@ -17,7 +17,7 @@
  * Тело читается со стандартного ввода. Автор и исполнитель — учётная запись бота,
  * та же, от которой идут коммиты; `--assignee` перекрывает исполнителя.
  */
-import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -38,6 +38,7 @@ import {
     graphql,
     numberFromTitle,
     taskState,
+    unstampFolder,
 } from './board.mjs';
 
 function parseArgs(argv) {
@@ -161,6 +162,7 @@ const branch = args.slug ? `${TASK_KEY}-${number}-${args.slug}` : `${TASK_KEY}-$
  * `docs/tasks/_draft-<slug>`. Оставленный черновиком, он остаётся вне истории, а следующий
  * заход его не находит: хук запуска ищет папку по имени ветки.
  */
+
 function adoptDraft() {
     if (!args.slug) {
         console.log(`\nПапка задачи: --slug не задан, переименовать черновик нечем.`);
@@ -174,10 +176,20 @@ function adoptDraft() {
         console.log(`\nПапка задачи уже на месте: docs/tasks/${branch}/`);
     } else if (existsSync(draft)) {
         renameSync(draft, target);
+        // Черновик тоже собирают с образца, и шапка в нём та же: снимается она и здесь.
+        unstampFolder(target);
         console.log(`\nПапка задачи: docs/tasks/_draft-${args.slug}/ → docs/tasks/${branch}/`);
     } else {
-        console.log(`\nПапка задачи собирается с образца:\n  cp -r docs/tasks/_template docs/tasks/${branch}`);
-        return;
+        const template = join(root, 'docs/tasks/_template');
+
+        if (!existsSync(template)) {
+            console.log(`\nПапки задачи нет, и собрать её не с чего: образца ${'docs/tasks/_template'} в дереве не лежит`);
+            return;
+        }
+
+        cpSync(template, target, { recursive: true });
+        unstampFolder(target);
+        console.log(`\nПапка задачи собрана с образца: docs/tasks/${branch}/`);
     }
 
     // Шапку замысла читает гард: по ней он находит договорённость о продукте. Номер в ней

package/assets/defaults/project.sh

@@ -258,24 +258,29 @@ rt_shell_writes_default() {
 # Судится заголовок команды — именно в нём стоит тот путь, куда команда пишет.
 #
 # Исключение — интерпретатор: ему код приходит телом, и путь записи стоит именно там. Признак
-# ошибается в сторону лишнего чтения тела: имя интерпретатора, стоящее в команде где угодно,
-# возвращает разбор тела целиком.
+# читается у той строки, которая тело открыла, а не у всей команды: тело принадлежит команде
+# своего заголовка. Прежде он читался у всего текста разом, и слово из документа отключало
+# вырезание целиком — строка «**Чем проверяется:** `bash projects/…`» в замысле делала запись
+# `plan.md` правкой кода приложения. Гард отбивал тем самым запись того файла, отсутствием
+# которого он же и отказывает.
 rt_shell_paths_default() {
     text="$(printf '%s' "$1" | tr "\"'\`" '   ')"
-    if ! printf '%s' "$text" \
-        | grep -Eq '(^|[|;&(]|[[:space:]])(python3?|node|ruby|perl|php|deno|bun|bash|sh|zsh)([[:space:]]|$)'; then
-        text="$(printf '%s' "$text" | awk '
-            function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
-            tag != "" { if (trim($0) == tag) tag = ""; next }
-            {
-                print
-                if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
-                    t = substr($0, RSTART, RLENGTH)
-                    sub(/^<<-?[ \t]*/, "", t)
-                    tag = t
-                }
-            }')"
-    fi
+    text="$(printf '%s' "$text" | awk '
+        function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
+        tag != "" {
+            if (keep) { print }
+            if (trim($0) == tag) { tag = ""; keep = 0 }
+            next
+        }
+        {
+            print
+            if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
+                t = substr($0, RSTART, RLENGTH)
+                sub(/^<<-?[ \t]*/, "", t)
+                tag = t
+                keep = ($0 ~ /(^|[|;&(]|[ \t])(python3?|node|ruby|perl|php|deno|bun|bash|sh|zsh)([ \t]|$)/)
+            }
+        }')"
 
     # Пути берутся только у тех кусков команды, которые пишут. Прежде брались у всей строки
     # целиком, и команда чтения, сцепленная с записью, отдавала свои пути как цели записи:

package/assets/defaults/turn-map.md

@@ -9,19 +9,17 @@
 
 ## Состояния и обязательные действия
 
-| Состояние                 | Обязательное действие                                  | Ведёт паттерн      |
-| ------------------------- | ------------------------------------------------------ | ------------------ |
-| `просьба-не-разобрана`    | разведка по дереву, затем вопросы                      | `task-flow-start`  |
-| `разбор-закрыт`           | договорённость о продукте либо причина её отсутствия   | `task-flow-start`  |
-| `договорённость-записана` | завести задачу, ветку и папку                          | `task-flow-start`  |
-| `задача-взята`            | написать замысел                                       | `task-flow-start`  |
-| `замысел-записан`         | делать первый этап                                     | `task-flow-start`  |
-| `этап-идёт`               | доделать этап и отметить в ходе работы                 | `task-flow-resume` |
-| `этапы-кончились`         | прогнать набор и открыть PR черновиком                 | `task-flow-close`  |
-| `работа-отдана`           | взять следующую задачу                                 | `task-flow-resume` |
-| `разбор-кончился`         | влить договорённость, привести тексты, разобрать папку | `task-flow-close`  |
-| `папка-разобрана`         | снять черновик и попросить влить                       | `task-flow-archive` |
-| `влито`                   | разбор работы правилами и сверка очереди               | `task-flow-archive` |
+- `просьба-не-разобрана` — разведка по дереву, затем вопросы; ведёт `task-flow-start`
+- `разбор-закрыт` — договорённость о продукте либо причина её отсутствия; ведёт `task-flow-start`
+- `договорённость-записана` — завести задачу, ветку и папку; ведёт `task-flow-start`
+- `задача-взята` — написать замысел; ведёт `task-flow-start`
+- `замысел-записан` — делать первый этап; ведёт `task-flow-start`
+- `этап-идёт` — доделать этап и отметить в ходе работы; ведёт `task-flow-resume`
+- `этапы-кончились` — прогнать набор и открыть PR черновиком; ведёт `task-flow-close`
+- `работа-отдана` — взять следующую задачу; ведёт `task-flow-resume`
+- `разбор-кончился` — влить договорённость, привести тексты, разобрать папку; ведёт `task-flow-close`
+- `папка-разобрана` — снять черновик и попросить влить; ведёт `task-flow-archive`
+- `влито` — разбор работы правилами и сверка очереди; ведёт `task-flow-archive`
 
 Ни у одного состояния обязательное действие не звучит как «ждать». Прогон, разбор владельцем и
 слияние идут без исполнителя и от взгляда быстрее не становятся.
@@ -30,12 +28,10 @@
 
 Способов четыре, и других нет.
 
-| Выход                                              | Чем подтверждается                                              |
-| -------------------------------------------------- | --------------------------------------------------------------- |
-| вопрос владельцу, ответа на который в правилах нет | вопрос задан, и за тот же ход правила читались                  |
-| отказ гарда                                        | отказ назван владельцу, обход не искался                        |
-| заполненное окно там, где сжатия нет               | ход работы дописан, передача написана                           |
-| работа отдана, и следующая начата                  | PR открыт, и по следующей задаче сделано действие, а не сказано |
+- **вопрос владельцу, ответа на который в правилах нет** — вопрос задан, и за тот же ход правила читались
+- **отказ гарда** — отказ назван владельцу, обход не искался
+- **заполненное окно там, где сжатия нет** — ход работы дописан, передача написана
+- **работа отдана, и следующая начата** — PR открыт, и по следующей задаче сделано действие, а не сказано
 
 Там, где дерево объявило порог сжатия ниже порога остановки, заполненное окно ход не кончает:
 контекст сжимается, передача приходит входом, и работа идёт дальше тем же заходом. Порог

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

@@ -41,6 +41,36 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 [ -z "$transcript" ] && exit 0
 [ -f "$transcript" ] || exit 0
 
+# Текст ответа ложится в запись хода не раньше, чем хост позовёт хук: гард, прочитавший файл
+# первым, судит ход, у которого сказанного нет вовсе, — и молчит, будучи неотличим от гарда,
+# который посмотрел и пропустил. Ждём его появления, и не дождавшись — возвращаем ход: пустая
+# запись означает не «владельцу ничего не сказано», а «прочитать нечего».
+#
+# Отказ этот принадлежит одному гарду нарочно. Текст судят трое, и печатай они свои объекты
+# подряд, вывод перестал бы разбираться целиком — то есть отбой пропал бы весь.
+if ! rt_turn_has_text "$transcript"; then
+    reason="BLOCKED by claim-guard: запись хода не отдала ни одного текста ответа, и судить сказанное владельцу нечем.
+
+Текст ложится в запись не раньше, чем хост зовёт хук. Прочитанная слишком рано запись выглядит ходом, в котором владельцу ничего не сказано, — и все гарды, судящие сказанное, проходят мимо молча.
+
+Повтори завершение хода: к этой минуте текст в записи уже есть. Ход при этом ничего не теряет — сказанное владельцу остаётся тем же.
+
+Гард судит один ход: следующий заход не отбивается."
+
+    # 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":"claim-guard: запись хода не отдала текста ответа — повтори завершение хода."}\n'
+    exit 0
+fi
+
 # Ход — всё, что записано после последней настоящей реплики владельца: ответ инструмента
 # приходит той же ролью и репликой не считается.
 turn="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r '
@@ -76,6 +106,10 @@ claims=(
     '(ветки|ветка|файлы|файл|папка|каталог)[^.]{0,40}(снят|удал|почищ|вычищ)|снят[оыа] с§git branch|git push .*--delete|git rm|gh api|rm §команду удаления — `git branch -d`, `git push --delete` или `git rm`'
     'прогон (зелёный|прошёл|кончился)|конвейер зелёный|проверки на PR зелёные§gh run§`gh run list` или `gh run view`'
     '(работа|правка|задача) готова|можно вливать|PR открыт|черновик снят§gh pr §`gh pr create`, `gh pr view` или `gh pr ready`'
+    # Ожидание чужого шага — тоже утверждение о состоянии, и врать ему есть чем: прогон бывает
+    # зелёным час, бывает не встав вовсе. Сказанное без команды оставляет готовую работу
+    # черновиком, и владелец узнаёт об этом последним — дважды за сутки так и вышло.
+    'жд[уёя][^.]{0,20}прогон|дожида[ею][^.]{0,20}прогон|прогон[^.]{0,20}(ещё идёт|не встал|не кончился|не дошёл)|черновик[^.]{0,30}(не снимаю|сниму|снимется)§gh run|gh pr checks|check-runs|check:board|board\.mjs§команду о прогоне — `gh run list`, `gh pr checks` или сверку очереди работ'
     'задача заведена|задача (в|переведена в) колонк|колонка переведена§gh issue|gh api|task:new|task:move|board\.mjs§команду очереди работ — заведение задачи или перевод колонки'
     '(в дереве|в репозитории|здесь|такого файла|такой команды)[^.]{0,30}(нет|не бывает)|не заводили|нигде не встречается§grep|rg |ls |find |git ls-files|git grep|git log|cat §команду поиска — `grep`, `git ls-files` или обход каталога'
 )

package/assets/hooks/dispatch.sh

@@ -46,24 +46,57 @@ export RT_HOOK_INPUT="$input"
 branches="$(grep -l '^# rt-hook:' "$here"/*.sh 2>/dev/null | sort)"
 [ -z "$branches" ] && exit 0
 
+# Объявлений у файла бывает несколько: гард, стоящий и на вызове инструмента, и на завершении
+# хода, называет оба события своими строками. Читалось прежде только первое — и вторая ветка не
+# звалась ни разу, молча: снаружи это неотличимо от гарда, который посмотрел и пропустил.
+collected=""
 for branch in $branches; do
-    declaration="$(sed -n 's/^# rt-hook:[[:space:]]*//p' "$branch" 2>/dev/null | head -1)"
-    [ -z "$declaration" ] && continue
-
-    branch_event="${declaration%% *}"
-    [ "$branch_event" = "$event" ] || continue
-
-    # Образец вызова: его нет вовсе — гард зовётся на любом; есть — сверяется с именем
-    # инструмента целиком, а не куском. Звёздочка и точка со звёздочкой значат одно: любой вызов.
-    matcher="${declaration#"$branch_event"}"
-    matcher="${matcher#"${matcher%%[![:space:]]*}"}"
-    if [ -n "$matcher" ] && [ "$matcher" != '*' ] && [ "$matcher" != '.*' ]; then
-        [[ "${RT_HOOK_TOOL:-}" =~ ^(${matcher})$ ]] || continue
-    fi
+    matched=0
+    while IFS= read -r declaration; do
+        [ -z "$declaration" ] && continue
+
+        branch_event="${declaration%% *}"
+        [ "$branch_event" = "$event" ] || continue
+
+        # Образец вызова: его нет вовсе — гард зовётся на любом; есть — сверяется с именем
+        # инструмента целиком, а не куском. Звёздочка и точка со звёздочкой значат одно: любой
+        # вызов.
+        matcher="${declaration#"$branch_event"}"
+        matcher="${matcher#"${matcher%%[![:space:]]*}"}"
+        if [ -n "$matcher" ] && [ "$matcher" != '*' ] && [ "$matcher" != '.*' ]; then
+            [[ "${RT_HOOK_TOOL:-}" =~ ^(${matcher})$ ]] || continue
+        fi
+
+        matched=1
+        break
+    done <<EOF
+$(sed -n 's/^# rt-hook:[[:space:]]*//p' "$branch" 2>/dev/null)
+EOF
+
+    # Совпало хоть одно объявление — ветка зовётся один раз. Два объявления одного события в
+    # одном файле звали бы гард дважды на один ввод, и второй вызов судил бы то же самое.
+    [ "$matched" = 1 ] || continue
 
-    printf '%s' "$input" | bash "$branch"
+    branch_out="$(printf '%s' "$input" | bash "$branch" 2>/dev/null)"
     code=$?
-    [ "$code" -ne 0 ] && exit "$code"
+    if [ "$code" -ne 0 ]; then
+        [ -n "$branch_out" ] && printf '%s\n' "$branch_out"
+        exit "$code"
+    fi
+
+    # Отбой ветки приходит не кодом возврата, а решением в выводе: гарды завершения хода
+    # печатают его и выходят нулём. Не остановившись здесь, диспетчер склеил бы этот объект с
+    # выводом следующей ветки — а склеенное не разбирается, и отбой пропадает целиком.
+    if [ -n "$branch_out" ] && printf '%s' "$branch_out" | jq -e '.decision == "block"' >/dev/null 2>&1; then
+        printf '%s\n' "$branch_out"
+        exit 0
+    fi
+
+    [ -n "$branch_out" ] && collected="${collected}${branch_out}
+"
 done
 
+# Ни одна ветка не отбила: отдаётся то, что они напечатали, — подсказки и сводки.
+[ -n "${collected:-}" ] && printf '%s' "$collected"
+
 exit 0

package/assets/hooks/hook-input.sh

@@ -75,3 +75,42 @@ rt_hook_tool() { rt_hook_field RT_HOOK_TOOL '.tool_name'; }
 rt_hook_cmd() { rt_hook_field RT_HOOK_CMD '.tool_input.command'; }
 rt_hook_file() { rt_hook_field RT_HOOK_FILE '.tool_input.file_path'; }
 rt_hook_cwd() { rt_hook_field RT_HOOK_CWD '.cwd'; }
+
+# ЖДЁТ ПОСЛЕДНИЙ ТЕКСТ ХОДА В ЗАПИСИ. Гарды завершения судят то, что сказано владельцу, а запись
+# хода на этот момент бывает неполна: текст ответа ложится в файл не раньше, чем хост позовёт
+# хук, и гард читает ход, у которого текста нет вовсе. Молчит он при этом честно — и снаружи
+# неотличим от гарда, который посмотрел и пропустил. Ровно так ход, поставивший работу в
+# зависимость от слова владельца, ушёл мимо трёх гардов сразу, а тот же ход, поданный им
+# повторно, был отбит.
+#
+# Ждём короткими попытками: файл дописывается за миллисекунды, а ход и без того кончается не
+# мгновенно. Дождались — ноль; текста так и нет — единица, и решает уже гард.
+rt_turn_has_text() {
+    local transcript="$1" tries="${2:-20}" got
+
+    [ -n "$transcript" ] && [ -f "$transcript" ] || return 1
+    command -v jq >/dev/null 2>&1 || return 1
+
+    while [ "$tries" -gt 0 ]; do
+        got="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r '
+            def is_input:
+                .type == "user"
+                and (((.message.content // []) | if type == "array"
+                        then ([.[] | select(.type == "tool_result")] | length)
+                        else 0 end) == 0);
+
+            (map(is_input) | rindex(true)) as $i
+            | (if $i == null then . else .[$i + 1:] end)
+            | [.[] | select(.type == "assistant") | (.message.content // [])[]
+                 | select(.type == "text") | .text]
+            | length
+        ' 2>/dev/null)"
+
+        [ -n "$got" ] && [ "$got" != '0' ] && return 0
+
+        tries=$((tries - 1))
+        [ "$tries" -gt 0 ] && sleep 0.05
+    done
+
+    return 1
+}

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