agent-quality-kit 0.9.0 → 0.10.1

package/tool/selfcheck/smoke.sh

@@ -23,7 +23,15 @@ PASS=0
 FAIL=0
 
 ok()   { printf '  \033[32m✔\033[0m  %s\n' "$1"; PASS=$((PASS + 1)); }
-bad()  { printf '  \033[31m✘\033[0m  %s\n' "$1"; printf '      %s\n' "${2:-}"; FAIL=$((FAIL + 1)); }
+# Упавшие называются ПОИМЁННО И С ПРИЧИНОЙ в итоге, а не только по ходу. Прогон запускают гейтом, а вывод
+# упавшего гейта обрезается — и причина, напечатанная в середине двухсот строк, до глаз не
+# доезжает. Час поисков в конвейере 2026-09-09 стоил ровно этого: список красных был, а увидеть
+# его было нельзя. Имени мало: следующий круг конвейера показал имя и не показал причину —
+# она печатается сразу под находкой, то есть в середине, которую обрезка и съедает.
+FAILED_NAMES=""
+bad()  { printf '  \033[31m✘\033[0m  %s\n' "$1"; printf '      %s\n' "${2:-}"; FAIL=$((FAIL + 1));
+         FAILED_NAMES="${FAILED_NAMES:+$FAILED_NAMES
+  }$1 — ${2:-без пояснения}"; }
 
 # Node на Windows видит мир глазами Windows, а Git Bash — глазами POSIX: путь вида
 # /tmp/tmp.XXXX, отданный в `node -e`, там не существует, и проверка падает не на том, что
@@ -35,6 +43,35 @@ node_in() { D="$1"; shift; ( cd "$D" && node "$@" ); }
 WORK="$(mktemp -d)"
 trap 'rm -rf "$WORK"' EXIT
 
+# ГЕРМЕТИЧНОСТЬ. Три строки, каждая закрывает свой класс отказов, найденный сплошным чтением
+# и замерами 2026-09-09. Прогон обязан давать один и тот же ответ на любой машине и в любой
+# день — иначе «116 зелёных» означает не «работает», а «сегодня совпало».
+#
+# 1. TMPDIR внутрь $WORK. В файле 65 вызовов `mktemp -d` и ОДИН trap — на $WORK. Прерванный
+#    прогон оставлял 64 каталога, а два из них несут по копии всего дерева (`cp -r tool kit`,
+#    ≈4000 файлов). Одна строка вместо правки шестидесяти пяти: mktemp читает TMPDIR, и вся
+#    временная работа попадает под уже существующую уборку.
+# 2. HOME в песочницу. Комплект пишет `~/.config/aqk/feedback-shown` — просьбу про звезду
+#    показывают один раз НА МАШИНУ. Из 65 фикстур свой HOME задавали 8. Значит на машине
+#    разработчика (отметка лежит с сентября) `init` молчит, а на свежем раннере — говорит:
+#    один и тот же прогон получает РАЗНЫЙ ввод. Плюс прогон гадил в настоящий домашний каталог.
+# 3. AQK_UPDATE=0. `doctor --brief` ходит в реестр npm по сети с таймаутом 3 с — и только вне
+#    конвейера (`updateWanted` выключается при CI). То есть локально тесты сетевые, а в
+#    конвейере нет. Сеть в тестах — отдельный класс флейков во всех разборах; здесь она ещё и
+#    делает две среды разными по построению.
+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
+
 printf '\n\033[1mtool/selfcheck/smoke.sh\033[0m\n\n'
 
 # --- 1. синтаксис самой программы ------------------------------------------
@@ -345,10 +382,24 @@ if [ -f "$BLOBDIR/GOD_AI.md" ]; then
     bad "blob собрал не все методички" "в kit/docs $EXPECT_MD, в склейке $GOT_MD"
   fi
   # Ссылки на соседние файлы внутри склейки ведут в никуда: соседей рядом больше нет.
