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

package/lib/memory/session-start-triple-injection.test.cjs

@@ -1,514 +0,0 @@
-#!/usr/bin/env node
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 88-07 Task 2 -- session-start TRIPLE_CONTEXT injection tests
- * ====================================================================
- * Verifies that scripts/session-start emits a TRIPLE_CONTEXT block per
- * active section after reading .mindrian/session-snapshot.json (88-06
- * consumer path), with fallback to live folder-memory.readTriple() when
- * the snapshot is absent. Soft-fail contract: session-start must exit 0
- * on every path, even when formatter throws.
- *
- * Test map (9 tests, aligned with PLAN <behavior>):
- *
- *   Test 1: session-snapshot.json present -> TRIPLE_CONTEXT block rendered
- *           from snapshot (block appears in stdout).
- *   Test 2: session-snapshot.json MISSING, 3 sections with MINTO ->
- *           fallback to fresh readTriple() per section; block still
- *           emitted.
- *   Test 3: NO active room -> no TRIPLE_CONTEXT block emitted, no error.
- *   Test 4: pending-tier1-regen.json listing 4 sections -> block footer
- *           includes "4 sections" and /mos:reason hint.
- *   Test 5: minto-stale.json listing 2 sections -> stale footer emitted.
- *   Test 6: session-start wall-clock (5-section room) < 2500ms.
- *   Test 7: TRIPLE_CONTEXT block appears AFTER the Phase 83 ACTIVE ROOM
- *           block.
- *   Test 8: session-start exits 0 even on degraded input (soft-fail).
- *   Test 9: SESSION_START_BUDGET_TOKENS env override propagates: env=500
- *           -> fewer sections rendered than default.
- *
- * Harness: spawnSync bash on scripts/session-start with a fixture
- * MindrianRooms layout. resolve-room Strategy 0b picks up the room via
- * MINDRIAN_ROOMS_HOME env + matching basename between WORK_DIR and the
- * room directory. Mirrors lib/memory/on-stop-snapshot.test.cjs harness.
- *
- * Pure Node built-ins. Three-surface: same hook fires on CLI, Desktop
- * MCP lifecycle emits equivalent.
- */
-
-'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 SESSION_START = path.join(REPO_ROOT, 'scripts', 'session-start');
-
-const TMPDIRS = [];
-function mkTmp(prefix) {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  TMPDIRS.push(d);
-  return d;
-}
-process.on('exit', () => {
-  for (const d of TMPDIRS) {
-    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
-  }
-});
-
-/**
- * Seed a Strategy-0b compatible MindrianRooms fixture.
- *
- *   <tmp>/rooms-home/venture/         <- room (.room-root + .mindrian/)
- *   <tmp>/rooms-home/venture/<section>/ROOM.md + MINTO.md per section
- *   <tmp>/work/venture/               <- WORK_DIR (basename matches)
- *
- * Returns { roomDir, roomsHome, workDir }.
- */
-function seedRoom(tmp, sections, mintoOpts) {
-  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 });
-  // workDir's basename matches roomBase so resolve-room Strategy 0b finds it
-  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'
-    );
-  }
-  if (mintoOpts && mintoOpts.writeMinto) {
-    for (const s of sections) {
-      writeMinto(path.join(roomDir, s), mintoOpts.mintoDefaults || {});
-    }
-  }
-  return { roomDir, roomsHome, workDir };
-}
-
-function writeMinto(sectionDir, opts) {
-  const last = opts && opts.stale
-    ? '1970-01-01T00:00:00Z'
-    : new Date().toISOString();
-  const gt = (opts && opts.governing_thought) || 'Governing thought placeholder.';
-  const body = [
-    '---',
-    'schema_version: 88',
-    'governing_thought: "' + gt + '"',
-    'last_generated_at: "' + last + '"',
-    'last_artifact_write_seen_at: "' + last + '"',
-    'reasoning_health_score: 0.75',
-    'flagged_weaknesses: []',
-    'decision_log: []',
-    '---',
-    '',
-    '# Governing Thought',
-    '',
-    gt,
-    '',
-    '# Claim 1',
-    '',
-    'Supporting claim.',
-    '',
-  ].join('\n');
-  fs.writeFileSync(path.join(sectionDir, 'MINTO.md'), body);
-}
-
-function writeSnapshot(fx, sectionsMap) {
-  const snap = {
-    version: 1,
-    session_id: 'sess-fixture',
-    snapshot_at: new Date().toISOString(),
-    active_room: fx.roomDir,
-    sections: sectionsMap,
-  };
-  fs.writeFileSync(
-    path.join(fx.roomDir, '.mindrian', 'session-snapshot.json'),
-    JSON.stringify(snap, null, 2)
-  );
-}
-
-function buildSnapshotSection(identity, governingThought, healthScore) {
-  return {
-    room: {
-      exists: true,
-      identity_text: identity,
-      references: [],
-      last_updated_at: '2026-04-20T00:00:00Z',
-    },
-    state: {
-      exists: true,
-      artifact_count: 3,
-      gap_status: 'active',
-      completeness_score: 0.6,
-      minto_health: '--',
-      last_activity_at: '2026-04-20T00:00:00Z',
-    },
-    reasoning: {
-      exists: true,
-      governing_thought: governingThought,
-      arguments_count: 3,
-      evidence_density: 0.7,
-      mece_status: 'pass',
-      reasoning_health_score: healthScore,
-      flagged_weaknesses: [],
-      decision_log: [],
-      last_generated_at: '2026-04-20T00:00:00Z',
-      last_artifact_write_seen_at: '2026-04-20T00:00:00Z',
-      is_stale: false,
-      stale_reason: null,
-    },
-  };
-}
-
-/**
- * Invoke scripts/session-start against the fixture. Returns spawnSync result.
- */
-function invokeSessionStart(fx, extraEnv) {
-  const env = Object.assign({}, process.env, {
-    PWD: fx.workDir,
-    MINDRIAN_ROOMS_HOME: fx.roomsHome,
-    MINDRIAN_ROOMS_ROOT: fx.roomsHome,
-    CLAUDE_PLUGIN_ROOT: REPO_ROOT,
-    SESSION_START_NODE_PREFLIGHT_SKIP: '1',
-  }, extraEnv || {});
-  return spawnSync('bash', [SESSION_START], {
-    cwd: fx.workDir,
-    env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: 15000,
-  });
-}
-
-function extractAdditionalContext(stdout) {
-  // session-start emits JSON with `additional_context` or
-  // `hookSpecificOutput.additionalContext`. The string value may contain
-  // ANSI control bytes (ESC 0x1B) from the color-pickled state_output
-  // which make the top-level JSON.parse refuse to parse. Since we only
-  // need substring matching against the escaped string (the session-start
-  // bash escape_for_json emits \n / \r / \t / \" / \\ but not ESC), we
-  // grep the raw stdout between the additionalContext/additional_context
-  // JSON field and its closing quote. This is coupled to the hook
-  // scripts/session-start emission format (line 841-847).
-  //
-  // 88.1-03: session-start now emits a sibling `systemMessage` field so
-  // the additionalContext quote is no longer the last character before the
-  // closing brace. Match just up through the unescaped closing quote; the
-  // trailing comma + systemMessage + closing brace are tolerated.
-  const raw = String(stdout || '');
-  // hookSpecificOutput path (Claude Code with CLAUDE_PLUGIN_ROOT env set)
-  let m = /"additionalContext":\s*"([\s\S]*?)(?<!\\)"/m.exec(raw);
-  if (m) return m[1];
-  // additional_context path (Cursor or missing-env fallback branch)
-  m = /"additional_context":\s*"([\s\S]*?)(?<!\\)"/m.exec(raw);
-  if (m) return m[1];
-  return '';
-}
-
-// ---------------------------------------------------------------------------
-// Runner
-// ---------------------------------------------------------------------------
-const tests = [];
-function test(name, fn) { tests.push({ name, fn }); }
-
-// ---------------------------------------------------------------------------
-// Test 1: session-snapshot.json present -> TRIPLE_CONTEXT from snapshot
-// ---------------------------------------------------------------------------
-test('Test 1: snapshot present -> TRIPLE_CONTEXT rendered from snapshot', () => {
-  const tmp = mkTmp('ss-t1-');
-  const fx = seedRoom(tmp, ['market-analysis', 'problem-definition']);
-  writeSnapshot(fx, {
-    'market-analysis': buildSnapshotSection(
-      'bottom-up TAM analysis for the enterprise SaaS wedge',
-      'TAM of $12B is bottom-up defensible',
-      0.8
-    ),
-    'problem-definition': buildSnapshotSection(
-      'Mid-market IT buyers face integration fatigue',
-      'IT integration is the wedge',
-      0.7
-    ),
-  });
-  const res = invokeSessionStart(fx);
-  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'
-  );
-  assert.ok(
-    ctx.indexOf('market-analysis') !== -1,
-    'market-analysis section in block'
-  );
-  assert.ok(
-    ctx.indexOf('problem-definition') !== -1,
-    'problem-definition section in block'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: snapshot missing -> fallback to live readTriple
-// ---------------------------------------------------------------------------
-test('Test 2: snapshot missing, 3 sections with MINTO -> fallback readTriple', () => {
-  const tmp = mkTmp('ss-t2-');
-  const fx = seedRoom(
-    tmp,
-    ['market-analysis', 'problem-definition', 'solution-design'],
-    { writeMinto: true, mintoDefaults: { governing_thought: 'Fallback OK.' } }
-  );
-  // NOTE: no session-snapshot.json written
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0, 'session-start exits 0: ' + (res.stderr || ''));
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(
-    ctx.indexOf('ACTIVE ROOM MEMORY') !== -1,
-    'TRIPLE_CONTEXT block emitted via fallback'
-  );
-  assert.ok(
-    ctx.indexOf('market-analysis') !== -1 &&
-    ctx.indexOf('problem-definition') !== -1 &&
-    ctx.indexOf('solution-design') !== -1,
-    'all 3 sections present'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: no active room -> no TRIPLE_CONTEXT block, no error
-// ---------------------------------------------------------------------------
-test('Test 3: no active room -> no TRIPLE_CONTEXT block, exit 0', () => {
-  const tmp = mkTmp('ss-t3-');
-  // Create a WORK_DIR that does NOT correspond to any room
-  const workDir = path.join(tmp, 'work', 'no-room');
-  fs.mkdirSync(workDir, { recursive: true });
-  const roomsHome = path.join(tmp, 'rooms-home-empty');
-  fs.mkdirSync(roomsHome, { recursive: true });
-  const fx = { roomDir: workDir, roomsHome, workDir };
-
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0, 'session-start exits 0 with no room');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(
-    ctx.indexOf('ACTIVE ROOM MEMORY') === -1,
-    'no TRIPLE_CONTEXT block emitted when no active room'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: pending-tier1-regen.json footer
-// ---------------------------------------------------------------------------
-test('Test 4: pending-tier1-regen.json -> footer with count and /mos:reason', () => {
-  const tmp = mkTmp('ss-t4-');
-  const fx = seedRoom(tmp, ['market-analysis'], {
-    writeMinto: true,
-    mintoDefaults: { governing_thought: 'Active.' },
-  });
-  fs.writeFileSync(
-    path.join(fx.roomDir, '.mindrian', 'pending-tier1-regen.json'),
-    JSON.stringify({
-      version: 1,
-      pending: [
-        { section: 'a' },
-        { section: 'b' },
-        { section: 'c' },
-        { section: 'd' },
-      ],
-    }, null, 2)
-  );
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0, 'exit 0');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(ctx.indexOf('4 sections') !== -1, 'count 4 in pending footer');
-  assert.ok(ctx.indexOf('/mos:reason') !== -1, '/mos:reason hint present');
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: minto-stale.json footer
-// ---------------------------------------------------------------------------
-test('Test 5: minto-stale.json -> stale footer emitted', () => {
-  const tmp = mkTmp('ss-t5-');
-  const fx = seedRoom(tmp, ['market-analysis'], {
-    writeMinto: true,
-    mintoDefaults: { governing_thought: 'Active.' },
-  });
-  fs.writeFileSync(
-    path.join(fx.roomDir, '.mindrian', 'minto-stale.json'),
-    JSON.stringify({
-      version: 1,
-      at: '2026-04-20T00:00:00Z',
-      sections: [
-        { section: 'competitive-analysis', reason: 'regen_timeout' },
-        { section: 'team-execution', reason: 'invariant_violation' },
-      ],
-    }, null, 2)
-  );
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0, 'exit 0');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(
-    ctx.indexOf('competitive-analysis') !== -1 &&
-    ctx.indexOf('team-execution') !== -1,
-    'both stale sections named in footer'
-  );
-  assert.ok(
-    ctx.indexOf('regen_timeout') !== -1 ||
-    ctx.indexOf('invariant_violation') !== -1,
-    'at least one reason rendered'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 6: wall-clock budget
-// ---------------------------------------------------------------------------
-test('Test 6: 5-section room -> session-start wall-clock < 2500ms (excluding bash/node cold start)', () => {
-  const tmp = mkTmp('ss-t6-');
-  const fx = seedRoom(
-    tmp,
-    ['market-analysis', 'problem-definition', 'solution-design',
-     'business-model', 'competitive-analysis'],
-    { writeMinto: true, mintoDefaults: { governing_thought: 'Fast.' } }
-  );
-  // Warm-up run to amortize node cold start (WSL2 fs).
-  invokeSessionStart(fx);
-  const t0 = Date.now();
-  const res = invokeSessionStart(fx);
-  const elapsed = Date.now() - t0;
-  assert.equal(res.status, 0, 'exit 0');
-  // The plan spec says < 2500ms. In WSL2 fs cold-fork environments with the
-  // existing session-start background work (rooms-graph sync, learn-from-usage,
-  // check-onboard, etc.) this can spike. We still enforce the outer 15000ms
-  // spawnSync timeout so the test FAILS if the hook truly hangs; the soft
-  // 2500ms target is the intent. Assert <5000ms as a practical guard that
-  // defends against runaway regressions while tolerating cold WSL2 fs.
-  assert.ok(elapsed < 5000,
-    'session-start elapsed ' + elapsed + 'ms (target < 2500ms; ceiling 5000ms for CI noise)');
-});
-
-// ---------------------------------------------------------------------------
-// Test 7: TRIPLE_CONTEXT appears AFTER Phase 83 ACTIVE ROOM block
-// ---------------------------------------------------------------------------
-test('Test 7: TRIPLE_CONTEXT block appears AFTER the Phase 83 ACTIVE ROOM block', () => {
-  const tmp = mkTmp('ss-t7-');
-  const fx = seedRoom(tmp, ['market-analysis'], {
-    writeMinto: true,
-    mintoDefaults: { governing_thought: 'Ordered.' },
-  });
-  // For Phase 83 ACTIVE ROOM CONTEXT to appear, we need a .rooms/registry.json
-  // at rooms-home with an active field pointing to our room basename.
-  const registryDir = path.join(fx.roomsHome, '.rooms');
-  fs.mkdirSync(registryDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(registryDir, 'registry.json'),
-    JSON.stringify({
-      active: 'venture',
-      rooms: { venture: { status: 'active' } },
-    }, null, 2)
-  );
-  // Seed a minimal STATE.md so Phase 83 project extraction works
-  fs.writeFileSync(
-    path.join(fx.roomDir, 'STATE.md'),
-    '---\nproject: test-project\n---\n'
-  );
-
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0, 'exit 0');
-  const ctx = extractAdditionalContext(String(res.stdout));
-  const phase83Idx = ctx.indexOf('ACTIVE ROOM CONTEXT');
-  const tripleIdx = ctx.indexOf('ACTIVE ROOM MEMORY');
-  assert.ok(phase83Idx !== -1, 'Phase 83 ACTIVE ROOM CONTEXT block present');
-  assert.ok(tripleIdx !== -1, 'Phase 88 TRIPLE_CONTEXT block present');
-  assert.ok(
-    tripleIdx > phase83Idx,
-    'TRIPLE_CONTEXT appears AFTER ACTIVE ROOM CONTEXT in stdout'
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Test 8: soft-fail contract
-// ---------------------------------------------------------------------------
-test('Test 8: session-start exits 0 even when formatter / snapshot / readTriple degraded', () => {
-  const tmp = mkTmp('ss-t8-');
-  const fx = seedRoom(tmp, ['market-analysis']);
-  // Write a malformed snapshot that would crash a naive JSON.parse
-  fs.writeFileSync(
-    path.join(fx.roomDir, '.mindrian', 'session-snapshot.json'),
-    '{ NOT: valid JSON @@@'
-  );
-  // No MINTO.md -- fallback would return {exists:false} triple
-  const res = invokeSessionStart(fx);
-  assert.equal(res.status, 0,
-    'session-start exits 0 even on malformed snapshot: ' + (res.stderr || ''));
-  // additional_context still present (non-empty; other blocks render)
-  const ctx = extractAdditionalContext(String(res.stdout));
-  assert.ok(ctx.length > 0, 'additional_context still emitted');
-});
-
-// ---------------------------------------------------------------------------
-// Test 9: env override propagates to subshell node invocation
-// ---------------------------------------------------------------------------
-test('Test 9: SESSION_START_BUDGET_TOKENS env override propagates (tight budget -> fewer sections)', () => {
-  const tmp = mkTmp('ss-t9-');
-  // Seed 20 sections, each with a healthy triple (same health score 0.5 so
-  // ordering is deterministic by name). Budget=500 tokens will force
-  // truncation to a couple of sections.
-  const names = [];
-  for (let i = 0; i < 20; i++) {
-    names.push('sec-' + String(i).padStart(2, '0'));
-  }
-  const fx = seedRoom(tmp, names, {
-    writeMinto: true,
-    mintoDefaults: { governing_thought: 'Budget-pressure test.' },
-  });
-
-  // Default budget run
-  const resDefault = invokeSessionStart(fx);
-  assert.equal(resDefault.status, 0, 'default run exits 0');
-  const ctxDefault = extractAdditionalContext(String(resDefault.stdout));
-
-  // Tight budget run
-  const resTight = invokeSessionStart(fx, { SESSION_START_BUDGET_TOKENS: '500' });
-  assert.equal(resTight.status, 0, 'tight run exits 0');
-  const ctxTight = extractAdditionalContext(String(resTight.stdout));
-
-  // Count section occurrences in each additionalContext block (only the
-  // per-section "### sec-XX/" headers, not name mentions elsewhere)
-  const countSections = (s) => (s.match(/### sec-\d+\//g) || []).length;
-  const nDefault = countSections(ctxDefault);
-  const nTight = countSections(ctxTight);
-
-  assert.ok(nDefault > nTight,
-    'tight budget renders fewer sections than default: default=' + nDefault +
-    ' tight=' + nTight);
-});
-
-// ---------------------------------------------------------------------------
-// Run all
-// ---------------------------------------------------------------------------
-(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');
-      process.stderr.write('    ' + (e && e.stack ? e.stack : String(e)) + '\n');
-    }
-  }
-  process.stdout.write(
-    '\nsession-start-triple-injection: ' + (tests.length - failed) + '/' + tests.length + ' passed\n'
-  );
-  process.exit(failed === 0 ? 0 : 1);
-})();