@rt-tools/agent-kit 0.14.0 → 0.16.0

package/README.md

@@ -27,6 +27,7 @@ npx agent-kit sync      # разложить выбранное в docs/constitu
 npx agent-kit doctor    # что разложено, что отстало, чего не хватает
 npx agent-kit adopt     # отдать пакету файлы, лежащие на его путях не от него
 npx agent-kit stats     # чем пользовались, чем ни разу, обо что спотыкались
+npx agent-kit cost      # сколько весит вход в работу, одно правило и весь слой
 ```
 
 `init` называет и то, чего пакет ждёт от дерева: значения дырок, которые придётся вписать в
@@ -274,6 +275,22 @@ npx agent-kit stats --json       # то же машиночитаемо
 Самая ценная строка сводки — не «чем пользовались», а **что разложено и не загружено ни разу**:
 чем пользуются, видно и по работе, а мёртвый ресурс ничем себя не выдаёт.
 
+## Цена контекста
+
+Сводка говорит, чем пользовались; цена — сколько это стоило. Заход платит за слой правил окном,
+и до этой команды вес того, что он получает целиком, не считало ничто.
+
+```bash
+npx agent-kit cost                  # вход в работу, самое тяжёлое правило, весь слой
+npx agent-kit cost --rule <имя>     # взвесить названное правило
+npx agent-kit cost --json           # то же машиночитаемо — этим числа кладут в замысел
+```
+
+Считается не файл, а то, что заход получает: описание правила приходит ему полем, словарь и
+карта хода — выводом хуков. Меряется в символах и байтах — тем, что берётся на месте, без сети.
+Число сравнимо только с числом, снятым той же командой; чем считано, стоит в первой строке
+вывода.
+
 Наблюдения лежат в `.claude/rt-kit/observations/` файлом на день и снимаются через тридцать
 дней. Запись выключается ключом `"observe": false` в конфиге — целиком, а не частями. Каталог
 просится в список игнорируемого; вписывает его проект — в чужие файлы дерева пакет не пишет.

package/assets/checks/archive-age.mjs

@@ -0,0 +1,107 @@
+/**
+ * Возраст записей описания прошлого.
+ *
+ * Каталог набирает по записи на каждую закрытую работу и не отдаёт обратно ничего: папку
+ * задачи разбирает паттерн закрытия работы, и запись оттуда переживает всё дерево. Срок
+ * назначает дерево ключом настройки; пакет умолчания не даёт — установка новой версии не
+ * вправе начать сносить чужой архив, а снимается там разбор просьбы, которого нет больше нигде.
+ *
+ * Отбор живёт здесь один на двоих: команда чистки снимает по нему, проверка по нему же
+ * краснеет. Разойдясь, они говорили бы о каталоге разное, а заметить это нечем — чистка молча
+ * оставляла бы то, на что проверка молча не смотрит.
+ *
+ * Возраст меряется датой последнего коммита файла. Время файла на диске не годится: свежий
+ * чекаут делает все записи одновременными, и чистка на чужой машине не сняла бы ни одной.
+ * Шапка записи не годится тоже — день слияния стоит в ней не всегда и не всюду одинаково.
+ *
+ * Запись, которой в истории ещё нет, считается сегодняшней: она приехала этой же веткой и
+ * перестоять не могла.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { CONFIG } from './rt-kit-checks.config.mjs';
+
+/** Каталог описания прошлого — без завершающей косой черты: её несёт настройка. */
+export const ARCHIVE_DIR = CONFIG.archiveDir.replace(/\/$/, '');
+
+/**
+ * Срок хранения записи в сутках. `null` — срок не назначен, и тогда молчат обе стороны:
+ * проверка не краснеет, чистка не снимает. Дерево называет своё число ключом настройки.
+ */
+export const RETENTION_DAYS = CONFIG.archiveRetentionDays ?? null;
+
+/** Сутки в миллисекундах — считать возраст удобнее в них. */
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Дата последнего коммита у каждой записи каталога.
+ *
+ * Один проход по истории вместо вызова на файл: на трёх сотнях записей это разница между
+ * секундой и полуминутой. Лог идёт новыми вперёд, поэтому первая встреченная дата файла и есть
+ * последняя.
+ */
+function lastCommitDates(root) {
+    const log = execFileSync('git', ['log', '--format=%cI', '--name-only', '--', ARCHIVE_DIR], {
+        cwd: root,
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+    });
+
+    const dates = new Map();
+    let current = null;
+
+    for (const line of log.split('\n')) {
+        if (line === '') {
+            continue;
+        }
+
+        if (line.startsWith(`${ARCHIVE_DIR}/`)) {
+            if (current !== null && !dates.has(line)) {
+                dates.set(line, current);
+            }
+
+            continue;
+        }
+
+        current = line;
+    }
+
+    return dates;
+}
+
+/**
+ * Записи каталога с их возрастом в сутках.
+ *
+ * @param root Корень дерева.
+ * @param now Момент отсчёта — передаётся, чтобы проверка и чистка судили по одному времени.
+ * @returns Записи: путь, дата последнего коммита и возраст в сутках.
+ */
+export function archiveRecords(root, now = new Date()) {
+    if (!existsSync(join(root, ARCHIVE_DIR))) {
+        return [];
+    }
+
+    const dates = lastCommitDates(root);
+
+    return readdirSync(join(root, ARCHIVE_DIR))
+        .filter((name) => name.endsWith('.md'))
+        .map((name) => {
+            const path = `${ARCHIVE_DIR}/${name}`;
+            const committed = dates.get(path);
+            const ageDays = committed === undefined ? 0 : (now.getTime() - new Date(committed).getTime()) / DAY_MS;
+
+            return { path, name, committed, ageDays };
+        })
+        .sort((one, other) => other.ageDays - one.ageDays);
+}
+
+/** Записи, перестоявшие срок. Срок не назначен — перестоявших нет ни одной. */
+export function staleRecords(root, now = new Date()) {
+    if (RETENTION_DAYS === null) {
+        return [];
+    }
+
+    return archiveRecords(root, now).filter((record) => record.ageDays > RETENTION_DAYS);
+}

package/assets/checks/archive-prune.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * Чистка описания прошлого по сроку.
+ *
+ * Запись живёт назначенный деревом срок, дальше снимается из дерева и остаётся в истории
+ * системы контроля версий — достать её оттуда можно по имени файла, оно же единственный
+ * указатель каталога.
+ *
+ * Сухой прогон — умолчание. Команда сносит разбор просьбы — единственную запись слов
+ * владельца, — и снос называется явно: `--apply`. Перечень снимаемого печатается в обоих
+ * случаях одинаково, чтобы решение принималось по тому же списку, который потом уедет.
+ *
+ * Срок и отбор берутся у `archive-age.mjs` — того же модуля, по которому краснеет проверка.
+ */
+import { execFileSync } from 'node:child_process';
+
+import { RETENTION_DAYS, archiveRecords, staleRecords } from './archive-age.mjs';
+import { ROOT } from './rt-kit-checks.config.mjs';
+
+if (RETENTION_DAYS === null) {
+    console.log('archive-prune: срок хранения описания прошлого деревом не назначен — снимать нечего');
+    process.exit(0);
+}
+
+const apply = process.argv.includes('--apply');
+const stale = staleRecords(ROOT);
+const total = archiveRecords(ROOT).length;
+
+if (stale.length === 0) {
+    console.log(`archive-prune: записей ${total}, перестоявших срок в ${RETENTION_DAYS} суток нет`);
+    process.exit(0);
+}
+
+console.log(`archive-prune: перестояло ${stale.length} из ${total} при сроке в ${RETENTION_DAYS} суток`);
+
+for (const record of stale) {
+    console.log(`  ${record.name} — ${Math.floor(record.ageDays)} суток, последний коммит ${record.committed.slice(0, 10)}`);
+}
+
+if (!apply) {
+    console.log('\nЭто сухой прогон: не снято ничего. Снос идёт доводом --apply.');
+    process.exit(0);
+}
+
+execFileSync('git', ['rm', '--quiet', '--', ...stale.map((record) => record.path)], { cwd: ROOT, stdio: 'inherit' });
+console.log(`\nСнято записей: ${stale.length}. Они остаются в истории — найти их можно по имени файла.`);

package/assets/checks/check-archive-age.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Сверка срока хранения описания прошлого.
+ *
+ * Одной чистки хватает ровно на срок: каталог набирает по записи на каждую закрытую работу, и
+ * первая уцелевшая перестаивает снова. Без сверки срок держался бы памятью того, кто помнит
+ * про команду чистки, — то есть не держался бы вовсе.
+ *
+ * Сверка не чистит: снос — решение, а не следствие проверки. Она называет перестоявшие записи
+ * и команду, которой их снимают.
+ *
+ * FAIL-OPEN: срок деревом не назначен — сверять нечего, нулевой код. Умолчания у срока нет
+ * намеренно: пакет, назначивший его за дерево, начал бы сносить чужой архив в день установки.
+ * Каталога нет — то же самое. Пустой каталог отказом не считается: он означает, что всё снято
+ * по сроку.
+ *
+ * Ненулевой код возврата и перечень перестоявших записей.
+ */
+import { ARCHIVE_DIR, RETENTION_DAYS, archiveRecords, staleRecords } from './archive-age.mjs';
+import { ROOT } from './rt-kit-checks.config.mjs';
+
+if (RETENTION_DAYS === null) {
+    console.log('check-archive-age: срок хранения описания прошлого деревом не назначен — сверять нечего');
+    process.exit(0);
+}
+
+const total = archiveRecords(ROOT).length;
+const stale = staleRecords(ROOT);
+
+if (stale.length > 0) {
+    console.error(`check-archive-age: расхождений ${stale.length}`);
+
+    for (const record of stale) {
+        console.error(`  ${record.path}: ${Math.floor(record.ageDays)} суток при сроке в ${RETENTION_DAYS}`);
+    }
+
+    console.error(`\nЗапись живёт ${RETENTION_DAYS} суток и снимается: \`node tools/archive-prune.mjs --apply\`.`);
+    console.error('Снятая остаётся в истории — найти её можно по имени файла.');
+    process.exit(1);
+}
+
+console.log(`check-archive-age: записей ${total} в ${ARCHIVE_DIR}, ни одна не перестояла срок в ${RETENTION_DAYS} суток`);

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

