@rt-tools/agent-kit 0.4.0 → 0.5.0

package/assets/checks/board.github.mjs

@@ -19,10 +19,11 @@
  * функции возвращают `null`, командный режим печатает `{"offline":true}`.
  */
 import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { join } from 'node:path';
 
-import { CONFIG } from './rt-kit-checks.config.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
 /**
  * Адрес борды и её колонки живут в `.claude/rt-kit/checks.json`: идентификаторы проекта, поля
@@ -218,6 +219,48 @@ export function numberFromTitle(title) {
     return match ? Number(match[1]) : null;
 }
 
+/**
+ * Номер задачи по имени папки. Ключ впереди необязателен: имя ветки вида `chore/312-slug`
+ * тоже законно, и папка под ним называется голым числом. Если сверка не распознает в имени
+ * номер, папка будет лежать среди текущих сколько угодно — одну такую нашли грепом, а не
+ * проверкой.
+ */
+export function numberFromTaskDir(name) {
+    // Ключ подставляем, только если дерево его задало: из пустого получилось бы `^(?:-)?`, и
+    // папка с ключом в имени вообще перестала бы распознаваться.
+    const prefix = TASK_KEY ? `(?:${TASK_KEY}-)?` : '';
+    const match = new RegExp(`^${prefix}(\\d+)-`).exec(name ?? '');
+    return match ? Number(match[1]) : null;
+}
+
+/**
+ * Папки задач, включая вложенные. Путь повторяет имя ветки целиком, вместе с косой, поэтому
+ * папка ветки `chore/312-slug` лежит на втором уровне — обход только по верхнему её не видит.
+ *
+ * Вглубь спускаемся ровно на один уровень: в имени ветки одна косая, а всё, что глубже, папкой
+ * задачи уже не будет — зато туда попал бы архив, если дерево держит его внутри.
+ */
+export function taskDirs(dir = join(ROOT, CONFIG.tasksDir), prefix = '') {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const found = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name === '_template') {
+            continue;
+        }
+        const name = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.name.startsWith('_draft-') || numberFromTaskDir(entry.name) !== null) {
+            found.push(name);
+            continue;
+        }
+        if (!prefix) {
+            found.push(...taskDirs(join(dir, entry.name), name));
+        }
+    }
+    return found;
+}
+
 export function numberFromBranch(branch) {
     const match = BRANCH_NUMBER.exec(branch ?? '');
     return match ? Number(match[1]) : null;

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

@@ -24,7 +24,7 @@
  *
  * Ненулевой код возврата и перечень расхождений.
  */
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { statSync } from 'node:fs';
 import { join } from 'node:path';
 
 import {
@@ -36,7 +36,9 @@ import {
     fetchBoard,
     fetchIssues,
     fetchOpenPulls,
+    numberFromTaskDir,
     numberFromTitle,
+    taskDirs,
 } from './board.mjs';
 import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
@@ -48,15 +50,6 @@ const DRAFT_DAYS = 7;
 const problems = [];
 const report = (message) => problems.push(message);
 
-function taskDirs() {
-    if (!existsSync(TASKS_DIR)) {
-        return [];
-    }
-    return readdirSync(TASKS_DIR, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && entry.name !== '_template')
-        .map((entry) => entry.name);
-}
-
 /**
  * Разбор просьбы владельца идёт до заведения задачи и лежит в `_draft-<slug>`. Заглохший на
  * середине, он остаётся на диске вне истории и выглядит так же, как начатый сегодня: второй
@@ -71,7 +64,7 @@ function checkDrafts() {
         }
         const age = Math.floor((now - statSync(join(TASKS_DIR, name)).mtimeMs) / 86400000);
         if (age >= DRAFT_DAYS) {
-            report(`docs/tasks/${name}/: разбор брошен ${age} дн. назад — заведи задачу или удали папку`);
+            report(`${CONFIG.tasksDir}/${name}/: разбор брошен ${age} дн. назад — заведи задачу или удали папку`);
         }
     }
 }
@@ -153,12 +146,12 @@ try {
     // в `docs/archive/`, остальное удаляется. Оставленная рядом с текущими, она читается как
     // текущая — тем убедительнее, чем старше.
     for (const name of taskDirs()) {
-        const number = Number(new RegExp(`^${TASK_KEY}-(\\d+)-`).exec(name)?.[1]);
-        if (!Number.isInteger(number) || openNumbers.has(number)) {
+        const number = numberFromTaskDir(name.split('/').pop());
+        if (number === null || openNumbers.has(number)) {
             continue;
         }
         if (issues.some((issue) => issue.number === number)) {
-            report(`docs/tasks/${name}/: задача #${number} закрыта, а папка лежит среди текущих — разбери её`);
+            report(`${CONFIG.tasksDir}/${name}/: задача #${number} закрыта, а папка лежит среди текущих — разбери её`);
         }
     }
 } catch (error) {

package/assets/checks/check-specs.mjs

@@ -730,6 +730,20 @@ function collectReferences() {
             // идентификатором: состояние теста читается, когда файл разобран целиком
             found.forEach(({ id, test: own, place }) => remember(id, { place, screen: Boolean(e2eRoot), off: Boolean(own?.off) }));
         }
+
+        // Наборы сценариев на shell. Так проверяются исполняемые файлы — гарды, проверки,
+        // умолчания: они не на TypeScript, и набор к ним пишут на том же языке, что и их
+        // самих. Выключателей здесь нет: пропустить сценарий в таком наборе нечем, поэтому
+        // достаточно найти идентификатор.
+        for (const file of walk(root, (name) => name.endsWith('.test.sh'))) {
+            read(file)
+                .split('\n')
+                .forEach((line, index) => {
+                    for (const [id] of line.matchAll(SCENARIO_REFERENCE)) {
+                        remember(id, { place: `${file}:${index + 1}`, screen: false, off: false });
+                    }
+                });
+        }
     }
 
     return references;
@@ -774,15 +788,47 @@ for (const file of walk(CONSTITUTION_DIR, (name) => name.endsWith('.md'))) {
     laws.set(name, file);
 }
 
+/**
+ * Директории, описывающие предмет: сам домен и его поддомены. Поддомен заводится, когда домен
+ * вырос настолько, что читать его целиком ради одной подробности дороже, чем найти её; устроен
+ * он так же — три файла и свой префикс сценариев.
+ *
+ * `proposed/` предметом не является: это договорённость о продукте до кода, и её сценарии живут
+ * в нумерации того спека, в который она вольётся.
+ */
+function collectSpecDirs(base) {
+    const found = [base];
+    let entries;
+    try {
+        entries = readdirSync(join(ROOT, base), { withFileTypes: true });
+    } catch {
+        return found;
+    }
+
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== 'proposed') {
+            found.push(...collectSpecDirs(`${base}/${entry.name}`));
+        }
+    }
+
+    return found;
+}
+
+/** Префикс сценариев принадлежит одному спеку по всему дереву. */
+const prefixOwners = new Map();
+
 for (const domain of domains) {
     const base = `${SPECS_DIR}/${domain}`;
-    // Домен, у которого есть только `proposed/`, ещё не существует: спека о нём
-    // нет, пока фича не выкачена
-    const isProposedOnly = exists(`${base}/proposed`) && !exists(`${base}/spec.md`);
-    if (!isProposedOnly) {
+    for (const dir of collectSpecDirs(base)) {
+        // Спек, у которого есть только `proposed/`, ещё не существует: его самого нет, пока
+        // фича не выкачена
+        if (exists(`${dir}/proposed`) && !exists(`${dir}/spec.md`)) {
+            continue;
+        }
+        const what = dir === base ? 'домен' : 'поддомен';
         ['spec.md', 'scenarios.md']
-            .filter((name) => !exists(`${base}/${name}`))
-            .forEach((name) => report(base, `нет файла \`${name}\` — домен описан наполовину`));
+            .filter((name) => !exists(`${dir}/${name}`))
+            .forEach((name) => report(dir, `нет файла \`${name}\` — ${what} описан наполовину`));
     }
 
     // Спеки фич из `proposed/` проверяются наравне со спеком домена: они и есть
@@ -803,10 +849,38 @@ for (const domain of domains) {
     }
 
     const found = walk(base, (name) => name === 'scenarios.md').flatMap(parseScenarios);
-    const prefixes = new Set(found.map((scenario) => scenario.prefix));
-    if (prefixes.size > 1) {
-        report(base, `в домене больше одного префикса сценариев: ${[...prefixes].sort().join(', ')}`);
+
+    // Префикс судится в пределах одного спека, а не всего дерева домена: у поддомена он свой, и
+    // по номеру видно, о чём сценарий. Два префикса в одном спеке по-прежнему означают, что
+    // предмет описан дважды.
+    const prefixesOf = new Map();
+    for (const scenario of found) {
+        const dir = dirname(scenario.file);
+        if (!prefixesOf.has(dir)) {
+            prefixesOf.set(dir, new Set());
+        }
+        prefixesOf.get(dir).add(scenario.prefix);
     }
+
+    for (const [dir, prefixes] of prefixesOf) {
+        if (prefixes.size > 1) {
+            report(dir, `в спеке больше одного префикса сценариев: ${[...prefixes].sort().join(', ')}`);
+        }
+        // Договорённость о продукте нумеруется вместе со спеком, в который вольётся:
+        // идентификаторы переезд переживают, и занятым префикс от неё не становится
+        if (dir.includes('/proposed/')) {
+            continue;
+        }
+        for (const prefix of prefixes) {
+            const owner = prefixOwners.get(prefix);
+            if (owner && owner !== dir) {
+                report(dir, `префикс \`SC-${prefix}\` уже занят — \`${owner}\`; по номеру не видно, чей сценарий`);
+                continue;
+            }
+            prefixOwners.set(prefix, dir);
+        }
+    }
+
     scenarios.push(...found);
 }
 
@@ -887,11 +961,16 @@ for (const file of walk('.claude/skills', (name) => name === 'SKILL.md')) {
     }
 }
 
+// Предложенный закон правила не требует: договорённость записана раньше кода, привязывать её
+// не к чему, и требование правила заставило бы завести его с якорями в несуществующие места.
+// Признак стоит строкой статуса в самом законе, а не списком исключений рядом с проверкой.
+const isProposedLaw = (file) => /^\*\*Статус:\*\*\s*предложен/m.test(read(file));
+
 // Обратные стороны связи. Закон без правила читается как договорённость, которую этот проект
 // не применяет; правило без паттерна оставляет готовый код там, где ему не место, — в самом
 // правиле, которое читается при каждой правке.
 [...laws]
-    .filter(([law]) => !ruled.has(law))
+    .filter(([law, file]) => !ruled.has(law) && !isProposedLaw(file))
     .forEach(([, file]) => report(file, 'у закона нет ни одного правила — заведи скил с `law:` на него'));
 
 for (const file of walk('.claude/skills', (name) => name === 'SKILL.md')) {

package/assets/defaults/gate-map.sh

@@ -61,8 +61,14 @@ skill_for_default() {
                 */docs/constitution/*) printf '%s\n' 'spec-driven' ;;
                 *.md) printf '%s\n' 'doc-style' ;;
 
-                # Поставка: состав зависимостей — это то, что приезжает на прод.
-                */package.json | */pnpm-lock.yaml | */pnpm-workspace.yaml | */package-lock.json) printf '%s\n' 'dependencies' ;;
+                # Поставка: состав зависимостей — это то, что приезжает на прод. Правка
+                # скриптов зависимостью не является, и правило про версии на неё не вступает.
+                # Оговорка: удаление зависимости приходит правкой без номера версии и сюда не
+                # попадает — его ловит снимок дерева, который правится тем же коммитом.
+                */package.json)
+                    printf '%s' "$written" | grep -qE '"(dependencies|devDependencies|peerDependencies|optionalDependencies|overrides|resolutions|packageManager)"|"[^"]+"[[:space:]]*:[[:space:]]*"[~^]?[0-9]+\.[0-9]+' \
+                        && printf '%s\n' 'dependencies' ;;
+                */pnpm-lock.yaml | */pnpm-workspace.yaml | */package-lock.json) printf '%s\n' 'dependencies' ;;
 
                 # Границы между либами: манифест, алиасы, барель.
                 */project.json | */tsconfig.base.json | */eslint/boundaries/* | */src/index.ts | */public-api.ts | */ng-package.json)

