@mindrian_os/install 1.13.0-beta.17 → 1.13.0-beta.19

package/lib/hmi/shape-f7-breakthrough-renderer.test.cjs

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 120-01 Task 1 -- F.7 Breakthrough Surface renderer test suite.
+ *
+ * Per 120-01-PLAN.md behavior tests (11 tests):
+ *   T1  F7_VERBS verbatim lock (5 strings, exact order, Object.freeze invariant)
+ *   T2  F7_DISMISS_INDEX === 3 (zero-indexed position of 'Dismiss')
+ *   T3  renderShapeF7Breakthrough happy path (contract envelope)
+ *   T4  Two-row layout (title + verbs)
+ *   T5  [Dismiss] MANDATORY guard (D-10 -- assertContractInvariants refuses without 'Dismiss')
+ *   T6  D-20 HARD FLOOR -- empty artifact_ids returns {error: 'provenance_required'}
+ *   T7  "More breakthroughs (N)" affordance (D-11; only when more_count > 0)
+ *   T8  Closed-vocab carve-out -- contract.freeTextOffered === false; no Free-Text
+ *   T9  formatTimeAnchor buckets (in the last hour / today / this week / etc.)
+ *   T10 Canon Part 8 source-grep (zero brain-client / fetch brain.mindrian / cross-room aggregat*)
+ *   T11 Em-dash invariant (HARD RULE; zero U+2014 in the renderer source)
+ *
+ * Pure CJS, node built-ins only, zero deps (Phase 87 invariant).
+ */
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const RENDERER_PATH = path.resolve(__dirname, 'shape-f7-breakthrough-renderer.cjs');
+const renderer = require('./shape-f7-breakthrough-renderer.cjs');
+const {
+  renderShapeF7Breakthrough,
+  F7_VERBS,
+  F7_DISMISS_INDEX,
+  formatTimeAnchor,
+  assertContractInvariants,
+  KIND_DISPLAY_NAMES,
+} = renderer;
+
+// --- T1: F7_VERBS verbatim lock ---
+test('T1: F7_VERBS is the 5 verbs verbatim in exact order', () => {
+  assert.deepEqual(F7_VERBS, ['Explore deeper', 'Confirm', 'File as decision', 'Dismiss', 'Back']);
+  assert.equal(F7_VERBS.length, 5);
+});
+
+test('T1b: F7_VERBS is Object.freeze-d -- mutation does not change the array', () => {
+  const before = F7_VERBS.slice();
+  // Frozen arrays: push throws in strict mode OR silently no-ops in sloppy mode.
+  // Either way, the canonical array contents must be unchanged after the attempt.
+  try { F7_VERBS.push('Free-Text'); } catch (_e) { /* expected in strict */ }
+  assert.deepEqual(F7_VERBS.slice(0, 5), before);
+  assert.equal(F7_VERBS.length, 5, 'mutation must not extend the frozen array');
+});
+
+// --- T2: F7_DISMISS_INDEX ---
+test('T2: F7_DISMISS_INDEX === 3 (zero-indexed slot of Dismiss in F7_VERBS)', () => {
+  assert.equal(F7_DISMISS_INDEX, 3);
+  assert.equal(F7_VERBS[F7_DISMISS_INDEX], 'Dismiss');
+});
+
+// --- T3: happy path ---
+test('T3: renderShapeF7Breakthrough returns canonical {zones, contract} envelope', () => {
+  const now = Date.now();
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: {
+      id: 'bk:1',
+      kind: 'convergence',
+      theme: 'X',
+      confidence: 0.55,
+      artifact_ids: ['a1', 'a2', 'a3', 'a4'],
+      detected_at: now - 3600 * 1000,
+    },
+    more_count: 2,
+  });
+  assert.equal(typeof out, 'object');
+  assert.equal(out.contract.shape, 'F.7');
+  assert.deepEqual(out.contract.verbs, F7_VERBS);
+  assert.equal(out.contract.freeTextOffered, false);
+  assert.equal(out.contract.mode, 'closed');
+  assert.equal(out.contract.recommended, null);
+  assert.equal(out.contract.breakthrough_id, 'bk:1');
+  assert.equal(out.contract.more_count, 2);
+  assert.equal(typeof out.zones.header, 'string');
+  assert.equal(typeof out.zones.body, 'string');
+});
+
+// --- T4: two-row layout ---
+test('T4: zones.body contains title row + 5-verb row with [X] brackets', () => {
+  const now = Date.now();
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: {
+      id: 'bk:1',
+      kind: 'convergence',
+      theme: 'X',
+      artifact_ids: ['a1', 'a2', 'a3'],
+      detected_at: now - 1800 * 1000,
+    },
+    more_count: 0,
+  });
+  // Row 1: title with kind capitalized + theme + time anchor
+  assert.match(out.zones.body, /Convergence: X/);
+  assert.match(out.zones.body, /\(in the last hour\)/i);
+  // Row 2: 5 verbs in [X] brackets in the locked order
+  assert.match(out.zones.body, /\[Explore deeper\]/);
+  assert.match(out.zones.body, /\[Confirm\]/);
+  assert.match(out.zones.body, /\[File as decision\]/);
+  assert.match(out.zones.body, /\[Dismiss\]/);
+  assert.match(out.zones.body, /\[Back\]/);
+});
+
+// --- T5: D-10 mandatory Dismiss guard ---
+test('T5: assertContractInvariants refuses a verbs array missing Dismiss (D-10 MANDATORY)', () => {
+  // Direct invariant call: a verbs array with the same length but Dismiss replaced.
+  const broken = ['Explore deeper', 'Confirm', 'File as decision', 'NotDismiss', 'Back'];
+  const result = assertContractInvariants(broken);
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, 'dismiss_required');
+});
+
+test('T5b: assertContractInvariants refuses a wrong-count verbs array', () => {
+  const tooShort = ['Explore deeper', 'Confirm', 'File as decision', 'Dismiss'];
+  const r1 = assertContractInvariants(tooShort);
+  assert.equal(r1.ok, false);
+  assert.equal(r1.reason, 'verb_count_mismatch');
+
+  const wrong = ['Explore deeper', 'wrongverb', 'File as decision', 'Dismiss', 'Back'];
+  const r2 = assertContractInvariants(wrong);
+  assert.equal(r2.ok, false);
+  assert.equal(r2.reason, 'verb_order_mismatch');
+});
+
+// --- T6: D-20 HARD FLOOR -- empty artifact_ids ---
+test('T6: D-20 HARD FLOOR -- empty artifact_ids returns {error: provenance_required}', () => {
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: { id: 'bk:1', kind: 'convergence', theme: 'X', artifact_ids: [], detected_at: Date.now() },
+    more_count: 0,
+  });
+  assert.equal(typeof out, 'object');
+  assert.equal(out.error, 'provenance_required');
+  assert.equal(out.zones, undefined);
+  assert.equal(out.contract, undefined);
+});
+
+test('T6b: missing breakthrough returns provenance_required', () => {
+  const out = renderShapeF7Breakthrough({ tier: 1, more_count: 0 });
+  assert.equal(out.error, 'provenance_required');
+});
+
+test('T6c: artifact_ids not an array returns provenance_required', () => {
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: { id: 'bk:1', kind: 'convergence', theme: 'X', artifact_ids: 'not-array', detected_at: Date.now() },
+    more_count: 0,
+  });
+  assert.equal(out.error, 'provenance_required');
+});
+
+// --- T7: More breakthroughs (N) affordance ---
+test('T7: more_count > 0 renders "More breakthroughs (N)" in zones.footer', () => {
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: { id: 'bk:1', kind: 'convergence', theme: 'X', artifact_ids: ['a1'], detected_at: Date.now() },
+    more_count: 2,
+  });
+  assert.match(out.zones.footer, /More breakthroughs \(2\)/);
+});
+
+test('T7b: more_count === 0 leaves zones.footer empty (no affordance)', () => {
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: { id: 'bk:1', kind: 'convergence', theme: 'X', artifact_ids: ['a1'], detected_at: Date.now() },
+    more_count: 0,
+  });
+  assert.equal(out.zones.footer.indexOf('More breakthroughs'), -1);
+});
+
+// --- T8: closed-vocab carve-out ---
+test('T8: contract.freeTextOffered === false; verbs does NOT contain Free-Text', () => {
+  const out = renderShapeF7Breakthrough({
+    tier: 1,
+    breakthrough: { id: 'bk:1', kind: 'convergence', theme: 'X', artifact_ids: ['a1'], detected_at: Date.now() },
+    more_count: 0,
+  });
+  assert.equal(out.contract.freeTextOffered, false);
+  assert.equal(out.contract.verbs.indexOf('Free-Text'), -1);
+  assert.equal(out.contract.verbs.length, 5);
+});
+
+// --- T9: formatTimeAnchor buckets ---
+test('T9: formatTimeAnchor returns the correct bucket string per age', () => {
+  const now = Date.now();
+  // < 1 hour -> "in the last hour"
+  assert.equal(formatTimeAnchor(now - 30 * 60 * 1000), 'in the last hour');
+  // 1-8 hours -> "in the last N hours"
+  assert.match(formatTimeAnchor(now - 4 * 3600 * 1000), /in the last \d+ hours/);
+  // 8-24 hours -> "today"
+  assert.equal(formatTimeAnchor(now - 12 * 3600 * 1000), 'today');
+  // 1-2 days -> "in the last day"
+  assert.equal(formatTimeAnchor(now - 36 * 3600 * 1000), 'in the last day');
+  // 2-7 days -> "this week"
+  assert.equal(formatTimeAnchor(now - 4 * 24 * 3600 * 1000), 'this week');
+  // 7-14 days -> "in the last two weeks"
+  assert.equal(formatTimeAnchor(now - 10 * 24 * 3600 * 1000), 'in the last two weeks');
+  // > 14 days -> "on YYYY-MM-DD"
+  assert.match(formatTimeAnchor(now - 30 * 24 * 3600 * 1000), /^on \d{4}-\d{2}-\d{2}$/);
+});
+
+// --- T10: Canon Part 8 source-grep ---
+test('T10: Canon Part 8 invariant -- zero brain-client / brain.mindrian / cross-room aggregat in renderer source', () => {
+  const src = fs.readFileSync(RENDERER_PATH, 'utf8');
+  assert.equal(/require\([^)]*brain-client[^)]*\)/.test(src), false, 'must not require brain-client');
+  assert.equal(/fetch\([^)]*brain\.mindrian[^)]*\)/.test(src), false, 'must not fetch brain.mindrian');
+  assert.equal(/cross.{0,3}room.{0,3}aggregat/i.test(src), false, 'must not mention cross-room aggregat');
+});
+
+// --- T11: em-dash invariant ---
+test('T11: em-dash invariant -- zero U+2014 in renderer source (HARD RULE)', () => {
+  const src = fs.readFileSync(RENDERER_PATH, 'utf8');
+  // U+2014 is the em-dash. The test file itself avoids the literal char so this
+  // suite stays em-dash-free.
+  const emDash = String.fromCharCode(0x2014);
+  assert.equal(src.indexOf(emDash), -1, 'renderer source must contain zero em-dashes');
+});
+
+// --- Bonus: KIND_DISPLAY_NAMES sanity ---
+test('Bonus: KIND_DISPLAY_NAMES covers the four known detector kinds', () => {
+  assert.equal(KIND_DISPLAY_NAMES.convergence, 'Convergence');
+  assert.equal(KIND_DISPLAY_NAMES.contradiction_resolved, 'Contradiction resolved');
+  assert.equal(KIND_DISPLAY_NAMES.cross_domain_analogy, 'Cross-domain analogy');
+  assert.equal(KIND_DISPLAY_NAMES.reverse_salient_closed, 'Reverse salient closed');
+});

