@rt-tools/agent-kit 0.16.1 → 0.18.0

package/assets/hooks/grill-gate.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
-# rt-hook: PreToolUse AskUserQuestion
 # Требует: hooks/deny-tail.sh
 # rt-hook: Stop
 # Гард разговора: вопрос владельцу не задаётся, пока за этот же ход не читались законы и
-# правила. Стоит на двух событиях, и это не дублирование.
+# правила. Судит два события, и это не дублирование; второе объявлено соседним ресурсом
+# `hooks/grill-gate-ask.sh`, который отдаёт вызов сюда.
 #
 # Зачем именно так. Требование «правила читаются до разговора» исполнимо ровно до отправки
 # вопроса. Проверка на завершении хода отбивает задним числом: к моменту отказа вопрос уже у
@@ -13,12 +13,23 @@
 # Одним этим перехватом дыра не закрывается: вопрос чаще задаётся прозой, и ровно так был задан
 # тот, из-за которого гард заведён. Прозаический вопрос инструментом не является, и поймать его
 # можно только на завершении хода — событие получает путь к записи хода и видит его целиком.
-# Отсюда два события: меню ловится до отправки, проза — после.
+# Отсюда два события: меню ловится до отправки, проза — после. Объявлены они разными ресурсами
+# затем, чтобы дерево, у которого инструмент вопроса занят своим гардом, могло взять половину, а
+# не отказаться от требования целиком.
 #
 # Чтением правил считается любой из трёх путей: загрузка правила, чтение файла законов или
 # правил, поиск по ним. Требовать именно загрузку значило бы гнать на неё там, где хватило
 # одного поиска, — гард мешал бы работе вместо того, чтобы её выправлять.
 #
+# Но чтение чего угодно из слоя правил вопроса не закрывает: прочитанный разбор чужого промаха
+# и поиск по каталогу засчитывались наравне с правилом, которое этой работе и требуется, — а
+# ответ на заданный владельцу вопрос лежал ровно в нём. Поэтому, когда область работы этого хода
+# известна, чтением считается только правило этой области. Область берётся оттуда же, откуда её
+# берёт гейт правил: по путям правок хода.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ и здесь: правок в ходу нет, карты гейта нет, область не определилась —
+# засчитывается любое чтение, как прежде.
+#
 # ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, отсутствии записи хода и повторном заходе ход
 # РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
 
@@ -57,15 +68,56 @@ done
 laws_dir="${RT_LAWS_DIR-docs/constitution}"
 rules_dir="${RT_RULES_DIR-.claude/skills}"
 specs_dir="${RT_SPECS_DIR-docs/specs}"
+# Замысел эпика и описание прошлого читаются наравне с законами: решение, связывающее задачи
+# эпика, лежит именно там. Прочитавший замысел получал отказ наравне с не читавшим ничего, и
+# снимался тот отказ поиском по трём каталогам, среди которых нужного не было.
+plans_dir="${RT_PLANS_DIR-docs/plans}"
+archive_dir="${RT_ARCHIVE_DIR-docs/archive}"
 
 # Дерево, у которого нет ни законов, ни правил, требования не получает: читать нечего.
 [ -z "$laws_dir" ] && [ -z "$rules_dir" ] && exit 0
 
+# Карта гейта: по ней имя правила достаётся из пути правки. Нет её — область не определяется, и
+# всё остаётся прежним.
+rt_hooks_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for map in "$rt_hooks_dir/../rt-kit/defaults/gate-map.sh" "$rt_hooks_dir/../defaults/gate-map.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/gate-map.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/gate-map.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$map" ] && . "$map" 2>/dev/null
+done
+
 # Образец, по которому вызов инструмента считается чтением правил. Каталоги идут в него как
 # есть: точка в `.claude` совпадает с любым знаком и лишнего сюда не приводит.
-read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
+read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir|$plans_dir|$archive_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
 [ -z "$read_re" ] && exit 0
 
