@rt-tools/agent-kit 0.9.1 → 0.11.0

package/assets/checks/check-state-next.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+/**
+ * Сверка того, что раздел состояния называет следующее движение.
+ *
+ * Раздел, обрывающийся на последнем приёме, читается как конец работы: исполнитель
+ * доводит обязательное действие до конца, дочитывает раздел, следующего движения в
+ * нём не находит — и отдаёт ход отчётом о сделанном. Так кончились два хода: один
+ * на записанном замысле, второй на закрытом разборе просьбы. Сверка состояний этого
+ * не видит: она сравнивает имена разделов с перечнем и внутрь не смотрит.
+ *
+ * Читаются четыре текста:
+ *   перечень — таблица состояний в правиле ведения работы: имя и ведущий паттерн;
+ *   разделы  — заголовки вида «Состояние `имя`» в этих паттернах;
+ *   правило  — оно же: в нём стоит утверждение о границе состояния;
+ *   карта и закон — там же стоит то же утверждение, если дерево их разложило.
+ *
+ * Строка следующего движения узнаётся по зачину, а называет своё: единая дословная
+ * строка читается как шаблон и перестаёт замечаться на третьем разделе. Поэтому
+ * повтор хвоста считается расхождением наравне с его отсутствием.
+ *
+ * FAIL-OPEN: правила ведения работы в дереве нет — сверять нечего, нулевой код.
+ * Пустая таблица состояний отказом считается: она означает не «нечего сверять», а
+ * «перечень сломан». Ведущий паттерн, которого в дереве нет, здесь не судится — его
+ * называет сверка состояний, и два отказа об одном промахе читаются как две
+ * претензии.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const RULE = join(ROOT, '.claude/skills/task-flow/SKILL.md');
+const SKILLS = join(ROOT, '.claude/skills');
+const MAP = join(ROOT, '.claude/rt-kit/defaults/turn-map.md');
+const LAW = join(ROOT, 'docs/constitution/work-conduct.md');
+
+/** Зачин строки: по нему её находят, а хвост у каждого раздела свой. */
+const MARKER = '**Следующее движение:**';
+
+/** Утверждение о границе состояния. Стоит в правиле, в карте и в законе теми же словами. */
+const BOUNDARY = 'Переход из состояния в состояние';
+
+/** Короче этого хвост движения не называет: зачин без движения — та же пустота. */
+const MIN_TAIL = 20;
+
+/** Имя состояния и паттерн, который его ведёт, — из таблицы правила. */
+function statesFromRule(text) {
+    const states = [];
+
+    for (const line of text.split('\n')) {
+        if (!line.startsWith('|')) {
+            continue;
+        }
+
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+
+        if (cells.length < 4) {
+            continue;
+        }
+
+        const name = cells[0].match(/^`([^`]+)`$/);
+        const pattern = cells[3].match(/^`([^`]+)`$/);
+
+        if (name && pattern) {
+            states.push({ name: name[1], pattern: pattern[1] });
+        }
+    }
+
+    return states;
+}
+
+/** Разделы состояний паттерна: имя, заголовок целиком и найденные в разделе строки движения. */
+function sectionsOf(pattern) {
+    const file = join(SKILLS, pattern, 'SKILL.md');
+
+    if (!existsSync(file)) {
+        return null;
+    }
+
+    const sections = [];
+    let current = null;
+
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+        const heading = line.match(/^#+\s+Состояние\s+`([^`]+)`/);
+
+        if (heading) {
+            current = { name: heading[1], heading: line.replace(/^#+\s+/, ''), moves: [] };
+            sections.push(current);
+            continue;
+        }
+
+        if (current && line.startsWith(MARKER)) {
+            current.moves.push(line.slice(MARKER.length).trim());
+        }
+    }
+
+    return sections;
+}
+
+if (!existsSync(RULE)) {
+    console.log('check-state-next: правила ведения работы в дереве нет — сверять нечего');
+    process.exit(0);
+}
+
+const ruleText = readFileSync(RULE, 'utf8');
+const states = statesFromRule(ruleText);
+
+if (states.length === 0) {
+    console.error('check-state-next: в правиле ведения работы не нашлось таблицы состояний');
+    process.exit(1);
+}
+
+const problems = [];
+const patterns = new Map();
+const tails = new Map();
+let counted = 0;
+
+for (const state of states) {
+    if (!patterns.has(state.pattern)) {
+        patterns.set(state.pattern, sectionsOf(state.pattern));
+    }
+}
+
+for (const [pattern, sections] of patterns) {
+    if (sections === null) {
+        continue;
+    }
+
+    for (const section of sections) {
+        counted += 1;
+
+        const where = `\`${section.name}\` в паттерне \`${pattern}\``;
+
+        if (section.moves.length === 0) {
+            problems.push(`${where}: в разделе «${section.heading}» нет строки «${MARKER}»`);
+            continue;
+        }
+
+        if (section.moves.length > 1) {
+            problems.push(`${where}: в разделе «${section.heading}» таких строк ${section.moves.length}, а движение одно`);
+            continue;
+        }
+
+        const tail = section.moves[0];
+
+        if (tail.length < MIN_TAIL) {
+            problems.push(`${where}: зачин есть, а движение за ним не названо`);
+            continue;
+        }
+
+        const twin = tails.get(tail);
+
+        if (twin) {
+            problems.push(`${where}: движение слово в слово то же, что у ${twin}`);
+            continue;
+        }
+
+        tails.set(tail, `\`${section.name}\` в паттерне \`${pattern}\``);
+    }
+}
+
+if (counted === 0) {
+    problems.push('ни одного раздела состояния не нашлось: паттерны не разложены или заголовки в них другие');
+}
+
+if (!ruleText.includes(BOUNDARY)) {
+    problems.push(`правило ведения работы о границе состояния молчит: строки «${BOUNDARY}» в нём нет`);
+}
+
+for (const [file, what] of [
+    [MAP, 'карта хода'],
+    [LAW, 'закон о ведении работы'],
+]) {
+    if (existsSync(file) && !readFileSync(file, 'utf8').includes(BOUNDARY)) {
+        problems.push(`${what} о границе состояния молчит: строки «${BOUNDARY}» в ней нет`);
+    }
+}
+
+if (problems.length > 0) {
+    console.error(`check-state-next: расхождений ${problems.length}`);
+
+    for (const problem of problems) {
+        console.error(`  ${problem}`);
+    }
+
+    console.error('\nСтрока следующего движения стоит в каждом разделе состояния: зачин общий, движение своё.');
+    process.exit(1);
+}
+
+console.log(`check-state-next: разделов состояния ${counted}, у каждого названо следующее движение`);

package/assets/checks/check-states.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Сверка перечня состояний работы с разделами паттернов, которые их ведут.
+ *
+ * Состояние без ведущего текста читается как конец работы: исполнитель дочитывает
+ * паттерн до последнего раздела, следующего движения в нём нет, и ход кончается
+ * отчётом. Так простояло состояние «замысел записан» — оно встречалось один раз,
+ * клеткой таблицы, и дыру нашло происшествие, а не проверка. Разбор —
+ * `docs/postmortems/2026-08-21-turn-ended-at-the-written-plan.md`.
+ *
+ * Сверяются два множества в обе стороны:
+ *   перечень — таблица состояний в правиле ведения работы: имя и ведущий паттерн;
+ *   разделы  — заголовки вида «Состояние `имя`» в паттернах.
+ *
+ * Состояние без раздела — расхождение. Раздел про состояние вне перечня — тоже:
+ * переименованное состояние иначе оставляет прежний раздел, и тот выглядит
+ * действующим.
+ *
+ * Ведущий паттерн берётся из самой таблицы, а не из имён файлов: раздел, лежащий
+ * не в том паттерне, который назначен, читателя до себя не доводит — он открывает
+ * назначенный.
+ *
+ * FAIL-OPEN: правила ведения работы в дереве нет — сверять нечего, нулевой код.
+ * Пустая таблица состояний отказом считается: она означает не «нечего сверять», а
+ * «перечень сломан».
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const RULE = join(ROOT, '.claude/skills/task-flow/SKILL.md');
+const SKILLS = join(ROOT, '.claude/skills');
+
+/** Имя состояния и паттерн, который его ведёт, — из таблицы правила. */
+function statesFromRule(text) {
+    const states = [];
+
+    for (const line of text.split('\n')) {
+        if (!line.startsWith('|')) {
+            continue;
+        }
+
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+
+        if (cells.length < 4) {
+            continue;
+        }
+
+        const name = cells[0].match(/^`([^`]+)`$/);
+        const pattern = cells[3].match(/^`([^`]+)`$/);
+
+        if (name && pattern) {
+            states.push({ name: name[1], pattern: pattern[1] });
+        }
+    }
+
+    return states;
+}
+
+/** Состояния, про которые в паттерне есть раздел. Заголовок любого уровня. */
+function sectionsOf(pattern) {
+    const file = join(SKILLS, pattern, 'SKILL.md');
+
+    if (!existsSync(file)) {
+        return null;
+    }
+
+    const found = new Set();
+
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+        const heading = line.match(/^#+\s+Состояние\s+`([^`]+)`/);
+
+        if (heading) {
+            found.add(heading[1]);
+        }
+    }
+
+    return found;
+}
+
+if (!existsSync(RULE)) {
+    console.log('check-states: правила ведения работы в дереве нет — сверять нечего');
+    process.exit(0);
+}
+
+const states = statesFromRule(readFileSync(RULE, 'utf8'));
+
+if (states.length === 0) {
+    console.error('check-states: в правиле ведения работы не нашлось таблицы состояний');
+    process.exit(1);
+}
+
+const known = new Set(states.map((state) => state.name));
+const problems = [];
+const seen = new Map();
+
+for (const state of states) {
+    if (!seen.has(state.pattern)) {
+        seen.set(state.pattern, sectionsOf(state.pattern));
+    }
+
+    const sections = seen.get(state.pattern);
+
+    if (sections === null) {
+        problems.push(`состояние \`${state.name}\`: ведущий паттерн \`${state.pattern}\` в дереве не разложен`);
+        continue;
+    }
+
+    if (!sections.has(state.name)) {
+        problems.push(`состояние \`${state.name}\`: в паттерне \`${state.pattern}\` нет раздела «Состояние \`${state.name}\`»`);
+    }
+}
+
+for (const [pattern, sections] of seen) {
+    if (sections === null) {
+        continue;
+    }
+
+    for (const name of sections) {
+        if (!known.has(name)) {
+            problems.push(`паттерн \`${pattern}\`: раздел про \`${name}\`, а такого состояния в перечне нет`);
+        }
+    }
+}
+
+if (problems.length > 0) {
+    console.error(`check-states: расхождений ${problems.length}`);
+
+    for (const problem of problems) {
+        console.error(`  ${problem}`);
+    }
+
+    console.error('\nПеречень состояний — правило `task-flow`, разделы — паттерны при нём.');
+    process.exit(1);
+}
+
+console.log(`check-states: состояний ${states.length}, у каждого есть раздел в ведущем паттерне`);

package/assets/checks/check-styles.mjs

@@ -33,7 +33,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { basename, dirname, join } from 'node:path';
 
-import { allowlistOf, CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+import { allowlistOf, baselineOf, CONFIG, ROOT, parseAllowlist } from './rt-kit-checks.config.mjs';
 
 const ALLOWLIST = allowlistOf('styles');
 const SOURCE_ROOTS = CONFIG.sourceRoots;
@@ -51,9 +51,9 @@ const USE_RE = /@(?:use|forward)\s+['"]([^'"]+)['"]/g;
 /** Строка списка известного: имя класса и перечень файлов при нём */
 const KEY_RE = /^elem (\S+) @ (.*)$/;
 
-const allowlist = JSON.parse(readFileSync(join(ROOT, ALLOWLIST), 'utf8'));
-const known = new Set([...(allowlist.accepted ?? []), ...(allowlist.debt ?? [])]);
-const debt = new Set(allowlist.debt ?? []);
+const allowlist = parseAllowlist('styles');
+const known = allowlist.keys;
+const debt = new Set(allowlist.debt.keys());
 
 /** Строки списка по имени класса: перечень файлов в ключ входит, но сверяется отдельно */
 const knownByName = new Map();
@@ -223,7 +223,7 @@ for (const [name, files] of [...usedIn].sort(([first], [second]) => first.locale
 }
 
 if (process.argv.includes('--baseline')) {
-    console.log(JSON.stringify({ ...allowlist, debt: findings.map((finding) => finding.key).sort() }, null, 4));
+    console.log(baselineOf(findings.map((finding) => finding.key).sort(), allowlist));
     process.exit(0);
 }
 

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

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * Сверка карты хода: её размер и её полнота.
+ *
+ * Карту кладёт в контекст хук входа в заход — целиком, до первой реплики. Тем она и
+ * отличается от правила: правило исполнитель читает сам и платит за это ходом, карта
+ * приходит даром. Даром — пока она короткая: карта, выросшая до правила, съедает то
+ * самое окно, ради которого её и заводили, и заметить это нечем — она продолжает
+ * приходить и продолжает быть верной.
+ *
+ * Второе, чего не видно без сверки: состояние, заведённое в правиле и забытое в карте.
+ * Заход тогда получает карту, не находит в ней своего состояния и идёт читать правило —
+ * то есть карта работает ровно до первого нового состояния.
+ *
+ * Сверяются три вещи:
+ *   размер    — байты разложенной карты против объявленного предела;
+ *   состояния — имена из таблицы правила против имён в карте, в обе стороны;
+ *   выходы    — все четыре выхода хода названы.
+ *
+ * FAIL-OPEN: карты в дереве нет — сверять нечего, нулевой код. Дерево может её не
+ * раскладывать. Пустая таблица состояний в карте отказом считается: это не «нечего
+ * сверять», а «карта сломана».
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const MAP = join(ROOT, '.claude/rt-kit/defaults/turn-map.md');
+const RULE = join(ROOT, '.claude/skills/task-flow/SKILL.md');
+
+/**
+ * Предел размера карты в байтах.
+ *
+ * Число одно и живёт здесь: карта приходит в каждый заход целиком, и предел ей — свойство
+ * приёма, а не дерева. Шесть килобайт взяты замером, а не на глаз: карта в день заведения
+ * весит 4495 байт, правило, из которого она выжата, — 63803. Запас в полтора килобайта —
+ * это два-три новых состояния; выйдя за него, карта перестаёт быть выжимкой, и делить её
+ * тогда надо, а не поднимать предел.
+ */
+const LIMIT_BYTES = 6144;
+
+/** Имена состояний из таблицы: первая ячейка в обратных кавычках и всё, что за ней. */
+function statesOf(text) {
+    const states = [];
+
+    for (const line of text.split('\n')) {
+        if (!line.startsWith('|')) {
+            continue;
+        }
+
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+
+        if (cells.length < 2) {
+            continue;
+        }
+
+        const name = cells[0].match(/^`([^`]+)`$/);
+
+        if (name) {
+            states.push({ name: name[1], rest: cells.slice(1) });
+        }
+    }
+
+    return states;
+}
+
+/** Выходы хода, названные законом. Ищутся по началу строки таблицы, а не по всему тексту. */
+const EXITS = ['вопрос владельцу', 'отказ гарда', 'заполненное окно', 'работа отдана'];
+
+function main() {
+    if (!existsSync(MAP)) {
+        console.log('check-turn-map: карты хода в дереве нет — сверять нечего');
+
+        return 0;
+    }
+
+    const text = readFileSync(MAP, 'utf8');
+    const bytes = statSync(MAP).size;
+    const faults = [];
+
+    if (bytes > LIMIT_BYTES) {
+        faults.push(`карта выросла: ${bytes} байт при пределе ${LIMIT_BYTES}`);
+    }
+
+    const inMap = statesOf(text);
+
+    if (inMap.length === 0) {
+        faults.push('в карте нет ни одного состояния — таблица сломана');
+    }
+
+    for (const state of inMap) {
+        if (!state.rest[0]) {
+            faults.push(`${state.name}: в карте нет обязательного действия`);
+        }
+    }
+
+    if (existsSync(RULE)) {
+        const inRule = statesOf(readFileSync(RULE, 'utf8'));
+        const mapNames = new Set(inMap.map((state) => state.name));
+        const ruleNames = new Set(inRule.map((state) => state.name));
+
+        for (const state of ruleNames) {
+            if (!mapNames.has(state)) {
+                faults.push(`${state}: состояние объявлено правилом и забыто в карте`);
+            }
+        }
+
+        for (const state of mapNames) {
+            if (!ruleNames.has(state)) {
+                faults.push(`${state}: состояние стоит в карте, а правило его не объявляет`);
+            }
+        }
+    }
+
+    for (const exit of EXITS) {
+        if (!text.includes(exit)) {
+            faults.push(`выход хода «${exit}» в карте не назван`);
+        }
+    }
+
+    if (faults.length > 0) {
+        console.log(`check-turn-map: расхождений ${faults.length}, размер ${bytes} байт при пределе ${LIMIT_BYTES}\n`);
+
+        for (const fault of faults) {
+            console.log(`  ${fault}`);
+        }
+
+        console.log('\nКарта короче правила — этим она и полезна. Выросшая, она съедает то окно, ради');
+        console.log('которого её кладут в контекст. Правится она в ресурсе пакета, а не в разложенной копии.');
+
+        return 1;
+    }
+
+    console.log(
+        `check-turn-map: ${inMap.length} состояний, ${EXITS.length} выхода хода, ` + `${bytes} байт при пределе ${LIMIT_BYTES} — сошлось`
+    );
+
+    return 0;
+}
+
+process.exit(main());

package/assets/checks/lib-common.mjs

@@ -9,7 +9,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { CONFIG, ROOT, readAllowlist } from './rt-kit-checks.config.mjs';
+import { CONFIG, ROOT, parseAllowlist } from './rt-kit-checks.config.mjs';
 
 const FAMILIES = CONFIG.families;
 /**
@@ -60,8 +60,8 @@ const isLib = (path) => existsSync(join(ROOT, path, 'project.json'));
  * нет вовсе, и прямое чтение роняло проверку отказом «нет такого файла» — то есть первая же
  * установка получала поломку вместо отчёта о том, что долгов нет.
  */
-const allowlist = readAllowlist('lib-layers');
-const pathsOf = (key) => (allowlist[key] ?? []).map((exception) => exception.path);
+const allowlist = parseAllowlist('lib-layers', ['notDomains', 'legacyDomains', 'legacyLibs', 'singleLayerDomains', 'accepted', 'debt']);
+const pathsOf = (key) => [...allowlist[key].keys()];
 
 /** Паттерн `<корень>/x/*` покрывает и сам каталог `<корень>/x`: исключение снимается целиком */
 const matches = (patterns, path) =>

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

@@ -187,8 +187,92 @@ export const allowlistOf = (name) => join(CONFIG.allowlistDir, `${name}-allowlis
  */
 export const readAllowlist = (name) => {
     const path = join(ROOT, allowlistOf(name));
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    } catch (error) {
+        // Нечитаемая настройка — это не пустой список, и молчать о ней нельзя: проверка,
+        // прочитавшая пустоту вместо перечня, назовёт долгом всё дерево разом.
+        console.error(`${allowlistOf(name)}: список известного не прочитан — не разбирается как JSON: ${error.message}`);
+        process.exit(1);
+    }
+};
+
+/**
+ * Разбор списка принятого: запись отвечает за себя сама.
+ *
+ * Причина, написанная прозой на весь список, за отдельную строку не отвечает: список пустеет и
+ * наполняется, а причина остаётся прежней — строка, внесённая позже, выглядит покрытой ею. Так
+ * и вышло у четырёх списков дерева: шапка говорила о разобранном долге, а под ней лежало
+ * принятое, которого в тот день ещё не было.
+ *
+ * Поэтому форма одна на все списки: сторона — объект, где ключ говорит, что принято, а
+ * значение несёт причину и номер задачи, которой запись внесена. Стороны называет зовущий:
+ * у большинства списков это `accepted` и `debt`, у иных свои имена, а разбор у всех один. Номер — это дорога
+ * к разговору, в котором заглушить разрешили: без него запись объясняет сама себя, а спросить
+ * о ней некого.
+ *
+ * Отказ называет файл и саму запись: список читают не целиком, а по строке, и «где-то здесь
+ * неверная запись» стоит того же, что и молчание.
+ */
+export const parseAllowlist = (name, sides = ['accepted', 'debt']) => {
+    const file = allowlistOf(name);
+    const raw = readAllowlist(name);
+    const key = CONFIG.board.taskKey;
+    const taskForm = key ? new RegExp(`^${key}-\\d+$`) : /^[A-Za-z]+-\d+$/;
+    const refuse = (message) => {
+        console.error(`${file}: ${message}`);
+        process.exit(1);
+    };
+    const parseSide = (side) => {
+        const entries = raw[side];
+        if (entries === undefined) {
+            return new Map();
+        }
+        if (Array.isArray(entries) || typeof entries !== 'object' || entries === null) {
+            refuse(`«${side}» записан не объектом — у записи нет места ни для причины, ни для номера задачи`);
+        }
+        const parsed = new Map();
+        for (const [entry, value] of Object.entries(entries)) {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                refuse(`«${entry}» записан без причины — рядом с записью стоят «reason» и «task»`);
+            }
+            if (typeof value.reason !== 'string' || value.reason.trim() === '') {
+                refuse(`у «${entry}» пустая причина — заглушённое без причины через месяц не отличить от забытого`);
+            }
+            if (typeof value.task !== 'string' || !taskForm.test(value.task)) {
+                refuse(`у «${entry}» нет номера задачи вида «${key || 'КЛЮЧ'}-<номер>» — спросить о записи будет некого`);
+            }
+            parsed.set(entry, { reason: value.reason, task: value.task });
+        }
+
+        return parsed;
+    };
+    const parsed = Object.fromEntries(sides.map((side) => [side, parseSide(side)]));
+
+    return { ...parsed, keys: new Set(sides.flatMap((side) => [...parsed[side].keys()])) };
+};
+
+/**
+ * Заготовка списка принятого для режима пересъёмки: прежние записи сохраняются целиком, а
+ * новые приходят с пустой причиной и пустым номером задачи.
+ *
+ * Пустые поля здесь намеренны. Пересъёмка — это помощник, а не разрешение: заглушить проверку
+ * можно только словом владельца, и записать его должен человек. Разбор такую запись отбивает,
+ * поэтому список, снятый пересъёмкой и не заполненный, дальше гейта не проходит.
+ */
+export const baselineOf = (keys, parsed, side = 'debt') => {
+    const entryOf = (key) => parsed.debt?.get(key) ?? parsed.accepted?.get(key) ?? { reason: '', task: '' };
+    const fresh = keys.filter((key) => !parsed.keys.has(key));
+    if (fresh.length > 0) {
+        console.error(`новых записей ${fresh.length} — у каждой заполняются «reason» и «task», иначе разбор списка отбивает прогон`);
+    }
+    const filled = Object.fromEntries(keys.map((key) => [key, entryOf(key)]));
+    const rest = Object.fromEntries([...(parsed.accepted ?? new Map())].filter(([key]) => !keys.includes(key)));
 
-    return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : {};
+    return JSON.stringify(side === 'accepted' ? { accepted: filled } : { accepted: rest, debt: filled }, null, 4);
 };
 
 /** Есть ли в дереве то, без чего проверке нечего делать. Нет — она выходит с нулём и говорит это. */

package/assets/commands/agent-kit-digest.md

@@ -12,9 +12,9 @@ argument-hint: '[пусто | --days N]'
 
 ## 1. Собери, что пришло
 
-Груз уезжает в приём, а не в очередь работ: сводка говорит о рабочих привычках команды, и в
-открытой очереди это выложено всему свету. Записи приёма читает его админка; пока её нет,
-собранное читается запросом к его хранилищу — как именно, сказано в компаньоне этой команды.
+Чем груз читается и что значит взять его в работу, говорит правило `cargo-triage`: здесь этот
+порядок не повторяется, а зовётся. Сведению от него нужен один шаг — список неразобранного,
+суженный отбором по состоянию «новое».
 
 Записи, заведённые прежним порядком, лежат в очереди работ и никуда не делись:
 
@@ -66,13 +66,14 @@ npx agent-kit stats --days <отрезок> --json
 По каждой — ресурс, место, готовый текст и число записей, из которых она вышла. Не правь ничего
 сам: решение принимает владелец, а работа идёт обычным ходом — задача, ветка, папка задачи.
 
-Заведи задачу на то, что владелец принял:
+Заведи задачу на то, что владелец принял, и тем же ходом отметь вошедшие в неё записи груза —
+как именно, говорит паттерн `cargo-triage-mark`:
 
 ```bash
 npm run task:new -- --title '<что не так>' --slug <короткое-имя> --label enhancement < тело.md
 ```
 
-Записи, вошедшие в задачу, закрой ссылкой на неё:
+Записи, заведённые в очереди работ прежним порядком, закрываются там же ссылкой на задачу:
 
 ```bash
 gh issue close <номер> --comment 'Вошло в #<номер задачи>.'