@rt-tools/agent-kit 0.17.0 → 0.19.0

package/assets/checks/check-hook-scope.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Сверка объявления гарда с тем, что разбирает его тело.
+ *
+ * Гард несёт своё событие и образец вызова сам — строкой `# rt-hook:` во второй строке файла; по
+ * ней его подписывают в настройке агента. Тело при этом умеет больше, чем объявлено: разбирает
+ * имя инструмента, которого в образце нет, — и до этой ветки вызов не доходит никогда. Снаружи
+ * гард выглядит работающим: путь назван, файл разложен, набор сценариев зелёный, потому что зовёт
+ * гард напрямую с подставленным вводом и объявления не читает вовсе.
+ *
+ * Хуже того, расхождение читается как промах дерева. Дерево, подписавшее гард шире объявления,
+ * получает отказ сверки раскладки и сужает подписку до объявления — вместе с расхождением снимая
+ * работавшее покрытие. Чинится это в пакете, а платит за него дерево.
+ *
+ * Что сверяется: имена инструментов из веток `case` по имени инструмента против образца
+ * объявления. Комментарии и тексты отказов не читаются: имя инструмента упоминают и там, а
+ * судится то, на что гард ветвится.
+ *
+ * FAIL-OPEN: каталога хуков нет — сверять нечего, нулевой код.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = process.cwd();
+const HOOKS = join(ROOT, '.claude/hooks');
+
+/** Объявление гарда: событие и образец вызова. */
+const DECLARATION = /^#\s*rt-hook:\s*(\S+)(?:[ \t]+(\S.*))?$/m;
+
+/** Ветка `case` по имени инструмента: `Bash | mcp__webstorm__execute_tool)`. */
+const TOOL_CASE = /^[ \t]*([A-Za-z_][\w-]*(?:__[\w-]+)*(?:[ \t]*\|[ \t]*[A-Za-z_][\w-]*(?:__[\w-]+)*)*)\)/;
+
+/** Имена инструментов, на которые ветвится тело гарда. */
+function branchedTools(text) {
+    const lines = text.split('\n');
+    const tools = new Set();
+    let inside = false;
+
+    for (const line of lines) {
+        const code = line.replace(/^([^#]*)#.*$/, '$1');
+
+        if (/case[ \t]+"?\$(\{)?(tool|RT_HOOK_TOOL)/.test(code) || /case[ \t]+"\$\(rt_hook_tool\)"/.test(code)) {
+            inside = true;
+            continue;
+        }
+
+        if (inside && /^[ \t]*esac\b/.test(code)) {
+            inside = false;
+            continue;
+        }
+
+        if (!inside) {
+            continue;
+        }
+
+        const branch = code.match(TOOL_CASE);
+        if (branch) {
+            for (const name of branch[1].split('|')) {
+                const tool = name.trim();
+                // Звёздочка — ветка «всё остальное», именем инструмента она не является.
+                if (tool && tool !== '*') {
+                    tools.add(tool);
+                }
+            }
+        }
+    }
+
+    return [...tools];
+}
+
+/** Покрывает ли образец объявления это имя инструмента. */
+function covers(matcher, tool) {
+    try {
+        return new RegExp(`^(?:${matcher})$`).test(tool);
+    } catch {
+        // Образец, который не разобрать, — своё расхождение, и молчать о нём нельзя: имя
+        // инструмента под ним не совпадёт ни с чем, а выглядит объявление написанным.
+        return false;
+    }
+}
+
+function main() {
+    if (!existsSync(HOOKS)) {
+        console.log('check-hook-scope: каталога хуков в дереве нет — сверять нечего');
+
+        return 0;
+    }
+
+    const faults = [];
+
+    for (const file of readdirSync(HOOKS).filter((one) => one.endsWith('.sh')).sort()) {
+        const text = readFileSync(join(HOOKS, file), 'utf8');
+        const declared = text.match(DECLARATION);
+        if (!declared || !declared[2]) {
+            continue;
+        }
+
+        const matcher = declared[2].trim();
+        for (const tool of branchedTools(text)) {
+            if (!covers(matcher, tool)) {
+                faults.push(`${file}: тело ветвится на «${tool}», а объявление его не называет`);
+            }
+        }
+    }
+
+    if (faults.length > 0) {
+        console.log(`check-hook-scope: расхождений ${faults.length}\n`);
+
+        for (const fault of faults) {
+            console.log(`  ${fault}`);
+        }
+
+        console.log('\nВетка тела, которой нет в объявлении, не исполняется ни разу: под этим именем гард');
+        console.log('не зовут. Объявление правится в источнике пакета, а не в разложенной копии.');
+
+        return 1;
+    }
+
+    console.log('check-hook-scope: объявления гардов покрывают то, на что ветвятся их тела — сошлось');
+
+    return 0;
+}
+
+process.exit(main());

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

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * Сверка надстроек профиля с таблицами компаньонов.
+ *
+ * Правило говорит одно, а дерево работает по-другому — и оба места законны. Расхождение
+ * объявляется переменной профиля, а читатель ищет его в компаньоне правила, где перечислено, чем
+ * здесь зовётся сказанное правилом. Пока эти два места никто не сравнивает, компаньон обещает
+ * пакетное умолчание там, где дерево давно работает по-своему: правило требовало одной формы
+ * заголовка заявки, дерево замещало её переменной, и гард, читавший форму, номера не доставал
+ * вовсе — сверка номера молча не выполнялась, выглядя сошедшейся.
+ *
+ * Что сверяется: имя каждой переменной профиля, чьё значение разошлось с умолчанием пакета,
+ * против текстов компаньонов правил. Значение не сверяется ни с чем: сказать, верно ли оно,
+ * машине нечем, а назвать замещённое в компаньоне — можно.
+ *
+ * FAIL-OPEN: нет профиля, нет умолчаний, нет каталога правил — сверять нечего, нулевой код.
+ * Дерево вправе не держать ни того, ни другого.
+ *
+ * Ненулевой код возврата и перечень расхождений.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const ROOT = process.cwd();
+const PROFILE = join(ROOT, '.claude/rt-kit/project.sh');
+const DEFAULTS = join(ROOT, '.claude/rt-kit/defaults/project.sh');
+const RULES = join(ROOT, '.claude/skills');
+
+/** Присвоение верхнего уровня: `RT_ИМЯ='значение'` либо `RT_ИМЯ="значение"`. */
+const ASSIGN = /^(RT_[A-Z0-9_]+)=(.*)$/;
+
+/** Умолчание пакета: `RT_ИМЯ="${RT_ИМЯ:-значение}"` — значение берётся из подстановки. */
+const FALLBACK = /^RT_[A-Z0-9_]+="\$\{RT_[A-Z0-9_]+:-(.*)\}"$/;
+
+/** Значение без окружающих кавычек: сравниваются строки, а не их запись. */
+function unquote(text) {
+    const trimmed = text.trim();
+    const paired = trimmed.length > 1 && (trimmed.startsWith("'") || trimmed.startsWith('"')) && trimmed.endsWith(trimmed[0]);
+
+    return paired ? trimmed.slice(1, -1) : trimmed;
+}
+
+/** Карта «имя переменной → значение» по присвоениям верхнего уровня. */
+function valuesOf(path) {
+    const values = new Map();
+
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const assign = line.match(ASSIGN);
+        if (!assign) {
+            continue;
+        }
+
+        const fallback = line.match(FALLBACK);
+        values.set(assign[1], fallback ? unquote(fallback[1]) : unquote(assign[2]));
+    }
+
+    return values;
+}
+
+/** Тексты всех компаньонов правил дерева, склеенные в один: ищется в них имя, а не место. */
+function companionsText() {
+    if (!existsSync(RULES)) {
+        return null;
+    }
+
+    const texts = [];
+
+    for (const rule of readdirSync(RULES, { withFileTypes: true })) {
+        if (!rule.isDirectory()) {
+            continue;
+        }
+
+        const companion = join(RULES, rule.name, 'implementation.md');
+        if (existsSync(companion)) {
+            texts.push(readFileSync(companion, 'utf8'));
+        }
+    }
+
+    return texts.length > 0 ? texts.join('\n') : null;
+}
+
+/**
+ * Набор гейта пуша, собранный оболочкой: с надстройкой дерева и без неё.
+ *
+ * Собирается вызовом, а не чтением текста: набор — функция, и она смотрит на дерево — есть ли
+ * настройка раскладки, лежит ли конфиг оформления, исполним ли набор сценариев. Прочитанный
+ * текстом, он назвал бы командами то, чего в этом дереве нет вовсе.
+ *
+ * Пусто — собрать нечем: нет оболочки, нет функции, отказ вызова. Сверять тогда нечего.
+ */
+function gateSet(withProfile) {
+    const source = withProfile ? `. '${DEFAULTS}'; . '${PROFILE}';` : `. '${DEFAULTS}';`;
+    const run = spawnSync('bash', ['-c', `${source} command -v rt_push_checks >/dev/null 2>&1 || exit 9; rt_push_checks ''`], {
+        cwd: ROOT,
+        encoding: 'utf8',
+    });
+
+    return run.status === 0 && typeof run.stdout === 'string' ? run.stdout.split('\n').filter(Boolean) : null;
+}
+
+/**
+ * Проверки, названные в наборе, — по имени файла, а не по всей строке команды.
+ *
+ * Строка целиком сверке не годится: дерево вправе позвать ту же проверку другим запускателем или
+ * с другим доводом, и расхождением это не является. Пропажа самой проверки — является.
+ */
+function checksIn(lines) {
+    const names = new Set();
+
+    for (const line of lines) {
+        for (const [word] of line.matchAll(/[\w./-]+\.(?:mjs|sh)/g)) {
+            names.add(basename(word));
+        }
+    }
+
+    return names;
+}
+
+/**
+ * Проверки, которые умолчание пакета зовёт, а набор дерева — нет.
+ *
+ * Набор гейта собирается умолчанием и надстройкой, и надстройка вправе объявить функцию заново.
+ * Выкушенная так проверка ничем не отличима от проверки, которой в дереве нет вовсе: гейт зелен,
+ * потому что её никто не звал, а сводка раскладки о наборе не знает ничего — она сличает
+ * переменные, а тут заменена функция.
+ *
+ * Отказ в пользу работы: собрать набор нечем — строк нет, и сверка идёт дальше своим делом.
+ */
+function cutFromGate() {
+    const packaged = gateSet(false);
+    const here = gateSet(true);
+    if (packaged === null || here === null) {
+        return [];
+    }
+
+    const mine = checksIn(here);
+
+    return [...checksIn(packaged)].filter((name) => !mine.has(name)).sort((first, second) => first.localeCompare(second, 'ru'));
+}
+
+function main() {
+    if (!existsSync(PROFILE) || !existsSync(DEFAULTS)) {
+        console.log('check-profile-drift: профиля дерева или умолчаний пакета нет — сверять нечего');
+
+        return 0;
+    }
+
+    const companions = companionsText();
+    if (companions === null) {
+        console.log('check-profile-drift: компаньонов правил в дереве нет — сверять не с чем');
+
+        return 0;
+    }
+
+    const cut = cutFromGate();
+    if (cut.length > 0) {
+        console.log(`check-profile-drift: набор гейта пуша не зовёт проверок умолчания: ${cut.length}\n`);
+
+        for (const name of cut) {
+            console.log(`  ${name}`);
+        }
+
+        console.log('\nНабор гейта собирается умолчанием пакета и надстройкой дерева. Проверка, выкушенная');
+        console.log('надстройкой, ничем не отличима от проверки, которой в дереве нет: гейт зелен потому,');
+        console.log('что её никто не звал. Верни её в набор либо объясни отказ в компаньоне правила поставки.');
+
+        return 1;
+    }
+
+    const defaults = valuesOf(DEFAULTS);
+    const profile = valuesOf(PROFILE);
+    const overridden = [...profile].filter(([name, value]) => !defaults.has(name) || defaults.get(name) !== value);
+    const unnamed = overridden.filter(([name]) => !companions.includes(name));
+
+    if (unnamed.length > 0) {
+        console.log(`check-profile-drift: замещено ${overridden.length}, не названо компаньоном ${unnamed.length}\n`);
+
+        for (const [name, value] of unnamed) {
+            console.log(`  ${name} = ${value.length > 60 ? `${value.slice(0, 57)}…` : value}`);
+        }
+
+        console.log('\nЗамещённое читают в компаньоне правила: там перечислено, чем здесь зовётся сказанное');
+        console.log('правилом. Не названное там, оно оставляет читателю пакетное умолчание вместо того, по');
+        console.log('чему дерево работает на самом деле.');
+
+        return 1;
+    }
+
+    console.log(`check-profile-drift: замещено ${overridden.length}, все названы компаньонами — сошлось`);
+
+    return 0;
+}
+
+process.exit(main());

package/assets/checks/check-specs.mjs

@@ -17,7 +17,7 @@
  *    владельца, а четырём незаведённым механикам скидок привязки не нашлось бы
  *    вовсе. Ключ связи — сам текст правила, поэтому переформулировать его, забыв
  *    поправить привязку, нельзя. Правило без привязки — намерение, и писать его
- *    надо как `Q-N`.
+ *    надо как открытый вопрос закона — `Q-<буква закона>-<номер>`.
  *
  * 2. КОНТРАКТ ПРОТИВ ДЕКОРАТОРОВ. Таблица процедур сверяется с тем, что
  *    объявлено в `*.procedure.ts` домена: `@RequiresPermission` / `@PublicProcedure`

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

@@ -185,6 +185,19 @@ const DEFAULTS = {
         bot: '',
         tokenPath: '',
         reviewer: '',
+        /**
+         * Метка карточки эпика. По ней сверка находит эпики и сверяет их связь с задачами в обе
+         * стороны. Слово у каждого дерева своё, общего умолчания нет: не названа — связь не
+         * судится вовсе, потому что отличить карточку эпика от обычной задачи станет нечем.
+         */
+        epicLabel: '',
+        /**
+         * Метки, которыми в очереди работ помечен груз — присланные деревьями разборы и
+         * предложения. Задачами они не судятся вовсе: заголовка с номером, исполнителя и места
+         * на борде у них нет и не будет. Слово у каждого дерева своё, общего умолчания нет:
+         * пусто — сверка судит как прежде.
+         */
+        cargoLabels: [],
     },
 };
 

package/assets/checks/spec-anchors.mjs

@@ -140,7 +140,7 @@ function checkRuleImplementation(specFile, text, mapFile, heading = '## Прав
             report(
                 mapFile,
                 `правило без привязки: «${head.slice(0, 60)}…» — допиши строку с \`файл:символ\`, ` +
-                    'вердиктом «Не исполняется» с причиной либо перенеси правило в «Открытые вопросы» как Q-N'
+                    'вердиктом «Не исполняется» с причиной либо перенеси правило в «Открытые вопросы» закона как Q-<буква>-<номер>'
             );
             continue;
         }
@@ -263,7 +263,7 @@ function checkTracedAnchors() {
             report(
                 mapFile,
                 `привязка ведёт в мёртвый код: \`${symbol}\` объявлен в \`${path}\` и больше нигде не встречается — ` +
-                    'либо правило исполняется в другом месте, либо ему место в «Открытых вопросах» как Q-N'
+                    'либо правило исполняется в другом месте, либо ему место в «Открытых вопросах» закона как Q-<буква>-<номер>'
             );
         }
     }

