@dzhechkov/p-replicator 1.5.18 → 1.9.0

package/templates/.claude/hooks/autocommit-roadmap.cjs

@@ -10,35 +10,118 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 
-const TARGET = path.resolve(process.cwd(), '.claude', 'feature-roadmap.json');
-const RELATIVE = path.relative(process.cwd(), TARGET);
-const SILENT = { stdio: 'ignore' };
+// The project root, never the process cwd: a `cd` inside any tool call moves cwd for the rest of
+// the session, and these hooks are non-blocking, so a wrong anchor fails SILENTLY. CLAUDE_PROJECT_DIR
+// first — the host is authoritative about what the project is. `__dirname` second: a hook always
+// lives at <project>/.claude/hooks/<x>.cjs, so its own location settles the root with no cooperation
+// from anyone, which is what keeps this working when the variable is absent (hand-run, older host).
+const ENV_ROOT = process.env.CLAUDE_PROJECT_DIR;
+// isAbsolute, not just truthy: a RELATIVE value would still be resolved against the drifting
+// cwd, which is the very bug this anchor exists to remove.
+const ROOT = (ENV_ROOT && path.isAbsolute(ENV_ROOT))
+  ? ENV_ROOT
+  : path.resolve(__dirname, '..', '..');
+
+const TARGET = path.resolve(ROOT, '.claude', 'feature-roadmap.json');
+const RELATIVE = path.relative(ROOT, TARGET);
+// cwd: ROOT — the paths below are relative to ROOT, so git must run there too.
+// stderr is PIPED, not ignored: on success nothing is printed anyway, and on failure git's
+// own words are the only thing that tells a reader WHY. Discarding them leaves a report that
+// names what failed and not why, which is half a report.
+const SILENT = { stdio: ['ignore', 'pipe', 'pipe'], cwd: ROOT };
+
+// What the hook was DOING when it failed. The outer catch also sees staging failures and a
+// missing git binary, and reporting either of those as "could not commit" would send the reader
+// looking in the wrong place.
+let stage = 'start';
 
 function git(args) {
   return execFileSync('git', args, SILENT);
 }
 
 try {
-  // Skip if file doesn't exist or we're not in a git repo.
-  if (!fs.existsSync(TARGET)) process.exit(0);
-  try { git(['rev-parse', '--git-dir']); } catch { process.exit(0); }
+  // The repository probe comes FIRST now, because the absence check below needs to ask git a
+  // question and there is no point asking outside a repository.
+  stage = 'inspect the repository';
+  try {
+    git(['rev-parse', '--git-dir']);
+  } catch (probeErr) {
+    // "Not a git repository" is the ordinary case and stays silent. Everything else — no git on
+    // PATH, dubious ownership, a permission error — is a real failure that used to look exactly
+    // like it, which is how a broken machine and an ordinary directory became indistinguishable.
+    const why = String((probeErr && probeErr.stderr) || '').trim();
+    if (!why || /not a git repository/i.test(why)) process.exit(0);
+    throw probeErr;
+  }
+
+  // Absent — but absent HOW? A path that never existed is nothing to do, as before. A path git
+  // still tracks is a DELETION, and a deletion is exactly the change this hook exists to record.
+  //
+  // `git ls-files` is the discriminator, and it must run BEFORE staging: staging a deletion
+  // removes the entry from the index, after which the same question answers "not tracked".
+  // CORRECTION, measured: `--error-unmatch` also discriminates correctly here, for files AND for
+  // directories — 0 for a deleted-but-tracked path, 1 for one that never existed. An earlier note
+  // here claimed otherwise; that claim came from measuring it AFTER staging, which is what made it
+  // fail, not the directory-ness. `ls-files --` is preferred only because it answers with DATA
+  // (empty or not) instead of by throwing, so the ordinary case needs no exception handling.
+  //
+  // Simply DELETING the existence guard would have been the naive fix and would have broken the
+  // reporting that shipped yesterday: `git add` on a path that never existed exits 128, so every
+  // session stop in every project without this artifact would print a failure line. MEASURED.
+  if (!fs.existsSync(TARGET)) {
+    // A bare `catch { tracked = '' }` here would turn a REAL git failure into "never existed"
+    // and skip a deletion that should have been recorded — a silent bypass of the very thing
+    // this feature adds. A failure is rethrown into the reporting path; only a genuinely
+    // empty answer means the artifact never lived here.
+    const tracked = String(git(['ls-files', '--', RELATIVE]) || '').trim();
+    if (!tracked) process.exit(0);   // never existed here — silent, exactly as before
+  }
 
-  // Stage only the target file.
+  // Stage the target (or its removal).
+  stage = 'stage the change';
   git(['add', '--', RELATIVE]);
 
   // Check whether anything is staged for THIS path.
   // `git diff --cached --quiet -- <path>` exits 0 = no diff, 1 = diff exists.
-  let hasDiff = false;
+  // Ask git WHAT it staged, not merely WHETHER something changed — same subprocess, strictly
+  // more information. Deriving "this is a removal" from whether the path still exists was
+  // wrong for a directory: deleting ONE file inside it, or deleting every tracked file while
+  // an ignored one keeps the directory present, would have been committed as an update and
+  // defeated the very search this feature promises.
+  let staged = '';
   try {
-    git(['diff', '--cached', '--quiet', '--', RELATIVE]);
+    staged = String(git(['diff', '--cached', '--name-status', '--', RELATIVE]) || '').trim();
   } catch {
-    hasDiff = true;
+    // No HEAD yet (an unborn repository): there is no history to record a removal against.
+    staged = '';
   }
+  const deleted = staged.split('\n').some((l) => /^D/.test(l.trim()));
+  const hasDiff = staged.length > 0;
 
   if (hasDiff) {
-    git(['commit', '--only', '--', RELATIVE, '-m', 'docs(roadmap): auto-update']);
+    // -m BEFORE the `--`: everything after `--` is a PATHSPEC, so the old order made git
+    // look for files literally named '-m' and 'docs(roadmap): auto-update' — it failed every
+    // time, from every directory, and this hook exits 0 on failure, so nobody saw it.
+    stage = 'commit';
+    // A deletion gets its own subject, so the event is findable in `git log` without
+    // reading diffs — which is the whole point of recording it.
+    git(['commit', '-m', deleted ? 'docs(roadmap): auto-remove' : 'docs(roadmap): auto-update', '--only', '--', RELATIVE]);
   }
-} catch (_err) {
-  // Best-effort — never break Claude session on commit failures.
+} catch (err) {
+  // Best-effort — never break the Claude session on commit failures. But "not breaking the session"
+  // and "saying nothing" are different things, and only the first one is the contract: it is about
+  // the EXIT CODE. Silence is what let a permanent defect live here undetected — `-m` after `--`
+  // made every commit fail, from every directory, forever, and nothing said so.
+  //
+  // A held index.lock, a missing user.email, a repository pre-commit hook that rejected the commit,
+  // an ignored target: each now costs one line and still exits 0. The ordinary "nothing to commit"
+  // path never reaches here, deliberately — a notice that fires when nothing is wrong trains people
+  // to ignore notices, and the next real failure scrolls past with them.
+  const artifactName = '.claude/feature-roadmap.json';
+  const gitSaid = err && err.stderr ? String(err.stderr).trim() : '';
+  const detail = (gitSaid || String((err && err.message) || err)).split('\n')
+    .map((l) => l.trim()).filter(Boolean)[0] || 'unknown error';
+  process.stdout.write('[autocommit-roadmap] could not ' + stage + ' — ' + artifactName + ': '
+    + detail.slice(0, 200) + '\n');
   process.exit(0);
 }

