@rt-tools/agent-kit 0.14.0 → 0.15.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/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();

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

@@ -80,6 +80,19 @@ const DEFAULTS = {
      * только это число.
      */
     proseSizeLimit: 300,
+    /**
+     * Предел веса текста слоя правил — в знаках. Строки меряют, сколько текста помещается на
+     * экран; веса они не меряют вовсе: правило о заявках занимает 282 строки при 13 595 знаках,
+     * а правило поставки — 272 строки при 21 508. Сжатие слоя срезает знаки и оставляет число
+     * переносов прежним, поэтому строковый предел достигнутого не закрепляет, и текст отрастает
+     * обратно молча.
+     *
+     * Число назначено по сжатому слою: самое тяжёлое правило весит 21 508 знаков, и предел стоит
+     * чуть выше него. Ниже ставить нельзя — это потребовало бы резать заново то, что уже прошло
+     * сжатие; выше незачем — тогда он ничего не закрепляет. Ноль выключает проверку веса вовсе:
+     * дерево, не назвавшее числа, судится по-прежнему одними строками.
+     */
+    proseCharLimit: 22000,
     /**
      * Корни, под которыми лежит текст слоя правил, и его источники. Файл отсюда судится
      * пределом текста, всё остальное — пределом кода. Пусто — предел один на всё дерево.
@@ -258,7 +271,10 @@ export const parseAllowlist = (name, sides = ['accepted', 'debt']) => {
             return new Map();
         }
         if (Array.isArray(entries) || typeof entries !== 'object' || entries === null) {
-            refuse(`«${side}» записан не объектом — у записи нет места ни для причины, ни для номера задачи`);
+            refuse(
+                `«${side}» записан не объектом — у записи нет места ни для причины, ни для номера задачи. ` +
+                    `Форма: {"${side}": {"<ключ>": {"reason": "<почему>", "task": "${key || 'КЛЮЧ'}-<номер>"}}}`,
+            );
         }
         const parsed = new Map();
         for (const [entry, value] of Object.entries(entries)) {

package/assets/checks/spec-anchors.mjs

@@ -108,7 +108,11 @@ function checkRuleImplementation(specFile, text, mapFile, heading = '## Прав
 
     const rows = new Map();
     for (const line of rowsOfMap(specFile, mapFile, mapHeading)) {
-        const cells = line.match(/^\|([^|]+)\|([^|]*)\|\s*$/);
+        // Привязка записывается двумя формами, и читаются обе. Таблица — прежняя; список — та,
+        // ради которой из компаньонов уходят пробелы выравнивания: форматтер добивает столбцы до
+        // общей ширины, и в компаньонах дерева это 120 017 знаков из 328 738, то есть 37%.
+        // Связь при этом не меняется: она идёт по тексту утверждения, а не по форме строки.
+        const cells = line.match(/^\|([^|]+)\|([^|]*)\|\s*$/) ?? line.match(/^-\s+\*\*(.+?)\*\*\s+—\s+(.*)$/);
         if (!cells) {
             continue;
         }
@@ -210,8 +214,14 @@ function symbolOwners() {
 
     for (const file of SOURCE_ROOTS.flatMap((root) => walk(root, (name) => name.endsWith('.ts') || name.endsWith('.html')))) {
         const text = file.endsWith('.ts') ? codeOf(read(file)) : read(file);
-        for (const [token] of text.matchAll(/[A-Za-z_][\w-]*/g)) {
+        // Решётка входит в токен: приватное поле класса объявлено с ней, и якорь на него иначе
+        // не попадал бы в перечень владельцев ни разу. Имя без решётки помнится наравне с ним
+        // самим — привязки прежней формы остаются зелёными, и переходить разом не приходится.
+        for (const [token] of text.matchAll(/#?[A-Za-z_][\w-]*/g)) {
             remember(token, file);
+            if (token.startsWith('#')) {
+                remember(token.slice(1), file);
+            }
             if (token.includes('-')) {
                 token.split('-').forEach((part) => part && remember(part, file));
             }
@@ -242,7 +252,12 @@ function checkTracedAnchors() {
 
     const owners = symbolOwners();
     for (const { mapFile, path, symbol } of declared) {
-        const here = (codeAt(path).match(new RegExp(`\\b${escapeForRegExp(symbol)}\\b`, 'g')) || []).length;
+        // Граница слова ставится только там, где она есть: перед решёткой её нет, и образец с
+        // ней давал бы ноль вхождений у всякого приватного имени.
+        const bound = symbol.startsWith('#')
+            ? `${escapeForRegExp(symbol)}\\b`
+            : `\\b${escapeForRegExp(symbol)}\\b`;
+        const here = (codeAt(path).match(new RegExp(bound, 'g')) || []).length;
         const elsewhere = [...(owners.get(symbol) || [])].filter((file) => file !== path).length;
         if (here + elsewhere < 2) {
             report(

package/assets/checks/spec-common.mjs

@@ -66,8 +66,12 @@ const E2E_ROOTS = CONFIG.e2eRoots;
  * переписан целиком. Алфавит не перечисляется диапазонами: перечисленные молча не покрывают
  * соседнего, и промах выглядит отсутствием привязки. Путь при этом остаётся латинским — он
  * адрес в дереве, а не слово текста.
+ *
+ * Решётка перед именем законна: приватное поле класса объявлено с ней, и записанное без неё имя
+ * называет метод не тем именем, каким он объявлен. Проверка при этом остаётся зелёной — граница
+ * слова перед решёткой есть, — поэтому промах не краснеет ни разу и виден только чтением.
  */
-const ANCHOR = /`([\w./-]+\.[A-Za-z]{2,10}):(\p{L}[\p{L}\p{N}_-]*|_[\w-]*)`/gu;
+const ANCHOR = /`([\w./-]+\.[A-Za-z]{2,10}):(#?\p{L}[\p{L}\p{N}_-]*|#?_[\w-]*)`/gu;
 /**
  * Явный вердикт вместо якоря: статья, которой в дереве исполняться негде. Так бывает
  * законно — правило говорит о службе, которой дерево не держит, или о движении человека,

package/assets/defaults/project.sh

@@ -258,24 +258,29 @@ rt_shell_writes_default() {
 # Судится заголовок команды — именно в нём стоит тот путь, куда команда пишет.
 #
 # Исключение — интерпретатор: ему код приходит телом, и путь записи стоит именно там. Признак
-# ошибается в сторону лишнего чтения тела: имя интерпретатора, стоящее в команде где угодно,
-# возвращает разбор тела целиком.
+# читается у той строки, которая тело открыла, а не у всей команды: тело принадлежит команде
+# своего заголовка. Прежде он читался у всего текста разом, и слово из документа отключало
+# вырезание целиком — строка «**Чем проверяется:** `bash projects/…`» в замысле делала запись
+# `plan.md` правкой кода приложения. Гард отбивал тем самым запись того файла, отсутствием
+# которого он же и отказывает.
 rt_shell_paths_default() {
     text="$(printf '%s' "$1" | tr "\"'\`" '   ')"
-    if ! printf '%s' "$text" \
-        | grep -Eq '(^|[|;&(]|[[:space:]])(python3?|node|ruby|perl|php|deno|bun|bash|sh|zsh)([[:space:]]|$)'; then
-        text="$(printf '%s' "$text" | awk '
-            function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
-            tag != "" { if (trim($0) == tag) tag = ""; next }
-            {
-                print
-                if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
-                    t = substr($0, RSTART, RLENGTH)
-                    sub(/^<<-?[ \t]*/, "", t)
-                    tag = t
-                }
-            }')"
-    fi
+    text="$(printf '%s' "$text" | awk '
+        function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
+        tag != "" {
+            if (keep) { print }
+            if (trim($0) == tag) { tag = ""; keep = 0 }
+            next
+        }
+        {
+            print
+            if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
+                t = substr($0, RSTART, RLENGTH)
+                sub(/^<<-?[ \t]*/, "", t)
+                tag = t
+                keep = ($0 ~ /(^|[|;&(]|[ \t])(python3?|node|ruby|perl|php|deno|bun|bash|sh|zsh)([ \t]|$)/)
+            }
+        }')"
 
     # Пути берутся только у тех кусков команды, которые пишут. Прежде брались у всей строки
     # целиком, и команда чтения, сцепленная с записью, отдавала свои пути как цели записи:

package/assets/defaults/turn-map.md

@@ -9,19 +9,17 @@
 
 ## Состояния и обязательные действия
 
-| Состояние                 | Обязательное действие                                  | Ведёт паттерн      |
-| ------------------------- | ------------------------------------------------------ | ------------------ |
-| `просьба-не-разобрана`    | разведка по дереву, затем вопросы                      | `task-flow-start`  |
-| `разбор-закрыт`           | договорённость о продукте либо причина её отсутствия   | `task-flow-start`  |
-| `договорённость-записана` | завести задачу, ветку и папку                          | `task-flow-start`  |
-| `задача-взята`            | написать замысел                                       | `task-flow-start`  |
-| `замысел-записан`         | делать первый этап                                     | `task-flow-start`  |
-| `этап-идёт`               | доделать этап и отметить в ходе работы                 | `task-flow-resume` |
-| `этапы-кончились`         | прогнать набор и открыть PR черновиком                 | `task-flow-close`  |
-| `работа-отдана`           | взять следующую задачу                                 | `task-flow-resume` |
-| `разбор-кончился`         | влить договорённость, привести тексты, разобрать папку | `task-flow-close`  |
-| `папка-разобрана`         | снять черновик и попросить влить                       | `task-flow-archive` |
-| `влито`                   | разбор работы правилами и сверка очереди               | `task-flow-archive` |
+- `просьба-не-разобрана` — разведка по дереву, затем вопросы; ведёт `task-flow-start`
+- `разбор-закрыт` — договорённость о продукте либо причина её отсутствия; ведёт `task-flow-start`
+- `договорённость-записана` — завести задачу, ветку и папку; ведёт `task-flow-start`
+- `задача-взята` — написать замысел; ведёт `task-flow-start`
+- `замысел-записан` — делать первый этап; ведёт `task-flow-start`
+- `этап-идёт` — доделать этап и отметить в ходе работы; ведёт `task-flow-resume`
+- `этапы-кончились` — прогнать набор и открыть PR черновиком; ведёт `task-flow-close`
+- `работа-отдана` — взять следующую задачу; ведёт `task-flow-resume`
+- `разбор-кончился` — влить договорённость, привести тексты, разобрать папку; ведёт `task-flow-close`
+- `папка-разобрана` — снять черновик и попросить влить; ведёт `task-flow-archive`
+- `влито` — разбор работы правилами и сверка очереди; ведёт `task-flow-archive`
 
 Ни у одного состояния обязательное действие не звучит как «ждать». Прогон, разбор владельцем и
 слияние идут без исполнителя и от взгляда быстрее не становятся.
@@ -30,12 +28,10 @@
 
 Способов четыре, и других нет.
 
-| Выход                                              | Чем подтверждается                                              |
-| -------------------------------------------------- | --------------------------------------------------------------- |
-| вопрос владельцу, ответа на который в правилах нет | вопрос задан, и за тот же ход правила читались                  |
-| отказ гарда                                        | отказ назван владельцу, обход не искался                        |
-| заполненное окно там, где сжатия нет               | ход работы дописан, передача написана                           |
-| работа отдана, и следующая начата                  | PR открыт, и по следующей задаче сделано действие, а не сказано |
+- **вопрос владельцу, ответа на который в правилах нет** — вопрос задан, и за тот же ход правила читались
+- **отказ гарда** — отказ назван владельцу, обход не искался
+- **заполненное окно там, где сжатия нет** — ход работы дописан, передача написана
+- **работа отдана, и следующая начата** — PR открыт, и по следующей задаче сделано действие, а не сказано
 
 Там, где дерево объявило порог сжатия ниже порога остановки, заполненное окно ход не кончает:
 контекст сжимается, передача приходит входом, и работа идёт дальше тем же заходом. Порог