@rt-tools/agent-kit 0.9.1 → 0.11.0

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

@@ -14,6 +14,8 @@
 # FAIL-OPEN: нет `jq`, не git-репозиторий, нет папки задачи — выходим молча. Сессия важнее
 # контекста.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 ROOT="${CLAUDE_PROJECT_DIR:-.}"
 command -v jq >/dev/null 2>&1 || exit 0
 cd "$ROOT" 2>/dev/null || exit 0

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: PreToolUse Edit|Write|MultiEdit|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
-# Требует: hooks/profile-check.sh
+# Требует: hooks/profile-check.sh, hooks/deny-tail.sh
 # PreToolUse guard for Edit|Write|MultiEdit: код не пишется раньше замысла.
 #
 # Работа идёт много заходов, и между ними исполнитель не помнит ничего. Замысел, лежащий на
@@ -8,9 +8,14 @@
 # закоммичены, PR не открыт, а очередь работ показывает задачу начатой и молчит о том, что
 # внутри неё сделано.
 #
-# Гард требует три вещи и ровно их: папку задачи по имени ветки, замысел в ней и названную в
-# замысле договорённость о продукте. Полноту написанного он не судит — это за владельцем
-# (решения в законе `docs/constitution/work-conduct.md`).
+# Гард требует четыре вещи и ровно их: папку задачи по имени ветки, замысел в ней, объявленное
+# в ходе работы состояние — из тех, в которых код правится, — и названную в замысле
+# договорённость о продукте. Полноту написанного он не судит — это за владельцем (решения в
+# законе `docs/constitution/work-conduct.md`).
+#
+# Состояние судится раньше договорённости и её обхода: обход снимает требование договорённости,
+# а не требование дойти до правки кода. Судится объявленный переход, а не наличие файлов —
+# артефакт, положенный ради снятия отказа, лежит так же, как написанный.
 #
 # Правило целиком — скил `task-flow`.
 #
@@ -20,6 +25,8 @@
 # FAIL-OPEN: нет jq, не git-репозиторий, битый ввод, чужой инструмент → пропуск. Сломанный
 # гард не должен мешать работать.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 command -v jq >/dev/null 2>&1 || exit 0
@@ -102,9 +109,20 @@ EOF
 # Каталог папок задач: у дерева он свой, но имя обычно общее.
 tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
 
+# Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть. Файл
+# может быть не разложен — тогда хвоста нет, а причина отказа остаётся прежней.
+# shellcheck disable=SC1090
+[ -f "$rt_hooks_dir/deny-tail.sh" ] && . "$rt_hooks_dir/deny-tail.sh"
+command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+
+# Отказ: причина первым параметром, законная форма обхода — вторым. Хвост дописывается здесь, а
+# не в каждом тексте: пропущенный в одном месте, он читается как «у этого отказа ходов нет».
 deny() {
-    jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
-        || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$1"
+    reason="$1"
+    tail_text="$(rt_deny_tail "$2")"
+    [ -n "$tail_text" ] && reason="$1 ${tail_text}"
+    jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
+        || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$reason"
     exit 0
 }
 
@@ -130,6 +148,53 @@ if [ ! -f "$plan" ]; then
     deny "BLOCKED by task-flow: нет замысла — '${tasks_dir}/${branch}/plan.md'. Собери папку задачи с образца (cp -r ${tasks_dir}/_template ${tasks_dir}/${branch}) и заполни шапку, след задачи и этапы, затем повтори. Правило — скил task-flow."
 fi
 
