@claude-flow/cli 3.12.4 → 3.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.12.4",
+  "version": "3.13.0",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -113,9 +113,10 @@
     "@claude-flow/memory": "^3.0.0-alpha.20",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@claude-flow/security": "^3.0.0-alpha.10",
+    "@metaharness/darwin": "~0.3.1",
     "@metaharness/kernel": "~0.1.0",
     "@metaharness/router": "~0.3.2",
-    "metaharness": "~0.1.11",
+    "metaharness": "~0.2.6",
     "@ruvector/attention": "^0.1.32",
     "@ruvector/attention-darwin-arm64": "0.1.32",
     "@ruvector/diskann": "^0.1.0",

package/plugins/ruflo-metaharness/scripts/_darwin.mjs

@@ -0,0 +1,200 @@
+// _darwin.mjs — shared invocation helper for the `@metaharness/darwin` CLI.
+//
+// Mirrors `_harness.mjs` for the umbrella `metaharness` / `harness` binaries,
+// but targets the separate darwin binary (`metaharness-darwin`) which is
+// published as its own npm package (`@metaharness/darwin@~0.3.1`).
+//
+// Three subcommands surfaced (matches darwin 0.3.x):
+//   - `metaharness-darwin evolve <repo> [...]`         — harness self-improvement
+//   - `metaharness-darwin bench <create|verify> ...`   — bench-suite lifecycle
+//   - `metaharness-darwin security bench [...]`        — Darwin Shield (upstream ADR-155)
+//
+// CONTRACT (identical to runMetaharness/runHarness):
+//   - returns `{ stdout, stderr, exitCode, json|null, durationMs, degraded, reason? }`
+//   - `--json` is appended automatically when `opts.json !== false`
+//   - subprocess hard timeout (default 60s, override with opts.timeoutMs)
+//   - on MODULE_NOT_FOUND / network failure / "not installed", returns
+//     `degraded: true, reason: 'metaharness-darwin-not-available'` — never throws
+//     (ADR-150 graceful-degradation rule #3; ADR-153 §"Architecture" constraint 3)
+//
+// IMPORTANT — evolve has long timeouts:
+//   `evolve` is the only long-running verb in the metaharness family. A real
+//   evolution with --generations 10 --children 5 --concurrency 2 takes
+//   minutes-to-hours, NOT seconds. Callers MUST pass an explicit `timeoutMs`
+//   matched to their --generations × --children × sandbox cost; the 60s
+//   default is for `bench verify` and `security bench --population 2 --cycles 1`
+//   smoke shapes only.
+
+import { spawnSync, spawn } from 'node:child_process';
+
+const DEFAULT_TIMEOUT_MS = 60_000;
+
+// Pinned semver range. Bump in lock-step with optionalDependencies in
+// @claude-flow/cli/package.json + ruflo/package.json. The `~` allows
+// patch upgrades without re-pinning.
+const DARWIN_PIN = '@metaharness/darwin@~0.3.1';
+
+const DEGRADED_RX = /could not determine executable|404|not installed|MODULE_NOT_FOUND|ENOTFOUND|getaddrinfo|ECONNREFUSED|ETIMEDOUT/i;
+
+function buildArgv(args, wantJson) {
+  // `metaharness-darwin` historically does NOT take --json on every
+  // subcommand (some emit plain text reports — security bench in
+  // particular is markdown). We still append --json for callers that
+  // explicitly request it, but never silently inject it on subcommands
+  // that don't accept it. The shape that does support --json is the
+  // single-verb `evolve` and `bench verify`.
+  if (!wantJson || args.includes('--json')) return args;
+  return [...args, '--json'];
+}
+
+function classifyDegraded(stderr, exitCode) {
+  if (exitCode === null) return { degraded: true, reason: 'metaharness-darwin-timeout' };
+  if (DEGRADED_RX.test(stderr)) return { degraded: true, reason: 'metaharness-darwin-not-available' };
+  return { degraded: false };
+}
+
+function maybeParseJson(stdout) {
+  // darwin's evolve emits a final JSON object at end of stdout when --json
+  // is passed; everything before is human-readable progress. Grab the LAST
+  // {...} block, not the first — the first may be a per-generation log line.
+  const matches = [...stdout.matchAll(/\{[\s\S]*?\}/g)];
+  if (matches.length === 0) return null;
+  // Try last match first; fall back to greedy single-block match.
+  for (let i = matches.length - 1; i >= 0; i--) {
+    try { return JSON.parse(matches[i][0]); } catch { /* try previous */ }
+  }
+  const greedy = /\{[\s\S]*\}/.exec(stdout);
+  if (greedy) { try { return JSON.parse(greedy[0]); } catch { return null; } }
+  return null;
+}
+
+/**
+ * Sync invocation. Use for short subcommands (`bench verify`, smoke shapes).
+ * Async variant below for long-running `evolve` calls.
+ */
+export function runDarwin(args, opts = {}) {
+  const start = Date.now();
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const wantJson = opts.json !== false;
+  const argv = buildArgv(args, wantJson);
+  const r = spawnSync('npx', ['-y', '-p', DARWIN_PIN, 'metaharness-darwin', ...argv], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf-8',
+    timeout: timeoutMs,
+    cwd: opts.cwd,
+    env: { ...process.env, ...(opts.env || {}) },
+    shell: process.platform === 'win32',
+  });
+  const durationMs = Date.now() - start;
+  const stdout = r.stdout || '';
+  const stderr = r.stderr || '';
+  const classified = classifyDegraded(stderr, r.status);
+  if (classified.degraded) {
+    return {
+      stdout, stderr,
+      exitCode: r.status ?? 127,
+      json: null,
+      durationMs,
+      degraded: true,
+      reason: classified.reason,
+    };
+  }
+  return {
+    stdout, stderr,
+    exitCode: r.status ?? 0,
+    json: wantJson ? maybeParseJson(stdout) : null,
+    durationMs,
+    degraded: false,
+  };
+}
+
+/**
+ * Async invocation with streaming. Required for `evolve` because the run
+ * can take 10+ minutes and the caller wants progress visibility.
+ *
+ * If `opts.onProgress(line)` is provided, called once per stderr line.
+ * darwin writes per-generation progress to stderr, structured result to
+ * stdout. Cancellable via opts.signal (AbortSignal).
+ */
+export function runDarwinAsync(args, opts = {}) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const wantJson = opts.json !== false;
+    const argv = buildArgv(args, wantJson);
+    const p = spawn('npx', ['-y', '-p', DARWIN_PIN, 'metaharness-darwin', ...argv], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: opts.cwd,
+      env: { ...process.env, ...(opts.env || {}) },
+      shell: process.platform === 'win32',
+    });
+    let stdout = '', stderr = '', stderrBuf = '';
+    p.stdout?.on('data', (d) => { stdout += d.toString(); });
+    p.stderr?.on('data', (d) => {
+      const s = d.toString();
+      stderr += s;
+      if (opts.onProgress) {
+        stderrBuf += s;
+        const lines = stderrBuf.split('\n');
+        stderrBuf = lines.pop() ?? '';
+        for (const line of lines) opts.onProgress(line);
+      }
+    });
+    const timer = setTimeout(() => {
+      try { p.kill('SIGTERM'); } catch { /* ignore */ }
+    }, timeoutMs);
+    if (opts.signal) {
+      opts.signal.addEventListener('abort', () => {
+        try { p.kill('SIGTERM'); } catch { /* ignore */ }
+      }, { once: true });
+    }
+    p.on('error', (e) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr: stderr + String(e?.message ?? e),
+        exitCode: 127, json: null, durationMs: Date.now() - start,
+        degraded: true, reason: 'metaharness-darwin-not-available',
+      });
+    });
+    p.on('close', (code) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      const classified = classifyDegraded(stderr, code);
+      if (classified.degraded) {
+        resolve({
+          stdout, stderr,
+          exitCode: code ?? 127, json: null, durationMs,
+          degraded: true, reason: classified.reason,
+        });
+        return;
+      }
+      resolve({
+        stdout, stderr,
+        exitCode: code ?? 0,
+        json: wantJson ? maybeParseJson(stdout) : null,
+        durationMs,
+        degraded: false,
+      });
+    });
+  });
+}
+
+/**
+ * Match the existing `emitDegradedJsonAndExit` shape used by the
+ * metaharness-umbrella scripts so MCP tool consumers see one contract.
+ */
+export function emitDarwinDegradedJsonAndExit(reason) {
+  const payload = {
+    degraded: true,
+    reason,
+    hint: 'Install with `npm i -D ' + DARWIN_PIN + '` or run `npx -y ' + DARWIN_PIN + ' --help` to verify network access.',
+    generatedAt: new Date().toISOString(),
+  };
+  console.log(JSON.stringify(payload, null, 2));
+  // Exit 0 — ADR-150 architectural constraint: ruflo continues to function
+  // when MetaHarness is absent. Same posture as the umbrella scripts.
+  process.exit(0);
+}
+
+export const DARWIN_VERSION_PIN = DARWIN_PIN;

