agent-quality-kit 0.11.0 → 0.13.0

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, selectGates } 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 называлась «гейты доказаны» и проверяла существование двух папок.
@@ -225,7 +249,7 @@ test("заявка подтверждена, когда коды правил е
 test("заявка не подтверждена, когда кодов нет нигде", () => {
   const man = parseManifest('gates:\n  lint: "ruff check ."\ncovers:\n  lint: [no-print-in-prod]\n');
   const catalog = [{ slug: "no-print-in-prod", recipes: { python: "ruff check --select T20 {dir}" } }];
-  assert.deepEqual(coversUnproven(man, catalog, ""), [{ entry: "no-print-in-prod", gate: "lint", codes: ["T20"] }]);
+  assert.deepEqual(coversUnproven(man, catalog, ""), [{ entry: "no-print-in-prod", gate: "lint", codes: ["T20"], linter: "ruff", kind: "unproven" }]);
 });
 
 // Правило может стоять не в команде, а в конфиге линтера — это нормальный уклад, и краснеть
@@ -243,6 +267,49 @@ test("запись без кодов правил в рецепте не пор
   assert.deepEqual(coversUnproven(man, catalog, ""), []);
 });
 
+// --- заявка сверяется правилами ТОГО линтера, которым закрыт гейт --------------------
+// Отзыв с живого проекта 2026-09-11 (TypeScript на Biome): заявка «lint держит no-print-in-prod»
+// всегда была «не подтверждена» — комплект искал коды ruff (T20, C901, BLE), а у Biome это
+// noConsole, noExcessiveCognitiveComplexity, noEmptyBlockStatements, и они стояли. Поле, которое
+// должно снимать шум, само его производило и подталкивало ставить второй линтер.
+const NP = { slug: "no-print-in-prod", biome_rules: "noConsole",
+  recipes: { python: "ruff check --select T20 {dir}", javascript: `eslint --rule '{"no-console":"error"}' {dir}` } };
+const TODO = { slug: "todo-without-task", biome_rules: "none", recipes: { python: "ruff check --select FIX,TD {dir}" } };
+
+test("Biome: правило записи стоит в biome.json — заявка подтверждена", () => {
+  const man = parseManifest('gates:\n  lint: "npx biome check ."\ncovers:\n  lint: [no-print-in-prod]\n');
+  const biome = '{"linter":{"rules":{"suspicious":{"noConsole":"error"}}}}';
+  assert.deepEqual(coversUnproven(man, [NP], { biome }), []);
+  const miss = coversUnproven(man, [NP], { biome: '{"linter":{"enabled":true}}' });
+  assert.equal(miss[0].kind, "unproven");
+  assert.deepEqual(miss[0].codes, ["noConsole"], "человеку названо ПРАВИЛО BIOME, а не код ruff");
+});
+
+test("линтер гейта узнаётся и через npm-скрипт", () => {
+  const man = parseManifest('gates:\n  lint: "npm run lint"\ncovers:\n  lint: [no-print-in-prod]\n');
+  const scripts = { lint: "biome check ." };
+  const r = coversUnproven(man, [NP], { biome: '"noConsole": "error"', scripts });
+  assert.deepEqual(r, []);
+});
+
+test("eslint: правило берётся из рецепта записи и ищется в конфиге eslint", () => {
+  const man = parseManifest('gates:\n  lint: "eslint ."\ncovers:\n  lint: [no-print-in-prod]\n');
+  assert.deepEqual(coversUnproven(man, [NP], { eslint: "rules: { 'no-console': 'error' }" }), []);
+  assert.equal(coversUnproven(man, [NP], { eslint: "rules: {}" })[0].kind, "unproven");
+});
+
+test("у линтера нет такого правила вовсе — заявка заведомо неверна, а не «не подтверждена»", () => {
+  const man = parseManifest('gates:\n  lint: "biome check ."\ncovers:\n  lint: [todo-without-task]\n');
+  const r = coversUnproven(man, [TODO], { biome: "{}" });
+  assert.equal(r[0].kind, "impossible");
+});
+
+test("линтер не распознан — «не умею проверить», а не обвинение", () => {
+  const man = parseManifest('gates:\n  lint: "make lint"\ncovers:\n  lint: [no-print-in-prod]\n');
+  const r = coversUnproven(man, [NP], {});
+  assert.equal(r[0].kind, "unknown");
+});
+
 // --- строка манифеста, которую разбор не понял, не исчезает молча ---------------
 // Найдено 2026-09-09 случайно: подсаживал падающий гейт с именем «плохой», чтобы посмотреть
 // на строку присутствия, — и прогон вышел с НУЛЁМ. Гейт не упал: его вообще не было. Разбор
