@rt-tools/agent-kit 0.9.0 → 0.10.0

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

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+# rt-hook: Stop
+# Требует: hooks/deny-tail.sh
+# Страж выходов хода: ход, в котором по работе не сделано ничего, не заканчивается, пока работа
+# не отдана. Stop.
+#
+# Зачем именно так. Правило перечисляет четыре законных выхода хода — вопрос без ответа в
+# правилах, отказ гарда, заполненное окно, отданная работа с начатой следующей, — и держится
+# это памятью исполнителя. Держится плохо: ход, кончившийся отчётом о сделанном, выглядит
+# работой лучше всякой другой — он полон, в нём названы номера и состояния, и пустоты за ним не
+# видно ни владельцу, ни самому заходу. Владелец назвал это прямо: прерываться посреди работы
+# нельзя, и запрет должна держать машина.
+#
+# Что считается работой: правка файла и команда, меняющая дерево или его состояние. Чтение,
+# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал.
+#
+# Что отпускает ход:
+#   1. Работа отдана либо влита — состояние работы говорит об этом само.
+#   2. За ход была работа: правка файла или команда, меняющая дерево.
+#   3. Вопрос владельцу инструментом опроса.
+#   4. Отказ гарда — он кончает ход по правилу.
+#   5. Передача захода написана — окно кончилось.
+#   6. Владелец сказал остановиться.
+#
+# Чего страж не судит. Заход вне ветки задачи и работу без папки: состояние там объявлять
+# негде, и отбивать было бы не за что. Это его известная граница.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода, папки задачи
+# или строки состояния ход РАЗРЕШАЕТСЯ (exit 0). Сломанный страж не имеет права заклинить
+# разговор.
+
+input="$(cat 2>/dev/null)"
+[ -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
+
+workdir="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
+[ -z "$workdir" ] && workdir="${CLAUDE_PROJECT_DIR:-.}"
+cd "$workdir" 2>/dev/null || exit 0
+git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
+
+branch="$(git branch --show-current 2>/dev/null)"
+[ -z "$branch" ] && exit 0
+
+root="$(git rev-parse --show-toplevel 2>/dev/null)"
+[ -z "$root" ] && exit 0
+tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
+progress="$root/$tasks_dir/$branch/progress.md"
+[ -f "$progress" ] || exit 0
+
+state="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Состояние:\*\*[[:space:]]*`\([^`]*\)`.*/\1/p' "$progress" 2>/dev/null | head -1)"
+[ -z "$state" ] && exit 0
+
+# Работа, дошедшая до этих двух состояний, чужого шага уже дождалась: дальше её двигает
+# владелец, и ход, закрытый здесь, ничего не роняет.
+case "$state" in
+    работа-отдана | влито) exit 0 ;;
+esac
+
+# Следующий шаг из хода работы — его страж и называет в отказе: исполнитель, которому сказано
+# только «работа не кончена», перечитывает ту же строку сам.
+next_step="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Следующий шаг:\*\*[[:space:]]*\(.*\)/\1/p' "$progress" 2>/dev/null | head -1)"
+[ -z "$next_step" ] && next_step="что стоит в разделе «Где стоим» хода работы"
+
+# Команда, меняющая дерево или его состояние. Чтение и поиск сюда не входят намеренно: ими и
+# заполняется ход, который встал.
+work_re='git (add|commit|push|checkout|merge|rm)|npm run|pnpm (run|exec)|nx (build|test|run)|gh (pr|issue|api|run)|task:(new|move)|mkdir|cp |mv |rm |sed -i|tee |>>?[[:space:]]*[^|&]'
+
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re" '
+    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) as $turn
+    | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "tool_use")] as $uses
+    # Правка файла — работа по определению, каким бы инструментом она ни шла.
+    | ($uses | map(.name // "") | any(test("^(Edit|Write|MultiEdit|NotebookEdit)$"))) as $edited
+    | ($uses | map(.name // "") | any(test("AskUserQuestion"))) as $asked
+    | ($uses | map((.input.command // "")) | join("\n")) as $ran
+    | ($ran | test($work)) as $ran_work
+    # Отказ гарда и передача захода — оба кончают ход по правилу.
+    | ([$turn[] | select(.type == "user") | .message.content // [] | select(type == "array") | .[]
+          | select(.type == "tool_result") | .content
+          | if type == "string" then .
+            elif type == "array" then (map(if type == "object" then (.text // "") else tostring end) | join("\n"))
+            else tostring end] | join("\n")) as $out
+    | (($out | test("BLOCKED by|Отбито гейтом")) or ($ran | test("BLOCKED by"))) as $denied
+    | ($ran | test("handoff")) as $handed
+    # Слово владельца об остановке: судится его собственная реплика, а не пересказ исполнителя.
+    | ([$turn[] | select(.type == "user") | .message.content
+          | if type == "string" then . elif type == "array"
+            then (map(if type == "object" then (.text // "") else "" end) | join("\n")) else "" end] | join("\n")) as $said
+    | ($said | test("останов|стоп|хватит|подожди|не надо|прерв|отложи")) as $told_stop
+    | { worked: ($edited or $ran_work), released: ($asked or $denied or $handed or $told_stop), ran: $ran }
+' 2>/dev/null)"
+
+[ -z "$verdict" ] && exit 0
+
+worked="$(printf '%s' "$verdict" | jq -r '.worked // false' 2>/dev/null)"
+released="$(printf '%s' "$verdict" | jq -r '.released // false' 2>/dev/null)"
+commands="$(printf '%s' "$verdict" | jq -r '.ran // ""' 2>/dev/null)"
+
+[ "$released" = "true" ] && exit 0
+
+# Контракт этапа. Отметка «этап сделан» — утверждение о дереве, и подтверждается оно выводом
+# команды, а не словами: этап, отмеченный по памяти, через заход неотличим от проверенного.
+# Страж сравнивает номер этапа с тем, что лежит в истории ветки, и на выросшем номере требует
+# команды из строки «Чем проверяется» — она стоит в замысле обратными кавычками. Приём, записанный
+# прозой, страж не читает: подтвердить его выводом нечем, и это его известная граница.
+stage_now="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$progress" 2>/dev/null | head -1)"
+stage_was="$(git -C "$root" show "HEAD:$tasks_dir/$branch/progress.md" 2>/dev/null | sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Этап:\*\*[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -1)"
+
+if [ -n "$stage_now" ] && [ -n "$stage_was" ] && [ "$stage_now" -gt "$stage_was" ] 2>/dev/null; then
+    plan="$root/$tasks_dir/$branch/plan.md"
+    # Контракт закрытого этапа, а не начатого: подтверждается то, что объявлено сделанным.
+    contract="$(awk -v n="$stage_was" '
+        $0 ~ "^### " n "\\." { inside = 1; next }
+        /^### / { inside = 0 }
+        inside && /\*\*Чем проверяется:\*\*/ { print }
+    ' "$plan" 2>/dev/null)"
+    missing=""
+    while IFS= read -r cmd; do
+        [ -z "$cmd" ] && continue
+        printf '%s' "$commands" | grep -qF -- "$cmd" || missing="$missing\n    $cmd"
+    done <<EOF
+$(printf '%s' "$contract" | grep -o '`[^`]*`' | tr -d '`')
+EOF
+    if [ -n "$missing" ]; then
+        reason="BLOCKED by turn-exit-guard: этап ${stage_was} объявлен закрытым, а команды, которыми он проверяется, за этот ход не запускались:$(printf '%b' "$missing")
+
+Отметка «этап сделан» — утверждение о дереве, и подтверждается оно выводом команды, а не словами: через заход отмеченное по памяти неотличимо от проверенного.
+
+Запусти их этим же ходом либо верни прежний номер этапа в ход работы.
+
+Страж судит один ход: следующий заход не отбивается."
+        # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+        # а причина отказа остаётся прежней.
+        # shellcheck disable=SC1090
+        [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+            && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+        command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+        deny_tail_text="$(rt_deny_tail "")"
+        [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+        jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+            || printf '{"decision":"block","reason":"turn-exit-guard: закрытый этап не подтверждён выводом команды."}\n'
+        exit 0
+    fi
+fi
+
+[ "$worked" = "true" ] && exit 0
+
+reason="BLOCKED by turn-exit-guard: работа в состоянии '${state}', а за этот ход по ней не сделано ничего — ни правки, ни команды, меняющей дерево.
+
+Ход кончается четырьмя способами, и других нет: вопрос владельцу, ответа на который в правилах нет; отказ гарда; заполненное окно захода; отданная работа с начатой следующей. Отчёт о сделанном выходом не является — он выглядит работой лучше всякой другой, и пустоты за ним не видно.
+
+Следующий шаг записан в ходе работы: ${next_step}
+
+Сделай его этим же ходом. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+# Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+# а причина отказа остаётся прежней.
+# shellcheck disable=SC1090
+[ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+    && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+deny_tail_text="$(rt_deny_tail "")"
+[ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+    || printf '{"decision":"block","reason":"turn-exit-guard: работа не кончена — следующий шаг стоит в ходе работы."}\n'
+
+exit 0

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: Stop
+# Требует: hooks/deny-tail.sh
 # Гард ожидания: ход, сообщающий владельцу о чужом шаге, не заканчивается, пока в нём не было ни
 # одного действия по следующей задаче. Stop.
 #
@@ -110,6 +111,17 @@ reason="BLOCKED by waiting-turn-guard: ${said}, а действия по сле
 
 Гард судит один ход: следующий заход не отбивается."
 
+# Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+# а причина отказа остаётся прежней.
+# 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: PR открыт — тем же ходом берётся следующая задача."}\n'
 

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: PostToolUse .*
-# Требует: hooks/profile-check.sh
+# Требует: hooks/profile-check.sh, hooks/deny-tail.sh
 # rt-hook: PreToolUse .*
 # Заполнение окна: заход доводится до логической точки заранее, а не обрывается на середине.
 #
@@ -150,6 +150,17 @@ reason="BLOCKED by window-fill-guard: заполнение окна ${pct}% (${f
 
 Пропускаются при этом: правка ${tasks_dir}/**, запись передачи, команды поставки и сверки, чтение файлов и вопрос владельцу."
 
+# Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.
+# Файл может быть не разложен — тогда хвоста нет, а причина отказа остаётся прежней.
+# 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" \
     '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
     || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"window-fill-guard: окно заполнено, заход закрывается передачей."}}\n'

package/assets/patterns/task-flow-close.md

@@ -19,7 +19,7 @@ description: Паттерн правила task-flow. Брать при закр
 кода отдаётся владельцу, — то есть до этого паттерна и, как правило, задолго до него. Здесь
 работа доводится до готовности и черновик снимается.
 
-## 10. Работа отдаётся на разбор
+## Состояние `этапы-кончились`: работа отдаётся на разбор
 
 PR открыт черновиком — и с этой минуты работа ждёт владельца, а не машину. Заход на этом не
 кончается: следующая задача эпика берётся тем же движением, паттерн `task-flow-resume`.
@@ -102,7 +102,7 @@ PR #<номер> готов к слиянию: прогон зелёный, па
 кто пишет тело. Разница между ними одна, и она вся: реплику владелец прочитает, только если
 вернётся в переписку, а раздел он видит там, куда смотрит, нажимая кнопку.
 
-## 12. Договорённость вливается в спек домена
+## Состояние `разбор-кончился`: договорённость вливается в спек домена
 
 Последним коммитом PR, до слияния. Код к этому моменту написан, поэтому привязки
 `файл:символ` известны — правило въезжает в спек домена сразу проверяемым.
@@ -131,7 +131,7 @@ npm run check:specs   # раздел «Пора вливать» называе
 npm run check:specs   # после вливания: привязки на месте, сценарии не потерялись
 ```
 
-## 13. Тексты домена приводятся к сделанному
+## Состояние `разбор-кончился`: тексты домена приводятся к сделанному
 
 В спек уезжает только то, что записали до кода. Остальные тексты — правила, паттерны, законы
 приложения — после правки никто не перечитывает, и они продолжают описывать старое дерево.
@@ -172,7 +172,7 @@ grep -rn -A3 "Чего из закона здесь нет" <каталог пр
 Что сделали на этом шаге, пишется в тело PR: что перечитали, что изменили, а если ничего
 не изменили — почему. Форма раздела — паттерн `git-workflow-commit`.
 
-## 14. Папка задачи разбирается
+## Состояние `разбор-кончился`: папка задачи разбирается
 
 Разбор идёт по трём исходам, а не по двум.
 
@@ -229,7 +229,7 @@ rm -r docs/tasks/<своя>
 Две записи в архиве, а не одна: работы разные, и решения в них разные. Сверка очереди работ
 после этого не называет ни одной папки — этим и проверяется, что разобраны обе.
 
-## 15. Сверка
+## Состояние `папка-разобрана`: сверка очереди работ
 
 ```bash
 npm run check:board   # папка закрытой задачи среди текущих, брошенные черновики
@@ -237,7 +237,7 @@ npm run check:specs   # договорённость влита, привязк
 npm run check:docs    # пути, названные в текстах, существуют
 ```
 
-## 16. Работа разбирается правилами — фоном, следом за PR
+## Состояние `влито`: работа разбирается правилами — фоном, следом за PR
 
 Шаг о слое правил, а не о продукте: что за эту работу грузилось, что помогло, чего не хватило и
 где текст правила разошёлся с деревом. Знает это только тот заход, который работу вёл, — через
@@ -261,13 +261,13 @@ npm run check:docs    # пути, названные в текстах, суще
 3. **Вернувшиеся находки принимают одним ходом** — записать и вернуться к прежнему. Разбор,
    отложенный «до удобного момента», не случается вовсе: заход кончается раньше.
 
-## 17. Находки разбора ложатся в папку задачи и ждут владельца
+## Состояние `влито`: находки разбора ложатся в папку задачи и ждут владельца
 
 Ответ роли живёт в переписке и умирает вместе с ней, поэтому он сразу ложится на диск — в папку
 задачи, файлом рядом с ходом работы. Пишет его исполнитель: роль файлов не пишет.
 
 Папка задачи умирает со слиянием, а находки должны пережить весь эпик — владелец читает их
-разом, когда эпик кончился. Поэтому при разборе папки (шаг 14) файл находок не удаляется вместе
+разом, когда эпик кончился. Поэтому при разборе папки файл находок не удаляется вместе
 с остальным, а **переезжает к замыслу эпика**: там его найдут и после того, как ветка въехала.
 Работа вне эпика показывает находки владельцу сразу, тем же ходом.
 

package/assets/patterns/task-flow-handoff.md

@@ -41,7 +41,7 @@ description: Паттерн правила task-flow. Брать, когда з
 Незакрытый этап — тоже законная точка, если в ходе работы записано, что именно из него сделано и
 чем это подтверждено. Незаконная точка одна: правка, о которой не записано ничего.
 
-## 9. Заход закрывается передачей
+## Заход закрывается передачей, состояние работы при этом не меняется
 
 Уборку этого шага — главную ветку, влитые ветки и запись самой передачи — делает команда
 `next-session`: она проходит его целиком и называет путь к передаче последней строкой. Ниже —

package/assets/patterns/task-flow-resume.md

@@ -34,7 +34,27 @@ description: Паттерн правила task-flow. Брать при возв
   ней проверяется деревом — сборкой, тестами, чтением файла, — а не вопросом.
 - **Не править замысел.** С ним сверяют результат; пересмотр идёт записью в ходе работы.
 
-## 7. Возвращение к работе новым заходом
+## Вход из передачи захода
+
+Передача написана прошлым заходом и лежит вне дерева. Её читают как задание — и берутся за
+работу мимо правила: состояние не сверено, правило не загружено, числа взяты на веру. Отличие
+входа из передачи от обычного захода одно: всё, что в ней написано, проверяется деревом, потому
+что писалась она вчера.
+
+Порядок короткий, четыре шага:
+
+1. **Правило ведения работы и этот паттерн — первым движением**, до первой реплики владельцу.
+2. **Ветка и состояние работы читаются в дереве**, а не в передаче: `git branch --show-current`
+   и строка состояния в ходе работы. Разошлось с передачей — верно дерево.
+3. **Числа из передачи пересчитываются** на текущем коммите. Оценка «работы вдвое больше» при
+   пересчёте не подтвердилась ни разу.
+4. **Следующий шаг берётся из хода работы**, а не из раздела передачи о нём: ход работы
+   коммитится, передача — нет, и разойтись они успевают за один заход.
+
+Чего в передаче нет и не будет: слов владельца — они в разборе просьбы; решений с причинами —
+они в ходе работы; замысла — он на диске. Передача пересказывает, а не заменяет.
+
+## Вход в заход: строка состояния сверяется с деревом
 
 Сверить «Где стоим» с деревом. Запись описывает день, когда её сделали:
 
@@ -44,9 +64,11 @@ git log --oneline origin/main..HEAD
 ```
 
 Разошлось — «Где стоим» правится сразу, до работы: следующий заход поверит записи, а не
-дереву.
+дереву. Строка состояния правится вместе с ним: гард читает её, и оставленная от прошлого
+захода она либо отбивает законную правку, либо пропускает работу, которая до правки кода ещё
+не дошла.
 
-## 8. Этап делается и отмечается в ходе работы
+## Состояние `этап-идёт`: этап делается и отмечается в ходе работы
 
 Раздел «Где стоим» **перезаписывается**, а не дописывается — это первое, что читает следующий
 заход, и единственное, что переживает обрезку по объёму:
@@ -54,6 +76,7 @@ git log --oneline origin/main..HEAD
 ```markdown
 ## Где стоим
 
+- **Состояние:** `этап-идёт`
 - **Этап:** 3 из 6 — гард и хук запуска
 - **Сделано:** закон заведён, папка задачи и образец написаны
 - **Следующий шаг:** сценарии обоих хуков, затем подключение в настройках
@@ -71,6 +94,9 @@ git log --oneline origin/main..HEAD
 - **PR:** #1396, ждёт разбора · отвечено 3 замечания из 5 · не сделано: разбор папки задачи
 ```
 
+С открытием PR состояние становится `работа-отдана`, и обязательное действие у него другое —
+следующая задача, а не ожидание разбора.
+
 Решение, принятое по ходу, — вместе с причиной и с тем, что было альтернативой:
 
 ```markdown
@@ -94,7 +120,7 @@ git log --oneline origin/main..HEAD
 - Доэтапное, не этой работы: сверка очереди перечисляет шесть закрытых задач вне борды.
 ```
 
-## 11. Следующая задача эпика берётся тем же движением
+## Состояние `работа-отдана`: следующая задача берётся тем же движением
 
 Задача закрыта, PR открыт и ждёт владельца — заход на этом не кончается. Отданное на разбор
 ждёт человека, а не машину: пока эпик не кончился, следующая его задача берётся сразу, тем же

package/assets/patterns/task-flow-start.md

@@ -21,7 +21,7 @@ description: Паттерн правила task-flow. Брать в начале
 не начинается заново. Весь список — в правиле `task-flow`; он же показывается владельцу в начале
 работы, чтобы после шести вопросов было видно, что впереди.
 
-### 1. Разведка — до первого вопроса
+### Состояние `просьба-не-разобрана`: разведка — до первого вопроса
 
 Вопрос, ответ на который лежит в коде, владельцу не задаётся: он обесценивает и остальные.
 
@@ -40,7 +40,7 @@ Agent(subagent_type: "Explore", prompt: "<тема просьбы>: что по
 считается сделанным, разведка исполняется как настроение: прочитанный переданный текст сходит
 за неё, и по текущему дереву не запускается ни одной команды.
 
-### 2. Разбор с владельцем
+### Состояние `просьба-не-разобрана`: разбор с владельцем
 
 Ведёт главный агент: субагент до владельца не достучится. Команда — `/grill-me`, один вопрос
 за раз, к каждому — свой рекомендуемый ответ с доводом.
@@ -89,7 +89,7 @@ mkdir -p docs/tasks/_draft-<slug>
 cp docs/tasks/_template/grill.md docs/tasks/_draft-<slug>/grill.md
 ```
 
-### 3. Конвейер после разбора
+### Состояние `разбор-закрыт`: конвейер после разбора
 
 Вопросов больше не будет — дальше роли:
 
@@ -107,7 +107,7 @@ Workflow(name: "plan", args: "docs/tasks/_draft-<slug>")
 «не входит». Находка критика, расходящаяся с ответом владельца, относится владельцу — она не
 исполняется молча и не считается закрытой правкой текста.
 
-### 4. Серия задач объявляется эпиком
+### Состояние `договорённость-записана`: серия задач объявляется эпиком
 
 Разбор кончился одной задачей — шаг пропускается. Вышло несколько, и порядок между ними
 значим — эпик объявляется здесь, до первой из них, и дважды: карточкой в очереди работ с меткой
@@ -134,7 +134,7 @@ Workflow(name: "plan", args: "docs/tasks/_draft-<slug>")
 Лежит замысел вне папки задачи: та умирает с мержем первой же задачи. Каталог для него называет
 компаньон правила — у пакета своего пути нет.
 
-### 5. Задача, ветка, папка
+### Состояние `договорённость-записана`: задача, ветка, папка
 
 ```bash
 npm run task:new -- --title '<Что не так>' --slug <slug> --label documentation --label area:tooling < тело.md
@@ -162,7 +162,16 @@ cp docs/tasks/_template/plan.md docs/tasks/<КЛЮЧ>-<номер>-<slug>/plan.m
 cp docs/tasks/_template/progress.md docs/tasks/<КЛЮЧ>-<номер>-<slug>/progress.md
 ```
 
-### 6. Шапка замысла
+В ходе работы первой строкой объявляется состояние — с этой минуты его читает гард:
+
+```markdown
+- **Состояние:** `задача-взята`
+```
+
+Пока не объявлено состояние, в котором код правится, гард отбивает правку и называет
+обязательное действие того состояния, которое стоит в строке.
+
+### Состояние `задача-взята`: шапка замысла
 
 Её читает гард:
 

package/assets/rules/git-workflow.azure.md

@@ -72,6 +72,22 @@ flowchart TD
   открытие, пока вершина главной ветки не стала предком текущей, и называет расхождение числом
   коммитов. PR с разошедшейся ветки показывает ревьюверу свою правку вперемешку с чужой, а всё,
   что автор проверил до публикации, он проверил от основания, которого в главной ветке уже нет.
+- **Несошедшиеся условия поставки называются одним отказом, а не по одному.** Гард копит их все
+  и печатает разом. Отбитый по первому промаху исполнитель правит основание, повторяет вызов,
+  упирается в заголовок, правит заголовок, упирается в рабочий элемент — и каждый круг стоит
+  ещё одного вызова, хотя всё несошедшееся было известно уже на первом.
+- **Условие, известное в начале работы, спрашивается в начале.** Заведение ветки отбивает
+  основание, в котором нет вершины главной ветки, и рабочую копию, подписывающую коммиты не той
+  почтой, что объявило дерево. На пуше и на открытии PR те же проверки остаются вторым рубежом,
+  но там они стоят дороже: основание чинится вливанием с разбором конфликта, подпись —
+  переписыванием всей ветки.
+- **Судится то основание, которое названо командой, а не вершина рабочей копии.** Ветку заводят
+  и от вершины главной ветки прямо — этой командой основание как раз и берут свежим, — и гард,
+  читающий только текущую вершину, отбивал бы её наравне с веткой от вчерашнего дерева.
+  Основание, о котором дерево ничего не знает, не судится вовсе.
+- **Ветка без номера рабочего элемента условий поставки не получает.** Локальная ветка под пробу
+  законна, и требовать от неё свежего основания значило бы отбивать работу, которая в главную
+  не поедет: PR с такой ветки не откроется.
 - **Правка кода отдаётся человеку открытым PR, а не запушенной веткой.** Ветка в списке ветвей
   ему не показывается, в его дела не приходит и обсуждения не имеет: до открытия PR правки для
   человека нет. Открывается он тем же ходом, которым исполнитель говорит, что работу отдаёт, и
@@ -100,6 +116,12 @@ flowchart TD
   элемент переводится в `Active`, PR открыт — в `Resolved`; делает это команда перевода, а не
   набор вызовов по памяти. Перевод идёт сразу за шагом, который его вызвал: очередь работ
   читают между шагами, а не после них.
+- **Рабочий элемент, оставшийся в начальном состоянии, PR не открывает.** Гард поставки называет
+  это состояние и команду перевода: по очереди работ такой элемент читается как невзятый, хотя
+  работа по нему сделана и выложена. На заведении ветки состояние не спрашивается — там его ещё
+  не двигали, и требование отбивало бы первую же команду работы вместе с той, которая его и
+  снимает. Имя начального состояния дерево называет само; не названо — состояние не судится
+  вовсе.
 - **На доске стоят рабочие элементы, а не PR о них.** Доска показывает, что сделано и что
   осталось; PR отвечает на другой вопрос — как именно сделано, — и открывается из элемента, где
   связь с ним стоит сама. Здесь эта связь ставится при создании PR, поэтому отдельная карточка
@@ -209,16 +231,21 @@ flowchart TD
 проверки под него не заводится: работа опознаётся заголовком рабочего элемента и PR, а это
 сверяется у всех. Сверка очереди имя ветки не судит вовсе: у открытого PR его не переименовать.
 
-Взятие задачи в работу не стережёт ничто: доска ветки не видит, а гард поставки её видит, но
-доску не правит — сетевой вызов в разборе команды падал бы вместе со связью и отбивал бы
-работу вместо промаха. Держится это памятью и подсказкой, которую печатает команда заведения
-задачи. Отставшее состояние находит сверка очереди — но уже после того, как PR открыт.
+Рабочий элемент в работу гард не переводит: доску он не правит — правка доски в разборе команды
+падала бы вместе со связью и отбивала бы работу вместо промаха. Перевод держится памятью и
+подсказкой, которую печатает команда заведения. Элемент, оставшийся в начальном состоянии, гард
+называет на открытии PR — то есть после того, как его должны были перевести; прочие расхождения
+состояния находит сверка очереди.
 
-Свежесть самой вершины главной ветки гард не проверяет: он судит по тому, что лежит в дереве, и
-вершину недельной давности от сегодняшней не отличает. Сетевой вызов сюда не заводится по той же
-причине, что и выше, — он падал бы вместе со связью. Поэтому гард ловит ветку, отставшую
-заведомо, а `git fetch` перед вливанием стоит первым пунктом чеклиста и держится тем же, чем
-держатся остальные его пункты.
+Ревьювера гард здесь не спрашивает: снятие черновика идёт правкой самого PR — тем же вызовом, что
+и остальные его поля, — и от прочих правок машине оно неотличимо. Держится это словарём выше, где
+разбор PR ведёт ревьювер, и памятью того, кто черновик снимает.
+
+Свежесть самой вершины главной ветки гард спрашивает вторым ярусом — тем же приёмом, что и
+состояние задачи: есть чем спросить, спрашивает; нет сети или доступа — пропускает молча. Первый
+ярус при этом остаётся, и работает он без сети: локальная ссылка отвечает на вопрос «отстало ли
+основание от того, что уже лежит в дереве», удалённая — на вопрос «не протухла ли сама ссылка».
+Без второго яруса молчание гарда значило лишь первое, а читалось как второе.
 
 ## Паттерны