@rt-tools/agent-kit 0.3.0 → 0.5.0

package/assets/hooks/docs-guard.sh

@@ -1,4 +1,5 @@
 #!/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
 # Гард пары «правка и её документ». PreToolUse.
 #
 # Расхождение кода с текстом беззвучно. Ни линтер, ни сборка, ни тесты не читают правила,
@@ -6,13 +7,17 @@
 # действующей справкой — тем убедительнее, чем он старше. Ловится это только чтением, и ловит
 # обычно владелец, а не проверка.
 #
-# Гард требует ровно тех пар, где связь механическая и спорить не о чем. Какие это пары, знает
-# профиль проекта: {{projectProfile}}, функция `rt_docs_pair_for <файл>` — печатает образец
-# пути, который обязан ехать тем же коммитом, или молчит.
+# Гард требует ровно тех пар, где связь механическая и спорить не о чем:
 #
-# Отдельно — законы. Совпал ли код с законом, машина не знает, поэтому правка самого закона не
-# отклоняется, а выносится вопросом владельцу: закон описывает договорённость о продукте, и
-# менять её молча гард не даёт.
+#   правило и его спутник      — когда правится раздел с утверждениями, а не «Ловушки»;
+#   заведение и удаление либы  — README этой либы;
+#   переезд файла между либами — README обеих;
+#   остальные пары             — их называет профиль дерева, функция `rt_docs_pair_for <файл>`.
+#
+# Отдельно — законы. Совпал ли код с законом, машина не знает: правка файла, на который закон
+# ссылается якорем, поэтому не отклоняется, а выносится вопросом владельцу. Тем же вопросом
+# встречается и правка самого закона: закон описывает договорённость о продукте, и менять её
+# молча гард не даёт.
 #
 # Обход — строка `Docs-skip: <причина>` в теле коммита. Причина остаётся в истории и видна при
 # разборе ветки; пустая не принимается.
@@ -33,32 +38,64 @@ decide() {
     exit 0
 }
 
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+# Объявленная в надстройке функция замещает умолчание целиком и вправе позвать его обратно
+# суффиксом `_default`.
+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" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/defaults/project.sh" "${CLAUDE_PROJECT_DIR:-.}/.claude/rt-kit/project.sh"; do
+    # shellcheck disable=SC1090
+    [ -f "$profile" ] && . "$profile" 2>/dev/null
+done
+
+laws_dir="${RT_LAWS_DIR:-docs/constitution}"
+lib_marker="${RT_LIB_MARKER:-project.json}"
+
 # ── Правка закона спрашивает владельца ────────────────────────────────────────
+#
+# Спутник рядом с законом — привязка статей к коду, она устаревает при каждом переименовании и
+# правится свободно. Спрашивается только сам текст закона.
 case "$tool" in
-    Edit | Write | MultiEdit | mcp__webstorm__create_new_file)
-        target="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.pathInProject // empty' 2>/dev/null)"
+    Edit | Write | MultiEdit | NotebookEdit | mcp__webstorm__create_new_file)
+        target="$(printf '%s' "$input" | jq -r '.tool_input.file_path // .tool_input.filePath // .tool_input.path // .tool_input.pathInProject // empty' 2>/dev/null)"
         case "$target" in
