@dzhechkov/p-replicator 1.12.0 → 1.13.1

package/tests/unit/look-phase-contract.test.js

@@ -0,0 +1,231 @@
+'use strict';
+
+// Phase 0.5 (Source Product Profile) is a SECTION IN MARKDOWN that a model reads and executes —
+// there is no deterministic phase engine in this package. So the deterministic layer available for
+// the phase itself is the CONTENT of the three files that declare the sequence, and its ORDER.
+//
+// Why order is an assertion and not decoration: the phase's whole justification is WHERE it sits.
+// Phase 0 is skipped entirely by the `--from-docs` entry, so a look-capture placed inside Phase 0
+// would switch itself off for exactly the projects that arrive with someone else's documentation —
+// which are, more often than not, replications of someone else's product. Move the section back
+// inside Phase 0 and this file goes red; that is the point.
+//
+// The sequence is declared in THREE places and they must agree. Every assertion below is
+// DISCRIMINATING: remove what it names and it goes red.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const TPL = path.join(__dirname, '..', '..', 'templates', '.claude');
+const read = (...p) => fs.readFileSync(path.join(TPL, ...p), 'utf-8');
+
+const CMD = read('commands', 'replicate.md');
+const RULE = read('rules', 'replicate-pipeline.md');
+const AGENT = read('agents', 'replicate-coordinator.md');
+const CJM = read('skills', 'reverse-engineering-unicorn', 'modules', '025-cjm-prototype.md');
+
+const PROFILE_PATH = 'docs/source-product-profile.md';
+const CHECKER = 'check-look-trace.cjs';
+const CAPTURE = 'capture-source-path.cjs';
+/** The reasons a NAMED source may go uncaptured. Closed, because each names a DIFFERENT fix.
+ *  The last four arrived with the browser instrument for the `путь` axis. */
+const REASONS = ['no-browser-mcp', 'unreachable', 'auth-required', 'out-of-scope',
+  'no-browser', 'bot-protected', 'timeout', 'robots-disallowed'];
+
+describe('Phase 0.5 is pinned where it must live, in all three places that declare the sequence', () => {
+  test('P1 - ORDER: the Phase 0.5 section sits between the Phase 0 checkpoint and Phase 1', () => {
+    // The first of three independent ways this file goes red when the phase is switched off.
+    const checkpoint0 = CMD.indexOf('✅ PHASE 0: PRODUCT DISCOVERY');
+    const phase05 = CMD.indexOf('### Phase 0.5: SOURCE PRODUCT PROFILE');
+    const phase1 = CMD.indexOf('### Phase 1: PLANNING');
+
+    assert.ok(checkpoint0 > 0, 'replicate.md must still carry the Phase 0 checkpoint');
+    assert.ok(phase1 > 0, 'replicate.md must still carry Phase 1');
+    assert.ok(phase05 > 0, 'replicate.md must carry a Phase 0.5 section heading');
+    assert.ok(phase05 > checkpoint0,
+      'Phase 0.5 must come AFTER the Phase 0 checkpoint — placed before it, it would be part of '
+      + 'the optional phase and would vanish with it');
+    assert.ok(phase05 < phase1,
+      'Phase 0.5 must come BEFORE Phase 1 — Phase 1 promotes its FR-LOOK rows, so a phase running '
+      + 'after Phase 1 would have nothing to promote into');
+  });
+
+  test('P2 - the phase is MANDATORY and explicitly survives --from-docs', () => {
+    // The second independent way. This is the whole reason the phase is separate; a Phase 0.5 that
+    // the alternative entry also skipped would be the defect wearing the fix's clothes.
+    const head = CMD.slice(CMD.indexOf('### Phase 0.5'), CMD.indexOf('### Phase 1: PLANNING'));
+    assert.match(head, /обязательная|ВСЕГДА/,
+      'the section heading/lead must say the phase always runs');
+    assert.match(head, /--from-docs|--skip-discovery/,
+      'and it must name the entry that skips Phase 0, so the reader knows what it survives');
+
+    // And the alternative-entry section itself must say so, because a reader who lands there is
+    // reading the list of what runs and what does not.
+    const alt = CMD.slice(CMD.indexOf('### Modified pipeline flow when triggered'),
+      CMD.indexOf('### Three sub-paths'));
+    assert.ok(alt.length > 0, 'replicate.md must still carry the modified-flow list');
+    assert.match(alt, /\*\*Phase 0\.5\*\*/, 'the modified-flow list must name Phase 0.5');
+    assert.match(alt, /RUNS/,
+      'and must say it RUNS — a list that names the phase without saying so reads as a skip');
+
+    const altRule = RULE.slice(RULE.indexOf('### Behavior'), RULE.indexOf('### Three supported sub-paths'));
+    assert.ok(altRule.length > 0, 'the rule must still carry the alternative-entry behaviour list');
+    assert.match(altRule, /Phase 0\.5 STILL RUNS/i,
+      'the rule\'s behaviour list must say Phase 0.5 still runs on the --from-docs entry');
+  });
+
+  test('P3 - THREE PLACES agree on the sequence: command, rule, coordinator agent', () => {
+    // The third independent way. These three declare the phase order; a change to one alone is a
+    // second-generation lie — the pipeline documented as doing something two of its own files
+    // never mention.
+    assert.match(CMD, /Phase 0\.5/, 'replicate.md must declare Phase 0.5');
+    assert.match(RULE, /Phase 0\.5/, 'replicate-pipeline.md must declare Phase 0.5');
+    assert.match(AGENT, /Phase 0\.5|0\.5/, 'replicate-coordinator.md must declare Phase 0.5');
+
+    // The rule's own sequence diagram, not merely a mention somewhere in the file.
+    const seq = RULE.slice(RULE.indexOf('## Phase Sequence'), RULE.indexOf('## Skill Loading Protocol'));
+    assert.match(seq, /Phase 0\.5/, 'the Phase Sequence block itself must contain Phase 0.5');
+    assert.match(seq, /always|ALWAYS|всегда/,
+      'and must mark it as the one that always runs, next to the optional Phase 0');
+
+    // The coordinator's own numbered sequence.
+    assert.match(AGENT, /0\s*→\s*0\.5\s*→\s*1\s*→\s*2\s*→\s*3\s*→\s*4/,
+      'the coordinator must carry the full ordered sequence including 0.5');
+
+    // All three must name the SAME artifact, or "the profile" means three different files.
+    for (const [name, text] of [['replicate.md', CMD], ['replicate-pipeline.md', RULE],
+      ['replicate-coordinator.md', AGENT]]) {
+      assert.ok(text.includes(PROFILE_PATH), name + ' must name ' + PROFILE_PATH);
+    }
+  });
+
+  test('P4 - THREE outcomes are declared, and the third is the one with a closed reason list', () => {
+    const head = CMD.slice(CMD.indexOf('### Phase 0.5'), CMD.indexOf('### Phase 1: PLANNING'));
+    for (const outcome of ['СНЯТ', 'НЕ ИЗМЕРЕНО', 'ИСТОЧНИКА НЕТ']) {
+      assert.ok(head.includes(outcome), 'the phase must declare the outcome ' + outcome);
+    }
+    for (const reason of REASONS) {
+      assert.ok(head.includes(reason),
+        'the closed reason list must be spelled out in the phase: missing ' + reason);
+    }
+    // Two outcomes would be the defect: "captured" and "not captured" collapses "we looked and there
+    // is nothing to look at" into "we could not look".
+    assert.match(head, /ТРИ исхода|три исхода/,
+      'the phase must say there are THREE outcomes, not two');
+  });
+
+  test('P5 - the phase carries its own deterministic gate with three exit codes', () => {
+    const head = CMD.slice(CMD.indexOf('### Phase 0.5'), CMD.indexOf('### Phase 1: PLANNING'));
+    assert.ok(head.includes(CHECKER), 'the phase must name its checker: ' + CHECKER);
+    assert.match(head, /проверка НЕ выполнена|НЕ выполнена/,
+      'exit 2 must be described as "the check did not run", never as a pass');
+    assert.ok(fs.existsSync(path.join(TPL, 'hooks', CHECKER)),
+      'and the checker the text names must actually ship');
+  });
+
+  test('P6 - Phase 1 is told to promote FR-LOOK rows, or the seed has no destination', () => {
+    const phase1 = CMD.slice(CMD.indexOf('### Phase 1: PLANNING'),
+      CMD.indexOf('### Прерванный прогон'));
+    assert.match(phase1, /FR-LOOK/, 'Phase 1 must name the FR-LOOK family it promotes');
+    assert.match(phase1, /Specification\.md/, 'and the file it promotes them into');
+    assert.match(phase1, /FR-GROWTH/,
+      'both seed families are promoted by the same step — naming only one invites a second dialect');
+  });
+
+  test('P7 - the industry palette is a FALLBACK, not an equal branch', () => {
+    // The defect this feature removes: a pipeline whose job is to reproduce a product invented its
+    // palette from the industry. The table stays — it is the right answer when there is no source —
+    // but it must be reachable only through the "no source / not measured" states.
+    const table = CJM.indexOf('| Health/Fitness | Emerald/Teal');
+    assert.ok(table > 0, 'the industry table must still exist — it is the legitimate fallback');
+
+    const precedence = CJM.indexOf('Порядок приоритета');
+    assert.ok(precedence > 0, 'a precedence block must exist above the table');
+    assert.ok(precedence < table,
+      'the precedence block must come BEFORE the table: a rule stated after the table is a rule the '
+      + 'reader meets after already using it');
+
+    const between = CJM.slice(precedence, table);
+    assert.match(between, /СНЯТ/, 'the captured state must be named');
+    assert.match(between, /НЕ ИЗМЕРЕН/, 'the not-measured state must be named');
+    assert.match(between, /ФОЛБЭК|фолбэк/, 'the table must be labelled a fallback');
+
+    // The table's own caption must carry the condition, because a reader who jumps to the table
+    // sees the caption and nothing above it.
+    const caption = CJM.slice(CJM.lastIndexOf('**Design адаптация', table), table);
+    assert.match(caption, /ФОЛБЭК/,
+      'the table caption itself must say it is the fallback, not only the paragraph above it');
+  });
+
+  test('P8 - the capture skill is CALLED, never vendored into this package', () => {
+    // ADR-0001 + sources.json: clone-website has one canonical home, in its own package. Vendoring
+    // it here would add an eleventh skill to a contract pinned in four places.
+    const shipped = fs.readdirSync(path.join(TPL, 'skills'));
+    assert.ok(!shipped.includes('clone-website'),
+      'clone-website must NOT be vendored into templates/.claude/skills/: ' + shipped.join(', '));
+    assert.match(CMD, /skills-website-cloner/,
+      'the phase must name the canonical package it calls');
+    assert.match(RULE, /skills-website-cloner/,
+      'and the rule must too, so the reference cannot drift to a copy');
+
+    // Its absence must be a legitimate outcome, not a blocked pipeline.
+    const head = CMD.slice(CMD.indexOf('### Phase 0.5'), CMD.indexOf('### Phase 1: PLANNING'));
+    assert.match(head, /no-browser-mcp/,
+      'an unmet prerequisite must map to a named reason, not to a stalled run');
+  });
+
+  test('P10 - the `путь` axis has an INSTRUMENT, and both files name it', () => {
+    // The axis existed as a column from the first day of Phase 0.5; nothing could fill it. A column
+    // with no instrument is a promise the pipeline cannot keep, and it would quietly stay empty
+    // forever — which reads exactly like "this product has no path requirements".
+    assert.ok(fs.existsSync(path.join(TPL, 'hooks', CAPTURE)), 'the instrument must ship: ' + CAPTURE);
+    const head = CMD.slice(CMD.indexOf('### Phase 0.5'), CMD.indexOf('### Phase 1: PLANNING'));
+    assert.ok(head.includes(CAPTURE), 'the phase must name the instrument of its second axis');
+    assert.ok(RULE.includes(CAPTURE), 'and the rule must too, or the two describe different phases');
+
+    // Both axes must answer for themselves. One shared status would have to lie about one of them.
+    assert.match(head, /Статус съёмки \(путь\)/,
+      'the phase must carry the second axis\'s own status line');
+    assert.match(RULE, /Статус съёмки \(путь\)/, 'and so must the rule');
+
+    // The instrument is a PRECONDITION, not a dependency: the package ships zero of those.
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    assert.equal(pkg.dependencies, undefined,
+      'Playwright is an EXTERNAL prerequisite; putting it in dependencies would end the '
+      + 'zero-dependency contract for a utility that honestly works without it');
+    assert.match(head + RULE, /no-browser/,
+      'and its absence must map to a named reason, not to a stalled run');
+  });
+
+  test('P11 - the legality boundary lives in the RULE, not only in a report', () => {
+    // A boundary stated only where the finished work is described is a boundary nobody reads BEFORE
+    // crossing it. This one governs what may be captured at all, so it sits in the always-loaded
+    // rule, next to the instrument that could cross it.
+    const sec = RULE.slice(RULE.indexOf('### Phase 0.5'), RULE.indexOf('## Skill Loading Protocol'));
+    assert.ok(sec.length > 0, 'the rule must still carry its Phase 0.5 section');
+    assert.match(sec, /REGULARITIES|закономерн/i,
+      'the rule must say that REGULARITIES are what gets captured');
+    assert.match(sec, /VALUES|значени/i, 'and that VALUES are what does not');
+    assert.match(sec, /copyright/i, 'third-party CSS/DOM as copyrighted code must be named');
+    assert.match(sec, /trademark/i, 'the logo+name+colours-together trademark case must be named');
+    assert.match(sec, /robots\.txt/, 'reading robots.txt before a crawl must be named');
+    assert.match(sec, /FORBIDDEN|ЗАПРЕЩ/,
+      'circumvention and authentication must be refused in words, not merely discouraged');
+    assert.match(sec, /sx-ds2y8i|class names/i,
+      'and the brittleness rule — never class names — must be stated where the instrument is');
+  });
+
+  test('P9 - the hook inventory in the rule matches what ships (the count is not decorative)', () => {
+    const { COMPONENTS } = require(path.join(__dirname, '..', '..', 'src', 'utils.js'));
+    const n = Object.keys(COMPONENTS.hooks.items).length;
+    const m = RULE.match(/\*\*Hooks \((\d+) files/);
+    assert.ok(m, 'replicate-pipeline.md must state the hook file count');
+    assert.equal(Number(m[1]), n,
+      'the rule advertises a hook count the package does not ship — the stale "8 files" line was '
+      + 'exactly this defect, one generation earlier');
+    assert.ok(RULE.includes(CHECKER),
+      'and the new checker must be listed among the deliberately-invoked utilities');
+  });
+});

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

@@ -0,0 +1,300 @@
+'use strict';
+
+// The deterministic half of «отрицательный вывод структурно НЕВИДИМ для отчётного гейта». No new
+// always-loaded rule: the corpus budget is spent (measured 2026-09-01) and the owner refused to
+// raise the threshold, so the doctrine lives in `references/negative-results.md` — loaded on
+// demand — plus four lines in the SKILL that a reader must carry.
+//
+// THE DEFECT, and how it was established. NOT by grep: grep finds the vocabulary, not the
+// blindness. By TWIN TEST. `check_report_evidence.py` walked FROM THE LEDGER TO THE REPORT — for
+// each recorded fact, is it used and is its use honest. That direction is structurally blind to a
+// claim with NO SOURCE, and the strongest claim a research report makes has exactly that shape.
+//
+// MEASURED 2026-09-01 and RE-MEASURED by P1 below: two runs over ONE ledger, the reports differing
+// by EXACTLY one line of unsupported negative conclusion, produced BYTE-IDENTICAL --json output,
+// both exit 0. So an unbacked negation could neither raise nor lower the finding count.
+//
+// THE MECHANISM: «не встретилось» and «доказано, что нет» arrive in the same form and are decided
+// on identically. The first is a property of the SEARCH, the second of the WORLD — and only the
+// second justifies building a product on an empty niche.
+//
+// THE ACCEPTED CORRECTION (P6): a ceiling of «enumerable corpus declared exhaustive» is NOT enough,
+// because an exhaustive LIST does not prove an exhaustive SEARCH. Method, query coverage, sampling
+// refusals and the corpus's time boundary are part of the ceiling too.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const PKG = path.resolve(__dirname, '..', '..');
+const SKILL_DIR = path.join(PKG, 'templates', '.claude', 'skills', 'goap-research-ed25519');
+const GATE = path.join(SKILL_DIR, 'scripts', 'check_report_evidence.py');
+
+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' });
+    if (probe.status === 0) return bin;
+  }
+  return null;
+}
+const PY = python();
+
+/** A one-fact ledger built from the skill's own shipped fixture, so the test does not invent a
+ *  ledger shape the gate might not accept. */
+function ledger() {
+  const fixture = JSON.parse(read(path.join('templates', '.claude', 'skills',
+    'goap-research-ed25519', 'scripts', 'fixture_legacy_v2_fact.json')));
+  return JSON.stringify({ facts: [fixture.fact] });
+}
+
+/** Run the REAL gate over a report and return its parsed JSON verdict. */
+function gate(reportText) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-neg-')));
+  try {
+    const report = path.join(dir, 'report.md');
+    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 raw = (r.stdout || '').trim();
+    let parsed = null;
+    try { parsed = JSON.parse(raw); } catch { /* left null, asserted by the caller */ }
+    return { code: r.status, raw, json: parsed, err: r.stderr || '' };
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+const BASE = '# Report\n\nCompetitor A charges 10 USD per seat.\n';
+const NEGATIVE = 'Вывод: функции нет ни у одного из трёх конкурентов; ниша свободна.\n';
+
+/** The five fields the claim must carry, with the values a case needs. */
+function basis({
+  corpus = 'справочные центры A (14 стр.), B (9 стр.), C (11 стр.) — перечень в приложении A',
+  completeness = 'перечислимо и объявлено исчерпывающим',
+  method = 'полнотекстовый поиск по 6 запросам: «bulk export», «экспорт», «CSV»',
+  boundary = 'по состоянию на 2026-08-30',
+  implication = 'не встретилось',
+} = {}) {
+  const line = (label, value) => (value === null ? '' : label + ': ' + value + '\n');
+  return line('КОРПУС', corpus) + line('ПОЛНОТА', completeness) + line('СПОСОБ ПОИСКА', method)
+    + line('ГРАНИЦА КОРПУСА', boundary) + line('СЛЕДСТВИЕ', implication);
+}
+
+const kinds = (v) => (v.json ? v.json.findings.map((f) => f.kind) : ['(unparseable)']);
+
+describe('отрицательный вывод — the second direction of the report gate', () => {
+  test('P1 - THE twin test: the two reports no longer produce identical verdicts', {
+    skip: PY ? false : 'python3 is not available in this environment',
+  }, () => {
+    // The measurement that established the defect, re-run as the proof of the fix. Before the
+    // change these two were byte-identical and both exit 0; asserting the difference is what makes
+    // this a fix rather than a description of one.
+    const plain = gate(BASE);
+    const negated = gate(BASE + NEGATIVE);
+    assert.ok(plain.json, 'the gate must emit JSON: ' + plain.raw + plain.err);
+    assert.ok(negated.json, 'the gate must emit JSON: ' + negated.raw + negated.err);
+
+    assert.equal(plain.code, 0, 'the report WITHOUT the negative conclusion is still clean: ' + plain.raw);
+    assert.equal(negated.code, 1, 'the unsupported negative conclusion must now be a finding');
+    assert.notDeepEqual(plain.json, negated.json,
+      'one added line of unsupported negation must change the verdict — identical output here IS '
+      + 'the defect, and it is what was measured on 2026-09-01');
+    assert.deepEqual(kinds(negated), ['NEGATIVE_CONCLUSION_WITHOUT_BASIS']);
+  });
+
+  test('P2 - the finding NAMES the conclusion and says which fields are missing', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    const v = gate(BASE + NEGATIVE);
+    const f = v.json.findings[0];
+    assert.match(f.claim, /ниша свободна/, 'the claim itself must be quoted back');
+    for (const field of ['КОРПУС', 'ПОЛНОТА', 'СПОСОБ ПОИСКА', 'ГРАНИЦА КОРПУСА', 'СЛЕДСТВИЕ']) {
+      assert.ok(f.detail.includes(field), 'the missing field must be named: ' + field);
+    }
+    // The mechanism, in words — the sentence a reader has to carry away.
+    assert.match(f.detail, /property of the\s+SEARCH/);
+  });
+
+  test('P3 - the SAME conclusion WITH its full basis passes', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    const v = gate(BASE + NEGATIVE + '\n' + basis());
+    assert.equal(v.code, 0, v.raw);
+    assert.deepEqual(kinds(v), []);
+  });
+
+  test('P4 - each of the five fields is load-bearing on its own', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // Without this the block could be satisfied by writing four of the five and the fifth would be
+    // decoration — which is how a required field quietly becomes optional.
+    for (const field of ['corpus', 'completeness', 'method', 'boundary', 'implication']) {
+      const v = gate(BASE + NEGATIVE + '\n' + basis({ [field]: null }));
+      assert.equal(v.code, 1, 'dropping ' + field + ' must fire: ' + v.raw);
+      assert.deepEqual(kinds(v), ['NEGATIVE_CONCLUSION_WITHOUT_BASIS'], field);
+    }
+  });
+
+  test('P5 - ПОЛНОТА and СЛЕДСТВИЕ are CLOSED vocabularies', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // An open field here collects a word that sounds thorough and commits to nothing.
+    const badCompleteness = gate(BASE + NEGATIVE + '\n' + basis({ completeness: 'достаточная' }));
+    assert.equal(badCompleteness.code, 1, badCompleteness.raw);
+    assert.deepEqual(kinds(badCompleteness), ['NEGATIVE_COMPLETENESS_UNRECOGNISED']);
+
+    const badImplication = gate(BASE + NEGATIVE + '\n' + basis({ implication: 'скорее всего нет' }));
+    assert.equal(badImplication.code, 1, badImplication.raw);
+    assert.deepEqual(kinds(badImplication), ['NEGATIVE_IMPLICATION_UNRECOGNISED']);
+  });
+
+  test('P6 - THE CEILING: a sample can never license «намеренно отсутствует»', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // The accepted correction, and the reason this record was worth shipping at all: an exhaustive
+    // LIST does not prove an exhaustive SEARCH, so absence in part of a corpus is absence from the
+    // SEARCH and not from the world.
+    for (const completeness of ['выборка — 34 из ~120 страниц', 'неизвестна']) {
+      const v = gate(BASE + NEGATIVE + '\n'
+        + basis({ completeness, implication: 'намеренно отсутствует' }));
+      assert.equal(v.code, 1, completeness + ': ' + v.raw);
+      assert.deepEqual(kinds(v), ['NEGATIVE_CLAIM_EXCEEDS_ITS_CEILING'], completeness);
+      assert.match(v.json.findings[0].detail, /absence from the\s+SEARCH/);
+    }
+
+    // The weaker implication on the same sample is fine — the point is a CEILING, not a ban.
+    const ok = gate(BASE + NEGATIVE + '\n'
+      + basis({ completeness: 'выборка — 34 из ~120 страниц', implication: 'не встретилось' }));
+    assert.equal(ok.code, 0, ok.raw);
+
+    // And the strong implication on an exhaustive corpus is exactly what the form is FOR.
+    const strong = gate(BASE + NEGATIVE + '\n' + basis({ implication: 'намеренно отсутствует' }));
+    assert.equal(strong.code, 0, strong.raw);
+  });
+
+  test('P7 - detail after the closed word is allowed, not punished', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // «выборка — 34 из ~120 страниц» says how big the sample is, which is strictly better than the
+    // bare word. Refusing it would teach authors to write less.
+    const v = gate(BASE + NEGATIVE + '\n' + basis({
+      completeness: 'выборка, 34 из ~120 страниц; отказ выборки: раздел для партнёров под входом',
+      implication: 'не встретилось — ни на одной прочитанной странице',
+    }));
+    assert.equal(v.code, 0, v.raw);
+  });
+
+  test('P8 - ordinary prose is NOT a negative universal claim', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // An eager guard is not a stricter guard; it is a guard people delete. `there is no` alone
+    // fires on ordinary sentences, so the patterns require the UNIVERSAL — which is precisely what
+    // makes the claim strong enough to need a basis.
+    const innocent = BASE
+      + 'There is no cache in the current design, and no timeline yet.\n'
+      + 'Нет данных за июль. Функция не описана в этом разделе.\n';
+    const v = gate(innocent);
+    assert.equal(v.code, 0, 'ordinary negation must not fire: ' + v.raw);
+    assert.deepEqual(kinds(v), []);
+  });
+
+  test('P9 - one sentence produces ONE finding, however many patterns it matches', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // The measured sentence matches two patterns at once («ни у одного» and «ниша свободна»).
+    // Counting it twice would inflate exactly the number the twin test compares.
+    const v = gate(BASE + NEGATIVE);
+    assert.equal(v.json.findings.length, 1, JSON.stringify(kinds(v)));
+  });
+
+  test('P10 - the basis in the appendix does not license a claim on page 2', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // A window, not a document: a block far away warns nobody reading the sentence.
+    const far = BASE + NEGATIVE + '\n' + 'x'.repeat(2000) + '\n' + basis();
+    const v = gate(far);
+    assert.equal(v.code, 1, v.raw);
+    assert.deepEqual(kinds(v), ['NEGATIVE_CONCLUSION_WITHOUT_BASIS']);
+  });
+
+  test('P11 - the gate still refuses inputs it cannot read', {
+    skip: PY ? false : 'python3 is not available',
+  }, () => {
+    // The pre-existing contract must survive the addition: exit 2 for an unreadable input, never 0.
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-neg2-')));
+    try {
+      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' });
+      assert.equal(r.status, 2, 'a gate that could not read its inputs has cleared nothing');
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+});
+
+describe('the doctrine is reachable, and the honest boundary is stated', () => {
+  test('P12 - the reference carries the form, the measurement and the ceiling', () => {
+    // It lives in references/ — loaded on demand — because the always-loaded corpus is spent. That
+    // placement is only legitimate if the SKILL points at it, which P13 asserts.
+    const ref = read(path.join('templates', '.claude', 'skills', 'goap-research-ed25519',
+      'references', 'negative-results.md'));
+    for (const field of ['КОРПУС', 'ПОЛНОТА', 'СПОСОБ ПОИСКА', 'ГРАНИЦА КОРПУСА', 'СЛЕДСТВИЕ']) {
+      assert.ok(ref.includes(field), 'the form must be spelled out: ' + field);
+    }
+    assert.match(ref, /ТВИН-ТЕСТОМ, а не грепом/, 'how the defect was established must survive');
+    assert.match(ref, /исчерпывающий ПЕРЕЧЕНЬ не доказывает\s*\n?исчерпывающего ПОИСКА/,
+      'the accepted correction is the load-bearing half and must not be lost');
+    assert.match(ref, /[Кк]арта\s+сайта/,
+      'the wrong-corpus case must stay: it is what the check deliberately cannot decide');
+  });
+
+  test('P13 - the SKILL names the obligation and points at the long form', () => {
+    const skill = read(path.join('templates', '.claude', 'skills', 'goap-research-ed25519', 'SKILL.md'));
+    assert.match(skill, /A NEGATIVE conclusion .* MUST carry its own basis/,
+      'the duty must read as a duty in the file that is actually loaded');
+    assert.match(skill, /references\/negative-results\.md/,
+      'a doctrine nobody can reach is a doctrine nobody applies');
+    assert.match(skill, /property of the SEARCH/,
+      'the distinguishing sentence must be carried, not deferred');
+  });
+
+  test('P14 - the gate PRINTS what it cannot decide', () => {
+    // Naming the corpus is enforceable; judging its fitness for the question is not. A gate that
+    // stayed silent about that would sell the stronger guarantee it does not have.
+    const src = read(path.join('templates', '.claude', 'skills', 'goap-research-ed25519',
+      'scripts', 'check_report_evidence.py'));
+    assert.match(src, /never that the named corpus fits the question/,
+      'the honest scope must be in the OUTPUT, not only in a comment');
+    assert.match(src, /def scan_negative_conclusions/, 'the second direction must exist as its own scan');
+  });
+
+  test('P15 - the mutation registry carries this feature\'s guards', () => {
+    const registry = JSON.parse(read('test/mutation-registry.json'));
+    const gateFile = 'templates/.claude/skills/goap-research-ed25519/scripts/check_report_evidence.py';
+    const expected = {
+      'negative-conclusion-is-seen-at-all': gateFile,
+      'negative-ceiling-blocks-the-strong-claim': gateFile,
+      'negative-every-field-is-load-bearing': gateFile,
+      'negative-skill-carries-the-obligation':
+        'templates/.claude/skills/goap-research-ed25519/SKILL.md',
+    };
+    for (const [id, file] of Object.entries(expected)) {
+      const entry = registry.entries.find((e) => e.id === id);
+      assert.ok(entry, 'missing targeted mutation id ' + id);
+      assert.equal(entry.file, file, id + ' mutates the wrong surface');
+      assert.ok(entry.property && entry.property.length > 40,
+        id + ' needs a behavioral property, not a cosmetic label');
+      assert.ok(entry.mutation && entry.mutation.find && entry.mutation.replace,
+        id + ' needs a real source mutation');
+      assert.ok(Number.isInteger(entry.minFailing) && entry.minFailing >= 1,
+        id + ' must require at least one failing test');
+      assert.equal(read(entry.file).split(entry.mutation.find).length - 1, 1,
+        id + ': mutation anchor must occur exactly once');
+    }
+  });
+});

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

@@ -0,0 +1,122 @@
+const assert = require("node:assert/strict");
+const { mkdtempSync, readFileSync, rmSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const test = require("node:test");
+
+const packageRoot = path.resolve(__dirname, "../..");
+const scriptsDir = path.join(
+  packageRoot,
+  "templates/.claude/skills/goap-research-ed25519/scripts",
+);
+
+function runPython(source, args = []) {
+  const result = spawnSync("python3", ["-c", source, ...args], {
+    cwd: scriptsDir,
+    encoding: "utf8",
+  });
+  assert.equal(result.status, 0, result.stderr || result.stdout);
+  return result.stdout.trim();
+}
+
+test("refuses verbatim for excerpt not hash-bound to its FetchRecord", () => {
+  const verdict = runPython(`
+import hashlib
+import evidence_fetch as ef
+import quote_provenance as qp
+body = b"a phrase captured from source bytes"
+record = ef.FetchRecord(url="https://example.test", final_url="https://example.test", status=200,
+    sha256_body=hashlib.sha256(body).hexdigest(), bytes_len=len(body),
+    fetched_at="2026-09-02T00:00:00Z", content_type="text/plain; charset=utf-8",
+    witness=ef._FETCH_WITNESS)
+captured = qp.capture_excerpt(body, "phrase captured from source bytes", record)
+captured["excerpt"] = "author-forged phrase captured from source bytes"
+fact = {"acquisition": "raw-fetch", "source_url": record.final_url,
+        "sha256_body": record.sha256_body}
+print(qp.verify_verbatim("phrase captured from source bytes", captured, fact))
+`);
+  assert.equal(verdict, "hash-mismatch");
+});
+
+test("verbatim policy accepts normalized exact match and rejects overlap paraphrase", () => {
+  const verdicts = runPython(`
+import hashlib
+import quote_provenance as qp
+excerpt = 'The source says “iron\\u00a0status & recovery” — exactly.'
+record = {"excerpt": excerpt, "content_type": "text/html; charset=utf-8",
+          "source_url": "https://example.test", "sha256_body": "a" * 64,
+          "sha256_excerpt": hashlib.sha256(excerpt.encode()).hexdigest()}
+fact = {"acquisition": "raw-fetch", "source_url": "https://example.test", "sha256_body": "a" * 64}
+print(qp.verify_verbatim('iron status & recovery" - exactly', record, fact))
+print(qp.verify_verbatim("iron status recovery was described exactly", record, fact))
+`);
+  assert.deepEqual(verdicts.split("\n"), ["verbatim-confirmed", "not-in-excerpt"]);
+});
+
+test("non-text body triggers named verbatim refusal", () => {
+  const refusal = runPython(`
+import hashlib
+import evidence_fetch as ef
+import quote_provenance as qp
+body = b"%PDF-1.7 quoted phrase in a binary body"
+record = ef.FetchRecord(url="https://example.test/file.pdf", final_url="https://example.test/file.pdf",
+    status=200, sha256_body=hashlib.sha256(body).hexdigest(), bytes_len=len(body),
+    fetched_at="2026-09-02T00:00:00Z", content_type="application/pdf", witness=ef._FETCH_WITNESS)
+try:
+    qp.capture_excerpt(body, "quoted phrase in a binary body", record)
+except qp.ExcerptCaptureRefused as exc:
+    print(str(exc))
+else:
+    raise AssertionError("PDF body unexpectedly produced an excerpt")
+`);
+  assert.match(refusal, /non-text body/);
+  assert.match(refusal, /application\/pdf/);
+});
+
+test("capture run writes gitignore that excludes excerpts", () => {
+  const temporary = mkdtempSync(path.join(tmpdir(), "quote-provenance-"));
+  try {
+    const init = spawnSync("git", ["init", "--quiet", temporary], { encoding: "utf8" });
+    assert.equal(init.status, 0, init.stderr);
+    const store = path.join(temporary, "evidence_excerpts");
+    const excerptId = runPython(`
+import hashlib
+import sys
+import evidence_fetch as ef
+import quote_provenance as qp
+body = b"captured phrase from a fetched source"
+record = ef.FetchRecord(url="https://example.test", final_url="https://example.test", status=200,
+    sha256_body=hashlib.sha256(body).hexdigest(), bytes_len=len(body),
+    fetched_at="2026-09-02T00:00:00Z", content_type="text/plain; charset=utf-8",
+    witness=ef._FETCH_WITNESS)
+captured = qp.capture_excerpt(body, "captured phrase from a fetched source", record)
+qp.write_excerpt(sys.argv[1], captured)
+print(captured["excerpt_id"])
+`, [store]);
+    assert.equal(readFileSync(path.join(store, ".gitignore"), "utf8"), "*\n");
+    const ignored = spawnSync(
+      "git",
+      ["-C", temporary, "check-ignore", "--quiet", path.join("evidence_excerpts", excerptId)],
+      { encoding: "utf8" },
+    );
+    assert.equal(ignored.status, 0, ignored.stderr || "captured excerpt was not ignored");
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+});
+
+test("unknown or absent acquisition method fails closed", () => {
+  const states = runPython(`
+import hashlib
+import quote_provenance as qp
+text = "a captured phrase long enough to be checked"
+record = {"excerpt": text, "content_type": "text/plain; charset=utf-8",
+          "source_url": "https://example.test", "sha256_body": "b" * 64,
+          "sha256_excerpt": hashlib.sha256(text.encode()).hexdigest()}
+for method in (None, "Raw-Fetch", "webfetch"):
+    fact = {"acquisition": method, "source_url": "https://example.test", "sha256_body": "b" * 64}
+    print(qp.verify_verbatim(text, record, fact))
+`);
+  assert.deepEqual(states.split("\n"), ["method-unknown", "method-unknown", "method-unknown"]);
+});