@rt-tools/agent-kit 0.16.0 → 0.17.0

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

@@ -0,0 +1,88 @@
+// Пути, которых не слушает конвейер, и заявка, чей вклад целиком под ними.
+//
+// Вынесено из сверки очереди отдельным модулем: разбор образцов конвейера к состоянию борды
+// отношения не имеет и читается сам по себе, а сверка от него росла быстрее предела длины.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { ghJson } from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
+const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
+
+/**
+ * Пути, которых конвейер не слушает: `paths-ignore` у его событий.
+ *
+ * Разбирается построчно, а не разборщиком разметки: у проверки его нет, а список — плоский
+ * перечень строк под одним ключом. Ключей в файле бывает несколько — по событию, — и все они
+ * складываются в один набор: ветка, чей вклад целиком лежит под ними, прогона не создаёт ни на
+ * одном событии.
+ */
+export function ignoredPaths() {
+    if (!HAS_PIPELINE) {
+        return [];
+    }
+
+    const lines = readFileSync(join(ROOT, PIPELINE), 'utf8').split('\n');
+    const found = [];
+    let inside = false;
+
+    for (const line of lines) {
+        if (/^\s*paths-ignore:\s*$/.test(line)) {
+            inside = true;
+            continue;
+        }
+        if (!inside) {
+            continue;
+        }
+        const item = /^\s*-\s+['"]?([^'"\s]+)['"]?\s*$/.exec(line);
+        if (item) {
+            found.push(item[1]);
+            continue;
+        }
+        inside = false;
+    }
+
+    return found;
+}
+
+const IGNORED_PATHS = ignoredPaths();
+
+/** Знаки образца, у которых в выражении своё значение: кроме звёздочек, они значат себя. */
+const escapeForRegExp = (value) => value.replace(/[.+?^${}()|[\]\\-]/g, '\\$&');
+
+/** Подпадает ли путь под образец конвейера: `**` — любой хвост, `*` — кусок имени. */
+function underPattern(path, pattern) {
+    const body = pattern
+        .split('**')
+        .map((piece) => piece.split('*').map(escapeForRegExp).join('[^/]*'))
+        .join('.*');
+
+    return new RegExp(`^${body}$`).test(path);
+}
+
+/**
+ * Вклад заявки целиком лежит под путями, которых конвейер не слушает.
+ *
+ * Такой ветке прогона не будет никогда, и требовать его — то же, что требовать его у ветки без
+ * единого коммита: признак верен по букве и лжёт по существу, а действие, которое он советует,
+ * не исполнимо. Красная строка при этом стоит рядом с настоящими расхождениями и учит
+ * пропускать сверку целиком.
+ *
+ * Состав не прочитать — отвечаем «нет»: молчать наугад дороже одной лишней строки.
+ */
+export function onlyIgnoredPaths(pull, options) {
+    if (!IGNORED_PATHS.length) {
+        return false;
+    }
+
+    let files = [];
+    try {
+        files = ghJson(['pr', 'view', String(pull.number), '--json', 'files'], options).files ?? [];
+    } catch {
+        return false;
+    }
+
+    return files.length > 0 && files.every((file) => IGNORED_PATHS.some((pattern) => underPattern(file.path, pattern)));
+}

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

@@ -10,7 +10,15 @@
  * Нет сети или нет токена — вызовы бросают `OfflineError`, как и остальная работа с хостингом:
  * невозможность спросить расхождением не считается.
  */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
 import { OWNER, REPO, gh } from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+/** Файл конвейера этого дерева; его нет — путей он не слушает вовсе. */
