agent-quality-kit 0.11.0 → 0.12.0

package/tool/lib/adopt.mjs

@@ -0,0 +1,98 @@
+// tool/lib/adopt.mjs — проверки, которые у проекта УЖЕ ЕСТЬ. Читаются из его собственных
+// файлов, а не выдумываются.
+//
+// ЗАЧЕМ. Комплект, поставленный в `express` — проект с eslint, mocha и конвейером, — показывал
+// двадцать крестов подряд и «держит машина 0». С точки зрения владельца это неправда: его
+// проверки держат, просто мы считали только СВОИ записи. Мы видели, что конвейер ЕСТЬ
+// (`has_ci`), но не читали, что в нём, и человек должен был переписать в манифест руками то,
+// что мы могли прочитать сами. Отсюда и «не понимает, что у него хорошо»: хорошее уже есть, а
+// мы о нём молчим.
+//
+// ОТДЕЛЬНЫМ ФАЙЛОМ, а не в repo.mjs: там осмотр репозитория ради НАШЕГО каталога, здесь —
+// чтение ЧУЖИХ конфигов, и у каждого источника свой формат, который меняется по своим
+// причинам. Шов вскрыл наш же `file-size-limit`: с python-источниками repo.mjs перевалил бы
+// за 500 строк.
+//
+// ПРЕДЛАГАЕМ, А НЕ ОБЪЯВЛЯЕМ. Гейт, вписанный в чужой манифест без спроса, — это наше решение
+// в чужом файле; и человек обязан видеть ИСТОЧНИК, иначе предложение неотличимо от догадки.
+//
+// Сборка и запуск проверками не считаются: `build` собирает, `start` запускает, судит — ни тот
+// ни другой. Берём только то, что отвечает «прошло или нет».
+const CHECK_NAMES = new Set(["test", "tests", "lint", "typecheck", "type-check", "types", "check"]);
+
+// Окружения tox, которые судят, а не гоняют тесты под матрицей версий. Голый `tox` не
+// предлагаем: он проходит все интерпретаторы из envlist, и у человека без пяти питонов это
+// красный прогон на пустом месте. Имена сняты с живых tox-файлов (rich, click, flask).
+const TOX_CHECKS = new Set(["lint", "style", "typing", "types", "type", "mypy", "check", "typecheck"]);
+
+// Источники в порядке доверия: при совпадении имени берётся первый. Замер 2026-09-11 на
+// восьми python-проектах: package.json нет ни у кого, Makefile у трёх, `.pre-commit-config.yaml`
+// у семи, tox у пяти, scripts/ у httpx. Шаги конвейера НЕ читаются: там `${{ matrix.x }}`,
+// `PYTHONPATH=…` и обёртки `uv run --locked --group …` — строка, которая работает только в
+// том конвейере, предложенная как локальный гейт, покраснела бы у человека в первую же минуту.
+function proposeGates(files = {}) {
+  const out = [];
+  const seen = new Set();
+  const push = (name, cmd, source) => {
+    const key = name === "tests" ? "test" : name.replace(/^type-?check$|^types$/, "typecheck");
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ name: key, cmd, source });
+  };
+
+  const pkg = files["package.json"];
+  if (pkg) {
+    let scripts = null;
+    try { scripts = JSON.parse(pkg)?.scripts; } catch { scripts = null; }
+    if (scripts && typeof scripts === "object") {
+      for (const name of Object.keys(scripts)) {
+        if (!CHECK_NAMES.has(name)) continue;
+        // `npm test` — каноничное написание для теста, остальное через `run`.
+        push(name, name === "test" || name === "tests" ? "npm test" : `npm run ${name}`, "package.json");
+      }
+    }
+  }
+
+  const mk = files.Makefile;
+  if (typeof mk === "string") {
+    for (const m of mk.matchAll(/^([A-Za-z][\w-]*):/gm)) {
+      if (CHECK_NAMES.has(m[1])) push(m[1], `make ${m[1]}`, "Makefile");
+    }
+  }
+
+  // pre-commit — одна команда на всё, что в нём стоит. Хуки называются поимённо: «у вас есть
+  // .pre-commit-config.yaml» ничего не говорит, «у вас есть ruff-check и check-yaml» — говорит.
+  const pc = files[".pre-commit-config.yaml"];
+  if (typeof pc === "string") {
+    const ids = [...pc.matchAll(/^\s*-\s*id:\s*["']?([\w.-]+)/gm)].map((m) => m[1]);
+    if (ids.length) {
+      const shown = ids.slice(0, 4).join(", ") + (ids.length > 4 ? ` +${ids.length - 4}` : "");
+      push("pre-commit", "pre-commit run --all-files", `.pre-commit-config.yaml: ${shown}`);
+    }
+  }
+
+  // tox живёт в двух местах и двух синтаксисах: `[testenv:lint]` в tox.ini (и внутри
+  // legacy_tox_ini в pyproject), `[tool.tox.env.lint]` в pyproject.toml нового образца.
+  for (const src of ["tox.ini", "pyproject.toml"]) {
+    const t = files[src];
+    if (typeof t !== "string") continue;
+    for (const m of t.matchAll(/^\s*\[(?:testenv:|tool\.tox\.env\.)([\w-]+)\]/gm)) {
+      if (TOX_CHECKS.has(m[1])) push(m[1], `tox -e ${m[1]}`, src);
+    }
+  }
+
+  // Каталог scripts/ с исполняемыми test, check, lint — соглашение encode (httpx, starlette):
+  // конвейер зовёт ровно их. Содержимое не читаем, важно только, что файл есть.
+  for (const name of ["test", "check", "lint"]) {
+    if (`scripts/${name}` in files) push(name, `scripts/${name}`, "scripts/");
+  }
+
+  return out;
+}
+
+// Какие файлы читать — знает тот, кто их разбирает. Список в команде разошёлся бы с разбором
+// в первый же день, когда появится новый источник.
+const ADOPT_FILES = ["package.json", "Makefile", ".pre-commit-config.yaml", "tox.ini", "pyproject.toml"];
+const ADOPT_SCRIPTS = ["scripts/test", "scripts/check", "scripts/lint"];
+
+export { proposeGates, ADOPT_FILES, ADOPT_SCRIPTS };

package/tool/lib/cadence.mjs

@@ -54,4 +54,39 @@ function probeEvery(man) {
   return n;
 }
 
-export { probeDue, probeState, probeEvery, PROBE_EVERY };
+// ИМЕНА непойманных классов в отметке. Хранилось одно число, `blind: 1`: агент в `context`
+// видел «один класс», человек в `doctor` не видел ничего, и чтобы узнать КАКОЙ, надо было снова
+// запускать пробу — ту самую команду, о которой не вспоминают. Находка, которую не показали,
+// ни от чего не предостерегает.
+//
+// Правило то же, что у `countProbe`: класс, слепой хоть где-то, — непокрыт, а «не смогли
+// проверить» слепотой не считается. Файл — первый, где слеп: пробы идут от самого горячего.
+function blindLines(records) {
+  const seen = new Set();
+  const out = [];
+  for (const { entry, file, verdict } of records || []) {
+    if (verdict !== "blind" || seen.has(entry)) continue;
+    seen.add(entry);
+    out.push(`blind-class: ${entry} ${file}`);
+  }
+  return out;
+}
+
+// Отметка старого формата строк `blind-class:` не несёт — тогда список пуст, и это «имён не
+// знаем», а не «слепых нет»: число `blind:` читается отдельно и остаётся правдой.
+function parseBlind(text) {
+  return [...String(text || "").matchAll(/^blind-class:\s*(\S+)\s+(.+?)\s*$/gm)]
+    .map((m) => ({ slug: m[1], file: m[2] }));
+}
+
+// Какие гейты проба ПРОГОНЯЛА. Без этого «объявлен сейчас» читалось как «поставлен после
+// пробы» — а проба как раз и гоняет объявленные: гейт, стоявший ДО неё и брак пропустивший,
+// получал утешительное «поймает ли, покажет следующая» вместо «здесь не ловит». Именно
+// прогонявшиеся, а не объявленные: медленные проба пропускает, и про них «не поймал» — ложь.
+// Старая отметка строки не несёт — null: «не знаем», а не «ничего не прогонялось».
+function parseRan(text) {
+  const m = /^ran:[ \t]*(.*)$/m.exec(String(text || ""));
+  return m ? new Set(m[1].split(/\s+/).filter(Boolean)) : null;
+}
+
+export { probeDue, probeState, probeEvery, PROBE_EVERY, blindLines, parseBlind, parseRan };

package/tool/lib/execution.mjs

@@ -27,6 +27,10 @@
 
 // Умолчание для незнакомой программы: ноль — чисто, единица — находка, остальное — сбой.
 // Это честнее догадки: неизвестный код становится «не знаем», а не «поймал».
+import { existsSync } from "node:fs";
+import { win32 } from "node:path";
+import { whichSync } from "./repo.mjs";
+
 const DEFAULT = (code) => code === 1;
 
 const ADAPTERS = {
@@ -64,4 +68,49 @@ function classify(r, isFinding = DEFAULT) {
   return { state: "infra_error", reason: "unexpected_exit", code };
 }
 
-export { classify, findingCodes };
+// КАКОЙ BASH ЗАПУСКАТЬ НА WINDOWS. В System32 лежит bash.exe — заглушка WSL, и в PATH она стоит
+// раньше Git Bash: установщик Git по умолчанию кладёт туда только Git\cmd. Команда гейта
+// `bash kit/gates/x/check.sh .` уезжала в Linux-подсистему — другие программы, другой git,
+// другие пути — и прогон краснел «не из-за кода». Отчёт с живого проекта 2026-09-11: «гейты
+// под Windows берут bash из WSL. Через Git Bash все проходят».
+//
+// Приём не выдуман: на ту же ловушку наступали Claude Code (anthropics/claude-code#23556) и
+// Archon (coleam00/Archon#1326), и общий ответ — не верить слову `bash` из PATH, а брать его
+// рядом с git. Git комплекту нужен всё равно. Явный путь — AQK_BASH: у всего, что мы решаем
+// сами, обязан быть способ решить иначе.
+//
+// Не нашли — null, и команда остаётся как есть. Подставлять заглушку WSL «за неимением» нельзя:
+// это ровно то, от чего мы уходим; `vitals` назовёт bash ненайденным.
+function gitBash({ platform = process.platform, env = process.env, which = whichSync, exists = existsSync } = {}) {
+  if (platform !== "win32") return null;
+  if (env.AQK_BASH) return env.AQK_BASH;
+  const cands = [];
+  const git = which("git", env);
+  if (git) {
+    // Git\cmd\git.exe и Git\mingw64\bin\git.exe — корень на два и на три уровня выше.
+    for (const root of [win32.dirname(win32.dirname(git)), win32.dirname(win32.dirname(win32.dirname(git)))]) {
+      cands.push(win32.join(root, "bin", "bash.exe"), win32.join(root, "usr", "bin", "bash.exe"));
+    }
+  }
+  for (const base of [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs")]) {
+    if (base) cands.push(win32.join(base, "Git", "bin", "bash.exe"));
+  }
+  return cands.find((p) => exists(p)) || null;
+}
+
+// Подменяется только ПЕРВОЕ слово: внутренний `bash` у обёртки храповика запускает уже Git Bash,
+// а у него свой PATH. Кавычки — путь почти всегда с пробелом («Program Files»).
+function launchable(cmd, bash) {
+  const s = String(cmd || "");
+  return bash && /^bash(\s|$)/.test(s) ? `"${bash}"${s.slice(4)}` : s;
+}
+
+// Одна точка для всех пяти мест, где запускается команда гейта: прогон, доказательство, проба,
+// храповик, `why`. Поиск делается раз на процесс — он смотрит на диск, а гейтов бывает тридцать.
+let cachedBash;
+function gateCommand(cmd) {
+  if (cachedBash === undefined) cachedBash = gitBash();
+  return launchable(cmd, cachedBash);
+}
+
+export { classify, findingCodes, gitBash, launchable, gateCommand };

package/tool/lib/history.mjs

@@ -111,19 +111,29 @@ function probeSummary({ caught = 0, blind = 0, unknown = 0, unprobed = 0 } = {})
 //   · гейт, ПОЗЕЛЕНЕВШИЙ от подсадки, — он смотрит не туда, и это тоже не поимка.
 // Исключены все — вердикт `unknown`, а не `blind`: «не по чему судить» и «никто не ловит»
 // разные факты, и молчание здесь и есть предмет спора.
+//
+// И ещё одно: гейт, СЛОМАННЫЙ подсадкой (работал до, не смог после), мог быть тем самым
+// ловцом. Пока никто другой не поймал, «слеп» про такой класс — неправда, и вердикт `unknown`.
+// Найдено пробой на самом комплекте 2026-09-11: образец лёг на место общей библиотеки
+// kit/gates/_skip.sh, двенадцать гейтов вышли с кодом 2 — включая тот, что этот образец в
+// отдельной папке ловит. Остальные молчали, и проба назвала класс слепым.
 function probeVerdictPaired(before, after) {
   const byName = new Map(after.map((r) => [r.name, r]));
-  let usable = 0, alreadyRed = 0, failed = 0, caught = 0;
+  let usable = 0, alreadyRed = 0, failed = 0, caught = 0, brokenByPlant = 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 (broke(b) || broke(a)) {
+      failed++;
+      if (!broke(b)) brokenByPlant++;
+      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 };
+  const verdict = caught ? "caught" : !usable || brokenByPlant ? "unknown" : "blind";
+  return { verdict, usable, alreadyRed, failed, caught, brokenByPlant };
 }
 
 // Счёт непокрытого КЛАССАМИ, а не пробами. Замер на десяти живых репозиториях 2026-09-10:

package/tool/lib/prove.mjs

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { CWD, exists } from "./core.mjs";
 import { parseManifest, gateRequires } from "./manifest.mjs";
 import { whichSync } from "./repo.mjs";
-import { classify, findingCodes } from "./execution.mjs";
+import { classify, findingCodes, gateCommand } from "./execution.mjs";
 
 // Гейт можно доказать, если у него есть оба образца. Признак по образцам, а не по тексту
 // команды: запись, делегирующая готовому инструменту (`npx knip --directory .`), каталог
@@ -108,7 +108,7 @@ async function samplesForRecipe(samplesDir, name) {
 // «не знаем» — а вызывающий тут же считал его находкой. Опыт 2026-09-09: проверка, виснущая
 // на красном образце, получала вердикт «доказана».
 function run(cmd, timeoutMs, prog) {
-  const r = spawnSync(cmd, { shell: true, encoding: "utf8", cwd: CWD, timeout: timeoutMs });
+  const r = spawnSync(gateCommand(cmd), { shell: true, encoding: "utf8", cwd: CWD, timeout: timeoutMs });
   const out = `${r.stdout || ""}${r.stderr || ""}`.trim();
   return { ...classify(r, findingCodes(prog)), out };
 }

package/tool/lib/repo.mjs

@@ -265,6 +265,22 @@ function pickRecipe(rec, facts, missing) {
     console.log(c.dim(`  ${c.yellow("!")}  ${L.recipe.skipped(lang, prog)}`));
   }
 
+  // Безъязыковой родной рецепт. Ключи рецептов — языки, и это верно для линтеров, но неверно
+  // для инструментов, которым язык безразличен: `gitleaks` ищет ключи в любом файле, и
+  // `secrets-not-in-code` объявлен `always: true`. Без этого ключа выбор был из двух плохих —
+  // продублировать команду под восемь языков (тот самый повтор, против которого у нас гейт)
+  // или оставить запись без родного рецепта. Второе и было: замер на десяти чужих проектах
+  // 2026-09-10 дал секреты в НЕПОКРЫТЫХ у axios и у всех четырёх python-проектов, то есть там,
+  // где польза наибольшая, команды для вставки не существовало.
+  //
+  // Стоит ПОСЛЕ языков и ПЕРЕД переносимым: свой язык точнее, а родной сильнее переносимого —
+  // но только если его есть чем выполнить.
+  if (recipes.native) {
+    const prog = String(recipes.native).trim().split(/\s+/)[0];
+    if (runnable(recipes.native)) return recipes.native;
+    if (Array.isArray(missing) && !missing.includes(prog)) missing.push(prog);
+  }
+
   return recipes.any || null;
 }
 
@@ -362,9 +378,40 @@ async function matchCatalog(query) {
   return out;
 }
 
+// С ЧЕГО НАЧАТЬ: три записи вместо двадцати равнозначных крестов.
+//
+// Двадцать одинаковых требований — это ноль требований: закрывают первое попавшееся или не
+// закрывают ничего. Порядок НЕ по нашему вкусу; два признака, оба — факты, которые у нас уже
+// есть:
+//   · запись родилась из настоящего отказа (`lifecycle: stable` — `proof` ссылается на журнал
+//     шишек), то есть она про боль, которая СЛУЧАЛАСЬ, а не про «хорошую практику»;
+//   · её можно закрыть одной готовой командой — цена входа минутная.
+// Сначала то, что и больно, и дёшево.
+//
+// При равенстве признаков — по имени: одинаковый ввод обязан давать одинаковый ответ, иначе
+// человек видит разный совет на двух прогонах подряд и перестаёт верить обоим.
+function startWith(entries, facts, n = 3) {
+  const langs = facts?.langs ? [...facts.langs] : [];
+  const cheap = (e) => {
+    const r = e?.recipes && typeof e.recipes === "object" ? e.recipes : {};
+    return [...langs, "native"].some((k) => r[k] && !/\{gate\}/.test(r[k])) ? 1 : 0;
+  };
+  // Зрелость НЕ поле записи, а вычисляемый признак: `proof` ссылается на журнал шишек. Тот же
+  // признак, которым каталог отделяет условную запись с первого дня (`entryLifecycle`).
+  // Заводить второй счёт нельзя: разъехавшись, они дали бы разные ответы про одну запись.
+  const hurt = (e) => (/incidents\//.test(String(e?.proof || "")) ? 1 : 0);
+  return [...entries]
+    .sort((a, b) =>
+      (hurt(b) + cheap(b)) - (hurt(a) + cheap(a)) ||
+      cheap(b) - cheap(a) ||
+      String(a.slug).localeCompare(String(b.slug)))
+    .slice(0, n);
+}
+
 // Наружу — то, что действительно импортируют другие файлы и модульные проверки. Экспорт,
 // который никто не берёт, читается как часть договора и мешает менять внутренности.
 export {
   whichSync,
   EXT_LANG, detectFacts, readCatalog, triggerVerdict, pickRecipe, recipeFor, browserServerAdvice, MARKS,
+  startWith,
   stems, overlap, matchCatalog, isApiSpec };

package/tool/lib/run.mjs

@@ -13,6 +13,7 @@ import { scopeOutput, splitAdvice, changedFiles } from "./scope.mjs";
 import { CWD, c, die } from "./core.mjs";
 import { advisorySet } from "./manifest.mjs";
 import { L } from "../i18n/index.mjs";
+import { gateCommand } from "./execution.mjs";
 
 
 // «Гейт объявлен» и «гейт работает» — разные утверждения. Первое читается из манифеста,
@@ -39,10 +40,36 @@ function sinceRef(argv = process.argv) {
   return v && !v.startsWith("-") ? v : null;
 }
 
+// СТРОКА «ИДЁТ». Гейт идёт через spawnSync, и строка про него печаталась только по завершении:
+// минута `smoke` — минута пустого экрана, «работает» неотличимо от «повисло», и человек пишет
+// сам, не дождавшись. Просьба владельца 2026-09-10: «я запустил и должен видеть, как идёт».
+//
+// Только в терминал. В пайп и в конвейер — ни байта: лог там читают глазами и разбирают
+// машиной, и строка, переписанная возвратом каретки, в файле превращается в мусор.
+// Секунды не тикают: для этого нужен асинхронный запуск и убийство группы процессов на
+// таймауте, а у нас windows в конвейере. Имя и номер гейта отвечают на вопрос и без них.
+function progress({ tty = process.stdout.isTTY, write = (s) => process.stdout.write(s) } = {}) {
+  let shown = false;
+  return {
+    show(text) {
+      if (!tty) return;
+      if (shown) write("\r\x1b[K");
+      write(text);
+      shown = true;
+    },
+    clear() {
+      if (!tty || !shown) return;
+      write("\r\x1b[K");
+      shown = false;
+    },
+  };
+}
+
 function runGates(man, opts = {}) {
   const gates = declaredGates(man);
   if (!gates.length) return { failed: 0, ran: 0, results: [] };
   const advisory = advisorySet(man);
+  const bar = progress();
 
   // Сужение по дифу — договор с человеком, и он должен видеть, ЧТО именно сужено. Пустой диф
   // называется вслух: иначе «все гейты зелёные» означало бы «сравнили не с тем» и читалось бы
@@ -55,9 +82,11 @@ function runGates(man, opts = {}) {
   let failed = 0;
   const results = [];
 
-  for (const [name, cmd] of gates) {
+  for (const [i, [name, cmd]] of gates.entries()) {
+    bar.show(`  ${c.dim("⋯")}  ${name.padEnd(14)} ${c.dim(L.doctor.running(i + 1, gates.length))}`);
     const t0 = Date.now();
-    const r = spawnSync(cmd, { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
+    const r = spawnSync(gateCommand(cmd), { shell: true, cwd: CWD, encoding: "utf8", timeout: 300000 });
+    bar.clear();
     const secs = (Math.max(0, Date.now() - t0) / 1000).toFixed(1);
     // Вывод гейта запоминается целиком (с потолком, чтобы болтливый инструмент не съел память):
     // по нему считается покрытие дифа — какой файл вообще был назван хоть одной проверкой.
@@ -162,4 +191,4 @@ function runGates(man, opts = {}) {
   return { failed, ran: gates.length, results, advisoryFailed };
 }
 
-export { declaredGates, sinceRef, runGates };
+export { declaredGates, sinceRef, runGates, progress };

package/tool/selfcheck/gates.sh

@@ -118,14 +118,24 @@ for GATE in "$CAT"/*/; do
   # наблюдался трижды под тяжёлой параллельной нагрузкой, каждый раз на РАЗНОЙ записи, README
   # которой на месте и раздел содержит; воспроизвести в покое не удалось за сорок прогонов.
   # Причина не доказана — но обвинять запись в том, чего не проверяли, нельзя в любом случае.
-  printf '%s\n' "$README_TEXT" | grep -qE '[Гг]отовы(й аналог|й инструмент|е правил)|[Гг]отового аналога'
+  # ПОЧЕМУ ЗДЕСЬ НЕТ КОНВЕЙЕРА. Было `printf … | grep -qE …`, и это давало ПЛАВАЮЩИЙ отказ,
+  # который мы ловили трижды и не могли объяснить: запись обвинялась в отсутствии раздела,
+  # который у неё есть. Причина найдена 2026-09-10 тем самым сообщением «grep вышел с кодом
+  # 141», ради которого исход и был разложен на три. 141 = 128 + 13 = SIGPIPE: `grep -q`
+  # выходит на ПЕРВОМ совпадении и закрывает трубу, а `printf` в этот момент ещё пишет и
+  # умирает от сигнала. При `set -o pipefail` (строка 9) статусом конвейера становится 141.
+  # Воспроизведено 100 из 100, когда совпадение в НАЧАЛЕ текста, — оттого и «случайная»
+  # запись: у одних раздел в начале README, у других в конце.
+  # Здесь-строка конвейера не создаёт, и гонки не существует.
+  grep -qE '[Гг]отовы(й аналог|й инструмент|е правил)|[Гг]отового аналога' <<< "$README_TEXT"
   case $? in
     0) : ;;
     1) bad "$SLUG: в README нет раздела про готовый аналог — «не искал» и «нет» разные утверждения" ;;
     *) bad "$SLUG: поиск раздела про готовый аналог НЕ СОСТОЯЛСЯ (grep вышел с кодом $?) — это не приговор записи" ;;
   esac
   # Те же три исхода, что и у поиска выше, и по той же причине.
-  printf '%s\n' "$README_TEXT" | grep -qE 'чего НЕ ловит|Чего НЕ ловит|чего не ловит|Чего не ловит'
+  # Тот же довод, что у поиска выше: конвейер + `grep -q` = гонка с SIGPIPE.
+  grep -qE 'чего НЕ ловит|Чего НЕ ловит|чего не ловит|Чего не ловит' <<< "$README_TEXT"
   case $? in
     0) : ;;
     1) bad "$SLUG: в README нет раздела «чего НЕ ловит» — граница записи обязана быть названа" ;;

package/tool/selfcheck/units-cadence.mjs

@@ -7,7 +7,7 @@
 // незачем, а сто коммитов за день перепроверить надо.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { probeDue, probeState, probeEvery, PROBE_EVERY } from "../lib/cadence.mjs";
+import { probeDue, probeState, probeEvery, PROBE_EVERY, blindLines, parseBlind, parseRan } from "../lib/cadence.mjs";
 
 test("порог по умолчанию — сто коммитов, и он назван числом, а не спрятан", () => {
   assert.equal(PROBE_EVERY, 100);
@@ -67,3 +67,39 @@ test("непонятое значение порога — null, а не тих
   assert.equal(probeEvery({ probe: "часто" }), null);
   assert.equal(probeEvery({ probe: -5 }), null);
 });
+
+// --- отметка несёт ИМЕНА непойманных классов ------------------------------------------
+// ЗАЧЕМ. Отметка хранила одно число — `blind: 1`. Агент в `context` видел «один класс», человек
+// в `doctor` не видел ничего, и чтобы узнать КАКОЙ, надо было снова запускать пробу — ту самую
+// команду, о которой никто не вспоминает. Находка, которую не показали, не предостерегает.
+test("отметка пробы: по строке на слепой класс, в самом горячем файле, где он слеп", () => {
+  const recs = [
+    { entry: "swallowed-error", file: "src/a.py", verdict: "blind" },
+    { entry: "swallowed-error", file: "src/b.py", verdict: "blind" },
+    { entry: "no-print-in-prod", file: "src/a.py", verdict: "caught" },
+    { entry: "dead-code", file: "src/b.py", verdict: "unknown" },
+  ];
+  const lines = blindLines(recs);
+  // То же правило, что у countProbe: класс, слепой хоть где-то, — непокрыт; «не смогли» — не слеп.
+  assert.deepEqual(lines, ["blind-class: swallowed-error src/a.py"]);
+  const text = ["at: 5", "blind: 1", "", ...lines, "- src/a.py (fixes: 3)"].join("\n");
+  assert.deepEqual(parseBlind(text), [{ slug: "swallowed-error", file: "src/a.py" }]);
+});
+
+test("отметка старого формата и пустая — пустой список, а не падение", () => {
+  assert.deepEqual(parseBlind("at: 5\nblind: 1\n"), []);
+  assert.deepEqual(parseBlind(""), []);
+  assert.deepEqual(parseBlind(null), []);
+});
+
+// «Объявлен сейчас» не значит «поставлен после пробы»: проба и гоняет объявленные гейты.
+// Первая версия так и решила — и на самом комплекте написала «поставлено после пробы» про
+// gate-not-weakened, который стоял ДО неё и в kit/gates/_skip.sh брак пропустил. Самое ценное
+// сообщение («объявлен, но здесь не ловит») подменилось утешительным. Поймано живым прогоном.
+test("отметка помнит, какие гейты проба ПРОГОНЯЛА", () => {
+  const text = "at: 5\nblind: 1\nran: smoke gate-not-weakened units\n\nblind-class: x a.sh\n";
+  assert.deepEqual([...parseRan(text)].sort(), ["gate-not-weakened", "smoke", "units"]);
+  // Старая отметка этой строки не несёт: «не знаем», а не «ничего не было объявлено».
+  assert.equal(parseRan("at: 5\nblind: 1\n"), null);
+  assert.deepEqual([...parseRan("ran:\n")], []);
+});

package/tool/selfcheck/units-execution.mjs

@@ -17,7 +17,7 @@
 // рядом с инструментом — нормализующим адаптером, а протокол остаётся простым.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { classify, findingCodes } from "../lib/execution.mjs";
+import { classify, findingCodes, gitBash, launchable, gateCommand } from "../lib/execution.mjs";
 
 // Вход — то, что отдаёт spawnSync: { status, signal, error }.
 const R = (over = {}) => ({ status: 0, signal: null, error: undefined, ...over });
@@ -86,3 +86,80 @@ test("адаптеры знают свои коды: vulture 3 — находк
 test("наши собственные обёртки: 2 — «нет инструмента», а не находка", () => {
   assert.equal(classify(R({ status: 2 }), findingCodes("bash")).state, "infra_error");
 });
+
+// --- какой bash запускать на Windows ---------------------------------------------------
+// ЗАЧЕМ. На Windows 10/11 в System32 лежит bash.exe — заглушка WSL, и в PATH она стоит раньше
+// Git Bash (установщик Git по умолчанию кладёт в PATH только Git\cmd). Команда гейта
+// `bash kit/gates/x/check.sh .` уезжала в Linux-подсистему: другие программы, другой git,
+// другие пути — и прогон краснел «не из-за кода». Отчёт с живого проекта 2026-09-11: «гейты
+// под Windows берут bash из WSL. Через Git Bash все проходят». Известная ловушка, на неё
+// наступали Claude Code (issue #23556) и Archon (#1326); общий приём — брать bash рядом с git.
+const winFs = (files) => (p) => files.includes(p);
+test("Windows: bash берётся рядом с git.exe, а не из PATH", () => {
+  const git = "C:\\Program Files\\Git\\cmd\\git.exe";
+  const bash = "C:\\Program Files\\Git\\bin\\bash.exe";
+  const got = gitBash({ platform: "win32", env: {}, which: () => git, exists: winFs([bash]) });
+  assert.equal(got, bash);
+});
+
+test("Windows: git из mingw64 и запасной путь в Program Files тоже находятся", () => {
+  const bash = "C:\\Program Files\\Git\\bin\\bash.exe";
+  const deep = gitBash({ platform: "win32", env: {},
+    which: () => "C:\\Program Files\\Git\\mingw64\\bin\\git.exe", exists: winFs([bash]) });
+  assert.equal(deep, bash);
+  const pf = gitBash({ platform: "win32", env: { ProgramFiles: "C:\\Program Files" },
+    which: () => null, exists: winFs([bash]) });
+  assert.equal(pf, bash);
+});
+
+test("Windows: явный AQK_BASH главнее поиска; не нашли — null, а не заглушка WSL", () => {
+  assert.equal(gitBash({ platform: "win32", env: { AQK_BASH: "D:\\x\\bash.exe" }, which: () => null, exists: () => false }),
+    "D:\\x\\bash.exe");
+  assert.equal(gitBash({ platform: "win32", env: {}, which: () => null, exists: () => false }), null);
+});
+
+test("не Windows — bash из PATH как был, команда не трогается", () => {
+  assert.equal(gitBash({ platform: "linux", env: {}, which: () => "/usr/bin/git", exists: () => true }), null);
+  assert.equal(launchable("bash x.sh .", null), "bash x.sh .");
+});
+
+test("подменяется только первое слово bash, в кавычках — путь с пробелом", () => {
+  const b = "C:\\Program Files\\Git\\bin\\bash.exe";
+  assert.equal(launchable("bash kit/gates/x/check.sh .", b), `"${b}" kit/gates/x/check.sh .`);
+  // Внутренний bash обёртки храповика запускает уже Git Bash — у него свой PATH, трогать незачем.
+  assert.equal(launchable("bash r/_ratchet.sh r/x.txt bash g/check.sh .", b), `"${b}" r/_ratchet.sh r/x.txt bash g/check.sh .`);
+  assert.equal(launchable("bashate lint.sh", b), "bashate lint.sh");
+  assert.equal(launchable("npm test", b), "npm test");
+});
+
+// Сторож одной точки: команда гейта, запущенная оболочкой В ОБХОД gateCommand, на Windows снова
+// уедет в WSL. Пять мест запуска починены разом; шестое, добавленное через месяц, забудет.
+test("каждый запуск команды через оболочку идёт через gateCommand", async () => {
+  const { readdir, readFile } = await import("node:fs/promises");
+  const { join, dirname } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const bad = [];
+  for (const dir of ["lib", "commands"]) {
+    for (const f of (await readdir(join(root, dir))).filter((n) => n.endsWith(".mjs"))) {
+      const text = await readFile(join(root, dir, f), "utf8");
+      for (const m of text.matchAll(/spawnSync\(([^,]+),\s*\{[^}]*shell:\s*true/g)) {
+        if (!m[1].trim().startsWith("gateCommand(")) bad.push(`${dir}/${f}: spawnSync(${m[1].trim()}, …)`);
+      }
+    }
+  }
+  assert.deepEqual(bad, [], "запуск в обход gateCommand");
+});
+
+// Живьём, на настоящем Windows: модульные проверки выше подставляют пути, а не запускают. Без
+// этой строки «windows: pass» в конвейере ничего не говорил о подмене — задание не гоняло ни
+// этот файл, ни гейты через комплект. Кавычки в команде двойные: cmd.exe одинарные не снимает.
+test("Windows: команда гейта со словом bash отвечает из Git Bash", { skip: process.platform !== "win32" && "только на Windows" }, async () => {
+  const { spawnSync } = await import("node:child_process");
+  const bash = gitBash();
+  assert.ok(bash, "Git Bash не найден рядом с git.exe");
+  assert.doesNotMatch(bash, /\\(system32|windowsapps)\\/i, "найдена заглушка WSL, а не Git Bash");
+  const r = spawnSync(gateCommand('bash -c "uname -s"'), { shell: true, encoding: "utf8" });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /MINGW|MSYS/, `ответил не Git Bash: ${r.stdout}`);
+});

package/tool/selfcheck/units-level.mjs

@@ -12,6 +12,30 @@ import assert from "node:assert/strict";
 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";
+import { progress } from "../lib/run.mjs";
+
+// --- строка «идёт» во время прогона ---------------------------------------------------
+// ЗАЧЕМ. Гейт идёт через spawnSync, и строка про него печаталась только по завершении: минута
+// `smoke` — минута пустого экрана. Человек не отличает «работает» от «повисло» и пишет сам.
+test("строка «идёт» пишется только в терминал и стирается без следа", () => {
+  const out = [];
+  const pipe = progress({ tty: false, write: (s) => out.push(s) });
+  pipe.show("⋯ smoke [2/10]");
+  pipe.clear();
+  assert.deepEqual(out, [], "в пайп и в конвейер — ни байта: лог читается глазами и разбирается машиной");
+
+  const term = [];
+  const p = progress({ tty: true, write: (s) => term.push(s) });
+  p.clear();
+  assert.deepEqual(term, [], "стирать нечего — управляющих кодов нет");
+  p.show("⋯ smoke [2/10]");
+  assert.ok(term.join("").includes("smoke [2/10]"));
+  assert.ok(!term.join("").includes("\n"), "без перевода строки: её перепишет итог гейта");
+  p.clear();
+  assert.equal(term.at(-1), "\r\x1b[K", "итог гейта ложится на чистую строку");
+  p.clear();
+  assert.equal(term.filter((s) => s === "\r\x1b[K").length, 1, "повторное стирание ничего не пишет");
+});
 
 // --- доказательство гейтов ------------------------------------------------------------
 // ЗАЧЕМ. Ступень AQK-2 называлась «гейты доказаны» и проверяла существование двух папок.