@@ -297,3 +364,34 @@ test("сбой арбитра отнимает ступень, законная
 
   assert.equal(verdict([{ state: "proven" }, { state: "broken" }]).ok, false);
 });
+
+// --- группы гейтов и --only / --skip ----------------------------------------------------
+// ЗАЧЕМ. Отзыв с живого проекта 2026-09-11: гейт цены меряет план на засеянной базе. Объявишь
+// его — он валит прогон без стенда; уберёшь — promise-has-gate справедливо ругается. Пришлось
+// выкручиваться через advisory. Прогон бывал только «всё или ничего».
+test("выбор гейтов: --skip группой и именем, --only сужает, пропущенные названы", () => {
+  const man = parseManifest('gates:\n  lint: "x"\n  unit: "x"\n  cost: "x"\n  e2e: "x"\ngroups:\n  stack: [cost, e2e]\n');
+  const names = Object.entries(man.gates);
+  const s = selectGates(names, man, { skip: ["stack"] });
+  assert.deepEqual(s.run.map(([n]) => n), ["lint", "unit"]);
+  assert.deepEqual(s.skipped, ["cost", "e2e"]);
+  const o = selectGates(names, man, { only: ["lint", "cost"] });
+  assert.deepEqual(o.run.map(([n]) => n), ["lint", "cost"]);
+  assert.deepEqual(o.skipped, ["unit", "e2e"]);
+});
+
+test("выбор гейтов: неизвестное имя — ошибка, а не тихое «пропустили ничего»", () => {
+  const man = parseManifest('gates:\n  lint: "x"\ngroups:\n  stack: [lint]\n');
+  const s = selectGates(Object.entries(man.gates), man, { skip: ["stak"] });
+  assert.deepEqual(s.unknown, ["stak"]);
+  // Группа, в которой назван необъявленный гейт, — тоже названа: иначе группа молча пустеет.
+  const man2 = parseManifest('gates:\n  lint: "x"\ngroups:\n  stack: [cots]\n');
+  assert.deepEqual(selectGates(Object.entries(man2.gates), man2, { skip: ["stack"] }).unknown, ["cots"]);
+});
+
+test("выбор гейтов: без флагов гоняется всё, как раньше", () => {
+  const man = parseManifest('gates:\n  a: "x"\n  b: "x"\n');
+  const s = selectGates(Object.entries(man.gates), man, {});
+  assert.equal(s.run.length, 2);
+  assert.deepEqual(s.skipped, []);
+});

package/tool/selfcheck/units-probe.mjs

@@ -4,6 +4,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { isFix, fixHotspots, probeSummary, probeVerdictPaired, countProbe } from "../lib/history.mjs";
 import { probeableGates, gatesState, extAlternatives, planProbeGates, isCode } from "../commands/probe.mjs";
+import { blindAdvice } from "../lib/advice.mjs";
 
 // Признак починки берётся из ТЕМЫ коммита, а не из тела: тема — единственное, что пишут все,
 // и единственное, что видно в `git log --oneline`. Три написания, потому что репозитории
@@ -220,6 +221,21 @@ test("парный вердикт: гейт позеленел от подсад
   assert.equal(probeVerdictPaired(before, after).verdict, "unknown");
 });
 
+// Гейт работал ДО подсадки и сломался ОТ неё. Он мог быть тем самым ловцом — «никто не ловит»
+// о нём сказать нельзя. Найдено пробой на самом комплекте 2026-09-11: образец лёг на место
+// kit/gates/_skip.sh, общей библиотеки двенадцати гейтов, все двенадцать вышли с кодом 2 —
+// включая gate-not-weakened, который в отдельной папке этот образец ловит. Остальные молчали,
+// и проба назвала класс слепым; doctor повторил это человеку жирным.
+test("парный вердикт: подсадка сломала работавший гейт — «не смогли», а не «слеп»", () => {
+  const { before, after } = pairs([["lint", 0], ["units", 0]], [["lint", 2], ["units", 0]]);
+  const r = probeVerdictPaired(before, after);
+  assert.equal(r.verdict, "unknown");
+  assert.equal(r.brokenByPlant, 1);
+  // Поимка соседом остаётся поимкой: знание получено, и сломанный гейт его не отменяет.
+  const other = pairs([["lint", 0], ["units", 0]], [["lint", 2], ["units", 1]]);
+  assert.equal(probeVerdictPaired(other.before, other.after).verdict, "caught");
+});
+
 test("парный вердикт: гейтов нет вовсе", () => {
   assert.equal(probeVerdictPaired([], []).verdict, "unknown");
 });
