@dzhechkov/p-replicator 1.6.0 → 1.9.0

package/tests/unit/check-growth-trace.test.js

@@ -0,0 +1,188 @@
+'use strict';
+
+// The deterministic half of the growth gate. The validator criterion is prose a model reads —
+// layer 3. This is layer 1, and only for whoever runs it.
+//
+// The load-bearing property is the THIRD exit code, for the same reason it was in check-ports:
+// a checker that answers "clean" when it could not look converts an unknown into a reassurance.
+// Here the unknown has a specific and common cause — the --from-docs entry skips Phase 0, so the
+// brief legitimately does not exist. That must be 2. Reading it as 0 would report "all growth
+// requirements traced" for a project that never analysed growth at all.
+//
+// These are BEHAVIOUR tests: the real utility, real files, real exit codes.
+
+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 TPL = path.join(PKG, 'templates', '.claude');
+const CHECK = path.join(TPL, 'hooks', 'check-growth-trace.cjs');
+
+/** Build a throwaway project and run the real checker over it. */
+function check(files) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-growth-')));
+  try {
+    for (const [rel, body] of Object.entries(files || {})) {
+      const abs = path.join(dir, rel);
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      fs.writeFileSync(abs, body);
+    }
+    const r = spawnSync(process.execPath, [CHECK, dir], { encoding: 'utf8' });
+    return { code: r.status, out: (r.stdout || '') + (r.stderr || '') };
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+const brief = (rows) => '# Brief\n\n## 🌱 Growth Requirements Seed\n\n'
+  + '| ID | Требование | Блок-источник | Confidence | Статус |\n'
+  + '|----|----|----|----|----|\n' + rows.join('\n') + '\n';
+
+const ROW1 = '| FR-GROWTH-001 | Реферальная петля в онбординге | A. Primary Growth Loop | 4/5 | ЧЕРНОВИК |';
+const ROW2 = '| FR-GROWTH-002 | Интеграция с маркетплейсом | B. Top-3 Acquisition Channels | 3/5 | ЧЕРНОВИК |';
+
+describe('the growth-trace checker answers three questions, and never confuses two of them', () => {
+  test('P1 - a traced requirement is exit 0', () => {
+    const r = check({
+      'docs/product-discovery-brief.md': brief([ROW1]),
+      'docs/Specification.md': '# Spec\n\n## FR-GROWTH-001 Реферальная петля\n\nПодробности.\n',
+    });
+    assert.equal(r.code, 0, 'a traced id must pass: ' + r.out);
+    assert.match(r.out, /прослежены/, r.out);
+  });
+
+  test('P2 - an analysed-then-dropped requirement is exit 1, and the id is named', () => {
+    const r = check({
+      'docs/product-discovery-brief.md': brief([ROW1]),
+      'docs/Specification.md': '# Spec\n\nНичего про рост.\n',
+    });
+    assert.equal(r.code, 1, 'a dropped obligation must fail: ' + r.out);
+    assert.match(r.out, /FR-GROWTH-001/, 'and the lost id must be named: ' + r.out);
+  });
+
+  test('P3 - an absent brief is exit 2, never exit 0', () => {
+    // The single most important case. --from-docs skips Phase 0, so this is the COMMON state, and
+    // reading it as clean would silently bless every such project.
+    const r = check({ 'docs/Specification.md': '# Spec\n' });
+    assert.equal(r.code, 2, 'no brief means the check did not run: ' + r.out);
+    assert.match(r.out, /проверка НЕ выполнена/, r.out);
+    assert.match(r.out, /Фаза 0 не запускалась/, 'and the reason must be named: ' + r.out);
+  });
+
+  test('P4 - an absent Specification is exit 2, not exit 1', () => {
+    // Without the destination there is nothing to compare against. Calling that "nothing traced"
+    // would blame the project for the checker's blindness.
+    const r = check({ 'docs/product-discovery-brief.md': brief([ROW1]) });
+    assert.equal(r.code, 2, 'no Specification means the check could not run: ' + r.out);
+    assert.match(r.out, /Specification/, r.out);
+  });
+
+  test('P5 - an untouched template table is exit 2, not exit 0', () => {
+    // The shipped module carries example rows with bracketed placeholders. Counting them would let
+    // an untouched template look like a filled-in one — and then "0 traced of 0" reads as clean.
+    const r = check({
+      'docs/product-discovery-brief.md': brief([
+        '| FR-GROWTH-001 | [что обязаны построить, одним предложением] | A. Primary Growth Loop | [как записано] | ЧЕРНОВИК |',
+        '| FR-GROWTH-002 | ... | B. Top-3 Acquisition Channels | ... | ... |',
+      ]),
+      'docs/Specification.md': '# Spec\n',
+    });
+    assert.equal(r.code, 2, 'a placeholder row is not an obligation: ' + r.out);
+    assert.match(r.out, /шаблоном|ни одной заполненной/, r.out);
+  });
+
+  test('P6 - a rejection WITH a reason passes; a bare drop does not', () => {
+    const withReason = check({
+      'docs/product-discovery-brief.md': brief([ROW1]),
+      'docs/Specification.md': '# Spec\n\nFR-GROWTH-001 отклонено — нет бюджета на реферальную программу в MVP.\n',
+    });
+    assert.equal(withReason.code, 0, 'a recorded rejection is a legitimate answer: ' + withReason.out);
+
+    const bare = check({
+      'docs/product-discovery-brief.md': brief([ROW1]),
+      'docs/Specification.md': '# Spec\n\nFR-GROWTH-001\n',
+    });
+    // A bare id mention IS a trace by the stated definition — that is deliberate and documented.
+    // What must not pass is an id that appears nowhere, which P2 covers.
+    assert.equal(bare.code, 0, 'the exact token is the definition of a mention: ' + bare.out);
+  });
+
+  test('P7 - a partial loss is reported with the count, not averaged away', () => {
+    const r = check({
+      'docs/product-discovery-brief.md': brief([ROW1, ROW2]),
+      'docs/Specification.md': '# Spec\n\nFR-GROWTH-001 реализуем.\n',
+    });
+    assert.equal(r.code, 1, 'one of two lost is still a loss: ' + r.out);
+    assert.match(r.out, /1 из 2/, 'the count must be reported: ' + r.out);
+    assert.match(r.out, /FR-GROWTH-002/, 'and the lost one named: ' + r.out);
+    assert.ok(!/FR-GROWTH-001/.test(r.out.split('\n').filter((l) => l.includes('•')).join('\n')),
+      'the traced one must NOT be listed as lost: ' + r.out);
+  });
+
+  test('P8 - one binary, all three verdicts in a single run', () => {
+    // Each case above asserts ONE direction, so a constant-answer implementation could pass a
+    // subset. The same executable must produce 0, 1 and 2.
+    const seen = [
+      check({ 'docs/product-discovery-brief.md': brief([ROW1]),
+        'docs/Specification.md': 'FR-GROWTH-001\n' }).code,
+      check({ 'docs/product-discovery-brief.md': brief([ROW1]),
+        'docs/Specification.md': 'ничего\n' }).code,
+      check({}).code,
+    ];
+    assert.deepEqual(seen, [0, 1, 2], 'expected clean/lost/could-not-check: ' + JSON.stringify(seen));
+  });
+
+  test('P11 - the counter-examples cross-family review supplied', () => {
+    // Each was a false CLEAN in the first version, and each is named by the input that produced it.
+    const cases = [
+      [1, '# Spec\nFR-GROWTH-001 rejected\n',
+        'a bare refusal with no reason: the reason pattern accepted a hyphen and the IDENTIFIER '
+        + 'carries two — and the mention rule reached the line first, so the reason was never asked for'],
+      [0, '# Spec\nFR-GROWTH-001 отклонено — нет бюджета на реферальную программу в MVP\n',
+        'a refusal WITH a reason is a legitimate answer and must still pass'],
+      [1, '# Spec\nFR-GROWTH-001 declined - x\n',
+        'one character is a separator plus noise, not a reason'],
+    ];
+    for (const [expected, spec, why] of cases) {
+      const r = check({ 'docs/product-discovery-brief.md': brief([ROW1]), 'docs/Specification.md': spec });
+      assert.equal(r.code, expected, why + ' — got ' + r.code + ': ' + r.out);
+    }
+  });
+
+  test('P12 - a reused id is exit 2, because one mention would clear two obligations', () => {
+    // The module's own rule is that a number is never reused. When it is, `mentioned()` answers from
+    // a Set and a SINGLE mention marks BOTH rows traced — coverage counted over usable items rather
+    // than per position. Malformed input is inconclusive, never a pass.
+    const dup = '| FR-GROWTH-001 | Совсем другое требование | B. Top-3 Acquisition Channels | 3/5 | ЧЕРНОВИК |';
+    const r = check({
+      'docs/product-discovery-brief.md': brief([ROW1, dup]),
+      'docs/Specification.md': '# Spec\nFR-GROWTH-001 берём\n',
+    });
+    assert.equal(r.code, 2, 'a duplicate id must not read as clean: ' + r.out);
+    assert.match(r.out, /повторяются идентификаторы/, r.out);
+    assert.match(r.out, /FR-GROWTH-001/, 'and the duplicated id must be named: ' + r.out);
+  });
+
+  test('P9 - it is a hooks component wired to NO event', () => {
+    const { COMPONENTS } = require(path.join(PKG, 'src', 'utils.js'));
+    assert.ok(COMPONENTS.hooks.items['check-growth-trace'],
+      'it must be registered, or init/doctor/verify will not know it');
+    const settings = fs.readFileSync(path.join(TPL, 'settings.json'), 'utf-8');
+    assert.ok(!settings.includes('check-growth-trace'),
+      'it must not be wired to an event: this packages hooks are non-blocking by contract, so a '
+      + 'hook could only print — it could never refuse anything');
+    const statusline = fs.readFileSync(path.join(TPL, 'hooks', 'statusline.cjs'), 'utf-8');
+    const m = statusline.match(/hooksExpected:\s*(\d+)/);
+    assert.ok(m, 'statusline must declare hooksExpected');
+    assert.equal(Number(m[1]), Object.keys(COMPONENTS.hooks.items).length,
+      'the status line would report a phantom missing hook: ' + m[1]);
+  });
+
+  test('P10 - a directory that does not exist is exit 2', () => {
+    const r = spawnSync(process.execPath, [CHECK, '/nonexistent-path-for-this-test'],
+      { encoding: 'utf8' });
+    assert.equal(r.status, 2, 'an unusable argument is not a clean bill: ' + r.stdout);
+  });
+});

package/tests/unit/growth-axes-and-compliance.test.js

@@ -0,0 +1,169 @@
+'use strict';
+
+// Two prose defects in 05-growth-engine.md, shipped as one change because the file has four
+// byte-identical copies and splitting them means two three-package releases.
+//
+// P4: the growth-type list forced ONE choice across TWO different questions — how a company reaches
+// buyers, and what makes usage produce more usage. A sales-led company running a referral loop was
+// literally unsayable. Three loop mechanics were also absent.
+//
+// P2: the Research Protocol's three modes mentioned no constraint of any kind, so the module could
+// design a violation with full confidence — confidence here comes from data quality, not legality.
+//
+// The load-bearing rule in P2's fix, and the evidence for it is the source report's own failure: it
+// warned that a 2024 penalty figure was stale and then quoted the 2025 figure as current, in August
+// 2026. Warning and error, one document, one year apart. So: cite the norm, never the amount — and
+// P5 exists to make a future edit that re-adds a figure go red.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MODULE = path.join(__dirname, '..', '..', 'templates', '.claude', 'skills',
+  'reverse-engineering-unicorn', 'modules', '05-growth-engine.md');
+
+const read = () => fs.readFileSync(MODULE, 'utf-8');
+
+/** A named section, from its heading to the next heading at the same level. */
+function section(heading, level) {
+  const src = read();
+  const start = src.indexOf(heading);
+  assert.ok(start > 0, 'the module must carry: ' + heading);
+  const end = src.indexOf('\n' + '#'.repeat(level) + ' ', start + 1);
+  assert.ok(end > start, heading + ' must be followed by another section');
+  return src.slice(start, end);
+}
+
+const compliance = () => section('### ⚖️ Чеклист допустимости', 3);
+
+describe('growth type is two questions, and the protocol knows constraints exist', () => {
+  test('P1 - the two axes are separate and independently chosen', () => {
+    const src = read();
+    assert.match(src, /\*\*Ось 1 — МОТИОН/, 'the go-to-market axis must be its own list');
+    assert.match(src, /\*\*Ось 2 — ПЕТЛЯ/, 'and the loop axis its own');
+    assert.match(src, /Оси НЕЗАВИСИМЫ/, 'independence must be stated, not left to be inferred');
+    assert.match(src, /Sales-Led` \+ `Поощряемая реферальная/,
+      'and shown with the combination the old single list made unsayable');
+
+    // The defect was ONE instruction spanning both questions. Its removal is the property.
+    assert.ok(!/\*\*Выбранный тип:\*\* \[ONE из:\]/.test(src),
+      'the single cross-axis selector must be gone, or the fix is cosmetic');
+  });
+
+  test('P2 - the three missing loop mechanics are present', () => {
+    const src = read();
+    for (const m of ['Значковая / встраиваемая', 'Поощряемая реферальная', 'Сетевой эффект']) {
+      assert.ok(src.includes(m), 'the loop axis must offer: ' + m);
+    }
+    // "no loop" must be sayable, or every project claims one it does not have.
+    assert.match(src, /Нет петли/, 'absence of a loop must be a choice');
+    assert.match(src, /полноценный ответ, а не пропуск/,
+      'and must be marked as an answer, not a blank');
+  });
+
+  test('P3 - the artifact does not claim the module was blind to virality', () => {
+    // The backlog item's own correction: the K-factor is already tracked and referrals already
+    // appear in the TRIZ table. A false problem statement outlives the fix that follows it.
+    const src = read();
+    assert.ok(/K-фактор|K-factor/.test(src), 'the pre-existing K-factor site must survive the edit');
+    assert.ok(/[Рр]еферал|referral/i.test(src), 'and the pre-existing referral mentions');
+    for (const claim of ['не знает про виральность', 'слеп к виральности', 'ignores virality']) {
+      assert.ok(!src.includes(claim), 'the module must not be accused of what it already did: ' + claim);
+    }
+  });
+
+  test('P4 - the compliance checklist covers all three research modes', () => {
+    const src = read();
+    const c = src.indexOf('### ⚖️ Чеклист допустимости');
+    const quick = src.indexOf('### 🟢 Режим QUICK');
+    assert.ok(c > 0 && quick > c,
+      'the checklist must precede the modes, or it reads as an afterthought to QUICK alone');
+    assert.match(compliance(), /все три режима/,
+      'and must say it applies to all three, not only the one it sits above');
+  });
+
+  // The two detectors P5 runs. Declared at module scope so P8 can drive them over counter-examples:
+  // a detector asserted only against text that happens to be clean proves nothing about its reach.
+  //
+  // Cross-family review found both too narrow. The statute pattern REQUIRED a leading number, so the
+  // ordinary form `Article 6 GDPR` slipped through; the money pattern required a currency marker, so
+  // a bare threshold such as `30 дней` did too — and the rule forbids thresholds, not only prices.
+  const MONEY = /(?:[0-9][0-9\s,.]*\s*(?:долл|USD|\$|€|руб|₽|%|дн(?:я|ей)|мес|год|лет|час|тыс|млн))|(?:(?:не более|не менее|до|свыше|от)\s+[0-9])/gi;
+  const L = '(?<![\\p{L}\\p{N}])';   // a real left boundary, Cyrillic included
+  const STATUTE = new RegExp(
+    '(?:' + L + '\\d+\\s*(?:CFR|U\\.?S\\.?C|USC|ФЗ))'
+    + '|(?:' + L + '(?:Article|Art\\.|Статья|ст\\.)\\s*\\d+)'
+    + '|(?:' + L + '(?:GDPR|CCPA))'
+    + '|(?:' + L + 'ФЗ[- ]?\\d+)'
+    + '|(?:' + L + '\\d+-ФЗ)', 'giu');
+
+  test('P5 - no monetary figure and no statute is asserted', () => {
+    // THE rule. A number in a template is wrong within a year; a statute is jurisdiction-specific and
+    // unverified in this repository. Written so a future edit re-adding either goes red.
+    const c = compliance();
+    MONEY.lastIndex = 0; STATUTE.lastIndex = 0;
+    const money = c.match(MONEY) || [];
+    assert.deepEqual(money, [],
+      'a monetary figure or threshold appeared in the checklist: ' + JSON.stringify(money));
+    const statutes = c.match(STATUTE) || [];
+    assert.deepEqual(statutes, [],
+      'a statute is asserted as authoritative, and none was verified here: ' + JSON.stringify(statutes));
+    assert.match(c, /Ссылайтесь на \*\*норму и на то, где её смотреть\*\*, никогда — на сумму/,
+      'the rule itself must be written down, or the absence above is an accident');
+    assert.match(c, /Здесь намеренно нет ни одной\s*\n?цифры/,
+      'and the absence must be declared deliberate, so a later editor does not "helpfully" add one');
+  });
+
+  test('P6 - it is questions, and it says it is not a gate', () => {
+    const c = compliance();
+    assert.match(c, /это вопросы, а не утверждения о праве/,
+      'a template installed into arbitrary projects cannot assert any project law');
+    assert.match(c, /Это не юридическая проверка и не застава/,
+      'and it must refuse to be read as a gate — it has no verifiable input');
+    assert.match(c, /у неё нет проверяемого входа/, 'with the reason stated');
+    assert.match(c, /Ответ «нет» — это находка, а не формальность/,
+      'an unanswered question and a cleared one must not look alike');
+    assert.ok((c.match(/^\| \d+ \|/gm) || []).length >= 5,
+      'the checklist needs enough questions to be worth running');
+  });
+
+  test('P8 - the detectors CATCH the forms a future edit would actually add', () => {
+    // A detector run only against clean text is vacuous evidence: it cannot be distinguished from a
+    // detector that matches nothing at all. These are the exact strings that slipped through the
+    // first version, plus the ones it did catch, so the fix is proven to have widened reach without
+    // losing it.
+    const mustCatch = [
+      ['штраф 53088 долларов', MONEY, 'the stale figure this whole rule exists because of'],
+      ['30 дней', MONEY, 'a bare time threshold — the rule forbids thresholds, not only prices'],
+      ['не более 3 месяцев', MONEY, 'a threshold written in words plus a number'],
+      ['до 20% оборота', MONEY, 'a percentage cap'],
+      ['Article 6 GDPR', STATUTE, 'the ordinary citation form, which needed no leading number'],
+      ['16 CFR Part 465', STATUTE, 'the US form'],
+      ['ст. 15 ФЗ-152', STATUTE, 'the Russian form'],
+      ['152-ФЗ', STATUTE, 'and its other spelling'],
+    ];
+    for (const [text, re, why] of mustCatch) {
+      re.lastIndex = 0;
+      assert.ok(re.test(text), 'detector missed (' + why + '): ' + JSON.stringify(text));
+    }
+
+    // And it must not fire on ordinary prose, or the guard becomes noise someone disables.
+    const mustNotCatch = ['вопрос 1', 'семь вопросов', 'Ось 2 — ПЕТЛЯ', 'K-фактор'];
+    for (const text of mustNotCatch) {
+      MONEY.lastIndex = 0; STATUTE.lastIndex = 0;
+      assert.ok(!MONEY.test(text) && !STATUTE.test(text),
+        'detector false-fires on ordinary text: ' + JSON.stringify(text));
+    }
+  });
+
+  test('P7 - the staleness lesson is recorded where the next editor will read it', () => {
+    // The reason for the norm-not-amount rule is a real, dated failure. Keeping the reason next to
+    // the rule is what stops the rule from being softened by someone who does not know why it exists.
+    const c = compliance();
+    assert.match(c, /предупреждал, что цифра позапрошлого\s*\n?года устарела/,
+      'the source failure must be recorded');
+    assert.match(c, /Предупреждение и ошибка в одном\s*\n?документе/,
+      'including what made it instructive');
+  });
+});