@@ -138,6 +138,12 @@ function folderInBranch(branch, options) {
  *
  * Свежая вершина не судится: между пушем и прогоном проходит время, и красная строка на этом
  * промежутке значила бы «подожди», а не «чини».
+ *
+ * У конфликтующей заявки прогона не бывает вовсе, и причина не в потерянном событии: конвейер
+ * проверяет слияние ветки с базой, а слияния при конфликте нет. Совет вернуть событие
+ * выполняется буквально и не помогает — за один заход заявка перезакрывалась дважды подряд, и
+ * прогон встал только после вливания главной ветки. Строка поэтому называет ту причину, которая
+ * чинится.
  */
 function checkHeadRun(pull, options) {
     if (checkEvicted(pull, options)) {
@@ -154,6 +160,16 @@ function checkHeadRun(pull, options) {
         return;
     }
 
+    if (pull.mergeable === 'CONFLICTING') {
+        report(
+            `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет и не будет, пока она конфликтует — ` +
+                `конвейер проверяет слияние ветки с базой, а слияния при конфликте нет; влей главную ветку и запушь, ` +
+                `перезакрытие PR тут не помогает`
+        );
+
+        return;
+    }
+
     report(
         `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет, а лежит она ${minutes} мин — ` +
             `конвейер события не получил; верни его новым коммитом либо перезакрытием PR ` +

package/assets/checks/check-descriptions.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * Сверка длины описаний правил и паттернов.
+ *
+ * Описание едет в системный промпт каждого захода — все, сколько их есть в дереве, — и
+ * платит их заход, чем бы ни занимался. Тем оно и отличается от тела правила: тело
+ * исполнитель читает сам и платит за это ходом, описание приходит даром. Даром — пока
+ * оно короткое.
+ *
+ * Растёт оно само: описание пишут вслед за правилом и пересказывают в нём содержимое.
+ * Ни одна проверка длины не считала, и на дереве, где эта сверка заводилась, сорок
+ * описаний из семидесяти четырёх переросли предел.
+ *
+ * Отвечает описание на один вопрос — брать это правило или нет. Всё, что отвечает на
+ * вопрос «а что там внутри», приходит вторым разом вместе с самим правилом.
+ *
+ * FAIL-OPEN: каталога скилов в дереве нет — сверять нечего, нулевой код.
+ *
+ * Описание длиннее предела, оставленное намеренно, называется в перечне принятого долга
+ * рядом — по имени скила, с причиной. Молчаливое превышение и осознанное выглядят
+ * одинаково, поэтому второе называется списком.
+ *
+ * Ненулевой код возврата и перечень превысивших с числами.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const SKILLS = join(ROOT, '.claude/skills');
+const DEBT = join(ROOT, '.claude/rt-kit/description-debt.json');
+
+/**
+ * Предел длины описания в знаках.
+ *
+ * Считаются знаки, а не байты: байт о цене окна не говорит, а кириллица делает его в
+ * полтора раза больше знака. Триста — число владельца, назначенное от первого замера.
+ */
+const LIMIT = 300;
+
+/** Описание из шапки: строка `description:` до конца строки. */
+function descriptionOf(text) {
+    const match = /^description:\s*(.+)$/m.exec(text);
+
+    return match === null ? null : match[1].trim();
+}
+
+/** Перечень принятого долга: имя скила → причина. Нет файла — долга нет. */
+function debt() {
+    if (!existsSync(DEBT)) {
+        return {};
+    }
+
+    try {
+        return JSON.parse(readFileSync(DEBT, 'utf8'));
+    } catch {
+        return {};
+    }
+}
+
+function main() {
+    if (!existsSync(SKILLS)) {
+        console.log('check-descriptions: каталога скилов нет — сверять нечего');
+
+        return 0;
+    }
+
+    const accepted = debt();
+    const over = [];
+    const owed = [];
+    let counted = 0;
+
+    for (const name of readdirSync(SKILLS)) {
+        const file = join(SKILLS, name, 'SKILL.md');
+
+        if (!existsSync(file)) {
+            continue;
+        }
+
+        const description = descriptionOf(readFileSync(file, 'utf8'));
+
+        if (description === null) {
+            continue;
+        }
+
+        counted += 1;
+
+        if (description.length <= LIMIT) {
+            continue;
+        }
+
+        if (Object.hasOwn(accepted, name)) {
+            owed.push(`${name}: ${description.length} знаков — ${accepted[name]}`);
+            continue;
+        }
+
+        over.push({ name, length: description.length });
+    }
+
+    for (const line of owed) {
+        console.log(`  долг ${line}`);
+    }
+
+    if (over.length > 0) {
+        over.sort((first, second) => second.length - first.length);
+        console.log(`check-descriptions: длиннее предела ${over.length} из ${counted}, предел ${LIMIT} знаков\n`);
+
+        for (const item of over) {
+            console.log(`  ${item.name}: ${item.length} знаков, лишних ${item.length - LIMIT}`);
+        }
+
+        console.log('\nОписание отвечает на один вопрос — брать это правило или нет. Перечисление разделов');
+        console.log('и пересказ статей приходят вторым разом вместе с самим правилом.');
+        console.log('Оставленное намеренно называется в .claude/rt-kit/description-debt.json с причиной.');
+
+        return 1;
+    }
+
+    console.log(`check-descriptions: описаний ${counted}, все в пределе ${LIMIT} знаков` + (owed.length > 0 ? `, принятого долга ${owed.length}` : ''));
+
+    return 0;
+}
+
+process.exit(main());

package/assets/checks/check-dupes.mjs

@@ -163,6 +163,12 @@ const PAIR_RE = /([\w'"[\].]+)\s*:\s*([^,\n]+)/g;
 const MIN_VALUE_LENGTH = 4;
 /** Минимум пар, при котором совпадение таблиц о чём-то говорит */
 const MIN_TABLE_PAIRS = 2;
+/**
+ * Доля совпавших пар, начиная с которой таблицы считаются одной. Полное равенство слепо ровно
+ * там, где копия разошлась с оригиналом на строку, — а это и есть тот случай, ради которого
+ * копии сводят. Порог высокий: таблицы одного домена делят по две-три пары без всякого родства.
+ */
+const MIN_TABLE_SHARE = 0.8;
 
 /**
  * Пакеты, чьи наборы считаются наравне с либами. Своё перечисление под уже
@@ -237,7 +243,7 @@ for (const path of SOURCE_ROOTS.flatMap((root) => collectFiles(root))) {
             ([, key, value]) => `${key.replaceAll(/['"[\]]/g, '')}:${value.trim().replace(/,$/, '')}`
         );
         if (pairs.length >= MIN_TABLE_PAIRS) {
-            tables.push({ name, lib, pairs: [...pairs].sort().join('|') });
+            tables.push({ name, lib, pairs: new Set(pairs) });
         }
     }
 
@@ -286,14 +292,36 @@ for (const [value, places] of [...namesByValue.entries()].sort()) {
     findings.push({ key: `value ${value} @ ${where}`, text: `значение ${value} объявлено в ${libs.size} либах: ${where}` });
 }
 
+/**
+ * Доля совпавших пар считается от большей таблицы: от меньшей таблица из двух пар, целиком
+ * лежащая внутри таблицы из двадцати, читалась бы полной копией.
+ */
+const tableOverlap = (first, second) => {
+    let same = 0;
+    for (const pair of first.pairs) {
+        if (second.pairs.has(pair)) {
+            same += 1;
+        }
+    }
+    const larger = Math.max(first.pairs.size, second.pairs.size);
+
+    return { same, larger, share: same / larger };
+};
+
 for (let i = 0; i < tables.length; i++) {
     for (let j = i + 1; j < tables.length; j++) {
         const [first, second] = [tables[i], tables[j]];
-        if (first.lib === second.lib || first.pairs !== second.pairs) {
+        if (first.lib === second.lib) {
+            continue;
+        }
+        const { same, larger, share } = tableOverlap(first, second);
+        if (share < MIN_TABLE_SHARE) {
             continue;
         }
         const key = `table ${[`${first.name} @ ${first.lib}`, `${second.name} @ ${second.lib}`].sort().join(' ~ ')}`;
-        findings.push({ key, text: `${first.name} (${first.lib}) и ${second.name} (${second.lib}) — одна таблица соответствий` });
+        const apart = larger - same;
+        const tail = apart === 0 ? 'одна таблица соответствий' : `одна таблица соответствий, разошедшаяся на ${apart} из ${larger} пар`;
+        findings.push({ key, text: `${first.name} (${first.lib}) и ${second.name} (${second.lib}) — ${tail}` });
     }
 }
 

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

@@ -38,6 +38,14 @@ const ALLOWLIST = allowlistOf('file-size');
 /** Пределов два: код и текст слоя правил. Какой из них применён, каждая строка отказа называет. */
 const LIMIT = CONFIG.fileSizeLimit;
 const PROSE_LIMIT = CONFIG.proseSizeLimit ?? CONFIG.fileSizeLimit;
+/**
+ * Второй предел текста — в знаках. Строки меряют, сколько текста помещается на экран, но веса
+ * не меряют вовсе: правило о заявках занимает 282 строки при 13 595 знаках, а правило поставки —
+ * 272 строки при 21 508. Сжатие слоя срезает знаки, а число переносов оставляет прежним, и
+ * строковый предел достигнутого не закрепляет. Дерево, не назвавшее этого числа, судится
+ * по-прежнему одними строками.
+ */
+const PROSE_CHARS = CONFIG.proseCharLimit ?? 0;
 /** Корни текста слоя правил; дерево, их не назвавшее, судится одним пределом. */
 const PROSE_ROOTS = CONFIG.proseRoots ?? [];
 
@@ -74,6 +82,16 @@ function lineCount(path) {
     return readFileSync(join(ROOT, path), 'utf8').split('\n').length;
 }
 
+/** Спутник — таблица связи, а не проза: компаньон правила и перечень сценариев спека. */
+function companion(path) {
+    return path.endsWith('/implementation.md') || path.endsWith('/scenarios.md');
+}
+
+/** Знаки, а не байты: кириллица весит по два байта, и байтовый счёт судил бы язык, а не текст. */
+function charCount(path) {
+    return readFileSync(join(ROOT, path), 'utf8').length;
+}
+
 /**
  * Список известного читается отдельно от общего читателя: у этой проверки нет файла — это
  * не пустой список, а нечитаемая настройка, и молчать о ней нельзя. Пустой список законен
@@ -86,15 +104,32 @@ const known = new Map([...[...accepted.keys()].map((path) => [path, 'приня
 const tooLong = new Map();
 const tracked = trackedFiles().filter(judged);
 
+const overweight = new Map();
+
 for (const path of tracked) {
     const lines = lineCount(path);
     if (lines > limitOf(path).limit) {
         tooLong.set(path, lines);
     }
+
+    // Вес судится только у текста слоя правил и только там, где дерево назвало число: у кода
+    // длину стережёт ещё и линтер, а у прозы — одни эти два предела.
+    //
+    // Спутники из счёта веса выведены. Компаньон правила и перечень сценариев — таблицы связи:
+    // заголовок привязки дословно повторяет утверждение, потому что связь идёт по его тексту, и
+    // резать там нечего, не порвав саму связь. Вес такого файла растёт с числом утверждений, а
+    // не с многословием: у правила поставки семьдесят шесть привязок на 24 326 знаков, из них
+    // пояснений всего 5 729. Строковый предел на них остаётся — он ловит другое.
+    if (PROSE_CHARS > 0 && PROSE_ROOTS.length > 0 && limitOf(path).title === 'предел текста' && !companion(path)) {
+        const chars = charCount(path);
+        if (chars > PROSE_CHARS) {
+            overweight.set(path, chars);
+        }
+    }
 }
 
 if (process.argv.includes('--baseline')) {
-    console.log(baselineOf([...tooLong.keys()].sort(), allowlist));
+    console.log(baselineOf([...new Set([...tooLong.keys(), ...overweight.keys()])].sort(), allowlist));
     process.exit(0);
 }
 
@@ -104,7 +139,11 @@ const gone = [...known.keys()].filter((path) => !existsSync(join(ROOT, path)));
 /** Файл поделили, а строку оставили: список перестал бы отвечать за то, что в нём стоит. */
 const shrunk = [...known.keys()].filter((path) => !tooLong.has(path) && existsSync(join(ROOT, path)));
 
+/** Тяжёлое по знакам судится тем же списком известного: один долг на файл, а не два. */
+const heavy = [...overweight].filter(([path]) => !known.has(path) && !tooLong.has(path));
+
 const problems = [
+    ...heavy.map(([path, chars]) => `${path}: ${chars} знаков, предел веса текста ${PROSE_CHARS} — резать довод, а не дописывать строку в ${ALLOWLIST}`),
     ...fresh.map(([path, lines]) => {
         const { limit, title } = limitOf(path);
         return `${path}: ${lines} строк, ${title} ${limit} — делить, а не дописывать строку в ${ALLOWLIST}`;
@@ -121,8 +160,14 @@ if (problems.length > 0) {
 }
 
 const limits = PROSE_ROOTS.length > 0 ? `предел кода ${LIMIT}, предел текста ${PROSE_LIMIT}` : `предел ${LIMIT}`;
+/**
+ * Предел веса называется только там, где дерево задало и число, и корни текста: вес судится у
+ * прозы слоя правил, а дерево, её корней не назвавшее, судится одним числом строк — и вторая
+ * цифра в сводке говорила бы о проверке, которая там не работает.
+ */
+const weight = PROSE_CHARS > 0 && PROSE_ROOTS.length > 0 ? `, предел веса текста ${PROSE_CHARS} знаков` : '';
 
 console.log(
-    `check-file-size: проверено ${tracked.length} файлов, ${limits}, длиннее предела ${tooLong.size}, ` +
+    `check-file-size: проверено ${tracked.length} файлов, ${limits}${weight}, длиннее предела ${tooLong.size}, ` +
         `из них принято ${accepted.size}, долг ${debt.size} — новых нет`
 );

package/assets/checks/check-turn-map.mjs

@@ -41,11 +41,28 @@ const RULE = join(ROOT, '.claude/skills/task-flow/SKILL.md');
  */
 const LIMIT_BYTES = 6144;
 
-/** Имена состояний из таблицы: первая ячейка в обратных кавычках и всё, что за ней. */
-function statesOf(text) {
+/**
+ * Имена состояний: строка таблицы, у которой первая ячейка стоит в обратных кавычках, — а для
+ * карты хода ещё и строка списка «- `имя` — действие; ведёт `паттерн`». В правиле список так не
+ * читается: тем же видом там записаны паттерны, и они попали бы в состояния.
+ * у которой первая ячейка стоит в обратных кавычках.
+ *
+ * Обе формы читаются намеренно. Список дешевле таблицы на треть — форматтер добивает столбцы
+ * пробелами до общей ширины, и эти пробелы едут в контекст каждого захода, ничего не значая;
+ * таблица при этом остаётся законной, и дерево, которое её не переписывало, работает как
+ * прежде.
+ */
+function statesOf(text, { listed: readListed = false } = {}) {
     const states = [];
 
     for (const line of text.split('\n')) {
+        const listed = readListed && line.match(/^-\s+`([^`]+)`\s+—\s+(.+)$/);
+
+        if (listed) {
+            states.push({ name: listed[1], rest: listed[2].split(';').map((part) => part.trim()) });
+            continue;
+        }
+
         if (!line.startsWith('|')) {
             continue;
         }
@@ -87,7 +104,7 @@ function main() {
         faults.push(`карта выросла: ${bytes} байт при пределе ${LIMIT_BYTES}`);
     }
 
-    const inMap = statesOf(text);
+    const inMap = statesOf(text, { listed: true });
 
     if (inMap.length === 0) {
         faults.push('в карте нет ни одного состояния — таблица сломана');

package/assets/checks/lib-common.mjs

@@ -60,7 +60,18 @@ const isLib = (path) => existsSync(join(ROOT, path, 'project.json'));
  * нет вовсе, и прямое чтение роняло проверку отказом «нет такого файла» — то есть первая же
  * установка получала поломку вместо отчёта о том, что долгов нет.
  */
-const allowlist = parseAllowlist('lib-layers', ['notDomains', 'legacyDomains', 'legacyLibs', 'singleLayerDomains', 'accepted', 'debt']);
+// `flatLibRoots` стоит в перечне наравне с остальными: сбор плоских либ читает эту сторону, а
+// разбор её не собирал — значение выходило пустым и подставлялось пустым списком молча. Дерево с
+// непустым набором плоских корней получало ноль плоских либ и зелёную проверку.
+const allowlist = parseAllowlist('lib-layers', [
+    'notDomains',
+    'legacyDomains',
+    'legacyLibs',
+    'singleLayerDomains',
+    'flatLibRoots',
+    'accepted',
+    'debt',
+]);
 const pathsOf = (key) => [...allowlist[key].keys()];
 
 /** Паттерн `<корень>/x/*` покрывает и сам каталог `<корень>/x`: исключение снимается целиком */

package/assets/checks/lib-domains.mjs

@@ -196,7 +196,7 @@ function collectStrayLibs(knownLibs) {
  * `nx test` по ней молча не гонял ни одной спеки.
  */
 function collectFlatLibs() {
-    return (allowlist.flatLibRoots ?? [])
+    return [...(allowlist.flatLibRoots?.keys() ?? [])]
         .flatMap((root) => dirsIn(root).map((entry) => `${root}/${entry}`))
         .filter((path) => isLib(path))
         .sort();