@rt-tools/agent-kit 0.19.0 → 0.21.0

package/assets/hooks/handoff-write.sh

@@ -12,6 +12,16 @@
 # дерево — ветку, незакоммиченное и коммиты сверх главной. Ничего от себя он не добавляет:
 # передача пересказывает записанное, а не заменяет его.
 #
+# Кладётся она разделом в ход работы задачи — туда же, где лежит состояние. Свой файл вне дерева
+# передачу теряет при переходе на другую машину: каталог закрыт от истории, и работу, оборванную
+# заполнением окна, оттуда не подхватить — состояние есть в ходе работы, а особенности захода,
+# следующий шаг и то, чего делать не надо, остаются на прежней машине. Второй записи об одном и
+# том же при этом не заводится: раздел живёт в том же файле, что и «Где стоим», и уезжает в
+# ветку тем же коммитом. Коммитит его исполнитель — хук не знает, что ещё лежит в индексе.
+#
+# Файл вне дерева остаётся запасным путём: у работы без папки задачи — на отсоединённой голове,
+# на ветке без заведённой задачи — разделу лечь некуда, а молчание здесь стоит захода целиком.
+#
 # Написанное руками не затирается молча: файл один, и последняя запись побеждает. Исполнитель,
 # закрывающий заход по правилу, пишет поверх — его передача полнее, потому что он знает то,
 # чего на диске нет.
@@ -93,8 +103,15 @@ ahead="$(git log --oneline origin/main..HEAD 2>/dev/null | head -20)"
 
 target="$root/$handoff_dir/$handoff_name.md"
 
+# Заголовок раздела в ходе работы: по нему прежняя передача и находится.
+section='## Передача захода'
+
+# Собирается передача во временный файл: и раздел, и запасной путь пишут одно и то же, и второй
+# сборки для второго места не заводится.
+scratch="$(mktemp 2>/dev/null)" || exit 0
+
 {
-    printf '# Передача захода — сжатие контекста (%s)\n\n' "$trigger"
+    printf 'Собрана хуком перед сжатием контекста (%s).\n\n' "$trigger"
     printf '**Рабочее дерево:** %s\n' "$root"
     if [ -n "$branch" ]; then
         printf '**Ветка:** %s\n\n' "$branch"
@@ -103,22 +120,56 @@ target="$root/$handoff_dir/$handoff_name.md"
     fi
 
     if [ -n "$state" ]; then
-        printf '## Где стоим\n\n'
+        printf '### Где стоим на минуту сжатия\n\n'
         printf -- '- **Состояние:** %s\n' "$state"
         [ -n "$stage" ] && printf -- '- **Этап:** %s\n' "$stage"
         [ -n "$next_step" ] && printf -- '- **Следующий шаг:** %s\n' "$next_step"
         [ -n "$pull" ] && printf -- '- **PR:** %s\n' "$pull"
         printf '\nХод работы целиком — `%s/%s/progress.md`; замысел рядом с ним.\n\n' "$tasks_dir" "$branch"
     elif [ -z "$branch" ]; then
-        printf '## Где стоим\n\nИмени у головы нет, папки задачи при ней тоже: состояние работы взять неоткуда. Читающая сторона ищет передачу по имени ветки, а не найдя его — по последней записи каталога.\n\n'
+        printf '### Где стоим на минуту сжатия\n\nИмени у головы нет, папки задачи при ней тоже: состояние работы взять неоткуда. Читающая сторона ищет передачу по имени ветки, а не найдя его — по последней записи каталога.\n\n'
     else
-        printf '## Где стоим\n\nПапки задачи у этой ветки нет: состояние работы взять неоткуда.\n\n'
+        printf '### Где стоим на минуту сжатия\n\nПапки задачи у этой ветки нет: состояние работы взять неоткуда.\n\n'
     fi
 
-    printf '## Незакоммиченное\n\n```\n%s\n```\n\n' "$uncommitted"
-    printf '## Коммиты сверх главной\n\n```\n%s\n```\n\n' "$ahead"
+    printf '### Незакоммиченное\n\n```\n%s\n```\n\n' "$uncommitted"
+    printf '### Коммиты сверх главной\n\n```\n%s\n```\n\n' "$ahead"
     printf 'Написана хуком перед сжатием контекста. Всё, что здесь стоит, проверяется деревом:\n'
     printf 'передача пересказывает записанное и описывает минуту, когда её собрали.\n'
-} > "$target" 2>/dev/null
+} > "$scratch" 2>/dev/null
+
+[ -s "$scratch" ] || exit 0
+
+# Есть ход работы — передача ложится его разделом, и прежний такой раздел заменяется целиком:
+# дописанный вторым, он оставил бы в одном файле две правды об одной работе.
+if [ -n "$progress" ] && [ -f "$progress" ]; then
+    kept="$scratch.kept"
+    # Сравнение идёт байтами. Под локалью с национальными настройками `awk` этой системы считает
+    # разные кириллические строки равными — «## Где стоим» совпадало с «## Передача захода», — и
+    # выемка прежнего раздела сносила состояние работы вместе с ним. Виден промах только там, где
+    # локаль объявлена: у исполнителя с `C.UTF-8` набор зелёный, на прогоне конвейера — красный.
+    LC_ALL=C awk -v mark="$section" '
+        $0 == mark { skip = 1; next }
+        skip && /^## / && $0 != mark { skip = 0 }
+        !skip { print }
+    ' "$progress" > "$kept" 2>/dev/null || { rm -f "$scratch" "$kept"; exit 0; }
+
+    {
+        # Хвостовые пустые строки прежнего текста снимаются: раздел приписывается к нему через
+        # одну пустую строку, а не через сколько их там осталось.
+        awk 'BEGIN { blanks = 0 }
+            { if ($0 ~ /^[[:space:]]*$/) { blanks++; next }
+              while (blanks > 0) { print ""; blanks-- }
+              print }' "$kept"
+        printf '\n%s\n\n' "$section"
+        cat "$scratch"
+    } > "$progress.rt-handoff" 2>/dev/null \
+        && mv "$progress.rt-handoff" "$progress" 2>/dev/null
+
+    rm -f "$scratch" "$kept"
+    exit 0
+fi
+
+mv "$scratch" "$target" 2>/dev/null || rm -f "$scratch"
 
 exit 0

