agent-quality-kit 0.13.0 → 0.15.0

package/kit/gates/entry-commands-exist/red/AGENTS.md

@@ -0,0 +1,9 @@
+# Rules
+
+Build and check before every commit:
+
+```sh
+npm run build
+npm run debug        # build + install + logs
+make deploy
+```

package/kit/gates/entry-commands-exist/red/Makefile

@@ -0,0 +1,2 @@
+test:
+	node --test

package/kit/gates/entry-commands-exist/red/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "sample",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "debug": "4.3.4"
+  }
+}

package/llms.txt

@@ -46,6 +46,10 @@ Zero runtime dependencies. Node 18+ and an `sh` shell. MIT.
   adds the command map and the rulebook verbatim (~7000 tokens): a deliberate trade, chosen by
   the owner after the objection about long inputs, on the grounds that an agent reads files
   poorly and the tokens are the price of it not guessing
+- Hand the agent one task instead of retelling the diagnosis: `npx agent-quality-kit prompt` —
+  ground rules on top, at most five items by weight (red gates, defects the probe planted and no
+  check caught, the project's own checks to declare, rules Claude Code cannot see, catalog
+  entries to propose), and for every item the command that proves it done. Nothing is run
 - Check that the kit's own wiring is actually connected: `npx agent-quality-kit vitals` — are the
   tools the declared gates need installed, is the hook present in `.git/hooks` (a line in the
   config is an intention, not a guard), does the agent receive the state, is the version current.
@@ -72,7 +76,7 @@ Zero runtime dependencies. Node 18+ and an `sh` shell. MIT.
   the files `init` writes are owned by root, so you cannot edit your own manifest. Debian-based
   on purpose: the gates are `sh`, `grep`, `awk`, `find` — under alpine's busybox they behave
   differently, and an image where the gates behave differently is worse than no image
-- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.13.0` with `min: 1`
+- As a GitHub Action: `uses: arsen-ask-lx/Agent_Quality_Kit@v0.15.0` with `min: 1`
   (https://github.com/marketplace/actions/agent-quality-kit-aqk)
 
 ## What makes it different

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-quality-kit",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Turns the rules an agent is supposed to follow into commands with exit codes, and reports which of them actually run. Zero dependencies.",
   "type": "module",
   "bin": {

package/tool/commands/context.mjs

@@ -21,14 +21,14 @@
 // а агент примет его за утверждение. Поэтому каждое незнание называется словом: прогона не было —
 // так и написано, прогон устарел — тоже, инструмента нет — тоже.
 import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { spawnSync } from "node:child_process";
 import { join } from "node:path";
 import { CWD, TARGET_DIR, SELF, c, exists, commandRows, preCommitHook } from "../lib/core.mjs";
+import { maybeAsk } from "./feedback.mjs";
 import { readManifest, assessLevel, coversOf } from "../lib/manifest.mjs";
 import { detectFacts, readCatalog } from "../lib/repo.mjs";
 import { catalogBuckets, startWith, blindAdvice } from "../lib/advice.mjs";
 import { proposeGates, readAdoptFiles } from "../lib/adopt.mjs";
-import { declaredGates } from "../lib/run.mjs";
+import { declaredGates, readRun } from "../lib/run.mjs";
 import { probeStatus } from "./probe.mjs";
 import { L } from "../i18n/index.mjs";
 
@@ -73,11 +73,17 @@ function contextBlock(state, T = L.context) {
     out.push(T.runNone);
   } else {
     const red = state.run.red || [];
-    const shown = red.slice(0, MAX_RED);
-    const names = red.length > MAX_RED
-      ? `${shown.join(", ")} — ${T.andMore(red.length - MAX_RED)}`
-      : shown.join(", ");
-    out.push(red.length ? T.runRed(state.run.when, names) : T.runClean(state.run.when));
+    const cannot = state.run.cannot || [];
+    const short = (list) => (list.length > MAX_RED
+      ? `${list.slice(0, MAX_RED).join(", ")} — ${T.andMore(list.length - MAX_RED)}`
+      : list.join(", "));
+    if (red.length) out.push(T.runRed(state.run.when, short(red)));
+    // «НЕ СМОГЛИ ПРОВЕРИТЬ» — ОТДЕЛЬНОЙ СТРОКОЙ, И ЧИСТО ТОЛЬКО КОГДА ОБА СПИСКА ПУСТЫ.
+    // Гейт, который не сумел отработать, не находка о коде: агент, прочитавший его как находку,
+    // пойдёт чинить исправный файл. А если бы он не попал НИКУДА, прогон, где всё сломалось,
+    // читался бы как «чисто» — та же тишина, только внутри блока, который читает машина.
+    if (cannot.length) out.push(T.runCannot(short(cannot)));
+    if (!red.length && !cannot.length) out.push(T.runClean(state.run.when));
     if (state.run.stale) out.push(T.runStale(state.run.when));
     if (state.run.skipped) out.push(T.skipped(state.run.skipped));
   }
@@ -148,20 +154,13 @@ function contextBlock(state, T = L.context) {
   // чем промолчать: он пойдёт его читать и получит пустоту вместо правил. Замерено на шести
   // чужих проектах: на flask блок писал «Свод правил: AGENTS.md», которого там нет.
   if (state.entryExists !== false) out.push("", T.where(state.entry || "AGENTS.md"));
+  // ПРОСЬБА ОБ ОТЗЫВЕ — последней строкой и только при содержании (feedback.mjs). Последней
+  // потому, что это единственная строка блока, которая не про состояние проекта: ставить её
+  // выше значило бы отодвинуть работой то, ради чего блок и читают.
+  if (state.ask) out.push("", state.ask);
   return out;
 }
 
-// Разбор отчёта прошлого прогона. Формат кладёт сам `doctor` в .aqk/last-run.md; читаем его,
-// а не запускаем гейты заново: хук обязан укладываться в секунду-две, а прогон у нас идёт минуту.
-function parseLastRun(text) {
-  if (!text) return null;
-  const when = (text.match(/^# aqk doctor --run — (.+)$/m) || [])[1] || "";
-  const red = [];
-  for (const m of text.matchAll(/^✘ ([^\s—]+)/gm)) red.push(m[1]);
-  const skipped = (text.match(/^~ /gm) || []).length;
-  return { when: when.trim(), red, skipped, stale: false };
-}
-
 // Правила и их арбитры: отметка `<!-- aqk: имя -->` рядом с правилом. `человек` — честное
 // признание, что машина этого не держит; так его и считаем, отдельно от машинных.
 function countArbiters(text, humanWords) {
@@ -173,16 +172,6 @@ function countArbiters(text, humanWords) {
   return { total: marks.length, machine: marks.length - human, human };
 }
 
-// Прогон старше последнего коммита описывает не тот код, что лежит перед агентом. Молча выдать
-// его за свежий — соврать: именно так «зелёный месяц назад» превращается в «зелёный сейчас».
-function runIsStale(when) {
-  if (!when) return false;
-  const r = spawnSync("git", ["log", "-1", "--format=%cI"], { cwd: CWD, encoding: "utf8" });
-  if (r.status !== 0 || !r.stdout) return false;
-  const commit = Date.parse(r.stdout.trim());
-  const run = Date.parse(when.replace(" ", "T"));
-  return Number.isFinite(commit) && Number.isFinite(run) && run < commit;
-}
 
 
 // УСТАНОВКА ХУКА — отдельной командой, а не частью `init`, и это решение, а не лень. Комплект
@@ -260,6 +249,27 @@ async function installHook(full = false) {
   console.log(c.dim(`  ${T.hookWhat}`));
 }
 
+// Что советовать — теми же функциями, что у `doctor`: корзины каталога, «начните с трёх», совет
+// под язык, чужие проверки проекта. Одно место на `context` и `prompt`: второй расчёт того же
+// самого разошёлся бы с первым. Класс из пробы, чей гейт уже стоит, в совет не идёт — ставить
+// его второй раз бессмысленно.
+async function readAdvice(man, probe) {
+  const facts = await detectFacts(man);
+  const catalog = await readCatalog();
+  const { todo } = catalogBuckets(catalog, facts, coversOf(man).covered);
+  const adopt = declaredGates(man).length ? [] : proposeGates(await readAdoptFiles(CWD));
+  const blind = (probe?.classes || [])
+    .filter((b) => !facts.gateKeys.includes(b.slug))
+    .map((b) => ({ ...b, command: blindAdvice(catalog.find((r) => r.slug === b.slug), facts, {}).command }));
+  const start = startWith(todo, facts, 3)
+    .map((rec) => ({ slug: rec.slug, intent: rec.intent || "", command: blindAdvice(rec, facts, {}).command }));
+  // Гейт стоит, проба его ГОНЯЛА — и брак он пропустил. Самое ценное, что проба знает: не
+  // «поставь», а «твоя проверка здесь слепа». Гейт, поставленный после пробы, сюда не идёт —
+  // поймает ли, покажет следующая.
+  const missed = (probe?.classes || []).filter((b) => facts.gateKeys.includes(b.slug) && probe?.ran?.has(b.slug));
+  return { adopt, blind, start, missed };
+}
+
 async function cmdContext(args = []) {
   const full = args.includes("--full");
   if (args.includes("--install")) return installHook(full);
@@ -286,12 +296,7 @@ async function cmdContext(args = []) {
     rules = countArbiters(await readFile(join(CWD, entry), "utf8"), ["человек", "human", "nobody"]);
   }
 
-  let run = null;
-  const lastRun = join(CWD, TARGET_DIR, "last-run.md");
-  if (await exists(lastRun)) {
-    run = parseLastRun(await readFile(lastRun, "utf8"));
-    if (run) run.stale = runIsStale(run.when);
-  }
+  const run = await readRun();
 
   // Проба: сколько классов не ловит никто и насколько отметка отстала. Читается из файла,
   // ничего не запускает — блок обязан укладываться в секунду.
@@ -334,21 +339,31 @@ async function cmdContext(args = []) {
   // язык, чужие проверки проекта. Второй расчёт того же самого разошёлся бы с первым.
   let next = null;
   try {
-    const facts = await detectFacts(man);
-    const catalog = await readCatalog();
-    const { todo } = catalogBuckets(catalog, facts, coversOf(man).covered);
-    const adopt = declaredGates(man).length ? [] : proposeGates(await readAdoptFiles(CWD));
-    const blind = (probe?.classes || [])
-      .filter((b) => !facts.gateKeys.includes(b.slug))
-      .map((b) => ({ ...b, command: blindAdvice(catalog.find((r) => r.slug === b.slug), facts, {}).command }));
-    const start = startWith(todo, facts, 3).map((rec) => ({ slug: rec.slug, command: blindAdvice(rec, facts, {}).command }));
+    const { adopt, blind, start } = await readAdvice(man, probe);
     next = nextSteps({ init: !man, adopt, blind, start });
   } catch { /* не посчитали — блок скажет остальное; выдумывать шаги нельзя */ }
 
+  // ЕДИНСТВЕННАЯ ПЛАТА ЗА КОМПЛЕКТ — один ответ автору, и просит о нём агент: он читает этот
+  // блок каждую сессию и передаёт человеку то, что в нём написано. Замер 2026-09-14: тысяча
+  // скачиваний в неделю и ноль отзывов за всё время — просьба печаталась только при `init`, то
+  // есть до того, как комплект сделал хоть что-то.
+  //
+  // ТРИ УСЛОВИЯ, И ВСЕ ТРИ ОБЯЗАТЕЛЬНЫ: не выключено человеком, не просили на этом проекте
+  // раньше, и ЕСТЬ О ЧЁМ рассказать. Без третьего это «оставьте отзыв» — шум, а шум выключают
+  // вместе с хуком, в котором он приехал.
+  //
+  // ЕДИНСТВЕННАЯ ЗАПИСЬ НА ДИСК В ЭТОЙ КОМАНДЕ, кроме `--install`. Без отметки просьба
+  // повторялась бы каждую сессию: красный гейт живёт в проекте днями, а блок читается заново
+  // при каждом запуске агента и после каждого сжатия контекста.
+  const ask = await maybeAsk({
+    cannot: run?.cannot || [], red: run?.red || [],
+    blind: (probe?.classes || []).map((b) => b.slug),
+  }, portableSelf(SELF), { agent: true });
+
   console.log(contextBlock({
     entry, entryExists: rules !== null, level, rules, run, ratchets, probe, full: fullPart,
-    next, when: { hook: await preCommitHook(CWD) },
+    next, when: { hook: await preCommitHook(CWD) }, ask,
   }).join("\n"));
 }
 
-export { cmdContext, contextBlock, nextSteps, parseLastRun, countArbiters, withHook, hasOurHook, portableSelf };
+export { cmdContext, contextBlock, nextSteps, countArbiters, withHook, hasOurHook, portableSelf, readAdvice };

package/tool/commands/doctor-catalog.mjs

@@ -0,0 +1,222 @@
+// tool/commands/doctor-catalog.mjs — что каталог говорит об ЭТОМ репозитории: какие записи
+// держит машина, что у проекта уже есть, что пропустила проба, с чего начать, что неприменимо.
+//
+// Вынесено из doctor.mjs, когда тот дорос до 496 строк при пределе 500 (наш же
+// `file-size-limit`). Шов настоящий: прогон гейтов и уровень — про то, что ОБЪЯВЛЕНО и как оно
+// отработало; здесь — про каталог против фактов репозитория, и меняется это в другие дни.
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CWD, SELF, c } from "../lib/core.mjs";
+import { coversOf, coversUnproven } from "../lib/manifest.mjs";
+import { readCatalog, browserServerAdvice } from "../lib/repo.mjs";
+import { startWith, catalogBuckets, blindAdvice } from "../lib/advice.mjs";
+import { proposeGates, readAdoptFiles } from "../lib/adopt.mjs";
+import { assessBaseline, DEP_FILES, BASELINE_TOTAL } from "../lib/baseline.mjs";
+import { declaredGates } from "../lib/run.mjs";
+import { L } from "../i18n/index.mjs";
+
+// Обязательный минимум проекта — прогоном, а не по памяти. До сих пор это было единственное
+// место, где комплект просил верить на слово, что человек прочитал методичку и сверился.
+async function reportBaseline(man, facts) {
+  const { readdir, readFile } = await import("node:fs/promises");
+  let files = [];
+  try {
+    files = (await readdir(CWD, { withFileTypes: true })).map((d) => d.name);
+  } catch { /* пустой список честнее выдуманного: ни один пункт не подтвердится */ }
+
+  // Файлы зависимостей читаются целиком и склеиваются: трекер ошибок объявляют по-разному в
+  // каждой экосистеме, а искать его надо одинаково.
+  let depsText = "";
+  for (const f of DEP_FILES) {
+    if (!files.some((n) => n.toLowerCase() === f)) continue;
+    try { depsText += (await readFile(join(CWD, f), "utf8")).toLowerCase() + "\n"; } catch { /* нечитаемый файл — просто не признак */ }
+  }
+
+  const rows = assessBaseline({ files, gateKeys: facts.gateKeys, facts, manifest: man || {}, depsText });
+  const okCount = rows.filter((r) => r.ok).length;
+
+  console.log(c.bold(`\n  ${L.baseline.heading}\n`));
+  console.log(c.dim(`  ${L.baseline.intro(rows.length, BASELINE_TOTAL)}`));
+  console.log(c.dim(`  ${L.baseline.caveat}\n`));
+  for (const r of rows) {
+    const mark = r.ok ? c.green("✔") : c.yellow("✘");
+    const title = L.baseline.titles[r.key] || r.key;
+    console.log(`  ${mark}  ${String(r.n).padStart(2)}. ${title}`);
+    console.log(c.dim(`        ${r.ok ? L.baseline.by(r.by) : L.baseline.none}`));
+  }
+  console.log(
+    "\n  " + (okCount === rows.length ? c.green(`${okCount}/${rows.length}`) : c.yellow(`${okCount}/${rows.length}`)) +
+      c.dim(`  ·  ${L.baseline.eyes(BASELINE_TOTAL - rows.length, "kit/docs/ai/project-baseline.md")}\n`)
+  );
+}
+
+async function reportCatalog(man, facts, probe = null, verbose = true) {
+  const catalog = await readCatalog();
+  if (!catalog.length) return;
+
+  // Четвёртая корзина, а не третья: «закрыто другим арбитром» — это НЕ «не поставлено».
+  // Пока их считали вместе, вывод каждый прогон называл долгом то, что уже держит biome или
+  // ruff. Просьба первого чужого пользователя; она же — наша собственная норма про вывод.
+  const { covered, unknownGates } = coversOf(man);
+  const { held, todo, skip, byOther } = catalogBuckets(catalog, facts, covered);
+
+  console.log(c.bold(`\n  ${L.doctor.gatesHeading}\n`));
+  const marks = ["has_ci", "has_db", "has_docker", "has_tests", "has_deps"]
+    .filter((k) => facts[k])
+    .map((k) => k.replace("has_", ""));
+  console.log(
+    c.dim(`  ${L.doctor.langs}: ${[...facts.langs].join(", ") || L.doctor.langsUnknown} · ${L.doctor.files}: ${facts.files}` +
+      (marks.length ? ` · ${L.doctor.hasThings}: ${marks.join(", ")}` : "") + "\n")
+  );
+
+  if (verbose) for (const rec of held) console.log(`  ${c.green("✔")}  ${rec.slug.padEnd(22)} ${c.dim(rec.intent || "")}`);
+  else if (held.length) console.log(`  ${c.green("✔")}  ${L.doctor.heldQuiet(held.length, `${SELF} doctor --verbose`)}`);
+  // ЧТО У ВАС УЖЕ ЕСТЬ — до итога и до списка крестов. Комплект, поставленный в проект с
+  // eslint, mocha и конвейером, показывал двадцать крестов и «держит машина 0»: мы считали
+  // только СВОИ записи, а чужие проверки не читали вовсе. С точки зрения владельца это
+  // неправда, и первое, что он видел, было обвинением. Предлагаем, а не вписываем: гейт в
+  // чужом манифесте без спроса — наше решение в чужом файле.
+  if (!declaredGates(man).length) {
+    const found = proposeGates(await readAdoptFiles(CWD));
+    if (found.length) {
+      console.log(`\n  ${c.bold(L.doctor.haveAlready(found.length))}`);
+      for (const g of found) {
+        console.log(`  ${c.green("✔")}  ${g.name.padEnd(12)} ${c.dim(`${g.cmd}   ← ${g.source}`)}`);
+      }
+      console.log(c.dim(`     ${L.doctor.haveAlreadyHow(found.map((g) => `${g.name}: "${g.cmd}"`).join("  "))}`));
+    }
+  }
+
+  // ЧТО ВАШИ ПРОВЕРКИ ПРОПУСТИЛИ. Проба знала имена непойманных классов и писала в отметку одно
+  // число; человек в `doctor` не видел ничего. Это самое конкретное, что мы знаем о проекте, —
+  // не «хорошая практика», а брак, подсаженный в ЕГО файл и ЕГО проверками не замеченный, —
+  // поэтому стоит выше списка «с чего начать». Читается из файла: ничего не запускает.
+  const blindOnes = (probe?.classes || []).map((b) => [b, catalog.find((r) => r.slug === b.slug)]).filter(([, r]) => r);
+  if (blindOnes.length) {
+    console.log(`\n  ${c.yellow("⚠")}  ${c.bold(L.doctor.blindHeading(probe.behind))}`);
+    for (const [b, rec] of blindOnes) {
+      // Три случая, и сливать их нельзя. Гейт стоял и проба его ГОНЯЛА — «стоит, но здесь не
+      // ловит», самое ценное. Гейт объявлен, но проба его не гоняла (поставлен позже или
+      // медленный) — «поймает ли, покажет следующая», а не «пойман». Гейта нет — совет.
+      const ranIt = probe.ran?.has(rec.slug);
+      const now = facts.gateKeys.includes(rec.slug);
+      console.log(`  ${now && !ranIt ? c.dim("~") : c.red("✘")}  ${rec.slug.padEnd(22)} ${c.dim(`${rec.intent || ""}  ← ${b.file}`)}`);
+      if (ranIt) { console.log(c.dim(`     ${L.doctor.blindRan(rec.slug)}`)); continue; }
+      if (now) { console.log(c.dim(`     ${L.doctor.blindInstalled}`)); continue; }
+      const adv = blindAdvice(rec, facts, {});
+      if (adv.command) console.log(c.dim(`     ${L.doctor.startCmd(adv.command)}`));
+      else console.log(c.dim(`     ${L.doctor.install(`${SELF} add ${rec.slug}`)}`));
+    }
+    console.log(c.dim(`     ${L.doctor.blindMore(`${SELF} probe`)}`));
+  } else if (probe?.state === "never" && declaredGates(man).length) {
+    console.log(c.dim(`\n  ${L.doctor.probeNever(`${SELF} probe`)}`));
+  }
+
+  // С ЧЕГО НАЧАТЬ. Двадцать одинаковых крестов — это ноль требований: закрывают первое
+  // попавшееся или не закрывают ничего. Порядок не по нашему вкусу: сперва то, что родилось из
+  // настоящего отказа И закрывается одной готовой командой.
+  const first = todo.length > 3 ? startWith(todo, facts, 3) : [];
+  if (first.length) {
+    console.log(`\n  ${c.bold(L.doctor.startWith)}`);
+    for (const rec of first) {
+      const adv = blindAdvice(rec, facts, {});
+      console.log(`  ${c.yellow("→")}  ${rec.slug.padEnd(22)} ${c.dim(rec.intent || "")}`);
+      if (adv.command) console.log(c.dim(`     ${L.doctor.startCmd(adv.command)}`));
+      if (adv.tool) console.log(c.dim(`     ${L.doctor.startTool(adv.tool)}`));
+    }
+    // Одна проверка руками — это разовый героизм. Сказать про хук здесь, а не в конце: человек
+    // читает первые строки и закрывает, а именно сейчас у него в руках список того, что стоит
+    // повесить перед пушем.
+    console.log(c.dim(`\n     ${L.doctor.startHook}`));
+  }
+
+  // ОСТАЛЬНОЕ — ПОСЛЕ ГЛАВНОГО И СЖАТО. Список шёл первым, по две строки на запись (вторая —
+  // «поставить: aqk add …»), и на requests главное начиналось со строки 84 из 102: человек
+  // читает сверху и закрывает раньше. Разбор соседа 2026-09-11 (research/competitors/agentlint.md):
+  // там первыми идут пять главных исправлений. Записи не теряются — теряется повтор подсказки.
+  const rest = todo.filter((r) => !first.includes(r));
+  if (rest.length) {
+    if (first.length) console.log(`\n  ${c.bold(L.doctor.todoRest(rest.length))}`);
+    else console.log("");
+    // ○, а не ✘: запись не установлена — это не падение. Крест в зелёном прогоне глаз читает
+    // как провал, и через неделю человек перестаёт смотреть на красное вообще (отзыв с живого
+    // проекта 2026-09-11). ✘ остаётся за тем, что упало или пропустило брак.
+    for (const rec of rest) console.log(`  ${c.dim("○")}  ${rec.slug.padEnd(22)} ${rec.intent || ""}`);
+    console.log(c.dim(`     ${L.doctor.todoRestHow(SELF)}`));
+  }
+
+  // Второстепенное — в конце: что закрыто чужим арбитром, что неприменимо, советы без вердикта.
+  if (byOther.length) {
+    console.log(c.dim(`\n  ${L.doctor.coveredBy(byOther.length)}`));
+    for (const [rec, gate] of byOther) console.log(c.dim(`  ~  ${rec.slug.padEnd(22)} ${L.doctor.coveredByGate(gate)}`));
+  }
+  // Гейт, которого нет в gates:, не закрывает ничего — и молчать об этом нельзя: человек
+  // считает запись закрытой, а её не держит никто. Называется поимённо, жёлтым.
+  if (unknownGates.length) {
+    console.log(c.yellow(`\n  ${L.doctor.coversUnknown(unknownGates.join(", "))}`));
+  }
+  // Заявка «эту запись держит наш линтер» сверяется с кодами правил из рецепта записи.
+  // Замерено на живом ruff.toml: девятнадцать групп правил, а print() не ловится — и заявка
+  // сняла бы запись с долга, не закрыв её ничем.
+  // Конфиги — ПО ЛИНТЕРАМ, а не одной склейкой: заявка сверяется правилами того линтера,
+  // которым закрыт гейт (отзыв с живого проекта 2026-09-11 — коды ruff искались в biome.json).
+  const readAll = async (names) => {
+    let t = "";
+    for (const f of names) { try { t += await readFile(join(CWD, f), "utf8") + "\n"; } catch { /* нет файла */ } }
+    return t;
+  };
+  let scripts = {}, pkgText = "";
+  try { pkgText = await readFile(join(CWD, "package.json"), "utf8"); scripts = JSON.parse(pkgText)?.scripts || {}; } catch { /* нет или не JSON */ }
+  const configs = {
+    // ruff.toml и .ruff.toml — конфиг ruff целиком, слово «ruff» в них писать незачем (поймал наш же
+    // smoke: `extend-select = [..., "T20"]` выбрасывался). pyproject.toml — только если в нём есть
+    // раздел ruff: он есть почти у каждого python-проекта и без ruff.
+    ruff: (await readAll(["ruff.toml", ".ruff.toml"])) +
+      ((await readAll(["pyproject.toml"])).match(/^\[tool\.ruff[\s\S]*/m)?.[0] || ""),
+    eslint: (await readAll([".eslintrc", ".eslintrc.json", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.yml", "eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts"])) +
+      (/"eslintConfig"/.test(pkgText) ? pkgText : ""),
+    biome: await readAll(["biome.json", "biome.jsonc"]),
+    scripts,
+  };
+  for (const u of coversUnproven(man, catalog, configs)) {
+    if (u.kind === "unproven") {
+      console.log(c.yellow(`\n  ${L.doctor.coversUnproven(u.entry, u.gate, u.codes.join(", "))}`));
+      console.log(c.dim(`  ${L.doctor.coversUnprovenHow(`${SELF} add ${u.entry}`)}`));
+    } else if (u.kind === "impossible") {
+      console.log(c.yellow(`\n  ${L.doctor.coversImpossible(u.entry, u.gate, u.linter)}`));
+      console.log(c.dim(`  ${L.doctor.coversUnprovenHow(`${SELF} add ${u.entry}`)}`));
+    } else {
+      console.log(c.dim(`\n  ${L.doctor.coversCantCheck(u.entry, u.gate)}`));
+    }
+  }
+  // Не вердикт, а совет: отсутствие браузерного сервера — незанятая возможность, а не дефект.
+  // Поэтому строка тусклая и без значка, и её нет у проекта без интерфейса.
+  let mcpText = "";
+  for (const f of [".mcp.json", ".cursor/mcp.json", ".vscode/mcp.json", ".claude/mcp.json"]) {
+    try { mcpText += await readFile(join(CWD, f), "utf8"); } catch { /* нет файла — нечего читать */ }
+  }
+  const browser = browserServerAdvice(facts, mcpText);
+  if (browser) {
+    console.log(c.dim(`\n  ${L.doctor.noBrowserServer}`));
+    console.log(c.dim(`  ${L.doctor.noBrowserServerHow(browser.servers.join("  ·  "))}`));
+  }
+  if (skip.length) {
+    if (verbose) {
+      console.log(c.dim(`\n  ${L.doctor.notApplicable(skip.length)}`));
+      for (const [rec, why] of skip) console.log(c.dim(`  ·  ${rec.slug.padEnd(22)} ${why}`));
+    } else {
+      console.log(c.dim(`\n  ${L.doctor.skipQuiet(skip.length, `${SELF} doctor --verbose`)}`));
+    }
+  }
+  console.log(
+    `\n  ${c.bold(L.doctor.total)} ${L.doctor.totalHeld(held.length)}, ${L.doctor.totalTodo(c.yellow(todo.length))}, ` +
+      (byOther.length ? `${L.doctor.totalCovered(byOther.length)}, ` : "") +
+      c.dim(L.doctor.totalSkip(skip.length)) + "\n"
+  );
+  // Числа отдаются наружу, а не пересчитываются второй раз: два счёта одного и того же
+  // расходятся ровно так же, как два списка команд.
+  return { held: held.length, todo: todo.length, todoRecs: todo };
+}
+
+export { reportBaseline, reportCatalog };