@rt-tools/agent-kit 0.16.1 → 0.18.0

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 {
@@ -42,12 +42,17 @@ import {
     fetchBoard,
     fetchIssues,
     fetchOpenPulls,
+    behindMain,
     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 { checkEpicLinks } from './board-epics.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,12 +68,22 @@ const RUN_GRACE_MINUTES = 10;
  * Конвейер дерева. Прогоны спрашиваются только там, где ему есть откуда взяться: дерево без
  * конвейера получило бы строку на каждый открытый PR, и не о чём.
  */
-const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
-const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
 /**
  * Рабочий поток выкатки и ветка, с которой прод сравнивают. Не назвав потока, дерево сверки
  * прода не получает — и сверка говорит об этом вслух: молчание читалось бы как «прод сошёлся».
  */
+/**
+ * Метки, которыми в очереди работ помечен груз — присланные деревьями разборы происшествий и
+ * предложения. Задачами они не являются: заголовок у них без номера, исполнителя нет, на борде
+ * их нет, — и сверка печатала на каждую по три строки, среди которых настоящее расхождение уже
+ * не читалось. Заводить такие записи в очередь перестали, а заведённые прежним порядком оттуда
+ * никуда не денутся: закрывать их — решение владельца, а не сверки.
+ *
+ * Имя метки называет дерево: у каждого оно своё, а выдуманное умолчание не совпало бы ни с чем
+ * и молча выключило бы отсев. Дерево, метки не назвавшее, судится как прежде.
+ */
+const CARGO_LABELS = new Set(CONFIG.board?.cargoLabels ?? []);
+
 const DEPLOY_WORKFLOW = CONFIG.deploy?.workflow ?? '';
 const MAIN_BRANCH = CONFIG.deploy?.mainBranch ?? 'main';
 
@@ -94,6 +109,12 @@ function checkDrafts() {
     }
 }
 
+/**
+ * Значимые слова заголовка: ключ задачи и короткие служебные слова выброшены.
+ *
+ * Разбор нарочно грубый — совпадение слов здесь не приговор, а повод посмотреть: точное
+ * сравнение заголовков не находит ничего, потому что дубль пишут другими словами.
+ */
 function closesNumbers(body) {
     return [...String(body ?? '').matchAll(/\bCloses\s+#(\d+)\b/gi)].map((match) => Number(match[1]));
 }
@@ -160,6 +181,10 @@ function checkHeadRun(pull, options) {
         return;
     }
 
+    if (onlyIgnoredPaths(pull, options)) {
+        return;
+    }
+
     if (pull.mergeable === 'CONFLICTING') {
         report(
             `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет и не будет, пока она конфликтует — ` +
@@ -254,7 +279,7 @@ function checkConflicting(pull) {
     );
 }
 
-let checked = { issues: 0, pulls: 0 };
+let checked = { issues: 0, pulls: 0, cargo: 0 };
 
 // Черновики судятся по диску и потому проверяются всегда: связи для этого не нужно.
 checkDrafts();
@@ -264,9 +289,13 @@ try {
     const options = { token: botToken() ?? undefined };
     const board = fetchBoard(options);
     const issues = fetchIssues('all', options);
-    const open = issues.filter((issue) => issue.state === 'OPEN');
+    const allOpen = issues.filter((issue) => issue.state === 'OPEN');
+    // Отсев идёт один раз и до всех проверок задачи: помеченная запись не задача целиком, а не
+    // наполовину, — её не судят ни заголовком, ни исполнителем, ни бордой, ни сводкой совпавших
+    // заголовков, ни связью с эпиком.
+    const open = CARGO_LABELS.size === 0 ? allOpen : allOpen.filter((issue) => !(issue.labels ?? []).some((label) => CARGO_LABELS.has(label.name)));
     const pulls = fetchOpenPulls(options);
-    checked = { issues: issues.length, pulls: pulls.length };
+    checked = { issues: issues.length, pulls: pulls.length, cargo: allOpen.length - open.length };
 
     for (const item of board.foreign) {
         report(`борда: ${item} — на борде стоят задачи, а не PR о них`);
@@ -286,6 +315,9 @@ try {
         }
     }
 
+    similarTitles(open);
+    checkEpicLinks(open, report);
+
     const openNumbers = new Set(open.map((issue) => issue.number));
     const claimed = new Map();
     for (const pull of pulls) {
@@ -317,6 +349,17 @@ try {
 
         checkConflicting(pull);
 
+        // Отставание заявки от главной ветки: гард судит основание один раз, в минуту открытия,
+        // а заявка стоит днями. Влитая с отставанием, она везёт в главную сочетание, которого не
+        // проверял никто, — и по странице заявки этого не видно: прогон на ней зелёный.
+        const behind = behindMain(pull.headRefName, MAIN_BRANCH, options);
+        if (behind > 0) {
+            report(
+                `PR #${pull.number}: ветка отстала от «${MAIN_BRANCH}» на ${behind} коммитов — прогон шёл от основания, ` +
+                    `которого в главной ветке уже нет. Влей главную, пересмотри набор проверок по тому, что ветка везёт теперь, и прогони заново`
+            );
+        }
+
         if (!FOLDER_SKIP.test(String(pull.body ?? '')) && pull.headRefName) {
             const folder = folderInBranch(pull.headRefName, options);
             if (folder !== null) {
@@ -394,6 +437,12 @@ if (!offline && !DEPLOY_WORKFLOW) {
     console.log('check-board: прод с главной веткой не сверялся — рабочий поток выкатки в настройке дерева не назван');
 }
 
+// Отсеянное называется числом: молчаливый отсев неотличим от сломанной сверки — метка,
+// названная с опечаткой, выключила бы проверку целиком и не сказала бы об этом.
+if (!offline && checked.cargo > 0) {
+    console.log(`check-board: записей груза в очереди ${checked.cargo} — задачами они не судятся`);
+}
+
 if (!offline && !HAS_PIPELINE) {
     console.log('check-board: прогоны на вершинах не спрашивались — файла конвейера в дереве нет');
 }

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-hook-scope.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Сверка объявления гарда с тем, что разбирает его тело.
+ *
+ * Гард несёт своё событие и образец вызова сам — строкой `# rt-hook:` во второй строке файла; по
+ * ней его подписывают в настройке агента. Тело при этом умеет больше, чем объявлено: разбирает
+ * имя инструмента, которого в образце нет, — и до этой ветки вызов не доходит никогда. Снаружи
+ * гард выглядит работающим: путь назван, файл разложен, набор сценариев зелёный, потому что зовёт
+ * гард напрямую с подставленным вводом и объявления не читает вовсе.
+ *
+ * Хуже того, расхождение читается как промах дерева. Дерево, подписавшее гард шире объявления,
+ * получает отказ сверки раскладки и сужает подписку до объявления — вместе с расхождением снимая
+ * работавшее покрытие. Чинится это в пакете, а платит за него дерево.
+ *
+ * Что сверяется: имена инструментов из веток `case` по имени инструмента против образца
+ * объявления. Комментарии и тексты отказов не читаются: имя инструмента упоминают и там, а
+ * судится то, на что гард ветвится.
+ *
+ * FAIL-OPEN: каталога хуков нет — сверять нечего, нулевой код.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const HOOKS = join(ROOT, '.claude/hooks');
+
+/** Объявление гарда: событие и образец вызова. */
+const DECLARATION = /^#\s*rt-hook:\s*(\S+)(?:[ \t]+(\S.*))?$/m;
+
+/** Ветка `case` по имени инструмента: `Bash | mcp__webstorm__execute_tool)`. */
+const TOOL_CASE = /^[ \t]*([A-Za-z_][\w-]*(?:__[\w-]+)*(?:[ \t]*\|[ \t]*[A-Za-z_][\w-]*(?:__[\w-]+)*)*)\)/;
+
+/** Имена инструментов, на которые ветвится тело гарда. */
+function branchedTools(text) {
+    const lines = text.split('\n');
+    const tools = new Set();
+    let inside = false;
+
+    for (const line of lines) {
+        const code = line.replace(/^([^#]*)#.*$/, '$1');
+
+        if (/case[ \t]+"?\$(\{)?(tool|RT_HOOK_TOOL)/.test(code) || /case[ \t]+"\$\(rt_hook_tool\)"/.test(code)) {
+            inside = true;
+            continue;
+        }
+
+        if (inside && /^[ \t]*esac\b/.test(code)) {
+            inside = false;
+            continue;
+        }
+
+        if (!inside) {
+            continue;
+        }
+
+        const branch = code.match(TOOL_CASE);
+        if (branch) {
+            for (const name of branch[1].split('|')) {
+                const tool = name.trim();
+                // Звёздочка — ветка «всё остальное», именем инструмента она не является.
+                if (tool && tool !== '*') {
+                    tools.add(tool);
+                }
+            }
+        }
+    }
+
+    return [...tools];
+}
+
+/** Покрывает ли образец объявления это имя инструмента. */
+function covers(matcher, tool) {
+    try {
+        return new RegExp(`^(?:${matcher})$`).test(tool);
+    } catch {
+        // Образец, который не разобрать, — своё расхождение, и молчать о нём нельзя: имя
+        // инструмента под ним не совпадёт ни с чем, а выглядит объявление написанным.
+        return false;
+    }
+}
+
+function main() {
+    if (!existsSync(HOOKS)) {
+        console.log('check-hook-scope: каталога хуков в дереве нет — сверять нечего');
+
+        return 0;
+    }
+
+    const faults = [];
+
+    for (const file of readdirSync(HOOKS).filter((one) => one.endsWith('.sh')).sort()) {
+        const text = readFileSync(join(HOOKS, file), 'utf8');
+        const declared = text.match(DECLARATION);
+        if (!declared || !declared[2]) {
+            continue;
+        }
+
+        const matcher = declared[2].trim();
+        for (const tool of branchedTools(text)) {
+            if (!covers(matcher, tool)) {
+                faults.push(`${file}: тело ветвится на «${tool}», а объявление его не называет`);
+            }
+        }
+    }
+
+    if (faults.length > 0) {
+        console.log(`check-hook-scope: расхождений ${faults.length}\n`);
+
+        for (const fault of faults) {
+            console.log(`  ${fault}`);
+        }
+
+        console.log('\nВетка тела, которой нет в объявлении, не исполняется ни разу: под этим именем гард');
+        console.log('не зовут. Объявление правится в источнике пакета, а не в разложенной копии.');
+
+        return 1;
+    }
+
+    console.log('check-hook-scope: объявления гардов покрывают то, на что ветвятся их тела — сошлось');
+
+    return 0;
+}
+
+process.exit(main());

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

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * Сверка надстроек профиля с таблицами компаньонов.
+ *
+ * Правило говорит одно, а дерево работает по-другому — и оба места законны. Расхождение
+ * объявляется переменной профиля, а читатель ищет его в компаньоне правила, где перечислено, чем
+ * здесь зовётся сказанное правилом. Пока эти два места никто не сравнивает, компаньон обещает
+ * пакетное умолчание там, где дерево давно работает по-своему: правило требовало одной формы
+ * заголовка заявки, дерево замещало её переменной, и гард, читавший форму, номера не доставал
+ * вовсе — сверка номера молча не выполнялась, выглядя сошедшейся.
+ *
+ * Что сверяется: имя каждой переменной профиля, чьё значение разошлось с умолчанием пакета,
+ * против текстов компаньонов правил. Значение не сверяется ни с чем: сказать, верно ли оно,
+ * машине нечем, а назвать замещённое в компаньоне — можно.
+ *
+ * FAIL-OPEN: нет профиля, нет умолчаний, нет каталога правил — сверять нечего, нулевой код.
+ * Дерево вправе не держать ни того, ни другого.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const ROOT = process.cwd();
+const PROFILE = join(ROOT, '.claude/rt-kit/project.sh');
+const DEFAULTS = join(ROOT, '.claude/rt-kit/defaults/project.sh');
+const RULES = join(ROOT, '.claude/skills');
+
+/** Присвоение верхнего уровня: `RT_ИМЯ='значение'` либо `RT_ИМЯ="значение"`. */
+const ASSIGN = /^(RT_[A-Z0-9_]+)=(.*)$/;
+
+/** Умолчание пакета: `RT_ИМЯ="${RT_ИМЯ:-значение}"` — значение берётся из подстановки. */
+const FALLBACK = /^RT_[A-Z0-9_]+="\$\{RT_[A-Z0-9_]+:-(.*)\}"$/;
+
+/** Значение без окружающих кавычек: сравниваются строки, а не их запись. */
+function unquote(text) {
+    const trimmed = text.trim();
+    const paired = trimmed.length > 1 && (trimmed.startsWith("'") || trimmed.startsWith('"')) && trimmed.endsWith(trimmed[0]);
+
+    return paired ? trimmed.slice(1, -1) : trimmed;
+}
+
+/** Карта «имя переменной → значение» по присвоениям верхнего уровня. */
+function valuesOf(path) {
+    const values = new Map();
+
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const assign = line.match(ASSIGN);
+        if (!assign) {
+            continue;
+        }
+
+        const fallback = line.match(FALLBACK);
+        values.set(assign[1], fallback ? unquote(fallback[1]) : unquote(assign[2]));
+    }
+
+    return values;
+}
+
+/** Тексты всех компаньонов правил дерева, склеенные в один: ищется в них имя, а не место. */
+function companionsText() {
+    if (!existsSync(RULES)) {
+        return null;
+    }
+
+    const texts = [];
+
+    for (const rule of readdirSync(RULES, { withFileTypes: true })) {
+        if (!rule.isDirectory()) {
+            continue;
+        }
+
+        const companion = join(RULES, rule.name, 'implementation.md');
+        if (existsSync(companion)) {
+            texts.push(readFileSync(companion, 'utf8'));
+        }
+    }
+
+    return texts.length > 0 ? texts.join('\n') : null;
+}
+
+/**
+ * Набор гейта пуша, собранный оболочкой: с надстройкой дерева и без неё.
+ *
+ * Собирается вызовом, а не чтением текста: набор — функция, и она смотрит на дерево — есть ли
+ * настройка раскладки, лежит ли конфиг оформления, исполним ли набор сценариев. Прочитанный
+ * текстом, он назвал бы командами то, чего в этом дереве нет вовсе.
+ *
+ * Пусто — собрать нечем: нет оболочки, нет функции, отказ вызова. Сверять тогда нечего.
+ */
+function gateSet(withProfile) {
+    const source = withProfile ? `. '${DEFAULTS}'; . '${PROFILE}';` : `. '${DEFAULTS}';`;
+    const run = spawnSync('bash', ['-c', `${source} command -v rt_push_checks >/dev/null 2>&1 || exit 9; rt_push_checks ''`], {
+        cwd: ROOT,
+        encoding: 'utf8',
+    });
+
+    return run.status === 0 && typeof run.stdout === 'string' ? run.stdout.split('\n').filter(Boolean) : null;
+}
+
+/**
+ * Проверки, названные в наборе, — по имени файла, а не по всей строке команды.
+ *
+ * Строка целиком сверке не годится: дерево вправе позвать ту же проверку другим запускателем или
+ * с другим доводом, и расхождением это не является. Пропажа самой проверки — является.
+ */
+function checksIn(lines) {
+    const names = new Set();
+
+    for (const line of lines) {
+        for (const [word] of line.matchAll(/[\w./-]+\.(?:mjs|sh)/g)) {
+            names.add(basename(word));
+        }
+    }
+
+    return names;
+}
+
+/**
+ * Проверки, которые умолчание пакета зовёт, а набор дерева — нет.
+ *
+ * Набор гейта собирается умолчанием и надстройкой, и надстройка вправе объявить функцию заново.
+ * Выкушенная так проверка ничем не отличима от проверки, которой в дереве нет вовсе: гейт зелен,
+ * потому что её никто не звал, а сводка раскладки о наборе не знает ничего — она сличает
+ * переменные, а тут заменена функция.
+ *
+ * Отказ в пользу работы: собрать набор нечем — строк нет, и сверка идёт дальше своим делом.
+ */
+function cutFromGate() {
+    const packaged = gateSet(false);
+    const here = gateSet(true);
+    if (packaged === null || here === null) {
+        return [];
+    }
+
+    const mine = checksIn(here);
+
+    return [...checksIn(packaged)].filter((name) => !mine.has(name)).sort((first, second) => first.localeCompare(second, 'ru'));
+}
+
+function main() {
+    if (!existsSync(PROFILE) || !existsSync(DEFAULTS)) {
+        console.log('check-profile-drift: профиля дерева или умолчаний пакета нет — сверять нечего');
+
+        return 0;
+    }
+
+    const companions = companionsText();
+    if (companions === null) {
+        console.log('check-profile-drift: компаньонов правил в дереве нет — сверять не с чем');
+
+        return 0;
+    }
+
+    const cut = cutFromGate();
+    if (cut.length > 0) {
+        console.log(`check-profile-drift: набор гейта пуша не зовёт проверок умолчания: ${cut.length}\n`);
+
+        for (const name of cut) {
+            console.log(`  ${name}`);
+        }
+
+        console.log('\nНабор гейта собирается умолчанием пакета и надстройкой дерева. Проверка, выкушенная');
+        console.log('надстройкой, ничем не отличима от проверки, которой в дереве нет: гейт зелен потому,');
+        console.log('что её никто не звал. Верни её в набор либо объясни отказ в компаньоне правила поставки.');
+
+        return 1;
+    }
+
+    const defaults = valuesOf(DEFAULTS);
+    const profile = valuesOf(PROFILE);
+    const overridden = [...profile].filter(([name, value]) => !defaults.has(name) || defaults.get(name) !== value);
+    const unnamed = overridden.filter(([name]) => !companions.includes(name));
+
+    if (unnamed.length > 0) {
+        console.log(`check-profile-drift: замещено ${overridden.length}, не названо компаньоном ${unnamed.length}\n`);
+
+        for (const [name, value] of unnamed) {
+            console.log(`  ${name} = ${value.length > 60 ? `${value.slice(0, 57)}…` : value}`);
+        }
+
+        console.log('\nЗамещённое читают в компаньоне правила: там перечислено, чем здесь зовётся сказанное');
+        console.log('правилом. Не названное там, оно оставляет читателю пакетное умолчание вместо того, по');
+        console.log('чему дерево работает на самом деле.');
+
+        return 1;
+    }
+
+    console.log(`check-profile-drift: замещено ${overridden.length}, все названы компаньонами — сошлось`);
+
+    return 0;
+}
+
+process.exit(main());