package/assets/defaults/project.sh

@@ -72,6 +72,30 @@ rt_lint_for_default() {
 # Каталог папок задач. Пусто — ведения работы папкой в дереве нет, и гард замысла молчит.
 RT_TASKS_DIR="${RT_TASKS_DIR:-docs/tasks}"
 
+# Каталог записей о законченных работах. Туда переносят то, что объясняет решения закрытой
+# задачи. Гард поставки требует, чтобы ветка, удалившая папку задачи, что-то сюда добавила:
+# удалить проще, чем разобрать, а слова владельца больше нигде не записаны.
+RT_ARCHIVE_DIR="${RT_ARCHIVE_DIR:-docs/archive}"
+
+# Где лежат тексты, которые читают до вопроса владельцу: законы, правила и договорённости о
+# продукте. По ним гард разговора судит, читалось ли за ход хоть что-то, и их же называет в
+# подсказке. Пусто у законов и правил разом — дерево этого требования не получает: читать
+# нечего.
+RT_LAWS_DIR="${RT_LAWS_DIR:-docs/constitution}"
+RT_RULES_DIR="${RT_RULES_DIR:-.claude/skills}"
+RT_SPECS_DIR="${RT_SPECS_DIR:-docs/specs}"
+
+# Главная ветка. Гарду она нужна, чтобы найти общего предка и понять, что ветка сделала с
+# папкой задачи и с архивом. Если общего предка нет, сравнивать не с чем — проверка молчит.
+RT_MAIN_BRANCH="${RT_MAIN_BRANCH:-main}"
+
+# Тело PR по его номеру. Обход требования пишут в PR, а в команде слияния его нет — там только
+# номер. Пустой ответ значит «спросить не у кого»: тогда обход ищется только в тексте команды.
+rt_report_body_default() {
+    command -v gh >/dev/null 2>&1 || return 1
+    gh pr view "$1" --json body -q '.body' 2>/dev/null
+}
+
 # Код приложения ли это. Успех — да, и тогда правка требует замысла на диске.
 #
 # Признак — путь, а не оценка на глаз: оценку назначает тот, кому она мешает, и порог плывёт.
@@ -177,3 +201,4 @@ rt_reinvented_in() { rt_reinvented_in_default "$@"; }
 rt_is_app_code() { rt_is_app_code_default "$@"; }
 rt_qa_decorative() { rt_qa_decorative_default "$@"; }
 rt_task_state() { rt_task_state_default "$@"; }
+rt_report_body() { rt_report_body_default "$@"; }

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

@@ -79,6 +79,14 @@ 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 \
@@ -86,6 +94,21 @@ deny() {
     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"
@@ -127,11 +150,62 @@ if [ -n "$branch_arg" ]; then
     exit 0
 fi
 
+# --- слияние заявки ----------------------------------------------------------------------
+#
+# Папку задачи разбирают тем же 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
+
+    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
+
 # --- открытие заявки на слияние ----------------------------------------------------------
-case "$cmd" in
-    *gh\ pr\ create* | *glab\ mr\ create* | *az\ repos\ pr\ create*) ;;
-    *) exit 0 ;;
-esac
+# Команду ищем от начала строки или после разделителя — по той же причине, что и слияние:
+# упоминание в кавычках командой не является.
+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 — не про этот случай
@@ -164,4 +238,13 @@ 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/grill-gate.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# rt-hook: Stop
+# Гард разговора: ход, в котором владельцу задан вопрос, не заканчивается, пока за этот же ход
+# не читались законы и правила. Stop.
+#
+# Зачем именно так. Требование «правила читаются до разговора» записано в правиле ведения
+# работы, а исполнения у него не было: все прочие гарды судят правку файла или команду, а
+# вопрос в чат ни тем, ни другим не является. Поймать его можно только на завершении хода —
+# событие получает путь к записи хода и видит его целиком.
+#
+# Перехват инструмента меню вариантов эту дыру не закрывает: вопрос чаще задаётся прозой, и
+# ровно так был задан тот, из-за которого гард заведён.
+#
+# Чтением правил считается любой из трёх путей: загрузка правила, чтение файла законов или
+# правил, поиск по ним. Требовать именно загрузку значило бы гнать на неё там, где хватило
+# одного поиска, — гард мешал бы работе вместо того, чтобы её выправлять.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: при любой ошибке, отсутствии записи хода и повторном заходе ход
+# РАЗРЕШАЕТСЯ (exit 0). Сломанный гард не имеет права заклинить разговор.
+
+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
+
+# Профиль дерева: каталоги законов, правил и спеков у каждого свои, а знать их надо и для
+# признака чтения, и для подсказки в отказе.
+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}"
+rules_dir="${RT_RULES_DIR-.claude/skills}"
+specs_dir="${RT_SPECS_DIR-docs/specs}"
+
+# Дерево, у которого нет ни законов, ни правил, требования не получает: читать нечего.
+[ -z "$laws_dir" ] && [ -z "$rules_dir" ] && exit 0
+
+# Образец, по которому вызов инструмента считается чтением правил. Каталоги идут в него как
+# есть: точка в `.claude` совпадает с любым знаком и лишнего сюда не приводит.
+read_re="$(printf '%s' "$laws_dir|$rules_dir|$specs_dir" | sed 's/^|*//; s/|*$//; s/||*/|/g')"
+[ -z "$read_re" ] && exit 0
+
+# Ход — это всё, что записано после последнего настоящего ввода владельца. Ответ инструмента
+# приходит той же ролью `user`, поэтому строки с `tool_result` вводом не считаются: иначе ходом
+# оказался бы кусок после последнего вызова инструмента, и чтение правил в его начале потерялось
+# бы.
+#
+# Хвост в 400 строк: запись хода растёт всю сессию, а судится только последний ход.
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg re "$read_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 + 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
+    | (($texts | join("\n")) | test("\\?[[:space:]]*$"; "m")) as $asked_prose
+    | ($uses | map(.name == "AskUserQuestion") | any) as $asked_menu
+    | if ($asked_prose or $asked_menu) and ($read | not) then "ask" else "pass" end
+' 2>/dev/null)"
+
+[ "$verdict" = "ask" ] || exit 0
+
+reason="BLOCKED by grill-gate: в ответе есть вопрос владельцу, а законы и правила за этот ход не читались. Вопрос, ответ на который уже записан, владельцу не задаётся — правило ведения работы. Прогони поиск по словам темы и ответь по найденному; спрашивай только то, что документацией не покрыто:
+
+    grep -rn -i \"<слово темы>\" $laws_dir $rules_dir $specs_dir
+
+Гард судит один ход: следующий заход не отбивается."
+
+jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+    || printf '{"decision":"block","reason":"grill-gate: прочитай законы и правила по теме, прежде чем спрашивать владельца."}\n'
+
+exit 0

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

