agent-quality-kit 0.10.0 → 0.10.1

package/README.md

@@ -340,7 +340,7 @@ Already using [pre-commit](https://pre-commit.com)? Three lines in the file you
 ```yaml
 repos:
   - repo: https://github.com/arsen-ask-lx/Agent_Quality_Kit
-    rev: v0.10.0
+    rev: v0.10.1
     hooks:
       - id: aqk            # runs what the repository declares; blocks below AQK-1
       # - id: aqk-doctor   # read-only: the level and what is missing, blocks nothing
@@ -361,7 +361,7 @@ layer AQK adds.
 [![on the GitHub Marketplace](https://img.shields.io/badge/GitHub%20Marketplace-Agent%20Quality%20Kit-2ea44f?logo=github)](https://github.com/marketplace/actions/agent-quality-kit-aqk)
 
 ```yaml
-- uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.0
+- uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.1
   with:
     min: 1   # the build fails below AQK-1, or if any declared gate failed
 ```

package/README.ru.md

@@ -343,7 +343,7 @@ aqk badge --check  # в конвейере: код 1 в тот день, ког
 ```yaml
 repos:
   - repo: https://github.com/arsen-ask-lx/Agent_Quality_Kit
-    rev: v0.10.0
+    rev: v0.10.1
     hooks:
       - id: aqk            # запускает объявленное; роняет коммит ниже AQK-1
       # - id: aqk-doctor   # только осмотр: уровень и чего не хватает, ничего не роняет
@@ -362,7 +362,7 @@ repos:
 [![в GitHub Marketplace](https://img.shields.io/badge/GitHub%20Marketplace-Agent%20Quality%20Kit-2ea44f?logo=github)](https://github.com/marketplace/actions/agent-quality-kit-aqk)
 
 ```yaml
-- uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.0
+- uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.1
   with:
     min: 1   # сборка падает ниже AQK-1 или если упал любой объявленный гейт
 ```

package/kit/gates/protection-not-removed/check.sh

@@ -35,23 +35,28 @@ RDIR="$(printf '%s\n' "$MANTEXT" | sed -n 's/^ratchets:[[:space:]]*//p' | head -
 REG="$DIR/$RDIR/gates-declared.txt"
 REL="$RDIR/gates-declared.txt"
 
+# ПРОВЕРКА ТОЛЬКО СРАВНИВАЕТ. Раньше она сама создавала снимок и дописывала в него новые
+# гейты — то есть меняла то, о чём судит. Цена измерена опытом 2026-09-09: в мелком клоне, где
+# удаление снимка лежит ГЛУБЖЕ выкладки, свидетель (история git) слеп, и проверка записала УЖЕ
+# ОСЛАБЛЕННЫЙ набор новым эталоном — «снят снимок: 2 гейтов», код 0, исчезнувший гейт узаконен.
+# Храповик крутился назад. Писать снимок — дело явной операции (`aqk add`), а не вердикта.
 if [ ! -f "$REG" ]; then
-  # Реестра нет. Два разных случая, и путать их нельзя: снимка ещё не снимали — или его
-  # УДАЛИЛИ, что и есть тот самый обход, только другим файлом. Свидетель — git: если у пути
-  # есть история, файл существовал.
+  # Два разных случая, и путать их нельзя: снимка ещё не снимали — или его УДАЛИЛИ, что и есть
+  # тот самый обход, только другим файлом. Свидетель — git: если у пути есть история, файл был.
+  # В мелком клоне свидетель слеп, и поэтому отсутствие снимка красное в ОБОИХ случаях.
   if git -C "$DIR" log -1 --format=%H -- "$REL" 2>/dev/null | grep -q .; then
     echo "$REL был в истории и удалён — снимок объявленной защиты уничтожен"
     echo "  почини: верни файл (git checkout -- $REL). Удаление снимка снимает и саму проверку —"
     echo "  почини: это тот же обход, что удаление гейта, только через соседний файл."
     exit 1
   fi
-  mkdir -p "$DIR/$RDIR" || { echo "не создать $RDIR"; exit 2; }
-  printf '# Снимок объявленной защиты. Набор может только РАСТИ.\n' > "$REG"
-  printf '# Убрал гейт — напиши причину после # в его строке, иначе проверка краснеет.\n' >> "$REG"
-  printf '%s\n' "$DECLARED" >> "$REG"
-  echo "снят снимок объявленной защиты: $(printf '%s\n' "$DECLARED" | wc -l | tr -d ' ') гейтов → $REL"
-  echo "  почини: закоммить этот файл — без него проверка не знает, что защита была."
-  exit 0
+  echo "$REL: снимка объявленной защиты нет — без него удаление гейта не видно"
+  echo "  почини: заведи файл со списком объявленных сейчас гейтов и закоммить его."
+  echo "  почини: содержимое:"
+  echo "    # Снимок объявленной защиты. Набор может только РАСТИ."
+  echo "    # Убрал гейт — напиши причину после # в его строке, иначе проверка краснеет."
+  printf '%s\n' "$DECLARED" | sed 's/^/    /'
+  exit 1
 fi
 
 # Имя без причины — строка реестра, где после имени НЕТ решётки. Имя с причиной — снятое
@@ -80,13 +85,17 @@ if [ -n "$GONE" ]; then
   exit 1
 fi
 
-# Всё на месте — дописываем новые. Набор растёт сам; укоротить его молча нельзя.
+# СНИМОК, ОТСТАВШИЙ ОТ МАНИФЕСТА, — ТОЖЕ РАСХОЖДЕНИЕ. Раньше проверка дописывала новые имена
+# сама и выходила с нулём. Это удобно и неверно: гейт, добавленный и убранный до того, как
+# снимок обновят, уходит незамеченным — а сама проверка при этом молча правит рабочее дерево,
+# в том числе в конвейере. Храповик обязан ТРЕБОВАТЬ записи, а не догонять её.
 NEW=""
 for N in $DECLARED; do
   sed 's/[[:space:]]*#.*//; s/[[:space:]]*$//' "$REG" | grep -qx "$N" || NEW="$NEW $N"
 done
 if [ -n "$NEW" ]; then
-  for N in $NEW; do printf '%s\n' "$N" >> "$REG"; done
-  echo "совет: в снимок дописаны новые гейты:$NEW"
+  for N in $NEW; do echo "$REL: гейт «$N» объявлен, но в снимке его нет"; done
+  echo "  почини: допиши эти имена в $REL и закоммить — снимок обязан знать всё, что защищает."
+  exit 1
 fi
 exit 0

package/llms.txt

@@ -68,7 +68,7 @@ Zero runtime dependencies. Node 18+ and an `sh` shell. MIT.
   the files `init` writes are owned by root, so you cannot edit your own manifest. Debian-based
   on purpose: the gates are `sh`, `grep`, `awk`, `find` — under alpine's busybox they behave
   differently, and an image where the gates behave differently is worse than no image
-- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.0` with `min: 1`
+- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.1` with `min: 1`
   (https://github.com/marketplace/actions/agent-quality-kit-aqk)
 
 ## What makes it different

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-quality-kit",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Turns the rules an agent is supposed to follow into commands with exit codes, and reports which of them actually run. Zero dependencies.",
   "type": "module",
   "bin": {

package/tool/commands/context.mjs

@@ -69,9 +69,17 @@ function contextBlock(state, T = L.context) {
   // прочитать. Блок читается по построению, поэтому знание живёт здесь, а не в команде.
   // Состояние «не делалась» печатается как НЕИЗВЕСТНО, а не опускается: молчание тут
   // прочиталось бы как «всё прикрыто», а прикрыто ли — мы не знаем.
+  // СОСТОЯНИЙ У ПРОБЫ ПЯТЬ, А ВЕТОК БЫЛО ТРИ. В «иначе» падали `off` (пробу выключили в
+  // манифесте) и `unknown` (счётчик коммитов не взять либо непонятое значение поля) — и оба
+  // печатались как «в местах пробы всё прикрыто». То есть выключенная и несостоявшаяся проверка
+  // выдавались за проверку, сказавшую «чисто». Блок читает машина: она примет это за
+  // разрешение. Перечисление исчерпывающее намеренно — новое состояние обязано сюда попасть,
+  // а не утечь в «иначе».
   const pr = state.probe;
   if (pr) {
     if (pr.state === "never") out.push(T.probeNever);
+    else if (pr.state === "off") out.push(T.probeOff);
+    else if (pr.state === "unknown") out.push(T.probeUnknown);
     else if (pr.blind > 0) out.push(T.probeBlind(pr.blind, pr.state === "stale" ? pr.behind : 0));
     else out.push(T.probeClean(pr.state === "stale" ? pr.behind : 0));
   }

package/tool/commands/gates.mjs

@@ -9,6 +9,7 @@ import {
   copyDir,
 } from "../lib/core.mjs";
 import { parseManifest, readManifest, manifestWithGate, entryLifecycle } from "../lib/manifest.mjs";
+import { recordProtection } from "../lib/protection.mjs";
 import {
   detectFacts, readCatalog, pickRecipe, triggerVerdict, stems, overlap, matchCatalog,
 } from "../lib/repo.mjs";
@@ -75,6 +76,7 @@ async function installGate(slug, man, facts) {
   const manPath = join(CWD, MANIFEST);
   const { text, why } = manifestWithGate(await readFile(manPath, "utf8"), slug, cmd);
   if (text) await writeFile(manPath, text, "utf8");
+  if (text) await recordProtection(man, slug);
   return { rec, cmd, copied, declared: Boolean(text), why };
 }
 

package/tool/i18n/en-docs.mjs

@@ -68,6 +68,8 @@ const enDocs = {
     andMore: (n) => `and ${n} more`,
     skipped: (n) => `Not run: ${n} — the tool is absent on this machine, their state is unknown.`,
     probeNever: "No coverage probe has run — what is covered by nothing here is UNKNOWN. That is not \"covered\": `aqk probe`.",
+    probeOff: "The coverage probe is switched off in the manifest (`probe: 0`) — nobody counts what is covered by nothing here.",
+    probeUnknown: "The coverage probe could not run — what is covered by nothing here is UNKNOWN. That is not \"covered\".",
     probeBlind: (n, behind) =>
       `Covered by nothing: ${n} defect classes in the places people most often come back to fix` +
       (behind ? ` (the probe is ${behind} commits behind)` : "") + ". Details: `aqk probe`.",

package/tool/i18n/ru-docs.mjs

@@ -70,6 +70,8 @@ const ruDocs = {
     andMore: (n) => `и ещё ${n}`,
     skipped: (n) => `Не запускались: ${n} — инструмента нет на этой машине, их состояние неизвестно.`,
     probeNever: "Проба покрытия не делалась — что здесь не прикрыто ничем, НЕИЗВЕСТНО. Это не «прикрыто»: `aqk probe`.",
+    probeOff: "Проба покрытия выключена в манифесте (`probe: 0`) — что здесь не прикрыто ничем, никто не считает.",
+    probeUnknown: "Пробу покрытия провести не удалось — что здесь не прикрыто ничем, НЕИЗВЕСТНО. Это не «прикрыто».",
     probeBlind: (n, behind) =>
       `Не прикрыто ничем: ${n} классов брака в местах, куда чаще всего возвращаются с починкой` +
       (behind ? ` (проба отстала на ${behind} коммитов)` : "") + ". Подробно: `aqk probe`.",

package/tool/lib/evidence.mjs

@@ -75,10 +75,23 @@ function targetsOf(cmd, isDir) {
 // не проверен», хотя его обходят пять проверок — они просто промолчали, потому что нашли
 // чисто. Замеряно 2026-09-08.
 function coverage(files, results, isDir = () => false) {
+  // НАЗВАН — ЭТО ТОЛЬКО ВЫВОД. Пути брались из команды И вывода разом, и гейт, не напечатавший
+  // ни слова, делал «названным» любой файл, упомянутый в строке запуска. Опыт 2026-09-09:
+  // молчащая проверка `sh checks/quiet.sh .` давала «названо проверкой: checks/quiet.sh».
+  // Так «доказывалась» каждая правка `kit/gates/*/check.sh` и `tool/selfcheck/*.sh` — то есть
+  // самих проверок, где правда важнее всего.
+  //
+  // Но и выбросить команду нельзя: она отвечает на ДРУГОЙ вопрос — куда гейт был направлен.
+  // Каталог из команды даёт «обойдено молча» через `targets`; отдельный файл раньше не давал
+  // ничего, потому что `targetsOf` берёт только каталоги, — и такой файл падал в «никто не
+  // смотрел». Поэтому имена из команды хранятся отдельно и сравниваются ТОЧНО.
   const seen = results.map((r) => ({
     name: r.name,
-    paths: pathsIn(`${r.cmd || ""}\n${r.out || ""}`),
+    paths: pathsIn(r.out || ""),
     targets: targetsOf(r.cmd, isDir),
+    named: new Set(
+      String(r.cmd || "").split(/\s+/).filter((t) => t && !t.startsWith("-")).map(normPath)
+    ),
   }));
   const covered = new Map();
   const silent = new Map();
@@ -88,7 +101,7 @@ function coverage(files, results, isDir = () => false) {
     const by = seen.filter((n) => n.paths.has(f)).map((n) => n.name);
     if (by.length) { covered.set(raw, by); continue; }
     const aimed = seen
-      .filter((n) => n.targets.some((t) => t === "" || f === t || f.startsWith(`${t}/`)))
+      .filter((n) => n.named.has(f) || n.targets.some((t) => t === "" || f === t || f.startsWith(`${t}/`)))
       .map((n) => n.name);
     if (aimed.length) silent.set(raw, aimed);
     else uncovered.push(raw);

package/tool/lib/execution.mjs

@@ -0,0 +1,67 @@
+// tool/lib/execution.mjs — ИСХОД ЗАПУСКА процесса, отдельно от смысла находки.
+//
+// ЗАЧЕМ. Прежде `prove.mjs` считал находкой ЛЮБОЙ ненулевой код на красном образце. Опыт
+// 2026-09-09: проверка, которая ВИСНЕТ на красном образце и молчит на зелёном, получала вердикт
+// `proven: 1, ok: true` — зависший гейт объявлялся ловящим брак. Это `pytest || true` в функции,
+// считающей наш главный уровень. Тот же класс поймал перемежающийся отказ прогона: под
+// нагрузкой арбитр записи не успевал, и приёмка печатала «гейт ругается на исправный код» —
+// сбой инструмента выдавался за приговор записи каталога.
+//
+// ТРИ ИСХОДА, А НЕ ДВА: clean · finding · infra_error. Четвёртое состояние — `unavailable`,
+// «инструмента нет» — сюда НЕ входит намеренно: это результат осмотра окружения ДО запуска.
+// Если процесс уже запускался и не смог отработать — это сбой инструмента, а не его отсутствие.
+//
+// ПОЧЕМУ У КАЖДОГО ИНСТРУМЕНТА СВОЙ АДАПТЕР, А НЕ ОДНО ПРАВИЛО. Замер по настоящим
+// инструментам 2026-09-09 (числа сняты запуском, кроме pylint и eslint — их документацией):
+//
+//   ruff     чисто 0 · находка 1 (синтаксическая ошибка тоже 1) · неверный флаг 2
+//            · НЕСУЩЕСТВУЮЩИЙ ПУТЬ → 0 и «All checks passed!»
+//   eslint   чисто 0 · находка 1 · настройка либо внутренняя ошибка 2
+//   vulture  чисто 0 · НАХОДКА 3 · плохой ввод 1 · ошибка CLI 2
+//   pylint   чисто 0 · находка битовой маской (2 ошибка, 4 предупреждение, 8, 16)
+//            · ОШИБКА ВЫЗОВА 32
+//
+// Общее правило «1 — находка, 2+ — сбой» переврало бы vulture (его находка это 3, а 1 и 2 —
+// ошибки) и pylint (его ошибка вызова 32 больше любой находки) — причём в ОБЕ стороны.
+// Поэтому знание о кодах живёт рядом с инструментом, а протокол остаётся простым.
+
+// Умолчание для незнакомой программы: ноль — чисто, единица — находка, остальное — сбой.
+// Это честнее догадки: неизвестный код становится «не знаем», а не «поймал».
+const DEFAULT = (code) => code === 1;
+
+const ADAPTERS = {
+  ruff: DEFAULT,
+  eslint: DEFAULT,
+  // Наши собственные обёртки: 0 чисто, 1 находка, 2 «нет делегированного инструмента».
+  bash: DEFAULT,
+  sh: DEFAULT,
+  vulture: (code) => code === 3,
+  // Битовая маска: любое ненулевое БЕЗ бита 32 — находка; бит 32 — ошибка вызова.
+  pylint: (code) => code > 0 && (code & 32) === 0,
+};
+
+function findingCodes(prog) {
+  const key = String(prog || "").split("/").pop();
+  return ADAPTERS[key] || DEFAULT;
+}
+
+// Вход — то, что отдаёт spawnSync: { status, signal, error }. Выход — исход и, у сбоя, причина.
+function classify(r, isFinding = DEFAULT) {
+  // ПОРЯДОК ВАЖЕН, И ОН НЕОЧЕВИДЕН. При истечении срока Node ставит И `signal: SIGTERM`,
+  // И `error` с кодом ETIMEDOUT: если смотреть на error первым и не различать его код, таймаут
+  // назовётся «ошибкой запуска». Состояние вышло бы верным, а объяснение ложным — а объяснение
+  // здесь и есть смысл работы. Замерено прямо на spawnSync 2026-09-09.
+  if (r?.error?.code === "ETIMEDOUT") return { state: "infra_error", reason: "timeout", code: null };
+  if (r?.error) return { state: "infra_error", reason: "spawn_error", code: null };
+  if (r?.status === null || r?.status === undefined) {
+    // Срок мог сработать и без error: процесс убит SIGTERM. Иной сигнал — не наш срок.
+    const reason = !r?.signal || r.signal === "SIGTERM" ? "timeout" : "signal";
+    return { state: "infra_error", reason, code: null };
+  }
+  const code = r.status;
+  if (code === 0) return { state: "clean", reason: null, code };
+  if (isFinding(code)) return { state: "finding", reason: null, code };
+  return { state: "infra_error", reason: "unexpected_exit", code };
+}
+
+export { classify, findingCodes };

package/tool/lib/protection.mjs

@@ -0,0 +1,52 @@
+// tool/lib/protection.mjs — снимок объявленной защиты: кто его пишет и в каком виде.
+//
+// ОТДЕЛЬНЫМ МОДУЛЕМ, а не строкой в `add`: у формата снимка два читателя — эта запись и
+// проверка `kit/gates/protection-not-removed/check.sh`. Знание об одном файле, размазанное по
+// двум местам, однажды разъедется; здесь оно собрано с той стороны, где на JS.
+// Вторая копия неизбежна: проверка написана на POSIX sh и разделить с ней код нельзя —
+// поэтому шапка ниже и текст в её сообщении «почини» обязаны меняться вместе.
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CWD, RATCHET_DIR, MANIFEST } from "./core.mjs";
+
+const HEADER =
+  "# Снимок объявленной защиты. Набор может только РАСТИ.\n" +
+  "# Убрал гейт — напиши причину после # в его строке, иначе проверка краснеет.\n";
+
+// СНИМОК ОБЪЯВЛЕННОЙ ЗАЩИТЫ ПИШЕТ УСТАНОВКА, А НЕ ПРОВЕРКА.
+//
+// Раньше его вёл сам гейт `protection-not-removed`: при отсутствии создавал, при появлении новых
+// имён дописывал. То есть проверка меняла то, о чём судит. Опыт 2026-09-09: в мелком клоне, где
+// удаление снимка лежит глубже выкладки, свидетель (история git) слеп — и проверка записала уже
+// ОСЛАБЛЕННЫЙ набор новым эталоном, вернув ноль. Храповик крутился назад.
+//
+// Здесь этому место по смыслу: `add` уже меняет манифест, и запись в снимок — часть того же
+// действия. Проверка теперь только сравнивает.
+async function recordProtection(man, slug) {
+  // `init` кладёт `ratchets: ""` намеренно: пустое поле честнее заглушки. Заполняем его при
+  // первой записи — ровно так же поступает `ratchet`. Иначе источников истины два: пустой
+  // манифест и умолчание внутри проверки, — и они однажды разойдутся.
+  let rdir = typeof man?.ratchets === "string" ? man.ratchets.trim() : "";
+  const manPath = join(CWD, MANIFEST);
+  if (!rdir) {
+    rdir = RATCHET_DIR;
+    try {
+      const t = await readFile(manPath, "utf8");
+      if (/^ratchets:\s*""\s*$/m.test(t)) {
+        await writeFile(manPath, t.replace(/^ratchets:\s*""\s*$/m, `ratchets: ${RATCHET_DIR}`), "utf8");
+      }
+    } catch { /* манифест не прочитан — снимок всё равно заведём в умолчательном каталоге */ }
+  }
+  const file = join(CWD, rdir, "gates-declared.txt");
+  let body = "";
+  try { body = await readFile(file, "utf8"); } catch { /* снимка ещё нет — заведём */ }
+  const names = body.split("\n").map((l) => l.replace(/\s*#.*$/, "").trim()).filter(Boolean);
+  if (names.includes(slug)) return;
+  const head = body ? body.replace(/\n?$/, "\n") : HEADER;
+  await mkdir(join(CWD, rdir), { recursive: true });
+  await writeFile(file, `${head}${slug}\n`, "utf8");
+}
+
+// Наружу — только запись. `HEADER` остаётся внутри: экспорт, который никто не берёт, читается
+// как часть договора и мешает менять внутренности. Поймал наш же dead-code.
+export { recordProtection };

package/tool/lib/prove.mjs

@@ -15,6 +15,7 @@ import { join } from "node:path";
 import { CWD, exists } from "./core.mjs";
 import { parseManifest, gateRequires } from "./manifest.mjs";
 import { whichSync } from "./repo.mjs";
+import { classify, findingCodes } from "./execution.mjs";
 
 // Гейт можно доказать, если у него есть оба образца. Признак по образцам, а не по тексту
 // команды: запись, делегирующая готовому инструменту (`npx knip --directory .`), каталог
@@ -102,12 +103,14 @@ async function samplesForRecipe(samplesDir, name) {
   }
 }
 
-function run(cmd, timeoutMs) {
+// Запуск возвращает РАЗОБРАННЫЙ исход, а не сырой код. Прежде здесь стояло
+// `code = r.status === null ? 124 : r.status`, и комментарий рядом честно называл 124
+// «не знаем» — а вызывающий тут же считал его находкой. Опыт 2026-09-09: проверка, виснущая
+// на красном образце, получала вердикт «доказана».
+function run(cmd, timeoutMs, prog) {
   const r = spawnSync(cmd, { shell: true, encoding: "utf8", cwd: CWD, timeout: timeoutMs });
   const out = `${r.stdout || ""}${r.stderr || ""}`.trim();
-  // Убитый по таймауту процесс возвращает null — это не «ноль», а «не знаем».
-  const code = r.status === null ? 124 : r.status;
-  return { code, out };
+  return { ...classify(r, findingCodes(prog)), out };
 }
 
 // Возвращает { proven, broken, unprovable, results } — числами и списком, чтобы вызывающий
@@ -159,24 +162,48 @@ async function proveGates(man, { timeoutMs = 300000 } = {}) {
       continue;
     }
 
-    const red = run(commandFor(cmd, s.red), timeoutMs);
-    const green = run(commandFor(cmd, s.green), timeoutMs);
-    if (red.code === 0) {
+    // Программа, чьи коды разбираем: первое слово команды БЕЗ обёрток. У обёрнутой записи
+    // это ruff/vulture, а не bash, — иначе адаптер брался бы для оболочки.
+    const prog = effective[0];
+    const red = run(commandFor(cmd, s.red), timeoutMs, prog);
+    const green = run(commandFor(cmd, s.green), timeoutMs, prog);
+
+    // СБОЙ АРБИТРА — НЕ ВЕРДИКТ О ЗАПИСИ, ни в ту сторону, ни в другую. Раньше сбой на красном
+    // читался как «поймал», а сбой на зелёном — как «ругается на исправный код»: инструмент
+    // ломался, а обвиняли запись каталога. Оба случая теперь «доказать не смогли», и причина
+    // названа.
+    if (red.state === "infra_error" || green.state === "infra_error") {
+      const side = red.state === "infra_error" ? "red" : "green";
+      const bad = side === "red" ? red : green;
+      results.push({ name, state: "unprovable", why: "infra", side, reason: bad.reason, red, green });
+    } else if (red.state === "clean") {
       results.push({ name, state: "broken", why: "red-passed", red, green });
-    } else if (green.code !== 0) {
+    } else if (green.state === "finding") {
       results.push({ name, state: "broken", why: "green-failed", red, green });
     } else {
       results.push({ name, state: "proven", red, green });
     }
   }
 
+  return { ...verdict(results), results };
+}
+
+// ВЕРДИКТ ОТДЕЛЁН ОТ ПРОГОНА — чтобы правило можно было проверить без запуска процессов.
+//
+// Прежнее правило было `broken === 0 && proven > 0`, и оно позволяло ОДНОМУ доказанному гейту
+// компенсировать сколько угодно недоказанных: проект с пятью объявленными проверками, из
+// которых четыре не смогли отработать, получал AQK-2 за счёт пятой.
+//
+// Различие тонкое и обязательное. «Нечем доказывать» бывает ЗАКОННЫМ: нет образцов, нет
+// программы на этой машине, стоит рецепт под другой язык — ступень за это не отнимают, иначе
+// уровень стал бы зависеть от того, что установлено. А «запускали и не смогло отработать» —
+// сбой, и он ступень отнимает: иначе таймаут арбитра снова становится способом получить зелёное.
+function verdict(results) {
   const proven = results.filter((r) => r.state === "proven").length;
   const broken = results.filter((r) => r.state === "broken").length;
   const unprovable = results.filter((r) => r.state === "unprovable").length;
-  // Доказательство состоялось, если ни один доказуемый гейт не сломан И хоть один доказан.
-  // Второе условие обязательно: проект, у которого все гейты недоказуемы, ничего не доказал —
-  // именно так выглядит подделка с тремя `true`.
-  return { proven, broken, unprovable, ok: broken === 0 && proven > 0, results };
+  const infra = results.filter((r) => r.state === "unprovable" && r.why === "infra").length;
+  return { proven, broken, unprovable, infra, ok: broken === 0 && infra === 0 && proven > 0 };
 }
 
-export { proveGates, commandFor };
+export { proveGates, commandFor, verdict };

package/tool/selfcheck/smoke/protection.test.mjs

@@ -0,0 +1,101 @@
+// Снимок объявленной защиты: проверка ТОЛЬКО СРАВНИВАЕТ, а пишет его отдельная явная операция.
+// Написаны ДО правки.
+//
+// ОПЫТ, ИЗ КОТОРОГО ОНИ ВЗЯЛИСЬ (2026-09-09). Проверка при отсутствии реестра создавала его
+// сама и выходила с нулём. В мелком клоне, где удаление реестра лежит ГЛУБЖЕ выкладки, свидетель
+// (история git) слеп — и проверка записала УЖЕ ОСЛАБЛЕННЫЙ набор как новый эталон:
+//
+//   снят снимок объявленной защиты: 2 гейтов → ratchets/gates-declared.txt
+//   код: 0                                   ← гейт «secrets» исчез и УЗАКОНЕН
+//
+// Храповик крутился назад. Отсюда правило: отсутствующий снимок — не зелёное, и проверка,
+// выносящая вердикт, не имеет права менять то, о чём судит.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { project, run, aqk, gate } from "./_fixture.mjs";
+
+const MAN = (gates) =>
+  `aqk: 1\nentry: [AGENTS.md]\nratchets: ratchets\ngates:\n${gates.map((g) => `  ${g}: "true"\n`).join("")}`;
+const REG = "# Снимок объявленной защиты. Набор может только РАСТИ.\n";
+
+test("отсутствующий снимок — не зелёное, и проверка его не создаёт", (t) => {
+  const p = project(t, { ".aqk.yml": MAN(["lint", "secrets"]), "AGENTS.md": "# свод\n" });
+  const r = gate(p, "protection-not-removed");
+  assert.notEqual(r.code, 0, `снимка нет, а проверка зелёная:\n${r.out}`);
+  assert.equal(existsSync(join(p.dir, "ratchets", "gates-declared.txt")), false,
+    "проверка создала файл, о котором судит");
+});
+
+test("мелкий клон не узаконивает ослабленный набор", (t) => {
+  const p = project(t, {
+    ".aqk.yml": MAN(["lint", "secrets", "tests"]),
+    "AGENTS.md": "# свод\n",
+    "ratchets/gates-declared.txt": `${REG}lint\nsecrets\ntests\n`,
+  });
+  run(p, "git", ["add", "-A"]);
+  run(p, "git", ["commit", "-q", "-m", "первый", "-m", "Сделано: x", "-m", "Не уверен: y"]);
+  // Обход: убрали гейт И удалили снимок.
+  run(p, "bash", ["-c", `printf '%s' '${MAN(["lint", "tests"])}' > .aqk.yml && git rm -q ratchets/gates-declared.txt`]);
+  run(p, "git", ["commit", "-qam", "обход", "-m", "Сделано: x", "-m", "Не уверен: y"]);
+  // ...и ушли вперёд, чтобы удаление оказалось глубже выкладки конвейера.
+  for (let i = 0; i < 5; i++) {
+    run(p, "bash", ["-c", `echo ${i} > f${i}.txt`]);
+    run(p, "git", ["add", "-A"]);
+    run(p, "git", ["commit", "-qm", `работа ${i}`, "-m", "Сделано: x", "-m", "Не уверен: y"]);
+  }
+  run(p, "bash", ["-c", "git clone -q --depth 3 file://$PWD shallow 2>/dev/null"]);
+  const r = gate(p, "protection-not-removed", "shallow");
+  assert.notEqual(r.code, 0, `мелкий клон получил зелёное на ослабленном наборе:\n${r.out}`);
+  const reg = join(p.dir, "shallow", "ratchets", "gates-declared.txt");
+  assert.equal(existsSync(reg), false, "проверка записала ослабленный набор новым эталоном");
+});
+
+// Снимок, отставший от манифеста, — тоже расхождение: иначе гейт, добавленный и убранный до
+// обновления снимка, уходит незамеченным. Храповик обязан требовать записи, а не догонять сам.
+test("снимок, отставший от манифеста, — не зелёное и не дописывается молча", (t) => {
+  const p = project(t, {
+    ".aqk.yml": MAN(["lint", "secrets"]),
+    "AGENTS.md": "# свод\n",
+    "ratchets/gates-declared.txt": `${REG}lint\n`,
+  });
+  const r = gate(p, "protection-not-removed");
+  assert.notEqual(r.code, 0, `снимок отстал, а проверка зелёная:\n${r.out}`);
+  const body = readFileSync(join(p.dir, "ratchets", "gates-declared.txt"), "utf8");
+  assert.doesNotMatch(body, /secrets/, "проверка дописала снимок сама");
+});
+
+test("совпадающий снимок — зелёное; снятый без причины — красное", (t) => {
+  const ok = project(t, {
+    ".aqk.yml": MAN(["lint", "secrets"]),
+    "AGENTS.md": "# свод\n",
+    "ratchets/gates-declared.txt": `${REG}lint\nsecrets\n`,
+  });
+  assert.equal(gate(ok, "protection-not-removed").code, 0, "совпадающий снимок покраснел");
+
+  const gone = project(t, {
+    ".aqk.yml": MAN(["lint"]),
+    "AGENTS.md": "# свод\n",
+    "ratchets/gates-declared.txt": `${REG}lint\nsecrets\n`,
+  });
+  assert.equal(gate(gone, "protection-not-removed").code, 1, "снятый без причины прошёл");
+
+  const named = project(t, {
+    ".aqk.yml": MAN(["lint"]),
+    "AGENTS.md": "# свод\n",
+    "ratchets/gates-declared.txt": `${REG}lint\nsecrets  # снят: закрыт гейтом lint\n`,
+  });
+  assert.equal(gate(named, "protection-not-removed").code, 0, "снятый с причиной покраснел");
+});
+
+// Писать снимок — дело явной операции, а не проверки. `add` и есть эта операция: он уже меняет
+// манифест, и запись в снимок — часть того же действия.
+test("aqk add записывает гейт в снимок", (t) => {
+  const p = project(t, { "src/a.py": "x = 1\n" });
+  aqk(p, "init");
+  aqk(p, "add", "todo-without-task");
+  const reg = join(p.dir, "ratchets", "gates-declared.txt");
+  assert.equal(existsSync(reg), true, "add не создал снимок");
+  assert.match(readFileSync(reg, "utf8"), /todo-without-task/, "add не записал гейт в снимок");
+});

package/tool/selfcheck/smoke/release-tools.test.mjs

@@ -0,0 +1,55 @@
+// Конвейер выпуска обязан ставить всё, что нужно ОБЪЯВЛЕННЫМ гейтам.
+//
+// ЗАЧЕМ. Шаг выпуска гоняет `doctor --run --min 1`. Гейт, чьей программы нет, выходит с кодом
+// 2 «не найден инструмент» — и выпуск встаёт на ровном месте, уже после метки. Так и вышло
+// 2026-09-10: объявили `test-not-adjusted`, его арбитр `checkwash` в publish.yml не ставился,
+// и выпуск 0.10.1 упал между меткой и публикацией.
+//
+// В самом publish.yml написано: «этот файл однажды уже разошёлся с ci.yml». Разошёлся второй
+// раз — значит нужен сторож, а не третья правка руками. Список выводится из МАНИФЕСТА: какие
+// программы объявленные записи называют полем `requires`, те и обязаны ставиться.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+
+// Имена объявленных гейтов — из .aqk.yml, а не из каталога: ставить нужно то, что гоняется.
+function declaredGates() {
+  const man = readFileSync(join(ROOT, ".aqk.yml"), "utf8").split("\n");
+  const out = [];
+  let inGates = false;
+  for (const line of man) {
+    if (/^gates:/.test(line)) { inGates = true; continue; }
+    if (/^[A-Za-z]/.test(line)) inGates = false;
+    const m = inGates && /^\s+([A-Za-z0-9_-]+):\s*\S/.exec(line);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+
+function requiredProgram(slug) {
+  const yml = join(ROOT, "kit", "gates", slug, "gate.yml");
+  if (!existsSync(yml)) return null;
+  const m = /^requires:\s*(\S+)/m.exec(readFileSync(yml, "utf8"));
+  return m ? m[1] : null;
+}
+
+test("конвейер выпуска ставит программы всех объявленных записей", () => {
+  // ЧИТАЮТСЯ ТОЛЬКО СТРОКИ УСТАНОВКИ, а не файл целиком. Первая редакция искала имя по всему
+  // тексту — и нашла `checkwash` В КОММЕНТАРИИ, объявив сторожа зелёным ровно тогда, когда
+  // выпуск падал. Тот же грех, что ловим весь день, в проверке, написанной против него.
+  const wf = readFileSync(join(ROOT, ".github", "workflows", "publish.yml"), "utf8");
+  const installed = wf
+    .split("\n")
+    .filter((l) => /^\s*(pipx install|npm i -g|uv tool install)\s/.test(l))
+    .join("\n");
+  const missing = declaredGates()
+    .map((g) => requiredProgram(g))
+    .filter(Boolean)
+    .filter((prog) => !installed.includes(prog));
+  assert.deepEqual(missing, [],
+    `publish.yml не ставит: ${missing.join(", ")} — выпуск встанет после метки`);
+});

package/tool/selfcheck/smoke.sh

@@ -60,6 +60,15 @@ trap 'rm -rf "$WORK"' EXIT
 #    конвейере нет. Сеть в тестах — отдельный класс флейков во всех разборах; здесь она ещё и
 #    делает две среды разными по построению.
 export TMPDIR="$WORK/tmp"; mkdir -p "$TMPDIR"
+# PYTHONUSERBASE — ДО подмены HOME и из-за неё. Инструменты, поставленные `pip --user`
+# (`vulture`, `checkwash`), это python-скрипты, которые ищут свои модули в
+# `$HOME/.local/lib/python*/site-packages`. С песочницей вместо HOME импорт падает, а гейт,
+# чей арбитр упал, печатает «арбитр покраснел на ЗЕЛЁНОМ образце» — то есть проверка врёт о
+# записи каталога, а не о своей поломке. Найдено 2026-09-09 в тот же час, когда инструменты
+# были поставлены: до установки этот путь кода не исполнялся вовсе.
+# Переменная — штатный способ указать python, где искать пользовательские пакеты; бинарям
+# (`ruff`, `zizmor`, `slopcheck`) она не нужна, и им песочница не мешала.
+export PYTHONUSERBASE="${PYTHONUSERBASE:-$HOME/.local}"
 export HOME="$WORK/home"; export USERPROFILE="$HOME"; mkdir -p "$HOME"
 export AQK_UPDATE=0
 
@@ -723,7 +732,12 @@ BDIR="$(mktemp -d)"
 )
 B_OUT=$( cd "$BDIR" && node "$CLI" badge 2>&1 )
 B_LVL=$(printf '%s' "$B_OUT" | sed -n 's|.*img.shields.io/badge/AQK-\([0-9]\)-.*|\1|p' | head -1)
-D_LVL=$( cd "$BDIR" && node "$CLI" doctor 2>&1 | sed -n 's/.*Уровень: AQK-\([0-9]\).*/\1/p' | head -1 )
+# ЗНАЧОК СВЕРЯЕТСЯ С ДОКАЗАННЫМ УРОВНЕМ. `badge` гоняет доказательство сам, а `doctor` без
+# `--run` его не гоняет и честно говорит «не доказано» — это РАЗНЫЕ вопросы, и сравнивать их
+# нельзя. Пока доказательство ни на что не влияло в этой фикстуре, оба ответа совпадали
+# случайно; как только у проекта появился храповик, они разошлись, и проверка обвинила
+# исправную программу. Найдено 2026-09-10 правкой, не трогавшей ни значок, ни уровень.
+D_LVL=$( cd "$BDIR" && node "$CLI" doctor --run 2>&1 | sed -n 's/.*Уровень: AQK-\([0-9]\).*/\1/p' | head -1 )
 if [ -n "$B_LVL" ] && [ "$B_LVL" = "$D_LVL" ]; then
   ok "badge выдаёт значок с уровнем doctor (AQK-$B_LVL)"
 else

package/tool/selfcheck/units-context.mjs

@@ -186,3 +186,27 @@ test("без --full свод не вливается — только ссылк
   assert.doesNotMatch(t, /Правило одно/);
   assert.match(t, /AGENTS\.md/);
 });
+
+// --- СОСТОЯНИЯ ПРОБЫ: пять, а веток было три ---------------------------------------------
+// ЗАЧЕМ. Блок читает машина: пустое место и «всё прикрыто» она примет за разрешение. Состояний
+// у пробы пять — `never`, `off`, `unknown`, `stale`, `fresh`, — а печатались три ветки: «не
+// делалась», «есть непрокрытое», иначе «всё прикрыто». В последнюю падали ДВА состояния, где мы
+// как раз ничего не знаем:
+//   off      — пробу выключили в манифесте (`probe: 0`);
+//   unknown  — счётчик коммитов не взять либо в манифесте непонятое значение.
+// Обе печатались как «в местах пробы всё прикрыто» — то есть выключенная и несостоявшаяся
+// проверка выдавались за проверку, сказавшую «чисто».
+test("выключенная и несостоявшаяся проба не выдаются за «всё прикрыто»", () => {
+  // Якорь берётся из САМОГО текста, а не из представления о нём: первая редакция искала слово
+  // «прикрыт», которого в строке про чистую пробу нет, — и краснела на исправном выводе.
+  const clean = text({ probe: { state: "fresh", behind: 3, blind: 0 } });
+  assert.match(clean, /каждый применимый класс/, "строка про чистую пробу пропала");
+
+  const off = text({ probe: { state: "off", behind: null, blind: 0 } });
+  assert.doesNotMatch(off, /всё прикрыто|прикрыто ничем нет/,
+    `выключенная проба выдана за покрытие: ${off}`);
+  assert.match(off, /выключен|отключен/i, `не сказано, что проба выключена: ${off}`);
+
+  const unknown = text({ probe: { state: "unknown", behind: null, blind: 0 } });
+  assert.match(unknown, /НЕИЗВЕСТНО|неизвестн/i, `несостоявшаяся проба не названа: ${unknown}`);
+});

package/tool/selfcheck/units-evidence.mjs

@@ -81,3 +81,37 @@ test("покрытие: файл вне всех целей остаётся н
   assert.deepEqual(cov.silent.get("tool/a.js"), ["size"]);
   assert.deepEqual(cov.uncovered, [".github/workflows/ci.yml"]);
 });
+
+// --- НАЗВАН ПРОВЕРКОЙ — ЭТО ТОЛЬКО ВЫВОД ------------------------------------------------
+// ЗАЧЕМ. Пути брались из КОМАНДЫ и вывода разом: `pathsIn(cmd + "\n" + out)`. Гейт, не
+// напечатавший ни слова, делал «названным» любой файл, упомянутый в строке запуска. Опыт
+// 2026-09-09: молчащая проверка `sh checks/quiet.sh .` дала
+//   названо проверкой: [ 'checks/quiet.sh' ]
+// Так «доказывалась» у нас каждая правка `kit/gates/*/check.sh` и `tool/selfcheck/*.sh` —
+// то есть самих проверок, где правда важнее всего.
+//
+// Но и выбросить команду нельзя: она отвечает на ДРУГОЙ вопрос — куда гейт был направлен.
+// Файл, названный в команде и не упомянутый в выводе, — это «обойдён молча», а не «никто не
+// смотрел»: разница между «просмотрен и чист» и «не просмотрен» и есть предмет этого модуля.
+test("молчащий гейт не «называет» файл из своей команды, но и не теряет его", async () => {
+  const { coverage } = await import("../lib/evidence.mjs");
+  const results = [{ name: "тихий", cmd: "sh checks/quiet.sh .", out: "" }];
+  const r = coverage(["checks/quiet.sh"], results, () => false);
+  assert.deepEqual([...r.covered.keys()], [], "путь из команды выдан за находку проверки");
+  assert.deepEqual([...r.silent.keys()], ["checks/quiet.sh"], "файл, куда гейт направлен, потерян");
+});
+
+test("гейт, направленный на конкретный файл, накрывает именно его", async () => {
+  const { coverage } = await import("../lib/evidence.mjs");
+  const results = [{ name: "линт", cmd: "eslint src/a.js", out: "" }];
+  const r = coverage(["src/a.js", "src/b.js"], results, () => false);
+  assert.deepEqual([...r.silent.keys()], ["src/a.js"]);
+  assert.deepEqual(r.uncovered, ["src/b.js"]);
+});
+
+test("напечатанный путь по-прежнему означает «названо»", async () => {
+  const { coverage } = await import("../lib/evidence.mjs");
+  const results = [{ name: "линт", cmd: "eslint .", out: "src/a.js:3: находка" }];
+  const r = coverage(["src/a.js"], results, () => false);
+  assert.deepEqual([...r.covered.keys()], ["src/a.js"]);
+});

package/tool/selfcheck/units-execution.mjs

@@ -0,0 +1,88 @@
+// tool/selfcheck/units-execution.mjs — исход ЗАПУСКА процесса, отдельно от смысла находки.
+// Написаны ДО реализации.
+//
+// ЗАЧЕМ. `prove.mjs` считал находкой ЛЮБОЙ ненулевой код на красном образце. Опыт 2026-09-09:
+// проверка, которая ВИСНЕТ на красном образце и молчит на зелёном, получала вердикт
+// `proven: 1, ok: true` — то есть зависший гейт объявлялся ловящим брак. Это `pytest || true`
+// в функции, которая считает наш главный уровень.
+//
+// ПОЧЕМУ НЕЛЬЗЯ ОДНИМ ПРАВИЛОМ «1 — находка, 2+ — сбой». Замер по настоящим инструментам:
+//   ruff     чисто 0 · находка 1 (и синтаксическая ошибка тоже 1) · неверный флаг 2
+//            · НЕСУЩЕСТВУЮЩИЙ ПУТЬ → 0 и «All checks passed!»
+//   eslint   чисто 0 · находка 1 · настройка или внутренняя ошибка 2
+//   vulture  чисто 0 · НАХОДКА 3 · плохой ввод 1 · ошибка CLI 2
+//   pylint   чисто 0 · находка битовой маской (2 ошибка, 4 предупреждение, 8, 16)
+//            · ОШИБКА ВЫЗОВА 32
+// Общее правило переврало бы vulture и pylint в обе стороны. Значит знание о кодах живёт
+// рядом с инструментом — нормализующим адаптером, а протокол остаётся простым.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { classify, findingCodes } from "../lib/execution.mjs";
+
+// Вход — то, что отдаёт spawnSync: { status, signal, error }.
+const R = (over = {}) => ({ status: 0, signal: null, error: undefined, ...over });
+
+test("ноль — чисто, объявленный код находки — находка", () => {
+  assert.equal(classify(R({ status: 0 })).state, "clean");
+  assert.equal(classify(R({ status: 1 })).state, "finding");
+});
+
+// Убитый по таймауту процесс отдаёт status null. Прежний код превращал его в 124 и считал
+// находкой — а сам же комментарий рядом называл это «не знаем».
+test("таймаут — не находка, а сбой инструмента", () => {
+  const r = classify(R({ status: null, signal: "SIGTERM" }));
+  assert.equal(r.state, "infra_error");
+  assert.equal(r.reason, "timeout");
+});
+
+test("убийство сигналом — сбой инструмента", () => {
+  const r = classify(R({ status: null, signal: "SIGKILL" }));
+  assert.equal(r.state, "infra_error");
+  assert.match(r.reason, /timeout|signal/);
+});
+
+// Процесс не запустился вовсе: нет программы, нет прав, нет каталога.
+// Node при истечении срока ставит И signal, И error с кодом ETIMEDOUT. Если смотреть на
+// error первым и не различать его код, таймаут называется «ошибкой запуска»: состояние верное,
+// причина ложная. Поймано первым же контрпримером после правки — вердикт стал верным, а
+// объяснение врало.
+test("таймаут не выдаётся за ошибку запуска: у Node при сроке стоит и signal, и error", () => {
+  const timedOut = { status: null, signal: "SIGTERM",
+    error: Object.assign(new Error("spawnSync /bin/sh ETIMEDOUT"), { code: "ETIMEDOUT" }) };
+  assert.equal(classify(timedOut).reason, "timeout");
+  const notFound = { status: null, signal: null,
+    error: Object.assign(new Error("spawnSync ENOENT"), { code: "ENOENT" }) };
+  assert.equal(classify(notFound).reason, "spawn_error");
+});
+
+test("ошибка запуска — сбой инструмента, а не находка", () => {
+  const r = classify(R({ status: null, signal: null, error: new Error("spawn ENOENT") }));
+  assert.equal(r.state, "infra_error");
+  assert.equal(r.reason, "spawn_error");
+});
+
+test("неожиданный код — сбой инструмента, а не находка", () => {
+  const r = classify(R({ status: 2 }));
+  assert.equal(r.state, "infra_error");
+  assert.equal(r.reason, "unexpected_exit");
+  assert.equal(r.code, 2);
+});
+
+// Знание о кодах живёт рядом с инструментом. Числа — из замера, а не из памяти.
+test("адаптеры знают свои коды: vulture 3 — находка, pylint 32 — ошибка вызова", () => {
+  assert.equal(classify(R({ status: 3 }), findingCodes("vulture")).state, "finding");
+  assert.equal(classify(R({ status: 1 }), findingCodes("vulture")).state, "infra_error");
+
+  assert.equal(classify(R({ status: 2 }), findingCodes("pylint")).state, "finding");
+  assert.equal(classify(R({ status: 24 }), findingCodes("pylint")).state, "finding");
+  assert.equal(classify(R({ status: 32 }), findingCodes("pylint")).state, "infra_error");
+
+  // Незнакомая программа — умолчание: 0 чисто, 1 находка, остальное сбой. Это ЧЕСТНЕЕ, чем
+  // догадка: неизвестный код становится «не знаем», а не «поймал».
+  assert.equal(classify(R({ status: 1 }), findingCodes("неизвестный-инструмент")).state, "finding");
+  assert.equal(classify(R({ status: 3 }), findingCodes("неизвестный-инструмент")).state, "infra_error");
+});
+
+test("наши собственные обёртки: 2 — «нет инструмента», а не находка", () => {
+  assert.equal(classify(R({ status: 2 }), findingCodes("bash")).state, "infra_error");
+});

package/tool/selfcheck/units-level.mjs

@@ -9,7 +9,7 @@
 //   node --test tool/selfcheck/units-level.mjs
 import test from "node:test";
 import assert from "node:assert/strict";
-import { commandFor } from "../lib/prove.mjs";
+import { commandFor, verdict } from "../lib/prove.mjs";
 import { assessLevel, layoutChecks, unknownKeys, KNOWN_KEYS, parseManifest, coversOf, coversUnproven, unparsedLines } from "../lib/manifest.mjs";
 import { pickLang, langFromText } from "../i18n/index.mjs";
 
@@ -266,3 +266,34 @@ test("правильный манифест не порождает жалоб",
 test("комментарии и пустые строки не считаются потерянными", () => {
   assert.deepEqual(unparsedLines("# заметка\n\naqk: 1\n   # ещё\n"), []);
 });
+
+// --- ВЕРДИКТ ДОКАЗАТЕЛЬСТВА: один доказанный гейт не покрывает недоказанный -------------
+// ЗАЧЕМ. Прежнее правило было `broken === 0 && proven > 0`. Оно позволяло ОДНОМУ доказанному
+// гейту компенсировать сколько угодно недоказанных: проект с пятью объявленными проверками,
+// из которых четыре не смогли отработать, получал AQK-2 за счёт пятой. Ступень называется
+// «гейты доказаны», а доказан был один.
+//
+// Различие тонкое и обязательное: «нечем доказывать» бывает ЗАКОННЫМ (нет образцов, нет
+// программы на этой машине, стоит рецепт под другой язык) — такое ступень не отнимает.
+// А «запускали и не смогло отработать» — это сбой, и он ступень отнимает: иначе таймаут
+// арбитра снова становится способом получить зелёное.
+test("сбой арбитра отнимает ступень, законная недоказуемость — нет", () => {
+  assert.equal(verdict([{ state: "proven" }]).ok, true);
+  assert.equal(verdict([]).ok, false, "доказывать нечего — не доказано");
+  assert.equal(verdict([{ state: "unprovable", why: "no-samples" }]).ok, false,
+    "ни один гейт не доказан");
+
+  // Законная недоказуемость рядом с доказанным гейтом ступень не отнимает.
+  assert.equal(verdict([
+    { state: "proven" },
+    { state: "unprovable", why: "needs-program" },
+  ]).ok, true);
+
+  // А вот сбой арбитра — отнимает, сколько бы соседей ни было доказано.
+  assert.equal(verdict([
+    { state: "proven" },
+    { state: "unprovable", why: "infra", reason: "timeout" },
+  ]).ok, false, "таймаут арбитра компенсирован соседним гейтом");
+
+  assert.equal(verdict([{ state: "proven" }, { state: "broken" }]).ok, false);
+});