@rt-tools/agent-kit 0.17.0 → 0.18.0

package/assets/hooks/grill-gate.sh

@@ -21,6 +21,15 @@
 # правил, поиск по ним. Требовать именно загрузку значило бы гнать на неё там, где хватило
 # одного поиска, — гард мешал бы работе вместо того, чтобы её выправлять.
 #
+# Но чтение чего угодно из слоя правил вопроса не закрывает: прочитанный разбор чужого промаха
+# и поиск по каталогу засчитывались наравне с правилом, которое этой работе и требуется, — а
+# ответ на заданный владельцу вопрос лежал ровно в нём. Поэтому, когда область работы этого хода
+# известна, чтением считается только правило этой области. Область берётся оттуда же, откуда её
+# берёт гейт правил: по путям правок хода.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ и здесь: правок в ходу нет, карты гейта нет, область не определилась —
+# засчитывается любое чтение, как прежде.
+#
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, отсутствии записи хода и повторном заходе ход
 # РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
@@ -68,11 +77,47 @@ archive_dir="${RT_ARCHIVE_DIR-docs/archive}"
 # Дерево, у которого нет ни законов, ни правил, требования не получает: читать нечего.
 [ -z "$laws_dir" ] && [ -z "$rules_dir" ] && exit 0
 
+# Карта гейта: по ней имя правила достаётся из пути правки. Нет её — область не определяется, и
+# всё остаётся прежним.
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for map in "$rt_hooks_dir/../rt-kit/defaults/gate-map.sh" "$rt_hooks_dir/../defaults/gate-map.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/gate-map.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/gate-map.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$map" ] && . "$map" 2>/dev/null
+done
+
 # Образец, по которому вызов инструмента считается чтением правил. Каталоги идут в него как
 # есть: точка в `.claude` совпадает с любым знаком и лишнего сюда не приводит.
 read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir|$plans_dir|$archive_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
 [ -z "$read_re" ] && exit 0
 
+# Область работы этого хода: правила, которых требует гейт от путей, правленных в ходу. Пути
+# достаются тем же разбором хода, что и ниже, — своим вызовом, чтобы образец чтения был готов
+# к главному разбору.
+need_re=''
+if command -v skill_for >/dev/null 2>&1 && [ -n "$rules_dir" ]; then
+    edited="$(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 == "tool_use") | select(.name == "Edit" or .name == "Write" or .name == "NotebookEdit")
+            | (.input.file_path // .input.notebook_path // "")]
+        | map(select(. != "")) | unique | .[]
+    ' 2>/dev/null)"
+    for path in $edited; do
+        for rule in $(skill_for edit "$path" '' 2>/dev/null); do
+            case "|$need_re|" in
+                *"|$rule|"*) ;;
+                *) need_re="${need_re}${need_re:+|}${rule}" ;;
+            esac
+        done
+    done
+fi
+
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью `user`, поэтому строки с `tool_result` вводом не считаются: иначе ходом
 # оказался бы кусок после последнего вызова инструмента, и чтение правил в его начале потерялось
@@ -82,7 +127,7 @@ read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir|$plans_dir|$archive_dir"
 # На событии вызова инструмента вопрос уже известен — он и есть вызов; судится только то,
 # читались ли за этот ход правила. На завершении хода вопрос ищется в тексте реплик: меню к
 # этому моменту уже отбито раньше.
-verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re" --arg tool "$tool" '
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re" --arg tool "$tool" --arg need "$need_re" --arg rules "$rules_dir" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -93,11 +138,23 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re"
     | (if $i == null then . else .[$i + 1:] end) as $turn
     | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "text") | .text] as $texts
     | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "tool_use")] as $uses
