agent-quality-kit 0.10.1 → 0.12.0

package/kit/gates/secrets-not-in-code/gate.yml

@@ -4,7 +4,27 @@ intent_en: keys, passwords and private keys do not end up in the code
 trigger:
   always: true
 
+# Домашние страницы готовых инструментов, которые зовут рецепты ниже. Адреса сверены
+# по реестру github 2026-09-10, а не написаны по памяти: три выдуманных адреса чужих
+# репозиториев — записанная шишка комплекта.
+tool: https://github.com/gitleaks/gitleaks
+
 recipes:
+  # Готовый аналог сильнее нашего, и об этом прямо сказано в README записи: `gitleaks` знает
+  # сотни форматов токенов и умеет читать историю, а не только рабочее дерево. Наша проверка —
+  # запасная, для тех, кто не хочет ставить лишний бинарь.
+  #
+  # Ключ `native`, а не язык: секреты ищутся в любом файле, и раскладывать одну команду по
+  # восьми языкам значило бы завести ровно тот повтор, против которого у нас есть гейт.
+  #
+  # `dir` — рабочее дерево; чтение истории (`gitleaks git`) сюда не берём: гейт обязан отвечать
+  # про ТЕКУЩЕЕ состояние, а прошлое лечится не проверкой, а ротацией ключа.
+  #
+  # ОСТОРОЖНО С КОДОМ ВОЗВРАТА: у `gitleaks` 1 означает «нашёл ЛИБО сломался» — по документации,
+  # проверено 2026-09-10. То есть для него «находка» и «сбой инструмента» неразличимы, и это
+  # ровно тот класс, который мы разделяем у себя. Пока принимаем как есть и говорим об этом
+  # вслух, а не делаем вид, что кодов три.
+  native: gitleaks dir --no-banner {dir}
   any: bash {gate}/check.sh {dir}
 
 proof: kit/docs/ai/project-baseline.md, пункт 5 — «секреты не хранятся в коде вообще: ни в истории, ни в примерах, ни в тестах»

package/kit/gates/secrets-not-in-code/green/config.js

@@ -0,0 +1,4 @@
+// Ключ приходит из окружения. В коде остаётся только его ИМЯ — это не секрет.
+export const STRIPE_KEY = process.env.STRIPE_KEY;
+
+if (!STRIPE_KEY) throw new Error("STRIPE_KEY не задан: см. .env.example");

package/kit/gates/secrets-not-in-code/red/leak.js

@@ -0,0 +1,6 @@
+// Ключ в коде: он уедет в историю git и останется там навсегда.
+//
+// Строка намеренно КОРОЧЕ настоящего ключа Stripe и повторяет ту, что лежит в leak.go:
+// правдоподобный ключ блокирует защита GitHub от секретов, и образец нельзя отправить в
+// репозиторий вовсе.
+export const STRIPE_KEY = "sk_live_51HxxQwErTyUiOpAsDfGh";

package/kit/gates/swallowed-error/gate.yml

@@ -7,11 +7,16 @@ intent_en: an error is not silently swallowed — it is handled and logged, or r
 trigger:
   langs: python, javascript, typescript, go
 
+# Домашние страницы готовых инструментов, которые зовут рецепты ниже. Адреса сверены
+# по реестру github 2026-09-10, а не написаны по памяти: три выдуманных адреса чужих
+# репозиториев — записанная шишка комплекта.
+tool: https://github.com/astral-sh/ruff · https://github.com/eslint/eslint · https://github.com/kisielk/errcheck
+
 recipes:
   # BLE — ловля голого исключения, TRY400 — запись без трейса, SIM105 — перехват ради тишины.
-  python: ruff check --select BLE,TRY400,SIM105 {dir}
-  typescript: eslint --rule '{"no-empty":["error",{"allowEmptyCatch":false}]}' {dir}
-  javascript: eslint --rule '{"no-empty":["error",{"allowEmptyCatch":false}]}' {dir}
+  python: ruff check -q --output-format=concise --select BLE,TRY400,SIM105 {dir}
+  typescript: eslint --no-config-lookup --ignore-pattern 'gates/*/red/**' --ignore-pattern 'gates/*/green/**' --rule '{"no-empty":["error",{"allowEmptyCatch":false}]}' {dir}
+  javascript: eslint --no-config-lookup --ignore-pattern 'gates/*/red/**' --ignore-pattern 'gates/*/green/**' --rule '{"no-empty":["error",{"allowEmptyCatch":false}]}' {dir}
   # errcheck — канонический инструмент Go под этот же предмет: ошибка присвоена и не проверена.
   go: errcheck -blank {dir}/...
 

