@dzhechkov/p-replicator 1.5.18 → 1.9.0

package/tests/unit/autocommit-deletion.test.js

@@ -0,0 +1,242 @@
+'use strict';
+
+// All three autocommit hooks opened with `if (!fs.existsSync(TARGET)) process.exit(0);`, so a DELETED
+// roadmap was "nothing to do" — though a deletion is exactly the change these hooks exist to record.
+// The history showed the file being maintained and then, silently, not.
+//
+// THE TRAP, measured before a line was written: simply deleting that guard breaks the failure
+// reporting that shipped the day before.
+//
+//   git add -- <a path that never existed>   → exit 128, "fatal: pathspec … did not match any files"
+//   git add -- <a tracked file, deleted>     → exit 0, and diff --cached then reports a change
+//
+// A failing git call now prints one line, so the naive fix would print a failure on EVERY session
+// stop in every project without this artifact — which is most of them. That is the noise the same
+// feature's own comment warns trains people to ignore notices. P3 is the guard on it.
+//
+// The discriminator is `git ls-files -- <path>`: entries for a path git knows, nothing for one it
+// does not. It must run BEFORE staging: staging a deletion removes the entry from the index, after
+// which the same question answers "not tracked". (`--error-unmatch` discriminates just as well, for
+// files and directories alike — an earlier note here said otherwise and was withdrawn after
+// re-measuring. `ls-files --` is preferred only because it answers with data instead of throwing.)
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { execFileSync, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const TPL = path.join(__dirname, '..', '..', 'templates', '.claude');
+
+const HOOKS = [
+  { name: 'autocommit-roadmap', remove: /auto-remove/,
+    make: (root) => {
+      fs.mkdirSync(path.join(root, '.claude'), { recursive: true });
+      const f = path.join(root, '.claude', 'feature-roadmap.json');
+      fs.writeFileSync(f, '{"v":1}\n');
+      return { drop: () => fs.rmSync(f), touch: () => fs.writeFileSync(f, '{"v":2}\n') };
+    } },
+  { name: 'autocommit-insights', remove: /auto-remove/,
+    make: (root) => {
+      const d = path.join(root, '.claude', 'insights');
+      fs.mkdirSync(d, { recursive: true });
+      fs.writeFileSync(path.join(d, 'index.md'), '## one\n');
+      return { drop: () => fs.rmSync(d, { recursive: true }),
+        touch: () => fs.writeFileSync(path.join(d, 'index.md'), '## one\n## two\n') };
+    } },
+  { name: 'autocommit-plans', remove: /auto-remove/,
+    make: (root) => {
+      const d = path.join(root, 'docs', 'plans');
+      fs.mkdirSync(d, { recursive: true });
+      fs.writeFileSync(path.join(d, 'a.md'), '# plan\n');
+      return { drop: () => fs.rmSync(d, { recursive: true }),
+        touch: () => fs.writeFileSync(path.join(d, 'a.md'), '# plan v2\n') };
+    } },
+];
+
+function project(opts) {
+  const o = opts || {};
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-del-')));
+  fs.mkdirSync(path.join(root, '.claude', 'hooks'), { recursive: true });
+  for (const h of HOOKS) {
+    fs.copyFileSync(path.join(TPL, 'hooks', h.name + '.cjs'),
+      path.join(root, '.claude', 'hooks', h.name + '.cjs'));
+  }
+  if (o.git !== false) {
+    const git = (a) => execFileSync('git', a, { cwd: root, stdio: 'ignore' });
+    git(['init', '-q']);
+    git(['config', 'user.email', 'test@example.invalid']);
+    git(['config', 'user.name', 'test']);
+  }
+  return root;
+}
+
+const git = (root, args) =>
+  execFileSync('git', args, { cwd: root, encoding: 'utf8' }).trim();
+const commitAll = (root) => {
+  execFileSync('git', ['add', '-A'], { cwd: root, stdio: 'ignore' });
+  execFileSync('git', ['commit', '-qm', 'base'], { cwd: root, stdio: 'ignore' });
+};
+
+function run(root, hookName) {
+  const r = spawnSync(process.execPath,
+    [path.join(root, '.claude', 'hooks', hookName + '.cjs')],
+    { cwd: root, env: Object.assign({}, process.env, { CLAUDE_PROJECT_DIR: root }),
+      encoding: 'utf8' });
+  return { code: r.status, out: (r.stdout || '') + (r.stderr || '') };
+}
+
+const cleanup = (d) => fs.rmSync(d, { recursive: true, force: true });
+
+describe('a deleted artifact is recorded, and an absent one is still silent', () => {
+  test('P1 — deleting a tracked target produces a commit and leaves the tree clean', () => {
+    const root = project({});
+    try {
+      const h = HOOKS[0];
+      const ctl = h.make(root);
+      commitAll(root);
+      const before = Number(git(root, ['rev-list', '--count', 'HEAD']));
+      ctl.drop();
+
+      const r = run(root, h.name);
+      assert.equal(r.code, 0, 'the hook must stay non-blocking: ' + r.out);
+      assert.equal(Number(git(root, ['rev-list', '--count', 'HEAD'])), before + 1,
+        'the deletion must be committed, not treated as nothing to do');
+      assert.equal(git(root, ['status', '--porcelain']), '',
+        'and the tree must be left clean, not merely staged');
+    } finally { cleanup(root); }
+  });
+
+  test('P2 — the commit names the removal, so the event is findable in the log', () => {
+    // The owner's stated purpose: be able to spot the event and undo it. A deletion recorded as
+    // "auto-update" is findable only by reading diffs.
+    const root = project({});
+    try {
+      const h = HOOKS[0];
+      const ctl = h.make(root);
+      commitAll(root);
+      ctl.drop();
+      run(root, h.name);
+      const subject = git(root, ['log', '-1', '--format=%s']);
+      assert.match(subject, h.remove,
+        'the subject must say the artifact was removed: ' + JSON.stringify(subject));
+    } finally { cleanup(root); }
+  });
+
+  test('P3 — a project that never had the artifact stays SILENT', () => {
+    // The guard on the naive fix. Deleting the existence check outright would make `git add` exit
+    // 128 here, and the failure reporting that shipped yesterday would print a line on every session
+    // stop in every project without this artifact.
+    const root = project({});
+    try {
+      fs.writeFileSync(path.join(root, 'unrelated.txt'), 'x\n');
+      commitAll(root);
+      for (const h of HOOKS) {
+        const r = run(root, h.name);
+        assert.equal(r.code, 0, h.name + ' must exit 0');
+        assert.equal(r.out.trim(), '',
+          h.name + ' printed something for an artifact this project never had: ' + r.out);
+      }
+      assert.equal(git(root, ['rev-list', '--count', 'HEAD']), '1',
+        'and nothing may be committed');
+    } finally { cleanup(root); }
+  });
+
+  test('P4 — not a git repository: silent, exit 0', () => {
+    const root = project({ git: false });
+    try {
+      const r = run(root, HOOKS[0].name);
+      assert.equal(r.code, 0);
+      assert.equal(r.out.trim(), '', 'not-a-repo is not a failure to report: ' + r.out);
+    } finally { cleanup(root); }
+  });
+
+  test('P5 — an existing, changed target still commits as before', () => {
+    const root = project({});
+    try {
+      const h = HOOKS[0];
+      const ctl = h.make(root);
+      commitAll(root);
+      ctl.touch();
+      const before = Number(git(root, ['rev-list', '--count', 'HEAD']));
+      assert.equal(run(root, h.name).code, 0);
+      assert.equal(Number(git(root, ['rev-list', '--count', 'HEAD'])), before + 1,
+        'the ordinary update path must be untouched');
+      assert.doesNotMatch(git(root, ['log', '-1', '--format=%s']), /auto-remove/,
+        'and an update must NOT be labelled a removal');
+    } finally { cleanup(root); }
+  });
+
+  test('P6 — an existing, unchanged target is silent', () => {
+    const root = project({});
+    try {
+      const h = HOOKS[0];
+      h.make(root);
+      commitAll(root);
+      const before = Number(git(root, ['rev-list', '--count', 'HEAD']));
+      const r = run(root, h.name);
+      assert.equal(r.code, 0);
+      assert.equal(r.out.trim(), '', 'nothing to commit must stay silent: ' + r.out);
+      assert.equal(Number(git(root, ['rev-list', '--count', 'HEAD'])), before,
+        'and must not create an empty commit');
+    } finally { cleanup(root); }
+  });
+
+  test('P8 — a PARTIAL deletion is still a removal, even though the directory remains', () => {
+    // Cross-family QE: classifying from `existsSync` on the DIRECTORY was wrong. Deleting one file
+    // inside it — or every tracked file while an ignored one keeps the directory present — left the
+    // path existing, so the commit said "auto-save" and the removal was unfindable by the very
+    // search this feature promises. The classification now comes from what git actually STAGED.
+    const root = project({});
+    try {
+      const d = path.join(root, 'docs', 'plans');
+      fs.mkdirSync(d, { recursive: true });
+      fs.writeFileSync(path.join(d, 'a.md'), 'a\n');
+      fs.writeFileSync(path.join(d, 'b.md'), 'b\n');
+      commitAll(root);
+      fs.rmSync(path.join(d, 'a.md'));           // the directory still exists
+
+      const r = run(root, 'autocommit-plans');
+      assert.equal(r.code, 0, r.out);
+      assert.ok(fs.existsSync(d), 'the fixture must leave the directory in place');
+      assert.match(git(root, ['log', '-1', '--format=%s']), /auto-remove/,
+        'one deleted file inside a surviving directory is still a removal: '
+        + git(root, ['log', '-1', '--format=%s']));
+    } finally { cleanup(root); }
+  });
+
+  test('P9 — a real git failure is not laundered into "never existed"', () => {
+    // The `ls-files` answer decides whether a deletion is recorded at all. A bare catch that turned
+    // every failure into an empty answer would silently skip the deletion — a bypass of the feature
+    // itself, wearing the shape of the ordinary case.
+    for (const h of HOOKS) {
+      const src = fs.readFileSync(path.join(TPL, 'hooks', h.name + '.cjs'), 'utf-8');
+      const at = src.indexOf("git(['ls-files'");
+      assert.ok(at > 0, h.name + ' must ask git whether the path is tracked');
+      const around = src.slice(at - 200, at + 200);
+      assert.ok(!/catch\s*\{\s*tracked\s*=\s*''/.test(around),
+        h.name + ' swallows a real ls-files failure as "not tracked": ' + around);
+    }
+  });
+
+  test('P7 — all three hooks record their own deletion identically', () => {
+    // Two of the three watch a DIRECTORY rather than a file, so the deletion path has to work for
+    // both shapes — that is what this case proves, and it is why the fixtures differ.
+    for (const h of HOOKS) {
+      const root = project({});
+      try {
+        const ctl = h.make(root);
+        commitAll(root);
+        const before = Number(git(root, ['rev-list', '--count', 'HEAD']));
+        ctl.drop();
+        const r = run(root, h.name);
+        assert.equal(r.code, 0, h.name + ' must exit 0: ' + r.out);
+        assert.equal(Number(git(root, ['rev-list', '--count', 'HEAD'])), before + 1,
+          h.name + ' did not record its deletion');
+        assert.match(git(root, ['log', '-1', '--format=%s']), h.remove,
+          h.name + ' did not name the removal');
+      } finally { cleanup(root); }
+    }
+  });
+});

package/tests/unit/check-docs-complete.test.js

@@ -0,0 +1,249 @@
+'use strict';
+
+// Phase 2 launched a swarm of validation agents over whatever Phase 1 produced, with nothing in
+// between. Existence, emptiness and unfilled placeholders are decidable by forty lines of code, so
+// sending a swarm to discover them is a layer-1 check living at layer 3.
+//
+// The trap this suite exists to hold: an eager placeholder pattern. A bracketed token is also how
+// markdown writes a link and how a citation looks, so a naive /\[.*\]/ refuses legitimate documents
+// — the same eager-gate failure this repo closed for the Measurable criterion and twice today for
+// the growth criterion. P4 is the guard on it.
+
+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-docs-complete.cjs');
+
+const REQUIRED = ['PRD.md', 'Solution_Strategy.md', 'Specification.md', 'Pseudocode.md',
+  'Architecture.md', 'Refinement.md', 'Completion.md', 'Research_Findings.md', 'Final_Summary.md'];
+
+/** Real prose, comfortably over the emptiness threshold, with no placeholder in it. */
+const REAL = '# Документ\n\n' + 'Содержательный абзац про предметную область проекта. '.repeat(12);
+
+/** Build a project and run the real checker over it. */
+function check(files, opts) {
+  const o = opts || {};
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-docs-')));
+  try {
+    if (!o.noDocs) {
+      fs.mkdirSync(path.join(dir, 'docs'), { recursive: true });
+      for (const [name, body] of Object.entries(files || {})) {
+        fs.writeFileSync(path.join(dir, 'docs', name), 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 complete = (over) => Object.assign(
+  Object.fromEntries(REQUIRED.map((f) => [f, REAL])), over || {});
+
+describe('the cheap question is asked before the swarm is spent', () => {
+  test('P1 - a complete document set exits 0', () => {
+    const r = check(complete());
+    assert.equal(r.code, 0, 'a full set must pass: ' + r.out);
+    assert.match(r.out, /9 проверено/, r.out);
+  });
+
+  test('P2 - a missing required document exits 1 and is NAMED', () => {
+    const files = complete();
+    delete files['Specification.md'];
+    const r = check(files);
+    assert.equal(r.code, 1, r.out);
+    assert.match(r.out, /Specification\.md: отсутствует/, 'the missing one must be named: ' + r.out);
+    assert.ok(!/PRD\.md/.test(r.out), 'and the present ones must not be: ' + r.out);
+  });
+
+  test('P3 - a document that exists but says nothing exits 1', () => {
+    // The case `test -f` misses, and the reason this check is not a one-liner.
+    const r = check(complete({ 'Refinement.md': '# Refinement\n' }));
+    assert.equal(r.code, 1, r.out);
+    assert.match(r.out, /Refinement\.md: пуст или почти пуст/, r.out);
+  });
+
+  test('P4 - markdown links and citations are not placeholders', () => {
+    // A naive bracket pattern refuses this document, which is entirely legitimate. An eager gate is
+    // not a stricter gate — it is a gate people turn off.
+    const withLinks = '# Архитектура\n\n'
+      + 'Смотри [документацию Postgres](https://www.postgresql.org/docs/) и [ADR-001](docs/ADR.md). '
+      + 'Подход описан в [Fowler 2019](https://martinfowler.com/articles/). '.repeat(6);
+    const r = check(complete({ 'Architecture.md': withLinks }));
+    assert.equal(r.code, 0,
+      'markdown links must not read as unfilled placeholders: ' + r.out);
+  });
+
+  test('P5 - a project missing only optional documents passes', () => {
+    // ADR.md and C4_Diagrams.md are "(if applicable)" in replicate.md. Demanding them would refuse
+    // every project without DDD, forever — the trap already closed for Measurable and for growth.
+    const r = check(complete());   // neither optional file is present
+    assert.equal(r.code, 0, 'optional absence is a legitimate answer: ' + r.out);
+  });
+
+  test('P13 - the counter-examples cross-family review supplied', () => {
+    // Both REPRODUCED as exit 1 before the fix, and both would have been catastrophic:
+    // the first blocks EVERY normally generated project, the second deadlocks a documented flow.
+    const mermaid = '# Architecture\n\n```mermaid\ngraph TD\n    A[Web App] --> B[API]\n'
+      + '    B --> F[(Database)]\n```\n\n' + REAL;
+    assert.equal(check(complete({ 'Architecture.md': mermaid })).code, 0,
+      'the BUNDLED sparc-prd-mini skill REQUIRES mermaid (SKILL.md:570-583) — blocking on its node '
+      + 'labels would refuse every normally generated Architecture.md');
+
+    const gap = '# Specification\n\n[GAP: needs performance targets from the client]\n\n' + REAL;
+    assert.equal(check(complete({ 'Specification.md': gap })).code, 0,
+      'Phase 1 writes [GAP: ...] deliberately in --from-docs mode for Phase 2 to resolve '
+      + '(replicate.md:82-94). Blocking deadlocks it: the only step that can clear the marker is '
+      + 'the one this gate would refuse to start');
+
+    const citations = '# Research_Findings\n\nПо данным [1] и [^2] рынок растёт.\n\n' + REAL;
+    assert.equal(check(complete({ 'Research_Findings.md': citations })).code, 0,
+      'citations and footnotes are not placeholders');
+  });
+
+  test('P14 - bracketed prose WARNS but never blocks', () => {
+    // The design change the review forced. This script cannot tell `[описание продукта]` from a
+    // diagram label without understanding the document, and a false block stops the whole pipeline —
+    // strictly worse than a missed placeholder the Phase-2 swarm would catch anyway. So the two
+    // confidence levels are separated, and the uncertain one is not given the power to refuse.
+    const r = check(complete({ 'PRD.md': '# PRD\n\n[описание продукта]\n\n' + REAL }));
+    assert.equal(r.code, 0, 'bracketed prose must not block: ' + r.out);
+    assert.match(r.out, /НЕ блокирует/, 'and must say plainly that it does not: ' + r.out);
+    assert.match(r.out, /PRD\.md: возможно незаполнено/, 'while still naming it: ' + r.out);
+  });
+
+  test('P6 - an UNAMBIGUOUS placeholder is caught, in both blocking vocabularies', () => {
+    // Narrowed by the review: the bracketed-prose vocabulary moved to a warning (P14). What blocks
+    // is what cannot be anything else.
+    for (const [body, why] of [
+      ['# PRD\n\n{{company_name}} строит продукт.\n\n' + REAL, 'a mustache placeholder'],
+      ['# PRD\n\nTODO: дописать сегменты.\n\n' + REAL, 'a TODO marker'],
+    ]) {
+      const r = check(complete({ 'PRD.md': body }));
+      assert.equal(r.code, 1, why + ' must block: ' + r.out);
+      assert.match(r.out, /PRD\.md: остались/, r.out);
+    }
+  });
+
+  test('P7 - no docs directory exits 2, and an empty one does too', () => {
+    const none = check({}, { noDocs: true });
+    assert.equal(none.code, 2, 'nothing to check is not "complete": ' + none.out);
+    assert.match(none.out, /проверка НЕ выполнена/, none.out);
+    assert.match(none.out, /Фаза 1 ещё не отработала/, 'the reason must be named: ' + none.out);
+
+    const empty = check({});
+    assert.equal(empty.code, 2, 'an empty docs/ is not "complete" either: ' + empty.out);
+  });
+
+  test('P10 - one binary, all three verdicts in a single run', () => {
+    const seen = [
+      check(complete()).code,
+      check(Object.assign(complete(), { 'PRD.md': '# PRD\n' })).code,
+      check({}, { noDocs: true }).code,
+    ];
+    assert.deepEqual(seen, [0, 1, 2], 'expected complete/incomplete/could-not-check: '
+      + JSON.stringify(seen));
+  });
+
+  test('P11 - Phase 2 runs it BEFORE the swarm and refuses on exit 1', () => {
+    const src = fs.readFileSync(path.join(TPL, 'commands', 'replicate.md'), 'utf-8');
+    const start = src.indexOf('### Phase 2: VALIDATION');
+    const end = src.indexOf('\n### Phase 3', start + 1);
+    assert.ok(start > 0 && end > start, 'replicate.md must have a Phase 2');
+    const phase2 = src.slice(start, end);
+
+    const call = phase2.indexOf('check-docs-complete.cjs');
+    const swarm = phase2.indexOf('Swarm of Validation Agents');
+    assert.ok(call > 0, 'Phase 2 must invoke the check');
+    assert.ok(swarm > call,
+      'the check must precede the swarm, or it cannot save the swarm: call=' + call + ' swarm=' + swarm);
+    assert.match(phase2, /\*\*НЕ запускайте рой\.\*\*/,
+      'exit 1 must stop the swarm, or the check is advice');
+    assert.match(phase2, /это НЕ «всё в порядке»/,
+      'exit 2 must be refused as a pass, in the artifact a reader sees');
+  });
+
+  test('P8 - prepublishOnly runs the snapshot test', () => {
+    // tests/ is in files[] (MEASURED: 29 test files in npm pack --dry-run), so baseline.json SHIPS.
+    // prepublishOnly ran only the signature gate, which signs whatever is present — dz sign prints
+    // the limit itself: "Ed25519 gives tamper-evidence, never truthfulness." A drifted baseline was
+    // therefore signed, shipped and wrong. The source backlog item claimed publish was already
+    // blocked; its own ground-check caught that this was false.
+    const pkg = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf-8'));
+    const pre = pkg.scripts.prepublishOnly || '';
+    assert.match(pre, /tests\/snapshot\/templates\.test\.js/,
+      'a drifted baseline must not be publishable: ' + pre);
+    assert.ok(pre.indexOf('templates.test.js') < pre.indexOf('prepublish-gate'),
+      'the snapshot must run BEFORE signing, or a drifted baseline gets signed first: ' + pre);
+    assert.ok((pkg.files || []).includes('tests/'),
+      'this assertion only matters because tests/ ships — if that changes, revisit');
+  });
+
+  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-docs-complete'], 'it must be registered');
+    const settings = fs.readFileSync(path.join(TPL, 'settings.json'), 'utf-8');
+    assert.ok(!settings.includes('check-docs-complete'),
+      'this packages hooks are non-blocking by contract; a hook could print but never refuse');
+    const statusline = fs.readFileSync(path.join(TPL, 'hooks', 'statusline.cjs'), 'utf-8');
+    const m = statusline.match(/hooksExpected:\s*(\d+)/);
+    assert.equal(Number(m[1]), Object.keys(COMPONENTS.hooks.items).length,
+      'the status line would report a phantom missing hook: ' + m[1]);
+  });
+
+  test('P12 - the artifact states its own limit', () => {
+    const r = check(complete());
+    assert.match(r.out, /документы НАПИСАНЫ, а не что они верны/,
+      'a completeness pass looks like a correctness pass and must refuse the reading: ' + r.out);
+  });
+});
+
+// ── Appended: the resume half of backlog 58575b07 ─────────────────────────────────────────────
+// The item asked for automated resume detection. Evidence gathered 2026-08-27 says the automation
+// is not the valuable half: /replicate has FOUR interactive checkpoints (MEASURED: `grep -c
+// 'Checkpoint:'`), commits after EVERY phase (replicate-pipeline.md:134-137), and — since this same
+// feature — a deterministic docs-completeness answer. The item's own verifier said the payoff of
+// automation is "modest even post-demo" for a pipeline where a human sits at every checkpoint.
+//
+// So what shipped is the documentation of the three signals that already exist, plus the recorded
+// decision NOT to add branching logic. This test holds that record: a section that says "we decided
+// not to" is worth nothing if the next reader cannot find the reasoning.
+
+const { test: resumeTest, describe: resumeDescribe } = require('node:test');
+
+resumeDescribe('an interrupted run can be resumed from what already exists', () => {
+  resumeTest('P13 - the three existing resume signals are named, with their commands', () => {
+    const src = fs.readFileSync(path.join(TPL, 'commands', 'replicate.md'), 'utf-8');
+    const start = src.indexOf('### Прерванный прогон');
+    assert.ok(start > 0, 'replicate.md must tell a user how to resume');
+    const end = src.indexOf('\n### ', start + 1);
+    const sec = src.slice(start, end > start ? end : undefined);
+
+    assert.match(sec, /git log --oneline/, 'the per-phase commits are the phase marker');
+    assert.match(sec, /check-docs-complete\.cjs/, 'the deterministic completeness answer');
+    assert.match(sec, /p-replicator verify/, 'and the Phase-3 toolkit signal');
+    assert.match(sec, /продолжай с Фазы 3/,
+      'and a concrete sentence to say, not just a list of probes');
+  });
+
+  resumeTest('P14 - the decision NOT to automate is recorded with its reasoning', () => {
+    // A skipped item leaves no trace unless the skip is written down. Without this the next reader
+    // re-derives the question from scratch, or builds the thing that was deliberately not built.
+    const src = fs.readFileSync(path.join(TPL, 'commands', 'replicate.md'), 'utf-8');
+    const start = src.indexOf('### Прерванный прогон');
+    const end = src.indexOf('\n### ', start + 1);
+    const sec = src.slice(start, end > start ? end : undefined);
+
+    assert.match(sec, /сознательно НЕ реализовано/, 'the decision must be stated');
+    assert.match(sec, /бэклог `58575b07`/, 'with the item it answers');
+    assert.match(sec, /свежая логика ветвления в\s*\n?интерактивном конвейере/,
+      'and the reason, so a future reader can disagree with the reason rather than guess it');
+    assert.match(sec, /начинайте с\s*\n?того, что перечисленного выше оказалось недостаточно/,
+      'and the condition under which revisiting it is warranted');
+  });
+});