package/plugins/ruflo-metaharness/scripts/bench.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// bench.mjs — wrapper around `metaharness-darwin bench <create|verify>`.
+//
+// Bench suites are JSON files describing a corpus of (input, expected-output)
+// tasks. `evolve --bench <suite.json>` scores each variant against the
+// corpus instead of (or in addition to) the project's test command, which
+// lets you evolve a harness against a fixed evaluation set independent of
+// the repo's natural tests. `bench create` scaffolds a suite from a repo;
+// `bench verify` checks a suite parses and every task is well-formed.
+//
+// USAGE
+//   node scripts/bench.mjs --op create --repo .              # scaffold suite.json from current dir
+//   node scripts/bench.mjs --op create --repo . --out /tmp/foo.json
+//   node scripts/bench.mjs --op verify --suite /tmp/foo.json
+//
+// EXIT CODES
+//   0  ok (or degraded — Darwin not available)
+//   1  --op verify and any task malformed
+//   2  config error or upstream invocation failure
+
+import { runDarwin, emitDarwinDegradedJsonAndExit } from './_darwin.mjs';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const ARGS = (() => {
+  const a = { op: null, repo: '.', suite: null, out: null, format: 'json' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--op') a.op = process.argv[++i];
+    else if (v === '--repo') a.repo = process.argv[++i];
+    else if (v === '--suite') a.suite = process.argv[++i];
+    else if (v === '--out') a.out = process.argv[++i];
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+function safetyChecks() {
+  if (!['create', 'verify'].includes(ARGS.op)) {
+    console.error('bench: --op must be create|verify');
+    process.exit(2);
+  }
+  if (ARGS.op === 'create' && !existsSync(resolve(ARGS.repo))) {
+    console.error(`bench: --repo path does not exist: ${ARGS.repo}`);
+    process.exit(2);
+  }
+  if (ARGS.op === 'verify' && !ARGS.suite) {
+    console.error('bench: --suite is required for verify');
+    process.exit(2);
+  }
+  if (ARGS.op === 'verify' && !existsSync(resolve(ARGS.suite))) {
+    console.error(`bench: --suite path does not exist: ${ARGS.suite}`);
+    process.exit(2);
+  }
+}
+
+function main() {
+  safetyChecks();
+
+  const cliArgs = ARGS.op === 'create'
+    ? ['bench', 'create', resolve(ARGS.repo), ...(ARGS.out ? ['--out', resolve(ARGS.out)] : [])]
+    : ['bench', 'verify', resolve(ARGS.suite)];
+
+  const r = runDarwin(cliArgs, { timeoutMs: 60_000 });
+
+  if (r.degraded) {
+    emitDarwinDegradedJsonAndExit(r.reason);
+    return;
+  }
+
+  if (r.exitCode !== 0 && r.exitCode !== 1) {
+    const payload = {
+      success: false,
+      data: { exitCode: r.exitCode, stderrTail: r.stderr.slice(-400) },
+      generatedAt: new Date().toISOString(),
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(2);
+  }
+
+  const payload = {
+    success: r.exitCode === 0,
+    data: {
+      op: ARGS.op,
+      ...(r.json ?? { stdoutTail: r.stdout.slice(-2000) }),
+      durationMs: r.durationMs,
+    },
+    generatedAt: new Date().toISOString(),
+  };
+
+  console.log(JSON.stringify(payload, null, 2));
+  process.exit(r.exitCode);
+}
+
+main();

package/plugins/ruflo-metaharness/scripts/evolve.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+// evolve.mjs — wrapper around `metaharness-darwin evolve <repo>`.
+//
+// ADR-153: Darwin Mode is the WRITE layer that closes the loop ADR-150's
+// READ layer (score / genome / mcp-scan / threat-model / oia-audit) opens.
+// score+genome tell you where the harness IS; darwin evolve tells you which
+// mutation makes it provably better, without retraining the foundation model.
+//
+// SAFETY (ADR-153 §"Safety model"):
+//   - Variant generation + sandbox happen under <repo>/.metaharness/variants/,
+//     never in the repo root. Upstream `inspectVariant()` rejects nested dirs,
+//     symlinks, secret-shaped strings, shell-out / network / dynamic-eval
+//     before any variant runs. Exit code 99 is reserved for "safety-disqualified".
+//   - --confirm is REQUIRED. Without it the script prints a plan and exits 0
+//     (mirrors mint.mjs convention). This is in addition to upstream's safety
+//     layer — defense in depth at the ruflo boundary.
+//   - Default --generations 3 --children 3 (small) — anything larger is opt-in.
+//     Real evolutions are minutes-to-hours; ruflo's default sandbox config
+//     errs toward "show me the mechanism works" over "find a winner today".
+//
+// USAGE
+//   node scripts/evolve.mjs --repo .                                       # dry-run plan
+//   node scripts/evolve.mjs --repo . --confirm                             # actually evolve
+//   node scripts/evolve.mjs --repo . --confirm --generations 5 --children 3
+//   node scripts/evolve.mjs --repo . --confirm --sandbox mock              # no real tests
+//   node scripts/evolve.mjs --repo . --confirm --selection pareto
+//
+// EXIT CODES
+//   0  evolved OK (or dry-run, or degraded — MetaHarness Darwin not available)
+//   1  --alert-on-no-improvement and champion did not beat parent
+//   2  config error or evolution failure
+//   99 reserved — upstream "safety-disqualified" (propagated)
+
+import { runDarwinAsync, emitDarwinDegradedJsonAndExit } from './_darwin.mjs';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const ARGS = (() => {
+  const a = {
+    repo: '.',
+    generations: 3,
+    children: 3,
+    concurrency: 2,
+    seed: null,
+    sandbox: 'real',
+    selection: null,
+    crossover: false,
+    epistasis: false,
+    curriculum: false,
+    riskBudget: null,
+    fdr: null,
+    tie: null,
+    bench: null,
+    mutator: 'deterministic',
+    ruvllmUrl: null,
+    ruvllmModel: null,
+    confirm: false,
+    alertOnNoImprovement: false,
+    format: 'json',
+    timeoutMs: null,  // computed below if unset
+  };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--repo') a.repo = process.argv[++i];
+    else if (v === '--generations') a.generations = parseInt(process.argv[++i], 10);
+    else if (v === '--children') a.children = parseInt(process.argv[++i], 10);
+    else if (v === '--concurrency') a.concurrency = parseInt(process.argv[++i], 10);
+    else if (v === '--seed') a.seed = parseInt(process.argv[++i], 10);
+    else if (v === '--sandbox') a.sandbox = process.argv[++i];
+    else if (v === '--selection') a.selection = process.argv[++i];
+    else if (v === '--crossover') a.crossover = true;
+    else if (v === '--epistasis') a.epistasis = true;
+    else if (v === '--curriculum') a.curriculum = true;
+    else if (v === '--risk-budget') a.riskBudget = parseInt(process.argv[++i], 10);
+    else if (v === '--fdr') a.fdr = parseFloat(process.argv[++i]);
+    else if (v === '--tie') a.tie = process.argv[++i];
+    else if (v === '--bench') a.bench = process.argv[++i];
+    else if (v === '--mutator') a.mutator = process.argv[++i];
+    else if (v === '--ruvllm-url') a.ruvllmUrl = process.argv[++i];
+    else if (v === '--ruvllm-model') a.ruvllmModel = process.argv[++i];
+    else if (v === '--confirm') a.confirm = true;
+    else if (v === '--alert-on-no-improvement') a.alertOnNoImprovement = true;
+    else if (v === '--format') a.format = process.argv[++i];
+    else if (v === '--timeout-ms') a.timeoutMs = parseInt(process.argv[++i], 10);
+  }
+  return a;
+})();
+
+function safetyChecks() {
+  const repoPath = resolve(ARGS.repo);
+  if (!existsSync(repoPath)) {
+    console.error(`evolve: repo path does not exist: ${repoPath}`);
+    process.exit(2);
+  }
+  if (ARGS.generations < 1 || ARGS.generations > 50) {
+    console.error('evolve: --generations must be 1..50 (ruflo cap; upstream supports more)');
+    process.exit(2);
+  }
+  if (ARGS.children < 1 || ARGS.children > 20) {
+    console.error('evolve: --children must be 1..20 (ruflo cap)');
+    process.exit(2);
+  }
+  if (ARGS.concurrency < 1 || ARGS.concurrency > 8) {
+    console.error('evolve: --concurrency must be 1..8 (ruflo cap)');
+    process.exit(2);
+  }
+  if (!['real', 'mock', 'agent'].includes(ARGS.sandbox)) {
+    console.error(`evolve: --sandbox must be real|mock|agent (got: ${ARGS.sandbox})`);
+    process.exit(2);
+  }
+  if (ARGS.selection && !['quality-diversity', 'behavioral-diversity', 'niche-steering', 'clade', 'pareto'].includes(ARGS.selection)) {
+    console.error(`evolve: --selection must be one of quality-diversity|behavioral-diversity|niche-steering|clade|pareto`);
+    process.exit(2);
+  }
+  if (!['deterministic', 'ruvllm'].includes(ARGS.mutator)) {
+    console.error(`evolve: --mutator must be deterministic|ruvllm`);
+    process.exit(2);
+  }
+  return repoPath;
+}
+
+// Compute a sensible timeout from the search shape if caller didn't specify.
+// Rough budget: each variant ~= 30s (sandbox test command + safety inspect),
+// total ~= generations × children × per-variant / concurrency.
+function defaultTimeoutMs() {
+  const perVariantMs = ARGS.sandbox === 'mock' ? 2_000 : 60_000;
+  const variants = ARGS.generations * ARGS.children;
+  const parallelism = Math.min(ARGS.concurrency, variants);
+  const wall = Math.ceil(variants / parallelism) * perVariantMs;
+  // Add 30s overhead for npm install + initial profile + final report.
+  return Math.max(60_000, wall + 30_000);
+}
+
+async function main() {
+  const repoPath = safetyChecks();
+
+  const plan = {
+    binary: 'metaharness-darwin evolve',
+    repo: repoPath,
+    generations: ARGS.generations,
+    children: ARGS.children,
+    concurrency: ARGS.concurrency,
+    sandbox: ARGS.sandbox,
+    selection: ARGS.selection,
+    crossover: ARGS.crossover,
+    epistasis: ARGS.epistasis,
+    curriculum: ARGS.curriculum,
+    mutator: ARGS.mutator,
+    estVariants: ARGS.generations * ARGS.children,
+    timeoutMs: ARGS.timeoutMs ?? defaultTimeoutMs(),
+    output: `${repoPath}/.metaharness/{archive.json, lineage.json, variants/, runs/, reports/winner.json}`,
+  };
+
+  if (!ARGS.confirm) {
+    const payload = {
+      success: true,
+      data: { plan, dryRun: true, message: 'Pass --confirm to run the evolution.' },
+      generatedAt: new Date().toISOString(),
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(0);
+  }
+
+  const cliArgs = ['evolve', repoPath,
+    '--generations', String(ARGS.generations),
+    '--children', String(ARGS.children),
+    '--concurrency', String(ARGS.concurrency),
+    '--sandbox', ARGS.sandbox,
+    '--mutator', ARGS.mutator,
+  ];
+  if (ARGS.seed != null) cliArgs.push('--seed', String(ARGS.seed));
+  if (ARGS.selection) cliArgs.push('--selection', ARGS.selection);
+  if (ARGS.crossover) cliArgs.push('--crossover');
+  if (ARGS.epistasis) cliArgs.push('--epistasis');
+  if (ARGS.curriculum) cliArgs.push('--curriculum');
+  if (ARGS.riskBudget != null) cliArgs.push('--risk-budget', String(ARGS.riskBudget));
+  if (ARGS.fdr != null) cliArgs.push('--fdr', String(ARGS.fdr));
+  if (ARGS.tie) cliArgs.push('--tie', ARGS.tie);
+  if (ARGS.bench) cliArgs.push('--bench', ARGS.bench);
+  if (ARGS.ruvllmUrl) cliArgs.push('--ruvllm-url', ARGS.ruvllmUrl);
+  if (ARGS.ruvllmModel) cliArgs.push('--ruvllm-model', ARGS.ruvllmModel);
+
+  // Forward progress lines to stderr so the user sees per-generation activity
+  // (subprocess-of-an-MCP-tool case: this still surfaces in the agent log).
+  const r = await runDarwinAsync(cliArgs, {
+    timeoutMs: plan.timeoutMs,
+    onProgress: (line) => { if (line.trim()) process.stderr.write(`[evolve] ${line}\n`); },
+  });
+
+  if (r.degraded) {
+    emitDarwinDegradedJsonAndExit(r.reason);
+    return;
+  }
+
+  // Upstream exit code 99 = safety-disqualified — propagate verbatim so
+  // CI gates can distinguish "evolution failed" from "evolution surfaced
+  // a safety-tripping mutation". This is a designed-in tripwire, not an
+  // error the ruflo layer should remap.
+  if (r.exitCode === 99) {
+    const payload = {
+      success: false,
+      data: { safetyDisqualified: true, hint: 'A variant tripped the safety inspection layer. See <repo>/.metaharness/runs/ for which surface and pattern.' },
+      stderrTail: r.stderr.slice(-400),
+      durationMs: r.durationMs,
+      generatedAt: new Date().toISOString(),
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(99);
+  }
+
+  if (r.exitCode !== 0) {
+    const payload = {
+      success: false,
+      data: { exitCode: r.exitCode, stderrTail: r.stderr.slice(-400) },
+      generatedAt: new Date().toISOString(),
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(2);
+  }
+
+  const champion = r.json || {};
+  const noImprovement = champion.parentScore != null && champion.championScore != null &&
+                        champion.championScore <= champion.parentScore;
+
+  const payload = {
+    success: true,
+    data: {
+      ...champion,
+      plan,
+      durationMs: r.durationMs,
+      improved: !noImprovement,
+    },
+    generatedAt: new Date().toISOString(),
+  };
+
+  console.log(JSON.stringify(payload, null, 2));
+  if (ARGS.alertOnNoImprovement && noImprovement) process.exit(1);
+  process.exit(0);
+}
+
+main().catch((e) => {
+  console.error(`evolve: unexpected failure: ${e?.message ?? e}`);
+  process.exit(2);
+});