agent-quality-kit 0.12.0 → 0.14.0

package/tool/selfcheck/smoke/verdict.test.mjs

@@ -6,9 +6,9 @@
 // Обратная сторона нашего же принципа: молчание неотличимо не только от успеха, но и от отказа.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { project, aqk } from "./_fixture.mjs";
+import { project, aqk, aqkEnv } from "./_fixture.mjs";
 
 test("прогон называет свой вердикт словами в обоих исходах", (t) => {
   const p = project(t, { "src/a.py": "def s():\n    return 1\n" });
@@ -23,7 +23,10 @@ test("прогон называет свой вердикт словами в о
   const man = join(p.dir, ".aqk.yml");
   writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m, 'gates:\n  тихий: "true"'), "utf8");
 
-  // .gitignore нет — прогон красный, и обязан сказать, из-за чего именно.
+  // .gitignore нет — прогон красный, и обязан сказать, из-за чего именно. Удаляется ЯВНО:
+  // `init` с 2026-09-11 сам создаёт .gitignore под служебные файлы, и прежняя посылка теста
+  // («после init его нет») перестала быть правдой.
+  rmSync(join(p.dir, ".gitignore"), { force: true });
   const red = aqk(p, "doctor", "--run");
   // Сообщение утверждения обязано нести ВЕСЬ хвост: проверка, которая говорит только «не
   // совпало», отправляет читателя гадать — ровно то, за что мы ругаем чужие проверки.
@@ -38,3 +41,88 @@ test("прогон называет свой вердикт словами в о
   assert.equal(green.code, 0, `прогон остался красным:\n${greenTail}`);
   assert.match(greenTail, /зелён/, `успех не назван словами:\n${greenTail}`);
 });
