@mindrian_os/install 1.13.0-beta.11

package/lib/memory/test-rs-breakthrough-scorer.cjs

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.2 Plan 07 Task 2 -- breakthrough scorer fixture suite.
+ *
+ * 10 scenarios for the Phase 3 deterministic 5-dimension 0-10 rubric:
+ *
+ *   feasibility   0-2 from substrate.tier (core=2, applied=1.5, theoretical=1)
+ *   market        0-2 from industry signal count (0=0, 1-3=0.5, 4-9=1.0,
+ *                                                  10-19=1.5, 20+=2.0)
+ *   magnitude     0-2 from diff value (>=0.7=2, >=0.5=1.5, >=0.3=1.0, else 0)
+ *   advantage     0-2 from cross-domain pair rarity (2 * (1 - density), clamped)
+ *   impact        0-2 from BERT score (>=0.8=2, >=0.6=1.5, >=0.4=1.0,
+ *                                       >=0.2=0.5, else 0)
+ *
+ *   Test 1  full rubric all-max -- score=10, dominant='feasibility' (frozen-order tie)
+ *   Test 2  full rubric all-min (theoretical) -- score=1, dominant='feasibility' (only non-zero)
+ *   Test 3  substrate tier 'applied' -- feasibility=1.5
+ *   Test 4  industry signals 1-3 -- market=0.5
+ *   Test 5  industry signals 4-9 -- market=1.0
+ *   Test 6  industry signals 10-19 -- market=1.5
+ *   Test 7  industry signals 20+ -- market=2.0
+ *   Test 8  determinism (two invocations -> JSON.stringify identical)
+ *   Test 9  CANON PART 8 adversarial: forbidden in classified_pair.query_concept
+ *   Test 10 CANON PART 8 adversarial: forbidden in opts.substrate_metadata.title
+ *
+ * Suite-end audit:
+ *   A1  walk every captured scoreBreakthrough output; JSON.stringify scan
+ *       against FORBIDDEN_PATTERNS + DANGEROUS_SUBSTRINGS; ZERO hits.
+ *
+ * Pure CJS, zero npm deps, node built-ins only.
+ */
+
+const assert = require('node:assert/strict');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+const crossRoomAggregator = require('../core/cross-room-aggregator.cjs');
+const FORBIDDEN_PATTERNS = crossRoomAggregator.FORBIDDEN_PATTERNS;
+
+const DANGEROUS_SUBSTRINGS = Object.freeze([
+  'Lawrence',
+  '5.2M',
+  'meeting with',
+  'jonathan@mindrian.com',
+  '123-45-6789',
+]);
+
+// ---------- Suite bookkeeping ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+const SCENARIO_RESULTS = [];
+
+function captureOutput(name, output) {
+  SCENARIO_RESULTS.push({ scenario: name, output: output });
+}
+
+function resetRequireCache() {
+  const targets = [
+    '../core/rs-egress-violations.cjs',
+    '../core/rs-egress-prompts.cjs',
+    '../core/rs-breakthrough-scorer.cjs',
+  ];
+  for (const t of targets) {
+    try {
+      const p = require.resolve(t);
+      delete require.cache[p];
+    } catch (_e) { /* best effort */ }
+  }
+}
+
+function runScenario(name, fn) {
+  const start = Date.now();
+  try {
+    fn();
+    passed += 1;
+    process.stdout.write('  ok  ' + name + '  (' + (Date.now() - start) + 'ms)\n');
+  } catch (err) {
+    failed += 1;
+    failures.push({ name: name, err: err });
+    process.stderr.write('  FAIL  ' + name + '\n');
+    process.stderr.write('        ' + (err && err.stack ? err.stack : err) + '\n');
+  } finally {
+    resetRequireCache();
+  }
+}
+
+// ---------- Helper: build a baseline classified_pair (post-classifier shape) ----------
+
+function baselineClassifiedPair(overrides) {
+  const base = {
+    query_concept: 'cancer immunotherapy',
+    doc_concept: 'checkpoint inhibitor PD-1',
+    diff: 0.4, lsa: 0.5, bert: 0.1, passes: true,
+    classification: 'structural_transfer',
+    bridge_concept: 'cross-domain isomorphism',
+  };
+  if (overrides) {
+    for (const k of Object.keys(overrides)) base[k] = overrides[k];
+  }
+  return base;
+}
+
+// ---------- Scenarios ----------
+
+function scenario1AllMax() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.8, bert: 0.9 });
+  const opts = {
+    substrate_metadata: { tier: 'core' },
+    industry_signal_count: 20,
+    pair_density: 0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('1-all-max', out);
+  assert.ok(out.breakthrough, 'has breakthrough field');
+  assert.equal(out.breakthrough.score, 10, 'all-max score should be 10; got ' + out.breakthrough.score);
+  assert.equal(out.breakthrough.breakdown.feasibility, 2.0);
+  assert.equal(out.breakthrough.breakdown.market, 2.0);
+  assert.equal(out.breakthrough.breakdown.magnitude, 2.0);
+  assert.equal(out.breakthrough.breakdown.advantage, 2.0);
+  assert.equal(out.breakthrough.breakdown.impact, 2.0);
+  // Frozen-order tie-break: feasibility first.
+  assert.equal(out.breakthrough.dominant_dimension, 'feasibility',
+    'all-tied dominant should be feasibility (frozen-order tie-break first); got ' +
+    out.breakthrough.dominant_dimension);
+}
+
+function scenario2AllMin() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'theoretical' },
+    industry_signal_count: 0,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('2-all-min', out);
+  // theoretical -> feasibility=1; signals=0 -> market=0; diff=0.1 -> magnitude=0;
+  // density=1 -> advantage=0; bert=0.1 -> impact=0. Total = 1.
+  assert.equal(out.breakthrough.score, 1, 'all-min score should be 1; got ' + out.breakthrough.score);
+  assert.equal(out.breakthrough.breakdown.feasibility, 1.0);
+  assert.equal(out.breakthrough.breakdown.market, 0.0);
+  assert.equal(out.breakthrough.breakdown.magnitude, 0.0);
+  assert.equal(out.breakthrough.breakdown.advantage, 0.0);
+  assert.equal(out.breakthrough.breakdown.impact, 0.0);
+  assert.equal(out.breakthrough.dominant_dimension, 'feasibility',
+    'only non-zero dim is feasibility; got ' + out.breakthrough.dominant_dimension);
+}
+
+function scenario3SubstrateTierApplied() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'applied' },
+    industry_signal_count: 0,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('3-substrate-applied', out);
+  assert.equal(out.breakthrough.breakdown.feasibility, 1.5,
+    'applied tier -> feasibility 1.5; got ' + out.breakthrough.breakdown.feasibility);
+  assert.equal(out.breakthrough.score, 1.5, 'total = 1.5');
+}
+
+function scenario4IndustrySignals1to3() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'theoretical' },
+    industry_signal_count: 2,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('4-signals-1to3', out);
+  assert.equal(out.breakthrough.breakdown.market, 0.5,
+    '1-3 signals -> market 0.5; got ' + out.breakthrough.breakdown.market);
+}
+
+function scenario5IndustrySignals4to9() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'theoretical' },
+    industry_signal_count: 7,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('5-signals-4to9', out);
+  assert.equal(out.breakthrough.breakdown.market, 1.0,
+    '4-9 signals -> market 1.0; got ' + out.breakthrough.breakdown.market);
+}
+
+function scenario6IndustrySignals10to19() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'theoretical' },
+    industry_signal_count: 15,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('6-signals-10to19', out);
+  assert.equal(out.breakthrough.breakdown.market, 1.5,
+    '10-19 signals -> market 1.5; got ' + out.breakthrough.breakdown.market);
+}
+
+function scenario7IndustrySignals20Plus() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.1, bert: 0.1 });
+  const opts = {
+    substrate_metadata: { tier: 'theoretical' },
+    industry_signal_count: 35,
+    pair_density: 1.0,
+  };
+  const out = m.scoreBreakthrough(cp, opts);
+  captureOutput('7-signals-20plus', out);
+  assert.equal(out.breakthrough.breakdown.market, 2.0,
+    '20+ signals -> market 2.0; got ' + out.breakthrough.breakdown.market);
+}
+
+function scenario8Determinism() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair({ diff: 0.45, bert: 0.55 });
+  const opts = {
+    substrate_metadata: { tier: 'applied' },
+    industry_signal_count: 8,
+    pair_density: 0.4,
+  };
+  const out1 = m.scoreBreakthrough(cp, opts);
+  const out2 = m.scoreBreakthrough(cp, opts);
+  captureOutput('8-determinism-1', out1);
+  captureOutput('8-determinism-2', out2);
+  assert.equal(JSON.stringify(out1), JSON.stringify(out2),
+    'determinism: same input must produce byte-identical output');
+  // Score in [0, 10].
+  assert.ok(out1.breakthrough.score >= 0 && out1.breakthrough.score <= 10,
+    'score in [0,10]; got ' + out1.breakthrough.score);
+}
+
+function scenario9AdversarialQueryConcept() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  // FORBIDDEN_PATTERNS[2]: "Lawrence said" / "Jonathan said" etc.
+  const cp = baselineClassifiedPair({
+    query_concept: 'Lawrence said cancer immunotherapy is the future',
+  });
+  const opts = {
+    substrate_metadata: { tier: 'core' },
+    industry_signal_count: 10,
+    pair_density: 0.5,
+  };
+  let threw = null;
+  try {
+    m.scoreBreakthrough(cp, opts);
+  } catch (err) {
+    threw = err;
+  }
+  assert.ok(threw, 'must throw on forbidden in query_concept');
+  assert.equal(threw.name, 'ExternalEgressViolation',
+    'must throw ExternalEgressViolation; got ' + (threw && threw.name));
+  captureOutput('9-adv-query-throw', { thrown: threw.name });
+}
+
+function scenario10AdversarialSubstrateTitle() {
+  const m = require('../core/rs-breakthrough-scorer.cjs');
+  const cp = baselineClassifiedPair();
+  // FORBIDDEN_PATTERNS[0]: email regex.
+  const opts = {
+    substrate_metadata: {
+      tier: 'core',
+      title: 'Strategy paper from jonathan@mindrian.com archive',
+    },
+    industry_signal_count: 10,
+    pair_density: 0.5,
+  };
+  let threw = null;
+  let out = null;
+  try {
+    out = m.scoreBreakthrough(cp, opts);
+  } catch (err) {
+    threw = err;
+  }
+  // Either the scorer threw on the smuggled email, OR the output does
+  // not contain it (Layer 2 audit catches via auditQueryObject; for the
+  // scorer to embed substrate_metadata.title in its output is a design
+  // choice -- if the field is not propagated, no leak; if it is
+  // propagated, Layer 2 must catch). Both satisfy Canon Part 8.
+  if (threw) {
+    assert.equal(threw.name, 'ExternalEgressViolation',
+      'must throw ExternalEgressViolation; got ' + (threw && threw.name));
+    captureOutput('10-adv-substrate-throw', { thrown: threw.name });
+  } else {
+    captureOutput('10-adv-substrate-scrubbed', out);
+    const json = JSON.stringify(out);
+    assert.ok(!/jonathan@mindrian\.com/i.test(json),
+      'output must not contain leaked email; got: ' + json);
+  }
+}
+
+// ---------- A1 end-of-suite sweep ----------
+
+function a1Sweep() {
+  let hits = 0;
+  for (const rec of SCENARIO_RESULTS) {
+    const json = JSON.stringify(rec.output);
+    for (const re of FORBIDDEN_PATTERNS) {
+      if (re.test(json)) {
+        hits += 1;
+        process.stderr.write(
+          '  A1 HIT  scenario=' + rec.scenario +
+          '  pattern=' + re.source + '\n'
+        );
+      }
+    }
+    for (const sub of DANGEROUS_SUBSTRINGS) {
+      if (json.indexOf(sub) !== -1) {
+        hits += 1;
+        process.stderr.write(
+          '  A1 HIT  scenario=' + rec.scenario +
+          '  substring=' + sub + '\n'
+        );
+      }
+    }
+  }
+  return hits;
+}
+
+// ---------- Main ----------
+
+(function main() {
+  process.stdout.write('=== 89.2-07-breakthrough suite (REPO_ROOT=' +
+    REPO_ROOT + ') ===\n');
+
+  runScenario('1-all-max', scenario1AllMax);
+  runScenario('2-all-min', scenario2AllMin);
+  runScenario('3-substrate-applied', scenario3SubstrateTierApplied);
+  runScenario('4-signals-1to3', scenario4IndustrySignals1to3);
+  runScenario('5-signals-4to9', scenario5IndustrySignals4to9);
+  runScenario('6-signals-10to19', scenario6IndustrySignals10to19);
+  runScenario('7-signals-20plus', scenario7IndustrySignals20Plus);
+  runScenario('8-determinism', scenario8Determinism);
+  runScenario('9-adversarial-query-concept', scenario9AdversarialQueryConcept);
+  runScenario('10-adversarial-substrate-title', scenario10AdversarialSubstrateTitle);
+
+  const sweepHits = a1Sweep();
+  if (sweepHits > 0) {
+    failed += 1;
+    failures.push({
+      name: 'A1-sweep',
+      err: new Error('A1 sweep found ' + sweepHits + ' forbidden-pattern hits'),
+    });
+    process.stderr.write('  FAIL  A1-sweep (' + sweepHits + ' hits)\n');
+  } else {
+    process.stdout.write('  ok  A1-sweep (zero forbidden-pattern hits)\n');
+  }
+
+  process.stdout.write('=== 89.2-07-breakthrough suite: ' +
+    passed + '/10 passed' +
+    (failed > 0 ? '  (' + failed + ' failed)' : '') +
+    ' ===\n');
+
+  if (failed > 0) {
+    for (const f of failures) {
+      process.stderr.write('  FAILURE: ' + f.name + ': ' +
+        (f.err && f.err.message ? f.err.message : String(f.err)) + '\n');
+    }
+    process.exit(1);
+  }
+  process.exit(0);
+})();

