@rt-tools/agent-kit 0.5.0 → 0.5.1

package/README.md

@@ -260,6 +260,11 @@ npx agent-kit init --laws access,delivery,verifiability
 `skill-curator` приезжает и слеш-командой: она собирает сводку о задаче и список загруженных
 правил, без которых разбор выродится в пересказ.
 
+Вторая команда, `next-session`, закрывает заход: приводит дерево к главной ветке — переходом на
+неё, если работа шла по правилу и отчёт влит, и вливанием в текущую ветку во всех прочих
+случаях, — снимает влитые локальные ветки, называет невлитые и пишет передачу для следующего
+захода. Незакоммиченная правка её останавливает до первого действия; поставки она не касается.
+
 ## Как этим пользуются в дереве
 
 Всё, что выше, пакет объясняет человеку. Агенту то же самое объясняет скил `agent-kit` —

package/assets/checks/check-doc-paths.mjs

@@ -1,19 +1,28 @@
 #!/usr/bin/env node
 /**
- * Проверка того, что пути, названные в документации, существуют.
+ * Проверка того, что адреса, названные в документации, существуют.
  *
  * Документ, ссылающийся на исчезнувший файл, хуже отсутствующего: он выглядит
  * действующей справкой и уводит читателя в каталог, которого нет. Накапливается
  * это молча — перекладка дерева правит код и ломает текст, а текст никто не
- * собирает. К моменту заведения проверки из 159 путей, названных в `docs/`,
- * не существовало 80.
+ * собирает.
  *
- * Считаются только пути в обратных кавычках и вне блоков кода: в блоках лежат
- * команды и вывод, где `dist/apps/api/main.js` — результат сборки, а не файл
- * репозитория. Шаблоны (`*`, `<…>`, `{…}`) пропускаются: это форма пути, а не путь.
+ * Считаются только адреса в обратных кавычках и вне блоков кода: в блоках лежат
+ * команды и вывод, где путь до собранного — результат сборки, а не файл
+ * репозитория. Шаблоны (`*`, `<…>`, `{…}`) пропускаются: это форма адреса, а не адрес.
  *
- * Документы, которые по устройству говорят о несуществующем — планы будущего и
- * архив, — перечислены в tools/doc-paths-allowlist.json.
+ * Адрес бывает трёх родов, и все три судятся одинаково: укоренённый в дереве путь,
+ * голое имя файла и каталог. Каталогами занята половина таблиц «Где это лежит», и
+ * проверка, знающая только строку с расширением, их не видит вовсе.
+ *
+ * Документы, которые по устройству говорят о несуществующем — планы будущего, архив
+ * и папки задач, — из проверки выведены. Там же переносимый текст: его адреса
+ * принадлежат тому дереву, куда правило ложится, и в этом они примеры, а не ссылки.
+ *
+ * Вторым заходом сверяется полнота указателя каталога: обзорный документ перечисляет
+ * записи таблицей, и читатель ищет по ней, а не обходом. Это обратная сторона той же
+ * договорённости — не только адрес из текста ведёт в файл, но и файл назван в тексте,
+ * по которому его ищут.
  *
  * Ненулевой код возврата и перечень расхождений.
  */
