agent-quality-kit 0.15.0 → 0.16.0

package/tool/lib/core.mjs

@@ -40,8 +40,16 @@ const exists = async (p) => access(p, constants.F_OK).then(() => true, () => fal
 // Как звать программу — зависит от того, как её запустили. Через npx команды `aqk` в системе
 // нет: подсказка «aqk doctor» отправляет человека в «команда не найдена» на первом же шаге.
 // Печатаем то, что можно скопировать и выполнить прямо сейчас.
-// Имя в реестре, а не адрес репозитория: короче, скачивается 230 КБ вместо клона всего
-// репозитория и не заставляет человека ждать три минуты в тишине на первой же команде.
+// Имя в реестре, а не адрес репозитория: короче, тянет пакет вместо клона всего репозитория и
+// не заставляет человека ждать три минуты в тишине на первой же команде.
+//
+// ЧИСЛА ЗДЕСЬ БОЛЬШЕ НЕТ, И ЭТО РЕШЕНИЕ. Стояло «230 КБ»; замер 2026-09-10 дал 574 КБ, замер
+// 2026-09-14 — 692 КБ. Число, которое никто не сторожит, врёт тем сильнее, чем дольше живёт, —
+// наше же правило про утверждение без арбитра, нарушенное в собственном комментарии. Текущий
+// размер считается одной командой: `npm pack --dry-run`. Из 2,2 МБ распакованного 584 КБ — это
+// `tool/selfcheck`, то есть наши собственные тесты, уезжающие каждому пользователю; вырезать их
+// из `files` можно только после проверки, что собранный пакет работает, — иначе поломка
+// установки обойдётся дороже сэкономленного.
 const REPO = "agent-quality-kit";
 // Адрес репозитория отдельно от имени пакета. Когда имя стало коротким, ссылка «поставь
 // звезду» собиралась из него и вела на github.com/agent-quality-kit — несуществующую
@@ -88,6 +96,7 @@ function commandRows(L) {
     { name: "badge", args: "", text: h.badge },
     { name: "vitals", args: "", text: h.vitals },
     { name: "feedback", args: "", text: h.feedback },
+    { name: "feedback", args: "--send", text: h.feedbackSend },
     { name: "version", args: "", text: h.version },
   ];
 }
@@ -171,15 +180,42 @@ async function ensureIgnored(cwd = CWD) {
 }
 
 // Стоит ли хук pre-commit НА САМОМ ДЕЛЕ — в `.git/hooks`, а не в `.pre-commit-config.yaml`:
