@rt-tools/agent-kit 0.13.0 → 0.15.0

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

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

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

@@ -63,12 +63,19 @@ red_re='completed[[:space:]]+failure|"conclusion"[[:space:]]*:[[:space:]]*"failu
 # по следующей задаче не считается — она чинит прежнюю, а не двигает работу дальше.
 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'
+
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью, поэтому строки с `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 opened "$opened_re" --arg moved "$moved_re" --arg read "$read_re" --arg red "$red_re" \
+    --arg ready "$ready_re" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -90,12 +97,41 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
     | ($ran | test($opened; "i")) as $opened_pr
     | (($ran | test($read; "i")) and ($out | test($red; "i"))) as $red_run
     | ($ran | test($moved; "i")) as $went_on
-    | if $went_on then "pass"
-      elif $opened_pr then "owe:pr"
+    | ($ran | test($ready; "i")) as $checked
+    | if $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"
       else "pass" end
 ' 2>/dev/null)"
 
+# Черновик, оставленный при взятой следующей задаче, — отдельный отказ: там требование не про
+# следующую задачу, а про доведение отданной.
+if [ "$verdict" = "owe:draft" ]; then
+    reason="BLOCKED by waiting-turn-guard: в этом ходе открыт PR, следующая задача взята, а состояние отданной работы не спрошено ни одной командой.
+
+Черновик читается владельцем как «работа не кончена»: кнопка слияния у него заблокирована самим хостингом, и по списку заявок готовое от недоделанного не отличить — серое и там и там. Довести отданное до снятого черновика обязан тот, кто его отдал.
+
+Спроси прогон на вершине этим же ходом — `gh run list`, `gh pr checks` или сверку очереди работ — и сними черновик, когда он зелёный, а ветка сливается. Прогон ещё идёт — так и скажи владельцу, назвав его вывод.
+
+Следующая задача берётся сверх этого, а не вместо: обе готовые заявки простояли черновиками ровно на такой подмене.
+
+Гард судит один ход: следующий заход не отбивается."
+
+    # 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
+
 case "$verdict" in
     owe:pr) said="в этом ходе открыт PR" ;;
     owe:run) said="в этом ходе прочитан красный прогон" ;;