@@ -100,8 +100,19 @@ case "$draft" in
     *) draft_path="$root/$draft" ;;
 esac
 
-if [ ! -e "$draft_path" ]; then
-    deny "BLOCKED by task-flow: замысел называет договорённость '${draft}', а её на диске нет. Заведи её с образца (docs/specs/_template) или поправь путь в '${tasks_dir}/${branch}/plan.md'. Правило — скил task-flow."
+if [ -e "$draft_path" ]; then
+    exit 0
+fi
+
+# Договорённость, влитая в спек домена, с диска уходит — так и задумано: в главной ветке
+# директории «предложено» быть не должно. Но замысел на неё ссылается до конца работы, и без
+# этой развилки последний коммит отчёта запирал бы ветку: ни правки по замечаниям разбора, ни
+# записи в журнал изменений после вливания уже не сделать.
+#
+# Влитое от незаведённого отличает история ветки: путь, которого в ней никогда не было,
+# договорённостью не был. Спросить об этом нечем, кроме git, поэтому нет git — отказ остаётся.
+if git -C "$root" log --oneline -1 -- "$draft" 2>/dev/null | grep -q .; then
+    exit 0
 fi
 
-exit 0
+deny "BLOCKED by task-flow: замысел называет договорённость '${draft}', а её на диске нет и в истории ветки не было. Заведи её с образца (docs/specs/_template) или поправь путь в '${tasks_dir}/${branch}/plan.md'. Правило — скил task-flow."