+# Состояние работы. Артефакт на диске не говорит, дошла ли работа до правки кода: пустой
+# `plan.md`, положенный ради снятия отказа, лежит точно так же, как написанный замысел, и
+# требование снимает сам собой. Единица работы — состояние, а не файл: исполнитель объявляет
+# его строкой в ходе работы, гард судит объявленный переход, а не наличие файлов.
+#
+# Состояние стоит в разделе «Где стоим» и перезаписывается вместе с ним. Имя берётся из
+# перечня — своё имя состоянием не является: перечень называет вход, выход и обязательное
+# действие каждого, и слово вне перечня не говорит ни о чём из трёх.
+progress="$dir/progress.md"
+
+if [ ! -f "$progress" ]; then
+    deny "BLOCKED by task-flow: нет хода работы — '${tasks_dir}/${branch}/progress.md'. В нём объявляется состояние работы, и без него не видно, дошла ли она до правки кода. Собери папку задачи с образца (cp -r ${tasks_dir}/_template ${tasks_dir}/${branch}), затем повтори. Правило — скил task-flow."
+fi
+
+state="$(sed -n 's/^[[:space:]]*[-*][[:space:]]*\*\*Состояние:\*\*[[:space:]]*`\([^`]*\)`.*/\1/p' "$progress" 2>/dev/null | head -1)"
+
+# Обязательное действие состояния. Отказ называет его целиком: исполнитель, которому сказано
+# только «не в том состоянии», переписывает строку состояния вместо того, чтобы сделать шаг.
+state_action() {
+    case "$1" in
+        просьба-не-разобрана) printf '%s' 'разведка по дереву, затем вопросы владельцу' ;;
+        разбор-закрыт) printf '%s' 'договорённость о продукте либо названная причина её отсутствия' ;;
+        договорённость-записана) printf '%s' 'завести задачу, ветку и папку задачи' ;;
+        задача-взята) printf '%s' 'написать замысел' ;;
+        замысел-записан) printf '%s' 'делать первый этап' ;;
+        папка-разобрана) printf '%s' 'снять черновик и попросить владельца влить' ;;
+        влито) printf '%s' 'разбор работы правилами и сверка очереди работ' ;;
+        *) printf '%s' '' ;;
+    esac
+}
+
+if [ -z "$state" ]; then
+    deny "BLOCKED by task-flow: в '${tasks_dir}/${branch}/progress.md' не объявлено состояние работы. Впиши в раздел «Где стоим» строку '- **Состояние:** \`<имя>\`' — имя из перечня состояний правила, — затем повтори. Код правится в состояниях 'этап-идёт', 'этапы-кончились', 'работа-отдана' и 'разбор-кончился'. Правило — скил task-flow."
+fi
+
+case "$state" in
+    # Состояния, в которых код приложения правится. Три последних — не про первый заход:
+    # прогон бывает красным, а разбор — с замечаниями, и починка идёт в ту же ветку.
+    этап-идёт | этапы-кончились | работа-отдана | разбор-кончился) ;;
+    просьба-не-разобрана | разбор-закрыт | договорённость-записана | задача-взята | замысел-записан | папка-разобрана | влито)
+        deny "BLOCKED by task-flow: в ходе работы объявлено состояние '${state}', а код в нём не правится. Обязательное действие этого состояния — $(state_action "$state"). Дошла работа до правки кода — перепиши строку состояния в '${tasks_dir}/${branch}/progress.md' на '- **Состояние:** \`этап-идёт\`'. Правило — скил task-flow."
+        ;;
+    *)
+        deny "BLOCKED by task-flow: в '${tasks_dir}/${branch}/progress.md' объявлено состояние '${state}', а такого в перечне нет. Имя берётся из перечня состояний правила — своё слово не говорит ни о входе, ни о выходе, ни об обязательном действии. Правило — скил task-flow."
+        ;;
+esac
+
 # Строка обхода: поведение не меняется, договорённость о продукте не нужна. Причина обязана
 # стоять — без неё обход становится умолчанием.
 if grep -qE '^\*\*Поведение:\*\*[[:space:]]*не меняется[[:space:]]*—[[:space:]]*\S' "$plan" 2>/dev/null; then
@@ -139,7 +204,8 @@ fi
 draft="$(sed -n 's/^\*\*Драфт:\*\*[[:space:]]*`\([^`]*\)`.*/\1/p' "$plan" 2>/dev/null | head -1)"
 
 if [ -z "$draft" ]; then
-    deny "BLOCKED by task-flow: в '${tasks_dir}/${branch}/plan.md' не названа договорённость о продукте. Заведи её в docs/specs/<домен>/proposed/<фича>/ и укажи строкой '**Драфт:** \`путь\`'. Если правка поведения не меняет — поставь '**Поведение:** не меняется — <причина владельца>'. Правило — скил task-flow."
+    deny "BLOCKED by task-flow: в '${tasks_dir}/${branch}/plan.md' не названа договорённость о продукте. Заведи её в docs/specs/<домен>/proposed/<фича>/ и укажи строкой '**Драфт:** \`путь\`'. Правило — скил task-flow." \
+        "строка '**Поведение:** не меняется — <причина владельца>' в замысле; пустая причина не принимается"
 fi
 
 case "$draft" in

