@rt-tools/agent-kit 0.5.2 → 0.6.0

package/README.md

@@ -325,13 +325,41 @@ gh label create agent-kit-feedback --description 'Предложение по с
 Роль вопросов владельцу не задаёт: ни она, ни конвейер до него не достучатся. Поэтому разбор
 ведёт главный агент, а роли стоят по обе стороны от него — разведка до, конвейер после.
 
-`skill-curator` приезжает и слеш-командой: она собирает сводку о задаче и список загруженных
-правил, без которых разбор выродится в пересказ.
+`skill-curator` приезжает и слеш-командой — о ней и остальных двух ниже.
 
-Вторая команда, `next-session`, закрывает заход: приводит дерево к главной ветке — переходом на
-неё, если работа шла по правилу и отчёт влит, и вливанием в текущую ветку во всех прочих
-случаях, — снимает влитые локальные ветки, называет невлитые и пишет передачу для следующего
-захода. Незакоммиченная правка её останавливает до первого действия; поставки она не касается.
+## Слеш-команды
+
+Род `commands` ложится в `.claude/commands/`, по файлу на команду. **Имя команды — это имя
+файла:** `next-session.md` зовётся `/next-session`. Больше нигде команды не объявляются —
+перечня, который пришлось бы держать в согласии с каталогом, нет вовсе. Строка `description:` во
+вступлении файла — то единственное, что агент видит до вызова и по чему решает, брать ли
+команду; `argument-hint:` говорит, что она принимает.
+
+| Команда             | Ресурс                         | Что делает                                                     |
+| ------------------- | ------------------------------ | -------------------------------------------------------------- |
+| `/next-session`     | `commands/next-session.md`     | закрывает заход: главная ветка, влитые ветки, передача         |
+| `/skill-curator`    | `commands/skill-curator.md`    | разбирает закрытую задачу и выгружает предложения файлом       |
+| `/agent-kit-digest` | `commands/agent-kit-digest.md` | сводит накопленные предложения и наблюдения в правки ресурсов  |
+
+`/next-session` приводит дерево к главной ветке — переходом на неё, если работа шла по правилу и
+отчёт влит, и вливанием в текущую ветку во всех прочих случаях, — снимает влитые локальные
+ветки, называет невлитые и пишет передачу для следующего захода. Незакоммиченная правка
+останавливает её до первого действия; поставки она не касается.
+
+`/skill-curator` — та же роль, приехавшая командой: она собирает сводку о задаче и список
+загруженных за неё правил, без которых разбор выродится в пересказ, и кладёт предложения файлом
+с адресом в заголовке.
+
+`/agent-kit-digest` зовётся **в репозитории самого пакета**, а не в дереве, где он стоит: там
+лежат ресурсы, которые предстоит править, и видно всех потребителей сразу.
+
+Разложенная команда правится как любой разложенный файл — не на месте: либо ресурс в пакете,
+либо надстройка `.claude/rt-kit/overrides/commands/<имя>.md`. Свою команду дерево заводит файлом
+рядом; файл без шапки раскладки пакет чужим считает и не перезаписывает.
+
+Слешем зовётся и то, что командой не является: скилы — правила, паттерны и скилы без закона из
+`.claude/skills/` — и конвейеры из `.claude/workflows/`. Что из всего этого разложено и откуда
+взялось, говорят `npx agent-kit list` и `npx agent-kit doctor`.
 
 ## Как этим пользуются в дереве
 

