@rt-tools/agent-kit 0.10.0 → 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-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/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 'Вошло в #<номер задачи>.'

package/assets/defaults/project.sh

@@ -87,7 +87,8 @@ rt_push_checks_default() {
     [ -x "$root/$RT_HOOKS_TESTS" ] && printf '%s\n' "bash $RT_HOOKS_TESTS"
 
     for check in check-doc-paths check-specs check-file-size check-dupes check-styles \
-        check-lib-layers check-reuse check-schema-drift check-push-gate; do
+        check-lib-layers check-reuse check-schema-drift check-states check-state-next \
+        check-turn-map check-push-gate; do
         [ -f "$root/$RT_CHECKS_DIR/$check.mjs" ] && printf '%s\n' "node $RT_CHECKS_DIR/$check.mjs"
     done
 
@@ -135,9 +136,27 @@ RT_ARCHIVE_DIR="${RT_ARCHIVE_DIR:-docs/archive}"
 # Размер окна захода в токенах и пороги стража. Пусто — стража нет: считать долю не от чего, а
 # выведенный из записи захода размер врал бы — модель записана там без пометки о расширенном
 # окне. Дерево задаёт его в настройке агента, переменной окружения того же имени.
+#
+# Теми же двумя числами задаётся порог, на котором инструмент сжимает контекст сам, — а значит и
+# порог, на котором пишется передача захода. В настройке агента им отвечает пара: размер окна
+# автосжатия и доля в процентах, при которой оно приходит. Разъехавшись, они дают заход, который
+# либо сжимается до того, как передача написана, либо доживает до предела окна. Сведены они или
+# нет — говорит разбор состояния раскладки; здесь у пакета своих значений нет, потому что окно
+# принадлежит дереву, а не ему.
+#
+# Сведёнными считаются не совпавшие числа, а разведённые. Порог сжатия обязан стоять НИЖЕ порога
+# остановки: первым срабатывает то, что заход продолжает, а не то, что его останавливает.
+# Совпавшая пара — гонка, и выигрывает её страж: он стоит на вызове инструмента, а сжатие
+# приходит между ходами. Ровно так заход и вставал на пороге вместо того, чтобы продолжиться
+# сжатым, — при том что сверка обе стороны считала настроенными.
+#
+# Насколько ниже — своё число дерева: сжатие идёт не мгновенно, и разница в один процент
+# требование «ниже» удовлетворяет, а работу не спасает. Запас объявляется, а не выводится
+# разницей.
 RT_WINDOW_TOKENS="${RT_WINDOW_TOKENS:-}"
 RT_WINDOW_WARN_PCT="${RT_WINDOW_WARN_PCT:-40}"
 RT_WINDOW_STOP_PCT="${RT_WINDOW_STOP_PCT:-50}"
+RT_WINDOW_MARGIN_PCT="${RT_WINDOW_MARGIN_PCT:-5}"
 
 # Куда кладётся передача захода. Вне дерева: состояние работы живёт в ходе работы и коммитится,
 # а передача его пересказывает для вставки в новый заход и в историю не едет.
@@ -214,19 +233,52 @@ rt_is_app_code_default() {
 # Список намеренно широк, и цена этого названа: команда чтения, в которой стоит имя
 # интерпретатора, будет отбита наравне с командой правки. Узкий список стоил бы дороже —
 # пропущенная форма записи возвращает обход целиком, а найти её можно только промахом.
+#
+# Перенаправление в пустое устройство и в поток ошибок снимается до разбора: файла оно не
+# пишет, а выглядит как перенаправление в файл. Так глушат вывод команды чтения, и без этого
+# `grep -rn x libs/ 2>/dev/null` судится наравне с записью — правило требуется на чтение, а
+# отбитий, пришедшихся не на правку файла, набирается большинство. Настоящая запись рядом с
+# заглушённым потоком остаётся видной: снимается перенаправление, а не команда целиком.
 rt_shell_writes_default() {
-    printf '%s' "$1" | grep -Eq \
-        '>>?[[:space:]]*[^|&>[:space:]]|\btee\b|\bsed\b[^|]*-i|\bperl\b[^|]*-i|\bpython3?\b|\bnode\b|\bruby\b|\bdd\b[^|]*of=|\bcp\b|\bmv\b|\brm\b|\btouch\b|\btruncate\b|\binstall\b|\bpatch\b|\bgit[[:space:]]+(checkout|restore|apply|stash)\b'
+    printf '%s' "$1" \
+        | sed -E 's#(&|[0-9]*)>>?[[:space:]]*/dev/(null|stderr)##g; s#[0-9]*>&[0-9-]##g' \
+        | grep -Eq \
+            '>>?[[:space:]]*[^|&>[:space:]]|\btee\b|\bsed\b[^|]*-i|\bperl\b[^|]*-i|\bpython3?\b|\bnode\b|\bruby\b|\bdd\b[^|]*of=|\bcp\b|\bmv\b|\brm\b|\btouch\b|\btruncate\b|\binstall\b|\bpatch\b|\bgit[[:space:]]+(checkout|restore|apply|stash)\b'
 }
 
 # Пути, названные командой оболочки. Печатает по одному в строке; судит их зовущий.
 #
 # Разбирать оболочку по-настоящему нечем — здесь и не разбирают: из текста вынимается всё, что
 # похоже на путь, и каждое отдаётся признаку. Лишнее он отсеет сам, а пропущенное вернуло бы
-# обход. Кавычки и heredoc снимаются заменой на пробел: путь внутри них тот же самый.
+# обход. Кавычки снимаются заменой на пробел: путь внутри них тот же самый.
+#
+# Тело документа на месте путей не даёт: там лежит текст, который команда кладёт в файл, а
+# чужой путь, названный в нём словами, требовал бы правила под запись, которой нет. Запись
+# замысла так отбивалась трижды подряд, пока пути под каталогом кода не были названы иначе.
+# Судится заголовок команды — именно в нём стоит тот путь, куда команда пишет.
+#
+# Исключение — интерпретатор: ему код приходит телом, и путь записи стоит именно там. Признак
+# ошибается в сторону лишнего чтения тела: имя интерпретатора, стоящее в команде где угодно,
+# возвращает разбор тела целиком.
 rt_shell_paths_default() {
-    printf '%s' "$1" \
-        | tr "\"'\`(),;=" '        ' \
+    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
+
+    printf '%s' "$text" \
+        | tr "(),;=" '     ' \
         | tr '[:space:]' '\n' \
         | grep -E '^[A-Za-z0-9_@.-]*/[A-Za-z0-9_@./-]+$' \
         | sed 's|^\./||' \

package/assets/defaults/turn-map.md

@@ -0,0 +1,46 @@
+# Карта хода
+
+Это не правило, а его короткая выжимка: правило объясняет, карта называет. Полный текст —
+скил `task-flow`; он же называет паттерн, который ведёт каждое состояние.
+
+Состояние работы объявлено строкой в разделе «Где стоим» хода работы. Пока обязательное
+действие не сделано, работа стоит в том же состоянии.
+
+## Состояния и обязательные действия
+
+| Состояние                 | Обязательное действие                                  | Ведёт паттерн      |
+| ------------------------- | ------------------------------------------------------ | ------------------ |
+| `просьба-не-разобрана`    | разведка по дереву, затем вопросы                      | `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-close`  |
+| `влито`                   | разбор работы правилами и сверка очереди               | `task-flow-close`  |
+
+Ни у одного состояния обязательное действие не звучит как «ждать». Прогон, разбор владельцем и
+слияние идут без исполнителя и от взгляда быстрее не становятся.
+
+## Чем ход кончается
+
+Способов четыре, и других нет.
+
+| Выход                                              | Чем подтверждается                                              |
+| -------------------------------------------------- | --------------------------------------------------------------- |
+| вопрос владельцу, ответа на который в правилах нет | вопрос задан, и за тот же ход правила читались                  |
+| отказ гарда                                        | отказ назван владельцу, обход не искался                        |
+| заполненное окно там, где сжатия нет               | ход работы дописан, передача написана                           |
+| работа отдана, и следующая начата                  | PR открыт, и по следующей задаче сделано действие, а не сказано |
+
+Там, где дерево объявило порог сжатия ниже порога остановки, заполненное окно ход не кончает:
+контекст сжимается, передача приходит входом, и работа идёт дальше тем же заходом. Порог
+остановки там — страховка на случай, когда сжатие не пришло.
+
+Всё остальное — продолжение хода. Ходом не кончаются: коммит, записанный замысел, закрытый
+разбор просьбы, прочитанная договорённость, зелёная проверка, сводка о чужом шаге и объявление
+намерения. Переход из состояния в состояние — тем более: обязательное действие сделано, и
+следующее делается тем же ходом. Названо может быть только сделанное.