@rt-tools/agent-kit 0.16.1 → 0.18.0

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
 
 # То же самое, но объявить это на диске уже нечем: папка задачи разбирается до открытия заявки,
@@ -145,7 +153,14 @@ 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:]]*[^|&]'
+#
+# Перенаправления вывода здесь нет, и снято оно по разбору: страж отбил два хода из семи,
+# простоявших без работы, а пять засчитал работой ровно по нему. Тело будущей заявки писалось во
+# временный каталог захода — вне рабочего дерева, — а одно из ожиданий несло только отвод потока
+# ошибок в устройство пустоты. Ни то ни другое дерева не меняет, а образцу они были неотличимы
+# от записи в рабочий файл: он видел саму стрелку и не спрашивал, куда она ведёт. Признаком
+# остаются правка файла инструментом правки и перечисленные здесь команды.
+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 '
 
 # Разведка. Те же слова, что и в образце работы, но подкоманда читающая: переключение ветки,
 # подтягивание, просмотр истории, чтение заявок и прогонов. Образец работы называет их работой,
@@ -270,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
 
@@ -320,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
 
@@ -356,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
 
 # Ход кончился ожиданием чужого шага. Работа в нём была — тем он и обманчив: полон, и пустоты за
@@ -383,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
 
 # Общий рубеж. Работа за ход была — но последним действием стал не она, а текст владельцу.
@@ -410,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
@@ -456,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

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

@@ -180,7 +180,11 @@ reason="BLOCKED by window-fill-guard: заполнение окна ${pct}% (${f
 2. Закоммить проверенное: незакоммиченное не переживёт перерыв.
 3. Напиши передачу в ${handoff_dir}/ и отдай владельцу путь к ней — что в неё входит, говорит паттерн task-flow-handoff.
 
