fullstack-gates 0.1.0

package/scripts/next-slice.ts

@@ -0,0 +1,602 @@
+/**
+ * `bun run next-slice` — что брать следующим и почему.
+ *
+ * Очередь работы существовала и раньше, но в двух местах и в разных единицах: долг вёрстки — в
+ * `scripts/prototype-boundary.allow`, покрытие критериев — в `docs/usecases/**`. Чтобы ответить
+ * «какой слайс следующий», приходилось складывать их в голове, а сложенное в голове держится ровно
+ * до следующей сессии. Здесь они сведены и напечатаны одним ответом.
+ *
+ * Скрипт НИЧЕГО не решает за человека: он печатает три структурных факта на слайс и правило, по
+ * которому отсортировал. Правило видно в выводе, а не спрятано в коде, — иначе порядок работ
+ * становится магией, которую никто не оспаривает.
+ *
+ * Читаемые факты (все — из репозитория, ни одного из отчёта прошлого прогона):
+ *   • критерии: сколько `- [x]` из скольких `- [ ]`/`- [x]` в `docs/usecases/<пакет>/<слайс>.md`;
+ *     галочки ставит `bun run ac` по результатам тестов, руками их не ставят;
+ *   • долг вёрстки: сколько файлов слайса числятся в `prototype-boundary.allow`;
+ *   • порт: существует ли `features/<слайс>/db/store.ts` — то есть заведена ли персистентность;
+ *   • провод: сколько пишущих эндпоинтов слайса числятся долгом в `scripts/write-path.allow` —
+ *     то есть сколько действий экрана до сервера не доходят.
+ */
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { comparePriorityThenPhase, parsePriority, type Priority } from "./lib/priority.ts";
+
+/**
+ * Корень РЕПЫ, а не скрипта.
+ *
+ * Скрипт живёт в плагине и запускается из репы (`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 USECASES = join(ROOT, "docs/usecases");
+const ALLOW = join(ROOT, "scripts/prototype-boundary.allow");
+const CONFLICTS = join(ROOT, "scripts/docs-conflicts.open");
+const WRITE_PATH = join(ROOT, "scripts/write-path.allow");
+const PROTO_IDS = join(ROOT, "scripts/proto-ids.allow");
+const PROTO_VALUES = join(ROOT, "scripts/proto-values.allow");
+const WIRING = join(ROOT, "scripts/screen-wiring.allow");
+/**
+ * Критерии, ждущие ЧУЖОГО слайса. Формат строки: `AC-XXX-01.2  <пакет>/<слайс>  причина`.
+ *
+ * Заведено потому, что очередь трижды подряд называла один и тот же слайс: его остаток нельзя
+ * закрыть кодом ЭТОГО слайса — критерий требует поиска, которого ещё нет, или отсутствия
+ * транспортной ветвистости там, где кода вовсе нет. `/build` брал названный слайс, упирался и брал
+ * его снова: работа есть, сделать её нельзя, отметка `BUILD_BLOCKED` при этом была бы ложью — работа
+ * закрывается, просто не сейчас.
+ *
+ * Это НЕ разрешение и не «известная особенность»: строка называет, ЧЕГО ждут, и исчезает, когда
+ * ожидаемый слайс построен. Список только сокращается.
+ */
+const AC_BLOCKED = join(ROOT, "scripts/ac-blocked.open");
+
+/**
+ * Реестр ДОЛГОВ — сознательно не сделанное (`scripts/debt.open`, гейт `check:debt`).
+ *
+ * Очередь его не исполняет и не сортирует по нему: долг не работа слайса, а решение не делать.
+ * Она его СЧИТАЕТ и печатает, потому что очередь — то единственное место, куда смотрят каждый цикл.
+ * Долг, видимый только в отдельной команде, которую никто не запускает, равен отсутствующему.
+ */
+const DEBT = join(ROOT, "scripts/debt.open");
+
+/** Ожидания по критериям: `AC-ID` → слайс, которого он ждёт. */
+const blockedBy = new Map<string, string>();
+if (existsSync(AC_BLOCKED)) {
+  for (const raw of readFileSync(AC_BLOCKED, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const [id, slice] = line.split(/\s+/);
+    if (id && slice) blockedBy.set(id, slice);
+  }
+}
+
+const долгов = existsSync(DEBT)
+  ? readFileSync(DEBT, "utf8")
+      .split("\n")
+      .filter((l) => /^\s*DEBT-\d/.test(l.split("#")[0] ?? "")).length
+  : 0;
+
+type Slice = {
+  pkg: string;
+  slice: string;
+  order: string;
+  title: string;
+  /** Полоса работ: `high` идёт раньше `normal`, `normal` раньше `low`. См. `lib/priority.ts`. */
+  priority: Priority;
+  /** Объявлен ли приоритет вслух. Не объявлено ≠ normal: normal — решение, отсутствие — его нет. */
+  prioDeclared: boolean;
+  /** Кто поставил: `owner` перегенерацией спеки не сбрасывается. */
+  prioBy: "owner" | "derived";
+  /** Основание приоритета: ID требования либо решение владельца. Обязательно при объявлении. */
+  prioWhy: string | null;
+  /** Недействительное объявление. Молча умолчанием НЕ становится — печатается вслух. */
+  prioError: string | null;
+  total: number;
+  covered: number;
+  /** Критериев, ждущих чужого слайса. Работой ЭТОГО слайса они не являются. */
+  waiting: number;
+  /** Чего именно ждут — списком слайсов, чтобы это было видно, а не выводилось. */
+  waitingFor: string[];
+  debt: number;
+  /** Пишущие эндпоинты слайса, до которых экран не дотягивается. */
+  wire: number;
+  /** Адресов экрана, для которых приложение не умеет собрать настоящий ключ (`check:proto-ids`). */
+  addr: number;
+  /** Значений прототипа, которые экран ПЕЧАТАЕТ: счётчик из вёрстки, ключ в подписи (`check:proto-values`). */
+  vals: number;
+  /** Обрывы проводки: мёртвый проп, дубль хваталки, чтение без вызывающего. */
+  wiring: number;
+  hasPort: boolean;
+  /** Открытые противоречия между артефактами: пока они есть, слайс в работу не берут. */
+  conflicts: string[];
+};
+
+/** Слайс, которому принадлежит файл долга: `packages/<пакет>/src/features/<слайс>/…`. */
+const sliceOfPath = (p: string): string | null => {
+  const m = /^packages\/([^/]+)\/src\/features\/([^/]+)\//.exec(p);
+  return m ? `${m[1]}/${m[2]}` : null;
+};
+
+/**
+ * Пишущие эндпоинты без вызывающего — по слайсам.
+ *
+ * Слайс определяется ПРЕФИКСОМ пути, а он объявлен в `routes.ts` каждой группы. Читаем префиксы
+ * оттуда, а не выводим из имени слайса: `roles` держит и `/roles`, и `/domains`, а
+ * `governance-history` — `/governance-changes` и `/proposals`. Совпадение ищем по самому длинному
+ * префиксу, иначе `/role-links` уедет в `/roles`.
+ */
+const wireBySlice = new Map<string, number>();
+if (existsSync(WRITE_PATH)) {
+  const prefixes: Array<{ prefix: string; slice: string }> = [];
+  const scan = (dir: string) => {
+    if (!existsSync(dir)) return;
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (["node_modules", "dist", "build", ".turbo"].includes(e.name)) continue;
+        scan(full);
+      } else if (e.name === "routes.ts") {
+        const m = /packages\/([^/]+)\/src\/features\/([^/]+)\/server\/routes\.ts$/.exec(
+          full.split("\\").join("/")
+        );
+        if (!m) continue;
+        for (const p of readFileSync(full, "utf8").matchAll(
+          /new Elysia\(\{\s*prefix:\s*"([^"]*)"/g
+        ))
+          prefixes.push({ prefix: p[1]!, slice: `${m[1]}/${m[2]}` });
+      }
+    }
+  };
+  scan(join(ROOT, "packages"));
+  prefixes.sort((a, b) => b.prefix.length - a.prefix.length);
+  for (const raw of readFileSync(WRITE_PATH, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const path = line.split(/\s+/)[1] ?? "";
+    const hit = prefixes.find(
+      (p) => p.prefix && (path === p.prefix || path.startsWith(`${p.prefix}/`))
+    );
+    if (hit) wireBySlice.set(hit.slice, (wireBySlice.get(hit.slice) ?? 0) + 1);
+  }
+}
+
+/**
+ * Адреса без настоящего ключа — по слайсам.
+ *
+ * Файл долга (`scripts/proto-ids.allow`) перечисляет ФАЙЛЫ экранов, а путь экрана уже несёт и пакет,
+ * и слайс: `packages/<пакет>/src/features/<слайс>/ui/…`. Клиент приложения (каталог `client`
+ * внутри `apps`) слайсу не принадлежит — его строки считаются общими и в очередь не уезжают: слайс
+ * за оболочку не отвечает, и повесить её долг на первый попавшийся слайс значило бы отправить
+ * работу не туда.
+ */
+const addrBySlice = new Map<string, number>();
+if (existsSync(PROTO_IDS)) {
+  for (const raw of readFileSync(PROTO_IDS, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const at = line.lastIndexOf(" ");
+    const file = line.slice(0, at);
+    const n = Number(line.slice(at + 1));
+    // Разбор СЕГМЕНТАМИ, а не регуляркой: путь и так разложен слэшами, а выражение, кончающееся
+    // на экранированный слэш перед закрывающим, читается парсером неоднозначно.
+    const seg = file.split("/");
+    const ok = seg[0] === "packages" && seg[2] === "src" && seg[3] === "features" && seg.length > 5;
+    if (!ok || !Number.isFinite(n)) continue;
+    const key = seg[1] + "/" + seg[4];
+    addrBySlice.set(key, (addrBySlice.get(key) ?? 0) + n);
+  }
+}
+
+/**
+ * Значения прототипа — по слайсам, тем же разбором пути, что у адресов.
+ *
+ * Считается это РАБОТОЙ по той же причине, по которой ею считается провод: за напечатанным числом
+ * прототипа нет критерия. Критерии доказываются серверными тестами, поэтому «Найдено 22 из 9» на
+ * экране совместимо с покрытием 100% — и очередь, не видя этого числа, объявила бы пустоту
+ * приложению, которое врёт глазами.
+ */
+const valsBySlice = new Map<string, number>();
+if (existsSync(PROTO_VALUES)) {
+  for (const raw of readFileSync(PROTO_VALUES, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const at = line.lastIndexOf(" ");
+    const file = line.slice(0, at);
+    const n = Number(line.slice(at + 1));
+    const seg = file.split("/");
+    const ok = seg[0] === "packages" && seg[2] === "src" && seg[3] === "features" && seg.length > 5;
+    if (!ok || !Number.isFinite(n)) continue;
+    const key = seg[1] + "/" + seg[4];
+    valsBySlice.set(key, (valsBySlice.get(key) ?? 0) + n);
+  }
+}
+
+/**
+ * Долг ПРОВОДКИ — по слайсам, тем же разбором пути, что у значений.
+ *
+ * Считается работой по той же причине, что и провод записи: за обрывом НЕТ критерия. Экран
+ * выгрузки показывает «Выгрузка сформирована» и файла не создаёт, а `AC-EXP-03.*` при этом
+ * зелёные — они доказаны серверными тестами. Измерить и не гнать — это не «почти сделано»,
+ * это счёт, который никто не закрывает.
+ */
+const wiringBySlice = new Map<string, number>();
+if (existsSync(WIRING)) {
+  for (const raw of readFileSync(WIRING, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const at = line.lastIndexOf(" ");
+    const file = line.slice(0, at);
+    const n = Number(line.slice(at + 1));
+    const seg = file.split("/");
+    const ok = seg[0] === "packages" && seg[2] === "src" && seg[3] === "features" && seg.length > 5;
+    if (!ok || !Number.isFinite(n)) continue;
+    const key = seg[1] + "/" + seg[4];
+    wiringBySlice.set(key, (wiringBySlice.get(key) ?? 0) + n);
+  }
+}
+
+const debtBySlice = new Map<string, number>();
+/** Файлы долга уровня ПАКЕТА (composition): работа есть, но она не принадлежит одному срезу. */
+let sharedDebt = 0;
+if (existsSync(ALLOW)) {
+  for (const raw of readFileSync(ALLOW, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const key = sliceOfPath(line);
+    // Файл уровня пакета (composition) слайсу не принадлежит — он общий, и приписать его одному
+    // срезу значило бы обещать, что этот срез его и погасит.
+    if (key) debtBySlice.set(key, (debtBySlice.get(key) ?? 0) + 1);
+    else sharedDebt++;
+  }
+}
+
+/**
+ * Конфликт → слайс, которого он касается.
+ *
+ * Адрес слайса берётся из ПУТИ артефакта: `docs/{usecases/<пакет>,api,ui}/<слайс>.md`. Имя слайса
+ * уникально по всему каталогу, поэтому пакета в пути `api`/`ui` не требуется. Файлы, не
+ * принадлежащие слайсу (`docs/engineering`, `docs/architecture`, `docs/seeds.md`), не приписываются
+ * никому: приписать их одному срезу значило бы обещать, что этот срез их и закроет.
+ */
+const conflictsBySlice = new Map<string, string[]>();
+let unassignedConflicts = 0;
+if (existsSync(CONFLICTS)) {
+  for (const raw of readFileSync(CONFLICTS, "utf8").split("\n")) {
+    const line = raw.split("#")[0]!.trim();
+    if (!line) continue;
+    const file = line.split("|")[0]!.trim();
+    const m = /^docs\/(?:usecases\/[^/]+|api|ui)\/([^/]+)\.md$/.exec(file);
+    if (!m) {
+      unassignedConflicts++;
+      continue;
+    }
+    const slice = m[1]!;
+    conflictsBySlice.set(slice, [...(conflictsBySlice.get(slice) ?? []), line]);
+  }
+}
+
+/**
+ * Каталога use cases может не быть вовсе — так выглядит репа сразу после `setup-tooling`, до
+ * первого слайса. Без этой проверки `readdirSync` бросал сырой ENOENT со стеком: человек читал
+ * «scandir failed» и шёл чинить bun или права на каталог, хотя чинить нечего — работы просто ещё
+ * нет. Отказ должен называть причину, иначе он хуже молчания. (`check-priority` так и делает.)
+ */
+if (!existsSync(USECASES)) {
+  console.error(
+    `next-slice: нет каталога ${USECASES} — use cases ещё не заведены.\n` +
+      "Очередь работ строится ИЗ НИХ, поэтому назвать следующий слайс не из чего.\n" +
+      "Заведите первый: docs/usecases/<пакет>/<слайс>.md с `feature:` в шапке."
+  );
+  process.exit(1);
+}
+
+const slices: Slice[] = [];
+for (const pkg of readdirSync(USECASES, { withFileTypes: true }).filter((e) => e.isDirectory())) {
+  for (const file of readdirSync(join(USECASES, pkg.name)).filter((f) => f.endsWith(".md"))) {
+    const path = join(USECASES, pkg.name, file);
+    const text = readFileSync(path, "utf8");
+    // Индекс каталога не несёт `feature:` — так он и отличается от файла модуля.
+    const order = /^feature:\s*(.+)$/m.exec(text)?.[1]?.trim();
+    if (!order) continue;
+
+    const slice = file.replace(/\.md$/, "");
+    const criteria = [...text.matchAll(/^- \[( |x)\] `(AC-[A-Z]+-\d+\.\d+)`/gm)];
+    const открытые = criteria.filter((m) => m[1] !== "x").map((m) => m[2]!);
+    const ждут = открытые.filter((id) => blockedBy.has(id));
+    const prio = parsePriority(text);
+    slices.push({
+      pkg: pkg.name,
+      slice,
+      order,
+      priority: prio.value,
+      prioDeclared: prio.declared,
+      prioBy: prio.by,
+      prioWhy: prio.why,
+      prioError: prio.error,
+      title: /^title:\s*"?(.+?)"?$/m.exec(text)?.[1]?.trim() ?? slice,
+      total: criteria.length,
+      covered: criteria.filter((m) => m[1] === "x").length,
+      waiting: ждут.length,
+      waitingFor: [...new Set(ждут.map((id) => blockedBy.get(id)!))].sort(),
+      debt: debtBySlice.get(`${pkg.name}/${slice}`) ?? 0,
+      wire: wireBySlice.get(`${pkg.name}/${slice}`) ?? 0,
+      addr: addrBySlice.get(`${pkg.name}/${slice}`) ?? 0,
+      vals: valsBySlice.get(`${pkg.name}/${slice}`) ?? 0,
+      wiring: wiringBySlice.get(`${pkg.name}/${slice}`) ?? 0,
+      hasPort: existsSync(join(ROOT, `packages/${pkg.name}/src/features/${slice}/db/store.ts`)),
+      conflicts: conflictsBySlice.get(slice) ?? [],
+    });
+  }
+}
+
+/**
+ * Порядок работ — ОБЪЯВЛЕННЫЙ, а не выведенный здесь.
+ *
+ * Работа есть у слайса, чьи критерии доказаны не все: `covered < total`. Это единственный честный
+ * признак — «нет порта» им не является (у `access` данные производные, порт ему не нужен вовсе), и
+ * «есть долг вёрстки» тоже: долг говорит, КАКАЯ работа, а не есть ли она.
+ *
+ * Очерёдность берётся из `feature: Ф<N>` спеки. Это порядок аналитики, и он же порядок
+ * зависимостей: роли живут внутри кругов (`roles.circle_id → circles.id`), назначения — внутри
+ * ролей. Сортировать по числу критериев, как я сделал сперва, значит поставить `roles` (40) перед
+ * `circles` (29) — то есть строить этаж раньше несущей стены.
+ */
+const phaseNo = (s: Slice) => Number(/\d+/.exec(s.order)?.[0] ?? 999);
+/**
+ * Работа есть у слайса, чьи критерии доказаны не все — ЛИБО чей экран не дотягивается до сервера.
+ *
+ * Второе добавлено 2026-08-20 и отличается от долга вёрстки принципиально. Долг вёрстки говорит,
+ * КАКАЯ работа, а не есть ли она: слайс с прототипной фикстурой может иметь все критерии
+ * доказанными. Неподключённый пишущий эндпоинт — другое: за ним НЕТ критерия вовсе, потому что
+ * критерии доказываются серверными тестами, и покрытие 100% при неработающей форме — законное
+ * состояние отчёта. Не считая провод работой, очередь объявляла бы пустоту приложению, в котором
+ * ничего нельзя сохранить.
+ */
+/**
+ * Работа есть у слайса, у которого не доказаны критерии, ЛИБО экран не доходит до сервера, ЛИБО
+ * экран адресует записи выдумкой.
+ *
+ * Третье слагаемое появилось не из симметрии. Репа была: покрытие 320/322, провод разведён, очередь
+ * называла три слайса — и приложение не работало, потому что каждая вторая ссылка вела на
+ * `/circles/c-mkt`, которого в базе нет. Долг был ИЗМЕРЕН гейтом и не был РАБОТОЙ: очередь его не
+ * видела, `/build` по нему не гнал, а `BUILD_COMPLETE` при таком состоянии — ложь о готовности.
+ * Измерить и не гнать — это не «почти сделано», это счёт, который никто не закрывает.
+ */
+/*
+  Четвёртое слагаемое — ПРОВОДКА, и оно добавлено по той же причине, что третье.
+
+  Репа была: покрытие 322/322, провод записи разведён, значения сняты — очередь называла работу
+  только там, где не хватало критериев. И при этом кнопка «Выгрузить» показывала «Выгрузка
+  сформирована», не создавая файла: `GET /export` не звал никто. Гейт это ИЗМЕРИЛ и не сделал
+  РАБОТОЙ — очередь долга не видела, `/build` по нему не гнал, а `BUILD_COMPLETE` при таком
+  состоянии — ложь о готовности.
+*/
+/*
+  Пятое уточнение — ОЖИДАНИЕ, и оно не добавляет работы, а вычитает её.
+
+  Критерий, ждущий чужого слайса, работой ЭТОГО слайса не является: закрыть его здешним кодом
+  нельзя. Без вычитания очередь называла один и тот же слайс трижды подряд — `/build` брал его,
+  упирался и брал снова, а `BUILD_BLOCKED` при этом был бы ложью: работа закрывается, просто не
+  сейчас и не здесь.
+
+  Ожидание ОБЪЯВЛЕНО (`scripts/ac-blocked.open`) и печатается числом: невидимое ожидание
+  превратило бы «сделано» и «отложено» в одно состояние — ровно то, против чего заведён весь
+  остальной счёт.
+*/
+const hasWork = (s: Slice) =>
+  s.covered + s.waiting < s.total || s.wire > 0 || s.addr > 0 || s.vals > 0 || s.wiring > 0 ? 1 : 0;
+/**
+ * Слайс с открытым конфликтом НЕ называется следующим.
+ *
+ * Он не исчезает из таблицы — исчезнувшая работа выглядит сделанной, — но уходит вниз и помечен.
+ * Разработчик, взявший такой слайс, встретит противоречие посреди работы и придёт с вопросом; ровно
+ * это и должно решаться раньше, на аналитическом этапе, а не догадкой в коде.
+ */
+const ready = (s: Slice) => (s.conflicts.length === 0 ? 1 : 0);
+/**
+ * ПРИОРИТЕТ стоит МЕЖДУ готовностью и номером спеки, и это его точное место.
+ *
+ * Выше него — только то, есть ли работа вообще и не заблокирована ли она: слайс без работы
+ * приоритетом не оживает, а слайс с открытым противоречием приоритетом не разблокируется. Ниже —
+ * объявленный порядок, и он действует ЦЕЛИКОМ внутри полосы: приоритет двигает полосы, а не
+ * отдельные слайсы, иначе он ломал бы зависимости внутри полосы, ради которых номер и заведён.
+ *
+ * Правило разбора и обратный ход к нему — `lib/priority.ts`.
+ */
+const ranked = [...slices].sort(
+  (a, b) =>
+    hasWork(b) - hasWork(a) ||
+    ready(b) - ready(a) ||
+    comparePriorityThenPhase(
+      { priority: a.priority, phase: phaseNo(a) },
+      { priority: b.priority, phase: phaseNo(b) }
+    )
+);
+
+const bar = (s: Slice) => (s.total === 0 ? "—" : `${s.covered}/${s.total}`);
+const pct = (s: Slice) => (s.total === 0 ? 0 : Math.round((s.covered / s.total) * 100));
+
+console.log(`\n=== ОЧЕРЕДЬ СЛАЙСОВ ===`);
+console.log(
+  `Правило: работа есть там, где доказаны не все критерии, ЛИБО экран не доходит до сервера,
+ЛИБО экран адресует записи выдумкой, ЛИБО экран ПЕЧАТАЕТ значения прототипа,
+ЛИБО у экрана ОБОРВАНА ПРОВОДКА: мёртвый проп, дубль хваталки, чтение без вызывающего.`
+);
+console.log(
+  `Порядок: ПРИОРИТЕТ задаёт полосу (high → normal → low), а внутри полосы очерёдность —
+объявленная спекой (feature: Ф<N>), она же порядок зависимостей. Галочки ставит bun run ac.
+Приоритет объявляется в шапке файла слайса: priority + priority-why (+ priority-by: owner).\n`
+);
+console.log(
+  `  ${"прио".padEnd(7)} ${"Ф".padEnd(4)} ${"слайс".padEnd(30)} ${"крит.".padEnd(8)} ${"ждут".padEnd(5)} ${"%".padEnd(5)} ${"провод".padEnd(7)} ${"адрес".padEnd(7)} ${"значения".padEnd(9)} ${"проводка".padEnd(9)} ${"порт".padEnd(6)} конфликты`
+);
+for (const s of ranked) {
+  const name = `${s.pkg}/${s.slice}`;
+  /** Не объявленный приоритет помечен точкой: «обычный по умолчанию» ≠ «решено, что обычный». */
+  const prio = s.prioError
+    ? "⛔СБОЙ"
+    : `${s.priority}${s.prioDeclared ? (s.prioBy === "owner" ? "*" : "") : "·"}`;
+  console.log(
+    `  ${prio.padEnd(7)} ${s.order.padEnd(4)} ${name.padEnd(30)} ${bar(s).padEnd(8)} ${(s.waiting || "—").toString().padEnd(5)} ${String(pct(s)).padEnd(5)} ` +
+      `${(s.wire || "—").toString().padEnd(7)} ${(s.addr || "—").toString().padEnd(7)} ${(s.vals || "—").toString().padEnd(9)} ${(s.wiring || "—").toString().padEnd(9)} ${(s.hasPort ? "есть" : "нет").padEnd(6)} ` +
+      `${s.conflicts.length ? `⛔ ${s.conflicts.length}` : "—"}`
+  );
+}
+
+const next = ranked[0];
+if (next) {
+  console.log(`\n=== СЛЕДУЮЩИЙ: ${next.pkg}/${next.slice} ===`);
+  console.log(`  ${next.title}`);
+  console.log(
+    `  критериев ${next.total}, доказано ${next.covered}` +
+      (next.waiting ? `, ждут чужого слайса ${next.waiting} (${next.waitingFor.join(", ")})` : "")
+  );
+  /**
+   * ПОЧЕМУ именно он — строкой, а не выводом из таблицы выше.
+   *
+   * Порядок, который надо восстанавливать в голове по колонкам, восстанавливают неверно: первый же
+   * агент, увидев `high` у трёх слайсов, возьмёт тот, что удобнее. Названная причина делает выбор
+   * оспоримым — а неоспоримый порядок работ и есть магия, против которой написан весь этот скрипт.
+   */
+  const behind = ranked.filter((s) => hasWork(s) === 1 && s !== next && phaseNo(s) < phaseNo(next));
+  console.log(
+    `  приоритет: ${next.priority}` +
+      (next.prioError
+        ? ` — ОБЪЯВЛЕНИЕ НЕДЕЙСТВИТЕЛЬНО: ${next.prioError}`
+        : next.prioDeclared
+          ? ` (${next.prioBy === "owner" ? "владелец" : "выведен"}) — ${next.prioWhy}`
+          : " (не объявлен — умолчание)")
+  );
+  if (behind.length) {
+    // Приоритет ОБГОНЯЕТ объявленный порядок — ровно то, ради чего он заведён, и ровно то, что
+    // нельзя делать молча: обгон соседа, которым слайс пользуется, встретится посреди работы.
+    console.log(
+      `  обгоняет по спеке: ${behind.map((s) => `${s.order} ${s.pkg}/${s.slice} (${s.priority})`).join(", ")}\n` +
+        `  Проверь, что обгон законен: слайс не должен обгонять того, чьими данными он живёт.`
+    );
+  }
+  console.log(
+    `  неподключённых эндпоинтов: ${next.wire || "нет"} · адресов без ключа: ${next.addr || "нет"} · значений прототипа: ${next.vals || "нет"} · обрывов проводки: ${next.wiring || "нет"} · порт персистентности: ${next.hasPort ? "есть" : "НЕТ"}`
+  );
+  console.log(`\n  Спека: docs/usecases/${next.pkg}/${next.slice}.md`);
+  console.log(`  Данные стенда: docs/seeds.md (что уже засеяно — bun run db:seed печатает числа)`);
+  console.log(
+    `\n  ПЕРВЫЙ ШАГ — не работа, а проверка предпосылки: чем адресуются сущности слайса.\n` +
+      `  Если ключ — строка из вёрстки (r-smm, c-mkt), слайс не начинают, пока это не решено:\n` +
+      `  выдумка, ставшая ключом, потом снимается только переписыванием четырёх слоёв разом.\n` +
+      `  Разбор таких случаев ведут в документе расхождений порта.`
+  );
+}
+
+const left = ranked.filter((s) => hasWork(s) === 1).length;
+const blocked = ranked.filter((s) => hasWork(s) === 1 && s.conflicts.length > 0);
+const withWork = ranked.filter((s) => hasWork(s) === 1);
+const highLeft = withWork.filter((s) => s.priority === "high").length;
+console.log(
+  `\nСлайсов с работой: ${left} из ${slices.length}; из них заблокировано конфликтом: ${blocked.length}.`
+);
+/**
+ * Высокий приоритет — ОТДЕЛЬНЫМ числом, потому что по нему ставится цель внешнего цикла.
+ *
+ * Одно общее «слайсов с работой» не отличает «осталось три обычных» от «основной путь не собран».
+ * Цель, поставленная по одному числу, второго не увидит — так уже было с долгом адресации.
+ */
+console.log(
+  `Из них высокого приоритета: ${highLeft}` +
+    // Оговорка только там, где полоса `high` вообще ОБЪЯВЛЕНА. «Основной путь собран» при нуле
+    // объявленных high — не отчёт о состоянии, а поздравление с тем, чего никто не заявлял.
+    (highLeft === 0 && left > 0 && slices.some((s) => s.priority === "high")
+      ? " — полоса high пуста, дальше идёт обычная (сборка НЕ закончена)"
+      : "")
+);
+/**
+ * Не объявленный приоритет — счётчиком, а не молчанием.
+ *
+ * Слайс без объявления работает как `normal`, и это правильное умолчание. Но «никто не решал» и
+ * «решили, что обычный» — разные состояния, и неразличимые в отчёте они означают, что вопрос
+ * приоритетов считается закрытым, пока его никто не открывал.
+ */
+const waitingTotal = slices.reduce((a, s) => a + s.waiting, 0);
+if (waitingTotal > 0) {
+  const кого = [...new Set(slices.flatMap((s) => s.waitingFor))].sort();
+  console.log(
+    `Критериев, ждущих чужого слайса: ${waitingTotal} (ждут: ${кого.join(", ")}) — ` +
+      `объявлено в scripts/ac-blocked.open, работой своего слайса они не считаются`
+  );
+}
+/**
+ * ДОЛГИ — рядом с работой, а не в отдельной команде.
+ *
+ * Долг это не «ещё не дошли руки», а решение НЕ делать объявленное: очередь его не назовёт никогда,
+ * потому что работой слайса он не является. Значит единственное место, где его увидят каждый цикл,
+ * — вот эта сводка. Напечатать его только по отдельной команде — то же самое, что не печатать.
+ */
+if (долгов > 0) {
+  console.log(
+    `Долгов (сознательно не сделано): ${долгов} — scripts/debt.open, разбор: bun run check:debt. ` +
+      `Сборку они НЕ блокируют, но и не исчезают`
+  );
+}
+
+const undeclared = slices.filter((s) => !s.prioDeclared && !s.prioError).length;
+if (undeclared) {
+  console.log(
+    `Без объявленного приоритета: ${undeclared} из ${slices.length} (работают как normal; в таблице помечены «·»)`
+  );
+}
+const broken = slices.filter((s) => s.prioError);
+if (broken.length) {
+  console.log(`\n⛔ НЕДЕЙСТВИТЕЛЬНОЕ ОБЪЯВЛЕНИЕ ПРИОРИТЕТА — ${broken.length}:`);
+  for (const s of broken) console.log(`   ${s.pkg}/${s.slice}: ${s.prioError}`);
+  console.log(
+    `   Такой слайс СЧИТАЕТСЯ обычным, но объявлено было другое. Гейт bun run ac по этому краснеет.`
+  );
+}
+if (unassignedConflicts) {
+  console.log(
+    `Конфликтов вне слайса: ${unassignedConflicts} (engineering, architecture, seeds) — ` +
+      `они не блокируют очередь, но и не исчезают: scripts/docs-conflicts.open`
+  );
+}
+/**
+ * Долг ВЁРСТКИ печатается, только пока он есть.
+ *
+ * Гейт границы прототипа (`check:proto`) СНИМАЕТСЯ, когда фикстура перестаёт пересекать границу
+ * представления: порт кончился, и дальше он держал бы проект у прототипа. Строка «долг 0 (столько
+ * же считает bun run check:proto)» после снятия ссылалась бы на команду, которой в репе нет, —
+ * очередь обязана печатать состояние репы, а не память о нём.
+ */
+const sliceDebt = [...debtBySlice.values()].reduce((a, b) => a + b, 0);
+if (sliceDebt + sharedDebt > 0) {
+  console.log(
+    `Файлов долга вёрстки: ${sliceDebt} по срезам + ${sharedDebt} уровня пакета = ${sliceDebt + sharedDebt}` +
+      ` (столько же считает bun run check:proto)`
+  );
+}
+const valsTotal = [...valsBySlice.values()].reduce((a, b) => a + b, 0);
+const wiringTotal = [...wiringBySlice.values()].reduce((a, b) => a + b, 0);
+if (valsTotal > 0) {
+  console.log(
+    `Значений прототипа в экранах: ${valsTotal} (столько же считает bun run check:proto-values)`
+  );
+}
+/*
+  Своё условие, а не общее со значениями.
+
+  Строка проводки стояла ВНУТРИ `if (valsTotal > 0)`, и её не было видно ровно тогда, когда она
+  единственная и оставалась: репа с нулём значений прототипа и ненулевым долгом проводки печатала
+  очередь, из которой остаток не следовал. Два независимых числа под одним условием — это не
+  форматирование, это отчёт, который молчит по чужой причине.
+*/
+if (wiringTotal > 0) {
+  console.log(
+    `Обрывов проводки: ${wiringTotal} (столько же считает bun run check:wiring) — мёртвый проп, дубль хваталки, чтение без вызывающего`
+  );
+}
+console.log(`Отчёт покрытия целиком: docs/acceptance.md (обновляется bun run ac)\n`);