@rt-tools/agent-kit 0.22.0 → 0.24.0

package/README.md

@@ -358,10 +358,16 @@ npx agent-kit enroll --token <токен>            # положить токе
 | Где | Что нужно |
 | --- | --- |
 | у потребителя | `jq` — его требуют и сами гарды |
-| у потребителя | адрес приёма ключом `intake` в `.claude/rt-kit.json` |
+| у потребителя | адрес приёма ключом `intake` в `.claude/rt-kit.json` — берётся у владельца приёма вместе с кодом приглашения |
 | у потребителя | токен дерева в файле вне дерева, названном ключом `token` |
 | у приёма | заведённое дерево: токен выдаёт его команда и печатает один раз |
 
+Адреса приёма пакет не знает: приём поднимает владелец, и у каждой мастерской он свой.
+Спрашивается он у того же человека, который выдаёт код приглашения, — код и адрес идут парой и
+порознь не работают. Вид адреса — `https://<приём мастерской>`; без TLS команда запрещает обмен у
+себя, не доходя до сети: токен приходит единственным ответом, и по открытому пути его прочитает
+любой. Исключение сделано только для локальной машины.
+
 Признак, которым дерево представляется приёму, считается хешем от адреса его удалённого
 репозитория: адрес по нему не восстанавливается, а у двух рабочих копий одного репозитория он
 один. Репозитория нет — признак называется ключом `tree`.
@@ -420,7 +426,7 @@ PR влит, и вливанием в текущую ветку во всех п
 либо надстройка `.claude/rt-kit/overrides/commands/<имя>.md`. Свою команду дерево заводит файлом
 рядом; файл без шапки раскладки пакет чужим считает и не перезаписывает.
 
-Слешем зовётся и то, что командой не является: скилы — правила, паттерны и скилы без закона из
+Слешем зовётся не только команда: скилы — правила, паттерны и скилы без закона из
 `.claude/skills/` — и конвейеры из `.claude/workflows/`. Что из всего этого разложено и откуда
 взялось, говорят `npx agent-kit list` и `npx agent-kit doctor`.
 

package/assets/checks/board-long-work.github.mjs