-Пропускаются при этом: правка ${tasks_dir}/**, запись передачи, команды поставки и сверки, чтение файлов и вопрос владельцу."
+Что после порога проходит:
+- правка ${tasks_dir}/** и ${handoff_dir}/**, чтение любого файла, вопрос владельцу;
+- команда, начинающаяся со слова поставки или сверки: git, клиент хостинга, перевод колонки, npm run check:*.
+
+Команда судится по началу строки: вход в каталог перед ней снимает совпадение, и отбит будет тот же коммит, который прошёл бы без него. Начинай команду с самого слова поставки."
 
 # Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.
 # Файл может быть не разложен — тогда хвоста нет, а причина отказа остаётся прежней.

package/assets/hooks/work-start-guard.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# rt-hook: Stop
+# Требует: hooks/deny-tail.sh, hooks/profile-check.sh
+# Гард начала работы: ход, правивший код приложения, не заканчивается, пока владелец в этом же
+# ходе о работе не просил. Stop.
+#
+# Зачем именно так. Статья «заход работу не начинает сам» держится памятью исполнителя, и
+# держится плохо: заход, открывшийся после чистки контекста, получает от хука запуска состояние
+# незаконченной работы и замысел с этапами — и оба говорят, что делать, если работать. О том,
+# работать ли, не говорит ни один. Строка с путём к файлу, присланная владельцем, прочитана как
+# поручение, и заход правит полсотни файлов, которых у него никто не просил.
+#
+# Соседние гарды этого не ловят, и не по недосмотру: каждый судит своё. Гард замысла требует
+# замысел на диске — он лежит; гард эпика отбивает чужую задачу — задача своя; гард разговора
+# судит ход, в котором задан вопрос, — а вопроса не задали ровно потому, что решили не
+# спрашивать. Все три судят предмет правки и её порядок, и ни один не спрашивает, кто эту
+# правку заказал.
+#
+# Просьба ловится формой, а не смыслом. Смысл машине не виден, и гард, взявшийся его понимать,
+# отбивал бы работу по настроению; поэтому судится обратное — то, что просьбой не бывает ни при
+# каком прочтении: пустая реплика, одно слово и путь к файлу. Всё остальное считается просьбой,
+# и это выбрано намеренно: ложный отказ здесь стоит дороже пропуска — он останавливает работу,
+# которую владелец заказал.
+#
+# Код приложения узнаётся признаком дерева `rt_is_app_code` — тем же, которым его узнаёт гард
+# замысла. Дерево, признака не объявившее, этого гарда не получает: судить ему нечем.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет `jq`, нет записи хода, нет признака дерева, повторный заход, любая
+# своя ошибка — ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
+
+rt_hook_read
+input="$RT_HOOK_INPUT"
+[ -z "$input" ] && exit 0
+
+command -v jq >/dev/null 2>&1 || exit 0
+
+# Повторный заход по тому же ходу не судится: гард сказал своё один раз и отпускает.
+active="$(printf '%s' "$input" | jq -r '.stop_hook_active // false' 2>/dev/null)"
+[ "$active" = "true" ] && exit 0
+
+transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)"
+[ -z "$transcript" ] && exit 0
+[ -f "$transcript" ] || exit 0
+
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+for profile in "$rt_hooks_dir/../rt-kit/defaults/project.sh" "$rt_hooks_dir/../defaults/project.sh" \
+    "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/profile-check.sh" ] && . "$rt_hooks_dir/profile-check.sh"
+command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2>&1; }
+rt_needs rt_is_app_code work-start-guard || exit 0
+
+# Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
+# приходит той же ролью, поэтому строки с `tool_result` вводом не считаются.
+#
+# Хвост в 400 строк: запись хода растёт всю сессию, а судится только последний ход.
+asked="$(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].message.content
+         | if type == "string" then .
+           elif type == "array" then (map(if type == "object" then (.text // "") else tostring end) | join("\n"))
+           else "" end)
+      end
+' 2>/dev/null)"
+
+# Ввода в записи нет вовсе — судить нечего: ход разрешается.
+[ -z "$asked" ] && exit 0
+
+# Правленные за ход файлы: инструменты правки называют путь полем, а команда оболочки — своим
+# разбором, и его здесь нет намеренно. Гард судит явную правку файла: команда, пишущая в код
+# мимо инструмента правки, остаётся его известной границей.
+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:] end)
+    | [.[] | select(.type == "assistant") | (.message.content // [])[]
+        | select(.type == "tool_use")
+        | select(.name == "Edit" or .name == "Write" or .name == "MultiEdit" or .name == "NotebookEdit")
+        | (.input.file_path // .input.notebook_path // empty)]
+    | unique | .[]
+' 2>/dev/null)"
+
+[ -z "$edited" ] && exit 0
+
+touched=""
+while IFS= read -r path; do
+    [ -z "$path" ] && continue
+    if rt_is_app_code "$path" 2>/dev/null; then
+        touched="$path"
+        break
+    fi
+done <<EOF
+$edited
+EOF
+
+# Код приложения за ход не правился: гард молчит. Разбор, тексты и обвязка идут своим ходом —
+# требовать слова владельца на них значило бы запретить разведку до просьбы.
+[ -z "$touched" ] && exit 0
+
+# Просьбой не бывает ни при каком прочтении: пустая реплика, одно слово, путь к файлу. Судится
+# первая непустая строка ввода: развёрнутая просьба своей первой строкой уже просьба, а путь,
+# присланный один, ею не станет и дальше.
+first="$(printf '%s' "$asked" | tr -d '\r' | sed -n '/[^[:space:]]/{p;q;}')"
+words="$(printf '%s' "$asked" | tr -s '[:space:]' '\n' | grep -c '[^[:space:]]' 2>/dev/null || echo 0)"
+
+case "$first" in
+    # Служебная отметка о прерывании: своей просьбы в ней нет.
+    '[Request interrupted'*) kind="прерывание" ;;
+    *)
+        if [ "$words" -le 1 ] 2>/dev/null; then
+            case "$first" in
+                */*) kind="путь к файлу" ;;
+                *) kind="одно слово" ;;
+            esac
+        else
+            kind=""
+        fi
+        ;;
+esac
+
+# Просьба в ходе есть: работа заказана, и гард отпускает.
+[ -z "$kind" ] && exit 0
+
+reason="BLOCKED by work-start-guard: за ход правился код приложения — «${touched}», — а последняя реплика владельца просьбой не была: ${kind}.
+
+Заход работу не начинает сам. Передача прошлого захода, состояние задачи из хука запуска и назначенный эпик говорят, что делать, если работать, и молчат о том, работать ли. Строка с адресом называет файл, а не действие: прочитанная как поручение, она даёт заходу задание, которого владелец не давал.
+
+Ход отсюда один: назови владельцу состояние работы и спроси, продолжать ли, — и дождись ответа. Сделанное этим ходом не откатывается само: скажи, что уже правлено.
+
+Гард судит один ход: следующий заход не отбивается."
+
+# Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+# а причина отказа остаётся прежней.
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/deny-tail.sh" ] && . "$rt_hooks_dir/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":"work-start-guard: код правился, а просьбы владельца в этом ходе не было."}\n'
+
+exit 0

package/assets/hooks/write-targets.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Цели записи, названные командой оболочки прямо: перенаправление, `tee`, правка на месте,
+# копирование поверх. Печатает по одной в строке.
+#
+# Строки `# rt-hook:` здесь нет намеренно: это помощник, а не хук. Он ничего не решает сам и
+# зовётся оттуда, где судят правку файла, — гардом места правки и гардом экзамена. Общий он
+# потому, что признак записи у обоих один и тот же: разойдясь, две копии пропустили бы разные
+# формы записи, и заметить это было бы нечем.
+#
+# Общий признак записи здесь не берётся намеренно — он широк, в нём и имя интерпретатора, и
+# запуск разложенной проверки читался бы как правка её самой. Снятие копии сюда тоже не входит:
+# снятый файл раскладка кладёт заново, и так чинят копию, которую переписал форматтер.
+
+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
+}

