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

package/lib/memory/triple-context-formatter.test.cjs

@@ -1,442 +0,0 @@
-#!/usr/bin/env node
-/*
- * Copyright (c) 2026 Mindrian. BSL 1.1.
- *
- * Phase 88-07 Task 1 -- triple-context-formatter tests
- * =====================================================
- * Pure unit tests for the TRIPLE_CONTEXT formatter.
- *
- * Test map (12 cases, aligned with PLAN <behavior>):
- *
- *   Test 1:  3-section input, all healthy -> formatter emits one block per
- *            section with Identity, References, State, Reasoning, Decision
- *            log lines.
- *   Test 2:  Section with empty decision_log -> "Decision log:" header
- *            omitted (don't show empty list).
- *   Test 3:  Section with 21 decision_log entries -> render only the latest
- *            3, footer "[+18 older]".
- *   Test 4:  Section with null governing_thought -> Reasoning line reads
- *            `governing thought: (not yet generated)`.
- *   Test 5:  References rendering: 5 items -> 5 wikilinks space-separated;
- *            > 5 -> first 5 then `[+N more]`.
- *   Test 6:  Budget cap (weakest-first): 30 sections @ 1k tokens -> truncate
- *            at MAX_BUDGET_TOKENS; append "N strongest sections elided"
- *            footer. Sort ascending by reasoning_health_score.
- *   Test 6b: reasoning_health_score === null is sorted FIRST (treated as
- *            weakest / highest-priority-to-surface). A section with null
- *            score appears BEFORE a section with score=0.1.
- *   Test 7:  Token estimation uses Math.ceil((body || '').length / 4)
- *            consistently; total emitted length / 4 <= MAX_BUDGET_TOKENS.
- *   Test 8:  Stale sections: is_stale:true -> annotate in the State line
- *            `MINTO health (warn) (stale: <stale_reason>)`.
- *   Test 9:  pending-tier1-regen.json with 4 sections -> footer includes
- *            that count and the /mos:reason hint.
- *   Test 10: Zero sections -> formatter returns empty string (no block
- *            emitted; session-start falls through to existing behavior).
- *   Test 11: SESSION_START_BUDGET_TOKENS env override: env=3000 -> cap=3000;
- *            env="abc" -> default; env unset -> default.
- *   Test 12: Baseline measurement recorded in SUMMARY.md. Automated check:
- *            grep -c "baseline.*tokens\|measured.*session-start" SUMMARY >=1.
- *
- * Registered in lib/memory/run-feynman-tests.cjs.
- * Pure unit tests. Zero fs mutation. No child processes.
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const REPO = path.resolve(__dirname, '..', '..');
-const FORMATTER_PATH = path.join(REPO, 'lib/memory/triple-context-formatter.cjs');
-
-// ---------------------------------------------------------------------------
-// Runner
-// ---------------------------------------------------------------------------
-const tests = [];
-function test(name, fn) { tests.push({ name, fn }); }
-
-// ---------------------------------------------------------------------------
-// Fixture helpers
-// ---------------------------------------------------------------------------
-function healthySection(overrides) {
-  const o = overrides || {};
-  return {
-    room: {
-      exists: true,
-      identity_text: o.identity_text || 'Bottom-up TAM analysis for the enterprise SaaS wedge',
-      references: o.references || [
-        { target: 'financial-model/tam-bottom-up', type: 'artifact', label: 'financial-model/tam-bottom-up' },
-        { target: 'competitive-analysis/first-mover', type: 'artifact', label: 'competitive-analysis/first-mover' }
-      ],
-      last_updated_at: o.last_updated_at || '2026-04-18T00:00:00Z',
-    },
-    state: {
-      exists: true,
-      artifact_count: o.artifact_count !== undefined ? o.artifact_count : 7,
-      gap_status: o.gap_status || 'active',
-      completeness_score: o.completeness_score !== undefined ? o.completeness_score : 0.85,
-      minto_health: '--',
-      last_activity_at: o.last_activity_at || '2026-04-18T00:00:00Z',
-    },
-    reasoning: {
-      exists: true,
-      governing_thought: o.governing_thought !== undefined
-        ? o.governing_thought
-        : 'TAM of $12B is bottom-up defensible',
-      arguments_count: o.arguments_count !== undefined ? o.arguments_count : 3,
-      evidence_density: o.evidence_density !== undefined ? o.evidence_density : 0.9,
-      mece_status: o.mece_status || 'pass',
-      reasoning_health_score: o.reasoning_health_score !== undefined ? o.reasoning_health_score : 0.8,
-      flagged_weaknesses: o.flagged_weaknesses || [],
-      decision_log: o.decision_log || [],
-      last_generated_at: o.last_generated_at || '2026-04-18T00:00:00Z',
-      last_artifact_write_seen_at: o.last_artifact_write_seen_at || '2026-04-18T00:00:00Z',
-      is_stale: o.is_stale !== undefined ? o.is_stale : false,
-      stale_reason: o.stale_reason !== undefined ? o.stale_reason : null,
-    },
-  };
-}
-
-function mkDecision(i) {
-  return {
-    session_id: 'sess-' + String(i),
-    timestamp: '2026-04-' + String((i % 28) + 1).padStart(2, '0') + 'T12:00:00Z',
-    action: 'flag_tam_staleness',
-    user_response: i % 2 === 0 ? 'approve' : 'defer',
-    reason: 'reason ' + String(i),
-    outcome: 'outcome ' + String(i),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Test 1: 3-section healthy input -> block has all lines per section
-// ---------------------------------------------------------------------------
-test('Test 1: 3-section input emits one block per section with required lines', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'market-analysis': healthySection({
-      identity_text: 'bottom-up TAM analysis for enterprise SaaS wedge',
-      governing_thought: 'TAM of $12B is bottom-up defensible',
-    }),
-    'problem-definition': healthySection({
-      identity_text: 'Mid-market IT buyers face integration fatigue',
-      governing_thought: 'IT integration is the wedge',
-    }),
-    'solution-design': healthySection({
-      identity_text: 'API-first middleware layer',
-      governing_thought: 'API middleware unblocks integration',
-    }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(out.length > 0, 'output non-empty');
-  assert.ok(out.indexOf('## ACTIVE ROOM MEMORY') !== -1, 'header present');
-  assert.ok(out.indexOf('### market-analysis/') !== -1, 'market-analysis section header');
-  assert.ok(out.indexOf('### problem-definition/') !== -1, 'problem-definition section header');
-  assert.ok(out.indexOf('### solution-design/') !== -1, 'solution-design section header');
-  // Each section has Identity / References / State / Reasoning lines
-  assert.ok(out.indexOf('Identity:') !== -1, 'Identity line');
-  assert.ok(out.indexOf('References:') !== -1, 'References line');
-  assert.ok(out.indexOf('State:') !== -1, 'State line');
-  assert.ok(out.indexOf('Reasoning:') !== -1, 'Reasoning line');
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: Empty decision_log -> "Decision log:" header omitted
-// ---------------------------------------------------------------------------
-test('Test 2: empty decision_log -> "Decision log:" header omitted', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'market-analysis': healthySection({ decision_log: [] }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(out.indexOf('Decision log:') === -1,
-    'Decision log header must NOT appear when empty');
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: 21 entries -> render only latest 3 with "[+18 older]" footer
-// ---------------------------------------------------------------------------
-test('Test 3: 21 decision_log entries -> render only latest 3 with +18 older footer', () => {
-  const fmt = require(FORMATTER_PATH);
-  const decisions = [];
-  for (let i = 0; i < 21; i++) decisions.push(mkDecision(i));
-  const sections = {
-    'market-analysis': healthySection({ decision_log: decisions }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(out.indexOf('Decision log:') !== -1, 'Decision log header present');
-  // latest 3 = indices 18, 19, 20 (end of array is latest by write order)
-  assert.ok(out.indexOf('reason 18') !== -1, 'latest-3 entry 18 rendered');
-  assert.ok(out.indexOf('reason 19') !== -1, 'latest-3 entry 19 rendered');
-  assert.ok(out.indexOf('reason 20') !== -1, 'latest-3 entry 20 rendered');
-  // earlier entries NOT rendered
-  assert.ok(out.indexOf('reason 0\n') === -1 && out.indexOf('reason 0 ') === -1 && out.indexOf('reason 0,') === -1,
-    'earliest entry NOT rendered');
-  // overflow footer present
-  assert.ok(out.indexOf('[+18 older]') !== -1, '+18 older footer present');
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: null governing_thought -> "(not yet generated)"
-// ---------------------------------------------------------------------------
-test('Test 4: null governing_thought -> Reasoning line reads (not yet generated)', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'market-analysis': healthySection({ governing_thought: null }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(out.indexOf('(not yet generated)') !== -1,
-    '(not yet generated) placeholder present');
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: References rendering -- 5 items = all; > 5 = first 5 + [+N more]
-// ---------------------------------------------------------------------------
-test('Test 5: 5 references render fully; > 5 show first 5 + [+N more]', () => {
-  const fmt = require(FORMATTER_PATH);
-  // Case A: exactly 5 references render fully (no overflow marker)
-  const sections5 = {
-    'market-analysis': healthySection({
-      references: [
-        { target: 'a', type: 'section', label: 'a' },
-        { target: 'b', type: 'section', label: 'b' },
-        { target: 'c', type: 'section', label: 'c' },
-        { target: 'd', type: 'section', label: 'd' },
-        { target: 'e', type: 'section', label: 'e' },
-      ],
-    }),
-  };
-  const out5 = fmt.formatTripleContext({ sections: sections5 });
-  assert.ok(out5.indexOf('[[a]]') !== -1, 'ref a rendered');
-  assert.ok(out5.indexOf('[[e]]') !== -1, 'ref e rendered');
-  assert.ok(out5.indexOf('[+') === -1 || out5.indexOf('[+0 more]') !== -1,
-    'no overflow marker for exactly 5 refs');
-
-  // Case B: 8 references -> first 5 + [+3 more]
-  const sections8 = {
-    'market-analysis': healthySection({
-      references: [
-        { target: 'r1', type: 'section', label: 'r1' },
-        { target: 'r2', type: 'section', label: 'r2' },
-        { target: 'r3', type: 'section', label: 'r3' },
-        { target: 'r4', type: 'section', label: 'r4' },
-        { target: 'r5', type: 'section', label: 'r5' },
-        { target: 'r6', type: 'section', label: 'r6' },
-        { target: 'r7', type: 'section', label: 'r7' },
-        { target: 'r8', type: 'section', label: 'r8' },
-      ],
-    }),
-  };
-  const out8 = fmt.formatTripleContext({ sections: sections8 });
-  assert.ok(out8.indexOf('[[r1]]') !== -1, 'r1 rendered');
-  assert.ok(out8.indexOf('[[r5]]') !== -1, 'r5 rendered');
-  assert.ok(out8.indexOf('[[r6]]') === -1, 'r6 NOT rendered');
-  assert.ok(out8.indexOf('[+3 more]') !== -1, '+3 more footer present');
-});
-
-// ---------------------------------------------------------------------------
-// Test 6: Budget cap + weakest-first elision
-// ---------------------------------------------------------------------------
-test('Test 6: budget cap truncates weakest-first with strongest-elided footer', () => {
-  const fmt = require(FORMATTER_PATH);
-  // 30 sections, varying health scores 0.01..0.30 (1/100ths apart)
-  // Each has a fat payload so any 5-6 of them blow the default 5000-token cap.
-  const sections = {};
-  const fatIdentity = 'identity text '.repeat(200); // ~2800 chars per section
-  const fatThought = 'governing thought '.repeat(50);
-  for (let i = 0; i < 30; i++) {
-    const score = (i + 1) / 100; // 0.01, 0.02, ... 0.30
-    sections['section-' + String(i).padStart(2, '0')] = healthySection({
-      identity_text: fatIdentity,
-      governing_thought: fatThought,
-      reasoning_health_score: score,
-      references: [{ target: 't' + i, type: 'section', label: 't' + i }],
-    });
-  }
-  // Ensure default cap
-  delete process.env.SESSION_START_BUDGET_TOKENS;
-  const cap = fmt.getBudgetTokens();
-
-  const out = fmt.formatTripleContext({ sections });
-  // Total emitted tokens must be <= budget cap
-  const tokens = fmt.estimateTokens(out);
-  assert.ok(tokens <= cap,
-    'emitted ' + tokens + ' tokens <= cap ' + cap);
-
-  // Weakest-first: section-00 (score 0.01) must appear BEFORE section-29 (0.30)
-  // If both were emitted, 00 appears earlier in the string; if not both,
-  // weakest (00) must be present and strongest (29) must be elided.
-  const idx00 = out.indexOf('### section-00/');
-  const idx29 = out.indexOf('### section-29/');
-  assert.ok(idx00 !== -1, 'weakest (section-00) present');
-  if (idx29 !== -1) {
-    assert.ok(idx00 < idx29, 'weakest appears before strongest');
-  }
-
-  // Elision footer present
-  assert.ok(/\[\+\d+ strongest sections elided/.test(out) ||
-           out.indexOf('strongest sections elided for budget') !== -1,
-    'elision footer present (format: "N strongest sections elided for budget")');
-});
-
-// ---------------------------------------------------------------------------
-// Test 6b: null reasoning_health_score sorts FIRST (weakest)
-// ---------------------------------------------------------------------------
-test('Test 6b: null reasoning_health_score sorted FIRST (before score=0.1)', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'score-01': healthySection({ reasoning_health_score: 0.1 }),
-    'score-null': healthySection({ reasoning_health_score: null }),
-    'score-09': healthySection({ reasoning_health_score: 0.9 }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  const idxNull = out.indexOf('### score-null/');
-  const idx01 = out.indexOf('### score-01/');
-  const idx09 = out.indexOf('### score-09/');
-  assert.ok(idxNull !== -1 && idx01 !== -1 && idx09 !== -1, 'all sections present');
-  assert.ok(idxNull < idx01, 'null score appears BEFORE score=0.1');
-  assert.ok(idx01 < idx09, 'score=0.1 appears BEFORE score=0.9');
-});
-
-// ---------------------------------------------------------------------------
-// Test 7: Token estimation consistency
-// ---------------------------------------------------------------------------
-test('Test 7: estimateTokens uses Math.ceil(length/4) and total <= cap', () => {
-  const fmt = require(FORMATTER_PATH);
-  // Known inputs
-  assert.equal(fmt.estimateTokens(''), 0, 'empty -> 0 tokens');
-  assert.equal(fmt.estimateTokens('abcd'), 1, '4 chars -> 1 token');
-  assert.equal(fmt.estimateTokens('abcde'), 2, '5 chars -> 2 tokens (ceil)');
-  assert.equal(fmt.estimateTokens(null), 0, 'null -> 0 tokens');
-  assert.equal(fmt.estimateTokens(undefined), 0, 'undefined -> 0 tokens');
-
-  // Formatted output always within cap
-  delete process.env.SESSION_START_BUDGET_TOKENS;
-  const cap = fmt.getBudgetTokens();
-  const sections = {};
-  for (let i = 0; i < 10; i++) {
-    sections['s' + i] = healthySection({ reasoning_health_score: i / 10 });
-  }
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(fmt.estimateTokens(out) <= cap,
-    'total tokens <= cap (' + fmt.estimateTokens(out) + ' <= ' + cap + ')');
-});
-
-// ---------------------------------------------------------------------------
-// Test 8: Stale annotation on State line
-// ---------------------------------------------------------------------------
-test('Test 8: is_stale:true -> State line annotated with stale_reason', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'market-analysis': healthySection({
-      is_stale: true,
-      stale_reason: 'artifacts_newer_than_minto',
-    }),
-  };
-  const out = fmt.formatTripleContext({ sections });
-  assert.ok(out.indexOf('stale: artifacts_newer_than_minto') !== -1,
-    'stale reason annotated on State line');
-});
-
-// ---------------------------------------------------------------------------
-// Test 9: pending-tier1-regen footer
-// ---------------------------------------------------------------------------
-test('Test 9: pendingTier1 with 4 sections -> footer with count and /mos:reason hint', () => {
-  const fmt = require(FORMATTER_PATH);
-  const sections = {
-    'market-analysis': healthySection(),
-  };
-  const out = fmt.formatTripleContext({
-    sections,
-    pendingTier1: [
-      { section: 'a' }, { section: 'b' }, { section: 'c' }, { section: 'd' },
-    ],
-  });
-  assert.ok(out.indexOf('4 sections') !== -1, 'count of 4 in footer');
-  assert.ok(out.indexOf('tier-0') !== -1 || out.indexOf('tier 0') !== -1 || out.indexOf('tier-1') !== -1,
-    'tier-0 / tier-1 language in footer');
-  assert.ok(out.indexOf('/mos:reason') !== -1, '/mos:reason hint present');
-});
-
-// ---------------------------------------------------------------------------
-// Test 10: Zero sections -> empty string
-// ---------------------------------------------------------------------------
-test('Test 10: zero sections -> empty string', () => {
-  const fmt = require(FORMATTER_PATH);
-  assert.equal(fmt.formatTripleContext({ sections: {} }), '',
-    'empty sections returns empty string');
-  assert.equal(fmt.formatTripleContext({ sections: null }), '',
-    'null sections returns empty string');
-  assert.equal(fmt.formatTripleContext({}), '',
-    'missing sections returns empty string');
-});
-
-// ---------------------------------------------------------------------------
-// Test 11: SESSION_START_BUDGET_TOKENS env override
-// ---------------------------------------------------------------------------
-test('Test 11: SESSION_START_BUDGET_TOKENS env override behavior', () => {
-  const fmt = require(FORMATTER_PATH);
-  const DEFAULT = fmt.DEFAULT_BUDGET_TOKENS;
-
-  // Set to a valid number -> cap = that number
-  process.env.SESSION_START_BUDGET_TOKENS = '3000';
-  assert.equal(fmt.getBudgetTokens(), 3000, 'env=3000 -> cap=3000');
-
-  // Set to garbage -> fallback to default
-  process.env.SESSION_START_BUDGET_TOKENS = 'abc';
-  assert.equal(fmt.getBudgetTokens(), DEFAULT, 'env=abc -> fallback to DEFAULT');
-
-  // Set to 0 -> fallback to default (invalid, must be > 0)
-  process.env.SESSION_START_BUDGET_TOKENS = '0';
-  assert.equal(fmt.getBudgetTokens(), DEFAULT, 'env=0 -> fallback to DEFAULT');
-
-  // Set to negative -> fallback
-  process.env.SESSION_START_BUDGET_TOKENS = '-100';
-  assert.equal(fmt.getBudgetTokens(), DEFAULT, 'env=-100 -> fallback to DEFAULT');
-
-  // Unset -> default
-  delete process.env.SESSION_START_BUDGET_TOKENS;
-  assert.equal(fmt.getBudgetTokens(), DEFAULT, 'env unset -> DEFAULT');
-});
-
-// ---------------------------------------------------------------------------
-// Test 12: Baseline measurement recorded in SUMMARY.md
-// ---------------------------------------------------------------------------
-test('Test 12: baseline session-start emission recorded in 88-07-SUMMARY.md', () => {
-  const summaryPath = path.join(
-    REPO,
-    '.planning',
-    'phases',
-    '88-feynman-minto-memory-layer',
-    '88-07-SUMMARY.md'
-  );
-  assert.ok(fs.existsSync(summaryPath),
-    'SUMMARY.md must exist at ' + summaryPath);
-  const body = fs.readFileSync(summaryPath, 'utf8');
-  const hit = /baseline.*tokens|measured.*session-start/i.test(body);
-  assert.ok(hit,
-    'SUMMARY.md must contain baseline-tokens or measured-session-start phrasing');
-});
-
-// ---------------------------------------------------------------------------
-// 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(
-    '\ntriple-context-formatter: ' + (tests.length - failed) + '/' + tests.length + ' passed\n'
-  );
-  process.exit(failed === 0 ? 0 : 1);
-})();