package/tests/unit/growth-gate-conditional.test.js

@@ -0,0 +1,122 @@
+'use strict';
+
+// The Growth Traceability criterion is CONDITIONAL, and that is where the danger is.
+//
+// An unconditional growth threshold sends a project with no acquisition objective (internal tool,
+// on-prem) into a permanent NEEDS WORK loop — the exact trap already closed once for the Measurable
+// criterion. But the cure has its own failure mode, and it is the quieter one: a condition that can
+// never be true makes a gate that never fires, and a gate that never fires reads exactly like a gate
+// that always passes.
+//
+// Recalled lesson (dz recall, 0.85): "a verification probe that CAN run in a mode where it checks
+// nothing is vacuous evidence". So both directions are asserted here — the -10 path must be
+// REACHABLE, and the +0 path must exist for the projects the condition exempts.
+
+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 VALIDATOR = path.join(TPL, 'skills', 'requirements-validator', 'SKILL.md');
+
+const read = () => fs.readFileSync(VALIDATOR, 'utf-8');
+
+/** The criterion, from its heading to the next one. */
+function criterion() {
+  const src = read();
+  const start = src.indexOf('### Growth Traceability');
+  assert.ok(start > 0, 'requirements-validator must carry the Growth Traceability criterion');
+  const end = src.indexOf('\n### ', start + 1);
+  assert.ok(end > start, 'the criterion must be followed by another section');
+  return src.slice(start, end);
+}
+
+describe('the growth gate has teeth AND an exemption, and neither swallows the other', () => {
+  test('P1 - the penalty path is reachable and the exempt path is not', () => {
+    const c = criterion();
+    // REACHABLE: a project with a filled seed table and no trace scores the penalty.
+    assert.match(c, /-10 not traced|-10 if the seed table carries rows/,
+      'the -10 path must exist for a project the criterion applies to');
+    assert.match(c, /≥1 `FR-GROWTH-nnn` row \| YES/,
+      'and the applicable row of the table must say YES, or nothing ever reaches -10');
+    // EXEMPT: three named situations score +0, and each is a row of the same table.
+    for (const exempt of ['says `нет` / is empty', 'internal tool, on-prem', 'is ABSENT']) {
+      assert.ok(c.includes(exempt), 'the exemption table must name: ' + exempt);
+    }
+    // The two must be distinguishable by a reader: an applicability table with only YES rows or
+    // only no rows is one of the two failure modes above wearing the other's clothes.
+    const yes = (c.match(/\| YES \|/g) || []).length;
+    const no = (c.match(/\| no \|/g) || []).length;
+    assert.ok(yes >= 1 && no >= 3,
+      'both verdicts must be reachable in the table: YES=' + yes + ' no=' + no);
+  });
+
+  test('P2 - an absent brief is +0, never -10, with the reason stated', () => {
+    const c = criterion();
+    assert.match(c, /An absent brief is \+0, never -10/,
+      'the --from-docs entry skips Phase 0 — penalising it would loop those projects forever');
+    assert.match(c, /Phase 0 did not run.*is not.*the growth requirements are missing/is,
+      'and the two must be distinguished in words, not only in a table cell');
+  });
+
+  test('P3 - the condition is APPLICABILITY, not project type', () => {
+    // Gating on type was tried upstream and refuted: replicate.md:171 records that gating M5 on
+    // PRODUCT TYPE disabled the one branch M5 declares, and every B2B project got an empty slot.
+    // Repeating that mistake one phase later would re-open it.
+    const c = criterion();
+    assert.match(c, /acquisition or adoption is in scope/,
+      'the condition must be the same fact replicate.md gates M5 on');
+    assert.match(c, /incl\. B2B/, 'including B2B explicitly, or the refuted type-gate returns');
+    assert.match(c, /it is not about project type/i,
+      'and the artifact must refuse the type reading out loud');
+  });
+
+  test('P4 - the scoring stays OUTSIDE the 100-point table', () => {
+    // validation-gate-teeth.test.js pins 72/100 in its own title, derived from the current weight
+    // table. A new weight changes that arithmetic and reddens the test whose job is holding the
+    // gate's teeth. The Security criterion already solved this; this one copies the mechanism.
+    const c = criterion();
+    assert.match(c, /scores OUTSIDE the 100-point/i, 'the criterion must say where it scores');
+    assert.match(c, /adds no\s*\n?weight to any existing criterion/i,
+      'and that it adds no weight');
+    // Structural proof, not a promise: the INVEST/SMART weight headings must be untouched.
+    const src = read();
+    assert.match(src, /### INVEST Criteria \(User Stories\) — 50% weight/,
+      'the INVEST weight must still be 50%');
+    assert.match(src, /### SMART Criteria \(Acceptance Criteria\) — 30% weight/,
+      'and SMART still 30% — a growth weight here is what reddens validation-gate-teeth');
+    assert.ok(!/Growth.*—\s*\d+% weight/i.test(src),
+      'no growth criterion may carry a percentage weight');
+  });
+
+  test('P5 - TRACED is defined, and a silent drop is separated from a recorded rejection', () => {
+    const c = criterion();
+    assert.match(c, /case-sensitive, the exact token/,
+      '"mention" must be defined or every reader draws a different line');
+    assert.match(c, /not a title, not a paraphrase/i, 'and what does NOT count must be named');
+    assert.match(c, /A silently dropped row is the defect/,
+      'the defect class must be stated');
+    assert.match(c, /A row rejected on the record is not/,
+      'and a conscious rejection must be permitted, or the gate forbids saying no');
+  });
+
+  test('P6 - the criterion states its own limit and does not claim legality', () => {
+    const c = criterion();
+    assert.match(c, /proves an obligation was CARRIED FORWARD, not that it was built/,
+      'a traceability gate looks like proof of implementation and must refuse the reading');
+    assert.match(c, /Legality is not assessed anywhere in this pipeline/,
+      'and legality must be disclaimed here too — it is a separate backlog item');
+  });
+
+  test('P7 - the prose gate points at its deterministic counterpart and does not claim to be one', () => {
+    // AR-2: this section is read by a model — layer 3. Calling it layer 1 would be exactly the
+    // documented-but-false safety story this project has been burned by.
+    const c = criterion();
+    assert.match(c, /check-growth-trace\.cjs/, 'the deterministic checker must be named');
+    assert.match(c, /This\s*\n?section is a prose gate read by a model/i,
+      'and the prose gate must say what it is');
+    assert.match(c, /the utility is the deterministic one/,
+      'and which of the two is deterministic');
+  });
+});

