@mindrian_os/install 1.13.0-beta.11

package/lib/memory/stamp-artifact-write.test.cjs

@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 88-04 Task 1 -- stamp-artifact-write tests
+ * =================================================
+ * Covers the 5 behavior cases:
+ *   1. MINTO.md exists -> stamp updates last_artifact_write_seen_at to current ISO;
+ *      all other frontmatter keys untouched.
+ *   2. MINTO.md absent -> stamp writes to .mindrian/pending-stamps/<section>.json
+ *      with {section, last_artifact_write_seen_at}.
+ *   3. Narrative body preserved byte-for-byte across stamp.
+ *   4. Concurrent stamp writes (2 forks) -> final MINTO has ONE timestamp, no corruption.
+ *   5. Malformed MINTO frontmatter -> stamp writes to pending-stamps instead, logs
+ *      warning to stderr; no throw; exit 0.
+ *
+ * Test harness mirrors the pattern in lib/memory/minto-debouncer.test.cjs +
+ * lib/memory/recompile-room-references.test.cjs: synchronous runner, mkTmp
+ * helper per test, cleanup via process.on('exit').
+ */
+
+'use strict';
+
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { fork, spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const STAMP_CLI = path.join(REPO_ROOT, 'scripts', 'stamp-artifact-write.cjs');
+
+// --- tmp dir management -----------------------------------------------------
+
+const createdTmpDirs = [];
+function mkTmp(prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  createdTmpDirs.push(d);
+  return d;
+}
+process.on('exit', () => {
+  for (const d of createdTmpDirs) {
+    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
+  }
+});
+
+// --- helpers ----------------------------------------------------------------
+
+function seedRoomAndSection(tmp, sectionName) {
+  // .room-root sentinel at tmp; section is a sibling folder.
+  fs.writeFileSync(path.join(tmp, '.room-root'), '');
+  fs.mkdirSync(path.join(tmp, '.mindrian'), { recursive: true });
+  const sectionDir = path.join(tmp, sectionName);
+  fs.mkdirSync(sectionDir, { recursive: true });
+  return sectionDir;
+}
+
+function writeMintoMd(sectionDir, frontmatterLines, bodyLines) {
+  const content =
+    ['---', ...frontmatterLines, '---', '', ...bodyLines, ''].join('\n');
+  fs.writeFileSync(path.join(sectionDir, 'MINTO.md'), content);
+  return content;
+}
+
+function runStampCli(sectionDir, extraEnv) {
+  return spawnSync(
+    process.execPath,
+    [STAMP_CLI, sectionDir],
+    {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: Object.assign({}, process.env, extraEnv || {}),
+    }
+  );
+}
+
+// --- test runner ------------------------------------------------------------
+
+const tests = [];
+function test(name, fn) { tests.push({ name, fn }); }
+
+// ---------- Test 1: happy path, updates only last_artifact_write_seen_at ----
+test('Test 1: MINTO.md present -> last_artifact_write_seen_at stamped', async () => {
+  const tmp = mkTmp('stamp-t1-');
+  const sec = seedRoomAndSection(tmp, 'market-analysis');
+  const fm = [
+    'schema_version: "1.0"',
+    'type: section-minto',
+    'section: market-analysis',
+    'governing_thought: "Market analysis anchors the venture thesis."',
+    'last_generated_at: "2026-01-01T00:00:00Z"',
+    'last_artifact_write_seen_at: null',
+    'reasoning_health_score: null',
+    'flagged_weaknesses: []',
+    'decision_log: []',
+  ];
+  const body = ['# Market Analysis -- Minto Reasoning', '', 'Body paragraph.'];
+  const before = writeMintoMd(sec, fm, body);
+
+  const r = runStampCli(sec);
+  assert.strictEqual(r.status, 0, 'stamp CLI must exit 0');
+
+  const after = fs.readFileSync(path.join(sec, 'MINTO.md'), 'utf8');
+  // last_artifact_write_seen_at now carries an ISO timestamp.
+  const mm = after.match(
+    /^last_artifact_write_seen_at:\s*"(20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)"\s*$/m
+  );
+  assert.ok(mm, 'last_artifact_write_seen_at must be ISO-stamped (got: ' + after + ')');
+
+  // All other keys unchanged.
+  assert.ok(/^schema_version: "1\.0"$/m.test(after), 'schema_version preserved');
+  assert.ok(/^type: section-minto$/m.test(after), 'type preserved');
+  assert.ok(/^section: market-analysis$/m.test(after), 'section preserved');
+  assert.ok(
+    /^governing_thought: "Market analysis anchors the venture thesis\."$/m.test(after),
+    'governing_thought preserved'
+  );
+  assert.ok(
+    /^last_generated_at: "2026-01-01T00:00:00Z"$/m.test(after),
+    'last_generated_at preserved'
+  );
+  assert.ok(/^reasoning_health_score: null$/m.test(after), 'reasoning_health_score preserved');
+  assert.ok(/^flagged_weaknesses: \[\]$/m.test(after), 'flagged_weaknesses preserved');
+  assert.ok(/^decision_log: \[\]$/m.test(after), 'decision_log preserved');
+
+  // Body preserved.
+  assert.ok(after.includes('# Market Analysis -- Minto Reasoning'), 'body H1 preserved');
+  assert.ok(after.includes('Body paragraph.'), 'body paragraph preserved');
+});
+
+// ---------- Test 2: MINTO absent -> pending-stamps fallback ----------------
+test('Test 2: MINTO.md absent -> pending-stamps fallback', async () => {
+  const tmp = mkTmp('stamp-t2-');
+  const sec = seedRoomAndSection(tmp, 'problem-definition');
+
+  const r = runStampCli(sec);
+  assert.strictEqual(r.status, 0, 'stamp CLI must exit 0 even when MINTO absent');
+
+  const pendingDir = path.join(tmp, '.mindrian', 'pending-stamps');
+  assert.ok(fs.existsSync(pendingDir), 'pending-stamps dir created');
+  const pendingFile = path.join(pendingDir, 'problem-definition.json');
+  assert.ok(fs.existsSync(pendingFile), 'pending stamp JSON written for section');
+
+  const payload = JSON.parse(fs.readFileSync(pendingFile, 'utf8'));
+  assert.strictEqual(payload.section, 'problem-definition');
+  assert.ok(
+    /^20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(payload.last_artifact_write_seen_at),
+    'pending stamp carries ISO timestamp'
+  );
+});
+
+// ---------- Test 3: narrative body preserved byte-for-byte -----------------
+test('Test 3: narrative body preserved byte-for-byte after stamp', async () => {
+  const tmp = mkTmp('stamp-t3-');
+  const sec = seedRoomAndSection(tmp, 'solution-design');
+  const fm = [
+    'schema_version: "1.0"',
+    'type: section-minto',
+    'section: solution-design',
+    'governing_thought: "Solution design is the synthesis of prior analysis."',
+    'last_generated_at: "2026-02-01T00:00:00Z"',
+    'last_artifact_write_seen_at: null',
+    'reasoning_health_score: 0.42',
+    'flagged_weaknesses: []',
+    'decision_log: []',
+  ];
+  // Body with multiple lines, wikilinks, special chars.
+  const body = [
+    '# Solution Design -- Minto Reasoning',
+    '',
+    '> [!abstract] Governing Thought',
+    '> Solution design is the synthesis of prior analysis.',
+    '',
+    '## Argument Structure',
+    '',
+    '### Claim 1: Architecture',
+    '',
+    'See [[../problem-definition/MINTO.md|Problem]]',
+    '',
+    '### Claim 2: Constraints',
+    '',
+    'Unicode safe: citations (Smith 2024) -> key-results.',
+    '',
+    '---',
+    '',
+  ];
+  writeMintoMd(sec, fm, body);
+  const before = fs.readFileSync(path.join(sec, 'MINTO.md'), 'utf8');
+
+  const r = runStampCli(sec);
+  assert.strictEqual(r.status, 0, 'stamp CLI must exit 0');
+
+  const after = fs.readFileSync(path.join(sec, 'MINTO.md'), 'utf8');
+
+  // Extract the body regions (everything after closing `---`) and diff them.
+  function bodyOf(content) {
+    const m = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+    return m ? m[1] : content;
+  }
+  const beforeBody = bodyOf(before);
+  const afterBody = bodyOf(after);
+  assert.strictEqual(
+    afterBody, beforeBody,
+    'body region must be byte-identical after stamp'
+  );
+});
+
+// ---------- Test 4: concurrent stamp writes serialize, no corruption -------
+test('Test 4: 2 concurrent stamp forks -> one ISO, no corruption', async () => {
+  const tmp = mkTmp('stamp-t4-');
+  const sec = seedRoomAndSection(tmp, 'business-model');
+  const fm = [
+    'schema_version: "1.0"',
+    'type: section-minto',
+    'section: business-model',
+    'governing_thought: "Business model drives monetization pathways."',
+    'last_generated_at: "2026-03-01T00:00:00Z"',
+    'last_artifact_write_seen_at: null',
+    'reasoning_health_score: null',
+    'flagged_weaknesses: []',
+    'decision_log: []',
+  ];
+  writeMintoMd(sec, fm, ['# Business Model -- Minto', '', 'Body.']);
+
+  // Fork two concurrent stamp CLIs.
+  const children = [
+    fork(STAMP_CLI, [sec], { silent: true }),
+    fork(STAMP_CLI, [sec], { silent: true }),
+  ];
+  const results = await Promise.all(children.map((c) => new Promise((resolve) => {
+    c.on('exit', (code) => resolve(code));
+  })));
+  // Both should exit 0 (soft-fail guarantee; worst case one bails on lock).
+  for (const code of results) {
+    assert.strictEqual(code, 0, 'every concurrent stamp exits 0');
+  }
+
+  // MINTO.md still well-formed: frontmatter parses, body intact.
+  const after = fs.readFileSync(path.join(sec, 'MINTO.md'), 'utf8');
+  assert.ok(
+    /^---\r?\n[\s\S]*?\r?\n---/.test(after),
+    'MINTO.md frontmatter structure preserved'
+  );
+  const matches = after.match(/^last_artifact_write_seen_at:\s*.*$/gm);
+  assert.ok(matches && matches.length === 1,
+    'exactly one last_artifact_write_seen_at line (no duplication)');
+  assert.ok(
+    /last_artifact_write_seen_at:\s*"20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z"/.test(after),
+    'final stamp has valid ISO timestamp'
+  );
+  assert.ok(after.includes('# Business Model -- Minto'), 'body preserved after race');
+});
+
+// ---------- Test 5: malformed frontmatter -> pending-stamps fallback ------
+test('Test 5: malformed MINTO frontmatter -> pending-stamps + stderr warn', async () => {
+  const tmp = mkTmp('stamp-t5-');
+  const sec = seedRoomAndSection(tmp, 'team');
+  // Write a file called MINTO.md but missing the closing --- delimiter.
+  fs.writeFileSync(
+    path.join(sec, 'MINTO.md'),
+    '---\nschema_version: "1.0"\ntype: section-minto\n# NO CLOSING DELIMITER\nbody text'
+  );
+
+  const r = runStampCli(sec);
+  assert.strictEqual(r.status, 0, 'stamp CLI must exit 0 even on malformed MINTO');
+
+  const pendingDir = path.join(tmp, '.mindrian', 'pending-stamps');
+  assert.ok(fs.existsSync(pendingDir), 'pending-stamps dir created as fallback');
+  const pendingFile = path.join(pendingDir, 'team.json');
+  assert.ok(fs.existsSync(pendingFile), 'pending stamp written as fallback');
+
+  // Stderr should carry a warning but must not throw.
+  const stderr = r.stderr ? r.stderr.toString() : '';
+  // Warning is expected but we stay permissive: at minimum, no uncaught exception.
+  assert.ok(
+    !/UnhandledPromiseRejection|Error:\s+ENOENT/i.test(stderr) ||
+      /pending-stamps|malformed|frontmatter/i.test(stderr),
+    'stderr does not crash; malformed signal acceptable'
+  );
+});
+
+// --- CLI smoke: non-existent section path -> still exits 0 -----------------
+test('Test 6 (acceptance): non-existent section path -> exit 0 (soft-fail)', async () => {
+  const r = runStampCli('/does/not/exist/anywhere/section');
+  assert.strictEqual(r.status, 0, 'stamp on missing dir must still exit 0');
+});
+
+// --- runner ----------------------------------------------------------------
+
+(async () => {
+  let failed = 0;
+  for (const t of tests) {
+    try {
+      await t.fn();
+      process.stdout.write('PASS ' + t.name + '\n');
+    } catch (e) {
+      failed += 1;
+      process.stderr.write('FAIL ' + t.name + '\n' + (e && e.stack || e) + '\n');
+    }
+  }
+  process.stdout.write(
+    '\nstamp-artifact-write.test.cjs: ' +
+    (tests.length - failed) + '/' + tests.length + ' passed\n'
+  );
+  process.exit(failed === 0 ? 0 : 1);
+})();

package/lib/memory/statusline-active-room.test.cjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 94-01 -- statusline active room read contract acceptance tests.
+ * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
+ *
+ * Verifies the canonical read path for the statusline's active-room name:
+ *
+ *   STATE.md frontmatter current_room
+ *     -> lib/core/folder-memory.cjs getCurrentRoom()
+ *     -> scripts/context-monitor render
+ *
+ * Lawrence Aronhime reproducer: in his 2026-04-28 38-minute live test he
+ * said "look at the bottom. It still says core power" four times. Root
+ * cause was the statusline deriving the room name from a stale source
+ * (cwd or its own cache) instead of STATE.md. This test fixture proves
+ * the new canonical contract: switch rooms in fixture STATE.md, the very
+ * next getCurrentRoom() call returns the new slug. No caching across
+ * calls, no exceptions on every failure mode.
+ *
+ * Test map (8 cases, one-to-one with the PLAN <behavior> block):
+ *   1. getCurrentRoom() returns null when STATE.md missing in canonical path
+ *   2. getCurrentRoom() returns null when STATE.md exists but lacks frontmatter
+ *   3. getCurrentRoom() returns null when frontmatter exists but current_room absent
+ *   4. getCurrentRoom() returns {slug, path, source} on a happy frontmatter
+ *   5. getCurrentRoom() returns null when YAML frontmatter is malformed
+ *   6. Lawrence reproducer: switch room slug, next call reflects within one cycle
+ *   7. getCurrentRoom() ignores quotes and trailing whitespace around slug
+ *   8. End-to-end: spawn scripts/context-monitor with fixture STATE.md, stdout
+ *      contains the new slug
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const SYNC_PATH = path.join(REPO, 'lib/core/folder-memory.cjs');
+const CONTEXT_MONITOR = path.join(REPO, 'scripts/context-monitor');
+
+// ---------- Fixture helpers ----------
+
+const TMP_ROOTS = [];
+function mkTmp(prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  TMP_ROOTS.push(d);
+  return d;
+}
+process.on('exit', () => {
+  for (const d of TMP_ROOTS) {
+    try {
+      fs.rmSync(d, { recursive: true, force: true });
+    } catch (_e) { /* best effort */ }
+  }
+});
+
+function writeStateMdWithFrontmatter(dir, frontmatterLines, body) {
+  const lines = ['---'];
+  for (const fl of frontmatterLines) lines.push(fl);
+  lines.push('---');
+  lines.push('');
+  lines.push(body || '# Room State');
+  fs.writeFileSync(path.join(dir, 'STATE.md'), lines.join('\n'), 'utf8');
+}
+
+function writeRoomFixture(roomDir, currentRoomValue) {
+  fs.mkdirSync(roomDir, { recursive: true });
+  const frontmatter = [
+    'venture_stage: Pre-Opportunity',
+    'last_updated: 2026-04-28',
+  ];
+  if (currentRoomValue !== undefined) {
+    frontmatter.push('current_room: ' + currentRoomValue);
+  }
+  writeStateMdWithFrontmatter(roomDir, frontmatter, '# Room State');
+}
+
+function writeRegistry(workDir, activeSlug, roomDirAbs) {
+  const dotRooms = path.join(workDir, '.rooms');
+  fs.mkdirSync(dotRooms, { recursive: true });
+  const registry = {
+    active: activeSlug,
+    rooms: {},
+  };
+  registry.rooms[activeSlug] = {
+    name: activeSlug,
+    path: path.relative(workDir, roomDirAbs) || '.',
+  };
+  fs.writeFileSync(
+    path.join(dotRooms, 'registry.json'),
+    JSON.stringify(registry, null, 2),
+    'utf8'
+  );
+}
+
+// ---------- Module pre-condition ----------
+
+function t0_moduleFileExists() {
+  assert.ok(fs.existsSync(SYNC_PATH), 'lib/core/folder-memory.cjs missing');
+}
+
+// ---------- Test 1: missing STATE.md returns null ----------
+
+function test_1_missingStateMdReturnsNull(sync) {
+  const work = mkTmp('statusline-active-room-t1-');
+  // No STATE.md anywhere; no .rooms registry; no room/ legacy dir.
+  let r;
+  assert.doesNotThrow(() => {
+    r = sync.getCurrentRoom(work);
+  }, 't1: no throws when STATE.md absent');
+  assert.strictEqual(r, null, 't1: returns null on missing STATE.md');
+}
+
+// ---------- Test 2: STATE.md without frontmatter returns null ----------
+
+function test_2_stateMdWithoutFrontmatterReturnsNull(sync) {
+  const work = mkTmp('statusline-active-room-t2-');
+  const room = path.join(work, 'room');
+  fs.mkdirSync(room, { recursive: true });
+  // No leading --- delimiter; just plain markdown.
+  fs.writeFileSync(
+    path.join(room, 'STATE.md'),
+    '# Room State\n\nNo frontmatter here.\n',
+    'utf8'
+  );
+  const r = sync.getCurrentRoom(work);
+  assert.strictEqual(r, null, 't2: returns null when frontmatter absent');
+}
+
+// ---------- Test 3: frontmatter without current_room returns null ----------
+
+function test_3_frontmatterWithoutCurrentRoomReturnsNull(sync) {
+  const work = mkTmp('statusline-active-room-t3-');
+  const room = path.join(work, 'room');
+  fs.mkdirSync(room, { recursive: true });
+  writeStateMdWithFrontmatter(room, [
+    'venture_stage: Pre-Opportunity',
+    'last_updated: 2026-04-28',
+  ], '# Room State');
+  const r = sync.getCurrentRoom(work);
+  assert.strictEqual(r, null, 't3: returns null when current_room absent');
+}
+
+// ---------- Test 4: happy path ----------
+
+function test_4_happyFrontmatterReturnsTriple(sync) {
+  const work = mkTmp('statusline-active-room-t4-');
+  const room = path.join(work, 'room');
+  writeRoomFixture(room, 'core-power');
+
+  const r = sync.getCurrentRoom(work);
+  assert.ok(r !== null, 't4: returns non-null when current_room present');
+  assert.strictEqual(r.slug, 'core-power', 't4: slug parsed');
+  assert.strictEqual(r.source, 'state_md', 't4: source tag');
+  assert.ok(typeof r.path === 'string' && r.path.length > 0, 't4: path string');
+  assert.ok(path.isAbsolute(r.path), 't4: path is absolute');
+  assert.ok(r.path.endsWith('STATE.md'), 't4: path points at STATE.md');
+}
+
+// ---------- Test 5: malformed YAML returns null ----------
+
+function test_5_malformedYamlReturnsNull(sync) {
+  const work = mkTmp('statusline-active-room-t5-');
+  const room = path.join(work, 'room');
+  fs.mkdirSync(room, { recursive: true });
+  // Frontmatter open delimiter but never closes; malformed key syntax.
+  fs.writeFileSync(
+    path.join(room, 'STATE.md'),
+    '---\nthis is not valid yaml because : : : :\nmore garbage\n',
+    'utf8'
+  );
+  let r;
+  assert.doesNotThrow(() => {
+    r = sync.getCurrentRoom(work);
+  }, 't5: no throws on malformed YAML');
+  assert.strictEqual(r, null, 't5: returns null on malformed YAML');
+}
+
+// ---------- Test 6: Lawrence reproducer (no caching across calls) ----------
+
+function test_6_lawrenceReproducerNoCaching(sync) {
+  const work = mkTmp('statusline-active-room-t6-');
+  const room = path.join(work, 'room');
+
+  writeRoomFixture(room, 'core-power');
+  const first = sync.getCurrentRoom(work);
+  assert.ok(first !== null, 't6a: first read returns object');
+  assert.strictEqual(first.slug, 'core-power', 't6a: first slug = core-power');
+
+  // Lawrence's reproducer step: /mos:rooms switches to a new room.
+  // STATE.md is rewritten with the new current_room.
+  writeRoomFixture(room, 'curriculum-redesign-fall-2026');
+
+  const second = sync.getCurrentRoom(work);
+  assert.ok(second !== null, 't6b: second read returns object');
+  assert.strictEqual(
+    second.slug,
+    'curriculum-redesign-fall-2026',
+    't6b: second slug = curriculum-redesign-fall-2026 (no stale cache)'
+  );
+}
+
+// ---------- Test 7: quotes and whitespace stripped ----------
+
+function test_7_quotesAndWhitespaceStripped(sync) {
+  const variants = [
+    { raw: 'core-power', expected: 'core-power' },
+    { raw: '"core-power"', expected: 'core-power' },
+    { raw: "'core-power'", expected: 'core-power' },
+    { raw: '  core-power  ', expected: 'core-power' },
+    { raw: '"  core-power  "', expected: 'core-power' },
+  ];
+  for (const v of variants) {
+    const work = mkTmp('statusline-active-room-t7-');
+    const room = path.join(work, 'room');
+    writeRoomFixture(room, v.raw);
+    const r = sync.getCurrentRoom(work);
+    assert.ok(r !== null, 't7: non-null for variant ' + JSON.stringify(v.raw));
+    assert.strictEqual(
+      r.slug,
+      v.expected,
+      't7: variant ' + JSON.stringify(v.raw) + ' -> ' + v.expected
+    );
+  }
+}
+
+// ---------- Test 8: end-to-end context-monitor render ----------
+
+function test_8_endToEndContextMonitorRender(sync) {
+  const work = mkTmp('statusline-active-room-t8-');
+  const room = path.join(work, 'room');
+  writeRoomFixture(room, 'switched-room-name-94-01');
+
+  // Also seed a registry entry pointing at our fixture room so the
+  // existing context-monitor room-resolution path can find it. The
+  // registry's active slug stays aligned with current_room for the
+  // happy-path test.
+  writeRegistry(work, 'switched-room-name-94-01', room);
+
+  // Prepare the JSON payload Claude Code feeds the statusline on stdin.
+  const stdinPayload = JSON.stringify({
+    model: { id: 'claude-3-5-sonnet', display_name: 'Sonnet' },
+    workspace: { current_dir: work },
+    context_window: {
+      remaining_percentage: 80,
+      used_percentage: 20,
+      context_window_size: 200000,
+    },
+  });
+
+  let stdout = '';
+  try {
+    stdout = execFileSync(process.execPath, [CONTEXT_MONITOR], {
+      input: stdinPayload,
+      encoding: 'utf8',
+      timeout: 5000,
+      env: Object.assign({}, process.env, {
+        MINDRIAN_OS_ROOT: REPO,
+      }),
+    });
+  } catch (e) {
+    // Surface the captured streams for diagnostic clarity.
+    const detail = e && e.stdout ? String(e.stdout) : '(no stdout)';
+    const errDetail = e && e.stderr ? String(e.stderr) : '(no stderr)';
+    throw new Error(
+      't8: context-monitor exec failed -- stdout=' + detail +
+      ' stderr=' + errDetail
+    );
+  }
+
+  assert.ok(
+    stdout.indexOf('switched-room-name-94-01') !== -1,
+    't8: context-monitor stdout contains switched-room-name-94-01 ' +
+    '(got: ' + stdout.replace(/\x1b\[[0-9;]*m/g, '').slice(0, 300) + ')'
+  );
+}
+
+// ---------- Runner ----------
+
+async function run() {
+  t0_moduleFileExists();
+
+  // eslint-disable-next-line global-require
+  const sync = require(SYNC_PATH);
+
+  assert.ok(
+    typeof sync.getCurrentRoom === 'function',
+    'precondition: folder-memory.cjs must export getCurrentRoom function'
+  );
+
+  test_1_missingStateMdReturnsNull(sync);
+  test_2_stateMdWithoutFrontmatterReturnsNull(sync);
+  test_3_frontmatterWithoutCurrentRoomReturnsNull(sync);
+  test_4_happyFrontmatterReturnsTriple(sync);
+  test_5_malformedYamlReturnsNull(sync);
+  test_6_lawrenceReproducerNoCaching(sync);
+  test_7_quotesAndWhitespaceStripped(sync);
+  test_8_endToEndContextMonitorRender(sync);
+
+  process.stdout.write('statusline-active-room: 8/8 tests passed\n');
+  process.exit(0);
+}
+
+run().catch((e) => {
+  process.stderr.write((e && e.stack) || String(e));
+  process.stderr.write('\n');
+  process.exit(1);
+});