+# Область работы этого хода: правила, которых требует гейт от путей, правленных в ходу. Пути
+# достаются тем же разбором хода, что и ниже, — своим вызовом, чтобы образец чтения был готов
+# к главному разбору.
+need_re=''
+if command -v skill_for >/dev/null 2>&1 && [ -n "$rules_dir" ]; then
+    edited="$(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 == "tool_use") | select(.name == "Edit" or .name == "Write" or .name == "NotebookEdit")
+            | (.input.file_path // .input.notebook_path // "")]
+        | map(select(. != "")) | unique | .[]
+    ' 2>/dev/null)"
+    for path in $edited; do
+        for rule in $(skill_for edit "$path" '' 2>/dev/null); do
+            case "|$need_re|" in
+                *"|$rule|"*) ;;
+                *) need_re="${need_re}${need_re:+|}${rule}" ;;
+            esac
+        done
+    done
+fi
+
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью `user`, поэтому строки с `tool_result` вводом не считаются: иначе ходом
 # оказался бы кусок после последнего вызова инструмента, и чтение правил в его начале потерялось
@@ -75,7 +127,7 @@ read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir" | sed 's/^|*//; s/|*$//
 # На событии вызова инструмента вопрос уже известен — он и есть вызов; судится только то,
 # читались ли за этот ход правила. На завершении хода вопрос ищется в тексте реплик: меню к
 # этому моменту уже отбито раньше.
-verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re" --arg tool "$tool" '
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re" --arg tool "$tool" --arg need "$need_re" --arg rules "$rules_dir" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -86,11 +138,23 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_re"
     | (if $i == null then . else .[$i + 1:] end) as $turn
     | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "text") | .text] as $texts
     | [$turn[] | select(.type == "assistant") | (.message.content // [])[] | select(.type == "tool_use")] as $uses
-    | ($uses | map(
-          (.name == "Skill")
-          or ((.name // "") | test("^(Read|Grep|Glob)$")) and ((.input | tostring) | test($re))
-          or ((.name == "Bash") and ((.input.command // "") | test($re)))
-      ) | any) as $read
+    | (if $need == "" then
+          $uses | map(
+              (.name == "Skill")
+              or ((.name // "") | test("^(Read|Grep|Glob)$")) and ((.input | tostring) | test($re))
+              or ((.name == "Bash") and ((.input.command // "") | test($re)))
+          ) | any
+      else
+          # Область работы известна — засчитывается только правило этой области: прочитанный
+          # разбор чужого промаха на заданный вопрос не отвечает.
+          ($need | split("|")) as $rules_needed
+          | $uses | map(
+              ((.name == "Skill") and (((.input.skill // "") | tostring) as $s | $rules_needed | index($s) != null))
+              or (((.name // "") | test("^(Read|Grep|Glob|Bash)$"))
+                  and ((.input | tostring) as $text
+                       | $rules_needed | map(. as $rule | $text | test($rules + "/" + $rule + "(/|\\b)")) | any))
+          ) | any
+      end) as $read
     | (($texts | join("\n")) | test("\\?[[:space:]]*$"; "m")) as $asked_prose
     | ($tool != "") as $asking_now
     | if ($asked_prose or $asking_now) and ($read | not) then "ask" else "pass" end
@@ -106,7 +170,7 @@ fi
 
 reason="$head Вопрос, ответ на который уже записан, владельцу не задаётся — правило ведения работы. Прогони поиск по словам темы и ответь по найденному; спрашивай только то, что документацией не покрыто:
 
-    grep -rn -i \"<слово темы>\" $laws_dir $rules_dir $specs_dir
+    grep -rn -i \"<слово темы>\" $laws_dir $rules_dir $specs_dir $plans_dir $archive_dir
 
 Гард судит один ход: следующий заход не отбивается."
 

package/assets/hooks/lint-after-edit.sh

@@ -3,11 +3,15 @@
 # Требует: hooks/profile-check.sh
 # Линтер по следам правки. PostToolUse.
 #
-# Два входа. Правка файла — линтуется один изменённый файл. Перенос файла командой — линтуются
-# файлы по адресу назначения: перенос меняет либу, а вместе с ней и границы, и импорт, законный
-# на прежнем месте, на новом уже запрещён. Ровно так запрещённый импорт уезжает в общую либу
-# молча: файлы перекладываются командой, хук на неё не смотрит, и правило границ сработало бы —
-# но его никто не запустил.
+# Два входа. Правка файла — линтуется один изменённый файл. Команда оболочки — линтуется то,
+# что она записала: перенос меняет либу, а вместе с ней и границы, и импорт, законный на прежнем
+# месте, на новом уже запрещён; запись перенаправлением, дозаписью или интерпретатором меняет
+# сам файл, и линтера он прежде не получал вовсе. Ровно так запрещённый импорт уезжает в общую
+# либу молча, а правленая проверка выходит из-под форматтера: правило сработало бы — но его
+# никто не запустил.
+#
+# Что команда пишет и куда, знает профиль дерева, и знает он это одним способом для всех: тот
+# же признак читает гейт правил.
 #
 # Полный набор гоняет гард на пуше, но это конец работы: к моменту, когда правило срабатывает,
 # поверх нарушения лежит десяток правок, и разбор превращается в археологию. Здесь тот же
@@ -19,6 +23,8 @@
 #
 # Что здесь чем зовётся, знает профиль дерева:
 #   rt_lint_for      — чем линтуется этот файл;
+#   rt_shell_writes  — пишет ли эта команда;
+#   rt_shell_paths   — какие пути она записала;
 #   rt_is_app_code   — где лежит код, к которому линтеры вообще относятся;
 #   RT_LINT_SKIP_RE  — что из него исключено;
 #   rt_push_checks   — что гоняет гейт пуша. По нему же решается, догонит ли замечание позже:
@@ -46,14 +52,12 @@ case "$tool" in
     *) exit 0 ;;
 esac
 
-# Отсев до всякой работы: хук висит на каждой команде оболочки, а перенос среди них — редкость.
+# Отсев до всякой работы: хук висит на каждой команде оболочки, а пишет из них меньшинство.
+# Пустая команда отсеивается здесь же — признак записи у неё спрашивать не о чем.
 command_text=""
 if [ "$mode" = "move" ]; then
     command_text="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
-    case "$command_text" in
-        *"git mv "*) ;;
-        *) exit 0 ;;
-    esac
+    [ -z "$command_text" ] && exit 0
 fi
 
 workdir="$(rt_hook_cwd)"
@@ -75,6 +79,15 @@ done
 command -v rt_needs >/dev/null 2>&1 || rt_needs() { command -v "$1" >/dev/null 2>&1; }
 rt_needs rt_lint_for lint-after-edit || exit 0
 
+# Признак записи спрашивается после профиля: до него функций ещё нет. Дерево, которое признака
+# не объявило, остаётся при прежнем поведении — разбирается один перенос.
+if [ "$mode" = "move" ] && rt_needs rt_shell_writes lint-after-edit; then
+    case "$command_text" in
+        *"git mv "*) ;;
+        *) rt_shell_writes "$command_text" || exit 0 ;;
+    esac
+fi
+
 # --- какие файлы проверяем -------------------------------------------------------------
 
 # Пути назначения всех переносов в команде. Команда бывает составной, поэтому режется по
@@ -136,7 +149,17 @@ if [ "$mode" = "edit" ]; then
     esac
     candidates="$(expand "$path")"
 else
-    candidates="$(collect_moved "$command_text" | while IFS= read -r moved; do expand "$moved"; done)"
+    # Перенос разворачивает каталог: он двигает целые слои. Запись — нет: пишут всегда в файл,
+    # а каталог в команде записи — это рабочий каталог, и развёрнутый он отдаёт линтеру половину
+    # дерева. Поэтому у записанных путей берутся только существующие файлы.
+    written=""
+    if rt_needs rt_shell_paths lint-after-edit; then
+        written="$(rt_shell_paths "$command_text" 2>/dev/null | while IFS= read -r path; do
+            [ -f "$path" ] && printf '%s\n' "$path"
+        done)"
+    fi
+    candidates="$( { collect_moved "$command_text" | while IFS= read -r moved; do expand "$moved"; done
+        printf '%s\n' "$written"; } | sort -u)"
 fi
 
 [ -z "$candidates" ] && exit 0
@@ -214,11 +237,16 @@ else
     tail_line="Почини их сейчас: этот линтер в гейт пуша не входит, и отложенное замечание уедет в главную ветку молча."
 fi
 
-if [ "$mode" = "move" ]; then
-    head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ПЕРЕНОСА. Перенос меняет либу, а вместе с ней границы: импорт, законный на прежнем месте, на новом может быть запрещён."
-else
-    head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ:"
-fi
+case "$mode:$command_text" in
+    # Перенос назван отдельно: замечание после него объясняется не правкой файла, а сменой его
+    # места, и без этой строки читатель ищет промах в тексте, которого никто не менял.
+    move:*"git mv "*)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ПЕРЕНОСА. Перенос меняет либу, а вместе с ней границы: импорт, законный на прежнем месте, на новом может быть запрещён." ;;
+    move:*)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ ПОСЛЕ ЗАПИСИ КОМАНДОЙ:" ;;
+    *)
+        head_line="ЛИНТЕР (${linters}) НАШЁЛ ЗАМЕЧАНИЯ:" ;;
+esac
 
 ctx="${head_line}
 ${report}

package/assets/hooks/proposal-guard.sh

@@ -38,16 +38,24 @@ transcript="$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/nu
 [ -f "$transcript" ] || exit 0
 
 # Каталог предложений у дерева свой. Заданный пустым — отказ дерева от требования: дереву, не
-# берущему переносимый слой правил, гард не навязывается.
+# берущему переносимый слой правил, гард не навязывается. Каталога нет на диске — то же самое:
+# дерево механизмом не пользуется, и стража ему не навязывают. Судить по одной переменной значило
+# бы требовать отправки там, где отправлять нечем и некуда.
+root="${CLAUDE_PROJECT_DIR:-.}"
 proposals_dir="${RT_PROPOSALS_DIR-.claude/rt-kit/proposals}"
 [ -z "$proposals_dir" ] && exit 0
+[ -d "$root/$proposals_dir" ] || exit 0
 
 # Просьба владельца. Набор открыт и пополняется правкой: полнота его — открытый вопрос
 # договорённости, а не обещание.
-asked_re='(завед|напиш|отправ|пошл|зашл|отошл|выгруз)[а-яё]*[^.!?]{0,40}(пропозал|предложени)|(пропозал|предложени)[а-яё]*[^.!?]{0,40}(завед|напиш|отправ|пошл|зашл|отошл|выгруз)'
+#
+# Латиница читается наравне: заход, который владелец ведёт по-английски, отличается от русского
+# словами, а требование в нём то же. Своей ветки ей не заводится — обе пары стоят в одном
+# образце, иначе одну из них правили бы, забывая про вторую.
+asked_re='(завед|напиш|отправ|пошл|зашл|отошл|выгруз|send|file|open|submit|raise|report)[а-яёa-z]*[^.!?]{0,40}(пропозал|предложени|proposal)|(пропозал|предложени|proposal)[а-яёa-z]*[^.!?]{0,40}(завед|напиш|отправ|пошл|зашл|отошл|выгруз|send|file|open|submit|raise|report)'
 
 # Сосед, без которого слово «предложение» не считается просьбой о слое правил.
-context_re='пропозал|слою правил|слоя правил|слой правил|пакет|agent-kit|наверх'
+context_re='пропозал|слою правил|слоя правил|слой правил|пакет|agent-kit|наверх|proposal|rule layer|upstream|package'
 
 # Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
 # приходит той же ролью, поэтому строки с `tool_result` вводом не считаются.
@@ -86,7 +94,6 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg asked "$asked_
 # зависимостью, зовёт бинарь из зависимостей; дерево, где пакет живёт исходниками, бинаря не
 # имеет вовсе — там зовут собранный bin. Названная наугад команда стоит исполнителю хода: отказ
 # читается как указание, и вызов `npx agent-kit` отвечает в таком дереве отказом установки.
-root="${CLAUDE_PROJECT_DIR:-.}"
 if [ -x "$root/node_modules/.bin/agent-kit" ]; then
     propose_cmd="npx agent-kit propose"
 else

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/profile-check.sh, hooks/deny-tail.sh, hooks/write-targets.sh
 # Гард места правки: слой правил чинится там, где сломано, а не там, где виден.
 #
 # Слой правил правит тот же исполнитель, которым слой правил управляет, и разницы между
@@ -53,18 +53,13 @@ deny() {
     exit 0
 }
 
-# Цели записи, названные командой прямо. Печатает по одной в строке.
-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
-}
+# Цели записи разбирает общий помощник: тот же признак нужен гарду экзамена, и разойдясь, две
+# копии пропустили бы разные формы записи. Файла нет — остаётся молчаливое умолчание, чтобы гард
+# не сломался на неполной раскладке.
+# shellcheck disable=SC1090
+[ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/write-targets.sh" ] \
+    && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/write-targets.sh" 2>/dev/null
+command -v rt_write_targets >/dev/null 2>&1 || rt_write_targets() { cat >/dev/null; }
 
 tool="$(rt_hook_tool)"
 candidates=""

package/assets/hooks/skill-gate-layers.sh

@@ -22,6 +22,13 @@
 # как два разных требования.
 . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/utf8.sh" 2>/dev/null || true
 
+# Собранное дерево кодом не бывает: путь к артефакту приходит из команды, которая его запускает.
+# Карта гейта такой путь уже пропускает, и слои обязаны молчать вместе с ней — иначе выход из
+# карты снимает одно требование и оставляет полтора десятка других.
+case "$target" in
+    */node_modules/* | */dist/* | */build/* | */.nx/* | */coverage/*) return 0 ;;
+esac
+
 rt_layer_add() {
     case " $req " in
         *" $1 "*) return 0 ;;

package/assets/hooks/skill-gate.sh

@@ -151,6 +151,20 @@ for name in $req; do
     break
 done
 [ -z "$want" ] && exit 0
+
+# Что потребуется дальше по этой же команде. Требуется по-прежнему одно правило за раз, но
+# длину пути заход видит с первого отказа: на сквозной правке отказы идут по одному на вызов и
+# читаются как разные требования — тринадцать подряд за одну задачу, и каждый стоил хода.
+ahead=""
+for name in $req; do
+    [ "$name" = "$want" ] && continue
+    [ -f "$root/$rules_dir/${name}/SKILL.md" ] || continue
+    if [ -f "$loaded" ] && grep -qE "^([^:]*:)?$(printf '%s' "$name" | sed 's/[][\.*^$/]/\\&/g')$" "$loaded" 2>/dev/null; then
+        continue
+    fi
+    ahead="${ahead}${ahead:+, }${name}"
+done
+
 req="$want"
 
 # Отбитие — наблюдение: правило, которое приходится требовать чаще прочего, и род правки, на
@@ -197,6 +211,21 @@ ${article}
     fi
 fi
 
+# Что потребуется дальше по этой же команде. Строка стоит после всех веток текста: их три, и
+# каждая переписывает причину целиком.
+[ -n "$ahead" ] && reason="${reason} Дальше по этой команде потребуются: ${ahead}."
+
+# Спутник зовётся отдельным предложением и ко всем видам отказа разом. Прежде он был назван
+# только запасным ходом — «если инструмент такого имени не знает», — и читатель, у которого имя
+# известно, до него не доходил вовсе. Цена этого: правило называет способ, а спутник рядом
+# объявляет его здесь невозможным; работа, сделанная способом из правила, кончилась результатом,
+# которого для её заказчика не существовало, а разделы спутника за тот заход не открывались ни
+# разу.
+companion="$rules_dir/${req}/implementation.md"
+[ -f "$root/$companion" ] && reason="${reason}
+
+Спутник правила — ${companion} — читается вместе с ним: правило говорит, что должно быть верно, а спутник — чем это верно здесь и что здесь названо невозможным. Инструментом он не грузится, его читают файлом."
+
 # Общий хвост отказа: два законных хода и законная форма обхода, если она у отказа есть.
 # Файл может быть не разложен — тогда хвоста нет, а причина отказа остаётся прежней.
 # shellcheck disable=SC1090

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

@@ -52,12 +52,44 @@ emit() {
 # Ветка под задачу без папки — работа идёт мимо. Сессию не рвём: SessionStart, отбивающий
 # запуск, оставляет владельца без агента вовсе, а правку кода поймает `task-flow-guard`.
 if [ ! -d "$DIR" ]; then
+    # Папки нет по двум разным причинам, и говорить о них надо разное. Первая — работа шла мимо
+    # правила. Вторая — папку разобрала сама ветка последним коммитом перед заявкой: это законный
+    # исход, и указание собрать её заново уводит заход с хвоста работы обратно в её начало.
+    #
+    # Различает их история ветки: снос папки её же коммитом после общего предка с главной. Ход
+    # работы к этой минуте уехал вместе с папкой, и состояние держат заявка и передача захода.
+    main_branch="${RT_MAIN_BRANCH:-main}"
+    base="$(git merge-base "origin/${main_branch}" HEAD 2>/dev/null || git merge-base "$main_branch" HEAD 2>/dev/null)"
+    dropped=''
+    [ -n "$base" ] && dropped="$(git log "${base}..HEAD" --diff-filter=D --name-only --pretty=format: -- "$DIR" 2>/dev/null | head -1)"
+
+    if [ -n "$dropped" ]; then
+        {
+            printf 'РАБОТА ЗАКРЫВАЕТСЯ — папка задачи разобрана этой веткой.\n\n'
+            printf 'Ход работы удалён вместе с папкой: состояние держат заявка и передача захода.\n'
+            printf 'Папка заново не собирается. Правка кода после разбора требует восстановить её\n'
+            printf 'на время правки и повторить разбор тем же коммитом. Порядок — скил `task-flow`,\n'
+            printf 'паттерны `task-flow-close` и `task-flow-archive`.\n'
+        } | emit
+        exit 0
+    fi
+
     if rt_needs rt_task_branch_ok task-context-load && rt_task_branch_ok "$branch"; then
         {
             printf 'РАБОТА БЕЗ ПАПКИ ЗАДАЧИ.\n\n'
             printf 'Ветка `%s` названа задачей, а `%s/` нет: ход работы записывать некуда,\n' "$branch" "$DIR"
             printf 'и следующий заход начнёт с расспросов владельца.\n\n'
             printf 'Собрать с образца:\n\n    cp -r %s/_template %s\n\n' "$TASKS_DIR" "$DIR"
+            # Папка бывает названа не именем ветки: этапы одной большой задачи идут отдельными
+            # ветками при одной общей папке. Названная поимённо папка — единственное, по чему
+            # заход её найдёт; иначе он читает отказ как «записей нет» и отвечает владельцу из
+            # кода, минуя всё, что в этих записях решено.
+            others="$(find "$TASKS_DIR" -mindepth 1 -maxdepth 1 -type d ! -name '_template' 2>/dev/null | sort)"
+            if [ -n "$others" ]; then
+                printf 'В каталоге задач при этом лежит:\n\n%s\n\n' "$others"
+                printf 'Этапы одной задачи идут отдельными ветками при общей папке — прежде чем\n'
+                printf 'считать, что записей нет, смотрят в названные.\n\n'
+            fi
             # О соседнем ресурсе — условно и по имени: пакет не знает, разложен ли он здесь,
             # а сказанное безусловно приходит в контекст каждой сессии и врёт про дерево тем
             # увереннее, что печатает это сам инструмент.