@dzhechkov/p-replicator 1.13.2 → 1.13.4

package/tests/unit/capture-source-path.test.js

@@ -104,19 +104,55 @@ function site({ robots = null, forbid = [] } = {}) {
     if (!body) { res.writeHead(404); return res.end('nf'); }
     res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' }); res.end(body);
   });
-  return { srv, hits, listen: () => new Promise((r) => srv.listen(0, '127.0.0.1', () => r(srv.address().port))) };
+  // `close()` НЕ закрывает сервер, пока жив хоть один keep-alive сокет: он ждёт их естественной
+  // смерти. ИЗМЕРЕНО 2026-09-03 — тест P20 после этого не завершался вовсе, и полоса вместе с ним
+  // висела дольше десятиминутного потолка вызова. `closeAllConnections()` рвёт живые сокеты, то
+  // есть закрывает сервер ДЕТЕРМИНИРОВАННО, а не при удаче. `shutdown()` возвращает обещание,
+  // поэтому вызывающий может дождаться закрытия вместо того, чтобы надеяться на него.
+  const shutdown = () => new Promise((r) => {
+    if (typeof srv.closeAllConnections === 'function') srv.closeAllConnections();
+    srv.close(() => r());
+  });
+  return {
+    srv, hits, shutdown,
+    listen: () => new Promise((r) => srv.listen(0, '127.0.0.1', () => r(srv.address().port))),
+  };
 }
 
 /** АСИНХРОННЫЙ запуск — см. измерение в шапке файла. */
+/**
+ * Потолок времени на один запуск инструмента.
+ *
+ * ИЗМЕРЕНО 2026-09-03: без него полоса `npm run test:browser` не завершалась ВООБЩЕ — убита по
+ * внешнему таймауту дважды, на 400 с и на 560 с. Ждущий вечно тест не отличим от идущего долго, и
+ * снаружи оба выглядят как «ещё работает». Потолок превращает зависание в ИМЕНОВАННЫЙ отказ, то
+ * есть в результат, который можно прочитать.
+ *
+ * Значение выбрано не на глаз: браузерные сценарии этого файла на живой машине укладываются в
+ * единицы секунд, а сценарии ОТСУТСТВИЯ браузера обязаны отвечать почти мгновенно — им нечего
+ * запускать. 20 секунд оставляют десятикратный запас медленному сценарию и всё равно ловят
+ * зависание за время, которое человек готов ждать.
+ */
+const RUN_TIMEOUT_MS = 20_000;
+
 function run(args, env) {
   return new Promise((resolve) => {
     const child = spawn(process.execPath, [TOOL, ...args], {
       env: { ...process.env, ...(PW ? { PLAYWRIGHT_MODULE: PW } : {}), ...env },
     });
     let out = '';
+    let settled = false;
+    const finish = (code) => { if (settled) return; settled = true; clearTimeout(timer); resolve({ code, out }); };
+    const timer = setTimeout(() => {
+      out += `\n[ТАЙМАУТ ТЕСТА] инструмент не завершился за ${RUN_TIMEOUT_MS} мс и был убит; ` +
+             'это НЕ «не удалось проверить», а именованный отказ: зависание есть дефект.\n';
+      child.kill('SIGKILL');
+      finish('timeout');
+    }, RUN_TIMEOUT_MS);
     child.stdout.on('data', (d) => { out += d; });
     child.stderr.on('data', (d) => { out += d; });
-    child.on('close', (code) => resolve({ code, out }));
+    child.on('close', (code) => finish(code));
+    child.on('error', (e) => { out += String(e && e.message); finish('spawn-error'); });
   });
 }
 