@@ -0,0 +1,101 @@
+/**
+ * Работа, которую одним заходом не закрыть: метка карточки против записи в линии работ.
+ *
+ * Своим файлом по той же причине, что и связь с эпиком: сверка очереди работ и без них стоит у
+ * предела длины, а читают эти проверки порознь.
+ *
+ * Помечена такая работа в двух местах, и одна метка без другой лжёт молча: исполнитель открывает
+ * карточку раньше, чем линию работ, а планирует по линии. Карточка без записи обещает
+ * многозаходность, которой линия не знает; запись без метки оставляет карточку выглядеть работой
+ * на один заход — и следующий заход берёт её, рассчитывая закрыть за раз.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { TASK_KEY } from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+/**
+ * Метка многозаходной карточки и каталог линий работ. Не названо любое из двух — связь не
+ * судится вовсе: отличить многозаходную карточку от обычной станет нечем, а каталог линий у
+ * каждого дерева свой.
+ */
+const LONG_LABEL = CONFIG.longWork?.label ?? '';
+const PLANS_DIR = CONFIG.longWork?.plansDir ?? '';
+
+/** Строки линий работ, где стоит слово метки: только они считаются записью о многозаходности. */
+function markedRows() {
+    const dir = join(ROOT, PLANS_DIR);
+    if (!existsSync(dir)) {
+        return null;
+    }
+
+    const rows = [];
+    for (const name of readdirSync(dir).filter((one) => one.endsWith('.md'))) {
+        for (const line of readFileSync(join(dir, name), 'utf8').split('\n')) {
+            if (line.includes(LONG_LABEL)) {
+                rows.push({ file: name, line });
+            }
+        }
+    }
+
+    return rows;
+}
+
+/**
+ * Связь метки с линией работ, прочитанная в обе стороны.
+ *
+ * Записью считается строка, где стоят и слово метки, и номер задачи. Голое упоминание номера не
+ * годится: линия работ называет все свои задачи, и большинство из них однозаходные — обратная
+ * сторона краснела бы на каждой.
+ *
+ * Судится только открытое, как и вся остальная сверка: закрытая задача — история, и строку о ней
+ * нечем закрыть.
+ */
+export function checkLongWork(open, report) {
+    if (!LONG_LABEL || !PLANS_DIR) {
+        return;
+    }
+
+    const rows = markedRows();
+    if (rows === null) {
+        report(`каталога линий работ «${PLANS_DIR}» нет на диске — многозаходную работу сверять не с чем`);
+
+        return;
+    }
+
+    // Номера, названные в помеченных строках. Ключ задачи и решётка читаются оба: линия пишется
+    // человеком, и форма номера в ней от строки к строке разная.
+    const written = new Set();
+    const whereWritten = new Map();
+    for (const row of rows) {
+        for (const match of row.line.matchAll(new RegExp(`(?:#|${TASK_KEY}-)(\\d+)`, 'g'))) {
+            const number = Number(match[1]);
+            written.add(number);
+            if (!whereWritten.has(number)) {
+                whereWritten.set(number, row.file);
+            }
+        }
+    }
+
+    const labelled = new Set(
+        open.filter((issue) => (issue.labels ?? []).some((label) => label.name === LONG_LABEL)).map((issue) => issue.number)
+    );
+
+    for (const number of labelled) {
+        if (!written.has(number)) {
+            report(
+                `#${number}: помечена как «${LONG_LABEL}», а в линиях работ «${PLANS_DIR}» такой строки нет — планируют по линии, а не по карточке`
+            );
+        }
+    }
+
+    // Обратная сторона: линия знает работу многозаходной, а карточка выглядит работой на один
+    // заход — и следующий заход берёт её, рассчитывая закрыть за раз.
+    const byNumber = new Set(open.map((issue) => issue.number));
+    for (const number of written) {
+        if (byNumber.has(number) && !labelled.has(number)) {
+            report(`#${number}: линия работ «${whereWritten.get(number)}» знает её многозаходной, а метки «${LONG_LABEL}» на карточке нет`);
+        }
+    }
+}

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

@@ -65,6 +65,40 @@ export function deployLag(workflow, mainBranch, options) {
     return { sha: run.sha, at: run.at, behind: Number(String(behind).trim()) };
 }
 
+/**
+ * Чем кончилась последняя выкатка: `success`, `failure`, `running` либо `none`, если её не
+ * запускали ни разу.
+ *
+ * Спрашивается отдельно от отставания прода. Отставание считается по последней УСПЕШНОЙ выкатке,
+ * и две разные беды выглядят через него одинаково: выкатку не запускали и выкатка упала. Ведут
+ * они к разному — первую запускают, вторую читают журналом и чинят, — а четыре слияния подряд
+ * уехали поверх поломки, которую принёс первый, и прод простоял почти два часа.
+ *
+ * Идущая выкатка расхождением не считается: она ещё может кончиться успехом.
+ */
+export function lastDeploy(workflow, options) {
+    const runs = gh(
+        [
+            'api',
+            `repos/${OWNER}/${REPO}/actions/workflows/${encodeURIComponent(workflow)}/runs?per_page=1`,
+            '--jq',
+            '[.workflow_runs[] | {status, conclusion, sha: .head_sha, at: .created_at, url: .html_url}] | first // empty',
+        ],
+        options
+    );
+    const last = String(runs).trim();
+    if (!last) {
+        return { verdict: 'none' };
+    }
+
+    const run = JSON.parse(last);
+    if (run.status !== 'completed') {
+        return { verdict: 'running', ...run };
+    }
+
+    return { verdict: run.conclusion === 'success' ? 'success' : 'failure', ...run };
+}
+
 /**
  * Чем кончились прогоны на этой вершине: `success`, если все завершились успехом, `running`,
  * если хоть один ещё идёт, `failure` — если хоть один упал. Прогонов нет вовсе — `none`.

package/assets/checks/board.github.mjs

@@ -213,7 +213,7 @@ export function behindMain(branch, mainBranch, options) {
  * потом значило бы второй вызов на каждый PR. */
 export function fetchOpenPulls(options) {
     return ghJson(
-        ['pr', 'list', '--state', 'open', '--limit', '200', '--json', 'number,title,headRefName,headRefOid,isDraft,body,mergeable'],
+        ['pr', 'list', '--state', 'open', '--limit', '200', '--json', 'number,title,headRefName,headRefOid,isDraft,body,mergeable,baseRefName'],
         options
     );
 }

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