package/assets/laws/delivery.md

@@ -27,6 +27,20 @@
   Правка одного рода остаётся одной задачей, сколько бы файлов она ни задела; объём захода
   говорит, какого размера задачу заводить среди тех, что делятся законно, и делить неделимое не
   даёт.
+- **Работы, идущие одна за другой, ветвятся одна от другой.** Ветка следующей отводится от
+  предыдущей, а не от главной: тогда правка предыдущей лежит в общем предке, и сводить два разных
+  изменения одного файла уже не нужно. Ветки, заведённые от главной подряд, друг о друге не знают,
+  и первое же слияние делает остальные расходящимися — тем вернее, чем ближе работы по предмету:
+  расходятся не сами правки, а строки, куда обе дописали. Цена не исчезает, а переносится: платит
+  её тот, кто ветвится, один раз — вместо того, кто вливает, столько раз, сколько заявок открыто.
+  От главной ветвится первая работа череды и всякая, не связанная с предыдущей.
+- **Череда веток отдаётся снизу вверх, и порядок называется владельцу.** Заявка каждой стоит на
+  предыдущей, а не на главной, поэтому влитая не по порядку тащит за собой всё, что под ней.
+  Порядок известен тому, кто ветвился, и не виден тому, кто вливает: несказанный, он читается как
+  его отсутствие.
+- **Ветка, стоящая под другой, историю не переписывает.** Силовая отправка нижней делает вершину
+  верхней достижимой из её основания, и хостинг закрывает заявку верхней как слитую — при том что
+  в главной ветке её правок нет. Расхождение чинится вливанием, а не переносом истории.
 - **Правка самой поставки проверяется её прогоном, а не рассуждением.** Проверить её иначе нечем:
   она исполняется только там, где выкатывает, и в среде, которой на месте работы нет — с чужими
   правами, чужим хранилищем ключей и чужой сетью. «Проверю после слияния» решением исполнителя не
@@ -60,6 +74,11 @@
 - **Признак режима исполнения объявлен в самом артефакте развёртывания, а не только в составе его
   запуска.** Артефакт поднимают и мимо состава — руками, при разборе, на чужой машине, — и без
   объявления он в этот момент считает себя отладочным, не сказав об этом ничего.
+- **Артефакт развёртывания несёт всё, чем настраивается запускаемое им.** Сборка проверяет, что
+  артефакт собрался, а не что его собственные шаги запуска исполнимы: недостающий файл настройки
+  не виден ни линтеру, ни сборке, ни шагу сборки образа в конвейере — он отказывает на первом
+  подъёме, то есть уже там, куда выкатили. Файл, лежащий рядом в репозитории, внутрь артефакта
+  сам не попадает.
 - **Выкатывается образ того коммита, который выкатывают.** Умолчание «последний» отстаёт от
   главной ветки, и приложение молча возвращается к прежней версии, продолжая отвечать.
 - **Из одного и того же коммита всегда ставятся одни и те же зависимости.** Если версия задана

package/assets/laws/frontend-application.md

@@ -18,6 +18,10 @@
 - **Оформление берётся из общего набора значений, а не пишется числом на месте.** Написанное
   числом расходится с остальным при первой же смене оформления, и найти все такие места
   нечем.
+- **Управляющий элемент не меняет размер, пока идёт начатая им работа.** Готовые наборы
+  элементов на время работы подменяют подпись и значок индикатором ожидания, и элемент
+  сжимается до собственных отступов: он прыгает, сдвигает соседей, а нажатие, которое человек
+  уже начал, уходит мимо.
 - **У каждого класса в разметке есть своё правило стилей.** Класс без правила выглядит
   рабочим и молча ничего не делает.
 - **Набор записей приходит с сервера страницей, а не целиком.** Список, растущий вместе с

package/assets/laws/verifiability.md

@@ -16,6 +16,17 @@
   человек его видит, лежит всё, чего проверка не касалась.
 - **Тест, выключенный признаком окружения, покрытием не считается.** В обычном прогоне он не
   исполняется ни разу, а в сводке выглядит так же, как исполненный.
