agent-quality-kit 0.7.0 → 0.9.0

package/tool/selfcheck/units-level.mjs

@@ -1,14 +1,17 @@
 // tool/selfcheck/units-level.mjs — проверки уровня и доказательства гейтов.
 //
 // ОТДЕЛЬНЫМ ФАЙЛОМ, а не в units.mjs: тот перерос собственный предел в 500 строк, и поймал
-// это наш же гейт `file-size-limit` на прогоне. Шов по смыслу: здесь всё про то, чем ступень
-// отличается от заявления, — остальное осталось на месте.
+// это наш же гейт `file-size-limit` на прогоне. Шов по смыслу: здесь всё, что программа
+// вычитывает ИЗ МАНИФЕСТА и объявляет о проекте, — ступень, доказательство гейтов и раскладка
+// (где правила, методички, точка входа). Общее у них одно и важное: ответ обязан приходить из
+// манифеста, а не из умолчаний, совпадающих с нашими собственными значениями.
 //
 //   node --test tool/selfcheck/units-level.mjs
 import test from "node:test";
 import assert from "node:assert/strict";
 import { commandFor } from "../lib/prove.mjs";
-import { assessLevel } from "../lib/manifest.mjs";
+import { assessLevel, layoutChecks, unknownKeys, KNOWN_KEYS, parseManifest, coversOf, coversUnproven, unparsedLines } from "../lib/manifest.mjs";
+import { pickLang, langFromText } from "../i18n/index.mjs";
 
 // --- доказательство гейтов ------------------------------------------------------------
 // ЗАЧЕМ. Ступень AQK-2 называлась «гейты доказаны» и проверяла существование двух папок.
@@ -58,3 +61,208 @@ test("обе обёртки снимаются вместе", () => {
     "bash gates/_native.sh gates/x/green ruff check gates/x/green"
   );
 });
