@dzhechkov/p-replicator 1.13.2 → 1.13.3

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/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 }); }
   });

package/tests/unit/optional-doc-idiom.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/**
+ * A document may be retired from the required set only WITH A DATED MEASUREMENT beside it.
+ *
+ * WHY THIS IS A TEST AND NOT A CONVENTION. Retiring a document is the cheapest way to make a
+ * pipeline look faster, and it is invisible afterwards: nobody notices a check that stopped
+ * running. The package already ships the honest form of this move — `Final_Summary.md` carries
+ * `{ optional: true, expected: true }` plus a comment naming WHAT was measured, WHEN, and WHY the
+ * evidence is not yet enough to decide. That is reversible and it leaves a receipt.
+ *
+ * This test makes the receipt mandatory. `optional: true` without a `MEASURED YYYY-MM-DD` comment
+ * above it turns red, so the next person who wants to drop a document must either measure or argue
+ * in the open. The guard is deliberately about the RECEIPT, not about which documents are optional:
+ * deciding that is a design call, and this file does not pretend to make it.
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const HOOK = path.join(__dirname, '..', '..', 'templates', '.claude', 'hooks', 'check-docs-complete.cjs');
+const DATE = /MEASURED \d{4}-\d{2}-\d{2}/;
+
+/** Lines of the DOCS array, paired with the comment block immediately above each entry. */
+function optionalEntriesWithContext(source) {
+  const lines = source.split('\n');
+  const out = [];
+  lines.forEach((line, i) => {
+    // Match an ENTRY of the DOCS array, not any prose that happens to contain the words. The first
+    // version of this parser matched a doc-comment at :29 that merely EXPLAINS the flag, which
+    // would have made the guard permanently red for a reason unrelated to any real receipt.
+    if (!/^\s*\{\s*file:\s*'[^']+'.*optional:\s*true/.test(line)) return;
+    // Walk up through the contiguous comment block directly above this entry.
+    let j = i - 1;
+    const comment = [];
+    while (j >= 0 && /^\s*\/\//.test(lines[j])) { comment.unshift(lines[j]); j -= 1; }
+    out.push({ line: i + 1, entry: line.trim(), comment: comment.join('\n') });
+  });
+  return out;
+}
+
+describe('retiring a document leaves a dated receipt', () => {
+  test('every `optional: true` entry carries a MEASURED date above it', () => {
+    const source = fs.readFileSync(HOOK, 'utf8');
+    const entries = optionalEntriesWithContext(source);
+    assert.ok(entries.length > 0, 'the fixture assumes at least one optional document exists');
+
+    const undated = entries.filter((e) => !DATE.test(e.comment));
+    assert.deepEqual(
+      undated.map((e) => `${HOOK}:${e.line} ${e.entry}`),
+      [],
+      'a document was made optional without a dated measurement — say what was measured and when',
+    );
+  });
+
+  test('the guard fires on an injected undated entry', () => {
+    // Discrimination: without this, a guard that found nothing would look identical to a guard
+    // that cannot see anything. Inject the exact shape it must catch.
+    const injected = [
+      "const DOCS = [",
+      "  { file: 'Honest.md' },",
+      "  // a comment with no date at all",
+      "  { file: 'Sneaky.md', optional: true },",
+      "];",
+    ].join('\n');
+    const found = optionalEntriesWithContext(injected).filter((e) => !DATE.test(e.comment));
+    assert.equal(found.length, 1, 'the parser must catch an undated optional entry');
+    assert.match(found[0].entry, /Sneaky\.md/);
+  });
+
+  test('a dated entry passes, so the guard is not simply always-red', () => {
+    const injected = [
+      "const DOCS = [",
+      "  // MEASURED 2026-08-27 against a real project: produced 8 of 9 promised documents.",
+      "  { file: 'Final_Summary.md', optional: true, expected: true },",
+      "];",
+    ].join('\n');
+    const found = optionalEntriesWithContext(injected).filter((e) => !DATE.test(e.comment));
+    assert.deepEqual(found, [], 'a dated entry must pass');
+  });
+});

package/tests/unit/quote-provenance.test.js

@@ -15,6 +15,10 @@ function runPython(source, args = []) {
   const result = spawnSync("python3", ["-c", source, ...args], {
     cwd: scriptsDir,
     encoding: "utf8",
+    // PYTHONDONTWRITEBYTECODE: a test run must not leave __pycache__/*.pyc inside templates/.
+    // Measured 2026-09-02: six .pyc files were signed into a package manifest and packed for
+    // publication because `npm test` spawned python3 here without it.
+    env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1" },
   });
   assert.equal(result.status, 0, result.stderr || result.stdout);
   return result.stdout.trim();

package/tests/unit/traceability-negative-fixture.test.js

@@ -230,14 +230,28 @@ describe('the per-feature traceability gap is a named negative fixture (PR-021)'
     const pkg = JSON.parse(read(PACKAGE_JSON));
     const unitFiles = fs.readdirSync(path.join(PACKAGE_ROOT, 'tests', 'unit'));
 
-    assert.deepEqual(unregisteredUnitTests(unitFiles, pkg.scripts['test:unit']), [],
-      'test:unit has a file on disk that it never executes');
-    assert.deepEqual(unregisteredUnitTests(unitFiles, pkg.scripts.test), [],
-      'test has a unit file on disk that it never executes');
+    // Registration is checked against the UNION of the declared lanes, not against `test:unit`
+    // alone. A unit file may legitimately live in a slower lane — `test:browser` drives a real
+    // browser and ran for over 6m40s inside the 9m20s `npm test`, pushing the whole suite against
+    // the 10-minute call ceiling (measured 2026-09-03). What must NEVER happen is a file that runs
+    // in NO lane, because that is how "we made the suite fast" turns into "we stopped testing it".
+    // So the union is what the guard accepts, and the lane list itself is asserted below: dropping
+    // `test:browser` from package.json turns this test red rather than silently shrinking coverage.
+    const LANES = ['test:unit', 'test:browser'];
+    for (const lane of LANES) {
+      assert.ok(typeof pkg.scripts[lane] === 'string' && pkg.scripts[lane].length > 0,
+        `lane ${lane} must exist in package.json — a lane that vanishes takes its tests with it`);
+    }
+    const unionScript = LANES.map((l) => pkg.scripts[l]).join(' ');
+
+    assert.deepEqual(unregisteredUnitTests(unitFiles, unionScript), [],
+      'a unit file on disk runs in NO declared lane');
+    assert.deepEqual(unregisteredUnitTests(unitFiles, `${pkg.scripts.test} ${pkg.scripts['test:browser']}`), [],
+      'a unit file runs in neither `test` nor `test:browser`');
 
     const probe = '__unregistered-probe.test.js';
     assert.deepEqual(
-      unregisteredUnitTests([...unitFiles, probe], pkg.scripts['test:unit']),
+      unregisteredUnitTests([...unitFiles, probe], unionScript),
       [probe],
       'the registration guard must fire on a real injected unregistered filename',
     );

package/tests/unit/verdict-vocabulary.test.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * «НЕ УСТАНОВЛЕНО» / «НЕ ИЗМЕРЕНО» mean REFUSAL here, and no future text may reuse them to mean
+ * "carry on".
+ *
+ * WHY A TEST AND NOT A STYLE NOTE. The toolkit already ships a three-valued verdict whose third
+ * value BLOCKS: `commands/feature.md` («`2` ПРОВЕРКА НЕ ВЫПОЛНЕНА, и это никогда не «всё чисто»»),
+ * `hooks/capture-source-path.cjs` («единственная дверь к коду 2»), `hooks/check-look-trace.cjs`.
+ * A proposal reviewed on 2026-09-02 reused the SAME words for a passing outcome — a row written by
+ * the author saying "not established, moving on". Two opposite meanings behind one phrase is worse
+ * than a new phrase: a reader who learned the blocking sense would read a pass as a refusal, and a
+ * reader who learned the passing sense would ignore a real block.
+ *
+ * The guard is deliberately narrow. It does NOT try to parse intent. It asserts that every file
+ * introducing these terms as a VERDICT also contains a non-zero exit, i.e. the vocabulary and the
+ * refusal live together. Prose that merely mentions the phrase in passing is not a verdict and is
+ * excluded by requiring the term to appear in a verdict-shaped context.
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const HOOKS = path.join(__dirname, '..', '..', 'templates', '.claude', 'hooks');
+const TERMS = /НЕ УСТАНОВЛЕНО|НЕ ИЗМЕРЕНО|NOT-ESTABLISHED/;
+// Three shapes of refusal, all of them real in this package and the first version of this predicate
+// only saw the first. `check-dangling-refs.cjs` computes its code in `main()` and calls
+// `process.exit(main(argv))`; the guard called that "cannot refuse" and fired on a hook that
+// refuses perfectly well. A guard whose predicate is narrower than the thing it guards produces
+// false accusations, which cost more trust than the misses they were meant to prevent.
+const NONZERO_EXIT = new RegExp([
+  'process\\.exit\\(\\s*[1-9]\\d*\\s*\\)',   // literal: process.exit(2)
+  'exitCode\\s*=\\s*[1-9]',                    // assigned: process.exitCode = 1
+  'process\\.exit\\(\\s*[A-Za-z_$]',           // computed: process.exit(main(argv))
+].join('|'));
+
+function hookFiles() {
+  return fs.readdirSync(HOOKS).filter((f) => f.endsWith('.cjs')).map((f) => path.join(HOOKS, f));
+}
+
+describe('the refusal vocabulary always sits next to a refusal', () => {
+  test('every hook using the terms can also exit non-zero', () => {
+    const offenders = [];
+    for (const file of hookFiles()) {
+      const src = fs.readFileSync(file, 'utf8');
+      if (!TERMS.test(src)) continue;
+      if (!NONZERO_EXIT.test(src)) offenders.push(path.basename(file));
+    }
+    assert.deepEqual(offenders, [],
+      'a hook speaks the refusal vocabulary but has no way to refuse — the words promise a block the code cannot deliver');
+  });
+
+  test('the guard fires on a hook that speaks the words without refusing', () => {
+    // Discrimination on the predicate itself: a guard that found nothing must be shown to be
+    // capable of finding something. Without this, an empty offender list is indistinguishable
+    // from a broken matcher.
+    const speaksButCannotRefuse = "// НЕ ИЗМЕРЕНО\nconsole.log('ok');\nprocess.exit(0);\n";
+    assert.equal(TERMS.test(speaksButCannotRefuse), true, 'the term matcher must see the phrase');
+    assert.equal(NONZERO_EXIT.test(speaksButCannotRefuse), false, 'exit(0) is not a refusal');
+  });
+
+  test('at least one hook really does carry both, so the guard is not vacuous', () => {
+    const both = hookFiles().filter((f) => {
+      const src = fs.readFileSync(f, 'utf8');
+      return TERMS.test(src) && NONZERO_EXIT.test(src);
+    });
+    assert.ok(both.length >= 2,
+      'the fixture assumes the toolkit really does use this vocabulary with real refusals');
+  });
+});