package/lib/memory/test-rs-canon-violations.cjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.4 Plan 01 -- Canon Part 3 closed-vocabulary fixture suite.
+ *
+ * 8 scenarios covering the Wave-1 foundation module:
+ *   lib/core/rs-canon-violations.cjs
+ *
+ * Test 1 (10 valid verbs pass): every CANONICAL_VERBS entry round-trips
+ *                               through validateVerb verbatim.
+ * Test 2 (invalid verb throws): 'Cancel' throws CanonVerbViolation;
+ *                               err.name + err.meta.attempted_verb verified.
+ * Test 3 (empty string throws CanonVerbViolation): NOT TypeError;
+ *                                                  err.meta.attempted_verb === ''.
+ * Test 4 (non-string number throws TypeError): with message containing
+ *                                              'must be a string'.
+ * Test 5 (null + undefined throw TypeError): both inputs raise TypeError.
+ * Test 6 (CANONICAL_VERBS frozen): Object.isFrozen + length === 10
+ *                                  + mutation throws in strict mode.
+ * Test 7 (canonical order verified): 10 strings exact-match in
+ *                                    canon-mandated order.
+ * Test 8 (surface tag propagation): err.meta.surface populated when caller
+ *                                   supplies; defaults to 'unknown' otherwise.
+ *
+ * Pure CJS, zero npm deps, node built-ins only (assert).
+ */
+
+const assert = require('node:assert/strict');
+
+// ---------- Suite bookkeeping ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function record(name, fn) {
+  try {
+    fn();
+    passed++;
+    process.stdout.write('PASS ' + name + '\n');
+  } catch (err) {
+    failed++;
+    failures.push({ name, message: err && err.message ? err.message : String(err) });
+    process.stdout.write('FAIL ' + name + ': ' + (err && err.message ? err.message : String(err)) + '\n');
+  }
+}
+
+// Helper: assert a function throws CanonVerbViolation with expected attempted_verb.
+function assertThrowsCanonVerbViolation(fn, expectedAttemptedVerb) {
+  let caught = null;
+  try {
+    fn();
+  } catch (e) {
+    caught = e;
+  }
+  assert.ok(caught !== null, 'expected throw, got none');
+  assert.equal(caught.name, 'CanonVerbViolation', 'expected err.name CanonVerbViolation, got ' + caught.name);
+  assert.ok(caught.meta && typeof caught.meta === 'object', 'expected err.meta to be object');
+  assert.equal(caught.meta.attempted_verb, expectedAttemptedVerb,
+    'expected err.meta.attempted_verb=' + JSON.stringify(expectedAttemptedVerb)
+    + ', got ' + JSON.stringify(caught.meta.attempted_verb));
+  return caught;
+}
+
+// Helper: assert a function throws TypeError.
+function assertThrowsTypeError(fn, messageSubstring) {
+  let caught = null;
+  try {
+    fn();
+  } catch (e) {
+    caught = e;
+  }
+  assert.ok(caught !== null, 'expected throw, got none');
+  assert.ok(caught instanceof TypeError, 'expected TypeError, got ' + (caught && caught.name));
+  if (messageSubstring) {
+    assert.ok(
+      caught.message.indexOf(messageSubstring) !== -1,
+      'expected TypeError message to contain ' + JSON.stringify(messageSubstring)
+        + ', got ' + JSON.stringify(caught.message)
+    );
+  }
+  return caught;
+}
+
+// ---------- Module under test ----------
+
+const mod = require('../core/rs-canon-violations.cjs');
+const { CanonVerbViolation, CANONICAL_VERBS, validateVerb } = mod;
+
+// ---------- Canonical 10-verb authoritative source ----------
+// (per docs/MINDRIAN-CANON.md Part 3 lines 153-162)
+const EXPECTED_VERBS = [
+  'Run Methodology',
+  'Reformulate',
+  'Spawn Sub-Agent',
+  'Navigate Graph',
+  "Devil's Advocate",
+  'Scenario Plan',
+  'Synthesize',
+  'Bank Opportunity',
+  'Defer',
+  'Free-Text',
+];
+
+// ---------- Tests ----------
+
+record('T1 all 10 valid verbs pass validateVerb (returns input verbatim)', function () {
+  assert.ok(Array.isArray(CANONICAL_VERBS), 'CANONICAL_VERBS must be array');
+  assert.equal(CANONICAL_VERBS.length, 10, 'CANONICAL_VERBS.length must be 10');
+  for (const verb of CANONICAL_VERBS) {
+    const result = validateVerb(verb);
+    assert.equal(result, verb, 'validateVerb(' + JSON.stringify(verb) + ') must return input verbatim');
+  }
+});
+
+record('T2 invalid verb Cancel throws CanonVerbViolation with meta.attempted_verb', function () {
+  const err = assertThrowsCanonVerbViolation(function () {
+    validateVerb('Cancel');
+  }, 'Cancel');
+  assert.ok(err instanceof CanonVerbViolation, 'err must be instanceof CanonVerbViolation');
+  assert.ok(err instanceof Error, 'err must also be instanceof Error');
+});
+
+record('T3 empty string throws CanonVerbViolation (NOT TypeError)', function () {
+  const err = assertThrowsCanonVerbViolation(function () {
+    validateVerb('');
+  }, '');
+  assert.ok(err instanceof CanonVerbViolation, 'empty string must produce CanonVerbViolation, not TypeError');
+});
+
+record('T4 non-string number 42 throws TypeError with must be a string', function () {
+  assertThrowsTypeError(function () {
+    validateVerb(42);
+  }, 'must be a string');
+});
+
+record('T5 null and undefined throw TypeError', function () {
+  assertThrowsTypeError(function () {
+    validateVerb(null);
+  }, 'must be a string');
+  assertThrowsTypeError(function () {
+    validateVerb(undefined);
+  }, 'must be a string');
+});
+
+record('T6 CANONICAL_VERBS frozen + length 10 + mutation throws in strict mode', function () {
+  assert.equal(Object.isFrozen(CANONICAL_VERBS), true, 'CANONICAL_VERBS must be frozen');
+  assert.equal(CANONICAL_VERBS.length, 10, 'CANONICAL_VERBS.length must equal 10');
+  // Test file is in strict mode; mutation must throw.
+  let mutationThrew = false;
+  try {
+    CANONICAL_VERBS[0] = 'Hijacked';
+  } catch (e) {
+    mutationThrew = true;
+  }
+  assert.ok(mutationThrew, 'mutation of frozen array must throw in strict mode');
+  assert.equal(CANONICAL_VERBS[0], 'Run Methodology', 'CANONICAL_VERBS[0] must remain Run Methodology');
+});
+
+record('T7 CANONICAL_VERBS contains exact required strings in canonical order', function () {
+  for (let i = 0; i < EXPECTED_VERBS.length; i++) {
+    assert.equal(
+      CANONICAL_VERBS[i],
+      EXPECTED_VERBS[i],
+      'CANONICAL_VERBS[' + i + '] must equal ' + JSON.stringify(EXPECTED_VERBS[i])
+        + ', got ' + JSON.stringify(CANONICAL_VERBS[i])
+    );
+  }
+});
+
+record('T8 surface tag propagation: provided populates meta.surface; omitted defaults to unknown', function () {
+  // With surface provided
+  let withSurfaceErr = null;
+  try {
+    validateVerb('NotAVerb', 'navigation-engine');
+  } catch (e) {
+    withSurfaceErr = e;
+  }
+  assert.ok(withSurfaceErr !== null, 'expected throw');
+  assert.equal(withSurfaceErr.name, 'CanonVerbViolation');
+  assert.equal(
+    withSurfaceErr.meta.surface,
+    'navigation-engine',
+    'err.meta.surface must equal supplied surface tag'
+  );
+
+  // Without surface (omitted)
+  let omittedErr = null;
+  try {
+    validateVerb('NotAVerb');
+  } catch (e) {
+    omittedErr = e;
+  }
+  assert.ok(omittedErr !== null, 'expected throw');
+  assert.equal(omittedErr.name, 'CanonVerbViolation');
+  assert.equal(
+    omittedErr.meta.surface,
+    'unknown',
+    'err.meta.surface must default to unknown when surface omitted'
+  );
+});
+
+// ---------- Suite report ----------
+
+const total = passed + failed;
+process.stdout.write('\n');
+if (failed === 0) {
+  process.stdout.write('=== 89.4-01 rs-canon-violations suite: ' + passed + '/' + total + ' passed ===\n');
+  process.exit(0);
+} else {
+  process.stdout.write('=== 89.4-01 rs-canon-violations suite: ' + passed + '/' + total + ' passed (' + failed + ' failed) ===\n');
+  for (const f of failures) {
+    process.stdout.write('  FAIL ' + f.name + ': ' + f.message + '\n');
+  }
+  process.exit(1);
+}