-    | ($uses | map(
-          (.name == "Skill")
-          or ((.name // "") | test("^(Read|Grep|Glob)$")) and ((.input | tostring) | test($re))
-          or ((.name == "Bash") and ((.input.command // "") | test($re)))
-      ) | any) as $read
+    | (if $need == "" then
+          $uses | map(
+              (.name == "Skill")
+              or ((.name // "") | test("^(Read|Grep|Glob)$")) and ((.input | tostring) | test($re))
+              or ((.name == "Bash") and ((.input.command // "") | test($re)))
+          ) | any
+      else
+          # Область работы известна — засчитывается только правило этой области: прочитанный
+          # разбор чужого промаха на заданный вопрос не отвечает.
+          ($need | split("|")) as $rules_needed
+          | $uses | map(
+              ((.name == "Skill") and (((.input.skill // "") | tostring) as $s | $rules_needed | index($s) != null))
+              or (((.name // "") | test("^(Read|Grep|Glob|Bash)$"))
+                  and ((.input | tostring) as $text
+                       | $rules_needed | map(. as $rule | $text | test($rules + "/" + $rule + "(/|\\b)")) | any))
+          ) | any
+      end) as $read
     | (($texts | join("\n")) | test("\\?[[:space:]]*$"; "m")) as $asked_prose
     | ($tool != "") as $asking_now
     | if ($asked_prose or $asking_now) and ($read | not) then "ask" else "pass" end

package/assets/hooks/proposal-guard.sh

@@ -38,16 +38,24 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 [ -f "$transcript" ] || exit 0
 
 # Каталог предложений у дерева свой. Заданный пустым — отказ дерева от требования: дереву, не
-# берущему переносимый слой правил, гард не навязывается.
+# берущему переносимый слой правил, гард не навязывается. Каталога нет на диске — то же самое:
+# дерево механизмом не пользуется, и стража ему не навязывают. Судить по одной переменной значило
+# бы требовать отправки там, где отправлять нечем и некуда.
+root="${CLAUDE_PROJECT_DIR:-.}"
 proposals_dir="${RT_PROPOSALS_DIR-.claude/rt-kit/proposals}"
 [ -z "$proposals_dir" ] && exit 0
+[ -d "$root/$proposals_dir" ] || exit 0
 
 # Просьба владельца. Набор открыт и пополняется правкой: полнота его — открытый вопрос
 # договорённости, а не обещание.
-asked_re='(завед|напиш|отправ|пошл|зашл|отошл|выгруз)[а-яё]*[^.!?]{0,40}(пропозал|предложени)|(пропозал|предложени)[а-яё]*[^.!?]{0,40}(завед|напиш|отправ|пошл|зашл|отошл|выгруз)'
+#
+# Латиница читается наравне: заход, который владелец ведёт по-английски, отличается от русского
+# словами, а требование в нём то же. Своей ветки ей не заводится — обе пары стоят в одном
+# образце, иначе одну из них правили бы, забывая про вторую.
+asked_re='(завед|напиш|отправ|пошл|зашл|отошл|выгруз|send|file|open|submit|raise|report)[а-яёa-z]*[^.!?]{0,40}(пропозал|предложени|proposal)|(пропозал|предложени|proposal)[а-яёa-z]*[^.!?]{0,40}(завед|напиш|отправ|пошл|зашл|отошл|выгруз|send|file|open|submit|raise|report)'
 
 # Сосед, без которого слово «предложение» не считается просьбой о слое правил.
-context_re='пропозал|слою правил|слоя правил|слой правил|пакет|agent-kit|наверх'
+context_re='пропозал|слою правил|слоя правил|слой правил|пакет|agent-kit|наверх|proposal|rule layer|upstream|package'
 
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью, поэтому строки с `tool_result` вводом не считаются.
@@ -86,7 +94,6 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg asked "$asked_
 # зависимостью, зовёт бинарь из зависимостей; дерево, где пакет живёт исходниками, бинаря не
 # имеет вовсе — там зовут собранный bin. Названная наугад команда стоит исполнителю хода: отказ
 # читается как указание, и вызов `npx agent-kit` отвечает в таком дереве отказом установки.
-root="${CLAUDE_PROJECT_DIR:-.}"
 if [ -x "$root/node_modules/.bin/agent-kit" ]; then
     propose_cmd="npx agent-kit propose"
 else

package/assets/hooks/rule-source-guard.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
-# Требует: hooks/profile-check.sh, hooks/deny-tail.sh
+# Требует: hooks/profile-check.sh, hooks/deny-tail.sh, hooks/write-targets.sh
 # Гард места правки: слой правил чинится там, где сломано, а не там, где виден.
 #
 # Слой правил правит тот же исполнитель, которым слой правил управляет, и разницы между
@@ -53,18 +53,13 @@ deny() {
     exit 0
 }
 
-# Цели записи, названные командой прямо. Печатает по одной в строке.
-rt_write_targets() {
-    tr "\"'\`" '   ' \
-        | sed -E 's/>>?/\n>/g' \
-        | sed -nE '
-            s/^>[[:space:]]*([^[:space:]|&;]+).*/\1/p
-            s/(^|.*[[:space:]])tee[[:space:]]+(-a[[:space:]]+)?([^[:space:]|&;]+).*/\3/p
-            s/(^|.*[[:space:]])sed[[:space:]]+-i[[:space:]]+([^[:space:]]+[[:space:]]+)*([^[:space:]|&;]+)$/\3/p
-            s/(^|.*[[:space:]])(cp|mv|install)[[:space:]]+([^[:space:]]+[[:space:]]+)+([^[:space:]|&;]+).*/\4/p
-        ' \
-        | sort -u
-}
+# Цели записи разбирает общий помощник: тот же признак нужен гарду экзамена, и разойдясь, две
+# копии пропустили бы разные формы записи. Файла нет — остаётся молчаливое умолчание, чтобы гард
+# не сломался на неполной раскладке.
+# shellcheck disable=SC1090
+[ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/write-targets.sh" ] \
+    && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/write-targets.sh" 2>/dev/null
+command -v rt_write_targets >/dev/null 2>&1 || rt_write_targets() { cat >/dev/null; }
 
 tool="$(rt_hook_tool)"
 candidates=""

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

@@ -52,6 +52,28 @@ emit() {
 # Ветка под задачу без папки — работа идёт мимо. Сессию не рвём: SessionStart, отбивающий
 # запуск, оставляет владельца без агента вовсе, а правку кода поймает `task-flow-guard`.
 if [ ! -d "$DIR" ]; then
+    # Папки нет по двум разным причинам, и говорить о них надо разное. Первая — работа шла мимо
+    # правила. Вторая — папку разобрала сама ветка последним коммитом перед заявкой: это законный
+    # исход, и указание собрать её заново уводит заход с хвоста работы обратно в её начало.
+    #
+    # Различает их история ветки: снос папки её же коммитом после общего предка с главной. Ход
+    # работы к этой минуте уехал вместе с папкой, и состояние держат заявка и передача захода.
+    main_branch="${RT_MAIN_BRANCH:-main}"
+    base="$(git merge-base "origin/${main_branch}" HEAD 2>/dev/null || git merge-base "$main_branch" HEAD 2>/dev/null)"
+    dropped=''
+    [ -n "$base" ] && dropped="$(git log "${base}..HEAD" --diff-filter=D --name-only --pretty=format: -- "$DIR" 2>/dev/null | head -1)"
+
+    if [ -n "$dropped" ]; then
+        {
+            printf 'РАБОТА ЗАКРЫВАЕТСЯ — папка задачи разобрана этой веткой.\n\n'
+            printf 'Ход работы удалён вместе с папкой: состояние держат заявка и передача захода.\n'
+            printf 'Папка заново не собирается. Правка кода после разбора требует восстановить её\n'
+            printf 'на время правки и повторить разбор тем же коммитом. Порядок — скил `task-flow`,\n'
+            printf 'паттерны `task-flow-close` и `task-flow-archive`.\n'
+        } | emit
+        exit 0
+    fi
+
     if rt_needs rt_task_branch_ok task-context-load && rt_task_branch_ok "$branch"; then
         {
             printf 'РАБОТА БЕЗ ПАПКИ ЗАДАЧИ.\n\n'

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

@@ -97,6 +97,15 @@ rt_task_flow_context() {
                 ' 2>/dev/null)"
                 [ -n "$rt_tf_inner" ] && rt_tf_cmd="$rt_tf_inner"
             fi
+            # Команда заведения задачи не судится вовсе. Она пишет папку задачи и карточку в
+            # очереди работ, а текст её несёт тело задачи целиком: цитата со знаком «больше»
+            # подходит под признак записи, путь к коду в прозе тела — под признак пути. Отбитая,
+            # она отбивается тем самым гардом, который печатает её в тексте своего отказа, и
+            # завести задачу становится нечем — ни с ветки закрытой задачи, ни с главной. Имя
+            # команды берётся у профиля дерева: своя копия разошлась бы с ним молча.
+            case "$rt_tf_cmd" in
+                *"${RT_TASK_NEW_CMD:-npm run task:new}"*) return 1 ;;
+            esac
             rt_needs rt_shell_writes task-flow-guard || return 1
             rt_needs rt_shell_paths task-flow-guard || return 1
             rt_shell_writes "$rt_tf_cmd" || return 1

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

@@ -89,4 +89,21 @@ if git -C "$root" log --oneline -1 -- "$draft" 2>/dev/null | grep -q .; then
     exit 0
 fi
 
+# Вливание бывает и первым коммитом, который вообще завёл названный путь: черновик писали, не
+# коммитя, а в историю уехал уже спек домена. Тогда истории у пути нет, а работа сделана ровно
+# так, как велит паттерн закрытия, — и отказ запирал бы ветку на последнем шаге. Признак:
+# договорённость названа путём вида `<домен>/proposed/<фича>`, каталог домена в дереве есть, и
+# имя фичи в нём встречается. Пока такого спека нет, отказ остаётся прежним.
+case "$draft" in
+    */proposed/*)
+        domain_dir="${draft%%/proposed/*}"
+        feature="${draft##*/proposed/}"
+        feature="${feature%/}"
+        if [ -n "$feature" ] && [ -d "$root/$domain_dir" ] \
+            && grep -rq -- "$feature" "$root/$domain_dir" 2>/dev/null; then
+            exit 0
+        fi
+        ;;
+esac
+
 deny "BLOCKED by task-flow: замысел называет договорённость '${draft}', а её на диске нет и в истории ветки не было. Заведи её с образца (docs/specs/_template) или поправь путь в '${tasks_dir}/${branch}/plan.md'. Правило — скил task-flow."

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

@@ -38,6 +38,27 @@
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
 rt_hook_read
+
+# Отказ печатается одной формой: причина, общий хвост о двух законных ходах и запасная строка
+# на случай, если разборщика нет. Прежде эти двенадцать строк стояли восемью копиями — файл рос
+# на каждом новом ярусе быстрее, чем на самом требовании.
+rt_te_deny() {
+    rt_te_reason="$1"
+    rt_te_short="$2"
+    # 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() { :; }
+    rt_te_tail="$(rt_deny_tail "")"
+    [ -n "$rt_te_tail" ] && rt_te_reason="${rt_te_reason}
+
+${rt_te_tail}"
+
+    jq -n --arg r "$rt_te_reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: %s"}\n' "$rt_te_short"
+    exit 0
+}
+
 input="$RT_HOOK_INPUT"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
@@ -97,20 +118,7 @@ if [ "$state" = "замысел-записан" ]; then
 
 Страж судит один ход: следующий заход не отбивается."
 
-    # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
-    # а причина отказа остаётся прежней.
-    # 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
+    rt_te_deny "$reason" "замысел записан, а первый этап не начат."
 fi
 
 # То же самое, но объявить это на диске уже нечем: папка задачи разбирается до открытия заявки,
@@ -277,18 +285,7 @@ if [ "$archived" != "true" ] && [ -z "$progress" ] && [ -n "$branch" ] && [ ! -d
 
 Страж судит один ход: следующий заход не отбивается."
 
-        # 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
+        rt_te_deny "$reason" "работа взята и не начата — напиши замысел."
     fi
 fi
 
@@ -327,20 +324,7 @@ EOF
 Запусти их этим же ходом либо верни прежний номер этапа в ход работы.
 
 Страж судит один ход: следующий заход не отбивается."
-        # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
-        # а причина отказа остаётся прежней.
-        # 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
+        rt_te_deny "$reason" "закрытый этап не подтверждён выводом команды."
     fi
 fi
 
@@ -363,18 +347,7 @@ if [ "$handed_over" = "true" ] && [ "$started_next" != "true" ]; then
 
 Страж судит один ход: следующий заход не отбивается."
 
-    # 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
+    rt_te_deny "$reason" "работа отдана, а следующая не начата."
 fi
 
 # Ход кончился ожиданием чужого шага. Работа в нём была — тем он и обманчив: полон, и пустоты за
@@ -390,18 +363,7 @@ if [ "$waited" = "true" ]; then
 
 Страж судит один ход: следующий заход не отбивается."
 
-    # 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
+    rt_te_deny "$reason" "ход кончился ожиданием чужого шага."
 fi
 
 # Общий рубеж. Работа за ход была — но последним действием стал не она, а текст владельцу.
@@ -417,18 +379,26 @@ if [ "$worked" = "true" ] && [ "$ended_working" != "true" ]; then
 
 Страж судит один ход: следующий заход не отбивается."
 
-    # 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}
+    rt_te_deny "$reason" "последним действием хода стала не работа."
+fi
 
-${deny_tail_text}"
+# Работа, оставшаяся в рабочем дереве. Ветка ушла вперёд своей удалённой ссылки, а заявки при
+# ней в этом ходе не открывали: сделанное лежит там, где его не видит никто, кроме сделавшего.
+# Признак читается без сети и молчит там, где ссылки нет вовсе — под пробу заводят и такие ветки.
+# Разбор — `docs/postmortems/2026-08-25-fifteen-branches-over-one-index.md`.
+if [ "$worked" = "true" ] && [ "$handed_over" != "true" ]; then
+    unpushed="$(git -C "$root" rev-list --count '@{u}..HEAD' 2>/dev/null)"
+    if [ -n "$unpushed" ] && [ "$unpushed" -gt 0 ] 2>/dev/null; then
+        reason="BLOCKED by turn-exit-guard: за ход была работа, но она осталась в рабочем дереве — неотданных коммитов ${unpushed}.
 
-    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
-        || printf '{"decision":"block","reason":"turn-exit-guard: последним действием хода стала не работа."}\n'
-    exit 0
+Владелец видит прежнее состояние и читает его как «не сделано ничего». Ходов отсюда два: довести работу до хостинга — запушить ветку и открыть заявку — либо снять сделанное, если оно не нужно.
+
+Оставшееся в дереве называется причиной — словом владельца, а не списком остатков.
+
+Страж судит один ход: следующий заход не отбивается."
+
+        rt_te_deny "$reason" "работа осталась в рабочем дереве."
+    fi
 fi
 
 [ "$worked" = "true" ] && exit 0
@@ -463,18 +433,6 @@ else
 Страж судит один ход: следующий заход не отбивается."
 fi
 
-# Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
-# а причина отказа остаётся прежней.
-# 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'
+rt_te_deny "$reason" "работа не кончена — следующий шаг стоит в ходе работы."
 
 exit 0

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

@@ -69,13 +69,20 @@ moved_re='task:new|task:move|checkout[[:space:]]+-b|docs/tasks/'
 # следующая задача была взята вместо этого, а не сверх этого.
 ready_re='pr[[:space:]]+ready|run[[:space:]]+(list|view|watch)|pr[[:space:]]+checks|check-runs|check:board|board\.mjs'
 
+# Своё названное действие. Пустой ход, объявивший, что сделает дальше, ничем себя не выдаёт:
+# заявку он не открывал, прогона не читал, и оба прежних признака молчат. Ловится он формой —
+# набором образцов будущего времени о собственном шаге, — а не пониманием смысла; за словами
+# при этом не должно стоять ни одного вызова, иначе объявление сказано по ходу работы, а не
+# вместо неё.
+vow_re='дальше беру|дальше возьму|дальше иду|следующим шагом|следующий шаг:|затем сделаю|затем возьму|потом сделаю|после этого сделаю|далее беру'
+
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью, поэтому строки с `tool_result` вводом не считаются.
 #
 # Хвост в 400 строк: запись хода растёт всю сессию, а судится только последний ход.
 verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
     --arg opened "$opened_re" --arg moved "$moved_re" --arg read "$read_re" --arg red "$red_re" \
-    --arg ready "$ready_re" '
+    --arg ready "$ready_re" --arg vow "$vow_re" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -98,13 +105,69 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
     | (($ran | test($read; "i")) and ($out | test($red; "i"))) as $red_run
     | ($ran | test($moved; "i")) as $went_on
     | ($ran | test($ready; "i")) as $checked
-    | if $opened_pr and ($went_on | not) then "owe:pr"
+    | ([$turn[] | select(.type == "assistant") | (.message.content // [])[]
+          | select(.type == "text") | .text] | join("\n")) as $said
+    | ($said | test($vow; "i")) as $announced
+    | ($uses | length) as $tools
+    | if $opened_pr and ($went_on | not) and ($checked | not) then "owe:both"
+      elif $opened_pr and ($went_on | not) then "owe:pr"
       elif $opened_pr and ($checked | not) then "owe:draft"
       elif $went_on then "pass"
       elif $red_run then "owe:run"
+      elif $announced and $tools == 0 then "owe:vow"
       else "pass" end
 ' 2>/dev/null)"
 
+# Ни одного из двух действий: отказ называет оба разом. Прежде он называл только первое, и
+# снимался тоже первым — исполнитель брал следующую задачу, признак открытой заявки уходил
+# вместе с ходом, и второе требование испарялось, ни разу не прозвучав.
+if [ "$verdict" = "owe:both" ]; then
+    reason="BLOCKED by waiting-turn-guard: в этом ходе открыт PR, а по отданной работе не сделано ни одного из двух действий — ни состояние её не спрошено, ни следующая задача не взята.
+
+Действий именно два, и снять отказ одним нельзя: отданное доводится до снятого черновика тем, кто его отдал, а следующая берётся сверх этого, а не вместо. Взятая следующая уносит признак открытой заявки с собой — второе требование после неё не прозвучит уже никогда.
+
+    gh run list                                # состояние отданного
+    npm run task:new -- <заголовок>            # следующая работа
+
+Гард судит один ход: следующий заход не отбивается."
+
+    # 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":"waiting-turn-guard: по отданной работе не сделано ни одного из двух действий."}\n'
+    exit 0
+fi
+
+# Ход, объявивший своё следующее действие и не сделавший по нему ничего. Отказ называет само
+# объявление: исполнитель, которому сказано «ход пуст», перепишет слова, а не сделает шаг.
+if [ "$verdict" = "owe:vow" ]; then
+    reason="BLOCKED by waiting-turn-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":"waiting-turn-guard: следующее действие названо словами, а за ход не сделано ничего."}\n'
+    exit 0
+fi
+
 # Черновик, оставленный при взятой следующей задаче, — отдельный отказ: там требование не про
 # следующую задачу, а про доведение отданной.
 if [ "$verdict" = "owe:draft" ]; then