+
+// Отзыв второго пользователя, 2026-09-08: на Windows `prove` объявил два ИСПРАВНЫХ гейта
+// сломанными. Путь к образцу собирался `path.join`, то есть `gates\x\red`, и уезжал в строку
+// команды — а её исполняет `sh`, который обратный слэш съедает как экранирование: остаётся
+// `gatesxred`. Каталога нет → `find` молчит → код 0 → «промолчал на КРАСНОМ образце».
+// Проверка идёт здесь, а не в самом сборщике пути: `commandFor` — единственная дверь, через
+// которую каталог попадает в оболочку, и закрывать её надо там, кто бы путь ни собрал.
+test("каталог образца уходит в оболочку с прямыми слэшами", () => {
+  assert.equal(
+    commandFor("bash gates/x/check.sh .", "gates\\x\\red"),
+    "bash gates/x/check.sh gates/x/red",
+  );
+});
+
+// Тот же путь едет ВТОРЫМ адресом — первым аргументом фильтра образцов. Пропустить его значит
+// починить половину: фильтр не узнает образец и спрячет ровно то, что образец обязан показать.
+test("обёртка родного инструмента тоже получает прямые слэши", () => {
+  assert.equal(
+    commandFor("bash gates/_native.sh . npx knip --directory .", "gates\\x\\red"),
+    "bash gates/_native.sh gates/x/red npx knip --directory gates/x/red",
+  );
+});
+
+// --- где у проекта лежат правила и методички ----------------------------------
+// Отзыв второго пользователя, 2026-09-08: `doctor` рисовал два красных креста за сделанное.
+// У проекта `rules: .temper/rules`, правила на месте, гейт entry-links-exist их видит, уровень
+// AQK-1 считается ПО МАНИФЕСТУ — а список в шапке проверял литеральные `.aqk/rules` и
+// `.aqk/docs` и советовал сделать сделанное. Уровень и вывод расходились в разные стороны:
+// хуже неверного вывода только вывод, который расходится с собственным вердиктом.
+test("каталог правил берётся из манифеста, а не из умолчания", () => {
+  const paths = layoutChecks({ rules: ".temper/rules" }, false).map(([p]) => p);
+  assert.ok(paths.includes(".temper/rules"), "путь из манифеста обязан попасть в список");
+  assert.ok(!paths.includes(".aqk/rules"), "умолчание обязано уступить манифесту");
+});
+
+// Поля `docs:` не было вовсе: перенести методички было НЕКУДА, и проект, разложивший их иначе,
+// получал крест без единого способа его снять. Умолчание остаётся для тех, кто поля не завёл.
+test("каталог методичек тоже берётся из манифеста", () => {
+  const paths = layoutChecks({ docs: ".temper/docs" }, false).map(([p]) => p);
+  assert.ok(paths.includes(".temper/docs"));
+  assert.ok(!paths.includes(".aqk/docs"));
+});
+
+test("без манифеста остаются умолчания", () => {
+  const paths = layoutChecks(null, false).map(([p]) => p);
+  assert.ok(paths.includes(".aqk/rules") && paths.includes(".aqk/docs"));
+});
+
+// В самом комплекте лежат оригиналы, а не разложенная копия: копия завтра разошлась бы с ними.
+test("внутри комплекта проверяются его собственные каталоги", () => {
+  const paths = layoutChecks({ rules: "kit/rules" }, true).map(([p]) => p);
+  assert.ok(paths.includes("kit/rules") && paths.includes("kit/docs"));
+});
+
+// Поле, которое программа читает, обязано быть в списке известных: иначе манифест с ним
+// получает предупреждение «неизвестное поле» за то, что работает.
+test("docs — известное поле манифеста", () => {
+  assert.ok(KNOWN_KEYS.includes("docs"));
+  assert.deepEqual(unknownKeys({ docs: ".aqk/docs" }), []);
+});
+
+// --- covers: запись закрыта другим арбитром -----------------------------------
+// Просьба первого чужого пользователя, 2026-09-08, названная им первой: «нельзя сказать, что
+// эта запись у нас закрыта другим гейтом. complexity-limit, no-print-in-prod, swallowed-error
+// держит biome — одним арбитром, точнее переносимого. doctor каждый прогон печатает
+// „применимо, но не поставлено: 5“ — неправду».
+//
+// Неправда в НАШЕМ выводе — самая дорогая из возможных: весь стандарт стоит на том, что вывод
+// не врёт. Поэтому поле есть, но оно не признание на слово: гейт, который «закрывает», обязан
+// быть объявлен в gates:. Иначе covers: становится способом объявить защиту, которой нет, —
+// то самое, против чего написан комплект.
+test("вложенный список в квадратных скобках разбирается как список", () => {
+  const man = parseManifest("covers:\n  lint: [no-print-in-prod, swallowed-error]\n");
+  assert.deepEqual(man.covers.lint, ["no-print-in-prod", "swallowed-error"]);
+});
+
+test("covers отдаёт связь «запись → чем закрыта»", () => {
+  const man = parseManifest("gates:\n  lint: \"biome ci .\"\ncovers:\n  lint: [no-print-in-prod, swallowed-error]\n");
+  const { covered } = coversOf(man);
+  assert.equal(covered.get("no-print-in-prod"), "lint");
+  assert.equal(covered.get("swallowed-error"), "lint");
+});
+
+// Гейт, которого нет в gates:, не закрывает ничего. Промолчать здесь значит выдать
+// несуществующего арбитра за существующего — ровно тот отказ, ради которого всё написано.
+test("закрывать может только объявленный гейт", () => {
+  const man = parseManifest("gates:\n  lint: \"biome ci .\"\ncovers:\n  biome: [complexity-limit]\n");
+  const { covered, unknownGates } = coversOf(man);
+  assert.equal(covered.size, 0, "необъявленный гейт не закрывает ничего");
+  assert.deepEqual(unknownGates, ["biome"]);
+});
+
+test("пустой covers ничего не ломает", () => {
+  const { covered, unknownGates } = coversOf(parseManifest("aqk: 1\n"));
+  assert.equal(covered.size, 0);
+  assert.deepEqual(unknownGates, []);
+});
+
+test("covers — известное поле манифеста", () => {
+  assert.ok(KNOWN_KEYS.includes("covers"));
+  assert.deepEqual(unknownKeys({ covers: {} }), []);
+});
+
+// --- язык вывода: настройка ПРОЕКТА, а не машины ------------------------------
+// Просьба первого чужого пользователя: «язык берётся из LC_ALL/LANG, а на Windows их просто
+// нет: русский проект получает английский вывод. AQK_LANG=ru чинит, но у следующего человека
+// будет своё. Место этому в .aqk.yml». Он прав: язык репозитория — свойство репозитория,
+// а локаль — свойство машины, на которой его сегодня открыли.
+//
+// Порядок намеренный: переменная окружения ВЫШЕ манифеста. Человек, набравший AQK_LANG=en
+// руками, хочет английский именно сейчас — и спорить с ним манифестом значит отнять последнее
+// средство. Манифест выше локали: он про проект, локаль про машину.
+test("манифест задаёт язык, когда переменной окружения нет", () => {
+  assert.equal(pickLang({ LANG: "en_US.UTF-8" }, { lang: "ru" }), "ru");
+});
+
+test("переменная окружения сильнее манифеста", () => {
+  assert.equal(pickLang({ AQK_LANG: "en" }, { lang: "ru" }), "en");
+});
+
+test("без манифеста всё как раньше — локаль, потом английский", () => {
+  assert.equal(pickLang({ LANG: "ru_RU.UTF-8" }, null), "ru");
+  assert.equal(pickLang({}, null), "en");
+});
+
+test("мусор в поле lang не молчит, а просто не действует", () => {
+  assert.equal(pickLang({}, { lang: "клингонский" }), "en");
+});
+
+// Сокращённый разбор языка в i18n/index.mjs существует потому, что каталог строк нужен раньше,
+// чем кто-либо успеет прочитать манифест целиком. Два разбора одного файла — то же, что два
+// свода правил: через месяц они расходятся, и непонятно, какой настоящий. Сверяем ответы.
+test("сокращённый разбор языка не расходится с настоящим", () => {
+  for (const text of [
+    'aqk: 1\nlang: ru\ngates:\n  lint: "true"\n',
+    "aqk: 1\nlang: 'en'\n",
+    'aqk: 1\nlang: "ru"   # комментарий\n',
+    "aqk: 1\ngates:\n  lang: ru\n",     // вложенный ключ — не язык проекта
+    "aqk: 1\n",
+  ]) {
+    assert.equal(langFromText(text), String(parseManifest(text).lang || ""), text);
+  }
+});
+
+// --- заявка covers сверяется, а не принимается на слово -----------------------
+// Поле `covers:` я завёл этим же утром и сам записал в коммит: «снимает запись с долга по
+// СЛОВУ человека; проверить, что чужой гейт ловит то же самое, машина не может». К вечеру
+// выяснилось, что это не теория. Запуск на настоящем `ruff.toml` из живого проекта: девятнадцать
+// групп правил в `extend-select`, и `print()` не ловится — группы `T20` среди них нет.
+// То есть заявка «no-print-in-prod держит наш lint» была бы ЛОЖНОЙ, а запись ушла бы из долга.
+//
+// Проверяется ровно то, что можно: у записи каталога в рецепте стоят коды правил
+// (`ruff check --select T20`). Если ни команда закрывающего гейта, ни конфиг линтера этих кодов
+// не называют — заявка не подтверждена. Это не «ложь», а «не подтверждено»: правило могло
+// прийти из плагина или пресета, и объявлять такое ошибкой значит краснеть на нормальном укладе.
+test("заявка подтверждена, когда коды правил есть в команде гейта", () => {
+  const man = parseManifest('gates:\n  lint: "ruff check --select T20,BLE ."\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, ""), []);
+});
+
+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"] }]);
+});
+
+// Правило может стоять не в команде, а в конфиге линтера — это нормальный уклад, и краснеть
+// на нём нельзя. Настоящий пример: extend-select в ruff.toml.
+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, 'extend-select = ["I", "T20", "B"]'), []);
+});
+
+// У записи без кодов правил в рецепте сверять нечего — молчим, а не выдумываем вердикт.
+test("запись без кодов правил в рецепте не порождает придирки", () => {
+  const man = parseManifest('gates:\n  lint: "true"\ncovers:\n  lint: [duplicate-code]\n');
+  const catalog = [{ slug: "duplicate-code", recipes: { any: "bash {gate}/check.sh {dir}" } }];
+  assert.deepEqual(coversUnproven(man, catalog, ""), []);
+});
+
+// --- строка манифеста, которую разбор не понял, не исчезает молча ---------------
+// Найдено 2026-09-09 случайно: подсаживал падающий гейт с именем «плохой», чтобы посмотреть
+// на строку присутствия, — и прогон вышел с НУЛЁМ. Гейт не упал: его вообще не было. Разбор
+// принимает имена только латиницей, а строку, которая под это не подошла, ВЫБРАСЫВАЛ без слова.
+//
+// Это наш класс в чистом виде: человек объявил проверку, видит её в файле, а она не
+// существует. Хуже опечатки в имени поля — ту мы называем с 2026-09-06, а эту не называли.
+// Чинится не расширением алфавита, а голосом: любая непонятая строка обязана быть названа.
+test("непонятая строка манифеста называется с номером", () => {
+  const bad = unparsedLines('aqk: 1\ngates:\n  ok: "true"\n  плохой: "false"\n');
+  assert.equal(bad.length, 1);
+  assert.equal(bad[0].line, 4);
+  assert.match(bad[0].text, /плохой/);
+});
+
+test("правильный манифест не порождает жалоб", () => {
+  assert.deepEqual(unparsedLines('aqk: 1\nentry:\n  - AGENTS.md\ngates:\n  ok: "true"\n'), []);
+});
+
+// Комментарии и пустые строки — не находка: они и не должны разбираться.
+test("комментарии и пустые строки не считаются потерянными", () => {
+  assert.deepEqual(unparsedLines("# заметка\n\naqk: 1\n   # ещё\n"), []);
+});

