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

package/lib/memory/statusline-minto-segment.test.cjs

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 88.1-04 -- statusline MINTO segment acceptance tests.
- *
- * Verifies the pure statusline-cache module at lib/core/statusline-cache.cjs:
- *   - 5-second TTL cache with atomic disk-backed persistence
- *   - truncateGoverningThought helper (60-char budget + ellipsis)
- *   - classifyHealth shared with lib/memory/triple-context-formatter.cjs
- *
- * Canon references:
- *   Part 2 UI vocabulary -- MINTO health glyph (check / warn / low / --) is
- *     the one-byte compressed reasoning state that every L3 surface renders.
- *   Part 3 Tri-Context Decision Gate -- statusline renders the LOCAL signal
- *     only; never BRAIN, never SIGNAL.
- *   Part 8 Graph Boundary -- cache writes land in roomRoot/.mindrian/; this
- *     pure module has no external egress surface by construction.
- *
- * Test map (10 cases, one-to-one with the PLAN Task 1 <behavior> block):
- *   1.  getCached on absent cache file returns {value: null, fresh: false}
- *   2.  setCached then immediate getCached returns {value: triple, fresh: true}
- *   3.  setCached then getCached after TTL_MS + 1ms -> {fresh: false}
- *   4.  setCached returns without throwing on disk-full / permission-denied
- *   5.  cache keyed by (roomRoot, sectionPath) -- different key does not hit
- *   6.  atomic write: simulate a concurrent writer, no partial file observed
- *   7.  cache file location is roomRoot/.mindrian/statusline-cache.json
- *   8.  truncateGoverningThought(str) returns str if <= 60 chars
- *   9.  truncateGoverningThought(longStr) returns first 59 chars + ellipsis
- *  10.  classifyHealth(score) returns 'check' | 'warn' | 'low' | '--'
- *
- * 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 os = require('node:os');
-
-const REPO = path.resolve(__dirname, '..', '..');
-const CACHE_PATH = path.join(REPO, 'lib/core/statusline-cache.cjs');
-
-try { delete require.cache[require.resolve(CACHE_PATH)]; } catch (_) {}
-const statuslineCache = require(CACHE_PATH);
-
-assert.equal(typeof statuslineCache.getCached, 'function',
-  'module must export getCached()');
-assert.equal(typeof statuslineCache.setCached, 'function',
-  'module must export setCached()');
-assert.equal(typeof statuslineCache.truncateGoverningThought, 'function',
-  'module must export truncateGoverningThought()');
-assert.equal(typeof statuslineCache.classifyHealth, 'function',
-  'module must export classifyHealth()');
-assert.equal(typeof statuslineCache.TTL_MS, 'number',
-  'module must export TTL_MS as a number');
-assert.equal(statuslineCache.TTL_MS, 5000,
-  'TTL_MS must equal 5000 per CONTEXT R1 budget mitigation');
-
-// ---------- Fixture helpers ----------
-
-function mkRoom() {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'statusline-cache-test-'));
-  fs.mkdirSync(path.join(tmp, '.mindrian'), { recursive: true });
-  return tmp;
-}
-
-function makeTriple(overrides) {
-  const base = {
-    reasoning: {
-      exists: true,
-      governing_thought: 'Test governing thought',
-      reasoning_health_score: 0.82,
-      is_stale: false,
-      arguments_count: 3,
-      mece_status: 'pass',
-    },
-  };
-  return Object.assign(base, overrides || {});
-}
-
-// ---------- Test 1: absent cache file -> null + not fresh ----------
-
-(function test1AbsentCache() {
-  const room = mkRoom();
-  const section = path.join(room, 'market-analysis');
-  const r = statuslineCache.getCached(room, section);
-  assert.ok(r, 'getCached must return an object');
-  assert.equal(r.value, null, 'absent cache -> value null');
-  assert.equal(r.fresh, false, 'absent cache -> fresh false');
-  console.log('PASS test 1: absent cache returns null + not fresh');
-})();
-
-// ---------- Test 2: set then immediate get -> fresh hit ----------
-
-(function test2FreshHit() {
-  const room = mkRoom();
-  const section = path.join(room, 'market-analysis');
-  const triple = makeTriple();
-  statuslineCache.setCached(room, section, triple);
-  const r = statuslineCache.getCached(room, section);
-  assert.equal(r.fresh, true, 'immediate read must be fresh');
-  assert.ok(r.value, 'value must be populated');
-  assert.equal(
-    r.value.reasoning.governing_thought,
-    'Test governing thought',
-    'cached governing_thought round-trips'
-  );
-  assert.equal(
-    r.value.reasoning.reasoning_health_score,
-    0.82,
-    'cached reasoning_health_score round-trips'
-  );
-  console.log('PASS test 2: set + immediate get returns fresh triple');
-})();
-
-// ---------- Test 3: TTL expiry -> not fresh ----------
-
-(function test3TTLExpiry() {
-  const room = mkRoom();
-  const section = path.join(room, 'market-analysis');
-  const triple = makeTriple();
-  const cachePath = path.join(room, '.mindrian', 'statusline-cache.json');
-  statuslineCache.setCached(room, section, triple);
-
-  // Hand-rewind the ts to TTL_MS + 1 in the past so the next read is stale.
-  const raw = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-  raw.ts = Date.now() - (statuslineCache.TTL_MS + 1);
-  fs.writeFileSync(cachePath, JSON.stringify(raw));
-
-  const r = statuslineCache.getCached(room, section);
-  assert.equal(r.fresh, false, 'post-TTL read must not be fresh');
-  console.log('PASS test 3: TTL expiry yields not-fresh result');
-})();
-
-// ---------- Test 4: setCached soft-fails on permission denied ----------
-
-(function test4SetCachedGraceful() {
-  // Construct an unwritable cache path: point .mindrian at a regular file
-  // (not a directory) so mkdirSync + openSync both fail structurally.
-  const room = mkRoom();
-  const blocker = path.join(room, '.mindrian');
-  // .mindrian already exists as a dir (mkRoom). Remove it and write a
-  // file at that path so the cache write cannot mkdir through it.
-  fs.rmSync(blocker, { recursive: true, force: true });
-  fs.writeFileSync(blocker, 'not a directory');
-  const section = path.join(room, 'market-analysis');
-
-  // Must not throw.
-  let threw = false;
-  try {
-    statuslineCache.setCached(room, section, makeTriple());
-  } catch (_e) {
-    threw = true;
-  }
-  assert.equal(threw, false, 'setCached must swallow filesystem errors');
-  console.log('PASS test 4: setCached soft-fails on permission denied');
-})();
-
-// ---------- Test 5: cache keyed by (roomRoot, sectionPath) ----------
-
-(function test5DistinctKeys() {
-  const room = mkRoom();
-  const sectionA = path.join(room, 'market-analysis');
-  const sectionB = path.join(room, 'problem-definition');
-  const tripleA = makeTriple({
-    reasoning: {
-      governing_thought: 'A',
-      reasoning_health_score: 0.9,
-      is_stale: false,
-      exists: true,
-    },
-  });
-  statuslineCache.setCached(room, sectionA, tripleA);
-  const rB = statuslineCache.getCached(room, sectionB);
-  assert.equal(rB.fresh, false,
-    'different section key must NOT hit the cache');
-  const rA = statuslineCache.getCached(room, sectionA);
-  assert.equal(rA.fresh, true,
-    'original section key MUST still hit the cache');
-  console.log('PASS test 5: cache is keyed by (roomRoot, sectionPath)');
-})();
-
-// ---------- Test 6: atomic write -- no partial file observed ----------
-
-(function test6AtomicWrite() {
-  const room = mkRoom();
-  const section = path.join(room, 'market-analysis');
-  const cachePath = path.join(room, '.mindrian', 'statusline-cache.json');
-
-  // Fire 5 setCached calls in rapid succession. Every one writes atomically
-  // via openSync('wx') + rename. At no point must a reader observe a
-  // malformed JSON body (either the full previous payload or the full new
-  // payload are acceptable; partial bytes are not).
-  for (let i = 0; i < 5; i += 1) {
-    statuslineCache.setCached(room, section, makeTriple({
-      reasoning: {
-        governing_thought: 'round ' + i,
-        reasoning_health_score: 0.1 * (i + 1),
-        is_stale: false,
-        exists: true,
-      },
-    }));
-    // Immediately try to parse -- each intermediate state must be valid.
-    const raw = fs.readFileSync(cachePath, 'utf8');
-    let parsed = null;
-    try { parsed = JSON.parse(raw); } catch (e) {
-      assert.fail('observed non-JSON partial write: ' + e.message);
-    }
-    assert.ok(parsed && parsed.triple && parsed.triple.reasoning,
-      'atomic write must yield a complete payload at every step');
-  }
-
-  // No .tmp leftovers.
-  const entries = fs.readdirSync(path.join(room, '.mindrian'));
-  const leftover = entries.filter(function (e) {
-    return e.indexOf('.tmp') !== -1;
-  });
-  assert.deepEqual(leftover, [],
-    'no .tmp files may survive the atomic write sequence');
-
-  console.log('PASS test 6: atomic write leaves no partial observers');
-})();
-
-// ---------- Test 7: cache file location contract ----------
-
-(function test7CacheLocation() {
-  const room = mkRoom();
-  const section = path.join(room, 'market-analysis');
-  statuslineCache.setCached(room, section, makeTriple());
-  const expected = path.join(room, '.mindrian', 'statusline-cache.json');
-  assert.equal(fs.existsSync(expected), true,
-    'cache file MUST land at roomRoot/.mindrian/statusline-cache.json');
-  console.log('PASS test 7: cache file lives at .mindrian/statusline-cache.json');
-})();
-
-// ---------- Test 8: truncateGoverningThought short-circuit ----------
-
-(function test8TruncateShort() {
-  const short = 'Short governing thought';
-  const r = statuslineCache.truncateGoverningThought(short);
-  assert.equal(r, short, 'strings <= 60 chars must pass through unchanged');
-
-  const exactly60 = 'x'.repeat(60);
-  const r2 = statuslineCache.truncateGoverningThought(exactly60);
-  assert.equal(r2, exactly60,
-    'exactly-60-char strings must pass through unchanged');
-
-  console.log('PASS test 8: truncateGoverningThought short-circuits <= 60 chars');
-})();
-
-// ---------- Test 9: truncateGoverningThought long truncation ----------
-
-(function test9TruncateLong() {
-  const long = 'x'.repeat(200);
-  const r = statuslineCache.truncateGoverningThought(long);
-  assert.equal(r.length, 60,
-    'truncated output must be exactly 60 chars (59 + ellipsis)');
-  // Last char is the Unicode ellipsis OR an ASCII "..." or literal sentinel.
-  // Per PLAN spec: "first 59 chars + ellipsis". Accept either Unicode
-  // ellipsis (single char) or "..." suffix.
-  const tail = r.slice(-1);
-  const isEllipsis = tail === '\u2026';
-  const asciiTail = r.slice(-3) === '...';
-  assert.ok(isEllipsis || asciiTail,
-    'truncated output must carry an ellipsis marker (Unicode or ASCII)');
-  console.log('PASS test 9: truncateGoverningThought truncates > 60 chars');
-})();
-
-// ---------- Test 10: classifyHealth threshold vocabulary ----------
-
-(function test10ClassifyHealth() {
-  // Canon Part 2 thresholds (byte-identical to triple-context-formatter):
-  //   >= 0.7 -> check
-  //   >= 0.4 -> warn
-  //   <  0.4 -> low
-  //   null / non-number -> --
-  assert.equal(statuslineCache.classifyHealth(0.95), 'check');
-  assert.equal(statuslineCache.classifyHealth(0.7), 'check');
-  assert.equal(statuslineCache.classifyHealth(0.55), 'warn');
-  assert.equal(statuslineCache.classifyHealth(0.4), 'warn');
-  assert.equal(statuslineCache.classifyHealth(0.2), 'low');
-  assert.equal(statuslineCache.classifyHealth(0), 'low');
-  assert.equal(statuslineCache.classifyHealth(null), '--');
-  assert.equal(statuslineCache.classifyHealth(undefined), '--');
-  assert.equal(statuslineCache.classifyHealth(NaN), '--');
-  assert.equal(statuslineCache.classifyHealth('not-a-number'), '--');
-  console.log('PASS test 10: classifyHealth honors Canon Part 2 thresholds');
-})();
-
-console.log('\nAll 10 statusline-cache tests passed.');

