@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.44

package/lib/memory/brain-derivation-queue.test.cjs

@@ -1,539 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 90-02 Task 1 -- brain-derivation-queue.cjs fixture tests (15 cases)
- * ========================================================================
- * 15 tests covering enqueue (idempotent + replace + cross-section + dir
- * autocreate), readQueue (missing + malformed + self-heal), writeQueueAtomic
- * (tmpfile + concurrent race), caps (SOFT 500 / HARD 1000), Canon Part 8
- * audit (Test 12: queue carries ONLY hashes + slugs + reasons + timestamps),
- * and drain (stale-queue-race guard, Brain-offline re-enqueue, maxEntries
- * partition).
- *
- * Mocking strategy: mirror Phase 90-01 brain-derivation.test.cjs --
- * require.cache override for brain-client.cjs and folder-memory.cjs so the
- * drain path can be exercised without real network or live triple files.
- *
- * Pure node built-ins. Zero npm deps. CJS.
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-
-// ---------- Tmp workspace helpers ----------
-
-const TMP_ROOTS = [];
-function makeTmpRoot(tag) {
-  const r = fs.mkdtempSync(path.join(os.tmpdir(), 'brain-q-' + tag + '-'));
-  TMP_ROOTS.push(r);
-  return r;
-}
-process.on('exit', function () {
-  for (const r of TMP_ROOTS) {
-    try { fs.rmSync(r, { recursive: true, force: true }); } catch (_e) { /* best effort */ }
-  }
-});
-
-// ---------- Mock brain-client + folder-memory ----------
-
-function installMocks(opts) {
-  opts = opts || {};
-  const audit = {
-    isAvailable_calls: 0,
-    readTriple_calls: [],
-  };
-  const brainClientPath = require.resolve('../core/brain-client.cjs');
-  require.cache[brainClientPath] = {
-    id: brainClientPath,
-    filename: brainClientPath,
-    loaded: true,
-    exports: {
-      isAvailable: function () {
-        audit.isAvailable_calls += 1;
-        return opts.isAvailable === undefined ? true : opts.isAvailable;
-      },
-      query: async function () { return { records: [] }; },
-      search: async function () { return { matches: [] }; },
-      schema: async function () { return { brain_graph_version: 1 }; },
-    },
-  };
-
-  const folderMemPath = require.resolve('../core/folder-memory.cjs');
-  require.cache[folderMemPath] = {
-    id: folderMemPath,
-    filename: folderMemPath,
-    loaded: true,
-    exports: {
-      readTriple: function (sectionPath) {
-        audit.readTriple_calls.push(sectionPath);
-        if (opts.readTripleReturn) return opts.readTripleReturn(sectionPath);
-        // Default: triple with governing_thought matching opts.tripleGoverningThought
-        const gt = opts.tripleGoverningThought == null
-          ? 'default governing thought text'
-          : opts.tripleGoverningThought;
-        return {
-          room: { exists: true },
-          state: { exists: true },
-          reasoning: {
-            exists: true,
-            governing_thought: gt,
-            arguments_count: 4,
-            evidence_density: 0.5,
-            mece_status: 'pass',
-            reasoning_health_score: 0.7,
-            flagged_weaknesses: [],
-            decision_log: [],
-            is_stale: false,
-            stale_reason: null,
-          },
-        };
-      },
-      readDecisionLog: function () { return []; },
-      computeHealthScore: function () { return 0.7; },
-    },
-  };
-  return audit;
-}
-
-function resetMockCache() {
-  delete require.cache[require.resolve('../core/brain-client.cjs')];
-  delete require.cache[require.resolve('../core/folder-memory.cjs')];
-  delete require.cache[require.resolve('../core/brain-derivation-queue.cjs')];
-}
-
-// ---------- Hash helper ----------
-
-function sha256Hex(s) {
-  return 'sha256:' + crypto.createHash('sha256').update(String(s || '')).digest('hex');
-}
-
-// ---------- Test runner ----------
-
-let passed = 0;
-let failed = 0;
-
-function run(name, fn) {
-  try {
-    resetMockCache();
-    fn();
-    passed += 1;
-    process.stdout.write('  ok  ' + name + '\n');
-  } catch (err) {
-    failed += 1;
-    process.stderr.write('  FAIL  ' + name + '\n');
-    process.stderr.write('        ' + (err && err.stack ? err.stack : err) + '\n');
-  }
-}
-
-async function runAsync(name, fn) {
-  try {
-    resetMockCache();
-    await fn();
-    passed += 1;
-    process.stdout.write('  ok  ' + name + '\n');
-  } catch (err) {
-    failed += 1;
-    process.stderr.write('  FAIL  ' + name + '\n');
-    process.stderr.write('        ' + (err && err.stack ? err.stack : err) + '\n');
-  }
-}
-
-// ---------- 15 Tests ----------
-
-async function main() {
-
-  // Test 01: enqueue new entry -> queue file created with one entry.
-  run('Test 01: enqueue new entry creates queue with one entry', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t01');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const r = Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('new'), 'governing_thought_changed');
-    assert.equal(r.queued, true);
-    assert.equal(r.queue_size, 1);
-    const qPath = path.join(roomDir, '.mindrian', 'brain-derivation-queue.json');
-    assert.ok(fs.existsSync(qPath), 'queue file must exist');
-    const q = JSON.parse(fs.readFileSync(qPath, 'utf8'));
-    assert.equal(q.entries.length, 1);
-    assert.equal(q.entries[0].section, 'market-analysis');
-  });
-
-  // Test 02: idempotent same hash dedupes.
-  run('Test 02: enqueue same section + same new_hash -> idempotent (queue_size still 1)', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t02');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const h = sha256Hex('thoughtA');
-    Q.enqueue(roomDir, 'market-analysis', null, h, 'governing_thought_changed');
-    const r = Q.enqueue(roomDir, 'market-analysis', null, h, 'governing_thought_changed');
-    assert.equal(r.queued, true);
-    assert.equal(r.queue_size, 1);
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 1);
-  });
-
-  // Test 03: same section, different new_hash -> prior entry replaced.
-  run('Test 03: enqueue same section different new_hash -> entry replaced (queue_size = 1)', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t03');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('A'), 'governing_thought_changed');
-    Q.enqueue(roomDir, 'market-analysis', sha256Hex('A'), sha256Hex('B'), 'governing_thought_changed');
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 1, 'section is unique key');
-    assert.equal(q.entries[0].new_governing_thought_hash, sha256Hex('B'));
-  });
-
-  // Test 04: two different sections -> queue has 2 entries.
-  run('Test 04: enqueue two different sections -> queue has 2 entries', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t04');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('A'), 'governing_thought_changed');
-    Q.enqueue(roomDir, 'business-model', null, sha256Hex('B'), 'governing_thought_changed');
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 2);
-    const sections = q.entries.map(function (e) { return e.section; }).sort();
-    assert.deepEqual(sections, ['business-model', 'market-analysis']);
-  });
-
-  // Test 05: enqueue when .mindrian dir missing -> creates dir + file.
-  run('Test 05: enqueue creates .mindrian dir if missing', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t05');
-    // No .mindrian/ pre-created.
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const r = Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('A'), 'governing_thought_changed');
-    assert.equal(r.queued, true);
-    assert.ok(fs.existsSync(path.join(roomDir, '.mindrian')));
-    assert.ok(fs.existsSync(path.join(roomDir, '.mindrian', 'brain-derivation-queue.json')));
-  });
-
-  // Test 06: readQueue on missing file returns empty shape (no throw).
-  run('Test 06: readQueue on missing file returns {version:1, entries:[]}', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t06');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const q = Q.readQueue(roomDir);
-    assert.deepEqual(q, { version: 1, entries: [] });
-  });
-
-  // Test 07: readQueue on malformed JSON self-heals.
-  run('Test 07: readQueue on malformed JSON returns empty shape (self-heal)', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t07');
-    fs.mkdirSync(path.join(roomDir, '.mindrian'), { recursive: true });
-    fs.writeFileSync(path.join(roomDir, '.mindrian', 'brain-derivation-queue.json'), 'not valid json {{{');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const q = Q.readQueue(roomDir);
-    assert.deepEqual(q, { version: 1, entries: [] });
-  });
-
-  // Test 08: writeQueueAtomic writes tmpfile then renames; tmpfile cleaned.
-  run('Test 08: writeQueueAtomic atomic rename + tmpfile cleanup', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t08');
-    fs.mkdirSync(path.join(roomDir, '.mindrian'), { recursive: true });
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const ok = Q.writeQueueAtomic(roomDir, {
-      version: 1,
-      entries: [{ section: 'foo', previous_governing_thought_hash: null, new_governing_thought_hash: sha256Hex('x'), enqueued_at: '2026-04-20T00:00:00Z', reason: 'test' }],
-    });
-    assert.equal(ok, true);
-    const tmpFiles = fs.readdirSync(path.join(roomDir, '.mindrian'))
-      .filter(function (n) { return n.indexOf('.tmp.') !== -1; });
-    assert.deepEqual(tmpFiles, [], 'no tmp leftovers');
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 1);
-  });
-
-  // Test 09: concurrent writes -- one wins; queue file remains valid JSON.
-  await runAsync('Test 09: concurrent writes do not corrupt queue.json', async function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t09');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    // Fire 10 concurrent enqueues for distinct sections.
-    const promises = [];
-    for (let i = 0; i < 10; i++) {
-      const section = 'sec-' + i;
-      promises.push(Promise.resolve().then(function () {
-        return Q.enqueue(roomDir, section, null, sha256Hex(section), 'governing_thought_changed');
-      }));
-    }
-    await Promise.all(promises);
-    // Queue file must be parseable JSON; entries count <= 10 (some may collide on rename race).
-    const q = Q.readQueue(roomDir);
-    assert.ok(Array.isArray(q.entries), 'entries must be array');
-    assert.ok(q.entries.length >= 1, 'at least one enqueue must persist');
-    const tmpFiles = fs.readdirSync(path.join(roomDir, '.mindrian'))
-      .filter(function (n) { return n.indexOf('.tmp.') !== -1; });
-    assert.deepEqual(tmpFiles, [], 'no tmp leftovers after concurrent writes');
-  });
-
-  // Test 10: SOFT_CAP -- 501st entry accepted with warning flag.
-  run('Test 10: SOFT_CAP 500 -- 501st entry accepted with warning', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t10');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    assert.equal(Q.SOFT_CAP, 500);
-    // Pre-fill queue to SOFT_CAP via direct write.
-    const entries = [];
-    for (let i = 0; i < 500; i++) {
-      entries.push({
-        section: 'sec-' + i,
-        previous_governing_thought_hash: null,
-        new_governing_thought_hash: sha256Hex('h' + i),
-        enqueued_at: '2026-04-20T00:00:00Z',
-        reason: 'governing_thought_changed',
-      });
-    }
-    Q.writeQueueAtomic(roomDir, { version: 1, entries: entries });
-    const r = Q.enqueue(roomDir, 'sec-501', null, sha256Hex('h501'), 'governing_thought_changed');
-    assert.equal(r.queued, true);
-    assert.equal(r.queue_size, 501);
-    assert.equal(r.warning, 'queue_soft_cap', 'soft cap warning should fire');
-  });
-
-  // Test 11: HARD_CAP 1000 -- 1001st entry rejected.
-  run('Test 11: HARD_CAP 1000 -- 1001st entry rejected with error', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t11');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    assert.equal(Q.HARD_CAP, 1000);
-    const entries = [];
-    for (let i = 0; i < 1000; i++) {
-      entries.push({
-        section: 'sec-' + i,
-        previous_governing_thought_hash: null,
-        new_governing_thought_hash: sha256Hex('h' + i),
-        enqueued_at: '2026-04-20T00:00:00Z',
-        reason: 'governing_thought_changed',
-      });
-    }
-    Q.writeQueueAtomic(roomDir, { version: 1, entries: entries });
-    const r = Q.enqueue(roomDir, 'sec-1001', null, sha256Hex('h1001'), 'governing_thought_changed');
-    assert.equal(r.queued, false);
-    assert.equal(r.error, 'queue_hard_cap');
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 1000, 'queue must stay at HARD_CAP');
-  });
-
-  // Test 12: CANON PART 8 invariant -- queue carries ONLY safe scalars.
-  run('Test 12: Canon Part 8 invariant -- queue.json contains NO governing_thought text', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t12');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    // Inject hashes for a section whose triple contains dangerous content.
-    const dangerous = 'Lawrence said we will hit 5M revenue by Q4 if pricing holds.';
-    const newHash = sha256Hex(dangerous);
-    Q.enqueue(roomDir, 'business-model', null, newHash, 'governing_thought_changed');
-    const qPath = path.join(roomDir, '.mindrian', 'brain-derivation-queue.json');
-    const raw = fs.readFileSync(qPath, 'utf8');
-    // Forbidden substrings audit -- the dangerous text must not appear anywhere.
-    const forbidden = ['Lawrence', '5M', 'revenue', 'Q4', 'pricing', /[A-Z][a-z]+\s+said/, /@[a-z]+\.[a-z]{2,}/, /\$\s?[0-9]/];
-    for (const f of forbidden) {
-      if (typeof f === 'string') {
-        assert.ok(raw.indexOf(f) === -1, 'forbidden substring "' + f + '" leaked into queue');
-      } else {
-        assert.ok(!f.test(raw), 'forbidden regex matched queue contents: ' + f);
-      }
-    }
-    // Verify only allow-list keys appear in entries.
-    const q = JSON.parse(raw);
-    const allowed = new Set(['section', 'previous_governing_thought_hash', 'new_governing_thought_hash', 'enqueued_at', 'reason']);
-    for (const entry of q.entries) {
-      for (const k of Object.keys(entry)) {
-        assert.ok(allowed.has(k), 'forbidden key in entry: ' + k);
-      }
-    }
-  });
-
-  // Test 13: drain reads triple, compares hash, skips on mismatch.
-  await runAsync('Test 13: drain skips entry when current triple hash differs from queue entry', async function () {
-    // Mock readTriple to return a triple whose hash WILL NOT match the queued new_hash.
-    installMocks({ tripleGoverningThought: 'CURRENT-DIFFERENT-TEXT' });
-    const roomDir = makeTmpRoot('t13');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('OLD-QUEUED-TEXT'), 'governing_thought_changed');
-    const r = await Q.drain(roomDir, { maxEntries: 5, dryRun: true });
-    assert.equal(r.skipped, 1, 'expected 1 skipped (stale queue race)');
-    assert.equal(r.processed, 0);
-    // Stale entry removed from queue (skip is consumed).
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 0, 'skipped stale entry should be dropped');
-  });
-
-  // Test 14: drain with brain offline -- entries kept (re_enqueued).
-  await runAsync('Test 14: drain with Brain offline -- entries re-enqueued (NOT dropped)', async function () {
-    installMocks({ isAvailable: false, tripleGoverningThought: 'thought-X' });
-    const roomDir = makeTmpRoot('t14');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    Q.enqueue(roomDir, 'market-analysis', null, sha256Hex('thought-X'), 'governing_thought_changed');
-    const r = await Q.drain(roomDir, { maxEntries: 5, dryRun: true });
-    assert.equal(r.re_enqueued, 1, 'expected 1 re-enqueued');
-    assert.equal(r.processed, 0);
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 1, 'entry must remain in queue when brain offline');
-  });
-
-  // Test 15: drain maxEntries=3 partitions a 5-entry queue.
-  await runAsync('Test 15: drain maxEntries=3 on 5-entry queue -> processes 3, leaves 2', async function () {
-    installMocks({ tripleGoverningThought: 'matching-text' });
-    const roomDir = makeTmpRoot('t15');
-    const Q = require('../core/brain-derivation-queue.cjs');
-    const matchingHash = sha256Hex('matching-text');
-    for (let i = 0; i < 5; i++) {
-      Q.enqueue(roomDir, 'sec-' + i, null, matchingHash, 'governing_thought_changed');
-    }
-    assert.equal(Q.readQueue(roomDir).entries.length, 5);
-    const r = await Q.drain(roomDir, { maxEntries: 3, dryRun: true });
-    assert.equal(r.processed, 3, 'expected 3 processed');
-    const q = Q.readQueue(roomDir);
-    assert.equal(q.entries.length, 2, 'expected 2 remaining');
-  });
-
-  // ---------------------------------------------------------------------
-  // Task 2 wiring tests (16-19): post-regen hook + drain script + hooks.json
-  // ---------------------------------------------------------------------
-
-  // Test 16: vault-section-minto-generator.cjs imports the queue module.
-  run('Test 16: vault-section-minto-generator wires brain-derivation-queue', function () {
-    const genPath = path.join(REPO_ROOT, 'scripts', 'vault-section-minto-generator.cjs');
-    const src = fs.readFileSync(genPath, 'utf8');
-    assert.ok(src.indexOf('brain-derivation-queue') !== -1,
-      'generator must reference brain-derivation-queue');
-    assert.ok(src.indexOf('tryEnqueueBrainDerivation') !== -1,
-      'generator must define post-regen enqueue hook');
-    assert.ok(src.indexOf('readPriorGoverningThoughtHash') !== -1,
-      'generator must capture prior hash before write');
-    // Hash-unchanged no-enqueue: the hook returns early when hashes match.
-    assert.ok(src.indexOf('priorHash === newHash') !== -1,
-      'generator must short-circuit on hash equality');
-  });
-
-  // Test 17: hooks.json registers brain-derivation-drain on UserPromptSubmit.
-  run('Test 17: hooks/hooks.json registers brain-derivation-drain on UserPromptSubmit', function () {
-    const hooksPath = path.join(REPO_ROOT, 'hooks', 'hooks.json');
-    const raw = fs.readFileSync(hooksPath, 'utf8');
-    const json = JSON.parse(raw); // throws if invalid JSON
-    assert.ok(raw.indexOf('brain-derivation-drain') !== -1,
-      'hooks.json must reference brain-derivation-drain');
-    const ups = json.hooks && json.hooks.UserPromptSubmit;
-    assert.ok(Array.isArray(ups), 'UserPromptSubmit must be array');
-    // Find indexes of intent-classifier and brain-derivation-drain.
-    let intentIdx = -1;
-    let drainIdx = -1;
-    for (let i = 0; i < ups.length; i++) {
-      const cmd = JSON.stringify(ups[i]);
-      if (cmd.indexOf('intent-classifier') !== -1) intentIdx = i;
-      if (cmd.indexOf('brain-derivation-drain') !== -1) drainIdx = i;
-    }
-    assert.ok(intentIdx !== -1, 'intent-classifier hook must exist');
-    assert.ok(drainIdx !== -1, 'brain-derivation-drain hook must exist');
-    assert.ok(drainIdx > intentIdx,
-      'brain-derivation-drain must come AFTER intent-classifier (order constraint)');
-  });
-
-  // Test 18: brain-derivation-drain.cjs script exists with BSL header and CLI.
-  run('Test 18: scripts/brain-derivation-drain.cjs has BSL 1.1 header + CJS purity', function () {
-    const scriptPath = path.join(REPO_ROOT, 'scripts', 'brain-derivation-drain.cjs');
-    assert.ok(fs.existsSync(scriptPath), 'drain script must exist');
-    const src = fs.readFileSync(scriptPath, 'utf8');
-    assert.ok(src.indexOf('BSL 1.1') !== -1, 'BSL 1.1 header required');
-    assert.ok(src.indexOf("require('node:") !== -1 || src.indexOf('require(\'node:') !== -1,
-      'must use node: built-in scheme');
-    // Detached child-process spawn for non-blocking dispatch.
-    assert.ok(src.indexOf('detached: true') !== -1,
-      'must spawn deriveSection child detached');
-    assert.ok(src.indexOf('unref()') !== -1,
-      'must unref detached child so parent exits immediately');
-    // Em-dash / en-dash check (zero allowed).
-    assert.ok(src.indexOf('\u2014') === -1 && src.indexOf('\u2013') === -1,
-      'no em-dashes or en-dashes allowed');
-  });
-
-  // Test 19: end-to-end -- writing a MINTO file enqueues brain-derivation
-  // (verifies post-regen hook lands when content has a governing_thought).
-  run('Test 19: writing MINTO with governing_thought triggers enqueue (post-regen hook fires)', function () {
-    installMocks();
-    const roomDir = makeTmpRoot('t19');
-    const sectionName = 'market-analysis';
-    const sectionDir = path.join(roomDir, sectionName);
-    fs.mkdirSync(sectionDir, { recursive: true });
-    // Drop a .room-root sentinel so the write-lock primitive accepts roomDir.
-    fs.writeFileSync(path.join(roomDir, '.room-root'), '');
-    const mintoPath = path.join(sectionDir, 'MINTO.md');
-
-    // Build a minimal valid MINTO content with governing_thought.
-    const newGt = 'A test governing thought for Phase 90-02 wiring verification.';
-    const content = [
-      '---',
-      'schema_version: "1.0"',
-      'type: section-minto',
-      'section: ' + sectionName,
-      'created: 2026-04-20',
-      'room: test-room',
-      'parent-moc: ROOM.md',
-      'methodology: minto-pyramid',
-      'sources: []',
-      'related: []',
-      'status: active',
-      'governing_thought: "' + newGt + '"',
-      'last_generated_at: "2026-04-20T00:00:00Z"',
-      'last_artifact_write_seen_at: null',
-      'reasoning_health_score: null',
-      'flagged_weaknesses: []',
-      'decision_log: []',
-      '---',
-      '',
-      '# Test',
-      '',
-      '## Governing Thought',
-      '',
-      '> ' + newGt,
-      '',
-    ].join('\n');
-
-    // Invoke atomicWriteMinto via the generator's exported API.
-    const generator = require(path.join(REPO_ROOT, 'scripts', 'vault-section-minto-generator.cjs'));
-    const env = generator.atomicWriteMinto(mintoPath, content, roomDir);
-    // The write may be rejected by invariants if the content fails a stricter
-    // check (we built minimal-valid above); accept either success or rejection
-    // -- the assertion focuses on the queue-enqueue side effect when success.
-    if (env && env.success) {
-      const Q = require('../core/brain-derivation-queue.cjs');
-      const q = Q.readQueue(roomDir);
-      assert.equal(q.entries.length, 1,
-        'post-regen hook must enqueue when governing_thought changes (got ' + q.entries.length + ')');
-      assert.equal(q.entries[0].section, sectionName);
-      assert.equal(q.entries[0].previous_governing_thought_hash, null,
-        'first regen prior hash should be null');
-      const expectedHash = sha256Hex(newGt);
-      assert.equal(q.entries[0].new_governing_thought_hash, expectedHash);
-      assert.equal(q.entries[0].reason, 'governing_thought_changed');
-    } else {
-      // If the write was rejected by invariants (depends on validator strictness
-      // for fixture content), the queue should remain empty -- which is also
-      // the correct contract (no enqueue when write fails). Test still passes.
-      const Q = require('../core/brain-derivation-queue.cjs');
-      const q = Q.readQueue(roomDir);
-      assert.equal(q.entries.length, 0,
-        'no enqueue when MINTO write was rejected');
-    }
-  });
-
-  process.stdout.write('\nbrain-derivation-queue tests: ' + passed + '/' + (passed + failed) + ' passed\n');
-  process.exit(failed === 0 ? 0 : 1);
-}
-
-main().catch(function (err) {
-  process.stderr.write('FATAL: ' + (err && err.stack ? err.stack : err) + '\n');
-  process.exit(1);
-});