package/assets/checks/check-file-size.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Проверка того, что файл не длиннее предела.
+ *
+ * Файл, который не влезает на экран целиком, читают по частям, и правку в нём
+ * делают, не увидев остального. У кода длину стережёт линтер; здесь — всё, до
+ * чего он не доходит: проза, стили, шаблоны, обвязка разработки и сами гарды.
+ *
+ * Судятся `.md`, `.scss`, `.html`, `.js`, `.mjs` и `.sh`. Данные не судятся
+ * вовсе: словарь локали и настройка сборки читаются поиском, а не подряд, и
+ * делить их не на что. Код на языке, где длину стережёт линтер, тоже не
+ * судится — два отказа на один файл читаются как две разные претензии.
+ *
+ * Строки считаются все, включая пустые и комментарии, и тем же способом, каким
+ * их считает линтер: по числу разрывов плюс один. Файл, кончающийся переводом
+ * строки, поэтому весит на строку больше, чем показывает `wc -l`, — зато у обеих
+ * проверок дерева одно понятие длины.
+ *
+ * Описание прошлого из счёта выведено: архив по устройству перечисляет то, чего
+ * в дереве уже нет, а папка задачи умирает со слиянием. Сгенерированное выведено
+ * каталогом: его переписывает генератор целиком, и спорить с ним о длине некому.
+ *
+ * Накопленное к моменту заведения проверки лежит в списке известного и отказом
+ * не считается: гейт падает на НОВОМ длинном файле, а старое остаётся видимым
+ * числом в сводке. Принятое и долг там различаются: принятое дерево делить не
+ * собирается, на долг заведена работа. Строка снимается вместе с делением своего
+ * файла, и проверка сама говорит, какую строку пора убрать.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { allowlistOf, CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const ALLOWLIST = allowlistOf('file-size');
+/** Предел один на все роды файлов: своё число каждому роду — спор о числе на каждой правке. */
+const LIMIT = CONFIG.fileSizeLimit;
+
+/** Роды файлов, которых не читает линтер. Код остаётся за ним. */
+const JUDGED = ['.md', '.scss', '.html', '.js', '.mjs', '.sh'];
+
+/** Описание прошлого, папка задачи и то, что переписывает генератор. */
+const SKIPPED_PREFIXES = [CONFIG.archiveDir, `${CONFIG.tasksDir}/`, ...CONFIG.generatedDirs];
+
+/** Дерево спрашивается у системы контроля версий: иначе каталоги с точки не видны, а сборка видна. */
+function trackedFiles() {
+    return execFileSync('git', ['ls-files'], { cwd: ROOT, encoding: 'utf8', maxBuffer: 1024 * 1024 * 32 })
+        .split('\n')
+        .filter(Boolean);
+}
+
+function judged(path) {
+    if (SKIPPED_PREFIXES.some((prefix) => prefix && path.startsWith(prefix))) {
+        return false;
+    }
+
+    return JUDGED.some((extension) => path.endsWith(extension));
+}
+
+/** Тем же способом, каким считает линтер: число разрывов плюс один. */
+function lineCount(path) {
+    return readFileSync(join(ROOT, path), 'utf8').split('\n').length;
+}
+
+/**
+ * Список известного читается отдельно от общего читателя: у этой проверки нет файла — это
+ * не пустой список, а нечитаемая настройка, и молчать о ней нельзя. Пустой список законен
+ * ровно один раз — в дереве, где длинных файлов нет вовсе.
+ */
+function readKnown() {
+    const path = join(ROOT, ALLOWLIST);
+    if (!existsSync(path)) {
+        return { accepted: [], debt: [] };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+
+        return { accepted: parsed.accepted ?? [], debt: parsed.debt ?? [] };
+    } catch (error) {
+        console.error(`check-file-size: список известного не прочитан — ${ALLOWLIST}: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+const { accepted, debt } = readKnown();
+const known = new Map([...accepted.map((path) => [path, 'принято']), ...debt.map((path) => [path, 'долг'])]);
+
+const tooLong = new Map();
+const tracked = trackedFiles().filter(judged);
+
+for (const path of tracked) {
+    const lines = lineCount(path);
+    if (lines > LIMIT) {
+        tooLong.set(path, lines);
+    }
+}
+
+if (process.argv.includes('--baseline')) {
+    console.log(JSON.stringify({ accepted, debt: [...tooLong.keys()].sort() }, null, 4));
+    process.exit(0);
+}
+
+const fresh = [...tooLong].filter(([path]) => !known.has(path));
+/** Строка на файл, которого в дереве нет, — устаревшая: иначе список копит мёртвое. */
+const gone = [...known.keys()].filter((path) => !existsSync(join(ROOT, path)));
+/** Файл поделили, а строку оставили: список перестал бы отвечать за то, что в нём стоит. */
+const shrunk = [...known.keys()].filter((path) => !tooLong.has(path) && existsSync(join(ROOT, path)));
+
+const problems = [
+    ...fresh.map(([path, lines]) => `${path}: ${lines} строк, предел ${LIMIT} — делить, а не дописывать строку в ${ALLOWLIST}`),
+    ...gone.map((path) => `${path}: строка в ${ALLOWLIST} устарела — файла в дереве нет`),
+    ...shrunk.map((path) => `${path}: значится в ${ALLOWLIST}, но уже короче предела — строку убрать`),
+];
+
+if (problems.length > 0) {
+    console.error(`check-file-size: расхождений ${problems.length}\n`);
+    problems.forEach((problem) => console.error(`  ${problem}`));
+    console.error('\nПредел длины файла — правило о языке для кода и правило о текстах для прозы.');
+    process.exit(1);
+}
+
+console.log(
+    `check-file-size: проверено ${tracked.length} файлов, длиннее ${LIMIT} строк ${tooLong.size}, ` +
+        `из них принято ${accepted.length}, долг ${debt.length} — новых нет`
+);

package/assets/checks/rt-kit-checks.config.mjs

@@ -53,6 +53,16 @@ const DEFAULTS = {
     tasksDir: 'docs/tasks',
     /** Куда сложены списки принятых долгов. */
     allowlistDir: 'tools',
+    /**
+     * Каталоги, которые переписывает генератор целиком: контракт, клиент хранилища, разложенное
+     * из пакета. Спорить с генератором о длине файла и о повторе некому.
+     */
+    generatedDirs: [],
+    /**
+     * Предел длины файла — одно число на все роды: своё число каждому роду означает спор о
+     * числе на каждой правке, а не о длине файла.
+     */
+    fileSizeLimit: 500,
     /** Корни сквозных тестов; пусто — их в дереве нет. */
     e2eRoots: ['apps/site-e2e', 'apps/admin-e2e'],
     /** Корни бэкенда: у него нет ни компонентов, ни шаблонов, и часть признаков к нему не применяется. */

package/assets/defaults/gate-map.sh

@@ -15,32 +15,21 @@
 #
 # Порядок веток решает: первое совпадение выигрывает, поэтому частное идёт раньше общего.
 
-# Правила, которые вступают не от рода файла, а от того, что в него пишут.
-#
-# Обращение к среде исполнения приходит в обычный сервис, а число-настройка и перечисление —
-# в обычный класс: по имени файла ни то ни другое не видно, и правило, требуемое только по
-# расширению, здесь молчало бы.
-skill_for_written() {
-    target="$1"
-    written="$2"
-
-    [ -z "$written" ] && return 0
-
-    case "$target" in
-        *.spec.ts | */docs/* | *.md) return 0 ;;
-    esac
-
-    printf '%s' "$written" | grep -qE '(globalThis|window\.|document\.defaultView|PLATFORM_ID|isPlatformBrowser|localStorage|sessionStorage)' \
-        && printf '%s\n' 'platform-access'
+# Правила, вступающие не от рода файла, а от того, что в него пишут, здесь не выбираются:
+# они приходят слоем поверх доменного — `hooks/skill-gate-layers.sh`. Карта судит путь, слой
+# судит текст, и оба зовутся из гейта в одной оболочке.
 
-    case "$target" in
-        *.ts)
-            printf '%s' "$written" | grep -qE '^[[:space:]]*(export[[:space:]]+)?(const[[:space:]]+[A-Z][A-Z0-9_]*[[:space:]]*(:[^=]*)?=[[:space:]]*-?[0-9]|enum[[:space:]])' \
-                && printf '%s\n' 'shared-code'
-            ;;
-    esac
-
-    return 0
+# Команда считается ВЫЗОВОМ, только когда стоит в начале строки или сразу за разделителем.
+# Совпадение по подстроке ловит любое УПОМИНАНИЕ: строка о коммите в теле самого коммита и поиск
+# по истории отбивались как настоящий коммит.
+#
+# `([A-Za-z_]…=…[[:space:]]+)*` — переменные окружения перед вызовом: адрес хранилища ставят
+# приставкой самой команды, и без этого куска вызов не опознавался вовсе. `(npx…)?` — запуск
+# через раннер пакетов, `([^[:space:]]*/)?` — путь до исполняемого файла. Многострочную команду
+# поиск разбирает построчно, поэтому начало строки — начало каждой.
+rt_gate_invokes() {
+    printf '%s\n' "$1" \
+        | grep -qE "(^|[;&|(])[[:space:]]*([A-Za-z_][A-Za-z0-9_]*=[^[:space:]]*[[:space:]]+)*((npx|pnpm|yarn|bun|npm)([[:space:]]+(exec|run|dlx))?[[:space:]]+)?([^[:space:]]*/)?$2([[:space:]]|$)"
 }
 
 skill_for_default() {
@@ -81,6 +70,37 @@ skill_for_default() {
                 # строк комментария стоят захода, а второе прочитанное правило не пригождается.
                 */tools/check-dupes.mjs | */tools/dupes-allowlist.json) printf '%s\n' 'shared-code' ;;
 
+                # Остальные проверки — то же самое: проверка исполняет утверждения своего
+                # правила, и признаки, по которым она судит, объявлены у него в привязке. Правя
+                # признак в проверке, второе место открывают рядом — иначе они расходятся молча,
+                # и проверка числит отказом то, что правило разрешает.
+                */check-specs.mjs) printf '%s\n' 'spec-driven' ;;
+                */check-doc-paths.mjs | */doc-paths-allowlist.json | */check-file-size.mjs)
+                    printf '%s\n' 'doc-style' ;;
+                */check-styles.mjs | */styles-allowlist.json | */stylelint-rules/*)
+                    printf '%s\n' 'styling-bem' ;;
+                */check-lib-layers.mjs | */lib-layers-allowlist.json) printf '%s\n' 'lib-layers' ;;
+                */check-reuse.mjs | */reuse-allowlist.json) printf '%s\n' 'reuse-first' ;;
+                */check-board.mjs | */board.mjs | */task-new.mjs | */check-schema-drift.mjs)
+                    printf '%s\n' 'git-workflow' ;;
+                # Своё правило линтера кода пишется по тем же соглашениям, что и код под ним.
+                */eslint-rules/*) printf '%s\n' 'typescript-conventions' ;;
+
+                # Схема хранилища и её миграции: порядок каталогов лексикографический, а метку
+                # времени ставит инструмент в момент заведения — цепочка ломается молча и падает
+                # только накатом с нуля, то есть уже после слияния. Правило живёт при поставке.
+                */schema.prisma | */prisma/migrations/*) printf '%s\n' 'git-workflow' ;;
+                # Конвейер и образ: проверки решают, что вообще гоняется до слияния, а образ —
+                # что приезжает на прод. И то и другое правилось без единого правила поставки.
+                */.github/workflows/*.yml | */.gitlab-ci.yml | */azure-pipelines*.yml)
+                    printf '%s\n' 'git-workflow' ;;
+                */Dockerfile | */*.Dockerfile | */docker-compose*.yml | */docker-compose*.yaml)
+                    printf '%s\n' 'git-workflow' ;;
+
+                # Сквозная спека проверяет поднятое приложение, а не класс: по имени файла она от
+                # обычного модуля не отличается, и без этой ветки уходила бы в соглашения языка.
+                *-e2e/*) printf '%s\n' 'testing' ;;
+
                 # Поставка: состав зависимостей — это то, что приезжает на прод. Правка
                 # скриптов зависимостью не является, и правило про версии на неё не вступает.
                 # Оговорка: удаление зависимости приходит правкой без номера версии и сюда не
@@ -105,18 +125,54 @@ skill_for_default() {
 
                 *.ts) printf '%s\n' 'typescript-conventions' ;;
             esac
-            skill_for_written "$target" "$written"
             ;;
         bash)
-            case "$target" in
-                *git\ commit* | *git\ push* | *git\ merge* | *git\ rebase* | *git\ cherry-pick* | *gh\ pr\ * | *glab\ mr\ * | *az\ repos\ *)
-                    printf '%s\n' 'git-workflow' ;;
-                *git\ worktree\ add* | *git\ worktree\ remove*)
-                    printf '%s\n' 'git-workflow' ;;
-                *prisma\ migrate* | *prisma\ db\ *) printf '%s\n' 'git-workflow' ;;
-                *curl\ *localhost* | *wget\ *localhost*) printf '%s\n' 'browser-verification' ;;
-            esac
+            # Ветки идут проверкой на вызов, а не совпадением по подстроке: упоминание команды
+            # командой не является, и гейт отбивал собственный текст о коммите.
+            if rt_gate_invokes "$target" "git[[:space:]]+(commit|push|merge|rebase|cherry-pick)" \
+                || rt_gate_invokes "$target" "git[[:space:]]+worktree[[:space:]]+(add|remove)" \
+                || rt_gate_invokes "$target" "git[[:space:]]+checkout[[:space:]]+-b" \
+                || rt_gate_invokes "$target" "git[[:space:]]+switch[[:space:]]+-c" \
+                || rt_gate_invokes "$target" "(gh|glab)[[:space:]]+(pr|mr|issue)[[:space:]]+(create|merge|edit)" \
+                || rt_gate_invokes "$target" "az[[:space:]]+(repos|boards)" \
+                || rt_gate_invokes "$target" "[^[:space:]]*task:new" \
+                || rt_gate_invokes "$target" "prisma[[:space:]]+(migrate|db)"; then
+                printf '%s\n' 'git-workflow'
+            # Правка тела отчёта через клиент хостинга ловится двумя признаками сразу — вызовом
+            # клиента И адресом запроса: одного слова о заявке мало, оно попадает в строку любой
+            # команды, которая о ней пишет. Тело отчёта не читает ни одна проверка, и утверждение
+            # о дереве стареет в нём молча.
+            elif rt_gate_invokes "$target" "(gh|glab)[[:space:]]+api" \
+                && printf '%s' "$target" | grep -qE '(-X|--method)[[:space:]]+(PATCH|PUT).*(pulls|merge_requests)/[0-9]+'; then
+                printf '%s\n' 'git-workflow'
+            # Образы и реестр на машине владельца: там же лежат его собственные стенды и работы
+            # других его веток. Снятие и чистка важнее сборки — они уносят чужое безвозвратно.
+            # Команды чтения остаются вне гейта: ими нехватку места и разбирают, и требовать на
+            # них правило значило бы отбивать сам приём. Поэтому общая чистка ловится с `prune`.
+            elif rt_gate_invokes "$target" "docker[[:space:]]+(build|buildx|pull|push|run|compose|login|rm|rmi|stop|start|restart|image|volume|builder|network)" \
+                || rt_gate_invokes "$target" "docker[[:space:]]+system[[:space:]]+prune"; then
+                printf '%s\n' 'git-workflow'
+            fi
+
+            # Слияние отчёта — последний момент, когда папку закрытой задачи ещё можно разобрать
+            # тем же отчётом: после слияния сверка очереди её видит, а отвечать за неё уже
+            # некому. Требуется ВТОРЫМ слоем, дополнительно к правилу поставки.
+            rt_gate_invokes "$target" "(gh[[:space:]]+pr|glab[[:space:]]+mr)[[:space:]]+merge" \
+                && printf '%s\n' 'task-flow'
+
+            # Обращение к поднятому приложению: врёт здесь не код, а то, что отвечает на порту.
+            # Ответ сборки прошлого захода неотличим от ответа живой ветки. Нужны оба признака —
+            # вызов клиента И адрес: одного адреса мало, он попадает в строку любой команды,
+            # которая о нём пишет, и гейт отбивал проверку самого гейта. Порт не перечисляется:
+            # свой разовый стенд поднимается на любом свободном.
+            if printf '%s' "$target" | grep -qE '(localhost|127\.0\.0\.1):[0-9]{4,5}' \
+                && { rt_gate_invokes "$target" curl || rt_gate_invokes "$target" wget; }; then
+                printf '%s\n' 'browser-verification'
+            fi
             ;;
+        # Проверка через браузер — единственная область, где правило нужно не под правку файла, а
+        # под инструмент: врут там не файлы, а стенд и координаты.
+        browser) printf '%s\n' 'browser-verification' ;;
     esac
 
     return 0

package/assets/defaults/project.sh

@@ -25,19 +25,42 @@ rt_runner() {
 # Порты у каждого дерева свои, поэтому умолчание молчит: назвать чужой порт хуже, чем не назвать.
 RT_STANDS="${RT_STANDS:-}"
 
+# Где лежат проверки дерева и набор сценариев его гардов. Проверку, которой в дереве нет, гейт
+# пуша не зовёт: список печатается по тому, что лежит на диске.
+RT_CHECKS_DIR="${RT_CHECKS_DIR:-tools}"
+RT_HOOKS_TESTS="${RT_HOOKS_TESTS:-.claude/hooks/tests/run.sh}"
+
 # Команды, которые обязаны пройти перед пушем. По одной на строку; первая упавшая отбивает пуш.
 # Линтер стилей отдельной строкой: линтер кода файлы стилей не читает вовсе.
 #
 # Первый параметр — база: ветка, относительно которой считается вклад. Пустая означает, что
 # удалённого нет, и тогда гоняется всё: набор строже нужного безопасен, набор уже нужного — нет.
+#
+# Сборка идёт наравне с линтом и спеками. Линтер типов не читает, а спеки читают только то, что
+# кто-то ввёз в них импортом: ошибка типов в непокрытом коде доживает до сборки образа, то есть
+# до слияния. Стоит это мало — дальше работает кэш прогонщика.
+#
+# Заведённая проверка встаёт сюда, а не только в общий прогон, который никто не зовёт сам:
+# новая строка в её списке известного уезжает в главную ветку молча, а список при этом читается
+# как действующая охрана.
 rt_push_checks_default() {
     runner="$(rt_runner)"
+    root="${CLAUDE_PROJECT_DIR:-.}"
     if [ -n "$1" ]; then
-        printf '%s\n' "$runner nx affected -t lint test --base=$1"
+        printf '%s\n' "$runner nx affected -t lint test build --base=$1"
     else
-        printf '%s\n' "$runner nx run-many -t lint test --all"
+        printf '%s\n' "$runner nx run-many -t lint test build --all"
     fi
-    [ -f "${CLAUDE_PROJECT_DIR:-.}/stylelint.config.js" ] && printf '%s\n' "$runner stylelint \"**/*.scss\" --max-warnings 0"
+    [ -f "$root/stylelint.config.js" ] && printf '%s\n' "$runner stylelint \"**/*.scss\" --max-warnings 0"
+
+    # Сценарии гардов — такой же код, как всё остальное: на них держится и разбор ветки, и
+    # уверенность, что обвязка ещё работает. Прогон занимает секунды: он ничего не собирает.
+    [ -x "$root/$RT_HOOKS_TESTS" ] && printf '%s\n' "bash $RT_HOOKS_TESTS"
+
+    for check in check-doc-paths check-specs check-file-size check-dupes check-styles \
+        check-lib-layers check-reuse check-schema-drift; do
+        [ -f "$root/$RT_CHECKS_DIR/$check.mjs" ] && printf '%s\n' "node $RT_CHECKS_DIR/$check.mjs"
+    done
 
     return 0
 }

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

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# Слои гейта правил: требования, которые приходят ПОВЕРХ доменного.
+#
+# Доменное правило выбирается один раз по пути файла — у правки один предмет, и правило под него
+# одно. Слоёв поверх него полтора десятка: доступ к среде исполнения виден только в тексте
+# правки, наблюдаемость приходит вместе с доменом, а не вместо него, проза и ведение работы
+# судят тот же файл вторым признаком. Вместе они не помещаются в карту гейта, которую читают
+# целиком, — поэтому лежат здесь.
+#
+# Подключается из `skill-gate.sh` в его же оболочке: читает `$input`, `$target` и `$req` и
+# дописывает имена правил в `$req`. Отдельным процессом слои возвращали бы то же самое через
+# диск.
+#
+# ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нечем разобрать вход — слой молчит. Разбор входа здесь побочная
+# работа, и её поломка не имеет права остановить правку.
+#
+# Адреса дерева слои не знают: где у него бэкенд, витрина и сквозные тесты, говорит само дерево
+# — функцией `skill_layer_skip <правило> <цель>` в своей карте гейта. Нет её — слой действует
+# везде, где подошёл его признак.
+
+# Уже названное вторым разом не требуется: отказ, перечисляющий одно правило дважды, читается
+# как два разных требования.
+rt_layer_add() {
+    case " $req " in
+        *" $1 "*) return 0 ;;
+    esac
+    req="${req:+$req }$1"
+}
+
+# Дерево вправе снять слой с места, где признак законен: прямое обращение к среде исполнения на
+# бэкенде, чтение окружения в обвязке, заведение файла в сквозных тестах.
+rt_layer_allowed() {
+    command -v skill_layer_skip >/dev/null 2>&1 || return 0
+    skill_layer_skip "$1" "$2" && return 1
+    return 0
+}
+
+# Текст правки читается один раз на все слои: разбор входа стоит дороже самих признаков.
+rt_layer_payload=""
+if command -v jq >/dev/null 2>&1; then
+    rt_layer_payload="$(printf '%s' "$input" \
+        | jq -r '[.tool_input.content, .tool_input.text, .tool_input.new_string, (.tool_input.edits[]?.new_string)]
+                 | map(select(. != null)) | join("\n")' 2>/dev/null)"
+fi
+
+# Спека проверяет поведение, а не заводит его: там нужен `testing`, и слои поведения её обходят.
+rt_layer_is_spec=1
+case "$target" in *.spec.ts) rt_layer_is_spec=0 ;; esac
+
+# --- слой по тексту: обращение к среде исполнения ---------------------------------------------
+#
+# Путь говорит, ЧТО за файл, а обращение к глобальному объекту видно только в содержимом: гейт,
+# знающий один путь, пропускает его молча. Значение, полученное внедрением, признаком не
+# считается — это уже зависимость, а не прямое обращение.
+if [ -n "$rt_layer_payload" ] && [ "$rt_layer_is_spec" = 1 ]; then
+    case "$target" in
+        */main.ts|*/main.server.ts|*/server.ts|*/index.html) ;;
+        *.ts|*.html)
+            if printf '%s' "$rt_layer_payload" | grep -qE \
+                'globalThis|PLATFORM_ID|isPlatformBrowser|defaultView|(^|[^[:alnum:]_.#$])window[[:space:]]*\.'; then
+                rt_layer_allowed platform-access "$target" && rt_layer_add platform-access
+            fi
+            ;;
+    esac
+fi
+
+# --- слой по тексту: наблюдаемость ------------------------------------------------------------
+#
+# Чтение переменной окружения и есть тот момент, когда заводится новая необязательная
+# возможность. Сводка старта перечисляет их руками, и забывшая дописать себя не попадёт ни в
+# один из трёх списков — на проде она выглядит не выключенной, а несуществующей.
+if [ -n "$rt_layer_payload" ] && [ "$rt_layer_is_spec" = 1 ]; then
+    case "$target" in
+        *.ts)
+            if printf '%s' "$rt_layer_payload" | grep -qE 'process\.env'; then
+                rt_layer_allowed observability "$target" && rt_layer_add observability
+            fi
+            ;;
+    esac
+fi
+
+# --- слой по тексту: общий код ----------------------------------------------------------------
+#
+# Заводимое число-настройка и заводимое перечисление — тот момент, когда рядом с уже общим
+# появляется копия. Каждая копия сама по себе исправна, и ни линт, ни сборка второй не видят.
+# Спеки не в счёт: там значения местные, это фикстуры.
+if [ -n "$rt_layer_payload" ] && [ "$rt_layer_is_spec" = 1 ]; then
+    case "$target" in
+        *.ts)
+            if printf '%s' "$rt_layer_payload" | grep -qE \
+                '(^|[[:space:]])(export[[:space:]]+)?const[[:space:]]+[A-Z][A-Z0-9_]*[[:space:]]*(:[[:space:]]*number[[:space:]]*)?=[[:space:]]*[0-9]|(^|[[:space:]])export[[:space:]]+enum[[:space:]]'; then
+                rt_layer_allowed shared-code "$target" && rt_layer_add shared-code
+            fi
+            ;;
+    esac
+fi
+
+# --- слой по пути: классы Angular -------------------------------------------------------------
+#
+# Компонент и стор — тоже классы: сигнальный API входов, обнаружение изменений и место подписки
+# живут в `angular-patterns`, а первым слоем эти файлы уходят в устройство компонента и в
+# соглашения языка, где ничего этого нет.
+if [ "$rt_layer_is_spec" = 1 ]; then
+    case "$target" in
+        *.component.ts|*.store.ts)
+            rt_layer_allowed angular-patterns "$target" && rt_layer_add angular-patterns
+            ;;
+    esac
+fi
+
+# --- слой по пути: проза ----------------------------------------------------------------------
+#
+# Формат спека держит `spec-driven`, а как формулировать — `doc-style`, и нужен он не только
+# спекам. Список известного у проверки — та же проза: его поле объясняет, что перечисленное
+# отказом не считается, а сверка текстов читает только `.md`.
+#
+# Хозяйство самого агента слой обходит: правило на него — оно само, и карта гейта решает про
+# эти файлы целиком. Слой, наложенный поверх, требовал бы правило там, где карта его нарочно
+# не назвала.
+case "$target" in
+    */.claude/*) ;;
+    *.md|*-allowlist.json) rt_layer_allowed doc-style "$target" && rt_layer_add doc-style ;;
+esac
+
+# --- слой по пути: ведение работы -------------------------------------------------------------
+#
+# Папка задачи, договорённость о продукте до кода и линия работ — первые файлы, которые
+# заводятся в работе. Требование ловит на них того, кто пошёл мимо порядка: «пришла новая
+# задача» инструментом не является, и поймать это больше нечем.
+case "$target" in
+    */docs/tasks/*|*/docs/specs/*/proposed/*|*/docs/plans/*)
+        rt_layer_allowed task-flow "$target" && rt_layer_add task-flow
+        ;;
+esac
+
+# --- слой по заведению файла ------------------------------------------------------------------
+#
+# Ничего не пишется с нуля, и спрашивается это там, где решение и принимается, — на заведении
+# нового файла: у правки существующего опора уже выбрана, а требовать правило на каждую строку
+# значит сделать его фоном.
+case "$target" in
+    */docs/*) ;;
+    *.spec.ts|*.stories.ts) ;;
+    *.ts|*.html|*.scss)
+        [ -f "$target" ] || { rt_layer_allowed reuse-first "$target" && rt_layer_add reuse-first; }
+        ;;
+esac
+
+# Куда встаёт заведённая проверка и какой формы у неё список известного — утверждения `testing`,
+# и нужны они ровно в момент заведения: у существующей проверки и место в гейте, и форма списка
+# уже выбраны.
+case "$target" in
+    */check-*.mjs|*-allowlist.json)
+        [ -f "$target" ] || { rt_layer_allowed testing "$target" && rt_layer_add testing; }
+        ;;
+esac

package/assets/hooks/skill-gate.sh

@@ -62,6 +62,11 @@ case "$tool" in
         # приходит в обычный сервис, а число-настройка в обычный класс.
         written="$(printf '%s' "$input" | jq -r '[.tool_input.content, .tool_input.text, .tool_input.new_string, (.tool_input.edits[]?.new_string)] | map(select(. != null)) | join("\n")' 2>/dev/null)"
         req="$(skill_for edit "$target" "$written" 2>/dev/null)"
+        # Слои поверх доменного правила лежат отдельным файлом и зовутся в этой же оболочке:
+        # доменное правило выбирается один раз по пути, а слоёв полтора десятка, и вместе они не
+        # помещаются в карту, которую читают целиком. Нет файла — гейт остаётся одним слоем.
+        # shellcheck disable=SC1090
+        [ -f "$rt_hooks_dir/skill-gate-layers.sh" ] && . "$rt_hooks_dir/skill-gate-layers.sh" 2>/dev/null
         # Род правки для наблюдения. Одно расширение, без пути и без имени файла: наблюдение
         # уезжает наружу, и всё, кроме рода, там было бы адресом этого дерева.
         case "${target##*/}" in
@@ -123,7 +128,11 @@ req="$want"
 [ -f "$rt_hooks_dir/observe.sh" ] && . "$rt_hooks_dir/observe.sh" 2>/dev/null
 command -v rt_note >/dev/null 2>&1 && rt_note gate-deny "res=$req" "kind=$kind" "sid=$sid"
 
-reason="Отбито гейтом правил: загрузи правило «${req}» инструментом Skill и повтори действие. Для этой области это происходит один раз за сессию."
+# Запасной ход называется прямо в отказе: правило, заведённое в этой же ветке, реестру правил
+# неизвестно — он собирается на запуске сессии, а гейт читает диск. Без этой строки следующий
+# заход ищет обход перебором и обычно находит не тот.
+fallback="Если инструмент такого имени не знает, правило завели после начала сессии — прочитай ${rules_dir}/${req}/SKILL.md и спутник рядом с ним."
+reason="Отбито гейтом правил: загрузи правило «${req}» инструментом Skill и повтори действие. ${fallback} Для этой области это происходит один раз за сессию."
 
 # Правило называет свой закон одним словом, а слоёв законов два: общий лежит в корне, закон
 # приложения — в каталоге под ним. Путь ищется, а не собирается из имени, иначе отказ ведёт в
@@ -134,7 +143,7 @@ if [ -n "$law" ]; then
     law_path="$laws_dir/${law}.md"
     [ -f "$root/$law_path" ] || law_path="$laws_dir/application/${law}.md"
     [ -f "$root/$law_path" ] \
-        && reason="Отбито гейтом правил: загрузи правило «${req}» инструментом Skill — оно применяет закон ${law_path} к этому дереву — и повтори действие. Для этой области это происходит один раз за сессию."
+        && reason="Отбито гейтом правил: загрузи правило «${req}» инструментом Skill — оно применяет закон ${law_path} к этому дереву — и повтори действие. ${fallback} Для этой области это происходит один раз за сессию."
 fi
 
 jq -n --arg r "$reason" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}' 2>/dev/null \

package/assets/laws/code-structure.md

@@ -20,6 +20,9 @@
   причина названа рядом.
 - **Отметка об устаревании — повод убрать, а не повод оставить.** Устаревшее объявление,
   которое молча продолжает работать, переживает того, кто его пометил.
+- **Файл читается целиком.** Длина, при которой его читают по частям, объявлена одним числом на
+  все роды файлов, и накопленное до объявления перечислено поимённо: перечень отмечает долг, а
+  не выдаёт разрешение.
 
 ## Открытые вопросы
 

package/assets/laws/delivery.md

@@ -75,3 +75,12 @@
   его написали, а разбора ждёт днями: за это время главная ветка вливается в ветку, и
   утверждение отчёта о соседних файлах становится неправдой молча — тел отчётов не читает ни
   одна проверка. Всё, что вливается в ветку после публикации отчёта, — повод перечитать его.
+- **Слияние в главную ветку ещё не означает, что правка доехала.** Отказ выкатки не трогает ни
+  задачу, ни очередь работ, поэтому расхождение главной ветки с тем, что работает, обязано быть
+  видно там, где очередь читают. Иначе следующие работы вливаются поверх поломки, которую не
+  приносили, и каждая выглядит доехавшей.
+- **Состоявшаяся поломка разбирается записью, которая переживает задачу.** Починка уезжает
+  веткой, задача закрывается — и причина, по которой приложение встало, остаётся знанием одного
+  исполнителя. Запись называет, что сломалось, чем это стало видно и почему починка чинит
+  причину, а не признак; живёт она среди описаний состоявшегося, а не там, что умирает вместе с
+  задачей.