+
+// --skip ГРУППОЙ: гейт, которому нужен стенд, в быстром прогоне не идёт — и это СКАЗАНО, а не
+// скрыто. Отзыв с живого проекта 2026-09-11 (гейт цены без стенда валил прогон).
+test("--skip группой: прогон зелёный, пропущенный назван в выводе и в отчёте", (t) => {
+  const p = project(t, { "src/a.py": "x = 1\n" });
+  aqk(p, "init");
+  const man = join(p.dir, ".aqk.yml");
+  writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m, 'gates:\n  тихий: "true"\n  cost: "false"') +
+    "groups:\n  stack: [cost]\n", "utf8");
+  const r = aqk(p, "doctor", "--run", "--skip", "stack");
+  assert.equal(r.code, 0, `прогон без стенда покраснел:\n${r.out.slice(-600)}`);
+  assert.match(r.out, /cost/, "пропущенный гейт не назван");
+  const report = readFileSync(join(p.dir, ".aqk", "last-run.md"), "utf8");
+  assert.match(report, /^~ cost/m, `в отчёте для агента пропущенный не отмечен:\n${report}`);
+  // Опечатка в имени группы — отказ с названной причиной, а не прогон всего подряд.
+  const typo = aqk(p, "doctor", "--run", "--skip", "stak");
+  assert.notEqual(typo.code, 0);
+  assert.match(typo.out, /stak/);
+});
+
+// --jobs N: независимые гейты параллельно. Отзыв с живого проекта 2026-09-11: 34 гейта идут
+// друг за другом больше минуты, «а быструю проверку, которую долго ждать, перестают запускать».
+// Параллельность — по флагу: гейты, пишущие в одни файлы (общий dist/), иначе плавали бы.
+test("--jobs 3: три секундных гейта идут одновременно, порядок и вердикт прежние", (t) => {
+  const p = project(t, { "src/a.py": "x = 1\n", ".gitignore": "x\n" });
+  aqk(p, "init");
+  const man = join(p.dir, ".aqk.yml");
+  writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m,
+    'gates:\n  a: "sleep 1"\n  b: "sleep 1; exit 1"\n  c: "sleep 1"'), "utf8");
+  const t0 = Date.now();
+  // --verbose: зелёные a и c без него свёрнуты в одну строку, а проверяется порядок всех трёх.
+  const r = aqk(p, "doctor", "--run", "--jobs", "3", "--verbose");
+  const secs = (Date.now() - t0) / 1000;
+  assert.notEqual(r.code, 0, "упавший гейт b не уронил прогон");
+  const order = [...r.out.matchAll(/^\s+\S+\s+([abc])\s/gm)].map((m) => m[1]);
+  assert.deepEqual(order, ["a", "b", "c"], `порядок вывода не по объявлению: ${order}`);
+  // Три секунды последовательно; параллельно — одна плюс запуск node. Запас на медленную машину.
+  assert.ok(secs < 2.8, `прогон шёл ${secs.toFixed(1)} с — параллельности нет`);
+});
+
+test("--jobs без числа или с нулём — отказ с причиной, а не тихий последовательный прогон", (t) => {
+  const p = project(t, { "src/a.py": "x = 1\n" });
+  aqk(p, "init");
+  const r = aqk(p, "doctor", "--run", "--jobs", "0");
+  assert.notEqual(r.code, 0);
+  assert.match(r.out, /--jobs/);
+});
+
+// Коротко по умолчанию. Отзыв с живого проекта 2026-09-11: сто строк вывода, семьдесят из них —
+// зелёные галочки, и красное теряется между ними. Свёрнуто только то, что ничего не требует;
+// упавший и совещательный видны всегда, поимённо — по --verbose.
+test("зелёные гейты свёрнуты в строку, упавший и совещательный видны; --verbose — все", (t) => {
+  const p = project(t, { "src/a.py": "x = 1\n", ".gitignore": "x\n" });
+  aqk(p, "init");
+  const man = join(p.dir, ".aqk.yml");
+  writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m,
+    'gates:\n  green1: "true"\n  green2: "true"\n  broken: "false"\n  advice: "true"') + "advisory: [advice]\n", "utf8");
+  const short = aqk(p, "doctor", "--run").out;
+  assert.doesNotMatch(short, /^\s+\S+\s+green1\s/m, `зелёный гейт не свёрнут:\n${short}`);
+  assert.match(short, /^\s+\S+\s+broken\s/m, "упавший гейт спрятан");
+  assert.match(short, /^\s+\S+\s+advice\s/m, "совещательный обязан быть назван каждый прогон");
+  assert.match(short, /(прошли ещё 2|2 more passed)/, `нет строки со счётом свёрнутых:\n${short}`);
+  const full = aqk(p, "doctor", "--run", "--verbose").out;
+  assert.match(full, /^\s+\S+\s+green1\s/m, "--verbose не показал зелёный гейт");
+  assert.doesNotMatch(full, /(прошли ещё|more passed)/);
+});
+
+// Находки — пометками у строк файла в pull request, но только в GitHub Actions: в терминале
+// строка `::error …` — мусор. Вердикт от пометок не меняется.
+test("в GitHub Actions упавший гейт даёт пометку у строки файла; вне его — нет", (t) => {
+  // Гейт — файлом через bash: строку «echo …; exit 1» Node на Windows отдаёт cmd.exe, где точка с
+  // запятой не разделяет команды, — код 0, и проверка падала на оснастке (поймано конвейером).
+  const p = project(t, {
+    "src/a.py": "x = 1\n", ".gitignore": "x\n",
+    "bad.sh": "echo 'src/a.py:1: x — плохо'\necho '  почини: убери x'\nexit 1\n",
+  });
+  aqk(p, "init");
+  const man = join(p.dir, ".aqk.yml");
+  writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m, 'gates:\n  bad: "bash bad.sh"'), "utf8");
+  const gh = aqkEnv(p, { GITHUB_ACTIONS: "true" }, "doctor", "--run");
+  assert.notEqual(gh.code, 0, "пометки не должны менять вердикт");
+  assert.match(gh.out, /^::error file=src\/a\.py,line=1,title=aqk%3A bad::x — плохо — почини: убери x$/m, gh.out);
+  const local = aqkEnv(p, { GITHUB_ACTIONS: "" }, "doctor", "--run");
+  assert.doesNotMatch(local.out, /^::error/m, "вне GitHub Actions пометок нет");
+});