package/lib/memory/body-shape-coverage.test.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 121.5-01 Task 2 -- Body-shape coverage acceptance tests.
+ *
+ * Verifies scripts/audit-body-shape-coverage.cjs and output-styles/destijl.md.
+ * The audit script is the CI tripwire that scans commands/*.md frontmatter for
+ * body_shape: presence and a valid value from the locked vocabulary. The
+ * output style is the system-prompt-enforced 4-zone De Stijl format that lifts
+ * SKILL.md from skill-instruction-suggested to force-for-plugin-enforced.
+ *
+ * Canon references:
+ *   Part 3 UI Ruling System -- this test enforces the body_shape contract
+ *           that the ruling system depends on.
+ *   Part 7 Reuse Before Build -- no new commands are created; this is a
+ *           pure compliance + infrastructure pass.
+ *   Part 8 Graph Boundary -- audit script + output style add zero network
+ *           surface, zero Brain calls, zero telemetry egress.
+ *
+ * Test map (7 cases, one-to-one with PLAN Task 2 <behavior>):
+ *
+ *   1.  output-styles/destijl.md exists and parses as valid YAML frontmatter
+ *       + markdown body.
+ *   2.  Frontmatter contains exactly `force-for-plugin: true` AND
+ *       `keep-coding-instructions: true` (literal string match).
+ *   3.  Body documents the four zones in fixed order matching SKILL.md
+ *       Section 1: Header Panel / Content Body / Intelligence Strip /
+ *       Action Footer.
+ *   4.  Body documents the 5+2 body shapes (A, B, C, D, E + F family)
+ *       mapping to the SKILL.md Section 2 vocabulary.
+ *   5.  scripts/audit-body-shape-coverage.cjs exits 0 against the live
+ *       commands/ directory (post-Task-1 state). Exits 1 against a
+ *       synthetic fixture with a command missing body_shape:.
+ *   6.  The audit script reports per-category counts (A / B / C / D / E /
+ *       F.x / methodology) in --json mode.
+ *   7.  Every body_shape: value in commands/*.md is one of the locked
+ *       vocabulary {A, B, C, D, E, F.0..F.6, methodology}. The audit
+ *       script flags any other value.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const DESTIJL_PATH = path.join(REPO, 'output-styles', 'destijl.md');
+const AUDIT_PATH = path.join(REPO, 'scripts', 'audit-body-shape-coverage.cjs');
+const COMMANDS_DIR = path.join(REPO, 'commands');
+
+// ---------- Fixture helpers ----------
+
+const TMP_ROOTS = [];
+function mkTmp(prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  TMP_ROOTS.push(d);
+  return d;
+}
+process.on('exit', () => {
+  for (const d of TMP_ROOTS) {
+    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
+  }
+});
+
+function readDestijl() {
+  return fs.readFileSync(DESTIJL_PATH, 'utf8');
+}
+
+function loadAudit() {
+  try { delete require.cache[require.resolve(AUDIT_PATH)]; } catch (_) {}
+  return require(AUDIT_PATH);
+}
+
+// Run audit script as a subprocess (mirrors how CI will invoke it).
+// Returns { code, stdout, stderr }.
+function runAudit(args, env) {
+  const result = { code: 0, stdout: '', stderr: '' };
+  try {
+    result.stdout = execFileSync('node', [AUDIT_PATH, ...(args || [])], {
+      env: Object.assign({}, process.env, env || {}),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    result.code = (e && typeof e.status === 'number') ? e.status : 1;
+    result.stdout = (e && e.stdout) ? e.stdout.toString() : '';
+    result.stderr = (e && e.stderr) ? e.stderr.toString() : '';
+  }
+  return result;
+}
+
+// ---------- Tests ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log('  ok  ' + name);
+  } catch (e) {
+    failed++;
+    failures.push({ name, error: e });
+    console.log('  FAIL  ' + name);
+    console.log('         ' + (e && e.message ? e.message : String(e)));
+  }
+}
+
+console.log('Phase 121.5-01 Task 2 -- body-shape-coverage acceptance suite');
+console.log('');
+
+// Test 1: destijl.md exists and parses
+test('Test 1: output-styles/destijl.md exists with frontmatter + body', () => {
+  assert.ok(fs.existsSync(DESTIJL_PATH), 'output-styles/destijl.md missing');
+  const text = readDestijl();
+  const fm = text.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  assert.ok(fm, 'destijl.md does not parse as frontmatter + body');
+  assert.ok(fm[1].length > 0, 'frontmatter is empty');
+  assert.ok(fm[2].length > 100, 'body is too short (< 100 chars)');
+});
+
+// Test 2: force-for-plugin + keep-coding-instructions present
+test('Test 2: frontmatter has force-for-plugin: true AND keep-coding-instructions: true', () => {
+  const text = readDestijl();
+  const fm = text.match(/^---\n([\s\S]*?)\n---/);
+  assert.ok(fm, 'no frontmatter found');
+  assert.ok(/^force-for-plugin:\s*true\s*$/m.test(fm[1]),
+    'force-for-plugin: true not found in frontmatter');
+  assert.ok(/^keep-coding-instructions:\s*true\s*$/m.test(fm[1]),
+    'keep-coding-instructions: true not found in frontmatter');
+});
+
+// Test 3: 4 zones documented in fixed order
+test('Test 3: body documents 4 zones in SKILL.md Section 1 order', () => {
+  const text = readDestijl();
+  const idxHeader = text.indexOf('Header Panel');
+  const idxBody = text.indexOf('Content Body');
+  const idxStrip = text.indexOf('Intelligence Strip');
+  const idxFooter = text.indexOf('Action Footer');
+  assert.ok(idxHeader > 0, 'Header Panel zone not documented');
+  assert.ok(idxBody > idxHeader, 'Content Body must come after Header Panel');
+  assert.ok(idxStrip > idxBody, 'Intelligence Strip must come after Content Body');
+  assert.ok(idxFooter > idxStrip, 'Action Footer must come after Intelligence Strip');
+});
+
+// Test 4: 5+2 body shapes documented
+test('Test 4: body documents shapes A, B, C, D, E + F family + methodology', () => {
+  const text = readDestijl();
+  // Each shape letter must appear in the shape table or shape documentation.
+  // Use regex to find the shape table row pattern: "| <letter> |" or "Shape <letter>".
+  for (const shape of ['A', 'B', 'C', 'D', 'E']) {
+    const re = new RegExp('(\\|\\s*' + shape + '\\s*\\||Shape\\s+' + shape + '\\b)');
+    assert.ok(re.test(text), 'Shape ' + shape + ' not documented in body');
+  }
+  // F family members
+  for (const fSub of ['F.0', 'F.1', 'F.2', 'F.3', 'F.4', 'F.5', 'F.6']) {
+    const re = new RegExp('\\b' + fSub.replace('.', '\\.') + '\\b');
+    assert.ok(re.test(text), fSub + ' not documented in body');
+  }
+  assert.ok(/methodology/i.test(text), 'methodology not documented in body');
+});
+
+// Test 5a: audit script exits 0 against live commands/ (post-Task-1 state)
+test('Test 5a: audit exits 0 against live commands/ (100% coverage)', () => {
+  assert.ok(fs.existsSync(AUDIT_PATH), 'audit script missing');
+  const r = runAudit([]);
+  if (r.code !== 0) {
+    console.log('         stdout: ' + r.stdout);
+    console.log('         stderr: ' + r.stderr);
+  }
+  assert.strictEqual(r.code, 0, 'audit script exited non-zero on live repo');
+});
+
+// Test 5b: audit exits 1 on synthetic fixture missing body_shape
+test('Test 5b: audit exits 1 on synthetic command missing body_shape', () => {
+  const tmp = mkTmp('body-shape-audit-');
+  const cmdsDir = path.join(tmp, 'commands');
+  fs.mkdirSync(cmdsDir, { recursive: true });
+  // Good file
+  fs.writeFileSync(path.join(cmdsDir, 'good.md'),
+    '---\nname: good\ndescription: test\nbody_shape: A\n---\n# good\n');
+  // Bad file (missing body_shape)
+  fs.writeFileSync(path.join(cmdsDir, 'bad.md'),
+    '---\nname: bad\ndescription: test\n---\n# bad\n');
+
+  // Audit accepts a --dir override.
+  const r = runAudit(['--dir', cmdsDir]);
+  assert.notStrictEqual(r.code, 0,
+    'audit must fail when a command is missing body_shape (got exit 0)');
+});
+
+// Test 6: --json mode reports per-category counts
+test('Test 6: --json mode reports histogram per category', () => {
+  const r = runAudit(['--json']);
+  assert.strictEqual(r.code, 0, 'audit --json exited non-zero');
+  let parsed;
+  try {
+    parsed = JSON.parse(r.stdout);
+  } catch (e) {
+    assert.fail('--json output not valid JSON: ' + e.message);
+  }
+  assert.ok(parsed && typeof parsed === 'object', '--json must emit object');
+  assert.ok(typeof parsed.total === 'number', 'total missing in --json output');
+  assert.ok(parsed.histogram && typeof parsed.histogram === 'object',
+    'histogram missing in --json output');
+  // At least 3 distinct shape categories should appear in a healthy repo
+  // (proves the sweep is a spread, not a monoculture).
+  const keys = Object.keys(parsed.histogram);
+  assert.ok(keys.length >= 3,
+    'histogram has < 3 distinct shapes -- monoculture detected: ' + keys.join(','));
+});
+
+// Test 7: all body_shape values in live repo are in the locked vocabulary
+test('Test 7: every body_shape value in commands/*.md is in locked vocab', () => {
+  const { VALID_SHAPES } = loadAudit();
+  assert.ok(VALID_SHAPES && typeof VALID_SHAPES.has === 'function',
+    'audit must export VALID_SHAPES Set');
+  // Sanity-check the vocabulary itself
+  for (const v of ['A', 'B', 'C', 'D', 'E',
+                   'F.0', 'F.1', 'F.2', 'F.3', 'F.4', 'F.5', 'F.6',
+                   'methodology']) {
+    assert.ok(VALID_SHAPES.has(v), 'VALID_SHAPES missing required value: ' + v);
+  }
+  // Now scan live commands and validate each
+  const files = fs.readdirSync(COMMANDS_DIR).filter(f => f.endsWith('.md'));
+  const offenders = [];
+  for (const f of files) {
+    const text = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf8');
+    const fm = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm) { offenders.push(f + ' (no frontmatter)'); continue; }
+    const m = fm[1].match(/^body_shape:\s*(.+)$/m);
+    if (!m) { offenders.push(f + ' (no body_shape)'); continue; }
+    // Strip trailing parenthetical (e.g. "B (Semantic Tree)" -> "B")
+    let v = m[1].trim().replace(/\s*\(.*\)\s*$/, '');
+    // Strip surrounding quotes if present
+    v = v.replace(/^['"]|['"]$/g, '');
+    if (!VALID_SHAPES.has(v)) {
+      offenders.push(f + ' = "' + m[1].trim() + '" (extracted: "' + v + '")');
+    }
+  }
+  if (offenders.length) {
+    assert.fail('commands with invalid body_shape values:\n  ' + offenders.join('\n  '));
+  }
+});
+
+// ---------- Summary ----------
+
+console.log('');
+console.log('========================================');
+console.log('Tests: ' + (passed + failed) + ' total, ' + passed + ' passed, ' + failed + ' failed');
+console.log('========================================');
+
+if (failed > 0) {
+  console.log('');
+  console.log('Failures:');
+  for (const f of failures) {
+    console.log('  - ' + f.name);
+  }
+  process.exit(1);
+}
+
+process.exit(0);