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

package/lib/memory/test-rs-discovery-engine.cjs

@@ -1,603 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- * Phase 89.5 Plan 04 -- rs-discovery-engine fixture suite.
- *
- * Tests the top-level orchestrator at scripts/rs-discovery-engine.cjs.
- * The orchestrator chains every RS phase end-to-end:
- *   Phase 1 (Domain Analysis 89.1) -> Phase 1.5 (Fetchers 89.2) ->
- *   Phase 2 (Preprocessor 89.2) -> Phase 3 (Differential Scorer +
- *   Classifier + Breakthrough Scorer 89.2) -> Phase 4 (Thesis 89.2 +
- *   Commercial Assessor 89.5-01 + Expert Mapper 89.3) -> Output Layer
- *   (89.3 Aura/SQLite writer + Mind Map) -> Chain Downstream (89.4
- *   Chain Feeder).
- *
- * 9 scenarios total (>=8 mandated by plan):
- *   T1 -- happy path: full pipeline with mocked 89.1-89.5 modules; bundle
- *         shape verified ({topic, domain_analysis, query_matrix,
- *         fetched_results, preprocessed, scored, classified, breakthroughs,
- *         theses, commercial, output: {written, mind_map, experts},
- *         chain_metadata}); chain_metadata array of >=1 entry per
- *         discovery; each entry has {recommended_verb, feeds_into,
- *         spawn_skill, confidence, reasoning}.
- *   T2 -- Tier 0 fallback: rs-neo4j-writer.writeDiscovery throws
- *         AuraUnreachableError -> orchestrator catches; bundle.output.written.tier
- *         === 'tier0' (dispatched to rs-sqlite-mirror).
- *   T3 -- Mode B graceful: chain-feeder.lookupUpstream returns
- *         {state: 'ready'} (Brain-unreachable graceful path); bundle still
- *         populates chain_metadata; emitChainMetadata still works locally.
- *   T4 -- chain composition: every chain_metadata.recommended_verb is in
- *         CANONICAL_VERBS; spawn_skill is null OR matches a SKILL_SPAWN_RULES
- *         rule; feeds_into is one of {'PWS VP', 'Causal Loop',
- *         'Navigation Engine', 'JTBD'}.
- *   T5 -- Canon Part 8 input audit: opts contains forbidden bytes ->
- *         auditQueryObject throws ExternalEgressViolation BEFORE any module
- *         is invoked; err.meta.surface === 'rs-discovery-engine-input'.
- *   T6 -- Brain chokepoint exclusivity: read scripts/rs-discovery-engine.cjs
- *         source; assert grep 'fetch(' === 0; grep 'require.*brain-client'
- *         === 0 (orchestrator never directly imports brain-client; ALL
- *         Brain queries go through chain-feeder.lookupUpstream).
- *   T7 -- pause-state bubble: chain-feeder.lookupUpstream returns
- *         {state: 'pause', missing_upstream, suggested_action}; orchestrator
- *         returns the pause envelope verbatim; NO further phase modules
- *         invoked (mocks track invocation count; assert all === 0 after
- *         pause).
- *   T8 -- A1 sweep: every positive-path bundle JSON.stringify contains ZERO
- *         FORBIDDEN_PATTERNS hits.
- *   T9 -- runDiscovery is AsyncFunction (Module exports surface check).
- *
- * Pure CJS, zero npm deps, node built-ins only (assert + fs).
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-// ---------- Suite bookkeeping ----------
-
-let passed = 0;
-let failed = 0;
-const failures = [];
-const tests = [];
-
-function record(name, fn) {
-  tests.push({ name, fn });
-}
-
-async function runAll() {
-  for (const t of tests) {
-    try {
-      await t.fn();
-      passed++;
-      process.stdout.write('PASS ' + t.name + '\n');
-    } catch (err) {
-      failed++;
-      failures.push({ name: t.name, message: err && err.message ? err.message : String(err) });
-      process.stdout.write('FAIL ' + t.name + ': ' + (err && err.message ? err.message : String(err)) + '\n');
-    }
-  }
-}
-
-// ---------- Module under test ----------
-
-const ENGINE_PATH = path.resolve(__dirname, '..', '..', 'scripts', 'rs-discovery-engine.cjs');
-const orchestrator = require(ENGINE_PATH);
-const { runDiscovery } = orchestrator;
-
-// ---------- Reference imports for invariants ----------
-
-const { CANONICAL_VERBS, SKILL_SPAWN_RULES } = require('../core/rs-chain-feeder.cjs');
-const { FORBIDDEN_PATTERNS } = require('../core/rs-egress-prompts.cjs');
-
-const FEEDS_INTO_CANONICAL = new Set(['PWS VP', 'Causal Loop', 'Navigation Engine', 'JTBD']);
-
-// ---------- Helper: build deterministic mocks ----------
-//
-// Every mock returns a deterministic fixture so the orchestrator can be
-// tested without external infrastructure (Brain, Aura, filesystem). The
-// orchestrator's _test_mocks option substitutes these for the real
-// require'd modules.
-
-function makeInvocationCounters() {
-  return {
-    domainAnalyzer: 0,
-    queryMatrix: 0,
-    fetcherAcademic: 0,
-    fetcherPatents: 0,
-    fetcherIndustry: 0,
-    fetcherExperts: 0,
-    preprocessor: 0,
-    differentialScorer: 0,
-    innovationClassifier: 0,
-    breakthroughScorer: 0,
-    thesisGenerator: 0,
-    commercialAssessor: 0,
-    expertMapper: 0,
-    neo4jWriter: 0,
-    sqliteMirror: 0,
-    mindMap: 0,
-    chainFeederLookup: 0,
-    chainFeederEmit: 0,
-  };
-}
-
-function buildMockSet(opts) {
-  opts = opts || {};
-  const counts = opts.counts || makeInvocationCounters();
-
-  const mocks = {
-    domainAnalyzer: {
-      analyzeDomain: async function (topic) {
-        counts.domainAnalyzer += 1;
-        return {
-          primary_domain: 'biotech',
-          concepts: ['quantum', 'imaging', 'brain'],
-          terminology: ['MRI', 'qubit', 'fMRI'],
-          methods: ['superconducting', 'tomography'],
-          breakthroughs: ['NV-center diamond sensing'],
-          boundary_flag: false,
-          adjacent_domains: ['neurology', 'condensed matter physics'],
-        };
-      },
-    },
-    queryMatrix: {
-      generateQueryMatrix: function (analysis) {
-        counts.queryMatrix += 1;
-        return {
-          a_intersect_b: ['quantum AND imaging'],
-          a_leads_to_b: ['quantum -> imaging'],
-          b_leads_to_a: ['imaging -> quantum'],
-          adjacent: ['NV-center'],
-        };
-      },
-    },
-    fetcherAcademic: {
-      fetchAcademic: async function (queries) {
-        counts.fetcherAcademic += 1;
-        return {
-          papers: [
-            {
-              id: 'oa:123',
-              title: 'NV-center diamond magnetometry',
-              abstract: 'Superconducting qubit imaging.',
-              authors: [{ name: 'Dr. A', orcid: '0000-0001', institution: 'MIT' }],
-              source: 'openalex',
-            },
-          ],
-          telemetry: [{ source: 'openalex', status: 'ok' }],
-        };
-      },
-    },
-    fetcherPatents: {
-      fetchPatents: async function (queries) {
-        counts.fetcherPatents += 1;
-        return {
-          patents: [{ id: 'us:9876543', title: 'Method for NV-center imaging', abstract: 'patent abstract' }],
-          telemetry: [],
-        };
-      },
-    },
-    fetcherIndustry: {
-      fetchIndustry: async function (queries) {
-        counts.fetcherIndustry += 1;
-        return {
-          signals: [{ id: 'cb:co1', title: 'StartupCo NV imaging', signal: 'industry signal' }],
-          telemetry: [],
-        };
-      },
-    },
-    fetcherExperts: {
-      mapExperts: function (papers) {
-        counts.fetcherExperts += 1;
-        return [
-          {
-            name: 'Dr. A',
-            orcid: '0000-0001',
-            institution: 'MIT',
-            paper_count: 1,
-            h_index_estimate: 5,
-          },
-        ];
-      },
-    },
-    preprocessor: {
-      preprocess: function (documents) {
-        counts.preprocessor += 1;
-        return [
-          {
-            document_id: 'oa:123',
-            technical_terms: ['NV', 'magnetometry'],
-            concepts: ['quantum imaging'],
-            methods: ['superconducting'],
-            relevance_score: 0.8,
-            boundary_flag: false,
-          },
-        ];
-      },
-    },
-    differentialScorer: {
-      score: async function (queryConcept, docConcept, opts) {
-        counts.differentialScorer += 1;
-        return { diff: 0.3, lsa: 0.6, bert: 0.3, passes: true };
-      },
-    },
-    innovationClassifier: {
-      classify: function (scoredPair) {
-        counts.innovationClassifier += 1;
-        return Object.assign({}, scoredPair, {
-          query_concept: scoredPair.query_concept || 'quantum imaging',
-          doc_concept: scoredPair.doc_concept || 'transformer attention',
-          classification: 'structural_transfer',
-          bridge_concept: 'graph attention',
-        });
-      },
-    },
-    breakthroughScorer: {
-      scoreBreakthrough: function (classifiedPair) {
-        counts.breakthroughScorer += 1;
-        return Object.assign({}, classifiedPair, {
-          breakthrough: {
-            score: 8,
-            breakdown: { feasibility: 1.5, market: 1.6, magnitude: 1.7, advantage: 1.5, impact: 1.7 },
-            dominant_dimension: 'magnitude',
-          },
-        });
-      },
-    },
-    thesisGenerator: {
-      generateThesis: function (classifiedPair, breakthrough) {
-        counts.thesisGenerator += 1;
-        return 'By applying quantum imaging to transformer attention, achieve novelty because graph attention.';
-      },
-    },
-    commercialAssessor: {
-      assess: function (rsDiscovery) {
-        counts.commercialAssessor += 1;
-        return {
-          market_size_estimate: 'addressable market in the high single-digit billions',
-          value_proposition: 'translate quantum imaging into transformer attention',
-          partnership_targets: [{ name: 'MIT', type: 'academic', score: 0.9 }],
-        };
-      },
-    },
-    expertMapper: {
-      mapAuthorsToAura: async function (experts, opts) {
-        counts.expertMapper += 1;
-        return {
-          resolved_authors: [{
-            name: 'Dr. A', orcid: '0000-0001', institution: 'MIT',
-            h_index_estimate: 5, paper_count: 1, aura_node_id: null,
-          }],
-          resolved_institutions: [{ name: 'MIT', author_count: 1 }],
-          citation_edges: [],
-          missed_count: 0,
-          resolution_quality: 'degraded',
-          tier: 'sqlite',
-          schema_version: 1,
-          note: 'tier-0 degraded',
-        };
-      },
-    },
-    neo4jWriter: {
-      writeDiscovery: async function (pair, opts) {
-        counts.neo4jWriter += 1;
-        return {
-          wrote_node_count: 3,
-          wrote_edge_count: 2,
-          rollback_cypher: 'MATCH ... DETACH DELETE',
-          aura_op_id: 'op-aura-1',
-          schema_version: 1,
-        };
-      },
-      AuraUnreachableError: class AuraUnreachableError extends Error {
-        constructor(msg, meta) { super(msg); this.name = 'AuraUnreachableError'; this.meta = meta || {}; }
-      },
-    },
-    sqliteMirror: {
-      writeDiscovery: async function (pair, opts) {
-        counts.sqliteMirror += 1;
-        return {
-          wrote_node_count: 3,
-          wrote_edge_count: 2,
-          rollback_cypher: 'DELETE FROM ...',
-          aura_op_id: 'op-sqlite-1',
-          schema_version: 1,
-        };
-      },
-    },
-    mindMap: {
-      renderMindMap: async function (queryFilter, opts) {
-        counts.mindMap += 1;
-        return {
-          branches: {},
-          elements: [],
-          branch_colors: {},
-          metadata: { tier: 'sqlite', branch_counts: {}, total_nodes: 0, total_edges: 0, schema_version: 1 },
-          html_wrapper: '<html></html>',
-        };
-      },
-    },
-    chainFeeder: {
-      lookupUpstream: async function (problemType, stage, opts) {
-        counts.chainFeederLookup += 1;
-        return { state: 'ready' };
-      },
-      emitChainMetadata: function (rsType, score, activeContext) {
-        counts.chainFeederEmit += 1;
-        // Mirror the real chain-feeder logic for these scalars so T4
-        // chain composition checks (CANONICAL_VERBS membership +
-        // SKILL_SPAWN_RULES alignment + feeds_into canonical set) hold.
-        let feedsInto = 'JTBD';
-        if (rsType === 'structural_transfer') feedsInto = 'PWS VP';
-        else if (rsType === 'semantic_implementation') feedsInto = 'Causal Loop';
-        else if (rsType === 'hybrid') feedsInto = 'Navigation Engine';
-        const safeScore = Number.isFinite(score) ? score : 0;
-        let verb = 'Reformulate';
-        if (safeScore >= 7) verb = 'Bank Opportunity';
-        else if (safeScore >= 5) verb = 'Synthesize';
-        let spawnSkill = null;
-        let confidence = 0;
-        let reasoning = 'no rule matched';
-        // Mirror the first SKILL_SPAWN_RULES rule for happy-path mocks
-        // (score>=7 + structural_transfer -> /mos:find-analogies @ 0.85).
-        if (safeScore >= 7 && rsType === 'structural_transfer') {
-          spawnSkill = '/mos:find-analogies';
-          confidence = 0.85;
-          reasoning = 'high breakthrough + structural transfer -> SAPPhIRE/TRIZ deepening';
-        }
-        return {
-          recommended_verb: verb,
-          feeds_into: feedsInto,
-          spawn_skill: spawnSkill,
-          confidence: confidence,
-          reasoning: reasoning,
-        };
-      },
-    },
-  };
-
-  return { mocks, counts };
-}
-
-// Capture box for A1 sweep.
-const positiveBundles = [];
-
-// ---------- Tests ----------
-
-record('T1 happy path: full pipeline with mocked 89.1-89.5 modules; bundle shape verified', async function () {
-  const { mocks, counts } = buildMockSet();
-  const bundle = await runDiscovery('quantum brain imaging', {
-    room_dir: '/tmp/test-room',
-    _test_mocks: mocks,
-  });
-
-  // Bundle shape.
-  assert.equal(typeof bundle, 'object', 'bundle must be object');
-  assert.equal(bundle.topic, 'quantum brain imaging', 'bundle.topic must match input');
-  assert.ok(bundle.domain_analysis && typeof bundle.domain_analysis === 'object', 'domain_analysis required');
-  assert.ok(bundle.query_matrix && typeof bundle.query_matrix === 'object', 'query_matrix required');
-  assert.ok(bundle.fetched_results && typeof bundle.fetched_results === 'object', 'fetched_results required');
-  assert.ok(Array.isArray(bundle.preprocessed), 'preprocessed must be array');
-  assert.ok(Array.isArray(bundle.scored), 'scored must be array');
-  assert.ok(Array.isArray(bundle.classified), 'classified must be array');
-  assert.ok(Array.isArray(bundle.breakthroughs), 'breakthroughs must be array');
-  assert.ok(Array.isArray(bundle.theses), 'theses must be array');
-  assert.ok(Array.isArray(bundle.commercial), 'commercial must be array');
-  assert.ok(bundle.output && typeof bundle.output === 'object', 'output required');
-  assert.ok(bundle.output.written && typeof bundle.output.written === 'object', 'output.written required');
-  assert.ok(bundle.output.mind_map && typeof bundle.output.mind_map === 'object', 'output.mind_map required');
-  assert.ok(bundle.output.experts && typeof bundle.output.experts === 'object', 'output.experts required');
-  assert.ok(Array.isArray(bundle.chain_metadata), 'chain_metadata must be array');
-
-  // Chain metadata contract: >=1 entry; each has the 5 canonical fields.
-  assert.ok(bundle.chain_metadata.length >= 1, 'chain_metadata must have >=1 entry');
-  for (const e of bundle.chain_metadata) {
-    assert.equal(typeof e.recommended_verb, 'string', 'recommended_verb must be string');
-    assert.equal(typeof e.feeds_into, 'string', 'feeds_into must be string');
-    assert.ok(e.spawn_skill === null || typeof e.spawn_skill === 'string',
-      'spawn_skill must be null or string');
-    assert.equal(typeof e.confidence, 'number', 'confidence must be number');
-    assert.equal(typeof e.reasoning, 'string', 'reasoning must be string');
-  }
-
-  // Sanity: every mocked phase invoked at least once.
-  assert.ok(counts.domainAnalyzer >= 1, 'domainAnalyzer must be invoked');
-  assert.ok(counts.queryMatrix >= 1, 'queryMatrix must be invoked');
-  assert.ok(counts.fetcherAcademic >= 1, 'fetcherAcademic must be invoked');
-  assert.ok(counts.preprocessor >= 1, 'preprocessor must be invoked');
-  assert.ok(counts.chainFeederEmit >= 1, 'chainFeederEmit must be invoked');
-
-  positiveBundles.push(bundle);
-});
-
-record('T2 Tier 0 fallback: writeDiscovery throws AuraUnreachableError -> dispatched to sqlite', async function () {
-  const { mocks, counts } = buildMockSet();
-  // Force tier1 dispatch (simulate Aura url present) but make Aura write throw.
-  mocks.neo4jWriter.writeDiscovery = async function () {
-    counts.neo4jWriter += 1;
-    const E = mocks.neo4jWriter.AuraUnreachableError;
-    throw new E('Aura backend unreachable: simulated', { original: 'simulated' });
-  };
-
-  const bundle = await runDiscovery('quantum brain imaging', {
-    room_dir: '/tmp/test-room',
-    aura_url: 'neo4j+s://fake.aura.io',  // forces tier1 detection
-    _test_mocks: mocks,
-  });
-
-  // Orchestrator must catch AuraUnreachableError and dispatch to sqlite.
-  assert.equal(bundle.output.written.tier, 'tier0',
-    'output.written.tier must === tier0 after Aura-unreachable graceful fallback');
-  assert.ok(counts.sqliteMirror >= 1, 'sqliteMirror must be invoked on Tier 0 fallback');
-  assert.ok(counts.neo4jWriter >= 1, 'neo4jWriter must have been attempted before fallback');
-
-  positiveBundles.push(bundle);
-});
-
-record('T3 Mode B graceful: lookupUpstream ready (Brain unreachable) -> chain_metadata populated', async function () {
-  const { mocks, counts } = buildMockSet();
-  mocks.chainFeeder.lookupUpstream = async function () {
-    counts.chainFeederLookup += 1;
-    // Brain-unreachable graceful path per 89.4-02.
-    return { state: 'ready' };
-  };
-
-  const bundle = await runDiscovery('quantum brain imaging', {
-    room_dir: '/tmp/test-room',
-    _test_mocks: mocks,
-  });
-
-  // chain_metadata still populated locally (emitChainMetadata works without Brain).
-  assert.ok(Array.isArray(bundle.chain_metadata), 'chain_metadata must be array');
-  assert.ok(bundle.chain_metadata.length >= 1, 'chain_metadata must populate even in Mode B');
-  assert.ok(counts.chainFeederEmit >= 1, 'emitChainMetadata must run locally even when Brain is unreachable');
-
-  positiveBundles.push(bundle);
-});
-
-record('T4 chain composition: every recommended_verb in CANONICAL_VERBS; spawn_skill aligned; feeds_into canonical', async function () {
-  const { mocks } = buildMockSet();
-  const bundle = await runDiscovery('quantum brain imaging', {
-    room_dir: '/tmp/test-room',
-    _test_mocks: mocks,
-  });
-
-  const validSpawnSkills = new Set(SKILL_SPAWN_RULES.map(function (r) { return r.spawn; }));
-  for (const e of bundle.chain_metadata) {
-    assert.ok(CANONICAL_VERBS.includes(e.recommended_verb),
-      'recommended_verb must be in CANONICAL_VERBS; got ' + JSON.stringify(e.recommended_verb));
-    if (e.spawn_skill !== null) {
-      assert.ok(validSpawnSkills.has(e.spawn_skill),
-        'spawn_skill must match SKILL_SPAWN_RULES rule; got ' + JSON.stringify(e.spawn_skill));
-    }
-    assert.ok(FEEDS_INTO_CANONICAL.has(e.feeds_into),
-      'feeds_into must be in canonical set; got ' + JSON.stringify(e.feeds_into));
-  }
-
-  positiveBundles.push(bundle);
-});
-
-record('T5 Canon Part 8 input audit: forbidden bytes in opts -> ExternalEgressViolation BEFORE any module invoked', async function () {
-  const counts = makeInvocationCounters();
-  const { mocks } = buildMockSet({ counts: counts });
-
-  let caught = null;
-  try {
-    await runDiscovery('topic', {
-      meeting_transcript: 'meeting with Lawrence said the deal is $5M',
-      _test_mocks: mocks,
-    });
-  } catch (err) {
-    caught = err;
-  }
-
-  assert.ok(caught !== null, 'expected ExternalEgressViolation throw, got none');
-  assert.equal(caught.name, 'ExternalEgressViolation',
-    'expected err.name=ExternalEgressViolation; got ' + (caught && caught.name));
-  assert.ok(caught.meta && typeof caught.meta === 'object', 'err.meta must be object');
-  assert.equal(caught.meta.surface, 'rs-discovery-engine-input',
-    'expected err.meta.surface=rs-discovery-engine-input; got ' + JSON.stringify(caught.meta.surface));
-
-  // Defense-in-depth: NO module invoked because audit ran at the gate.
-  assert.equal(counts.domainAnalyzer, 0, 'domainAnalyzer must NOT be invoked after audit throw');
-  assert.equal(counts.queryMatrix, 0, 'queryMatrix must NOT be invoked after audit throw');
-  assert.equal(counts.fetcherAcademic, 0, 'fetcherAcademic must NOT be invoked after audit throw');
-  assert.equal(counts.chainFeederLookup, 0, 'chainFeederLookup must NOT be invoked after audit throw');
-});
-
-record('T6 Brain chokepoint exclusivity: source has zero fetch( and zero direct brain-client require', function () {
-  const src = fs.readFileSync(ENGINE_PATH, 'utf8');
-  // No code path may invoke fetch( from the orchestrator. The 89.2 fetchers
-  // each have their OWN audit chokepoint; the orchestrator never reaches
-  // the network directly.
-  // Strip line comments and block comments before scanning.
-  const stripped = src
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/\/\/[^\n]*/g, '');
-  assert.ok(stripped.indexOf('fetch(') === -1,
-    'orchestrator source must NOT contain fetch( in code (defense-in-depth: zero new fetch surface)');
-
-  // The orchestrator never directly imports brain-client. ALL Brain queries
-  // go through chain-feeder.lookupUpstream which wraps brainClient.query
-  // per 89.4-02 chokepoint reuse.
-  const brainRequireRegex = /require\([^)]*brain-client[^)]*\)/;
-  assert.equal(brainRequireRegex.test(stripped), false,
-    'orchestrator must NOT directly require brain-client.cjs; reuse 89.4-02 chain-feeder.lookupUpstream chokepoint');
-});
-
-record('T7 pause-state bubble: lookupUpstream pause -> pause envelope returned; NO further phase modules invoked', async function () {
-  const counts = makeInvocationCounters();
-  const { mocks } = buildMockSet({ counts: counts });
-  mocks.chainFeeder.lookupUpstream = async function () {
-    counts.chainFeederLookup += 1;
-    return {
-      state: 'pause',
-      missing_upstream: ['systems-thinking'],
-      suggested_action: 'Run Methodology',
-    };
-  };
-
-  const result = await runDiscovery('quantum brain imaging', {
-    room_dir: '/tmp/test-room',
-    _test_mocks: mocks,
-  });
-
-  // Pause envelope bubbles up verbatim.
-  assert.equal(result.state, 'pause', 'pause-state result.state must === pause');
-  assert.ok(Array.isArray(result.missing_upstream), 'pause result.missing_upstream must be array');
-  assert.equal(result.missing_upstream[0], 'systems-thinking', 'missing_upstream[0] preserved');
-  assert.equal(result.suggested_action, 'Run Methodology', 'suggested_action preserved');
-
-  // No phase modules beyond the chain-feeder gate were invoked.
-  assert.equal(counts.domainAnalyzer, 0, 'domainAnalyzer must NOT run after pause');
-  assert.equal(counts.queryMatrix, 0, 'queryMatrix must NOT run after pause');
-  assert.equal(counts.fetcherAcademic, 0, 'fetcherAcademic must NOT run after pause');
-  assert.equal(counts.preprocessor, 0, 'preprocessor must NOT run after pause');
-  assert.equal(counts.differentialScorer, 0, 'differentialScorer must NOT run after pause');
-  assert.equal(counts.chainFeederEmit, 0, 'chainFeederEmit must NOT run after pause');
-  assert.equal(counts.neo4jWriter, 0, 'neo4jWriter must NOT run after pause');
-  assert.equal(counts.sqliteMirror, 0, 'sqliteMirror must NOT run after pause');
-});
-
-record('T8 A1 sweep: every positive-path bundle JSON contains ZERO FORBIDDEN_PATTERNS hits', function () {
-  assert.ok(Array.isArray(FORBIDDEN_PATTERNS) && FORBIDDEN_PATTERNS.length >= 6,
-    'FORBIDDEN_PATTERNS must be re-exported (>= 6 patterns)');
-  assert.ok(positiveBundles.length >= 4,
-    'A1 sweep requires at least 4 captured positive bundles; got ' + positiveBundles.length);
-  for (let i = 0; i < positiveBundles.length; i += 1) {
-    const json = JSON.stringify(positiveBundles[i]);
-    for (const re of FORBIDDEN_PATTERNS) {
-      assert.equal(re.test(json), false,
-        'positive bundle ' + i + ' contains FORBIDDEN_PATTERNS hit ' + re.source
-          + ' in JSON: ' + json.slice(0, 200));
-    }
-  }
-});
-
-record('T9 runDiscovery is AsyncFunction; Module exports surface verified', function () {
-  assert.equal(typeof runDiscovery, 'function', 'runDiscovery must be a function');
-  assert.equal(runDiscovery.constructor.name, 'AsyncFunction',
-    'runDiscovery must be AsyncFunction; got ' + runDiscovery.constructor.name);
-  assert.ok(orchestrator._test && typeof orchestrator._test === 'object',
-    '_test export surface must be present for whitebox introspection');
-});
-
-// ---------- Suite report ----------
-
-(async function () {
-  await runAll();
-  const total = passed + failed;
-  process.stdout.write('\n');
-  if (failed === 0) {
-    process.stdout.write('=== 89.5-04 rs-discovery-engine suite: ' + passed + '/' + total + ' passed ===\n');
-    process.exit(0);
-  } else {
-    process.stdout.write('=== 89.5-04 rs-discovery-engine suite: ' + passed + '/' + total + ' passed (' + failed + ' failed) ===\n');
-    for (const f of failures) {
-      process.stdout.write('  FAIL ' + f.name + ': ' + f.message + '\n');
-    }
-    process.exit(1);
-  }
-})();