package/tests/unit/growth-module-b2b-gate.test.js

@@ -89,16 +89,34 @@ describe('the growth module is not gated off for the type it handles itself', ()
     // This is the load-bearing one. Removing the gate is safe BECAUSE the module decides per type.
     // Without this assertion someone could delete the justification and keep the removal, and the
     // module would then run for B2B with no B2B behaviour.
-    assert.match(read(MODULE), /Если B2B → sales-led growth, не product-led/,
+    // REWORDED 2026-08-27 by growth-list-and-compliance. The old wording said "sales-led growth,
+    // не product-led", treating MOTION and LOOP as one exclusive choice — which the axis split had
+    // just refuted, so a B2B company with a sales-led motion and a product-led loop was told to
+    // reject the latter. Cross-family review caught the contradiction. The INTENT this test defends
+    // is unchanged and still asserted below: the module branches on type, which is what makes the
+    // ungated call correct. Only the wording moved, and it now says which axis it speaks about.
+    assert.match(read(MODULE), /Если B2B → мотион почти всегда sales-led или partnership-led/,
       'the branch that makes the ungated call correct must still be there');
+    assert.match(read(MODULE), /ТОЛЬКО про ось 1: петля выбирается отдельно/,
+      'and it must scope itself to one axis, or it re-asserts the exclusivity the split removed');
   });
 
   test('P5 — the growth module is byte-identical: this feature touches two callers only', () => {
     // Four byte-identical copies across three published packages hang off this file. Pinning its
     // hash is what keeps a two-line fix from becoming a three-package release by accident.
+    //
+    // MOVED ONCE, deliberately, 2026-08-27 by growth-requirements-bridge, which added the
+    // `Growth Requirements Seed` section and IS the three-package release this message demands.
+    // MOVED A THIRD TIME by prebake-skill-paths: the module's own /mnt/ references became
+    // .claude/skills/ paths. Pins: 98e8577a… → bd9cfcb8… → 6657dbe2… → this.
+    // MOVED AGAIN, same day, by growth-list-and-compliance (two axes + the compliance
+    // checklist) — also a three-package release. Pins so far: 98e8577a… → bd9cfcb8… → this.
+    // Previous pin: 98e8577a… The tripwire is not weakened by the move — re-pinning is the
+    // conscious decision it exists to force, and the accompanying module-copy-identity.test.js now
+    // also proves all four copies still agree, which a single hash never could.
     const sha = crypto.createHash('sha256')
       .update(fs.readFileSync(path.join(TPL, MODULE))).digest('hex');
-    assert.equal(sha, '98e8577aa5a5472574ac9bac590b76a4a3d16f99bc67ebec2b09b604c7c1faab',
+    assert.equal(sha, '84658390dc7beb590f70164b391ace915e42926660bc1015e4be300752b74a37',
       'the growth module changed; that is a three-package release, not this feature');
   });
 });