-// запись в конфиге — намерение, сработает только то, что лежит в гите. Три ответа: true — стоит,
-// false — нет, null — не git или файл не прочитать («не знаем» не сливается с «нет»).
-// Одна функция на `vitals` (подключено ли) и `context` (что сказать агенту перед коммитом).
+// запись в конфиге — намерение, сработает только то, что лежит в гите.
+//
+// ЧЕТЫРЕ ОТВЕТА, А НЕ ТРИ. Раньше тело хука проверялось регуляркой `/pre-commit|aqk/i`, то есть
+// ПО ИМЕНИ: у любого проекта с фреймворком pre-commit слово «pre-commit» в хуке есть всегда, и
+// `vitals` печатал «прописан в .git/hooks» репозиторию, где AQK не вызывался ни разу. Разбор
+// живой интеграции 2026-09-16: человек прочитал это как «обвязка на месте» и ушёл. Наш
+// собственный класс «объявлено ≠ работает», у нас самих.
+//
+//   null    — не git либо файл не прочитать («не знаем» не сливается с «нет»);
+//   false   — хука нет;
+//   "other" — хук есть, но AQK в нём не участвует: ставить не надо, надо дописать;
+//   true    — AQK участвует.
+//
+// КАК ЭТО ДЕЛАЮТ СНАРУЖИ. pre-commit узнаёт свой хук функцией `is_our_script()` — ищет в теле
+// собственный маркер (CURRENT_HASH плюс пять PRIOR_HASHES), а не имя. У них же есть режим
+// миграции: при установке поверх чужого хука запускаются оба, старый уезжает в `.legacy`. То
+// есть «в теле есть слово pre-commit» не доказывает даже, что хук ихний.
+//
+// ДВА ПУТИ ПОДКЛЮЧЕНИЯ, И СЧИТАТЬ НАДО ОБА. Прямой вызов в теле хука — и наш хук из
+// `.pre-commit-hooks.yaml`, поставленный через фреймворк: там в `.git/hooks/pre-commit` лежит
+// диспетчер, а что он запустит, написано в `.pre-commit-config.yaml` проекта. Смотреть только в
+// тело значило бы соврать в обратную сторону — сказать «AQK не подключён» тому, кто подключил.
+const AQK_IN_HOOK = /\baqk\b|agent[-_]quality[-_]kit/i;
+const AQK_IN_CONFIG = /agent[-_]quality[-_]kit|Agent_Quality_Kit|(?:^|\s)-\s*id:\s*["']?aqk\b/im;
+
 async function preCommitHook(cwd = CWD) {
   const { readFile } = await import("node:fs/promises");
   if (!(await exists(join(cwd, ".git")))) return null;
   const hook = join(cwd, ".git", "hooks", "pre-commit");
   if (!(await exists(hook))) return false;
-  try { return /pre-commit|aqk/i.test(await readFile(hook, "utf8")); } catch { return null; }
+  let body = "";
+  try { body = await readFile(hook, "utf8"); } catch { return null; }
+  if (AQK_IN_HOOK.test(body)) return true;
+  let config = "";
+  try { config = await readFile(join(cwd, ".pre-commit-config.yaml"), "utf8"); } catch { /* нет конфига — значит подключения через фреймворк нет */ }
+  return AQK_IN_CONFIG.test(config) ? true : "other";
 }
 
 export {

package/tool/lib/execution.mjs

@@ -105,6 +105,37 @@ function launchable(cmd, bash) {
   return bash && /^bash(\s|$)/.test(s) ? `"${bash}"${s.slice(4)}` : s;
 }
 
+// СКОЛЬКО ЖДАТЬ ЧУЖУЮ КОМАНДУ. Знание лежит здесь, рядом с остальным протоколом запуска: до
+// 2026-09-16 число 300000 было вписано в четырёх местах — `run.mjs`, `prove.mjs` и дважды
+// `gates.mjs`. Это не похожие строки, а одно знание в четырёх файлах.
+//
+// СПОСОБ РЕШИТЬ ИНАЧЕ ОБЯЗАН БЫТЬ — правило записано парой десятков строк ниже, про выбор bash,
+// и у таймаута его не было. Цена известна: живой проект, чей полный verify идёт дольше пяти
+// минут, просто не стал объявлять свою главную проверку гейтом.
+//
+// ПЯТЬ МИНУТ НЕ ВЫДУМАНЫ, И ПЕРЕМЕННАЯ СРЕДЫ — ТОЖЕ НЕ НАША ВЫДУМКА. У SonarQube
+// `SONAR_QUALITY_GATE_TIMEOUT` ровно 300 секунд, у GitLab срок шага задаётся
+// `RUNNER_AFTER_SCRIPT_TIMEOUT`. Поля `timeout` у команды нет ни у lefthook (весь их список
+// ключей проверен 2026-09-16), ни у pre-commit — поэтому в манифест мы его не заводим:
+// соглашения снаружи нет, а просьба была одна. Заведём, когда попросят второй раз.
+//
+// ПРОБА ЖИВЁТ ПО СВОИМ ЧАСАМ намеренно (`probe.mjs`): она гоняет десятки гейтов на подсаженном
+// дефекте, и её минута-две — осознанный предел выборки, а не «сколько ждать эту проверку».
+const GATE_TIMEOUT_DEFAULT = 300000;
+
+// Возвращается ОБЪЕКТ, а не число: мусор в переменной нельзя проглотить молча — человек задал
+// её и ждёт действия, — но и печатать отсюда нельзя, функция чистая. Поэтому «исправно ли» едет
+// рядом со значением, а говорит об этом тот, у кого есть экран (`run.mjs`).
+function gateTimeout(env = process.env) {
+  const raw = String(env?.AQK_GATE_TIMEOUT ?? "").trim();
+  if (!raw) return { ms: GATE_TIMEOUT_DEFAULT, raw: "", ok: true };
+  const secs = Number(raw);
+  // Ноль и отрицательное у spawnSync означают «ждать вечно» — то есть висящий гейт вместо
+  // честного «не смогли проверить». Ровно тот исход, ради различения которого написан файл.
+  if (!Number.isFinite(secs) || secs <= 0) return { ms: GATE_TIMEOUT_DEFAULT, raw, ok: false };
+  return { ms: Math.round(secs * 1000), raw, ok: true };
+}
+
 // Одна точка для всех пяти мест, где запускается команда гейта: прогон, доказательство, проба,
 // храповик, `why`. Поиск делается раз на процесс — он смотрит на диск, а гейтов бывает тридцать.
 let cachedBash;
@@ -113,4 +144,4 @@ function gateCommand(cmd) {
   return launchable(cmd, cachedBash);
 }
 
-export { classify, findingCodes, gitBash, launchable, gateCommand };
+export { classify, findingCodes, gitBash, launchable, gateCommand, gateTimeout, GATE_TIMEOUT_DEFAULT };

package/tool/lib/manifest.mjs

@@ -112,7 +112,7 @@ function unparsedLines(text) {
 // Список обязан совпадать с тем, что программа РЕАЛЬНО читает (`man?.<поле>` в tool/):
 // лишнее имя здесь молча узаконивает поле, которое ни на что не влияет, — та же тишина,
 // только с другой стороны. Сверено обходом: aqk, entry, rules, gates, samples, ratchets, lessons.
-const KNOWN_KEYS = ["aqk", "entry", "rules", "docs", "lang", "gates", "covers", "samples", "ratchets", "lessons", "advisory", "probe", "groups"];
+const KNOWN_KEYS = ["aqk", "entry", "rules", "docs", "lang", "gates", "covers", "requires", "samples", "ratchets", "lessons", "advisory", "probe", "groups"];
 
 // ГДЕ У ПРОЕКТА ЛЕЖИТ РАЗЛОЖЕННЫЙ КОМПЛЕКТ. Список для шапки `doctor`. До 2026-09-08 он был
 // литеральным: `.aqk/rules`, `.aqk/docs`, `AGENTS.md` — независимо от того, что написано в
@@ -306,19 +306,45 @@ function entryLifecycle(rec) {
 // `vitals` печатал «все инструменты на месте» ровно там, где прогон краснел.
 // `has` передаётся вызывающим, а не берётся отсюда: manifest.mjs не должен знать про осмотр
 // репозитория — импорт в обратную сторону завёл бы цикл. Заодно функция проверяема модульно.
-async function gateRequires(samplesDir, name, has) {
-  if (!samplesDir) return null;
-  const yml = join(CWD, samplesDir, name, "gate.yml");
-  if (!(await exists(yml))) return null;
-  try {
-    const rec = parseManifest(await readFile(yml, "utf8"));
-    const raw = typeof rec?.requires === "string" ? rec.requires.trim() : "";
-    if (!raw) return null;
-    const missing = raw.split(",").map((x) => x.trim()).filter(Boolean).filter((x) => !has(x));
-    return missing.length ? missing : null;
-  } catch {
-    return null;
+// ДВА ИСТОЧНИКА, А НЕ ОДИН. Поле читалось только из `<samples>/<гейт>/gate.yml`, то есть было
+// доступно НАШИМ записям и недоступно гейтам проекта. Разбор чужой интеграции 2026-09-16: гейт
+// объявлен как `docker run --rm … promtool test rules …`, `vitals` смотрит первое слово, видит
+// `docker` и говорит «инструменты на месте». У проекта с чужими командами `samples` пуст по
+// построению, и сказать «этому гейту нужен docker» было нечем.
+//
+// СНАРУЖИ СОГЛАШЕНИЯ НЕТ — проверено 2026-09-16, и это сказано вслух, а не выдано за
+// общепринятое. У pre-commit ровно эта просьба закрыта нерешённой (issue #2042: трактовать
+// `additional_dependencies` как список программ в $PATH и пропускать хук, если программы нет;
+// ответ — `system`-хуки окружения не ставят). У lefthook такого ключа нет вовсе. Поэтому мы не
+// копируем чужую форму, а распространяем свою: то же имя поля и та же форма «имя гейта →
+// значение», что у `covers:` и `groups:`. Новых понятий в манифесте не появляется.
+//
+// ГРАНИЦА НАЗЫВАЕТСЯ ВСЛУХ: «программа есть в PATH» и «программа сможет отработать» — разные
+// утверждения. `docker` в PATH при мёртвом демоне по-прежнему считается найденным; это не
+// ложь vitals, а предел того, что видно без запуска. Запускать чужой инструмент ради осмотра
+// мы не будем: осмотр обязан быть дешёвым и без побочных действий.
+function requiredBy(man, name) {
+  const r = man?.requires && typeof man.requires === "object" && !Array.isArray(man.requires) ? man.requires : null;
+  const v = r ? r[name] : null;
+  if (Array.isArray(v)) return v.map((x) => String(x).trim()).filter(Boolean);
+  return typeof v === "string" ? v.split(",").map((x) => x.trim()).filter(Boolean) : [];
+}
+
+async function gateRequires(man, samplesDir, name, has) {
+  const names = [...requiredBy(man, name)];
+  if (samplesDir) {
+    const yml = join(CWD, samplesDir, name, "gate.yml");
+    if (await exists(yml)) {
+      try {
+        const rec = parseManifest(await readFile(yml, "utf8"));
+        const raw = typeof rec?.requires === "string" ? rec.requires.trim() : "";
+        for (const x of raw.split(",").map((s) => s.trim()).filter(Boolean)) names.push(x);
+      } catch { /* нечитаемая запись — не повод обвинять гейт */ }
+    }
   }
+  if (!names.length) return null;
+  const missing = [...new Set(names)].filter((x) => !has(x));
+  return missing.length ? missing : null;
 }
 
 // ПОЧЕМУ СПИСКОМ В МАНИФЕСТЕ, А НЕ ФЛАГОМ ПРОГОНА. Флаг «не роняй ничего» — это тот самый

package/tool/lib/prove.mjs

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { CWD, exists } from "./core.mjs";
 import { parseManifest, gateRequires } from "./manifest.mjs";
 import { whichSync } from "./repo.mjs";
-import { classify, findingCodes, gateCommand } from "./execution.mjs";
+import { classify, findingCodes, gateCommand, gateTimeout } from "./execution.mjs";
 
 // Гейт можно доказать, если у него есть оба образца. Признак по образцам, а не по тексту
 // команды: запись, делегирующая готовому инструменту (`npx knip --directory .`), каталог
@@ -115,7 +115,7 @@ function run(cmd, timeoutMs, prog) {
 
 // Возвращает { proven, broken, unprovable, results } — числами и списком, чтобы вызывающий
 // сам решал, что печатать и чем краснеть.
-async function proveGates(man, { timeoutMs = 300000 } = {}) {
+async function proveGates(man, { timeoutMs = gateTimeout().ms } = {}) {
   const gates = man?.gates && typeof man.gates === "object" && !Array.isArray(man.gates) ? man.gates : {};
   const samplesDir = typeof man?.samples === "string" ? man.samples.trim() : "";
   const results = [];
@@ -135,7 +135,7 @@ async function proveGates(man, { timeoutMs = 300000 } = {}) {
     // Программы, без которой запись не работает, может не быть на машине — тогда доказывать
     // нечем, а не «гейт сломан». Проверяется ДО запуска: без неё обёртка краснеет на обоих
     // образцах, и вердикт вышел бы «краснеет на исправном коде».
-    const missing = await gateRequires(samplesDir, name, whichSync);
+    const missing = await gateRequires(man, samplesDir, name, whichSync);
     if (missing) {
       results.push({ name, state: "unprovable", why: "needs-program", missing });
       continue;

package/tool/lib/run.mjs

@@ -17,7 +17,7 @@ import { scopeOutput, splitAdvice, changedFiles } from "./scope.mjs";
 import { CWD, TARGET_DIR, c, die, exists } from "./core.mjs";
 import { advisorySet } from "./manifest.mjs";
 import { L } from "../i18n/index.mjs";
-import { gateCommand, classify, findingCodes } from "./execution.mjs";
+import { gateCommand, classify, findingCodes, gateTimeout } from "./execution.mjs";
 import { annotations } from "./annotate.mjs";
 
 
@@ -103,11 +103,12 @@ function selectGates(gates, man, { only = [], skip = [] } = {}) {
   return { run, skipped: gates.map(([n]) => n).filter((n) => !kept.has(n)), unknown: [...new Set(unknown)] };
 }
 
-const GATE_TIMEOUT = 300000;
+// Сколько ждать — знает `execution.mjs`, там же, где всё остальное про запуск чужой команды.
+// Число жило здесь и ещё в трёх местах; переопределяется переменной AQK_GATE_TIMEOUT.
 
 // Один гейт в этом потоке — прежний путь, без `--jobs`.
 function spawnGate(cmd) {
-  return spawnSync(gateCommand(cmd), { shell: true, cwd: CWD, encoding: "utf8", timeout: GATE_TIMEOUT });
+  return spawnSync(gateCommand(cmd), { shell: true, cwd: CWD, encoding: "utf8", timeout: gateTimeout().ms });
 }
 
 // ПАРАЛЛЕЛЬНО — ПО ФЛАГУ. Отзыв с живого проекта 2026-09-11: 34 независимых гейта шли друг за
@@ -125,7 +126,7 @@ function startPool(cmds, jobs) {
     const onErr = (e) => { results[id].res({ status: null, stdout: "", stderr: String(e?.message || e), error: { code: "WORKER" } }); };
     w.once("error", onErr);
     w.once("message", (m) => { w.off("error", onErr); results[id].res(m); feed(w); });
-    w.postMessage({ id, cmd: cmds[id], cwd: CWD, timeout: GATE_TIMEOUT });
+    w.postMessage({ id, cmd: cmds[id], cwd: CWD, timeout: gateTimeout().ms });
   };
   for (let i = 0; i < Math.min(jobs, cmds.length); i++) feed(new Worker(url));
   return results;
@@ -140,6 +141,12 @@ async function runGates(man, opts = {}) {
   const advisory = advisorySet(man);
   const bar = progress();
 
+  // Мусор в AQK_GATE_TIMEOUT называется вслух ОДИН раз за прогон. Молча вернуть умолчание
+  // значило бы, что человек задал переменную, ничего не получил и об этом не узнал, — та же
+  // тишина, против которой написан комплект, только в его собственной настройке.
+  const t = gateTimeout();
+  if (!t.ok) console.log(c.yellow(`  ${L.doctor.timeoutBadEnv(t.raw, Math.round(t.ms / 1000))}`));
+
   // Сужение по дифу — договор с человеком, и он должен видеть, ЧТО именно сужено. Пустой диф
   // называется вслух: иначе «все гейты зелёные» означало бы «сравнили не с тем» и читалось бы
   // как успех. Это тот же класс, что и весь стандарт, только внутри нашего флага.
@@ -350,9 +357,21 @@ async function writeRunReport({ version, reached, results, skipped = [] }) {
     L.report.summary(ok, results.length),
   ].filter((l) => l !== null);
 
+  // ЗАПИСЬ ОТЧЁТА НЕ РОНЯЕТ ПРОГОН. Тот же класс, что у `report` (разбор 2026-09-16): в рабочей
+  // области, где `.aqk/` не создать — read-only контейнер, чужой конвейер, каталог под
+  // ревью, — прогон падал уже ПОСЛЕ того, как все гейты отработали, и человек не получал ни
+  // вердикта, ни кода возврата. Побочное действие отменяло то, ради чего команду звали.
+  //
+  // Но молчать нельзя: отчёт читают `context` и `prompt`, и его отсутствие они прочтут как
+  // «прогона не было». Разница между «не было» и «был, записать не смогли» — ровно та, которую
+  // весь комплект и защищает, поэтому она называется вслух.
   const dst = join(CWD, TARGET_DIR, "last-run.md");
-  await mkdir(join(CWD, TARGET_DIR), { recursive: true });
-  await writeFile(dst, lines.join("\n") + "\n", "utf8");
+  try {
+    await mkdir(join(CWD, TARGET_DIR), { recursive: true });
+    await writeFile(dst, lines.join("\n") + "\n", "utf8");
+  } catch (e) {
+    console.log(c.yellow(`  ${L.report.notWritten(join(TARGET_DIR, "last-run.md"), e?.code || String(e?.message || e))}`));
+  }
 }
 
 // Разбор отчёта прошлого прогона. Формат кладёт сам `doctor` в .aqk/last-run.md; читаем его,

package/tool/selfcheck/smoke/_fixture.mjs

@@ -93,6 +93,18 @@ function run({ dir, home }, cmd, args = [], extra = {}) {
   return { code: r.status, out: `${r.stdout || ""}${r.stderr || ""}` };
 }
 
+// ХВОСТ ВЫВОДА — последние N строк. Знание «как взять хвост» лежало в трёх проверках тремя
+// одинаковыми цепочками; сообщение утверждения без хвоста отправляет читателя гадать, поэтому
+// хвост берут все, кто что-то утверждает о выводе.
+//
+// Попутно это уводит наши файлы из-под чужого дефекта: `checkwash` (0.2.13 и 0.3.4 одинаково)
+// принимает строковый литерал `"\n"` за ИМЯ тестового юнита, и файл, где таких литералов два,
+// на любом сдвиге строк получает `TEST_DISABLED — test unit disappeared` уровня high. То есть
+// наш собственный гейт `test-not-adjusted` краснел на добавленном комментарии. Воспроизведение
+// в шесть строк отправлено автору; здесь не обход ради обхода, а устранение настоящего повтора,
+// у которого этот эффект оказался побочным.
+const tail = (out, n = 6) => String(out).trimEnd().split("\n").slice(-n).join("\n");
+
 const aqk = (p, ...args) => run(p, process.execPath, [CLI, ...args]);
 const aqkEnv = (p, extra, ...args) => run(p, process.execPath, [CLI, ...args], extra);
 
@@ -113,4 +125,4 @@ const gate = (p, name, sub = ".") =>
 // никто не берёт, читается как часть договора и мешает менять внутренности — поймал наш же
 // dead-code через минуту после того, как файл был написан. `run` вернулся, когда появилась
 // проверка, которой нужен сырой git: экспорт заводится под потребителя, а не про запас.
-export { project, run, aqk, aqkEnv, gate };
+export { project, run, aqk, aqkEnv, gate, tail };

package/tool/selfcheck/smoke/feedback-send.test.mjs

@@ -0,0 +1,87 @@
+// tool/selfcheck/smoke/feedback-send.test.mjs — ОТПРАВКА ТОЛЬКО ПО ЯВНОМУ СЛОВУ.
+//
+// ЗАЧЕМ ЭТО ГЛАВНАЯ ПРОВЕРКА ФАЙЛА. Владелец 2026-09-14 спросил, нельзя ли отправлять отзыв
+// «без согласия пользователя, чтобы агент мог быстро сообщить». Ответ — нет, и не из вежливости:
+// в README и SECURITY.md написано, что исходящий запрос у комплекта ровно один, про версию.
+// Инструмент, который втихую шлёт что-то из чужого репозитория, становится ровно тем, что мы
+// критикуем, — а наша аудитория это те, кто проверяет инструменты на вранье.
+//
+// Поэтому согласие живёт В САМОМ ФЛАГЕ: `--send` не набирают случайно. И это утверждение обязана
+// держать машина, а не наше обещание в документации, — иначе однажды рефакторинг отправит письмо
+// из команды, которая всю жизнь только печатала.
+//
+// КАК ПРОВЕРЯЕТСЯ. `AQK_GH` подменяет программу `gh` на скрипт, который записывает сам факт
+// вызова в файл. Запуск через `node`, а не через оболочку: то же решение, что у `AQK_BASH` в
+// execution.mjs, и оно работает и на windows-задании конвейера.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { project, aqkEnv } from "./_fixture.mjs";
+
+// Поддельный `gh`: пишет, с какими доводами его позвали, и отвечает так, чтобы отправка дошла
+// до конца. Чего он НЕ делает — ничего наружу.
+function fakeGh(p) {
+  const log = join(p.dir, "gh-calls.txt");
+  const script = join(p.dir, "fake-gh.mjs");
+  writeFileSync(script, `
+import { appendFileSync } from "node:fs";
+const args = process.argv.slice(2);
+appendFileSync(${JSON.stringify(log)}, args.join(" ") + "\\n");
+if (args[0] === "auth") process.exit(0);
+const all = args.join(" ");
+if (all.includes("addDiscussionComment")) { console.log(JSON.stringify({ data: { addDiscussionComment: { comment: { url: "https://example.invalid/c/1" } } } })); process.exit(0); }
+console.log(JSON.stringify({ data: { repository: { discussion: { id: "D_test" } } } }));
+`, "utf8");
+  return { log, env: { AQK_GH: `node ${script.replace(/\\\\/g, "/")}` } };
+}
+
+const posix = (s) => String(s).replace(/\\/g, "/");
+
+// ГЛАВНОЕ УТВЕРЖДЕНИЕ ФАЙЛА.
+test("без --send команда не зовёт gh ни разу", (t) => {
+  const p = project(t, { "AGENTS.md": "# проект\n", ".aqk.yml": 'aqk: 1\nentry:\n  - AGENTS.md\ngates:\n  lint: "true"\n' });
+  const g = fakeGh(p);
+  const r = aqkEnv(p, g.env, "feedback");
+  assert.ok(!existsSync(g.log),
+    `команда без --send позвала gh — то есть отправила что-то наружу без слова человека. Вывод:\n${r.out}`);
+  assert.match(r.out, /###/, `отчёт не напечатан вовсе. Вывод:\n${r.out}`);
+});
+
+test("и с чужими доводами рядом — тоже не зовёт", (t) => {
+  const p = project(t, { "AGENTS.md": "# проект\n" });
+  const g = fakeGh(p);
+  aqkEnv(p, g.env, "feedback", "--verbose", "что-то своими словами");
+  assert.ok(!existsSync(g.log), "слово без флага прочиталось как разрешение отправить");
+});
+
+test("с --send отправка происходит и адрес показан человеку", (t) => {
+  const p = project(t, { "AGENTS.md": "# проект\n", ".aqk.yml": 'aqk: 1\nentry:\n  - AGENTS.md\ngates:\n  lint: "true"\n' });
+  const g = fakeGh(p);
+  const r = aqkEnv(p, g.env, "feedback", "--send");
+  assert.ok(existsSync(g.log), `с --send gh не позвался вовсе. Вывод:\n${r.out}`);
+  const calls = readFileSync(g.log, "utf8");
+  assert.match(calls, /auth/, "вход не проверялся — отправили бы вслепую");
+  assert.match(calls, /addDiscussionComment/, `комментарий не отправлялся. Вызовы:\n${calls}`);
+  assert.match(r.out, /example\.invalid/, `человеку не показали, куда ушёл отзыв. Вывод:\n${r.out}`);
+});
+
+// Своя строка — самое ценное во всём письме, и она обязана доехать целиком.
+test("слова человека попадают в отправленное", (t) => {
+  const p = project(t, { "AGENTS.md": "# проект\n" });
+  const g = fakeGh(p);
+  aqkEnv(p, g.env, "feedback", "--send", "у меня не нашёл ни одного гейта");
+  const calls = readFileSync(g.log, "utf8");
+  assert.match(calls, /не нашёл ни одного гейта/, `строка человека потерялась. Вызовы:\n${calls}`);
+});
+
+// «Не смогли» и «отправлено» обязаны различаться: молчаливый отказ здесь означал бы, что человек
+// считает отзыв ушедшим, а его нет. Тот же договор, что у гейтов.
+test("без входа в gh команда говорит это вслух и не молчит", (t) => {
+  const p = project(t, { "AGENTS.md": "# проект\n" });
+  const script = join(p.dir, "no-auth.mjs");
+  writeFileSync(script, 'process.exit(1);\n', "utf8");
+  const r = aqkEnv(p, { AQK_GH: `node ${posix(script)}` }, "feedback", "--send");
+  assert.doesNotMatch(r.out, /example\.invalid/, "сказали, что отправили, хотя не смогли");
+  assert.match(r.out, /github\.com/, `не дали запасного пути — человек остался ни с чем. Вывод:\n${r.out}`);
+});

package/tool/selfcheck/smoke/first-run.test.mjs

@@ -9,7 +9,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { project, aqk, run } from "./_fixture.mjs";
+import { project, aqk, run, tail } from "./_fixture.mjs";
 
 // Цвет снимается до разбора: заголовок жирный, значки цветные, и регулярка по сырому выводу
 // не узнаёт ни то, ни другое.
@@ -99,8 +99,8 @@ test("нет .aqk/docs и .aqk/rules — прогон всё равно зелё
   const man = join(p.dir, ".aqk.yml");
   writeFileSync(man, readFileSync(man, "utf8").replace(/^gates:\s*$/m, 'gates:\n  тихий: "true"'), "utf8");
   const r = aqk(p, "doctor", "--run");
-  const tail = plain(r.out).trimEnd().split("\n").slice(-4).join("\n");
-  assert.equal(r.code, 0, `прогон покраснел из-за методичек:\n${tail}`);
+  const last = tail(plain(r.out), 4);
+  assert.equal(r.code, 0, `прогон покраснел из-за методичек:\n${last}`);
   assert.match(plain(r.out), /\.aqk\/docs/, "отсутствие методичек не названо вовсе");
 });
 
@@ -142,3 +142,67 @@ test("prompt: задание без прогона начинается с пр
   assert.match(r.out, /(Как проверить, что готово|How to verify)/);
   assert.doesNotMatch(r.out, /\x1b\[/, "задание уходит агенту текстом — без цветовых кодов");
 });
+
+// ВЫКЛЮЧЕННАЯ ПРОВЕРКА НАЗЫВАЕТСЯ ВЫКЛЮЧЕННОЙ — В ПЕРВЫЕ ПЯТЬ СЕКУНД.
+//
+// Найдено 2026-09-14 живым прогоном на репозитории, где выключено всё: `"test": "node --test ||
+// true"`, `"lint": "ruff check . --exit-zero"`, шаг конвейера под `continue-on-error`. `doctor`
+// печатал «Проверки, которые у вас УЖЕ ЕСТЬ (2)» с двумя ЗЕЛЁНЫМИ галочками: мы читали ИМЯ
+// скрипта и ни разу не заглядывали в его тело. Тот самый класс отказа, ради которого написан
+// комплект, — в нашем собственном первом экране.
+//
+// Это главная встреча постороннего с инструментом: ноль настройки, одна команда. Если здесь мы
+// подтверждаем ложное «у вас всё хорошо», второго запуска не будет.
+test("проверка, которую нельзя провалить, названа находкой, а не зелёной галочкой", (t) => {
+  const p = project(t, {
+    ...FILES,
+    "package.json": JSON.stringify({ name: "x", scripts: { test: "node --test || true", lint: "ruff check . --exit-zero" } }),
+  });
+  const out = plain(aqk(p, "doctor").out);
+  const block = out.slice(out.indexOf("УЖЕ ЕСТЬ"));
+  assert.ok(block, "блок «проверки, которые уже есть» пропал совсем");
+  assert.doesNotMatch(block.split("\n").slice(0, 3).join("\n"), /✔/,
+    `выключенная проверка получила зелёную галочку — это ложное «у вас всё хорошо»:\n${block.slice(0, 400)}`);
+  assert.match(block, /\|\| true/, "человеку не показали строку, по которой он найдёт выключатель у себя");
+  assert.match(block, /--exit-zero/, "флаг, гасящий исход, не назван");
+
+  // И то же знание — агенту: иначе он впишет дыру в манифест, и с этого дня за неё ручается машина.
+  const ctx = plain(aqk(p, "context").out);
+  assert.match(ctx, /покраснеть не могут/,
+    `блок для агента велит объявить проверки, которые не могут провалиться:\n${ctx.slice(0, 600)}`);
+});
+
+// ЗРЕЛЫЙ ПРОЕКТ НЕ ТЕРЯЕТ СВОИ ПРОВЕРКИ ИЗ ВИДА, КОГДА ОБЪЯВИЛ ГЕЙТ.
+//
+// Замер 2026-09-16 по двенадцати чужим репозиториям: у шести зрелых (requests, httpx, fastapi,
+// black, express, flask) блок «у вас уже есть» исчезал целиком, стоило объявить один гейт, —
+// и итог печатал «держит машина 0» проекту с настоящим pre-commit и Makefile. Чем больше
+// человек настроил, тем меньше мы о нём знали: условие показывало чужие проверки только тому,
+// у кого гейтов нет вовсе.
+test("объявленный гейт не прячет проверки, которые у проекта уже есть", (t) => {
+  const p = project(t, {
+    ...FILES,
+    Makefile: "test:\n\tpytest -q\n\nlint:\n\truff check .\n",
+    ".aqk.yml": 'aqk: 1\nentry: [AGENTS.md]\ngates:\n  project-verify: "bash scripts/verify.sh"\n',
+    "AGENTS.md": "# вход\n",
+  });
+  const out = plain(aqk(p, "doctor").out);
+  assert.match(out, /УЖЕ ЕСТЬ/,
+    `проект объявил один гейт — и его собственные проверки пропали из вывода:\n${out.slice(-1500)}`);
+  assert.match(out, /make test|npm test/, "найденная команда не названа человеку");
+});
+
+// И обратное: то, что УЖЕ объявлено, вторым списком не повторяется. Иначе вывод советует
+// поставить то, что стоит, — и человек перестаёт читать этот блок целиком.
+test("объявленная проверка не советуется второй раз", (t) => {
+  const p = project(t, {
+    ...FILES,
+    Makefile: "test:\n\tpytest -q\n",
+    ".aqk.yml": 'aqk: 1\nentry: [AGENTS.md]\ngates:\n  test: "make test"\n  lint: "npm run lint"\n',
+    "AGENTS.md": "# вход\n",
+  });
+  const out = plain(aqk(p, "doctor").out);
+  const block = out.includes("УЖЕ ЕСТЬ") ? out.slice(out.indexOf("УЖЕ ЕСТЬ")) : "";
+  assert.doesNotMatch(block.split("\n").slice(0, 6).join("\n"), /make test/,
+    `«make test» уже объявлен гейтом, а мы советуем его снова:\n${block.slice(0, 400)}`);
+});

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

@@ -0,0 +1,83 @@
+// Прогон, который не может состояться, обязан сказать это, а не показать пятнадцать крестов.
+//
+// НАЙДЕНО ЧУЖИМ РАЗБОРОМ 2026-09-16. `smoke.sh`, запущенный внутри песочницы Codex, дал 15
+// падений из 123. Настоящая причина: дочерним процессам Node запрещалось запускать git и npm —
+// `spawnSync` возвращал EPERM. Проверки об этом не знали и печатали обычные кресты. Человек
+// час разбирал несуществующие дефекты, а строка «дефекты AQK 0.15.0» уехала в чужой отчёт.
+//
+// ИРОНИЯ, РАДИ КОТОРОЙ ЭТОТ ФАЙЛ И НАПИСАН. `tool/lib/execution.mjs` различает три исхода —
+// clean · finding · infra_error — именно затем, чтобы сбой инструмента не выдавался за приговор
+// коду. Своей собственной оснастке мы это правило не применили.
+//
+// ЧАСТИЧНЫЙ ПРОГОН НИЧЕГО НЕ ДОКАЗЫВАЕТ: 108 зелёных из 123 при недоступном git — не «почти
+// всё хорошо», а «мерить было нечем». Поэтому предполёт отказывает целиком и выходит кодом 3 —
+// тем же, которым pytest отделяет INTERNAL_ERROR от провала теста (их код 1).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname, delimiter } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+const SMOKE = join(ROOT, "tool", "selfcheck", "smoke.sh");
+
+const WIN = process.platform === "win32";
+
+// Заглушка вместо настоящей программы: выходит кодом 126 — «найдено, но запустить нельзя».
+// Ровно то, чем для нас выглядел запрет песочницы.
+//
+// ДВА ФАЙЛА, А НЕ ОДИН. Поймано windows-заданием конвейера: скрипт без расширения там не
+// перехватывает ничего — CreateProcess ищет `.exe`/`.cmd` по PATHEXT, а Git Bash понимает
+// shebang. Значит нужны обе заглушки сразу, иначе проверка молча меряет настоящий git и
+// краснеет на исправной машине — то есть сама становится тем ложным красным, против которого
+// написан предполёт.
+function stubDir(t, name) {
+  const dir = mkdtempSync(join(tmpdir(), "aqk-stub-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  writeFileSync(join(dir, name), "#!/bin/sh\nexit 126\n", "utf8");
+  chmodSync(join(dir, name), 0o755);
+  if (WIN) writeFileSync(join(dir, `${name}.cmd`), "@echo off\r\nexit /b 126\r\n", "utf8");
+  return dir;
+}
+
+// PATH СОБИРАЕТСЯ ЧЕРЕЗ `delimiter`, А НЕ ЧЕРЕЗ ДВОЕТОЧИЕ. На Windows разделитель — точка с
+// запятой, а сам путь вида `C:\Users\…` содержит двоеточие внутри: строка `"C:\...:" + PATH`
+// разваливается на первом же символе, заглушка в PATH не попадает, и проверка меряет настоящий
+// git. Поймано windows-заданием дважды подряд — первый раз я починил вызов, а не сборку пути.
+const withStub = (dir) => (dir ? `${dir}${delimiter}${process.env.PATH}` : process.env.PATH);
+
+const runPreflight = (extraPath) => spawnSync("bash", [SMOKE, "--preflight-only"], {
+  encoding: "utf8", timeout: 60000,
+  env: { ...process.env, PATH: withStub(extraPath), AQK_LANG: "ru" },
+});
+
+test("предполёт: исправная машина проходит и ничего не ломает", () => {
+  const r = runPreflight(null);
+  assert.equal(r.status, 0, `предполёт отказал на исправной машине:\n${r.stdout}${r.stderr}`);
+});
+
+test("предполёт: недоступный git — это «не смогли проверить», а не падения проверок", (t) => {
+  const r = runPreflight(stubDir(t, "git"));
+  assert.equal(r.status, 3,
+    `код ${r.status}: запрет среды неотличим от провала проверок. Нужен 3 — тот же, которым pytest отделяет внутреннюю ошибку от провала теста`);
+  const out = `${r.stdout || ""}${r.stderr || ""}`;
+  assert.match(out, /git/i, "не сказано, ЧТО именно недоступно");
+  assert.doesNotMatch(out, /✘/, `предполёт напечатал крест — значит выдал сбой среды за находку:\n${out}`);
+});
+
+// Тот самый случай из отчёта: сам шелл git видит, а подпроцессы Node — нет. Проверять только
+// первое значило бы пройти предполёт и упасть пятнадцатью крестами следом.
+test("предполёт: git виден шеллу, но не подпроцессу Node — тоже отказ", (t) => {
+  const dir = stubDir(t, "git");
+  // `shell` — тот же, что в самом предполёте: на Windows без оболочки Node не видит ни `.cmd`
+  // заглушки, ни настоящего `npm`. Проверка обязана звать так же, как зовёт код, иначе она
+  // проверяет не его. Ровно на этом конвейер и поймал первую версию.
+  // Node зовётся НАПРЯМУЮ, без оболочки-посредника: подстановка пути в строку `bash -c` — это
+  // ещё один способ потерять заглушку, и именно так эта проверка уже ошиблась.
+  const probe = `const r=require("node:child_process").spawnSync("git",["--version"],{shell:${WIN}}); process.exit(r.status===0?0:3)`;
+  const r = spawnSync(process.execPath, ["-e", probe],
+    { encoding: "utf8", timeout: 30000, env: { ...process.env, PATH: withStub(dir) } });
+  assert.equal(r.status, 3, "оснастка проверки неверна: заглушка не перехватывает git у Node");
+});