package/assets/hooks/override-write-guard.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # rt-hook: PreToolUse Write|Bash|mcp__webstorm__create_new_file|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
-# Требует: hooks/deny-tail.sh
+# Требует: hooks/deny-tail.sh, hooks/guard-note.sh
 # Гард затирания надстройки: запись поверх — не то же самое, что правка.
 #
 # Надстройка дерева сливается с ресурсом пакета по разделу «## »: раздел, который дерево
@@ -20,6 +20,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет `jq`, битый ввод, чужой инструмент, файла нет, файл пуст —
 # правка РАЗРЕШАЕТСЯ. Сломанный гард не имеет права заклинить работу.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=override-write-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
@@ -35,9 +38,6 @@ rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { printf ''; }
 
 deny() {
-    # shellcheck disable=SC1090
-    [ -f "$rt_hooks_dir/observe.sh" ] && . "$rt_hooks_dir/observe.sh" 2>/dev/null
-    command -v rt_note >/dev/null 2>&1 && rt_note guard-deny res=override-write-guard
 
     reason="$1 $(rt_deny_tail "$2")"
     jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \

package/assets/hooks/postmortem-guard.sh

@@ -21,6 +21,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, отсутствии записи хода и повторном заходе ход
 # РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=postmortem-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
@@ -40,9 +43,18 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 
 root="${CLAUDE_PROJECT_DIR:-.}"
 
-# Каталог записей у дерева свой. Заданный пустым — отказ дерева от требования: дереву, которое
-# записей не ведёт, гард не навязывается.
-notes_dir="${RT_POSTMORTEMS_DIR-docs/postmortems}"
+# Каталог записей у дерева свой, и называет его настройка дерева — тем же ключом, каким его
+# читает отправка груза. Одно имя на обе стороны: дерево, унёсшее каталог из истории, иначе
+# получало бы гард, ищущий записи по прежнему адресу, — и тот молчал бы всегда. Переменная
+# остаётся обходом на один запуск, а пустая строка в любой из двух — отказ дерева от требования:
+# дереву, которое записей не ведёт, гард не навязывается.
+if [ -n "${RT_POSTMORTEMS_DIR+set}" ]; then
+    notes_dir="$RT_POSTMORTEMS_DIR"
+elif [ -f "$root/.claude/rt-kit.json" ]; then
+    notes_dir="$(jq -r '.postmortems // "docs/postmortems"' "$root/.claude/rt-kit.json" 2>/dev/null)"
+else
+    notes_dir="docs/postmortems"
+fi
 [ -z "$notes_dir" ] && exit 0
 [ -d "$root/$notes_dir" ] || exit 0
 

package/assets/hooks/proposal-guard.sh

@@ -20,6 +20,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
 # заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=proposal-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/prose-style-guard.sh

@@ -12,6 +12,9 @@
 #
 # FAIL-OPEN: нет узла, нет проверки, чужой инструмент, не `.md` → пропуск.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=prose-style-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/qa-dataid-guard.sh

@@ -25,6 +25,9 @@
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет разборщика, битый ввод, чужой инструмент — пропуск.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=qa-dataid-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/rerun-guard.sh

@@ -20,6 +20,9 @@
 # похож на перезапуск — пропуск. Гард без номера судить не берётся: перезапуск последнего
 # упавшего прогона зовут и без него, а угадывать, о каком задании речь, значит отбивать наугад.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=rerun-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/reuse-first-guard.sh

@@ -32,6 +32,9 @@
 #
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет разборщика, битый ввод, чужой инструмент — пропуск.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=reuse-first-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/rule-article.sh

@@ -88,7 +88,7 @@ rt_rule_article_heads() {
 }
 
 rt_rule_article_at() {
-    awk -v mark="$2" '
+    LC_ALL=C awk -v mark="$2" '
         NR <= mark && /^- / { start = NR }
         { line[NR] = $0 }
         END {

package/assets/hooks/rule-source-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/deny-tail.sh, hooks/write-targets.sh
+# Требует: hooks/profile-check.sh, hooks/deny-tail.sh, hooks/write-targets.sh, hooks/guard-note.sh
 # Гард места правки: слой правил чинится там, где сломано, а не там, где виден.
 #
 # Слой правил правит тот же исполнитель, которым слой правил управляет, и разницы между
@@ -20,6 +20,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет `jq`, битый ввод, чужой инструмент, файла нет, шапки в нём нет,
 # не git-репозиторий — правка РАЗРЕШАЕТСЯ. Сломанный гард не имеет права заклинить работу.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=rule-source-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
@@ -43,9 +46,6 @@ command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2
 command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { printf ''; }
 
 deny() {
-    # shellcheck disable=SC1090
-    [ -f "$rt_hooks_dir/observe.sh" ] && . "$rt_hooks_dir/observe.sh" 2>/dev/null
-    command -v rt_note >/dev/null 2>&1 && rt_note guard-deny res=rule-source-guard
 
     reason="$1 $(rt_deny_tail "$2")"
     jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \

package/assets/hooks/sql-guard.sh

@@ -40,6 +40,9 @@
 # пропускаются целиком — иначе слова «drop» и «update» в описании коммита читались бы как
 # запрос. Доставки запроса внутри такой команды не бывает, так что цена послабления нулевая.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=sql-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

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

@@ -139,7 +139,7 @@ done
             cat "$PROGRESS"
         else
             # Раздел «Где стоим» перезаписывается каждым заходом и переживает любой объём.
-            awk '/^## Где стоим/{f=1} f&&/^## /&&!/^## Где стоим/{exit} f' "$PROGRESS"
+            LC_ALL=C awk '/^## Где стоим/{f=1} f&&/^## /&&!/^## Где стоим/{exit} f' "$PROGRESS"
             printf '\n<обрезано по объёму. Последние записи:>\n\n'
             tail -40 "$PROGRESS"
             printf '\n<читается целиком: %s>\n' "$PROGRESS"

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

@@ -23,6 +23,9 @@
 # FAIL-OPEN: нет jq, не git-репозиторий, битый ввод, чужой инструмент → пропуск. Сломанный
 # гард не должен мешать работать.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=task-flow-draft-guard
+
 rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Разбор вызова — общий у обоих гардов хода работы. Файл может быть не разложен: тогда судить

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

@@ -22,6 +22,9 @@
 # FAIL-OPEN: нет jq, не git-репозиторий, битый ввод, чужой инструмент → пропуск. Сломанный
 # гард не должен мешать работать.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=task-flow-guard
+
 rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Разбор вызова — общий у обоих гардов хода работы. Файл может быть не разложен: тогда судить

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

@@ -39,11 +39,36 @@ map="$rt_hooks_dir/../rt-kit/defaults/turn-map.md"
 [ -f "$map" ] || map="$ROOT/.claude/rt-kit/defaults/turn-map.md"
 
 # Передача берётся по имени текущей ветки. Чужая, поданная как своя, описывает работу, которой
-# в этом дереве нет, — поэтому имя файла собирается из ветки, а не выбирается из каталога.
+# в этом дереве нет, — поэтому и раздел, и файл ищутся по ветке, а не выбираются из каталога.
+#
+# Мест два, и порядок между ними один. Передача ветки с папкой задачи лежит разделом её хода
+# работы: он коммитится и едет в ветку, поэтому переживает переход на другую машину. Файл вне
+# дерева — запасной путь: у работы без папки задачи разделу лечь некуда. Найдя раздел, файл не
+# читают: это одна и та же передача, и вторая копия старше первой.
+tasks_dir="${RT_TASKS_DIR:-docs/tasks}"
+progress=''
+[ -n "$branch" ] && progress="$ROOT/$tasks_dir/$branch/progress.md"
+
+section=''
+if [ -n "$progress" ] && [ -r "$progress" ]; then
+    # Сравнение байтами: под локалью с национальными настройками `awk` этой системы считает
+    # разные кириллические заголовки равными, и вход читал бы разделом передачи первый попавшийся.
+    section="$(LC_ALL=C awk '
+        $0 == "## Передача захода" { skip = 1; next }
+        skip && /^## / { skip = 0 }
+        skip { print }
+    ' "$progress" 2>/dev/null)"
+fi
+
 handoff=''
 [ -n "$branch" ] && handoff="$ROOT/$handoff_dir/$branch.md"
 
-if [ -n "$handoff" ] && [ -r "$handoff" ]; then
+if [ -n "$section" ]; then
+    printf 'ПЕРЕДАЧА ПРОШЛОГО ЗАХОДА — раздел «Передача захода» в `%s/%s/progress.md`, ниже целиком.\n\n' "$tasks_dir" "$branch"
+    printf 'Она написана прошлым заходом и описывает минуту, когда её собрали. Всё, что в ней\n'
+    printf 'стоит о дереве, проверяется деревом: команда этого хода главнее записанной вчера.\n\n'
+    printf '%s\n\n' "$section"
+elif [ -n "$handoff" ] && [ -r "$handoff" ]; then
     printf 'ПЕРЕДАЧА ПРОШЛОГО ЗАХОДА — `%s/%s.md`, ниже целиком.\n\n' "$handoff_dir" "$branch"
     printf 'Она написана прошлым заходом и описывает минуту, когда её собрали. Всё, что в ней\n'
     printf 'стоит о дереве, проверяется деревом: команда этого хода главнее записанной вчера.\n\n'

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

@@ -34,6 +34,9 @@
 # или строки состояния ход РАЗРЕШАЕТСЯ (exit 0). Сломанный страж не имеет права заклинить
 # разговор.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=turn-exit-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
@@ -166,7 +169,7 @@ work_re='git (add|commit|push|checkout|merge|rm)|npm run|pnpm (run|exec)|nx (bui
 # подтягивание, просмотр истории, чтение заявок и прогонов. Образец работы называет их работой,
 # потому что знает только первое слово — `git` и `gh` стоят в нём целиком, — и ход, в котором
 # исполнитель перешёл на главную ветку, прочитал историю и написал владельцу отчёт, выходил
-# отсюда нулём. Разбор — `docs/postmortems/2026-08-25-read-only-turn-counted-as-work.md`.
+# отсюда нулём. Разбор — запись «2026-08-25-read-only-turn-counted-as-work» в приёме.
 #
 # Разведка выглядит работой лучше всего остального: в ней команды, числа и точные ответы. Тем
 # она и опасна — ход, набитый ею, читается как полный и владельцем, и самим заходом.
@@ -179,7 +182,7 @@ part_re='&&|\|\||;|\n'
 # Ожидание чужого шага. Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда
 # быстрее не становятся — правило прямо говорит, что состоянием работы это не бывает. Судится
 # только ПОСЛЕДНЕЕ действие хода: ожидание в середине законно, а запуск работы в фоне работой
-# остаётся. Разбор — `docs/postmortems/2026-08-25-turn-ended-on-waiting.md`.
+# остаётся. Разбор — запись «2026-08-25-turn-ended-on-waiting» в приёме.
 #
 # Прежний признак спрашивал одно: была ли за ход работа. Ход, где разобран конфликт, сделаны
 # коммит и пуш, а последним действием стал цикл до готовности прогона, проходил его целиком —
@@ -264,7 +267,7 @@ commands="$(printf '%s' "$verdict" | jq -r '.ran // ""' 2>/dev/null)"
 # Ровно так ход и вставал: задача взята, номер назван владельцу, отчёт написан — и следующее
 # действие состояния «задача-взята», написать замысел, не сделано. Отчёт выглядит работой лучше
 # всякой другой, а страж, знающий только «была ли за ход работа», подтверждает это: работа была.
-# Разбор — `docs/postmortems/2026-08-25-task-taken-and-turn-ended.md`.
+# Разбор — запись «2026-08-25-task-taken-and-turn-ended» в приёме.
 #
 # Папка, разобранная коммитом ветки, сюда не попадает: `archived` означает отданную работу, и её
 # судит прежний ярус. Ветка без номера задачи не судится вовсе — под пробу заводят и такие.
@@ -332,7 +335,7 @@ fi
 # вся она по сданной задаче: отдача завершает прошлую работу, а не ход. Девять разборов
 # происшествий за сутки описывают девять разных остановок, и во всех девяти последним действием
 # хода был текст владельцу: отчёт, сводка, объявление намерения.
-# Разбор — `docs/postmortems/2026-08-25-handover-turn-ends-on-intent.md`.
+# Разбор — запись «2026-08-25-handover-turn-ends-on-intent» в приёме.
 if [ "$handed_over" = "true" ] && [ "$started_next" != "true" ]; then
     reason="BLOCKED by turn-exit-guard: заявка открыта, а по следующей работе за этот ход не сделано ничего.
 
@@ -385,7 +388,7 @@ fi
 # Работа, оставшаяся в рабочем дереве. Ветка ушла вперёд своей удалённой ссылки, а заявки при
 # ней в этом ходе не открывали: сделанное лежит там, где его не видит никто, кроме сделавшего.
 # Признак читается без сети и молчит там, где ссылки нет вовсе — под пробу заводят и такие ветки.
-# Разбор — `docs/postmortems/2026-08-25-fifteen-branches-over-one-index.md`.
+# Разбор — запись «2026-08-25-fifteen-branches-over-one-index» в приёме.
 if [ "$worked" = "true" ] && [ "$handed_over" != "true" ]; then
     unpushed="$(git -C "$root" rev-list --count '@{u}..HEAD' 2>/dev/null)"
     if [ -n "$unpushed" ] && [ "$unpushed" -gt 0 ] 2>/dev/null; then

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

@@ -19,9 +19,10 @@
 # Спросить хостинг было бы точнее, но сетевой вызов на завершении хода падает вместе со связью и
 # отбивал бы работу вместо промаха.
 #
-# Что считается действием: заведение задачи, заведение ветки, перевод колонки очереди работ,
-# заведение папки задачи. Набор открыт и пополняется правкой — полнота его открытый вопрос, а не
-# обещание.
+# Что считается действием: заведение задачи, заведение ветки, перевод задачи в колонку работы,
+# заведение папки задачи. Перевод в колонку разбора и снятие папки сюда не входят — это шаги
+# закрытия прежней работы, а не начало следующей. Набор открыт и пополняется правкой — полнота
+# его открытый вопрос, а не обещание.
 #
 # Чего гард не судит. Ход, в котором о чужом шаге не сказано ничего, — здесь он молчит: пустой
 # ход неотличим от хода, которому нечего было делать. Это известная его граница. Зелёный прогон
@@ -30,6 +31,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, нехватке `jq`, отсутствии записи хода и повторном
 # заходе ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=waiting-turn-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 
@@ -58,10 +62,23 @@ opened_re='gh[^|;&]*pr[[:space:]]+create|api[^|;&]*-X[[:space:]]+POST[^|;&]*/pul
 read_re='run[[:space:]]+(list|view|watch)|pipelines[[:space:]]+runs'
 red_re='completed[[:space:]]+failure|"conclusion"[[:space:]]*:[[:space:]]*"failure"|conclusion:[[:space:]]*failure|completed with .failure.|run[[:space:]]+failed'
 
-# Первое действие по следующей задаче. Заведение папки стоит здесь наравне с командами: работа
-# по уже заведённому номеру начинается именно с неё. Правка кода в ветке того же PR действием
-# по следующей задаче не считается — она чинит прежнюю, а не двигает работу дальше.
-moved_re='task:new|task:move|checkout[[:space:]]+-b|docs/tasks/'
+# Первое действие по следующей задаче. Перечисляется то, чем взятие БЫВАЕТ, а не то, что
+# действием считается: список шагов закрытия работы открыт и растёт, а список действий по
+# следующей задаче закрыт — у перечня «что бывает» дыры закрывающего шага нет.
+#
+# Перевода закрываемой задачи в колонку разбора и снятия её папки здесь нет намеренно: оба —
+# обязательные шаги закрытия работы, и оба стоят в том же ходе, которым открыт PR. Пока признак
+# перечислял их наравне со взятием, он совпадал всегда, и гард отпускал ход, ради которого
+# заведён, — работа так вставала трижды за один заход.
+#
+# Правка кода в ветке того же PR действием по следующей задаче не считается — она чинит
+# прежнюю, а не двигает работу дальше.
+taken_re='task:new|checkout[[:space:]]+-b|task:move[^|;&]*in-progress|(cp|mkdir)[^|;&]*/tasks/'
+
+# Заведение папки задачи идёт и не оболочкой: инструмент правки файла пишет её первым файлом, и
+# командной строки за этим нет вовсе. Поэтому рядом с командами судится путь правки — у него
+# свой образец, потому что имени команды в нём нет.
+taken_path_re='/tasks/'
 
 # Чем ход показывает, что отданную работу он довёл до конца, а не бросил черновиком. Снятие
 # черновика — очевидный случай; чтение прогона — тот, где снимать ещё нечего, но исполнитель
@@ -81,8 +98,8 @@ vow_re='дальше беру|дальше возьму|дальше иду|сл
 #
 # Хвост в 400 строк: запись хода растёт всю сессию, а судится только последний ход.
 verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
-    --arg opened "$opened_re" --arg moved "$moved_re" --arg read "$read_re" --arg red "$red_re" \
-    --arg ready "$ready_re" --arg vow "$vow_re" '
+    --arg opened "$opened_re" --arg taken "$taken_re" --arg taken_path "$taken_path_re" \
+    --arg read "$read_re" --arg red "$red_re" --arg ready "$ready_re" --arg vow "$vow_re" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -93,6 +110,10 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
     | (if $i == null then [] else .[$i:] end) as $turn
     | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "tool_use")] as $uses
     | ($uses | map((.input.command // "")) | join("\n")) as $ran
+    # Путь правки — второй способ завести папку задачи. Судятся только инструменты письма: у
+    # чтения путь тот же, а работой оно не является.
+    | ($uses | map(select(.name == "Write" or .name == "Edit" or .name == "MultiEdit")
+          | (.input.file_path // "")) | join("\n")) as $wrote
     # Ответ инструмента берётся текстом, а не в записи JSON: у той таб и кавычка уезжают
     # экранированными, и образец по ним не попадает вовсе. Приходит он и строкой, и списком
     # блоков — обе формы сводятся к одному тексту.
@@ -103,7 +124,7 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r \
             else tostring end] | join("\n")) as $out
     | ($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
+    | (($ran | test($taken; "i")) or ($wrote | test($taken_path; "i"))) as $went_on
     | ($ran | test($ready; "i")) as $checked
     | ([$turn[] | select(.type == "assistant") | (.message.content // [])[]
           | select(.type == "text") | .text] | join("\n")) as $said

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

@@ -29,6 +29,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет размера окна, нет записи захода, нет разборщика, битый разбор —
 # работа РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=window-fill-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

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

@@ -28,6 +28,9 @@
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет `jq`, нет записи хода, нет признака дерева, повторный заход, любая
 # своя ошибка — ход РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить работу.
 
+# Своё имя в наблюдениях: отбой пишет общий хвост отказа, а не сам гард.
+RT_GUARD_NAME=work-start-guard
+
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/hook-input.sh" 2>/dev/null || true
 

package/assets/hooks/write-targets.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Цели записи, названные командой оболочки прямо: перенаправление, `tee`, правка на месте,
-# копирование поверх. Печатает по одной в строке.
+# копирование поверх, а у интерпретатора — пути из его тела. Печатает по одной в строке.
 #
 # Строки `# rt-hook:` здесь нет намеренно: это помощник, а не хук. Он ничего не решает сам и
 # зовётся оттуда, где судят правку файла, — гардом места правки и гардом экзамена. Общий он
@@ -10,15 +10,64 @@
 # Общий признак записи здесь не берётся намеренно — он широк, в нём и имя интерпретатора, и
 # запуск разложенной проверки читался бы как правка её самой. Снятие копии сюда тоже не входит:
 # снятый файл раскладка кладёт заново, и так чинят копию, которую переписал форматтер.
+#
+# Интерпретатор с кодом в доводе или в теле — особый случай, и без него у гардов была дыра
+# ровно в ту сторону, которой правят чаще всего. Путь записи стоит там внутри кода — в вызове
+# записи файла, — и ни одним из образцов выше не ловится: команда снаружи выглядит запуском
+# интерпретатора, а не записью. Разложенную копию так правили молча, и ловила это уже раскладка
+# — на сборке, когда правка написана целиком и переносить её приходится руками.
+#
+# Разбирать чужой язык нечем, и здесь не разбирают: из тела берётся всё путеподобное, а решает
+# по нему зовущий — гард места правки отбивает лишь то, что несёт шапку раскладки. Цена названа
+# прямо: чтение файла интерпретатором судится наравне с записью в него. Читают в оболочке
+# другим — `cat`, `grep`, `sed -n`, — а интерпретатор, которому назвали путь разложенной копии,
+# почти всегда её и правит.
 
 rt_write_targets() {
-    tr "\"'\`" '   ' \
-        | sed -E 's/>>?/\n>/g' \
-        | sed -nE '
-            s/^>[[:space:]]*([^[:space:]|&;]+).*/\1/p
-            s/(^|.*[[:space:]])tee[[:space:]]+(-a[[:space:]]+)?([^[:space:]|&;]+).*/\3/p
-            s/(^|.*[[:space:]])sed[[:space:]]+-i[[:space:]]+([^[:space:]]+[[:space:]]+)*([^[:space:]|&;]+)$/\3/p
-            s/(^|.*[[:space:]])(cp|mv|install)[[:space:]]+([^[:space:]]+[[:space:]]+)+([^[:space:]|&;]+).*/\4/p
-        ' \
-        | sort -u
+    rt_wt_text="$(cat)"
+
+    {
+        printf '%s' "$rt_wt_text" \
+            | tr "\"'\`" '   ' \
+            | sed -E 's/>>?/\n>/g' \
+            | sed -nE '
+                s/^>[[:space:]]*([^[:space:]|&;]+).*/\1/p
+                s/(^|.*[[:space:]])tee[[:space:]]+(-a[[:space:]]+)?([^[:space:]|&;]+).*/\3/p
+                s/(^|.*[[:space:]])sed[[:space:]]+-i[[:space:]]+([^[:space:]]+[[:space:]]+)*([^[:space:]|&;]+)$/\3/p
+                s/(^|.*[[:space:]])(cp|mv|install)[[:space:]]+([^[:space:]]+[[:space:]]+)+([^[:space:]|&;]+).*/\4/p
+            '
+
+        # Тело интерпретатора: код приходит доводом `-c`, доводом `-e` либо телом heredoc, и
+        # путь записи стоит внутри него. Берётся именно тело, а не вся команда: составная
+        # строка, в которой heredoc пишет один файл, а рядом запускается проверка, отдала бы
+        # путь этой проверки как цель записи — и запуск разложенной проверки снова читался бы
+        # правкой её самой.
+        printf '%s\n' "$rt_wt_text" | awk '
+            function emit(s,   n, i, parts) {
+                n = split(s, parts, /[^A-Za-z0-9_.@\/-]+/)
+                for (i = 1; i <= n; i++) {
+                    if (parts[i] ~ /\// && parts[i] ~ /\.[A-Za-z0-9]+$/) { print parts[i] }
+                }
+            }
+            function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
+            tag != "" {
+                if (trim($0) == tag) { tag = ""; next }
+                if (keep) { emit($0) }
+                next
+            }
+            {
+                # Код доводом: всё, что стоит за `-c` или `-e` у интерпретатора.
+                if ($0 ~ /(^|[|;&(]|[ \t])(python3?|node|ruby|perl|php|deno|bun)([ \t]|$)/ \
+                    && match($0, /[ \t]-[ce][ \t]/)) {
+                    emit(substr($0, RSTART + RLENGTH))
+                }
+                # Тело heredoc: путь записи интерпретатора стоит именно там.
+                if (match($0, /<<-?[ \t]*[\047\"]?[A-Za-z_][A-Za-z0-9_]*/)) {
+                    t = substr($0, RSTART, RLENGTH)
+                    sub(/^<<-?[ \t]*[\047\"]?/, "", t)
+                    tag = t
+                    keep = ($0 ~ /(^|[|;&(]|[ \t])(python3?|node|ruby|perl|php|deno|bun)([ \t]|$)/)
+                }
+            }'
+    } | sort -u
 }

package/assets/laws/delivery.md

@@ -63,6 +63,11 @@
   ни умолчания: работа с очередью отказывает и говорит, где он задаётся. Пустой ключ хуже
   отсутствующей проверки — от имени остаётся огрызок, которому ничто не отвечает, и правильно
   названной не выглядит ни одна задача.
+- **Заведённое в очереди работ видно той стороне, для которой заводилось.** Учётная запись, чьи
+  объекты хостинг показывает не всем, оставляет за собой работу, которой для остальных не
+  существует, — и снаружи это неотличимо от сделанного: задача заведена, PR открыт, а владелец
+  видит пустую очередь. Видимость проверяется чужими глазами — чтением очереди тем, кому она
+  адресована, — а не успешным ответом команды заведения.
 - **У задачи есть исполнитель с момента её заведения.** Задача без исполнителя выглядит ничьей: по
   очереди работ не видно, кто её взял, и заведённая по ходу правка теряется среди чужих.
 - **Состояние задачи в очереди работ отвечает тому, что с ней происходит.** Взятая в работу видна