@mindrian_os/install 1.13.0-beta.11

package/lib/memory/folder-memory-quadruple.test.cjs

@@ -0,0 +1,548 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 90-04 -- readQuadruple fixture tests (17 cases)
+ * =====================================================
+ * Extends Phase 88-01 readTriple to readQuadruple additively. Five
+ * parser-isolation tests (Task 1) + twelve integration tests (Task 2).
+ *
+ * Test map (17 cases, one-to-one with the PLAN <behavior> blocks):
+ *
+ * Task 1 (parser-level, folder-memory-shared.cjs):
+ *   1.  parseBrainMd on valid fixture -> full struct, parse_failed:false, 9 sections mapped
+ *   2.  parseBrainMd on absent path -> null (literal)
+ *   3.  parseBrainMd on malformed frontmatter -> emptyBrain with parse_failed:true
+ *   4.  parseBrainMd with 3/9 sections populated -> sections[present]:{body,tokens_estimate}, sections[absent]:null
+ *   5.  parseBrainMd with unknown heading '## Secret Analysis' -> ignored (future-compat)
+ *   (Bonus): OPTIONAL_SECTION_HEADINGS byte-identical parity with brain-md-schema
+ *
+ * Task 2 (integration, folder-memory.cjs + folder-memory-async.cjs):
+ *   6.  readQuadruple sync on section with triple + valid BRAIN.md -> {room,state,reasoning,brain:{exists:true,...}}
+ *   7.  readQuadruple sync on section with triple + BRAIN.md absent -> {..., brain:null}
+ *   8.  readQuadruple sync on section with triple + malformed BRAIN.md -> {..., brain:{exists:true, parse_failed:true, ...}}
+ *   9.  readQuadruple sync on nonexistent sectionPath -> does NOT throw; returns all-empty shells + brain:null
+ *   10. readQuadruple async AsyncFunction constructor.name === 'AsyncFunction'
+ *   11. sync + async return identical shapes on same fixture (deep equality)
+ *   12. key-set parity: Object.keys(sync).filter(fn).sort() === Object.keys(async).filter(fn).sort()
+ *   13. isQuadrupleFresh: reasoning.is_stale:false + brain:null -> true
+ *   14. isQuadrupleFresh: reasoning.is_stale:false + brain.staleness:'fresh' -> true
+ *   15. isQuadrupleFresh: reasoning.is_stale:true -> false (regardless of brain)
+ *   16. isQuadrupleFresh: reasoning.is_stale:false + brain.stale_reason:'brain_offline' -> true
+ *   17. isQuadrupleFresh: reasoning.is_stale:false + brain.staleness:'stale' + stale_reason:'governing_thought_changed' -> false
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const SHARED_PATH = path.join(REPO, 'lib/core/folder-memory-shared.cjs');
+const SYNC_PATH = path.join(REPO, 'lib/core/folder-memory.cjs');
+const ASYNC_PATH = path.join(REPO, 'lib/core/folder-memory-async.cjs');
+const SCHEMA_PATH = path.join(REPO, 'lib/core/brain-md-schema.cjs');
+
+// ---------- Tmp workspace 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 (_e) { /* best effort */ }
+  }
+});
+
+function isoFromMs(ms) {
+  return new Date(ms).toISOString().replace(/\.\d+Z$/, 'Z');
+}
+
+// ---------- Fixture writers ----------
+
+function writeRoomMd(dir, identity, refs) {
+  const payload =
+    identity +
+    '\n\n<!-- BEGIN REFERENCES -->\n' +
+    (refs || '') +
+    '\n<!-- END REFERENCES -->\n';
+  fs.writeFileSync(path.join(dir, 'ROOM.md'), payload, 'utf8');
+}
+
+function writeStateMd(dir, opts) {
+  const o = opts || {};
+  const lines = [
+    '# Section State',
+    '',
+    'artifact_count: ' + (o.artifact_count != null ? o.artifact_count : 2),
+    'gap_status: ' + (o.gap_status || 'active'),
+    'completeness_score: ' + (o.completeness_score != null ? o.completeness_score : 0.6),
+    '',
+    'Last activity: ' + (o.last_activity || '2026-04-19'),
+    '',
+  ];
+  fs.writeFileSync(path.join(dir, 'STATE.md'), lines.join('\n'), 'utf8');
+}
+
+function writeMintoMd(dir, fm, body) {
+  const lines = ['---'];
+  for (const k of Object.keys(fm)) {
+    const v = fm[k];
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        lines.push(k + ': []');
+      } else {
+        lines.push(k + ':');
+        for (const s of v) lines.push('  - ' + JSON.stringify(s));
+      }
+    } else if (v === null) {
+      lines.push(k + ': null');
+    } else if (typeof v === 'string') {
+      lines.push(k + ': "' + v.replace(/"/g, '\\"') + '"');
+    } else {
+      lines.push(k + ': ' + v);
+    }
+  }
+  lines.push('---');
+  lines.push('');
+  lines.push(body || '# MINTO body');
+  fs.writeFileSync(path.join(dir, 'MINTO.md'), lines.join('\n'), 'utf8');
+}
+
+// Build a BRAIN.md fixture with given frontmatter + section bodies map.
+// sections is { '## Pattern Matches': 'body text', ... } -- only present
+// headings become sections; absent headings stay absent on parse.
+function writeBrainMd(dir, fm, sections) {
+  fs.mkdirSync(dir, { recursive: true });
+  const lines = ['---'];
+  for (const k of Object.keys(fm)) {
+    const v = fm[k];
+    if (v === null) {
+      lines.push(k + ': null');
+    } else if (typeof v === 'string') {
+      lines.push(k + ': "' + v.replace(/"/g, '\\"') + '"');
+    } else {
+      lines.push(k + ': ' + v);
+    }
+  }
+  lines.push('---');
+  lines.push('');
+  lines.push('# Brain Derivation -- ' + (fm.section || 'unknown'));
+  lines.push('');
+  if (sections && typeof sections === 'object') {
+    for (const h of Object.keys(sections)) {
+      lines.push(h);
+      lines.push('');
+      lines.push(sections[h]);
+      lines.push('');
+    }
+  }
+  fs.writeFileSync(path.join(dir, 'BRAIN.md'), lines.join('\n'), 'utf8');
+}
+
+function defaultBrainFm(section) {
+  return {
+    section: section || 'market-analysis',
+    brain_generated_at: isoFromMs(Date.now()),
+    brain_graph_version: 1,
+    governing_thought_hash: 'sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+    staleness: 'fresh',
+    stale_reason: null,
+    author: 'brain',
+    confidence_baseline: 0.7,
+  };
+}
+
+// Seed a full section directory with ROOM/STATE/MINTO + optional BRAIN.
+function seedSection(dir, opts) {
+  const o = opts || {};
+  writeRoomMd(dir, o.identity || '# test-section\n\nIdentity prose.', o.refs || '');
+  writeStateMd(dir, o.state || {});
+  writeMintoMd(
+    dir,
+    {
+      schema_version: 'v88',
+      governing_thought: o.governing_thought || 'Test governing thought.',
+      last_generated_at: isoFromMs(Date.now()),
+      decision_log: [],
+    },
+    o.body || 'body content'
+  );
+}
+
+// ---------- Task 1: Parser-level tests ----------
+
+function test_1_parseBrainMd_valid(shared) {
+  const dir = mkTmp('quad-t1-');
+  const fm = defaultBrainFm('market-analysis');
+  const sections = {
+    '## Pattern Matches': 'Framework match: SWOT + Porter Five.',
+    '## Cross-Domain Analogies': 'Analogous to 1995 ISP market.',
+    '## Wicked Indicators': 'High uncertainty + stakeholder divergence.',
+    '## Unfilled Opportunity Matches': 'Gap in mid-market enterprise.',
+    '## Framework Chain Predictions': 'SWOT -> Porter -> JTBD.',
+    '## Assessment Thinking Chain Position': 'RigorLevel 3.',
+    '## ProblemType Classification': 'UDP-Complex, confidence 0.8.',
+    '## Flagged Contradictions (cross-room)': '(no signal)',
+    '## HSI Signals': 'Disruption index high.',
+  };
+  writeBrainMd(dir, fm, sections);
+
+  const brain = shared.parseBrainMd(path.join(dir, 'BRAIN.md'));
+  assert.notStrictEqual(brain, null, 't1: brain non-null');
+  assert.strictEqual(brain.exists, true, 't1: exists true');
+  assert.strictEqual(brain.parse_failed, false, 't1: parse_failed false');
+  assert.strictEqual(brain.section, 'market-analysis', 't1: section scalar');
+  assert.strictEqual(brain.brain_graph_version, 1, 't1: brain_graph_version cast');
+  assert.strictEqual(brain.staleness, 'fresh', 't1: staleness scalar');
+  assert.strictEqual(brain.stale_reason, null, 't1: stale_reason null');
+  assert.strictEqual(brain.author, 'brain', 't1: author');
+  assert.strictEqual(brain.confidence_baseline, 0.7, 't1: confidence_baseline float');
+  assert.ok(brain.sections && typeof brain.sections === 'object', 't1: sections present');
+  const expectedKeys = [
+    'pattern_matches',
+    'cross_domain_analogies',
+    'wicked_indicators',
+    'unfilled_opportunity_matches',
+    'framework_chain_predictions',
+    'assessment_thinking_chain_position',
+    'problemtype_classification',
+    'flagged_contradictions_xroom',
+    'hsi_signals',
+  ];
+  for (const k of expectedKeys) {
+    assert.ok(k in brain.sections, 't1: key ' + k + ' present');
+    assert.ok(brain.sections[k] !== null, 't1: section ' + k + ' populated');
+    assert.ok(typeof brain.sections[k].body === 'string', 't1: ' + k + ' body string');
+    assert.ok(brain.sections[k].body.length > 0, 't1: ' + k + ' body non-empty');
+    assert.ok(typeof brain.sections[k].tokens_estimate === 'number', 't1: ' + k + ' tokens_estimate number');
+    assert.ok(brain.sections[k].tokens_estimate > 0, 't1: ' + k + ' tokens_estimate positive');
+  }
+  assert.ok(Array.isArray(brain.flagged_weaknesses), 't1: flagged_weaknesses array');
+}
+
+function test_2_parseBrainMd_absent(shared) {
+  const dir = mkTmp('quad-t2-');
+  const result = shared.parseBrainMd(path.join(dir, 'BRAIN.md'));
+  assert.strictEqual(result, null, 't2: absent -> null literal');
+}
+
+function test_3_parseBrainMd_malformed(shared) {
+  const dir = mkTmp('quad-t3-');
+  fs.mkdirSync(dir, { recursive: true });
+  // No frontmatter delimiters at all.
+  fs.writeFileSync(
+    path.join(dir, 'BRAIN.md'),
+    'This is not a BRAIN.md. No frontmatter. No sections.\n',
+    'utf8'
+  );
+  const brain = shared.parseBrainMd(path.join(dir, 'BRAIN.md'));
+  assert.notStrictEqual(brain, null, 't3: malformed still returns emptyBrain struct');
+  assert.strictEqual(brain.exists, true, 't3: exists:true for present-but-malformed');
+  assert.strictEqual(brain.parse_failed, true, 't3: parse_failed:true');
+  assert.strictEqual(brain.staleness, 'stale', 't3: staleness:stale on parse fail');
+  assert.ok(brain.sections && typeof brain.sections === 'object', 't3: sections shell');
+  for (const k of Object.keys(brain.sections)) {
+    assert.strictEqual(brain.sections[k], null, 't3: ' + k + ' null on parse fail');
+  }
+}
+
+function test_4_parseBrainMd_partialSections(shared) {
+  const dir = mkTmp('quad-t4-');
+  const fm = defaultBrainFm('problem-definition');
+  const sections = {
+    '## Pattern Matches': 'Only three present.',
+    '## Wicked Indicators': 'Second of three.',
+    '## HSI Signals': 'Third of three.',
+  };
+  writeBrainMd(dir, fm, sections);
+  const brain = shared.parseBrainMd(path.join(dir, 'BRAIN.md'));
+  assert.strictEqual(brain.parse_failed, false, 't4: parse ok');
+  assert.ok(brain.sections.pattern_matches != null, 't4: pattern_matches present');
+  assert.ok(brain.sections.wicked_indicators != null, 't4: wicked_indicators present');
+  assert.ok(brain.sections.hsi_signals != null, 't4: hsi_signals present');
+  // Six absent sections stay null.
+  const absentKeys = [
+    'cross_domain_analogies',
+    'unfilled_opportunity_matches',
+    'framework_chain_predictions',
+    'assessment_thinking_chain_position',
+    'problemtype_classification',
+    'flagged_contradictions_xroom',
+  ];
+  for (const k of absentKeys) {
+    assert.strictEqual(brain.sections[k], null, 't4: absent ' + k + ' is null');
+  }
+}
+
+function test_5_parseBrainMd_unknownHeading(shared) {
+  const dir = mkTmp('quad-t5-');
+  const fm = defaultBrainFm('solution-design');
+  const sections = {
+    '## Pattern Matches': 'Known heading.',
+    '## Secret Analysis': 'Unknown heading; must be ignored.',
+  };
+  writeBrainMd(dir, fm, sections);
+  const brain = shared.parseBrainMd(path.join(dir, 'BRAIN.md'));
+  assert.strictEqual(brain.parse_failed, false, 't5: still parses fine');
+  assert.ok(brain.sections.pattern_matches != null, 't5: known heading captured');
+  // The unknown heading must not appear as a key anywhere.
+  for (const k of Object.keys(brain.sections)) {
+    assert.ok(
+      k.indexOf('secret') === -1,
+      't5: no secret_* key leaked into sections'
+    );
+  }
+}
+
+function test_bonus_optionalHeadingsParity(shared) {
+  // Parity with brain-md-schema OPTIONAL_SECTION_HEADINGS array.
+  const schema = require(SCHEMA_PATH);
+  assert.ok(Array.isArray(schema.OPTIONAL_SECTION_HEADINGS), 'bonus: schema array present');
+  assert.ok(Array.isArray(shared.OPTIONAL_SECTION_HEADINGS), 'bonus: shared array present');
+  assert.strictEqual(
+    shared.OPTIONAL_SECTION_HEADINGS.length,
+    schema.OPTIONAL_SECTION_HEADINGS.length,
+    'bonus: same length'
+  );
+  for (let i = 0; i < schema.OPTIONAL_SECTION_HEADINGS.length; i++) {
+    assert.strictEqual(
+      shared.OPTIONAL_SECTION_HEADINGS[i],
+      schema.OPTIONAL_SECTION_HEADINGS[i],
+      'bonus: entry ' + i + ' byte-identical'
+    );
+  }
+}
+
+// ---------- Task 2: Integration tests ----------
+
+function test_6_readQuadruple_valid(sync) {
+  const dir = mkTmp('quad-t6-');
+  seedSection(dir, {});
+  writeBrainMd(dir, defaultBrainFm(path.basename(dir)), {
+    '## Pattern Matches': 'Framework match body.',
+    '## HSI Signals': 'HSI signal body.',
+  });
+  const q = sync.readQuadruple(dir);
+  assert.ok(q, 't6: returns object');
+  assert.ok(q.room && q.room.exists === true, 't6: room.exists');
+  assert.ok(q.state && q.state.exists === true, 't6: state.exists');
+  assert.ok(q.reasoning && q.reasoning.exists === true, 't6: reasoning.exists');
+  assert.ok(q.brain != null, 't6: brain non-null');
+  assert.strictEqual(q.brain.exists, true, 't6: brain.exists');
+  assert.strictEqual(q.brain.parse_failed, false, 't6: brain parsed ok');
+  assert.strictEqual(q.brain.author, 'brain', 't6: brain.author');
+}
+
+function test_7_readQuadruple_brainAbsent(sync) {
+  const dir = mkTmp('quad-t7-');
+  seedSection(dir, {});
+  // No BRAIN.md.
+  const q = sync.readQuadruple(dir);
+  assert.ok(q.room.exists === true, 't7: room still present');
+  assert.strictEqual(q.brain, null, 't7: brain null when absent');
+}
+
+function test_8_readQuadruple_malformedBrain(sync) {
+  const dir = mkTmp('quad-t8-');
+  seedSection(dir, {});
+  fs.writeFileSync(path.join(dir, 'BRAIN.md'), 'garbage no frontmatter\n', 'utf8');
+  const q = sync.readQuadruple(dir);
+  assert.ok(q.brain != null, 't8: brain non-null (file exists)');
+  assert.strictEqual(q.brain.exists, true, 't8: exists:true when file present');
+  assert.strictEqual(q.brain.parse_failed, true, 't8: parse_failed:true');
+  assert.strictEqual(q.brain.staleness, 'stale', 't8: staleness:stale on malformed');
+}
+
+function test_9_readQuadruple_nonexistentPath(sync) {
+  const dir = path.join(os.tmpdir(), 'quad-t9-nonexistent-' + Date.now() + '-' + Math.random());
+  let q;
+  assert.doesNotThrow(() => {
+    q = sync.readQuadruple(dir);
+  }, 't9: no throws on nonexistent path');
+  assert.strictEqual(q.room.exists, false, 't9: room shell');
+  assert.strictEqual(q.state.exists, false, 't9: state shell');
+  assert.strictEqual(q.reasoning.exists, false, 't9: reasoning shell');
+  assert.strictEqual(q.brain, null, 't9: brain null on absent path');
+}
+
+function test_10_asyncReadQuadruple_isAsyncFunction(asyncMod) {
+  assert.strictEqual(
+    typeof asyncMod.readQuadruple,
+    'function',
+    't10: readQuadruple defined on async module'
+  );
+  assert.strictEqual(
+    asyncMod.readQuadruple.constructor.name,
+    'AsyncFunction',
+    't10: async readQuadruple is AsyncFunction (got ' + asyncMod.readQuadruple.constructor.name + ')'
+  );
+  assert.strictEqual(
+    asyncMod.isQuadrupleFresh.constructor.name,
+    'AsyncFunction',
+    't10: async isQuadrupleFresh is AsyncFunction'
+  );
+}
+
+async function test_11_syncAsyncDeepEquality(sync, asyncMod) {
+  const dir = mkTmp('quad-t11-');
+  seedSection(dir, { governing_thought: 'Parity GT' });
+  writeBrainMd(dir, defaultBrainFm(path.basename(dir)), {
+    '## Pattern Matches': 'same body both paths',
+  });
+
+  const syncResult = sync.readQuadruple(dir);
+  const asyncResult = await asyncMod.readQuadruple(dir);
+
+  assert.deepStrictEqual(
+    Object.keys(syncResult).sort(),
+    Object.keys(asyncResult).sort(),
+    't11: top-level keys match'
+  );
+  assert.deepStrictEqual(
+    syncResult.brain,
+    asyncResult.brain,
+    't11: brain field deep equal'
+  );
+  assert.strictEqual(
+    syncResult.reasoning.governing_thought,
+    asyncResult.reasoning.governing_thought,
+    't11: reasoning gt match'
+  );
+}
+
+function test_12_keySetParity(sync, asyncMod) {
+  const syncKeys = Object.keys(sync).filter((k) => typeof sync[k] === 'function').sort();
+  const asyncKeys = Object.keys(asyncMod).filter((k) => typeof asyncMod[k] === 'function').sort();
+  assert.deepStrictEqual(syncKeys, asyncKeys, 't12: key-set parity');
+  // Sanity: both include readQuadruple and isQuadrupleFresh.
+  assert.ok(syncKeys.indexOf('readQuadruple') !== -1, 't12: sync.readQuadruple present');
+  assert.ok(syncKeys.indexOf('isQuadrupleFresh') !== -1, 't12: sync.isQuadrupleFresh present');
+  assert.ok(asyncKeys.indexOf('readQuadruple') !== -1, 't12: async.readQuadruple present');
+  assert.ok(asyncKeys.indexOf('isQuadrupleFresh') !== -1, 't12: async.isQuadrupleFresh present');
+  // Phase 88-01 back-compat: readTriple still exported on both.
+  assert.ok(syncKeys.indexOf('readTriple') !== -1, 't12: sync.readTriple back-compat');
+  assert.ok(asyncKeys.indexOf('readTriple') !== -1, 't12: async.readTriple back-compat');
+  // Every async export is AsyncFunction.
+  for (const k of asyncKeys) {
+    assert.strictEqual(
+      asyncMod[k].constructor.name,
+      'AsyncFunction',
+      't12: async.' + k + ' must be AsyncFunction'
+    );
+  }
+}
+
+function test_13_isQuadrupleFresh_brainNull(sync) {
+  const q = {
+    room: { exists: true },
+    state: { exists: true },
+    reasoning: { exists: true, is_stale: false, stale_reason: null },
+    brain: null,
+  };
+  assert.strictEqual(sync.isQuadrupleFresh(q), true, 't13: fresh triple + brain null -> true');
+}
+
+function test_14_isQuadrupleFresh_brainFresh(sync) {
+  const q = {
+    room: { exists: true },
+    state: { exists: true },
+    reasoning: { exists: true, is_stale: false },
+    brain: { exists: true, staleness: 'fresh', stale_reason: null },
+  };
+  assert.strictEqual(sync.isQuadrupleFresh(q), true, 't14: fresh triple + fresh brain -> true');
+}
+
+function test_15_isQuadrupleFresh_tripleStale(sync) {
+  const q = {
+    room: { exists: true },
+    state: { exists: true },
+    reasoning: { exists: true, is_stale: true, stale_reason: 'artifacts_newer_than_minto' },
+    brain: { exists: true, staleness: 'fresh' },
+  };
+  assert.strictEqual(sync.isQuadrupleFresh(q), false, 't15: stale triple -> false');
+  // And even with brain null.
+  const q2 = Object.assign({}, q, { brain: null });
+  assert.strictEqual(sync.isQuadrupleFresh(q2), false, 't15b: stale triple + brain null -> false');
+}
+
+function test_16_isQuadrupleFresh_brainOffline(sync) {
+  const q = {
+    room: { exists: true },
+    state: { exists: true },
+    reasoning: { exists: true, is_stale: false },
+    brain: { exists: true, staleness: 'stale', stale_reason: 'brain_offline' },
+  };
+  assert.strictEqual(
+    sync.isQuadrupleFresh(q),
+    true,
+    't16: brain-offline not counted as derivation-stale'
+  );
+}
+
+function test_17_isQuadrupleFresh_brainStale(sync) {
+  const q = {
+    room: { exists: true },
+    state: { exists: true },
+    reasoning: { exists: true, is_stale: false },
+    brain: { exists: true, staleness: 'stale', stale_reason: 'governing_thought_changed' },
+  };
+  assert.strictEqual(
+    sync.isQuadrupleFresh(q),
+    false,
+    't17: derivation-stale -> false'
+  );
+}
+
+// ---------- Runner ----------
+
+async function run() {
+  // Module-file existence checks.
+  assert.ok(fs.existsSync(SHARED_PATH), 'precondition: shared module exists');
+  assert.ok(fs.existsSync(SYNC_PATH), 'precondition: sync module exists');
+  assert.ok(fs.existsSync(ASYNC_PATH), 'precondition: async module exists');
+
+  const shared = require(SHARED_PATH);
+  const sync = require(SYNC_PATH);
+  const asyncMod = require(ASYNC_PATH);
+
+  // Task 1 -- parser-level.
+  test_1_parseBrainMd_valid(shared);
+  test_2_parseBrainMd_absent(shared);
+  test_3_parseBrainMd_malformed(shared);
+  test_4_parseBrainMd_partialSections(shared);
+  test_5_parseBrainMd_unknownHeading(shared);
+  test_bonus_optionalHeadingsParity(shared);
+
+  // Task 2 -- integration.
+  test_6_readQuadruple_valid(sync);
+  test_7_readQuadruple_brainAbsent(sync);
+  test_8_readQuadruple_malformedBrain(sync);
+  test_9_readQuadruple_nonexistentPath(sync);
+  test_10_asyncReadQuadruple_isAsyncFunction(asyncMod);
+  await test_11_syncAsyncDeepEquality(sync, asyncMod);
+  test_12_keySetParity(sync, asyncMod);
+  test_13_isQuadrupleFresh_brainNull(sync);
+  test_14_isQuadrupleFresh_brainFresh(sync);
+  test_15_isQuadrupleFresh_tripleStale(sync);
+  test_16_isQuadrupleFresh_brainOffline(sync);
+  test_17_isQuadrupleFresh_brainStale(sync);
+
+  process.stdout.write('folder-memory-quadruple: 17/17 tests passed (5 parser + 12 integration + 1 parity bonus)\n');
+  process.exit(0);
+}
+
+run().catch((e) => {
+  process.stderr.write((e && e.stack) || String(e));
+  process.stderr.write('\n');
+  process.exit(1);
+});