package/assets/hooks/turn-entry-load.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# rt-hook: SessionStart startup|resume|compact|clear
+# Требует: hooks/handoff-write.sh
+# SessionStart: передача прошлого захода и карта хода уезжают в контекст на каждом запуске.
+#
+# Передачу пишет хук перед сжатием — и на этом её путь кончался: читать её не умел никто, и
+# в новый заход её клал человек. Написанная и не прочитанная, она равна ненаписанной.
+#
+# Второе, чего заход после сжатия не знает, — как здесь ведут работу. Перечень состояний с
+# обязательными действиями лежит в правиле, а правило после сжатия не загружено: заход первым
+# движением идёт читать его целиком, то есть тратит на восстановление порядка ту часть окна,
+# ради которой сжатие и случилось. Карта отвечает на этот вопрос до того, как он задан.
+#
+# Подаётся это на всех четырёх запусках, а не только после сжатия: заход после обрыва и заход
+# после очистки начинают с того же пустого места, и разница между ними исполнителю не видна.
+#
+# FAIL-OPEN: не git-репозиторий, нет ветки, нет каталога передач, нет карты, нечитаемый файл —
+# хук выходит нулём и молчит о той части, которой нет. Запуск он не отбивает никогда: сессия
+# важнее контекста.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
+ROOT="${CLAUDE_PROJECT_DIR:-.}"
+cd "$ROOT" 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)"
+
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+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" \
+    "$ROOT/.claude/rt-kit/defaults/project.sh" "$ROOT/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+handoff_dir="${RT_HANDOFF_DIR:-.claude/handoff}"
+map="$rt_hooks_dir/../rt-kit/defaults/turn-map.md"
+[ -f "$map" ] || map="$ROOT/.claude/rt-kit/defaults/turn-map.md"
+
+# Передача берётся по имени текущей ветки. Чужая, поданная как своя, описывает работу, которой
+# в этом дереве нет, — поэтому имя файла собирается из ветки, а не выбирается из каталога.
+handoff=''
+[ -n "$branch" ] && handoff="$ROOT/$handoff_dir/$branch.md"
+
+if [ -n "$handoff" ] && [ -r "$handoff" ]; then
+    printf 'ПЕРЕДАЧА ПРОШЛОГО ЗАХОДА — `%s/%s.md`, ниже целиком.\n\n' "$handoff_dir" "$branch"
+    printf 'Она написана прошлым заходом и описывает минуту, когда её собрали. Всё, что в ней\n'
+    printf 'стоит о дереве, проверяется деревом: команда этого хода главнее записанной вчера.\n\n'
+    cat "$handoff" 2>/dev/null
+    printf '\n\n'
+fi
+
+if [ -r "$map" ]; then
+    printf 'КАРТА ХОДА — состояния работы и то, чем ход кончается. Ниже целиком.\n\n'
+    printf 'Это выжимка правила ведения работы, а не оно само: правило объясняет, карта\n'
+    printf 'называет. Своё состояние заход читает в разделе «Где стоим» хода работы.\n\n'
+    cat "$map" 2>/dev/null
+    printf '\n'
+fi
+
+exit 0

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

@@ -0,0 +1,191 @@
+#!/usr/bin/env bash
+# rt-hook: Stop
+# Требует: hooks/deny-tail.sh
+# Страж выходов хода: ход, в котором по работе не сделано ничего, не заканчивается, пока работа
+# не отдана. Stop.
+#
+# Зачем именно так. Правило перечисляет четыре законных выхода хода — вопрос без ответа в
+# правилах, отказ гарда, заполненное окно, отданная работа с начатой следующей, — и держится
+# это памятью исполнителя. Держится плохо: ход, кончившийся отчётом о сделанном, выглядит
+# работой лучше всякой другой — он полон, в нём названы номера и состояния, и пустоты за ним не
+# видно ни владельцу, ни самому заходу. Владелец назвал это прямо: прерываться посреди работы
+# нельзя, и запрет должна держать машина.
+#
+# Что считается работой: правка файла и команда, меняющая дерево или его состояние. Чтение,
+# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал.
+#
+# Что отпускает ход:
+#   1. Работа отдана либо влита — состояние работы говорит об этом само.
+#   2. За ход была работа: правка файла или команда, меняющая дерево.
+#   3. Вопрос владельцу инструментом опроса.
+#   4. Отказ гарда — он кончает ход по правилу.
+#   5. Передача захода написана — окно кончилось.
+#   6. Владелец сказал остановиться.
+#
+# Чего страж не судит. Заход вне ветки задачи и работу без папки: состояние там объявлять
+# негде, и отбивать было бы не за что. Это его известная граница.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода, папки задачи
+# или строки состояния ход РАЗРЕШАЕТСЯ (exit 0). Сломанный страж не имеет права заклинить
+# разговор.
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
+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/utf8.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Локаль исполнения гарда. Подключается первой строкой тела: `. "<каталог гардов>/utf8.sh"`.
+#
+# Образцы гардов написаны словами того языка, на котором говорит дерево, и совпадение с ними
+# зависит от локали процесса. В локали C складывание регистра работает только для латиницы:
+# «В дереве этого нет» под образцом `(в дереве|здесь)…` не находится вовсе, гард выходит нулём
+# и пропускает ход, который обязан был вернуть. Счёт `{0,30}` там же считает байты, а не буквы,
+# и буква вне латиницы весит два.
+#
+# Заметить это на своей машине нечем: терминал разработчика идёт в UTF-8, а служба, запускающая
+# ту же работу, наследует пустую локаль. Три сценария так и падали в конвейере, проходя на
+# машине, где их писали.
+#
+# FAIL-OPEN: локали UTF-8 в системе не нашлось — ничего не объявляется, и гард работает как
+# прежде. Отобрать у него работу из-за отсутствия локали хуже, чем оставить прежнее поведение.
+
+rt_use_utf8_locale() {
+    case "${LC_ALL:-${LC_CTYPE:-${LANG:-}}}" in
+        *UTF-8* | *utf-8* | *UTF8* | *utf8*) return 0 ;;
+    esac
+
+    local available candidate
+    available="$(locale -a 2>/dev/null)" || return 0
+
+    for candidate in C.UTF-8 en_US.UTF-8 ru_RU.UTF-8; do
+        if printf '%s\n' "$available" | grep -qx -- "$candidate"; then
+            export LC_ALL="$candidate"
+            return 0
+        fi
+    done
+
+    return 0
+}
+
+rt_use_utf8_locale

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: Stop
+# Требует: hooks/deny-tail.sh
 # Гард ожидания: ход, сообщающий владельцу о чужом шаге, не заканчивается, пока в нём не было ни
 # одного действия по следующей задаче. Stop.
 #
