@mindrian_os/install 1.13.0-beta.11

package/lib/memory/sessionstart-banner-formatter.cjs

@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 88.1-06 -- SessionStart MINTO banner formatter
+ * =====================================================
+ * Pure formatter for the 4-line MINTO banner that scripts/session-start
+ * emits at the top of every session boundary. Gives the navigator an
+ * immediate re-entry snapshot: brand + version + active-room + top-3
+ * most-recently-active sections with Canon Part 2 health glyph + truncated
+ * governing_thought.
+ *
+ * Banner shape (4 structural lines + N <= 3 section sublines):
+ *
+ *   MindrianOS v1.10.15
+ *   Room: ${room_slug}
+ *   Focus (top 3 recently-active sections):
+ *     ${glyph1} ${section1}: "${gt1_truncated}"
+ *     ${glyph2} ${section2}: "${gt2_truncated}"
+ *     ${glyph3} ${section3}: "${gt3_truncated}"
+ *
+ * Canon references:
+ *   Part 1  Wicked Navigator -- banner is the re-entry affordance. Surface
+ *           L4 at the session boundary.
+ *   Part 2  UI glyph vocabulary -- check / warn / low / --. Byte-identical
+ *           with lib/core/statusline-cache.cjs (Plan 88.1-04) and
+ *           lib/memory/triple-context-formatter.cjs (Phase 88-07). Shared
+ *           classifyHealth via helpers.
+ *   Part 3  Tri-Context Decision Gate -- banner compresses the LOCAL
+ *           context BEFORE the full TRIPLE_CONTEXT per-section block.
+ *           Order: Phase 83 ACTIVE ROOM CONTEXT -> this banner -> Phase
+ *           88-07 TRIPLE_CONTEXT -> Phase 88-05 drain / Phase 88-13
+ *           guardian.
+ *   Part 8  Graph Boundary -- pure formatter. Zero fs reads inside the
+ *           render path (caller supplies triples). readPluginVersion reads
+ *           only .claude-plugin/plugin.json (local, LOCAL-only by
+ *           construction). Zero Brain / fetch / external endpoint
+ *           references.
+ *
+ * Reuse contract (from Plan 88.1-04):
+ *   - classifyHealth from lib/core/statusline-cache.cjs.
+ *   - truncateGoverningThought from lib/core/statusline-cache.cjs
+ *     (60-char budget; banner sacrifices detail for density; matches
+ *     statusline and is tighter than /mos:status 80-char budget).
+ *
+ * Budget integration with Phase 88-07:
+ *   - Phase 88-07 formatter uses SESSION_START_BUDGET_TOKENS, default 5000.
+ *   - Banner is ADDITIONAL and adds < 200 tokens when all 3 rows render.
+ *   - Under tight budget, banner drops rows in reverse order (last -> first)
+ *     until the remaining content fits.
+ *   - Banner goes FIRST in additionalContext; TRIPLE_CONTEXT follows.
+ *
+ * Top-3 selection algorithm:
+ *   Caller supplies a triples object keyed by section slug. Each triple
+ *   MAY carry reasoning._mtime (the effective "recent activity" timestamp
+ *   the caller computed: max of section_root_mtime, MINTO.md mtime, most-
+ *   recent artifact mtime). Caller owns fs reads (Part 8 keeps the
+ *   formatter pure); formatter owns the selection + rendering.
+ *
+ * Pure CJS, node built-ins only, zero npm dependencies. Three-surface
+ * compatible by construction (CLI + Desktop MCP + Cowork).
+ *
+ * API:
+ *   formatBanner({ roomRoot, roomSlug, triples, version, budget }) -> string
+ *   readPluginVersion(pluginRoot) -> string
+ *   classifyHealth(score)          -> 'check'|'warn'|'low'|'--'   (re-export)
+ *   truncateGoverningThought(str)  -> string                       (re-export)
+ *   estimateTokens(str)            -> number
+ *   BANNER_RESERVE_TOKENS          -> number
+ *
+ * License: BSL 1.1.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Reuse Plan 88.1-04 helpers. Byte-identical classifier + truncator keeps
+// the banner glyph and governing_thought rendering in lock-step with the
+// statusline and /mos:status surfaces. If the cache module is unavailable
+// (degraded install), the formatter still works via an inline fallback.
+let statuslineCache = null;
+try {
+  statuslineCache = require('../core/statusline-cache.cjs');
+} catch (_e) {
+  statuslineCache = null;
+}
+
+// ---------- Tunables ----------
+
+// Target maximum tokens the banner itself consumes when all 3 rows render.
+// Banner is ADDITIVE to Phase 88-07's TRIPLE_CONTEXT block. Under tight
+// budget we drop rows instead of starving the downstream block.
+const BANNER_RESERVE_TOKENS = 200;
+
+// 60-char governing_thought budget for banner rows (tighter than
+// /mos:status 80-char, matches statusline 60-char). Fallback constant
+// when statusline-cache module is unavailable.
+const GOVERNING_THOUGHT_BUDGET_FALLBACK = 60;
+
+// Per-row prompt-format overhead. The char-count-over-4 estimator only
+// accounts for the visible row text; when Claude Code injects the banner
+// into additionalContext the row carries additional envelope cost
+// (JSON-string escaping, newline prefixes, downstream formatter
+// accounting). We charge every row this flat overhead so the caller's
+// budget parameter has stable semantics: budget >= ~240 -> 3 rows fit,
+// budget ~200 -> 2 rows fit, budget <= ~80 -> 0 rows fit. Matches the
+// PLAN budget-cascade contract (200 -> 2 rows, 50 -> 0 rows).
+const ROW_OVERHEAD_TOKENS = 60;
+
+// ---------- Shared helpers (with fallback when cache module missing) ----
+
+function classifyHealth(score) {
+  if (statuslineCache && typeof statuslineCache.classifyHealth === 'function') {
+    return statuslineCache.classifyHealth(score);
+  }
+  if (typeof score !== 'number' || !Number.isFinite(score)) return '--';
+  if (score >= 0.7) return 'check';
+  if (score >= 0.4) return 'warn';
+  return 'low';
+}
+
+function truncateGoverningThought(str) {
+  if (statuslineCache && typeof statuslineCache.truncateGoverningThought === 'function') {
+    return statuslineCache.truncateGoverningThought(str);
+  }
+  if (typeof str !== 'string') return '';
+  if (str.length <= GOVERNING_THOUGHT_BUDGET_FALLBACK) return str;
+  return str.slice(0, GOVERNING_THOUGHT_BUDGET_FALLBACK - 1) + '\u2026';
+}
+
+// Rough token estimator: chars / 4, rounded up. Matches the estimator in
+// lib/memory/triple-context-formatter.cjs so banner + TRIPLE_CONTEXT agree
+// on token accounting.
+function estimateTokens(str) {
+  if (!str) return 0;
+  const s = typeof str === 'string' ? str : String(str);
+  return Math.ceil(s.length / 4);
+}
+
+// ---------- Version read (dynamic; no hardcoded drift) ---------------------
+
+/**
+ * readPluginVersion(pluginRoot) -> string
+ *
+ * Reads .claude-plugin/plugin.json and returns the version string. Never
+ * throws. Returns 'unknown' on any error (file missing, JSON malformed,
+ * version field absent). Caller supplies this into formatBanner so the
+ * brand line tracks the actual installed version with zero drift on
+ * release.
+ */
+function readPluginVersion(pluginRoot) {
+  if (!pluginRoot || typeof pluginRoot !== 'string') return 'unknown';
+  const p = path.join(pluginRoot, '.claude-plugin', 'plugin.json');
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.version === 'string' && parsed.version) {
+      return parsed.version;
+    }
+    return 'unknown';
+  } catch (_e) {
+    return 'unknown';
+  }
+}
+
+// ---------- Top-3 selection ------------------------------------------------
+
+/**
+ * Sort section keys by reasoning._mtime descending (most-recently-active
+ * first). Missing / non-numeric mtimes sort LAST (least recent). Ties
+ * broken by section name ascending for determinism across runs.
+ */
+function sortKeysMostRecentFirst(triples) {
+  const keys = Object.keys(triples || {});
+  return keys.sort(function (a, b) {
+    const ta = triples[a] && triples[a].reasoning && triples[a].reasoning._mtime;
+    const tb = triples[b] && triples[b].reasoning && triples[b].reasoning._mtime;
+    const na = (typeof ta === 'number' && Number.isFinite(ta)) ? ta : -1;
+    const nb = (typeof tb === 'number' && Number.isFinite(tb)) ? tb : -1;
+    if (na !== nb) return nb - na;
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+}
+
+// ---------- Row rendering --------------------------------------------------
+
+/**
+ * Build a single section subline:
+ *   "  {glyph} {section}: \"{governing_thought}\" [(stale: reason)]"
+ *
+ * Empty / missing governing_thought -> "(no MINTO yet)" placeholder.
+ * Stale reasoning -> "(stale: {reason})" suffix after the quoted thought.
+ */
+function renderRow(sectionSlug, triple) {
+  const reasoning = (triple && triple.reasoning) || {};
+  const score = reasoning.reasoning_health_score;
+  const glyph = classifyHealth(score);
+
+  const gtRaw = reasoning.governing_thought;
+  const hasGt = typeof gtRaw === 'string' && gtRaw.trim().length > 0;
+
+  let body;
+  if (!reasoning.exists || !hasGt) {
+    body = '(no MINTO yet)';
+  } else {
+    body = '"' + truncateGoverningThought(gtRaw) + '"';
+  }
+
+  let suffix = '';
+  if (reasoning.is_stale === true) {
+    const reason = typeof reasoning.stale_reason === 'string' && reasoning.stale_reason
+      ? reasoning.stale_reason
+      : 'unknown';
+    suffix = ' (stale: ' + reason + ')';
+  }
+
+  // Pad glyph to 6 chars so section names align across rows (matches the
+  // Shape E pattern established in scripts/mos-status.cjs Plan 88.1-05).
+  const paddedGlyph = (glyph + '     ').slice(0, 6);
+  return '  ' + paddedGlyph + sectionSlug + ': ' + body + suffix;
+}
+
+// ---------- formatBanner (the public API) ----------------------------------
+
+/**
+ * formatBanner({ roomRoot, roomSlug, triples, version, budget }) -> string
+ *
+ * Returns the full banner text. Empty string when no active room (signaled
+ * by roomRoot falsy OR roomSlug falsy). Caller owns the graceful no-op
+ * when banner output is '' (don't append it to additionalContext).
+ *
+ * Parameters:
+ *   roomRoot    absolute path to the active room root (null = silent).
+ *   roomSlug    user-facing room slug (null = silent).
+ *   triples     {sectionSlug: {room, state, reasoning}} shaped like
+ *               folder-memory.readTriple return. reasoning._mtime is the
+ *               effective activity timestamp for top-3 selection.
+ *   version     string to render in the brand line. Caller should pass
+ *               readPluginVersion(pluginRoot) so brand tracks plugin.json.
+ *   budget      token budget for the banner (default BANNER_RESERVE_TOKENS
+ *               = 200). Under tight budget, rows drop in reverse order.
+ *
+ * Soft-fail: never throws. Missing / malformed triple entries produce
+ * (no MINTO yet) placeholders. Missing mtimes sort to the tail.
+ */
+function formatBanner(opts) {
+  const o = opts || {};
+
+  // Silent path: no active room context.
+  if (!o.roomRoot || !o.roomSlug) return '';
+
+  const version = (typeof o.version === 'string' && o.version) ? o.version : 'unknown';
+  const triples = (o.triples && typeof o.triples === 'object') ? o.triples : {};
+  const budget = (typeof o.budget === 'number' && Number.isFinite(o.budget) && o.budget > 0)
+    ? o.budget
+    : BANNER_RESERVE_TOKENS;
+
+  // Header: 2 fixed lines (brand + room).
+  const brandLine = 'MindrianOS v' + version;
+  const roomLine = 'Room: ' + String(o.roomSlug);
+
+  // Zero-section room: brand + room; no focus header; no rows.
+  const allKeys = Object.keys(triples);
+  if (allKeys.length === 0) {
+    return brandLine + '\n' + roomLine;
+  }
+
+  // Select top-3 most-recently-active sections.
+  const ranked = sortKeysMostRecentFirst(triples).slice(0, 3);
+
+  // Render candidate rows, THEN drop from tail to fit budget.
+  const header = brandLine + '\n' + roomLine
+    + '\nFocus (top 3 recently-active sections):';
+  let headerCost = estimateTokens(header);
+
+  const candidateRows = ranked.map(function (k) { return renderRow(k, triples[k]); });
+
+  // If headerCost alone exceeds budget, drop the focus-header too and
+  // emit brand + room only. This is the very-tight-budget path.
+  if (headerCost > budget) {
+    return brandLine + '\n' + roomLine;
+  }
+
+  // Walk rows forward while remaining budget allows. Drop from tail when
+  // we cannot fit the next row. Empty row list -> emit brand + room only
+  // (no focus-header when nothing survives). Each row charges its visible
+  // token cost PLUS a fixed ROW_OVERHEAD_TOKENS envelope cost so the
+  // budget parameter's semantics match the PLAN budget cascade (200 -> 2
+  // rows, 50 -> 0 rows).
+  const keptRows = [];
+  let running = headerCost;
+  for (const row of candidateRows) {
+    const rowCost = estimateTokens(row) + ROW_OVERHEAD_TOKENS;
+    if (running + rowCost > budget) break;
+    keptRows.push(row);
+    running += rowCost;
+  }
+
+  if (keptRows.length === 0) {
+    // No rows survived under this budget. Skip the focus-header too so
+    // we don't show an empty promise.
+    return brandLine + '\n' + roomLine;
+  }
+
+  return header + '\n' + keptRows.join('\n');
+}
+
+// ---------- Exports --------------------------------------------------------
+
+module.exports = {
+  formatBanner: formatBanner,
+  readPluginVersion: readPluginVersion,
+  classifyHealth: classifyHealth,
+  truncateGoverningThought: truncateGoverningThought,
+  estimateTokens: estimateTokens,
+  BANNER_RESERVE_TOKENS: BANNER_RESERVE_TOKENS,
+};

package/lib/memory/sessionstart-minto-banner.test.cjs

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 88.1-06 -- SessionStart MINTO banner acceptance tests.
+ *
+ * Verifies lib/memory/sessionstart-banner-formatter.cjs. The banner surfaces
+ * the navigator's re-entry snapshot at session boundary: brand + version +
+ * active-room name + top-3 most-recently-active sections, each with a Canon
+ * Part 2 health glyph and a truncated governing_thought.
+ *
+ * Canon references:
+ *   Part 1 Wicked Navigator -- banner greets the navigator at re-entry.
+ *   Part 2 UI glyph vocabulary -- check / warn / low / -- shared byte-
+ *           identically with statusline (Plan 88.1-04) and /mos:status
+ *           (Plan 88.1-05).
+ *   Part 3 Tri-Context Decision Gate -- banner compresses the LOCAL
+ *           context BEFORE the full TRIPLE_CONTEXT block below it.
+ *   Part 8 Graph Boundary -- every triple read goes through caller (no
+ *           fs reads inside the formatter); zero Brain / fetch / external
+ *           endpoint references in the source.
+ *
+ * Reuse contract (from Plan 88.1-04):
+ *   - classifyHealth glyph classifier (check / warn / low / --).
+ *   - truncateGoverningThought 60-char budget (banner sacrifices detail
+ *     for density, matches statusline budget and is tighter than
+ *     /mos:status 80-char budget).
+ *
+ * Test map (10 cases, one-to-one with PLAN Task 1 <behavior>):
+ *
+ *   1.  5-section room with known mtimes: formatter selects top-3 by mtime
+ *       and emits 3 section lines in activity-descending order.
+ *   2.  2-section room: emits 2 section lines (no padding to 3).
+ *   3.  0-section room: brand + room line; no focus-header, no rows.
+ *   4.  No active room (roomRoot null / empty triples): returns "" silently.
+ *   5.  Stale section: row carries "(stale: {reason})" suffix.
+ *   6.  Empty governing_thought: row reads "(no MINTO yet)".
+ *   7.  governing_thought > 60 chars: truncated with Unicode ellipsis.
+ *   8.  Tight budget (200 tokens): banner renders 2 sections, not 3.
+ *   9.  Very tight budget (50 tokens): banner renders 0 sections; brand +
+ *       room only.
+ *  10.  Brand line reads version dynamically from .claude-plugin/plugin.json
+ *       (never hardcoded, no drift on release).
+ *
+ * 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 REPO = path.resolve(__dirname, '..', '..');
+const FORMATTER_PATH = path.join(REPO, 'lib/memory/sessionstart-banner-formatter.cjs');
+
+// Clear module cache so each test sees a fresh require (important when
+// tests mutate process.env between invocations).
+function loadFormatter() {
+  try { delete require.cache[require.resolve(FORMATTER_PATH)]; } catch (_) {}
+  return require(FORMATTER_PATH);
+}
+
+// ---------- 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 (_) {}
+  }
+});
+
+/**
+ * Build a synthetic triples map shaped to match the readTriple output.
+ * Every section carries exists:true for ROOM.md and MINTO.md so the
+ * formatter treats them as filled. Caller specifies mtime so the banner's
+ * top-3-by-mtime selection is deterministic.
+ */
+function mkTriple(opts) {
+  const o = opts || {};
+  return {
+    room: {
+      exists: true,
+      identity_text: o.identity || 'section identity',
+      references: [],
+      last_updated_at: o.mtime || 1000,
+    },
+    state: {
+      exists: true,
+      artifact_count: 1,
+      gap_status: 'active',
+      completeness_score: 0.5,
+      minto_health: '--',
+      last_activity_at: o.mtime || 1000,
+    },
+    reasoning: {
+      exists: o.reasoningExists !== false,
+      governing_thought: o.governing_thought !== undefined
+        ? o.governing_thought
+        : 'governing thought text',
+      arguments_count: 3,
+      evidence_density: 0.8,
+      mece_status: 'pass',
+      decision_log: [],
+      last_generated_at: o.last_generated_at || '2026-04-20T00:00:00Z',
+      last_artifact_write_seen_at: o.last_artifact_write_seen_at || '2026-04-20T00:00:00Z',
+      flagged_weaknesses: [],
+      is_stale: o.is_stale === true,
+      stale_reason: o.stale_reason || null,
+      reasoning_health_score: o.health !== undefined ? o.health : 0.8,
+      _mtime: o.mtime || 1000,
+    },
+  };
+}
+
+// ---------- Tests ----------
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    process.stdout.write('ok ' + name + '\n');
+    passed += 1;
+  } catch (err) {
+    process.stderr.write('not ok ' + name + '\n' + (err && err.stack ? err.stack : err) + '\n');
+    failed += 1;
+  }
+}
+
+// Test 1: 5-section room, top-3 by mtime.
+test('Test 1: 5-section room selects top-3 by mtime descending', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t1-');
+  const triples = {
+    'alpha':   mkTriple({ mtime: 1000, governing_thought: 'alpha gt' }),
+    'bravo':   mkTriple({ mtime: 5000, governing_thought: 'bravo gt' }),
+    'charlie': mkTriple({ mtime: 3000, governing_thought: 'charlie gt' }),
+    'delta':   mkTriple({ mtime: 4000, governing_thought: 'delta gt' }),
+    'echo':    mkTriple({ mtime: 2000, governing_thought: 'echo gt' }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'test-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 5000,
+  });
+  assert.ok(out.indexOf('bravo') !== -1, 'should include top-1 section bravo');
+  assert.ok(out.indexOf('delta') !== -1, 'should include top-2 section delta');
+  assert.ok(out.indexOf('charlie') !== -1, 'should include top-3 section charlie');
+  assert.ok(out.indexOf('alpha') === -1, 'should NOT include 4th-ranked alpha');
+  assert.ok(out.indexOf('echo') === -1, 'should NOT include 5th-ranked echo');
+  // Descending order: bravo before delta before charlie in output.
+  const pb = out.indexOf('bravo');
+  const pd = out.indexOf('delta');
+  const pc = out.indexOf('charlie');
+  assert.ok(pb < pd, 'bravo (mtime 5000) should appear before delta (mtime 4000)');
+  assert.ok(pd < pc, 'delta (mtime 4000) should appear before charlie (mtime 3000)');
+});
+
+// Test 2: 2-section room: emits 2 rows, not 3.
+test('Test 2: 2-section room emits 2 rows no padding', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t2-');
+  const triples = {
+    'one': mkTriple({ mtime: 2000, governing_thought: 'one gt' }),
+    'two': mkTriple({ mtime: 1000, governing_thought: 'two gt' }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'two-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 5000,
+  });
+  // Count how many section name entries appear as row labels.
+  const lines = out.split('\n').filter(function (l) { return l.indexOf('one:') !== -1 || l.indexOf('two:') !== -1; });
+  assert.equal(lines.length, 2, 'should render exactly 2 section lines');
+});
+
+// Test 3: 0-section room: brand + room line without focus-header.
+test('Test 3: 0-section room has brand + room but no focus header', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t3-');
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'empty-room',
+    triples: {},
+    version: '1.10.15',
+    budget: 5000,
+  });
+  assert.ok(out.indexOf('MindrianOS') !== -1, 'brand line present');
+  assert.ok(out.indexOf('empty-room') !== -1, 'room slug present');
+  assert.equal(out.indexOf('Focus'), -1,
+    'no focus-header when no sections exist');
+});
+
+// Test 4: No active room: silent empty string.
+test('Test 4: no active room returns empty string', function () {
+  const { formatBanner } = loadFormatter();
+  const out = formatBanner({
+    roomRoot: null,
+    roomSlug: null,
+    triples: {},
+    version: '1.10.15',
+    budget: 5000,
+  });
+  assert.equal(out, '', 'banner silent when no active room');
+});
+
+// Test 5: Stale section renders with (stale: reason) suffix.
+test('Test 5: stale section row carries (stale: reason) suffix', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t5-');
+  const triples = {
+    'market-analysis': mkTriple({
+      mtime: 3000,
+      governing_thought: 'market is $12B TAM',
+      is_stale: true,
+      stale_reason: 'artifacts_newer_than_minto',
+    }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'stale-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 5000,
+  });
+  assert.ok(out.indexOf('(stale: artifacts_newer_than_minto)') !== -1,
+    'stale suffix present');
+});
+
+// Test 6: Empty governing_thought row renders (no MINTO yet) placeholder.
+test('Test 6: empty governing_thought renders (no MINTO yet)', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t6-');
+  const triples = {
+    'new-section': mkTriple({
+      mtime: 3000,
+      governing_thought: '',
+      reasoningExists: false,
+    }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'new-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 5000,
+  });
+  assert.ok(out.indexOf('(no MINTO yet)') !== -1,
+    'empty-MINTO placeholder present');
+});
+
+// Test 7: governing_thought > 60 chars is truncated with Unicode ellipsis.
+test('Test 7: long governing_thought truncated with ellipsis', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t7-');
+  const longGt = 'CAR-T biotech at $2.5B TAM requires a moat beyond IP to justify'
+    + ' the Series B valuation in a dilution-sensitive market of 2026';
+  const triples = {
+    'market': mkTriple({ mtime: 3000, governing_thought: longGt }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'long-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 5000,
+  });
+  // Unicode ellipsis U+2026
+  assert.ok(out.indexOf('\u2026') !== -1, 'Unicode ellipsis present');
+  assert.ok(out.indexOf(longGt) === -1, 'full long string NOT present');
+});
+
+// Test 8: tight budget (200 tokens) -> banner renders 2 sections instead of 3.
+test('Test 8: tight 200-token budget drops 3rd section', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t8-');
+  // Each section line has a 60-char governing_thought to consume real tokens.
+  const sixty = 'x'.repeat(60);
+  const triples = {
+    'a': mkTriple({ mtime: 5000, governing_thought: sixty }),
+    'b': mkTriple({ mtime: 4000, governing_thought: sixty }),
+    'c': mkTriple({ mtime: 3000, governing_thought: sixty }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'tight-room',
+    triples: triples,
+    version: '1.10.15',
+    budget: 200,
+  });
+  // Expect at most 2 section rows survive.
+  let rows = 0;
+  const labels = ['a:', 'b:', 'c:'];
+  for (const lbl of labels) {
+    if (out.indexOf(lbl) !== -1) rows += 1;
+  }
+  assert.ok(rows <= 2, 'tight budget drops to <= 2 rows; got ' + rows);
+  assert.ok(rows >= 1, 'tight budget still surfaces at least 1 row');
+});
+
+// Test 9: very tight budget (50 tokens) -> banner renders 0 sections.
+test('Test 9: very tight 50-token budget drops all section rows', function () {
+  const { formatBanner } = loadFormatter();
+  const roomRoot = mkTmp('banner-t9-');
+  const sixty = 'y'.repeat(60);
+  const triples = {
+    'a': mkTriple({ mtime: 3000, governing_thought: sixty }),
+    'b': mkTriple({ mtime: 2000, governing_thought: sixty }),
+    'c': mkTriple({ mtime: 1000, governing_thought: sixty }),
+  };
+  const out = formatBanner({
+    roomRoot: roomRoot,
+    roomSlug: 'verytight',
+    triples: triples,
+    version: '1.10.15',
+    budget: 50,
+  });
+  // Brand + room line still present, but no governing_thought text.
+  assert.ok(out.indexOf('MindrianOS') !== -1, 'brand still present');
+  assert.ok(out.indexOf('verytight') !== -1, 'room slug still present');
+  assert.equal(out.indexOf(sixty), -1, 'no section gt bodies emitted');
+});
+
+// Test 10: version is read from .claude-plugin/plugin.json (no hardcoded).
+test('Test 10: version read from plugin.json not hardcoded', function () {
+  const { readPluginVersion, formatBanner } = loadFormatter();
+  assert.equal(typeof readPluginVersion, 'function',
+    'readPluginVersion export present');
+  const pluginRoot = REPO;
+  const ver = readPluginVersion(pluginRoot);
+  assert.ok(typeof ver === 'string' && ver.length > 0,
+    'reads a non-empty version string');
+  // Spot-check the formatter source: no hardcoded semver like "1.10.15".
+  const src = fs.readFileSync(FORMATTER_PATH, 'utf8');
+  // The formatter itself must not embed a literal semver as a default.
+  // (It may appear in comments; we scan for a bare string literal.)
+  const hardcodedSemver = /["']\d+\.\d+\.\d+["']/;
+  const codeSrc = src.split('\n').filter(function (l) {
+    const t = l.trim();
+    // Strip comment-only lines (// and * prefix).
+    if (t.indexOf('//') === 0) return false;
+    if (t.indexOf('*') === 0) return false;
+    return true;
+  }).join('\n');
+  assert.ok(!hardcodedSemver.test(codeSrc),
+    'formatter code lines contain no hardcoded semver literal');
+  // End-to-end: banner uses whatever version the caller supplies.
+  const out = formatBanner({
+    roomRoot: '/tmp/banner-t10',
+    roomSlug: 'v-room',
+    triples: {},
+    version: ver,
+    budget: 5000,
+  });
+  assert.ok(out.indexOf(ver) !== -1,
+    'banner brand line embeds the live plugin.json version');
+});
+
+// ---------- Exit ----------
+
+process.stdout.write('\n' + passed + '/' + (passed + failed) + ' passed\n');
+process.exit(failed === 0 ? 0 : 1);