package/tool/selfcheck/smoke.sh

@@ -16,6 +16,10 @@ set -uo pipefail
 # Язык вывода закреплён: проверки ниже сверяют русский текст, а без этой строки они зависели бы
 # от локали машины — на англоязычном раннере зелёное стало бы красным без единой правки в коде.
 export AQK_LANG=ru
+# Полный вывод: проверки этого файла написаны до того, как doctor стал сворачивать пройденное и
+# неприменимое, и ищут строки из этих списков — в том числе ОТСУТСТВИЕ строки, которое на
+# свёрнутом выводе прошло бы вхолостую. Свёртку проверяют файлы smoke/*.mjs, они флаг сбрасывают.
+export AQK_VERBOSE=1
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 CLI="$ROOT/tool/program.mjs"
@@ -1903,8 +1907,12 @@ CADP="$(mktemp -d)"
   node "$CLI" init && node "$CLI" add todo-without-task
 ) >/dev/null 2>&1
 CTX0=$( cd "$CADP" && AQK_LANG=ru node "$CLI" context 2>&1 )
-RUN1=$( cd "$CADP" && AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
-RUN2=$( cd "$CADP" && AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
+# Путь ЧЕЛОВЕКА: переменные конвейера сняты. С 2026-09-11 в конвейере проба сама не идёт (минуты
+# сюрпризом в быстрой проверке), и без `env -u` эта проверка была зелёной у нас и красной в CI —
+# она проверяла бы окружение, а не каденцию. Поведение в конвейере сторожит units-cadence.mjs.
+NOCI="env -u CI -u GITHUB_ACTIONS -u GITLAB_CI -u BUILDKITE -u JENKINS_URL"
+RUN1=$( cd "$CADP" && $NOCI AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
+RUN2=$( cd "$CADP" && $NOCI AQK_LANG=ru node "$CLI" doctor --run 2>&1 )
 CTX1=$( cd "$CADP" && AQK_LANG=ru node "$CLI" context 2>&1 )
 if printf '%s' "$CTX0" | grep -q "НЕИЗВЕСТНО" &&
    printf '%s' "$RUN1" | grep -q "ещё не делали" &&

package/tool/selfcheck/units-annotate.mjs

@@ -0,0 +1,67 @@
+// tool/selfcheck/units-annotate.mjs — находки гейтов пометками GitHub Actions.
+//
+// ЗАЧЕМ. Находка гейта видна только в логе конвейера, куда почти никто не заглядывает. Строка
+// `::error file=…,line=…,title=…::…` в выводе шага становится красной пометкой у строки файла в
+// pull request. Идея — из разбора AgentLint (research/competitors/agentlint-0xmariowu.md).
+// Формат — документация GitHub (workflow-commands); экранирование — официальный
+// @actions/core (packages/core/src/command.ts: escapeData, escapeProperty), а не чужой код.
+//
+//   node --test tool/selfcheck/units-annotate.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { locate, annotations } from "../lib/annotate.mjs";
+
+const exists = (f) => ["src/a.py", "AGENTS.md", "kit/x.sh"].includes(f);
+
+test("locate: «файл:строка: находка» и «файл: находка»; без пути — ничего", () => {
+  assert.deepEqual(locate("src/a.py:12: print(x) в прод-коде"), { file: "src/a.py", line: 12, message: "print(x) в прод-коде" });
+  assert.deepEqual(locate("./AGENTS.md: «npm run debug» — такого скрипта нет"), { file: "AGENTS.md", line: null, message: "«npm run debug» — такого скрипта нет" });
+  assert.deepEqual(locate("src/a.py:3:7: E501 line too long"), { file: "src/a.py", line: 3, message: "E501 line too long" });
+  assert.equal(locate("прогон красный: 2 находки"), null);
+  assert.equal(locate("  почини: убери print"), null, "совет — не находка");
+});
+
+test("упавший гейт — пометка у строки с советом; совещательный — предупреждение", () => {
+  const r = annotations([
+    { name: "no-print", ok: false, out: "src/a.py:12: print(x)\n  почини: замени на logger\n" },
+    { name: "todo", ok: false, advisory: true, out: "src/a.py:3: TODO без задачи\n" },
+    { name: "lint", ok: true, out: "src/a.py:1: не важно\n" },
+  ], { exists });
+  assert.equal(r.lines.length, 2, "зелёный гейт пометок не даёт");
+  assert.equal(r.lines[0], "::error file=src/a.py,line=12,title=aqk%3A no-print::print(x) — почини: замени на logger");
+  assert.match(r.lines[1], /^::warning file=src\/a\.py,line=3,/);
+});
+
+// Пометка на файл, которого нет, — пометка в никуда: GitHub повесит её на `.github`, и человек
+// будет искать то, чего не существует. Такая находка идёт общей пометкой гейта без файла.
+test("путь, которого нет в репозитории, и находка без пути — одна общая пометка гейта", () => {
+  const r = annotations([
+    { name: "gates-run-in-ci", ok: false, out: "гейт smoke не запускается конвейером\n" },
+    { name: "ghost", ok: false, out: "vendor/lib.js:4: чужой файл\n" },
+  ], { exists });
+  assert.deepEqual(r.lines, [
+    "::error title=aqk%3A gates-run-in-ci::гейт smoke не запускается конвейером",
+    "::error title=aqk%3A ghost::vendor/lib.js:4: чужой файл",
+  ]);
+});
+
+test("экранирование по @actions/core: % \\r \\n в тексте, ещё : и , в свойствах", () => {
+  const r = annotations([{ name: "a,b", ok: false, out: "src/a.py:1: 100% готово, но\r нет\n" }], { exists });
+  assert.equal(r.lines[0], "::error file=src/a.py,line=1,title=aqk%3A a%2Cb::100%25 готово, но%0D нет");
+});
+
+// Потолок. В документации GitHub лимита не нашли; в обсуждении сообщества 2020 года (#26680):
+// «10 warning annotations and 10 error annotations per step». Держимся его, остаток — числом.
+test("не больше 10 ошибок и 10 предупреждений; остаток назван числом", () => {
+  const out = Array.from({ length: 14 }, (_, i) => `src/a.py:${i + 1}: находка ${i + 1}`).join("\n");
+  const r = annotations([{ name: "g", ok: false, out }], { exists });
+  assert.equal(r.lines.filter((l) => l.startsWith("::error")).length, 10);
+  assert.equal(r.dropped, 4);
+});
+
+// Поймано конвейером на первом прогоне: при --since пометки вешались на находки ВНЕ дифа, потому
+// что брались из сырого вывода. Показанное прогоном — единственный источник.
+test("пометки берутся из показанного прогоном, а не из сырого вывода", () => {
+  const r = annotations([{ name: "g", ok: false, out: "src/a.py:1: в дифе\nkit/x.sh:2: вне дифа\n", shown: "src/a.py:1: в дифе" }], { exists });
+  assert.deepEqual(r.lines, ["::error file=src/a.py,line=1,title=aqk%3A g::в дифе"]);
+});

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, blindLines, parseBlind, parseRan } from "../lib/cadence.mjs";
+import { probeDue, probeState, probeEvery, PROBE_EVERY, blindLines, parseBlind, parseRan, autoProbeAllowed, parseCounts, levelLimits } from "../lib/cadence.mjs";
 
 test("порог по умолчанию — сто коммитов, и он назван числом, а не спрятан", () => {
   assert.equal(PROBE_EVERY, 100);
@@ -103,3 +103,42 @@ test("отметка помнит, какие гейты проба ПРОГОН
   assert.equal(parseRan("at: 5\nblind: 1\n"), null);
   assert.deepEqual([...parseRan("ran:\n")], []);
 });
+
+// Проба, встроенная в `doctor --run`, в конвейере — это +2–3 минуты в случайном прогоне раз в
+// сто коммитов. Отзыв с живого проекта 2026-09-11: «пусть probe будет отдельной командой или
+// задачей, а не сюрпризом внутри быстрой проверки». В конвейере она сама не запускается; у
+// человека — по-прежнему сама: там её и надо не забыть.
+test("проба сама не запускается в конвейере, в коротком режиме и при AQK_PROBE=0", () => {
+  assert.equal(autoProbeAllowed({ brief: false, env: {} }), true);
+  assert.equal(autoProbeAllowed({ brief: false, env: { CI: "true" } }), false);
+  assert.equal(autoProbeAllowed({ brief: false, env: { GITHUB_ACTIONS: "true" } }), false);
+  assert.equal(autoProbeAllowed({ brief: true, env: {} }), false);
+  assert.equal(autoProbeAllowed({ brief: false, env: { AQK_PROBE: "0" } }), false);
+  // Явное AQK_PROBE=1 включает и в конвейере: у всего, что решено за человека, есть способ решить иначе.
+  assert.equal(autoProbeAllowed({ brief: false, env: { CI: "true", AQK_PROBE: "1" } }), true);
+});
+
+// --- чего уровень НЕ доказывает --------------------------------------------------
+// Отзыв с живого проекта 2026-09-11: «после одного --run у нас AQK-3, All levels reached. При
+// этом CI ни разу не запускался, а probe засчитывает всё подряд. Уровень меряет наличие
+// артефактов, а не то, что они работают». Смысл ступеней не меняем — поднимать планку молча
+// значит отнять опубликованный уровень у всех разом; вместо этого под уровнем стоит, чего он
+// не доказывает, и что про это знает последняя проба.
+test("отметка пробы несёт числа пойманных и недоказанных, старая — «не знаем»", () => {
+  assert.deepEqual(parseCounts("at: 5\nblind: 0\ncaught: 7\nunknown: 2\n"), { caught: 7, unknown: 2 });
+  assert.equal(parseCounts("at: 5\nblind: 0\n"), null, "старая отметка: чисел нет — это не ноль");
+});
+
+test("строка про брак в ваших файлах говорит ровно то, что знает проба", () => {
+  assert.equal(levelLimits(null).kind, "never");
+  assert.equal(levelLimits({ state: "never", behind: null, classes: [], ran: null }).kind, "never");
+  assert.equal(levelLimits({ state: "off" }).kind, "off");
+  const blind = levelLimits({ state: "fresh", behind: 3, classes: [{ slug: "swallowed-error", file: "a.py" }], ran: new Set(), counts: { caught: 4, unknown: 0 } });
+  assert.deepEqual([blind.kind, blind.names, blind.behind], ["blind", ["swallowed-error"], 3], "непойманное — первым, даже если пойманного больше");
+  const part = levelLimits({ state: "fresh", behind: 0, classes: [], ran: new Set(), counts: { caught: 4, unknown: 2 } });
+  assert.deepEqual([part.kind, part.caught, part.unknown], ["partial", 4, 2]);
+  assert.equal(levelLimits({ state: "stale", behind: 150, classes: [], ran: new Set(), counts: { caught: 5, unknown: 0 } }).kind, "caught");
+  assert.equal(levelLimits({ state: "fresh", behind: 1, classes: [], ran: new Set(), counts: { caught: 0, unknown: 0 } }).kind, "nothing");
+  assert.equal(levelLimits({ state: "fresh", behind: 1, classes: [], ran: new Set(), counts: null }).kind, "old", "старая отметка — «подробности в пробе», а не «всё поймано»");
+  assert.equal(levelLimits({ state: "unknown", behind: null, classes: [], ran: new Set(), counts: { caught: 2, unknown: 0 } }).kind, "caught", "без git отметка всё равно читается");
+});

package/tool/selfcheck/units-context.mjs

@@ -9,7 +9,7 @@
 //   node --test tool/selfcheck/units-context.mjs
 import test from "node:test";
 import assert from "node:assert/strict";
-import { contextBlock, countArbiters, parseLastRun, withHook, hasOurHook, portableSelf } from "../commands/context.mjs";
+import { contextBlock, countArbiters, parseLastRun, withHook, hasOurHook, portableSelf, nextSteps } from "../commands/context.mjs";
 import { CATALOGS } from "../i18n/index.mjs";
 import { commandRows } from "../lib/core.mjs";
 import { readFile } from "node:fs/promises";
@@ -210,3 +210,66 @@ test("выключенная и несостоявшаяся проба не в
   const unknown = text({ probe: { state: "unknown", behind: null, blind: 0 } });
   assert.match(unknown, /НЕИЗВЕСТНО|неизвестн/i, `несостоявшаяся проба не названа: ${unknown}`);
 });
+
+// --- «Дальше» и «Когда что» ------------------------------------------------------------
+// ЗАЧЕМ. Блок отвечал только на «как дела»: уровень, красное, проба. Что делать ДАЛЬШЕ, `doctor`
+// знал — три первых шага, непойманные пробой классы, чужие проверки проекта, — а в контекст это
+// не попадало. Карта «какую команду когда» жила только в полной версии, в восьми тысячах
+// токенов, где агент её пролистывал. Владелец 2026-09-11: «агент читает половину и не
+// пользуется всем функционалом». Документация Claude Code (code.claude.com/docs/en/memory):
+// «The more specific and concise your instructions, the more consistently Claude follows them»;
+// «"Run `npm test` before committing" instead of "Test your changes"».
+test("дальше: не больше трёх шагов, остаток назван числом, свои проверки проекта — первыми", () => {
+  const adopt = [{ name: "test", cmd: "make test" }];
+  const blind = [
+    { slug: "swallowed-error", file: "src/a.py", command: "ruff check --select BLE ." },
+    { slug: "no-print-in-prod", file: "src/b.py", command: null },
+  ];
+  const start = [
+    { slug: "complexity-limit", command: "ruff check --select C901 ." },
+    { slug: "swallowed-error", command: "ruff check --select BLE ." },
+    { slug: "dead-code", command: "vulture ." },
+  ];
+  const { steps, rest } = nextSteps({ adopt, blind, start });
+  assert.deepEqual(steps.map((s) => s.kind), ["adopt", "blind", "blind"]);
+  // Класс из пробы и тот же класс в «начните с трёх» — один шаг, а не два.
+  assert.equal(rest, 2, "complexity-limit и dead-code остаются; swallowed-error уже учтён пробой");
+  assert.deepEqual(nextSteps({}), { steps: [], rest: 0 });
+});
+
+test("дальше: блок печатает шаги по номерам, с командами; пусто — заголовка нет", () => {
+  const next = nextSteps({ start: [{ slug: "dead-code", command: "vulture ." }] });
+  const t = text({ next });
+  assert.match(t, new RegExp(T.nextTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+  assert.match(t, /1\. .*dead-code/);
+  assert.match(t, /vulture \./, "команда, которую можно выполнить сейчас, обязана быть в шаге");
+  assert.doesNotMatch(text({ next: { steps: [], rest: 0 } }), new RegExp(T.nextTitle.slice(0, 12)));
+});
+
+test("когда что: правило про коммит зависит от того, стоит ли хук", () => {
+  const withHook = text({ when: { hook: true } });
+  const noHook = text({ when: { hook: false } });
+  assert.match(withHook, /--no-verify/, "хук стоит — агенту сказано не обходить его");
+  assert.match(noHook, /doctor --run --since main/, "хука нет — агенту дана команда");
+  assert.notEqual(withHook, noHook);
+  // Каждое правило — «ситуация → команда»: без команды в строке правило непроверяемо.
+  for (const line of T.whenRules) assert.match(line, /`[^`]+`/, `в правиле нет команды: ${line}`);
+});
+
+// Без манифеста `aqk add` отказывает («сначала init») — шаг «поставь запись» на таком проекте
+// отправлял агента в ошибку. Найдено живым прогоном блока на requests 2026-09-11.
+test("дальше: манифеста нет — первый шаг `aqk init`, остальные после него", () => {
+  const { steps } = nextSteps({ init: true, start: [{ slug: "dead-code", command: null }] });
+  assert.equal(steps[0].kind, "init");
+  assert.equal(steps[1].kind, "start");
+  assert.match(T.nextStep.init(steps[0]), /`aqk init`/);
+});
+
+// Отзыв с живого проекта 2026-09-11: в `aqk help` у `vitals` вместо описания стояло `undefined` —
+// команду добавили в список, а текст справки забыли. Сторож на весь список, на оба языка.
+test("у каждой команды в справке есть описание на обоих языках", () => {
+  for (const lang of ["ru", "en"]) {
+    const empty = commandRows(CATALOGS[lang]).filter((r) => typeof r.text !== "string" || !r.text.trim()).map((r) => r.name);
+    assert.deepEqual(empty, [], `${lang}: нет описания у ${empty.join(", ")}`);
+  }
+});

package/tool/selfcheck/units-learn.mjs

@@ -86,3 +86,35 @@ test("typedFrom: реплика блоками собирается из тек
   });
   assert.equal(typedFrom(line)[0].text, "всегда так");
 });
+
+// ПОВТОР — СИГНАЛ, КОТОРЫЙ ДАЁТ САМ ЧЕЛОВЕК. Разбор AgentLint 2026-09-11: их SS2 сопоставляет
+// поправку с правилом свода по словам. Замер на логах владельца: из 45 поправок к записанным
+// правилам относятся от силы две — такой приём дал бы шум. Зато человек сам помечает повтор:
+// «я же говорил», «опять», «снова». Из 14 таких реплик в одном проекте настоящих норм 5–6, и
+// прежний отбор по маркерам наставления не ловил НИ ОДНОЙ.
+test("isRepeat: «я же говорил», «опять», «снова» — повтор; «опять же» и вопрос-недоумение — нет", async () => {
+  const { isRepeat } = await import("../commands/learn.mjs");
+  assert.equal(isRepeat("нет старые задачи не трогаем я же говорил только пусть новые так работают"), true);
+  assert.equal(isRepeat("стой зачем ты сумму убрал я же не просил этого ты опять не верно меня понял"), true);
+  assert.equal(isRepeat("ок давай запишем, только опять не хочу плодить файлы"), true);
+  assert.equal(isRepeat("I told you not to touch the lockfile"), true);
+  assert.equal(isRepeat("и сказать в чате, опять же, где что смотреть"), false, "«опять же» — связка, а не повтор");
+  assert.equal(isRepeat("ок го дальше"), false);
+  // Второй прогон на тех же логах: половина шума — вопросы-недоумения и вставленные цитаты агента.
+  assert.equal(isRepeat("не понял еще нужно что то опять в env добавить?"), false, "вопрос с «опять» — недоумение, а не норма");
+  assert.equal(isRepeat("⬜ Два мира ролей — всплывёт, если снова будем трогать роли. поясни"), false, "цитата ответа агента");
+  assert.equal(isRepeat("почему ты так долго тестируешь я же говорю не нужно столько тестов?"), true, "сильная пометка держится и с вопросом");
+});
+
+// Повтор, совпавший с правилом свода, — главное, что может сказать эта команда: правило
+// записано, а человек всё равно поправляет. Текстом оно не держится — ему нужен сторож.
+test("repeatedRules: повтор, совпавший с правилом свода, называет это правило", async () => {
+  const { repeatedRules } = await import("../commands/learn.mjs");
+  const entry = "# Правила\n\n- **Не плодить файлы.** Новый файл — только если без него нельзя. <!-- aqk: человек -->\n" +
+    "- **Секреты только в .env.** <!-- aqk: secrets-not-in-code -->\n- обычная строка списка без метки\n";
+  const hits = repeatedRules([{ text: "опять ты плодишь файлы, я же говорил", when: "2026-09-03" }], entry);
+  assert.equal(hits.length, 1);
+  assert.match(hits[0].rule, /Не плодить файлы/);
+  assert.equal(hits[0].arbiter, "человек");
+  assert.equal(repeatedRules([{ text: "опять не тот цвет кнопки", when: "x" }], entry).length, 0, "повтор не про правило — не сюда");
+});

package/tool/selfcheck/units-level.mjs

@@ -11,8 +11,8 @@ import test from "node:test";
 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";
+import { pickLang, langFromText, langFromDocs } from "../i18n/index.mjs";
+import { progress, selectGates } from "../lib/run.mjs";
 
 // --- строка «идёт» во время прогона ---------------------------------------------------
 // ЗАЧЕМ. Гейт идёт через spawnSync, и строка про него печаталась только по завершении: минута
@@ -214,6 +214,26 @@ test("мусор в поле lang не молчит, а просто не дей
   assert.equal(pickLang({}, { lang: "клингонский" }), "en");
 });
 
+// Отзыв с живого проекта 2026-09-11: свод правил и методички на русском, машина на Windows без
+// LANG — и весь вывод английский, пока руками не впишешь `lang:`. Язык текста, который проект
+// сам о себе написал, — свойство проекта; поэтому он выше локали и ниже манифеста.
+test("язык свода проекта сильнее локали и слабее манифеста", () => {
+  const ruDoc = "# Правила\n\nПеред коммитом запусти `npm run check` и `make gates`. Схемы живут в " +
+    "`packages/contract`, их проверяет сервер.\n\n```sh\nnpm run typecheck && npm run lint\n```\n" +
+    "Любое изменение договора проходит через ревью и фиксируется в журнале решений.\n";
+  const enDoc = "# Rules\n\nBefore committing run `npm run check`. Schemas live in packages/contract " +
+    "and the server validates them. Every contract change goes through review and is logged.\n";
+  assert.equal(langFromDocs(ruDoc.repeat(2)), "ru", "русский свод с кодом внутри не узнан");
+  assert.equal(langFromDocs(enDoc.repeat(2)), "en");
+  assert.equal(langFromDocs("# X\n\n`npm test`\n"), "", "по трём словам язык не решается");
+  assert.equal(pickLang({ LANG: "en_US.UTF-8" }, null, "ru"), "ru");
+  assert.equal(pickLang({}, null, "ru"), "ru", "Windows без LANG: свод решает");
+  assert.equal(pickLang({ LANG: "ru_RU.UTF-8" }, null, "en"), "en");
+  assert.equal(pickLang({}, { lang: "en" }, "ru"), "en", "манифест сильнее свода");
+  assert.equal(pickLang({ AQK_LANG: "en" }, null, "ru"), "en", "переменная сильнее свода");
+  assert.equal(pickLang({ LANG: "ru_RU.UTF-8" }, null, ""), "ru", "свод молчит — решает локаль");
+});
+
 // Сокращённый разбор языка в i18n/index.mjs существует потому, что каталог строк нужен раньше,
 // чем кто-либо успеет прочитать манифест целиком. Два разбора одного файла — то же, что два
 // свода правил: через месяц они расходятся, и непонятно, какой настоящий. Сверяем ответы.
@@ -249,7 +269,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" }]);
 });
 
 // Правило может стоять не в команде, а в конфиге линтера — это нормальный уклад, и краснеть
@@ -267,6 +287,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 случайно: подсаживал падающий гейт с именем «плохой», чтобы посмотреть
 // на строку присутствия, — и прогон вышел с НУЛЁМ. Гейт не упал: его вообще не было. Разбор
@@ -321,3 +384,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

@@ -3,7 +3,8 @@
 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, blindAdvice, isCode } from "../commands/probe.mjs";
+import { probeableGates, gatesState, extAlternatives, planProbeGates, isCode } from "../commands/probe.mjs";
+import { blindAdvice } from "../lib/advice.mjs";
 
 // Признак починки берётся из ТЕМЫ коммита, а не из тела: тема — единственное, что пишут все,
 // и единственное, что видно в `git log --oneline`. Три написания, потому что репозитории