@@ -50,7 +50,8 @@ import {
     taskDirs,
 } from './board.mjs';
 import { onlyIgnoredPaths } from './board-paths.mjs';
-import { HAS_PIPELINE, deployLag, evictedOnHead, headCommittedAt, runsOnHead, verdictOnHead } from './board-runs.mjs';
+import { checkLongWork } from './board-long-work.mjs';
+import { HAS_PIPELINE, deployLag, evictedOnHead, headCommittedAt, lastDeploy, runsOnHead, verdictOnHead } from './board-runs.mjs';
 import { checkEpicLinks } from './board-epics.mjs';
 import { similarTitles } from './board-titles.mjs';
 import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
@@ -195,6 +196,20 @@ function checkHeadRun(pull, options) {
         return;
     }
 
+    // Заявка поверх соседней прогона не получает: рабочий поток слушает заявки в главную ветку и
+    // событий с другой базой не видит. Строка о потерянном событии здесь неверна дважды: событие
+    // не терялось, и перезакрытие его не вернёт — совет исполняется буквально, прогон не
+    // запускается, и на второй попытке поломку начинают искать в хостинге.
+    if (pull.baseRefName && pull.baseRefName !== MAIN_BRANCH) {
+        report(
+            `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет и не будет — ` +
+                `заявка открыта в ветку «${pull.baseRefName}», а рабочий поток слушает заявки в главную; ` +
+                `перенеси базу на «${MAIN_BRANCH}», когда нижняя заявка влита`
+        );
+
+        return;
+    }
+
     report(
         `PR #${pull.number}: на вершине ${pull.headRefOid.slice(0, 8)} прогона нет, а лежит она ${minutes} мин — ` +
             `конвейер события не получил; верни его новым коммитом либо перезакрытием PR ` +
@@ -317,6 +332,7 @@ try {
 
     similarTitles(open);
     checkEpicLinks(open, report);
+    checkLongWork(open, report);
 
     const openNumbers = new Set(open.map((issue) => issue.number));
     const claimed = new Map();
@@ -415,7 +431,8 @@ try {
 // сколько угодно коммитов, и заметить это неоткуда.
 if (!offline && DEPLOY_WORKFLOW) {
     try {
-        const lag = deployLag(DEPLOY_WORKFLOW, MAIN_BRANCH, { token: botToken() ?? undefined });
+        const token = botToken() ?? undefined;
+        const lag = deployLag(DEPLOY_WORKFLOW, MAIN_BRANCH, { token });
         if (lag === null) {
             report(`выкаток по «${DEPLOY_WORKFLOW}» не было ни одной — сравнить прод не с чем`);
         } else if (lag.behind > 0) {
@@ -423,6 +440,17 @@ if (!offline && DEPLOY_WORKFLOW) {
                 `прод отстал от «${MAIN_BRANCH}» на ${lag.behind} коммитов: последняя выкатка — ${lag.sha.slice(0, 8)} от ${String(lag.at).slice(0, 10)}`
             );
         }
+
+        // Отчего прод отстал, отставание не говорит: оно считается по последней УСПЕШНОЙ
+        // выкатке, и «не запускали» с «упала» выглядят через него одинаково. Ведут они к
+        // разному — первую запускают, вторую читают журналом и чинят.
+        const deploy = lastDeploy(DEPLOY_WORKFLOW, { token });
+        if (deploy.verdict === 'failure') {
+            report(
+                `выкатка «${DEPLOY_WORKFLOW}» упала на ${String(deploy.sha).slice(0, 8)} от ${String(deploy.at).slice(0, 10)}: ` +
+                    `главная ветка впереди прода, и слияния поверх уедут туда же — ${deploy.url}`
+            );
+        }
     } catch (error) {
         if (error instanceof OfflineError) {
             console.log(`check-board: прод не сверялся — ${error.message}`);

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

@@ -28,7 +28,7 @@
  */
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, posix } from 'node:path';
 
 import { allowlistOf, CONFIG, ROOT, parseAllowlist } from './rt-kit-checks.config.mjs';
 
@@ -163,7 +163,7 @@ const TREE = treeOfRepo();
  * каталог — оба ищутся по дереву, потому что адрес у них один, а написан он коротко.
  */
 function looksLikePath(candidate) {
-    if (/[*<>{}$|\s]|\.\.\.|…/.test(candidate)) {
+    if (/[*<>{}$|\s()[\]'",;=]|\.\.\.|…/.test(candidate)) {
         return false;
     }
     if (/^(https?:|@|~|\/|-)/.test(candidate) || candidate.includes(':')) {
@@ -187,9 +187,21 @@ function looksLikePath(candidate) {
  * среди каталогов: имя каталога в обзорном документе либы означает каталог рядом, а не
  * каталог в корне.
  */
-function existsInTree(candidate) {
+function existsInTree(candidate, fromDir = '') {
     const bare = candidate.replace(/\/$/, '');
 
+    /**
+     * Относительный адрес принадлежит каталогу документа, а не корню дерева: `../routes.ts` из
+     * `libs/x/shell/src/shell/README.md` — это `libs/x/shell/src/routes.ts`. Без разрешения от
+     * каталога такой адрес ищется по дереву строкой и не находится никогда, то есть проверка
+     * краснеет на каждой ссылке, написанной так, как её пишут в разметке.
+     */
+    if (/^\.{1,2}(\/|$)/.test(bare)) {
+        const resolved = posix.normalize(posix.join(fromDir, bare));
+
+        return resolved.startsWith('..') ? false : existsSync(join(ROOT, resolved));
+    }
+
     if (ROOTED_IN.has(bare.split('/')[0])) {
         return existsSync(join(ROOT, bare));
     }
@@ -260,6 +272,7 @@ function checkIndex(dir) {
 
 function checkDoc(doc, allowed) {
     const lines = readFileSync(join(ROOT, doc), 'utf8').split('\n');
+    const fromDir = posix.dirname(doc);
     let insideFence = false;
 
     lines.forEach((line, index) => {
@@ -276,7 +289,7 @@ function checkDoc(doc, allowed) {
             if (!looksLikePath(candidate) || allowed.has(candidate)) {
                 continue;
             }
-            if (!existsInTree(candidate)) {
+            if (!existsInTree(candidate, fromDir)) {
                 report(doc, index + 1, candidate);
             }
         }
@@ -308,8 +321,14 @@ INDEXED_DIRS.forEach((dir) => checkIndex(dir));
 if (problems.length > 0) {
     console.error(`check-doc-paths: расхождений ${problems.length}\n`);
     problems.forEach((problem) => console.error(`  ${problem}`));
+    // Вариантов три, и третий назван: список известного хранит принятое, а не результаты
+    // сломанной проверки. Прежний текст предлагал вносить в список всё спорное — учил обходу,
+    // который закон о проверяемости запрещает; один разбор дал 51 ложный отказ из 264, каждый
+    // на существующий адрес.
     console.error(
-        `\nЛибо адрес устарел и его надо поправить, либо документ описывает ещё не созданное —\nтогда он вносится в ${ALLOWLIST}.`
+        `\nХодов отсюда три: поправить устаревший адрес; внести имя в ${ALLOWLIST}, если документ` +
+            `\nописывает ещё не созданное; починить саму проверку, если ошибается она, — разобрать` +
+            `\nотказы поимённо и показать разбор владельцу. Спорное в список не вносится.`
     );
 }
 

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

@@ -144,8 +144,14 @@ if (process.argv.includes('--baseline')) {
 const fresh = [...tooLong].filter(([path]) => !known.has(path));
 /** Строка на файл, которого в дереве нет, — устаревшая: иначе список копит мёртвое. */
 const gone = [...known.keys()].filter((path) => !existsSync(join(ROOT, path)));
-/** Файл поделили, а строку оставили: список перестал бы отвечать за то, что в нём стоит. */
-const shrunk = [...known.keys()].filter((path) => !tooLong.has(path) && existsSync(join(ROOT, path)));
+/**
+ * Файл поделили, а строку оставили: список перестал бы отвечать за то, что в нём стоит.
+ * Тяжёлый по знакам файл под предел строк не подпадает, и без второй проверки его запись
+ * читалась бы устаревшей — долг нельзя было бы ни записать, ни оставить.
+ */
+const shrunk = [...known.keys()].filter(
+    (path) => !tooLong.has(path) && !overweight.has(path) && existsSync(join(ROOT, path))
+);
 
 /** Тяжёлое по знакам судится тем же списком известного: один долг на файл, а не два. */
 const heavy = [...overweight].filter(([path]) => !known.has(path) && !tooLong.has(path));

package/assets/checks/check-prose-style.mjs

@@ -39,7 +39,16 @@ const MARKS = [
     [/(?<![а-яёА-ЯЁ])в рамках(?![а-яёА-ЯЁ])/giu, 'назвать отношение прямо: «в», «при», «для»'],
     [/(?<![а-яёА-ЯЁ])на основании(?![а-яёА-ЯЁ])/giu, '«по»'],
     [/(?<![а-яёА-ЯЁ])посредством(?![а-яёА-ЯЁ])/giu, '«через», «командой», «вызовом»'],
-    [/(?<![а-яёА-ЯЁ])данн(ый|ая|ое|ые)(?![а-яёА-ЯЁ])/giu, '«этот» или ничего'],
+    [/(?<![а-яёА-ЯЁ])данн(ый|ая|ое)(?![а-яёА-ЯЁ])/giu, '«этот» или ничего'],
+    // Форма «данные» бывает и существительным, и заменить его нечем: данные стенда — это данные.
+    // Проверяется она поэтому по тому, что стоит следом: местоимением она читается перед словом,
+    // которое сама и определяет. Перечень корней короткий намеренно — распознаётся то, что
+    // встречалось, а ложный отказ здесь дороже пропуска: проверка стоит в наборе гейта пуша, и
+    // красное на слове, которому нет замены, останавливает работу целиком.
+    [
+        /(?<![а-яёА-ЯЁ])данные\s+(требовани|услови|значени|обстоятельств|сведени|фактор|параметр|вопрос|правил|подход|принцип|случа)[а-яё]*/giu,
+        '«эти» или ничего',
+    ],
     [/(?<![а-яёА-ЯЁ])соответствующ(ий|ая|ее|ие)(?![а-яёА-ЯЁ])/giu, 'назвать, чему именно соответствует'],
     [/(?<![а-яёА-ЯЁ])необходимо(?![а-яёА-ЯЁ])/giu, '«надо» или повелительное наклонение'],
     [/(?<![а-яёА-ЯЁ])должен быть (выполнен|произведён|осуществлён)(?![а-яёА-ЯЁ])/giu, 'сказать, кто это делает'],

package/assets/checks/check-reuse.mjs

@@ -137,7 +137,10 @@ if (process.argv.includes('--baseline')) {
 }
 
 const problems = [
-    ...fresh.map((finding) => `${finding.key} — готовое: ${finding.instead}`),
+    // Готовое названо оговоркой намеренно: признак судит тег, а место показа — нет. Замена своего
+    // абзаца отказа на готовый компонент того же экрана закрывает признак и оставляет нарушение
+    // на месте — так починили тринадцать шаблонов сразу. Строка вывода — измерение, а не задание.
+    ...fresh.map((finding) => `${finding.key} — готовое (если место показа верно): ${finding.instead}`),
     ...stale.map((key) => `${key}: значится в ${ALLOWLIST}, а в дереве такого расхождения больше нет — строку поправить или убрать`),
 ];
 

package/assets/checks/check-schema-drift.mjs

@@ -83,6 +83,43 @@ function shadowAddresses(url) {
 // которой нечего смотреть, поломкой не является.
 const SKIP = Number(process.env.RT_SKIP_CODE ?? 7);
 
+/**
+ * Тронула ли ветка хранилище — схему либо каталог миграций.
+ *
+ * Пропуск проверки законен ровно до этой черты. База на машине разработчика бывает погашена
+ * буднично, и отбивать за это пуш документации не за что; но ветка, правившая миграции, без
+ * прогона цепочки уезжает в главную вслепую — и падает не у неё, а на выкатке. Так и упал прод:
+ * пять полей появились в схеме без миграций, часть страниц стала отвечать «не найдено», полчаса
+ * недоступности, чинили откатом. Гейт при этом был зелёным: проверка вернула код пропуска.
+ *
+ * Смотрятся обе стороны — незакоммиченное в рабочем дереве и вклад ветки от главной. Одного
+ * вклада мало: правка, ещё не попавшая в коммит, уходит тем же пушем следом.
+ *
+ * ОТКАЗ В ПОЛЬЗУ РАБОТЫ: нет git, нет главной ветки, вызов упал — считается, что не тронула.
+ * Проверка, отбивающая пуш по своей слепоте, хуже пропуска: чинить в ней нечего.
+ */
+function touchedStorage() {
+    const paths = [CONFIG.schemaFile, CONFIG.migrationsDir].filter(Boolean);
+    if (!paths.length) {
+        return false;
+    }
+
+    const git = (args) => {
+        const out = spawnSync('git', args, { cwd: ROOT, encoding: 'utf8' });
+
+        return out.status === 0 ? (out.stdout ?? '') : '';
+    };
+
+    // Главная ветка берётся удалённой ссылкой: локальная — снимок последнего подтягивания, и
+    // вклад, посчитанный от неё, врёт ровно в ту сторону, где проверка молчит.
+    const main = CONFIG.mainBranch ?? 'main';
+    const base = [`origin/${main}`, main].find((ref) => git(['rev-parse', '--verify', '--quiet', ref]).trim()) ?? '';
+
+    const changed = [git(['status', '--porcelain']), base ? git(['diff', '--name-only', `${base}...HEAD`]) : ''].join('\n');
+
+    return paths.some((one) => changed.split('\n').some((line) => line.includes(one)));
+}
+
 function prisma(args, url) {
     return spawnSync('npx', ['prisma', ...args], {
         cwd: ROOT,
@@ -103,9 +140,7 @@ async function withServiceClient(serviceUrl, run) {
         // Погашенный докер — обычное состояние машины, а не повод не дать запушить
         // документацию.
         if (SERVER_DOWN_CODES.includes(error?.code)) {
-            console.log('check-schema-drift: база недоступна — сверять негде');
-
-            return SKIP;
+            return unavailable('база недоступна');
         }
         throw error;
     }
@@ -117,6 +152,32 @@ async function withServiceClient(serviceUrl, run) {
     }
 }
 
+/**
+ * Ответ на «проверять негде»: пропуск либо отказ — смотря тронула ли ветка хранилище.
+ *
+ * Отказ называет, чем поднять базу. Сказанное только «негде» исполнитель читает как разрешение:
+ * поднимать её он не обязан, а гейт зелёный.
+ */
+function unavailable(why) {
+    if (!touchedStorage()) {
+        console.log(`check-schema-drift: ${why} — сверять негде`);
+
+        return SKIP;
+    }
+
+    console.error(`check-schema-drift: ${why}, а ветка правила схему или миграции — сверять негде, но было чем\n`);
+    console.error(
+        'Цепочка миграций на пустом хранилище — единственное место, где виден их настоящий порядок:\n' +
+            'метку времени ставит момент создания, и миграция из ветки, начатой раньше, встаёт перед той,\n' +
+            'от которой зависит. На развёрнутом хранилище разработчика она ложится, на чистом падает — и\n' +
+            'видно это в первый раз на выкатке.\n\n' +
+            'Подними базу и повтори; когда её под рукой нет, цепочка гоняется на одноразовом контейнере —\n' +
+            'готовые команды в паттерне `git-workflow-migration`.'
+    );
+
+    return 1;
+}
+
 async function main() {
     // Незаданное имя спрашивается отдельно от несуществующего файла. Склеенное с корнем, пустое
     // имя даёт сам корень — а он есть всегда, и проверка шла дальше, будто схема на месте.
@@ -135,9 +196,7 @@ async function main() {
 
     const url = databaseUrl();
     if (!url) {
-        console.log('check-schema-drift: адрес базы не задан — сверять негде');
-
-        return SKIP;
+        return unavailable('адрес базы не задан');
     }
 
     if (PRODUCTION_MARKS.some((mark) => url.includes(mark))) {

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

@@ -175,6 +175,19 @@ const DEFAULTS = {
         workflow: '',
         mainBranch: 'main',
     },
+    /**
+     * Работа, которую одним заходом не закрыть. `label` — метка такой карточки; `plansDir` —
+     * каталог, где живут линии работ. Метка и запись в линии сверяются в обе стороны: одна без
+     * другой лжёт молча, потому что исполнитель открывает карточку раньше, чем линию, а
+     * планирует по линии.
+     *
+     * Не названо любое из двух — связь не судится вовсе: отличить многозаходную карточку от
+     * обычной станет нечем, а каталог линий у каждого дерева свой.
+     */
+    longWork: {
+        label: '',
+        plansDir: '',
+    },
     /** Очередь работ: владелец, репозиторий, борда и учётная запись машинной работы. */
     board: {
         owner: '',

package/assets/checks/signals.mjs

@@ -48,6 +48,46 @@ function readBundle(name) {
     return parseSignals(readFileSync(path, 'utf8'));
 }
 
+/** Признак, ищущий нативный тег: `<input\\b`, `<textarea\\b`, `<select\\b`. */
+const NATIVE_TAG = /^<([a-z]+)\\b$/;
+
+/** Спецзнаки выражения в имени директивы: имя приходит из настройки дерева, а не из кода. */
+function escaped(name) {
+    return name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Директивы своей дизайн-системы вычёркиваются из признаков нативных тегов.
+ *
+ * Источник вида в дереве бывает не один: панель владельца собирается набором кита, публичный
+ * сайт — своей системой, и закон о единообразии разводит их по приложениям. Директива такой
+ * системы стоит на нативном теге ровно так же, как директива кнопки кита, — и признак кнопки её
+ * уже вырезает своим `strip`, а признаки поля, области текста и списка не вырезают ничего: форма,
+ * собранная из готового своего, числится расхождением целиком, пять полей из пяти.
+ *
+ * Список директив называет дерево — ключом `reuse.kitDirectives`. Не назвало — не вырезается
+ * ничего, и дерево с одним источником вида ведёт себя как прежде.
+ */
+export function withKitDirectives(signals, directives) {
+    const names = (directives ?? []).filter(Boolean).map(escaped);
+    if (names.length === 0) {
+        return signals;
+    }
+
+    const alternatives = names.join('|');
+
+    return signals.map((signal) => {
+        const tag = NATIVE_TAG.exec(signal.find ?? '')?.[1];
+        if (!tag || signal.ext !== '.html') {
+            return signal;
+        }
+
+        const own = `<${tag}\\b[^>]*(?:${alternatives})[^>]*>`;
+
+        return { ...signal, strip: signal.strip ? `${signal.strip}|${own}` : own };
+    });
+}
+
 /**
  * Признаки объявленных наборов, а поверх них — свои признаки дерева.
  *
@@ -84,5 +124,5 @@ export function loadSignals(config, root) {
         );
     }
 
-    return [...byKey.values()];
+    return withKitDirectives([...byKey.values()], config.kitDirectives);
 }

package/assets/commands/next-session.md

@@ -54,12 +54,19 @@ git merge-base --is-ancestor HEAD "origin/${RT_MAIN_BRANCH:-main}" && echo вл
 
 ## 4. Приведи дерево к главной ветке
 
-- **Работа по правилу и PR влит** — задача закрыта, ветка больше не нужна:
+- **Работа по правилу и PR влит** — задача закрыта, ветка больше не нужна. Локальная главная
+  двигается до удалённой без перехода на неё:
 
     ```bash
-    git switch "${RT_MAIN_BRANCH:-main}" && git pull --ff-only
+    git fetch origin "${RT_MAIN_BRANCH:-main}:${RT_MAIN_BRANCH:-main}"
     ```
 
+    Рабочее дерево при этом не трогается вовсе, поэтому шаг исполним и тогда, когда в нём лежит
+    незакоммиченное — а лежит оно там по слову самой этой команды, велевшей шагом раньше его не
+    трогать. Переход на главную нужен, только чтобы там работать; уборке он не нужен, а
+    `git pull` на ветке задачи тянет не главную вовсе и отвечает «no such ref was fetched»:
+    ветку к этой минуте уже сняли с удалённого слиянием заявки.
+
 - **Всё остальное** — работа не кончилась, и ветка остаётся местом, где она продолжится:
 
     ```bash
@@ -74,17 +81,21 @@ git merge-base --is-ancestor HEAD "origin/${RT_MAIN_BRANCH:-main}" && echo вл
 Снимаются только влитые в главную: их коммиты есть в ней, и восстанавливать нечего.
 
 ```bash
-git branch --merged "${RT_MAIN_BRANCH:-main}" \
+git branch --merged "origin/${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")"
+for b in $(git branch --no-merged "origin/${RT_MAIN_BRANCH:-main}" --format='%(refname:short)'); do
+    printf '%s: %s коммитов мимо главной\n' "$b" "$(git rev-list --count "origin/${RT_MAIN_BRANCH:-main}..$b")"
 done
 ```
 

package/assets/defaults/gate-map.sh

@@ -175,6 +175,19 @@ skill_for_default() {
                 printf '%s\n' 'git-workflow'
             fi
 
+            # Тело задачи и тело заявки публикуются вызовом клиента и файлом дерева не
+            # становятся: гейт проверял расширение правимого файла и на такой команде молчал.
+            # Читает этот текст человек, и чаще, чем любой файл дерева: владелец прочитал семь
+            # своих задач и две заявки и назвал язык в них нечитаемым, а ни одна проверка об этом
+            # не сообщила. Признака два сразу: вызов клиента и тело в доводах — одного слова о
+            # заявке мало, оно есть в строке любой команды, которая о ней пишет.
+            if { rt_gate_invokes "$target" "(gh|glab)[[:space:]]+(pr|mr|issue)[[:space:]]+(create|edit)" \
+                || rt_gate_invokes "$target" "[^[:space:]]*task:new"; } \
+                && printf '%s' "$target" | grep -qE '(--body|--body-file|--description|-F[[:space:]]*body)'; then
+                printf '%s\n' 'doc-style'
+                printf '%s\n' 'doc-style-human'
+            fi
+
             # Слияние PR — последний момент, когда папку закрытой задачи ещё можно разобрать
             # тем же PR: после слияния сверка очереди её видит, а отвечать за неё уже
             # некому. Требуется ВТОРЫМ слоем, дополнительно к правилу поставки.