@@ -29,6 +30,8 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
 # заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 
@@ -110,6 +113,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 .*
 # Заполнение окна: заход доводится до логической точки заранее, а не обрывается на середине.
 #
@@ -16,12 +16,21 @@
 # Место между порогами и есть то, на что закрывается заход: дописать ход работы, написать
 # передачу, закоммитить проверенное.
 #
+# Там, где дерево объявило порог сжатия ниже порога остановки, напоминание говорит обратное:
+# точку остановки выбирать не надо, потому что заход через порог пройдёт сам — сжатие придёт
+# первым, передачу к тому времени напишет свой хук, и работа продолжится тем же заходом. Отбой
+# при этом остаётся: он превращается из конца захода в страховку на случай, когда сжатие не
+# пришло. Напоминание, зовущее закрывать заход там, где закрывать его не надо, — это остановка
+# работы без причины, и стоит она ровно того же, что и отбой.
+#
 # Размер окна берётся из настройки дерева. Из записи захода он не выводится: модель записана
 # там без пометки о расширенном окне, и заход на широкое окно от захода на узкое неотличим.
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет размера окна, нет записи захода, нет разборщика, битый разбор —
 # работа РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
 
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
+
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
 
@@ -49,6 +58,21 @@ esac
 
 warn_pct="${RT_WINDOW_WARN_PCT:-40}"
 stop_pct="${RT_WINDOW_STOP_PCT:-50}"
+
+# Доля, на которой контекст сжимает сам инструмент. Объявлена деревом — заход через порог
+# проходит сам: сжатие приходит первым, передачу к тому моменту уже написал свой хук, и работа
+# идёт дальше тем же заходом. Не объявлена — прежний порядок: заход кончается передачей.
+#
+# От этого зависит текст напоминания, а не отказ. Отбой на пороге остановки остаётся в обоих
+# случаях: он и есть страховка на случай, когда сжатие не пришло — настройка снята, версия
+# другая, сжатие отказало. Отобрав отбой у дерева, объявившего сжатие, страж пустил бы такой
+# заход до предела окна, где работа теряется целиком.
+compact_pct="${CLAUDE_AUTOCOMPACT_PCT_OVERRIDE:-}"
+case "$compact_pct" in
+    '' | *[!0-9]*) compact_pct='' ;;
+esac
+[ -n "$compact_pct" ] && [ "$compact_pct" -ge "$stop_pct" ] 2>/dev/null && compact_pct=''
+
 tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
 handoff_dir="${RT_HANDOFF_DIR:-.claude/handoff}"
 
@@ -99,7 +123,13 @@ if [ "$event" = "PostToolUse" ]; then
     printf '%s' "$step" > "$mark" 2>/dev/null
 
     if [ "$pct" -ge "$stop_pct" ]; then
