agent-quality-kit 0.9.0 → 0.10.0

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

@@ -0,0 +1,4 @@
+pub fn send(to: &str) -> bool {
+    // FIXME: переписать на очередь
+    deliver(to)
+}

package/llms.txt

@@ -47,6 +47,13 @@ Zero runtime dependencies. Node 18+ and an `sh` shell. MIT.
   config is an intention, not a guard), does the agent receive the state, is the version current.
   Four states, not two: connected · BROKEN · not connected and that is a choice · could not look.
   Only BROKEN affects the exit code
+- See what your declared checks CANNOT see: `npx agent-quality-kit probe` — takes the files your
+  own fix history calls hot, plants a proven red sample from the catalogue into a copy of each,
+  and runs YOUR declared gates against it. Coverage is not declared, it is proven by planting.
+  Three states that never merge: caught · nothing catches it · nothing to check with. Measured on
+  the kit itself: a real file, a swallowed error and a debug print planted, 21 declared gates,
+  none went red. The working tree is untouched and the exit code is always 0 — a look, not a
+  threshold
 - See what you told the agent and never wrote down: `npx agent-quality-kit learn` — reads Claude Code
   transcripts for this project on this machine and prints rule candidates missing from the entry
   point. Current project only, terminal only, writes nothing, always exits 0
@@ -56,13 +63,12 @@ Zero runtime dependencies. Node 18+ and an `sh` shell. MIT.
   package itself; there are no dependencies to pull in.
 - Without Node at all (a Python, Go or Rust project where nobody installed it):
   `docker run --rm -u "$(id -u):$(id -g)" -v "$PWD:/work" ghcr.io/arsen-ask-lx/aqk doctor`.