@@ -24,20 +33,47 @@ import { join } from 'node:path';
 import { allowlistOf, CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
 const ALLOWLIST = allowlistOf('doc-paths');
-// `worktrees` — копии репозитория под `.claude/`: их документы описывают раскладку своей
-// ветки, а проверка ищет пути в дереве текущей. Одна брошенная копия дала 73 расхождения и
-// красный сквозной прогон на ветке, которая её не заводила.
+// `worktrees` — копии репозитория под каталогом агента: их документы описывают раскладку
+// своей ветки, а проверка ищет адреса в дереве текущей. Одна брошенная копия дала 73
+// расхождения и красный сквозной прогон на ветке, которая её не заводила.
 const SKIPPED_DIRS = CONFIG.skippedDirs;
 /**
- * Архив описывает раскладку, бывшую на момент записи. Править в нём пути — значит
+ * Архив описывает раскладку, бывшую на момент записи. Править в нём адреса — значит
  * переписывать историю задним числом, поэтому он выведен из проверки целиком.
  */
 const ARCHIVE_DIR = CONFIG.archiveDir;
-/** Расширения, по которым строка в кавычках считается путём, а не именем сущности */
+/**
+ * Папка задачи описывает ход работы, и снятое она называет по имени: раздел находок
+ * перечисляет ровно то, чего в дереве нет. Отличить такое упоминание от ссылки машине
+ * нечем, а живёт папка до слияния — поэтому она выведена из проверки, как архив.
+ */
+const TASKS_DIR = CONFIG.tasksDir.endsWith('/') ? CONFIG.tasksDir : `${CONFIG.tasksDir}/`;
+/**
+ * Каталоги, чей указатель сверяется с содержимым. Каталог, выведенный из проверки адресов,
+ * иначе не судит ничто: запись, приехавшая слиянием соседней ветки, остаётся неназванной, а
+ * читатель ищет по указателю. Сверенный руками указатель расходится снова через сутки.
+ */
+const INDEXED_DIRS = (CONFIG.indexedDirs ?? []).map((dir) => (dir.endsWith('/') ? dir : `${dir}/`));
+/**
+ * Исходники переносимых текстов: правило, которое ложится в другое дерево, называет адреса
+ * того дерева. Разложенная копия узнаётся по шапке, а исходник шапки не несёт — её ставит
+ * раскладка, — поэтому его каталог называется настройкой.
+ */
+const PORTABLE_DIRS = (CONFIG.portableDirs ?? []).map((dir) => (dir.endsWith('/') ? dir : `${dir}/`));
+/** Шапка разложенного файла: версия пакета, ресурс и сумма тела. */
+const STAMP_LINE = /rt-kit\s+v\S+\s+·\s+\S+\s+·\s+[0-9a-f]{12}/;
+/** Шапка встаёт первой строкой тела, а тело начинается после вступления скила. */
+const STAMP_LOOKAHEAD = 12;
+/** Расширения, по которым голое имя считается файлом, а не именем сущности */
 const EXTENSIONS = 'ts|mts|cts|js|mjs|cjs|json|jsonc|scss|css|html|proto|conf|ya?ml|sh|md|sql|txt|xml|svg|webp|png|ico|env|Dockerfile|lock';
-const PATH_IN_BACKTICKS = new RegExp(`\`([^\`\\n]+?\\.(?:${EXTENSIONS}))\``, 'g');
+/**
+ * Берётся любая строка в кавычках: каталог расширения не несёт, и требовать его в самой
+ * выборке значило бы не видеть половину таблиц «Где это лежит». Отсев — в `looksLikePath`.
+ */
+const PATH_IN_BACKTICKS = /`([^`\n]+?)`/g;
 
 const problems = [];
+const indexProblems = [];
 const report = (doc, line, path) => problems.push(`${doc}:${line}: нет файла \`${path}\``);
 
 function readAllowlist() {
@@ -71,9 +107,9 @@ function collectDocs(dir = '.') {
 
 /**
  * Документы, которые в репозиторий не попадут: личный черновик, лежащий в дереве и
- * закрытый `.gitignore` или `.git/info/exclude`. Проверка судит репозиторий, а не рабочий
- * стол того, кто её запустил: мёртвая ссылка в чужом черновике держала гейт пуша, хотя ни
- * в одну ветку этот файл не едет.
+ * закрытый настройкой неотслеживаемого. Проверка судит репозиторий, а не рабочий стол того,
+ * кто её запустил: мёртвая ссылка в чужом черновике держала гейт пуша, хотя ни в одну ветку
+ * этот файл не едет.
  */
 function droppedByGit(docs) {
     if (docs.length === 0) {
@@ -91,12 +127,7 @@ function droppedByGit(docs) {
     return new Set((ignored.stdout ?? '').split('\n').filter(Boolean));
 }
 
-/**
- * Верхний уровень дерева. Проверяются только адреса, укоренённые в нём: `src/index.ts`
- * в правиле означает «любой файл такого вида», а `services/theme/theme.service.ts` —
- * обрывок чужого пути. Ни то, ни другое адресом не является, и требовать их
- * существования значит ловить форму записи вместо ссылки.
- */
+/** Верхний уровень дерева: по нему узнаётся адрес, укоренённый в репозитории */
 const ROOTED_IN = new Set(
     readdirSync(ROOT, { withFileTypes: true })
         .filter((entry) => entry.isDirectory() && !SKIPPED_DIRS.includes(entry.name))
@@ -104,18 +135,138 @@ const ROOTED_IN = new Set(
 );
 
 /**
- * Путь ли это вообще. Отсекается всё, что описывает форму, а не адрес: шаблоны,
- * URL и пакеты npm.
+ * Дерево спрашивается у системы контроля версий, а не обходом каталогов: каталоги агента и
+ * конвейера начинаются с точки, и обход мимо них проходит молча — всё, что в них лежит,
+ * читалось бы как несуществующее. Неотслеживаемое берётся вместе с отслеживаемым: файл,
+ * заведённый этой же веткой и ещё не добавленный, существует ничуть не меньше.
+ */
+function treeOfRepo() {
+    const listed = spawnSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+        cwd: ROOT,
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    const paths = (listed.stdout ?? '').split('\n').filter(Boolean);
+    const files = new Set(paths);
+    const dirs = new Set();
+    const byName = new Map();
+
+    for (const path of paths) {
+        const segments = path.split('/');
+        for (let depth = 1; depth < segments.length; depth += 1) {
+            dirs.add(segments.slice(0, depth).join('/'));
+        }
+        byName.set(segments[segments.length - 1], true);
+    }
+    for (const dir of dirs) {
+        byName.set(dir.split('/').pop(), true);
+    }
+
+    return { files, dirs, byName };
+}
+
+const TREE = treeOfRepo();
+
+/**
+ * Адрес ли это вообще. Отсекается всё, что описывает форму, а не адрес: шаблоны, сетевые
+ * ссылки, имена пакетов, флаги и привязка «путь:символ» — её судит сверка спеков. Дальше
+ * кандидат бывает двух родов: укоренённый в дереве и голое имя. Голым именем зовут и файл, и
+ * каталог — оба ищутся по дереву, потому что адрес у них один, а написан он коротко.
  */
 function looksLikePath(candidate) {
     if (/[*<>{}$|\s]|\.\.\.|…/.test(candidate)) {
         return false;
     }
-    if (/^(https?:|@|~|\/)/.test(candidate)) {
+    if (/^(https?:|@|~|\/|-)/.test(candidate) || candidate.includes(':')) {
+        return false;
+    }
+    // Каталог, который проверка не обходит, она и не судит: там чужое, сборка и служебное
+    if (SKIPPED_DIRS.some((dir) => candidate.startsWith(`${dir}/`))) {
+        return false;
+    }
+    // Начинается с точки и стоит без каталога — род файла, а не файл
+    if (/^\.[^/]+$/.test(candidate)) {
         return false;
     }
 
-    return ROOTED_IN.has(candidate.split('/')[0]);
+    return candidate.includes('/') || new RegExp(`\\.(?:${EXTENSIONS})$`).test(candidate);
+}
+
+/**
+ * Есть ли такой адрес в дереве. Укоренённый спрашивается у файловой системы: он назван
+ * целиком, и промах в нём — промах. Голое имя ищется по дереву целиком — и среди файлов, и
+ * среди каталогов: имя каталога в обзорном документе либы означает каталог рядом, а не
+ * каталог в корне.
+ */
+function existsInTree(candidate) {
+    const bare = candidate.replace(/\/$/, '');
+
+    if (ROOTED_IN.has(bare.split('/')[0])) {
+        return existsSync(join(ROOT, bare));
+    }
+    if (TREE.files.has(bare) || TREE.dirs.has(bare)) {
+        return true;
+    }
+    if (bare.includes('/')) {
+        return [...TREE.files, ...TREE.dirs].some((path) => path.endsWith(`/${bare}`));
+    }
+
+    return TREE.byName.has(bare);
+}
+
+/**
+ * Переносимый текст: разложенный пакетом — по шапке, его исходник — по каталогу из настройки.
+ * Адреса в нём принадлежат тому дереву, куда правило ложится: `libs/common/util` в дереве,
+ * которое зовёт свои корни иначе, — не мёртвая ссылка, а пример. Судить их здесь значит
+ * краснеть на полтораста строк, ни одна из которых не чинится правкой этого дерева.
+ */
+function isPortable(doc) {
+    if (PORTABLE_DIRS.some((dir) => doc.startsWith(dir))) {
+        return true;
+    }
+
+    return readFileSync(join(ROOT, doc), 'utf8')
+        .split('\n', STAMP_LOOKAHEAD)
+        .some((line) => STAMP_LINE.test(line));
+}
+
+/** Из проверки адресов выведены документы, которые по устройству говорят о несуществующем. */
+const isSkipped = (doc) => doc.startsWith(ARCHIVE_DIR) || doc.startsWith(TASKS_DIR) || isPortable(doc);
+
+/**
+ * Полнота указателя каталога: у каждой записи каталога есть строка в таблице, у каждой
+ * строки — запись. Записью считается первое имя в обратных кавычках строки таблицы: во
+ * второй колонке стоит проза, и брать оттуда было бы нечего. Каталог берётся у системы
+ * контроля версий той же выборкой, что и дерево: черновик, закрытый настройкой
+ * неотслеживаемого, в репозиторий не едет и указателю не нужен.
+ */
+function checkIndex(dir) {
+    const index = `${dir}README.md`;
+    if (!existsSync(join(ROOT, index))) {
+        return;
+    }
+
+    const named = new Set(
+        readFileSync(join(ROOT, index), 'utf8')
+            .split('\n')
+            .filter((line) => line.startsWith('|'))
+            .map((line) => line.match(PATH_IN_BACKTICKS)?.[0].replaceAll('`', ''))
+            .filter((name) => name?.endsWith('.md'))
+    );
+    const stored = new Set(
+        [...TREE.files]
+            .filter((path) => path.startsWith(dir) && path.endsWith('.md') && path !== index)
+            .map((path) => path.slice(dir.length))
+    );
+
+    [...stored]
+        .filter((name) => !named.has(name))
+        .sort()
+        .forEach((name) => indexProblems.push(`${index}: запись \`${name}\` лежит в каталоге, но в таблице не названа`));
+    [...named]
+        .filter((name) => !stored.has(name))
+        .sort()
+        .forEach((name) => indexProblems.push(`${index}: строка \`${name}\` названа в таблице, но записи в каталоге нет`));
 }
 
 function checkDoc(doc, allowed) {
@@ -136,27 +287,46 @@ function checkDoc(doc, allowed) {
             if (!looksLikePath(candidate) || allowed.has(candidate)) {
                 continue;
             }
-            if (!existsSync(join(ROOT, candidate))) {
+            if (!existsInTree(candidate)) {
                 report(doc, index + 1, candidate);
             }
         }
     });
 }
 
+/** Расхождение указателя печатается своим списком: чинится оно строкой в таблице, а не молчанием. */
+function reportIndex() {
+    if (indexProblems.length === 0) {
+        return;
+    }
+
+    console.error(`\nуказатель разошёлся с каталогом, расхождений ${indexProblems.length}\n`);
+    indexProblems.forEach((problem) => console.error(`  ${problem}`));
+    console.error(
+        '\nЗапись называется в таблице указателя тем же изменением, которым кладётся:\nчитатель ищет по указателю, а не обходом каталога.'
+    );
+}
+
 const allowlist = readAllowlist();
 const allowedPaths = new Set(allowlist.paths);
-const collected = collectDocs().filter((doc) => !allowlist.files.includes(doc) && !doc.startsWith(ARCHIVE_DIR));
+const collected = collectDocs().filter((doc) => !allowlist.files.includes(doc) && !isSkipped(doc));
 const dropped = droppedByGit(collected);
 const docs = collected.filter((doc) => !dropped.has(doc));
 
 docs.forEach((doc) => checkDoc(doc, allowedPaths));
+INDEXED_DIRS.forEach((dir) => checkIndex(dir));
 
 if (problems.length > 0) {
     console.error(`check-doc-paths: расхождений ${problems.length}\n`);
     problems.forEach((problem) => console.error(`  ${problem}`));
     console.error(
-        `\nЛибо путь устарел и его надо поправить, либо документ описывает ещё не созданное —\nтогда он вносится в ${ALLOWLIST}.`
+        `\nЛибо адрес устарел и его надо поправить, либо документ описывает ещё не созданное —\nтогда он вносится в ${ALLOWLIST}.`
     );
+}
+
+reportIndex();
+
+if (problems.length > 0 || indexProblems.length > 0) {
     process.exit(1);
 }
 

package/assets/checks/check-specs.mjs

@@ -62,14 +62,20 @@ const TEST_ROOTS = CONFIG.sourceRoots;
 const SOURCE_ROOTS = [...CONFIG.sourceRoots, ...(CONFIG.schemaFile ? [CONFIG.schemaFile.split('/')[0]] : [])];
 const SKIPPED_DIRS = CONFIG.skippedDirs;
 
-/** `### SC-BK-03 — заявка на занятые даты` */
-const SCENARIO_HEADING = /^###\s+(SC-([A-Z]{2,4})-(\d{2,3}))\s+—\s+(.+?)\s*$/;
+/**
+ * `### SC-BK-03 — заявка на занятые даты`
+ *
+ * Номер принимается от одной цифры до трёх. Заголовок, не подошедший под шаблон, сценария не
+ * заводит и отказа не даёт: дерево, пронумеровавшее сценарии с единицы, теряло бы первые
+ * девять из них молча — ни в покрытии, ни в долгах, при зелёной сверке.
+ */
+const SCENARIO_HEADING = /^###\s+(SC-([A-Z]{2,4})-(\d{1,3}))\s+—\s+(.+?)\s*$/;
 /** Отметка осознанно непокрытого сценария; причина обязательна */
 const UNCOVERED = /^Не покрыто:\s*\S/;
 /** Тест есть, но проверяет не всё обещанное или идёт другим путём */
 const PARTIAL = /^Покрытие:\s*частичное\s*—\s*\S/;
-/** Упоминание сценария в заголовке теста */
-const SCENARIO_REFERENCE = /\bSC-[A-Z]{2,4}-\d{2,3}\b/g;
+/** Упоминание сценария в заголовке теста; номер той же длины, что и в заголовке сценария */
+const SCENARIO_REFERENCE = /\bSC-[A-Z]{2,4}-\d{1,3}\b/g;
 /** Строка обещания сценария; её продолжения идут с отступом */
 const PROMISE = /^Тогда\s+\S/;
 /**
@@ -229,7 +235,34 @@ function ruleHeadOf(bulletText) {
  * Одно слово в двух смыслах развели именно здесь: «правило» — слой между законом и скилом,
  * а внутри закона живут статьи.
  */
-function checkRuleImplementation(specFile, text, mapFile, heading = '## Правила') {
+/**
+ * Строки таблицы привязок компаньона.
+ *
+ * Компаньон правила держит три таблицы: чем вещи правила названы в этом дереве, где лежат
+ * механизмы и где исполняется каждая статья. Привязки — только третья, и берётся она по имени
+ * раздела, а не по месту в файле. Пока читался весь файл, строки первых двух попадали в список
+ * наравне с настоящими и тут же объявлялись расхождением: статьи с таким текстом в правиле нет
+ * и быть не может. Две трети перечня в дереве были ими, и правильно дописанная строка «Где это
+ * лежит» отвечала отказом.
+ *
+ * У компаньона спека домена раздела нет: там таблица одна, и сужать нечего — такой зовёт без
+ * имени раздела. У правила раздел стоит в образце компаньона, поэтому его отсутствие — отказ:
+ * молча прочесть вместо него весь файл значило бы вернуть тот же дефект.
+ */
+function rowsOfMap(specFile, mapFile, mapHeading) {
+    const text = read(mapFile);
+    if (!mapHeading) {
+        return text.split('\n');
+    }
+    const section = sectionOf(text, mapHeading);
+    if (!section.length) {
+        report(mapFile, `нет раздела \`${mapHeading}\` — привязкам правила негде лежать`);
+    }
+
+    return section;
+}
+
+function checkRuleImplementation(specFile, text, mapFile, heading = '## Правила', mapHeading = '') {
     const bullets = bulletsOf(sectionOf(text, heading));
     if (!bullets.length) {
         report(specFile, `в разделе \`${heading}\` нет ни одного пункта`);
@@ -244,7 +277,7 @@ function checkRuleImplementation(specFile, text, mapFile, heading = '## Прав
     }
 
     const rows = new Map();
-    for (const line of read(mapFile).split('\n')) {
+    for (const line of rowsOfMap(specFile, mapFile, mapHeading)) {
         const cells = line.match(/^\|([^|]+)\|([^|]*)\|\s*$/);
         if (!cells) {
             continue;
@@ -907,6 +940,8 @@ for (const file of walk(CONSTITUTION_DIR, (name) => name.endsWith('.md'))) {
 // Правило — скил с `kind: rule` в шапке. Оно и знает о проекте: имена, пути, связи. Привязка
 // его утверждений к коду живёт в `implementation.md` рядом со скилом.
 const RULE_HEADING = '## Как закон применяется здесь';
+/** Раздел компаньона правила, где лежат привязки; остальные его таблицы называют имена дерева. */
+const MAP_HEADING = '## Где исполняются статьи';
 
 /**
  * Шапка скила — первый блок между `---`. Читается только она: паттерн, который учит заводить
@@ -953,7 +988,7 @@ for (const file of walk('.claude/skills', (name) => name === 'SKILL.md')) {
     } else {
         ruled.add(law);
     }
-    checkRuleImplementation(file, text, `${dirname(file)}/implementation.md`, RULE_HEADING);
+    checkRuleImplementation(file, text, `${dirname(file)}/implementation.md`, RULE_HEADING, MAP_HEADING);
 
     const name = nameOf(head);
     if (name && name !== file.slice('.claude/skills/'.length, -'/SKILL.md'.length)) {

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

@@ -36,6 +36,18 @@ const DEFAULTS = {
     docsDir: 'docs',
     /** Отложенное: про него проверки молчат — оно описывает прошлое, а не дерево. */
     archiveDir: 'docs/archive/',
+    /**
+     * Каталоги, чей указатель сверяется с содержимым: обзорный документ в них перечисляет
+     * записи таблицей, и читатель ищет по ней, а не обходом. Пусто — сверки указателя нет.
+     */
+    indexedDirs: ['docs/archive/'],
+    /**
+     * Каталоги, где лежат исходники переносимых текстов. Такой текст называет адреса того
+     * дерева, куда он ложится, а не того, где написан, — и сверять его с этим деревом значит
+     * краснеть на каждый пример. Разложенную копию проверка узнаёт по шапке сама; сюда
+     * вносится только исходник. Пусто — переносимых текстов дерево не держит.
+     */
+    portableDirs: [],
     /** Где лежат спеки доменов; пусто — их в дереве нет, и сверка спеков не запускается. */
     specsDir: 'docs/specs',
     tasksDir: 'docs/tasks',

package/assets/commands/next-session.md

@@ -0,0 +1,122 @@
+---
+description: Закрытие захода — главная ветка подтянута, влитые ветки сняты, передача написана
+argument-hint: '[пусто | <что дописать в передачу от себя>]'
+---
+
+Закрой заход: приведи дерево к главной ветке, убери влитые ветки и напиши передачу для
+следующего захода. Дописка владельца к передаче: `$ARGUMENTS`
+
+Вызывается **последним действием захода** — после того, как работа закоммичена, а отчёт открыт
+или влит. Команда ничего не мержит, не пушит и не открывает: закрытие захода — уборка, а не
+поставка.
+
+## 1. Прочитай профиль дерева
+
+Имя главной ветки, каталог папок задач и каталог передачи у каждого дерева свои:
+
+```bash
+for profile in .claude/rt-kit/defaults/project.sh .claude/rt-kit/project.sh; do
+    [ -f "$profile" ] && . "$profile"
+done
+printf 'главная: %s · задачи: %s · передача: %s\n' \
+    "${RT_MAIN_BRANCH:-main}" "${RT_TASKS_DIR:-docs/tasks}" "${RT_HANDOFF_DIR:-.claude/handoff}"
+```
+
+Зашивать эти имена в команду нельзя: в первом же дереве, которое зовёт главную ветку иначе,
+уборка уедет не туда.
+
+## 2. Остановись, если в дереве есть незакоммиченное
+
+```bash
+git status --short
+```
+
+Непустой вывод — конец команды. Назови файлы владельцу и не трогай ни веток, ни главной: смена
+ветки уносит правку за собой или отбивается на полпути, а решает, что с ней делать, владелец.
+
+Неотслеживаемый файл — тоже незакоммиченное. Скажи о нём отдельной строкой: он мог остаться от
+работы, которую бросили.
+
+## 3. Пойми, по правилу ли ведётся работа
+
+```bash
+git fetch --prune --quiet
+branch="$(git branch --show-current)"
+```
+
+Работа идёт **по правилу**, если имя ветки несёт номер задачи — это `rt_task_branch_ok` из
+профиля — или если в каталоге папок задач лежит папка с именем ветки. Отчёт **влит**, когда
+коммиты ветки уже есть в удалённой главной:
+
+```bash
+git merge-base --is-ancestor HEAD "origin/${RT_MAIN_BRANCH:-main}" && echo влит || echo 'не влит'
+```
+
+## 4. Приведи дерево к главной ветке
+
+- **Работа по правилу и отчёт влит** — задача закрыта, ветка больше не нужна:
+
+    ```bash
+    git switch "${RT_MAIN_BRANCH:-main}" && git pull --ff-only
+    ```
+
+- **Всё остальное** — работа не кончилась, и ветка остаётся местом, где она продолжится:
+
+    ```bash
+    git merge "origin/${RT_MAIN_BRANCH:-main}"
+    ```
+
+    Конфликт разбирается сейчас, а не в начале следующего захода: назови его владельцу и
+    останови команду до его решения.
+
+## 5. Убери ветки
+
+Снимаются только влитые в главную: их коммиты есть в ней, и восстанавливать нечего.
+
+```bash
+git branch --merged "${RT_MAIN_BRANCH:-main}" \
+    | grep -vE "^\*|^\s*${RT_MAIN_BRANCH:-main}$" \
+    | xargs -r git branch -d
+```
+
+Невлитую ветку **не сноси**. Назови её владельцу вместе с числом коммитов, которых нет в
+главной, — по ним видно, что именно потеряется, если её снести:
+
+```bash
+for b in $(git branch --no-merged "${RT_MAIN_BRANCH:-main}" --format='%(refname:short)'); do
+    printf '%s: %s коммитов мимо главной\n' "$b" "$(git rev-list --count "${RT_MAIN_BRANCH:-main}..$b")"
+done
+```
+
+Мёртвые ссылки на удалённые ветки снял `git fetch --prune` шагом 3.
+
+## 6. Напиши передачу
+
+Что в ней стоит и в какой форме — паттерн `task-flow-handoff`; здесь только место и порядок.
+Файл один на ветку и лежит вне истории дерева:
+
+```bash
+mkdir -p "${RT_HANDOFF_DIR:-.claude/handoff}"
+# файл — ${RT_HANDOFF_DIR:-.claude/handoff}/<ветка>.md
+```
+
+Имя берётся от той ветки, в которой шла работа, — не от той, куда команда перешла шагом 4.
+
+К тому, что требует паттерн, эта команда добавляет своё: что она убрала — снятые ветки,
+состояние главной, оставшееся невлитым. Следующий заход начинается ровно с этого.
+
+Заход, кончившийся ничем, передачу пишет тоже: «пробовали так — не вышло, потому что» стоит
+дороже пустого файла. Дописку владельца из `$ARGUMENTS` вставь своим разделом, не пересказывая.
+
+## 7. Отдай итог
+
+Последней строкой — путь к передаче: владелец вставляет её в новый заход одной вставкой. Перед
+ней: что стало с главной веткой, какие ветки сняты, какие остались невлитыми. Содержание
+передачи не пересказывай — владелец её и так прочитает.
+
+## Чего команда не делает
+
+- не мержит отчёт и не пушит: это поставка, и вслепую она не делается;
+- не сносит невлитую ветку и не трогает папку задачи;
+- не коммитит передачу — она лежит вне дерева намеренно, иначе рядом с ходом работы заводится
+  вторая запись об одном и том же.

package/assets/defaults/gate-map.sh

@@ -51,7 +51,15 @@ skill_for_default() {
     case "$kind" in
         edit)
             case "$target" in
-                # Файлы самого агента правятся без правила: правило на них — это оно само.
+                # Правило и паттерн — такая же договорённость, как спек: обязательные разделы,
+                # утверждение с привязкой, граница между статьёй закона и утверждением правила.
+                # Ветка стоит раньше общего исключения и раньше `*.md`: под исключением текст
+                # правила переписывался без единого требования, а `*.md` увёл бы его в правило
+                # формулировок — оно про слова, не про устройство.
+                */.claude/skills/*.md) printf '%s\n' 'spec-driven' ;;
+
+                # Остальные файлы самого агента правятся без правила: правило на них — это оно
+                # само.
                 */.claude/skills/* | */.claude/agents/* | */.claude/commands/* | */.claude/workflows/*) return 0 ;;
 
                 # Тексты проекта. Спек держит устройство домена, закон — договорённость,
@@ -61,6 +69,18 @@ skill_for_default() {
                 */docs/constitution/*) printf '%s\n' 'spec-driven' ;;
                 *.md) printf '%s\n' 'doc-style' ;;
 
+                # Конфиги линтеров — то же самое, только запреты в них исполняемые: они и есть
+                # исполнение правил про типы и про оформление, а комментарии в них пересказывают
+                # эти правила поимённо. Правились без единого правила под рукой.
+                */eslint.config.mjs | */eslint.config.js) printf '%s\n' 'typescript-conventions' ;;
+                */stylelint.config.js | */stylelint.config.mjs) printf '%s\n' 'styling-bem' ;;
+
+                # Проверка повторов исполняет утверждения правила об общем коде и требуется
+                # только им: правило о раскладке либ говорит про неё одной строкой с отсылкой,
+                # а привязки её признаков стоят при общем коде. Два отказа подряд на правку двух
+                # строк комментария стоят захода, а второе прочитанное правило не пригождается.
+                */tools/check-dupes.mjs | */tools/dupes-allowlist.json) printf '%s\n' 'shared-code' ;;
+
                 # Поставка: состав зависимостей — это то, что приезжает на прод. Правка
                 # скриптов зависимостью не является, и правило про версии на неё не вступает.
                 # Оговорка: удаление зависимости приходит правкой без номера версии и сюда не

package/assets/defaults/project.sh

@@ -77,6 +77,30 @@ RT_TASKS_DIR="${RT_TASKS_DIR:-docs/tasks}"
 # удалить проще, чем разобрать, а слова владельца больше нигде не записаны.
 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_HANDOFF_DIR="${RT_HANDOFF_DIR:-.claude/handoff}"
+
+# Команды, которые проходят после порога остановки: ими заход закрывается. Отбить их значило бы
+# отобрать у него единственный способ закончиться. Вызов считается по началу строки или сразу за
+# разделителем — упоминание команды в тексте командой не является.
+rt_handoff_allowed_cmd_default() {
+    case "$1" in
+        git\ * | *[\;\&\|]\ *git\ * | *\$\(git\ *) return 0 ;;
+        gh\ * | */gh\ * | glab\ * | */glab\ * | az\ * | */az\ *) return 0 ;;
+        *task:move* | *check:* | mkdir\ -p\ * | cat\ * | ls\ *) return 0 ;;
+    esac
+
+    return 1
+}
+
 # Где лежат тексты, которые читают до вопроса владельцу: законы, правила и договорённости о
 # продукте. По ним гард разговора судит, читалось ли за ход хоть что-то, и их же называет в
 # подсказке. Пусто у законов и правил разом — дерево этого требования не получает: читать
@@ -202,3 +226,4 @@ rt_is_app_code() { rt_is_app_code_default "$@"; }
 rt_qa_decorative() { rt_qa_decorative_default "$@"; }
 rt_task_state() { rt_task_state_default "$@"; }
 rt_report_body() { rt_report_body_default "$@"; }
+rt_handoff_allowed_cmd() { rt_handoff_allowed_cmd_default "$@"; }