-  if grep -qE '\]\((?!https?:)[^)]*\.md\)' "$BLOBDIR/GOD_AI.md" 2>/dev/null; then
+  #
+  # ДВА ПРОХОДА, А НЕ ОПЕРЕЖАЮЩАЯ ПРОВЕРКА. Здесь стояло `grep -qE '...(?!https?:)...'`, и это
+  # была ЛОЖЬ: `(?!` — синтаксис PCRE, в POSIX ERE его нет. GNU grep печатает предупреждение и
+  # не находит ничего, ugrep падает с ошибкой разбора — в обоих случаях `if` уходит в `else`, и
+  # проверка печатала зелёное НА ЛЮБЫХ ДАННЫХ. Ровно тот грех, ради поимки которого написан весь
+  # комплект, внутри прибора, который его ищет. Найдено сплошным чтением 2026-09-09.
+  #
+  # Поэтому же ниже проверяется САМА ПРОВЕРКА: подделываем склейку с относительной ссылкой и
+  # требуем, чтобы её нашли. Без этого следующая такая опечатка снова проедет зелёной.
+  rel_links() { grep -oE '\]\([^)]+\.md[^)]*\)' "$1" 2>/dev/null | grep -vE '^\]\(https?:' | grep -q .; }
+  printf '%s' "$(cat "$BLOBDIR/GOD_AI.md")" > "$BLOBDIR/doctored.md"
+  printf '\nсм. [соседний файл](other.md)\n' >> "$BLOBDIR/doctored.md"
+  if rel_links "$BLOBDIR/GOD_AI.md"; then
     bad "в склейке остались ссылки на соседние файлы" "внутри одного файла они ведут в никуда"
+  elif ! rel_links "$BLOBDIR/doctored.md"; then
+    bad "проверка ссылок не может покраснеть" "подделанная склейка с относительной ссылкой прошла"
   else
-    ok "ссылки на соседние файлы в склейке сняты"
+    ok "ссылки на соседние файлы сняты, и проверка это умеет заметить"
   fi
 else
   bad "blob не создал GOD_AI.md" "$BLOBDIR"
@@ -579,7 +630,7 @@ REPDIR="$(mktemp -d)"
 (
   cd "$REPDIR" && git init -q . && mkdir -p src &&
   printf 'a = 1  # noqa\n' > src/a.py &&
-  node "$CLI" start > /tmp/aqk-start.log 2>&1
+  node "$CLI" start > "$WORK/start.log" 2>&1
 )
 REP_OUT=$( cd "$REPDIR" && node "$CLI" report 2>&1 ); REP_CODE=$?
 if [ "$REP_CODE" -ne 0 ] && printf '%s' "$REP_OUT" | grep -q '❌ gate-not-weakened'; then
@@ -591,7 +642,7 @@ else
   G_LS=$( cd "$REPDIR" && ls gates 2>&1 | tr '\n' ' ' )
   G_DECL=$( cd "$REPDIR" && sed -n '/^gates:/,$p' .aqk.yml 2>/dev/null | grep -cE '^[[:space:]]+[A-Za-z0-9_-]+:' )
   G_OUT=$( cd "$REPDIR" && bash gates/gate-not-weakened/check.sh . 2>&1 | head -2 ); G_CODE=$?
-  bad "report не отличает красное от зелёного" "код отчёта $REP_CODE; гейт напрямую: код $G_CODE, вывод «$(printf '%s' "$G_OUT" | tr '\n' ' ')»; в gates/: «$G_LS»; объявлено гейтов: $G_DECL; хвост start: «$(tail -4 /tmp/aqk-start.log 2>/dev/null | tr '\n' ' ')»"
+  bad "report не отличает красное от зелёного" "код отчёта $REP_CODE; гейт напрямую: код $G_CODE, вывод «$(printf '%s' "$G_OUT" | tr '\n' ' ')»; в gates/: «$G_LS»; объявлено гейтов: $G_DECL; хвост start: «$(tail -4 "$WORK/start.log" 2>/dev/null | tr '\n' ' ')»"
 fi
 if [ -f "$REPDIR/.aqk/report.md" ] && grep -q '^## ' "$REPDIR/.aqk/report.md"; then
   ok "report сохраняет .aqk/report.md"