-  Published from v0.9.0 onward, by the same run that publishes the package; before that tag,
-  build it from the repository: `docker build -t aqk . && docker run --rm -u "$(id -u):$(id -g)"
-  -v "$PWD:/work" aqk doctor`. Keep the `--user` flag: without it the container runs as root and
+  Pushed to the registry by the same run, from the same tag, that publishes the package.
+  Keep the `--user` flag: without it the container runs as root and
   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.9.0` with `min: 1`
+- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.10.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.9.0",
+  "version": "0.10.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": {
@@ -44,6 +44,7 @@
   "knip": {
     "entry": [
       "tool/selfcheck/units*.mjs",
+      "tool/selfcheck/smoke/*.test.mjs",
       "tool/selfcheck/lifecycle.mjs"
     ],
     "project": [

package/tool/commands/context.mjs

@@ -25,6 +25,7 @@ import { spawnSync } from "node:child_process";
 import { join } from "node:path";
 import { CWD, TARGET_DIR, SELF, c, exists, commandRows } from "../lib/core.mjs";
 import { readManifest, assessLevel } from "../lib/manifest.mjs";
+import { probeStatus } from "./probe.mjs";
 import { L } from "../i18n/index.mjs";
 
 // Больше пяти имён подряд агент всё равно не удержит, а блок ради них раздувается. Остаток
@@ -63,6 +64,18 @@ function contextBlock(state, T = L.context) {
   const rat = (state.ratchets || []).slice(0, MAX_RATCHETS);
   if (rat.length) out.push(T.ratchets(rat.map((r) => `${r.name} (${r.count})`).join(", ")));
 
+  // ЧТО НЕ ПРИКРЫТО НИЧЕМ — сюда попадает потому, что иначе об этом не узнает никто. Команду
+  // `probe` надо вспомнить, а агент не вспомнит: это тот же класс, что файл, который можно не
+  // прочитать. Блок читается по построению, поэтому знание живёт здесь, а не в команде.
+  // Состояние «не делалась» печатается как НЕИЗВЕСТНО, а не опускается: молчание тут
+  // прочиталось бы как «всё прикрыто», а прикрыто ли — мы не знаем.
+  const pr = state.probe;
+  if (pr) {
+    if (pr.state === "never") out.push(T.probeNever);
+    else if (pr.blind > 0) out.push(T.probeBlind(pr.blind, pr.state === "stale" ? pr.behind : 0));
+    else out.push(T.probeClean(pr.state === "stale" ? pr.behind : 0));
+  }
+
   // ПОЛНЫЙ БЛОК — решение владельца от 2026-09-08, принятое ПОСЛЕ возражения и вопреки ему.
   // Возражение было такое: вход, растущий в длину, роняет качество у всех проверенных моделей,
   // и свод, влитый целиком, даёт правило, которое в контексте есть и не выполняется. Ответ
@@ -233,6 +246,20 @@ async function cmdContext(args = []) {
     if (run) run.stale = runIsStale(run.when);
   }
 
+  // Проба: сколько классов не ловит никто и насколько отметка отстала. Читается из файла,
+  // ничего не запускает — блок обязан укладываться в секунду.
+  let probe = null;
+  try {
+    const st = await probeStatus();
+    let blind = null;
+    const mark = join(CWD, TARGET_DIR, "last-probe.md");
+    if (await exists(mark)) {
+      const m = /^blind:\s*(\d+)/m.exec(await readFile(mark, "utf8"));
+      if (m) blind = Number(m[1]);
+    }
+    probe = { ...st, blind };
+  } catch { /* пробы нет — блок просто не покажет строку про неё */ }
+
   const ratchets = [];
   const dir = typeof man?.ratchets === "string" ? man.ratchets.trim() : "";
   if (dir && (await exists(join(CWD, dir)))) {
@@ -257,7 +284,7 @@ async function cmdContext(args = []) {
   }
 
   console.log(contextBlock({
-    entry, entryExists: rules !== null, level, rules, run, ratchets, full: fullPart,
+    entry, entryExists: rules !== null, level, rules, run, ratchets, probe, full: fullPart,
   }).join("\n"));
 }
 

package/tool/commands/doctor.mjs

@@ -5,6 +5,7 @@ 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 { 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";
@@ -246,8 +247,19 @@ function runGates(man, opts = {}) {
       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}`)}`);
-      for (const line of out.slice(0, 3)) console.log(c.dim(`        ${line.slice(0, 100)}`));
-      if (out.length > 3) console.log(c.dim(`        ${L.doctor.moreLines(out.length - 3)}`));
+      // ГОЛОВА И ХВОСТ, А НЕ ТОЛЬКО ГОЛОВА. Гейт, который сам является прогоном (наш `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 });
@@ -404,6 +416,31 @@ async function cmdDoctor() {
     gateFailed = run.failed;
     failedNames = run.results.filter((r) => !r.ok).map((r) => r.name);
     await writeRunReport({ version, reached, results: run.results });
+
+    // ПРОБА ЗАПУСКАЕТСЯ САМА. Владелец сформулировал так: «команду, о которой надо вспомнить,
+    // агент не вспомнит, а человек о ней не узнает». Это тот же класс, что файл, который можно
+    // не прочитать, — и весь комплект написан против него. `probe` отвечает на важнейший
+    // вопрос («что здесь не прикрыто ничем») и, оставаясь ручной, не задаётся никем.
+    //
+    // Поэтому не напоминание, а действие: раз в сто коммитов прогон делает пробу сам. Единица
+    // — коммиты, а не сутки: месяц без работы перепроверять незачем, сто коммитов за день —
+    // надо. В кратком режиме не запускается: там хук на воротах коммита, и лишние секунды там
+    // стоят дороже. Не влияет на код возврата НИКОГДА — это осмотр, а не порог.
+    // Выключается AQK_PROBE=0 — у всего, что случается само, обязан быть выключатель.
+    if (!brief && process.env.AQK_PROBE !== "0") {
+      try {
+        const st = await probeStatus();
+        if (st.badEvery !== undefined) {
+          console.log(c.yellow(`\n  ${L.probe.badEvery(st.badEvery)}`));
+        } else if (st.state === "never" || st.state === "stale") {
+          // Сообщение обязано быть верным в обоих случаях. Первая версия печатала «прошло сто
+          // коммитов» и там, где пробы не было ВОВСЕ: число бралось из порога, а не из факта.
+          // Мелочь, но того же класса, что и всё остальное здесь: вывод, который не врёт.
+          console.log(c.dim(`\n  ${st.state === "never" ? L.probe.autoFirst : L.probe.auto(st.behind)}`));
+          await cmdProbe([], { auto: true });
+        }
+      } catch { /* проба не состоялась — прогон это не роняет: он про гейты, а не про неё */ }
+    }
   } else if (gates.length) {
     console.log(
       c.yellow(`  ${L.doctor.declaredNotRun(gates.length)}`) +
@@ -429,6 +466,23 @@ async function cmdDoctor() {
     process.exit(pass ? 0 : 1);
   }
   const ok = !(missing || reached < 0 || gateFailed);
+  // ВЕРДИКТ НАЗЫВАЕТСЯ СЛОВАМИ, а не только кодом возврата. С `--min` он печатался всегда, без
+  // него — никогда: прогон выходил с единицей, а внизу человек видел список зелёных гейтов и
+  // шёл искать причину. Обратная сторона нашего же принципа: молчание неотличимо не только от
+  // успеха, но и от отказа. Найдено аудитом фич 2026-09-09.
+  //
+  // Печатается и на зелёном тоже: «ничего не сказал» и «всё проверено» обязаны различаться.
+  if (wantRun) {
+    if (ok) {
+      console.log(c.green(`  ${L.doctor.runVerdictOk}\n`));
+    } else {
+      const why = [];
+      if (missing) why.push(L.doctor.whyMissing);
+      if (reached < 0) why.push(L.doctor.whyLevel);
+      if (gateFailed) why.push(L.doctor.whyGates(gateFailed, failedNames.join(", ")));
+      console.log(c.red(`  ${L.doctor.runVerdictFail(why.join(", "))}\n`));
+    }
+  }
   await finishBrief(buf, { held: cat.held, todo: cat.todo, level: reached, red: [] }, cat.todoRecs, ok);
   process.exit(ok ? 0 : 1);
 }

package/tool/commands/probe.mjs

@@ -0,0 +1,228 @@
+// tool/commands/probe.mjs — `aqk probe`: чего объявленные проверки НЕ видят.
+//
+// ЗАЧЕМ ЭТО ОТДЕЛЬНАЯ КОМАНДА. `doctor` отвечает «держит машина 21». Двадцать один из чего?
+// Знаменателя нет: 21 — это то, что мы успели написать в каталог, а не то, что важно в этом
+// проекте. `prove` доказывает, что гейт ловит брак НА СВОЁМ образце. Ни один из них не
+// отвечает на вопрос владельца: «что у меня не прикрыто вообще».
+//
+// Замер, с которого команда началась, — на самом комплекте, 2026-09-09. Взят настоящий файл
+// проекта, в копию подсажены проглоченная ошибка и отладочная печать, прогнаны ВСЕ 21
+// сканирующих гейта из манифеста. Покраснело: ноль. У проекта с AQK-3 есть брак, невидимый
+// всем его проверкам, — и узнать об этом было нечем.
+//
+// КАК УСТРОЕНО. Два источника, и оба — факты, а не наш вкус:
+//   1. история репозитория: где брак ВОЗВРАЩАЕТСЯ (коммиты-починки, `history.mjs`);
+//   2. красные образцы каталога: каждый доказан прогоном, каждый — настоящий брак.
+// Образец кладётся во временный каталог по пути горячего файла, и по нему прогоняются
+// ОБЪЯВЛЕННЫЕ гейты проекта. Никто не покраснел — класс не прикрыт, и это доказано, а не
+// выведено из списка.
+//
+// ЧЕГО КОМАНДА НЕ ДЕЛАЕТ. Не трогает рабочее дерево: проба живёт в каталоге mkdtemp и
+// удаляется. Не меняет манифест. Не роняет прогон: код возврата всегда 0 — это осмотр, а
+// не порог. Порог — у `doctor --run --min`.
+import { spawnSync } from "node:child_process";
+import { mkdtemp, mkdir, copyFile, rm, readdir, writeFile, readFile } 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 { 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";
+import { L } from "../i18n/index.mjs";
+
+// Тот же набор расширений, что у привязки доказательства к дифу. Список один на программу:
+// второй через месяц разошёлся бы с первым.
+const CODE_EXT = new Set([
+  "c", "cjs", "cpp", "cs", "css", "go", "h", "java", "js", "json", "jsx", "kt", "mjs", "mts",
+  "php", "pl", "py", "rb", "rs", "scala", "sh", "sql", "swift", "ts", "tsx", "vue",
+]);
+
+const isCode = (p) =>
+  CODE_EXT.has(extname(p).slice(1).toLowerCase()) &&
+  !/(^|\/)gates\/[^/]+\/(red|green)(\/|$)/.test(p);
+
+// Мелкий клон истории не содержит. `fetch-depth: 2` в конвейере — обычная настройка, и на нём
+// рейтинг починок пуст ВСЕГДА. Сказать там «коммитов-починок не найдено» значит выдать
+// отсутствие данных за факт о репозитории: та же подмена, что «зелено, потому что не
+// проверялось». Найдено собственным конвейером 2026-09-09.
+function isShallow() {
+  const r = spawnSync("git", ["rev-parse", "--is-shallow-repository"], { cwd: CWD, encoding: "utf8" });
+  return r.status === 0 && String(r.stdout || "").trim() === "true";
+}
+
+// История берётся одним вызовом: тема коммита и его файлы. Слияния исключены — в них файлы
+// второй ветки, а починку делали не в них.
+function gitLog(limit) {
+  const r = spawnSync(
+    "git",
+    ["log", "--no-merges", `--max-count=${limit}`, "--format=%s", "--name-only"],
+    { cwd: CWD, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 },
+  );
+  return r.status === 0 ? r.stdout || "" : null;
+}
+
+// Сколько коммитов в репозитории сейчас. Единица каденции — коммиты, а не сутки: месяц без
+// работы перепроверять незачем, а сто коммитов за день — надо.
+function commitCount() {
+  const r = spawnSync("git", ["rev-list", "--count", "HEAD"], { cwd: CWD, encoding: "utf8" });
+  if (r.status !== 0) return null;
+  const n = Number(String(r.stdout || "").trim());
+  return Number.isFinite(n) ? n : null;
+}
+
+const MARK = () => join(CWD, TARGET_DIR, "last-probe.md");
+
+// Отметка о прошлой пробе. Формат человеческий намеренно: файл читают глазами и агентом,
+// а не только программой. Разбирается одна строка — та, что несёт число коммитов.
+async function readMark() {
+  try {
+    const text = await readFile(MARK(), "utf8");
+    const m = /^at:\s*(\d+)/m.exec(text);
+    return m ? { at: Number(m[1]), text } : {};
+  } catch { return null; }
+}
+
+async function writeMark(now, blind, lines) {
+  await mkdir(join(CWD, TARGET_DIR), { recursive: true });
+  const body = [
+    "# Проба покрытия — что объявленные проверки НЕ видят",
+    "",
+    `at: ${now === null ? "?" : now}`,
+    `blind: ${blind}`,
+    "",
+    ...lines,
+    "",
+    "Файл эфемерный: его переписывает каждая проба. В .gitignore его стоит держать самому.",
+  ].join("\n");
+  await writeFile(MARK(), body + "\n", "utf8");
+}
+
+// Гейты, которым можно подставить каталог. Команда записи каталога кончается каталогом
+// проверки; написанная руками — чем угодно, и подставлять там некуда. Ровно то же правило,
+// по которому `prove` объявляет запись недоказуемой, а не сломанной.
+function scanningGates(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));
+}
+
+// Красный образец записи, подходящий по расширению горячего файла. Расширение обязано
+// совпадать: питоновский образец в проекте на TypeScript не проверит ничего, а покажет
+// «не прикрыто» — ложная тревога того же класса, что молчащий гейт, только наоборот.
+async function redSampleFor(entry, ext) {
+  const dir = join(GATES_SRC, entry, "red");
+  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;
+}
+
+// Проба: временный каталог, в нём образец по пути горячего файла. Путь сохраняется целиком —
+// правила, привязанные к путям (`.aqkignore`, исключения гейтов), обязаны действовать так же,
+// как в настоящем репозитории. Без этого проба отвечала бы про несуществующее место.
+async function buildProbe(relPath, sample) {
+  const root = await mkdtemp(join(tmpdir(), "aqk-probe-"));
+  const dest = join(root, relPath);
+  await mkdir(dirname(dest), { recursive: 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;
+}
+
+function runGates(gates, dir) {
+  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 });
+  }
+  return out;
+}
+
+// `auto` — проба запущена САМА, по каденции, из `doctor --run`. Тогда она короче и говорит
+// вслух, почему случилась: команда, возникшая без спроса, обязана объяснить себя, иначе её
+// читают как сбой.
+async function cmdProbe(args, { auto = false } = {}) {
+  const P = L.probe;
+  const topArg = Number(args[args.indexOf("--top") + 1]);
+  const TOP = args.includes("--top") && Number.isFinite(topArg) && topArg > 0 ? topArg : (auto ? 3 : 5);
+
+  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 raw = gitLog(2000);
+  if (raw === null) { console.log(c.yellow(`  ${P.noGit}\n`)); return; }
+  const hot = fixHotspots(raw, { isCode }).slice(0, TOP);
+  if (!hot.length) { console.log(c.yellow(`  ${isShallow() ? P.shallow : P.noFixes}\n`)); return; }
+
+  // Записи каталога, применимые к ЭТОМУ репозиторию. Показывать пробы записей, которые
+  // проекту не подходят, значит советовать закрыть дыру, которой нет.
+  const facts = await detectFacts();
+  const catalog = await readCatalog();
+  const entries = catalog.filter((e) => triggerVerdict(e, facts).applies);
+
+  console.log(c.dim(`  ${P.method(hot.length, entries.length)}\n`));
+
+  let blind = 0;
+  for (const { path: rel, fixes } of hot) {
+    console.log(`  ${c.bold(rel)}  ${c.dim(P.fixes(fixes))}`);
+    const ext = extname(rel).toLowerCase();
+    let probed = 0;
+
+    for (const e of entries) {
+      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);
+      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 || "—")}`));
+  }
+
+  console.log(blind ? c.yellow(`\n  ${P.summaryBlind(blind)}\n`) : c.green(`\n  ${P.summaryClean}\n`));
+
+  // Отметка нужна не для отчёта, а для КАДЕНЦИИ: по ней следующий прогон поймёт, что пора.
+  // Без неё команда снова становится тем, о чём надо вспомнить.
+  await writeMark(commitCount(), blind, hot.map(({ path: p2, fixes }) => `- ${p2} (${P.fixes(fixes)})`));
+}
+
+// Состояние пробы для тех, кто только ПОКАЗЫВАЕТ его: прогон и блок для агента.
+//
+// Порог берётся из манифеста (`probe: 250`), умолчание — PROBE_EVERY. Непонятое значение не
+// подменяется умолчанием молча: в манифесте было бы написано одно, а происходило бы другое.
+// Возвращается пометка `badEvery`, и вызывающий говорит о ней вслух.
+async function probeStatus() {
+  const man = await readManifest();
+  const every = probeEvery(man);
+  if (every === null) return { state: "unknown", behind: null, badEvery: String(man?.probe) };
+  if (every === 0) return { state: "off", behind: null };
+  return probeState(await readMark(), commitCount(), every);
+}
+
+export { cmdProbe, probeStatus, scanningGates, isCode };

package/tool/commands/vitals.mjs

@@ -55,13 +55,21 @@ function vitalsRows(f) {
     },
   ];
   // Устаревшая версия — не отказ: человек мог закрепить её сознательно, и ронять за это нельзя.
+  //
+  // СОСТОЯНИЙ ТРИ, А НЕ ДВА. Реестр может ответить ошибкой — не упасть, а вернуть не-200; тогда
+  // `latest` пустой, и прежняя ветка печатала «свежая». Посмотреть не смогли, а сказали «всё
+  // хорошо»: тот самый грех, против которого написан весь комплект, у него самого. Найдено
+  // аудитом фич 2026-09-09.
   if (f.version) {
+    const latest = String(f.version.latest || "");
     rows.push({
       key: "version",
       ok: null,
-      detail: f.version.latest && f.version.latest !== f.version.current
-        ? t.versionOld(f.version.latest, f.version.current)
-        : t.versionOk(f.version.current),
+      detail: !latest
+        ? t.versionUnknown(f.version.current)
+        : latest !== f.version.current
+          ? t.versionOld(latest, f.version.current)
+          : t.versionOk(f.version.current),
     });
   }
   return rows;

package/tool/i18n/en-docs.mjs

@@ -29,6 +29,7 @@ const enDocs = {
     sessionOk: "the SessionStart hook hands the state to the agent",
     sessionNo: (cmd) => `the agent gets no state: ${cmd}`,
     versionOk: (v) => `${v}, current`,
+    versionUnknown: (v) => `${v}, could not reach the registry — freshness unknown`,
     versionOld: (l, cur) => `${l} is out, you have ${cur}`,
   },
   // Блок краткого вывода переехал сюда 2026-09-09: терминальный каталог снова перерос
@@ -66,6 +67,13 @@ const enDocs = {
     runRed: (when, names) => `Last run ${when} — RED: ${names}.`,
     andMore: (n) => `and ${n} more`,
     skipped: (n) => `Not run: ${n} — the tool is absent on this machine, their state is unknown.`,
+    probeNever: "No coverage probe has run — what is covered by nothing here is UNKNOWN. That is not \"covered\": `aqk probe`.",
+    probeBlind: (n, behind) =>
+      `Covered by nothing: ${n} defect classes in the places people most often come back to fix` +
+      (behind ? ` (the probe is ${behind} commits behind)` : "") + ". Details: `aqk probe`.",
+    probeClean: (behind) =>
+      "Coverage probe: in the places probed, every applicable class is caught by something" +
+      (behind ? ` (${behind} commits behind)` : "") + ".",
     ratchets: (list) => `Ratchets: ${list}. The list may only get shorter, never longer.`,
     where: (entry) => `The rulebook: ${entry}. What proves a diff: \`aqk report --since main\`.`,
     mapTitle: "WHAT THIS TOOL CAN DO. The full list of commands — not a retelling, the same list\nthe help is built from:",