@dzhechkov/p-replicator 1.13.1 → 1.13.3

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-review-contract.test.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const PKG = path.resolve(__dirname, '..', '..');
+const CHECK = path.join(PKG, 'templates', '.claude', 'hooks', 'check-review-contract.cjs');
+const SLUG = 'traceability-floor';
+const SPEC = [
+  '# Specification',
+  '',
+  '### AC-trace-1 First criterion',
+  '',
+  'The first contour is observable.',
+  '',
+  '```markdown',
+  '### AC-ignored-9 Example only',
+  '```',
+  '',
+  '### AC-trace-2 Second criterion',
+  '',
+  'The second contour is observable.',
+  '',
+].join('\n');
+
+function digest(body) {
+  return crypto.createHash('sha256').update(body).digest('hex');
+}
+
+function report(options) {
+  const o = options || {};
+  const rows = o.rows || [
+    '| AC-trace-1 | met | tests/trace.test.js — proves the first contour |',
+    '| AC-trace-2 | unverifiable | |',
+  ];
+  return [
+    '# Review report',
+    ...(o.family === null ? [] : ['Reviewer family: ' + (o.family || 'claude')]),
+    'Spec revision: sha256:' + (o.revision || digest(SPEC)),
+    '',
+    ...(o.section === false ? [] : [
+      '## Spec conformance',
+      ...(o.table === false ? [] : [
+        '| Criterion | Verdict | Evidence |',
+        '|-----------|---------|----------|',
+        ...rows,
+      ]),
+    ]),
+    '',
+  ].join('\n');
+}
+
+function check(options) {
+  const o = options || {};
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-review-')));
+  const feature = path.join(root, 'docs', 'features', SLUG);
+  fs.mkdirSync(feature, { recursive: true });
+  try {
+    const specPath = path.join(feature, '01_specification.md');
+    if (o.symlinkSpec) {
+      const target = path.join(root, 'spec-target.md');
+      fs.writeFileSync(target, SPEC);
+      fs.symlinkSync(target, specPath);
+    } else {
+      fs.writeFileSync(specPath, SPEC);
+    }
+    if (!o.missingReport) {
+      const reportPath = path.join(feature, 'review-report.md');
+      fs.writeFileSync(reportPath, o.body === undefined ? report() : o.body);
+      if (o.unreadableReport) fs.chmodSync(reportPath, 0o000);
+    }
+    const result = spawnSync(process.execPath, [CHECK, root, SLUG], { encoding: 'utf8' });
+    return { code: result.status, out: (result.stdout || '') + (result.stderr || '') };
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function namedGap(options, pattern) {
+  const result = check(options);
+  assert.equal(result.code, 1, result.out);
+  assert.match(result.out, pattern, result.out);
+}
+
+test('honest input exits 0 and prints the measured counts', () => {
+  const result = check();
+  assert.equal(result.code, 0, result.out);
+  assert.match(result.out,
+    /PASS review-contract feature=traceability-floor AC-ids=2 rows=2/,
+    result.out);
+});
+
+test('missing reviewer family is a named gap', () => {
+  namedGap({ body: report({ family: null }) }, /GAP Reviewer family line missing/);
+});
+
+test('reviewer family outside the vocabulary is a named gap', () => {
+  namedGap({ body: report({ family: 'gpt' }) }, /GAP Reviewer family invalid value=gpt/);
+});
+
+test('revision mismatch names both 12-character prefixes', () => {
+  const wrong = '0'.repeat(64);
+  const actual = digest(SPEC).slice(0, 12);
+  namedGap(
+    { body: report({ revision: wrong }) },
+    new RegExp('GAP Spec revision mismatch report=000000000000 specification=' + actual),
+  );
+});
+
+test('missing Spec conformance section is a named gap', () => {
+  namedGap({ body: report({ section: false }) }, /GAP Spec conformance section missing/);
+});
+
+test('missing Spec conformance table is a named gap', () => {
+  namedGap({ body: report({ table: false }) }, /GAP Spec conformance table missing or malformed/);
+});
+
+test('an AC id with no row is named', () => {
+  namedGap({ body: report({ rows: [
+    '| AC-trace-1 | met | tests/trace.test.js — proves the first contour |',
+  ] }) }, /GAP AC-trace-2 has no Spec conformance row/);
+});
+
+test('a row id absent from the specification is named', () => {
+  namedGap({ body: report({ rows: [
+    '| AC-trace-1 | met | tests/trace.test.js — proves the first contour |',
+    '| AC-trace-2 | unverifiable | |',
+    '| AC-invented-3 | met | tests/trace.test.js — invented contour |',
+  ] }) }, /GAP AC-invented-3 row id is not in the specification/);
+});
+
+test('a duplicate row is named', () => {
+  namedGap({ body: report({ rows: [
+    '| AC-trace-1 | met | tests/trace.test.js — first proof |',
+    '| AC-trace-1 | met | tests/trace.test.js — duplicate proof |',
+    '| AC-trace-2 | unverifiable | |',
+  ] }) }, /GAP AC-trace-1 duplicate Spec conformance row/);
+});
+
+test('a verdict outside the vocabulary is named', () => {
+  namedGap({ body: report({ rows: [
+    '| AC-trace-1 | passed | tests/trace.test.js — first proof |',
+    '| AC-trace-2 | unverifiable | |',
+  ] }) }, /GAP AC-trace-1 verdict invalid value=passed/);
+});
+
+test('empty evidence on met and not met rows is named', () => {
+  for (const verdict of ['met', 'not met']) {
+    namedGap({ body: report({ rows: [
+      '| AC-trace-1 | ' + verdict + ' | |',
+      '| AC-trace-2 | unverifiable | |',
+    ] }) }, new RegExp('GAP AC-trace-1 evidence empty for verdict=' + verdict));
+  }
+});
+
+test('unreadable or missing report → exit 2', () => {
+  for (const options of [{ missingReport: true }, { unreadableReport: true }]) {
+    const result = check(options);
+    assert.equal(result.code, 2, result.out);
+    assert.match(result.out, /NOT-ESTABLISHED review contract: review report/, result.out);
+  }
+});
+
+test('symlinked spec → exit 2', () => {
+  const result = check({ symlinkSpec: true });
+  assert.equal(result.code, 2, result.out);
+  assert.match(result.out, /NOT-ESTABLISHED review contract: specification is a symlink/, result.out);
+});
+
+test('the family line is disclosure only: every vocabulary value passes, gpt fails', () => {
+  for (const family of ['claude', 'codex', 'human', 'unknown']) {
+    const result = check({ body: report({ family }) });
+    assert.equal(result.code, 0, family + ': ' + result.out);
+  }
+  namedGap({ body: report({ family: 'gpt' }) }, /GAP Reviewer family invalid value=gpt/);
+});

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

@@ -41,13 +41,50 @@ const RULES = ['honest-configuration', 'swarm-file-evidence'];
  * {files:34, bytes:356321, estimatedTokens:95940.35}, a measured delta of 3988.50 below the
  * unchanged 4037.75 trigger.
  * Reproducer: measureCorpus() over templates/.claude/{rules,commands}/*.md plus every SKILL.md.
- * `ESTIMATED_TRIGGER` was not touched.
+ * `ESTIMATED_TRIGGER` was not touched. *
+ * Re-pinned 2026-09-02 for feature `traceability-floor-and-contract` (three /feature gates + the
+ * Traceability floor). Preimage = the tree at its parent commit d126adec^ (HEAD~1 of the feature),
+ * measured {files:34, bytes:372385, estimatedTokens:99956.35}. Against the PREVIOUS pin that state
+ * already sat at a delta of 4016.00 — the four night features between the two pins (check-ports
+ * receipts, design-analysis-hypothesis, quote-provenance, heal-bhr-drift) each fitted the trigger
+ * and none re-pinned, so 21.75 tokens of headroom remained and any new gate line would have tripped
+ * P5: the "ceiling nobody chose" this comment warns about, observed live. The feature's OWN delta
+ * against its true preimage is 715.75 tokens (feature.md gate mandates + validator report contract +
+ * the hook's inventory line), after its byte-level formats were moved to
+ * requirements-validator/references/feature-report-contracts.md. `ESTIMATED_TRIGGER` unchanged.
  */
-const FRESH_BEFORE = { files: 34, bytes: 356321, estimatedTokens: 95940.35 };
+const FRESH_BEFORE = { files: 34, bytes: 372385, estimatedTokens: 99956.35 };
 const ESTIMATED_TRIGGER = 4037.75;
 // Measured 2026-09-01 before corpus-budget-compression. Modules and references are outside
 // measureCorpus(); a 0-byte allowance makes any relocation growth visible instead of budget-free.
-const UNMEASURED_SKILL_SURFACES_BEFORE = { files: 59, bytes: 638309 };
+// Re-measured 2026-09-02 (features/traceability-floor-and-contract): +1 file, +4265 bytes —
+// requirements-validator/references/feature-report-contracts.md (the byte-level formats of the
+// 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.
+// ПЕРЕЗАКРЕПЛЕНО 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/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 }); }
   });