-            */{{lawsDir}}/*.md | {{lawsDir}}/*.md)
-                decide ask "Правка закона: \`${target##*/}\`. Закон описывает договорённость о продукте, а не устройство кода, — назови владельцу, что и почему меняешь, и дождись ответа. Если правка уже согласована, подтверди вызов." ;;
+            */"$laws_dir"/*.implementation.md | "$laws_dir"/*.implementation.md) exit 0 ;;
+            */"$laws_dir"/*.md | "$laws_dir"/*.md)
+                decide ask "Правка закона: \`${target##*/}\`. Закон описывает договорённость о продукте, а не устройство кода, — назови владельцу, что и почему меняешь, и дождись ответа. Если правка уже согласована, подтверди вызов."
+                ;;
         esac
-        exit 0 ;;
+        exit 0
+        ;;
 esac
 
-# ── Коммит: пара обязана ехать тем же коммитом ───────────────────────────────
+# ── Коммит ────────────────────────────────────────────────────────────────────
+
+# Терминал среды и универсальный исполнитель кладут команду в то же поле.
 case "$tool" in
     Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool) ;;
     *) exit 0 ;;
 esac
 
 cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+
+# Универсальный исполнитель передаёт настоящую команду вложенной строкой. Разбирать надо её,
+# иначе имя команды стоит сразу за кавычкой и ни одно правило до него не дотягивается.
+if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
+    inner="$(printf '%s' "$cmd" | perl -0ne '
+        if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
+            print defined $1 ? $1 : (defined $2 ? $2 : $3);
+        }
+    ' 2>/dev/null)"
+    [ -n "$inner" ] && cmd="$inner"
+fi
+
 case "$cmd" in
     *git\ commit*) ;;
     *) exit 0 ;;
 esac
 
-# Обход с причиной. Пустая причина не принимается: «Docs-skip:» без слов означает только то,
-# что строку дописали, чтобы пройти гард.
-if printf '%s' "$cmd" | grep -qE 'Docs-skip:[[:space:]]*[^[:space:]]'; then
+# Причина обхода остаётся в истории, поэтому обход законен. Пустая строка обходом не считается:
+# «Docs-skip:» без причины — это тот же молчаливый пропуск, только с двоеточием.
+if printf '%s' "$cmd" | grep -qiE 'Docs-skip:[[:space:]]*[^[:space:]"'"'"']{3,}'; then
     exit 0
 fi
 
@@ -67,30 +104,179 @@ workdir="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
 cd "$workdir" 2>/dev/null || exit 0
 git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
 
-profile="${CLAUDE_PROJECT_DIR:-.}/{{projectProfile}}"
-[ -f "$profile" ] || exit 0
-# shellcheck disable=SC1090
-. "$profile" 2>/dev/null || exit 0
-command -v rt_docs_pair_for >/dev/null 2>&1 || exit 0
-
-staged="$(git diff --cached --name-only 2>/dev/null)"
-[ -z "$staged" ] && exit 0
-
-missing=""
-while IFS= read -r file; do
-    [ -z "$file" ] && continue
-    want="$(rt_docs_pair_for "$file" 2>/dev/null)"
-    [ -z "$want" ] && continue
-    # Пара считается приехавшей, если хоть один подготовленный файл подходит под образец.
-    printf '%s\n' "$staged" | grep -qE "$want" && continue
-    missing="${missing}  ${file} — ждёт документ: ${want}"$'\n'
+# `-a` берёт все отслеживаемые правки, `--amend` — ещё и файлы переписываемого коммита.
+# Считать всегда по индексу значило бы проверять не тот набор, который уедет в историю.
+changes=''
+source_mode='index'
+case "$cmd" in
+    *' -a'* | *--all*)
+        changes="$(git diff HEAD --name-status -M 2>/dev/null)"
+        source_mode='worktree'
+        ;;
+    *) changes="$(git diff --cached --name-status -M 2>/dev/null)" ;;
+esac
+case "$cmd" in
+    *--amend*) changes="$(printf '%s\n%s' "$changes" "$(git show --name-status --format= HEAD 2>/dev/null)")" ;;
+esac
+
+changes="$(printf '%s\n' "$changes" | grep -v '^[[:space:]]*$')"
+[ -z "$changes" ] && exit 0
+
+# Пути коммита без статусов. Переименование подаётся тремя полями — берём обе стороны.
+paths="$(printf '%s\n' "$changes" | awk -F'\t' '{ for (i = 2; i <= NF; i++) if ($i != "") print $i }' | sort -u)"
+
+has_path() { printf '%s\n' "$paths" | grep -qxF "$1"; }
+
+# Содержимое таким, каким оно уедет в коммит. Источник тот же, по которому собран список
+# правок: `-a` заберёт рабочее дерево, обычный коммит — индекс. Читать индекс всегда нельзя —
+# при `-a` там лежит прежняя редакция, и гард держал бы коммит, который расхождение и чинит;
+# читать рабочее дерево всегда тоже нельзя — неподготовленная правка в коммит не попадёт.
+content_of() {
+    if [ "$source_mode" = 'worktree' ]; then
+        cat "$1" 2>/dev/null
+    else
+        git show ":$1" 2>/dev/null || cat "$1" 2>/dev/null
+    fi
+}
+
+problems=''
+add() { problems="${problems}
+  • $1"; }
+
+# ── 1. Правило и его спутник ──────────────────────────────────────────────────
+#
+# Утверждения правила ключуются своим текстом, и переформулировка без правки спутника рвёт
+# связь молча. Сверка спеков это ловит, но гоняется в гейте пуша — здесь та же пара
+# встречается коммитом раньше, пока правка ещё в голове у автора.
+#
+# Раздел с утверждениями — единственное, что связано со спутником; правка «Ловушек» или
+# таблицы «Где это лежит» его не трогает, поэтому сравнивается только этот раздел.
+STATEMENTS='/^## Как закон применяется здесь$/,/^## [^К]/'
+statements_of() { content_of "$1" | awk "$STATEMENTS"; }
+
+for rule in $(printf '%s\n' "$paths" | grep -E '/SKILL\.md$'); do
+    grep -q '^kind: rule$' "$rule" 2>/dev/null || continue
+    companion="${rule%/SKILL.md}/implementation.md"
+
+    [ -f "$companion" ] || continue
+    has_path "$companion" && continue
+
+    if [ "$(statements_of "$rule")" != "$(git show "HEAD:$rule" 2>/dev/null | awk "$STATEMENTS")" ]; then
+        add "утверждения \`$rule\` правятся без спутника — добавь в коммит \`$companion\`"
+    fi
+done
+
+# ── 2. Пары, которые называет дерево ──────────────────────────────────────────
+#
+# Контракт и спек домена, гард и его сценарии — что именно, знает профиль: связь у каждого
+# дерева своя, а механика одна.
+if command -v rt_docs_pair_for >/dev/null 2>&1; then
+    while IFS= read -r file; do
+        [ -z "$file" ] && continue
+        want="$(rt_docs_pair_for "$file" 2>/dev/null)"
+        [ -z "$want" ] && continue
+        # Пара считается приехавшей, если хоть один файл коммита подходит под образец.
+        printf '%s\n' "$paths" | grep -qE "$want" && continue
+        add "\`$file\` правится без документа — тем же коммитом ждёт \`$want\`"
+    done <<EOF
+$paths
+EOF
+fi
+
+# ── 3. Либа и её README ───────────────────────────────────────────────────────
+
+lib_root() {
+    dir="${1%/*}"
+    while [ -n "$dir" ] && [ "$dir" != "." ]; do
+        [ -f "$dir/$lib_marker" ] && { printf '%s' "$dir"; return 0; }
+        case "$dir" in */*) dir="${dir%/*}" ;; *) dir='' ;; esac
+    done
+
+    return 1
+}
+
+need_readme=''
+want_readme() {
+    root="$1"
+    [ -n "$root" ] || return 0
+    case " $need_readme " in *" $root "*) return 0 ;; esac
+    need_readme="$need_readme $root"
+}
+
+# Заведение и удаление либы: README — единственное место, где написано, что в ней лежит и кто
+# её зовёт, и раскладку она переживает только вместе с правкой этого текста.
+while IFS="$(printf '\t')" read -r status first second; do
+    case "$status" in
+        A* | D*)
+            case "$first" in */"$lib_marker") want_readme "${first%/"$lib_marker"}" ;; esac
+            ;;
+        R*)
+            # Переезд файла меняет обе стороны: у одной либы он пропал из состава, у другой
+            # появился.
+            from="$(lib_root "$first")" && to="$(lib_root "$second")"
+            if [ -n "$from" ] && [ -n "$to" ] && [ "$from" != "$to" ]; then
+                want_readme "$from"
+                want_readme "$to"
+            fi
+            ;;
+    esac
 done <<EOF
-$staged
+$changes
 EOF
 
-[ -z "$missing" ] && exit 0
+# Переезд, поданный парой «удалено там, добавлено тут»: переименованием считается не всё, что
+# им является, — правка содержимого при переносе сбивает поиск.
+moved_added="$(printf '%s\n' "$changes" | awk -F'\t' '$1 ~ /^A/ { n = split($2, p, "/"); print p[n] "\t" $2 }' | sort -u)"
+moved_deleted="$(printf '%s\n' "$changes" | awk -F'\t' '$1 ~ /^D/ { n = split($2, p, "/"); print p[n] "\t" $2 }' | sort -u)"
+if [ -n "$moved_added" ] && [ -n "$moved_deleted" ]; then
+    while IFS="$(printf '\t')" read -r base added; do
+        [ -n "$base" ] || continue
+        gone="$(printf '%s\n' "$moved_deleted" | awk -F'\t' -v b="$base" '$1 == b { print $2; exit }')"
+        [ -n "$gone" ] || continue
+        to="$(lib_root "$added")" || continue
+        from="$(lib_root "$gone")" || continue
+        [ "$from" = "$to" ] && continue
+        want_readme "$from"
+        want_readme "$to"
+    done <<EOF
+$moved_added
+EOF
+fi
+
+for root in $need_readme; do
+    [ -d "$root" ] || continue   # либу удалили целиком — править в ней нечего
+    has_path "$root/README.md" || add "состав либы \`$root\` изменился без правки \`$root/README.md\`"
+done
+
+if [ -n "$problems" ]; then
+    decide deny "BLOCKED: коммит правит код, но не документ, который его описывает.
+${problems}
+
+Текст правится в той же ветке, что и код: документ, разошедшийся с деревом, выглядит действующей справкой и уводит следующего читателя. Если правка документа здесь действительно не нужна — назови причину строкой \`Docs-skip: <причина>\` в теле коммита, она останется в истории."
+fi
 
-decide deny "Документ едет в том же коммите, что и правка, которую он описывает. Не хватает пар:
+# ── 4. Законы ─────────────────────────────────────────────────────────────────
+#
+# Отклонять нечего: сошлась ли правка с законом, видно только чтением. Но место, где статья
+# закона исполняется, названо якорем, и правка ровно этого файла — единственный момент, когда
+# сверку ещё дёшево сделать.
+#
+# Слоёв законов два: общий в корне, закон приложения — в каталоге под ним. Образец принимает
+# оба, иначе правка предметного закона считалась бы правкой мимо законов.
+if [ -d "$laws_dir" ] && ! printf '%s\n' "$paths" | grep -qE "^${laws_dir}/([^/]+/)?[^/]+\.md$"; then
+    touched=''
+    for anchor in $(grep -ohE '`[A-Za-z0-9_./@-]+\.(ts|mjs|html|scss|prisma|proto|json)(:[A-Za-z0-9_#.-]+)?`' "$laws_dir"/*.implementation.md 2>/dev/null \
+        | tr -d '`' | sed 's/:.*//' | grep '/' | sort -u); do
+        has_path "$anchor" && touched="${touched}
+  • \`$anchor\`"
+    done
+
+    if [ -n "$touched" ]; then
+        decide ask "Правка задевает места, где исполняются статьи законов:
+${touched}
+
+Законы лежат в \`${laws_dir}/\`, привязка — в спутниках рядом. Прочитай закон и скажи владельцу, сошлась ли с ним правка: если правка его уточняет или ему противоречит, закон правится в этой же ветке, но только с его ведома. Если закон не изменился — подтверди вызов."
+    fi
+fi
 
-${missing}
-Если документа здесь правда не нужно — строка «Docs-skip: <причина>» в теле коммита; пустая причина не принимается."
+exit 0

package/assets/hooks/git-guard-delivery.sh

@@ -1,23 +1,36 @@
 #!/usr/bin/env bash
-# Гард поставки. PreToolUse на заведении ветки и открытии PR.
+# rt-hook: PreToolUse Bash|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
+# Гард поставки. PreToolUse на заведении ветки и открытии заявки на слияние.
 #
 # Закон о поставке требует трёх вещей, которых обычно не проверяет ничто: правка начинается с
 # задачи, видимой в очереди работ; задача, ветка и отчёт несут один номер; у задачи есть
 # исполнитель. Держатся они памятью — и не удерживаются: задачи стоят вне очереди, исполнитель
-# не проставлен, а большинство влитых PR приходит с веток, за которыми задачи не стояло вовсе.
+# не проставлен, а большинство влитых заявок приходит с веток, за которыми задачи не стояло
+# вовсе.
 #
 # Гард стоит в двух точках, и в каждой требует того, что в этот момент исправимо:
 #
 #   заведение ветки — имя с номером разбирается на месте; имя без номера пропускается:
-#       локальная ветка под пробу законна, в главную она не поедет, потому что PR с неё не
-#       откроется;
-#   открытие PR — ветка обязана нести номер, а заголовок — начинаться с того же номера.
+#       локальная ветка под пробу законна, в главную она не поедет, потому что заявка с неё
+#       не откроется;
+#   открытие заявки — ветка обязана нести номер, заголовок обязан начинаться с того же номера,
+#       а задача — быть открытой, стоять в очереди работ и иметь исполнителя.
 #
-# Форму имени ветки и номер в заголовке знает профиль проекта: {{projectProfile}}, функция
-# `rt_task_branch_ok <имя>` и переменная RT_TASK_TITLE_RE. Нет профиля — гард пропускает: форму
-# имени пакет выдумать не может.
+# Два яруса. Формат — номер в имени ветки, номер в заголовке, их совпадение — читается из
+# текста команды и работает всегда. Состояние задачи требует сети: нет её, нет помощника или
+# нет токена — ярус пропускается, потому что проверять нечем.
 #
-# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: не репозиторий, нет разборщика, битый ввод — пропуск.
+# Что здесь чем зовётся, знает профиль дерева:
+#   rt_task_branch_ok    — форма имени ветки под задачу;
+#   RT_TASK_TITLE_RE     — форма номера в заголовке заявки;
+#   rt_task_state        — состояние задачи одним объектом (existsize, open, onBoard, assigned,
+#                          numbered); молчание значит «спросить некого»;
+#   RT_TASK_NEW_CMD      — чем заводится задача;
+#   RT_BOARD_CHECK_CMD   — чем сверяется очередь работ;
+#   RT_TASK_BOT          — учётная запись, которую ставят исполнителем.
+# Отказ называет и то, что не так, и чем это чинится: отказ без действия обходят, а не исполняют.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: не репозиторий, нет разборщика, битый ввод, нет профиля — пропуск.
 
 input="$(cat 2>/dev/null)"
 [ -z "$input" ] && exit 0
@@ -25,6 +38,7 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 tool="$(printf '%s' "$input" | jq -r '.tool_name // empty' 2>/dev/null)"
 case "$tool" in
+    # Терминал среды и универсальный исполнитель кладут команду в то же поле.
     Bash | mcp__webstorm__execute_terminal_command | mcp__webstorm__execute_tool) ;;
     *) exit 0 ;;
 esac
@@ -32,6 +46,8 @@ esac
 cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
 [ -z "$cmd" ] && exit 0
 
+# Универсальный исполнитель передаёт настоящую команду вложенной строкой. Разбирать надо её,
+# а не обёртку.
 if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&1; then
     inner="$(printf '%s' "$cmd" | perl -0ne '
         if (/--command(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(.+))/s) {
@@ -41,18 +57,79 @@ if [ "$tool" = "mcp__webstorm__execute_tool" ] && command -v perl >/dev/null 2>&
     [ -n "$inner" ] && cmd="$inner"
 fi
 
-profile="${CLAUDE_PROJECT_DIR:-.}/{{projectProfile}}"
-[ -f "$profile" ] || exit 0
-# shellcheck disable=SC1090
-. "$profile" 2>/dev/null || 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
+
+root="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null)}"
+
+# Профиль дерева: сперва умолчание пакета, поверх него — надстройка проекта, если она есть.
+# Объявленная в надстройке функция замещает умолчание целиком и вправе позвать его обратно
+# суффиксом `_default`. Нет ни того ни другого — хук пропускает: пустой гард лучше гарда,
+# отбивающего наугад.
+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
 command -v rt_task_branch_ok >/dev/null 2>&1 || exit 0
 
+title_re="${RT_TASK_TITLE_RE:-^\[[A-Za-z]+-[0-9]+\][[:space:]]+[^[:space:]]}"
+task_new="${RT_TASK_NEW_CMD:-npm run task:new}"
+board_check="${RT_BOARD_CHECK_CMD:-npm run check:board}"
+task_bot="${RT_TASK_BOT:-}"
+tasks_dir="${RT_TASKS_DIR:-}"
+archive_dir="${RT_ARCHIVE_DIR:-}"
+main_branch="${RT_MAIN_BRANCH:-main}"
+
+# Обход требования: строка с причиной. Причина видна тому, кто вливает, поэтому обход законен.
+# Без причины это просто молчаливый пропуск, поэтому она обязательна. Порог в три знака — тот
+# же, что у гарда документа: если сделать по-разному, две формы одного обхода разойдутся.
+folder_skip_re='Task-folder-skip:[[:space:]]*[^[:space:]"'"'"']{3,}'
+
 deny() {
     jq -n --arg r "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \
         || printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"Гард поставки."}}\n'
     exit 0
 }
 
+# Подсказка вместо отказа: на открытии отчёта папка ещё нужна. Решения подсказка не несёт,
+# команда идёт дальше своим ходом.
+hint() {
+    jq -n --arg c "$1" '{hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:$c}}' 2>/dev/null
+    exit 0
+}
+
+# Есть ли папка задачи в ветке. Смотрим содержимое ветки, а не рабочее дерево: если папку
+# удалили, но не закоммитили, проверка прошла бы, а папка всё равно уехала бы в main. Имя
+# ветки подставляем целиком, вместе с косой: у ветки вида `chore/312-slug` папка лежит во
+# вложенном каталоге.
+folder_in_branch() {
+    git ls-tree -d --name-only HEAD -- "$1" 2>/dev/null | head -1
+}
+
+check_task() {
+    number="$1"
+    where="$2"
+    command -v rt_task_state >/dev/null 2>&1 || return 0
+    state="$(cd "$root" && rt_task_state "$number" 2>/dev/null)" || return 0
+    [ -z "$state" ] && return 0
+
+    printf '%s' "$state" | jq -e '.exists' >/dev/null 2>&1 \
+        || deny "BLOCKED: ${where} ссылается на задачу #${number}, которой нет. Проверь номер или заведи задачу — ${task_new}."
+    printf '%s' "$state" | jq -e '.open' >/dev/null 2>&1 \
+        || deny "BLOCKED: задача #${number} закрыта, а у задачи одна ветка. Работа за закрытой задачей заводится новой задачей — ${task_new}."
+    printf '%s' "$state" | jq -e '.onBoard' >/dev/null 2>&1 \
+        || deny "BLOCKED: задачи #${number} нет в очереди работ — правка за ней не видна. Очередь к репозиторию не привязана и задачу сама не забирает; добавь её и сверь — ${board_check}."
+    printf '%s' "$state" | jq -e '.assigned' >/dev/null 2>&1 \
+        || deny "BLOCKED: у задачи #${number} нет исполнителя — по очереди работ не видно, кто её взял. Поставь исполнителя${task_bot:+: }${task_bot}."
+    printf '%s' "$state" | jq -e '.numbered' >/dev/null 2>&1 \
+        || deny "BLOCKED: заголовок задачи #${number} не начинается с её номера — одну работу придётся узнавать по тексту названия. Поправь заголовок и сверь очередь — ${board_check}."
+
+    return 0
+}
+
 # --- заведение ветки ---------------------------------------------------------------------
 branch_arg=''
 if printf '%s' "$cmd" | grep -qE '(^|[;&|[:space:]])git[[:space:]]+(checkout[[:space:]]+-b|switch[[:space:]]+-c)[[:space:]]'; then
@@ -64,47 +141,110 @@ fi
 if [ -n "$branch_arg" ]; then
     # Имя, притворяющееся веткой под задачу, но не совпадающее с формой, — это промах в имени,
     # а не осознанная беззадачная ветка. Ловится до первого коммита.
-    if printf '%s' "$branch_arg" | grep -qE '^[A-Za-z]+-[0-9]+' && ! rt_task_branch_ok "$branch_arg"; then
-        deny "Имя ветки «${branch_arg}» не той формы, что принята здесь. Номер у ветки тот же, что у задачи и у заголовка PR."
+    if printf '%s' "$branch_arg" | grep -qiE '^[A-Za-z]+-[0-9]+'; then
+        rt_task_branch_ok "$branch_arg" \
+            || deny "BLOCKED: имя ветки «${branch_arg}» не той формы, что принята здесь. Номер у ветки тот же, что у задачи и у заголовка заявки на слияние."
+        check_task "$(printf '%s' "$branch_arg" | sed -nE 's/^[A-Za-z]+-([0-9]+).*/\1/p')" "ветка «${branch_arg}»"
     fi
+    # Ветка без номера законна и живёт локально: заявка с неё не откроется.
     exit 0
 fi
 
-# --- открытие PR -------------------------------------------------------------------------
-case "$cmd" in
-    *gh\ pr\ create*) ;;
-    *) exit 0 ;;
-esac
+# --- слияние заявки ----------------------------------------------------------------------
+#
+# Папку задачи разбирают тем же PR, что и работу. После слияния этого уже никто не сделает:
+# работа перешла к следующей задаче, а PR закрыт. Раньше слияния требовать нельзя — пока идёт
+# ревью, plan.md нужен на диске, иначе гард хода работы не даст править код.
+# Команду ищем от начала строки или после разделителя, а не где угодно в тексте. Иначе гард
+# отбивает сообщение, где `gh pr merge` просто упомянут в кавычках, — так он и сработал на
+# правке этого же текста. Полностью подстроку в кавычках так не отсечь, но случайное упоминание
+# внутри слова или пути мимо уже не пройдёт.
+if printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*(gh[[:space:]]+pr[[:space:]]+merge|glab[[:space:]]+mr[[:space:]]+merge|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+update)([[:space:]]|$)'; then
+    [ -n "$tasks_dir" ] || exit 0   # ведения работы папкой в дереве нет
+
+    merge_branch="$(git branch --show-current 2>/dev/null)"
+    [ -z "$merge_branch" ] && exit 0
+    rt_task_branch_ok "$merge_branch" || exit 0   # за беззадачной веткой папки не стоит
+
+    folder="$tasks_dir/$merge_branch"
+
+    # Сначала ищем обход в самой команде — это работает и без сети. Если читать только
+    # тело PR, то без сети гард отбил бы слияние, причина которого в этом теле и написана.
+    printf '%s' "$cmd" | grep -qiE "$folder_skip_re" && exit 0
+
+    merge_number="$(printf '%s' "$cmd" | sed -nE 's/.*(pr|mr)[[:space:]]+(merge|update)[[:space:]]+([0-9]+).*/\3/p' | head -1)"
+    if [ -n "$merge_number" ] && command -v rt_report_body >/dev/null 2>&1; then
+        body="$(cd "$root" && rt_report_body "$merge_number" 2>/dev/null)"
+        [ -n "$body" ] && printf '%s' "$body" | grep -qiE "$folder_skip_re" && exit 0
+    fi
 
-workdir="$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)"
-[ -z "$workdir" ] && workdir="${CLAUDE_PROJECT_DIR:-.}"
-cd "$workdir" 2>/dev/null || exit 0
+    lying="$(folder_in_branch "$folder")"
+    [ -n "$lying" ] \
+        && deny "BLOCKED: в ветке осталась папка задачи «${lying}» — она уедет в главную. Разобрать её потом будет некому: работа перейдёт к следующей задаче, а этот PR закроется. Перенеси в «${archive_dir:-архив}» то, что объясняет принятые решения, остальное удали и повтори. Если работа вливается частями, поставь в тело PR строку «Task-folder-skip: <причина>»."
+
+    # Запись в архиве спрашиваем только у ветки, которая папку удалила. Иначе проверка
+    # цеплялась бы к работе, у которой папки и не было. Без общего предка с главной веткой
+    # сравнивать не с чем — тогда молчим.
+    [ -n "$archive_dir" ] || exit 0
+    base="$(git merge-base "$main_branch" HEAD 2>/dev/null)"
+    [ -z "$base" ] && exit 0
+
+    had="$(git ls-tree -d --name-only "$base" -- "$folder" 2>/dev/null | head -1)"
+    [ -z "$had" ] && had="$(git log "$base..HEAD" --diff-filter=A --name-only --pretty=format: -- "$folder" 2>/dev/null | head -1)"
+    [ -z "$had" ] && exit 0
+
+    gained="$(git diff --name-only --diff-filter=A "$base" HEAD -- "$archive_dir" 2>/dev/null | head -1)"
+    [ -z "$gained" ] \
+        && deny "BLOCKED: папку задачи удалили, но в «${archive_dir}» ветка ничего не добавила. Удалить проще, чем разобрать, — и вместе с папкой пропадает разбор просьбы, единственная запись слов владельца. Перенеси то, что объясняет принятые решения, одним файлом с понятным именем и повтори."
+
+    exit 0
+fi
+
+# --- открытие заявки на слияние ----------------------------------------------------------
+# Команду ищем от начала строки или после разделителя — по той же причине, что и слияние:
+# упоминание в кавычках командой не является.
+printf '%s' "$cmd" \
+    | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*(gh[[:space:]]+pr[[:space:]]+create|glab[[:space:]]+mr[[:space:]]+create|az[[:space:]]+repos[[:space:]]+pr[[:space:]]+create)([[:space:]]|$)' \
+    || exit 0
 
 branch="$(git branch --show-current 2>/dev/null)"
 [ -z "$branch" ] && exit 0   # открепившийся HEAD — не про этот случай
 
-# Локальная ветка без номера законна, а PR с неё — уже нет: правка, доезжающая до главной
+# Локальная ветка без номера законна, а заявка с неё — уже нет: правка, доезжающая до главной
 # ветки, начинается с задачи. Это единственное место, где беззадачная ветка упирается.
 rt_task_branch_ok "$branch" \
-    || deny "PR с ветки «${branch}», за которой не стоит задачи. Правка начинается с задачи, видимой в очереди работ: заведи её и перенеси работу в ветку с её номером."
+    || deny "BLOCKED: заявка с ветки «${branch}», за которой не стоит задачи. Правка начинается с задачи, видимой в очереди работ: заведи её — ${task_new} — и перенеси работу в ветку с её номером."
 
 number="$(printf '%s' "$branch" | sed -nE 's/^[A-Za-z]+-([0-9]+).*/\1/p')"
 
 title=''
 if command -v perl >/dev/null 2>&1; then
     title="$(printf '%s' "$cmd" | perl -0ne '
-        if (/--title(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|([^\s]+))/s) {
+        if (/(?:--title|-t)(?:=|\s+)(?:"((?:[^"\\]|\\.)*)"|\x27([^\x27]*)\x27|(\S+))/s) {
             print defined $1 ? $1 : (defined $2 ? $2 : $3);
         }
     ' 2>/dev/null)"
 fi
 
-if [ -n "$title" ] && [ -n "$number" ]; then
+if [ -n "$title" ]; then
+    printf '%s' "$title" | grep -qE "$title_re" \
+        || deny "BLOCKED: заголовок заявки не начинается с номера задачи. В списке заявок тела не видно, а строка связи живёт именно там — без номера в заголовке отчёт с задачей не сопоставить."
     title_number="$(printf '%s' "$title" | sed -nE 's/^\[[A-Za-z]+-([0-9]+)\].*/\1/p')"
-    [ -z "$title_number" ] \
-        && deny "Заголовок PR не начинается с номера задачи. В списке PR тела не видно, а строка связи живёт именно там — без номера в заголовке отчёт с задачей не сопоставить."
-    [ "$title_number" = "$number" ] \
-        || deny "В заголовке PR номер ${title_number}, у ветки — ${number}. Задача, ветка и отчёт несут один и тот же номер."
+    if [ -n "$number" ] && [ -n "$title_number" ]; then
+        [ "$title_number" = "$number" ] \
+            || deny "BLOCKED: в заголовке заявки номер ${title_number}, у ветки — ${number}. Задача, ветка и отчёт несут один и тот же номер."
+    fi
+fi
+
+check_task "$number" "заявка с ветки «${branch}»"
+
+# Сейчас папка ещё нужна: правки по замечаниям ревью идут в эту же ветку, а без plan.md их не
+# пропустит гард хода работы. Поэтому здесь только напоминание. Требование стоит на слиянии —
+# там папка уже не нужна, а вред от неё как раз и наступает.
+if [ -n "$tasks_dir" ]; then
+    lying="$(folder_in_branch "$tasks_dir/$branch")"
+    [ -n "$lying" ] \
+        && hint "В ветке лежит папка задачи «${lying}». Разбери её до слияния, этим же PR: потом за неё уже никто не возьмётся. На слиянии это будет отказ, а не напоминание."
 fi
 
 exit 0

package/assets/hooks/git-guard-main.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# rt-hook: PreToolUse Bash|mcp__webstorm__execute_terminal_command|mcp__webstorm__execute_tool
 # Гард главной ветки. PreToolUse на вызове коммита.
 #
 # Коммит в главную ветку минует ветку, PR и разбор, а поставка построена на них целиком —