@@ -358,3 +374,91 @@ test("счёт непокрытого: исходы разложены по св
 test("счёт непокрытого: пусто не роняет", () => {
   assert.deepEqual(countProbe([]), { blindClasses: 0, caughtClasses: 0, unknownClasses: 0, probes: 0 });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Непокрытый класс объясняется, а не называется. Написано ДО кода 2026-09-10.
+//
+// ЗАЧЕМ. Проба находит настоящие дыры — и печатает про них «close it: aqk add <имя>», то есть
+// «поставь нашу штуку». Человек, который видит комплект впервые, закрывает окно.
+//
+// А готовая однострочная команда под его стек У НАС УЖЕ ЛЕЖИТ, в `recipes` записи каталога. Мы
+// её просто не показываем. Замер руками на `requests` (самый скачиваемый python-пакет): в
+// `src/requests/utils.py` — 75 коммитов-починок; дописана функция с `except Exception: pass`;
+// их собственные `ruff` и `pytest` дали 0 и на чистой копии, и на подсаженной. Строка, которая
+// бы это поймала, — `ruff check --select BLE,TRY400,SIM105 .` — лежала в нашем каталоге всё это
+// время.
+//
+// Польза обязана быть видна ДО установки комплекта: скопировал строку, увидел находки у себя —
+// и только тогда думаешь, ставить ли нас. Отчёт, который учит, а не отчитывается.
+test("совет по непокрытому классу даёт команду под стек, а не «поставь нас»", () => {
+  const entry = {
+    slug: "swallowed-error",
+    recipes: {
+      any: "bash {gate}/check.sh {dir}",
+      python: "ruff check --select BLE,TRY400,SIM105 {dir}",
+    },
+  };
+  const a = blindAdvice(entry, { langs: new Set(["python"]) }, { file: "src/requests/utils.py", fixes: 75 });
+  assert.equal(a.command, "ruff check --select BLE,TRY400,SIM105 .",
+    "команда обязана быть готовой к вставке: {dir} подставлен, {gate} не годится");
+  assert.equal(a.file, "src/requests/utils.py");
+  assert.equal(a.fixes, 75);
+});
+
+// Переносимый рецепт зовёт наш файл — вставить его человеку, у которого комплекта нет, нельзя.
+// Тогда команды нет, и совет остаётся один: поставить запись.
+test("совет: переносимый рецепт вставить некуда — команда не выдумывается", () => {
+  const entry = { slug: "x", recipes: { any: "bash {gate}/check.sh {dir}" } };
+  assert.equal(blindAdvice(entry, { langs: new Set(["python"]) }, { file: "a.py", fixes: 1 }).command, null);
+});
+
+test("совет: у стека нет своего рецепта — команды нет", () => {
+  const entry = { slug: "x", recipes: { python: "ruff check {dir}" } };
+  assert.equal(blindAdvice(entry, { langs: new Set(["go"]) }, { file: "a.go", fixes: 2 }).command, null);
+});
+
+// Python-проекту показывалась ссылка на eslint и knip: поле `tool` у записи общее на все языки.
+// Совет, в котором половина не про тебя, читается весь как «не про тебя».
+test("совет: адрес инструмента — того, которым начинается команда", () => {
+  const entry = {
+    slug: "dead-code",
+    tool: "https://github.com/jendrikseipp/vulture · https://github.com/webpro-nl/knip",
+    recipes: { python: "vulture --min-confidence 60 {dir}", javascript: "npx knip" },
+  };
+  assert.equal(blindAdvice(entry, { langs: new Set(["python"]) }).tool, "https://github.com/jendrikseipp/vulture");
+  // Команды нет или имя не совпало — весь список: лучше лишняя ссылка, чем ни одной.
+  assert.equal(blindAdvice(entry, { langs: new Set(["go"]) }).tool, entry.tool);
+  assert.equal(blindAdvice({ slug: "x" }, { langs: new Set() }).tool, null);
+});
+
+test("совет: пустая запись не роняет разбор", () => {
+  assert.equal(blindAdvice({}, { langs: new Set() }, {}).command, null);
+  assert.equal(blindAdvice({}, {}, {}).command, null);
+});
+
+// Безъязыковой родной рецепт годится в совет так же, как языковой: секреты ищутся в любом
+// файле, и именно они чаще всего оказывались в непокрытых на чужих проектах.
+test("совет: безъязыковой родной рецепт тоже даёт команду", () => {
+  const entry = { slug: "secrets-not-in-code",
+    recipes: { native: "gitleaks dir --no-banner {dir}", any: "bash {gate}/check.sh {dir}" } };
+  const a = blindAdvice(entry, { langs: new Set(["python"]) }, { file: "a.py", fixes: 9 });
+  assert.equal(a.command, "gitleaks dir --no-banner .");
+});
+
+// Из совета вычищается то, что относится к НАМ, а не к его проекту. Исключение наших красных
+// образцов (`gates/*/red`) нужно установленному гейту — рядом с ним лежат образцы. Человеку,
+// который команду только копирует, эти флаги бессмысленны и подрывают доверие: он видит, что
+// инструмент говорит про какие-то чужие каталоги, которых у него нет.
+test("совет: исключения наших образцов в команду не попадают", () => {
+  const entry = { slug: "no-print-in-prod", recipes: { javascript:
+    "eslint --no-config-lookup --ignore-pattern 'gates/*/red/**' --ignore-pattern 'gates/*/green/**' --rule '{\"no-console\":\"error\"}' {dir}" } };
+  const a = blindAdvice(entry, { langs: new Set(["javascript"]) }, {});
+  assert.ok(!a.command.includes("gates/"), `в совете остались наши каталоги: ${a.command}`);
+  assert.ok(a.command.includes("no-console"), "правило потерялось вместе с исключениями");
+  assert.ok(a.command.startsWith("eslint "), a.command);
+});
+
+test("совет: команда без наших исключений не портится", () => {
+  const entry = { slug: "x", recipes: { python: "ruff check --select T20 {dir}" } };
+  assert.equal(blindAdvice(entry, { langs: new Set(["python"]) }, {}).command, "ruff check --select T20 .");
+});

package/tool/selfcheck/units-repo.mjs

@@ -9,6 +9,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { triggerVerdict, recipeFor, EXT_LANG, whichSync, browserServerAdvice, MARKS, isApiSpec } from "../lib/repo.mjs";
+import { startWith } from "../lib/advice.mjs";
+import { proposeGates } from "../lib/adopt.mjs";
 import { CATALOGS, L } from "../i18n/index.mjs";
 import { dirname } from "node:path";
 
@@ -162,3 +164,147 @@ test("у каждого признака репозитория есть объ
     // запись каталога, выключенная навсегда и молча. Сторожим ту сторону, которая ломает.
   }
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Чужие проверки, которые у проекта УЖЕ есть. Написано ДО кода 2026-09-10.
+//
+// ЗАЧЕМ. Поставил комплект в `express` — проект с eslint, mocha и конвейером — и первое, что он
+// увидел: двадцать крестов подряд и «держит машина 0». Это неправда с его точки зрения: его
+// проверки держат, просто мы считаем только СВОИ записи.
+//
+// Мы видим, что конвейер ЕСТЬ (`has_ci`), но не читаем, что в нём. Человек должен вручную
+// переписать в манифест то, что мы могли прочитать сами. Отсюда и «не понимает, что хорошо»:
+// хорошее у него уже есть, а мы о нём молчим.
+//
+// Предлагаем, а не объявляем: гейт, вписанный без спроса, — это чужое решение в чужом файле.
+test("чужие проверки: из package.json берутся test, lint и проверка типов", () => {
+  const pkg = JSON.stringify({ scripts: {
+    test: "mocha", lint: "eslint .", typecheck: "tsc --noEmit",
+    build: "rollup -c", start: "node server.js", prepare: "husky",
+  } });
+  const got = proposeGates({ "package.json": pkg });
+  assert.deepEqual(got.map((g) => g.name).sort(), ["lint", "test", "typecheck"]);
+  assert.equal(got.find((g) => g.name === "test").cmd, "npm test");
+  assert.equal(got.find((g) => g.name === "lint").cmd, "npm run lint");
+});
+
+// `npm test` и `npm run test` — разные написания одного; берём каноничное. А `build` и `start`
+// проверками не являются: они собирают и запускают, а не судят.
+test("чужие проверки: сборка и запуск проверками не считаются", () => {
+  const pkg = JSON.stringify({ scripts: { build: "tsc", start: "node .", dev: "vite" } });
+  assert.deepEqual(proposeGates({ "package.json": pkg }), []);
+});
+
+// Makefile — вторая по частоте точка входа, и в python-проектах чаще первая.
+test("чужие проверки: цели Makefile тоже видны", () => {
+  const mk = "install:\n\tpip install -e .\n\ntest:\n\tpytest -q\n\nlint:\n\truff check .\n";
+  const got = proposeGates({ Makefile: mk });
+  assert.deepEqual(got.map((g) => g.name).sort(), ["lint", "test"]);
+  assert.equal(got.find((g) => g.name === "test").cmd, "make test");
+});
+
+test("чужие проверки: нечего предложить — пустой список, а не выдумка", () => {
+  assert.deepEqual(proposeGates({}), []);
+  assert.deepEqual(proposeGates({ "package.json": "{ не json" }), []);
+});
+
+// Источник называется: человек обязан видеть, ОТКУДА мы это взяли, иначе предложение
+// неотличимо от нашей догадки.
+test("чужие проверки: у каждого предложения назван источник", () => {
+  const got = proposeGates({ "package.json": JSON.stringify({ scripts: { test: "jest" } }) });
+  assert.equal(got[0].source, "package.json");
+});
+
+// Python-проекты. Замер 2026-09-11 на восьми живых (requests, click, flask, httpx, black,
+// fastapi, pydantic, rich): package.json нет ни у кого, Makefile у трёх — и пятеро из восьми
+// слышали «у вас ничего нет». А `.pre-commit-config.yaml` лежит у семи, tox — у пяти (у click и
+// flask в pyproject.toml), у httpx — исполняемые scripts/test и scripts/check.
+// Куски ниже сняты с этих репозиториев, а не придуманы.
+test("чужие проверки: pre-commit предлагается целиком, хуки названы поимённо", () => {
+  const cfg = "repos:\n  - repo: https://github.com/pre-commit/pre-commit-hooks\n    hooks:\n" +
+    "      - id: check-yaml\n      - id: end-of-file-fixer\n" +
+    "  - repo: https://github.com/astral-sh/ruff-pre-commit\n    hooks:\n    - id: ruff-check\n";
+  const got = proposeGates({ ".pre-commit-config.yaml": cfg });
+  assert.equal(got.length, 1);
+  assert.equal(got[0].cmd, "pre-commit run --all-files");
+  assert.match(got[0].source, /ruff-check/, "человек видит, ЧТО там стоит, а не только файл");
+});
+
+test("чужие проверки: из tox берутся окружения-проверки, а не матрица версий", () => {
+  const ini = "[tox]\nenvlist = py{310,311}-{default}\n\n[testenv]\ncommands = pytest\n\n" +
+    "[testenv:lint]\ncommands = ruff check .\n\n[testenv:docs]\ncommands = sphinx-build\n\n[testenv:{,ci-}pypy3]\n";
+  assert.deepEqual(proposeGates({ "tox.ini": ini }).map((g) => g.cmd), ["tox -e lint"]);
+  // click и flask держат tox в pyproject.toml, новым синтаксисом.
+  const py = "[tool.tox]\nenv_list = [\"py3\"]\n\n[tool.tox.env.style]\ncommands = []\n\n" +
+    "[tool.tox.env.typing]\ncommands = []\n\n[tool.tox.env.docs]\ncommands = []\n";
+  const got = proposeGates({ "pyproject.toml": py });
+  assert.deepEqual(got.map((g) => g.cmd).sort(), ["tox -e style", "tox -e typing"]);
+  assert.equal(got[0].source, "pyproject.toml");
+});
+
+test("чужие проверки: исполняемые scripts/test и scripts/check — как у httpx", () => {
+  const got = proposeGates({ "scripts/test": "", "scripts/check": "", "scripts/publish": "" });
+  assert.deepEqual(got.map((g) => g.cmd).sort(), ["scripts/check", "scripts/test"]);
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// С чего начать: три записи вместо двадцати равнозначных крестов. Написано ДО кода.
+//
+// ЗАЧЕМ. После установки человек видит двадцать крестов одинаковой формы и не знает, за что
+// взяться. Двадцать одинаковых требований — это ноль требований: закрывают первое попавшееся
+// или не закрывают ничего.
+//
+// Порядок НЕ ПО НАШЕМУ ВКУСУ. Два признака, оба — факты, которые у нас уже есть:
+//   · запись родилась из настоящего отказа (`proof` ссылается на журнал шишек — тот же
+//     признак, которым каталог отделяет условную запись) — она про боль, которая случалась, а не про «хорошую практику»;
+//   · её можно закрыть ОДНОЙ ГОТОВОЙ КОМАНДОЙ — значит цена входа минутная.
+// Сначала то, что и больно, и дёшево.
+test("с чего начать: сперва рождённые из отказа и закрываемые одной командой", () => {
+  const list = [
+    { slug: "praktika", proof: "хорошая практика", recipes: { any: "bash {gate}/c.sh {dir}" } },
+    { slug: "bol-i-deshevo", proof: "incidents/README.md, 2026-09-01", recipes: { native: "gitleaks dir {dir}" } },
+    { slug: "bol-no-dorogo", proof: "incidents/README.md, 2026-08-02", recipes: { any: "bash {gate}/c.sh {dir}" } },
+    { slug: "deshevo", proof: "методичка", recipes: { python: "ruff check {dir}" } },
+  ];
+  assert.deepEqual(startWith(list, { langs: new Set(["python"]) }, 3).map((e) => e.slug),
+    ["bol-i-deshevo", "deshevo", "bol-no-dorogo"]);
+});
+
+test("с чего начать: список короче трёх не ломается", () => {
+  assert.deepEqual(startWith([], { langs: new Set() }, 3), []);
+  const one = [{ slug: "a", proof: "incidents/README.md", recipes: {} }];
+  assert.deepEqual(startWith(one, { langs: new Set() }, 3).map((e) => e.slug), ["a"]);
+});
+
+// Порядок обязан быть УСТОЙЧИВЫМ: одинаковый ввод — одинаковый ответ, иначе человек видит
+// разный совет на двух прогонах подряд и перестаёт верить обоим.
+test("с чего начать: при равенстве признаков порядок стабилен", () => {
+  const list = [
+    { slug: "b", proof: "incidents/README.md", recipes: {} },
+    { slug: "a", proof: "incidents/README.md", recipes: {} },
+  ];
+  assert.deepEqual(startWith(list, { langs: new Set() }, 2).map((e) => e.slug), ["a", "b"]);
+});
+
+// Совет под линтер ПРОЕКТА, а не под язык. Отзыв с живого проекта 2026-09-11: «начни с этих
+// трёх» советовал завести eslint проекту на Biome — комплект читал package.json и Makefile, но не
+// biome.json. Команда для Biome — одно правило разово (`--only`), и `--error-on-warnings`
+// обязателен: правило вне рекомендованных Biome ставит на «предупреждение», и без флага команда
+// выходила с нулём, напечатав находку. Проверено на Biome 2.5.12.
+test("совет проекту на Biome: команда Biome, а не eslint", async () => {
+  const { blindAdvice } = await import("../lib/advice.mjs");
+  const entry = {
+    slug: "no-print-in-prod", biome_rules: "suspicious/noConsole",
+    tool: "https://github.com/eslint/eslint",
+    recipes: { javascript: `eslint --no-config-lookup --rule '{"no-console":"error"}' {dir}` },
+  };
+  const biome = blindAdvice(entry, { langs: new Set(["typescript"]), has_biome: true });
+  assert.equal(biome.command, "npx @biomejs/biome lint --error-on-warnings --only=suspicious/noConsole .");
+  assert.equal(biome.tool, "https://github.com/biomejs/biome");
+  // Без biome.json — прежний совет под язык.
+  const plain = blindAdvice(entry, { langs: new Set(["javascript"]), has_biome: false });
+  assert.match(plain.command, /^eslint /);
+  // У Biome правила нет вовсе (`none`) — прежний совет, а не выдуманная команда Biome.
+  const none = blindAdvice({ ...entry, biome_rules: "none" }, { langs: new Set(["javascript"]), has_biome: true });
+  assert.match(none.command, /^eslint /);
+});

package/tool/selfcheck/units-verdict.mjs

@@ -0,0 +1,76 @@
+// tool/selfcheck/units-verdict.mjs — вердикт пробы: «поймано» только ПО ДЕЛУ.
+//
+// ОТДЕЛЬНЫМ ФАЙЛОМ: units-probe.mjs у предела в 500 строк, и шов настоящий — там разбор
+// истории и план пробы, здесь то, на чём держится главное обещание пробы.
+//
+// ЗАЧЕМ. Отзыв с живого проекта 2026-09-11 (Amplifie, TypeScript на Biome): класс «цвет из
+// токена темы» проба отметила пойманным линтером, хотя Biome цвета не проверяет. Подсаженный
+// кусок сломал форматирование — упал форматтер. Вердикт считал «покраснел» равным «поймал»:
+// код возврата сравнивался, вывод выбрасывался. Итог — «every applicable class is caught by
+// something», ложная уверенность ровно в сторону самоуспокоения. К себе комплект был мягче,
+// чем к проекту: от чужого гейта мы требуем покраснеть НА БРАКЕ, а свой вердикт этого не
+// проверял.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { namesPlant, probeVerdictPaired, catchVerdict } from "../lib/history.mjs";
+
+test("назвал подсаженный файл: путь появился в выводе после подсадки", () => {
+  assert.equal(namesPlant("", "src/ui/card.tsx:12:5 lint/style/noColorLiteral", "src/ui/card.tsx"), true);
+  // Любая форма пути: относительная с ./, абсолютная из песочницы, с обратными слешами Windows.
+  assert.equal(namesPlant("", "./src/ui/card.tsx:3 print found", "src/ui/card.tsx"), true);
+  assert.equal(namesPlant("", "/tmp/aqk-probe-x/src/ui/card.tsx:3", "src/ui/card.tsx"), true);
+  assert.equal(namesPlant("", "src\\ui\\card.tsx(3,1): error", "src/ui/card.tsx"), true);
+});
+
+test("не назвал: упал по своей причине — форматтер, чужой файл, общий итог", () => {
+  assert.equal(namesPlant("", "Formatter would have printed the following content.\nFound 1 error.", "src/ui/card.tsx"), false);
+  assert.equal(namesPlant("", "src/other.tsx:1 error", "src/ui/card.tsx"), false);
+  // Файл упоминался и до подсадки столько же раз — нового ничего не сказано.
+  assert.equal(namesPlant("src/ui/card.tsx:1 warn", "src/ui/card.tsx:1 warn", "src/ui/card.tsx"), false);
+});
+
+const pairs = (before, after) => ({
+  before: before.map(([name, code]) => ({ name, code })),
+  after: after.map(([name, code, named]) => ({ name, code, named })),
+});
+
+test("покраснел, но подсаженного файла не назвал — «неизвестно», а не «поймано»", () => {
+  const { before, after } = pairs([["lint", 0], ["units", 0]], [["lint", 1, false], ["units", 0]]);
+  const r = probeVerdictPaired(before, after);
+  assert.equal(r.verdict, "unknown");
+  assert.equal(r.unattributed, 1);
+  assert.equal(r.caught, 0);
+});
+
+test("поймал по делу хоть один — «поймано»; безымянное падение соседа этого не отменяет", () => {
+  const { before, after } = pairs([["fmt", 0], ["lint", 0]], [["fmt", 1, false], ["lint", 1, true]]);
+  const r = probeVerdictPaired(before, after);
+  assert.equal(r.verdict, "caught");
+  assert.equal(r.caught, 1);
+});
+
+test("без сведений о выводе (старые вызовы) поведение прежнее", () => {
+  const { before, after } = pairs([["lint", 0]], [["lint", 1, undefined]]);
+  assert.equal(probeVerdictPaired(before, after).verdict, "caught");
+});
+
+// ИМЕНИ ФАЙЛА МАЛО. Biome, падая на форматировании, тоже называет файл: «src/card.tsx format».
+// Отличить «упал на браке» от «упал на подсадке» можно только ПАРОЙ — ровно тем, чем мы проверяем
+// чужие гейты: в то же место кладётся ЗЕЛЁНЫЙ образец той же записи. Краснеет и на нём — гейт
+// падает от самой подсадки (форматирование, синтаксис), поимка не доказана.
+test("пара: на красном назвал файл, на зелёном молчит — поймал", () => {
+  const red = { code: 1, out: "src/card.tsx:3 lint/noColorLiteral" };
+  const green = { code: 0, out: "" };
+  assert.equal(catchVerdict("", red, green, "src/card.tsx"), "caught");
+});
+
+test("пара: краснеет и на зелёном, называя тот же файл, — падает от подсадки, не поймал", () => {
+  const red = { code: 1, out: "src/card.tsx format ━━━ Formatter would have printed" };
+  const green = { code: 1, out: "src/card.tsx format ━━━ Formatter would have printed" };
+  assert.equal(catchVerdict("", red, green, "src/card.tsx"), "planting");
+});
+
+test("пара: файла не назвал — «безымянно»; зелёного образца под расширение нет — судим по имени", () => {
+  assert.equal(catchVerdict("", { code: 1, out: "Found 1 error." }, { code: 0, out: "" }, "src/a.py"), "nameless");
+  assert.equal(catchVerdict("", { code: 1, out: "src/a.py:1 T201" }, null, "src/a.py"), "caught");
+});

package/tool/selfcheck/units.mjs

@@ -12,7 +12,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { parseManifest, manifestWithGate, unknownKeys, entryLifecycle, advisorySet, KNOWN_KEYS } from "../lib/manifest.mjs";
-import { triggerVerdict, recipeFor, stems, overlap, EXT_LANG, whichSync, browserServerAdvice, MARKS } from "../lib/repo.mjs";
+import { triggerVerdict, recipeFor, pickRecipe, stems, overlap, EXT_LANG, whichSync, browserServerAdvice, MARKS } from "../lib/repo.mjs";
 import { scopeOutput, splitAdvice } from "../lib/scope.mjs";
 import { assessBaseline, ITEMS, BASELINE_TOTAL } from "../lib/baseline.mjs";
 import { CATALOGS, pickLang, L } from "../i18n/index.mjs";
@@ -398,3 +398,36 @@ test("наборы файлов правил совпадают на обоих
 
 
 
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Рецепт, не привязанный к языку. Написано ДО кода 2026-09-10.
+//
+// ЗАЧЕМ. Ключи рецептов — языки: `python`, `javascript`, `go`. Это верно для линтеров, но
+// неверно для инструментов, которым язык безразличен. `secrets-not-in-code` объявлен
+// `always: true`, готовый аналог у него — `gitleaks`, и он ищет ключи в любом файле.
+//
+// Без такого ключа выбор один из двух, и оба плохие: продублировать `gitleaks` под восемь
+// языков (тот самый повтор, против которого у нас есть гейт) или оставить запись без родного
+// рецепта. Второе и было: замер на десяти проектах показал секреты в НЕПОКРЫТЫХ у axios и у
+// всех четырёх python-проектов — то есть там, где польза наибольшая, команды для вставки не
+// было.
+//
+// Порядок предпочтения: свой язык → безъязыковой родной → переносимый. Родной сильнее
+// переносимого (у `gitleaks` сотни форматов токенов и чтение истории), но только если его есть
+// чем выполнить: непоставленная программа даёт «not found», а это отсутствие сигнала, выданное
+// за успех.
+test("рецепт: безъязыковой родной берётся, когда своего языка нет", () => {
+  const rec = { recipes: { native: "true --scan", any: "bash {gate}/check.sh {dir}" } };
+  assert.equal(pickRecipe(rec, { langs: new Set(["python"]) }), "true --scan");
+});
+
+test("рецепт: свой язык сильнее безъязыкового", () => {
+  const rec = { recipes: { python: "true --py", native: "true --scan", any: "bash x {dir}" } };
+  assert.equal(pickRecipe(rec, { langs: new Set(["python"]) }), "true --py");
+});
+
+// Программы нет — родной не берётся ни в каком виде, иначе гейт встанет с «not found».
+test("рецепт: безъязыковой без программы уступает переносимому", () => {
+  const rec = { recipes: { native: "aqk-nesuschestvuyuschiy --scan", any: "bash {gate}/check.sh {dir}" } };
+  assert.equal(pickRecipe(rec, { langs: new Set(["python"]) }), "bash {gate}/check.sh {dir}");
+});