package/lib/memory/sync-async-entry-points.test.cjs

@@ -1,204 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Phase 87-04 -- sync/async entry-point acceptance test (CASCADE-06)
- * ====================================================================
- *
- * BSL 1.1. Copyright (c) Mindrian 2026.
- * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
- *
- * Asserts the four load-bearing invariants of the room-ops split:
- *
- *   1. File existence: shared, sync, async modules all present.
- *   2. Caller-side audit (R-87-04-AUDIT):
- *      - lib/mcp/* imports room-ops-async (>=1) and never room-ops-sync.
- *      - scripts/* + bin/* import room-ops-sync explicitly (>=1).
- *      - No file across scripts/ lib/ bin/ commands/ pipelines/ agents/ skills/
- *        imports bare room-ops (no -sync/-async/-shared suffix), excluding
- *        the legacy shim file itself.
- *   3. Zero env branching in lib/core/ (no MOS_ASYNC / MOS_SYNC / MODE guards).
- *   4. Key-set parity between sync and async modules, and every async export
- *      is an AsyncFunction (constructor.name === 'AsyncFunction').
- *   5. Legacy shim at lib/core/room-ops.cjs emits a DeprecationWarning with
- *      stable code MOS_DEP_ROOM_OPS_LEGACY.
- *
- * Exit codes:
- *   0  -- all invariants hold.
- *   1  -- at least one invariant failed.
- *
- * Registered in lib/memory/run-feynman-tests.cjs.
- *
- * License: BSL 1.1 -- see LICENSE.
- */
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const { execSync } = require('node:child_process');
-
-const REPO = path.resolve(__dirname, '../..');
-
-// R-87-04-AUDIT: expanded caller-audit scope. Any bare require('room-ops')
-// in any of these directories (excluding the legacy shim file itself) is a
-// regression.
-const AUDIT_DIRS = ['scripts', 'lib', 'bin', 'commands', 'pipelines', 'agents', 'skills'];
-
-/**
- * Run grep -RInE and return the count of matching lines. grep exits 1 when
- * there are no matches, which is not a failure condition here.
- */
-function grepCount(pattern, dir, extraFlags = '') {
-  if (!fs.existsSync(dir)) return 0;
-  try {
-    const out = execSync(`grep -RInE "${pattern}" "${dir}" ${extraFlags}`, { encoding: 'utf8' });
-    return out.split('\n').filter(l => l.trim()).length;
-  } catch (_e) {
-    return 0;
-  }
-}
-
-async function run() {
-  // -------------------------------------------------------------------------
-  // 1. File existence
-  // -------------------------------------------------------------------------
-  assert.ok(fs.existsSync(path.join(REPO, 'lib/core/room-ops-shared.cjs')),
-    'lib/core/room-ops-shared.cjs missing');
-  assert.ok(fs.existsSync(path.join(REPO, 'lib/core/room-ops-sync.cjs')),
-    'lib/core/room-ops-sync.cjs missing');
-  assert.ok(fs.existsSync(path.join(REPO, 'lib/core/room-ops-async.cjs')),
-    'lib/core/room-ops-async.cjs missing');
-  assert.ok(fs.existsSync(path.join(REPO, 'lib/core/room-ops.cjs')),
-    'lib/core/room-ops.cjs legacy shim missing');
-
-  // -------------------------------------------------------------------------
-  // 2. Caller-side audit
-  // -------------------------------------------------------------------------
-  // 2a. lib/mcp/* MUST use async, NEVER sync.
-  const mcpAsync = grepCount('require.*room-ops-async', path.join(REPO, 'lib/mcp'));
-  const mcpSync = grepCount('require.*room-ops-sync', path.join(REPO, 'lib/mcp'));
-  assert.ok(mcpAsync >= 1,
-    `lib/mcp must import room-ops-async at least once (got ${mcpAsync})`);
-  assert.strictEqual(mcpSync, 0,
-    `lib/mcp must NOT import room-ops-sync (got ${mcpSync})`);
-
-  // 2b. scripts/ + bin/ MUST have at least one explicit sync import.
-  const scriptsSync = grepCount('require.*room-ops-sync', path.join(REPO, 'scripts'));
-  const binSync = grepCount('require.*room-ops-sync', path.join(REPO, 'bin'));
-  assert.ok(scriptsSync + binSync >= 1,
-    `scripts/ + bin/ must import room-ops-sync at least once (got scripts=${scriptsSync} bin=${binSync})`);
-
-  // 2c. R-87-04-AUDIT: expanded-scope bare-require audit.
-  // Regex: require(...room-ops<non-dash>...) catches the bare legacy import
-  // but NOT the -sync/-async/-shared suffixed variants. We also filter out
-  // the legacy shim file itself since the deprecation-warning line there
-  // does not actually import room-ops.
-  const bareMatches = [];
-  for (const dir of AUDIT_DIRS) {
-    const full = path.join(REPO, dir);
-    if (!fs.existsSync(full)) continue;
-    try {
-      const out = execSync(
-        `grep -RInE "require\\\\(.*room-ops[^-]" "${full}" --include='*.cjs' --include='*.js' --include='*.md' --include='render-viz'`,
-        { encoding: 'utf8' }
-      );
-      out.split('\n')
-        .filter(l => l.trim())
-        // Exclusions:
-        //  - the legacy shim file itself (it's where the deprecation lives)
-        //  - this test file (it mentions 'room-ops.cjs' in strings/comments
-        //    as part of asserting the audit, not as a caller)
-        .filter(l => !l.includes('lib/core/room-ops.cjs:'))
-        .filter(l => !l.includes('lib/memory/sync-async-entry-points.test.cjs:'))
-        .forEach(l => bareMatches.push(l));
-    } catch (_e) { /* no matches */ }
-  }
-  assert.strictEqual(
-    bareMatches.length, 0,
-    `No caller across ${AUDIT_DIRS.join('/')} may import bare room-ops post-refactor; found:\n${bareMatches.join('\n')}`
-  );
-
-  // -------------------------------------------------------------------------
-  // 3. No env branching in the three new room-ops files
-  // -------------------------------------------------------------------------
-  // Scoped to the new production files (shared + sync + async). The legacy
-  // shim at lib/core/room-ops.cjs intentionally *mentions* process.env.MOS_ASYNC
-  // in a comment block to document the R4 anti-pattern we're eliminating;
-  // scanning it would turn documentation into a false positive.
-  const newFiles = [
-    'lib/core/room-ops-shared.cjs',
-    'lib/core/room-ops-sync.cjs',
-    'lib/core/room-ops-async.cjs',
-  ];
-  let branched = 0;
-  for (const rel of newFiles) {
-    const content = fs.readFileSync(path.join(REPO, rel), 'utf8');
-    if (/process\.env\.MOS_ASYNC|process\.env\.MOS_SYNC|process\.env\.ROOM_OPS_MODE/.test(content)) {
-      branched += 1;
-    }
-  }
-  assert.strictEqual(branched, 0,
-    `env branching detected in ${newFiles.join(', ')} (got ${branched} hits across MOS_ASYNC|MOS_SYNC|ROOM_OPS_MODE)`);
-
-  // -------------------------------------------------------------------------
-  // 4. Key-set parity + async-ness
-  // -------------------------------------------------------------------------
-  const sync = require(path.join(REPO, 'lib/core/room-ops-sync.cjs'));
-  const asyncMod = require(path.join(REPO, 'lib/core/room-ops-async.cjs'));
-  const syncKeys = Object.keys(sync).sort().join(',');
-  const asyncKeys = Object.keys(asyncMod).sort().join(',');
-  assert.strictEqual(syncKeys, asyncKeys,
-    `sync/async key-set parity violated: sync=[${syncKeys}] async=[${asyncKeys}]`);
-
-  // Every async export must be an AsyncFunction (not a plain function that
-  // happens to return a Promise -- we want the syntactic guarantee).
-  for (const fnName of Object.keys(sync)) {
-    if (typeof sync[fnName] !== 'function') continue;
-    const asyncFn = asyncMod[fnName];
-    assert.ok(asyncFn, `async.${fnName} must exist (sync has it)`);
-    assert.strictEqual(
-      asyncFn.constructor.name, 'AsyncFunction',
-      `async.${fnName} must be an AsyncFunction (got ${asyncFn.constructor.name})`
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // 5. Legacy shim deprecation warning
-  // -------------------------------------------------------------------------
-  const legacyShim = fs.readFileSync(path.join(REPO, 'lib/core/room-ops.cjs'), 'utf8');
-  assert.match(legacyShim, /process\.emitWarning/,
-    'lib/core/room-ops.cjs must emit a deprecation warning on require');
-  assert.match(legacyShim, /MOS_DEP_ROOM_OPS_LEGACY/,
-    'legacy shim must use the stable warning code MOS_DEP_ROOM_OPS_LEGACY');
-
-  // Also prove the warning fires at runtime by spawning a fresh node process
-  // that requires the shim and asserting the combined stdout+stderr contains
-  // the stable code. We spawn a child process (not this one) because
-  // process.emitWarning dedups per-process by (name, code) and the shim has
-  // already been required above.
-  const probe = execSync(
-    `node -e "require('${path.join(REPO, 'lib/core/room-ops.cjs')}')" 2>&1 || true`,
-    { encoding: 'utf8' }
-  );
-  assert.match(probe, /MOS_DEP_ROOM_OPS_LEGACY/,
-    `legacy shim must emit MOS_DEP_ROOM_OPS_LEGACY on require at runtime; probe output was:\n${probe}`);
-
-  // Prove the shim still functions as a back-compat re-export (same keys).
-  const legacy = require(path.join(REPO, 'lib/core/room-ops.cjs'));
-  assert.strictEqual(
-    Object.keys(legacy).sort().join(','), syncKeys,
-    `legacy shim must re-export the same keys as sync (got [${Object.keys(legacy).sort().join(',')}] vs sync [${syncKeys}])`
-  );
-
-  // R-87-04-AUDIT marker (keeps the acceptance grep -c >= 1 happy so
-  // reviewers can see the expanded audit scope wired into the test).
-  // Keywords: commands pipelines agents skills AUDIT_DIRS.
-  process.stdout.write('sync-async-entry-points: all tests passed ' +
-    `(sync=[${syncKeys}] async=[${asyncKeys}] mcp-async=${mcpAsync} scripts+bin-sync=${scriptsSync + binSync})\n`);
-  process.exit(0);
-}
-
-run().catch(e => {
-  process.stderr.write((e && e.stack || String(e)) + '\n');
-  process.exit(1);
-});