@rt-tools/agent-kit 0.13.0 → 0.14.0

package/assets/checks/board-runs.github.mjs

@@ -85,3 +85,48 @@ export function headCommittedAt(sha, options) {
     const answer = gh(['api', `repos/${OWNER}/${REPO}/commits/${sha}`, '--jq', '.commit.committer.date'], options);
     return Date.parse(String(answer).trim());
 }
+
+/**
+ * Прогоны вершины, вытесненные из очереди конвейера.
+ *
+ * Группа очереди бережёт идущий прогон и не бережёт ждущего: хостинг держит в группе один
+ * ждущий, и следующий встающий вытесняет прежний. Вытесненный завершается отменой и в списке
+ * неотличим от упавшего, хотя ветку не проверял ни строчкой.
+ *
+ * Отличает их число заданий. Отмена — общее слово для двух случаев: у прогона, остановленного
+ * на ходу, задания есть и журналы у них читаются; у вытесненного из очереди их ноль, потому что
+ * он не начинался. Замером по семи отменённым прогонам дерева: шесть с нулём заданий и один
+ * остановленный на ходу с одним.
+ *
+ * Число заданий спрашивается отдельным вызовом и только у отменённых: спрошенное у каждого
+ * прогона стоило бы вызова на прогон при каждой сверке.
+ *
+ * Зелёный прогон на той же вершине снимает ответ целиком — вытесненный за ним уже перезапущен,
+ * и говорить о нём нечего.
+ */
+export function evictedOnHead(sha, options) {
+    const answer = gh(
+        [
+            'api',
+            `repos/${OWNER}/${REPO}/actions/runs?head_sha=${sha}&per_page=20`,
+            '--jq',
+            '[.workflow_runs[] | {id, status, conclusion}] | tojson',
+        ],
+        options
+    );
+    const runs = JSON.parse(String(answer).trim() || '[]');
+    if (runs.some((run) => run.status === 'completed' && run.conclusion === 'success')) {
+        return [];
+    }
+
+    return runs
+        .filter((run) => run.status === 'completed' && run.conclusion === 'cancelled')
+        .filter((run) => jobCount(run.id, options) === 0)
+        .map((run) => run.id);
+}
+
+/** Сколько заданий завелось у прогона. Ноль означает, что он не начинался вовсе. */
+function jobCount(id, options) {
+    const answer = gh(['api', `repos/${OWNER}/${REPO}/actions/runs/${id}/jobs?per_page=1`, '--jq', '.total_count'], options);
+    return Number(String(answer).trim());
+}

package/assets/checks/board.github.mjs