package/assets/defaults/project.sh

@@ -88,7 +88,7 @@ rt_push_checks_default() {
 
     for check in check-doc-paths check-specs check-file-size check-dupes check-styles \
         check-glossary check-lib-layers check-reuse check-schema-drift check-states check-state-next \
-        check-turn-map check-archive-age check-push-gate; do
+        check-turn-map check-archive-age check-profile-drift check-hook-scope check-push-gate; do
         [ -f "$root/$RT_CHECKS_DIR/$check.mjs" ] && printf '%s\n' "node $RT_CHECKS_DIR/$check.mjs"
     done
 
@@ -225,122 +225,10 @@ rt_is_app_code_default() {
     esac
 }
 
-# Пишет ли команда оболочки файл. Успех — да, и тогда пути из неё судятся тем же признаком,
-# что и путь из вызова инструмента правки.
-#
-# Гарды подписаны на инструменты правки файла, и этого мало: ту же правку кладут командой —
-# перенаправлением, `tee`, `sed -i`, интерпретатором с heredoc. Отбитая правка дважды за один
-# заход легла именно так, и не увидел этого никто: в дереве она неотличима от положенной
-# инструментом. Разбор — `2026-08-15-guard-denied-shell-wrote-anyway.md`.
-#
-# Список намеренно широк, и цена этого названа: команда чтения, в которой стоит имя
-# интерпретатора, будет отбита наравне с командой правки. Узкий список стоил бы дороже —
-# пропущенная форма записи возвращает обход целиком, а найти её можно только промахом.
-#
-# Перенаправление в пустое устройство и в поток ошибок снимается до разбора: файла оно не
-# пишет, а выглядит как перенаправление в файл. Так глушат вывод команды чтения, и без этого
-# `grep -rn x libs/ 2>/dev/null` судится наравне с записью — правило требуется на чтение, а
-# отбитий, пришедшихся не на правку файла, набирается большинство. Настоящая запись рядом с
-# заглушённым потоком остаётся видной: снимается перенаправление, а не команда целиком.
-#
-# Стрелка снимается там же и по той же причине. `->` и `=>` в оболочке не значат ничего, а знак
-# в них тот же: команда, печатавшая таблицу «путь -> правило», объявлялась пишущей и отдавала
-# все свои пути под суд. Туда же закрывающая скобка комментария разметки.
-#
-# Цель перенаправления сужена до знаков, из которых собирают пути. Строка цитаты разметки —
-# знак и слово через пробел — от записи в файл одним знаком неотличима, и различает их только
-# цель: за настоящим знаком стоит путь, а не слово словами. Цена названа прямо: путь, набранный
-# не латиницей, записью больше не считается — в дереве таких нет ни одного, а появятся, признак
-# придётся расширить.
-rt_shell_writes_default() {
-    printf '%s' "$1" \
-        | sed -E 's#(&|[0-9]*)>>?[[:space:]]*/dev/(null|stderr)##g; s#[0-9]*>&[0-9-]##g; s#[-=]+>##g' \
-        | grep -Eq \
-            '>>?[[:space:]]*[A-Za-z0-9_./~$"'"'"'-]|\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'
-}
-
-# Пути, названные командой оболочки. Печатает по одному в строке; судит их зовущий.
-#
-# Разбирать оболочку по-настоящему нечем — здесь и не разбирают: из текста вынимается всё, что
-# похоже на путь, и каждое отдаётся признаку. Лишнее он отсеет сам, а пропущенное вернуло бы
-# обход. Кавычки снимаются заменой на пробел: путь внутри них тот же самый.
-#
-# Тело документа на месте путей не даёт: там лежит текст, который команда кладёт в файл, а
-# чужой путь, названный в нём словами, требовал бы правила под запись, которой нет. Запись
-# замысла так отбивалась трижды подряд, пока пути под каталогом кода не были названы иначе.
-# Судится заголовок команды — именно в нём стоит тот путь, куда команда пишет.
-#
-# Исключение — интерпретатор: ему код приходит телом, и путь записи стоит именно там. Признак
-# читается у той строки, которая тело открыла, а не у всей команды: тело принадлежит команде
-# своего заголовка. Прежде он читался у всего текста разом, и слово из документа отключало
-# вырезание целиком — строка «**Чем проверяется:** `bash projects/…`» в замысле делала запись
-# `plan.md` правкой кода приложения. Гард отбивал тем самым запись того файла, отсутствием
-# которого он же и отказывает.
-rt_shell_paths_default() {
-    text="$(printf '%s' "$1" | tr "\"'\`" '   ')"
-    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]|$)/)
-            }
-        }')"
-
-    # Пути берутся только у тех кусков команды, которые пишут. Прежде брались у всей строки
-    # целиком, и команда чтения, сцепленная с записью, отдавала свои пути как цели записи:
-    # `python3 <<PY … PY` рядом с `grep -n … projects/…` отбивался за правку кода, которой в нём
-    # не было. Отбитий, пришедшихся не на правку файла, набиралось большинство, и цену платил
-    # тот, кто просто читал соседний файл в той же строке.
-    #
-    # Кусок — строка верхнего уровня, а внутри неё `;`, `&&` и `||`. Тело heredoc от своей
-    # команды не отрывается: оно едет вместе с ней одним куском, потому что путь записи
-    # интерпретатора стоит именно там.
-    printf '%s' "$text" | awk '
-        function trim(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); return s }
-        function flush(  n, i, part) {
-            if (chunk == "") { return }
-            if (tag != "") { part = chunk; gsub(/\n/, " ", part); print part; chunk = ""; return }
-            n = split(chunk, parts, /;|&&|\|\|/)
-            for (i = 1; i <= n; i++) { print parts[i] }
-            chunk = ""
-        }
-        tag != "" {
-            chunk = chunk "\n" $0
-            if (trim($0) == tag) { flush(); tag = "" }
-            next
-        }
-        {
-            chunk = $0
-            if (match($0, /<<-?[ \t]*[A-Za-z_][A-Za-z0-9_]*/)) {
-                t = substr($0, RSTART, RLENGTH)
-                sub(/^<<-?[ \t]*/, "", t)
-                tag = t
-                next
-            }
-            flush()
-        }
-        END { if (chunk != "") { part = chunk; gsub(/\n/, " ", part); print part } }
-    ' \
-        | while IFS= read -r piece; do
-            [ -z "$piece" ] && continue
-            rt_shell_writes "$piece" || continue
-            printf '%s' "$piece" \
-                | tr "(),;=" '     ' \
-                | tr '[:space:]' '\n' \
-                | grep -E '^[A-Za-z0-9_@.-]*/[A-Za-z0-9_@./-]+$' \
-                | sed 's|^\./||'
-        done \
-        | sort -u
-}
+# Разбор команды оболочки — пишет ли она и какие пути называет — живёт соседним файлом:
+# вдвоём с ним профиль перерастал предел длины, а читают эти две функции порознь.
+# shellcheck disable=SC1090
+[ -f "$(dirname "${BASH_SOURCE[0]}")/shell.sh" ] && . "$(dirname "${BASH_SOURCE[0]}")/shell.sh"
 
 # Имя ветки, с которой разрешено открывать заявку на слияние: в имени стоит номер задачи.
 # Приставка — либо род правки, либо метка очереди работ: обе формы носят номер, а он и нужен.
