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

package/lib/memory/security-trifecta.test.cjs

@@ -1,312 +0,0 @@
-'use strict';
-
-/**
- * Security Trifecta Tests (Phase 87-01)
- * ======================================
- *
- * BSL 1.1. Copyright (c) Mindrian 2026.
- *
- * Proves SEC-01 + SEC-02 + SEC-03 defences in brain-client.cjs and
- * intelligence-cascade.cjs. Runs inside the feynman harness.
- *
- * SEC-01: sanitizeCypherInput() strips every non-whitelist character before
- *         a user-origin string reaches a Cypher interpolation site.
- * SEC-02: checkFilePermissions() refuses .env files with any group/world bit
- *         set (mode & 0o077 != 0). Must allow 0600, reject 0644.
- * SEC-03: intelligence-cascade.cjs uses HSI_TIMEOUT_MS = 30000 at every
- *         HSI-path spawn site in the shared `_runCascadeSteps` helper
- *         (classify, check-deps, compute-hsi, detect-reverse-salients,
- *         hsi-to-graph, compute-state). After Phase 87-03 cascade deduplication
- *         this is 6 unique sites inside the single helper (down from 12
- *         duplicated sites across runCascade + queueCascade pre-refactor).
- *         The invariant that matters is structural: zero `timeout: 5000`
- *         sites remain; every HSI-path spawn reads HSI_TIMEOUT_MS; the
- *         1 intentional `timeout: 15000` site (presentation) stays intact.
- *
- * Exit 0 on pass, 1 on any failure.
- * Run: node lib/memory/security-trifecta.test.cjs
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const brainClient = require('../core/brain-client.cjs');
-const { sanitizeCypherInput, checkFilePermissions } = brainClient._test || {};
-
-let passed = 0;
-let failed = 0;
-
-function test(name, fn) {
-  try {
-    fn();
-    process.stdout.write('  ok  ' + name + '\n');
-    passed++;
-  } catch (err) {
-    process.stdout.write('  FAIL  ' + name + '\n');
-    process.stdout.write('        ' + (err.message || err) + '\n');
-    failed++;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// SEC-01: sanitizeCypherInput
-// ---------------------------------------------------------------------------
-
-test('sanitizeCypherInput exported via module.exports._test', () => {
-  assert.equal(typeof sanitizeCypherInput, 'function');
-});
-
-test('sanitizeCypherInput passes clean alphanumerics through', () => {
-  assert.equal(sanitizeCypherInput('hello'), 'hello');
-  assert.equal(sanitizeCypherInput('Framework 42'), 'Framework 42');
-});
-
-test('sanitizeCypherInput strips Cypher injection payload', () => {
-  // Classic injection attempt: quotes, semicolons, comment, backtick,
-  // newline, curly braces, dollar sign, backslash. Spaces are in the
-  // whitelist (CONTEXT.md: [a-zA-Z0-9 ._-]) so they survive; the danger
-  // characters are the ones that must go.
-  const payload = 'DROP TABLE; --"`\n${var}';
-  const result = sanitizeCypherInput(payload);
-  assert.equal(result, 'DROP TABLE --var');
-  assert.ok(!result.includes(';'), 'semicolon must be stripped');
-  assert.ok(!result.includes('"'), 'double quote must be stripped');
-  assert.ok(!result.includes('`'), 'backtick must be stripped');
-  assert.ok(!result.includes('\n'), 'newline must be stripped');
-  assert.ok(!result.includes('$'), 'dollar sign must be stripped');
-  assert.ok(!result.includes('{'), 'open brace must be stripped');
-});
-
-test('sanitizeCypherInput strips every forbidden metachar', () => {
-  const hostile = 'a"b\'c`d{e}f$g\\h';
-  const out = sanitizeCypherInput(hostile);
-  assert.ok(!out.includes('"'), 'double quote survived');
-  assert.ok(!out.includes("'"), 'single quote survived');
-  assert.ok(!out.includes('`'), 'backtick survived');
-  assert.ok(!out.includes('{'), 'open brace survived');
-  assert.ok(!out.includes('}'), 'close brace survived');
-  assert.ok(!out.includes('$'), 'dollar sign survived');
-  assert.ok(!out.includes('\\'), 'backslash survived');
-});
-
-test('sanitizeCypherInput preserves whitelist: letters, digits, space, dot, underscore, dash', () => {
-  const ok = 'Name-with_underscore.and-dash 42';
-  assert.equal(sanitizeCypherInput(ok), ok);
-});
-
-test('sanitizeCypherInput handles null/undefined/non-string without crashing', () => {
-  assert.equal(sanitizeCypherInput(null), '');
-  assert.equal(sanitizeCypherInput(undefined), '');
-  assert.equal(sanitizeCypherInput(42), '42');
-  assert.equal(sanitizeCypherInput(false), 'false');
-});
-
-test('sanitizeCypherInput newline stripped (no Cypher comment injection)', () => {
-  const out = sanitizeCypherInput('abc\n// injected\ndef');
-  assert.ok(!out.includes('\n'));
-  assert.ok(!out.includes('/'));
-});
-
-// ---------------------------------------------------------------------------
-// SEC-02: checkFilePermissions
-// ---------------------------------------------------------------------------
-
-test('checkFilePermissions exported via module.exports._test', () => {
-  assert.equal(typeof checkFilePermissions, 'function');
-});
-
-// Linux/macOS-only semantics. On Windows the helper returns true (documented).
-const isWin = process.platform === 'win32';
-
-test('checkFilePermissions accepts 0600', () => {
-  if (isWin) {
-    process.stdout.write('        (skipped on win32)\n');
-    return;
-  }
-  const tmpFile = path.join(os.tmpdir(), `sec-trifecta-0600-${Date.now()}.env`);
-  fs.writeFileSync(tmpFile, 'MINDRIAN_BRAIN_KEY=test\n');
-  fs.chmodSync(tmpFile, 0o600);
-  try {
-    assert.equal(checkFilePermissions(tmpFile), true);
-  } finally {
-    try { fs.unlinkSync(tmpFile); } catch (_e) {}
-  }
-});
-
-test('checkFilePermissions rejects 0644 (group-readable)', () => {
-  if (isWin) {
-    process.stdout.write('        (skipped on win32)\n');
-    return;
-  }
-  const tmpFile = path.join(os.tmpdir(), `sec-trifecta-0644-${Date.now()}.env`);
-  fs.writeFileSync(tmpFile, 'MINDRIAN_BRAIN_KEY=test\n');
-  fs.chmodSync(tmpFile, 0o644);
-  try {
-    assert.equal(checkFilePermissions(tmpFile), false);
-  } finally {
-    try { fs.unlinkSync(tmpFile); } catch (_e) {}
-  }
-});
-
-test('checkFilePermissions rejects 0664 (group-writable too)', () => {
-  if (isWin) {
-    process.stdout.write('        (skipped on win32)\n');
-    return;
-  }
-  const tmpFile = path.join(os.tmpdir(), `sec-trifecta-0664-${Date.now()}.env`);
-  fs.writeFileSync(tmpFile, 'MINDRIAN_BRAIN_KEY=test\n');
-  fs.chmodSync(tmpFile, 0o664);
-  try {
-    assert.equal(checkFilePermissions(tmpFile), false);
-  } finally {
-    try { fs.unlinkSync(tmpFile); } catch (_e) {}
-  }
-});
-
-test('checkFilePermissions accepts 0400 (read-only owner)', () => {
-  if (isWin) {
-    process.stdout.write('        (skipped on win32)\n');
-    return;
-  }
-  const tmpFile = path.join(os.tmpdir(), `sec-trifecta-0400-${Date.now()}.env`);
-  fs.writeFileSync(tmpFile, 'MINDRIAN_BRAIN_KEY=test\n');
-  fs.chmodSync(tmpFile, 0o400);
-  try {
-    assert.equal(checkFilePermissions(tmpFile), true);
-  } finally {
-    try {
-      fs.chmodSync(tmpFile, 0o600);
-      fs.unlinkSync(tmpFile);
-    } catch (_e) {}
-  }
-});
-
-test('checkFilePermissions returns false for nonexistent file', () => {
-  const missing = path.join(os.tmpdir(), `sec-trifecta-missing-${Date.now()}.env`);
-  assert.equal(checkFilePermissions(missing), false);
-});
-
-// ---------------------------------------------------------------------------
-// SEC-03: HSI_TIMEOUT_MS is 30000 at every HSI-path cascade spawn site.
-// Phase 87-03 cascade deduplication: the 12 duplicated sites collapsed to 6
-// unique sites inside the shared _runCascadeSteps helper. The semantic
-// invariant is preserved: zero timeout:5000 sites remain, every HSI-path
-// spawn reads HSI_TIMEOUT_MS, the 1 intentional 15000ms site is intact.
-// ---------------------------------------------------------------------------
-
-test('intelligence-cascade.cjs defines HSI_TIMEOUT_MS = 30000', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  assert.match(
-    src,
-    /const\s+HSI_TIMEOUT_MS\s*=\s*30000/,
-    'HSI_TIMEOUT_MS = 30000 constant not found'
-  );
-});
-
-test('intelligence-cascade.cjs uses HSI_TIMEOUT_MS at exactly 6 unique spawn sites (post 87-03 dedup)', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  const matches = src.match(/timeout:\s*HSI_TIMEOUT_MS/g) || [];
-  assert.equal(
-    matches.length,
-    6,
-    `expected 6 timeout: HSI_TIMEOUT_MS sites after cascade dedup, got ${matches.length}`
-  );
-});
-
-test('intelligence-cascade.cjs has zero remaining timeout: 5000 sites', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  const matches = src.match(/timeout:\s*5000/g) || [];
-  assert.equal(
-    matches.length,
-    0,
-    `expected 0 remaining timeout: 5000 sites, got ${matches.length}`
-  );
-});
-
-test('intelligence-cascade.cjs preserves 1 intentional timeout: 15000 site (post 87-03 dedup)', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  const matches = src.match(/timeout:\s*15000/g) || [];
-  assert.equal(
-    matches.length,
-    1,
-    `expected 1 preserved timeout: 15000 site after cascade dedup, got ${matches.length}`
-  );
-});
-
-// Phase 87-03 structural invariants: the shared helper exists and is called
-// by both public entry points.
-test('intelligence-cascade.cjs defines _runCascadeSteps shared helper (87-03)', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  const defMatches = src.match(/async function _runCascadeSteps/g) || [];
-  assert.equal(
-    defMatches.length,
-    1,
-    `expected 1 _runCascadeSteps definition, got ${defMatches.length}`
-  );
-});
-
-test('intelligence-cascade.cjs: runCascade + queueCascade both call _runCascadeSteps (87-03)', () => {
-  const cascadePath = path.resolve(__dirname, '..', 'core', 'intelligence-cascade.cjs');
-  const src = fs.readFileSync(cascadePath, 'utf8');
-  // 1 definition + 2 call sites = at least 3 occurrences of "_runCascadeSteps("
-  const matches = src.match(/_runCascadeSteps\(/g) || [];
-  assert.ok(
-    matches.length >= 3,
-    `expected >= 3 _runCascadeSteps occurrences (1 def + 2 callers), got ${matches.length}`
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Integration cross-check: brain-client.cjs uses sanitizeCypherInput at 8 sites
-// and zero legacy .replace(/"/g, '\\"') patterns remain.
-// ---------------------------------------------------------------------------
-
-test('brain-client.cjs calls sanitizeCypherInput at 8 sites (plus definition)', () => {
-  const brainPath = path.resolve(__dirname, '..', 'core', 'brain-client.cjs');
-  const src = fs.readFileSync(brainPath, 'utf8');
-  const matches = src.match(/sanitizeCypherInput\s*\(/g) || [];
-  // 1 definition + 8 call sites = 9 (+1 _test export ref = 10).
-  assert.ok(
-    matches.length >= 9,
-    `expected >= 9 sanitizeCypherInput occurrences, got ${matches.length}`
-  );
-});
-
-test('brain-client.cjs has zero legacy .replace(/"/g, ...) injection patterns', () => {
-  const brainPath = path.resolve(__dirname, '..', 'core', 'brain-client.cjs');
-  const src = fs.readFileSync(brainPath, 'utf8');
-  const matches = src.match(/\.replace\(\/"\/g/g) || [];
-  assert.equal(
-    matches.length,
-    0,
-    `expected 0 legacy double-quote escape patterns, got ${matches.length}`
-  );
-});
-
-test('brain-client.cjs guards .env reads with checkFilePermissions', () => {
-  const brainPath = path.resolve(__dirname, '..', 'core', 'brain-client.cjs');
-  const src = fs.readFileSync(brainPath, 'utf8');
-  const matches = src.match(/checkFilePermissions\s*\(/g) || [];
-  // 1 definition + 2 getApiKey call sites (cwd .env + ~/.mindrian.env) = 3.
-  assert.ok(
-    matches.length >= 3,
-    `expected >= 3 checkFilePermissions occurrences, got ${matches.length}`
-  );
-});
-
-// ---------------------------------------------------------------------------
-
-process.stdout.write('\n');
-process.stdout.write(`${passed} passed, ${failed} failed\n`);
-if (failed > 0) {
-  process.stdout.write('FAIL\n');
-  process.exit(1);
-}
-process.stdout.write('PASS\n');

package/lib/memory/session-start-brain-staleness.test.cjs

@@ -1,363 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 90-03 Task 2 -- session-start BRAIN staleness injection tests
- * ====================================================================
- * Integration tests that spawn real bash scripts/session-start with
- * BRAIN.md fixtures, verifying that:
- *   - Brain annotations surface in TRIPLE_CONTEXT per section
- *   - Stale sections enqueue for regen (brain-derivation-queue.json)
- *   - Brain-offline suppresses enqueue (hold for when back online)
- *   - BRAIN_STALENESS_SKIP=1 restores pre-90-03 byte-identical output
- *
- * Harness: mirrors lib/memory/session-start-triple-injection.test.cjs.
- * We seed a MindrianRooms fixture via MINDRIAN_ROOMS_HOME env + basename
- * match, spawn bash session-start, and parse additionalContext.
- *
- * Brain-client availability is controlled via MINDRIAN_BRAIN_KEY env:
- *   - unset -> brain-client.isAvailable() === false (offline)
- *   - set to any non-empty string -> isAvailable() === true
- * (See lib/core/brain-client.cjs lines 121-155 for the contract.)
- *
- * Pure Node built-ins. Three-surface: same hook fires on CLI, Desktop
- * MCP lifecycle emits equivalent.
- */
-
-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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const SESSION_START = path.join(REPO_ROOT, 'scripts', 'session-start');
-
-// ---------- Tmp workspace helpers ----------
-
-const TMPDIRS = [];
-function mkTmp(prefix) {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  TMPDIRS.push(d);
-  return d;
-}
-process.on('exit', function () {
-  for (const d of TMPDIRS) {
-    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
-  }
-});
-
-function sha256Hex(s) {
-  return 'sha256:' + crypto.createHash('sha256')
-    .update(String(s == null ? '' : s).normalize('NFC'))
-    .digest('hex');
-}
-
-/**
- * Seed a Strategy-0b compatible MindrianRooms fixture.
- */
-function seedRoom(tmp, sections) {
-  const roomsHome = path.join(tmp, 'rooms-home');
-  const roomBase = 'venture';
-  const roomDir = path.join(roomsHome, roomBase);
-  fs.mkdirSync(roomDir, { recursive: true });
-  fs.writeFileSync(path.join(roomDir, '.room-root'), '');
-  fs.mkdirSync(path.join(roomDir, '.mindrian'), { recursive: true });
-  const workDir = path.join(tmp, 'work', roomBase);
-  fs.mkdirSync(workDir, { recursive: true });
-  for (const s of sections) {
-    const dir = path.join(roomDir, s);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(
-      path.join(dir, 'ROOM.md'),
-      '# ' + s + '\n\nIdentity text for ' + s + '.\n'
-    );
-  }
-  return { roomDir, roomsHome, workDir };
-}
-
-function writeMinto(sectionDir, governingThought) {
-  const now = new Date().toISOString();
-  const body = [
-    '---',
-    'schema_version: 88',
-    'governing_thought: "' + governingThought + '"',
-    'last_generated_at: "' + now + '"',
-    'last_artifact_write_seen_at: "' + now + '"',
-    'reasoning_health_score: 0.75',
-    'flagged_weaknesses: []',
-    'decision_log: []',
-    '---',
-    '',
-    '# Governing Thought',
-    '',
-    governingThought,
-    '',
-    '# Claim 1',
-    '',
-    'Supporting claim.',
-    '',
-  ].join('\n');
-  fs.writeFileSync(path.join(sectionDir, 'MINTO.md'), body);
-}
-
-function writeBrainMd(sectionDir, opts) {
-  opts = opts || {};
-  const gt = opts.governing_thought == null ? 'default governing thought' : opts.governing_thought;
-  const gtHash = opts.governing_thought_hash != null ? opts.governing_thought_hash : sha256Hex(gt);
-  const now = opts.brain_generated_at != null ? opts.brain_generated_at : new Date().toISOString();
-  const bgv = opts.brain_graph_version != null ? opts.brain_graph_version : 1;
-  const staleness = opts.staleness || 'fresh';
-  const section = opts.section || path.basename(sectionDir);
-  const body = [
-    '---',
-    'section: ' + section,
-    'brain_generated_at: "' + now + '"',
-    'brain_graph_version: ' + bgv,
-    'governing_thought_hash: "' + gtHash + '"',
-    'staleness: ' + staleness,
-    'author: brain',
-    '---',
-    '',
-    '## Pattern Matches',
-    '',
-    '(no signal)',
-    '',
-  ].join('\n');
-  fs.writeFileSync(path.join(sectionDir, 'BRAIN.md'), body);
-}
-
-function invokeSessionStart(fx, extraEnv) {
-  // Override HOME to a harmless path so brain-client.getApiKey() does NOT
-  // find a real ~/.mindrian.env file and leak availability into the test.
-  // (getApiKey falls back to <HOME>/.mindrian.env; pointing HOME at a tmp
-  // dir guarantees that fallback is empty.)
-  const safeHome = path.join(fx.workDir, '_home');
-  try { fs.mkdirSync(safeHome, { recursive: true }); } catch (_e) {}
-  const env = Object.assign({}, process.env, {
-    PWD: fx.workDir,
-    HOME: safeHome,
-    MINDRIAN_ROOMS_HOME: fx.roomsHome,
-    MINDRIAN_ROOMS_ROOT: fx.roomsHome,
-    CLAUDE_PLUGIN_ROOT: REPO_ROOT,
-    SESSION_START_NODE_PREFLIGHT_SKIP: '1',
-  }, extraEnv || {});
-  // Explicit handling: if caller set empty string, remove from env so
-  // process.env.MINDRIAN_BRAIN_KEY is undefined (not "") in the spawned
-  // node subprocess. Node treats empty-string env vars as defined.
-  if (env.MINDRIAN_BRAIN_KEY === '') delete env.MINDRIAN_BRAIN_KEY;
-  return spawnSync('bash', [SESSION_START], {
-    cwd: fx.workDir,
-    env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: 15000,
-  });
-}
-
-function extractAdditionalContext(stdout) {
-  const raw = String(stdout || '');
-  let m = /"additionalContext":\s*"([\s\S]*?)(?<!\\)"/m.exec(raw);
-  if (m) return m[1];
-  m = /"additional_context":\s*"([\s\S]*?)(?<!\\)"/m.exec(raw);
-  if (m) return m[1];
-  return '';
-}
-
-// ---------- Test runner ----------
-
-const tests = [];
-function test(name, fn) { tests.push({ name, fn }); }
-
-// ---------------------------------------------------------------------------
-// Test 1: Mixed fixture -- 1 fresh, 1 stale (hash mismatch), 1 absent.
-//   With Brain online, session-start produces TRIPLE_CONTEXT containing
-//   Brain annotation lines for fresh + stale (absent suppressed when no
-//   BRAIN.md exists for that section; or explicit "absent" line).
-// ---------------------------------------------------------------------------
-test('Test 1: 3-section mix (fresh / stale / absent) -> Brain annotations in TRIPLE_CONTEXT', () => {
-  const tmp = mkTmp('ss-90-03-t1-');
-  const fx = seedRoom(tmp, ['market-analysis', 'problem-definition', 'business-model']);
-
-  // market-analysis: fresh MINTO + fresh BRAIN (hash match, recent)
-  writeMinto(path.join(fx.roomDir, 'market-analysis'), 'TAM analysis stable');
-  writeBrainMd(path.join(fx.roomDir, 'market-analysis'), {
-    governing_thought: 'TAM analysis stable',
-    brain_graph_version: 1,
-    brain_generated_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
-  });
-
-  // problem-definition: stale BRAIN (hash mismatch -- MINTO changed)
-  writeMinto(path.join(fx.roomDir, 'problem-definition'), 'NEW problem framing');
-  writeBrainMd(path.join(fx.roomDir, 'problem-definition'), {
-    governing_thought: 'OLD problem framing',
-    brain_graph_version: 1,
-    brain_generated_at: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
-  });
-
-  // business-model: MINTO exists, no BRAIN.md
-  writeMinto(path.join(fx.roomDir, 'business-model'), 'subscription model');
-
-  // Simulate Brain online (any non-empty API key).
-  const res = invokeSessionStart(fx, { MINDRIAN_BRAIN_KEY: 'test-key-online' });
-  assert.equal(res.status, 0, 'session-start exits 0: ' + (res.stderr || ''));
-
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(ctx.length > 0, 'additional_context non-empty');
-  assert.ok(ctx.indexOf('ACTIVE ROOM MEMORY') !== -1, 'TRIPLE_CONTEXT header present');
-  // Fresh annotation
-  assert.ok(
-    /Brain derivation: fresh/.test(ctx),
-    'at least one "Brain derivation: fresh" line expected'
-  );
-  // Stale annotation with governing_thought changed reason
-  assert.ok(
-    /Brain derivation: stale.*governing_thought/.test(ctx),
-    'stale (governing_thought changed) annotation present'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: Brain offline -- stale sections marked, NO enqueue fires.
-// ---------------------------------------------------------------------------
-test('Test 2: Brain offline -> stale annotations present, queue NOT populated', () => {
-  const tmp = mkTmp('ss-90-03-t2-');
-  const fx = seedRoom(tmp, ['market-analysis']);
-
-  writeMinto(path.join(fx.roomDir, 'market-analysis'), 'NEW thought');
-  writeBrainMd(path.join(fx.roomDir, 'market-analysis'), {
-    governing_thought: 'OLD thought',
-    brain_graph_version: 1,
-    brain_generated_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
-  });
-
-  // Brain offline: remove any API key env.
-  const res = invokeSessionStart(fx, { MINDRIAN_BRAIN_KEY: '' });
-  assert.equal(res.status, 0, 'session-start exits 0: ' + (res.stderr || ''));
-  const ctx = extractAdditionalContext(String(res.stdout));
-
-  // Stale annotation should surface even when offline.
-  assert.ok(
-    /Brain derivation: stale/.test(ctx),
-    'stale annotation present even offline'
-  );
-
-  // Queue file should either not exist OR have zero entries (Brain offline
-  // -> recommended_action=enqueue_when_brain_online -> enqueue skipped).
-  const queuePath = path.join(fx.roomDir, '.mindrian', 'brain-derivation-queue.json');
-  if (fs.existsSync(queuePath)) {
-    const q = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-    assert.equal(q.entries.length, 0,
-      'Brain offline -> queue must stay empty (got ' + q.entries.length + ' entries)');
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: Brain online + stale -> enqueue fires; wall-clock < 5000ms.
-// ---------------------------------------------------------------------------
-test('Test 3: Brain online + stale -> enqueue lands, session-start < 5000ms', () => {
-  const tmp = mkTmp('ss-90-03-t3-');
-  const fx = seedRoom(tmp, ['market-analysis']);
-
-  writeMinto(path.join(fx.roomDir, 'market-analysis'), 'NEW thought');
-  writeBrainMd(path.join(fx.roomDir, 'market-analysis'), {
-    governing_thought: 'OLD thought',
-    brain_graph_version: 1,
-    brain_generated_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
-  });
-
-  // Warm up node cold start (WSL2 fs).
-  invokeSessionStart(fx, { MINDRIAN_BRAIN_KEY: 'warmup' });
-
-  // Clear any enqueue from warmup.
-  const queuePath = path.join(fx.roomDir, '.mindrian', 'brain-derivation-queue.json');
-  if (fs.existsSync(queuePath)) {
-    fs.writeFileSync(queuePath, JSON.stringify({ version: 1, entries: [] }));
-  }
-
-  const t0 = Date.now();
-  const res = invokeSessionStart(fx, { MINDRIAN_BRAIN_KEY: 'test-key-online' });
-  const elapsed = Date.now() - t0;
-  assert.equal(res.status, 0, 'exit 0');
-  assert.ok(elapsed < 5000, 'session-start wall-clock ' + elapsed + 'ms (ceiling 5000)');
-
-  // Queue should have the stale section enqueued.
-  assert.ok(fs.existsSync(queuePath), 'queue file should exist after Brain-online run');
-  const q = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-  assert.ok(q.entries.length >= 1, 'queue should have at least one entry (got ' + q.entries.length + ')');
-  const sections = q.entries.map(function (e) { return e.section; });
-  assert.ok(sections.indexOf('market-analysis') !== -1, 'market-analysis section enqueued');
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: BRAIN_STALENESS_SKIP=1 feature flag -> Brain annotations suppressed.
-// ---------------------------------------------------------------------------
-test('Test 4: BRAIN_STALENESS_SKIP=1 -> no Brain lines in TRIPLE_CONTEXT', () => {
-  const tmp = mkTmp('ss-90-03-t4-');
-  const fx = seedRoom(tmp, ['market-analysis']);
-
-  writeMinto(path.join(fx.roomDir, 'market-analysis'), 'Active thought');
-  writeBrainMd(path.join(fx.roomDir, 'market-analysis'), {
-    governing_thought: 'Active thought',
-    brain_graph_version: 1,
-    brain_generated_at: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
-  });
-
-  const res = invokeSessionStart(fx, {
-    MINDRIAN_BRAIN_KEY: 'test-key-online',
-    BRAIN_STALENESS_SKIP: '1',
-  });
-  assert.equal(res.status, 0, 'exit 0');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(ctx.indexOf('ACTIVE ROOM MEMORY') !== -1, 'TRIPLE_CONTEXT still emitted');
-  assert.ok(
-    ctx.indexOf('Brain derivation:') === -1,
-    'Brain derivation lines SUPPRESSED when BRAIN_STALENESS_SKIP=1'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: Backward-compat -- room with NO BRAIN.md files anywhere does not
-// emit "Brain derivation: absent" lines (keeps output byte-stable for
-// rooms that have never run a derivation).
-// ---------------------------------------------------------------------------
-test('Test 5: No BRAIN.md anywhere -> no "Brain derivation" lines (backward-compat)', () => {
-  const tmp = mkTmp('ss-90-03-t5-');
-  const fx = seedRoom(tmp, ['market-analysis', 'problem-definition']);
-  writeMinto(path.join(fx.roomDir, 'market-analysis'), 'Thought 1');
-  writeMinto(path.join(fx.roomDir, 'problem-definition'), 'Thought 2');
-  // NO BRAIN.md files.
-
-  const res = invokeSessionStart(fx, { MINDRIAN_BRAIN_KEY: 'test-key-online' });
-  assert.equal(res.status, 0, 'exit 0');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(ctx.indexOf('ACTIVE ROOM MEMORY') !== -1, 'TRIPLE_CONTEXT emitted');
-  assert.ok(
-    ctx.indexOf('Brain derivation:') === -1,
-    'no Brain lines when room has zero BRAIN.md (backward-compat)'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Runner
-// ---------------------------------------------------------------------------
-
-let passed = 0;
-let failed = 0;
-
-for (const t of tests) {
-  try {
-    t.fn();
-    passed++;
-    process.stdout.write('  pass: ' + t.name + '\n');
-  } catch (err) {
-    failed++;
-    process.stderr.write('  FAIL: ' + t.name + '\n');
-    process.stderr.write('        ' + (err && err.stack ? err.stack : err) + '\n');
-  }
-}
-
-process.stdout.write('\nsession-start-brain-staleness: ' + passed + '/' + (passed + failed) + ' passed\n');
-if (failed > 0) process.exit(1);