fullstack-gates 0.1.0

package/scripts/check-write-path.ts

@@ -0,0 +1,265 @@
+/**
+ * `bun run check:write-path` — доходит ли действие ЭКРАНА до сервера.
+ *
+ * ПРАВИЛО: **у каждого пишущего эндпоинта сервера есть вызывающий в клиенте, либо он объявлен
+ * долгом.** Экран, который показывает «готово» и ничего не отправляет, — это молчаливый успех,
+ * самая дорогая разновидность вранья в этом проекте: приложение выглядит рабочим ровно до того
+ * момента, как кто-то перезагрузит страницу.
+ *
+ * ПОЧЕМУ ГЕЙТ, А НЕ ЗАМЕТКА. Нашёл это не тест и не ревью, а владелец: создал круг «тест» и не
+ * увидел его. Ни один уровень поймать не мог — юнит и интеграция проверяют СЕРВЕР (49 пишущих
+ * эндпоинтов, все покрыты), приёмка и e2e ходят по экранам и сверяют РАЗМЕТКУ. Между доказанным
+ * сервером и проверенной разметкой лежит провод, которого нет, и не проверял его никто.
+ *
+ * ЧТО СЧИТАЕТСЯ. Слева — пишущие методы в роутах слайсов, приведённые к
+ * полному пути через `prefix` их Elysia-группы. Справа — все `fetch(...)` клиента с методом, отличным
+ * от GET. Путь клиента нормализуется: `${id}` и прочая подстановка становится `:id`, query
+ * отбрасывается.
+ *
+ * РЕЖИМ ХРАПОВИКА, как у `check:proto` и `check:core-drift`. Неподключённый эндпоинт, не объявленный
+ * в `scripts/write-path.allow`, роняет прогон. Запись, которая больше не нужна (эндпоинт подключили),
+ * роняет тоже: список, который нельзя сократить, за месяц превращается в фольклор.
+ *
+ * ЧЕГО ГЕЙТ НЕ ДЕЛАЕТ. Он не проверяет, что вызов ПРАВИЛЬНЫЙ — тело, заголовки, обработку отказа.
+ * Это работа приёмочного сценария. Здесь проверяется единственное и самое грубое: провод есть или
+ * его нет.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+/**
+ * Корень РЕПЫ, а не скрипта.
+ *
+ * Скрипт живёт в плагине и запускается из репы (`bun run "$CLAUDE_PLUGIN_ROOT/assets/scripts/…"`),
+ * поэтому свой собственный путь корнем быть не может: он указал бы внутрь плагина, гейт обошёл бы
+ * чужое дерево и объявил «нарушений нет» — зелёный на пустоте. Рабочий каталог задаёт `bun run`,
+ * и он всегда корень пакета; путь скрипта остаётся запасным для случая, когда файл всё-таки
+ * скопирован в репу.
+ */
+const ROOT = existsSync(join(process.cwd(), "package.json"))
+  ? resolve(process.cwd())
+  : resolve(import.meta.dir, "..");
+const ALLOW_FILE = join(ROOT, "scripts/write-path.allow");
+const write = Bun.argv.includes("--write");
+
+/**
+ * Где искать. Раскладка бывает разной (монорепо `packages/`+`apps/`, одиночный `src/`), поэтому
+ * берутся все существующие, а не одна угаданная, — то же правило, что у `check:proto`.
+ *
+ * Клиент ищется КАТАЛОГОМ, а не списком приложений: `apps/<любое>/src/client` и `src/client`. Не
+ * нашлось ни одного — это отказ ниже, а не пустой зелёный прогон.
+ */
+const SERVER_ROOTS = ["packages", "apps", "src", "server"];
+const CLIENT_DIR_NAME = "client";
+
+const files: string[] = [];
+function walk(dir: string, keep: (p: string) => boolean) {
+  if (!existsSync(dir)) return;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", "dist", "build", ".turbo"].includes(entry.name)) continue;
+      walk(full, keep);
+    } else if (keep(full)) files.push(full);
+  }
+}
+
+/* ─────────────────────── что сервер умеет писать ─────────────────────── */
+
+const routeFiles: string[] = [];
+for (const dir of SERVER_ROOTS) {
+  const before = files.length;
+  walk(join(ROOT, dir), (p) =>
+    /features\/[^/]+\/server\/routes\.ts$/.test(p.split("\\").join("/"))
+  );
+  routeFiles.push(...files.slice(before));
+}
+
+type Endpoint = { method: string; path: string; file: string; line: number };
+const endpoints: Endpoint[] = [];
+
+for (const file of routeFiles) {
+  const rel = relative(ROOT, file).split("\\").join("/");
+  // Комментарии вырезаются ДО поиска — по той же причине, что и в `check:proto`: файл, который
+  // ОБЪЯСНЯЕТ отсутствующий `.post`, содержит эту строку и выглядел бы эндпоинтом.
+  const source = readFileSync(file, "utf8").replace(/\/\*[\s\S]*?\*\//g, (m) =>
+    m.replace(/[^\n]/g, " ")
+  );
+  const lines = source.split("\n");
+
+  /**
+   * Префикс берётся у ГРУППЫ, а не угадывается по имени слайса: `roles/server/routes.ts` держит и
+   * `/roles`, и `/domains`, а `governance-history` — `/governance-changes` и `/proposals`. Имя
+   * файла об этом не говорит ничего.
+   */
+  const prefixes: { line: number; prefix: string }[] = [];
+  lines.forEach((raw, i) => {
+    const m = /new Elysia\(\{\s*prefix:\s*"([^"]*)"/.exec(raw);
+    if (m) prefixes.push({ line: i + 1, prefix: m[1]! });
+  });
+  const prefixAt = (line: number) => {
+    let found = "";
+    for (const p of prefixes) if (p.line <= line) found = p.prefix;
+    return found;
+  };
+
+  /**
+   * Ищем ПО ВСЕМУ тексту, а не построчно: у Elysia вызов и путь почти всегда на разных строках
+   * (`.post(` \n `"/",`). Построчный поиск нашёл бы ноль эндпоинтов и объявил бы, что всё
+   * подключено, — то есть соврал бы ровно в ту сторону, против которой гейт и заведён.
+   */
+  const CALL = /\.(post|put|patch|delete)\(\s*"([^"]*)"/g;
+  let m: RegExpExecArray | null;
+  while ((m = CALL.exec(source)) !== null) {
+    const line = source.slice(0, m.index).split("\n").length;
+    const tail = m[2]!;
+    const full = `${prefixAt(line)}${tail === "/" ? "" : tail}` || "/";
+    endpoints.push({ method: m[1]!.toUpperCase(), path: full, file: rel, line });
+  }
+}
+
+/* ─────────────────────── что клиент действительно зовёт ─────────────────────── */
+
+const clientFiles: string[] = [];
+{
+  const before = files.length;
+  for (const dir of SERVER_ROOTS)
+    walk(join(ROOT, dir), (p) => {
+      const rel = p.split("\\").join("/");
+      return /\.tsx?$/.test(rel) && rel.includes(`/${CLIENT_DIR_NAME}/`);
+    });
+  clientFiles.push(...files.slice(before));
+}
+
+/**
+ * Путь → форма пути. `${…}` в шаблоне и любой сегмент-подстановка становятся `:id`, query
+ * отбрасывается. Иначе `/api/roles/${id}` и `/roles/:id` никогда не совпадут, и гейт объявил бы
+ * долгом весь сервер.
+ */
+const shape = (raw: string): string =>
+  raw
+    .replace(/\?.*$/, "")
+    .replace(/^\/api/, "")
+    .replace(/\$\{[^}]*\}/g, ":id")
+    /**
+     * ИМЯ параметра роута тоже сводится к `:id`, и это не косметика.
+     *
+     * Клиент подставляет значение — `/api/roles/${id}/domains/${domainId}` — и о том, как параметр
+     * назван на сервере, не знает ничего. Сервер объявляет `/roles/:id/domains/:domainId`. Пока
+     * приводилась только клиентская сторона, совпасть могли ТОЛЬКО пути, у которых все параметры
+     * зовутся `:id`; всё остальное — `:kind`, `:contentId`, `:accountabilityId`, `:roleTemplateId` —
+     * не совпадало никогда, то есть числилось долгом даже будучи разведённым. Гейт при этом
+     * оставался зелёным (запись объявлена), и долг не мог убыть — самый тихий вид поломки: гейт,
+     * который нельзя удовлетворить, перестают пытаться удовлетворить.
+     */
+    .replace(/\/:[A-Za-z_$][\w$]*/g, "/:id")
+    .replace(/\/$/, "") || "/";
+
+const called = new Set<string>();
+for (const file of clientFiles) {
+  const source = readFileSync(file, "utf8").replace(/\/\*[\s\S]*?\*\//g, (m) =>
+    m.replace(/[^\n]/g, " ")
+  );
+  /**
+   * Вызов и его метод разнесены по строкам, поэтому берётся ОКНО текста после `fetch(`: путь в
+   * первом аргументе, `method:` — в объекте настроек следом. Окно ограничено, чтобы метод соседнего
+   * вызова не приписался этому.
+   */
+  const re = /fetch\(\s*[`"']([^`"']+)[`"']/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(source)) !== null) {
+    const window = source.slice(m.index, m.index + 400);
+    const method = /method:\s*"(POST|PUT|PATCH|DELETE)"/.exec(window)?.[1];
+    if (method) called.add(`${method} ${shape(m[1]!)}`);
+  }
+}
+
+/* ─────────────────────── сверка и храповик ─────────────────────── */
+
+const declared = existsSync(ALLOW_FILE)
+  ? new Set(
+      readFileSync(ALLOW_FILE, "utf8")
+        .split("\n")
+        .map((l) => l.split("#")[0]!.trim())
+        .filter(Boolean)
+    )
+  : new Set<string>();
+
+/**
+ * Два ключа намеренно. `key` — то, что ЧИТАЕТ человек в отчёте и в файле долга: путь ровно так, как
+ * его объявил роут. `match` — то, по чему идёт сверка: обе стороны, приведённые к одной форме.
+ * Свести их в один значило бы либо потерять читаемость долга (`/circles/:id/:id/:id`), либо
+ * потерять сверку.
+ */
+const key = (e: Endpoint) => `${e.method} ${e.path}`;
+const match = (e: Endpoint) => `${e.method} ${shape(e.path)}`;
+const unconnected = endpoints.filter((e) => !called.has(match(e)));
+const unconnectedKeys = new Set(unconnected.map(key));
+
+if (write) {
+  const body = [
+    "# ЭКРАН НЕ ДОХОДИТ ДО СЕРВЕРА — объявленный ДОЛГ, а не разрешение.",
+    "#",
+    "# Каждая строка — пишущий эндпоинт, у которого в клиенте нет вызывающего. Это значит, что",
+    "# соответствующее действие экрана либо отсутствует, либо показывает успех, ничего не отправив.",
+    "#",
+    "# Список СОКРАЩАЕТСЯ по мере разводки экранов. Запись, которая больше не нужна, роняет гейт:",
+    "# непочищенный список за месяц становится фольклором. Новая строка без разводки — новый долг,",
+    "# и заводить его молча нельзя.",
+    "#",
+    `# Записано ${unconnectedKeys.size} из ${endpoints.length} пишущих эндпоинтов.`,
+    "",
+    ...[...unconnectedKeys].sort(),
+    "",
+  ].join("\n");
+  Bun.write(ALLOW_FILE, body);
+  console.log(`\nбазовая линия записана: ${unconnectedKeys.size} из ${endpoints.length}\n`);
+  process.exit(0);
+}
+
+console.log(`\n=== ПУТЬ ЗАПИСИ: ЭКРАН → СЕРВЕР ===`);
+
+/**
+ * Ноль найденных эндпоинтов — это НЕ «всё подключено». Это гейт, который не отработал: переехавшая
+ * раскладка, не тот корень, изменившееся имя файла роутов. Зелёный при нулевом счёте — та же ложь,
+ * что и вручную поставленная галочка.
+ */
+if (endpoints.length === 0 || clientFiles.length === 0) {
+  console.error(
+    `\nОШИБКА: найдено эндпоинтов ${endpoints.length}, файлов клиента ${clientFiles.length}.` +
+      `\nГейт не отработал — проверь раскладку (искали в ${SERVER_ROOTS.join(", ")} от ${ROOT}).`
+  );
+  process.exit(1);
+}
+
+console.log(
+  `Пишущих эндпоинтов: ${endpoints.length} · подключено: ${endpoints.length - unconnectedKeys.size} · долг: ${unconnectedKeys.size} (объявлено ${declared.size})`
+);
+
+const fresh = [...unconnectedKeys].filter((k) => !declared.has(k)).sort();
+const stale = [...declared].filter((k) => !unconnectedKeys.has(k)).sort();
+
+if (fresh.length) {
+  console.error(`\nНОВЫЙ пишущий эндпоинт без вызывающего в клиенте:\n`);
+  for (const k of fresh) {
+    const e = unconnected.find((x) => key(x) === k)!;
+    console.error(`  ${k}   ← ${e.file}:${e.line}`);
+  }
+  console.error(
+    `\nЭкран, показывающий «готово» и ничего не отправивший, выглядит рабочим до перезагрузки.` +
+      `\nЛибо разведи действие до API, либо объяви долг строкой в ${relative(ROOT, ALLOW_FILE)}.`
+  );
+}
+
+if (stale.length) {
+  console.error(`\nЗАПИСЬ ДОЛГА БОЛЬШЕ НЕ НУЖНА — удали её из ${relative(ROOT, ALLOW_FILE)}:\n`);
+  for (const k of stale) console.error(`  ${k}`);
+}
+
+if (fresh.length || stale.length) {
+  console.error(`\nПроверка провалена: новых ${fresh.length}, протухших записей ${stale.length}.`);
+  process.exit(1);
+}
+
+console.log(`Новых разрывов нет. Объявленный долг: ${declared.size} эндпоинтов.\n`);
+process.exit(0);

package/scripts/integration-env.ts

@@ -0,0 +1,41 @@
+/**
+ * Окружение уровня «интеграция» — ОДНО место, где оно задаётся.
+ *
+ * Раньше это жило двумя копиями шелла ВНУТРИ `package.json`:
+ *
+ *   set -a; [ -f .env ] && . ./.env; set +a; export TEST_DATABASE_URL=${TEST_DATABASE_URL:-…} …
+ *
+ * Половина той строки была лишней с самого начала: **bun грузит `.env` сам**, без `--env-file` и без
+ * `source`. Вторая половина — умолчания — задавалась в JSON, где её не прокомментируешь и не
+ * протестируешь, и потому расходилась между `ac` и `test:it`: достаточно поправить одну строку и
+ * забыть вторую, чтобы раннер приёмки и уровень 3 измеряли РАЗНЫЕ базы. Зелёный прогон против не той
+ * базы неотличим от зелёного прогона против своей — этим уже платили (см. CHANGELOG ядра 2026.08.2).
+ *
+ * Поэтому умолчания переехали сюда: их видно, у них есть причина, и она одна на всех потребителей.
+ */
+
+/** Та же строка, что была в `package.json`. Совпадает с тем, что поднимает `docker compose` шаблона. */
+export const DEFAULT_TEST_DATABASE_URL = "postgres://app:app@localhost:5432/app_test";
+
+/**
+ * Проставляет окружение интеграции в текущий процесс и возвращает адрес тестовой БД.
+ *
+ * Именно в `process.env`, а не «возвращает объект»: дочерние процессы (`turbo run test`, `bun test`,
+ * `db:migrate`) наследуют окружение, и `turbo.json` объявляет эти же имена в `env` — то есть turbo
+ * учитывает их в ключе кэша. Вернуть значение и не проставить его значило бы, что уровень побежит с
+ * пустым `TEST_DATABASE_URL`: интеграционные тесты тогда не падают и не «скипаются» — их просто нет
+ * в отчёте.
+ *
+ * Уже заданное окружение НЕ перетирается: `TEST_DATABASE_URL=... bun run test:it` должен работать,
+ * иначе прогнать уровень против другой базы можно будет только правкой файла.
+ */
+export function applyIntegrationEnv(): string {
+  const url = process.env.TEST_DATABASE_URL || DEFAULT_TEST_DATABASE_URL;
+  process.env.TEST_DATABASE_URL = url;
+  // Не «можно, если получится», а «обязано побежать»: без этого интеграционные тесты снимают себя
+  // сами, и отчёт приёмки молча теряет то, что они доказывают.
+  process.env.REQUIRE_INTEGRATION = "1";
+  // Общая тестовая база на несколько параллельных пакетов — держим соединения в узде.
+  process.env.DB_POOL_MAX = process.env.DB_POOL_MAX || "2";
+  return url;
+}

package/scripts/lib/priority.ts

@@ -0,0 +1,161 @@
+/**
+ * ПРИОРИТЕТ СЛАЙСА — три значения и правило, по которому очередь их применяет.
+ *
+ * ─── ЗАЧЕМ ОН ВООБЩЕ ─────────────────────────────────────────────────────────────────────────────
+ *
+ * До этого очередь работ знала ровно один порядок — `feature: Ф<N>` из спеки. Это порядок АНАЛИЗА:
+ * им объявлено, что чем пользуется, и он же служил порядком стройки. У него есть свойство, которое
+ * долго не мешало и однажды помешало: он не знает, ЧТО В ПРОДУКТЕ ГЛАВНОЕ.
+ *
+ * На проекте базы знаний основной путь — вопрос к базе через MCP: индексация → поиск → поверхность.
+ * По номерам это Ф6, Ф7, Ф8, то есть последняя треть очереди. Сборка, идущая строго по номерам,
+ * шесть слайсов подряд строит то, без чего продукт неплох, и только потом — то, без чего его нет
+ * вовсе. Владелец при этом не может ни увидеть ключевой сценарий живым, ни проверить, что вся
+ * затея работает, пока не построено почти всё.
+ *
+ * Приоритет отвечает на второй вопрос, а не подменяет первый.
+ *
+ * ─── ЧТО ОН ЗНАЧИТ ТОЧНО ─────────────────────────────────────────────────────────────────────────
+ *
+ * **Приоритет задаёт ПОЛОСУ; `feature: Ф<N>` — порядок ВНУТРИ полосы.** Сначала берётся вся работа
+ * полосы `high` в объявленном порядке, потом вся `normal`, потом `low`. Это не «важное вперёд, а
+ * там как пойдёт»: внутри полосы порядок зависимостей сохраняется целиком, и слайс не может
+ * обогнать соседа, которым он пользуется, если оба в одной полосе.
+ *
+ * Чего приоритет НЕ делает: он не отменяет работу. `low` — это «позже», а не «не будем»: очередь
+ * пуста только когда пусты все три полосы, и отметка о завершении сборки читает именно это.
+ * Приоритет, умеющий закрывать сборку раньше времени, превратился бы в способ объявить победу.
+ *
+ * ─── ПОЧЕМУ ЗНАЧЕНИЕ ТРЕБУЕТ ПРИЧИНЫ ─────────────────────────────────────────────────────────────
+ *
+ * `priority-why` обязателен. Приоритет без названной причины — это предпочтение, а предпочтение
+ * переспрашивают каждую сессию: следующий агент видит `high`, не видит основания и либо чтит его
+ * как факт, либо тихо меняет. Названная причина превращает спор о вкусе в спор о том, верно ли
+ * прочитано требование, — а такой спор разрешим.
+ *
+ * ─── КТО ПОСТАВИЛ ────────────────────────────────────────────────────────────────────────────────
+ *
+ * `priority-by: owner` — поставил человек; перегенерация спеки его НЕ ТРОГАЕТ.
+ * `priority-by: derived` (умолчание) — вывела стадия анализа из требований; перегенерация вправе
+ * пересчитать.
+ *
+ * Без этого различения автоматическая простановка была бы разовой: первый же прогон генератора
+ * стёр бы решение владельца и не сказал бы об этом.
+ */
+
+export const PRIORITIES = ["high", "normal", "low"] as const;
+export type Priority = (typeof PRIORITIES)[number];
+
+/**
+ * Значение по умолчанию — `normal`, но ОТСУТСТВИЕ объявления это не то же самое, что `normal`.
+ *
+ * `normal` — принятое решение («это обычная работа»), отсутствие — решения нет. Очередь обязана
+ * различать их в выводе: слайс без объявления считается обычным, и это НАЗЫВАЕТСЯ числом, иначе
+ * «никто не думал» неотличимо от «подумали и решили, что обычный».
+ */
+export const DEFAULT_PRIORITY: Priority = "normal";
+
+export interface PriorityDecl {
+  /** Действующее значение: объявленное, либо умолчание. */
+  value: Priority;
+  /** Было ли объявление вообще. */
+  declared: boolean;
+  /** Кто поставил. Без объявления — `derived`. */
+  by: "owner" | "derived";
+  /** Основание. Требуется, когда приоритет объявлен. */
+  why: string | null;
+  /** Текст нарушения, если объявление недействительно. `null` — объявление в порядке. */
+  error: string | null;
+}
+
+/** Полоса как число: чем меньше, тем раньше. */
+export const rank = (p: Priority): number => PRIORITIES.indexOf(p);
+
+/**
+ * Полоса вперёд, объявленный порядок внутри полосы.
+ *
+ * Вынесено сюда, а не оставлено выражением в сортировке очереди, ровно потому, что это ПРАВИЛО, а
+ * не деталь: оно проверяется тестом, и обратный ход у него читаемый — уберёшь первое слагаемое,
+ * и порядок вернётся к номерам спеки.
+ */
+export const comparePriorityThenPhase = (
+  a: { priority: Priority; phase: number },
+  b: { priority: Priority; phase: number }
+): number => rank(a.priority) - rank(b.priority) || a.phase - b.phase;
+
+/**
+ * Блок frontmatter, и только он.
+ *
+ * Читать приоритет по всему файлу нельзя: строка `priority: high` встречается в прозе use case —
+ * например, в примере тела запроса или в таблице ошибок, — и совпадение с ней дало бы слайсу
+ * приоритет, которого никто не объявлял. Такая ошибка не падает: она выглядит как решение.
+ */
+export const frontmatterOf = (source: string): string => {
+  if (!source.startsWith("---")) return "";
+  const end = source.indexOf("\n---", 3);
+  return end === -1 ? "" : source.slice(4, end);
+};
+
+const scalar = (fm: string, key: string): string | null => {
+  const m = new RegExp(`^${key}:[ \\t]*(.*)$`, "m").exec(fm);
+  if (!m) return null;
+  const raw = (m[1] ?? "").trim();
+  // Кавычки снимаются, потому что контракт frontmatter требует их у значений с двоеточием, и
+  // владелец, закавычивший причину, не должен получить другой разбор, чем закавычивший её сосед.
+  const unquoted = /^"(.*)"$/.exec(raw)?.[1] ?? /^'(.*)'$/.exec(raw)?.[1] ?? raw;
+  return unquoted.trim();
+};
+
+/**
+ * Разбор объявления приоритета из полного текста файла слайса.
+ *
+ * НЕДЕЙСТВИТЕЛЬНОЕ объявление не превращается молча в умолчание. Опечатка `priority: heigh` при
+ * молчаливом умолчании дала бы слайсу `normal` — то есть ровно противоположное тому, что владелец
+ * написал, и без единого признака. Поэтому `error` возвращается наверх, а гейт по нему краснеет.
+ */
+export function parsePriority(source: string): PriorityDecl {
+  const fm = frontmatterOf(source);
+  const value = scalar(fm, "priority");
+  const by = scalar(fm, "priority-by");
+  const why = scalar(fm, "priority-why");
+
+  const fail = (error: string): PriorityDecl => ({
+    value: DEFAULT_PRIORITY,
+    declared: value !== null,
+    by: by === "owner" ? "owner" : "derived",
+    why: why || null,
+    error,
+  });
+
+  if (value === null || value === "") {
+    // Спутники без хозяина — тоже ошибка: `priority-why` без `priority` описывает решение,
+    // которого в файле нет, и читается как объявленный приоритет при беглом взгляде.
+    if (by !== null) return fail("`priority-by` объявлен без `priority`");
+    if (why !== null) return fail("`priority-why` объявлен без `priority`");
+    return {
+      value: DEFAULT_PRIORITY,
+      declared: false,
+      by: "derived",
+      why: null,
+      error: null,
+    };
+  }
+
+  if (!(PRIORITIES as readonly string[]).includes(value)) {
+    return fail(`приоритет \`${value}\` — не одно из ${PRIORITIES.join(" | ")}`);
+  }
+  if (by !== null && by !== "owner" && by !== "derived") {
+    return fail(`\`priority-by: ${by}\` — не одно из owner | derived`);
+  }
+  if (!why) {
+    return fail("приоритет объявлен без `priority-why` — причина обязательна");
+  }
+
+  return {
+    value: value as Priority,
+    declared: true,
+    by: by === "owner" ? "owner" : "derived",
+    why,
+    error: null,
+  };
+}