package/assets/laws/project-documentation.md

@@ -29,7 +29,17 @@
   — это намерение, а не свойство приложения: сверить его не с чем, и оно проходит любую
   проверку. Машине это не поручить: открытый вопрос пишется теми же словами, что и обещание,
   и проверка отбивала бы оба.
+- **Документ утверждает о состоявшемся, а не о том, что должно сработать.** Лечение,
+  записанное готовым до того, как его прогнали, дороже отсутствия записи: следующий читатель
+  берёт его за проверенное — и берёт в тот день, когда лечение понадобилось, а времени на
+  разбор нет. Непрогнанное либо не пишется вовсе, либо названо непроверенным тем же
+  предложением.
 - **Число в тексте пересчитывается тем же изменением, которым пишется, и за этим тоже следит
   автор.** Устаревшее число выглядит так же, как свежее, а машине их не различить: дата,
   версия и номер — такие же числа, и проверка, которая знает один способ записи, на другом
   ошибается молча.
+- **Отказ от слова распространяется на всё, что уже прочитано снаружи, а не только на файлы.**
+  Название работы, её описание и запись о правке живут вне дерева: поиск по файлам их не
+  видит, проверки текстов на них не смотрят, и отказ выглядит сделанным ровно до того, как
+  читатель наткнётся на снятое слово в заголовке. Читатель при этом заключает, что от слова
+  не отказывались вовсе.