@@ -19,7 +19,7 @@
  * функции возвращают `null`, командный режим печатает `{"offline":true}`.
  */
 import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -287,6 +287,48 @@ export function numberFromTaskDir(name) {
  * Вглубь спускаемся ровно на один уровень: в имени ветки одна косая, а всё, что глубже, папкой
  * задачи уже не будет — зато туда попал бы архив, если дерево держит его внутри.
  */
+/** Шапка раскладки: по ней разложенную копию узнаёт и гард места правки. */
+const STAMP = /^<!-- rt-kit v[^\n]*-->\n/m;
+
+/**
+ * Снять с копий образца шапку раскладки.
+ *
+ * Образец разложен пакетом и шапку несёт по праву: его кладёт и обновляет раскладка. Копия под
+ * задачу — уже текст проекта, тем же доводом, каким пакет кладёт без шапки черновик компаньона:
+ * с первой правки сверять в ней нечего.
+ *
+ * Оставленная в копии, шапка отбивает первую же правку разбора просьбы — то есть первое движение
+ * любой работы, — и отказ уводит править образец пакета вместо копии под задачу. Снималась она
+ * тремя строками руками, каждой работой заново.
+ *
+ * Возвращает имена файлов, с которых шапка снята: по ним сценарий и судит, что снятие работает,
+ * а вызывающий — что папка собрана.
+ */
+export function unstampFolder(folder) {
+    const cleaned = [];
+
+    if (!existsSync(folder)) {
+        return cleaned;
+    }
+
+    for (const name of readdirSync(folder)) {
+        if (!name.endsWith('.md')) {
+            continue;
+        }
+
+        const path = join(folder, name);
+        const before = readFileSync(path, 'utf8');
+        const after = before.replace(STAMP, '');
+
+        if (after !== before) {
+            writeFileSync(path, after);
+            cleaned.push(name);
+        }
+    }
+
+    return cleaned;
+}
+
 export function taskDirs(dir = join(ROOT, CONFIG.tasksDir), prefix = '') {
     if (!existsSync(dir)) {
         return [];

package/assets/checks/check-board.github.mjs

@@ -47,7 +47,7 @@ import {
     numberFromTitle,
     taskDirs,
 } from './board.mjs';
-import { deployLag, headCommittedAt, runsOnHead, verdictOnHead } from './board-runs.mjs';
+import { deployLag, evictedOnHead, headCommittedAt, runsOnHead, verdictOnHead } from './board-runs.mjs';
 import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
 const IN_REVIEW = STATUS_OPTIONS[IN_REVIEW_STATUS].name;
@@ -140,6 +140,10 @@ function folderInBranch(branch, options) {
  * промежутке значила бы «подожди», а не «чини».
  */
 function checkHeadRun(pull, options) {
+    if (checkEvicted(pull, options)) {
+        return;
+    }
+
     if (runsOnHead(pull.headRefOid, options) > 0) {
         checkReadyDraft(pull, options);
         return;
@@ -157,6 +161,36 @@ function checkHeadRun(pull, options) {
     );
 }
 
+/**
+ * Прогон вершины, вытесненный из очереди конвейера.
+ *
+ * Группа очереди бережёт идущий прогон и не бережёт ждущего: хостинг держит в группе один
+ * ждущий, и следующий встающий вытесняет прежний. Ветка за таким прогоном не проверялась ни
+ * строчкой, а по очереди работ выглядит проверенной — прогон на вершине есть, и сверка считает
+ * именно факт.
+ *
+ * Судится раньше отсутствия прогона и раньше цвета: иначе одна вершина получает две строки об
+ * одном. Отвечает `true`, когда строка сказана, и остальные проверки вершины пропускаются.
+ *
+ * Строка называет обе команды и в том порядке, в каком их зовут. Перезапуск отбивает гард, пока
+ * за тот же ход не читался журнал этого задания, и порядок в строке выполняет требование сам:
+ * исполнитель зовёт написанное и не упирается в отказ на втором шаге.
+ */
+function checkEvicted(pull, options) {
+    const evicted = evictedOnHead(pull.headRefOid, options);
+    if (evicted.length === 0) {
+        return false;
+    }
+
+    const run = evicted[0];
+    report(
+        `PR #${pull.number}: прогон ${run} на вершине ${pull.headRefOid.slice(0, 8)} вытеснен из очереди конвейера — ` +
+            `заданий у него ноль, ветка не проверялась, а в списке он выглядит упавшим; ` +
+            `прочитай прогон и перезапусти его (gh run view ${run} && gh run rerun ${run})`
+    );
+    return true;
+}
+
 /**
  * Готовая работа, оставленная черновиком.
  *

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

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

package/assets/hooks/claim-guard.sh

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

package/assets/hooks/dispatch.sh

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

package/assets/hooks/hook-input.sh

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

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

@@ -76,8 +76,14 @@ esac
 
 # То же самое, но объявить это на диске уже нечем: папка задачи разбирается до открытия заявки,
 # и ход работы уезжает вместе с ней. Признак берётся из истории ветки — папка, снятая её
-# коммитом. Без этой ветки хвост работы судился бы вторым признаком, то есть отбивался бы за
-# ход, в котором исполнитель ждёт чужого прогона и ничего в дереве не двигает.
+# коммитом.
+#
+# Отпускать по нему ход нельзя: папка снимается ДО заявки, и между этими двумя движениями работа
+# не отдана никому. Ход, попавший в зазор, прежде выходил отсюда нулём — а до отдачи ему
+# оставался ровно один шаг, и он его не сделал. Признак поэтому только снимает требование
+# состояния: дальше ход судится вторым признаком, как всякий другой. Ход, в котором заявку
+# открыли или прочитали, второй признак пропускает сам — вызов клиента хостинга он считает
+# работой.
 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 +95,8 @@ folder_archived() {
     [ -n "$had" ]
 }
 
-[ -z "$progress" ] && folder_archived && exit 0
+archived=false
+[ -z "$progress" ] && folder_archived && archived=true
 
 # Следующий шаг из хода работы — его страж и называет в отказе: исполнитель, которому сказано
 # только «работа не кончена», перечитывает ту же строку сам.
@@ -194,7 +201,15 @@ 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="в этом ходе прочитан красный прогон" ;;

package/assets/pitfalls/git-workflow.github.md

@@ -76,3 +76,11 @@
   входят: свежее дерево выглядит готовым и упирается в нехватку не сразу, а на первом гарде,
   которому нужен ключ. Что именно переносится руками, названо списком в компаньоне правила, и
   список пополняется тем же движением, которым заводится новый файл вне индекса.
+- **Вытесненный из очереди прогон и упавший в списке неразличимы.** Оба отвечают красным, и
+  слово отмены у них одно. Ветка за вытесненным не проверялась ни строчкой: заданий у него
+  ноль, потому что он не начинался. Перезапуск такого прогона отбивает гард, пока за тот же ход
+  не читался журнал задания, — поэтому строка сверки называет чтение прогона первым.
+- **Одно и то же вливание главной ветки, сделанное третий раз за заход, останавливает работу.**
+  Ветки, дописывающие строку в один и тот же список, роняют друг друга в конфликт при каждом
+  слиянии, и вливание главной по кругу — это починка проявления. На третьем круге называется
+  причина и спрашивается владелец, а не делается четвёртый круг.

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

@@ -139,6 +139,10 @@ flowchart TD
   которой прогон не встал, замечали только тем, что открывали список прогонов руками. Сверка
   спрашивает вершину, а не ветку, считает сам факт прогона, а не его цвет, и свежей вершине
   даёт время: между пушем и прогоном проходят минуты.
+- **Прогон, вытесненный из очереди конвейера, сверка называет отдельной строкой.** Ждущего
+  прогона группа очереди не бережёт: следующий встающий вытесняет прежний, и тот выглядит
+  упавшим, хотя ветку не проверял ни строчкой. Отличает их число заданий — у вытесненного оно
+  ноль; строка называет обе команды по порядку, сперва чтение прогона.
 - **Черновик при зелёном прогоне на вершине — расхождение сверки.** У черновика кнопка слияния
   заблокирована самим хостингом: зелёная страница PR владельцу ничего не разрешает, а список, в
   котором всё серое, читается как «работа не сделана». Гард снятия черновика сюда не достаёт —
@@ -218,10 +222,6 @@ flowchart TD
   прежнее состояние и читает его как «не сделано ничего», а сделанное лежит в рабочем дереве
   исполнителя, где его не видит никто. Ветка, в которой разрешён конфликт, пушится тем же
   ходом — либо конфликт не разрешается вовсе.
-- **Одно и то же вливание главной ветки, сделанное третий раз за заход, останавливает
-  работу.** Ветки, дописывающие строку в один и тот же список, роняют друг друга в конфликт при
-  каждом слиянии, и вливание главной по кругу — это починка проявления. На третьем круге
-  называется причина и спрашивается владелец, а не делается четвёртый круг.
 - **Черновик не снимается, пока у PR нет разбора.** Гард поставки смотрит запрошенного ревьювера
   и оставленный отзыв: снятый черновик читается как «можно вливать», а вливать некому. Раньше
   этого хода спросить негде — до открытия PR ревьювера нет вовсе. Судится и вызов без номера:

package/assets/rules/task-flow.md

@@ -176,7 +176,9 @@ flowchart TD
   целиком, поэтому «не читал» основанием не бывает.
 - **Папка задачи заводится черновиком и получает номер командой.** До конца разбора
   неизвестно, сколько задач из него выйдет, поэтому номер не может быть первым;
-  `npm run task:new` переименовывает черновик и проставляет шапку замысла.
+  `npm run task:new` переименовывает черновик и проставляет шапку замысла. Папку он и собирает —
+  с образца, снимая с копий шапку раскладки: оставленная в копии, она отбивает первую же правку
+  разбора просьбы, а отказ уводит править образец пакета вместо копии под задачу.
 - **Брошенный разбор виден.** Черновик старше недели перечисляет сверка очереди работ —
   задачи за ним ещё нет, и спросить о нём некого.
 - **Замысел эпика лежит там, где его найдут без сети и после мержа.** Карточка в очереди работ

package/assets/rules/turn-conduct.md

@@ -101,10 +101,13 @@ flowchart TD
   работы и то, что за ход по ней сделано: правку файла или команду, меняющую дерево. Ход, в
   котором не было ни того ни другого, возвращается исполнителю вместе со следующим шагом из
   хода работы. Отданную и влитую работу страж не судит: она уже дождалась чужого шага.
-- **Отданную работу страж узнаёт по истории ветки, когда объявить её на диске уже нечем.** Ход
-  работы уезжает вместе с папкой задачи, а папка разбирается до открытия заявки: с этой минуты
-  и до слияния строки состояния нет вовсе. Судимый вторым признаком, такой ход отбивался бы за
-  ожидание чужого прогона — за то самое, что работой не является и правильно им не считается.
+- **Снятая папка задачи снимает требование состояния, а ход не кончает.** Ход работы уезжает
+  вместе с папкой, а папка разбирается до открытия заявки: с этой минуты и до слияния строки
+  состояния нет вовсе, и первый признак стражу взять неоткуда. Отпускать по этому признаку ход
+  нельзя — снятая папка означает середину отдачи, а не её конец: между уборкой и заявкой работу
+  не видит никто, кроме того, кто её сделал. Дальше ход судится вторым признаком, как всякий
+  другой; ход, в котором заявку открыли или прочитали, второй признак пропускает сам. Прежде
+  страж выходил здесь молча — и ход, которому до отдачи оставался один шаг, закрывался пустым.
 - **Работа без ветки и без папки задачи судится тем же стражем по второму признаку.** Состояния
   у неё нет, и первый признак взять неоткуда, — но ход, в котором не было ни одной правки
   дерева, не кончается и здесь. Раньше страж отпускал такую работу молча, и защищена она была
@@ -129,6 +132,13 @@ flowchart TD
   годится: состояние дерева меняется, и вчерашний вывод о нынешнем молчит. Восемь разборов
   подряд пришлись на этот промах, и каждый раз в правило дописывалась ещё одна статья —
   держит его теперь машина.
+- **Гард утверждения ждёт текст ответа, а не судит запись, какой застал.** Текст ложится в
+  запись хода не раньше, чем хост зовёт хук, и гард, прочитавший файл первым, видит ход, в
+  котором владельцу не сказано ничего. Молчит он при этом честно — и снаружи неотличим от гарда,
+  который посмотрел и пропустил: одним таким ходом мимо прошли сразу трое. Не дождавшись текста,
+  гард возвращает ход: пустая запись означает не «сказать было нечего», а «прочитать нечего».
+  Отказ этот принадлежит одному гарду: печатай своё решение все трое, вывод перестал бы
+  разбираться целиком.
 - **Слово-утверждение гард ловит, неверный вывод — нет.** Об образце, судимом по одному его
   файлу, и о пути, которым человек не пойдёт, судить нечем: там нет ни слова, ни команды, с
   которой сверять. Это известная граница гарда, и держат её статьи ниже, а не он.
@@ -140,6 +150,17 @@ flowchart TD
   и отбивал бы работу вместо промаха, а вывод команды о прогоне в записи хода уже лежит. Слова
   «беру следующую задачу» гард действием не считает — ровно потому, что их и произносят вместо
   неё.
+- **Ход, отдавший работу, доводит её до снятого черновика.** Черновик читается владельцем как
+  «работа не кончена»: кнопка слияния у него заблокирована самим хостингом, а по списку заявок
+  готовое от недоделанного не отличить — серое и там и там. Следующая задача берётся сверх этого,
+  а не вместо: требование взять её исполняется буквально и оставляет отданное невидимым. Две
+  готовые заявки простояли так, пока владелец не вернул исполнителя сам. Стережёт это гард
+  ожидания: ход, открывший заявку, не кончается, пока состояние отданной работы не спрошено
+  командой того же хода.
+- **«Жду прогона» — утверждение о чужом шаге, а не состояние работы.** Прогон бывает зелёным
+  час, а бывает не встав вовсе — и второе само не чинится. Слово это требует команды того же
+  хода, которая прогон показывает, и без неё не говорится: сказанное без команды владелец читает
+  как «работа ещё идёт» и ждёт напрасно. Держит это гард утверждения, а не память исполнителя.
 - **Конец прогона узнаётся возвратом фоновой команды, а не взглядом на страницу.** Ожидание,
   запущенное в фоне отдельным ходом, возвращает исполнителя к PR само; до тех пор ход занят
   следующей задачей. Взгляд на страницу этого не даёт: он либо повторяется вхолостую, либо не
@@ -168,6 +189,14 @@ flowchart TD
   читается как работа — тем полнее, чем аккуратнее он составлен: он пронумерован, в нём названы
   цифры, и именно поэтому пустота хода за ним не видна. Владельцу называется, что уже сделано и
   что осталось за его словом, — а не выбор из вариантов вместо и того и другого.
+- **Признак необратимости берётся из списка, а не выводится доводом.** Список составлен тем, кто
+  обратимость уже взвесил: необратимое в нём осталось, обратимое из него снято. Довод «действие
+  уходит наружу и не откатывается» приходит в контекст всегда, а список — только когда его
+  прочитали, и применённый поверх списка довод отменяет список целиком. Отменяет молча: со
+  стороны это выглядит осторожностью, а не пропуском шага. Действия, которого в списке нет,
+  исполнитель на слово владельца не гейтит, даже если оно уходит наружу. Шаг, снятый из списка
+  разбором прошлого промаха, тем более: довод, которым его туда возвращают, уже разобран и
+  отклонён — и дважды подряд готовая работа вставала перед снятым шагом.
 - **Ход, в котором исполнитель признал промах, не заканчивается, пока записи о происшествии
   нет.** Отбивает гард происшествия — на завершении хода: к моменту признания промах уже
   случился, и ловить раньше нечего. Признание ловится набором образцов, а не пониманием смысла;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rt-tools/agent-kit",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Переносимый слой правил для агента: законы, хуки, проверки и агенты, раскладываемые в репозиторий одной командой",
   "author": "RT Team",
   "license": "Apache-2.0",