package/templates/.claude/hooks/check-docs-complete.cjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * check-docs-complete.cjs — the cheap question, asked before the expensive one.
+ *
+ * Phase 2 of /replicate launches a SWARM of validation agents over whatever Phase 1 produced. Between
+ * the two there was nothing: existence, emptiness and unfilled placeholders are decidable by this
+ * script, and sending a multi-agent swarm to discover them is a layer-1 check living at layer 3.
+ *
+ * NOT an event hook, like `state-update.cjs`, `check-ports.cjs` and `check-growth-trace.cjs`. This
+ * package's hooks are NON-BLOCKING by contract, so a hook could print but never refuse. Invoke it:
+ *
+ *   node .claude/hooks/check-docs-complete.cjs [path-to-project]
+ *
+ * Exit codes:
+ *   0  every required document exists, has content, and carries no unfilled placeholder
+ *   1  a NAMED document is missing, empty, or still a template
+ *   2  THE CHECK DID NOT RUN — no docs/ directory, or it could not be read
+ *
+ * Honest limit, and it is printed on the passing path: this proves the documents were WRITTEN, not
+ * that they are correct. Correctness is what the Phase-2 swarm is for; this only stops the swarm
+ * being spent discovering an empty file.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** What Phase 1 writes. `optional: true` mirrors replicate.md's own `(if applicable)`. */
+const DOCS = [
+  { file: 'PRD.md' },
+  { file: 'Solution_Strategy.md' },
+  { file: 'Specification.md' },
+  { file: 'Pseudocode.md' },
+  { file: 'Architecture.md' },
+  { file: 'Refinement.md' },
+  { file: 'Completion.md' },
+  { file: 'Research_Findings.md' },
+  { file: 'Final_Summary.md' },
+  { file: 'C4_Diagrams.md', optional: true },
+  { file: 'ADR.md', optional: true },
+];
+
+/** Below this a document has a heading and nothing under it. */
+const MIN_CHARS = 200;
+
+function say(s) { process.stdout.write(s + '\n'); }
+
+function cannotCheck(reason, hint) {
+  say('⚠️  проверка НЕ выполнена: ' + reason);
+  if (hint) say('    ' + hint);
+  process.exit(2);
+}
+
+/**
+ * Unfilled placeholders — and the reason this is split into two confidence levels.
+ *
+ * The first version used one rule: a bracketed token not followed by `(`. Cross-family review
+ * destroyed it with two inputs, both REPRODUCED before this rewrite:
+ *
+ *   1. `A[Web App]` — a mermaid node. The BUNDLED sparc-prd-mini skill REQUIRES mermaid diagrams in
+ *      Architecture.md (SKILL.md:570-583), so the gate blocked every normally generated project.
+ *   2. `[GAP: needs performance targets]` — which Phase 1 writes DELIBERATELY in --from-docs mode for
+ *      Phase 2 to resolve (replicate.md:82-94). Blocking on it deadlocks the documented flow: the
+ *      only step that can clear the marker is the one the gate refuses to start.
+ *
+ * The lesson is about CONFIDENCE, not about patterns. A false block here stops the whole pipeline,
+ * which is worse than a missed placeholder the Phase-2 swarm would have caught anyway. So:
+ *
+ *   BLOCKING  — shapes that cannot be anything else: `{{…}}`, TODO/TBD/XXX/FIXME.
+ *   WARNING   — bracketed prose. Reported by name, never blocking, because this script cannot tell
+ *               `[описание продукта]` from a diagram label or a citation without understanding the
+ *               document, and guessing wrong costs more than staying quiet.
+ */
+
+/** Fenced code blocks hold mermaid, arrays and code — none of it prose, none of it ours to judge. */
+function stripFences(body) {
+  return body.replace(/^```[\s\S]*?^```/gm, '').replace(/`[^`\n]*`/g, '');
+}
+
+const BLOCKING = [
+  { re: /\{\{[^}\n]{1,80}\}\}/g, what: 'незаполненный {{шаблон}}' },
+  { re: /(?<![\p{L}\p{N}])(TODO|TBD|XXX|FIXME)(?![\p{L}\p{N}])/giu, what: 'маркер TODO/TBD/XXX' },
+];
+
+/** A structured marker Phase 2 OWNS. It must reach Phase 2, so it is never a finding here. */
+const GAP = /\[GAP:[^\]\n]*\]/g;
+
+const SUSPECT = /\[[^\]\n]{1,80}\](?![(\[])/g;
+
+function scan(body) {
+  const clean = stripFences(body).replace(GAP, '');
+  const blocking = [];
+  for (const { re, what } of BLOCKING) {
+    re.lastIndex = 0;
+    for (let m = re.exec(clean); m !== null && blocking.length < 3; m = re.exec(clean)) {
+      blocking.push(what + ' «' + m[0].slice(0, 40) + '»');
+    }
+  }
+  const warn = [];
+  SUSPECT.lastIndex = 0;
+  for (let m = SUSPECT.exec(clean); m !== null && warn.length < 3; m = SUSPECT.exec(clean)) {
+    const t = m[0];
+    if (/^\[\^?\d+\]$/.test(t)) continue;          // a citation or footnote, not a placeholder
+    warn.push(t.slice(0, 40));
+  }
+  return { blocking, warn };
+}
+
+function main() {
+  const root = process.argv[2] || '.';
+  const docs = path.join(root, 'docs');
+  let st;
+  try { st = fs.statSync(docs); } catch {
+    cannotCheck('нет каталога ' + docs,
+      'Фаза 1 ещё не отработала — это НЕ «документы неполны», это «проверять нечего»');
+  }
+  if (!st.isDirectory()) cannotCheck(docs + ' существует, но это не каталог');
+
+  const problems = [];
+  const warnings = [];
+  let checked = 0;
+
+  for (const d of DOCS) {
+    const abs = path.join(docs, d.file);
+    let body;
+    try { body = fs.readFileSync(abs, 'utf-8'); } catch (e) {
+      if (e && e.code === 'ENOENT') {
+        if (!d.optional) problems.push(d.file + ': отсутствует');
+        continue;                                  // an optional absence is a legitimate answer
+      }
+      cannotCheck('не читается ' + d.file + ': ' + ((e && e.message) || e));
+    }
+    checked++;
+    if (body.trim().length < MIN_CHARS) {
+      problems.push(d.file + ': пуст или почти пуст (' + body.trim().length + ' симв., порог '
+        + MIN_CHARS + ')');
+      continue;
+    }
+    const { blocking, warn } = scan(body);
+    if (blocking.length) problems.push(d.file + ': остались ' + blocking.join(', '));
+    if (warn.length) warnings.push(d.file + ': возможно незаполнено — ' + warn.join(', '));
+  }
+
+  if (!checked) {
+    cannotCheck('в ' + docs + ' не нашлось ни одного SPARC-документа',
+      'каталог есть, но пуст — это не «всё в порядке»');
+  }
+
+  const sayWarnings = () => {
+    if (!warnings.length) return;
+    say('⚠️  на глаз (НЕ блокирует — скрипт не отличает шаблон от подписи к диаграмме):');
+    for (const w of warnings) say('   • ' + w);
+  };
+
+  if (problems.length) {
+    sayWarnings();
+    say('❌ документы Фазы 1 не готовы к валидации (' + problems.length + '):');
+    for (const p of problems) say('   • ' + p);
+    say('   Рой валидации запускать рано: он потратит агентов на то, что видно отсюда.');
+    process.exit(1);
+  }
+
+  sayWarnings();
+  say('✅ все обязательные документы на месте, непусты и без незаполненных шаблонов ('
+    + checked + ' проверено)');
+  say('   Ограничение: это доказывает, что документы НАПИСАНЫ, а не что они верны.');
+  say('   Верность — работа роя валидации Фазы 2; проверка лишь не даёт потратить его впустую.');
+  process.exit(0);
+}
+
+try { main(); } catch (err) {
+  cannotCheck('внутренняя ошибка проверки: ' + String((err && err.message) || err));
+}

package/templates/.claude/hooks/check-growth-trace.cjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * check-growth-trace.cjs — did the M5 growth analysis survive into the Specification, or was it
+ * analysed and dropped?
+ *
+ * NOT an event hook. Like `state-update.cjs` and `check-ports.cjs`, it lives here because this
+ * directory already carries plain Node utilities; nothing registers it in settings.json. This is
+ * deliberate and load-bearing: this package's hooks are NON-BLOCKING by contract (pinned by
+ * tests/unit/hooks-project-anchored.test.js, which requires exit 0), so a hook could never refuse
+ * anything — it could only print. Invoke it:
+ *
+ *   node .claude/hooks/check-growth-trace.cjs [path-to-project]
+ *
+ * Exit codes — three, and the third is the point:
+ *   0  every seed row is traced into docs/Specification.md, or rejected on the record
+ *   1  the seed table carries rows and the Specification traces none of them
+ *   2  THE CHECK DID NOT RUN — no brief, no Specification, or a seed table that would not parse
+ *
+ * A checker that answers "clean" when it could not look converts an unknown into a reassurance.
+ * An ABSENT brief means Phase 0 never ran (the --from-docs entry skips it); that is exit 2, never 0
+ * and never 1. "Phase 0 did not run" is not "nothing is missing".
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const BRIEF = path.join('docs', 'product-discovery-brief.md');
+const SPEC = path.join('docs', 'Specification.md');
+
+/** The exact token, case-sensitive. Not a title, not a paraphrase — the same definition the
+ *  validator's prose gate uses, so the two cannot disagree about what a mention is. */
+const ID = /\bFR-GROWTH-(\d{3})\b/g;
+
+/** A line that refuses an obligation. Shared by mentioned() and rejected() so the two rules cannot
+ *  disagree about what a refusal looks like. */
+const REJECT_WORD = /(отклон\w*|не берём|не беремся|не берем|rejected|declined|out of scope|вне области)/i;
+
+function say(s) { process.stdout.write(s + '\n'); }
+
+/** Exit 2 with a reason. Never merged with "clean": not-run and not-violated are different facts. */
+function cannotCheck(reason, hint) {
+  say('⚠️  проверка НЕ выполнена: ' + reason);
+  if (hint) say('    ' + hint);
+  process.exit(2);
+}
+
+/**
+ * Read one required file. Asks about the EXACT path — never lists a directory and matches names
+ * against the listing, because a listing answers a different question than "does this file exist"
+ * and the two diverge on case, symlinks and unicode normalisation.
+ */
+function readRequired(root, rel, absentReason, hint) {
+  const abs = path.join(root, rel);
+  let st;
+  try { st = fs.statSync(abs); } catch { cannotCheck(absentReason, hint); }
+  if (!st.isFile()) cannotCheck(rel + ' существует, но это не файл');
+  try { return fs.readFileSync(abs, 'utf-8'); } catch (e) {
+    cannotCheck('не читается ' + rel + ': ' + ((e && e.message) || e));
+  }
+  return '';
+}
+
+/**
+ * The seed rows, as the brief records them.
+ *
+ * A row is a markdown table row whose FIRST cell is an id. The template ships an example row with
+ * a placeholder id inside the module, so a row whose requirement cell is still a bracketed
+ * placeholder is a TEMPLATE row, not a real obligation, and counting it would let an untouched
+ * template look like a filled-in one.
+ */
+function seedRows(brief) {
+  const rows = [];
+  for (const raw of brief.split('\n')) {
+    const line = raw.trim();
+    if (!line.startsWith('|')) continue;
+    const cells = line.split('|').map((c) => c.trim());
+    // cells[0] is '' for a leading pipe; the id lives in cells[1]
+    const m = /^FR-GROWTH-(\d{3})$/.exec(cells[1] || '');
+    if (!m) continue;
+    const requirement = cells[2] || '';
+    const isPlaceholder = /^\[.*\]$/.test(requirement) || requirement === '...' || requirement === '';
+    if (isPlaceholder) continue;
+    const status = (cells[5] || cells[4] || '').toUpperCase();
+    rows.push({ id: cells[1], speculative: status.includes('SPECULATIVE') });
+  }
+  return rows;
+}
+
+/**
+ * Ids the Specification mentions, by the same definition the validator's prose gate uses.
+ *
+ * A REJECTION LINE IS NOT A MENTION. The two rules overlap on exactly the case that matters: a line
+ * reading `FR-GROWTH-001 rejected` contains the exact token, so a naive mention rule reports the
+ * obligation as carried forward — and the reason requirement on the rejection path is never reached.
+ * MEASURED before this fix: that line exited 0. Cross-family review found the reason-check hole; the
+ * hole was one layer deeper, in which of the two rules got to answer first.
+ */
+function mentioned(spec) {
+  const out = new Set();
+  for (const line of spec.split('\n')) {
+    if (REJECT_WORD.test(line)) continue;   // a refusal is decided by rejected(), which wants a reason
+    ID.lastIndex = 0;
+    for (let m = ID.exec(line); m !== null; m = ID.exec(line)) out.add(m[0]);
+  }
+  return out;
+}
+
+/**
+ * A row may also be REJECTED on the record instead of traced — the validator's prose gate says the
+ * same. A rejection is a line naming the id together with a rejection word AND a reason marker,
+ * because "FR-GROWTH-004 не берём" with nothing after it is indistinguishable from forgetting.
+ */
+function rejected(brief, spec, id) {
+  const re = new RegExp('^.*\\b' + id + '\\b.*$', 'gm');
+  for (const hay of [brief, spec]) {
+    for (const line of hay.match(re) || []) {
+      const m = REJECT_WORD.exec(line);
+      if (!m) continue;
+      // The reason must live AFTER the rejection word. Scanning the whole line was a false-clean:
+      // cross-family review found that `FR-GROWTH-001 rejected` passed, because the reason pattern
+      // included a bare hyphen and the IDENTIFIER contains two of them. MEASURED before the fix —
+      // that exact line exited 0. So: look only at the tail, and never at punctuation alone.
+      const tail = line.slice(m.index + m[0].length);
+      // A reason is WORDS, not a dash. A separator may introduce it but can never be it.
+      const hasReason = /[\p{L}\p{N}][\p{L}\p{N}\s]{6,}/u.test(tail.replace(/^[\s:—–-]+/, ''));
+      if (hasReason) return true;
+    }
+  }
+  return false;
+}
+
+function main() {
+  const root = process.argv[2] || '.';
+  try { if (!fs.statSync(root).isDirectory()) cannotCheck('это не каталог: ' + root); }
+  catch { cannotCheck('путь не существует: ' + root); }
+
+  const brief = readRequired(root, BRIEF,
+    'нет файла ' + BRIEF,
+    'это значит, что Фаза 0 не запускалась (вход --from-docs её пропускает) — а НЕ что требований по росту не нужно');
+
+  const rows = seedRows(brief);
+
+  // A REUSED id makes the brief malformed, and malformed is exit 2 — never a pass. The module's own
+  // rule is that a number is never reused; when it is, two distinct obligations share one token and
+  // a SINGLE mention in the Specification marks BOTH traced. Cross-family review found this, and it
+  // is the recurring shape: coverage counted over usable ITEMS instead of per POSITION.
+  const dupes = [...new Set(rows.map((r) => r.id).filter((id, i, a) => a.indexOf(id) !== i))];
+  if (dupes.length) {
+    cannotCheck('в таблице-семени повторяются идентификаторы: ' + dupes.join(', '),
+      'номер FR-GROWTH-nnn не переиспользуется — пока дубли не разведены, одно упоминание в '
+      + 'Specification.md зачло бы сразу два разных требования');
+  }
+
+  if (!rows.length) {
+    // An empty seed is a legitimate answer ("нет"), but it is not this checker's business: there is
+    // nothing to trace. Saying "clean" here would claim a check that did not happen.
+    cannotCheck('в брифе нет ни одной заполненной строки FR-GROWTH-nnn',
+      'либо M5 не запускался, либо таблица-семя осталась шаблоном — проверять нечего');
+  }
+
+  const spec = readRequired(root, SPEC, 'нет файла ' + SPEC,
+    'без спецификации не с чем сверять — это не «всё прослежено»');
+
+  const seen = mentioned(spec);
+  const missing = rows.filter((r) => !seen.has(r.id) && !rejected(brief, spec, r.id));
+
+  if (missing.length === rows.length) {
+    say('❌ ни одно требование по росту не доехало до ' + SPEC + ':');
+    for (const r of missing) say('   • ' + r.id + (r.speculative ? ' (SPECULATIVE)' : ''));
+    say('   Разбор роста сделан и выброшен — это ровно тот класс потерь, который ловит проверка.');
+    process.exit(1);
+  }
+  if (missing.length) {
+    say('❌ часть требований по росту потеряна (' + missing.length + ' из ' + rows.length + '):');
+    for (const r of missing) say('   • ' + r.id + (r.speculative ? ' (SPECULATIVE)' : ''));
+    say('   Каждое надо либо перенести в ' + SPEC + ', либо отклонить С ПРИЧИНОЙ — молча уронить нельзя.');
+    process.exit(1);
+  }
+  say('✅ все ' + rows.length + ' требований по росту прослежены в ' + SPEC + ' либо отклонены с причиной');
+  say('   Ограничение: это доказывает, что обязательство ДОНЕСЛИ, а не что его построили.');
+  process.exit(0);
+}
+
+try {
+  main();
+} catch (err) {
+  // Even an unexpected failure must not read as "clean".
+  cannotCheck('внутренняя ошибка проверки: ' + String((err && err.message) || err));
+}