+const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
+export const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
 
 /**
  * Сколько прогонов завелось на этой вершине.

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

@@ -0,0 +1,66 @@
+/**
+ * Открытые задачи, чьи заголовки сильно совпали.
+ *
+ * Отдельным файлом, а не внутри сверки очереди: у очереди свой предмет — задачи, колонки и
+ * заявки, — а здесь сравнивают слова заголовков между собой. Вместе они переросли предел длины
+ * файла, и делить их по предмету дешевле, чем по числу строк.
+ */
+
+function titleWords(title) {
+    return [
+        ...new Set(
+            String(title)
+                .replace(/^\s*\[[^\]]+\]\s*/, '')
+                .toLowerCase()
+                .split(/[^\p{L}\p{N}]+/u)
+                .filter((word) => word.length > 3)
+        ),
+    ];
+}
+
+/** Доля общих слов, начиная с которой две задачи стоит посмотреть глазами. */
+const TITLE_OVERLAP = 0.6;
+/** Меньше трёх общих слов совпадением не считается: два длинных слова совпадают у любой пары. */
+const TITLE_COMMON_MIN = 3;
+/** Больше скольких задач в группе — это серия эпика, а не дубль. */
+const TITLE_GROUP_MAX = 4;
+
+/**
+ * Открытые задачи, чьи заголовки сильно совпали.
+ *
+ * Печатается строкой сводки, а не отказом: серия однотипных задач эпика — законное состояние
+ * очереди, и отказ отбивал бы работу на каждой такой серии. Дубль же по отдельности исправен —
+ * у обеих задач номер, исполнитель и колонка, — и не находит его ничто: разошлись они словами
+ * заголовка, а совпадают дефектом и признаком закрытия.
+ */
+export function similarTitles(open) {
+    const words = new Map(open.map((issue) => [issue.number, titleWords(issue.title)]));
+    // Задачи сводятся в группы, а не в пары: серия однотипных задач эпика — законное состояние
+    // очереди, и парами она даёт по строке на каждое сочетание, то есть заглушает сама себя.
+    const groups = [];
+
+    for (const issue of open) {
+        const mine = words.get(issue.number);
+        const near = groups.find((group) =>
+            group.some((other) => {
+                const theirs = words.get(other.number);
+                const common = mine.filter((word) => theirs.includes(word)).length;
+                const smaller = Math.min(mine.length, theirs.length);
+
+                return smaller > 0 && common >= TITLE_COMMON_MIN && common / smaller >= TITLE_OVERLAP;
+            })
+        );
+        if (near) {
+            near.push(issue);
+            continue;
+        }
+        groups.push([issue]);
+    }
+
+    // Группа больше предела — это серия однотипных задач, а не дубль: у эпика их бывает
+    // полтора десятка, и строка о них говорит только то, что эпик существует.
+    for (const group of groups.filter((one) => one.length > 1 && one.length <= TITLE_GROUP_MAX)) {
+        const numbers = group.map((issue) => `#${issue.number}`).join(', ');
+        console.log(`check-board: ${numbers} — заголовки сильно совпадают, посмотри, не одна ли это работа: ` + `«${group[0].title}»`);
+    }
+}

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

