agent-quality-kit 0.10.1 → 0.11.0

package/tool/commands/probe.mjs

@@ -21,12 +21,11 @@
 // удаляется. Не меняет манифест. Не роняет прогон: код возврата всегда 0 — это осмотр, а
 // не порог. Порог — у `doctor --run --min`.
 import { spawnSync } from "node:child_process";
-import { mkdtemp, mkdir, copyFile, rm, readdir, writeFile, readFile } from "node:fs/promises";
+import { mkdtemp, mkdir, copyFile, rm, readdir, writeFile, readFile, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, dirname, extname } from "node:path";
 import { readManifest } from "../lib/manifest.mjs";
-import { commandFor } from "../lib/prove.mjs";
-import { fixHotspots, probeVerdict } from "../lib/history.mjs";
+import { fixHotspots, probeSummary, probeVerdictPaired, countProbe } from "../lib/history.mjs";
 import { detectFacts, readCatalog, triggerVerdict } from "../lib/repo.mjs";
 import { CWD, GATES_SRC, TARGET_DIR, c, SELF, exists } from "../lib/core.mjs";
 import { probeState, probeEvery, PROBE_EVERY } from "../lib/cadence.mjs";
@@ -99,14 +98,43 @@ async function writeMark(now, blind, lines) {
   await writeFile(MARK(), body + "\n", "utf8");
 }
 