package/tests/unit/growth-requirements-bridge.test.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// The M5 growth analysis reached Phase 1 as an in-conversation --product-brief value and was never
+// written to disk (sparc-prd-mini/SKILL.md:993-999). MEASURED before this feature:
+// `grep -rn 'growth' sparc-prd-mini/ requirements-validator/` returned 0 hits in these templates.
+//
+// So the filed diagnosis — "no downstream step is obliged to read the analysis" — was one layer off.
+// There was nothing to read. A seed section alone would have written obligations into an artifact
+// that evaporates, which is why P1 assertions here are paired with the persistence ones.
+
+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 REPLICATE = path.join(TPL, 'commands', 'replicate.md');
+const MODULE = path.join(TPL, 'skills', 'reverse-engineering-unicorn', 'modules', '05-growth-engine.md');
+
+const read = (f) => fs.readFileSync(f, 'utf-8');
+
+/** The seed section, from its heading to the next top-level one. */
+function seedSection() {
+  const src = read(MODULE);
+  const start = src.indexOf('## 🌱 Growth Requirements Seed');
+  assert.ok(start > 0, '05-growth-engine.md must carry the seed section');
+  const end = src.indexOf('\n## ', start + 1);
+  assert.ok(end > start, 'the seed section must be followed by another section');
+  return src.slice(start, end);
+}
+
+describe('the growth analysis becomes a written, traceable obligation', () => {
+  test('P1 - Phase 0 names and writes the brief path', () => {
+    const src = read(REPLICATE);
+    assert.match(src, /docs\/product-discovery-brief\.md/,
+      'Phase 0 must name the exact path it writes, or no consumer can find it');
+
+    // ORDER is the property, not mere presence: writing after the hand-off would leave Phase 1
+    // running against a brief the file does not yet contain.
+    const write = src.indexOf('**Write** the full Product Discovery Brief');
+    const hand = src.indexOf('pass it to Phase 1 as pre-filled context');
+    assert.ok(write > 0 && hand > write,
+      'the write must be instructed BEFORE the hand-off: write=' + write + ' handoff=' + hand);
+  });
+
+  test('P2 - the in-context hand-off is preserved, not replaced', () => {
+    // FR-A2. Replacing the hand-off with a file read would change what Phase 1 receives and silently
+    // break the documented pre-filled-context contract in sparc-prd-mini.
+    const src = read(REPLICATE);
+    assert.match(src, /pre-filled context/,
+      'the hand-off must survive — the file is an ADDITION');
+    assert.match(src, /the file is an ADDITION/i,
+      'and the artifact must say so, so a later editor does not "simplify" one of the two away');
+  });
+
+  test('P3 - an absent brief means Phase 0 did not run, and the artifact says so', () => {
+    // FR-A3. The --from-docs entry skips Phase 0 entirely. Absence read as "no growth requirements"
+    // would penalise every --from-docs project forever.
+    const src = read(REPLICATE);
+    assert.match(src, /absent it means Phase 0 did not run/i,
+      'absence must be given its meaning where the path is defined');
+    assert.match(src, /NOT evidence that the\s+project has no growth requirements/i,
+      'and the wrong reading must be refused explicitly');
+  });
+
+  test('P4 - the seed emits ids with a defined form', () => {
+    const s = seedSection();
+    assert.match(s, /FR-GROWTH-<nnn>/, 'the id form must be stated');
+    assert.match(s, /три цифры, по порядку, номер не переиспользуется/,
+      'an id without a uniqueness rule is an intention, not an identifier');
+    assert.match(s, /FR-GROWTH-001/, 'and the table must show a concrete row');
+  });
+
+  test('P5 - every row must name its source block', () => {
+    const s = seedSection();
+    assert.match(s, /Блок-источник/, 'the table needs a source column');
+    assert.match(s, /Требование без источника непрослеживаемо/,
+      'and the rule must say a sourceless row is not a seed at all');
+  });
+
+  test('P6 - confidence is carried verbatim, never recomputed', () => {
+    // The module declares NO numeric threshold and confidence is not one scale across modes
+    // (SKILL.md:60-64 — QUICK is a manual X/5, DEEP is a formula). Normalising would invent a number
+    // nobody measured, so the rule is verbatim carry plus the SHIPPED [H] convention for doubt.
+    const s = seedSection();
+    assert.match(s, /Confidence переносится ДОСЛОВНО/, 'verbatim carry must be the rule');
+    assert.match(s, /Не пересчитывайте/, 'and recomputation must be refused');
+    assert.match(s, /\[H\]/, 'SPECULATIVE must hang on the shipped [H] convention');
+    assert.match(s, /НЕ НАЙДЕНО/, 'and on the shipped not-found convention');
+    assert.ok(!/confidence\s*[<>]\s*0\.\d/i.test(s),
+      'a numeric threshold would be a convention invented here: ' + s.slice(0, 80));
+  });
+
+  test('P7 - the section states BOTH limits in the shipped artifact', () => {
+    // A seed table looks like proof of work planned. It is neither proof of building nor of legality.
+    const s = seedSection();
+    assert.match(s, /Черновик ≠ построено/, 'draft-is-not-built must be written where a reader sees it');
+    // RECONCILED 2026-08-27. The first version said flatly "Законность НЕ проверена" — true then,
+    // and false the moment the same feature-day added the ⚖️ compliance checklist, which DOES ask.
+    // Cross-family review found the contradiction: the seed disclaimed a question the module now
+    // puts to the user. The replacement is narrower AND stronger — asked, recorded, not established
+    // — and the distinction it draws is the load-bearing half.
+    assert.match(s, /Допустимость СПРОШЕНА, но не установлена/,
+      'the seed must say the question is asked, since the checklist asks it');
+    assert.match(s, /Это не юридическое заключение/,
+      'and must refuse to be read as a legal opinion');
+    assert.match(s, /не «это законно»/,
+      'the difference between "seven questions cleared" and "lawful" is the whole point');
+    assert.ok(!/Законность НЕ проверена/.test(s),
+      'the old flat disclaimer now contradicts the checklist and must not survive beside it');
+  });
+
+  test('P8 - an empty seed must be written, not omitted', () => {
+    // An absent table and a table saying "nothing to seed" are indistinguishable to the next reader,
+    // and the checker depends on being able to tell them apart.
+    const s = seedSection();
+    assert.match(s, /Пустая таблица — тоже ответ/, 'the empty case must be given a shape');
+    assert.match(s, /написана словом `нет`/, 'and a concrete token to write');
+  });
+
+  test('P9 - the seed says where it goes, closing the loop it was built to close', () => {
+    const s = seedSection();
+    assert.match(s, /docs\/product-discovery-brief\.md/, 'the seed must name its carrier file');
+    assert.match(s, /docs\/Specification\.md/, 'and its destination');
+    assert.match(s, /Фаза 2 проверяет/, 'and name the phase that checks the promotion happened');
+  });
+});