@@ -28,7 +28,7 @@
  *
  * Ненулевой код возврата и перечень расхождений.
  */
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 
 import {
@@ -43,11 +43,14 @@ import {
     fetchIssues,
     fetchOpenPulls,
     gh,
+    ghJson,
     numberFromTaskDir,
     numberFromTitle,
     taskDirs,
 } from './board.mjs';
-import { deployLag, evictedOnHead, headCommittedAt, runsOnHead, verdictOnHead } from './board-runs.mjs';
+import { onlyIgnoredPaths } from './board-paths.mjs';
+import { HAS_PIPELINE, deployLag, evictedOnHead, headCommittedAt, runsOnHead, verdictOnHead } from './board-runs.mjs';
+import { similarTitles } from './board-titles.mjs';
 import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
 const IN_REVIEW = STATUS_OPTIONS[IN_REVIEW_STATUS].name;
@@ -63,8 +66,6 @@ const RUN_GRACE_MINUTES = 10;
  * Конвейер дерева. Прогоны спрашиваются только там, где ему есть откуда взяться: дерево без
  * конвейера получило бы строку на каждый открытый PR, и не о чём.
  */
-const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
-const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
 /**
  * Рабочий поток выкатки и ветка, с которой прод сравнивают. Не назвав потока, дерево сверки
  * прода не получает — и сверка говорит об этом вслух: молчание читалось бы как «прод сошёлся».
@@ -94,6 +95,12 @@ function checkDrafts() {
     }
 }
 
+/**
+ * Значимые слова заголовка: ключ задачи и короткие служебные слова выброшены.
+ *
+ * Разбор нарочно грубый — совпадение слов здесь не приговор, а повод посмотреть: точное
+ * сравнение заголовков не находит ничего, потому что дубль пишут другими словами.
+ */
 function closesNumbers(body) {
     return [...String(body ?? '').matchAll(/\bCloses\s+#(\d+)\b/gi)].map((match) => Number(match[1]));
 }
@@ -160,6 +167,10 @@ function checkHeadRun(pull, options) {
         return;
     }
 
+    if (onlyIgnoredPaths(pull, options)) {
+        return;
+    }
+
     if (pull.mergeable === 'CONFLICTING') {
         report(
             `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет и не будет, пока она конфликтует — ` +
@@ -286,6 +297,8 @@ try {
         }
     }
 
+    similarTitles(open);
+
     const openNumbers = new Set(open.map((issue) => issue.number));
     const claimed = new Map();
     for (const pull of pulls) {

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

@@ -62,11 +62,19 @@ const JUDGED = ['.md', '.scss', '.html', '.js', '.mjs', '.sh'];
 /** Описание прошлого, папка задачи и то, что переписывает генератор. */
 const SKIPPED_PREFIXES = [CONFIG.archiveDir, `${CONFIG.tasksDir}/`, ...CONFIG.generatedDirs];
 
-/** Дерево спрашивается у системы контроля версий: иначе каталоги с точки не видны, а сборка видна. */
+/**
+ * Дерево спрашивается у системы контроля версий: иначе каталоги с точки не видны, а сборка видна.
+ *
+ * Снятое из рабочего дерева отсеивается здесь, а не в счётчиках: система контроля версий помнит
+ * файл, пока снос не заведён в историю, а прочитать его нечем — проверка падала трассировкой
+ * `ENOENT` и читалась как сломанная, хотя сломан был только незаведённый снос. Счётчиков два, и
+ * охрана при каждом разошлась бы.
+ */
 function trackedFiles() {
     return execFileSync('git', ['ls-files'], { cwd: ROOT, encoding: 'utf8', maxBuffer: 1024 * 1024 * 32 })
         .split('\n')
-        .filter(Boolean);
+        .filter(Boolean)
+        .filter((path) => existsSync(join(ROOT, path)));
 }
 
 function judged(path) {

package/assets/checks/check-glossary.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Слова, которых здесь не пишут: раздел «Так не пишем» словаря против дерева.
+ *
+ * Раздел лежал без единой проверки, и ровно поэтому расхождение росло годами: словарь звал
+ * службу одним словом, дерево — другим, и обе стороны выглядели действующими. Правило прямо
+ * велит брать слово из словаря или заводить его там же, а не краснело ничто — сверка адресов
+ * читает пути, сверка спеков читает сценарии, а словарь не читает никто.
+ *
+ * Проверка едет пакетом, а не пишется деревом: раздел «Так не пишем» везёт он же, и дерево,
+ * которое словарь получило, а проверки на него нет, живёт ровно с той дырой, ради которой она
+ * заведена. Слова при этом принадлежат словарю: пакет их не перечисляет, а читает из раздела.
+ * Общее для проверок — разбор списка известного и список пропускаемых каталогов — приезжает
+ * модулем настройки проверок, а не пишется здесь заново.
+ *
+ * Ищется левая колонка пар «слева запретное — справа принятое», и не вся: слово со скобочным
+ * уточнением («приём (о службе)») поиском не судится вовсе. Уточнение и означает, что запрещено
+ * одно значение из двух, а различить их в строке машине нечем: «операция приёма» законна, а
+ * «приём принимает груз» — нет, и обе строки для поиска одинаковы. Такое слово остаётся
+ * требованием к читателю; проверка о нём говорит вслух, чтобы молчание не читалось как охват.
+ *
+ * Сам словарь из поиска выведен: в нём запретное слово стоит по делу — тем и живёт левая
+ * колонка. Выведено и описание прошлого: оно по устройству называет то, чего в дереве уже нет.
+ *
+ * Ненулевой код возврата и перечень мест; накопленное к дню заведения проверки перечислено
+ * поимённо, с причиной и номером задачи.
+ */
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+
+import { CONFIG, ROOT, baselineOf, parseAllowlist } from './rt-kit-checks.config.mjs';
+
+const GLOSSARY = 'docs/GLOSSARY.md';
+const SECTION = '## Так не пишем';
+/** Пара словаря: `- **слева** — справа`. Слева бывает несколько слов через запятую. */
+const PAIR = /^-\s+\*\*(.+?)\*\*\s+—/;
+/** Скобочное уточнение при слове: запрещено одно значение из двух, и поиском их не развести. */
+const HINT = /\([^)]*\)\s*$/;
+
+/**
+ * Что проверка не читает.
+ *
+ * Всякий словарь — здешний, его надстройка и источник в пакете — выведен по делу: левая колонка
+ * тем и живёт, что называет запретное слово вслух. Описание прошлого и папки задач выведены по
+ * устройству: первое перечисляет то, чего в дереве уже нет, вторая умирает со слиянием.
+ */
+const UNREAD = ['docs/archive/', 'docs/tasks/', 'CHANGELOG'];
+const GLOSSARY_NAME = /(^|\/)GLOSSARY\.md$/;
+
+/** Левая колонка раздела «Так не пишем»: слова, которых в дереве быть не должно. */
+function forbiddenWords(text) {
+    const lines = text.split('\n');
+    const from = lines.findIndex((line) => line.trim() === SECTION);
+    if (from < 0) {
+        return { words: [], byReader: [] };
+    }
+
+    const words = [];
+    const byReader = [];
+    for (const line of lines.slice(from + 1)) {
+        if (line.startsWith('## ')) {
+            break;
+        }
+        const found = PAIR.exec(line);
+        if (!found) {
+            continue;
+        }
+        for (const part of found[1].split(',')) {
+            const word = part.trim();
+            if (!word) {
+                continue;
+            }
+            if (HINT.test(word)) {
+                byReader.push(word);
+                continue;
+            }
+            words.push(word);
+        }
+    }
+
+    return { words, byReader };
+}
+
+/** Файлы дерева, которые проверка читает. Список берётся у системы контроля версий. */
+function readableFiles() {
+    const listed = spawnSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+        cwd: ROOT,
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    if (listed.status !== 0) {
+        return [];
+    }
+
+    const skip = CONFIG.skipDirs ?? [];
+
+    return listed.stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((file) => file.endsWith('.md'))
+        .filter((file) => !GLOSSARY_NAME.test(file))
+        .filter((file) => !UNREAD.some((where) => file === where || file.startsWith(where) || file.includes(`/${where}`)))
+        .filter((file) => !skip.some((where) => file.includes(`/${where}/`) || file.startsWith(`${where}/`)));
+}
+
+function main() {
+    let glossary;
+    try {
+        glossary = readFileSync(join(ROOT, GLOSSARY), 'utf8');
+    } catch {
+        console.log(`check-glossary: словаря нет по адресу ${GLOSSARY} — сверять нечем`);
+
+        return Number(process.env.RT_SKIP_CODE ?? 7);
+    }
+
+    const { words, byReader } = forbiddenWords(glossary);
+    if (!words.length && !byReader.length) {
+        console.log('check-glossary: раздела запретных слов в словаре нет — сверять нечем');
+
+        return Number(process.env.RT_SKIP_CODE ?? 7);
+    }
+
+    const parsed = parseAllowlist('glossary');
+    const found = [];
+    for (const file of readableFiles()) {
+        let text;
+        try {
+            text = readFileSync(join(ROOT, file), 'utf8');
+        } catch {
+            continue;
+        }
+        for (const [index, line] of text.split('\n').entries()) {
+            for (const word of words) {
+                if (!new RegExp(`(^|[^\\p{L}])${word}([^\\p{L}]|$)`, 'iu').test(line)) {
+                    continue;
+                }
+                found.push({ key: `${file}:${word}`, file, line: index + 1, word });
+            }
+        }
+    }
+
+    const fresh = baselineOf(
+        found.map((one) => one.key),
+        parsed,
+    );
+    const news = found.filter((one) => fresh.includes(one.key));
+
+    if (news.length) {
+        console.error(`check-glossary: расхождений ${news.length}`);
+        for (const one of news) {
+            console.error(`  ${one.file}:${one.line} — «${one.word}»: слово стоит в разделе «Так не пишем» словаря`);
+        }
+        console.error('  либо слово меняется на принятое здесь, либо словарь перестаёт его запрещать');
+
+        return 1;
+    }
+
+    console.log(`check-glossary: запретных слов ${words.length}, читано документов ${readableFiles().length}, расхождений нет`);
+    if (byReader.length) {
+        // Молчание о невыполнимом поиске читалось бы как охват: эти слова не судит ничто.
+        console.log(`  поиском не судятся, остаются требованием к читателю: ${byReader.join(', ')}`);
+    }
+
+    return 0;
+}
+
+process.exit(main());

package/assets/checks/check-push-gate.mjs

@@ -18,7 +18,9 @@
  * `rt_push_checks` профиля; она сверяется с его выводом, потому что объявление
  * без исполнения — та же дыра. Исключение — причина, по которой шага в гейте
  * нет; пустая причина исключением не считается: она единственное, чем
- * постоянная дыра отличается от забытой строки.
+ * постоянная дыра отличается от забытой строки. Причина, называющая задачу,
+ * судится ещё и на живость этой задачи: отсрочка со сроком и отсрочка без срока
+ * выглядят одинаково, пока номер никто не спросил.
  *
  * Дерево без файла конвейера сверки не получает: проверка, падающая там, где
  * конвейера нет, отбивала бы работу вместо промаха.
@@ -34,6 +36,8 @@ import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 const GATE = CONFIG.pushGate ?? {};
 const PIPELINE = GATE.pipelineFile ?? '';
 const DECLARED = GATE.steps ?? {};
+/** Ключ задач дерева: по нему номер в причине отличается от версии, порта и года. */
+const TASK_KEY = CONFIG.board?.taskKey ?? '';
 
 /**
  * Профиль дерева ищется той же цепочкой, что и у гарда пуша: умолчание пакета, поверх него
@@ -85,9 +89,39 @@ rt_push_checks ""`;
     }
 }
 
+/**
+ * Номера задач, названные причиной. Ключ дерева обязателен: без него «663» неотличимо от порта,
+ * года и номера редакции, и проверка спрашивала бы очередь работ обо всём подряд.
+ */
+function taskNumbers(reason) {
+    if (!TASK_KEY) {
+        return [];
+    }
+    return [...reason.matchAll(new RegExp(`\\b${TASK_KEY}-(\\d+)\\b`, 'g'))].map((match) => Number(match[1]));
+}
+
+/**
+ * Очередь работ ищется разрешением модуля, а не собирается здесь: у каждого хостинга она своя, и
+ * дерево, у которого её нет, судится как прежде. Ярус тот же, что у гарда поставки: есть чем
+ * спросить — спрашивает, нет — молчит.
+ */
+async function boardModule() {
+    if (!TASK_KEY) {
+        return null;
+    }
+    try {
+        const module = await import('./board.mjs');
+        return typeof module.taskState === 'function' ? module : null;
+    } catch {
+        return null;
+    }
+}
+
 const steps = pipelineSteps();
 const checks = gateChecks();
 const problems = [];
+/** Задачи, названные причинами исключений: спрашиваются пачкой после разбора всех шагов. */
+const deferrals = [];
 
 for (const step of steps) {
     const declaration = DECLARED[step];
@@ -103,6 +137,10 @@ for (const step of steps) {
         const reason = String(declaration.skip ?? '').trim();
         if (!reason) {
             problems.push(`шаг конвейера «${step}» объявлен исключением без причины — пустая причина не считается`);
+            continue;
+        }
+        for (const number of taskNumbers(reason)) {
+            deferrals.push({ step, number });
         }
         continue;
     }
@@ -126,6 +164,26 @@ for (const step of Object.keys(DECLARED)) {
     }
 }
 
+/**
+ * Мёртвый номер в причине делает исключение бессрочным, не сказав об этом ни строкой. Первый же
+ * отказ сети кончает опрос целиком: спрашивать остальные незачем, а падать проверке, которую
+ * гоняют в самолёте, — тем более.
+ */
+const board = deferrals.length > 0 ? await boardModule() : null;
+if (board) {
+    for (const { step, number } of deferrals) {
+        let state;
+        try {
+            state = board.taskState(number);
+        } catch {
+            break;
+        }
+        if (state && state.exists === false) {
+            problems.push(`шаг конвейера «${step}» отложен до задачи ${TASK_KEY}-${number}, а такой задачи в очереди работ нет — отсрочка бессрочная`);
+        }
+    }
+}
+
 if (problems.length > 0) {
     console.error(`check-push-gate: расхождений ${problems.length}\n`);
     problems.forEach((problem) => console.error(`  ${problem}`));

package/assets/checks/check-schema-drift.mjs

@@ -76,6 +76,13 @@ function shadowAddresses(url) {
     return { shadowName, shadowUrl: shadow.toString(), serviceUrl: service.toString() };
 }
 
+// Код, которым проверка объявляет, что смотреть было не на что. Прежде каждый такой выход был
+// нулём: строка о пропуске уходила в вывод, а в сводке гейта пуша ноль стоял рядом с
+// пройденными проверками и ничем от них не отличался — набор читался как проверенный целиком.
+// Число знает и гард пуша: он называет пропущенное вслух, не отбивая пуш, потому что проверка,
+// которой нечего смотреть, поломкой не является.
+const SKIP = Number(process.env.RT_SKIP_CODE ?? 7);
+
 function prisma(args, url) {
     return spawnSync('npx', ['prisma', ...args], {
         cwd: ROOT,
@@ -98,7 +105,7 @@ async function withServiceClient(serviceUrl, run) {
         if (SERVER_DOWN_CODES.includes(error?.code)) {
             console.log('check-schema-drift: база недоступна — сверять негде');
 
-            return 0;
+            return SKIP;
         }
         throw error;
     }
@@ -117,26 +124,26 @@ async function main() {
     if (!CONFIG.schemaFile) {
         console.log('check-schema-drift: имя файла схемы не задано — сверять нечего');
 
-        return 0;
+        return SKIP;
     }
 
     if (!existsSync(join(ROOT, CONFIG.schemaFile))) {
         console.log('check-schema-drift: схемы нет — сверять нечего');
 
-        return 0;
+        return SKIP;
     }
 
     const url = databaseUrl();
     if (!url) {
         console.log('check-schema-drift: адрес базы не задан — сверять негде');
 
-        return 0;
+        return SKIP;
     }
 
     if (PRODUCTION_MARKS.some((mark) => url.includes(mark))) {
         console.log('check-schema-drift: адрес боевой — проверка туда не ходит');
 
-        return 0;
+        return SKIP;
     }
 
     const { shadowName, shadowUrl, serviceUrl } = shadowAddresses(url);

package/assets/checks/spec-contract.mjs

@@ -64,6 +64,15 @@ function contractRows(text) {
             continue;
         }
         const permission = (cells[1].match(/`([^`]+)`/) || [])[1] || cells[1];
+        // Строка с кодом отказа во второй ячейке процедурой не считается. Раздел «Контракта»
+        // держит две разные таблицы: список процедур с правами и список кодов отказа с поводами,
+        // — и по форме строки они неотличимы, обе несут значение в кавычках первой ячейкой.
+        // Пока разбор брал любую, спек с объявленными процедурами получал свою таблицу кодов
+        // прочитанной как список процедур: каждая её строка становилась процедурой, которой в
+        // домене нет.
+        if (/^\d{3}$/.test(permission.trim())) {
+            continue;
+        }
         rows.push({ line: index, name, permission: permission.trim(), short: name.split('.').pop() });
     }
 

package/assets/defaults/gate-map.sh

@@ -40,6 +40,12 @@ skill_for_default() {
     case "$kind" in
         edit)
             case "$target" in
+                # Собранное дерево кодом не бывает, и правкой его никто не занимается: путь к
+                # артефакту приходит из команды, которая его ЗАПУСКАЕТ. Под артефактом лежат те
+                # же имена каталогов, что и под исходником, поэтому ветка стоит первой — любая
+                # ниже совпала бы с ним и потребовала правило, которое работе ничего не даёт.
+                */node_modules/* | */dist/* | */build/* | */.nx/* | */coverage/*) return 0 ;;
+
                 # Надстройка над разложенным текстом — правка того же текста: путь другой, а
                 # предмет тот же. Ветка стоит первой, потому что путь надстройки кончается тем
                 # же именем файла, что и разложенная копия, и ветки ниже разобрали бы её по
@@ -93,10 +99,13 @@ skill_for_default() {
                 # Своё правило линтера кода пишется по тем же соглашениям, что и код под ним.
                 */eslint-rules/*) printf '%s\n' 'typescript-conventions' ;;
 
-                # Схема хранилища и её миграции: порядок каталогов лексикографический, а метку
-                # времени ставит инструмент в момент заведения — цепочка ломается молча и падает
-                # только накатом с нуля, то есть уже после слияния. Правило живёт при поставке.
-                */schema.prisma | */prisma/migrations/*) printf '%s\n' 'git-workflow' ;;
+                # Схема хранилища, её миграции и настройка клиента: порядок каталогов
+                # лексикографический, а метку времени ставит инструмент в момент заведения —
+                # цепочка ломается молча и падает только накатом с нуля, то есть уже после
+                # слияния. Настройка клиента стоит здесь же: её читает тот же накат, а правилась
+                # она без правила под рукой. Правило живёт при поставке.
+                */schema.prisma | */prisma/migrations/* | */prisma.config.ts)
+                    printf '%s\n' 'git-workflow' ;;
                 # Конвейер и образ: проверки решают, что вообще гоняется до слияния, а образ —
                 # что приезжает на прод. И то и другое правилось без единого правила поставки.
                 */.github/workflows/*.yml | */.gitlab-ci.yml | */azure-pipelines*.yml)