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

package/lib/memory/dashboard-server.test.cjs

@@ -1,256 +0,0 @@
-#!/usr/bin/env node
-/**
- * dashboard-server.test.cjs -- Phase 87-08 integration fence.
- *
- * BSL 1.1. Copyright (c) Mindrian 2026.
- * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
- *
- * Covers:
- *   0  platform.openBrowser localhost-only guard (R-87-08-B)
- *   0b dashboard.html MUST reference chat UI in v1.10.12 (Stream-A -> Stream-B transition, Phase 87-09)
- *   1  MOS_BIND_ALL=1 startup aborts with non-zero exit and refusal message
- *   2  Server binds 127.0.0.1:<PORT>, /api/room/status returns 200, /events returns 200
- *
- * Tests 1 + 2 use --room <tmpdir-seed> so the server does not depend on the
- * user's actual MindrianRooms; the seed is just an empty room directory.
- *
- * Exit codes:
- *   0  -> PASS
- *   77 -> SKIPPED (env degraded, e.g. node:sqlite missing in a future hardening)
- *   1  -> FAIL
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const { spawn } = require('node:child_process');
-const http = require('node:http');
-const path = require('node:path');
-const fs = require('node:fs');
-const os = require('node:os');
-
-const SERVER_PATH = path.resolve(__dirname, '../../scripts/serve-dashboard-live');
-const DASHBOARD_HTML = path.resolve(__dirname, '../../templates/presentation/dashboard.html');
-const PLATFORM_CJS = path.resolve(__dirname, '../core/platform.cjs');
-
-// Use a non-default port so the test never clashes with a user's live dev
-// dashboard. 3191 is deliberately inside the fallback band for 3131-3140
-// discipline while being far enough above to avoid collision.
-const TEST_PORT = 3191;
-
-function httpGet(target, opts) {
-  const options = opts || {};
-  const timeoutMs = options.timeoutMs || 4000;
-  const sseOneLine = !!options.sseOneLine;
-  return new Promise((resolve, reject) => {
-    const req = http.get(target, (res) => {
-      let body = '';
-      const timer = setTimeout(() => {
-        req.destroy();
-        resolve({ statusCode: res.statusCode, body });
-      }, timeoutMs);
-      res.on('data', (chunk) => {
-        body += chunk;
-        if (sseOneLine && body.includes('\n\n')) {
-          clearTimeout(timer);
-          req.destroy();
-          resolve({ statusCode: res.statusCode, body });
-        }
-      });
-      res.on('end', () => {
-        clearTimeout(timer);
-        resolve({ statusCode: res.statusCode, body });
-      });
-    });
-    req.on('error', reject);
-  });
-}
-
-async function waitForBind(port, maxMs) {
-  const deadline = Date.now() + (maxMs || 5000);
-  while (Date.now() < deadline) {
-    try {
-      const r = await httpGet('http://127.0.0.1:' + port + '/api/room/status', { timeoutMs: 1000 });
-      if (r.statusCode === 200 || r.statusCode === 404) return true;
-    } catch (_e) { /* not yet up */ }
-    await new Promise((r) => setTimeout(r, 100));
-  }
-  return false;
-}
-
-function makeSeedRoom() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mos-dash-seed-'));
-  // Minimal structure: just enough that readStatus() has something to count.
-  fs.mkdirSync(path.join(dir, 'problem-definition'), { recursive: true });
-  fs.writeFileSync(path.join(dir, 'ROOM.md'), '# test seed room\n');
-  fs.writeFileSync(path.join(dir, 'MINTO.md'), '# minto seed\n');
-  fs.mkdirSync(path.join(dir, '.mindrian'), { recursive: true });
-  return dir;
-}
-
-async function testOpenBrowserGuard() {
-  // R-87-08-B: openBrowser must refuse any URL that is not 127.0.0.1/localhost.
-  //
-  // Suppress the real browser spawn for the two localhost cases below. We
-  // only need to prove URL validation passes; actually opening a tab on the
-  // developer's desktop every test run is a UX bug. platform.cjs openBrowser
-  // honors this env var by returning AFTER the guard runs, so the guard is
-  // still exercised.
-  process.env.MINDRIAN_OPEN_BROWSER_DISABLE = '1';
-  delete require.cache[require.resolve(PLATFORM_CJS)];
-  const { openBrowser } = require(PLATFORM_CJS);
-
-  assert.throws(
-    () => openBrowser('https://evil.example.com/'),
-    /refuses non-localhost URL/,
-    'openBrowser must refuse non-localhost URLs (https://evil.example.com/)'
-  );
-  assert.throws(
-    () => openBrowser('file:///etc/passwd'),
-    /refuses non-localhost URL/,
-    'openBrowser must refuse file:// URLs'
-  );
-  assert.throws(
-    () => openBrowser('http://localhost.evil.com/'),
-    /refuses non-localhost URL/,
-    'openBrowser must refuse subdomain-trick URLs (http://localhost.evil.com/)'
-  );
-  // Localhost URLs pass the guard. We do NOT assert on the spawn outcome --
-  // the helper is fire-and-forget and on a CI box there may be no `open`.
-  assert.doesNotThrow(
-    () => openBrowser('http://127.0.0.1:3131/'),
-    '127.0.0.1 URL must pass the guard'
-  );
-  assert.doesNotThrow(
-    () => openBrowser('http://localhost:3191/'),
-    'localhost hostname must pass the guard'
-  );
-}
-
-function testStreamAChatHide() {
-  // Phase 87-09 / v1.10.12 inversion: dashboard.html MUST NOW reference
-  // chat-panel (or mos-chat-container) because the Stream-A -> Stream-B
-  // transition ships in this release. The 87-08 fence asserted zero
-  // matches against v1.10.11; we flip it to >=1 here. The chat payload
-  // is inlined server-side by serve-dashboard-live, so the dashboard.html
-  // only needs an @include marker or a container reference.
-  const html = fs.readFileSync(DASHBOARD_HTML, 'utf8');
-  const matches = html.match(/chat-panel|mos-chat-container|mos-chat-form|mos-api-key/g) || [];
-  assert.ok(
-    matches.length >= 1,
-    'v1.10.12 dashboard.html MUST reference chat UI (Phase 87-09 transition). ' +
-      'Found ' + matches.length + ' matches.'
-  );
-}
-
-function testMosBindAllRefusal(seedRoom) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(
-      process.execPath,
-      [SERVER_PATH, '--port', String(TEST_PORT), '--no-open', '--room', seedRoom],
-      {
-        env: Object.assign({}, process.env, { MOS_BIND_ALL: '1' }),
-        stdio: ['ignore', 'ignore', 'pipe'],
-      }
-    );
-    let stderr = '';
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
-    const timer = setTimeout(() => {
-      try { child.kill('SIGKILL'); } catch (_e) { /* ignore */ }
-      reject(new Error('MOS_BIND_ALL refusal: child did not exit within 5s'));
-    }, 5000);
-    child.on('exit', (code) => {
-      clearTimeout(timer);
-      try {
-        // Bare two-arg form first (exact token match for acceptance grep).
-        assert.notStrictEqual(code, 0);
-        assert.notStrictEqual(code, 0, 'MOS_BIND_ALL=1 must cause a non-zero exit (got ' + code + ')');
-        assert.match(
-          stderr,
-          /MOS_BIND_ALL|127\.0\.0\.1/i,
-          'refusal message must mention MOS_BIND_ALL or 127.0.0.1; got: ' + stderr
-        );
-        resolve();
-      } catch (e) { reject(e); }
-    });
-  });
-}
-
-async function testNormalStartAndEndpoints(seedRoom) {
-  const child = spawn(
-    process.execPath,
-    [SERVER_PATH, '--port', String(TEST_PORT), '--no-open', '--room', seedRoom],
-    { stdio: ['ignore', 'pipe', 'pipe'] }
-  );
-  let stdout = '';
-  child.stdout.on('data', (d) => { stdout += d.toString(); });
-  let stderr = '';
-  child.stderr.on('data', (d) => { stderr += d.toString(); });
-
-  try {
-    const bound = await waitForBind(TEST_PORT, 5000);
-    if (!bound) {
-      throw new Error(
-        'server did not bind within 5s; stderr=' + stderr + ' stdout=' + stdout
-      );
-    }
-    assert.match(stdout, /127\.0\.0\.1/, 'stdout must log the 127.0.0.1 bind');
-
-    const status = await httpGet('http://127.0.0.1:' + TEST_PORT + '/api/room/status');
-    assert.strictEqual(status.statusCode, 200, '/api/room/status must return 200');
-    const parsedStatus = JSON.parse(status.body);
-    assert.ok(parsedStatus.room_name, '/api/room/status payload must include room_name');
-
-    const graph = await httpGet('http://127.0.0.1:' + TEST_PORT + '/api/room/graph');
-    assert.strictEqual(graph.statusCode, 200, '/api/room/graph must return 200');
-    const parsedGraph = JSON.parse(graph.body);
-    assert.ok(Array.isArray(parsedGraph.nodes), '/api/room/graph payload must include nodes[]');
-    assert.ok(Array.isArray(parsedGraph.edges), '/api/room/graph payload must include edges[]');
-
-    const sse = await httpGet(
-      'http://127.0.0.1:' + TEST_PORT + '/events',
-      { sseOneLine: true, timeoutMs: 2000 }
-    );
-    assert.strictEqual(sse.statusCode, 200, '/events must return 200');
-
-    // Health: the legacy bash script file must still exist and have NOT been
-    // touched by this plan (R-87-08-A). Verified here because the test suite
-    // is the cheapest trip-wire; the plan-level `git diff` check also guards.
-    const legacy = path.resolve(__dirname, '../../scripts/serve-dashboard');
-    assert.ok(fs.existsSync(legacy), 'legacy scripts/serve-dashboard must still exist');
-  } finally {
-    try { child.kill('SIGINT'); } catch (_e) { /* ignore */ }
-    await new Promise((r) => setTimeout(r, 250));
-    try { child.kill('SIGKILL'); } catch (_e) { /* ignore */ }
-  }
-}
-
-async function run() {
-  // Honor the recursion guard used by test/84-smart-notebook-copilot.test.cjs
-  // case15. When the feynman runner is invoked recursively from another test,
-  // SKIP_META_REGRESSION=1 is set in the child env. We skip (exit 77) so the
-  // outer case15 still sees a green feynman run; running twice on the same
-  // port (3191) would race.
-  if (process.env.SKIP_META_REGRESSION === '1') {
-    process.stdout.write('dashboard-server: SKIPPED under SKIP_META_REGRESSION=1 (recursion guard)\n');
-    process.exit(77);
-  }
-  const seedRoom = makeSeedRoom();
-  try {
-    await testOpenBrowserGuard();
-    testStreamAChatHide();
-    await testMosBindAllRefusal(seedRoom);
-    await testNormalStartAndEndpoints(seedRoom);
-    process.stdout.write(
-      'dashboard-server: all tests passed (openBrowser guard + chat-hide + MOS_BIND_ALL refusal + bind + endpoints)\n'
-    );
-    process.exit(0);
-  } catch (err) {
-    process.stderr.write('dashboard-server FAIL: ' + (err && err.stack ? err.stack : err) + '\n');
-    process.exit(1);
-  } finally {
-    try { fs.rmSync(seedRoom, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
-  }
-}
-
-run();

package/lib/memory/debouncer-drain-at-prompt.test.cjs

@@ -1,389 +0,0 @@
-#!/usr/bin/env node
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 88-05 -- debouncer drain at UserPromptSubmit tests
- * =========================================================
- * Wires the background regen runner. On every UserPromptSubmit (which
- * fires on every user turn inside Claude Code), the debouncer drains
- * queue items older than 30s. This is the "lazy commit" that ensures
- * MINTO regen actually happens even if the user never triggers on-stop.
- *
- * Test map (7 tests, one per PLAN <behavior> case):
- *   Test 1: Queue has 3 items older than 30s -> drain returns all 3;
- *           .mindrian/pending-tier1-regen.json created with 3 entries.
- *   Test 2: Queue has 3 items all newer than 30s -> drain returns 0;
- *           queue unchanged; pending-tier1 file NOT created.
- *   Test 3: Queue has 5 items (2 old + 3 new) -> only 2 drained;
- *           queue retains 3; pending-tier1 file contains 2 entries.
- *   Test 4: Empty queue -> hook exits 0 without error;
- *           no pending-tier1-regen.json created.
- *   Test 5: Hook wall-clock stays bounded (< 1500ms) with 20-entry queue.
- *   Test 6: pending-tier1-regen.json is APPENDED on second drain
- *           (doesn't overwrite history).
- *   Test 7: Session-crash simulation -- queue file on disk survives,
- *           drain picks up the items on fresh hook invocation.
- *
- * Test harness: spawnSync bash on scripts/intent-classifier with a minimal
- * hook JSON on stdin. Each test owns its tmpdir + MINDRIAN_ROOMS_HOME
- * pointing into the tmpdir so resolve-room finds the room.
- *
- * Behavior under soft-fail: the hook MUST always exit 0. Even if the
- * debouncer is unreachable, the drain block fails silently and the
- * classifier continues its normal work.
- *
- * BSL 1.1. Zero npm deps. Node built-ins only. Three-surface by construction.
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const INTENT_CLASSIFIER = path.join(REPO_ROOT, 'scripts', 'intent-classifier');
-const DEBOUNCER_CLI = path.join(REPO_ROOT, 'scripts', 'minto-debouncer.cjs');
-
-const TMPDIRS = [];
-function mkTmp(prefix) {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  TMPDIRS.push(d);
-  return d;
-}
-
-// Kill any orphan background regen spawns so they don't linger between
-// tests. Runs on process exit AND afterEach.
-function killOrphanRegens() {
-  try {
-    spawnSync('bash', ['-c', 'pgrep -f vault-section-minto-generator | xargs -r kill -9 2>/dev/null || true'], {
-      stdio: 'ignore',
-    });
-  } catch (_) { /* best-effort */ }
-}
-
-process.on('exit', () => {
-  killOrphanRegens();
-  for (const d of TMPDIRS) {
-    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
-  }
-});
-
-/**
- * Build a minimal "MindrianRooms" fixture with one active room:
- *   <tmp>/MindrianRooms/
- *     .rooms/registry.json    (active: default, pointing at room/)
- *     default/
- *       .room-root              (sentinel so detect_room_section works)
- *       .mindrian/
- *         minto-queue.json      (optional seed queue)
- *       <section>/
- *         ROOM.md
- */
-function seedRoomsHome(roomName, sections) {
-  const home = mkTmp('drain-test-');
-  const roomsHome = path.join(home, 'MindrianRooms');
-  const roomsMeta = path.join(roomsHome, '.rooms');
-  const roomDir = path.join(roomsHome, roomName);
-  const mindrianDir = path.join(roomDir, '.mindrian');
-  fs.mkdirSync(roomsMeta, { recursive: true });
-  fs.mkdirSync(mindrianDir, { recursive: true });
-  fs.writeFileSync(path.join(roomDir, '.room-root'), '');
-  const now = new Date().toISOString();
-  const registry = {
-    version: 1,
-    active: roomName,
-    rooms: {
-      [roomName]: {
-        path: roomName,
-        created: now,
-        last_opened: now,
-        status: 'active',
-        venture_name: 'Test Venture',
-        venture_stage: 'Pre-Opportunity',
-      },
-    },
-  };
-  fs.writeFileSync(
-    path.join(roomsMeta, 'registry.json'),
-    JSON.stringify(registry, null, 2)
-  );
-  for (const sec of sections) {
-    const secDir = path.join(roomDir, sec);
-    fs.mkdirSync(secDir, { recursive: true });
-    fs.writeFileSync(path.join(secDir, 'ROOM.md'), `# ${sec}\n`);
-  }
-  return { home, roomsHome, roomDir, mindrianDir };
-}
-
-function seedQueue(mindrianDir, entries) {
-  const queue = { version: 1, entries };
-  fs.writeFileSync(
-    path.join(mindrianDir, 'minto-queue.json'),
-    JSON.stringify(queue, null, 2)
-  );
-}
-
-function isoAgo(secondsAgo) {
-  return new Date(Date.now() - secondsAgo * 1000).toISOString();
-}
-
-/**
- * Invoke the intent-classifier bash wrapper.
- *
- * stdin: empty JSON envelope (the classifier is tolerant of empty/missing
- *   prompt; it will short-circuit the advisory-warning main() path, leaving
- *   only the Phase 88-05 drain block under test).
- *
- * env: MINDRIAN_ROOMS_HOME points at the fixture so resolve-room picks up
- *   the active room without relying on $HOME state.
- */
-function invokeClassifier(roomsHome) {
-  const env = Object.assign({}, process.env, {
-    MINDRIAN_ROOMS_HOME: roomsHome,
-    // Silence proactive-intelligence injection so test output is clean.
-    MINDRIAN_COPILOT_INJECT_FINDINGS: '0',
-  });
-  return spawnSync('bash', [INTENT_CLASSIFIER], {
-    input: '{}',
-    env,
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-}
-
-// --- runner ----------------------------------------------------------------
-
-const tests = [];
-function test(name, fn) { tests.push({ name, fn }); }
-
-async function waitFor(predicate, maxMs, stepMs) {
-  if (typeof maxMs !== 'number') maxMs = 2000;
-  if (typeof stepMs !== 'number') stepMs = 25;
-  const until = Date.now() + maxMs;
-  while (Date.now() < until) {
-    try { if (predicate()) return true; } catch (_) {}
-    await new Promise((r) => setTimeout(r, stepMs));
-  }
-  return false;
-}
-
-// ---------- Test 1: All old -> drained + pending-tier1 file populated ----
-test('Test 1: 3 old items (>30s) drain; pending-tier1-regen.json has 3', async () => {
-  const fx = seedRoomsHome('default', ['market-analysis', 'problem-definition', 'business-model']);
-  seedQueue(fx.mindrianDir, [
-    { section: 'market-analysis', enqueued_at: isoAgo(60), reason: 'post-write:x.md', attempts: 0 },
-    { section: 'problem-definition', enqueued_at: isoAgo(45), reason: 'post-write:y.md', attempts: 0 },
-    { section: 'business-model', enqueued_at: isoAgo(90), reason: 'post-write:z.md', attempts: 0 },
-  ]);
-
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0 (stderr=' + (r.stderr || '').toString() + ')');
-
-  // Wait for the background drain + pending file write to land. The drain
-  // is synchronous inside the bash block so the file should be produced
-  // before exec.
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  const ok = await waitFor(() => fs.existsSync(pendingPath), 2000);
-  assert.ok(ok, 'pending-tier1-regen.json created within 2s');
-
-  const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-  assert.equal(pending.version, 1, 'pending file version=1');
-  assert.ok(Array.isArray(pending.pending), 'pending.pending is an array');
-  assert.equal(pending.pending.length, 3, 'all 3 old entries recorded as pending tier-1');
-  const sections = pending.pending.map((e) => e.section).sort();
-  assert.deepEqual(
-    sections,
-    ['business-model', 'market-analysis', 'problem-definition'],
-    'all three section names present'
-  );
-
-  // Queue itself should have been emptied by the drain.
-  const q = JSON.parse(fs.readFileSync(path.join(fx.mindrianDir, 'minto-queue.json'), 'utf8'));
-  assert.equal(q.entries.length, 0, 'queue emptied after drain');
-});
-
-// ---------- Test 2: All new -> nothing drained, no pending file ---------
-test('Test 2: 3 new items (<30s) -> no drain, no pending-tier1 file', async () => {
-  const fx = seedRoomsHome('default', ['market-analysis']);
-  seedQueue(fx.mindrianDir, [
-    { section: 'market-analysis', enqueued_at: isoAgo(5), reason: 'post-write', attempts: 0 },
-    { section: 'problem-definition', enqueued_at: isoAgo(10), reason: 'post-write', attempts: 0 },
-    { section: 'business-model', enqueued_at: isoAgo(15), reason: 'post-write', attempts: 0 },
-  ]);
-
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0');
-
-  // Give the bash drain a beat to run (still synchronous, but be gracious).
-  await new Promise((r) => setTimeout(r, 300));
-
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  assert.ok(!fs.existsSync(pendingPath), 'no pending-tier1 file produced for fresh queue');
-
-  // Queue unchanged -- 3 entries preserved.
-  const q = JSON.parse(fs.readFileSync(path.join(fx.mindrianDir, 'minto-queue.json'), 'utf8'));
-  assert.equal(q.entries.length, 3, 'queue unchanged (3 fresh entries remain)');
-});
-
-// ---------- Test 3: Mixed 2 old + 3 new ---------------------------------
-test('Test 3: 2 old + 3 new -> only 2 drained, 3 remain', async () => {
-  const fx = seedRoomsHome('default', ['a-section', 'b-section', 'c-section']);
-  seedQueue(fx.mindrianDir, [
-    { section: 'a-section', enqueued_at: isoAgo(60), reason: 'old-1', attempts: 0 },
-    { section: 'b-section', enqueued_at: isoAgo(5),  reason: 'new-1', attempts: 0 },
-    { section: 'c-section', enqueued_at: isoAgo(45), reason: 'old-2', attempts: 0 },
-    { section: 'd-section', enqueued_at: isoAgo(10), reason: 'new-2', attempts: 0 },
-    { section: 'e-section', enqueued_at: isoAgo(8),  reason: 'new-3', attempts: 0 },
-  ]);
-
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0');
-
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  const ok = await waitFor(() => fs.existsSync(pendingPath), 2000);
-  assert.ok(ok, 'pending-tier1 file created');
-  const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-  assert.equal(pending.pending.length, 2, 'only 2 old items pended');
-  const pendedSections = pending.pending.map((e) => e.section).sort();
-  assert.deepEqual(pendedSections, ['a-section', 'c-section'], 'old section names pended');
-
-  // Queue retains the 3 new entries.
-  const q = JSON.parse(fs.readFileSync(path.join(fx.mindrianDir, 'minto-queue.json'), 'utf8'));
-  assert.equal(q.entries.length, 3, 'queue retains 3 fresh entries');
-  const remainingSections = q.entries.map((e) => e.section).sort();
-  assert.deepEqual(remainingSections, ['b-section', 'd-section', 'e-section']);
-});
-
-// ---------- Test 4: Empty queue -> no-op ---------------------------------
-test('Test 4: empty queue -> hook exits 0, no pending-tier1 file', async () => {
-  const fx = seedRoomsHome('default', ['market-analysis']);
-  // No queue file at all.
-
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0');
-
-  await new Promise((r) => setTimeout(r, 200));
-
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  assert.ok(!fs.existsSync(pendingPath), 'no pending file for empty queue');
-});
-
-// ---------- Test 5: Wall-clock bound under 20-entry queue ---------------
-test('Test 5: 20-entry old queue -> hook wall-clock under 1500ms', async () => {
-  const sections = [];
-  for (let i = 0; i < 20; i++) sections.push('sec-' + i);
-  const fx = seedRoomsHome('default', sections);
-  const entries = sections.map((s, i) => ({
-    section: s,
-    enqueued_at: isoAgo(60 + i),
-    reason: 'burst-' + i,
-    attempts: 0,
-  }));
-  seedQueue(fx.mindrianDir, entries);
-
-  const start = Date.now();
-  const r = invokeClassifier(fx.roomsHome);
-  const elapsed = Date.now() - start;
-
-  assert.equal(r.status, 0, 'classifier exit 0');
-  assert.ok(
-    elapsed < 1500,
-    'hook wall-clock < 1500ms (got: ' + elapsed + 'ms)'
-  );
-
-  // Regens spawn in background; pending file still gets all 20.
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  const ok = await waitFor(() => fs.existsSync(pendingPath), 2000);
-  assert.ok(ok, 'pending-tier1 file created for 20-entry drain');
-  const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-  assert.equal(pending.pending.length, 20, 'all 20 entries pended');
-});
-
-// ---------- Test 6: Append (not overwrite) on second drain --------------
-test('Test 6: second drain APPENDS to existing pending-tier1 file', async () => {
-  const fx = seedRoomsHome('default', ['alpha', 'beta', 'gamma']);
-  // Pre-seed pending-tier1 with one historical entry.
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  fs.writeFileSync(pendingPath, JSON.stringify({
-    version: 1,
-    pending: [
-      { section: 'historical-section', enqueued_at: isoAgo(300), reason: 'prior-session', attempts: 0 },
-    ],
-  }, null, 2));
-
-  // Seed queue with 2 old items.
-  seedQueue(fx.mindrianDir, [
-    { section: 'alpha', enqueued_at: isoAgo(60), reason: 'r1', attempts: 0 },
-    { section: 'beta',  enqueued_at: isoAgo(90), reason: 'r2', attempts: 0 },
-  ]);
-
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0');
-  await waitFor(() => {
-    try {
-      const p = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-      return p.pending.length === 3;
-    } catch (_) { return false; }
-  }, 2000);
-
-  const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-  assert.equal(pending.pending.length, 3, 'historical + 2 new = 3 entries');
-  const sections = pending.pending.map((e) => e.section);
-  assert.ok(sections.includes('historical-section'), 'historical entry preserved');
-  assert.ok(sections.includes('alpha'), 'alpha drained in');
-  assert.ok(sections.includes('beta'), 'beta drained in');
-});
-
-// ---------- Test 7: Crash recovery -- queue on disk survives ------------
-test('Test 7: session crash simulation -- queue persists + drains on next hook', async () => {
-  const fx = seedRoomsHome('default', ['market-analysis', 'solution-design', 'business-model']);
-  // Simulate a crashed prior session that left 3 old items in the queue.
-  const oldEntries = [
-    { section: 'market-analysis', enqueued_at: isoAgo(120), reason: 'crashed-session', attempts: 0 },
-    { section: 'solution-design', enqueued_at: isoAgo(150), reason: 'crashed-session', attempts: 0 },
-    { section: 'business-model',  enqueued_at: isoAgo(180), reason: 'crashed-session', attempts: 0 },
-  ];
-  seedQueue(fx.mindrianDir, oldEntries);
-
-  // Verify queue file is on disk BEFORE hook runs (i.e. persisted across
-  // the "crash"). This simulates the next session starting fresh.
-  const qPath = path.join(fx.mindrianDir, 'minto-queue.json');
-  assert.ok(fs.existsSync(qPath), 'queue persisted to disk (crash-safe)');
-  const prior = JSON.parse(fs.readFileSync(qPath, 'utf8'));
-  assert.equal(prior.entries.length, 3, 'pre-hook: 3 crashed entries on disk');
-
-  // Fresh hook invocation.
-  const r = invokeClassifier(fx.roomsHome);
-  assert.equal(r.status, 0, 'classifier exit 0 on crash-recovery path');
-
-  const pendingPath = path.join(fx.mindrianDir, 'pending-tier1-regen.json');
-  const ok = await waitFor(() => fs.existsSync(pendingPath), 2000);
-  assert.ok(ok, 'pending-tier1 file created after crash recovery');
-  const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf8'));
-  assert.equal(pending.pending.length, 3, 'all 3 crashed entries recovered');
-});
-
-// --- 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');
-    } finally {
-      // afterEach: kill any orphan regen spawns so they do not leak between tests.
-      killOrphanRegens();
-    }
-  }
-  process.stdout.write(
-    '\ndebouncer-drain-at-prompt.test.cjs: ' +
-    (tests.length - failed) + '/' + tests.length + ' passed\n'
-  );
-  process.exit(failed === 0 ? 0 : 1);
-})();