+- **Тест, снимающий себя по тому, что застал на экране, покрытием не считается.** Набор, идущий
+  одной сессией, несёт состояние из теста в тест, и проверка, начинающаяся с «нужного на экране
+  нет — пропускаю», снимает себя от чужой правки, а не от своего окружения. В сводке это одна
+  строка про пропуск, а стоит за ней целая возможность.
+- **Тест приводит экран в нужное ему состояние сам и возвращает общее состояние таким, каким
+  застал.** Иначе снявшийся тест держится ровно до следующей правки соседа, а прогон называет
+  ноль падений и в тот день, когда проверка не исполнялась ни разу.
+- **Проговорённый список проверок проверкой не бывает.** Он называет замысел, а не то, что
+  ушло в команду, и оба текста пишутся одним ходом, не сверяясь друг с другом: список, названный
+  пункт за пунктом, от короткого «я проверил» отличается только длиной. Проверка — чтение
+  полученного: вывода команды, отданного текста, состояния после вызова.
 - **Упоминание в тесте сценария, которого нет, — отказ.** Так ловится переименованный или
   выкинутый сценарий: без этого он пропадает молча.
 - **Работающее приложение проверяется там, где его видит пользователь.** Отладочный режим ведёт
@@ -37,6 +48,16 @@
   Сообщение о готовности говорит лишь, что служба себя объявила: та, которой не досталось ни
   одного задания, выглядит в нём точно так же, как работающая. Проверяются обе стороны связи — что
   заказчик выбирает именно её и что задание через неё прошло.
+- **У обмена спрашивают обе стороны, и сторона, которой нет, называется прямо.** Односторонний
+  обмен выглядит рабочим с обеих сторон: отправляющая получает успех на каждый вызов, а того, что
+  прочитать результат нечем, не видно ниоткуда — молчание об отсутствующей стороне неотличимо от
+  работающего обмена. Поэтому у обмена спрашивают не «прошёл ли вызов», а «читает ли кто-нибудь
+  вторую сторону», и ответ «нечем» записывается словом, а не остаётся пробелом.
+- **Значение, объявленное одной стороной обмена, второй не пересчитывается, а берётся у первой.**
+  Две копии одного счёта расходятся молча, и обе стороны при этом отвечают успехом: одна шлёт под
+  одним значением, другая ищет под другим, и не находит ничего ни разу. Что именно объявлено —
+  признак, форма записи, способ счёта ключа — берётся у объявившей стороны целиком, а не
+  повторяется по её описанию.
 - **Причина отказа, на которой строится решение, подтверждается измерением, а не правдоподобием.**
   Объяснение, пришедшее первым, объясняет наблюдаемое не хуже верного: свойство среды и
   собственный промах выглядят в отказе одинаково, и разводит их только замер, поставленный так,
@@ -65,3 +86,26 @@
 - **Решение, зависящее от текущего момента, получает момент снаружи.** Иначе проверить его можно
   только подкруткой часов, а подкрученные часы действуют и на всё, что оказалось рядом: проверка
   начинает зависеть от того, что к ней отношения не имеет.
+- **Признак проверки выбирается по вопросу, на который отвечают, а не по тому, что задела
+  правка.** Признак, снятый с предмета правки, отвечает про неё же: правка собирала адрес — и
+  наличие адреса в отданной странице подтверждает, что приложение его собрало, а не что по нему
+  что-то приедет. Спрашивают при этом «показывается ли», и разницы между двумя ответами не видно
+  ни в одном выводе: оба выглядят как «проверено». Признак поэтому называется вместе с вопросом,
+  и первым проверяется, что он на этот вопрос отвечает.
+- **Чужой отказ называет своё состояние, а не причину на своей стороне.** Ответ внешней службы
+  говорит, чем кончился запрос у неё; что лежит в настройке, которую она читала, он не говорит
+  никогда — и достроенное из него утверждение выглядит выводом из наблюдения, которого не было.
+  Значение, о котором идёт речь, читается там, где оно лежит, а решение, выведенное из
+  непроверенной причины, наружу не выносится вовсе: оно просит чинить не то.
+- **Про прошлое поведение отвечает код той версии, о которой спрашивают.** Тело правки говорит,
+  что она сменила, и молчит о том, что было верно до неё: условие, в которое дописано ещё одно
+  обязательное значение, гасит показанное раньше — и видно это только сравнением с версией до
+  правки, а не чтением самой правки. Слово того, кто видел прежнее поведение своими глазами, —
+  показание: расхождение между ним и текстом в истории разбирается чтением кода на его стороне
+  расхождения.
+- **Проверка, снятая с набора ради того, чтобы прогон прошёл, работу не подтверждает.** Набор
+  собирается умолчанием и надстройкой дерева, и выкушенная надстройкой проверка ничем не отличима
+  от той, которой в дереве нет вовсе: прогон зелен потому, что её никто не звал. Соседняя статья
+  судит место, выведенное из-под проверки, — здесь выведено не место, а вся она, и следа в коде
+  не остаётся никакого. Расхождение закрывается тем, на что проверка указала, а несогласие с ней
+  самой — вопрос к владельцу.