@rt-tools/agent-kit 0.16.1 → 0.18.0

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

@@ -0,0 +1,123 @@
+/**
+ * Связь задачи с эпиком. Живёт своим файлом: сверка очереди работ и без неё стоит у предела
+ * длины, а читают эти две проверки порознь.
+ */
+import { existsSync, 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 EPIC_LABEL = CONFIG.board?.epicLabel ?? '';
+
+/**
+ * Строки состава эпика — те, что стоят в таблице с колонкой «Задача».
+ *
+ * Замысел эпика держит и другие таблицы: источники находок, состав семей, счёт пунктов. Номера,
+ * взятые из всего текста и даже из всех таблиц, делали бы задачей эпика всё, что он упомянул, —
+ * прошлый эпик, из находок которого он вырос, разбор, задачу соседнего дерева.
+ */
+function planRows(plan) {
+    const rows = [];
+    let inside = false;
+    for (const line of plan.split('\n')) {
+        const isRow = line.trimStart().startsWith('|');
+        if (!isRow) {
+            inside = false;
+            continue;
+        }
+        if (!inside) {
+            // Граница слова здесь не годится: `\b` знает только латиницу, и с кириллицей она не
+            // совпадает никогда — проверка молчала бы на любом замысле.
+            inside = /\|[^|]*Задача/.test(line);
+            continue;
+        }
+        rows.push(line);
+    }
+    return rows.join('\n');
+}
+
+/**
+ * Связь задачи с эпиком, прочитанная в обе стороны.
+ *
+ * Задача, заведённая под эпик, называет его в теле, а замысел эпика называет её со своей
+ * стороны. Односторонняя привязка выглядит целой ровно так же, как двусторонняя: читатель
+ * приходит то от замысла эпика, то от его карточки, и вторая сторона существует только для одного из
+ * них. Держалась она подражанием — пока тело писали с образца соседней задачи того же эпика,
+ * строка ехала вместе с формой, а задача, заведённая посреди работы находкой, писалась не с
+ * образца.
+ *
+ * Путь к замыслу берётся из тела карточки эпика: называть его она обязана и так, а настройка
+ * каталога завела бы второй источник правды. Путём считается написание с каталогом — голое имя
+ * файла в теле встречается прозой и уводило бы проверку на первое же упоминание. Замысла нет на
+ * диске — это своё расхождение: карточка ссылается в пустоту.
+ *
+ * Судится только открытое, как и вся остальная сверка: закрытая задача эпика — история, и
+ * строку о ней нечем закрыть.
+ */
+export function checkEpicLinks(open, report) {
+    // Метка не названа — карточку эпика отличить от обычной задачи нечем, и проверка молчит.
+    // Молчит именно так, а не «эпиков нет»: дерево без эпиков и дерево, не назвавшее метки,
+    // здесь неразличимы.
+    if (!EPIC_LABEL) {
+        return;
+    }
+
+    const byNumber = new Map(open.map((issue) => [issue.number, issue]));
+    const epics = open.filter((issue) => (issue.labels ?? []).some((label) => label.name === EPIC_LABEL));
+    const listedBy = new Map();
+    // Эпики, состав которых прочитать не вышло. Их задачи обратной стороной не судятся: о
+    // непрочитанном замысле уже сказано своей строкой, и четыре строки «задачи нет в замысле»
+    // рядом с ней говорят о том же промахе ещё раз, называя виноватыми чужие задачи.
+    const unreadable = new Set();
+
+    for (const epic of epics) {
+        const planPath = String(epic.body ?? '').match(/(?:^|[\s(`])([\w.-]+(?:\/[\w.-]+)+\.md)/)?.[1] ?? null;
+        if (planPath === null) {
+            report(`#${epic.number}: карточка эпика не называет путь к замыслу — состав эпика читать негде`);
+            unreadable.add(epic.number);
+            continue;
+        }
+        if (!existsSync(join(ROOT, planPath))) {
+            report(`#${epic.number}: замысла эпика «${planPath}» нет на диске — карточка ссылается в пустоту`);
+            unreadable.add(epic.number);
+            continue;
+        }
+
+        const plan = readFileSync(join(ROOT, planPath), 'utf8');
+        const mentions = planRows(plan).matchAll(new RegExp(`(?:#|${TASK_KEY}-)(\\d+)`, 'g'));
+        const numbers = new Set([...mentions].map((match) => Number(match[1])));
+        for (const number of numbers) {
+            if (number === epic.number || !byNumber.has(number)) {
+                continue;
+            }
+            listedBy.set(number, epic.number);
+            const body = String(byNumber.get(number).body ?? '');
+            if (!new RegExp(`(?:#|${TASK_KEY}-)${epic.number}\\b`).test(body)) {
+                report(
+                    `#${number}: замысел эпика #${epic.number} задачу называет, а её тело эпика — нет. Допиши строку «Задача эпика #${epic.number}, замысел — ${planPath}»`
+                );
+            }
+        }
+    }
+
+    // Обратная сторона: тело назвало эпик, а замысел эпика этой задачи не знает. Читается
+    // это как задача под эпиком, но «взять следующую» её не отдаст никогда.
+    const epicNumbers = new Set(epics.map((issue) => issue.number));
+    for (const issue of open) {
+        if (epicNumbers.has(issue.number)) {
+            continue;
+        }
+        const named = String(issue.body ?? '').match(new RegExp(`эпика?\\s+(?:#|${TASK_KEY}-)(\\d+)`, 'i'))?.[1];
+        if (named === undefined || !epicNumbers.has(Number(named)) || unreadable.has(Number(named))) {
+            continue;
+        }
+        if (listedBy.get(issue.number) !== Number(named)) {
+            report(`#${issue.number}: тело называет эпик #${named}, а в его замысле задачи нет — «взять следующую» её не отдаст`);
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * Вызов клиента хостинга: как его находят, чем подписывают и что считается временным отказом.
+ *
+ * Отделено от работы с очередью работ потому, что предмет здесь другой — не задача и не колонка,
+ * а сам вызов: где взять исполняемый файл, каким токеном его подписать, что читать как «сети
+ * нет» и что повторить. Вместе с очередью это переросло предел длины файла.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+import { CONFIG } from './rt-kit-checks.config.mjs';
+
+const BOARD = CONFIG.board ?? {};
+const BOT_TOKEN_FILE = BOARD.tokenPath ? BOARD.tokenPath.replace(/^~/, homedir()) : '';
+
+/**
+ * `gh` у владельца подменён обёрткой менеджера паролей, и вызов по имени уходит в неё.
+ * Поэтому сначала пробуется настоящий исполняемый файл, и только потом имя из PATH.
+ */
+function ghBinary() {
+    if (process.env.GH_BIN) {
+        return process.env.GH_BIN;
+    }
+    const homebrew = '/opt/homebrew/bin/gh';
+    return existsSync(homebrew) ? homebrew : 'gh';
+}
+
+/**
+ * Токен машинной записи лежит вне репозитория и в вывод не попадает. Его отсутствие — не отказ:
+ * дерево, не назвавшее токена в `board.tokenPath`, работает с очередью учётной записью, под
+ * которой залогинен клиент хостинга.
+ */
+export function botToken() {
+    if (!existsSync(BOT_TOKEN_FILE)) {
+        return null;
+    }
+    const token = readFileSync(BOT_TOKEN_FILE, 'utf8').trim();
+    return token.length > 0 ? token : null;
+}
+
+export class OfflineError extends Error {}
+
+/**
+ * Отказ сети от отказа по существу отличается только текстом: `gh` на оба отвечает
+ * ненулевым кодом. Сюда попадает то, после чего проверять нечем, — а не то, что
+ * проверено и оказалось не так.
+ */
+function isOffline(stderr) {
+    return /dial tcp|no such host|network is unreachable|timeout|TLS handshake|connection refused|Bad credentials|authentication|not logged/i.test(
+        stderr
+    );
+}
+
+/**
+ * Отказ, который проходит сам: хостинг ответил, но не смог.
+ *
+ * Отличается от отказа по существу тем, что повтор его снимает: пятисотые коды, шлюз и его
+ * таймаут. Отказ по праву, по несуществующей записи и по незнакомой колонке сюда не попадают —
+ * они не пройдут и на третий раз, а ждать заставят.
+ */
+function isUnavailable(stderr) {
+    return /HTTP 50[0234]\b|Bad Gateway|Service Unavailable|Gateway Time-?out|Server Error/i.test(stderr);
+}
+
+/** Сколько раз пробовать вызов, который отбит недоступностью хостинга. */
+const TRIES = 3;
+
+/**
+ * Пауза перед следующей попыткой, вдвое длиннее прежней. Синхронная: вызов хостинга здесь тоже
+ * синхронный, и уводить его в обещание пришлось бы вместе со всеми, кто его зовёт.
+ *
+ * Число берётся из окружения ради проб: своей паузы им не нужно, а ждать три секунды на каждый
+ * сценарий они не обязаны.
+ */
+const PAUSE_MS = Number(process.env.RT_GH_RETRY_MS ?? 1000) || 0;
+
+function pause(ms) {
+    if (ms > 0) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+}
+
+export function gh(args, { token } = {}) {
+    const env = { ...process.env };
+    if (token) {
+        env.GH_TOKEN = token;
+    }
+
+    let waited = PAUSE_MS;
+    for (let attempt = 1; ; attempt += 1) {
+        try {
+            return execFileSync(ghBinary(), args, { env, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+        } catch (error) {
+            const stderr = String(error.stderr ?? error.message ?? '');
+            if (error.code === 'ENOENT' || isOffline(stderr)) {
+                throw new OfflineError(stderr.trim() || 'gh недоступен');
+            }
+            // Правило требует двигать колонку тем же движением, что и работу, а хостинг отвечал
+            // недоступностью час подряд: без повтора исполнитель либо крутит вызов руками, либо
+            // оставляет колонку отставшей — и находит это сверка уже после открытия заявки.
+            if (isUnavailable(stderr) && attempt < TRIES) {
+                pause(waited);
+                waited *= 2;
+                continue;
+            }
+            const failure = new Error(stderr.trim() || `gh ${args[0]} завершился с ошибкой`);
+            failure.stderr = stderr;
+            throw failure;
+        }
+    }
+}
+
+export function ghJson(args, options) {
+    return JSON.parse(gh(args, options));
+}
+
+export function graphql(query, options) {
+    return ghJson(['api', 'graphql', '-f', `query=${query}`], options);
+}

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

@@ -0,0 +1,88 @@
+// Пути, которых не слушает конвейер, и заявка, чей вклад целиком под ними.
+//
+// Вынесено из сверки очереди отдельным модулем: разбор образцов конвейера к состоянию борды
+// отношения не имеет и читается сам по себе, а сверка от него росла быстрее предела длины.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { ghJson } from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
+const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
+
+/**
+ * Пути, которых конвейер не слушает: `paths-ignore` у его событий.
+ *
+ * Разбирается построчно, а не разборщиком разметки: у проверки его нет, а список — плоский
+ * перечень строк под одним ключом. Ключей в файле бывает несколько — по событию, — и все они
+ * складываются в один набор: ветка, чей вклад целиком лежит под ними, прогона не создаёт ни на
+ * одном событии.
+ */
+export function ignoredPaths() {
+    if (!HAS_PIPELINE) {
+        return [];
+    }
+
+    const lines = readFileSync(join(ROOT, PIPELINE), 'utf8').split('\n');
+    const found = [];
+    let inside = false;
+
+    for (const line of lines) {
+        if (/^\s*paths-ignore:\s*$/.test(line)) {
+            inside = true;
+            continue;
+        }
+        if (!inside) {
+            continue;
+        }
+        const item = /^\s*-\s+['"]?([^'"\s]+)['"]?\s*$/.exec(line);
+        if (item) {
+            found.push(item[1]);
+            continue;
+        }
+        inside = false;
+    }
+
+    return found;
+}
+
+const IGNORED_PATHS = ignoredPaths();
+
+/** Знаки образца, у которых в выражении своё значение: кроме звёздочек, они значат себя. */
+const escapeForRegExp = (value) => value.replace(/[.+?^${}()|[\]\\-]/g, '\\$&');
+
+/** Подпадает ли путь под образец конвейера: `**` — любой хвост, `*` — кусок имени. */
+function underPattern(path, pattern) {
+    const body = pattern
+        .split('**')
+        .map((piece) => piece.split('*').map(escapeForRegExp).join('[^/]*'))
+        .join('.*');
+
+    return new RegExp(`^${body}$`).test(path);
+}
+
+/**
+ * Вклад заявки целиком лежит под путями, которых конвейер не слушает.
+ *
+ * Такой ветке прогона не будет никогда, и требовать его — то же, что требовать его у ветки без
+ * единого коммита: признак верен по букве и лжёт по существу, а действие, которое он советует,
+ * не исполнимо. Красная строка при этом стоит рядом с настоящими расхождениями и учит
+ * пропускать сверку целиком.
+ *
+ * Состав не прочитать — отвечаем «нет»: молчать наугад дороже одной лишней строки.
+ */
+export function onlyIgnoredPaths(pull, options) {
+    if (!IGNORED_PATHS.length) {
+        return false;
+    }
+
+    let files = [];
+    try {
+        files = ghJson(['pr', 'view', String(pull.number), '--json', 'files'], options).files ?? [];
+    } catch {
+        return false;
+    }
+
+    return files.length > 0 && files.every((file) => IGNORED_PATHS.some((pattern) => underPattern(file.path, pattern)));
+}

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

@@ -10,7 +10,15 @@
  * Нет сети или нет токена — вызовы бросают `OfflineError`, как и остальная работа с хостингом:
  * невозможность спросить расхождением не считается.
  */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
 import { OWNER, REPO, gh } from './board.mjs';
+import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
+
+/** Файл конвейера этого дерева; его нет — путей он не слушает вовсе. */
+const PIPELINE = CONFIG.pushGate?.pipelineFile ?? '';
+export const HAS_PIPELINE = PIPELINE !== '' && existsSync(join(ROOT, PIPELINE));
 
 /**
  * Сколько прогонов завелось на этой вершине.

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

@@ -0,0 +1,66 @@
+/**
+ * Открытые задачи, чьи заголовки сильно совпали.
+ *
+ * Отдельным файлом, а не внутри сверки очереди: у очереди свой предмет — задачи, колонки и
+ * заявки, — а здесь сравнивают слова заголовков между собой. Вместе они переросли предел длины
+ * файла, и делить их по предмету дешевле, чем по числу строк.
+ */
+
+function titleWords(title) {
+    return [
+        ...new Set(
+            String(title)
+                .replace(/^\s*\[[^\]]+\]\s*/, '')
+                .toLowerCase()
+                .split(/[^\p{L}\p{N}]+/u)
+                .filter((word) => word.length > 3)
+        ),
+    ];
+}
+
+/** Доля общих слов, начиная с которой две задачи стоит посмотреть глазами. */
+const TITLE_OVERLAP = 0.6;
+/** Меньше трёх общих слов совпадением не считается: два длинных слова совпадают у любой пары. */
+const TITLE_COMMON_MIN = 3;
+/** Больше скольких задач в группе — это серия эпика, а не дубль. */
+const TITLE_GROUP_MAX = 4;
+
+/**
+ * Открытые задачи, чьи заголовки сильно совпали.
+ *
+ * Печатается строкой сводки, а не отказом: серия однотипных задач эпика — законное состояние
+ * очереди, и отказ отбивал бы работу на каждой такой серии. Дубль же по отдельности исправен —
+ * у обеих задач номер, исполнитель и колонка, — и не находит его ничто: разошлись они словами
+ * заголовка, а совпадают дефектом и признаком закрытия.
+ */
+export function similarTitles(open) {
+    const words = new Map(open.map((issue) => [issue.number, titleWords(issue.title)]));
+    // Задачи сводятся в группы, а не в пары: серия однотипных задач эпика — законное состояние
+    // очереди, и парами она даёт по строке на каждое сочетание, то есть заглушает сама себя.
+    const groups = [];
+
+    for (const issue of open) {
+        const mine = words.get(issue.number);
+        const near = groups.find((group) =>
+            group.some((other) => {
+                const theirs = words.get(other.number);
+                const common = mine.filter((word) => theirs.includes(word)).length;
+                const smaller = Math.min(mine.length, theirs.length);
+
+                return smaller > 0 && common >= TITLE_COMMON_MIN && common / smaller >= TITLE_OVERLAP;
+            })
+        );
+        if (near) {
+            near.push(issue);
+            continue;
+        }
+        groups.push([issue]);
+    }
+
+    // Группа больше предела — это серия однотипных задач, а не дубль: у эпика их бывает
+    // полтора десятка, и строка о них говорит только то, что эпик существует.
+    for (const group of groups.filter((one) => one.length > 1 && one.length <= TITLE_GROUP_MAX)) {
+        const numbers = group.map((issue) => `#${issue.number}`).join(', ');
+        console.log(`check-board: ${numbers} — заголовки сильно совпадают, посмотри, не одна ли это работа: ` + `«${group[0].title}»`);
+    }
+}

package/assets/checks/board.github.mjs

@@ -18,13 +18,16 @@
  * Нет сети или нет токена — это не расхождение, а невозможность проверить:
  * функции возвращают `null`, командный режим печатает `{"offline":true}`.
  */
-import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 
+import { OfflineError, botToken, gh, ghJson, graphql } from './board-gh.mjs';
 import { CONFIG, ROOT } from './rt-kit-checks.config.mjs';
 
+// Наружу клиент уезжает отсюда прежним именем: его зовут у борды три соседних модуля и команды
+// дерева, и переписывать их ради переезда объявления значило бы платить за деление файла дважды.
+export { OfflineError, botToken, gh, ghJson, graphql };
+
 /**
  * Адрес борды и её колонки живут в `.claude/rt-kit/checks.json`: идентификаторы проекта, поля
  * и вариантов выдаёт сам GitHub при заведении борды, и угадать их нельзя. Пустое значение
@@ -69,72 +72,6 @@ if (PROJECT_ID && !TASK_KEY) {
 }
 /** Кого запрашивают на разбор: без ревьювера PR не попадает во входящие владельца. */
 export const REVIEWER = BOARD.reviewer ?? '';
-const BOT_TOKEN_FILE = BOARD.tokenPath ? BOARD.tokenPath.replace(/^~/, homedir()) : '';
-
-/**
- * `gh` у владельца подменён обёрткой менеджера паролей, и вызов по имени уходит в неё.
- * Поэтому сначала пробуется настоящий исполняемый файл, и только потом имя из PATH.
- */
-function ghBinary() {
-    if (process.env.GH_BIN) {
-        return process.env.GH_BIN;
-    }
-    const homebrew = '/opt/homebrew/bin/gh';
-    return existsSync(homebrew) ? homebrew : 'gh';
-}
-
-/**
- * Токен машинной записи лежит вне репозитория и в вывод не попадает. Его отсутствие — не отказ:
- * дерево, не назвавшее токена в `board.tokenPath`, работает с очередью учётной записью, под
- * которой залогинен клиент хостинга.
- */
-export function botToken() {
-    if (!existsSync(BOT_TOKEN_FILE)) {
-        return null;
-    }
-    const token = readFileSync(BOT_TOKEN_FILE, 'utf8').trim();
-    return token.length > 0 ? token : null;
-}
-
-export class OfflineError extends Error {}
-
-/**
- * Отказ сети от отказа по существу отличается только текстом: `gh` на оба отвечает
- * ненулевым кодом. Сюда попадает то, после чего проверять нечем, — а не то, что
- * проверено и оказалось не так.
- */
-function isOffline(stderr) {
-    return /dial tcp|no such host|network is unreachable|timeout|TLS handshake|connection refused|Bad credentials|authentication|not logged/i.test(
-        stderr
-    );
-}
-
-export function gh(args, { token } = {}) {
-    const env = { ...process.env };
-    if (token) {
-        env.GH_TOKEN = token;
-    }
-    try {
-        return execFileSync(ghBinary(), args, { env, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
-    } catch (error) {
-        const stderr = String(error.stderr ?? error.message ?? '');
-        if (error.code === 'ENOENT' || isOffline(stderr)) {
-            throw new OfflineError(stderr.trim() || 'gh недоступен');
-        }
-        const failure = new Error(stderr.trim() || `gh ${args[0]} завершился с ошибкой`);
-        failure.stderr = stderr;
-        throw failure;
-    }
-}
-
-export function ghJson(args, options) {
-    return JSON.parse(gh(args, options));
-}
-
-export function graphql(query, options) {
-    return ghJson(['api', 'graphql', '-f', `query=${query}`], options);
-}
-
 /**
  * Тикеты, стоящие на борде, и элементы борды, тикетами не являющиеся. У каждого тикета —
  * его элемент борды и колонка: переставить задачу можно только по идентификатору элемента,
@@ -189,7 +126,12 @@ export function moveTask(number, status, options) {
 }
 
 export function fetchIssues(state, options) {
-    return ghJson(['issue', 'list', '--state', state, '--limit', '400', '--json', 'number,title,state,assignees,labels'], options);
+    // Тело берётся вместе со списком, а не поштучным вызовом на задачу: связь с эпиком читается
+    // как раз в нём, а четыреста вызовов вида «покажи одну задачу» стоили бы дороже всей сверки.
+    return ghJson(
+        ['issue', 'list', '--state', state, '--limit', '400', '--json', 'number,title,state,assignees,labels,body'],
+        options,
+    );
 }
 
 export function fetchIssue(number, options) {
@@ -237,8 +179,7 @@ export function pullState(ref, options) {
         author: pull.author?.login ?? null,
         reviewers,
         reviewed: reviewers.filter((login) => login !== (pull.author?.login ?? null)).length > 0,
-        // Конфликт приезжает в отданную заявку чужим слиянием, без единого действия её автора:
-        // хостинг считает сливаемость заново после каждой правки главной ветки. Судится только
+        // Конфликт приезжает чужим слиянием, без единого действия автора заявки. Судится только
         // прямое «конфликтует»: `UNKNOWN` означает, что хостинг ещё считает, и читать его как
         // конфликт значило бы отбивать работу на каждой свежей вершине.
         conflicting: pull.mergeable === 'CONFLICTING',
@@ -246,9 +187,30 @@ export function pullState(ref, options) {
 }
 
 /**
- * Вершина берётся вместе с остальным: спросить её потом значило бы второй вызов на каждый PR,
- * а судят по ней и папку задачи, и прогон.
+ * На сколько коммитов ветка заявки позади главной. Гард судит основание в минуту открытия, а
+ * заявка стоит днями: влитого за это время не видит ни он, ни зелёный прогон. Сравнить нечем —
+ * ноль: сверка без доступа отбивала бы работу вместо промаха; без сети летит отказ, как везде.
  */
+export function behindMain(branch, mainBranch, options) {
+    if (!OWNER || !REPO || !branch || !mainBranch) {
+        return 0;
+    }
+    try {
+        const behind = gh(
+            ['api', `repos/${OWNER}/${REPO}/compare/${encodeURIComponent(mainBranch)}...${encodeURIComponent(branch)}`, '--jq', '.behind_by'],
+            options
+        );
+        return Number(String(behind).trim()) || 0;
+    } catch (error) {
+        if (error instanceof OfflineError) {
+            throw error;
+        }
+        return 0;
+    }
+}
+
+/** Вершина берётся вместе с остальным: по ней судят и папку задачи, и прогон, а спросить её
+ * потом значило бы второй вызов на каждый PR. */
 export function fetchOpenPulls(options) {
     return ghJson(
         ['pr', 'list', '--state', 'open', '--limit', '200', '--json', 'number,title,headRefName,headRefOid,isDraft,body,mergeable'],
@@ -256,6 +218,32 @@ export function fetchOpenPulls(options) {
     );
 }
 
+/**
+ * Свои открытые заявки, помеченные конфликтующими. Спрашивается это в минуту, когда берётся
+ * новая работа: пока отданное конфликтует, влить его человек не может, и каждая следующая
+ * заявка прибавляет к очереди ещё одну, которую придётся догонять.
+ *
+ * Свои — значит открытые машинной записью дерева. Дерево, её не назвавшее, не спрашивается
+ * вовсе: `@me` отвечал бы учётной записью, под которой залогинен клиент хостинга, а это чаще
+ * всего владелец, и его заявки исполнителю не чинить.
+ *
+ * Судится только прямое `CONFLICTING`. `UNKNOWN` означает, что хостинг ещё считает сливаемость
+ * — он пересчитывает её после каждой правки главной ветки, — и читать его как конфликт значило
+ * бы отбивать работу на каждой свежей вершине.
+ */
+export function conflictingPulls(options) {
+    if (!BOT) {
+        return null;
+    }
+    const pulls = ghJson(['pr', 'list', '--author', BOT, '--state', 'open', '--limit', '100', '--json', 'number,headRefName,mergeable'], options);
+    if (!Array.isArray(pulls)) {
+        return null;
+    }
+    return pulls
+        .filter((pull) => pull.mergeable === 'CONFLICTING')
+        .map((pull) => ({ number: pull.number ?? null, branch: pull.headRefName ?? '' }));
+}
+
 /** `[<КЛЮЧ>-<номер>]` в начале заголовка — единственная форма номера в названиях */
 export const TITLE_NUMBER = new RegExp(`^\\[${TASK_KEY}-(\\d+)\\]\\s+\\S`);
 /** `<КЛЮЧ>-<номер>-<slug>` — имя ветки, отведённой под задачу */
@@ -447,6 +435,22 @@ if (isEntryPoint && process.argv[2] === 'pr') {
     }
 }
 
+// Свои конфликтующие заявки одной строкой JSON: `{"conflicting":[{"number":…,"branch":…}]}`.
+// Зовёт её гард поставки перед тем, как пустить взятие новой работы. Дерево без машинной записи
+// отвечает пустым списком: спрашивать не о ком.
+if (isEntryPoint && process.argv[2] === 'conflicts') {
+    try {
+        process.stdout.write(`${JSON.stringify({ conflicting: conflictingPulls() ?? [] })}\n`);
+    } catch (error) {
+        if (error instanceof OfflineError) {
+            process.stdout.write('{"offline":true}\n');
+        } else {
+            process.stdout.write(`${JSON.stringify({ error: String(error.message ?? error) })}\n`);
+            process.exit(1);
+        }
+    }
+}
+
 // Перевод колонки правит борду. Токен машинной записи здесь необязателен: не назвавшее его
 // дерево правит борду учётной записью, под которой залогинен клиент хостинга. Требование
 // токена держало бы очередь работ у дерева, машинной записи не заводившего, и у дерева, чью