@rt-tools/agent-kit 0.8.2 → 0.9.0

package/assets/checks/spec-scenarios.mjs

@@ -0,0 +1,201 @@
+/**
+ * Сценарии домена и уровень их привязки: что сценарий обещает, каким тестом это покрыто и не
+ * выключен ли тест переменной окружения.
+ */
+import {
+    ACTOR,
+    E2E_ROOTS,
+    PARTIAL,
+    PERCEIVES,
+    PROMISE,
+    SCENARIO_HEADING,
+    SCENARIO_REFERENCE,
+    TEST_ROOTS,
+    UNCOVERED,
+    read,
+    walk,
+} from './spec-common.mjs';
+
+// ── 4. Сценарии и уровень привязки ────────────────────────────────────────────
+
+function parseScenarios(file) {
+    const lines = read(file).split('\n');
+    const scenarios = [];
+    let current = null;
+    let inPromise = false;
+
+    lines.forEach((line, index) => {
+        const heading = SCENARIO_HEADING.exec(line);
+        if (heading) {
+            current = {
+                id: heading[1],
+                prefix: heading[2],
+                title: heading[4],
+                file,
+                line: index + 1,
+                uncovered: false,
+                partial: false,
+                promise: '',
+            };
+            inPromise = false;
+            scenarios.push(current);
+
+            return;
+        }
+        if (/^#{1,6}\s/.test(line)) {
+            current = null;
+
+            return;
+        }
+        if (!current) {
+            return;
+        }
+        if (UNCOVERED.test(line)) {
+            current.uncovered = true;
+        }
+        if (PARTIAL.test(line)) {
+            current.partial = true;
+        }
+        // «Тогда» и его продолжения с отступом — то, что сценарий обещает
+        if (PROMISE.test(line)) {
+            inPromise = true;
+            current.promise += ` ${line.trim()}`;
+
+            return;
+        }
+        if (inPromise && /^\s+\S/.test(line)) {
+            current.promise += ` ${line.trim()}`;
+
+            return;
+        }
+        inPromise = false;
+    });
+
+    return scenarios;
+}
+
+/**
+ * Обещан ли сценарием экран. Признак читается только из «Тогда»: «Дано» описывает
+ * обстановку, «Когда» — повод, а обещание пользователю стоит именно здесь.
+ *
+ * Человек и глагол восприятия требуются вместе, потому что порознь оба ошибаются.
+ * «Показывается» без человека стоит и там, где показывается запись в базе, а человек без
+ * восприятия — в каждом втором сценарии приёма заявки. Признак нарочно молчалив: сценарий,
+ * чьё «Тогда» человека не называет, под него не подпадает вовсе.
+ */
+function promisesScreen(promise) {
+    return ACTOR.test(promise) && PERCEIVES.test(promise);
+}
+
+/**
+ * Константы, собранные из окружения, вместе с теми, что собраны из них. Ими выключают
+ * сквозной тест целиком: без `BASE_URL` или пары входа он не исполняется ни разу.
+ * Цепочка раскрывается, пока есть что раскрывать: `HAS_ADMIN_SESSION` собран из двух
+ * других констант, а не из `process.env` напрямую.
+ */
+function environmentSwitches(root) {
+    // Объявление верхнего уровня: с отступом стоят локальные, и они гасят не тест, а случай
+    const declaration = /^const\s+([A-Za-z_]\w*)\s*(?::[^=]+)?=\s*([^;]+);/gm;
+    const assignments = [];
+    for (const file of walk(root, (name) => name.endsWith('.ts'))) {
+        for (const [, name, value] of read(file).matchAll(declaration)) {
+            assignments.push({ name, value });
+        }
+    }
+
+    const switches = new Set();
+    for (let pass = 0; pass <= assignments.length; pass += 1) {
+        const before = switches.size;
+        for (const { name, value } of assignments) {
+            if (value.includes('process.env') || [...switches].some((known) => new RegExp(`\\b${known}\\b`).test(value))) {
+                switches.add(name);
+            }
+        }
+        if (switches.size === before) {
+            break;
+        }
+    }
+
+    return switches;
+}
+
+/**
+ * Упоминания сценария в тестах: где стоит, идёт ли тест путём пользователя и не выключен ли
+ * он переменной окружения.
+ *
+ * Выключатель по состоянию стенда («у объекта меньше двух помещений») — это пропуск случая,
+ * и покрытие он не отменяет. Выключатель по переменной отменяет: тест с ним в обычном
+ * прогоне значится пропущенным, а сводка без этого читала бы его покрытием.
+ */
+function collectReferences() {
+    const references = new Map();
+    const remember = (id, place) => {
+        if (!references.has(id)) {
+            references.set(id, []);
+        }
+        references.get(id).push(place);
+    };
+    const switchesByRoot = new Map();
+
+    for (const root of TEST_ROOTS) {
+        for (const file of walk(root, (name) => name.endsWith('.spec.ts'))) {
+            const e2eRoot = E2E_ROOTS.find((dir) => file.startsWith(`${dir}/`));
+            if (e2eRoot && !switchesByRoot.has(e2eRoot)) {
+                switchesByRoot.set(e2eRoot, environmentSwitches(e2eRoot));
+            }
+            const switches = switchesByRoot.get(e2eRoot) ?? new Set();
+            const switched = (line) =>
+                [...line.matchAll(/test\.skip\(([^,]*)/g)].some(
+                    ([, condition]) =>
+                        condition.includes('process.env') || [...switches].some((name) => new RegExp(`\\b${name}\\b`).test(condition))
+                );
+
+            const found = [];
+            let test = null;
+            let describeSwitched = false;
+
+            read(file)
+                .split('\n')
+                .forEach((line, index) => {
+                    if (/^\s*test\.describe[.(]/.test(line)) {
+                        describeSwitched = false;
+                        test = null;
+                    } else if (/^\s*test\s*\(/.test(line)) {
+                        test = { off: describeSwitched };
+                    } else if (/test\.skip\(/.test(line)) {
+                        if (test) {
+                            test.off = test.off || switched(line);
+                        } else {
+                            describeSwitched = describeSwitched || switched(line);
+                        }
+                    }
+
+                    for (const [id] of line.matchAll(SCENARIO_REFERENCE)) {
+                        found.push({ id, test, place: `${file}:${index + 1}` });
+                    }
+                });
+
+            // Выключатель стоит первой строкой тела, то есть ниже заголовка теста с
+            // идентификатором: состояние теста читается, когда файл разобран целиком
+            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;
+}
+
+export { collectReferences, parseScenarios, promisesScreen };

package/assets/commands/feedback.md

@@ -0,0 +1,95 @@
+---
+description: Слово о слое правил, сказанное посреди работы, ложится блоком в файл предложений
+argument-hint: '<что мешает, чего не хватило, что сработало не так>'
+---
+
+Положи слово пользователя блоком в файл предложений. Слово: `$ARGUMENTS`
+
+Зовётся **посреди работы**, а не после неё: то, обо что споткнулись час назад, к разбору закрытой
+задачи уже забыто, а сама реплика живёт до конца сессии и умирает вместе с ней. Разбор закрытой
+задачи смотрит на загруженное и на ход работы; реплик он не видит вовсе.
+
+Команда ничего не отправляет. Она кладёт блок на диск, а увозит его обычная отправка, позванная
+отдельно. Скажи об этом пользователю последней строкой — иначе положенное читается как
+отправленное, и он ждёт ответа, которого никто не посылал.
+
+## 1. Пойми, о чём слово
+
+Слово пользователя — проза: «вот это правило мешает», «гейт требует не то», «этого в правилах
+нет вовсе». Твоё дело — перевести её в три вещи:
+
+- **адрес** — куда правка идёт;
+- **ресурс** — что именно правится;
+- **готовый текст** — ровно то, что вставить.
+
+Адрес один из трёх, и выбирается он не по удобству:
+
+    пакет      — правка ресурса @rt-tools/agent-kit; верна любому дереву и уезжает наружу
+    компаньон  — implementation.md рядом с правилом: имена этого дерева и привязка статей
+    дерево     — надстройка этого дерева; наружу не уезжает никогда
+
+Ресурс называется идентификатором пакета — `rules/styling-bem.md`, `hooks/skill-gate.sh`,
+`patterns/git-workflow-commit.md`, — а у адресов «компаньон» и «дерево» путём в дереве.
+
+**Непонятный адрес спрашивается, а не назначается по догадке.** Неверный адрес уводит правку в
+чужой репозиторий: сказанное о своём дереве уезжает всем, а сказанное обо всех остаётся лежать
+дома. Пока пользователь не ответил, в файл не записывается ничего.
+
+Спрашивать не надо, когда адрес виден из самого слова: речь о правиле, которое ты только что
+грузил, — это `пакет`; речь об именах, путях и командах этого дерева — `компаньон` или `дерево`.
+
+## 2. Найди файл сегодняшнего дня
+
+Блок ложится туда же, куда его кладёт разбор закрытой задачи: у них один адресат и один формат, а
+второй файл рядом означал бы, что отправка читает два места, а пользователь не помнит, в каком
+лежит его слово.
+
+```bash
+ls .claude/rt-kit/proposals/$(date +%F)-*.md 2>/dev/null
+```
+
+Нашёлся — дописывай в него. Не нашёлся — заведи с образца, назвав по ветке:
+
+```bash
+mkdir -p .claude/rt-kit/proposals
+cp .claude/rt-kit/templates/proposal.md \
+   ".claude/rt-kit/proposals/$(date +%F)-$(git branch --show-current).md"
+```
+
+У свежего файла шапка образца остаётся, а незаполненный образец блока — `rules/<правило>.md` со
+скобками — заменяется твоим блоком: отправка такой образец пропускает, но лежит он молчаливым
+мусором.
+
+## 3. Напиши блок
+
+Форма заголовка — не украшение: по ней отправка отбирает то, что уезжает наружу. Блок без адреса
+в заголовке не уедет никуда и останется лежать молча.
+
+```markdown
+## <адрес> · <ресурс>
+
+- **место:** раздел «<заголовок>», в конец
+- **повод:** что в этой работе пошло не так без этого правила
+
+> Готовый текст правки — ровно то, что вставить, в стиле соседних правил: по-русски,
+> утверждением, без воды.
+```
+
+Повод пишется от случая, а не от желания: «здесь было неудобно» правилом не становится. Слово
+пользователя пересказывается его смыслом, а не твоими выводами о том, как надо было бы.
+
+**Адреса этого дерева в тексте блока не бывает** — ни пути, ни имени корня, ни имени чужого
+репозитория: файл уезжает в чужой репозиторий целиком. Найденный адрес отбивает отправку с
+номером строки, и это проверка, а не напоминание. Правь текст, а не обходи её.
+
+## 4. Скажи, что вышло
+
+Одной строкой: в какой файл лёг блок, сколько блоков в нём теперь и чем он уедет.
+
+```bash
+npx agent-kit propose --dry-run     # что уехало бы
+npx agent-kit propose               # отправить груз в приём
+```
+
+Отправка увозит блоки с адресом «пакет» и метит их отправленными; блоки «компаньон» и «дерево»
+остаются лежать — их правит тот, кто работает в этом дереве.

package/assets/commands/rules-review.md

@@ -0,0 +1,98 @@
+---
+description: Смысловое ревью семьи текстов слоя правил — закон, его правила и паттерны при них
+argument-hint: '<имя закона>'
+---
+
+Прогони смысловое ревью одной семьи текстов пакета правил. Семья: `$ARGUMENTS`
+
+Зовётся **в репозитории самого пакета**, а не в дереве, где он стоит: судятся исходные тексты
+ресурсов, и лежат они только здесь. В чужом дереве лежит разложенная копия выбранных ресурсов, а
+не семья целиком, и путей, по которым команда ходит, в нём нет вовсе: обход по ним вернёт
+пустоту, неотличимую от «такого закона не бывает». Каталог ресурсов ниже назван так, как он
+зовётся в репозитории пакета.
+
+Считаемое ловит проверка полноты текстов — недостающий раздел, правило без паттерна, имя соседа,
+которому в наборе ничего не отвечает. Здесь ищется то, чего она не считает: два текста,
+говорящих об одном разное, и случай, которого не назвал ни один. Ответ роли не повторяется от
+запуска к запуску, поэтому в гейт он не идёт и ветку не отбивает.
+
+## 1. Пойми, какая семья
+
+Семья зовётся именем закона — без пути и без расширения: `work-conduct`, `delivery`,
+`project-documentation`.
+
+```bash
+ls projects/agent-kit/assets/laws/*.md projects/agent-kit/assets/laws/*/*.md
+```
+
+**Имени нет** — назови человеку перечень имён и остановись. Догадываться по похожести нельзя:
+ревью уйдёт на чужую семью, и его находки человек примет за находки о своей.
+
+**Названо несколько** — гони по одной, по очереди, и ответы не смешивай: находка семьи читается
+вместе с её законом, а сваленные в кучу они теряют адрес.
+
+**Довода нет вовсе** — потребуй имя и напечатай перечень. Умолчания здесь нет: «первый
+попавшийся закон» даёт прогон, неотличимый от осмысленного.
+
+**Закон лежит в слое приложения** — это законный случай, а не промах: у денег, локалей и доступа
+семья такая же. Читается он оттуда же, где лежит.
+
+## 2. Собери семью
+
+Правило принадлежит закону полем `law:`, паттерн правилу — полем `rule:`. Приставка имени
+ненадёжна: её несут не все паттерны.
+
+```bash
+LAW=<имя закона>
+grep -l "^law: $LAW\$" projects/agent-kit/assets/rules/*.md
+```
+
+Дальше по каждому найденному правилу — его паттерны. Имя правила для поиска берётся голым: без
+вида и без требования — оба стоят суффиксами в имени файла, а поле `rule:` у паттерна несёт
+только само имя.
+
+```bash
+RULE=<имя правила: первое слово имени файла, до первой точки>
+grep -l "^rule: $RULE\$" projects/agent-kit/assets/patterns/*.md
+```
+
+**Виды берутся все.** `git-workflow.github`, `git-workflow.gitlab`, `git-workflow.azure` — три
+редакции одного правила: дерево раскладывает одну, а расходятся они молча.
+
+**Суффикс требования — не вид.** `entity-conventions.needs-admin`, `observability.needs-app` —
+это правила, которые дерево берёт, только когда объявило нужную черту. Имя с этим суффиксом в
+поле `rule:` не стоит ни у одного паттерна: поиск по нему возвращает пустоту, и семья уезжает в
+ревью без паттернов вовсе — молча, потому что пустой ответ выглядит как «паттернов нет».
+
+**У закона нет ни одного правила** — скажи это человеку и остановись. Читать один закон нечем:
+расхождение живёт между двумя текстами, а пробел уровня статьи без правил под ней — не находка
+ревью, а отсутствие целого слоя. Сам по себе такой закон стоит разговора: его находит и проверка
+полноты текстов, и она же скажет, сколько их.
+
+## 3. Запусти роль
+
+Инструментом `Agent`, `subagent_type: 'rules-reviewer'`. В промпт — имя закона и полный список
+путей: закон, все его правила со всеми видами, все паттерны при них. Список собираешь ты: роль
+git-команд не зовёт и историю не читает.
+
+Одна роль на семью. Веер из нескольких ролей со сведением ответов здесь не заводится: взгляд на
+предмет один — два текста об одном говорят разное, — а сведение превращает дословные цитаты в
+пересказ.
+
+## 4. Покажи находки человеку
+
+**Как есть.** Роль возвращает цитаты дословно, и пересказ их портит: по пересказу человек не
+отличит настоящее расхождение от прочтения роли.
+
+Порядок сохрани: сперва расхождения — у каждого два места и две цитаты, — потом пробелы, у
+которых второго места нет.
+
+По каждой находке скажи своё: согласен или нет и почему. Правку не вноси — тексты правил
+действуют на все будущие сессии всех деревьев, и решает по ним человек.
+
+Находка, с которой человек согласился, идёт дальше двумя путями, и выбирает он:
+
+- **правится тут же** — если это правка текста пакета и она укладывается в текущую работу;
+- **уходит задачей** в очередь работ — если тянет за собой код, раскладку или другой закон.
+
+Пустой ответ роли — тоже результат: скажи, что находок нет, и не выдумывай их из вежливости.

package/assets/commands/skill-curator.md

@@ -6,8 +6,14 @@ argument-hint: '[пусто | <акцент, на что смотреть в п
 Запусти агента `skill-curator` на разбор только что закрытой задачи. Акцент от пользователя:
 `$ARGUMENTS`
 
-Вызывается **после того, как задача сделана и проверена**, до перехода к следующей. Агент ничего
-не правит — приносит готовые формулировки, а решение вставлять их принимает пользователь.
+Вызывается **сразу за открытием PR** — тем же ходом, которым работа отдана на разбор. Агент
+ничего не правит: он приносит готовые формулировки, а решение вставлять их принимает
+пользователь.
+
+**Запуск фоновый, и ход на нём не кончается.** Пока агент работает, берётся следующая задача:
+он ничего не спрашивает и быстрее от ожидания не идёт. Шаги 1 и 2 делаются до запуска — пока
+задача ещё в голове; шаги 4–6 принимают вернувшийся ответ одним ходом и возвращают исполнителя
+к прежней работе.
 
 ## 1. Найди список загруженного
 
@@ -42,50 +48,61 @@ ls -t "${TMPDIR}claude-skill-gate/"*.loaded | head -5
 которой не было» — ровно то, из чего получаются правила. Приглаженная сводка даёт приглаженный
 разбор.
 
-## 3. Запусти агента
+## 3. Запусти агента в фон и вернись к работе
 
 Инструментом `Agent`, `subagent_type: 'skill-curator'`. В промпт — путь к `.loaded` и сводку
 целиком.
 
-## 4. Выгрузи предложения файлом
+Ход на этом не кончается: пока агент работает, берётся следующая задача. Ответ придёт
+уведомлением, и тогда идут шаги 4–6 — один ход, после которого исполнитель возвращается к тому,
+что делал.
+
+## 4. Положи находки в папку задачи
 
-Ответ роли живёт в переписке и умирает вместе с ней, а правки в пакет идут из другого дерева и
-в другой день. Поэтому предложения ложатся на диск — их пишешь ты, не роль: файлов она не
-пишет вовсе.
+Ответ роли живёт в переписке и умирает вместе с ней, поэтому он сразу ложится на диск — рядом с
+ходом работы, в папку задачи. Пишешь его ты, не роль: файлов она не пишет вовсе.
 
 ```bash
-mkdir -p .claude/rt-kit/proposals
-cp .claude/rt-kit/templates/proposal.md .claude/rt-kit/proposals/$(date +%F)-<ветка>.md
+cat > docs/tasks/<ветка>/curator.md    # заголовок блока — «## <адрес> · <ресурс>»
 ```
 
-Дальше — по блоку на предложение, заголовком `## <адрес> · <ресурс>`. Адрес роль уже поставила,
-твоё дело — не потерять его и не переписать текст своими словами.
+Адрес у каждого блока роль уже поставила — «пакет», «компаньон» или «дерево». Твоё дело — не
+потерять его и не переписать текст своими словами.
 
-Файл читает `agent-kit propose`: по заголовку он отбирает то, что уезжает в приём. Блок без
-адреса в заголовке не уедет никуда и останется лежать молча.
+Папка задачи умирает со слиянием, а находки должны пережить весь эпик: владелец читает их
+разом, когда эпик кончился. Поэтому при разборе папки файл находок не удаляется, а переезжает к
+замыслу эпика — паттерн закрытия работы. Работа вне эпика показывает находки владельцу сразу.
 
-## 5. Отправь то, что адресовано пакету
+## 5. Отправь сводку наблюдений — и только её
 
 ```bash
 npx agent-kit propose --dry-run     # что уехало бы
 npx agent-kit propose               # отправить груз в приём
 ```
 
-Груз уезжает при каждом прогоне: сводка наблюдений со снимком надстроек, предложения с адресом
-«пакет» — когда они есть, — и разборы происшествий. Прогон без замечаний тоже говорит, чем
-пользовались, чем не пользовались ни разу и что дерево переопределило. Отправленное предложение
-помечается в том же файле и второй раз не уезжает.
+Груз уезжает при каждом прогоне: сводка наблюдений со снимком надстроек, разборы происшествий и
+предложения, лежащие в каталоге предложений. Сводка — факт: чем пользовались, чем не
+пользовались ни разу, что дерево переопределило. Она уезжает всегда и слова владельца не ждёт.
+
+**Находки разбора в каталог предложений сами не ложатся, и потому не уезжают.** Предложение —
+заготовка правки чужого дерева, и часть заготовок отпадает при первом же чтении; уехавшая без
+разбора, она становится работой того, кто её не заказывал. В каталог предложений переносится
+только то, что владелец назвал верным, — и тогда же уезжает.
 
 Отправка отказывает, если адрес этого дерева нашёлся в сводке или в тексте предложения — путь,
 имя корня, чужой репозиторий. Это не придирка: груз уезжает наружу целиком. Правь текст, а не
 обходи проверку. Разбор происшествия проверкой не накрыт: он по устройству называет файлы
 дерева, где промах случился.
 
-## 6. Отдай результат владельцу
+## 6. Отдай находки владельцу — по концу эпика
+
+Покажи находки **как есть**: роль пишет готовый текст для вставки, и пересказ его портит. По
+каждой скажи своё — согласен или нет и почему; правило, с которым ты не согласен, вставлять не
+надо.
 
-Покажи предложения агента **как есть**: он пишет готовый текст для вставки, и пересказ его
-портит. По каждому скажи своё — согласен или нет и почему; правило, с которым ты не согласен,
-вставлять не надо.
+Работа в эпике показывает их не сразу: находки копятся у замысла эпика и читаются разом, когда
+эпик кончился, — так владелец видит повторяющееся, а не разрозненные заметки. Названное им
+верным переносится в каталог предложений и уезжает шагом 5.
 
 У каждого предложения агент ставит пометку «пакет», «компаньон» или «дерево»: тексты приезжают
 из `@rt-tools/agent-kit`, и правка разложенного файла на месте теряется на следующем

package/assets/defaults/project.sh

@@ -43,9 +43,17 @@ RT_HOOKS_TESTS="${RT_HOOKS_TESTS:-.claude/hooks/tests/run.sh}"
 # Заведённая проверка встаёт сюда, а не только в общий прогон, который никто не зовёт сам:
 # новая строка в её списке известного уезжает в главную ветку молча, а список при этом читается
 # как действующая охрана.
+#
+# Сверка раскладки идёт первой строкой и по двум причинам. Она стоит секунды, поэтому отбивает
+# раньше, чем начнётся долгий прогон. И до неё расхождение разложенного с пакетом не отбивало
+# ничего: правка, положенная в разложенную копию мимо источника, ничего не ломает в день, когда
+# её делают, а всплывает на чужой работе — раскладка отказывает по правленому файлу целиком и не
+# кладёт ни одного другого. Признак — сама настройка раскладки: дерево без неё пакета не ставит,
+# и звать в нём нечего.
 rt_push_checks_default() {
     runner="$(rt_runner)"
     root="${CLAUDE_PROJECT_DIR:-.}"
+    [ -f "$root/.claude/rt-kit.json" ] && printf '%s\n' "$runner agent-kit sync --check"
     if [ -n "$1" ]; then
         printf '%s\n' "$runner nx affected -t lint test build --base=$1"
     else

package/assets/docs/GLOSSARY.md

@@ -13,26 +13,27 @@
 
 ## Слой правил
 
-| Термин                    | Что это                                                                                                                                                     |
-| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Закон                     | Файл в каталоге конституции. Говорит, что должно быть верно, и не знает ни путей, ни имён файлов. Верен для любого приложения этого класса                  |
-| Законы приложения         | Слой законов, верных только для этого приложения: деньги, локали, доступ. Предметность в них законна — она их предмет                                       |
-| Правило                   | Скил с `kind: rule`. Привязывает закон к этому дереву: чем это здесь названо и где лежит                                                                    |
-| Паттерн                   | Скил с `kind: pattern`. Готовый код и порядок действий; стоит при правиле                                                                                   |
-| Компаньон                 | Файл `implementation.md` рядом с правилом: имена и пути этого дерева. Пакет знает приём, но не знает имён — их пишет проект                                 |
-| Спек                      | Описание домена: как он работает. Говорит об установившемся, а не о предстоящем                                                                             |
-| Домен                     | Предмет, у которого свой спек. Выросший домен делится на поддомены, а не на соседние домены                                                                 |
-| Сценарий                  | Наблюдаемое поведение под номером `SC-<ПРЕФИКС>-<НОМЕР>`. Номер стоит в заголовке теста                                                                     |
-| Привязка                  | Строка `` `файл:символ` `` в компаньоне или в спутнике спека — место, где утверждение исполняется                                                           |
-| Спутник                   | Файл рядом со спеком или правилом: компаньон, перечень сценариев                                                                                            |
-| Договорённость о продукте | Как продукт себя поведёт, записанное до кода. Единственное место, где спек говорит о будущем; после выкатки вливается в спек домена, а директория удаляется |
-| Ресурс                    | Единица того, что везёт пакет правил: закон, правило, паттерн, гард, проверка, роль, команда, конвейер, шаблон, умолчание, документ                         |
-| Раскладка                 | Перенос ресурса из пакета в дерево по его роду и настройке слоя                                                                                             |
-| Разложенный файл          | Файл в дереве с шапкой пакета. Правится не на месте, а надстройкой: правка на месте теряется на следующей раскладке                                         |
-| Надстройка                | Файл дерева, который сливается с разложенным по заголовкам разделов                                                                                         |
-| Наблюдение                | Строка о событии слоя правил: правило загружено, гейт отбил, гард отказал. Пишет гард, живёт в дереве, наружу уезжает счётчиками. Журналом не называется    |
-| Сводка                    | Что наблюдения говорят за отрезок дней: чем пользовались, чем ни разу, обо что спотыкались                                                                  |
-| Предложение               | Готовая формулировка правки правил с адресом: пакет, компаньон или дерево. Приносит разбор закрытой задачи, отправляет человек командой                     |
+| Термин                    | Что это                                                                                                                                                          |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Закон                     | Файл в каталоге конституции. Говорит, что должно быть верно, и не знает ни путей, ни имён файлов. Верен для любого приложения этого класса                       |
+| Законы приложения         | Слой законов, верных только для этого приложения: деньги, локали, доступ. Предметность в них законна — она их предмет                                            |
+| Правило                   | Скил с `kind: rule`. Привязывает закон к этому дереву: чем это здесь названо и где лежит                                                                         |
+| Паттерн                   | Скил с `kind: pattern`. Готовый код и порядок действий; стоит при правиле                                                                                        |
+| Компаньон                 | Файл `implementation.md` рядом с правилом: имена и пути этого дерева. Пакет знает приём, но не знает имён — их пишет проект                                      |
+| Спек                      | Описание домена: как он работает. Говорит об установившемся, а не о предстоящем                                                                                  |
+| Домен                     | Предмет, у которого свой спек. Выросший домен делится на поддомены, а не на соседние домены                                                                      |
+| Сценарий                  | Наблюдаемое поведение под номером `SC-<ПРЕФИКС>-<НОМЕР>`. Номер стоит в заголовке теста                                                                          |
+| Привязка                  | Строка `` `файл:символ` `` в компаньоне или в спутнике спека — место, где утверждение исполняется                                                                |
+| Спутник                   | Файл рядом со спеком или правилом: компаньон, перечень сценариев                                                                                                 |
+| Договорённость о продукте | Как продукт себя поведёт, записанное до кода. Единственное место, где спек говорит о будущем; после выкатки вливается в спек домена, а директория удаляется      |
+| Ресурс                    | Единица того, что везёт пакет правил: закон, правило, паттерн, гард, проверка, роль, команда, конвейер, шаблон, умолчание, документ                              |
+| Раскладка                 | Перенос ресурса из пакета в дерево по его роду и настройке слоя                                                                                                  |
+| Разложенный файл          | Файл в дереве с шапкой пакета. Правится не на месте, а надстройкой: правка на месте теряется на следующей раскладке                                              |
+| Надстройка                | Файл дерева, который сливается с разложенным по заголовкам разделов                                                                                              |
+| Наблюдение                | Строка о событии слоя правил: правило загружено, гейт отбил, гард отказал. Пишет гард, живёт в дереве, наружу уезжает счётчиками. Журналом не называется         |
+| Сводка                    | Что наблюдения говорят за отрезок дней: чем пользовались, чем ни разу, обо что спотыкались                                                                       |
+| Предложение               | Готовая формулировка правки правил с адресом: пакет, компаньон или дерево. Приносит разбор закрытой задачи или слово посреди работы, отправляет человек командой |
+| Слово                     | Реплика человека посреди работы о слое правил: что мешает, чего не хватило, что сработало не так. Ложится блоком в файл предложений, а не живёт до конца захода  |
 
 ## Работа
 

package/assets/hooks/git-guard-push-tests.sh

@@ -36,10 +36,14 @@ case "$tool" in
 esac
 
 cmd="$(printf '%s' "$input" | jq -r '.tool_input.command // empty' 2>/dev/null)"
-case "$cmd" in
-    *git\ push*) ;;
-    *) exit 0 ;;
-esac
+
+# Вызов пуша узнаётся по двум признакам сразу — команда `git` в начале строки или за
+# разделителем и слово `push` отдельным словом. Тем же приёмом, что у гарда поставки: одной
+# подстрокой «git push» пуш не поймать — помощник учётных данных и заголовок запроса ставятся
+# ключами `-c` между ними, и ровно этой формой здесь и пушат. Пока признаком была подстрока,
+# весь набор гейта на таком пуше не гонялся вовсе, а молчание гарда читалось как «зелено».
+printf '%s' "$cmd" | grep -qE '(^|[;&|(]|&&|\|\|)[[:space:]]*git([[:space:]]|$)' || exit 0
+printf '%s' "$cmd" | grep -qE '(^|[[:space:]])push([[:space:]]|$)' || exit 0
 
 # Пробный пуш ничего не отправляет: гонять ради него весь набор незачем.
 case "$cmd" in