-// Гейты, которым можно подставить каталог. Команда записи каталога кончается каталогом
-// проверки; написанная руками — чем угодно, и подставлять там некуда. Ровно то же правило,
-// по которому `prove` объявляет запись недоказуемой, а не сломанной.
-function scanningGates(man) {
+
+// Отчего проба не состоялась. Раньше здесь было три состояния: гейты, чья команда не кончается
+// каталогом, объявлялись непригодными — подставить образец было некуда. С песочницей подставлять
+// в команду больше не нужно: образец кладётся в КОПИЮ ПРОЕКТА, а гейт запускается в ней как есть.
+// Поэтому пригодна любая непустая команда, и состояний осталось два.
+function gatesState(man) {
+  const gates = man?.gates && typeof man.gates === "object" && !Array.isArray(man.gates) ? man.gates : {};
+  const declared = Object.entries(gates)
+    .map(([name, raw]) => [name, String(raw || "").trim()])
+    .filter(([, cmd]) => cmd);
+  if (!declared.length) return { state: "none", declared: 0, probeable: 0 };
+  return { state: "ok", declared: declared.length, probeable: declared.length };
+}
+
+// Гейты, пригодные для пробы: все объявленные с непустой командой.
+function probeableGates(man) {
   const gates = man?.gates && typeof man.gates === "object" && !Array.isArray(man.gates) ? man.gates : {};
   return Object.entries(gates)
     .map(([name, raw]) => [name, String(raw || "").trim()])
-    .filter(([, cmd]) => cmd && /(\.|\.\/)$/.test(cmd));
+    .filter(([, cmd]) => cmd);
+}
+
+// Семьи расширений. Образец подбирается по ТОЧНОМУ расширению, и правило верное: питоновский
+// образец в проекте на TypeScript не проверит ничего, а покажет «не прикрыто» — ложная тревога
+// того же класса, что молчащий гейт, только наоборот.
+//
+// Но `.js` и `.mjs` — одно и то же содержимое, а не два языка. Прогон на самом комплекте
+// 2026-09-10: два горячих файла из пяти — `.mjs`, и обоим ответили «нет образца под .mjs»;
+// комплект целиком написан в этом расширении, то есть проба была слепа к собственному коду.
+// Заводить второй набор файлов ради той же строчки — дублирование, которое разойдётся.
+//
+// Семьи узкие намеренно: `.jsx`/`.tsx` сюда не входят, у них своя разметка.
+const EXT_FAMILIES = [[".js", ".mjs", ".cjs"], [".ts", ".mts", ".cts"]];
+
+function extAlternatives(ext) {
+  const fam = EXT_FAMILIES.find((f) => f.includes(ext));
+  return fam ? [ext, ...fam.filter((e) => e !== ext)] : [ext];
 }
 
 // Красный образец записи, подходящий по расширению горячего файла. Расширение обязано
@@ -117,39 +145,114 @@ async function redSampleFor(entry, ext) {
   if (!(await exists(dir))) return null;
   let names = [];
   try { names = await readdir(dir); } catch { return null; }
-  const hit = names.find((n) => extname(n).toLowerCase() === ext);
-  return hit ? join(dir, hit) : null;
+  for (const want of extAlternatives(ext)) {
+    const hit = names.find((n) => extname(n).toLowerCase() === want);
+    if (hit) return join(dir, hit);
+  }
+  return null;
+}
+
+// Песочница: КОПИЯ ПРОЕКТА, в которую подсаживается образец. Раньше здесь был временный каталог
+// с одним файлом, а путь к нему подставлялся в команду гейта — отчего пробовать можно было
+// только команды, кончающиеся каталогом. Замер 2026-09-10 на семи чужих репозиториях: у шести
+// команды такие (`xo`, `eslint lib/**/*.js`, `mocha --require…`, `pytest`), и проба не
+// запускалась вовсе.
+//
+// Способ взят из мутационного тестирования, где та же задача решена двадцать лет назад: Stryker
+// копирует проект во временный каталог, СИМЛИНКУЕТ `node_modules` и гоняет там родную команду.
+// Копируются только ОТСЛЕЖИВАЕМЫЕ файлы (`git archive HEAD`) — рабочее дерево не трогается, а
+// мусор сборки не тащится; тяжёлые каталоги зависимостей симлинкуются, иначе `npm test` в
+// песочнице падал бы с «модуль не найден», и это читалось бы как сбой инструмента.
+const DEP_DIRS = ["node_modules", ".venv", "venv", "vendor", "target", ".tox", ".bundle"];
+
+async function buildSandbox() {
+  // Копируется РАБОЧЕЕ ДЕРЕВО, а не HEAD. Первая версия брала `git archive HEAD`, и это было
+  // неверно: комплект зовут из хука ДО коммита, и пользователь пробует то, что у него сейчас,
+  // а не то, что уже записано. На свежем `init` + `add` без коммита проба вообще ничего не
+  // видела — гейты в песочнице отсутствовали и «не запускались».
+  //
+  // Список — `git ls-files --cached --others --exclude-standard`: отслеживаемые плюс новые, но
+  // БЕЗ игнорируемых. Игнорируемое — это сборка и зависимости; первое пробе не нужно, второе
+  // приходит симлинком.
+  //
+  // Копирование средствами node, а не `tar`: у конвейера есть windows-задание, и полагаться на
+  // ключи GNU tar там нельзя.
+  const r = spawnSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    cwd: CWD, encoding: "utf8", timeout: 60000, maxBuffer: 64 * 1024 * 1024,
+  });
+  if (r.status !== 0) return null;
+  const files = String(r.stdout || "").split("\0").filter(Boolean);
+  if (!files.length) return null;
+
+  const root = await mkdtemp(join(tmpdir(), "aqk-sandbox-"));
+  const made = new Set();
+  for (const rel of files) {
+    const dest = join(root, rel);
+    const dir = dirname(dest);
+    if (!made.has(dir)) { await mkdir(dir, { recursive: true }); made.add(dir); }
+    // Файл мог исчезнуть между списком и копией, а каталог — оказаться подмодулем.
+    try { await copyFile(join(CWD, rel), dest); } catch { /* пропускаем, не роняя пробу */ }
+  }
+  for (const dep of DEP_DIRS) {
+    const from = join(CWD, dep);
+    if (await exists(from)) { try { await symlink(from, join(root, dep), "junction"); } catch { /* уже есть */ } }
+  }
+  return root;
 }
 