package/tool/selfcheck/units-repo.mjs

@@ -0,0 +1,134 @@
+// tool/selfcheck/units-repo.mjs — осмотр репозитория: язык по расширению, триггеры записей,
+// выбор рецепта, поиск программы в PATH, совет про браузер у агента.
+//
+// ОТДЕЛЬНЫМ ФАЙЛОМ, а не в units.mjs: тот снова перерос собственный предел в 500 строк, и поймал
+// это наш же file-size-limit. Шов по смыслу: здесь всё, что программа УЗНАЁТ О ЧУЖОМ РЕПОЗИТОРИИ
+// и что из этого следует, — а в units.mjs осталось то, что она делает со своими данными.
+//
+//   node --test tool/selfcheck/units-repo.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { triggerVerdict, recipeFor, EXT_LANG, whichSync, browserServerAdvice, MARKS } from "../lib/repo.mjs";
+import { CATALOGS, L } from "../i18n/index.mjs";
+import { dirname } from "node:path";
+
+const facts = (over = {}) => ({ langs: new Set(), files: 0, ...over });
+
+// --- опознание языка по расширению -------------------------------------------
+// Найдено на самом aqk: вся программа лежит в .mjs, и запись про отладочную печать
+// пряталась с пояснением «нет языков: javascript» — в проекте, целиком на JavaScript.
+test("расширение .mjs — это JavaScript", () => {
+  assert.equal(EXT_LANG[".mjs"], "javascript");
+  assert.equal(EXT_LANG[".cjs"], "javascript");
+  assert.equal(EXT_LANG[".mts"], "typescript");
+  assert.equal(EXT_LANG[".py"], "python");
+});
+
+
+// --- триггер ------------------------------------------------------------------
+test("без триггера запись не показывается", () => {
+  assert.equal(triggerVerdict({}, facts()).applies, false);
+});
+
+test("условия складываются по И: одно ложное скрывает запись", () => {
+  const rec = { trigger: { langs: "python", files_gt: "10" } };
+  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["python"]), files: 50 })).applies, true);
+  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["python"]), files: 3 })).applies, false);
+  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["go"]), files: 50 })).applies, false);
+});
+
+test("причина, по которой запись скрыта, называется словами", () => {
+  const v = triggerVerdict({ trigger: { langs: "python, typescript" } }, facts({ langs: new Set(["go"]) }));
+  // Сверяем с каталогом, а не с буквами: текст переводится, а выбор причины — нет.
+  assert.equal(v.why, L.trigger.noLangs("python, typescript"));
+});
+
+test("always: false значит «никогда не применимо», а не «условие пропущено»", () => {
+  const v = triggerVerdict({ trigger: { always: "false" } }, facts());
+  assert.equal(v.applies, false);
+});
+
+test("неизвестное условие скрывает запись, а не пропускает её", () => {
+  // Молча пропустить незнакомое условие значит показать запись всем подряд.
+  const v = triggerVerdict({ trigger: { has_kubernetes: "true" } }, facts());
+  assert.equal(v.applies, false);
+  assert.equal(v.why, L.trigger.unknown("has_kubernetes"));
+});
+
+// --- выбор рецепта ------------------------------------------------------------
+test("без родного языка берётся переносимый рецепт, {dir} подставляется", () => {
+  const cmd = recipeFor({ slug: "x", recipes: { any: "bash {gate}/check.sh {dir}" } }, facts());
+  assert.match(cmd, /check\.sh \.$/);
+});
+
+test("рецепта нет — так и сказано, а не пустая строка", () => {
+  assert.equal(recipeFor({ slug: "x", recipes: {} }, facts()), L.recipe.none);
+});
+
+
+// --- поиск программы в PATH ---------------------------------------------------
+// ЗАЧЕМ. Раньше наличие программы проверялось через `command -v` в оболочке. На Windows
+// оболочка — cmd.exe, где такой команды нет, и ответ был «не установлено» ДЛЯ ЛЮБОЙ
+// программы: родной рецепт становился недостижим, гейт молча вставал на слабейший
+// переносимый вариант, а прогон показывал зелёное. Нашлось на чужом прогоне, не у нас.
+test("программа в PATH находится, несуществующая — нет", () => {
+  assert.ok(whichSync("node"), "node обязан находиться: им же запущена эта проверка");
+  assert.equal(whichSync("нет-такой-программы-12345"), null);
+  assert.equal(whichSync(""), null);
+});
+
+test("поиск не зависит от оболочки — работает с пустым окружением", () => {
+  // Тот самый случай: оболочки нет или она другая. Ответ обязан быть «не нашли»,
+  // а не исключение и не ложное «нашли».
+  assert.equal(whichSync("node", { PATH: "" }), null);
+  const dir = dirname(process.execPath);
+  assert.ok(whichSync(process.platform === "win32" ? "node" : "node", { PATH: dir }));
+});
+
+test("команда путём, а не именем, ищется на диске, а не в PATH", () => {
+  assert.ok(whichSync(process.execPath));
+  assert.equal(whichSync("./нет-такого-файла.sh"), null);
+});
+
+
+// --- совет про браузерный MCP-сервер ------------------------------------------
+// Решение владельца 2026-09-08: инструмент, дающий агенту браузер, надо РЕКОМЕНДОВАТЬ.
+// Возражение про нейтральность к вендору здесь не работает: MCP — межвендорный протокол,
+// и сервер одинаково нужен Cursor, Codex и Claude Code.
+//
+// Но совет показывается не всем. Проекту без интерфейса браузер не нужен, а совет, показанный
+// не тому, стоит доверия всем остальным советам — та же норма, что у записей каталога.
+test("совет про браузер даётся проекту с интерфейсом, у которого сервера нет", () => {
+  assert.ok(browserServerAdvice({ has_ui: true }, ""));
+});
+
+test("проекту без интерфейса совет не даётся", () => {
+  assert.equal(browserServerAdvice({ has_ui: false }, ""), null);
+});
+
+// Уже поставил — молчим. Совет, повторяемый тому, кто его выполнил, читается как шум,
+// и следующий совет он пролистает вместе с этим.
+test("сервер уже объявлен — совета нет", () => {
+  const cfg = '{"mcpServers":{"browser":{"command":"npx","args":["-y","chrome-devtools-mcp@1.9.0"]}}}';
+  assert.equal(browserServerAdvice({ has_ui: true }, cfg), null);
+  const pw = '{"mcpServers":{"b":{"command":"npx","args":["@playwright/mcp@0.0.80"]}}}';
+  assert.equal(browserServerAdvice({ has_ui: true }, pw), null);
+});
+
+// Признак репозитория без объяснения — это запись каталога, ВЫКЛЮЧЕННАЯ НАВСЕГДА. Триггер
+// с неизвестным ключом даёт «условие программа не умеет считать», и запись не показывается
+// никому и никогда. Поймано на себе 2026-09-08: завёл has_mcp в списке признаков, объяснение
+// не завёл, и новая запись стала неприменимой в любом репозитории. Видно это было только в
+// выводе doctor на чужой папке — ни один прогон не краснел.
+test("у каждого признака репозитория есть объяснение на обоих языках", () => {
+  const names = MARKS.map(([n]) => n);
+  for (const lang of ["ru", "en"]) {
+    const flags = CATALOGS[lang].trigger.flags;
+    const missing = names.filter((n) => !flags[n]);
+    assert.deepEqual(missing, [], `${lang}: нет объяснения для ${missing.join(", ")}`);
+    // Обратной проверки нет намеренно, и это не лень. Часть признаков считается не по наличию
+    // файла, а обходом содержимого (has_db, has_tests, has_ui), и в этом списке их нет.
+    // Риск несимметричен: объяснение без признака — мёртвая строка, признак без объяснения —
+    // запись каталога, выключенная навсегда и молча. Сторожим ту сторону, которая ломает.
+  }
+});

