agent-quality-kit 0.14.0 → 0.15.0

package/tool/selfcheck/smoke/fail-closed.test.mjs

@@ -20,7 +20,7 @@ import assert from "node:assert/strict";
 import { cpSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { project, run, aqk } from "./_fixture.mjs";
+import { project, run, aqk, aqkEnv } from "./_fixture.mjs";
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 const posix = (p) => String(p).replace(/\\/g, "/");
@@ -110,3 +110,98 @@ test("doctor называет человеку, сколько правил не
   assert.ok(/человек/i.test(r.out),
     `doctor не сказал про сторожа-человека ни слова, хотя таких правил здесь два.\n${r.out}`);
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// СБОЙ САМОЙ ПРОВЕРКИ НЕ СУЖАЕТСЯ ДИФОМ. Написано ДО кода 2026-09-14.
+//
+// ЗАЧЕМ. Внешний разбор (аудит Runcap, 2026-09-13) искал у нас тот же класс отказа, что нашёл
+// у соседа, и нашёл: `--since` фильтрует вывод ПО ПУТЯМ, и гейт, который НЕ СМОГ отработать,
+// печатался зелёным, если названный им путь в диф не попал. То есть
+//
+//   проверка сломалась → прогон говорит «чисто»
+//
+// — ровно та тишина, против которой построен весь стандарт, только внутри нашего же флага.
+// Договор уже записан в `execution.mjs` и уже соблюдается в `prove`: 0 чисто, 1 находка (у
+// vulture 3, у pylint битовой маской), ВСЁ ОСТАЛЬНОЕ — «не смогли». Сужать дифом можно только
+// НАХОДКУ: у сбоя нет места в коде, которое он называет, — есть только сам сбой.
+// Цвет снимается: в терминале между знаком и именем гейта стоит управляющая
+// последовательность, и проверка, написанная «по глазам», не совпала бы ни разу.
+const plain = (s) => String(s).replace(/\u001b\[[0-9;]*m/g, "");
+
+function scopeProject(t, { code, path }) {
+  const p = project(t, {
+    "AGENTS.md": "# проект\n",
+    ".aqk.yml": 'aqk: 1\nentry:\n  - AGENTS.md\ngates:\n  broken: "bash broken.sh"\n',
+    // Команда — ФАЙЛОМ, а не строкой `echo …; exit 2`: на Windows строку исполняет cmd.exe,
+    // где `;` не разделитель, и гейт выходит нулём. Поймано конвейером 2026-09-11.
+    "broken.sh": `echo "${path}: infrastructure failure"\nexit ${code}\n`,
+  });
+  run(p, "git", ["add", "-A"]);
+  run(p, "git", ["commit", "-qm", "база"]);
+  // Изменение ПОСЛЕ коммита: ровно один файл в дифе, и путь из вывода гейта в него не входит.
+  mkdirSync(join(p.dir, "src"), { recursive: true });
+  writeFileSync(join(p.dir, "src", "a.mjs"), "export const a = 1;\n", "utf8");
+  return p;
+}
+
+test("гейт, выпавший с непонятным кодом, остаётся красным и при --since", (t) => {
+  const p = scopeProject(t, { code: 2, path: "outside/old.mjs:1" });
+  const r = aqk(p, "doctor", "--run", "--since", "HEAD");
+  assert.match(plain(r.out), /✘\s+broken/,
+    "гейт вышел с кодом 2 — «не смогли проверить» — и показан зелёным, потому что названный " +
+    `им путь не попал в диф. Вывод:\n${r.out}`);
+});
+
+test("контроль: НАХОДКА вне дифа по-прежнему сужается", (t) => {
+  const p = scopeProject(t, { code: 1, path: "outside/old.mjs:1" });
+  const r = aqk(p, "doctor", "--run", "--since", "HEAD");
+  assert.match(plain(r.out), /✔\s+broken/,
+    `находка вне дифа обязана сужаться — иначе --since не делает ничего. Вывод:\n${r.out}`);
+});
+
+test("контроль: находка ВНУТРИ дифа остаётся красной", (t) => {
+  const p = scopeProject(t, { code: 1, path: "src/a.mjs:1" });
+  const r = aqk(p, "doctor", "--run", "--since", "HEAD");
+  assert.match(plain(r.out), /✘\s+broken/, `находка в изменённом файле пропала. Вывод:\n${r.out}`);
+});
+
+test("контроль: нулевой код остаётся «чисто»", (t) => {
+  const p = scopeProject(t, { code: 0, path: "outside/old.mjs:1" });
+  const r = aqk(p, "doctor", "--run", "--since", "HEAD", "--verbose");
+  assert.match(plain(r.out), /✔\s+broken/, `нулевой код перестал означать «чисто». Вывод:\n${r.out}`);
+});
+
+test("параллельный прогон говорит о сбое то же самое, что одиночный", (t) => {
+  const p = scopeProject(t, { code: 2, path: "outside/old.mjs:1" });
+  const one = plain(aqk(p, "doctor", "--run", "--since", "HEAD").out);
+  const many = plain(aqk(p, "doctor", "--run", "--since", "HEAD", "--jobs", "2").out);
+  const line = (out) => (out.split("\n").find((l) => /broken/.test(l) && /[✘✔!]/.test(l)) || "").trim();
+  assert.match(line(many), /✘/, `при --jobs сбой не покраснел. Вывод:\n${many}`);
+  assert.equal(line(many).replace(/\d+\.\ds/, ""), line(one).replace(/\d+\.\ds/, ""),
+    `одно и то же событие названо по-разному в одиночном и параллельном прогоне:\n${line(one)}\n${line(many)}`);
+});
+
+// Совещательный — это «показать, но не останавливать». Причина остановки тут ни при чём: сбой
+// такой проверки обязан быть НАЗВАН и обязан не ронять прогон. Раньше на таймауте ронял.
+test("сбой СОВЕЩАТЕЛЬНОГО гейта назван, но прогон не уронен", (t) => {
+  const p = scopeProject(t, { code: 2, path: "outside/old.mjs:1" });
+  writeFileSync(join(p.dir, ".aqk.yml"),
+    'aqk: 1\nentry:\n  - AGENTS.md\ngates:\n  broken: "bash broken.sh"\nadvisory:\n  - broken\n', "utf8");
+  const r = aqk(p, "doctor", "--run", "--since", "HEAD");
+  const out = plain(r.out);
+  assert.match(out, /!\s+broken/, `совещательный сбой не назван вовсе. Вывод:\n${out}`);
+  assert.match(out, /не смогли проверить/, `сбой назван находкой, а не «не смогли». Вывод:\n${out}`);
+  assert.doesNotMatch(out, /красных гейтов/,
+    `совещательный уронил прогон — список advisory перестал что-либо значить. Вывод:\n${out}`);
+});
+
+// Пометка в pull request у сбоя — ОБЩАЯ, без file=: путь из вывода упавшего гейта назвал не
+// виноватого, а того, до кого гейт успел дойти.
+test("в GitHub Actions сбой помечается гейтом, а не строкой чужого файла", (t) => {
+  const p = scopeProject(t, { code: 2, path: "outside/old.mjs:1" });
+  const r = aqkEnv(p, { GITHUB_ACTIONS: "true" }, "doctor", "--run", "--since", "HEAD");
+  const ann = plain(r.out).split("\n").filter((l) => l.startsWith("::error"));
+  assert.equal(ann.length, 1, `пометок про сбой не одна:\n${ann.join("\n")}`);
+  assert.doesNotMatch(ann[0], /file=/, `пометка повешена на файл, которого сбой не касается: ${ann[0]}`);
+  assert.match(ann[0], /title=aqk%3A broken/, `пометка не называет гейт: ${ann[0]}`);
+});

package/tool/selfcheck/units-ask.mjs

@@ -0,0 +1,85 @@
+// tool/selfcheck/units-ask.mjs — КОГДА КОМПЛЕКТ ОБРАЩАЕТСЯ К ЧЕЛОВЕКУ: ограничитель обращений.
+//
+// ЗАЧЕМ ЭТОТ ФАЙЛ И ЭТОТ МОДУЛЬ. Знание «мы это человеку уже показывали» жило в комплекте
+// ДВАЖДЫ и по-разному: `~/.config/aqk/feedback-shown` — файл-флаг, раз на машину, заведён в
+// core.mjs и прочитан в project.mjs; `.aqk/advice-shown` и `.aqk/update-checked` — отметка
+// временем плюс `adviceDue()` на сутки, заведённые в brief.mjs. Одно решение — «не долби» — в
+// двух местах с двумя форматами хранения. Третье обращение (просьба об отзыве по делу) завело
+// бы третий формат, и дальше они расходятся молча: именно так и умирает ограничитель.
+//
+// Поэтому здесь один модуль на все обращения и таблица видов. Вид объявляет ДВЕ вещи, и обе
+// нельзя угадать по имени: где живёт отметка (проект или дом) и как часто можно повторять.
+//
+//   node --test tool/selfcheck/units-ask.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { askDue, askFile, ASKS, ASK_FILES } from "../lib/ask.mjs";
+import { RUNTIME_FILES } from "../lib/core.mjs";
+
+const NOW = Date.parse("2026-09-14T20:00:00Z");
+
+// --- «раз в сутки»: совет и проверка версии ----------------------------------
+// Тот же договор, что был у adviceDue, и он обязан остаться прежним: совет на каждом коммите
+// превращается в шум, а шум пролистывают вместе с настоящими находками.
+test("суточное обращение: не показывали — пора", () => {
+  assert.equal(askDue("advice", null, NOW), true);
+});
+
+test("суточное обращение: час назад — рано, сутки назад — пора", () => {
+  assert.equal(askDue("advice", "2026-09-14T19:00:00Z", NOW), false);
+  assert.equal(askDue("advice", "2026-09-13T19:00:00Z", NOW), true);
+});
+
+// Испорченная отметка — это «не знаем, когда показывали». Молчать из-за нечитаемого файла
+// состояния значит потерять обращение навсегда и не сказать почему.
+test("испорченная отметка читается как «не знаем» и обращение показывается", () => {
+  assert.equal(askDue("advice", "не дата", NOW), true);
+});
+
+// --- «один раз»: просьба об отзыве -------------------------------------------
+// Разовое обращение отличается от суточного не числом, а СМЫСЛОМ: его нельзя повторить никогда,
+// сколько бы времени ни прошло. Считать его «раз в очень много часов» — значит однажды получить
+// повтор у человека, который поставил комплект год назад.
+test("разовое обращение: без отметки — пора, с любой отметкой — никогда", () => {
+  assert.equal(askDue("install", null, NOW), true);
+  assert.equal(askDue("install", "shown\n", NOW), false);
+  assert.equal(askDue("install", "2020-01-01T00:00:00Z", NOW), false);
+  assert.equal(askDue("install", "мусор", NOW), false);
+});
+
+// --- опечатка в виде обращения -----------------------------------------------
+// Неизвестный вид обязан падать, а не превращаться в «показывать всегда» или «не показывать
+// никогда». Оба умолчания — молчаливый выбор за человека, и оба неверны в половине случаев.
+test("неизвестный вид обращения — отказ, а не тихое умолчание", () => {
+  assert.throws(() => askDue("опечатка", null, NOW), /опечатка/);
+  assert.throws(() => askFile("опечатка", { project: "/p", home: "/h" }), /опечатка/);
+});
+
+// --- где лежит отметка --------------------------------------------------------
+// Разовая на машину отметка НЕ ИМЕЕТ ПРАВА лежать в проекте: внутри `.aqk/` она либо уедет в
+// чужой git как наш мусор, либо пропадёт при `init --force` — и то и другое врёт о том, видел
+// человек обращение или нет. Довод записан в core.mjs с 2026-09; проверки у него не было.
+test("разовая на машину отметка лежит вне проекта", () => {
+  const p = askFile("install", { project: "/p", home: "/h" });
+  assert.ok(!p.startsWith("/p"), `отметка машины уехала в проект: ${p}`);
+  assert.ok(p.startsWith("/h"), `отметка машины легла мимо дома: ${p}`);
+});
+
+test("отметки про этот проект лежат в проекте", () => {
+  for (const kind of Object.keys(ASKS).filter((k) => ASKS[k].where === "project")) {
+    const p = askFile(kind, { project: "/p", home: "/h" });
+    assert.ok(p.startsWith("/p"), `${kind}: отметка проекта легла мимо проекта: ${p}`);
+  }
+});
+
+// --- СВЯЗЬ ДВУХ СПИСКОВ, КОТОРУЮ ИНАЧЕ НЕ СТОРОЖИТ НИКТО ----------------------
+// Отметка, лежащая в `.aqk/` и не названная в RUNTIME_FILES, не попадёт в .gitignore — и уедет
+// в чужой коммит. Это уже случалось с `.aqk/last-run.md` на живом проекте 2026-09-11, и оттуда
+// же взялся сам список. Список и таблица видов — два разных файла, и связь между ними держится
+// только этой проверкой.
+test("каждая отметка проекта названа в RUNTIME_FILES — иначе уедет в чужой git", () => {
+  for (const f of ASK_FILES) {
+    assert.ok(RUNTIME_FILES.includes(f),
+      `«${f}» не назван в RUNTIME_FILES: init не положит его в .gitignore, и отметка уедет в коммит`);
+  }
+});

package/tool/selfcheck/units-brief.mjs

@@ -8,7 +8,7 @@
 //   node --test tool/selfcheck/units-brief.mjs
 import test from "node:test";
 import assert from "node:assert/strict";
-import { briefLine, adviceDue, pickAdvice, updateNotice, updateWanted } from "../lib/brief.mjs";
+import { briefLine, pickAdvice, updateNotice, updateWanted } from "../lib/brief.mjs";
 import { CATALOGS } from "../i18n/index.mjs";
 
 const T = CATALOGS.ru;
@@ -35,18 +35,8 @@ test("невычисленный уровень не выдумывается",
 });
 
 // --- ограничитель совета -----------------------------------------------------
-// Совет на КАЖДОМ коммите превращается в шум, а шум пролистывают вместе с настоящими
-// находками. Раз в сутки — это заметно и не мешает.
-test("совет не повторяется чаще раза в сутки", () => {
-  const now = Date.parse("2026-09-08T20:00:00Z");
-  assert.equal(adviceDue(null, now), true, "первый раз показывается");
-  assert.equal(adviceDue("2026-09-08T19:00:00Z", now), false, "час назад — рано");
-  assert.equal(adviceDue("2026-09-07T19:00:00Z", now), true, "сутки прошли");
-});
-
-test("испорченная отметка времени не мешает показать совет", () => {
-  assert.equal(adviceDue("не дата", Date.parse("2026-09-08T20:00:00Z")), true);
-});
+// Сам ограничитель переехал в `ask.mjs` — он общий на все обращения комплекта к человеку, и
+// проверки на него лежат в units-ask.mjs. Здесь остаётся то, что про краткий режим.
 
 // --- выбор совета ------------------------------------------------------------
 // Один совет за раз, а не список: список читается как «у вас всё плохо» и не помогает выбрать.

package/tool/selfcheck/units-context.mjs

@@ -9,7 +9,8 @@
 //   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, nextSteps } from "../commands/context.mjs";
+import { contextBlock, countArbiters, withHook, hasOurHook, portableSelf, nextSteps } from "../commands/context.mjs";
+import { parseLastRun } from "../lib/run.mjs";
 import { CATALOGS } from "../i18n/index.mjs";
 import { commandRows } from "../lib/core.mjs";
 import { readFile } from "node:fs/promises";

package/tool/selfcheck/units-feedback.mjs

@@ -0,0 +1,137 @@
+// tool/selfcheck/units-feedback.mjs — О ЧЁМ комплект просит человека и что кладёт в отчёт.
+//
+// ЗАЧЕМ ЭТО ВООБЩЕ. Замер 2026-09-14: 1342 скачивания в неделю в npm, из них ни одного
+// пользователя — версии качаются равномерно, включая прожившую двадцать пять минут, то есть это
+// зеркала и сканеры. На GitHub за две недели семь уникальных посетителей, две звезды, ноль чужих
+// комментариев за всё время. Обратной связи нет не потому, что люди молчат, — её не у кого
+// просить, и просить мы не умеем: единственная просьба печаталась при `init`, то есть ДО того,
+// как комплект сделал хоть что-то полезное.
+//
+// ПОЭТОМУ ЗДЕСЬ ДВЕ ЧИСТЫЕ ФУНКЦИИ И ДВА ПРАВИЛА.
+//   1. Просим, ТОЛЬКО когда есть что рассказать. «Оставьте отзыв» без содержания — шум, а шум
+//      выключают вместе с хуком, в котором он приехал. Самое ценное — «AQK не смог»: жалоба
+//      даётся людям легче похвалы, и она же говорит нам, где инструмент врёт.
+//   2. Отчёт не несёт ни путей, ни кода. Человек отправляет его сам, и он обязан видеть глазами
+//      всё, что отправляет, — иначе первый же внимательный читатель назовёт это телеметрией.
+//
+//   node --test tool/selfcheck/units-feedback.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { feedbackAsk, reportText, issueUrl, askLine, feedbackWanted } from "../commands/feedback.mjs";
+
+// --- о чём просим ------------------------------------------------------------
+
+// Рассказывать нечего — не просим. Это главное правило: просьба без содержания превращает
+// ограничитель в шум, а следующую просьбу — в то, что пролистывают не читая.
+test("сказать нечего — просьбы нет", () => {
+  assert.equal(feedbackAsk({ cannot: [], blind: [], red: [] }), null);
+  assert.equal(feedbackAsk({}), null);
+});
+
+// «Не смогли проверить» — самое ценное, что у нас бывает: это отказ прибора, а не находка о
+// коде. Такое человек рассказывает охотнее, чем похвалу, и чинить надо именно это.
+test("«не смогли проверить» важнее всего остального", () => {
+  const a = feedbackAsk({ cannot: ["smoke"], blind: ["swallowed-error"], red: ["lint"] });
+  assert.equal(a.reason, "cannot");
+  assert.deepEqual(a.names, ["smoke"]);
+});
+
+test("слепой класс важнее просто красного гейта", () => {
+  const a = feedbackAsk({ cannot: [], blind: ["swallowed-error"], red: ["lint"] });
+  assert.equal(a.reason, "blind");
+  assert.deepEqual(a.names, ["swallowed-error"]);
+});
+
+// Красный гейт — это момент, когда комплект принёс пользу: он поймал то, ради чего стоит.
+test("пойманное красным — тоже повод, но последний", () => {
+  const a = feedbackAsk({ cannot: [], blind: [], red: ["lint", "smoke"] });
+  assert.equal(a.reason, "red");
+  assert.deepEqual(a.names, ["lint", "smoke"]);
+});
+
+// --- что в отчёте ------------------------------------------------------------
+
+// ПУТЕЙ НЕ БЫВАЕТ. Проба знает файл, в который подсаживала брак («blind-class: slug path»), и
+// соблазн положить его в отчёт велик — он же объясняет находку. Нельзя: путь внутри чужого
+// репозитория рассказывает о чужом проекте больше, чем его владелец собирался рассказать.
+test("отчёт называет класс, но не файл, в котором его нашли", () => {
+  const text = reportText({
+    version: "0.15.0", node: "v22.0.0", platform: "linux", level: 3,
+    langs: ["javascript"], gates: 31, red: ["lint"], cannot: [],
+    blind: [{ slug: "swallowed-error", file: "src/secret/internal.js" }],
+  }).join("\n");
+  assert.match(text, /swallowed-error/, "класс не назван — отчёт бесполезен");
+  assert.doesNotMatch(text, /src\/secret\/internal\.js/, "в отчёт попал путь из чужого репозитория");
+  assert.doesNotMatch(text, /internal/, "в отчёт попал кусок пути из чужого репозитория");
+});
+
+// МЕТКА ИСТОЧНИКА. Отзыв в GitHub ничем не связан с просьбой, и понять, работает ли канал,
+// иначе нельзя. Метка видна человеку в том же тексте, который он отправляет: это не слежка,
+// а подпись. Слежки у комплекта нет и не будет — исходящий запрос ровно один, про версию.
+test("отчёт подписан командой и версией — иначе не узнать, работает ли канал", () => {
+  const text = reportText({ version: "0.15.0", node: "v22.0.0", platform: "linux" }).join("\n");
+  assert.match(text, /aqk feedback/, "нет метки источника");
+  assert.match(text, /0\.15\.0/, "нет версии");
+});
+
+// Незнание называется словом, а не пропускается: пустая строка в отчёте читается как «всё
+// хорошо» — тот же порок, против которого написан весь комплект, только в нашем же письме.
+test("чего не знаем — сказано словом, а не пустым местом", () => {
+  const text = reportText({ version: "0.15.0", node: "v22.0.0", platform: "linux", level: null }).join("\n");
+  assert.doesNotMatch(text, /уровень:\s*$/m, "уровень пропущен молча");
+});
+
+// --- ссылка ------------------------------------------------------------------
+
+// Предзаполнение задачи параметрами `title` и `body` описано в документации GitHub (Creating an
+// issue from a URL query, сверено 2026-09-14). Кодирование обязательно: в теле переносы строк,
+// решётки и пробелы, и незакодированная ссылка обрывается на первом же из них.
+test("ссылка предзаполнена и закодирована", () => {
+  const u = issueUrl("https://github.com/o/r", "Заголовок про AQK", "строка\nвторая #2");
+  assert.ok(u.startsWith("https://github.com/o/r/issues/new?"), `не та ссылка: ${u}`);
+  assert.match(u, /title=/);
+  assert.match(u, /body=/);
+  assert.doesNotMatch(u, /\n/, "перенос строки не закодирован — ссылка оборвётся");
+  assert.doesNotMatch(u, /#2/, "решётка не закодирована — всё после неё отвалится как якорь");
+});
+
+// --- как это звучит ----------------------------------------------------------
+// Строку строит feedback.mjs, а печатают её `context` (агенту) и `doctor` (человеку): один
+// текст на два места. Собери его в каждом месте отдельно — и через месяц они разойдутся, как
+// разошлись бы `context` и `prompt` без общего `readAdvice`.
+test("строка называет причину, имена и команду", () => {
+  const s = askLine({ reason: "cannot", names: ["smoke"] }, "npx agent-quality-kit");
+  assert.match(s, /smoke/, "не названо, что именно не смогли");
+  assert.match(s, /npx agent-quality-kit feedback/, "нет команды — просьбу нечем выполнить");
+});
+
+// АГЕНТУ — ОТДЕЛЬНАЯ ОГОВОРКА. Мы кладём строку в контекст ЧУЖОГО агента, и он исполнит то, что
+// там написано. Без «не настаивай» это превращается в рекламу в чужом окне — и хук, которым она
+// приехала, снесут в первый же день вместе со всей затеей.
+test("агенту сказано не настаивать, человеку — как выключить", () => {
+  const forAgent = askLine({ reason: "red", names: ["lint"] }, "aqk", { agent: true });
+  const forHuman = askLine({ reason: "red", names: ["lint"] }, "aqk", { agent: false });
+  assert.notEqual(forAgent, forHuman, "агенту и человеку сказано одно и то же");
+  assert.match(forHuman, /AQK_FEEDBACK=0/, "человеку не сказано, как это выключить");
+});
+
+test("просить нечего — строки нет, а не пустая", () => {
+  assert.equal(askLine(null, "aqk"), null);
+});
+
+// У всего, что случается само, обязан быть выключатель — то же правило, что у совета
+// (AQK_ADVICE=0), у пробы (AQK_PROBE=0) и у проверки версии (AQK_UPDATE=0).
+test("выключатель уважается", () => {
+  assert.equal(feedbackWanted({ AQK_FEEDBACK: "0" }), false);
+  assert.equal(feedbackWanted({}), true);
+});
+
+// ПРОБА НЕ ДЕЛАЛАСЬ — «НЕИЗВЕСТНО», А НЕ «НЕТ». Поймано на первом же живом запуске команды:
+// в письме стояло «классы, которые здесь не ловит никто: нет», хотя проба не запускалась ни
+// разу. То есть наш собственный отчёт об инструменте против тишины сам выдавал незнание за
+// чистоту — и автор, читающий такое письмо, сделал бы неверный вывод о чужом проекте.
+test("проба не делалась — в отчёте «неизвестно», а не «нет»", () => {
+  const text = reportText({ version: "0.15.0", blind: null }).join("\n");
+  assert.doesNotMatch(text, /не ловит никто: нет/, "незнание выдано за чистоту");
+  assert.match(text, /не ловит никто: неизвестно/, "незнание не названо словом");
+});