@@ -681,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
@@ -1731,7 +1787,7 @@ rm -rf "$PRVP"
 # и шесть `units-*.mjs`), и заметить это можно было только сверкой руками. Тот же класс, что
 # «гейт объявлен и не существует»: расхождение молчит.
 MISSING=""
-for F in "$ROOT"/tool/lib/*.mjs "$ROOT"/tool/commands/*.mjs "$ROOT"/tool/selfcheck/*; do
+for F in "$ROOT"/tool/lib/*.mjs "$ROOT"/tool/commands/*.mjs "$ROOT"/tool/selfcheck/* "$ROOT"/tool/selfcheck/*/*; do
   B=$(basename "$F")
   grep -qF "$B" "$ROOT/AGENTS.md" || MISSING="$MISSING $B"
 done
@@ -1786,6 +1842,132 @@ else
 fi
 chmod 700 "$HOMEH" 2>/dev/null; rm -rf "$HOMEP" "$HOMEH"
 
+# --- 109. probe: находит слепоту и не выдаёт её за покрытие ---------------------
+# ЗАЧЕМ КОМАНДА. `doctor` говорит «держит машина N» — N из чего? `prove` доказывает, что гейт
+# ловит брак НА СВОЁМ образце. Ни один не отвечает: что в ЭТОМ репозитории не прикрыто ничем.
+# Замер 2026-09-09 на самом комплекте: настоящий файл, подсаженные проглоченная ошибка и печать,
+# 21 объявленный гейт — покраснело НОЛЬ. Узнать об этом было нечем.
+# Проверяются ОБА конца: класс, который объявленный гейт ловит, обязан быть зелёным, а тот,
+# которого не ловит никто, — красным. Проверка одного конца пропустила бы команду, которая
+# всегда говорит «не прикрыто», и команду, которая всегда говорит «прикрыто».
+PRBP="$(mktemp -d)"
+(
+  cd "$PRBP" && git init -q . && git config user.email a@b && git config user.name a
+  mkdir -p src && printf 'def send(to):\n    return 1\n' > src/mailer.py
+  git add -A && git commit -qm "feat: почта"
+  printf '# правка\n' >> src/mailer.py && git add -A && git commit -qm "fix: письма не уходили"
+  node "$CLI" init && node "$CLI" add todo-without-task
+  # Коммитим ВСЁ, что положили init и add: иначе дерево грязное ещё до пробы, и проверка
+  # «probe ничего не пишет» меряла бы мою же фикстуру, а не команду.
+  git add -A && git commit -qm "Сделано: комплект. Не уверен: ничего"
+) >/dev/null 2>&1
+PRB=$( cd "$PRBP" && AQK_LANG=ru node "$CLI" probe --top 1 2>&1 ); PRB_C=$?
+# Слепое: secrets-not-in-code не объявлен, образец под .py у него есть — обязан быть красным.
+# Прикрытое: todo-without-task объявлен — обязан быть зелёным и назвать, кто поймал.
+if [ "$PRB_C" -eq 0 ] &&
+   printf '%s' "$PRB" | grep -q "НЕ ЛОВИТ НИКТО" &&
+   printf '%s' "$PRB" | grep -q "ловит: todo-without-task" &&
+   printf '%s' "$PRB" | grep -q "починок в истории: 1"; then
+  ok "probe: слепые классы названы, прикрытый назван поимённо, прогон не уронен"
+else
+  bad "probe не различает слепое и прикрытое" "код $PRB_C, слепых $(printf '%s' "$PRB" | grep -c 'НЕ ЛОВИТ'), пойманных $(printf '%s' "$PRB" | grep -c 'ловит:')"
+fi
+# КОД человека проба не трогает: образец живёт во временном каталоге. Если бы он попал в
+# репозиторий, команда осмотра стала бы командой правки — и её выключили бы в тот же день.
+# Своя отметка каденции — исключение, и единственное: она лежит в `.aqk/`, там же, где отчёт
+# прогона, и без неё каденция невозможна (следующий прогон не узнает, что проба была).
+# Проверяется именно это разделение: за пределами `.aqk/` — ни следа.
+DIRTY=$( cd "$PRBP" && git status --porcelain | grep -cv ' \.aqk/' )
+if [ "$DIRTY" -eq 0 ]; then
+  ok "probe не трогает код: пишет только свою отметку в .aqk/"
+else
+  bad "probe оставил следы вне .aqk/" "$(cd "$PRBP" && git status --porcelain | grep -v ' \.aqk/' | head -3 | tr '\n' ' ')"
+fi
+rm -rf "$PRBP"
+
+# --- 111. проба случается САМА, один раз, и попадает агенту в контекст -----------
+# ГЛАВНОЕ В ЭТОЙ ПРОВЕРКЕ — не механика, а замысел. Владелец сформулировал так: «команду, о
+# которой надо вспомнить, агент не вспомнит, а человек о ней не узнает». Это тот же класс, что
+# файл, который можно не прочитать, — и весь комплект написан против него. Значит `probe`,
+# оставленная ручной, отвечает на важнейший вопрос и не задаётся никем.
+# Проверяются три вещи, и каждая — отдельный способ провалиться:
+#   1. прогон делает пробу САМ, когда её не делали;
+#   2. второй прогон подряд её НЕ повторяет — иначе каденция превращается в шум;
+#   3. агент узнаёт результат из блока состояния, не зная про команду.
+CADP="$(mktemp -d)"
+(
+  cd "$CADP" && git init -q . && git config user.email a@b && git config user.name a
+  mkdir -p src && printf 'def s():\n    return 1\n' > src/a.py
+  git add -A && git commit -qm "feat: старт"
+  printf '# п\n' >> src/a.py && git add -A && git commit -qm "fix: не работало"
+  node "$CLI" init && node "$CLI" add todo-without-task
+) >/dev/null 2>&1
+CTX0=$( cd "$CADP" && AQK_LANG=ru node "$CLI" context 2>&1 )
+RUN1=$( cd "$CADP" && AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
+RUN2=$( cd "$CADP" && AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
+CTX1=$( cd "$CADP" && AQK_LANG=ru node "$CLI" context 2>&1 )
+if printf '%s' "$CTX0" | grep -q "НЕИЗВЕСТНО" &&
+   printf '%s' "$RUN1" | grep -q "ещё не делали" &&
+   ! printf '%s' "$RUN2" | grep -q "ещё не делали" &&
+   printf '%s' "$CTX1" | grep -q "Не прикрыто ничем"; then
+  ok "проба запускается прогоном сама, не повторяется и попадает агенту в контекст"
+else
+  bad "каденция пробы не работает" \
+      "до: $(printf '%s' "$CTX0" | grep -c 'НЕИЗВЕСТНО'), первый: $(printf '%s' "$RUN1" | grep -c 'ещё не делали'), второй: $(printf '%s' "$RUN2" | grep -c 'ещё не делали'), после: $(printf '%s' "$CTX1" | grep -c 'Не прикрыто')"
+fi
+# Выключатель обязан быть у всего, что случается само: иначе первый же, кому это помешало,
+# выключит весь прогон, а не одну пробу.
+CADP2="$(mktemp -d)"
+( cd "$CADP2" && git init -q . && git config user.email a@b && git config user.name a
+  mkdir -p src && printf 'def s():\n    return 1\n' > src/a.py
+  git add -A && git commit -qm "feat: старт"
+  node "$CLI" init && node "$CLI" add todo-without-task ) >/dev/null 2>&1
+OFF=$( cd "$CADP2" && AQK_PROBE=0 AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
+if ! printf '%s' "$OFF" | grep -q "ещё не делали"; then
+  ok "AQK_PROBE=0 выключает пробу, не трогая прогон"
+else
+  bad "проба игнорирует выключатель" "AQK_PROBE=0 не подействовал"
+fi
+rm -rf "$CADP" "$CADP2"
+
+# --- переехавшие проверки: встроенный раннер --------------------------------
+# ПОЧЕМУ ЗДЕСЬ МОСТ, А НЕ ВТОРАЯ КОМАНДА. Проверки переезжают на `node --test` по одной, и всё
+# это время у прогона обязана оставаться ОДНА точка входа и ОДИН счётчик: два числа в двух
+# местах через месяц разойдутся, и никто не заметит, что половина не запускается.
+#
+# ЗАЧЕМ ПЕРЕЕЗД. У встроенного раннера есть то, чего нет у этого файла и не появится: свой
+# каталог и уборка на каждую проверку, таймаут на каждую, точечный перезапуск одной по имени
+# (`--test-name-pattern`). Диагностика отказа падает с сорока секунд до одной. Проверено на
+# Node 20.20.2 — той версии, что стоит в конвейере.
+NODE_SMOKE="$ROOT/tool/selfcheck/smoke"
+if [ -d "$NODE_SMOKE" ]; then
+  NS_OUT=$(cd "$ROOT" && node --test --test-reporter=tap "$NODE_SMOKE"/*.test.mjs 2>&1)
+  # Разбираем только верхний уровень TAP: вложенные строки идут с отступом.
+  while IFS= read -r NS_LINE; do
+    case "$NS_LINE" in
+      "ok "*)     ok "${NS_LINE#*- }" ;;
+      "not ok "*)
+        # ОБЪЯСНЕНИЕ ОБЯЗАНО ДОЕХАТЬ. Первая редакция моста печатала только «не прошло» и совет
+        # запустить вручную — то есть отправляла гадать ровно там, где ответ уже был получен.
+        # Стоило это трёх кругов конвейера: проверка падала только на раннере, а сообщение
+        # утверждения оставалось в выводе, который мост выбрасывал. TAP кладёт его в блок после
+        # строки `not ok`, полем `error:`.
+        # TAP кладёт многострочное сообщение блочным скаляром: строка `error: |-`, а сам текст
+        # идёт следующими строками с отступом. Первая редакция брала только строку `error:` и
+        # печатала «|-» — то есть снова ничего.
+        NS_WHY=$(printf '%s\n' "$NS_OUT" | awk '
+          /^[[:space:]]+error:/ { inerr = 1; sub(/^[[:space:]]*error:[[:space:]]*/, ""); if ($0 != "|-" && $0 != "") print; next }
+          inerr && /^[[:space:]]+(code|stack|failureType|type|duration_ms):/ { inerr = 0 }
+          inerr && /^[[:space:]]*\.\.\.[[:space:]]*$/ { inerr = 0 }
+          inerr { sub(/^[[:space:]]+/, ""); print }
+        ' | head -6 | tr '\n' ' ')
+        bad "${NS_LINE#*- }" "${NS_WHY:-подробности: node --test $NODE_SMOKE/*.test.mjs}" ;;
+    esac
+  done <<EOF
+$(printf '%s\n' "$NS_OUT" | grep -E '^(ok|not ok) ')
+EOF
+fi
+
 # --- итог -------------------------------------------------------------------
 printf '\n'
 if [ "$FAIL" -eq 0 ]; then
@@ -1795,4 +1977,9 @@ else
 fi
 
 printf '  \033[2mне покрыто: СОДЕРЖАНИЕ документов (сверяется опись и структура, не текст),\n  установка с GitHub через npx\033[0m\n\n'
+
+# ИМЕНА УПАВШИХ — САМОЙ ПОСЛЕДНЕЙ СТРОКОЙ, и это не косметика. Прогон запускают гейтом, а вывод
+# упавшего гейта обрезается: видно голову и хвост. Значит единственное место, где список
+# гарантированно доедет до глаз, — конец. Проверено прогоном с нарочно сломанной проверкой.
+[ "$FAIL" -eq 0 ] || printf '  \033[31mупало: %s\033[0m\n\n' "$FAILED_NAMES"
 exit "$FAIL"

package/tool/selfcheck/units-cadence.mjs

@@ -0,0 +1,69 @@
+// Проверки каденции пробы. Написаны ДО кода.
+//
+// ЗАЧЕМ ЭТО ВООБЩЕ. Владелец сформулировал точнее, чем было в замысле: «команду, о которой надо
+// вспомнить, агент не вспомнит, а человек о ней не узнает». Это тот же класс, что файл, который
+// можно не прочитать, — и решать его надо так же: не напоминанием, а тем, что оно случается
+// само. Единица — коммиты, а не сутки: репозиторий, в котором месяц не работали, перепроверять
+// незачем, а сто коммитов за день перепроверить надо.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { probeDue, probeState, probeEvery, PROBE_EVERY } from "../lib/cadence.mjs";
+
+test("порог по умолчанию — сто коммитов, и он назван числом, а не спрятан", () => {
+  assert.equal(PROBE_EVERY, 100);
+});
+
+test("проба нужна, когда с прошлой прошло не меньше порога", () => {
+  assert.equal(probeDue({ at: 100 }, 199, 100), false);
+  assert.equal(probeDue({ at: 100 }, 200, 100), true);
+  assert.equal(probeDue({ at: 100 }, 350, 100), true);
+});
+
+// Пробы не было НИКОГДА — это не «свежая». Молчание здесь означало бы «всё прикрыто»,
+// а прикрыто ли — неизвестно.
+test("если пробы не было вовсе — она нужна", () => {
+  assert.equal(probeDue(null, 1, 100), true);
+  assert.equal(probeDue({}, 500, 100), true);
+});
+
+// История короче порога: проба всё равно нужна один раз, иначе новый репозиторий узнает,
+// чего он не видит, только на сто первом коммите.
+test("в молодом репозитории проба нужна сразу, а не после сотого коммита", () => {
+  assert.equal(probeDue(null, 3, 100), true);
+});
+
+test("счётчик коммитов неизвестен — состояние неизвестно, а не «свежо»", () => {
+  assert.equal(probeDue({ at: 10 }, null, 100), false);
+});
+
+// Состояние для человека и для агента: три исхода, и они не сливаются.
+test("состояние пробы: не делалась, устарела, свежая", () => {
+  assert.deepEqual(probeState(null, 40, 100), { state: "never", behind: null });
+  assert.deepEqual(probeState({ at: 10 }, 40, 100), { state: "fresh", behind: 30 });
+  assert.deepEqual(probeState({ at: 10 }, 210, 100), { state: "stale", behind: 200 });
+  assert.deepEqual(probeState({ at: 10 }, null, 100), { state: "unknown", behind: null });
+});
+
+// Порог — свойство ПРОЕКТА, а не наше: сто коммитов на репозитории с десятком коммитов в час
+// это трижды в день, а на редком проекте столько не наберётся никогда.
+test("порог берётся из манифеста, умолчание остаётся при пустом поле", () => {
+  assert.equal(probeEvery({ probe: "250" }), 250);
+  assert.equal(probeEvery({ probe: 250 }), 250);
+  assert.equal(probeEvery({}), PROBE_EVERY);
+  assert.equal(probeEvery(null), PROBE_EVERY);
+  assert.equal(probeEvery({ probe: "" }), PROBE_EVERY);
+});
+
+// Ноль — это «не делать», а не «делать всегда»: выключатель в манифесте нужен тому, кто не
+// может передать переменную окружения, — например конвейеру чужой площадки.
+test("ноль выключает пробу", () => {
+  assert.equal(probeEvery({ probe: 0 }), 0);
+  assert.equal(probeDue(null, 5, 0), true);
+});
+
+// Неразобранное значение обязано быть НАЗВАНО, а не подменено умолчанием: иначе в манифесте
+// написано одно, а происходит другое — ровно та тихая неправда, против которой весь комплект.
+test("непонятое значение порога — null, а не тихое умолчание", () => {
+  assert.equal(probeEvery({ probe: "часто" }), null);
+  assert.equal(probeEvery({ probe: -5 }), null);
+});

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);
+});