package/tool/selfcheck/units-vitals.mjs

@@ -0,0 +1,62 @@
+// tool/selfcheck/units-vitals.mjs — «всё ли у самого комплекта подключено».
+//
+// ЗАЧЕМ ЭТА КОМАНДА. `doctor` смотрит на РЕПОЗИТОРИЙ, `prove` — на гейты, `context` — на
+// состояние. На саму обвязку не смотрит никто: стоят ли инструменты, которых требуют
+// объявленные гейты; прописан ли хук в `.git/hooks` на самом деле; получает ли агент состояние.
+// Сегодня это выясняется красным гейтом посреди коммита — в худший момент из возможных.
+//
+//   node --test tool/selfcheck/units-vitals.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { vitalsRows, vitalsVerdict } from "../commands/vitals.mjs";
+
+const ok = { tools: [], unparsed: 0, preCommit: true, sessionHook: true, version: null };
+
+// ТРИ СОСТОЯНИЯ, А НЕ ДВА. «Не подключено» и «не знаем» — разные ответы, и сливать их значит
+// врать ровно тем способом, против которого написан весь комплект.
+test("неизвестное не выдаётся за исправное", () => {
+  const rows = vitalsRows({ ...ok, preCommit: null });
+  const hook = rows.find((r) => r.key === "preCommit");
+  assert.equal(hook.ok, null, "не смогли посмотреть — значит неизвестно, а не «нет»");
+  // И «нет» — тоже отдельное состояние, не равное ни «да», ни «неизвестно».
+  assert.equal(vitalsRows({ ...ok, preCommit: false }).find((r) => r.key === "preCommit").ok, "no");
+});
+
+test("отсутствующий инструмент объявленного гейта — отказ, а не мелочь", () => {
+  const rows = vitalsRows({ ...ok, tools: [{ gate: "lint", prog: "ruff", found: false }] });
+  const t = rows.find((r) => r.key === "tools");
+  assert.equal(t.ok, false);
+  assert.match(t.detail, /ruff/);
+  assert.match(t.detail, /lint/, "названо, КАКОЙ гейт останется без арбитра");
+});
+
+test("все инструменты на месте — строка зелёная", () => {
+  const rows = vitalsRows({ ...ok, tools: [{ gate: "lint", prog: "ruff", found: true }] });
+  assert.equal(rows.find((r) => r.key === "tools").ok, true);
+});
+
+test("непонятые строки манифеста попадают в вердикт", () => {
+  const rows = vitalsRows({ ...ok, unparsed: 2 });
+  assert.equal(rows.find((r) => r.key === "manifest").ok, false);
+});
+
+// Код возврата: красное — отказ, неизвестное — не отказ. Иначе команда краснела бы у всех,
+// у кого просто нет `.claude/`, и её выключили бы в первый день.
+test("вердикт краснеет от отказов, но не от незнания и не от выбора", () => {
+  assert.equal(vitalsVerdict(vitalsRows(ok)), 0);
+  assert.equal(vitalsVerdict(vitalsRows({ ...ok, preCommit: null, sessionHook: null })), 0);
+  // Хука нет — это решение человека (гоняет в конвейере), а не поломка. Команда, которая
+  // кричит «сломано» про выбор, перестаёт читаться вместе с настоящими отказами.
+  assert.equal(vitalsVerdict(vitalsRows({ ...ok, preCommit: false, sessionHook: false })), 0);
+  assert.equal(vitalsVerdict(vitalsRows({ ...ok, unparsed: 1 })), 1);
+  assert.equal(vitalsVerdict(vitalsRows({ ...ok, tools: [{ gate: "g", prog: "x", found: false }] })), 1);
+});
+
+// Устаревшая версия — не отказ: человек мог закрепить её сознательно.
+test("старая версия сообщается, но не роняет", () => {
+  const rows = vitalsRows({ ...ok, version: { current: "0.8.0", latest: "0.9.0" } });
+  const v = rows.find((r) => r.key === "version");
+  assert.equal(v.ok, null);
+  assert.match(v.detail, /0\.9\.0/);
+  assert.equal(vitalsVerdict(rows), 0);
+});

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 } from "../lib/repo.mjs";
+import { triggerVerdict, recipeFor, 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";
@@ -21,16 +21,6 @@ import { dirname } from "node:path";
 
 const facts = (over = {}) => ({ langs: new Set(), files: 0, ...over });
 
-// --- опознание языка по расширению -------------------------------------------
-// Найдено на самом aqk: вся программа лежит в .mjs, и запись про отладочную печать
-// пряталась с пояснением «нет языков: javascript» — в проекте, целиком на JavaScript.
-test("расширение .mjs — это JavaScript", () => {
-  assert.equal(EXT_LANG[".mjs"], "javascript");
-  assert.equal(EXT_LANG[".cjs"], "javascript");
-  assert.equal(EXT_LANG[".mts"], "typescript");
-  assert.equal(EXT_LANG[".py"], "python");
-});
-
 // --- разбор манифеста ---------------------------------------------------------
 test("список читается и строкой в скобках, и пунктами", () => {
   assert.deepEqual(parseManifest("entry: [AGENTS.md, CLAUDE.md]").entry, ["AGENTS.md", "CLAUDE.md"]);
@@ -43,46 +33,6 @@ test("вложенный блок читается словарём, комме
   assert.equal(m.rules, "kit/rules");
 });
 
-// --- триггер ------------------------------------------------------------------
-test("без триггера запись не показывается", () => {
-  assert.equal(triggerVerdict({}, facts()).applies, false);
-});
-
-test("условия складываются по И: одно ложное скрывает запись", () => {
-  const rec = { trigger: { langs: "python", files_gt: "10" } };
-  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["python"]), files: 50 })).applies, true);
-  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["python"]), files: 3 })).applies, false);
-  assert.equal(triggerVerdict(rec, facts({ langs: new Set(["go"]), files: 50 })).applies, false);
-});
-
-test("причина, по которой запись скрыта, называется словами", () => {
-  const v = triggerVerdict({ trigger: { langs: "python, typescript" } }, facts({ langs: new Set(["go"]) }));
-  // Сверяем с каталогом, а не с буквами: текст переводится, а выбор причины — нет.
-  assert.equal(v.why, L.trigger.noLangs("python, typescript"));
-});
-
-test("always: false значит «никогда не применимо», а не «условие пропущено»", () => {
-  const v = triggerVerdict({ trigger: { always: "false" } }, facts());
-  assert.equal(v.applies, false);
-});
-
-test("неизвестное условие скрывает запись, а не пропускает её", () => {
-  // Молча пропустить незнакомое условие значит показать запись всем подряд.
-  const v = triggerVerdict({ trigger: { has_kubernetes: "true" } }, facts());
-  assert.equal(v.applies, false);
-  assert.equal(v.why, L.trigger.unknown("has_kubernetes"));
-});
-
-// --- выбор рецепта ------------------------------------------------------------
-test("без родного языка берётся переносимый рецепт, {dir} подставляется", () => {
-  const cmd = recipeFor({ slug: "x", recipes: { any: "bash {gate}/check.sh {dir}" } }, facts());
-  assert.match(cmd, /check\.sh \.$/);
-});
-
-test("рецепта нет — так и сказано, а не пустая строка", () => {
-  assert.equal(recipeFor({ slug: "x", recipes: {} }, facts()), L.recipe.none);
-});
-
 // --- дедупликация по намерению ------------------------------------------------
 test("разные намерения не путаются служебными словами", () => {
   // Найдено на `aqk new dead-code-not-shipped`: слова not/in/code давали ложное совпадение
@@ -158,30 +108,6 @@ test("язык берётся из AQK_LANG, потом из локали, ин
   assert.equal(pickLang({}), "en");
 });
 
-// --- поиск программы в PATH ---------------------------------------------------
-// ЗАЧЕМ. Раньше наличие программы проверялось через `command -v` в оболочке. На Windows
-// оболочка — cmd.exe, где такой команды нет, и ответ был «не установлено» ДЛЯ ЛЮБОЙ
-// программы: родной рецепт становился недостижим, гейт молча вставал на слабейший
-// переносимый вариант, а прогон показывал зелёное. Нашлось на чужом прогоне, не у нас.
-test("программа в PATH находится, несуществующая — нет", () => {
-  assert.ok(whichSync("node"), "node обязан находиться: им же запущена эта проверка");
-  assert.equal(whichSync("нет-такой-программы-12345"), null);
-  assert.equal(whichSync(""), null);
-});
-
-test("поиск не зависит от оболочки — работает с пустым окружением", () => {
-  // Тот самый случай: оболочки нет или она другая. Ответ обязан быть «не нашли»,
-  // а не исключение и не ложное «нашли».
-  assert.equal(whichSync("node", { PATH: "" }), null);
-  const dir = dirname(process.execPath);
-  assert.ok(whichSync(process.platform === "win32" ? "node" : "node", { PATH: dir }));
-});
-
-test("команда путём, а не именем, ищется на диске, а не в PATH", () => {
-  assert.ok(whichSync(process.execPath));
-  assert.equal(whichSync("./нет-такого-файла.sh"), null);
-});
-
 // --- значок уровня ------------------------------------------------------------
 // ЗАЧЕМ. Значок печатает одна функция, а читает его обратно другое выражение — в том же
 // файле, но независимо. Разойдись они, и `badge --check` перестал бы узнавать собственный
@@ -469,3 +395,6 @@ test("наборы файлов правил совпадают на обоих
   assert.deepEqual(en, ru);
   assert.equal(ru.length > 0, true);
 });
+
+
+