package/kit/gates/test-has-assertion/check.sh

@@ -25,6 +25,13 @@ if [ ! -f "$SKIP_LIB" ]; then
   exit 2
 fi
 . "$SKIP_LIB"
+# Файл на месте — этого мало: подмена содержимого давала код 0. Метка стоит в КОНЦЕ _skip.sh,
+# поэтому проверка ловит и обрыв файла на середине.
+if [ "${AQK_SKIP_READY:-}" != 1 ]; then
+  echo "_skip.sh есть, но обход не собрался — проверка НЕ СОСТОЯЛАСЬ, а не прошла"
+  echo "  почини: замени kit/gates/_skip.sh целым файлом из каталога"
+  exit 2
+fi
 
 # Только файлы тестов. Слово «assert» в обычном коде — не тест, а проверка входа.
 FILES=$(find "$DIR" $(skip_find) -type f \( \

package/kit/gates/test-has-assertion/green/checkout.test.js

@@ -0,0 +1,5 @@
+import { checkout } from "./checkout.js";
+
+it("считает корзину", async () => {
+  expect(await checkout({ items: [1, 2] })).toEqual({ total: 3 });
+});

package/kit/gates/test-has-assertion/red/checkout.test.js

@@ -0,0 +1,8 @@
+import { checkout } from "./checkout.js";
+
+it("считает корзину", async () => {
+});
+
+it("не пускает пустую корзину", () => {
+  expect(true).toBe(true);
+});

package/kit/gates/test-not-adjusted/check.sh

@@ -56,8 +56,14 @@ if [ -d "$DIR/before" ] && [ -d "$DIR/after" ]; then
   REPO="$T"; RANGE="HEAD~1..HEAD"
 else
   if ! (cd "$DIR" 2>/dev/null && git rev-parse --git-dir >/dev/null 2>&1); then
-    echo "не git-репозиторий — проверять нечего"
-    exit 0
+    # НЕ «проверять нечего», а «проверить нечем»: без истории свидетель слеп, и код 0 здесь
+    # неотличим от «проверено и чисто». Договор комплекта: 0 — чисто, 1 — находка, остальное —
+    # не смогли. Тот же довод уже записан ниже про мелкий клон и в protection-not-removed:
+    # когда свидетель слеп, зеленеть нельзя.
+    echo "не git-репозиторий — историю смотреть нечем, проверка НЕ СОСТОЯЛАСЬ"
+    echo "  почини: запусти проверку в репозитории, либо убери запись из манифеста —"
+    echo "  почини: гейт, который не может посмотреть, не защищает ничего."
+    exit 2
   fi
   # Диапазон: по умолчанию последний коммит. Проект может назвать свой — так же, как это
   # делает `doctor --since`.

package/kit/gates/todo-without-task/check.sh

@@ -15,6 +15,13 @@ if [ ! -f "$SKIP_LIB" ]; then
   exit 2
 fi
 . "$SKIP_LIB"
+# Файл на месте — этого мало: подмена содержимого давала код 0. Метка стоит в КОНЦЕ _skip.sh,
+# поэтому проверка ловит и обрыв файла на середине.
+if [ "${AQK_SKIP_READY:-}" != 1 ]; then
+  echo "_skip.sh есть, но обход не собрался — проверка НЕ СОСТОЯЛАСЬ, а не прошла"
+  echo "  почини: замени kit/gates/_skip.sh целым файлом из каталога"
+  exit 2
+fi
 
 # shellcheck disable=SC2086
 # Маркер обязан стоять В КОММЕНТАРИИ. Иначе гейт краснеет на имени переменной с таким же

package/kit/gates/todo-without-task/gate.yml

@@ -4,10 +4,15 @@ intent_en: "fix later" markers are absent from finished code — a filed task re
 trigger:
   always: true
 
+# Домашние страницы готовых инструментов, которые зовут рецепты ниже. Адреса сверены
+# по реестру github 2026-09-10, а не написаны по памяти: три выдуманных адреса чужих
+# репозиториев — записанная шишка комплекта.
+tool: https://github.com/astral-sh/ruff · https://github.com/eslint/eslint
+
 recipes:
   any: bash {gate}/check.sh {dir}
   # Готовое правило точнее самописного и не требует поддержки.
-  python: ruff check --select FIX,TD {dir}
-  typescript: eslint --rule '{"no-warning-comments":["error",{"terms":["todo","fixme","hack","xxx"]}]}' {dir}
+  python: ruff check -q --output-format=concise --select FIX,TD {dir}
+  typescript: eslint --no-config-lookup --ignore-pattern 'gates/*/red/**' --ignore-pattern 'gates/*/green/**' --rule '{"no-warning-comments":["error",{"terms":["todo","fixme","hack","xxx"]}]}' {dir}
 
 proof: incidents/README.md — «2026-08-25 разбор 1069 коммитов»: 416 коммитов из 1069 оказались стабилизацией уже выкаченного

package/kit/gates/todo-without-task/green/app.js

@@ -0,0 +1,2 @@
+// XXX_LIMIT — имя переменной, а не маркер долга: слово внутри идентификатора долгом не делает.
+export const XXX_LIMIT = 10;

package/kit/gates/todo-without-task/red/later.js

@@ -0,0 +1,4 @@
+export function send(to) {
+  // TODO: переписать на очередь
+  return deliver(to);
+}

package/llms.txt

@@ -3,7 +3,9 @@
 > A standard and a CLI that check whether a repository is ready to have its code written by AI
 > coding agents. Every rule the project promises to follow becomes a command with an exit code,
 > so a machine holds the promise instead of somebody's attention. Reports a level from AQK-0 to
-> AQK-3, computed by a run — never by a questionnaire and never by a model's opinion.
+> AQK-3, computed by a run — never by a questionnaire and never by a model's opinion. One step
+> further than readiness scores: `probe` plants a known defect into a copy of the project and
+> checks whether the DECLARED guards go red. "Tests exist" and "tests catch" are different claims.
 
 Vendor-neutral: works with any coding agent (Claude Code, Codex, Cursor, Gemini CLI, GitHub
 Copilot, Windsurf, Aider, OpenCode) and with no AI at all. It calls no vendor API and needs no
@@ -68,7 +70,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.1` with `min: 1`
+- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.12.0` 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.1",
+  "version": "0.12.0",
   "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/badge.mjs

@@ -10,7 +10,7 @@ import { join } from "node:path";
 import { CWD, SELF, REPO_URL, c, exists, die } from "../lib/core.mjs";
 import { readManifest, assessLevel } from "../lib/manifest.mjs";
 import { proveGates } from "../lib/prove.mjs";
-import { runGates, declaredGates } from "./doctor.mjs";
+import { runGates, declaredGates } from "../lib/run.mjs";
 import { L } from "../i18n/index.mjs";
 
 // Один разбор на запись и на чтение: значок, который мы печатаем, обязан читаться нами же.

package/tool/commands/context.mjs

@@ -80,7 +80,9 @@ function contextBlock(state, T = L.context) {
     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 if (pr.blind > 0) out.push(T.probeBlind(pr.blind, pr.state === "stale" ? pr.behind : 0,
+      (pr.classes || []).map((b) => `${b.slug} (${b.file})`).join(", ")));
     else out.push(T.probeClean(pr.state === "stale" ? pr.behind : 0));
   }
 

package/tool/commands/doctor.mjs

@@ -5,13 +5,16 @@ import { join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { scopeOutput, splitAdvice, changedFiles } from "../lib/scope.mjs";
 import { CWD, PKG_ROOT, TARGET_DIR, MANIFEST, SELF, c, exists, die } from "../lib/core.mjs";
-import { cmdProbe, probeStatus } from "./probe.mjs";
+import { cmdProbe, probeStatus, blindAdvice } from "./probe.mjs";
 import { readManifest, assessLevel, unknownKeys, KNOWN_KEYS, advisorySet, layoutChecks, coversOf, coversUnproven, unparsedLines } from "../lib/manifest.mjs";
 import { proveGates } from "../lib/prove.mjs";
-import { detectFacts, readCatalog, triggerVerdict, browserServerAdvice } from "../lib/repo.mjs";
+import { detectFacts, readCatalog, triggerVerdict, browserServerAdvice, startWith } from "../lib/repo.mjs";
+import { proposeGates, ADOPT_FILES, ADOPT_SCRIPTS } from "../lib/adopt.mjs";
 import { assessBaseline, DEP_FILES, BASELINE_TOTAL } from "../lib/baseline.mjs";
 import { L } from "../i18n/index.mjs";
+import { countArbiters } from "./context.mjs";
 import { beginBrief, finishBrief } from "../lib/brief.mjs";
+import { declaredGates, sinceRef, runGates, progress } from "../lib/run.mjs";
 
 // Обязательный минимум проекта — прогоном, а не по памяти. До сих пор это было единственное
 // место, где комплект просил верить на слово, что человек прочитал методичку и сверился.
@@ -48,7 +51,7 @@ async function reportBaseline(man, facts) {
   );
 }
 
-async function reportCatalog(man, facts) {
+async function reportCatalog(man, facts, probe = null) {
   const catalog = await readCatalog();
   if (!catalog.length) return;
 
@@ -115,6 +118,70 @@ async function reportCatalog(man, facts) {
     console.log(c.dim(`\n  ${L.doctor.notApplicable(skip.length)}`));
     for (const [rec, why] of skip) console.log(c.dim(`  ·  ${rec.slug.padEnd(22)} ${why}`));
   }
+  // ЧТО У ВАС УЖЕ ЕСТЬ — до итога и до списка крестов. Комплект, поставленный в проект с
+  // eslint, mocha и конвейером, показывал двадцать крестов и «держит машина 0»: мы считали
+  // только СВОИ записи, а чужие проверки не читали вовсе. С точки зрения владельца это
+  // неправда, и первое, что он видел, было обвинением. Предлагаем, а не вписываем: гейт в
+  // чужом манифесте без спроса — наше решение в чужом файле.
+  if (!declaredGates(man).length) {
+    const files = {};
+    for (const n of ADOPT_FILES) {
+      try { files[n] = await readFile(join(CWD, n), "utf8"); } catch { /* нет — и ладно */ }
+    }
+    for (const n of ADOPT_SCRIPTS) if (await exists(join(CWD, n))) files[n] = "";
+    const found = proposeGates(files);
+    if (found.length) {
+      console.log(`\n  ${c.bold(L.doctor.haveAlready(found.length))}`);
+      for (const g of found) {
+        console.log(`  ${c.green("✔")}  ${g.name.padEnd(12)} ${c.dim(`${g.cmd}   ← ${g.source}`)}`);
+      }
+      console.log(c.dim(`     ${L.doctor.haveAlreadyHow(found.map((g) => `${g.name}: "${g.cmd}"`).join("  "))}`));
+    }
+  }
+
+  // ЧТО ВАШИ ПРОВЕРКИ ПРОПУСТИЛИ. Проба знала имена непойманных классов и писала в отметку одно
+  // число; человек в `doctor` не видел ничего. Это самое конкретное, что мы знаем о проекте, —
+  // не «хорошая практика», а брак, подсаженный в ЕГО файл и ЕГО проверками не замеченный, —
+  // поэтому стоит выше списка «с чего начать». Читается из файла: ничего не запускает.
+  const blindOnes = (probe?.classes || []).map((b) => [b, catalog.find((r) => r.slug === b.slug)]).filter(([, r]) => r);
+  if (blindOnes.length) {
+    console.log(`\n  ${c.yellow("⚠")}  ${c.bold(L.doctor.blindHeading(probe.behind))}`);
+    for (const [b, rec] of blindOnes) {
+      // Три случая, и сливать их нельзя. Гейт стоял и проба его ГОНЯЛА — «стоит, но здесь не
+      // ловит», самое ценное. Гейт объявлен, но проба его не гоняла (поставлен позже или
+      // медленный) — «поймает ли, покажет следующая», а не «пойман». Гейта нет — совет.
+      const ranIt = probe.ran?.has(rec.slug);
+      const now = facts.gateKeys.includes(rec.slug);
+      console.log(`  ${now && !ranIt ? c.dim("~") : c.red("✘")}  ${rec.slug.padEnd(22)} ${c.dim(`${rec.intent || ""}  ← ${b.file}`)}`);
+      if (ranIt) { console.log(c.dim(`     ${L.doctor.blindRan(rec.slug)}`)); continue; }
+      if (now) { console.log(c.dim(`     ${L.doctor.blindInstalled}`)); continue; }
+      const adv = blindAdvice(rec, facts, {});
+      if (adv.command) console.log(c.dim(`     ${L.doctor.startCmd(adv.command)}`));
+      else console.log(c.dim(`     ${L.doctor.install(`${SELF} add ${rec.slug}`)}`));
+    }
+    console.log(c.dim(`     ${L.doctor.blindMore(`${SELF} probe`)}`));
+  } else if (probe?.state === "never" && declaredGates(man).length) {
+    console.log(c.dim(`\n  ${L.doctor.probeNever(`${SELF} probe`)}`));
+  }
+
+  // С ЧЕГО НАЧАТЬ. Двадцать одинаковых крестов — это ноль требований: закрывают первое
+  // попавшееся или не закрывают ничего. Порядок не по нашему вкусу: сперва то, что родилось из
+  // настоящего отказа И закрывается одной готовой командой.
+  if (todo.length > 3) {
+    const first = startWith(todo, facts, 3);
+    console.log(`\n  ${c.bold(L.doctor.startWith)}`);
+    for (const rec of first) {
+      const adv = blindAdvice(rec, facts, {});
+      console.log(`  ${c.yellow("→")}  ${rec.slug.padEnd(22)} ${c.dim(rec.intent || "")}`);
+      if (adv.command) console.log(c.dim(`     ${L.doctor.startCmd(adv.command)}`));
+      if (adv.tool) console.log(c.dim(`     ${L.doctor.startTool(adv.tool)}`));
+    }
+    // Одна проверка руками — это разовый героизм. Сказать про хук здесь, а не в конце: человек
+    // читает первые строки и закрывает, а именно сейчас у него в руках список того, что стоит
+    // повесить перед пушем.
+    console.log(c.dim(`\n     ${L.doctor.startHook}`));
+  }
+
   console.log(
     `\n  ${c.bold(L.doctor.total)} ${L.doctor.totalHeld(held.length)}, ${L.doctor.totalTodo(c.yellow(todo.length))}, ` +
       (byOther.length ? `${L.doctor.totalCovered(byOther.length)}, ` : "") +
@@ -125,153 +192,6 @@ async function reportCatalog(man, facts) {
   return { held: held.length, todo: todo.length, todoRecs: todo };
 }
 
-// «Гейт объявлен» и «гейт работает» — разные утверждения. Первое читается из манифеста,
-// второе узнаётся только запуском. Пока doctor верил манифесту на слово, уровень означал
-// добросовестность автора, а не факт — ровно то, от чего мы защищаемся.
-//
-// Запуск чужих команд — по явной просьбе (--run), а не втихую: гейт бывает долгим и с
-// побочными действиями. Без флага doctor честно говорит, что не проверял.
-
-function declaredGates(man) {
-  const g = man?.gates && typeof man.gates === "object" && !Array.isArray(man.gates) ? man.gates : {};
-  return Object.entries(g)
-    .map(([name, cmd]) => [name, String(cmd || "").trim()])
-    .filter(([, cmd]) => cmd);
-}
-
-// Ссылка, относительно которой сужается вывод: `--since main`, `--since HEAD~5`.
-// Без значения флаг бессмыслен — молча взять умолчание нельзя: «сужено не тем» неотличимо
-// от «не сужено».
-function sinceRef(argv = process.argv) {
-  const i = argv.indexOf("--since");
-  if (i === -1) return null;
-  const v = argv[i + 1];
-  return v && !v.startsWith("-") ? v : null;
-}
-
-function runGates(man, opts = {}) {
-  const gates = declaredGates(man);
-  if (!gates.length) return { failed: 0, ran: 0, results: [] };
-  const advisory = advisorySet(man);
-
-  // Сужение по дифу — договор с человеком, и он должен видеть, ЧТО именно сужено. Пустой диф
-  // называется вслух: иначе «все гейты зелёные» означало бы «сравнили не с тем» и читалось бы
-  // как успех. Это тот же класс, что и весь стандарт, только внутри нашего флага.
-  const scoped = opts.since ? changedFiles(opts.since, CWD) : null;
-  if (opts.since && scoped === null) die(L.doctor.sinceBadRef(opts.since));
-  if (scoped) console.log(c.dim(`\n  ${L.doctor.sinceHeading(opts.since, scoped.size)}`));
-
-  console.log(c.bold(`\n  ${L.doctor.runHeading}\n`));
-  let failed = 0;
-  const results = [];
-
-  for (const [name, cmd] of gates) {
-    const t0 = Date.now();
-    const r = spawnSync(cmd, { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
-    const secs = (Math.max(0, Date.now() - t0) / 1000).toFixed(1);
-    // Вывод гейта запоминается целиком (с потолком, чтобы болтливый инструмент не съел память):
-    // по нему считается покрытие дифа — какой файл вообще был назван хоть одной проверкой.
-    // Без этого «готово = доказано» остаётся правилом, за которым следит только человек.
-    const outAll = `${r.stdout || ""}${r.stderr || ""}`.slice(0, 200000);
-
-    if (r.error && r.error.code === "ETIMEDOUT") {
-      console.log(`  ${c.red("✘")}  ${name.padEnd(14)} ${c.red(L.doctor.timeout)}`);
-      failed++;
-      results.push({ name, cmd, ok: false, secs, note: L.doctor.timeout, out: outAll });
-      continue;
-    }
-    const code = r.status;
-    if (code === 0) {
-      // Совещательный называется и когда он зелёный. Иначе гейт, который уронить прогон НЕ
-      // МОЖЕТ, по выводу неотличим от того, который может, — и список `advisory:` в манифесте
-      // виден только в тот день, когда он покраснел. Измерено 2026-09-09: зелёный
-      // совещательный печатался обычной галочкой, а README обещал, что список назван каждый
-      // прогон. Тот же класс, что молчащий гейт, только про сам прибор.
-      const quiet = advisory.has(name) ? ` ${c.yellow(L.doctor.advisoryQuiet)}` : "";
-      console.log(`  ${c.green("✔")}  ${name.padEnd(14)}${quiet} ${c.dim(`${secs}s · ${cmd}`)}`);
-      // Зелёный гейт иногда всё-таки говорит человеку что-то важное: храповик, дошедший до цели,
-      // просит убрать обёртку. Вывод успешного гейта не показывался вовсе, и это сообщение
-      // уходило в никуда — тот же класс, что обрезанный совет у красного, только тише.
-      // Показываем ровно строки с меткой совета: остальной вывод успешной проверки — шум.
-      const okAdvice = splitAdvice(`${r.stdout || ""}${r.stderr || ""}`.trim().split("\n").filter(Boolean)).advice;
-      for (const line of okAdvice.slice(0, 6)) console.log(c.yellow(`        ${line.trim().slice(0, 110)}`));
-      results.push({ name, cmd, ok: true, secs, advisory: advisory.has(name), out: outAll });
-    } else {
-      const raw = `${r.stdout || ""}${r.stderr || ""}`.trim().split("\n").filter(Boolean);
-      // Совет отделяется ДО сужения. Иначе он сам попадает под фильтр по путям: сообщение
-      // храповика про вышедший срок называет путь к реестру, реестра в дифе нет, и гейт,
-      // обязанный краснеть по сроку, печатался зелёным с пометкой «находки вне дифа».
-      // Ровно то, что стандарт запрещает: срок без последствия. Найдено ревью 2026-09-06.
-      const parted = splitAdvice(raw);
-      let out = parted.findings;
-      const alwaysAdvice = parted.advice;
-
-      // Сужение до дифа. Три исхода, и все три называются вслух.
-      if (scoped) {
-        const s = scopeOutput(out, scoped);
-        // Гейт, у которого находок нет вовсе, а есть только совет, сузить нечем: его вердикт
-        // не про файлы. Признать такой успешным — вернуть ту же тишину другим путём.
-        if (!s.scopable || out.length === 0) {
-          // Гейт печатает вердикт без путей — сузить нечем. Признать его успешным значило бы
-          // выдать провал за тишину; остаётся красным, и причина названа.
-          // Совещательный не роняет прогон НИКОГДА — в том числе здесь. Раньше failed++ стоял
-          // безусловно, и гейт, объявленный совещательным, валил сборку с `--since` только
-          // потому, что в его выводе нет путей. Измерено 2026-09-09.
-          const nsAdv = advisory.has(name);
-          const nsMark = nsAdv ? c.yellow("!") : c.red("✘");
-          const nsVerdict = nsAdv ? c.yellow(L.doctor.advisoryMark) : c.red(L.doctor.exitCode(code));
-          console.log(`  ${nsMark}  ${name.padEnd(14)} ${nsVerdict} ${c.dim(`· ${L.doctor.notScopable}`)}`);
-          if (!nsAdv) failed++;
-          results.push({ name, cmd, ok: false, secs, code, advisory: nsAdv, note: L.doctor.notScopable, out: outAll });
-          continue;
-        }
-        if (s.findings === 0) {
-          // Долг есть, но не в том, что внёс диф. Зелёный — но с числом спрятанного: молчаливое
-          // «всё хорошо» здесь было бы неправдой.
-          const sQuiet = advisory.has(name) ? ` ${c.yellow(L.doctor.advisoryQuiet)}` : "";
-          console.log(`  ${c.green("✔")}  ${name.padEnd(14)}${sQuiet} ${c.dim(`${secs}s · ${L.doctor.outsideDiff(out.length)}`)}`);
-          results.push({ name, cmd, ok: true, secs, advisory: advisory.has(name), scopedAway: out.length, out: outAll });
-          continue;
-        }
-        out = s.kept;
-      }
-
-      failed++;
-      // Находки обрезаются, совет — никогда. Все записи каталога печатают «почини: …» последней
-      // строкой, и при обрезке до трёх строк человек не видел именно её: находка без действия
-      // закрывает окно, а не дефект.
-      // Совещательный гейт показывает находки и не роняет прогон. Знак другой, чтобы «показано»
-      // и «провалено» не читались одинаково; в сводке ниже он назван поимённо.
-      const isAdvisory = advisory.has(name);
-      if (isAdvisory) failed--;
-      const mark = isAdvisory ? c.yellow("!") : c.red("✘");
-      const verdict = isAdvisory ? c.yellow(L.doctor.advisoryMark) : c.red(L.doctor.exitCode(code));
-      console.log(`  ${mark}  ${name.padEnd(14)} ${verdict} ${c.dim(`· ${secs}s · ${cmd}`)}`);
-      // ГОЛОВА И ХВОСТ, А НЕ ТОЛЬКО ГОЛОВА. Гейт, который сам является прогоном (наш `smoke`),
-      // печатает сотни строк, и вердикт у него в конце — при обрезке до первых трёх человек
-      // видел «программа разбирается» и ни слова о том, что упало. Час поисков в конвейере
-      // 2026-09-09 стоил ровно этого. Голова нужна тоже: у сканирующих записей находки идут
-      // с первой строки.
-      const HEAD = 3, TAIL = 2;
-      for (const line of out.slice(0, HEAD)) console.log(c.dim(`        ${line.slice(0, 100)}`));
-      if (out.length > HEAD + TAIL) {
-        console.log(c.dim(`        ${L.doctor.moreLines(out.length - HEAD - TAIL)}`));
-        for (const line of out.slice(-TAIL)) console.log(c.dim(`        ${line.slice(0, 100)}`));
-      } else {
-        for (const line of out.slice(HEAD)) console.log(c.dim(`        ${line.slice(0, 100)}`));
-      }
-      // Совет тоже не бесконечен: гейт, зовущий помощник шесть раз, печатает его шесть раз.
-      for (const line of alwaysAdvice.slice(0, 6)) console.log(c.yellow(`        ${line.trim().slice(0, 110)}`));
-      results.push({ name, cmd, ok: false, secs, code, advisory: isAdvisory, out: outAll });
-    }
-  }
-  // Совещательные, которые покраснели, называются вслух ВСЕГДА. Молчание о них — ровно та
-  // тишина, против которой построен стандарт: проверка выключена, а выглядит как её отсутствие.
-  const advisoryFailed = results.filter((x) => x.advisory && !x.ok).map((x) => x.name);
-  if (advisoryFailed.length) console.log(`\n  ${c.yellow(L.doctor.advisorySummary(advisoryFailed))}`);
-  return { failed, ran: gates.length, results, advisoryFailed };
-}
-
 // Короткий отчёт «что из этого реально брали» — не для человека, а для агента в следующей
 // сессии и для самого владельца: список объявленных гейтов молчит о том, сколько из них
 // действительно стоят и работают именно СЕЙЧАС. Перезаписывается каждым прогоном, не копится:
@@ -328,6 +248,21 @@ async function cmdDoctor() {
   const agents = join(CWD, entryFile);
   if (await exists(agents)) {
     const text = await readFile(agents, "utf8");
+
+    // Сколько обещаний НЕ сторожит машина. Считалось и печаталось это давно — но только в
+    // блоке `context`, который читает АГЕНТ. Человеку, который и назначен сторожем, `doctor`
+    // не говорил ни слова: единственный, кто обязан помнить о непроверяемом обещании, был
+    // единственным, кому о нём не сообщали.
+    //
+    // Найдено не нами: отчёт живого проекта 2026-09-10 — «всё, что касается масштаба, помечено
+    // aqk: человек. AQK отработал честно: потребовал назвать сторожа, мы назвали — и сторож не
+    // проверил». В нашем собственном своде так помечены 12 правил из 14.
+    const arb = countArbiters(text, ["человек", "human", "nobody"]);
+    if (arb.total && arb.human) {
+      console.log(`\n  ${c.yellow("!")}  ${L.doctor.rulesByHuman(arb.total, arb.machine, arb.human)}`);
+      console.log(c.dim(`     ${L.doctor.rulesByHumanWhy}`));
+    }
+
     const emptyCommands = (text.match(/^- [^:]+: ``$/gm) || []).length;
     if (emptyCommands) {
       console.log(
@@ -357,7 +292,11 @@ async function cmdDoctor() {
   // Доказательство считается только при прогоне: узнать, ловит ли гейт брак, нельзя иначе как
   // запустив его по образцу. Без прогона ступени со второй помечаются «не доказано» — это
   // честнее, чем показывать их выполненными по наличию папок.
+  // Доказательство — секунды тишины до первой строки уровня; строка «идёт» их называет.
+  const bar = progress();
+  if (process.argv.includes("--run")) bar.show(c.dim(`  ⋯  ${L.doctor.proving}`));
   const proof = process.argv.includes("--run") ? await proveGates(man) : null;
+  bar.clear();
   const { reached, steps } = await assessLevel(man, proof);
 
   console.log(c.bold(`\n  ${L.doctor.levelHeading}\n`));
@@ -404,7 +343,10 @@ async function cmdDoctor() {
     await reportBaseline(man, facts);
     process.exit(0);
   }
-  const cat = (await reportCatalog(man, facts)) || { held: 0, todo: 0, todoRecs: [] };
+  // Состояние пробы — из файла отметки, миллисекунды. Нет его — блок про пробу просто молчит.
+  let probe = null;
+  try { probe = await probeStatus(); } catch { /* пробы нет — и ладно */ }
+  const cat = (await reportCatalog(man, facts, probe)) || { held: 0, todo: 0, todoRecs: [] };
 
   // «Объявлен» ≠ «работает». Без --run говорим это вслух, а не молчим.
   const wantRun = process.argv.includes("--run");
@@ -489,4 +431,4 @@ async function cmdDoctor() {
 
 // Наружу — только команда. Остальное здесь же и используется: экспорт, который никто не
 // импортирует, читается как «это часть договора» и мешает менять внутренности.
-export { cmdDoctor, runGates, declaredGates, sinceRef };
+export { cmdDoctor };

package/tool/commands/gates.mjs

@@ -15,6 +15,7 @@ import {
 } from "../lib/repo.mjs";
 import { GATE_YML_TEMPLATE, CHECK_SH_TEMPLATE, README_TEMPLATE } from "../lib/templates.mjs";
 import { L } from "../i18n/index.mjs";
+import { gateCommand } from "../lib/execution.mjs";
 
 // Ставит гейт из каталога в проект. Проверка КОПИРУЕТСЯ в репозиторий, а не остаётся
 // ссылкой в пакет: при установке через npx пакет временный, и завтра команда в манифесте
@@ -230,7 +231,7 @@ async function cmdRatchet(args) {
 
   // Снимок текущих нарушений — это и есть долг. Ключ без номера строки: правка соседней
   // строки не должна читаться как новое нарушение.
-  const r = spawnSync(inner, { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
+  const r = spawnSync(gateCommand(inner), { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
   if (r.status === 127 || (r.error && r.error.code === "ENOENT")) {
     die(L.ratchet.notRunnable(slug, inner));
   }
@@ -438,7 +439,7 @@ async function cmdWhy(args) {
 
   // --- 3. объявлен: спрашиваем у него самого ---------------------------------
   console.log(c.dim(`  ${L.why.declaredAs(cmd)}`));
-  const r = spawnSync(String(cmd), { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
+  const r = spawnSync(gateCommand(String(cmd)), { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
   const ci = await runsInCi(slug, String(cmd));
 
   if (r.status === 127 || (r.error && r.error.code === "ENOENT")) {