-// Проба: временный каталог, в нём образец по пути горячего файла. Путь сохраняется целиком —
-// правила, привязанные к путям (`.aqkignore`, исключения гейтов), обязаны действовать так же,
-// как в настоящем репозитории. Без этого проба отвечала бы про несуществующее место.
-async function buildProbe(relPath, sample) {
-  const root = await mkdtemp(join(tmpdir(), "aqk-probe-"));
+// Подсадка образца на место горячего файла и возврат как было. Файл СНАЧАЛА удаляется:
+// в песочнице он может быть жёсткой ссылкой, и запись поверх задела бы оригинал.
+async function plant(root, relPath, sample) {
   const dest = join(root, relPath);
   await mkdir(dirname(dest), { recursive: true });
+  let backup = null;
+  try { backup = await readFile(dest); } catch { /* файла может не быть */ }
+  await rm(dest, { force: true });
   await copyFile(sample, dest);
-  // Переносится ТОЛЬКО .aqkignore: правила, привязанные к путям, обязаны действовать так же,
-  // как в настоящем репозитории. Манифест НЕ переносится намеренно — иначе записи, читающие
-  // `.aqk.yml` (`gates-are-runnable`, `gate-has-samples`, `protection-not-removed`), краснеют
-  // на том, что в пробе нет объявленных ими файлов, и проба объявляет класс прикрытым, хотя
-  // на подсаженный брак не отреагировал никто. Ошибка в сторону «прикрыто» — это тишина,
-  // а тишина здесь и есть предмет спора. Поймано первым же прогоном на своём репозитории.
-  if (await exists(join(CWD, ".aqkignore"))) {
-    await copyFile(join(CWD, ".aqkignore"), join(root, ".aqkignore"));
-  }
-  return root;
+  return async () => {
+    await rm(dest, { force: true });
+    if (backup !== null) await writeFile(dest, backup);
+  };
 }
 
-function runGates(gates, dir) {
+// Гейт запускается В ПЕСОЧНИЦЕ и командой КАК ЕСТЬ — ничего в неё не подставляется. Именно это
+// и делает пробу независимой от формы команды.
+//
+// `stopOnRed` — ранний выход: как только гейт покраснел, вердикт «поймано» уже получен, и гонять
+// остальные незачем. На сухом прогоне выхода нет: там нужны ВСЕ длительности и все коды.
+function runGates(gates, sandbox, { stopOnRed = false } = {}) {
   const out = [];
   for (const [name, cmd] of gates) {
-    const r = spawnSync(commandFor(cmd, dir), { shell: true, cwd: CWD, encoding: "utf8", timeout: 120000 });
-    out.push({ name, code: r.status === null ? 2 : r.status });
+    const t0 = Date.now();
+    const r = spawnSync(cmd, { shell: true, cwd: sandbox, encoding: "utf8", timeout: 120000 });
+    const code = r.status === null ? 2 : r.status;
+    out.push({ name, code, ms: Date.now() - t0 });
+    if (stopOnRed && code === 1) break;
   }
   return out;
 }
 
+// Каким гейтом пробовать и в каком порядке.
+//
+// Цена пробы = (файлы × записи) × сумма длительностей гейтов. На самом комплекте после перехода
+// на песочницу это стало больше десяти минут и упёрлось в таймаут: среди тридцати гейтов есть
+// `smoke` на 58 секунд, и он гонялся заново на каждую подсадку. Команда, идущая четверть часа,
+// не запускается никем.
+//
+// Длительности берутся из сухого прогона, который и так обязателен. Порядок — от быстрых к
+// медленным, чтобы ранний выход срабатывал раньше. Слишком медленные исключаются, но НЕ молча:
+// их имена обязаны попасть в вывод, иначе «никто не ловит» будет означать «никто из тех, кого
+// мы решили спросить».
+const SLOW_MS = 20000;
+
+function planProbeGates(before, { slowMs = SLOW_MS } = {}) {
+  const usable = before.filter((r) => r.code === 0).sort((a, b) => (a.ms || 0) - (b.ms || 0));
+  return {
+    use: usable.filter((r) => (r.ms || 0) <= slowMs),
+    tooSlow: usable.filter((r) => (r.ms || 0) > slowMs),
+  };
+}
+
 // `auto` — проба запущена САМА, по каденции, из `doctor --run`. Тогда она короче и говорит
 // вслух, почему случилась: команда, возникшая без спроса, обязана объяснить себя, иначе её
 // читают как сбой.
@@ -161,8 +264,9 @@ async function cmdProbe(args, { auto = false } = {}) {
   console.log(c.bold(`\n${P.title}\n`));
 
   const man = await readManifest();
-  const gates = scanningGates(man);
-  if (!gates.length) { console.log(c.yellow(`  ${P.noGates(`${SELF} add <имя>`)}\n`)); return; }
+  const gates = probeableGates(man);
+  const gs = gatesState(man);
+  if (gs.state === "none") { console.log(c.yellow(`  ${P.noGates(`${SELF} add <имя>`)}\n`)); return; }
 
   const raw = gitLog(2000);
   if (raw === null) { console.log(c.yellow(`  ${P.noGit}\n`)); return; }
@@ -175,9 +279,40 @@ async function cmdProbe(args, { auto = false } = {}) {
   const catalog = await readCatalog();
   const entries = catalog.filter((e) => triggerVerdict(e, facts).applies);
 
-  console.log(c.dim(`  ${P.method(hot.length, entries.length)}\n`));
+  // ПЕСОЧНИЦА строится ОДИН раз на прогон, а не на каждую пробу: копия отслеживаемых файлов
+  // стоит доли секунды, но умножать её на файлы × записи незачем — между пробами меняется
+  // ровно один файл.
+  const sandbox = await buildSandbox();
+  if (!sandbox) { console.log(c.yellow(`  ${P.noSandbox}\n`)); return; }
+
+  try {
+  // СУХОЙ ПРОГОН по чистой песочнице. Без него «покраснел от подсадки» неотличимо от «был
+  // красным и до неё»: у чужого проекта гейты краснеют на своём накопленном долге, и
+  // засчитывать эту красноту за поимку значит выдавать чужой долг за свою заслугу.
+  // В мутационном тестировании этот прогон обязателен по той же причине.
+  const before = runGates(gates, sandbox);
+  const plan = planProbeGates(before);
+  if (!plan.use.length) {
+    const red = before.filter((r) => r.code === 1).map((r) => r.name);
+    const broke = before.filter((r) => r.code !== 0 && r.code !== 1).map((r) => r.name);
+    if (plan.tooSlow.length) console.log(c.yellow(`  ${P.allSlow(plan.tooSlow.map((g) => g.name))}\n`));
+    else console.log(c.yellow(`  ${P.noBaseline(red, broke)}\n`));
+    return;
+  }
+  // Пробуем только запланированными, в порядке плана.
+  const byName = new Map(gates);
+  const probeGates = plan.use.map((g) => [g.name, byName.get(g.name)]);
+  const baseline = plan.use.map((g) => ({ name: g.name, code: g.code }));
+
+  console.log(c.dim(`  ${P.method(hot.length, entries.length, plan.use.length)}\n`));
+  if (plan.tooSlow.length) {
+    console.log(c.dim(`  ${P.tooSlow(plan.tooSlow.map((g) => `${g.name} (${Math.round(g.ms / 1000)}s)`))}\n`));
+  }
 
-  let blind = 0;
+  // Записи проб: по ним считаются КЛАССЫ, а не события. Счётчики на месте были
+  // событиями и втрое завышали итог — см. countProbe.
+  const records = [];
+  let unprobedN = 0;
   for (const { path: rel, fixes } of hot) {
     console.log(`  ${c.bold(rel)}  ${c.dim(P.fixes(fixes))}`);
     const ext = extname(rel).toLowerCase();
@@ -187,29 +322,50 @@ async function cmdProbe(args, { auto = false } = {}) {
       const sample = await redSampleFor(e.slug, ext);
       if (!sample) continue;
       probed++;
-      const dir = await buildProbe(rel, sample);
-      let results;
-      try { results = runGates(gates, dir); } finally { await rm(dir, { recursive: true, force: true }); }
-      const verdict = probeVerdict(results);
-      const caught = results.filter((r) => r.code === 1).map((r) => r.name);
+      const restore = await plant(sandbox, rel, sample);
+      let after;
+      try { after = runGates(probeGates, sandbox, { stopOnRed: true }); } finally { await restore(); }
+      // Ранний выход обрывает список: гейты, до которых не дошли, считаются такими же, как на
+      // сухом прогоне. Иначе их отсутствие прочиталось бы как сбой запуска.
+      const seen = new Set(after.map((a) => a.name));
+      const full = after.concat(baseline.filter((b) => !seen.has(b.name)));
+      const r = probeVerdictPaired(baseline, full);
+      const verdict = r.verdict;
+      const caught = full.filter((a) => a.code === 1 && baseline.find((b) => b.name === a.name)?.code === 0)
+        .map((a) => a.name);
+      records.push({ entry: e.slug, file: rel, verdict });
       if (verdict === "caught") {
         console.log(`    ${c.green("✔")}  ${e.intent.padEnd(48)} ${c.dim(P.caught(caught.join(", ")))}`);
       } else if (verdict === "blind") {
-        blind++;
         console.log(`    ${c.red("✘")}  ${e.intent.padEnd(48)} ${c.red(P.blind)}`);
         console.log(c.dim(`         ${P.install(`${SELF} add ${e.slug}`)}`));
       } else {
         console.log(`    ${c.dim("~")}  ${c.dim(e.intent.padEnd(48))} ${c.dim(P.unknown)}`);
       }
     }
-    if (!probed) console.log(c.dim(`    ${P.noSampleFor(ext || "—")}`));
+    if (!probed) { unprobedN++; console.log(c.dim(`    ${P.noSampleFor(ext || "—")}`)); }
   }
 
-  console.log(blind ? c.yellow(`\n  ${P.summaryBlind(blind)}\n`) : c.green(`\n  ${P.summaryClean}\n`));
+  const n = countProbe(records);
+  const blind = n.blindClasses;
+  const state = probeSummary({
+    caught: n.caughtClasses, blind, unknown: n.unknownClasses, unprobed: unprobedN,
+  });
+  const say = {
+    blind: () => c.yellow(P.summaryBlind(blind, n.probes)),
+    partial: () => c.yellow(P.summaryPartial(n.caughtClasses, n.unknownClasses, unprobedN)),
+    clean: () => c.green(P.summaryClean),
+    "nothing-ran": () => c.yellow(P.summaryNothingRan(n.unknownClasses)),
+    "nothing-probed": () => c.yellow(P.summaryNothingProbed(unprobedN)),
+  };
+  console.log(`\n  ${say[state]()}\n`);
 
   // Отметка нужна не для отчёта, а для КАДЕНЦИИ: по ней следующий прогон поймёт, что пора.
   // Без неё команда снова становится тем, о чём надо вспомнить.
   await writeMark(commitCount(), blind, hot.map(({ path: p2, fixes }) => `- ${p2} (${P.fixes(fixes)})`));
+  } finally {
+    await rm(sandbox, { recursive: true, force: true });
+  }
 }
 
 // Состояние пробы для тех, кто только ПОКАЗЫВАЕТ его: прогон и блок для агента.
@@ -225,4 +381,4 @@ async function probeStatus() {
   return probeState(await readMark(), commitCount(), every);
 }
 
-export { cmdProbe, probeStatus, scanningGates, isCode };
+export { cmdProbe, probeStatus, probeableGates, gatesState, extAlternatives, planProbeGates, isCode };

package/tool/commands/report.mjs

@@ -21,7 +21,7 @@ import { readManifest, assessLevel } from "../lib/manifest.mjs";
 import { proveGates } from "../lib/prove.mjs";
 import { detectFacts, readCatalog, triggerVerdict, whichSync } from "../lib/repo.mjs";
 import { changedCode, coverage, evidenceHash, readForHash } from "../lib/evidence.mjs";
-import { runGates, declaredGates, sinceRef } from "./doctor.mjs";
+import { runGates, declaredGates, sinceRef } from "../lib/run.mjs";
 import { L } from "../i18n/index.mjs";
 
 // Каким рецептом стоит гейт: родным инструментом или переносимой проверкой. Именно это

package/tool/i18n/en-gates.mjs

@@ -256,9 +256,10 @@ export const enGates = {
     autoFirst: "no coverage probe has ever run here — running it myself. Turn off: AQK_PROBE=0",
     auto: (n) => `${n} commits since the last probe — running it myself. Turn off: AQK_PROBE=0`,
     title: "aqk probe — what the declared checks cannot see",
-    method: (files, entries) =>
-      `method: a red sample from a catalogue entry is planted into a copy of each file, ` +
-      `then the DECLARED gates are run against it. Files: ${files}, applicable entries: ${entries}. ` +
+    method: (files, entries, gates) =>
+      `method: a red sample from a catalogue entry is planted into a COPY of the project, then the ` +
+      `DECLARED gates are run there — the command is used as written, nothing is substituted into it. ` +
+      `Files: ${files}, applicable entries: ${entries}, gates green on a clean checkout: ${gates}. ` +
       `The working tree is not touched.`,
     fixes: (n) => `fixes in history: ${n}`,
     caught: (names) => `caught by: ${names}`,
@@ -267,12 +268,25 @@ export const enGates = {
     install: (cmd) => `close it: ${cmd}`,
     noSampleFor: (ext) => `the catalogue has no red sample for "${ext}" — nothing to check with`,
     noGates: (cmd) => `no gates declared — nothing to probe with. First: ${cmd}`,
+    noSandbox: "could not build a sandbox: `git archive HEAD` failed. The probe needs a copy of the tracked files to plant a sample into — it never touches the working tree.",
+    noBaseline: (red, broke) =>
+      `nothing to judge by: on a CLEAN checkout ${red.length ? `these gates are ALREADY red (${red.join(", ")})` : ""}${red.length && broke.length ? " and " : ""}${broke.length ? `these failed to run (${broke.join(", ")})` : ""}. A gate that is red before the sample is planted says nothing about the sample. Get the pipeline green first, then repeat.`,
+    tooSlow: (names) => `not probed with (too slow to run on every planting): ${names.join(", ")}. If a class below is caught by nobody, one of these may still catch it — run them by hand.`,
+    allSlow: (names) => `every gate that is green on a clean checkout is too slow to probe with: ${names.join(", ")}. Probing would re-run them for every planting. Declare a fast gate, or run these by hand.`,
     noGit: "not a git repository — there is no fix history to read",
     noFixes: "no fix commits found: the subject starts with fix / bugfix / hotfix",
-    summaryBlind: (n) =>
-      `classes left uncovered: ${n}. This is not a judgement of the code: these are the places ` +
+    summaryBlind: (n, probes) =>
+      `classes caught by nobody: ${n}` +
+      (probes ? ` (over ${probes} plantings — one class repeated across several hot files is still ONE class)` : "") +
+      `. This is not a judgement of the code: these are the places ` +
       `people come back to with a fix, and defects none of your checks would see there.`,
     summaryClean: "in the places probed, every applicable class is caught by something.",
+    summaryPartial: (caught, unknown, unprobed) =>
+      `caught: ${caught}. Could NOT be checked: ${unknown} (the tool is missing, not the protection). Not probed at all: ${unprobed} file(s) — the catalogue has no red sample for their type. "Checked and clean", "not checked" and "not looked at" are three different facts and are not merged here.`,
+    summaryNothingRan: (n) =>
+      `NOTHING was checked: all ${n} probe(s) failed to run — the delegated tools are missing. This is not a clean result, it is the absence of a result. Install the tools, then repeat.`,
+    summaryNothingProbed: (unprobed) =>
+      `not a single probe was made${unprobed ? ` — ${unprobed} hot file(s) have no red sample for their type in the catalogue` : ""}. Nothing is known about coverage: this is the absence of a measurement, not a clean result.`,
   },
   prove: {
     title: "aqk prove — proving the gates",

package/tool/i18n/en.mjs

@@ -65,6 +65,9 @@ export const en = {
     gitignore: "repository hygiene",
     git: "project under version control",
 
+    rulesByHuman: (total, machine, human) =>
+      `${human} of ${total} rules in the entry point are guarded by a HUMAN, ${machine} by a machine.`,
+    rulesByHumanWhy: "A rule guarded by a human is guarded by nobody the day the human is busy. That is the hole this kit exists to close — and the reminder belongs to the human, not only to the agent. Counted in the ENTRY POINT only: a promise kept in any other file is checked by nothing at all, and this kit will not tell you it exists.",
     emptyCommands: (n) => `AGENTS.md has ${n} unfilled commands.`,
     emptyCommandsWhy: "An agent cannot execute an empty line.",
 

package/tool/i18n/ru-gates.mjs

@@ -258,9 +258,10 @@ export const ruGates = {
     autoFirst: "пробы покрытия здесь ещё не делали — делаю её сам. Выключить: AQK_PROBE=0",
     auto: (n) => `прошло ${n} коммитов с прошлой пробы — делаю её сам. Выключить: AQK_PROBE=0`,
     title: "aqk probe — чего объявленные проверки не видят",
-    method: (files, entries) =>
-      `метод: в копию каждого файла подсаживается красный образец записи каталога, ` +
-      `по нему прогоняются ОБЪЯВЛЕННЫЕ гейты. Файлов: ${files}, применимых записей: ${entries}. ` +
+    method: (files, entries, gates) =>
+      `способ: красный образец записи каталога подсаживается в КОПИЮ проекта, и там гоняются ` +
+      `ОБЪЯВЛЕННЫЕ гейты — команда берётся как написана, в неё ничего не подставляется. ` +
+      `Файлов: ${files}, применимых записей: ${entries}, гейтов зелёных на чистом дереве: ${gates}. ` +
       `Рабочее дерево не трогается.`,
     fixes: (n) => `починок в истории: ${n}`,
     caught: (names) => `ловит: ${names}`,
@@ -269,12 +270,25 @@ export const ruGates = {
     install: (cmd) => `закрыть: ${cmd}`,
     noSampleFor: (ext) => `в каталоге нет красного образца под «${ext}» — проверить нечем`,
     noGates: (cmd) => `гейтов не объявлено — пробовать нечем. Сначала: ${cmd}`,
+    noSandbox: "не удалось построить песочницу: `git archive HEAD` не отработал. Пробе нужна копия отслеживаемых файлов, чтобы подсадить в неё образец, — рабочее дерево она не трогает никогда.",
+    noBaseline: (red, broke) =>
+      `судить не по чему: на ЧИСТОМ дереве ${red.length ? `уже красные (${red.join(", ")})` : ""}${red.length && broke.length ? ", а " : ""}${broke.length ? `не запустились (${broke.join(", ")})` : ""}. Гейт, красный ДО подсадки, о подсадке не говорит ничего. Сначала позеленить конвейер, потом повторить.`,
+    tooSlow: (names) => `не пробовали ими (слишком долго гонять на каждую подсадку): ${names.join(", ")}. Если класс ниже не ловит никто — может ловить кто-то из них, проверьте руками.`,
+    allSlow: (names) => `все гейты, зелёные на чистом дереве, слишком медленны для пробы: ${names.join(", ")}. Проба гоняла бы их заново на каждую подсадку. Объявите быстрый гейт или прогоните эти руками.`,
     noGit: "это не репозиторий git — истории починок взять неоткуда",
     noFixes: "в истории не нашлось коммитов-починок: тема начинается с fix / исправ / почин",
-    summaryBlind: (n) =>
-      `не прикрыто классов: ${n}. Это не оценка кода: это места, куда возвращаются с починкой, ` +
-      `и брак, которого там не увидит ни одна ваша проверка.`,
+    summaryBlind: (n, probes) =>
+      `классов не ловит никто: ${n}` +
+      (probes ? ` (на ${probes} подсадках — один класс, повторённый по нескольким горячим файлам, остаётся ОДНИМ)` : "") +
+      `. Это не приговор коду: это места, куда возвращаются с починкой, и дефекты, ` +
+      `которых там не увидела бы ни одна ваша проверка.`,
     summaryClean: "в проверенных местах каждый применимый класс кто-то ловит.",
+    summaryPartial: (caught, unknown, unprobed) =>
+      `поймано: ${caught}. Проверить НЕ смогли: ${unknown} (не хватает инструмента, а не защиты). Не пробовали вовсе: файлов ${unprobed} — в каталоге нет красного образца их типа. «Проверено и чисто», «не проверено» и «не смотрели» — три разных факта, и здесь они не сливаются.`,
+    summaryNothingRan: (n) =>
+      `НЕ проверено ничего: все ${n} пробы не смогли запуститься — делегированные инструменты не установлены. Это не чистый результат, это отсутствие результата. Поставьте инструменты и повторите.`,
+    summaryNothingProbed: (unprobed) =>
+      `не сделано ни одной пробы${unprobed ? `: у ${unprobed} горячих файлов нет в каталоге красного образца их типа` : ""}. О прикрытии не известно ничего — это отсутствие замера, а не чистый результат.`,
   },
   prove: {
     title: "aqk prove — доказательство гейтов",

package/tool/i18n/ru.mjs

@@ -66,6 +66,9 @@ export const ru = {
     gitignore: "гигиена репозитория",
     git: "проект под контролем версий",
 
+    rulesByHuman: (total, machine, human) =>
+      `правил в точке входа: ${total}. Сторож — ЧЕЛОВЕК у ${human}, машина у ${machine}.`,
+    rulesByHumanWhy: "Правило со сторожем-человеком не сторожит никто в тот день, когда человек занят. Это та самая дыра, ради которой комплект и написан, — и напоминание про неё нужно человеку, а не только агенту. Считаны правила ТОЧКИ ВХОДА: обещание, живущее в любом другом файле, не проверяет вообще ничто, и комплект даже не скажет вам, что оно есть.",
     emptyCommands: (n) => `В AGENTS.md ${n} незаполненных команд.`,
     emptyCommandsWhy: "Агент не может выполнить пустую строку.",
 

package/tool/lib/history.mjs

@@ -9,7 +9,7 @@
 // брак возвращается; там и стоит спрашивать, смотрит ли на них хоть одна проверка.
 //
 // ЧТО ЭТО НЕ ЗНАЧИТ. Часто чинят и то, что часто меняют: рейтинг говорит «сюда возвращаются»,
-// а не «здесь плохо». Ответ на «прикрыто ли» даёт не он, а проба — см. probeVerdict.
+// а не «здесь плохо». Ответ на «прикрыто ли» даёт не он, а проба — см. probeVerdictPaired.
 
 // Признак починки берётся из ТЕМЫ коммита. Тема — единственное, что пишут все, и единственное,
 // что видно в `git log --oneline`.
@@ -71,12 +71,83 @@ function fixHotspots(raw, { isCode }) {
 // самый отказ, против которого написан весь комплект. Засчитать как «не прикрыто» — тоже
 // неправда: мы не знаем.
 //
-// Поймавший гейт сильнее непроверенного: класс закрыт, даже если рядом чего-то не хватает.
-function probeVerdict(results) {
-  if (results.some((r) => r.code === 1)) return "caught";
-  if (results.length === 0) return "unknown";
-  if (results.some((r) => r.code !== 0)) return "unknown";
-  return "blind";
+
+// Итог пробы по всем её исходам. Отдельная функция, а не тернарник на месте: исходов у
+// у пробы три, и пока веток было две, `unknown` молча падал в «поймано всё».
+//
+// Замер 2026-09-10 на проекте с чужими командами: единственная запись вернула «нечем
+// проверить — инструмент делегирован и не установлен», а итог сказал «каждый применимый
+// класс кем-то ловится». Ошибка запуска, выданная за чистоту, — то самое, ради чего
+// написан стандарт, в его собственной главной команде.
+//
+// Сочетания названы исчерпывающе. `partial` существует потому, что «поймано три, проверить
+// две не смогли» и «поймано три» — разные факты, и сливать их значит округлять в свою пользу.
+// `unprobed` — горячие файлы, которым проба не делалась ВОВСЕ: красного образца их расширения
+// в каталоге нет. Прогон на самом комплекте 2026-09-10: два `.mjs` из пяти горячих файлов не
+// пробовались никак, а итог говорил «каждый применимый класс кем-то ловится». Оговорка «в
+// пробованных местах» верна буквально и обманывает по смыслу — она молча сужает утверждение до
+// мест, где проба удалась. Поэтому «чисто» отвечается только при нуле пропущенных.
+function probeSummary({ caught = 0, blind = 0, unknown = 0, unprobed = 0 } = {}) {
+  if (blind) return "blind";
+  if (caught && (unknown || unprobed)) return "partial";
+  if (caught) return "clean";
+  if (unknown) return "nothing-ran";
+  return "nothing-probed";
+}
+
+// Парный вердикт: гейт прогнан ДВАЖДЫ — по чистой песочнице и по ней же с подсаженным
+// образцом. Так проба перестаёт зависеть от формы команды: `npm test`, `pytest`, `xo`,
+// `eslint lib/**/*.js` работают наравне с `bash check.sh .`.
+//
+// Замер 2026-09-10: у шести чужих репозиториев из семи команды каталогом не кончаются, и
+// старая проба на них не запускалась вовсе. Способ не выдуман — так устроено мутационное
+// тестирование: Stryker копирует проект во временный каталог, симлинкует `node_modules` и
+// гоняет РОДНУЮ команду; прогон по чистой копии там обязателен.
+//
+// Что исключается из суждения и почему:
+//   · сбой ЗАПУСКА (код не 0 и не 1) с любой стороны — про подсадку не сказано ничего;
+//   · гейт, красный ЕЩЁ ДО подсадки, — его краснота объясняется состоянием проекта, и
+//     засчитывать её за поимку значит выдавать чужой долг за свою заслугу;
+//   · гейт, ПОЗЕЛЕНЕВШИЙ от подсадки, — он смотрит не туда, и это тоже не поимка.
+// Исключены все — вердикт `unknown`, а не `blind`: «не по чему судить» и «никто не ловит»
+// разные факты, и молчание здесь и есть предмет спора.
+function probeVerdictPaired(before, after) {
+  const byName = new Map(after.map((r) => [r.name, r]));
+  let usable = 0, alreadyRed = 0, failed = 0, caught = 0;
+  for (const b of before) {
+    const a = byName.get(b.name);
+    const broke = (r) => !r || (r.code !== 0 && r.code !== 1);
+    if (broke(b) || broke(a)) { failed++; continue; }
+    if (b.code === 1) { alreadyRed++; continue; }
+    usable++;
+    if (a.code === 1) caught++;
+  }
+  const verdict = !usable ? "unknown" : caught ? "caught" : "blind";
+  return { verdict, usable, alreadyRed, failed, caught };
+}
+
+// Счёт непокрытого КЛАССАМИ, а не пробами. Замер на десяти живых репозиториях 2026-09-10:
+// у requests, click, flask и httpx проба сказала «непокрытых классов: 18», а различных классов
+// там ШЕСТЬ — повторены по трём горячим файлам. Втрое завышенное число, и завышали его мы сами
+// тем самым приёмом, который ловим у других: считали события, а называли их сущностями.
+//
+// Число проб остаётся отдельно: «шесть классов на трёх файлах» и «шесть на одном» — разные
+// факты. Класс, слепой ХОТЬ ГДЕ-ТО, считается непокрытым: «где-то ловится» не защищает то
+// место, где не ловится.
+function countProbe(records) {
+  const bins = { blind: new Set(), caught: new Set(), unknown: new Set() };
+  let probes = 0;
+  for (const { entry, verdict } of records) {
+    if (!bins[verdict]) continue;
+    bins[verdict].add(entry);
+    probes++;
+  }
+  return {
+    blindClasses: bins.blind.size,
+    caughtClasses: bins.caught.size,
+    unknownClasses: bins.unknown.size,
+    probes,
+  };
 }
 
-export { isFix, fixHotspots, probeVerdict };
+export { isFix, fixHotspots, probeSummary, probeVerdictPaired, countProbe };