@mindrian_os/cli 1.13.0-beta.10

package/lib/memory/navigation-engine-core.test.cjs

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 91-00 -- Navigation Engine Core fixture tests
+ * ====================================================
+ * The L5 Decision layer is the composition point that turns the shipped
+ * L1-L4 substrate into a routing decision surface. This file exercises
+ * lib/core/navigation-engine.cjs (decide) + lib/core/navigation-engine-shared.cjs
+ * (frozen tables + pure helpers) per the Phase 90-09 frozen interface
+ * contract v1 (.planning/research/navigation-engine-brain-interface.md).
+ *
+ * Test map (tests 1-33, one-to-one with the PLAN <behavior> blocks):
+ *
+ * Task 1 (shared helpers + frozen tables, pure functions, zero I/O):
+ *   1.  STALENESS_MULTIPLIERS table matches Section 4 byte-for-byte
+ *   2.  CANONICAL_VERBS frozen array length 10, Canon Part 3 order
+ *   3.  SECTION_WEIGHTS required-section sum equals 1.0; optional excluded
+ *   4.  applyStalenessMultiplier core rows (null, fresh, brain_offline 0.9)
+ *   5.  applyStalenessMultiplier clamps + parse_failed override + unknown
+ *       stale_reason fallback
+ *   6.  emptyDecision shell shape
+ *   7.  emptyDecisionTrace 8 Section 8 fields + 5 structural fields
+ *   8.  resolveTierMode -> mode_a (brain non-null + reachable + parseable)
+ *   9.  resolveTierMode -> mode_b (brain non-null + unreachable +
+ *       brain_offline)
+ *   10. resolveTierMode -> tier_0 (brain null OR parse_failed OR
+ *       unavailable)
+ *
+ * Task 2 (decide() orchestration + gates + triangulation):
+ *   11. decide on brain:null -> tier_0, weight 0.0, staleness 'absent'
+ *   12. decide on fresh+strong-pattern -> mode_a + RECOMMENDED rendered
+ *   13. decide on fresh+weak-pattern (0.65) -> RECOMMENDED suppressed,
+ *       confidence still recorded
+ *   14. RECOMMENDED never renders in mode_b
+ *   15. RECOMMENDED never renders in tier_0
+ *   16. Attribution guard: brain.author !== 'brain' -> weight 0.0 + trace
+ *       note
+ *   17. All 8 Section 8 trace fields present on every decision
+ *   18. brain_md_sections_consumed reflects non-null sections
+ *   19. Five-signal triangulation: weak-MINTO + strong-Brain
+ *   20. Five-signal triangulation: fresh-everything
+ *   21. Five-signal triangulation: wicked-detected -> soft-systems route
+ *   22. Brain-offline exemption: weight 0.9 + mode_b + RECOMMENDED off
+ *   23. parse_failed -> tier_0 + weight 0.0
+ *   24. governing_thought_changed -> weight 0.3
+ *   25. derivation_timeout -> weight 0.2
+ *   26. No cross-turn caching: tier mode re-resolves per turn
+ *   27. Per-turn cache boundary: within decide(), readQuadruple touched
+ *       at most once per sectionPath
+ *   28. FORBIDDEN direct fs reads on BRAIN.md (grep)
+ *   29. FORBIDDEN Brain network calls (grep)
+ *   30. Performance budget: 5-section fixture under 800ms cold, 300ms warm
+ *   31. suppress_skills output array shape
+ *   32. persona_updates output struct shape
+ *   33. offer_next_step noise gate (max 1 per turn)
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const SHARED_PATH = path.join(REPO, 'lib/core/navigation-engine-shared.cjs');
+const ENGINE_PATH = path.join(REPO, 'lib/core/navigation-engine.cjs');
+
+// Lazy require so the shared-helper-only tests can run before the engine
+// module exists (during Task 1 RED). Engine tests require the engine file.
+function requireShared() {
+  return require(SHARED_PATH);
+}
+function requireEngine() {
+  return require(ENGINE_PATH);
+}
+
+// ---------- Test scaffolding ----------
+
+let passed = 0;
+let failed = 0;
+function run(name, fn) {
+  try {
+    fn();
+    process.stdout.write('ok  ' + name + '\n');
+    passed += 1;
+  } catch (err) {
+    process.stderr.write('FAIL ' + name + '\n');
+    process.stderr.write(String(err && err.stack ? err.stack : err) + '\n');
+    failed += 1;
+  }
+}
+
+// ---------- Fixture builders ----------
+
+function makeBrain(overrides) {
+  const base = {
+    exists: true,
+    section: 'market-analysis',
+    brain_generated_at: '2026-04-20T12:00:00Z',
+    brain_graph_version: 1,
+    governing_thought_hash: 'sha256:abc123',
+    staleness: 'fresh',
+    stale_reason: null,
+    author: 'brain',
+    confidence_baseline: 0.5,
+    parse_failed: false,
+    sections: {
+      pattern_matches: null,
+      framework_chain_predictions: null,
+      cross_domain_analogies: null,
+      wicked_indicators: null,
+      unfilled_opportunity_matches: null,
+      assessment_thinking_chain_position: null,
+      problemtype_classification: null,
+      flagged_contradictions_xroom: null,
+      hsi_signals: null,
+    },
+    flagged_weaknesses: [],
+  };
+  return Object.assign({}, base, overrides || {});
+}
+
+function makeQuadruple(overrides) {
+  const base = {
+    room: { exists: true, identity_text: 'market analysis section', references: [] },
+    state: { exists: true, artifact_count: 3, completeness_score: 0.6 },
+    reasoning: {
+      exists: true,
+      governing_thought: 'Customers will pay a premium for X',
+      reasoning_health_score: 0.7,
+      is_stale: false,
+      arguments: [],
+    },
+    brain: makeBrain(),
+  };
+  return Object.assign({}, base, overrides || {});
+}
+
+function makeTurn(overrides) {
+  return Object.assign(
+    {
+      userText: 'help me think about market sizing',
+      sectionPath: '/tmp/fixture-room/market-analysis',
+      sessionId: 'test-session-1',
+    },
+    overrides || {}
+  );
+}
+
+function makeContext(overrides) {
+  return Object.assign(
+    {
+      quadruple: makeQuadruple(),
+      brainAvailable: true,
+      userPersona: { archetype: 'Founder', problem_type: 'IDP', venture_stage: 'discovery' },
+      intentSignal: { intent: 'analyze', confidence: 0.6 },
+    },
+    overrides || {}
+  );
+}
+
+// =========================================================
+// Task 1 -- shared helpers + frozen tables (Tests 1..10)
+// =========================================================
+
+run('Test 1: STALENESS_MULTIPLIERS table matches Section 4 byte-for-byte', () => {
+  const { STALENESS_MULTIPLIERS } = requireShared();
+  // Each row checked against the Section 4.1 multiplier table.
+  // Key shape: stale_reason string OR sentinel keys for null/fresh/unavailable.
+  assert.equal(STALENESS_MULTIPLIERS.null, 0.0);
+  assert.equal(STALENESS_MULTIPLIERS.fresh, 1.0);
+  assert.equal(STALENESS_MULTIPLIERS.age_exceeded, 0.7);
+  assert.equal(STALENESS_MULTIPLIERS.governing_thought_changed, 0.3);
+  assert.equal(STALENESS_MULTIPLIERS.brain_graph_version_mismatch, 0.5);
+  assert.equal(STALENESS_MULTIPLIERS.brain_offline, 0.9);
+  assert.equal(STALENESS_MULTIPLIERS.derivation_timeout, 0.2);
+  assert.equal(STALENESS_MULTIPLIERS.parse_failed, 0.0);
+  assert.equal(STALENESS_MULTIPLIERS.unavailable, 0.0);
+  assert.equal(Object.isFrozen(STALENESS_MULTIPLIERS), true);
+});
+
+run('Test 2: CANONICAL_VERBS frozen array length 10 in Canon Part 3 order', () => {
+  const { CANONICAL_VERBS } = requireShared();
+  assert.equal(Array.isArray(CANONICAL_VERBS), true);
+  assert.equal(CANONICAL_VERBS.length, 10);
+  assert.deepEqual(CANONICAL_VERBS, [
+    'Run Methodology',
+    'Reformulate',
+    'Spawn Sub-Agent',
+    'Navigate Graph',
+    "Devil's Advocate",
+    'Scenario Plan',
+    'Synthesize',
+    'Bank Opportunity',
+    'Defer',
+    'Free-Text',
+  ]);
+  assert.equal(Object.isFrozen(CANONICAL_VERBS), true);
+});
+
+run('Test 3: SECTION_WEIGHTS required sum to 1.0; optional excluded', () => {
+  const { SECTION_WEIGHTS } = requireShared();
+  // Required sections (Section 3.2 weights):
+  const requiredSum =
+    SECTION_WEIGHTS.pattern_matches +
+    SECTION_WEIGHTS.framework_chain_predictions +
+    SECTION_WEIGHTS.cross_domain_analogies +
+    SECTION_WEIGHTS.wicked_indicators +
+    SECTION_WEIGHTS.unfilled_opportunity_matches +
+    SECTION_WEIGHTS.assessment_thinking_chain_position +
+    SECTION_WEIGHTS.problemtype_classification;
+  // Floating-point sum is exact: 0.35 + 0.20 + 0.15 + 0.10 + 0.10 + 0.05 + 0.05 = 1.00.
+  assert.equal(Math.abs(requiredSum - 1.0) < 1e-9, true,
+    'required sections must sum to 1.0, got ' + requiredSum);
+  // Optional sections are explicitly recorded as 0 (caveat surface only).
+  assert.equal(SECTION_WEIGHTS.flagged_contradictions_xroom, 0);
+  assert.equal(SECTION_WEIGHTS.hsi_signals, 0);
+  assert.equal(Object.isFrozen(SECTION_WEIGHTS), true);
+});
+
+run('Test 4: applyStalenessMultiplier core rows', () => {
+  const { applyStalenessMultiplier } = requireShared();
+  assert.equal(applyStalenessMultiplier(null), 0.0);
+  assert.equal(applyStalenessMultiplier({ staleness: 'fresh' }), 1.0);
+  assert.equal(
+    applyStalenessMultiplier({ staleness: 'stale', stale_reason: 'brain_offline' }),
+    0.9
+  );
+});
+
+run('Test 5: applyStalenessMultiplier clamps + parse_failed + unknown reason', () => {
+  const { applyStalenessMultiplier } = requireShared();
+  // parse_failed override regardless of staleness label
+  assert.equal(applyStalenessMultiplier({ parse_failed: true, staleness: 'fresh' }), 0.0);
+  // unknown stale_reason falls back to 0.0 conservatively
+  assert.equal(
+    applyStalenessMultiplier({ staleness: 'stale', stale_reason: 'invented_reason' }),
+    0.0
+  );
+  // unavailable -> 0.0 regardless of stale_reason
+  assert.equal(
+    applyStalenessMultiplier({ staleness: 'unavailable', stale_reason: null }),
+    0.0
+  );
+  // Result always within [0, 1]
+  const out = applyStalenessMultiplier({ staleness: 'fresh' });
+  assert.equal(out >= 0.0 && out <= 1.0, true);
+});
+
+run('Test 6: emptyDecision returns expected shell', () => {
+  const { emptyDecision } = requireShared();
+  const d = emptyDecision();
+  assert.equal(d.fire_skill, null);
+  assert.equal(d.offer_next_step, null);
+  assert.deepEqual(d.suppress_skills, []);
+  assert.equal(d.persona_updates, null);
+  assert.equal(typeof d.decision_trace, 'object');
+  assert.notEqual(d.decision_trace, null);
+});
+
+run('Test 7: emptyDecisionTrace has 8 Section 8 fields + 5 structural fields', () => {
+  const { emptyDecisionTrace } = requireShared();
+  const t = emptyDecisionTrace();
+  // 8 Section 8 required fields:
+  assert.equal('brain_md_version' in t, true);
+  assert.equal('brain_md_staleness' in t, true);
+  assert.equal('brain_md_stale_reason' in t, true);
+  assert.equal('brain_md_weight_applied' in t, true);
+  assert.equal('brain_md_recommended_confidence' in t, true);
+  assert.equal('brain_md_recommended_marker_rendered' in t, true);
+  assert.equal('brain_md_tier_mode' in t, true);
+  assert.equal('brain_md_sections_consumed' in t, true);
+  // 5 structural fields:
+  assert.equal('icm_scope' in t, true);
+  assert.equal('sql_signals' in t, true);
+  assert.equal('minto_reasoning' in t, true);
+  assert.equal('intent_persona' in t, true);
+  assert.equal('chosen_rationale' in t, true);
+  // Sentinels:
+  assert.equal(t.brain_md_tier_mode, 'tier_0');
+  assert.equal(t.brain_md_recommended_marker_rendered, false);
+  assert.equal(Array.isArray(t.brain_md_sections_consumed), true);
+});
+
+run('Test 8: resolveTierMode -> mode_a happy path', () => {
+  const { resolveTierMode } = requireShared();
+  const q = makeQuadruple();
+  assert.equal(resolveTierMode(q, true), 'mode_a');
+});
+
+run('Test 9: resolveTierMode -> mode_b on brain_offline + unreachable', () => {
+  const { resolveTierMode } = requireShared();
+  const q = makeQuadruple({
+    brain: makeBrain({ staleness: 'stale', stale_reason: 'brain_offline' }),
+  });
+  assert.equal(resolveTierMode(q, false), 'mode_b');
+});
+
+run('Test 10: resolveTierMode -> tier_0 on null / parse_failed / unavailable', () => {
+  const { resolveTierMode } = requireShared();
+  // brain === null
+  assert.equal(resolveTierMode(makeQuadruple({ brain: null }), true), 'tier_0');
+  // parse_failed === true
+  assert.equal(
+    resolveTierMode(makeQuadruple({ brain: makeBrain({ parse_failed: true }) }), true),
+    'tier_0'
+  );
+  // staleness === 'unavailable'
+  assert.equal(
+    resolveTierMode(makeQuadruple({ brain: makeBrain({ staleness: 'unavailable' }) }), true),
+    'tier_0'
+  );
+});
+
+// =========================================================
+// Task 2 -- decide() orchestration + gates (Tests 11..33)
+// =========================================================
+// These tests REQUIRE lib/core/navigation-engine.cjs to exist. During
+// Task 1 RED they are skipped (file does not exist yet); Task 2 RED
+// re-runs them and they must fail; Task 2 GREEN they pass.
+
+function engineLoadable() {
+  return fs.existsSync(ENGINE_PATH);
+}
+
+if (engineLoadable()) {
+  run('Test 11: decide on brain:null -> tier_0, weight 0.0, absent', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({ quadruple: makeQuadruple({ brain: null }) });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'tier_0');
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.0);
+    assert.equal(d.decision_trace.brain_md_staleness, 'absent');
+    assert.equal(/Tier 0 fallback/i.test(d.decision_trace.chosen_rationale || ''), true);
+    assert.equal(d.fire_skill, null);
+  });
+
+  run('Test 12: fresh + strong pattern_matches (0.85) -> RECOMMENDED rendered', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: {
+              body: '- Run Methodology (confidence: 0.85, source: SWOT)',
+              tokens_estimate: 12,
+            },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'mode_a');
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, true);
+    assert.equal(d.decision_trace.brain_md_recommended_confidence, 0.85);
+  });
+
+  run('Test 13: weak pattern (0.65) -> RECOMMENDED suppressed, confidence recorded', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: {
+              body: '- Run Methodology (confidence: 0.65, source: PESTLE)',
+              tokens_estimate: 12,
+            },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, false);
+    assert.equal(d.decision_trace.brain_md_recommended_confidence, 0.65);
+  });
+
+  run('Test 14: RECOMMENDED never renders in mode_b', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      brainAvailable: false,
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          staleness: 'stale',
+          stale_reason: 'brain_offline',
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: {
+              body: '- Run Methodology (confidence: 0.95, source: BMC)',
+              tokens_estimate: 12,
+            },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'mode_b');
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, false);
+    assert.equal(/mode_b suppresses RECOMMENDED/i.test(d.decision_trace.chosen_rationale || ''), true);
+  });
+
+  run('Test 15: RECOMMENDED never renders in tier_0', () => {
+    const { decide } = requireEngine();
+    const d = decide(
+      makeTurn(),
+      makeContext({ quadruple: makeQuadruple({ brain: null }) })
+    );
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'tier_0');
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, false);
+  });
+
+  run('Test 16: attribution guard demotes non-brain author to weight 0.0', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          author: 'human',
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: {
+              body: '- Run Methodology (confidence: 0.9, source: forged)',
+              tokens_estimate: 12,
+            },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.0);
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, false);
+    assert.equal(/canon_part_2_attribution_breach/i.test(d.decision_trace.chosen_rationale || ''), true);
+  });
+
+  run('Test 17: all 8 Section 8 trace fields present on every decision', () => {
+    const { decide } = requireEngine();
+    const fixtures = [
+      makeContext({ quadruple: makeQuadruple({ brain: null }) }),
+      makeContext(),
+      makeContext({
+        brainAvailable: false,
+        quadruple: makeQuadruple({
+          brain: makeBrain({ staleness: 'stale', stale_reason: 'brain_offline' }),
+        }),
+      }),
+    ];
+    const required = [
+      'brain_md_version',
+      'brain_md_staleness',
+      'brain_md_stale_reason',
+      'brain_md_weight_applied',
+      'brain_md_recommended_confidence',
+      'brain_md_recommended_marker_rendered',
+      'brain_md_tier_mode',
+      'brain_md_sections_consumed',
+    ];
+    for (const ctx of fixtures) {
+      const d = decide(makeTurn(), ctx);
+      for (const k of required) {
+        assert.equal(k in d.decision_trace, true, 'missing trace field: ' + k);
+      }
+    }
+  });
+
+  run('Test 18: brain_md_sections_consumed reflects non-null sections only', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: { body: '- ok (confidence: 0.8)', tokens_estimate: 4 },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.deepEqual(d.decision_trace.brain_md_sections_consumed, ['pattern_matches']);
+  });
+
+  run('Test 19: weak-MINTO + strong-Brain -> trace captures both', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        reasoning: {
+          exists: true,
+          governing_thought: 'shaky claim',
+          reasoning_health_score: 0.3,
+          is_stale: false,
+          arguments: [],
+        },
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: { body: '- Run Methodology (confidence: 0.9)', tokens_estimate: 8 },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.minto_reasoning.reasoning_health_score, 0.3);
+    assert.equal(d.decision_trace.brain_md_weight_applied, 1.0);
+  });
+
+  run('Test 20: fresh-everything -> all five signals captured + non-null fire_skill', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        reasoning: {
+          exists: true,
+          governing_thought: 'firm claim',
+          reasoning_health_score: 0.9,
+          is_stale: false,
+          arguments: [],
+        },
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: { body: '- Run Methodology (confidence: 0.9, source: SWOT)', tokens_estimate: 10 },
+            framework_chain_predictions: { body: '- SWOT FEEDS_INTO Porter Five Forces', tokens_estimate: 8 },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.notEqual(d.decision_trace.icm_scope, null);
+    assert.notEqual(d.decision_trace.sql_signals, null);
+    assert.notEqual(d.decision_trace.minto_reasoning, null);
+    assert.notEqual(d.decision_trace.intent_persona, null);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'mode_a');
+    assert.notEqual(d.fire_skill, null);
+  });
+
+  run('Test 21: wicked_indicators (score 9) -> soft-systems route', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          sections: Object.assign({}, makeBrain().sections, {
+            wicked_indicators: { body: '- wicked_score: 9 stakeholders divergent', tokens_estimate: 8 },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(/soft.?systems/i.test(d.fire_skill || ''), true,
+      'expected soft-systems route, got ' + d.fire_skill);
+    assert.equal(/wicked_escalation/i.test(d.decision_trace.chosen_rationale || ''), true);
+  });
+
+  run('Test 22: brain-offline exemption -> weight 0.9, mode_b, RECOMMENDED off', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      brainAvailable: false,
+      quadruple: makeQuadruple({
+        brain: makeBrain({
+          staleness: 'stale',
+          stale_reason: 'brain_offline',
+          sections: Object.assign({}, makeBrain().sections, {
+            pattern_matches: { body: '- Run Methodology (confidence: 0.9)', tokens_estimate: 8 },
+          }),
+        }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.9);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'mode_b');
+    assert.equal(d.decision_trace.brain_md_recommended_marker_rendered, false);
+  });
+
+  run('Test 23: parse_failed -> tier_0, weight 0.0', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({ brain: makeBrain({ parse_failed: true }) }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'tier_0');
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.0);
+    assert.equal(/brain_parse_failed/i.test(d.decision_trace.chosen_rationale || ''), true);
+  });
+
+  run('Test 24: governing_thought_changed -> weight 0.3', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({ staleness: 'stale', stale_reason: 'governing_thought_changed' }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.3);
+    assert.equal(d.decision_trace.brain_md_tier_mode, 'mode_a');
+  });
+
+  run('Test 25: derivation_timeout -> weight 0.2', () => {
+    const { decide } = requireEngine();
+    const ctx = makeContext({
+      quadruple: makeQuadruple({
+        brain: makeBrain({ staleness: 'stale', stale_reason: 'derivation_timeout' }),
+      }),
+    });
+    const d = decide(makeTurn(), ctx);
+    assert.equal(d.decision_trace.brain_md_weight_applied, 0.2);
+  });
+
+  run('Test 26: no cross-turn caching: tier mode re-resolves per turn', () => {
+    const { decide } = requireEngine();
+    const turn = makeTurn();
+    const ctx1 = makeContext({ brainAvailable: true });
+    const d1 = decide(turn, ctx1);
+    assert.equal(d1.decision_trace.brain_md_tier_mode, 'mode_a');
+    const ctx2 = makeContext({
+      brainAvailable: false,
+      quadruple: makeQuadruple({
+        brain: makeBrain({ staleness: 'stale', stale_reason: 'brain_offline' }),
+      }),
+    });
+    const d2 = decide(turn, ctx2);
+    assert.equal(d2.decision_trace.brain_md_tier_mode, 'mode_b');
+  });
+
+  run('Test 27: per-turn cache bound (no cross-turn leakage of quadruple)', () => {
+    // The cache check is structural: decide() must not retain quadruple
+    // across calls. We test by mutating quadruple between calls and
+    // verifying the second call sees the new shape, not a cached one.
+    const { decide } = requireEngine();
+    const turn = makeTurn();
+    const q1 = makeQuadruple();
+    const d1 = decide(turn, makeContext({ quadruple: q1 }));
+    assert.equal(d1.decision_trace.brain_md_tier_mode, 'mode_a');
+    const q2 = makeQuadruple({ brain: null });
+    const d2 = decide(turn, makeContext({ quadruple: q2 }));
+    assert.equal(d2.decision_trace.brain_md_tier_mode, 'tier_0');
+  });
+
+  run('Test 28: FORBIDDEN direct fs reads on BRAIN.md (grep)', () => {
+    const src = fs.readFileSync(ENGINE_PATH, 'utf8');
+    // Forbidden: any fs.readFileSync or fs.readFile referencing BRAIN.md
+    const re = /fs\s*\.\s*(readFileSync|readFile|promises\.readFile)\s*\([^)]*BRAIN\.md/;
+    assert.equal(re.test(src), false,
+      'navigation-engine.cjs MUST NOT read BRAIN.md directly; route through readQuadruple');
+  });
+
+  run('Test 29: FORBIDDEN Brain network calls (grep)', () => {
+    const src = fs.readFileSync(ENGINE_PATH, 'utf8');
+    // Forbidden: brain-client.query / search / smartSearch and any direct
+    // network egress to brain.mindrian.ai or fetch/curl for Brain.
+    const reBad = /brain[-_]?client\s*\.\s*(query|search|smartSearch)\b|brain\.mindrian\.ai|\bfetch\s*\(|\bcurl\b/;
+    // Allow brain-client.isAvailable and brain-client.schema (Section 9.3).
+    // Strip those allowed calls before scanning.
+    const filtered = src
+      .replace(/brain[-_]?client\s*\.\s*isAvailable\s*\([^)]*\)/g, '')
+      .replace(/brain[-_]?client\s*\.\s*schema\s*\([^)]*\)/g, '');
+    assert.equal(reBad.test(filtered), false,
+      'navigation-engine.cjs MUST NOT call Brain network APIs from decision logic');
+  });
+
+  run('Test 30: performance budget on 5-section fixture', () => {
+    const { decide } = requireEngine();
+    // Build five distinct contexts (simulating five-section turn budget).
+    const sections = ['intro', 'market', 'tech', 'ops', 'finance'];
+    const contexts = sections.map((slug) =>
+      makeContext({
+        quadruple: makeQuadruple({
+          brain: makeBrain({
+            section: slug,
+            sections: Object.assign({}, makeBrain().sections, {
+              pattern_matches: { body: '- Run Methodology (confidence: 0.8)', tokens_estimate: 8 },
+              framework_chain_predictions: { body: '- A FEEDS_INTO B', tokens_estimate: 6 },
+            }),
+          }),
+        }),
+      })
+    );
+    const cold = process.hrtime.bigint();
+    for (const c of contexts) decide(makeTurn(), c);
+    const coldDur = Number(process.hrtime.bigint() - cold) / 1e6;
+    assert.equal(coldDur < 800, true, 'cold 5-section decide() exceeded 800ms: ' + coldDur + 'ms');
+    const warm = process.hrtime.bigint();
+    for (const c of contexts) decide(makeTurn(), c);
+    const warmDur = Number(process.hrtime.bigint() - warm) / 1e6;
+    assert.equal(warmDur < 300, true, 'warm 5-section decide() exceeded 300ms: ' + warmDur + 'ms');
+  });
+
+  run('Test 31: suppress_skills array shape', () => {
+    const { decide } = requireEngine();
+    const d = decide(makeTurn(), makeContext());
+    assert.equal(Array.isArray(d.suppress_skills), true);
+  });
+
+  run('Test 32: persona_updates struct shape (null when no update signal)', () => {
+    const { decide } = requireEngine();
+    const d = decide(makeTurn(), makeContext());
+    // null when no threshold crossed; struct when present.
+    if (d.persona_updates !== null) {
+      assert.equal(typeof d.persona_updates, 'object');
+      // Allowed keys per Phase 91 CONTEXT decide() signature.
+      const allowed = new Set(['archetype', 'problem_type', 'venture_stage']);
+      for (const k of Object.keys(d.persona_updates)) {
+        assert.equal(allowed.has(k), true, 'persona_updates has unexpected key: ' + k);
+      }
+    }
+  });
+
+  run('Test 33: offer_next_step noise gate (max 1 per turn)', () => {
+    const { decide } = requireEngine();
+    const d = decide(makeTurn(), makeContext());
+    // Either null OR a single object with command + reason.
+    if (d.offer_next_step !== null) {
+      assert.equal(typeof d.offer_next_step, 'object');
+      assert.equal('command' in d.offer_next_step, true);
+      assert.equal('reason' in d.offer_next_step, true);
+    }
+  });
+} else {
+  // Engine module absent (Task 1 RED phase). Skip Task 2 tests with a
+  // single notice; do NOT count as failure (matches RED contract).
+  process.stdout.write('skip Task 2 tests: ' + path.relative(REPO, ENGINE_PATH) + ' not yet implemented\n');
+}
+
+// ---------- Final summary ----------
+
+const total = passed + failed;
+process.stdout.write(
+  '\nnavigation-engine-core: ' + passed + '/' + total + ' passed, ' + failed + ' failed\n'
+);
+process.exit(failed === 0 ? 0 : 1);