-        text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается."
+        if [ -n "$compact_pct" ]; then
+            text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Сжатие объявлено на ${compact_pct}% и не пришло: порог остановки ${stop_pct}% пройден, а контекст прежний. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается — закрывай заход и скажи владельцу, что сжатие не сработало."
+        else
+            text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k) — заход закрывается сейчас. Всё, кроме записи хода работы, передачи и команд поставки, уже отбивается."
+        fi
+    elif [ -n "$compact_pct" ]; then
+        text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k). Точку остановки выбирать не надо: на ${compact_pct}% инструмент сожмёт контекст сам, передачу к тому времени напишет хук, и работа пойдёт дальше этим же заходом. Порог остановки ${stop_pct}% — страховка на случай, если сжатие не придёт. Работай дальше."
     else
         text="ЗАПОЛНЕНИЕ ОКНА ${pct}% (${fill_k}k из ${window_k}k). Пора выбирать точку остановки: с ${stop_pct}% останется только закрыть заход. Доведи текущий шаг до состояния, с которого следующий заход продолжит, перепиши «Где стоим» в ходе работы, напиши передачу и отдай владельцу путь к ней — паттерн task-flow-handoff."
     fi
@@ -150,6 +180,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/laws/work-conduct.md

@@ -71,6 +71,15 @@
   владельца.** Владелец знает, что работа не кончена, но не знает, где именно она стоит;
   пересказ он даёт по своей памяти, а не по ходу работы, и следующий заход начинает с чужой
   картины.
+- **Переданное прошлым заходом приходит в новый заход само, а не кладётся рукой.** Передача,
+  написанная и не прочитанная, равна ненаписанной: следующий заход о ней не знает и начинает с
+  пустого места — то есть с того же, ради чего её и писали. Кладёт её человек ровно до тех пор,
+  пока это не поручено машине; поручённое машине не забывается ночью.
+- **Порядок ведения работы приходит в заход вместе с работой, а не разыскивается им.** Заход,
+  знающий задачу и не знающий, что с ней делают дальше, первым движением идёт читать правило
+  целиком — и тратит на это ту часть места, ради которой заход и начали заново. Приходит
+  короткая выжимка: состояния, обязательное действие каждого и то, чем ход кончается. Правило
+  она не заменяет и заменить не может — она отвечает на вопрос «что делать», а не «почему».
 - **Замысел и ход работы — разные записи.** Замысел — то, с чем сверяют результат при
   приёмке; правленный по ходу, он перестаёт отличаться от PR, и приёмке сверять нечего.
 - **Сделанное отмечается в одном месте.** Две записи об одном разъезжаются молча, и после
@@ -142,6 +151,26 @@
   остановиться позволяет только предел заполнения окна. Заход, закрытый на готовой задаче,
   оставляет владельцу пустое место и стоит целого захода на возвращение к тому, что и так было
   под рукой.
+- **Предел заполнения окна останавливает заход только там, где инструмент не сжимает контекст
+  сам.** Где сжатие объявлено и приходит раньше предела, окно — не конец захода, а его
+  продолжение: контекст сжимается, записанное состояние работы возвращается в него, и работа
+  идёт дальше тем же заходом. Останавливаться там незачем, а остановка стоит того же, что и
+  всякая другая: владелец возвращает исполнителя в работу руками.
+- **Порог, на котором заход останавливают, стоит позже порога, на котором его продолжают.**
+  Два порога на одном числе — это не согласие, а гонка, и выигрывает её тот, кто ближе к
+  действию: остановка приходит на вызове, а сжатие — между ходами. Расстояние между ними
+  объявляется, а не выводится разницей: сжатие идёт не мгновенно, и порог, отстоящий на волос,
+  требование «раньше» удовлетворяет, а работу не спасает.
+- **Переход из состояния в состояние исполнителя не останавливает.** Обязательное
+  действие сделано — следующее начинается тем же движением, без отчёта владельцу и без его
+  слова. Граница между состояниями выглядит законченным куском лучше всякой другой вехи:
+  сделанное названо, отчитаться есть чем, — и отчёт встаёт ровно на то место, где должно было
+  стоять следующее действие. Владелец читает такой отчёт как сделанную работу, а работа стоит.
+- **Текст, ведущий состояние работы, называет, что делается сразу за ним.** Дочитанный до
+  последнего приёма, он кончается ничем: следующего движения в нём нет, и исполнитель выводит
+  его из пустоты — то есть останавливается. Названное движение стоит там же, где приёмы, и
+  своими словами: одинаковая на все состояния строка перестаёт замечаться раньше, чем
+  понадобится.
 - **Работа, отданная на разбор, освобождает исполнителя, а не останавливает его.** Отданное на
   разбор ждёт владельца, а не машину: следующая задача эпика берётся тем же движением, которым
   предыдущая ушла на разбор.