@@ -340,7 +376,7 @@ describe('ось «путь»: детерминированная половин
 
 describe('ось «путь»: живые прогоны браузером по локальной оснастке', { skip: LIVE_SKIP }, () => {
   test('P14 - СНЯТ: путь прокликан, строки выданы, нумерация продолжена', async () => {
-    const { srv, listen } = site();
+    const { srv, listen, shutdown } = site();
     const port = await listen();
     const dir = tmp();
     try {
@@ -358,11 +394,11 @@ describe('ось «путь»: живые прогоны браузером по
       // И измеренные закономерности стартового экрана, а не значения чужого оформления.
       assert.match(r.out, /шаг сетки отступов: 4px/, 'сетка 4px обязана вывестись: ' + r.out);
       assert.match(r.out, /брейкпоинты из настоящих @media: 768, 1024/, r.out);
-    } finally { srv.close(); fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally { await shutdown(); fs.rmSync(dir, { recursive: true, force: true }); }
   });
 
   test('P15 - доказательства помечены чужим материалом и закрыты своим .gitignore', async () => {
-    const { srv, listen } = site();
+    const { srv, listen, shutdown } = site();
     const port = await listen();
     const dir = tmp();
     try {
@@ -379,11 +415,11 @@ describe('ось «путь»: живые прогоны браузером по
         'DOM по умолчанию не сохраняется: ' + files.join(', '));
       assert.ok(files.some((f) => f.endsWith('.aria.txt')), 'семантический слепок — наш вывод');
       assert.ok(files.includes('capture.json'), 'измерения сохраняются');
-    } finally { srv.close(); fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally { await shutdown(); fs.rmSync(dir, { recursive: true, force: true }); }
   });
 
   test('P16 - ВЕЖЛИВОСТЬ: один поток, пауза выдержана, потолок страниц соблюдён', async () => {
-    const { srv, hits, listen } = site();
+    const { srv, hits, listen, shutdown } = site();
     const port = await listen();
     const dir = tmp();
     try {
@@ -397,13 +433,17 @@ describe('ось «путь»: живые прогоны браузером по
         'пауза между экранами обязана выдерживаться, измерено ' + (pages[1].t - pages[0].t) + ' мс');
       assert.match(pages[0].ua, new RegExp(lib.ROBOTS_AGENT),
         'User-Agent честный: маскировка под обычный браузер была бы обходом защиты');
-    } finally { srv.close(); fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally { await shutdown(); fs.rmSync(dir, { recursive: true, force: true }); }
   });
 
   test('P17 - robots.txt спрашивается ПЕРЕД обходом, и запрет — это исход', async () => {
+    // Закрытие серверов — в `finally`: упавшая проверка не должна превращаться в зависание
+    // (см. измерение в P18 ниже; там это стоило полосе всего её бюджета).
     const dir = tmp();
+    const deny = site({ robots: 'User-agent: *\nDisallow: /\n' });
+    const broken = site({ robots: 500 });
+    const one = site({ robots: 'User-agent: *\nDisallow: /\n' });
     try {
-      const deny = site({ robots: 'User-agent: *\nDisallow: /\n' });
       const p1 = await deny.listen();
       const r1 = await run([`http://127.0.0.1:${p1}/`, '--project', dir, '--out', 'e',
         '--max-pages', '3']);
@@ -411,53 +451,62 @@ describe('ось «путь»: живые прогоны браузером по
       assert.match(r1.out, /НЕ ИЗМЕРЕНО: robots-disallowed/, r1.out);
       assert.equal(deny.hits.filter((h) => h.url !== '/robots.txt').length, 0,
         'ни одной страницы не тронуто: robots.txt читается ДО обхода, а не после');
-      deny.srv.close();
 
       // Нечитаемый robots.txt — запрет, а не разрешение: «не смогли спросить» ≠ «нам разрешили».
-      const broken = site({ robots: 500 });
       const p2 = await broken.listen();
       const r2 = await run([`http://127.0.0.1:${p2}/`, '--project', dir, '--out', 'e',
         '--max-pages', '3']);
       assert.equal(r2.code, 2, r2.out);
       assert.match(r2.out, /robots-disallowed/, r2.out);
       assert.match(r2.out, /трактуется как запрет/, r2.out);
-      broken.srv.close();
 
       // ОДНА страница — не обход, robots.txt не запрашивается вовсе.
-      const one = site({ robots: 'User-agent: *\nDisallow: /\n' });
       const p3 = await one.listen();
       const r3 = await run([`http://127.0.0.1:${p3}/lonely`, '--project', dir, '--out', 'e',
         '--max-pages', '1']);
       assert.equal(one.hits.filter((h) => h.url === '/robots.txt').length, 0,
         'обхода нет — robots.txt не спрашивается: ' + r3.out);
-      one.srv.close();
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally {
+      await deny.shutdown();
+      await broken.shutdown();
+      await one.shutdown();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   test('P18 - 403 и экран входа — исходы с НАЗВАННОЙ причиной, никогда не обход', async () => {
+    // ЗАКРЫТИЕ СЕРВЕРОВ СТОИТ В `finally`, И ЭТО НЕ СТИЛЬ, А ПОЧИНКА ЗАВИСАНИЯ.
+    // ИЗМЕРЕНО 2026-09-03: закрытие стояло ПОСЛЕ проверок, поэтому первая же упавшая проверка
+    // выбрасывала исключение до него, сервер оставался слушать, и `node --test` ждал опустошения
+    // цикла событий ВЕЧНО. Снаружи это выглядело как «полоса идёт долго»: она не шла, она висела —
+    // убита по внешнему потолку на 400 с и на 560 с. Сам P18 в одиночку отрабатывает за секунды.
+    // Общая форма: ресурс, удерживающий цикл событий, закрывается в `finally`, иначе падение
+    // проверки превращается в зависание, а зависание неотличимо от долгой работы.
     const dir = tmp();
+    const blocked = site({ forbid: ['/'] });
+    const walled = site();
     try {
-      const blocked = site({ forbid: ['/'] });
       const p1 = await blocked.listen();
       const r1 = await run([`http://127.0.0.1:${p1}/`, '--project', dir, '--out', 'e',
         '--max-pages', '1']);
       assert.equal(r1.code, 2, r1.out);
       assert.match(r1.out, /НЕ ИЗМЕРЕНО: bot-protected/, r1.out);
       assert.match(r1.out, /ЗАПРЕЩЕНО/, 'и запрет на обход защиты обязан быть сказан: ' + r1.out);
-      blocked.srv.close();
 
-      const walled = site();
       const p2 = await walled.listen();
       const r2 = await run([`http://127.0.0.1:${p2}/signup`, '--project', dir, '--out', 'e',
         '--max-pages', '2']);
       assert.equal(r2.code, 2, 'стартовый экран за входом — не «снято»: ' + r2.out);
       assert.match(r2.out, /НЕ ИЗМЕРЕНО: auth-required/, r2.out);
-      walled.srv.close();
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally {
+      await blocked.shutdown();
+      await walled.shutdown();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   test('P19 - ИСТОЧНИКА НЕТ: экран открылся, перехода нет — доказанный отрицательный ответ', async () => {
-    const { srv, listen } = site();
+    const { srv, listen, shutdown } = site();
     const port = await listen();
     const dir = tmp();
     try {
@@ -468,13 +517,13 @@ describe('ось «путь»: живые прогоны браузером по
       assert.match(r.out, /\*\*Статус съёмки \(путь\):\*\* ИСТОЧНИКА НЕТ/,
         'и печатает готовую строку профиля: ' + r.out);
       assert.ok(!/FR-LOOK-\d{3} \|/.test(r.out), 'строк не выпускается — записывать нечего: ' + r.out);
-    } finally { srv.close(); fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally { await shutdown(); fs.rmSync(dir, { recursive: true, force: true }); }
   });
 
   test('P20 - один двоичный файл выдаёт все три исхода в одном прогоне', async () => {
     // Каждый случай выше утверждает ОДНО направление, поэтому реализация с постоянным ответом
     // прошла бы подмножество. Тот же исполняемый файл обязан выдать 0, 1 и 2.
-    const { srv, listen } = site();
+    const { srv, listen, shutdown } = site();
     const port = await listen();
     const dir = tmp();
     try {
@@ -487,6 +536,6 @@ describe('ось «путь»: живые прогоны браузером по
           '--max-pages', '1'])).code,
       ];
       assert.deepEqual(seen, [0, 1, 2], 'ожидались снято/пути-нет/не-измерено: ' + JSON.stringify(seen));
-    } finally { srv.close(); fs.rmSync(dir, { recursive: true, force: true }); }
+    } finally { await shutdown(); fs.rmSync(dir, { recursive: true, force: true }); }
   });
 });

package/tests/unit/check-dangling-refs.test.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Текст, ссылающийся на несуществующий файл, обязан быть замечен машиной.
+ *
+ * ПОЧЕМУ ЭТО ЕСТЬ. Этот класс дефекта ловился вручную минимум четыре раза: список хуков называл
+ * 4 из 8; таблица говорила «Rules 5» при шести; справка обещала 18 видов отказа при 17 в массиве;
+ * путь вывода называл несуществующий каталог. `verify` его не ловит ПО ПОСТРОЕНИЮ: он идёт от
+ * зарегистрированного объекта к его наличию, а этот дефект живёт в обратном направлении — от
+ * текста к объекту, которого нет.
+ *
+ * ПОЧЕМУ БАЗА, А НЕ НОЛЬ. Измерено 2026-09-03: 58 висячих ссылок в 23 файлах, и они не появляются
+ * после `init` (проверено на пустом проекте). Требовать ноль значило бы отказать каждому проекту в
+ * первый же день, то есть выключить заставу. База закреплена и может только уменьшаться.
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { spawnSync } = require('node:child_process');
+const HOOK = path.join(__dirname, '..', '..', 'templates', '.claude', 'hooks', 'check-dangling-refs.cjs');
+const { danglingRefs, BASELINE } = require('../../templates/.claude/hooks/check-dangling-refs.cjs');
+const TEMPLATES = path.join(__dirname, '..', '..', 'templates');
+
+describe('висячие ссылки не могут стать хуже базы', () => {
+  test('текущее дерево не превышает закреплённую базу', () => {
+    const found = danglingRefs(TEMPLATES);
+    assert.notEqual(found, null, 'templates/.claude должен существовать');
+    const unique = new Set(found.map((f) => `${f.from} → ${f.to}`));
+    assert.ok(unique.size <= BASELINE,
+      `висячих ссылок ${unique.size} при базе ${BASELINE} — новая ссылка на несуществующий файл`);
+  });
+
+  test('база не завышена: она равна измеренному, а не взята с запасом', () => {
+    // Запас в базе — это тихое разрешение добавить ещё столько же. База обязана совпадать с
+    // измерением, иначе она перестаёт быть границей и становится квотой.
+    const found = danglingRefs(TEMPLATES);
+    const unique = new Set(found.map((f) => `${f.from} → ${f.to}`));
+    assert.equal(unique.size, BASELINE,
+      `база ${BASELINE} разошлась с измеренным ${unique.size}: если починили — опустите базу, если добавили — верните ссылку`);
+  });
+
+  test('сторож видит внедрённую висячую ссылку', () => {
+    // Дискриминация: застава, которая ничего не нашла, неотличима от заставы, которая ничего не
+    // умеет. Подкладываем ровно ту форму, которую она обязана поймать.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dangl-'));
+    try {
+      fs.mkdirSync(path.join(dir, '.claude', 'rules'), { recursive: true });
+      fs.writeFileSync(path.join(dir, '.claude', 'rules', 'a.md'),
+        'Смотри `.claude/hooks/nonexistent-guard.cjs` — его нет.\n');
+      const found = danglingRefs(dir);
+      assert.equal(found.length, 1);
+      assert.equal(found[0].to, '.claude/hooks/nonexistent-guard.cjs');
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test('существующая цель висячей не считается', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dangl-ok-'));
+    try {
+      fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+      fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'real.cjs'), '// real\n');
+      fs.writeFileSync(path.join(dir, '.claude', 'a.md'), 'Смотри `.claude/hooks/real.cjs`.\n');
+      assert.deepEqual(danglingRefs(dir), []);
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test('честный вход: дерево без висячих ссылок даёт exits 0 и печатает измеренное', () => {
+    // Требование каталога хуков: у каждого check-*.cjs должен быть тест ЧЕСТНОГО ВХОДА — прогон на
+    // заведомо правильных данных. Без него застава, которая всегда красная, выглядела бы рабочей.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dangl-honest-'));
+    try {
+      fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+      fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'real.cjs'), '// real\n');
+      fs.writeFileSync(path.join(dir, '.claude', 'ok.md'), 'Ссылка на `.claude/hooks/real.cjs` — она есть.\n');
+      const r = spawnSync(process.execPath, [HOOK, dir], { encoding: 'utf8' });
+      assert.equal(r.status, 0, r.stderr || r.stdout);
+      assert.match(r.stdout, /висячих ссылок 0/);
+      assert.match(r.stdout, /Проверено файлов: 1/);
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test('отсутствие .claude — это НЕ УСТАНОВЛЕНО, а не «чисто»', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dangl-none-'));
+    try {
+      assert.equal(danglingRefs(dir), null, 'пустое дерево обязано дать null, а не пустой список');
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+});

package/tests/unit/check-external-deps.test.js

@@ -52,8 +52,12 @@ const check = (files) => run(CHECK, files);
 const GOOD_EVIDENCE = 'https://docs.example.test/email · checked 2026-08-30 · '
   + '«The API reports hard and soft bounces via webhook»';
 
+const EN_HEADER = '| Capability needed | Provider / API | Evidence | Verdict | Requirements relying on it |';
+/** The package writes its documents in Russian, so a Russian header is the TYPICAL case, not a corner. */
+const RU_HEADER = '| Возможность | Провайдер | Свидетельство | Вердикт | Требования |';
+
 /** An Architecture.md whose inventory says what the case needs. */
-function arch({ rows, before = '## Technology Stack\n\n| Layer | Technology | Rationale |\n|---|---|---|\n| Backend | Node | привычен команде |\n', section = true, prose = '' } = {}) {
+function arch({ rows, header = EN_HEADER, before = '## Technology Stack\n\n| Layer | Technology | Rationale |\n|---|---|---|\n| Backend | Node | привычен команде |\n', section = true, prose = '' } = {}) {
   const body = rows === undefined
     ? [['отправка писем', 'Postmark', GOOD_EVIDENCE, 'CONFIRMED', 'FR-010']]
     : rows;
@@ -61,7 +65,7 @@ function arch({ rows, before = '## Technology Stack\n\n| Layer | Technology | Ra
   if (section) {
     out += '## External Dependencies\n\n' + (prose ? prose + '\n\n' : '');
     if (body.length) {
-      out += '| Capability needed | Provider / API | Evidence | Verdict | Requirements relying on it |\n'
+      out += header + '\n'
         + '|---|---|---|---|---|\n'
         + body.map((r) => '| ' + r.join(' | ') + ' |').join('\n') + '\n';
     }
@@ -154,6 +158,26 @@ describe('инвентарь внешних зависимостей — the det
     assert.match(r.out, /FR-011/, 'the dependent requirements must be named, not counted');
   });
 
+  test('P9b - RU/EN twin: the header is recognised by POSITION, so a Russian header is never a data row', () => {
+    // MEASURED 2026-09-02 (backlog b8a7669d): the same table body under a Russian header produced a
+    // FALSE finding «строка инвентаря без вердикта • Возможность» — the header itself was read as a
+    // row — and that false finding fired FIRST, masking the real one. One variable differs between
+    // the twins: the header line. Every outcome below must be identical for both.
+    const clean = [['отправка писем', 'Postmark', GOOD_EVIDENCE, 'CONFIRMED', 'FR-010']];
+    for (const header of [EN_HEADER, RU_HEADER]) {
+      const r = check({ [ARCH]: arch({ rows: clean, header }) });
+      assert.equal(r.code, 0, header + '\n' + r.out);
+      assert.doesNotMatch(r.out, /Возможность|Capability needed/, 'the header must not surface as a row: ' + r.out);
+    }
+    const noVerdict = [['отправка писем', 'Postmark', GOOD_EVIDENCE, '', 'FR-010']];
+    const twins = [EN_HEADER, RU_HEADER].map((header) => check({ [ARCH]: arch({ rows: noVerdict, header }) }));
+    for (const r of twins) {
+      assert.equal(r.code, 1, r.out);
+      assert.match(r.out, /отправка писем/, 'the REAL defective row must be the one named: ' + r.out);
+      assert.doesNotMatch(r.out, /Возможность|Capability needed/, 'the header must not be the finding: ' + r.out);
+    }
+  });
+
   test('P10 - THE second fixture: CONFIRMED without a verbatim quote fails, WITH THE ROW NAMED', () => {
     const r = check({ [ARCH]: arch({ rows: [
       ['отправка писем', 'Postmark', 'https://docs.example.test/email · checked 2026-08-30', 'CONFIRMED', 'FR-010'],

package/tests/unit/detection-ladder-contract.test.js

@@ -4,11 +4,12 @@ const { test } = require('node:test');
 const assert = require('node:assert/strict');
 const { execFileSync } = require('node:child_process');
 const fs = require('node:fs');
-const Module = require('node:module');
 const os = require('node:os');
 const path = require('node:path');
 const { Worker } = require('node:worker_threads');
 
+const { announceNpmSkip, resolveNpmCli } = require('../npm-cli-resolver.js');
+
 const PKG_DIR = path.resolve(__dirname, '..', '..');
 const RULE_DIR = path.join(PKG_DIR, 'templates', '.claude', 'rules');
 const RULE_FILE = 'cost-of-detection-ladder.md';
@@ -18,13 +19,12 @@ const CLI = path.join(PKG_DIR, 'bin', 'cli.js');
 
 const read = (file) => fs.readFileSync(file, 'utf8');
 
-function npmPackDryRunFiles() {
-  const npmCli = process.env.npm_execpath && fs.existsSync(process.env.npm_execpath)
-    ? process.env.npm_execpath
-    : path.join(
-      path.dirname(require.resolve('npm/package.json', { paths: Module.globalPaths })),
-      'bin',
-      'npm-cli.js');
+// FR-3 / ADR-001. The previous line here asked whether `npm_execpath` EXISTS. Under `pnpm test` it
+// points at pnpm.cjs, that file exists, so the fallback never fired in the one case it was written
+// for — and pnpm was then loaded as the npm CLI: `Unknown option: 'dry-run'` (MEASURED 2026-09-18).
+// The resolver asks instead whether the thing at that path IS npm, and falls through to the
+// installed npm when it is not.
+function npmPackDryRunFiles(npmCli) {
   const cache = fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-npm-pack-cache-'));
 
   return new Promise((resolve, reject) => {
@@ -288,14 +288,24 @@ test('P5 — package runner and scope guards reject omitted and out-of-scope inp
     'a real out-of-scope package path must fire the scope safeguard');
 });
 
-test('A2 — package files include templates and the actual npm pack listing contains the ladder', async () => {
+test('A2 — package files include templates and the actual npm pack listing contains the ladder', async (t) => {
   const pkg = JSON.parse(read(path.join(PKG_DIR, 'package.json')));
   assert.deepEqual(packagingProblems(pkg), []);
   const omitted = JSON.parse(JSON.stringify(pkg));
   omitted.files = omitted.files.filter((entry) => entry !== 'templates/');
   assert.deepEqual(packagingProblems(omitted), ['package files[] omits templates/'],
     'a cloned files[] without templates/ must fire the distribution safeguard');
-  const packedFiles = await npmPackDryRunFiles();
+
+  // FR-4: no npm anywhere is a NAMED skip printed into the suite output, never a silent pass and
+  // never a crash. This test exists to exercise the REAL packer; a faked one would prove nothing.
+  const npmCli = resolveNpmCli(process.env);
+  if (npmCli.kind !== 'npm-cli') {
+    announceNpmSkip(npmCli);
+    t.skip(npmCli.reason);
+    return;
+  }
+
+  const packedFiles = await npmPackDryRunFiles(npmCli.path);
   assert.ok(
     packedFiles.includes(`templates/.claude/rules/${RULE_FILE}`),
     `actual npm pack listing omits templates/.claude/rules/${RULE_FILE}`);

package/tests/unit/guard-honest-input-meta.test.js

@@ -62,3 +62,52 @@ test('honest-input catalog probe reports a fake check with no same-named test',
   }
 });
 
+/**
+ * ВТОРОЙ УКУС — на ветку, которую первый не трогал.
+ *
+ * ИЗМЕРЕНО 2026-09-03: удаление проверки `missing-honest-input-title` из аудита оставляло ОБА
+ * метатеста зелёными. Первый укус подкладывает хук БЕЗ теста и потому доказывает только ветку
+ * `missing-test`; вторая ветка не проверялась ничем и могла быть удалена незаметно. Страж,
+ * половина которого удаляется без единого красного теста, охраняет ровно ту половину, что осталась.
+ */
+test('honest-input catalog probe reports a test file with no honest-input title', () => {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-honest-meta2-')));
+  const hooksCopy = path.join(root, 'hooks');
+  const testsCopy = path.join(root, 'unit');
+  try {
+    fs.cpSync(HOOKS, hooksCopy, { recursive: true });
+    fs.cpSync(TESTS, testsCopy, { recursive: true });
+    fs.writeFileSync(path.join(hooksCopy, 'check-yyy.cjs'), "'use strict';\n");
+    // Тест ЕСТЬ — и в нём нет ни одного заголовка честного входа. Это ровно та форма, которую
+    // первый укус пропускает: файл на месте, обязанность не выполнена.
+    fs.writeFileSync(path.join(testsCopy, 'check-yyy.test.js'),
+      "'use strict';\nconst { test } = require('node:test');\n" +
+      "test('refuses on a bad input', () => {});\n");
+
+    const result = auditHonestInputs(hooksCopy, testsCopy);
+    assert.deepEqual(result.issues.filter((issue) => issue.hook === 'check-yyy.cjs'), [{
+      hook: 'check-yyy.cjs', testFile: 'check-yyy.test.js', reason: 'missing-honest-input-title',
+    }], 'ветка отсутствующего заголовка обязана иметь собственный укус, иначе её удалят молча');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+/**
+ * ЧЕСТНАЯ ГРАНИЦА ЭТОГО ИНВАРИАНТА, названная здесь, чтобы её не пришлось выводить.
+ *
+ * Проверяется ЗАГОЛОВОК теста, а не его содержание. Заголовок «honest input exits 0» над пустым
+ * телом инвариант удовлетворяет. То есть страж ловит ЗАБЫВЧИВОСТЬ (никто не написал такого теста)
+ * и не ловит ОБМАН (написали заголовок, не написав проверки).
+ *
+ * Это осознанная граница, а не недосмотр: доказать по телу теста, что он действительно прогоняет
+ * честный вход, значит разбирать чужой код, а разбор кода регулярным выражением — тот самый
+ * механизм, который в этом пакете уже дважды давал ложные вердикты. Забывчивость при этом и есть
+ * массовый случай: заголовок пишут те, кто про обязанность помнит.
+ */
+test('the invariant is a TITLE check, and that boundary is stated rather than implied', () => {
+  const source = fs.readFileSync(__filename, 'utf8');
+  assert.match(source, /Проверяется ЗАГОЛОВОК теста, а не его содержание/,
+    'граница инварианта обязана быть написана в файле, а не подразумеваться');
+});
+

package/tests/unit/honest-failure-rules.test.js

@@ -62,7 +62,29 @@ const ESTIMATED_TRIGGER = 4037.75;
 // three /feature report gates; invocation-time material, the gates are the machine half) and the
 // Traceability floor row + FR-009 worked case in references/scoring-system.md. Not a relocation:
 // the always-loaded corpus measured by P5 GREW in the same change (feature.md gates), it did not shrink.
-const UNMEASURED_SKILL_SURFACES_BEFORE = { files: 60, bytes: 642574 };
+// ПЕРЕЗАКРЕПЛЕНО 2026-09-03: 642574 → 645401 байт при неизменных 60 файлах.
+//
+// ЧТО ЭТОТ СТОРОЖ ЛОВИТ, и почему перезакрепление здесь законно, а поднятие допуска — нет.
+// Он ловит ПЕРЕЕЗД всегда-загружаемого текста из измеряемого корпуса в неизмеряемые поверхности
+// навыков: так «сжатие корпуса» выглядит достигнутым, а контекст сессии не уменьшается ни на байт.
+// Признак переезда — рост здесь ПРИ УМЕНЬШЕНИИ там.
+//
+// ПРОВЕРЕНО ПЕРЕД ПЕРЕЗАКРЕПЛЕНИЕМ: `git diff --numstat` по правкам этого захода даёт в измеряемом
+// корпусе (`rules/`, `commands/`) 28 вставок и НОЛЬ удалений. Текст ниоткуда не уехал — это новое
+// содержание: правило S-08 о типе изображения по содержимому и шесть строк к S-01/S-02 о молчаливых
+// способах обойти изоляцию арендаторов, обе вставки в `references/security-patterns-library.md`.
+//
+// ТОЧНОСТЬ УЧЁТА, исправлена после проверки дискриминацией: сторож считает ТОЛЬКО `modules/` и
+// `references/` внутри навыков (строка 242), а `resources/` не считает вовсе. Первая редакция этого
+// комментария приписывала часть роста правкам в `resources/assessment-rubrics.md` — неверно, они в
+// базу не входят. Прирост 2827 байт объясняется одним файлом: 2483 байта дала правка
+// `security-patterns-library.md`, остальное — перенос строк внутри неё. Проверено пробой: приписка
+// к считаемому файлу красит тест, приписка к `resources/` — нет.
+//
+// ДОПУСК ОСТАЁТСЯ НУЛЁМ И НЕ ПОДНИМАЕТСЯ НИ ПРИ КАКОМ РЕЗУЛЬТАТЕ. Разница между двумя числами
+// принципиальная: база — это ИЗМЕРЕНИЕ, и переизмерить её с названной причиной честно; допуск —
+// это РАЗРЕШЕНИЕ расти молча, и любое его значение выше нуля превращает сторожа в квоту.
+const UNMEASURED_SKILL_SURFACES_BEFORE = { files: 60, bytes: 645401 };
 const UNMEASURED_SKILL_SURFACES_GROWTH_ALLOWANCE = 0;
 const SEAMS = [
   ['commands/feature.md', 'both'],

package/tests/unit/insights-writer.test.js

@@ -6,6 +6,7 @@ const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { skipWhenDzAbsent } = require('../dz-availability.js');
 
 const PKG = path.resolve(__dirname, '..', '..');
 const TPL = path.join(PKG, 'templates', '.claude');
@@ -258,7 +259,7 @@ describe('PR-022 harvest insight persistence', () => {
     } finally { cleanup(broken); }
   });
 
-  test('P16b - duplicate replay imports one learned row', () => {
+  test('P16b - duplicate replay imports one learned row', (t) => {
     const { writeInsight, stableTeachText, normalizePayload } = requireWriter();
     const root = tempProject('p-rep-real-dz-teach-');
     try {
@@ -266,6 +267,9 @@ describe('PR-022 harvest insight persistence', () => {
       const first = writeInsight(root, record);
       const replay = writeInsight(root, { ...record, date: '2026-08-31' });
       assert.equal(first.status, 'created');
+      // Backlog 1b4857a6: this case queries the learned rows dz itself stores, so a missing dz is
+      // an audible skip and a broken dz stays red — the rule lives once, in tests/dz-availability.js.
+      if (skipWhenDzAbsent(t, first.teach.state, 'it reads back the learned rows dz stores')) return;
       assert.equal(first.teach.state, 'ok');
       assert.equal(replay.status, 'duplicate');
       assert.equal(replay.teach.state, 'ok');

package/tests/unit/negative-conclusion-gate.test.js

@@ -38,7 +38,7 @@ const read = (rel) => fs.readFileSync(path.join(PKG, rel), 'utf8');
 /** Is a usable python3 present? Reported honestly rather than silently skipped past. */
 function python() {
   for (const bin of ['python3', 'python']) {
-    const probe = spawnSync(bin, ['--version'], { encoding: 'utf8' });
+    const probe = spawnSync(bin, ['--version'], { encoding: 'utf8', env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' } });
     if (probe.status === 0) return bin;
   }
   return null;
@@ -61,7 +61,7 @@ function gate(reportText) {
     const facts = path.join(dir, 'facts.json');
     fs.writeFileSync(report, reportText);
     fs.writeFileSync(facts, ledger());
-    const r = spawnSync(PY, [GATE, '--report', report, '--facts', facts, '--json'], { encoding: 'utf8' });
+    const r = spawnSync(PY, [GATE, '--report', report, '--facts', facts, '--json'], { encoding: 'utf8', env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' } });
     const raw = (r.stdout || '').trim();
     let parsed = null;
     try { parsed = JSON.parse(raw); } catch { /* left null, asserted by the caller */ }
@@ -231,7 +231,7 @@ describe('отрицательный вывод — the second direction of the
       const report = path.join(dir, 'report.md');
       fs.writeFileSync(report, BASE + NEGATIVE);
       const r = spawnSync(PY, [GATE, '--report', report, '--facts', path.join(dir, 'absent.json'),
-        '--json'], { encoding: 'utf8' });
+        '--json'], { encoding: 'utf8', env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' } });
       assert.equal(r.status, 2, 'a gate that could not read its inputs has cleared nothing');
     } finally { fs.rmSync(dir, { recursive: true, force: true }); }
   });