@@ -438,6 +326,21 @@ rt_pull_state_default() {
     printf '%s' "$state"
 }
 
+# Свои открытые заявки, помеченные конфликтующими, — по строке на заявку: «#номер ветка».
+# Спрашивает того же помощника очереди работ, что и два соседа выше. Пусто на выходе значит
+# «конфликтующих нет», отказ кода возврата — «спросить некого», и ярус гарда пропускается:
+# отбивать работу на молчании сети значило бы останавливать её всякий раз, когда её не с чем
+# сверить.
+rt_conflicting_pulls_default() {
+    command -v node >/dev/null 2>&1 || return 1
+    command -v jq >/dev/null 2>&1 || return 1
+    [ -f "${RT_BOARD_HELPER:-tools/board.mjs}" ] || return 1
+    state="$(node "${RT_BOARD_HELPER:-tools/board.mjs}" conflicts 2>/dev/null)" || return 1
+    [ -z "$state" ] && return 1
+    printf '%s' "$state" | jq -e 'has("conflicting")' >/dev/null 2>&1 || return 1
+    printf '%s' "$state" | jq -r '.conflicting[]? | "#\(.number) \(.branch)"'
+}
+
 # Что в этом дереве считается переизобретением. По строке «образец<таб>чем заменить».
 # Образцы узкие намеренно: гард сверяет только НОВЫЙ текст, и широкий образец отбивал бы
 # правку, которая ничего нового не заводит.
@@ -494,5 +397,6 @@ rt_kit_sources_dir() { rt_kit_sources_dir_default "$@"; }
 rt_qa_decorative() { rt_qa_decorative_default "$@"; }
 rt_task_state() { rt_task_state_default "$@"; }
 rt_pull_state() { rt_pull_state_default "$@"; }
+rt_conflicting_pulls() { rt_conflicting_pulls_default "$@"; }
 rt_report_body() { rt_report_body_default "$@"; }
 rt_handoff_allowed_cmd() { rt_handoff_allowed_cmd_default "$@"; }