package/assets/laws/verifiability.md

@@ -21,6 +21,10 @@
   выкинутый сценарий: без этого он пропадает молча.
 - **Работающее приложение проверяется там, где его видит пользователь.** Отладочный режим
   ведёт себя иначе рабочего, и проверка в нём подтверждает не то, что будет у пользователя.
+- **Перед отправкой правка проверяется тем же набором, что и конвейер, и теми же командами.**
+  Набор, собранный по изменённым файлам, пропускает то, до чего правка дошла связями: проверка
+  зелёная, а конвейер красный. Что проверять, считает инструмент от той же базы, а не память
+  автора.
 - **Проверка признака окружения относится только к тому пути запуска, на котором она
   сделана.** Пути, которыми одно и то же приложение поднимается, задают признаки по-разному,
   и подтверждённое на одном из них на остальных неверно — а выглядит проверенным целиком.
@@ -30,6 +34,15 @@
   наступило.** Часть запросов выполняется наполовину, и об отклонённой части в ответе ничего
   нет: по коду возврата такой вызов не отличить от исполненного. Поэтому результат читают
   отдельным запросом, и в отчёт идёт то, что прочитали, а не то, что заказывали.
+- **Служба считается поднятой, когда она выполнила задание, а не когда сообщила о
+  готовности.** Сообщение о готовности говорит лишь, что служба себя объявила: та, которой не
+  досталось ни одного задания, выглядит в нём точно так же, как работающая. Проверяются обе
+  стороны связи — что заказчик выбирает именно её и что задание через неё прошло.
+- **Причина отказа, на которой строится решение, подтверждается измерением, а не
+  правдоподобием.** Объяснение, пришедшее первым, объясняет наблюдаемое не хуже верного:
+  свойство среды и собственный промах выглядят в отказе одинаково, и разводит их только замер,
+  поставленный так, чтобы одно из двух не прошло. Решение, выведенное из неподтверждённой
+  причины, лечит не то — и стоит отката всей работы, а не одной правки.
 - **Если инструмент проверки запрещает приём, которым здесь пользуются постоянно, его правило
   выключают в настройке инструмента, а не обходят в каждом месте.** Обход приходится повторять
   столько раз, сколько таких мест, и ни в одном из них не написано, зачем он: со стороны это